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
8package 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
33import (
34 "reflect"
35 "sort"
36)
37
38const fastpathEnabled = true
39
40type fastpathT struct{}
41
42var fastpathTV fastpathT
43
44type 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
51type fastpathA [271]fastpathE
52
53func (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
70type fastpathAslice []fastpathE
71
72func (x fastpathAslice) Len() int { return len(x) }
73func (x fastpathAslice) Less(i, j int) bool { return x[i].rtid < x[j].rtid }
74func (x fastpathAslice) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
75
76var fastpathAV fastpathA
77
78// due to possible initialization loop error, make fastpath in an init()
79func 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
370func 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
1468func (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}
1475func (_ 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}
1494func (_ 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
1518func (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}
1525func (_ 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}
1544func (_ 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
1568func (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}
1575func (_ 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}
1594func (_ 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
1618func (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}
1625func (_ 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}
1644func (_ 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
1668func (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}
1675func (_ 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}
1694func (_ 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
1718func (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}
1725func (_ 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}
1744func (_ 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
1768func (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}
1775func (_ 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}
1794func (_ 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
1818func (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}
1825func (_ 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}
1844func (_ 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
1868func (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}
1875func (_ 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}
1894func (_ 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
1918func (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}
1925func (_ 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}
1944func (_ 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
1968func (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}
1975func (_ 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}
1994func (_ 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
2018func (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}
2025func (_ 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}
2044func (_ 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
2068func (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}
2075func (_ 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}
2094func (_ 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
2118func (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}
2125func (_ 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}
2144func (_ 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
2168func (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}
2175func (_ 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}
2194func (_ 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
2218func (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}
2225func (_ 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}
2244func (_ 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
2268func (e *Encoder) fastpathEncMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
2269 fastpathTV.EncMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), e)
2270}
2271func (_ 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
2324func (e *Encoder) fastpathEncMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
2325 fastpathTV.EncMapIntfStringV(rv2i(rv).(map[interface{}]string), e)
2326}
2327func (_ 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
2380func (e *Encoder) fastpathEncMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
2381 fastpathTV.EncMapIntfUintV(rv2i(rv).(map[interface{}]uint), e)
2382}
2383func (_ 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
2436func (e *Encoder) fastpathEncMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
2437 fastpathTV.EncMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), e)
2438}
2439func (_ 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
2492func (e *Encoder) fastpathEncMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
2493 fastpathTV.EncMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), e)
2494}
2495func (_ 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
2548func (e *Encoder) fastpathEncMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
2549 fastpathTV.EncMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), e)
2550}
2551func (_ 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
2604func (e *Encoder) fastpathEncMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
2605 fastpathTV.EncMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), e)
2606}
2607func (_ 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
2660func (e *Encoder) fastpathEncMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
2661 fastpathTV.EncMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), e)
2662}
2663func (_ 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
2716func (e *Encoder) fastpathEncMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
2717 fastpathTV.EncMapIntfIntV(rv2i(rv).(map[interface{}]int), e)
2718}
2719func (_ 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
2772func (e *Encoder) fastpathEncMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
2773 fastpathTV.EncMapIntfInt8V(rv2i(rv).(map[interface{}]int8), e)
2774}
2775func (_ 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
2828func (e *Encoder) fastpathEncMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
2829 fastpathTV.EncMapIntfInt16V(rv2i(rv).(map[interface{}]int16), e)
2830}
2831func (_ 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
2884func (e *Encoder) fastpathEncMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
2885 fastpathTV.EncMapIntfInt32V(rv2i(rv).(map[interface{}]int32), e)
2886}
2887func (_ 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
2940func (e *Encoder) fastpathEncMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
2941 fastpathTV.EncMapIntfInt64V(rv2i(rv).(map[interface{}]int64), e)
2942}
2943func (_ 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
2996func (e *Encoder) fastpathEncMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
2997 fastpathTV.EncMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), e)
2998}
2999func (_ 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
3052func (e *Encoder) fastpathEncMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
3053 fastpathTV.EncMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), e)
3054}
3055func (_ 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
3108func (e *Encoder) fastpathEncMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
3109 fastpathTV.EncMapIntfBoolV(rv2i(rv).(map[interface{}]bool), e)
3110}
3111func (_ 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
3164func (e *Encoder) fastpathEncMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
3165 fastpathTV.EncMapStringIntfV(rv2i(rv).(map[string]interface{}), e)
3166}
3167func (_ 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
3213func (e *Encoder) fastpathEncMapStringStringR(f *codecFnInfo, rv reflect.Value) {
3214 fastpathTV.EncMapStringStringV(rv2i(rv).(map[string]string), e)
3215}
3216func (_ 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
3262func (e *Encoder) fastpathEncMapStringUintR(f *codecFnInfo, rv reflect.Value) {
3263 fastpathTV.EncMapStringUintV(rv2i(rv).(map[string]uint), e)
3264}
3265func (_ 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
3311func (e *Encoder) fastpathEncMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
3312 fastpathTV.EncMapStringUint8V(rv2i(rv).(map[string]uint8), e)
3313}
3314func (_ 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
3360func (e *Encoder) fastpathEncMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
3361 fastpathTV.EncMapStringUint16V(rv2i(rv).(map[string]uint16), e)
3362}
3363func (_ 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
3409func (e *Encoder) fastpathEncMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
3410 fastpathTV.EncMapStringUint32V(rv2i(rv).(map[string]uint32), e)
3411}
3412func (_ 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
3458func (e *Encoder) fastpathEncMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
3459 fastpathTV.EncMapStringUint64V(rv2i(rv).(map[string]uint64), e)
3460}
3461func (_ 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
3507func (e *Encoder) fastpathEncMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
3508 fastpathTV.EncMapStringUintptrV(rv2i(rv).(map[string]uintptr), e)
3509}
3510func (_ 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
3556func (e *Encoder) fastpathEncMapStringIntR(f *codecFnInfo, rv reflect.Value) {
3557 fastpathTV.EncMapStringIntV(rv2i(rv).(map[string]int), e)
3558}
3559func (_ 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
3605func (e *Encoder) fastpathEncMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
3606 fastpathTV.EncMapStringInt8V(rv2i(rv).(map[string]int8), e)
3607}
3608func (_ 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
3654func (e *Encoder) fastpathEncMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
3655 fastpathTV.EncMapStringInt16V(rv2i(rv).(map[string]int16), e)
3656}
3657func (_ 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
3703func (e *Encoder) fastpathEncMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
3704 fastpathTV.EncMapStringInt32V(rv2i(rv).(map[string]int32), e)
3705}
3706func (_ 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
3752func (e *Encoder) fastpathEncMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
3753 fastpathTV.EncMapStringInt64V(rv2i(rv).(map[string]int64), e)
3754}
3755func (_ 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
3801func (e *Encoder) fastpathEncMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
3802 fastpathTV.EncMapStringFloat32V(rv2i(rv).(map[string]float32), e)
3803}
3804func (_ 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
3850func (e *Encoder) fastpathEncMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
3851 fastpathTV.EncMapStringFloat64V(rv2i(rv).(map[string]float64), e)
3852}
3853func (_ 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
3899func (e *Encoder) fastpathEncMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
3900 fastpathTV.EncMapStringBoolV(rv2i(rv).(map[string]bool), e)
3901}
3902func (_ 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
3948func (e *Encoder) fastpathEncMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
3949 fastpathTV.EncMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), e)
3950}
3951func (_ 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
3997func (e *Encoder) fastpathEncMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
3998 fastpathTV.EncMapFloat32StringV(rv2i(rv).(map[float32]string), e)
3999}
4000func (_ 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
4046func (e *Encoder) fastpathEncMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
4047 fastpathTV.EncMapFloat32UintV(rv2i(rv).(map[float32]uint), e)
4048}
4049func (_ 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
4095func (e *Encoder) fastpathEncMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
4096 fastpathTV.EncMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), e)
4097}
4098func (_ 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
4144func (e *Encoder) fastpathEncMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
4145 fastpathTV.EncMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), e)
4146}
4147func (_ 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
4193func (e *Encoder) fastpathEncMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
4194 fastpathTV.EncMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), e)
4195}
4196func (_ 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
4242func (e *Encoder) fastpathEncMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
4243 fastpathTV.EncMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), e)
4244}
4245func (_ 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
4291func (e *Encoder) fastpathEncMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
4292 fastpathTV.EncMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), e)
4293}
4294func (_ 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
4340func (e *Encoder) fastpathEncMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
4341 fastpathTV.EncMapFloat32IntV(rv2i(rv).(map[float32]int), e)
4342}
4343func (_ 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
4389func (e *Encoder) fastpathEncMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
4390 fastpathTV.EncMapFloat32Int8V(rv2i(rv).(map[float32]int8), e)
4391}
4392func (_ 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
4438func (e *Encoder) fastpathEncMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
4439 fastpathTV.EncMapFloat32Int16V(rv2i(rv).(map[float32]int16), e)
4440}
4441func (_ 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
4487func (e *Encoder) fastpathEncMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
4488 fastpathTV.EncMapFloat32Int32V(rv2i(rv).(map[float32]int32), e)
4489}
4490func (_ 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
4536func (e *Encoder) fastpathEncMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
4537 fastpathTV.EncMapFloat32Int64V(rv2i(rv).(map[float32]int64), e)
4538}
4539func (_ 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
4585func (e *Encoder) fastpathEncMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
4586 fastpathTV.EncMapFloat32Float32V(rv2i(rv).(map[float32]float32), e)
4587}
4588func (_ 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
4634func (e *Encoder) fastpathEncMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
4635 fastpathTV.EncMapFloat32Float64V(rv2i(rv).(map[float32]float64), e)
4636}
4637func (_ 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
4683func (e *Encoder) fastpathEncMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
4684 fastpathTV.EncMapFloat32BoolV(rv2i(rv).(map[float32]bool), e)
4685}
4686func (_ 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
4732func (e *Encoder) fastpathEncMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
4733 fastpathTV.EncMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), e)
4734}
4735func (_ 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
4781func (e *Encoder) fastpathEncMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
4782 fastpathTV.EncMapFloat64StringV(rv2i(rv).(map[float64]string), e)
4783}
4784func (_ 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
4830func (e *Encoder) fastpathEncMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
4831 fastpathTV.EncMapFloat64UintV(rv2i(rv).(map[float64]uint), e)
4832}
4833func (_ 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
4879func (e *Encoder) fastpathEncMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
4880 fastpathTV.EncMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), e)
4881}
4882func (_ 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
4928func (e *Encoder) fastpathEncMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
4929 fastpathTV.EncMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), e)
4930}
4931func (_ 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
4977func (e *Encoder) fastpathEncMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
4978 fastpathTV.EncMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), e)
4979}
4980func (_ 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
5026func (e *Encoder) fastpathEncMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
5027 fastpathTV.EncMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), e)
5028}
5029func (_ 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
5075func (e *Encoder) fastpathEncMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
5076 fastpathTV.EncMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), e)
5077}
5078func (_ 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
5124func (e *Encoder) fastpathEncMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
5125 fastpathTV.EncMapFloat64IntV(rv2i(rv).(map[float64]int), e)
5126}
5127func (_ 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
5173func (e *Encoder) fastpathEncMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
5174 fastpathTV.EncMapFloat64Int8V(rv2i(rv).(map[float64]int8), e)
5175}
5176func (_ 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
5222func (e *Encoder) fastpathEncMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
5223 fastpathTV.EncMapFloat64Int16V(rv2i(rv).(map[float64]int16), e)
5224}
5225func (_ 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
5271func (e *Encoder) fastpathEncMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
5272 fastpathTV.EncMapFloat64Int32V(rv2i(rv).(map[float64]int32), e)
5273}
5274func (_ 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
5320func (e *Encoder) fastpathEncMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
5321 fastpathTV.EncMapFloat64Int64V(rv2i(rv).(map[float64]int64), e)
5322}
5323func (_ 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
5369func (e *Encoder) fastpathEncMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
5370 fastpathTV.EncMapFloat64Float32V(rv2i(rv).(map[float64]float32), e)
5371}
5372func (_ 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
5418func (e *Encoder) fastpathEncMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
5419 fastpathTV.EncMapFloat64Float64V(rv2i(rv).(map[float64]float64), e)
5420}
5421func (_ 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
5467func (e *Encoder) fastpathEncMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
5468 fastpathTV.EncMapFloat64BoolV(rv2i(rv).(map[float64]bool), e)
5469}
5470func (_ 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
5516func (e *Encoder) fastpathEncMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
5517 fastpathTV.EncMapUintIntfV(rv2i(rv).(map[uint]interface{}), e)
5518}
5519func (_ 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
5565func (e *Encoder) fastpathEncMapUintStringR(f *codecFnInfo, rv reflect.Value) {
5566 fastpathTV.EncMapUintStringV(rv2i(rv).(map[uint]string), e)
5567}
5568func (_ 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
5614func (e *Encoder) fastpathEncMapUintUintR(f *codecFnInfo, rv reflect.Value) {
5615 fastpathTV.EncMapUintUintV(rv2i(rv).(map[uint]uint), e)
5616}
5617func (_ 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
5663func (e *Encoder) fastpathEncMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
5664 fastpathTV.EncMapUintUint8V(rv2i(rv).(map[uint]uint8), e)
5665}
5666func (_ 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
5712func (e *Encoder) fastpathEncMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
5713 fastpathTV.EncMapUintUint16V(rv2i(rv).(map[uint]uint16), e)
5714}
5715func (_ 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
5761func (e *Encoder) fastpathEncMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
5762 fastpathTV.EncMapUintUint32V(rv2i(rv).(map[uint]uint32), e)
5763}
5764func (_ 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
5810func (e *Encoder) fastpathEncMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
5811 fastpathTV.EncMapUintUint64V(rv2i(rv).(map[uint]uint64), e)
5812}
5813func (_ 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
5859func (e *Encoder) fastpathEncMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
5860 fastpathTV.EncMapUintUintptrV(rv2i(rv).(map[uint]uintptr), e)
5861}
5862func (_ 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
5908func (e *Encoder) fastpathEncMapUintIntR(f *codecFnInfo, rv reflect.Value) {
5909 fastpathTV.EncMapUintIntV(rv2i(rv).(map[uint]int), e)
5910}
5911func (_ 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
5957func (e *Encoder) fastpathEncMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
5958 fastpathTV.EncMapUintInt8V(rv2i(rv).(map[uint]int8), e)
5959}
5960func (_ 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
6006func (e *Encoder) fastpathEncMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
6007 fastpathTV.EncMapUintInt16V(rv2i(rv).(map[uint]int16), e)
6008}
6009func (_ 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
6055func (e *Encoder) fastpathEncMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
6056 fastpathTV.EncMapUintInt32V(rv2i(rv).(map[uint]int32), e)
6057}
6058func (_ 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
6104func (e *Encoder) fastpathEncMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
6105 fastpathTV.EncMapUintInt64V(rv2i(rv).(map[uint]int64), e)
6106}
6107func (_ 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
6153func (e *Encoder) fastpathEncMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
6154 fastpathTV.EncMapUintFloat32V(rv2i(rv).(map[uint]float32), e)
6155}
6156func (_ 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
6202func (e *Encoder) fastpathEncMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
6203 fastpathTV.EncMapUintFloat64V(rv2i(rv).(map[uint]float64), e)
6204}
6205func (_ 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
6251func (e *Encoder) fastpathEncMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
6252 fastpathTV.EncMapUintBoolV(rv2i(rv).(map[uint]bool), e)
6253}
6254func (_ 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
6300func (e *Encoder) fastpathEncMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
6301 fastpathTV.EncMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), e)
6302}
6303func (_ 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
6349func (e *Encoder) fastpathEncMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
6350 fastpathTV.EncMapUint8StringV(rv2i(rv).(map[uint8]string), e)
6351}
6352func (_ 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
6398func (e *Encoder) fastpathEncMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
6399 fastpathTV.EncMapUint8UintV(rv2i(rv).(map[uint8]uint), e)
6400}
6401func (_ 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
6447func (e *Encoder) fastpathEncMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
6448 fastpathTV.EncMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), e)
6449}
6450func (_ 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
6496func (e *Encoder) fastpathEncMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
6497 fastpathTV.EncMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), e)
6498}
6499func (_ 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
6545func (e *Encoder) fastpathEncMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
6546 fastpathTV.EncMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), e)
6547}
6548func (_ 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
6594func (e *Encoder) fastpathEncMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
6595 fastpathTV.EncMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), e)
6596}
6597func (_ 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
6643func (e *Encoder) fastpathEncMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
6644 fastpathTV.EncMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), e)
6645}
6646func (_ 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
6692func (e *Encoder) fastpathEncMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
6693 fastpathTV.EncMapUint8IntV(rv2i(rv).(map[uint8]int), e)
6694}
6695func (_ 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
6741func (e *Encoder) fastpathEncMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
6742 fastpathTV.EncMapUint8Int8V(rv2i(rv).(map[uint8]int8), e)
6743}
6744func (_ 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
6790func (e *Encoder) fastpathEncMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
6791 fastpathTV.EncMapUint8Int16V(rv2i(rv).(map[uint8]int16), e)
6792}
6793func (_ 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
6839func (e *Encoder) fastpathEncMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
6840 fastpathTV.EncMapUint8Int32V(rv2i(rv).(map[uint8]int32), e)
6841}
6842func (_ 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
6888func (e *Encoder) fastpathEncMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
6889 fastpathTV.EncMapUint8Int64V(rv2i(rv).(map[uint8]int64), e)
6890}
6891func (_ 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
6937func (e *Encoder) fastpathEncMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
6938 fastpathTV.EncMapUint8Float32V(rv2i(rv).(map[uint8]float32), e)
6939}
6940func (_ 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
6986func (e *Encoder) fastpathEncMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
6987 fastpathTV.EncMapUint8Float64V(rv2i(rv).(map[uint8]float64), e)
6988}
6989func (_ 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
7035func (e *Encoder) fastpathEncMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
7036 fastpathTV.EncMapUint8BoolV(rv2i(rv).(map[uint8]bool), e)
7037}
7038func (_ 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
7084func (e *Encoder) fastpathEncMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
7085 fastpathTV.EncMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), e)
7086}
7087func (_ 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
7133func (e *Encoder) fastpathEncMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
7134 fastpathTV.EncMapUint16StringV(rv2i(rv).(map[uint16]string), e)
7135}
7136func (_ 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
7182func (e *Encoder) fastpathEncMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
7183 fastpathTV.EncMapUint16UintV(rv2i(rv).(map[uint16]uint), e)
7184}
7185func (_ 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
7231func (e *Encoder) fastpathEncMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
7232 fastpathTV.EncMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), e)
7233}
7234func (_ 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
7280func (e *Encoder) fastpathEncMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
7281 fastpathTV.EncMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), e)
7282}
7283func (_ 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
7329func (e *Encoder) fastpathEncMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
7330 fastpathTV.EncMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), e)
7331}
7332func (_ 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
7378func (e *Encoder) fastpathEncMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
7379 fastpathTV.EncMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), e)
7380}
7381func (_ 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
7427func (e *Encoder) fastpathEncMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
7428 fastpathTV.EncMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), e)
7429}
7430func (_ 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
7476func (e *Encoder) fastpathEncMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
7477 fastpathTV.EncMapUint16IntV(rv2i(rv).(map[uint16]int), e)
7478}
7479func (_ 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
7525func (e *Encoder) fastpathEncMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
7526 fastpathTV.EncMapUint16Int8V(rv2i(rv).(map[uint16]int8), e)
7527}
7528func (_ 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
7574func (e *Encoder) fastpathEncMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
7575 fastpathTV.EncMapUint16Int16V(rv2i(rv).(map[uint16]int16), e)
7576}
7577func (_ 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
7623func (e *Encoder) fastpathEncMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
7624 fastpathTV.EncMapUint16Int32V(rv2i(rv).(map[uint16]int32), e)
7625}
7626func (_ 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
7672func (e *Encoder) fastpathEncMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
7673 fastpathTV.EncMapUint16Int64V(rv2i(rv).(map[uint16]int64), e)
7674}
7675func (_ 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
7721func (e *Encoder) fastpathEncMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
7722 fastpathTV.EncMapUint16Float32V(rv2i(rv).(map[uint16]float32), e)
7723}
7724func (_ 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
7770func (e *Encoder) fastpathEncMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
7771 fastpathTV.EncMapUint16Float64V(rv2i(rv).(map[uint16]float64), e)
7772}
7773func (_ 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
7819func (e *Encoder) fastpathEncMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
7820 fastpathTV.EncMapUint16BoolV(rv2i(rv).(map[uint16]bool), e)
7821}
7822func (_ 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
7868func (e *Encoder) fastpathEncMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
7869 fastpathTV.EncMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), e)
7870}
7871func (_ 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
7917func (e *Encoder) fastpathEncMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
7918 fastpathTV.EncMapUint32StringV(rv2i(rv).(map[uint32]string), e)
7919}
7920func (_ 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
7966func (e *Encoder) fastpathEncMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
7967 fastpathTV.EncMapUint32UintV(rv2i(rv).(map[uint32]uint), e)
7968}
7969func (_ 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
8015func (e *Encoder) fastpathEncMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
8016 fastpathTV.EncMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), e)
8017}
8018func (_ 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
8064func (e *Encoder) fastpathEncMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
8065 fastpathTV.EncMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), e)
8066}
8067func (_ 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
8113func (e *Encoder) fastpathEncMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
8114 fastpathTV.EncMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), e)
8115}
8116func (_ 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
8162func (e *Encoder) fastpathEncMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
8163 fastpathTV.EncMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), e)
8164}
8165func (_ 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
8211func (e *Encoder) fastpathEncMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
8212 fastpathTV.EncMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), e)
8213}
8214func (_ 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
8260func (e *Encoder) fastpathEncMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
8261 fastpathTV.EncMapUint32IntV(rv2i(rv).(map[uint32]int), e)
8262}
8263func (_ 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
8309func (e *Encoder) fastpathEncMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
8310 fastpathTV.EncMapUint32Int8V(rv2i(rv).(map[uint32]int8), e)
8311}
8312func (_ 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
8358func (e *Encoder) fastpathEncMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
8359 fastpathTV.EncMapUint32Int16V(rv2i(rv).(map[uint32]int16), e)
8360}
8361func (_ 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
8407func (e *Encoder) fastpathEncMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
8408 fastpathTV.EncMapUint32Int32V(rv2i(rv).(map[uint32]int32), e)
8409}
8410func (_ 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
8456func (e *Encoder) fastpathEncMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
8457 fastpathTV.EncMapUint32Int64V(rv2i(rv).(map[uint32]int64), e)
8458}
8459func (_ 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
8505func (e *Encoder) fastpathEncMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
8506 fastpathTV.EncMapUint32Float32V(rv2i(rv).(map[uint32]float32), e)
8507}
8508func (_ 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
8554func (e *Encoder) fastpathEncMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
8555 fastpathTV.EncMapUint32Float64V(rv2i(rv).(map[uint32]float64), e)
8556}
8557func (_ 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
8603func (e *Encoder) fastpathEncMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
8604 fastpathTV.EncMapUint32BoolV(rv2i(rv).(map[uint32]bool), e)
8605}
8606func (_ 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
8652func (e *Encoder) fastpathEncMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
8653 fastpathTV.EncMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), e)
8654}
8655func (_ 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
8701func (e *Encoder) fastpathEncMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
8702 fastpathTV.EncMapUint64StringV(rv2i(rv).(map[uint64]string), e)
8703}
8704func (_ 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
8750func (e *Encoder) fastpathEncMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
8751 fastpathTV.EncMapUint64UintV(rv2i(rv).(map[uint64]uint), e)
8752}
8753func (_ 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
8799func (e *Encoder) fastpathEncMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
8800 fastpathTV.EncMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), e)
8801}
8802func (_ 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
8848func (e *Encoder) fastpathEncMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
8849 fastpathTV.EncMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), e)
8850}
8851func (_ 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
8897func (e *Encoder) fastpathEncMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
8898 fastpathTV.EncMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), e)
8899}
8900func (_ 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
8946func (e *Encoder) fastpathEncMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
8947 fastpathTV.EncMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), e)
8948}
8949func (_ 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
8995func (e *Encoder) fastpathEncMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
8996 fastpathTV.EncMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), e)
8997}
8998func (_ 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
9044func (e *Encoder) fastpathEncMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
9045 fastpathTV.EncMapUint64IntV(rv2i(rv).(map[uint64]int), e)
9046}
9047func (_ 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
9093func (e *Encoder) fastpathEncMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
9094 fastpathTV.EncMapUint64Int8V(rv2i(rv).(map[uint64]int8), e)
9095}
9096func (_ 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
9142func (e *Encoder) fastpathEncMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
9143 fastpathTV.EncMapUint64Int16V(rv2i(rv).(map[uint64]int16), e)
9144}
9145func (_ 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
9191func (e *Encoder) fastpathEncMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
9192 fastpathTV.EncMapUint64Int32V(rv2i(rv).(map[uint64]int32), e)
9193}
9194func (_ 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
9240func (e *Encoder) fastpathEncMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
9241 fastpathTV.EncMapUint64Int64V(rv2i(rv).(map[uint64]int64), e)
9242}
9243func (_ 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
9289func (e *Encoder) fastpathEncMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
9290 fastpathTV.EncMapUint64Float32V(rv2i(rv).(map[uint64]float32), e)
9291}
9292func (_ 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
9338func (e *Encoder) fastpathEncMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
9339 fastpathTV.EncMapUint64Float64V(rv2i(rv).(map[uint64]float64), e)
9340}
9341func (_ 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
9387func (e *Encoder) fastpathEncMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
9388 fastpathTV.EncMapUint64BoolV(rv2i(rv).(map[uint64]bool), e)
9389}
9390func (_ 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
9436func (e *Encoder) fastpathEncMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
9437 fastpathTV.EncMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), e)
9438}
9439func (_ 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
9485func (e *Encoder) fastpathEncMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
9486 fastpathTV.EncMapUintptrStringV(rv2i(rv).(map[uintptr]string), e)
9487}
9488func (_ 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
9534func (e *Encoder) fastpathEncMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
9535 fastpathTV.EncMapUintptrUintV(rv2i(rv).(map[uintptr]uint), e)
9536}
9537func (_ 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
9583func (e *Encoder) fastpathEncMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
9584 fastpathTV.EncMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), e)
9585}
9586func (_ 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
9632func (e *Encoder) fastpathEncMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
9633 fastpathTV.EncMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), e)
9634}
9635func (_ 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
9681func (e *Encoder) fastpathEncMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
9682 fastpathTV.EncMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), e)
9683}
9684func (_ 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
9730func (e *Encoder) fastpathEncMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
9731 fastpathTV.EncMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), e)
9732}
9733func (_ 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
9779func (e *Encoder) fastpathEncMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
9780 fastpathTV.EncMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), e)
9781}
9782func (_ 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
9828func (e *Encoder) fastpathEncMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
9829 fastpathTV.EncMapUintptrIntV(rv2i(rv).(map[uintptr]int), e)
9830}
9831func (_ 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
9877func (e *Encoder) fastpathEncMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
9878 fastpathTV.EncMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), e)
9879}
9880func (_ 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
9926func (e *Encoder) fastpathEncMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
9927 fastpathTV.EncMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), e)
9928}
9929func (_ 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
9975func (e *Encoder) fastpathEncMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
9976 fastpathTV.EncMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), e)
9977}
9978func (_ 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
10024func (e *Encoder) fastpathEncMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
10025 fastpathTV.EncMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), e)
10026}
10027func (_ 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
10073func (e *Encoder) fastpathEncMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
10074 fastpathTV.EncMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), e)
10075}
10076func (_ 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
10122func (e *Encoder) fastpathEncMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
10123 fastpathTV.EncMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), e)
10124}
10125func (_ 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
10171func (e *Encoder) fastpathEncMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
10172 fastpathTV.EncMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), e)
10173}
10174func (_ 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
10220func (e *Encoder) fastpathEncMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
10221 fastpathTV.EncMapIntIntfV(rv2i(rv).(map[int]interface{}), e)
10222}
10223func (_ 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
10269func (e *Encoder) fastpathEncMapIntStringR(f *codecFnInfo, rv reflect.Value) {
10270 fastpathTV.EncMapIntStringV(rv2i(rv).(map[int]string), e)
10271}
10272func (_ 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
10318func (e *Encoder) fastpathEncMapIntUintR(f *codecFnInfo, rv reflect.Value) {
10319 fastpathTV.EncMapIntUintV(rv2i(rv).(map[int]uint), e)
10320}
10321func (_ 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
10367func (e *Encoder) fastpathEncMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
10368 fastpathTV.EncMapIntUint8V(rv2i(rv).(map[int]uint8), e)
10369}
10370func (_ 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
10416func (e *Encoder) fastpathEncMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
10417 fastpathTV.EncMapIntUint16V(rv2i(rv).(map[int]uint16), e)
10418}
10419func (_ 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
10465func (e *Encoder) fastpathEncMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
10466 fastpathTV.EncMapIntUint32V(rv2i(rv).(map[int]uint32), e)
10467}
10468func (_ 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
10514func (e *Encoder) fastpathEncMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
10515 fastpathTV.EncMapIntUint64V(rv2i(rv).(map[int]uint64), e)
10516}
10517func (_ 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
10563func (e *Encoder) fastpathEncMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
10564 fastpathTV.EncMapIntUintptrV(rv2i(rv).(map[int]uintptr), e)
10565}
10566func (_ 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
10612func (e *Encoder) fastpathEncMapIntIntR(f *codecFnInfo, rv reflect.Value) {
10613 fastpathTV.EncMapIntIntV(rv2i(rv).(map[int]int), e)
10614}
10615func (_ 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
10661func (e *Encoder) fastpathEncMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
10662 fastpathTV.EncMapIntInt8V(rv2i(rv).(map[int]int8), e)
10663}
10664func (_ 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
10710func (e *Encoder) fastpathEncMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
10711 fastpathTV.EncMapIntInt16V(rv2i(rv).(map[int]int16), e)
10712}
10713func (_ 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
10759func (e *Encoder) fastpathEncMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
10760 fastpathTV.EncMapIntInt32V(rv2i(rv).(map[int]int32), e)
10761}
10762func (_ 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
10808func (e *Encoder) fastpathEncMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
10809 fastpathTV.EncMapIntInt64V(rv2i(rv).(map[int]int64), e)
10810}
10811func (_ 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
10857func (e *Encoder) fastpathEncMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
10858 fastpathTV.EncMapIntFloat32V(rv2i(rv).(map[int]float32), e)
10859}
10860func (_ 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
10906func (e *Encoder) fastpathEncMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
10907 fastpathTV.EncMapIntFloat64V(rv2i(rv).(map[int]float64), e)
10908}
10909func (_ 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
10955func (e *Encoder) fastpathEncMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
10956 fastpathTV.EncMapIntBoolV(rv2i(rv).(map[int]bool), e)
10957}
10958func (_ 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
11004func (e *Encoder) fastpathEncMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
11005 fastpathTV.EncMapInt8IntfV(rv2i(rv).(map[int8]interface{}), e)
11006}
11007func (_ 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
11053func (e *Encoder) fastpathEncMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
11054 fastpathTV.EncMapInt8StringV(rv2i(rv).(map[int8]string), e)
11055}
11056func (_ 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
11102func (e *Encoder) fastpathEncMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
11103 fastpathTV.EncMapInt8UintV(rv2i(rv).(map[int8]uint), e)
11104}
11105func (_ 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
11151func (e *Encoder) fastpathEncMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
11152 fastpathTV.EncMapInt8Uint8V(rv2i(rv).(map[int8]uint8), e)
11153}
11154func (_ 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
11200func (e *Encoder) fastpathEncMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
11201 fastpathTV.EncMapInt8Uint16V(rv2i(rv).(map[int8]uint16), e)
11202}
11203func (_ 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
11249func (e *Encoder) fastpathEncMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
11250 fastpathTV.EncMapInt8Uint32V(rv2i(rv).(map[int8]uint32), e)
11251}
11252func (_ 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
11298func (e *Encoder) fastpathEncMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
11299 fastpathTV.EncMapInt8Uint64V(rv2i(rv).(map[int8]uint64), e)
11300}
11301func (_ 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
11347func (e *Encoder) fastpathEncMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
11348 fastpathTV.EncMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), e)
11349}
11350func (_ 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
11396func (e *Encoder) fastpathEncMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
11397 fastpathTV.EncMapInt8IntV(rv2i(rv).(map[int8]int), e)
11398}
11399func (_ 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
11445func (e *Encoder) fastpathEncMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
11446 fastpathTV.EncMapInt8Int8V(rv2i(rv).(map[int8]int8), e)
11447}
11448func (_ 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
11494func (e *Encoder) fastpathEncMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
11495 fastpathTV.EncMapInt8Int16V(rv2i(rv).(map[int8]int16), e)
11496}
11497func (_ 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
11543func (e *Encoder) fastpathEncMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
11544 fastpathTV.EncMapInt8Int32V(rv2i(rv).(map[int8]int32), e)
11545}
11546func (_ 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
11592func (e *Encoder) fastpathEncMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
11593 fastpathTV.EncMapInt8Int64V(rv2i(rv).(map[int8]int64), e)
11594}
11595func (_ 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
11641func (e *Encoder) fastpathEncMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
11642 fastpathTV.EncMapInt8Float32V(rv2i(rv).(map[int8]float32), e)
11643}
11644func (_ 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
11690func (e *Encoder) fastpathEncMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
11691 fastpathTV.EncMapInt8Float64V(rv2i(rv).(map[int8]float64), e)
11692}
11693func (_ 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
11739func (e *Encoder) fastpathEncMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
11740 fastpathTV.EncMapInt8BoolV(rv2i(rv).(map[int8]bool), e)
11741}
11742func (_ 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
11788func (e *Encoder) fastpathEncMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
11789 fastpathTV.EncMapInt16IntfV(rv2i(rv).(map[int16]interface{}), e)
11790}
11791func (_ 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
11837func (e *Encoder) fastpathEncMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
11838 fastpathTV.EncMapInt16StringV(rv2i(rv).(map[int16]string), e)
11839}
11840func (_ 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
11886func (e *Encoder) fastpathEncMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
11887 fastpathTV.EncMapInt16UintV(rv2i(rv).(map[int16]uint), e)
11888}
11889func (_ 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
11935func (e *Encoder) fastpathEncMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
11936 fastpathTV.EncMapInt16Uint8V(rv2i(rv).(map[int16]uint8), e)
11937}
11938func (_ 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
11984func (e *Encoder) fastpathEncMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
11985 fastpathTV.EncMapInt16Uint16V(rv2i(rv).(map[int16]uint16), e)
11986}
11987func (_ 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
12033func (e *Encoder) fastpathEncMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
12034 fastpathTV.EncMapInt16Uint32V(rv2i(rv).(map[int16]uint32), e)
12035}
12036func (_ 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
12082func (e *Encoder) fastpathEncMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
12083 fastpathTV.EncMapInt16Uint64V(rv2i(rv).(map[int16]uint64), e)
12084}
12085func (_ 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
12131func (e *Encoder) fastpathEncMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
12132 fastpathTV.EncMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), e)
12133}
12134func (_ 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
12180func (e *Encoder) fastpathEncMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
12181 fastpathTV.EncMapInt16IntV(rv2i(rv).(map[int16]int), e)
12182}
12183func (_ 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
12229func (e *Encoder) fastpathEncMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
12230 fastpathTV.EncMapInt16Int8V(rv2i(rv).(map[int16]int8), e)
12231}
12232func (_ 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
12278func (e *Encoder) fastpathEncMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
12279 fastpathTV.EncMapInt16Int16V(rv2i(rv).(map[int16]int16), e)
12280}
12281func (_ 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
12327func (e *Encoder) fastpathEncMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
12328 fastpathTV.EncMapInt16Int32V(rv2i(rv).(map[int16]int32), e)
12329}
12330func (_ 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
12376func (e *Encoder) fastpathEncMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
12377 fastpathTV.EncMapInt16Int64V(rv2i(rv).(map[int16]int64), e)
12378}
12379func (_ 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
12425func (e *Encoder) fastpathEncMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
12426 fastpathTV.EncMapInt16Float32V(rv2i(rv).(map[int16]float32), e)
12427}
12428func (_ 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
12474func (e *Encoder) fastpathEncMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
12475 fastpathTV.EncMapInt16Float64V(rv2i(rv).(map[int16]float64), e)
12476}
12477func (_ 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
12523func (e *Encoder) fastpathEncMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
12524 fastpathTV.EncMapInt16BoolV(rv2i(rv).(map[int16]bool), e)
12525}
12526func (_ 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
12572func (e *Encoder) fastpathEncMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
12573 fastpathTV.EncMapInt32IntfV(rv2i(rv).(map[int32]interface{}), e)
12574}
12575func (_ 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
12621func (e *Encoder) fastpathEncMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
12622 fastpathTV.EncMapInt32StringV(rv2i(rv).(map[int32]string), e)
12623}
12624func (_ 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
12670func (e *Encoder) fastpathEncMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
12671 fastpathTV.EncMapInt32UintV(rv2i(rv).(map[int32]uint), e)
12672}
12673func (_ 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
12719func (e *Encoder) fastpathEncMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
12720 fastpathTV.EncMapInt32Uint8V(rv2i(rv).(map[int32]uint8), e)
12721}
12722func (_ 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
12768func (e *Encoder) fastpathEncMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
12769 fastpathTV.EncMapInt32Uint16V(rv2i(rv).(map[int32]uint16), e)
12770}
12771func (_ 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
12817func (e *Encoder) fastpathEncMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
12818 fastpathTV.EncMapInt32Uint32V(rv2i(rv).(map[int32]uint32), e)
12819}
12820func (_ 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
12866func (e *Encoder) fastpathEncMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
12867 fastpathTV.EncMapInt32Uint64V(rv2i(rv).(map[int32]uint64), e)
12868}
12869func (_ 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
12915func (e *Encoder) fastpathEncMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
12916 fastpathTV.EncMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), e)
12917}
12918func (_ 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
12964func (e *Encoder) fastpathEncMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
12965 fastpathTV.EncMapInt32IntV(rv2i(rv).(map[int32]int), e)
12966}
12967func (_ 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
13013func (e *Encoder) fastpathEncMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
13014 fastpathTV.EncMapInt32Int8V(rv2i(rv).(map[int32]int8), e)
13015}
13016func (_ 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
13062func (e *Encoder) fastpathEncMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
13063 fastpathTV.EncMapInt32Int16V(rv2i(rv).(map[int32]int16), e)
13064}
13065func (_ 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
13111func (e *Encoder) fastpathEncMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
13112 fastpathTV.EncMapInt32Int32V(rv2i(rv).(map[int32]int32), e)
13113}
13114func (_ 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
13160func (e *Encoder) fastpathEncMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
13161 fastpathTV.EncMapInt32Int64V(rv2i(rv).(map[int32]int64), e)
13162}
13163func (_ 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
13209func (e *Encoder) fastpathEncMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
13210 fastpathTV.EncMapInt32Float32V(rv2i(rv).(map[int32]float32), e)
13211}
13212func (_ 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
13258func (e *Encoder) fastpathEncMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
13259 fastpathTV.EncMapInt32Float64V(rv2i(rv).(map[int32]float64), e)
13260}
13261func (_ 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
13307func (e *Encoder) fastpathEncMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
13308 fastpathTV.EncMapInt32BoolV(rv2i(rv).(map[int32]bool), e)
13309}
13310func (_ 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
13356func (e *Encoder) fastpathEncMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
13357 fastpathTV.EncMapInt64IntfV(rv2i(rv).(map[int64]interface{}), e)
13358}
13359func (_ 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
13405func (e *Encoder) fastpathEncMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
13406 fastpathTV.EncMapInt64StringV(rv2i(rv).(map[int64]string), e)
13407}
13408func (_ 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
13454func (e *Encoder) fastpathEncMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
13455 fastpathTV.EncMapInt64UintV(rv2i(rv).(map[int64]uint), e)
13456}
13457func (_ 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
13503func (e *Encoder) fastpathEncMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
13504 fastpathTV.EncMapInt64Uint8V(rv2i(rv).(map[int64]uint8), e)
13505}
13506func (_ 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
13552func (e *Encoder) fastpathEncMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
13553 fastpathTV.EncMapInt64Uint16V(rv2i(rv).(map[int64]uint16), e)
13554}
13555func (_ 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
13601func (e *Encoder) fastpathEncMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
13602 fastpathTV.EncMapInt64Uint32V(rv2i(rv).(map[int64]uint32), e)
13603}
13604func (_ 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
13650func (e *Encoder) fastpathEncMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
13651 fastpathTV.EncMapInt64Uint64V(rv2i(rv).(map[int64]uint64), e)
13652}
13653func (_ 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
13699func (e *Encoder) fastpathEncMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
13700 fastpathTV.EncMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), e)
13701}
13702func (_ 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
13748func (e *Encoder) fastpathEncMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
13749 fastpathTV.EncMapInt64IntV(rv2i(rv).(map[int64]int), e)
13750}
13751func (_ 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
13797func (e *Encoder) fastpathEncMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
13798 fastpathTV.EncMapInt64Int8V(rv2i(rv).(map[int64]int8), e)
13799}
13800func (_ 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
13846func (e *Encoder) fastpathEncMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
13847 fastpathTV.EncMapInt64Int16V(rv2i(rv).(map[int64]int16), e)
13848}
13849func (_ 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
13895func (e *Encoder) fastpathEncMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
13896 fastpathTV.EncMapInt64Int32V(rv2i(rv).(map[int64]int32), e)
13897}
13898func (_ 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
13944func (e *Encoder) fastpathEncMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
13945 fastpathTV.EncMapInt64Int64V(rv2i(rv).(map[int64]int64), e)
13946}
13947func (_ 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
13993func (e *Encoder) fastpathEncMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
13994 fastpathTV.EncMapInt64Float32V(rv2i(rv).(map[int64]float32), e)
13995}
13996func (_ 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
14042func (e *Encoder) fastpathEncMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
14043 fastpathTV.EncMapInt64Float64V(rv2i(rv).(map[int64]float64), e)
14044}
14045func (_ 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
14091func (e *Encoder) fastpathEncMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
14092 fastpathTV.EncMapInt64BoolV(rv2i(rv).(map[int64]bool), e)
14093}
14094func (_ 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
14140func (e *Encoder) fastpathEncMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
14141 fastpathTV.EncMapBoolIntfV(rv2i(rv).(map[bool]interface{}), e)
14142}
14143func (_ 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
14189func (e *Encoder) fastpathEncMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
14190 fastpathTV.EncMapBoolStringV(rv2i(rv).(map[bool]string), e)
14191}
14192func (_ 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
14238func (e *Encoder) fastpathEncMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
14239 fastpathTV.EncMapBoolUintV(rv2i(rv).(map[bool]uint), e)
14240}
14241func (_ 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
14287func (e *Encoder) fastpathEncMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
14288 fastpathTV.EncMapBoolUint8V(rv2i(rv).(map[bool]uint8), e)
14289}
14290func (_ 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
14336func (e *Encoder) fastpathEncMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
14337 fastpathTV.EncMapBoolUint16V(rv2i(rv).(map[bool]uint16), e)
14338}
14339func (_ 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
14385func (e *Encoder) fastpathEncMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
14386 fastpathTV.EncMapBoolUint32V(rv2i(rv).(map[bool]uint32), e)
14387}
14388func (_ 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
14434func (e *Encoder) fastpathEncMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
14435 fastpathTV.EncMapBoolUint64V(rv2i(rv).(map[bool]uint64), e)
14436}
14437func (_ 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
14483func (e *Encoder) fastpathEncMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
14484 fastpathTV.EncMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), e)
14485}
14486func (_ 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
14532func (e *Encoder) fastpathEncMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
14533 fastpathTV.EncMapBoolIntV(rv2i(rv).(map[bool]int), e)
14534}
14535func (_ 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
14581func (e *Encoder) fastpathEncMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
14582 fastpathTV.EncMapBoolInt8V(rv2i(rv).(map[bool]int8), e)
14583}
14584func (_ 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
14630func (e *Encoder) fastpathEncMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
14631 fastpathTV.EncMapBoolInt16V(rv2i(rv).(map[bool]int16), e)
14632}
14633func (_ 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
14679func (e *Encoder) fastpathEncMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
14680 fastpathTV.EncMapBoolInt32V(rv2i(rv).(map[bool]int32), e)
14681}
14682func (_ 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
14728func (e *Encoder) fastpathEncMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
14729 fastpathTV.EncMapBoolInt64V(rv2i(rv).(map[bool]int64), e)
14730}
14731func (_ 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
14777func (e *Encoder) fastpathEncMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
14778 fastpathTV.EncMapBoolFloat32V(rv2i(rv).(map[bool]float32), e)
14779}
14780func (_ 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
14826func (e *Encoder) fastpathEncMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
14827 fastpathTV.EncMapBoolFloat64V(rv2i(rv).(map[bool]float64), e)
14828}
14829func (_ 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
14875func (e *Encoder) fastpathEncMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
14876 fastpathTV.EncMapBoolBoolV(rv2i(rv).(map[bool]bool), e)
14877}
14878func (_ 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
14927func 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
17167func 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
17724func (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}
17739func (f fastpathT) DecSliceIntfX(vp *[]interface{}, d *Decoder) {
17740 v, changed := f.DecSliceIntfV(*vp, true, d)
17741 if changed {
17742 *vp = v
17743 }
17744}
17745func (_ 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 hasLen := containerLenS > 0
17761 var xlen int
17762 if hasLen && canChange {
17763 if containerLenS > cap(v) {
17764 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17765 if xlen <= cap(v) {
17766 v = v[:xlen]
17767 } else {
17768 v = make([]interface{}, xlen)
17769 }
17770 changed = true
17771 } else if containerLenS != len(v) {
17772 v = v[:containerLenS]
17773 changed = true
17774 }
17775 }
17776 j := 0
17777 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
17778 if j == 0 && len(v) == 0 && canChange {
17779 if hasLen {
17780 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17781 } else {
17782 xlen = 8
17783 }
17784 v = make([]interface{}, xlen)
17785 changed = true
17786 }
17787 // if indefinite, etc, then expand the slice if necessary
17788 var decodeIntoBlank bool
17789 if j >= len(v) {
17790 if canChange {
17791 v = append(v, nil)
17792 changed = true
17793 } else {
17794 d.arrayCannotExpand(len(v), j+1)
17795 decodeIntoBlank = true
17796 }
17797 }
17798 slh.ElemContainerState(j)
17799 if decodeIntoBlank {
17800 d.swallow()
17801 } else if dd.TryDecodeAsNil() {
17802 v[j] = nil
17803 } else {
17804 d.decode(&v[j])
17805 }
17806 }
17807 if canChange {
17808 if j < len(v) {
17809 v = v[:j]
17810 changed = true
17811 } else if j == 0 && v == nil {
17812 v = make([]interface{}, 0)
17813 changed = true
17814 }
17815 }
17816 slh.End()
17817 return v, changed
17818}
17819
17820func (d *Decoder) fastpathDecSliceStringR(f *codecFnInfo, rv reflect.Value) {
17821 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
17822 vp := rv2i(rv).(*[]string)
17823 v, changed := fastpathTV.DecSliceStringV(*vp, !array, d)
17824 if changed {
17825 *vp = v
17826 }
17827 } else {
17828 v := rv2i(rv).([]string)
17829 v2, changed := fastpathTV.DecSliceStringV(v, !array, d)
17830 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
17831 copy(v, v2)
17832 }
17833 }
17834}
17835func (f fastpathT) DecSliceStringX(vp *[]string, d *Decoder) {
17836 v, changed := f.DecSliceStringV(*vp, true, d)
17837 if changed {
17838 *vp = v
17839 }
17840}
17841func (_ fastpathT) DecSliceStringV(v []string, canChange bool, d *Decoder) (_ []string, changed bool) {
17842 dd := d.d
17843 slh, containerLenS := d.decSliceHelperStart()
17844 if containerLenS == 0 {
17845 if canChange {
17846 if v == nil {
17847 v = []string{}
17848 } else if len(v) != 0 {
17849 v = v[:0]
17850 }
17851 changed = true
17852 }
17853 slh.End()
17854 return v, changed
17855 }
17856 hasLen := containerLenS > 0
17857 var xlen int
17858 if hasLen && canChange {
17859 if containerLenS > cap(v) {
17860 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17861 if xlen <= cap(v) {
17862 v = v[:xlen]
17863 } else {
17864 v = make([]string, xlen)
17865 }
17866 changed = true
17867 } else if containerLenS != len(v) {
17868 v = v[:containerLenS]
17869 changed = true
17870 }
17871 }
17872 j := 0
17873 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
17874 if j == 0 && len(v) == 0 && canChange {
17875 if hasLen {
17876 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
17877 } else {
17878 xlen = 8
17879 }
17880 v = make([]string, xlen)
17881 changed = true
17882 }
17883 // if indefinite, etc, then expand the slice if necessary
17884 var decodeIntoBlank bool
17885 if j >= len(v) {
17886 if canChange {
17887 v = append(v, "")
17888 changed = true
17889 } else {
17890 d.arrayCannotExpand(len(v), j+1)
17891 decodeIntoBlank = true
17892 }
17893 }
17894 slh.ElemContainerState(j)
17895 if decodeIntoBlank {
17896 d.swallow()
17897 } else if dd.TryDecodeAsNil() {
17898 v[j] = ""
17899 } else {
17900 v[j] = dd.DecodeString()
17901 }
17902 }
17903 if canChange {
17904 if j < len(v) {
17905 v = v[:j]
17906 changed = true
17907 } else if j == 0 && v == nil {
17908 v = make([]string, 0)
17909 changed = true
17910 }
17911 }
17912 slh.End()
17913 return v, changed
17914}
17915
17916func (d *Decoder) fastpathDecSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
17917 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
17918 vp := rv2i(rv).(*[]float32)
17919 v, changed := fastpathTV.DecSliceFloat32V(*vp, !array, d)
17920 if changed {
17921 *vp = v
17922 }
17923 } else {
17924 v := rv2i(rv).([]float32)
17925 v2, changed := fastpathTV.DecSliceFloat32V(v, !array, d)
17926 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
17927 copy(v, v2)
17928 }
17929 }
17930}
17931func (f fastpathT) DecSliceFloat32X(vp *[]float32, d *Decoder) {
17932 v, changed := f.DecSliceFloat32V(*vp, true, d)
17933 if changed {
17934 *vp = v
17935 }
17936}
17937func (_ fastpathT) DecSliceFloat32V(v []float32, canChange bool, d *Decoder) (_ []float32, changed bool) {
17938 dd := d.d
17939 slh, containerLenS := d.decSliceHelperStart()
17940 if containerLenS == 0 {
17941 if canChange {
17942 if v == nil {
17943 v = []float32{}
17944 } else if len(v) != 0 {
17945 v = v[:0]
17946 }
17947 changed = true
17948 }
17949 slh.End()
17950 return v, changed
17951 }
17952 hasLen := containerLenS > 0
17953 var xlen int
17954 if hasLen && canChange {
17955 if containerLenS > cap(v) {
17956 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
17957 if xlen <= cap(v) {
17958 v = v[:xlen]
17959 } else {
17960 v = make([]float32, xlen)
17961 }
17962 changed = true
17963 } else if containerLenS != len(v) {
17964 v = v[:containerLenS]
17965 changed = true
17966 }
17967 }
17968 j := 0
17969 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
17970 if j == 0 && len(v) == 0 && canChange {
17971 if hasLen {
17972 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
17973 } else {
17974 xlen = 8
17975 }
17976 v = make([]float32, xlen)
17977 changed = true
17978 }
17979 // if indefinite, etc, then expand the slice if necessary
17980 var decodeIntoBlank bool
17981 if j >= len(v) {
17982 if canChange {
17983 v = append(v, 0)
17984 changed = true
17985 } else {
17986 d.arrayCannotExpand(len(v), j+1)
17987 decodeIntoBlank = true
17988 }
17989 }
17990 slh.ElemContainerState(j)
17991 if decodeIntoBlank {
17992 d.swallow()
17993 } else if dd.TryDecodeAsNil() {
17994 v[j] = 0
17995 } else {
17996 v[j] = float32(chkOvf.Float32V(dd.DecodeFloat64()))
17997 }
17998 }
17999 if canChange {
18000 if j < len(v) {
18001 v = v[:j]
18002 changed = true
18003 } else if j == 0 && v == nil {
18004 v = make([]float32, 0)
18005 changed = true
18006 }
18007 }
18008 slh.End()
18009 return v, changed
18010}
18011
18012func (d *Decoder) fastpathDecSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
18013 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18014 vp := rv2i(rv).(*[]float64)
18015 v, changed := fastpathTV.DecSliceFloat64V(*vp, !array, d)
18016 if changed {
18017 *vp = v
18018 }
18019 } else {
18020 v := rv2i(rv).([]float64)
18021 v2, changed := fastpathTV.DecSliceFloat64V(v, !array, d)
18022 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18023 copy(v, v2)
18024 }
18025 }
18026}
18027func (f fastpathT) DecSliceFloat64X(vp *[]float64, d *Decoder) {
18028 v, changed := f.DecSliceFloat64V(*vp, true, d)
18029 if changed {
18030 *vp = v
18031 }
18032}
18033func (_ fastpathT) DecSliceFloat64V(v []float64, canChange bool, d *Decoder) (_ []float64, changed bool) {
18034 dd := d.d
18035 slh, containerLenS := d.decSliceHelperStart()
18036 if containerLenS == 0 {
18037 if canChange {
18038 if v == nil {
18039 v = []float64{}
18040 } else if len(v) != 0 {
18041 v = v[:0]
18042 }
18043 changed = true
18044 }
18045 slh.End()
18046 return v, changed
18047 }
18048 hasLen := containerLenS > 0
18049 var xlen int
18050 if hasLen && canChange {
18051 if containerLenS > cap(v) {
18052 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18053 if xlen <= cap(v) {
18054 v = v[:xlen]
18055 } else {
18056 v = make([]float64, xlen)
18057 }
18058 changed = true
18059 } else if containerLenS != len(v) {
18060 v = v[:containerLenS]
18061 changed = true
18062 }
18063 }
18064 j := 0
18065 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18066 if j == 0 && len(v) == 0 && canChange {
18067 if hasLen {
18068 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18069 } else {
18070 xlen = 8
18071 }
18072 v = make([]float64, xlen)
18073 changed = true
18074 }
18075 // if indefinite, etc, then expand the slice if necessary
18076 var decodeIntoBlank bool
18077 if j >= len(v) {
18078 if canChange {
18079 v = append(v, 0)
18080 changed = true
18081 } else {
18082 d.arrayCannotExpand(len(v), j+1)
18083 decodeIntoBlank = true
18084 }
18085 }
18086 slh.ElemContainerState(j)
18087 if decodeIntoBlank {
18088 d.swallow()
18089 } else if dd.TryDecodeAsNil() {
18090 v[j] = 0
18091 } else {
18092 v[j] = dd.DecodeFloat64()
18093 }
18094 }
18095 if canChange {
18096 if j < len(v) {
18097 v = v[:j]
18098 changed = true
18099 } else if j == 0 && v == nil {
18100 v = make([]float64, 0)
18101 changed = true
18102 }
18103 }
18104 slh.End()
18105 return v, changed
18106}
18107
18108func (d *Decoder) fastpathDecSliceUintR(f *codecFnInfo, rv reflect.Value) {
18109 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18110 vp := rv2i(rv).(*[]uint)
18111 v, changed := fastpathTV.DecSliceUintV(*vp, !array, d)
18112 if changed {
18113 *vp = v
18114 }
18115 } else {
18116 v := rv2i(rv).([]uint)
18117 v2, changed := fastpathTV.DecSliceUintV(v, !array, d)
18118 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18119 copy(v, v2)
18120 }
18121 }
18122}
18123func (f fastpathT) DecSliceUintX(vp *[]uint, d *Decoder) {
18124 v, changed := f.DecSliceUintV(*vp, true, d)
18125 if changed {
18126 *vp = v
18127 }
18128}
18129func (_ fastpathT) DecSliceUintV(v []uint, canChange bool, d *Decoder) (_ []uint, changed bool) {
18130 dd := d.d
18131 slh, containerLenS := d.decSliceHelperStart()
18132 if containerLenS == 0 {
18133 if canChange {
18134 if v == nil {
18135 v = []uint{}
18136 } else if len(v) != 0 {
18137 v = v[:0]
18138 }
18139 changed = true
18140 }
18141 slh.End()
18142 return v, changed
18143 }
18144 hasLen := containerLenS > 0
18145 var xlen int
18146 if hasLen && canChange {
18147 if containerLenS > cap(v) {
18148 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18149 if xlen <= cap(v) {
18150 v = v[:xlen]
18151 } else {
18152 v = make([]uint, xlen)
18153 }
18154 changed = true
18155 } else if containerLenS != len(v) {
18156 v = v[:containerLenS]
18157 changed = true
18158 }
18159 }
18160 j := 0
18161 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18162 if j == 0 && len(v) == 0 && canChange {
18163 if hasLen {
18164 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18165 } else {
18166 xlen = 8
18167 }
18168 v = make([]uint, xlen)
18169 changed = true
18170 }
18171 // if indefinite, etc, then expand the slice if necessary
18172 var decodeIntoBlank bool
18173 if j >= len(v) {
18174 if canChange {
18175 v = append(v, 0)
18176 changed = true
18177 } else {
18178 d.arrayCannotExpand(len(v), j+1)
18179 decodeIntoBlank = true
18180 }
18181 }
18182 slh.ElemContainerState(j)
18183 if decodeIntoBlank {
18184 d.swallow()
18185 } else if dd.TryDecodeAsNil() {
18186 v[j] = 0
18187 } else {
18188 v[j] = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
18189 }
18190 }
18191 if canChange {
18192 if j < len(v) {
18193 v = v[:j]
18194 changed = true
18195 } else if j == 0 && v == nil {
18196 v = make([]uint, 0)
18197 changed = true
18198 }
18199 }
18200 slh.End()
18201 return v, changed
18202}
18203
18204func (d *Decoder) fastpathDecSliceUint8R(f *codecFnInfo, rv reflect.Value) {
18205 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18206 vp := rv2i(rv).(*[]uint8)
18207 v, changed := fastpathTV.DecSliceUint8V(*vp, !array, d)
18208 if changed {
18209 *vp = v
18210 }
18211 } else {
18212 v := rv2i(rv).([]uint8)
18213 v2, changed := fastpathTV.DecSliceUint8V(v, !array, d)
18214 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18215 copy(v, v2)
18216 }
18217 }
18218}
18219func (f fastpathT) DecSliceUint8X(vp *[]uint8, d *Decoder) {
18220 v, changed := f.DecSliceUint8V(*vp, true, d)
18221 if changed {
18222 *vp = v
18223 }
18224}
18225func (_ fastpathT) DecSliceUint8V(v []uint8, canChange bool, d *Decoder) (_ []uint8, changed bool) {
18226 dd := d.d
18227 slh, containerLenS := d.decSliceHelperStart()
18228 if containerLenS == 0 {
18229 if canChange {
18230 if v == nil {
18231 v = []uint8{}
18232 } else if len(v) != 0 {
18233 v = v[:0]
18234 }
18235 changed = true
18236 }
18237 slh.End()
18238 return v, changed
18239 }
18240 hasLen := containerLenS > 0
18241 var xlen int
18242 if hasLen && canChange {
18243 if containerLenS > cap(v) {
18244 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18245 if xlen <= cap(v) {
18246 v = v[:xlen]
18247 } else {
18248 v = make([]uint8, xlen)
18249 }
18250 changed = true
18251 } else if containerLenS != len(v) {
18252 v = v[:containerLenS]
18253 changed = true
18254 }
18255 }
18256 j := 0
18257 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18258 if j == 0 && len(v) == 0 && canChange {
18259 if hasLen {
18260 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18261 } else {
18262 xlen = 8
18263 }
18264 v = make([]uint8, xlen)
18265 changed = true
18266 }
18267 // if indefinite, etc, then expand the slice if necessary
18268 var decodeIntoBlank bool
18269 if j >= len(v) {
18270 if canChange {
18271 v = append(v, 0)
18272 changed = true
18273 } else {
18274 d.arrayCannotExpand(len(v), j+1)
18275 decodeIntoBlank = true
18276 }
18277 }
18278 slh.ElemContainerState(j)
18279 if decodeIntoBlank {
18280 d.swallow()
18281 } else if dd.TryDecodeAsNil() {
18282 v[j] = 0
18283 } else {
18284 v[j] = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
18285 }
18286 }
18287 if canChange {
18288 if j < len(v) {
18289 v = v[:j]
18290 changed = true
18291 } else if j == 0 && v == nil {
18292 v = make([]uint8, 0)
18293 changed = true
18294 }
18295 }
18296 slh.End()
18297 return v, changed
18298}
18299
18300func (d *Decoder) fastpathDecSliceUint16R(f *codecFnInfo, rv reflect.Value) {
18301 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18302 vp := rv2i(rv).(*[]uint16)
18303 v, changed := fastpathTV.DecSliceUint16V(*vp, !array, d)
18304 if changed {
18305 *vp = v
18306 }
18307 } else {
18308 v := rv2i(rv).([]uint16)
18309 v2, changed := fastpathTV.DecSliceUint16V(v, !array, d)
18310 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18311 copy(v, v2)
18312 }
18313 }
18314}
18315func (f fastpathT) DecSliceUint16X(vp *[]uint16, d *Decoder) {
18316 v, changed := f.DecSliceUint16V(*vp, true, d)
18317 if changed {
18318 *vp = v
18319 }
18320}
18321func (_ fastpathT) DecSliceUint16V(v []uint16, canChange bool, d *Decoder) (_ []uint16, changed bool) {
18322 dd := d.d
18323 slh, containerLenS := d.decSliceHelperStart()
18324 if containerLenS == 0 {
18325 if canChange {
18326 if v == nil {
18327 v = []uint16{}
18328 } else if len(v) != 0 {
18329 v = v[:0]
18330 }
18331 changed = true
18332 }
18333 slh.End()
18334 return v, changed
18335 }
18336 hasLen := containerLenS > 0
18337 var xlen int
18338 if hasLen && canChange {
18339 if containerLenS > cap(v) {
18340 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18341 if xlen <= cap(v) {
18342 v = v[:xlen]
18343 } else {
18344 v = make([]uint16, xlen)
18345 }
18346 changed = true
18347 } else if containerLenS != len(v) {
18348 v = v[:containerLenS]
18349 changed = true
18350 }
18351 }
18352 j := 0
18353 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18354 if j == 0 && len(v) == 0 && canChange {
18355 if hasLen {
18356 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18357 } else {
18358 xlen = 8
18359 }
18360 v = make([]uint16, xlen)
18361 changed = true
18362 }
18363 // if indefinite, etc, then expand the slice if necessary
18364 var decodeIntoBlank bool
18365 if j >= len(v) {
18366 if canChange {
18367 v = append(v, 0)
18368 changed = true
18369 } else {
18370 d.arrayCannotExpand(len(v), j+1)
18371 decodeIntoBlank = true
18372 }
18373 }
18374 slh.ElemContainerState(j)
18375 if decodeIntoBlank {
18376 d.swallow()
18377 } else if dd.TryDecodeAsNil() {
18378 v[j] = 0
18379 } else {
18380 v[j] = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
18381 }
18382 }
18383 if canChange {
18384 if j < len(v) {
18385 v = v[:j]
18386 changed = true
18387 } else if j == 0 && v == nil {
18388 v = make([]uint16, 0)
18389 changed = true
18390 }
18391 }
18392 slh.End()
18393 return v, changed
18394}
18395
18396func (d *Decoder) fastpathDecSliceUint32R(f *codecFnInfo, rv reflect.Value) {
18397 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18398 vp := rv2i(rv).(*[]uint32)
18399 v, changed := fastpathTV.DecSliceUint32V(*vp, !array, d)
18400 if changed {
18401 *vp = v
18402 }
18403 } else {
18404 v := rv2i(rv).([]uint32)
18405 v2, changed := fastpathTV.DecSliceUint32V(v, !array, d)
18406 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18407 copy(v, v2)
18408 }
18409 }
18410}
18411func (f fastpathT) DecSliceUint32X(vp *[]uint32, d *Decoder) {
18412 v, changed := f.DecSliceUint32V(*vp, true, d)
18413 if changed {
18414 *vp = v
18415 }
18416}
18417func (_ fastpathT) DecSliceUint32V(v []uint32, canChange bool, d *Decoder) (_ []uint32, changed bool) {
18418 dd := d.d
18419 slh, containerLenS := d.decSliceHelperStart()
18420 if containerLenS == 0 {
18421 if canChange {
18422 if v == nil {
18423 v = []uint32{}
18424 } else if len(v) != 0 {
18425 v = v[:0]
18426 }
18427 changed = true
18428 }
18429 slh.End()
18430 return v, changed
18431 }
18432 hasLen := containerLenS > 0
18433 var xlen int
18434 if hasLen && canChange {
18435 if containerLenS > cap(v) {
18436 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
18437 if xlen <= cap(v) {
18438 v = v[:xlen]
18439 } else {
18440 v = make([]uint32, xlen)
18441 }
18442 changed = true
18443 } else if containerLenS != len(v) {
18444 v = v[:containerLenS]
18445 changed = true
18446 }
18447 }
18448 j := 0
18449 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18450 if j == 0 && len(v) == 0 && canChange {
18451 if hasLen {
18452 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
18453 } else {
18454 xlen = 8
18455 }
18456 v = make([]uint32, xlen)
18457 changed = true
18458 }
18459 // if indefinite, etc, then expand the slice if necessary
18460 var decodeIntoBlank bool
18461 if j >= len(v) {
18462 if canChange {
18463 v = append(v, 0)
18464 changed = true
18465 } else {
18466 d.arrayCannotExpand(len(v), j+1)
18467 decodeIntoBlank = true
18468 }
18469 }
18470 slh.ElemContainerState(j)
18471 if decodeIntoBlank {
18472 d.swallow()
18473 } else if dd.TryDecodeAsNil() {
18474 v[j] = 0
18475 } else {
18476 v[j] = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
18477 }
18478 }
18479 if canChange {
18480 if j < len(v) {
18481 v = v[:j]
18482 changed = true
18483 } else if j == 0 && v == nil {
18484 v = make([]uint32, 0)
18485 changed = true
18486 }
18487 }
18488 slh.End()
18489 return v, changed
18490}
18491
18492func (d *Decoder) fastpathDecSliceUint64R(f *codecFnInfo, rv reflect.Value) {
18493 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18494 vp := rv2i(rv).(*[]uint64)
18495 v, changed := fastpathTV.DecSliceUint64V(*vp, !array, d)
18496 if changed {
18497 *vp = v
18498 }
18499 } else {
18500 v := rv2i(rv).([]uint64)
18501 v2, changed := fastpathTV.DecSliceUint64V(v, !array, d)
18502 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18503 copy(v, v2)
18504 }
18505 }
18506}
18507func (f fastpathT) DecSliceUint64X(vp *[]uint64, d *Decoder) {
18508 v, changed := f.DecSliceUint64V(*vp, true, d)
18509 if changed {
18510 *vp = v
18511 }
18512}
18513func (_ fastpathT) DecSliceUint64V(v []uint64, canChange bool, d *Decoder) (_ []uint64, changed bool) {
18514 dd := d.d
18515 slh, containerLenS := d.decSliceHelperStart()
18516 if containerLenS == 0 {
18517 if canChange {
18518 if v == nil {
18519 v = []uint64{}
18520 } else if len(v) != 0 {
18521 v = v[:0]
18522 }
18523 changed = true
18524 }
18525 slh.End()
18526 return v, changed
18527 }
18528 hasLen := containerLenS > 0
18529 var xlen int
18530 if hasLen && canChange {
18531 if containerLenS > cap(v) {
18532 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18533 if xlen <= cap(v) {
18534 v = v[:xlen]
18535 } else {
18536 v = make([]uint64, xlen)
18537 }
18538 changed = true
18539 } else if containerLenS != len(v) {
18540 v = v[:containerLenS]
18541 changed = true
18542 }
18543 }
18544 j := 0
18545 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18546 if j == 0 && len(v) == 0 && canChange {
18547 if hasLen {
18548 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18549 } else {
18550 xlen = 8
18551 }
18552 v = make([]uint64, xlen)
18553 changed = true
18554 }
18555 // if indefinite, etc, then expand the slice if necessary
18556 var decodeIntoBlank bool
18557 if j >= len(v) {
18558 if canChange {
18559 v = append(v, 0)
18560 changed = true
18561 } else {
18562 d.arrayCannotExpand(len(v), j+1)
18563 decodeIntoBlank = true
18564 }
18565 }
18566 slh.ElemContainerState(j)
18567 if decodeIntoBlank {
18568 d.swallow()
18569 } else if dd.TryDecodeAsNil() {
18570 v[j] = 0
18571 } else {
18572 v[j] = dd.DecodeUint64()
18573 }
18574 }
18575 if canChange {
18576 if j < len(v) {
18577 v = v[:j]
18578 changed = true
18579 } else if j == 0 && v == nil {
18580 v = make([]uint64, 0)
18581 changed = true
18582 }
18583 }
18584 slh.End()
18585 return v, changed
18586}
18587
18588func (d *Decoder) fastpathDecSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
18589 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18590 vp := rv2i(rv).(*[]uintptr)
18591 v, changed := fastpathTV.DecSliceUintptrV(*vp, !array, d)
18592 if changed {
18593 *vp = v
18594 }
18595 } else {
18596 v := rv2i(rv).([]uintptr)
18597 v2, changed := fastpathTV.DecSliceUintptrV(v, !array, d)
18598 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18599 copy(v, v2)
18600 }
18601 }
18602}
18603func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, d *Decoder) {
18604 v, changed := f.DecSliceUintptrV(*vp, true, d)
18605 if changed {
18606 *vp = v
18607 }
18608}
18609func (_ fastpathT) DecSliceUintptrV(v []uintptr, canChange bool, d *Decoder) (_ []uintptr, changed bool) {
18610 dd := d.d
18611 slh, containerLenS := d.decSliceHelperStart()
18612 if containerLenS == 0 {
18613 if canChange {
18614 if v == nil {
18615 v = []uintptr{}
18616 } else if len(v) != 0 {
18617 v = v[:0]
18618 }
18619 changed = true
18620 }
18621 slh.End()
18622 return v, changed
18623 }
18624 hasLen := containerLenS > 0
18625 var xlen int
18626 if hasLen && canChange {
18627 if containerLenS > cap(v) {
18628 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18629 if xlen <= cap(v) {
18630 v = v[:xlen]
18631 } else {
18632 v = make([]uintptr, xlen)
18633 }
18634 changed = true
18635 } else if containerLenS != len(v) {
18636 v = v[:containerLenS]
18637 changed = true
18638 }
18639 }
18640 j := 0
18641 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18642 if j == 0 && len(v) == 0 && canChange {
18643 if hasLen {
18644 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18645 } else {
18646 xlen = 8
18647 }
18648 v = make([]uintptr, xlen)
18649 changed = true
18650 }
18651 // if indefinite, etc, then expand the slice if necessary
18652 var decodeIntoBlank bool
18653 if j >= len(v) {
18654 if canChange {
18655 v = append(v, 0)
18656 changed = true
18657 } else {
18658 d.arrayCannotExpand(len(v), j+1)
18659 decodeIntoBlank = true
18660 }
18661 }
18662 slh.ElemContainerState(j)
18663 if decodeIntoBlank {
18664 d.swallow()
18665 } else if dd.TryDecodeAsNil() {
18666 v[j] = 0
18667 } else {
18668 v[j] = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
18669 }
18670 }
18671 if canChange {
18672 if j < len(v) {
18673 v = v[:j]
18674 changed = true
18675 } else if j == 0 && v == nil {
18676 v = make([]uintptr, 0)
18677 changed = true
18678 }
18679 }
18680 slh.End()
18681 return v, changed
18682}
18683
18684func (d *Decoder) fastpathDecSliceIntR(f *codecFnInfo, rv reflect.Value) {
18685 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18686 vp := rv2i(rv).(*[]int)
18687 v, changed := fastpathTV.DecSliceIntV(*vp, !array, d)
18688 if changed {
18689 *vp = v
18690 }
18691 } else {
18692 v := rv2i(rv).([]int)
18693 v2, changed := fastpathTV.DecSliceIntV(v, !array, d)
18694 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18695 copy(v, v2)
18696 }
18697 }
18698}
18699func (f fastpathT) DecSliceIntX(vp *[]int, d *Decoder) {
18700 v, changed := f.DecSliceIntV(*vp, true, d)
18701 if changed {
18702 *vp = v
18703 }
18704}
18705func (_ fastpathT) DecSliceIntV(v []int, canChange bool, d *Decoder) (_ []int, changed bool) {
18706 dd := d.d
18707 slh, containerLenS := d.decSliceHelperStart()
18708 if containerLenS == 0 {
18709 if canChange {
18710 if v == nil {
18711 v = []int{}
18712 } else if len(v) != 0 {
18713 v = v[:0]
18714 }
18715 changed = true
18716 }
18717 slh.End()
18718 return v, changed
18719 }
18720 hasLen := containerLenS > 0
18721 var xlen int
18722 if hasLen && canChange {
18723 if containerLenS > cap(v) {
18724 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18725 if xlen <= cap(v) {
18726 v = v[:xlen]
18727 } else {
18728 v = make([]int, xlen)
18729 }
18730 changed = true
18731 } else if containerLenS != len(v) {
18732 v = v[:containerLenS]
18733 changed = true
18734 }
18735 }
18736 j := 0
18737 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18738 if j == 0 && len(v) == 0 && canChange {
18739 if hasLen {
18740 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
18741 } else {
18742 xlen = 8
18743 }
18744 v = make([]int, xlen)
18745 changed = true
18746 }
18747 // if indefinite, etc, then expand the slice if necessary
18748 var decodeIntoBlank bool
18749 if j >= len(v) {
18750 if canChange {
18751 v = append(v, 0)
18752 changed = true
18753 } else {
18754 d.arrayCannotExpand(len(v), j+1)
18755 decodeIntoBlank = true
18756 }
18757 }
18758 slh.ElemContainerState(j)
18759 if decodeIntoBlank {
18760 d.swallow()
18761 } else if dd.TryDecodeAsNil() {
18762 v[j] = 0
18763 } else {
18764 v[j] = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
18765 }
18766 }
18767 if canChange {
18768 if j < len(v) {
18769 v = v[:j]
18770 changed = true
18771 } else if j == 0 && v == nil {
18772 v = make([]int, 0)
18773 changed = true
18774 }
18775 }
18776 slh.End()
18777 return v, changed
18778}
18779
18780func (d *Decoder) fastpathDecSliceInt8R(f *codecFnInfo, rv reflect.Value) {
18781 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18782 vp := rv2i(rv).(*[]int8)
18783 v, changed := fastpathTV.DecSliceInt8V(*vp, !array, d)
18784 if changed {
18785 *vp = v
18786 }
18787 } else {
18788 v := rv2i(rv).([]int8)
18789 v2, changed := fastpathTV.DecSliceInt8V(v, !array, d)
18790 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18791 copy(v, v2)
18792 }
18793 }
18794}
18795func (f fastpathT) DecSliceInt8X(vp *[]int8, d *Decoder) {
18796 v, changed := f.DecSliceInt8V(*vp, true, d)
18797 if changed {
18798 *vp = v
18799 }
18800}
18801func (_ fastpathT) DecSliceInt8V(v []int8, canChange bool, d *Decoder) (_ []int8, changed bool) {
18802 dd := d.d
18803 slh, containerLenS := d.decSliceHelperStart()
18804 if containerLenS == 0 {
18805 if canChange {
18806 if v == nil {
18807 v = []int8{}
18808 } else if len(v) != 0 {
18809 v = v[:0]
18810 }
18811 changed = true
18812 }
18813 slh.End()
18814 return v, changed
18815 }
18816 hasLen := containerLenS > 0
18817 var xlen int
18818 if hasLen && canChange {
18819 if containerLenS > cap(v) {
18820 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18821 if xlen <= cap(v) {
18822 v = v[:xlen]
18823 } else {
18824 v = make([]int8, xlen)
18825 }
18826 changed = true
18827 } else if containerLenS != len(v) {
18828 v = v[:containerLenS]
18829 changed = true
18830 }
18831 }
18832 j := 0
18833 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18834 if j == 0 && len(v) == 0 && canChange {
18835 if hasLen {
18836 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
18837 } else {
18838 xlen = 8
18839 }
18840 v = make([]int8, xlen)
18841 changed = true
18842 }
18843 // if indefinite, etc, then expand the slice if necessary
18844 var decodeIntoBlank bool
18845 if j >= len(v) {
18846 if canChange {
18847 v = append(v, 0)
18848 changed = true
18849 } else {
18850 d.arrayCannotExpand(len(v), j+1)
18851 decodeIntoBlank = true
18852 }
18853 }
18854 slh.ElemContainerState(j)
18855 if decodeIntoBlank {
18856 d.swallow()
18857 } else if dd.TryDecodeAsNil() {
18858 v[j] = 0
18859 } else {
18860 v[j] = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
18861 }
18862 }
18863 if canChange {
18864 if j < len(v) {
18865 v = v[:j]
18866 changed = true
18867 } else if j == 0 && v == nil {
18868 v = make([]int8, 0)
18869 changed = true
18870 }
18871 }
18872 slh.End()
18873 return v, changed
18874}
18875
18876func (d *Decoder) fastpathDecSliceInt16R(f *codecFnInfo, rv reflect.Value) {
18877 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18878 vp := rv2i(rv).(*[]int16)
18879 v, changed := fastpathTV.DecSliceInt16V(*vp, !array, d)
18880 if changed {
18881 *vp = v
18882 }
18883 } else {
18884 v := rv2i(rv).([]int16)
18885 v2, changed := fastpathTV.DecSliceInt16V(v, !array, d)
18886 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18887 copy(v, v2)
18888 }
18889 }
18890}
18891func (f fastpathT) DecSliceInt16X(vp *[]int16, d *Decoder) {
18892 v, changed := f.DecSliceInt16V(*vp, true, d)
18893 if changed {
18894 *vp = v
18895 }
18896}
18897func (_ fastpathT) DecSliceInt16V(v []int16, canChange bool, d *Decoder) (_ []int16, changed bool) {
18898 dd := d.d
18899 slh, containerLenS := d.decSliceHelperStart()
18900 if containerLenS == 0 {
18901 if canChange {
18902 if v == nil {
18903 v = []int16{}
18904 } else if len(v) != 0 {
18905 v = v[:0]
18906 }
18907 changed = true
18908 }
18909 slh.End()
18910 return v, changed
18911 }
18912 hasLen := containerLenS > 0
18913 var xlen int
18914 if hasLen && canChange {
18915 if containerLenS > cap(v) {
18916 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18917 if xlen <= cap(v) {
18918 v = v[:xlen]
18919 } else {
18920 v = make([]int16, xlen)
18921 }
18922 changed = true
18923 } else if containerLenS != len(v) {
18924 v = v[:containerLenS]
18925 changed = true
18926 }
18927 }
18928 j := 0
18929 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
18930 if j == 0 && len(v) == 0 && canChange {
18931 if hasLen {
18932 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 2)
18933 } else {
18934 xlen = 8
18935 }
18936 v = make([]int16, xlen)
18937 changed = true
18938 }
18939 // if indefinite, etc, then expand the slice if necessary
18940 var decodeIntoBlank bool
18941 if j >= len(v) {
18942 if canChange {
18943 v = append(v, 0)
18944 changed = true
18945 } else {
18946 d.arrayCannotExpand(len(v), j+1)
18947 decodeIntoBlank = true
18948 }
18949 }
18950 slh.ElemContainerState(j)
18951 if decodeIntoBlank {
18952 d.swallow()
18953 } else if dd.TryDecodeAsNil() {
18954 v[j] = 0
18955 } else {
18956 v[j] = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
18957 }
18958 }
18959 if canChange {
18960 if j < len(v) {
18961 v = v[:j]
18962 changed = true
18963 } else if j == 0 && v == nil {
18964 v = make([]int16, 0)
18965 changed = true
18966 }
18967 }
18968 slh.End()
18969 return v, changed
18970}
18971
18972func (d *Decoder) fastpathDecSliceInt32R(f *codecFnInfo, rv reflect.Value) {
18973 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
18974 vp := rv2i(rv).(*[]int32)
18975 v, changed := fastpathTV.DecSliceInt32V(*vp, !array, d)
18976 if changed {
18977 *vp = v
18978 }
18979 } else {
18980 v := rv2i(rv).([]int32)
18981 v2, changed := fastpathTV.DecSliceInt32V(v, !array, d)
18982 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
18983 copy(v, v2)
18984 }
18985 }
18986}
18987func (f fastpathT) DecSliceInt32X(vp *[]int32, d *Decoder) {
18988 v, changed := f.DecSliceInt32V(*vp, true, d)
18989 if changed {
18990 *vp = v
18991 }
18992}
18993func (_ fastpathT) DecSliceInt32V(v []int32, canChange bool, d *Decoder) (_ []int32, changed bool) {
18994 dd := d.d
18995 slh, containerLenS := d.decSliceHelperStart()
18996 if containerLenS == 0 {
18997 if canChange {
18998 if v == nil {
18999 v = []int32{}
19000 } else if len(v) != 0 {
19001 v = v[:0]
19002 }
19003 changed = true
19004 }
19005 slh.End()
19006 return v, changed
19007 }
19008 hasLen := containerLenS > 0
19009 var xlen int
19010 if hasLen && canChange {
19011 if containerLenS > cap(v) {
19012 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
19013 if xlen <= cap(v) {
19014 v = v[:xlen]
19015 } else {
19016 v = make([]int32, xlen)
19017 }
19018 changed = true
19019 } else if containerLenS != len(v) {
19020 v = v[:containerLenS]
19021 changed = true
19022 }
19023 }
19024 j := 0
19025 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
19026 if j == 0 && len(v) == 0 && canChange {
19027 if hasLen {
19028 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
19029 } else {
19030 xlen = 8
19031 }
19032 v = make([]int32, xlen)
19033 changed = true
19034 }
19035 // if indefinite, etc, then expand the slice if necessary
19036 var decodeIntoBlank bool
19037 if j >= len(v) {
19038 if canChange {
19039 v = append(v, 0)
19040 changed = true
19041 } else {
19042 d.arrayCannotExpand(len(v), j+1)
19043 decodeIntoBlank = true
19044 }
19045 }
19046 slh.ElemContainerState(j)
19047 if decodeIntoBlank {
19048 d.swallow()
19049 } else if dd.TryDecodeAsNil() {
19050 v[j] = 0
19051 } else {
19052 v[j] = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
19053 }
19054 }
19055 if canChange {
19056 if j < len(v) {
19057 v = v[:j]
19058 changed = true
19059 } else if j == 0 && v == nil {
19060 v = make([]int32, 0)
19061 changed = true
19062 }
19063 }
19064 slh.End()
19065 return v, changed
19066}
19067
19068func (d *Decoder) fastpathDecSliceInt64R(f *codecFnInfo, rv reflect.Value) {
19069 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
19070 vp := rv2i(rv).(*[]int64)
19071 v, changed := fastpathTV.DecSliceInt64V(*vp, !array, d)
19072 if changed {
19073 *vp = v
19074 }
19075 } else {
19076 v := rv2i(rv).([]int64)
19077 v2, changed := fastpathTV.DecSliceInt64V(v, !array, d)
19078 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
19079 copy(v, v2)
19080 }
19081 }
19082}
19083func (f fastpathT) DecSliceInt64X(vp *[]int64, d *Decoder) {
19084 v, changed := f.DecSliceInt64V(*vp, true, d)
19085 if changed {
19086 *vp = v
19087 }
19088}
19089func (_ fastpathT) DecSliceInt64V(v []int64, canChange bool, d *Decoder) (_ []int64, changed bool) {
19090 dd := d.d
19091 slh, containerLenS := d.decSliceHelperStart()
19092 if containerLenS == 0 {
19093 if canChange {
19094 if v == nil {
19095 v = []int64{}
19096 } else if len(v) != 0 {
19097 v = v[:0]
19098 }
19099 changed = true
19100 }
19101 slh.End()
19102 return v, changed
19103 }
19104 hasLen := containerLenS > 0
19105 var xlen int
19106 if hasLen && canChange {
19107 if containerLenS > cap(v) {
19108 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
19109 if xlen <= cap(v) {
19110 v = v[:xlen]
19111 } else {
19112 v = make([]int64, xlen)
19113 }
19114 changed = true
19115 } else if containerLenS != len(v) {
19116 v = v[:containerLenS]
19117 changed = true
19118 }
19119 }
19120 j := 0
19121 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
19122 if j == 0 && len(v) == 0 && canChange {
19123 if hasLen {
19124 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
19125 } else {
19126 xlen = 8
19127 }
19128 v = make([]int64, xlen)
19129 changed = true
19130 }
19131 // if indefinite, etc, then expand the slice if necessary
19132 var decodeIntoBlank bool
19133 if j >= len(v) {
19134 if canChange {
19135 v = append(v, 0)
19136 changed = true
19137 } else {
19138 d.arrayCannotExpand(len(v), j+1)
19139 decodeIntoBlank = true
19140 }
19141 }
19142 slh.ElemContainerState(j)
19143 if decodeIntoBlank {
19144 d.swallow()
19145 } else if dd.TryDecodeAsNil() {
19146 v[j] = 0
19147 } else {
19148 v[j] = dd.DecodeInt64()
19149 }
19150 }
19151 if canChange {
19152 if j < len(v) {
19153 v = v[:j]
19154 changed = true
19155 } else if j == 0 && v == nil {
19156 v = make([]int64, 0)
19157 changed = true
19158 }
19159 }
19160 slh.End()
19161 return v, changed
19162}
19163
19164func (d *Decoder) fastpathDecSliceBoolR(f *codecFnInfo, rv reflect.Value) {
19165 if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
19166 vp := rv2i(rv).(*[]bool)
19167 v, changed := fastpathTV.DecSliceBoolV(*vp, !array, d)
19168 if changed {
19169 *vp = v
19170 }
19171 } else {
19172 v := rv2i(rv).([]bool)
19173 v2, changed := fastpathTV.DecSliceBoolV(v, !array, d)
19174 if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
19175 copy(v, v2)
19176 }
19177 }
19178}
19179func (f fastpathT) DecSliceBoolX(vp *[]bool, d *Decoder) {
19180 v, changed := f.DecSliceBoolV(*vp, true, d)
19181 if changed {
19182 *vp = v
19183 }
19184}
19185func (_ fastpathT) DecSliceBoolV(v []bool, canChange bool, d *Decoder) (_ []bool, changed bool) {
19186 dd := d.d
19187 slh, containerLenS := d.decSliceHelperStart()
19188 if containerLenS == 0 {
19189 if canChange {
19190 if v == nil {
19191 v = []bool{}
19192 } else if len(v) != 0 {
19193 v = v[:0]
19194 }
19195 changed = true
19196 }
19197 slh.End()
19198 return v, changed
19199 }
19200 hasLen := containerLenS > 0
19201 var xlen int
19202 if hasLen && canChange {
19203 if containerLenS > cap(v) {
19204 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
19205 if xlen <= cap(v) {
19206 v = v[:xlen]
19207 } else {
19208 v = make([]bool, xlen)
19209 }
19210 changed = true
19211 } else if containerLenS != len(v) {
19212 v = v[:containerLenS]
19213 changed = true
19214 }
19215 }
19216 j := 0
19217 for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
19218 if j == 0 && len(v) == 0 && canChange {
19219 if hasLen {
19220 xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
19221 } else {
19222 xlen = 8
19223 }
19224 v = make([]bool, xlen)
19225 changed = true
19226 }
19227 // if indefinite, etc, then expand the slice if necessary
19228 var decodeIntoBlank bool
19229 if j >= len(v) {
19230 if canChange {
19231 v = append(v, false)
19232 changed = true
19233 } else {
19234 d.arrayCannotExpand(len(v), j+1)
19235 decodeIntoBlank = true
19236 }
19237 }
19238 slh.ElemContainerState(j)
19239 if decodeIntoBlank {
19240 d.swallow()
19241 } else if dd.TryDecodeAsNil() {
19242 v[j] = false
19243 } else {
19244 v[j] = dd.DecodeBool()
19245 }
19246 }
19247 if canChange {
19248 if j < len(v) {
19249 v = v[:j]
19250 changed = true
19251 } else if j == 0 && v == nil {
19252 v = make([]bool, 0)
19253 changed = true
19254 }
19255 }
19256 slh.End()
19257 return v, changed
19258}
19259
19260func (d *Decoder) fastpathDecMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
19261 if rv.Kind() == reflect.Ptr {
19262 vp := rv2i(rv).(*map[interface{}]interface{})
19263 v, changed := fastpathTV.DecMapIntfIntfV(*vp, true, d)
19264 if changed {
19265 *vp = v
19266 }
19267 } else {
19268 fastpathTV.DecMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), false, d)
19269 }
19270}
19271func (f fastpathT) DecMapIntfIntfX(vp *map[interface{}]interface{}, d *Decoder) {
19272 v, changed := f.DecMapIntfIntfV(*vp, true, d)
19273 if changed {
19274 *vp = v
19275 }
19276}
19277func (_ fastpathT) DecMapIntfIntfV(v map[interface{}]interface{}, canChange bool,
19278 d *Decoder) (_ map[interface{}]interface{}, changed bool) {
19279 dd, esep := d.d, d.hh.hasElemSeparators()
19280 containerLen := dd.ReadMapStart()
19281 if canChange && v == nil {
19282 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
19283 v = make(map[interface{}]interface{}, xlen)
19284 changed = true
19285 }
19286 if containerLen == 0 {
19287 dd.ReadMapEnd()
19288 return v, changed
19289 }
19290 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
19291 var mk interface{}
19292 var mv interface{}
19293 hasLen := containerLen > 0
19294 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19295 if esep {
19296 dd.ReadMapElemKey()
19297 }
19298 mk = nil
19299 d.decode(&mk)
19300 if bv, bok := mk.([]byte); bok {
19301 mk = d.string(bv)
19302 }
19303 if esep {
19304 dd.ReadMapElemValue()
19305 }
19306 if dd.TryDecodeAsNil() {
19307 if v == nil {
19308 } else if d.h.DeleteOnNilMapValue {
19309 delete(v, mk)
19310 } else {
19311 v[mk] = nil
19312 }
19313 continue
19314 }
19315 if mapGet {
19316 mv = v[mk]
19317 } else {
19318 mv = nil
19319 }
19320 d.decode(&mv)
19321 if v != nil {
19322 v[mk] = mv
19323 }
19324 }
19325 dd.ReadMapEnd()
19326 return v, changed
19327}
19328
19329func (d *Decoder) fastpathDecMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
19330 if rv.Kind() == reflect.Ptr {
19331 vp := rv2i(rv).(*map[interface{}]string)
19332 v, changed := fastpathTV.DecMapIntfStringV(*vp, true, d)
19333 if changed {
19334 *vp = v
19335 }
19336 } else {
19337 fastpathTV.DecMapIntfStringV(rv2i(rv).(map[interface{}]string), false, d)
19338 }
19339}
19340func (f fastpathT) DecMapIntfStringX(vp *map[interface{}]string, d *Decoder) {
19341 v, changed := f.DecMapIntfStringV(*vp, true, d)
19342 if changed {
19343 *vp = v
19344 }
19345}
19346func (_ fastpathT) DecMapIntfStringV(v map[interface{}]string, canChange bool,
19347 d *Decoder) (_ map[interface{}]string, changed bool) {
19348 dd, esep := d.d, d.hh.hasElemSeparators()
19349 containerLen := dd.ReadMapStart()
19350 if canChange && v == nil {
19351 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
19352 v = make(map[interface{}]string, xlen)
19353 changed = true
19354 }
19355 if containerLen == 0 {
19356 dd.ReadMapEnd()
19357 return v, changed
19358 }
19359 var mk interface{}
19360 var mv string
19361 hasLen := containerLen > 0
19362 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19363 if esep {
19364 dd.ReadMapElemKey()
19365 }
19366 mk = nil
19367 d.decode(&mk)
19368 if bv, bok := mk.([]byte); bok {
19369 mk = d.string(bv)
19370 }
19371 if esep {
19372 dd.ReadMapElemValue()
19373 }
19374 if dd.TryDecodeAsNil() {
19375 if v == nil {
19376 } else if d.h.DeleteOnNilMapValue {
19377 delete(v, mk)
19378 } else {
19379 v[mk] = ""
19380 }
19381 continue
19382 }
19383 mv = dd.DecodeString()
19384 if v != nil {
19385 v[mk] = mv
19386 }
19387 }
19388 dd.ReadMapEnd()
19389 return v, changed
19390}
19391
19392func (d *Decoder) fastpathDecMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
19393 if rv.Kind() == reflect.Ptr {
19394 vp := rv2i(rv).(*map[interface{}]uint)
19395 v, changed := fastpathTV.DecMapIntfUintV(*vp, true, d)
19396 if changed {
19397 *vp = v
19398 }
19399 } else {
19400 fastpathTV.DecMapIntfUintV(rv2i(rv).(map[interface{}]uint), false, d)
19401 }
19402}
19403func (f fastpathT) DecMapIntfUintX(vp *map[interface{}]uint, d *Decoder) {
19404 v, changed := f.DecMapIntfUintV(*vp, true, d)
19405 if changed {
19406 *vp = v
19407 }
19408}
19409func (_ fastpathT) DecMapIntfUintV(v map[interface{}]uint, canChange bool,
19410 d *Decoder) (_ map[interface{}]uint, changed bool) {
19411 dd, esep := d.d, d.hh.hasElemSeparators()
19412 containerLen := dd.ReadMapStart()
19413 if canChange && v == nil {
19414 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19415 v = make(map[interface{}]uint, xlen)
19416 changed = true
19417 }
19418 if containerLen == 0 {
19419 dd.ReadMapEnd()
19420 return v, changed
19421 }
19422 var mk interface{}
19423 var mv uint
19424 hasLen := containerLen > 0
19425 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19426 if esep {
19427 dd.ReadMapElemKey()
19428 }
19429 mk = nil
19430 d.decode(&mk)
19431 if bv, bok := mk.([]byte); bok {
19432 mk = d.string(bv)
19433 }
19434 if esep {
19435 dd.ReadMapElemValue()
19436 }
19437 if dd.TryDecodeAsNil() {
19438 if v == nil {
19439 } else if d.h.DeleteOnNilMapValue {
19440 delete(v, mk)
19441 } else {
19442 v[mk] = 0
19443 }
19444 continue
19445 }
19446 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
19447 if v != nil {
19448 v[mk] = mv
19449 }
19450 }
19451 dd.ReadMapEnd()
19452 return v, changed
19453}
19454
19455func (d *Decoder) fastpathDecMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
19456 if rv.Kind() == reflect.Ptr {
19457 vp := rv2i(rv).(*map[interface{}]uint8)
19458 v, changed := fastpathTV.DecMapIntfUint8V(*vp, true, d)
19459 if changed {
19460 *vp = v
19461 }
19462 } else {
19463 fastpathTV.DecMapIntfUint8V(rv2i(rv).(map[interface{}]uint8), false, d)
19464 }
19465}
19466func (f fastpathT) DecMapIntfUint8X(vp *map[interface{}]uint8, d *Decoder) {
19467 v, changed := f.DecMapIntfUint8V(*vp, true, d)
19468 if changed {
19469 *vp = v
19470 }
19471}
19472func (_ fastpathT) DecMapIntfUint8V(v map[interface{}]uint8, canChange bool,
19473 d *Decoder) (_ map[interface{}]uint8, changed bool) {
19474 dd, esep := d.d, d.hh.hasElemSeparators()
19475 containerLen := dd.ReadMapStart()
19476 if canChange && v == nil {
19477 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
19478 v = make(map[interface{}]uint8, xlen)
19479 changed = true
19480 }
19481 if containerLen == 0 {
19482 dd.ReadMapEnd()
19483 return v, changed
19484 }
19485 var mk interface{}
19486 var mv uint8
19487 hasLen := containerLen > 0
19488 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19489 if esep {
19490 dd.ReadMapElemKey()
19491 }
19492 mk = nil
19493 d.decode(&mk)
19494 if bv, bok := mk.([]byte); bok {
19495 mk = d.string(bv)
19496 }
19497 if esep {
19498 dd.ReadMapElemValue()
19499 }
19500 if dd.TryDecodeAsNil() {
19501 if v == nil {
19502 } else if d.h.DeleteOnNilMapValue {
19503 delete(v, mk)
19504 } else {
19505 v[mk] = 0
19506 }
19507 continue
19508 }
19509 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
19510 if v != nil {
19511 v[mk] = mv
19512 }
19513 }
19514 dd.ReadMapEnd()
19515 return v, changed
19516}
19517
19518func (d *Decoder) fastpathDecMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
19519 if rv.Kind() == reflect.Ptr {
19520 vp := rv2i(rv).(*map[interface{}]uint16)
19521 v, changed := fastpathTV.DecMapIntfUint16V(*vp, true, d)
19522 if changed {
19523 *vp = v
19524 }
19525 } else {
19526 fastpathTV.DecMapIntfUint16V(rv2i(rv).(map[interface{}]uint16), false, d)
19527 }
19528}
19529func (f fastpathT) DecMapIntfUint16X(vp *map[interface{}]uint16, d *Decoder) {
19530 v, changed := f.DecMapIntfUint16V(*vp, true, d)
19531 if changed {
19532 *vp = v
19533 }
19534}
19535func (_ fastpathT) DecMapIntfUint16V(v map[interface{}]uint16, canChange bool,
19536 d *Decoder) (_ map[interface{}]uint16, changed bool) {
19537 dd, esep := d.d, d.hh.hasElemSeparators()
19538 containerLen := dd.ReadMapStart()
19539 if canChange && v == nil {
19540 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
19541 v = make(map[interface{}]uint16, xlen)
19542 changed = true
19543 }
19544 if containerLen == 0 {
19545 dd.ReadMapEnd()
19546 return v, changed
19547 }
19548 var mk interface{}
19549 var mv uint16
19550 hasLen := containerLen > 0
19551 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19552 if esep {
19553 dd.ReadMapElemKey()
19554 }
19555 mk = nil
19556 d.decode(&mk)
19557 if bv, bok := mk.([]byte); bok {
19558 mk = d.string(bv)
19559 }
19560 if esep {
19561 dd.ReadMapElemValue()
19562 }
19563 if dd.TryDecodeAsNil() {
19564 if v == nil {
19565 } else if d.h.DeleteOnNilMapValue {
19566 delete(v, mk)
19567 } else {
19568 v[mk] = 0
19569 }
19570 continue
19571 }
19572 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
19573 if v != nil {
19574 v[mk] = mv
19575 }
19576 }
19577 dd.ReadMapEnd()
19578 return v, changed
19579}
19580
19581func (d *Decoder) fastpathDecMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
19582 if rv.Kind() == reflect.Ptr {
19583 vp := rv2i(rv).(*map[interface{}]uint32)
19584 v, changed := fastpathTV.DecMapIntfUint32V(*vp, true, d)
19585 if changed {
19586 *vp = v
19587 }
19588 } else {
19589 fastpathTV.DecMapIntfUint32V(rv2i(rv).(map[interface{}]uint32), false, d)
19590 }
19591}
19592func (f fastpathT) DecMapIntfUint32X(vp *map[interface{}]uint32, d *Decoder) {
19593 v, changed := f.DecMapIntfUint32V(*vp, true, d)
19594 if changed {
19595 *vp = v
19596 }
19597}
19598func (_ fastpathT) DecMapIntfUint32V(v map[interface{}]uint32, canChange bool,
19599 d *Decoder) (_ map[interface{}]uint32, changed bool) {
19600 dd, esep := d.d, d.hh.hasElemSeparators()
19601 containerLen := dd.ReadMapStart()
19602 if canChange && v == nil {
19603 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
19604 v = make(map[interface{}]uint32, xlen)
19605 changed = true
19606 }
19607 if containerLen == 0 {
19608 dd.ReadMapEnd()
19609 return v, changed
19610 }
19611 var mk interface{}
19612 var mv uint32
19613 hasLen := containerLen > 0
19614 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19615 if esep {
19616 dd.ReadMapElemKey()
19617 }
19618 mk = nil
19619 d.decode(&mk)
19620 if bv, bok := mk.([]byte); bok {
19621 mk = d.string(bv)
19622 }
19623 if esep {
19624 dd.ReadMapElemValue()
19625 }
19626 if dd.TryDecodeAsNil() {
19627 if v == nil {
19628 } else if d.h.DeleteOnNilMapValue {
19629 delete(v, mk)
19630 } else {
19631 v[mk] = 0
19632 }
19633 continue
19634 }
19635 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
19636 if v != nil {
19637 v[mk] = mv
19638 }
19639 }
19640 dd.ReadMapEnd()
19641 return v, changed
19642}
19643
19644func (d *Decoder) fastpathDecMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
19645 if rv.Kind() == reflect.Ptr {
19646 vp := rv2i(rv).(*map[interface{}]uint64)
19647 v, changed := fastpathTV.DecMapIntfUint64V(*vp, true, d)
19648 if changed {
19649 *vp = v
19650 }
19651 } else {
19652 fastpathTV.DecMapIntfUint64V(rv2i(rv).(map[interface{}]uint64), false, d)
19653 }
19654}
19655func (f fastpathT) DecMapIntfUint64X(vp *map[interface{}]uint64, d *Decoder) {
19656 v, changed := f.DecMapIntfUint64V(*vp, true, d)
19657 if changed {
19658 *vp = v
19659 }
19660}
19661func (_ fastpathT) DecMapIntfUint64V(v map[interface{}]uint64, canChange bool,
19662 d *Decoder) (_ map[interface{}]uint64, changed bool) {
19663 dd, esep := d.d, d.hh.hasElemSeparators()
19664 containerLen := dd.ReadMapStart()
19665 if canChange && v == nil {
19666 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19667 v = make(map[interface{}]uint64, xlen)
19668 changed = true
19669 }
19670 if containerLen == 0 {
19671 dd.ReadMapEnd()
19672 return v, changed
19673 }
19674 var mk interface{}
19675 var mv uint64
19676 hasLen := containerLen > 0
19677 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19678 if esep {
19679 dd.ReadMapElemKey()
19680 }
19681 mk = nil
19682 d.decode(&mk)
19683 if bv, bok := mk.([]byte); bok {
19684 mk = d.string(bv)
19685 }
19686 if esep {
19687 dd.ReadMapElemValue()
19688 }
19689 if dd.TryDecodeAsNil() {
19690 if v == nil {
19691 } else if d.h.DeleteOnNilMapValue {
19692 delete(v, mk)
19693 } else {
19694 v[mk] = 0
19695 }
19696 continue
19697 }
19698 mv = dd.DecodeUint64()
19699 if v != nil {
19700 v[mk] = mv
19701 }
19702 }
19703 dd.ReadMapEnd()
19704 return v, changed
19705}
19706
19707func (d *Decoder) fastpathDecMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
19708 if rv.Kind() == reflect.Ptr {
19709 vp := rv2i(rv).(*map[interface{}]uintptr)
19710 v, changed := fastpathTV.DecMapIntfUintptrV(*vp, true, d)
19711 if changed {
19712 *vp = v
19713 }
19714 } else {
19715 fastpathTV.DecMapIntfUintptrV(rv2i(rv).(map[interface{}]uintptr), false, d)
19716 }
19717}
19718func (f fastpathT) DecMapIntfUintptrX(vp *map[interface{}]uintptr, d *Decoder) {
19719 v, changed := f.DecMapIntfUintptrV(*vp, true, d)
19720 if changed {
19721 *vp = v
19722 }
19723}
19724func (_ fastpathT) DecMapIntfUintptrV(v map[interface{}]uintptr, canChange bool,
19725 d *Decoder) (_ map[interface{}]uintptr, changed bool) {
19726 dd, esep := d.d, d.hh.hasElemSeparators()
19727 containerLen := dd.ReadMapStart()
19728 if canChange && v == nil {
19729 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19730 v = make(map[interface{}]uintptr, xlen)
19731 changed = true
19732 }
19733 if containerLen == 0 {
19734 dd.ReadMapEnd()
19735 return v, changed
19736 }
19737 var mk interface{}
19738 var mv uintptr
19739 hasLen := containerLen > 0
19740 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19741 if esep {
19742 dd.ReadMapElemKey()
19743 }
19744 mk = nil
19745 d.decode(&mk)
19746 if bv, bok := mk.([]byte); bok {
19747 mk = d.string(bv)
19748 }
19749 if esep {
19750 dd.ReadMapElemValue()
19751 }
19752 if dd.TryDecodeAsNil() {
19753 if v == nil {
19754 } else if d.h.DeleteOnNilMapValue {
19755 delete(v, mk)
19756 } else {
19757 v[mk] = 0
19758 }
19759 continue
19760 }
19761 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
19762 if v != nil {
19763 v[mk] = mv
19764 }
19765 }
19766 dd.ReadMapEnd()
19767 return v, changed
19768}
19769
19770func (d *Decoder) fastpathDecMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
19771 if rv.Kind() == reflect.Ptr {
19772 vp := rv2i(rv).(*map[interface{}]int)
19773 v, changed := fastpathTV.DecMapIntfIntV(*vp, true, d)
19774 if changed {
19775 *vp = v
19776 }
19777 } else {
19778 fastpathTV.DecMapIntfIntV(rv2i(rv).(map[interface{}]int), false, d)
19779 }
19780}
19781func (f fastpathT) DecMapIntfIntX(vp *map[interface{}]int, d *Decoder) {
19782 v, changed := f.DecMapIntfIntV(*vp, true, d)
19783 if changed {
19784 *vp = v
19785 }
19786}
19787func (_ fastpathT) DecMapIntfIntV(v map[interface{}]int, canChange bool,
19788 d *Decoder) (_ map[interface{}]int, changed bool) {
19789 dd, esep := d.d, d.hh.hasElemSeparators()
19790 containerLen := dd.ReadMapStart()
19791 if canChange && v == nil {
19792 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
19793 v = make(map[interface{}]int, xlen)
19794 changed = true
19795 }
19796 if containerLen == 0 {
19797 dd.ReadMapEnd()
19798 return v, changed
19799 }
19800 var mk interface{}
19801 var mv int
19802 hasLen := containerLen > 0
19803 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19804 if esep {
19805 dd.ReadMapElemKey()
19806 }
19807 mk = nil
19808 d.decode(&mk)
19809 if bv, bok := mk.([]byte); bok {
19810 mk = d.string(bv)
19811 }
19812 if esep {
19813 dd.ReadMapElemValue()
19814 }
19815 if dd.TryDecodeAsNil() {
19816 if v == nil {
19817 } else if d.h.DeleteOnNilMapValue {
19818 delete(v, mk)
19819 } else {
19820 v[mk] = 0
19821 }
19822 continue
19823 }
19824 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
19825 if v != nil {
19826 v[mk] = mv
19827 }
19828 }
19829 dd.ReadMapEnd()
19830 return v, changed
19831}
19832
19833func (d *Decoder) fastpathDecMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
19834 if rv.Kind() == reflect.Ptr {
19835 vp := rv2i(rv).(*map[interface{}]int8)
19836 v, changed := fastpathTV.DecMapIntfInt8V(*vp, true, d)
19837 if changed {
19838 *vp = v
19839 }
19840 } else {
19841 fastpathTV.DecMapIntfInt8V(rv2i(rv).(map[interface{}]int8), false, d)
19842 }
19843}
19844func (f fastpathT) DecMapIntfInt8X(vp *map[interface{}]int8, d *Decoder) {
19845 v, changed := f.DecMapIntfInt8V(*vp, true, d)
19846 if changed {
19847 *vp = v
19848 }
19849}
19850func (_ fastpathT) DecMapIntfInt8V(v map[interface{}]int8, canChange bool,
19851 d *Decoder) (_ map[interface{}]int8, changed bool) {
19852 dd, esep := d.d, d.hh.hasElemSeparators()
19853 containerLen := dd.ReadMapStart()
19854 if canChange && v == nil {
19855 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
19856 v = make(map[interface{}]int8, xlen)
19857 changed = true
19858 }
19859 if containerLen == 0 {
19860 dd.ReadMapEnd()
19861 return v, changed
19862 }
19863 var mk interface{}
19864 var mv int8
19865 hasLen := containerLen > 0
19866 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19867 if esep {
19868 dd.ReadMapElemKey()
19869 }
19870 mk = nil
19871 d.decode(&mk)
19872 if bv, bok := mk.([]byte); bok {
19873 mk = d.string(bv)
19874 }
19875 if esep {
19876 dd.ReadMapElemValue()
19877 }
19878 if dd.TryDecodeAsNil() {
19879 if v == nil {
19880 } else if d.h.DeleteOnNilMapValue {
19881 delete(v, mk)
19882 } else {
19883 v[mk] = 0
19884 }
19885 continue
19886 }
19887 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
19888 if v != nil {
19889 v[mk] = mv
19890 }
19891 }
19892 dd.ReadMapEnd()
19893 return v, changed
19894}
19895
19896func (d *Decoder) fastpathDecMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
19897 if rv.Kind() == reflect.Ptr {
19898 vp := rv2i(rv).(*map[interface{}]int16)
19899 v, changed := fastpathTV.DecMapIntfInt16V(*vp, true, d)
19900 if changed {
19901 *vp = v
19902 }
19903 } else {
19904 fastpathTV.DecMapIntfInt16V(rv2i(rv).(map[interface{}]int16), false, d)
19905 }
19906}
19907func (f fastpathT) DecMapIntfInt16X(vp *map[interface{}]int16, d *Decoder) {
19908 v, changed := f.DecMapIntfInt16V(*vp, true, d)
19909 if changed {
19910 *vp = v
19911 }
19912}
19913func (_ fastpathT) DecMapIntfInt16V(v map[interface{}]int16, canChange bool,
19914 d *Decoder) (_ map[interface{}]int16, changed bool) {
19915 dd, esep := d.d, d.hh.hasElemSeparators()
19916 containerLen := dd.ReadMapStart()
19917 if canChange && v == nil {
19918 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
19919 v = make(map[interface{}]int16, xlen)
19920 changed = true
19921 }
19922 if containerLen == 0 {
19923 dd.ReadMapEnd()
19924 return v, changed
19925 }
19926 var mk interface{}
19927 var mv int16
19928 hasLen := containerLen > 0
19929 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19930 if esep {
19931 dd.ReadMapElemKey()
19932 }
19933 mk = nil
19934 d.decode(&mk)
19935 if bv, bok := mk.([]byte); bok {
19936 mk = d.string(bv)
19937 }
19938 if esep {
19939 dd.ReadMapElemValue()
19940 }
19941 if dd.TryDecodeAsNil() {
19942 if v == nil {
19943 } else if d.h.DeleteOnNilMapValue {
19944 delete(v, mk)
19945 } else {
19946 v[mk] = 0
19947 }
19948 continue
19949 }
19950 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
19951 if v != nil {
19952 v[mk] = mv
19953 }
19954 }
19955 dd.ReadMapEnd()
19956 return v, changed
19957}
19958
19959func (d *Decoder) fastpathDecMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
19960 if rv.Kind() == reflect.Ptr {
19961 vp := rv2i(rv).(*map[interface{}]int32)
19962 v, changed := fastpathTV.DecMapIntfInt32V(*vp, true, d)
19963 if changed {
19964 *vp = v
19965 }
19966 } else {
19967 fastpathTV.DecMapIntfInt32V(rv2i(rv).(map[interface{}]int32), false, d)
19968 }
19969}
19970func (f fastpathT) DecMapIntfInt32X(vp *map[interface{}]int32, d *Decoder) {
19971 v, changed := f.DecMapIntfInt32V(*vp, true, d)
19972 if changed {
19973 *vp = v
19974 }
19975}
19976func (_ fastpathT) DecMapIntfInt32V(v map[interface{}]int32, canChange bool,
19977 d *Decoder) (_ map[interface{}]int32, changed bool) {
19978 dd, esep := d.d, d.hh.hasElemSeparators()
19979 containerLen := dd.ReadMapStart()
19980 if canChange && v == nil {
19981 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
19982 v = make(map[interface{}]int32, xlen)
19983 changed = true
19984 }
19985 if containerLen == 0 {
19986 dd.ReadMapEnd()
19987 return v, changed
19988 }
19989 var mk interface{}
19990 var mv int32
19991 hasLen := containerLen > 0
19992 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
19993 if esep {
19994 dd.ReadMapElemKey()
19995 }
19996 mk = nil
19997 d.decode(&mk)
19998 if bv, bok := mk.([]byte); bok {
19999 mk = d.string(bv)
20000 }
20001 if esep {
20002 dd.ReadMapElemValue()
20003 }
20004 if dd.TryDecodeAsNil() {
20005 if v == nil {
20006 } else if d.h.DeleteOnNilMapValue {
20007 delete(v, mk)
20008 } else {
20009 v[mk] = 0
20010 }
20011 continue
20012 }
20013 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
20014 if v != nil {
20015 v[mk] = mv
20016 }
20017 }
20018 dd.ReadMapEnd()
20019 return v, changed
20020}
20021
20022func (d *Decoder) fastpathDecMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
20023 if rv.Kind() == reflect.Ptr {
20024 vp := rv2i(rv).(*map[interface{}]int64)
20025 v, changed := fastpathTV.DecMapIntfInt64V(*vp, true, d)
20026 if changed {
20027 *vp = v
20028 }
20029 } else {
20030 fastpathTV.DecMapIntfInt64V(rv2i(rv).(map[interface{}]int64), false, d)
20031 }
20032}
20033func (f fastpathT) DecMapIntfInt64X(vp *map[interface{}]int64, d *Decoder) {
20034 v, changed := f.DecMapIntfInt64V(*vp, true, d)
20035 if changed {
20036 *vp = v
20037 }
20038}
20039func (_ fastpathT) DecMapIntfInt64V(v map[interface{}]int64, canChange bool,
20040 d *Decoder) (_ map[interface{}]int64, changed bool) {
20041 dd, esep := d.d, d.hh.hasElemSeparators()
20042 containerLen := dd.ReadMapStart()
20043 if canChange && v == nil {
20044 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20045 v = make(map[interface{}]int64, xlen)
20046 changed = true
20047 }
20048 if containerLen == 0 {
20049 dd.ReadMapEnd()
20050 return v, changed
20051 }
20052 var mk interface{}
20053 var mv int64
20054 hasLen := containerLen > 0
20055 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20056 if esep {
20057 dd.ReadMapElemKey()
20058 }
20059 mk = nil
20060 d.decode(&mk)
20061 if bv, bok := mk.([]byte); bok {
20062 mk = d.string(bv)
20063 }
20064 if esep {
20065 dd.ReadMapElemValue()
20066 }
20067 if dd.TryDecodeAsNil() {
20068 if v == nil {
20069 } else if d.h.DeleteOnNilMapValue {
20070 delete(v, mk)
20071 } else {
20072 v[mk] = 0
20073 }
20074 continue
20075 }
20076 mv = dd.DecodeInt64()
20077 if v != nil {
20078 v[mk] = mv
20079 }
20080 }
20081 dd.ReadMapEnd()
20082 return v, changed
20083}
20084
20085func (d *Decoder) fastpathDecMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
20086 if rv.Kind() == reflect.Ptr {
20087 vp := rv2i(rv).(*map[interface{}]float32)
20088 v, changed := fastpathTV.DecMapIntfFloat32V(*vp, true, d)
20089 if changed {
20090 *vp = v
20091 }
20092 } else {
20093 fastpathTV.DecMapIntfFloat32V(rv2i(rv).(map[interface{}]float32), false, d)
20094 }
20095}
20096func (f fastpathT) DecMapIntfFloat32X(vp *map[interface{}]float32, d *Decoder) {
20097 v, changed := f.DecMapIntfFloat32V(*vp, true, d)
20098 if changed {
20099 *vp = v
20100 }
20101}
20102func (_ fastpathT) DecMapIntfFloat32V(v map[interface{}]float32, canChange bool,
20103 d *Decoder) (_ map[interface{}]float32, changed bool) {
20104 dd, esep := d.d, d.hh.hasElemSeparators()
20105 containerLen := dd.ReadMapStart()
20106 if canChange && v == nil {
20107 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
20108 v = make(map[interface{}]float32, xlen)
20109 changed = true
20110 }
20111 if containerLen == 0 {
20112 dd.ReadMapEnd()
20113 return v, changed
20114 }
20115 var mk interface{}
20116 var mv float32
20117 hasLen := containerLen > 0
20118 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20119 if esep {
20120 dd.ReadMapElemKey()
20121 }
20122 mk = nil
20123 d.decode(&mk)
20124 if bv, bok := mk.([]byte); bok {
20125 mk = d.string(bv)
20126 }
20127 if esep {
20128 dd.ReadMapElemValue()
20129 }
20130 if dd.TryDecodeAsNil() {
20131 if v == nil {
20132 } else if d.h.DeleteOnNilMapValue {
20133 delete(v, mk)
20134 } else {
20135 v[mk] = 0
20136 }
20137 continue
20138 }
20139 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
20140 if v != nil {
20141 v[mk] = mv
20142 }
20143 }
20144 dd.ReadMapEnd()
20145 return v, changed
20146}
20147
20148func (d *Decoder) fastpathDecMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
20149 if rv.Kind() == reflect.Ptr {
20150 vp := rv2i(rv).(*map[interface{}]float64)
20151 v, changed := fastpathTV.DecMapIntfFloat64V(*vp, true, d)
20152 if changed {
20153 *vp = v
20154 }
20155 } else {
20156 fastpathTV.DecMapIntfFloat64V(rv2i(rv).(map[interface{}]float64), false, d)
20157 }
20158}
20159func (f fastpathT) DecMapIntfFloat64X(vp *map[interface{}]float64, d *Decoder) {
20160 v, changed := f.DecMapIntfFloat64V(*vp, true, d)
20161 if changed {
20162 *vp = v
20163 }
20164}
20165func (_ fastpathT) DecMapIntfFloat64V(v map[interface{}]float64, canChange bool,
20166 d *Decoder) (_ map[interface{}]float64, changed bool) {
20167 dd, esep := d.d, d.hh.hasElemSeparators()
20168 containerLen := dd.ReadMapStart()
20169 if canChange && v == nil {
20170 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20171 v = make(map[interface{}]float64, xlen)
20172 changed = true
20173 }
20174 if containerLen == 0 {
20175 dd.ReadMapEnd()
20176 return v, changed
20177 }
20178 var mk interface{}
20179 var mv float64
20180 hasLen := containerLen > 0
20181 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20182 if esep {
20183 dd.ReadMapElemKey()
20184 }
20185 mk = nil
20186 d.decode(&mk)
20187 if bv, bok := mk.([]byte); bok {
20188 mk = d.string(bv)
20189 }
20190 if esep {
20191 dd.ReadMapElemValue()
20192 }
20193 if dd.TryDecodeAsNil() {
20194 if v == nil {
20195 } else if d.h.DeleteOnNilMapValue {
20196 delete(v, mk)
20197 } else {
20198 v[mk] = 0
20199 }
20200 continue
20201 }
20202 mv = dd.DecodeFloat64()
20203 if v != nil {
20204 v[mk] = mv
20205 }
20206 }
20207 dd.ReadMapEnd()
20208 return v, changed
20209}
20210
20211func (d *Decoder) fastpathDecMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
20212 if rv.Kind() == reflect.Ptr {
20213 vp := rv2i(rv).(*map[interface{}]bool)
20214 v, changed := fastpathTV.DecMapIntfBoolV(*vp, true, d)
20215 if changed {
20216 *vp = v
20217 }
20218 } else {
20219 fastpathTV.DecMapIntfBoolV(rv2i(rv).(map[interface{}]bool), false, d)
20220 }
20221}
20222func (f fastpathT) DecMapIntfBoolX(vp *map[interface{}]bool, d *Decoder) {
20223 v, changed := f.DecMapIntfBoolV(*vp, true, d)
20224 if changed {
20225 *vp = v
20226 }
20227}
20228func (_ fastpathT) DecMapIntfBoolV(v map[interface{}]bool, canChange bool,
20229 d *Decoder) (_ map[interface{}]bool, changed bool) {
20230 dd, esep := d.d, d.hh.hasElemSeparators()
20231 containerLen := dd.ReadMapStart()
20232 if canChange && v == nil {
20233 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
20234 v = make(map[interface{}]bool, xlen)
20235 changed = true
20236 }
20237 if containerLen == 0 {
20238 dd.ReadMapEnd()
20239 return v, changed
20240 }
20241 var mk interface{}
20242 var mv bool
20243 hasLen := containerLen > 0
20244 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20245 if esep {
20246 dd.ReadMapElemKey()
20247 }
20248 mk = nil
20249 d.decode(&mk)
20250 if bv, bok := mk.([]byte); bok {
20251 mk = d.string(bv)
20252 }
20253 if esep {
20254 dd.ReadMapElemValue()
20255 }
20256 if dd.TryDecodeAsNil() {
20257 if v == nil {
20258 } else if d.h.DeleteOnNilMapValue {
20259 delete(v, mk)
20260 } else {
20261 v[mk] = false
20262 }
20263 continue
20264 }
20265 mv = dd.DecodeBool()
20266 if v != nil {
20267 v[mk] = mv
20268 }
20269 }
20270 dd.ReadMapEnd()
20271 return v, changed
20272}
20273
20274func (d *Decoder) fastpathDecMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
20275 if rv.Kind() == reflect.Ptr {
20276 vp := rv2i(rv).(*map[string]interface{})
20277 v, changed := fastpathTV.DecMapStringIntfV(*vp, true, d)
20278 if changed {
20279 *vp = v
20280 }
20281 } else {
20282 fastpathTV.DecMapStringIntfV(rv2i(rv).(map[string]interface{}), false, d)
20283 }
20284}
20285func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, d *Decoder) {
20286 v, changed := f.DecMapStringIntfV(*vp, true, d)
20287 if changed {
20288 *vp = v
20289 }
20290}
20291func (_ fastpathT) DecMapStringIntfV(v map[string]interface{}, canChange bool,
20292 d *Decoder) (_ map[string]interface{}, changed bool) {
20293 dd, esep := d.d, d.hh.hasElemSeparators()
20294 containerLen := dd.ReadMapStart()
20295 if canChange && v == nil {
20296 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
20297 v = make(map[string]interface{}, xlen)
20298 changed = true
20299 }
20300 if containerLen == 0 {
20301 dd.ReadMapEnd()
20302 return v, changed
20303 }
20304 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
20305 var mk string
20306 var mv interface{}
20307 hasLen := containerLen > 0
20308 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20309 if esep {
20310 dd.ReadMapElemKey()
20311 }
20312 mk = dd.DecodeString()
20313 if esep {
20314 dd.ReadMapElemValue()
20315 }
20316 if dd.TryDecodeAsNil() {
20317 if v == nil {
20318 } else if d.h.DeleteOnNilMapValue {
20319 delete(v, mk)
20320 } else {
20321 v[mk] = nil
20322 }
20323 continue
20324 }
20325 if mapGet {
20326 mv = v[mk]
20327 } else {
20328 mv = nil
20329 }
20330 d.decode(&mv)
20331 if v != nil {
20332 v[mk] = mv
20333 }
20334 }
20335 dd.ReadMapEnd()
20336 return v, changed
20337}
20338
20339func (d *Decoder) fastpathDecMapStringStringR(f *codecFnInfo, rv reflect.Value) {
20340 if rv.Kind() == reflect.Ptr {
20341 vp := rv2i(rv).(*map[string]string)
20342 v, changed := fastpathTV.DecMapStringStringV(*vp, true, d)
20343 if changed {
20344 *vp = v
20345 }
20346 } else {
20347 fastpathTV.DecMapStringStringV(rv2i(rv).(map[string]string), false, d)
20348 }
20349}
20350func (f fastpathT) DecMapStringStringX(vp *map[string]string, d *Decoder) {
20351 v, changed := f.DecMapStringStringV(*vp, true, d)
20352 if changed {
20353 *vp = v
20354 }
20355}
20356func (_ fastpathT) DecMapStringStringV(v map[string]string, canChange bool,
20357 d *Decoder) (_ map[string]string, changed bool) {
20358 dd, esep := d.d, d.hh.hasElemSeparators()
20359 containerLen := dd.ReadMapStart()
20360 if canChange && v == nil {
20361 xlen := decInferLen(containerLen, d.h.MaxInitLen, 32)
20362 v = make(map[string]string, xlen)
20363 changed = true
20364 }
20365 if containerLen == 0 {
20366 dd.ReadMapEnd()
20367 return v, changed
20368 }
20369 var mk string
20370 var mv string
20371 hasLen := containerLen > 0
20372 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20373 if esep {
20374 dd.ReadMapElemKey()
20375 }
20376 mk = dd.DecodeString()
20377 if esep {
20378 dd.ReadMapElemValue()
20379 }
20380 if dd.TryDecodeAsNil() {
20381 if v == nil {
20382 } else if d.h.DeleteOnNilMapValue {
20383 delete(v, mk)
20384 } else {
20385 v[mk] = ""
20386 }
20387 continue
20388 }
20389 mv = dd.DecodeString()
20390 if v != nil {
20391 v[mk] = mv
20392 }
20393 }
20394 dd.ReadMapEnd()
20395 return v, changed
20396}
20397
20398func (d *Decoder) fastpathDecMapStringUintR(f *codecFnInfo, rv reflect.Value) {
20399 if rv.Kind() == reflect.Ptr {
20400 vp := rv2i(rv).(*map[string]uint)
20401 v, changed := fastpathTV.DecMapStringUintV(*vp, true, d)
20402 if changed {
20403 *vp = v
20404 }
20405 } else {
20406 fastpathTV.DecMapStringUintV(rv2i(rv).(map[string]uint), false, d)
20407 }
20408}
20409func (f fastpathT) DecMapStringUintX(vp *map[string]uint, d *Decoder) {
20410 v, changed := f.DecMapStringUintV(*vp, true, d)
20411 if changed {
20412 *vp = v
20413 }
20414}
20415func (_ fastpathT) DecMapStringUintV(v map[string]uint, canChange bool,
20416 d *Decoder) (_ map[string]uint, changed bool) {
20417 dd, esep := d.d, d.hh.hasElemSeparators()
20418 containerLen := dd.ReadMapStart()
20419 if canChange && v == nil {
20420 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20421 v = make(map[string]uint, xlen)
20422 changed = true
20423 }
20424 if containerLen == 0 {
20425 dd.ReadMapEnd()
20426 return v, changed
20427 }
20428 var mk string
20429 var mv uint
20430 hasLen := containerLen > 0
20431 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20432 if esep {
20433 dd.ReadMapElemKey()
20434 }
20435 mk = dd.DecodeString()
20436 if esep {
20437 dd.ReadMapElemValue()
20438 }
20439 if dd.TryDecodeAsNil() {
20440 if v == nil {
20441 } else if d.h.DeleteOnNilMapValue {
20442 delete(v, mk)
20443 } else {
20444 v[mk] = 0
20445 }
20446 continue
20447 }
20448 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
20449 if v != nil {
20450 v[mk] = mv
20451 }
20452 }
20453 dd.ReadMapEnd()
20454 return v, changed
20455}
20456
20457func (d *Decoder) fastpathDecMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
20458 if rv.Kind() == reflect.Ptr {
20459 vp := rv2i(rv).(*map[string]uint8)
20460 v, changed := fastpathTV.DecMapStringUint8V(*vp, true, d)
20461 if changed {
20462 *vp = v
20463 }
20464 } else {
20465 fastpathTV.DecMapStringUint8V(rv2i(rv).(map[string]uint8), false, d)
20466 }
20467}
20468func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, d *Decoder) {
20469 v, changed := f.DecMapStringUint8V(*vp, true, d)
20470 if changed {
20471 *vp = v
20472 }
20473}
20474func (_ fastpathT) DecMapStringUint8V(v map[string]uint8, canChange bool,
20475 d *Decoder) (_ map[string]uint8, changed bool) {
20476 dd, esep := d.d, d.hh.hasElemSeparators()
20477 containerLen := dd.ReadMapStart()
20478 if canChange && v == nil {
20479 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
20480 v = make(map[string]uint8, xlen)
20481 changed = true
20482 }
20483 if containerLen == 0 {
20484 dd.ReadMapEnd()
20485 return v, changed
20486 }
20487 var mk string
20488 var mv uint8
20489 hasLen := containerLen > 0
20490 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20491 if esep {
20492 dd.ReadMapElemKey()
20493 }
20494 mk = dd.DecodeString()
20495 if esep {
20496 dd.ReadMapElemValue()
20497 }
20498 if dd.TryDecodeAsNil() {
20499 if v == nil {
20500 } else if d.h.DeleteOnNilMapValue {
20501 delete(v, mk)
20502 } else {
20503 v[mk] = 0
20504 }
20505 continue
20506 }
20507 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
20508 if v != nil {
20509 v[mk] = mv
20510 }
20511 }
20512 dd.ReadMapEnd()
20513 return v, changed
20514}
20515
20516func (d *Decoder) fastpathDecMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
20517 if rv.Kind() == reflect.Ptr {
20518 vp := rv2i(rv).(*map[string]uint16)
20519 v, changed := fastpathTV.DecMapStringUint16V(*vp, true, d)
20520 if changed {
20521 *vp = v
20522 }
20523 } else {
20524 fastpathTV.DecMapStringUint16V(rv2i(rv).(map[string]uint16), false, d)
20525 }
20526}
20527func (f fastpathT) DecMapStringUint16X(vp *map[string]uint16, d *Decoder) {
20528 v, changed := f.DecMapStringUint16V(*vp, true, d)
20529 if changed {
20530 *vp = v
20531 }
20532}
20533func (_ fastpathT) DecMapStringUint16V(v map[string]uint16, canChange bool,
20534 d *Decoder) (_ map[string]uint16, changed bool) {
20535 dd, esep := d.d, d.hh.hasElemSeparators()
20536 containerLen := dd.ReadMapStart()
20537 if canChange && v == nil {
20538 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
20539 v = make(map[string]uint16, xlen)
20540 changed = true
20541 }
20542 if containerLen == 0 {
20543 dd.ReadMapEnd()
20544 return v, changed
20545 }
20546 var mk string
20547 var mv uint16
20548 hasLen := containerLen > 0
20549 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20550 if esep {
20551 dd.ReadMapElemKey()
20552 }
20553 mk = dd.DecodeString()
20554 if esep {
20555 dd.ReadMapElemValue()
20556 }
20557 if dd.TryDecodeAsNil() {
20558 if v == nil {
20559 } else if d.h.DeleteOnNilMapValue {
20560 delete(v, mk)
20561 } else {
20562 v[mk] = 0
20563 }
20564 continue
20565 }
20566 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
20567 if v != nil {
20568 v[mk] = mv
20569 }
20570 }
20571 dd.ReadMapEnd()
20572 return v, changed
20573}
20574
20575func (d *Decoder) fastpathDecMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
20576 if rv.Kind() == reflect.Ptr {
20577 vp := rv2i(rv).(*map[string]uint32)
20578 v, changed := fastpathTV.DecMapStringUint32V(*vp, true, d)
20579 if changed {
20580 *vp = v
20581 }
20582 } else {
20583 fastpathTV.DecMapStringUint32V(rv2i(rv).(map[string]uint32), false, d)
20584 }
20585}
20586func (f fastpathT) DecMapStringUint32X(vp *map[string]uint32, d *Decoder) {
20587 v, changed := f.DecMapStringUint32V(*vp, true, d)
20588 if changed {
20589 *vp = v
20590 }
20591}
20592func (_ fastpathT) DecMapStringUint32V(v map[string]uint32, canChange bool,
20593 d *Decoder) (_ map[string]uint32, changed bool) {
20594 dd, esep := d.d, d.hh.hasElemSeparators()
20595 containerLen := dd.ReadMapStart()
20596 if canChange && v == nil {
20597 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
20598 v = make(map[string]uint32, xlen)
20599 changed = true
20600 }
20601 if containerLen == 0 {
20602 dd.ReadMapEnd()
20603 return v, changed
20604 }
20605 var mk string
20606 var mv uint32
20607 hasLen := containerLen > 0
20608 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20609 if esep {
20610 dd.ReadMapElemKey()
20611 }
20612 mk = dd.DecodeString()
20613 if esep {
20614 dd.ReadMapElemValue()
20615 }
20616 if dd.TryDecodeAsNil() {
20617 if v == nil {
20618 } else if d.h.DeleteOnNilMapValue {
20619 delete(v, mk)
20620 } else {
20621 v[mk] = 0
20622 }
20623 continue
20624 }
20625 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
20626 if v != nil {
20627 v[mk] = mv
20628 }
20629 }
20630 dd.ReadMapEnd()
20631 return v, changed
20632}
20633
20634func (d *Decoder) fastpathDecMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
20635 if rv.Kind() == reflect.Ptr {
20636 vp := rv2i(rv).(*map[string]uint64)
20637 v, changed := fastpathTV.DecMapStringUint64V(*vp, true, d)
20638 if changed {
20639 *vp = v
20640 }
20641 } else {
20642 fastpathTV.DecMapStringUint64V(rv2i(rv).(map[string]uint64), false, d)
20643 }
20644}
20645func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, d *Decoder) {
20646 v, changed := f.DecMapStringUint64V(*vp, true, d)
20647 if changed {
20648 *vp = v
20649 }
20650}
20651func (_ fastpathT) DecMapStringUint64V(v map[string]uint64, canChange bool,
20652 d *Decoder) (_ map[string]uint64, changed bool) {
20653 dd, esep := d.d, d.hh.hasElemSeparators()
20654 containerLen := dd.ReadMapStart()
20655 if canChange && v == nil {
20656 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20657 v = make(map[string]uint64, xlen)
20658 changed = true
20659 }
20660 if containerLen == 0 {
20661 dd.ReadMapEnd()
20662 return v, changed
20663 }
20664 var mk string
20665 var mv uint64
20666 hasLen := containerLen > 0
20667 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20668 if esep {
20669 dd.ReadMapElemKey()
20670 }
20671 mk = dd.DecodeString()
20672 if esep {
20673 dd.ReadMapElemValue()
20674 }
20675 if dd.TryDecodeAsNil() {
20676 if v == nil {
20677 } else if d.h.DeleteOnNilMapValue {
20678 delete(v, mk)
20679 } else {
20680 v[mk] = 0
20681 }
20682 continue
20683 }
20684 mv = dd.DecodeUint64()
20685 if v != nil {
20686 v[mk] = mv
20687 }
20688 }
20689 dd.ReadMapEnd()
20690 return v, changed
20691}
20692
20693func (d *Decoder) fastpathDecMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
20694 if rv.Kind() == reflect.Ptr {
20695 vp := rv2i(rv).(*map[string]uintptr)
20696 v, changed := fastpathTV.DecMapStringUintptrV(*vp, true, d)
20697 if changed {
20698 *vp = v
20699 }
20700 } else {
20701 fastpathTV.DecMapStringUintptrV(rv2i(rv).(map[string]uintptr), false, d)
20702 }
20703}
20704func (f fastpathT) DecMapStringUintptrX(vp *map[string]uintptr, d *Decoder) {
20705 v, changed := f.DecMapStringUintptrV(*vp, true, d)
20706 if changed {
20707 *vp = v
20708 }
20709}
20710func (_ fastpathT) DecMapStringUintptrV(v map[string]uintptr, canChange bool,
20711 d *Decoder) (_ map[string]uintptr, changed bool) {
20712 dd, esep := d.d, d.hh.hasElemSeparators()
20713 containerLen := dd.ReadMapStart()
20714 if canChange && v == nil {
20715 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20716 v = make(map[string]uintptr, xlen)
20717 changed = true
20718 }
20719 if containerLen == 0 {
20720 dd.ReadMapEnd()
20721 return v, changed
20722 }
20723 var mk string
20724 var mv uintptr
20725 hasLen := containerLen > 0
20726 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20727 if esep {
20728 dd.ReadMapElemKey()
20729 }
20730 mk = dd.DecodeString()
20731 if esep {
20732 dd.ReadMapElemValue()
20733 }
20734 if dd.TryDecodeAsNil() {
20735 if v == nil {
20736 } else if d.h.DeleteOnNilMapValue {
20737 delete(v, mk)
20738 } else {
20739 v[mk] = 0
20740 }
20741 continue
20742 }
20743 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
20744 if v != nil {
20745 v[mk] = mv
20746 }
20747 }
20748 dd.ReadMapEnd()
20749 return v, changed
20750}
20751
20752func (d *Decoder) fastpathDecMapStringIntR(f *codecFnInfo, rv reflect.Value) {
20753 if rv.Kind() == reflect.Ptr {
20754 vp := rv2i(rv).(*map[string]int)
20755 v, changed := fastpathTV.DecMapStringIntV(*vp, true, d)
20756 if changed {
20757 *vp = v
20758 }
20759 } else {
20760 fastpathTV.DecMapStringIntV(rv2i(rv).(map[string]int), false, d)
20761 }
20762}
20763func (f fastpathT) DecMapStringIntX(vp *map[string]int, d *Decoder) {
20764 v, changed := f.DecMapStringIntV(*vp, true, d)
20765 if changed {
20766 *vp = v
20767 }
20768}
20769func (_ fastpathT) DecMapStringIntV(v map[string]int, canChange bool,
20770 d *Decoder) (_ map[string]int, changed bool) {
20771 dd, esep := d.d, d.hh.hasElemSeparators()
20772 containerLen := dd.ReadMapStart()
20773 if canChange && v == nil {
20774 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
20775 v = make(map[string]int, xlen)
20776 changed = true
20777 }
20778 if containerLen == 0 {
20779 dd.ReadMapEnd()
20780 return v, changed
20781 }
20782 var mk string
20783 var mv int
20784 hasLen := containerLen > 0
20785 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20786 if esep {
20787 dd.ReadMapElemKey()
20788 }
20789 mk = dd.DecodeString()
20790 if esep {
20791 dd.ReadMapElemValue()
20792 }
20793 if dd.TryDecodeAsNil() {
20794 if v == nil {
20795 } else if d.h.DeleteOnNilMapValue {
20796 delete(v, mk)
20797 } else {
20798 v[mk] = 0
20799 }
20800 continue
20801 }
20802 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
20803 if v != nil {
20804 v[mk] = mv
20805 }
20806 }
20807 dd.ReadMapEnd()
20808 return v, changed
20809}
20810
20811func (d *Decoder) fastpathDecMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
20812 if rv.Kind() == reflect.Ptr {
20813 vp := rv2i(rv).(*map[string]int8)
20814 v, changed := fastpathTV.DecMapStringInt8V(*vp, true, d)
20815 if changed {
20816 *vp = v
20817 }
20818 } else {
20819 fastpathTV.DecMapStringInt8V(rv2i(rv).(map[string]int8), false, d)
20820 }
20821}
20822func (f fastpathT) DecMapStringInt8X(vp *map[string]int8, d *Decoder) {
20823 v, changed := f.DecMapStringInt8V(*vp, true, d)
20824 if changed {
20825 *vp = v
20826 }
20827}
20828func (_ fastpathT) DecMapStringInt8V(v map[string]int8, canChange bool,
20829 d *Decoder) (_ map[string]int8, changed bool) {
20830 dd, esep := d.d, d.hh.hasElemSeparators()
20831 containerLen := dd.ReadMapStart()
20832 if canChange && v == nil {
20833 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
20834 v = make(map[string]int8, xlen)
20835 changed = true
20836 }
20837 if containerLen == 0 {
20838 dd.ReadMapEnd()
20839 return v, changed
20840 }
20841 var mk string
20842 var mv int8
20843 hasLen := containerLen > 0
20844 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20845 if esep {
20846 dd.ReadMapElemKey()
20847 }
20848 mk = dd.DecodeString()
20849 if esep {
20850 dd.ReadMapElemValue()
20851 }
20852 if dd.TryDecodeAsNil() {
20853 if v == nil {
20854 } else if d.h.DeleteOnNilMapValue {
20855 delete(v, mk)
20856 } else {
20857 v[mk] = 0
20858 }
20859 continue
20860 }
20861 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
20862 if v != nil {
20863 v[mk] = mv
20864 }
20865 }
20866 dd.ReadMapEnd()
20867 return v, changed
20868}
20869
20870func (d *Decoder) fastpathDecMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
20871 if rv.Kind() == reflect.Ptr {
20872 vp := rv2i(rv).(*map[string]int16)
20873 v, changed := fastpathTV.DecMapStringInt16V(*vp, true, d)
20874 if changed {
20875 *vp = v
20876 }
20877 } else {
20878 fastpathTV.DecMapStringInt16V(rv2i(rv).(map[string]int16), false, d)
20879 }
20880}
20881func (f fastpathT) DecMapStringInt16X(vp *map[string]int16, d *Decoder) {
20882 v, changed := f.DecMapStringInt16V(*vp, true, d)
20883 if changed {
20884 *vp = v
20885 }
20886}
20887func (_ fastpathT) DecMapStringInt16V(v map[string]int16, canChange bool,
20888 d *Decoder) (_ map[string]int16, changed bool) {
20889 dd, esep := d.d, d.hh.hasElemSeparators()
20890 containerLen := dd.ReadMapStart()
20891 if canChange && v == nil {
20892 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
20893 v = make(map[string]int16, xlen)
20894 changed = true
20895 }
20896 if containerLen == 0 {
20897 dd.ReadMapEnd()
20898 return v, changed
20899 }
20900 var mk string
20901 var mv int16
20902 hasLen := containerLen > 0
20903 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20904 if esep {
20905 dd.ReadMapElemKey()
20906 }
20907 mk = dd.DecodeString()
20908 if esep {
20909 dd.ReadMapElemValue()
20910 }
20911 if dd.TryDecodeAsNil() {
20912 if v == nil {
20913 } else if d.h.DeleteOnNilMapValue {
20914 delete(v, mk)
20915 } else {
20916 v[mk] = 0
20917 }
20918 continue
20919 }
20920 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
20921 if v != nil {
20922 v[mk] = mv
20923 }
20924 }
20925 dd.ReadMapEnd()
20926 return v, changed
20927}
20928
20929func (d *Decoder) fastpathDecMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
20930 if rv.Kind() == reflect.Ptr {
20931 vp := rv2i(rv).(*map[string]int32)
20932 v, changed := fastpathTV.DecMapStringInt32V(*vp, true, d)
20933 if changed {
20934 *vp = v
20935 }
20936 } else {
20937 fastpathTV.DecMapStringInt32V(rv2i(rv).(map[string]int32), false, d)
20938 }
20939}
20940func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, d *Decoder) {
20941 v, changed := f.DecMapStringInt32V(*vp, true, d)
20942 if changed {
20943 *vp = v
20944 }
20945}
20946func (_ fastpathT) DecMapStringInt32V(v map[string]int32, canChange bool,
20947 d *Decoder) (_ map[string]int32, changed bool) {
20948 dd, esep := d.d, d.hh.hasElemSeparators()
20949 containerLen := dd.ReadMapStart()
20950 if canChange && v == nil {
20951 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
20952 v = make(map[string]int32, xlen)
20953 changed = true
20954 }
20955 if containerLen == 0 {
20956 dd.ReadMapEnd()
20957 return v, changed
20958 }
20959 var mk string
20960 var mv int32
20961 hasLen := containerLen > 0
20962 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
20963 if esep {
20964 dd.ReadMapElemKey()
20965 }
20966 mk = dd.DecodeString()
20967 if esep {
20968 dd.ReadMapElemValue()
20969 }
20970 if dd.TryDecodeAsNil() {
20971 if v == nil {
20972 } else if d.h.DeleteOnNilMapValue {
20973 delete(v, mk)
20974 } else {
20975 v[mk] = 0
20976 }
20977 continue
20978 }
20979 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
20980 if v != nil {
20981 v[mk] = mv
20982 }
20983 }
20984 dd.ReadMapEnd()
20985 return v, changed
20986}
20987
20988func (d *Decoder) fastpathDecMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
20989 if rv.Kind() == reflect.Ptr {
20990 vp := rv2i(rv).(*map[string]int64)
20991 v, changed := fastpathTV.DecMapStringInt64V(*vp, true, d)
20992 if changed {
20993 *vp = v
20994 }
20995 } else {
20996 fastpathTV.DecMapStringInt64V(rv2i(rv).(map[string]int64), false, d)
20997 }
20998}
20999func (f fastpathT) DecMapStringInt64X(vp *map[string]int64, d *Decoder) {
21000 v, changed := f.DecMapStringInt64V(*vp, true, d)
21001 if changed {
21002 *vp = v
21003 }
21004}
21005func (_ fastpathT) DecMapStringInt64V(v map[string]int64, canChange bool,
21006 d *Decoder) (_ map[string]int64, changed bool) {
21007 dd, esep := d.d, d.hh.hasElemSeparators()
21008 containerLen := dd.ReadMapStart()
21009 if canChange && v == nil {
21010 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
21011 v = make(map[string]int64, xlen)
21012 changed = true
21013 }
21014 if containerLen == 0 {
21015 dd.ReadMapEnd()
21016 return v, changed
21017 }
21018 var mk string
21019 var mv int64
21020 hasLen := containerLen > 0
21021 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21022 if esep {
21023 dd.ReadMapElemKey()
21024 }
21025 mk = dd.DecodeString()
21026 if esep {
21027 dd.ReadMapElemValue()
21028 }
21029 if dd.TryDecodeAsNil() {
21030 if v == nil {
21031 } else if d.h.DeleteOnNilMapValue {
21032 delete(v, mk)
21033 } else {
21034 v[mk] = 0
21035 }
21036 continue
21037 }
21038 mv = dd.DecodeInt64()
21039 if v != nil {
21040 v[mk] = mv
21041 }
21042 }
21043 dd.ReadMapEnd()
21044 return v, changed
21045}
21046
21047func (d *Decoder) fastpathDecMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
21048 if rv.Kind() == reflect.Ptr {
21049 vp := rv2i(rv).(*map[string]float32)
21050 v, changed := fastpathTV.DecMapStringFloat32V(*vp, true, d)
21051 if changed {
21052 *vp = v
21053 }
21054 } else {
21055 fastpathTV.DecMapStringFloat32V(rv2i(rv).(map[string]float32), false, d)
21056 }
21057}
21058func (f fastpathT) DecMapStringFloat32X(vp *map[string]float32, d *Decoder) {
21059 v, changed := f.DecMapStringFloat32V(*vp, true, d)
21060 if changed {
21061 *vp = v
21062 }
21063}
21064func (_ fastpathT) DecMapStringFloat32V(v map[string]float32, canChange bool,
21065 d *Decoder) (_ map[string]float32, changed bool) {
21066 dd, esep := d.d, d.hh.hasElemSeparators()
21067 containerLen := dd.ReadMapStart()
21068 if canChange && v == nil {
21069 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21070 v = make(map[string]float32, xlen)
21071 changed = true
21072 }
21073 if containerLen == 0 {
21074 dd.ReadMapEnd()
21075 return v, changed
21076 }
21077 var mk string
21078 var mv float32
21079 hasLen := containerLen > 0
21080 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21081 if esep {
21082 dd.ReadMapElemKey()
21083 }
21084 mk = dd.DecodeString()
21085 if esep {
21086 dd.ReadMapElemValue()
21087 }
21088 if dd.TryDecodeAsNil() {
21089 if v == nil {
21090 } else if d.h.DeleteOnNilMapValue {
21091 delete(v, mk)
21092 } else {
21093 v[mk] = 0
21094 }
21095 continue
21096 }
21097 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21098 if v != nil {
21099 v[mk] = mv
21100 }
21101 }
21102 dd.ReadMapEnd()
21103 return v, changed
21104}
21105
21106func (d *Decoder) fastpathDecMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
21107 if rv.Kind() == reflect.Ptr {
21108 vp := rv2i(rv).(*map[string]float64)
21109 v, changed := fastpathTV.DecMapStringFloat64V(*vp, true, d)
21110 if changed {
21111 *vp = v
21112 }
21113 } else {
21114 fastpathTV.DecMapStringFloat64V(rv2i(rv).(map[string]float64), false, d)
21115 }
21116}
21117func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, d *Decoder) {
21118 v, changed := f.DecMapStringFloat64V(*vp, true, d)
21119 if changed {
21120 *vp = v
21121 }
21122}
21123func (_ fastpathT) DecMapStringFloat64V(v map[string]float64, canChange bool,
21124 d *Decoder) (_ map[string]float64, changed bool) {
21125 dd, esep := d.d, d.hh.hasElemSeparators()
21126 containerLen := dd.ReadMapStart()
21127 if canChange && v == nil {
21128 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
21129 v = make(map[string]float64, xlen)
21130 changed = true
21131 }
21132 if containerLen == 0 {
21133 dd.ReadMapEnd()
21134 return v, changed
21135 }
21136 var mk string
21137 var mv float64
21138 hasLen := containerLen > 0
21139 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21140 if esep {
21141 dd.ReadMapElemKey()
21142 }
21143 mk = dd.DecodeString()
21144 if esep {
21145 dd.ReadMapElemValue()
21146 }
21147 if dd.TryDecodeAsNil() {
21148 if v == nil {
21149 } else if d.h.DeleteOnNilMapValue {
21150 delete(v, mk)
21151 } else {
21152 v[mk] = 0
21153 }
21154 continue
21155 }
21156 mv = dd.DecodeFloat64()
21157 if v != nil {
21158 v[mk] = mv
21159 }
21160 }
21161 dd.ReadMapEnd()
21162 return v, changed
21163}
21164
21165func (d *Decoder) fastpathDecMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
21166 if rv.Kind() == reflect.Ptr {
21167 vp := rv2i(rv).(*map[string]bool)
21168 v, changed := fastpathTV.DecMapStringBoolV(*vp, true, d)
21169 if changed {
21170 *vp = v
21171 }
21172 } else {
21173 fastpathTV.DecMapStringBoolV(rv2i(rv).(map[string]bool), false, d)
21174 }
21175}
21176func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, d *Decoder) {
21177 v, changed := f.DecMapStringBoolV(*vp, true, d)
21178 if changed {
21179 *vp = v
21180 }
21181}
21182func (_ fastpathT) DecMapStringBoolV(v map[string]bool, canChange bool,
21183 d *Decoder) (_ map[string]bool, changed bool) {
21184 dd, esep := d.d, d.hh.hasElemSeparators()
21185 containerLen := dd.ReadMapStart()
21186 if canChange && v == nil {
21187 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
21188 v = make(map[string]bool, xlen)
21189 changed = true
21190 }
21191 if containerLen == 0 {
21192 dd.ReadMapEnd()
21193 return v, changed
21194 }
21195 var mk string
21196 var mv bool
21197 hasLen := containerLen > 0
21198 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21199 if esep {
21200 dd.ReadMapElemKey()
21201 }
21202 mk = dd.DecodeString()
21203 if esep {
21204 dd.ReadMapElemValue()
21205 }
21206 if dd.TryDecodeAsNil() {
21207 if v == nil {
21208 } else if d.h.DeleteOnNilMapValue {
21209 delete(v, mk)
21210 } else {
21211 v[mk] = false
21212 }
21213 continue
21214 }
21215 mv = dd.DecodeBool()
21216 if v != nil {
21217 v[mk] = mv
21218 }
21219 }
21220 dd.ReadMapEnd()
21221 return v, changed
21222}
21223
21224func (d *Decoder) fastpathDecMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
21225 if rv.Kind() == reflect.Ptr {
21226 vp := rv2i(rv).(*map[float32]interface{})
21227 v, changed := fastpathTV.DecMapFloat32IntfV(*vp, true, d)
21228 if changed {
21229 *vp = v
21230 }
21231 } else {
21232 fastpathTV.DecMapFloat32IntfV(rv2i(rv).(map[float32]interface{}), false, d)
21233 }
21234}
21235func (f fastpathT) DecMapFloat32IntfX(vp *map[float32]interface{}, d *Decoder) {
21236 v, changed := f.DecMapFloat32IntfV(*vp, true, d)
21237 if changed {
21238 *vp = v
21239 }
21240}
21241func (_ fastpathT) DecMapFloat32IntfV(v map[float32]interface{}, canChange bool,
21242 d *Decoder) (_ map[float32]interface{}, changed bool) {
21243 dd, esep := d.d, d.hh.hasElemSeparators()
21244 containerLen := dd.ReadMapStart()
21245 if canChange && v == nil {
21246 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21247 v = make(map[float32]interface{}, xlen)
21248 changed = true
21249 }
21250 if containerLen == 0 {
21251 dd.ReadMapEnd()
21252 return v, changed
21253 }
21254 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
21255 var mk float32
21256 var mv interface{}
21257 hasLen := containerLen > 0
21258 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21259 if esep {
21260 dd.ReadMapElemKey()
21261 }
21262 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21263 if esep {
21264 dd.ReadMapElemValue()
21265 }
21266 if dd.TryDecodeAsNil() {
21267 if v == nil {
21268 } else if d.h.DeleteOnNilMapValue {
21269 delete(v, mk)
21270 } else {
21271 v[mk] = nil
21272 }
21273 continue
21274 }
21275 if mapGet {
21276 mv = v[mk]
21277 } else {
21278 mv = nil
21279 }
21280 d.decode(&mv)
21281 if v != nil {
21282 v[mk] = mv
21283 }
21284 }
21285 dd.ReadMapEnd()
21286 return v, changed
21287}
21288
21289func (d *Decoder) fastpathDecMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
21290 if rv.Kind() == reflect.Ptr {
21291 vp := rv2i(rv).(*map[float32]string)
21292 v, changed := fastpathTV.DecMapFloat32StringV(*vp, true, d)
21293 if changed {
21294 *vp = v
21295 }
21296 } else {
21297 fastpathTV.DecMapFloat32StringV(rv2i(rv).(map[float32]string), false, d)
21298 }
21299}
21300func (f fastpathT) DecMapFloat32StringX(vp *map[float32]string, d *Decoder) {
21301 v, changed := f.DecMapFloat32StringV(*vp, true, d)
21302 if changed {
21303 *vp = v
21304 }
21305}
21306func (_ fastpathT) DecMapFloat32StringV(v map[float32]string, canChange bool,
21307 d *Decoder) (_ map[float32]string, changed bool) {
21308 dd, esep := d.d, d.hh.hasElemSeparators()
21309 containerLen := dd.ReadMapStart()
21310 if canChange && v == nil {
21311 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
21312 v = make(map[float32]string, xlen)
21313 changed = true
21314 }
21315 if containerLen == 0 {
21316 dd.ReadMapEnd()
21317 return v, changed
21318 }
21319 var mk float32
21320 var mv string
21321 hasLen := containerLen > 0
21322 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21323 if esep {
21324 dd.ReadMapElemKey()
21325 }
21326 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21327 if esep {
21328 dd.ReadMapElemValue()
21329 }
21330 if dd.TryDecodeAsNil() {
21331 if v == nil {
21332 } else if d.h.DeleteOnNilMapValue {
21333 delete(v, mk)
21334 } else {
21335 v[mk] = ""
21336 }
21337 continue
21338 }
21339 mv = dd.DecodeString()
21340 if v != nil {
21341 v[mk] = mv
21342 }
21343 }
21344 dd.ReadMapEnd()
21345 return v, changed
21346}
21347
21348func (d *Decoder) fastpathDecMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
21349 if rv.Kind() == reflect.Ptr {
21350 vp := rv2i(rv).(*map[float32]uint)
21351 v, changed := fastpathTV.DecMapFloat32UintV(*vp, true, d)
21352 if changed {
21353 *vp = v
21354 }
21355 } else {
21356 fastpathTV.DecMapFloat32UintV(rv2i(rv).(map[float32]uint), false, d)
21357 }
21358}
21359func (f fastpathT) DecMapFloat32UintX(vp *map[float32]uint, d *Decoder) {
21360 v, changed := f.DecMapFloat32UintV(*vp, true, d)
21361 if changed {
21362 *vp = v
21363 }
21364}
21365func (_ fastpathT) DecMapFloat32UintV(v map[float32]uint, canChange bool,
21366 d *Decoder) (_ map[float32]uint, changed bool) {
21367 dd, esep := d.d, d.hh.hasElemSeparators()
21368 containerLen := dd.ReadMapStart()
21369 if canChange && v == nil {
21370 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21371 v = make(map[float32]uint, xlen)
21372 changed = true
21373 }
21374 if containerLen == 0 {
21375 dd.ReadMapEnd()
21376 return v, changed
21377 }
21378 var mk float32
21379 var mv uint
21380 hasLen := containerLen > 0
21381 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21382 if esep {
21383 dd.ReadMapElemKey()
21384 }
21385 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21386 if esep {
21387 dd.ReadMapElemValue()
21388 }
21389 if dd.TryDecodeAsNil() {
21390 if v == nil {
21391 } else if d.h.DeleteOnNilMapValue {
21392 delete(v, mk)
21393 } else {
21394 v[mk] = 0
21395 }
21396 continue
21397 }
21398 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
21399 if v != nil {
21400 v[mk] = mv
21401 }
21402 }
21403 dd.ReadMapEnd()
21404 return v, changed
21405}
21406
21407func (d *Decoder) fastpathDecMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
21408 if rv.Kind() == reflect.Ptr {
21409 vp := rv2i(rv).(*map[float32]uint8)
21410 v, changed := fastpathTV.DecMapFloat32Uint8V(*vp, true, d)
21411 if changed {
21412 *vp = v
21413 }
21414 } else {
21415 fastpathTV.DecMapFloat32Uint8V(rv2i(rv).(map[float32]uint8), false, d)
21416 }
21417}
21418func (f fastpathT) DecMapFloat32Uint8X(vp *map[float32]uint8, d *Decoder) {
21419 v, changed := f.DecMapFloat32Uint8V(*vp, true, d)
21420 if changed {
21421 *vp = v
21422 }
21423}
21424func (_ fastpathT) DecMapFloat32Uint8V(v map[float32]uint8, canChange bool,
21425 d *Decoder) (_ map[float32]uint8, changed bool) {
21426 dd, esep := d.d, d.hh.hasElemSeparators()
21427 containerLen := dd.ReadMapStart()
21428 if canChange && v == nil {
21429 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
21430 v = make(map[float32]uint8, xlen)
21431 changed = true
21432 }
21433 if containerLen == 0 {
21434 dd.ReadMapEnd()
21435 return v, changed
21436 }
21437 var mk float32
21438 var mv uint8
21439 hasLen := containerLen > 0
21440 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21441 if esep {
21442 dd.ReadMapElemKey()
21443 }
21444 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21445 if esep {
21446 dd.ReadMapElemValue()
21447 }
21448 if dd.TryDecodeAsNil() {
21449 if v == nil {
21450 } else if d.h.DeleteOnNilMapValue {
21451 delete(v, mk)
21452 } else {
21453 v[mk] = 0
21454 }
21455 continue
21456 }
21457 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
21458 if v != nil {
21459 v[mk] = mv
21460 }
21461 }
21462 dd.ReadMapEnd()
21463 return v, changed
21464}
21465
21466func (d *Decoder) fastpathDecMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
21467 if rv.Kind() == reflect.Ptr {
21468 vp := rv2i(rv).(*map[float32]uint16)
21469 v, changed := fastpathTV.DecMapFloat32Uint16V(*vp, true, d)
21470 if changed {
21471 *vp = v
21472 }
21473 } else {
21474 fastpathTV.DecMapFloat32Uint16V(rv2i(rv).(map[float32]uint16), false, d)
21475 }
21476}
21477func (f fastpathT) DecMapFloat32Uint16X(vp *map[float32]uint16, d *Decoder) {
21478 v, changed := f.DecMapFloat32Uint16V(*vp, true, d)
21479 if changed {
21480 *vp = v
21481 }
21482}
21483func (_ fastpathT) DecMapFloat32Uint16V(v map[float32]uint16, canChange bool,
21484 d *Decoder) (_ map[float32]uint16, changed bool) {
21485 dd, esep := d.d, d.hh.hasElemSeparators()
21486 containerLen := dd.ReadMapStart()
21487 if canChange && v == nil {
21488 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
21489 v = make(map[float32]uint16, xlen)
21490 changed = true
21491 }
21492 if containerLen == 0 {
21493 dd.ReadMapEnd()
21494 return v, changed
21495 }
21496 var mk float32
21497 var mv uint16
21498 hasLen := containerLen > 0
21499 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21500 if esep {
21501 dd.ReadMapElemKey()
21502 }
21503 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21504 if esep {
21505 dd.ReadMapElemValue()
21506 }
21507 if dd.TryDecodeAsNil() {
21508 if v == nil {
21509 } else if d.h.DeleteOnNilMapValue {
21510 delete(v, mk)
21511 } else {
21512 v[mk] = 0
21513 }
21514 continue
21515 }
21516 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
21517 if v != nil {
21518 v[mk] = mv
21519 }
21520 }
21521 dd.ReadMapEnd()
21522 return v, changed
21523}
21524
21525func (d *Decoder) fastpathDecMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
21526 if rv.Kind() == reflect.Ptr {
21527 vp := rv2i(rv).(*map[float32]uint32)
21528 v, changed := fastpathTV.DecMapFloat32Uint32V(*vp, true, d)
21529 if changed {
21530 *vp = v
21531 }
21532 } else {
21533 fastpathTV.DecMapFloat32Uint32V(rv2i(rv).(map[float32]uint32), false, d)
21534 }
21535}
21536func (f fastpathT) DecMapFloat32Uint32X(vp *map[float32]uint32, d *Decoder) {
21537 v, changed := f.DecMapFloat32Uint32V(*vp, true, d)
21538 if changed {
21539 *vp = v
21540 }
21541}
21542func (_ fastpathT) DecMapFloat32Uint32V(v map[float32]uint32, canChange bool,
21543 d *Decoder) (_ map[float32]uint32, changed bool) {
21544 dd, esep := d.d, d.hh.hasElemSeparators()
21545 containerLen := dd.ReadMapStart()
21546 if canChange && v == nil {
21547 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
21548 v = make(map[float32]uint32, xlen)
21549 changed = true
21550 }
21551 if containerLen == 0 {
21552 dd.ReadMapEnd()
21553 return v, changed
21554 }
21555 var mk float32
21556 var mv uint32
21557 hasLen := containerLen > 0
21558 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21559 if esep {
21560 dd.ReadMapElemKey()
21561 }
21562 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21563 if esep {
21564 dd.ReadMapElemValue()
21565 }
21566 if dd.TryDecodeAsNil() {
21567 if v == nil {
21568 } else if d.h.DeleteOnNilMapValue {
21569 delete(v, mk)
21570 } else {
21571 v[mk] = 0
21572 }
21573 continue
21574 }
21575 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
21576 if v != nil {
21577 v[mk] = mv
21578 }
21579 }
21580 dd.ReadMapEnd()
21581 return v, changed
21582}
21583
21584func (d *Decoder) fastpathDecMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
21585 if rv.Kind() == reflect.Ptr {
21586 vp := rv2i(rv).(*map[float32]uint64)
21587 v, changed := fastpathTV.DecMapFloat32Uint64V(*vp, true, d)
21588 if changed {
21589 *vp = v
21590 }
21591 } else {
21592 fastpathTV.DecMapFloat32Uint64V(rv2i(rv).(map[float32]uint64), false, d)
21593 }
21594}
21595func (f fastpathT) DecMapFloat32Uint64X(vp *map[float32]uint64, d *Decoder) {
21596 v, changed := f.DecMapFloat32Uint64V(*vp, true, d)
21597 if changed {
21598 *vp = v
21599 }
21600}
21601func (_ fastpathT) DecMapFloat32Uint64V(v map[float32]uint64, canChange bool,
21602 d *Decoder) (_ map[float32]uint64, changed bool) {
21603 dd, esep := d.d, d.hh.hasElemSeparators()
21604 containerLen := dd.ReadMapStart()
21605 if canChange && v == nil {
21606 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21607 v = make(map[float32]uint64, xlen)
21608 changed = true
21609 }
21610 if containerLen == 0 {
21611 dd.ReadMapEnd()
21612 return v, changed
21613 }
21614 var mk float32
21615 var mv uint64
21616 hasLen := containerLen > 0
21617 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21618 if esep {
21619 dd.ReadMapElemKey()
21620 }
21621 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21622 if esep {
21623 dd.ReadMapElemValue()
21624 }
21625 if dd.TryDecodeAsNil() {
21626 if v == nil {
21627 } else if d.h.DeleteOnNilMapValue {
21628 delete(v, mk)
21629 } else {
21630 v[mk] = 0
21631 }
21632 continue
21633 }
21634 mv = dd.DecodeUint64()
21635 if v != nil {
21636 v[mk] = mv
21637 }
21638 }
21639 dd.ReadMapEnd()
21640 return v, changed
21641}
21642
21643func (d *Decoder) fastpathDecMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
21644 if rv.Kind() == reflect.Ptr {
21645 vp := rv2i(rv).(*map[float32]uintptr)
21646 v, changed := fastpathTV.DecMapFloat32UintptrV(*vp, true, d)
21647 if changed {
21648 *vp = v
21649 }
21650 } else {
21651 fastpathTV.DecMapFloat32UintptrV(rv2i(rv).(map[float32]uintptr), false, d)
21652 }
21653}
21654func (f fastpathT) DecMapFloat32UintptrX(vp *map[float32]uintptr, d *Decoder) {
21655 v, changed := f.DecMapFloat32UintptrV(*vp, true, d)
21656 if changed {
21657 *vp = v
21658 }
21659}
21660func (_ fastpathT) DecMapFloat32UintptrV(v map[float32]uintptr, canChange bool,
21661 d *Decoder) (_ map[float32]uintptr, changed bool) {
21662 dd, esep := d.d, d.hh.hasElemSeparators()
21663 containerLen := dd.ReadMapStart()
21664 if canChange && v == nil {
21665 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21666 v = make(map[float32]uintptr, xlen)
21667 changed = true
21668 }
21669 if containerLen == 0 {
21670 dd.ReadMapEnd()
21671 return v, changed
21672 }
21673 var mk float32
21674 var mv uintptr
21675 hasLen := containerLen > 0
21676 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21677 if esep {
21678 dd.ReadMapElemKey()
21679 }
21680 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21681 if esep {
21682 dd.ReadMapElemValue()
21683 }
21684 if dd.TryDecodeAsNil() {
21685 if v == nil {
21686 } else if d.h.DeleteOnNilMapValue {
21687 delete(v, mk)
21688 } else {
21689 v[mk] = 0
21690 }
21691 continue
21692 }
21693 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
21694 if v != nil {
21695 v[mk] = mv
21696 }
21697 }
21698 dd.ReadMapEnd()
21699 return v, changed
21700}
21701
21702func (d *Decoder) fastpathDecMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
21703 if rv.Kind() == reflect.Ptr {
21704 vp := rv2i(rv).(*map[float32]int)
21705 v, changed := fastpathTV.DecMapFloat32IntV(*vp, true, d)
21706 if changed {
21707 *vp = v
21708 }
21709 } else {
21710 fastpathTV.DecMapFloat32IntV(rv2i(rv).(map[float32]int), false, d)
21711 }
21712}
21713func (f fastpathT) DecMapFloat32IntX(vp *map[float32]int, d *Decoder) {
21714 v, changed := f.DecMapFloat32IntV(*vp, true, d)
21715 if changed {
21716 *vp = v
21717 }
21718}
21719func (_ fastpathT) DecMapFloat32IntV(v map[float32]int, canChange bool,
21720 d *Decoder) (_ map[float32]int, changed bool) {
21721 dd, esep := d.d, d.hh.hasElemSeparators()
21722 containerLen := dd.ReadMapStart()
21723 if canChange && v == nil {
21724 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21725 v = make(map[float32]int, xlen)
21726 changed = true
21727 }
21728 if containerLen == 0 {
21729 dd.ReadMapEnd()
21730 return v, changed
21731 }
21732 var mk float32
21733 var mv int
21734 hasLen := containerLen > 0
21735 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21736 if esep {
21737 dd.ReadMapElemKey()
21738 }
21739 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21740 if esep {
21741 dd.ReadMapElemValue()
21742 }
21743 if dd.TryDecodeAsNil() {
21744 if v == nil {
21745 } else if d.h.DeleteOnNilMapValue {
21746 delete(v, mk)
21747 } else {
21748 v[mk] = 0
21749 }
21750 continue
21751 }
21752 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
21753 if v != nil {
21754 v[mk] = mv
21755 }
21756 }
21757 dd.ReadMapEnd()
21758 return v, changed
21759}
21760
21761func (d *Decoder) fastpathDecMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
21762 if rv.Kind() == reflect.Ptr {
21763 vp := rv2i(rv).(*map[float32]int8)
21764 v, changed := fastpathTV.DecMapFloat32Int8V(*vp, true, d)
21765 if changed {
21766 *vp = v
21767 }
21768 } else {
21769 fastpathTV.DecMapFloat32Int8V(rv2i(rv).(map[float32]int8), false, d)
21770 }
21771}
21772func (f fastpathT) DecMapFloat32Int8X(vp *map[float32]int8, d *Decoder) {
21773 v, changed := f.DecMapFloat32Int8V(*vp, true, d)
21774 if changed {
21775 *vp = v
21776 }
21777}
21778func (_ fastpathT) DecMapFloat32Int8V(v map[float32]int8, canChange bool,
21779 d *Decoder) (_ map[float32]int8, changed bool) {
21780 dd, esep := d.d, d.hh.hasElemSeparators()
21781 containerLen := dd.ReadMapStart()
21782 if canChange && v == nil {
21783 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
21784 v = make(map[float32]int8, xlen)
21785 changed = true
21786 }
21787 if containerLen == 0 {
21788 dd.ReadMapEnd()
21789 return v, changed
21790 }
21791 var mk float32
21792 var mv int8
21793 hasLen := containerLen > 0
21794 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21795 if esep {
21796 dd.ReadMapElemKey()
21797 }
21798 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21799 if esep {
21800 dd.ReadMapElemValue()
21801 }
21802 if dd.TryDecodeAsNil() {
21803 if v == nil {
21804 } else if d.h.DeleteOnNilMapValue {
21805 delete(v, mk)
21806 } else {
21807 v[mk] = 0
21808 }
21809 continue
21810 }
21811 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
21812 if v != nil {
21813 v[mk] = mv
21814 }
21815 }
21816 dd.ReadMapEnd()
21817 return v, changed
21818}
21819
21820func (d *Decoder) fastpathDecMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
21821 if rv.Kind() == reflect.Ptr {
21822 vp := rv2i(rv).(*map[float32]int16)
21823 v, changed := fastpathTV.DecMapFloat32Int16V(*vp, true, d)
21824 if changed {
21825 *vp = v
21826 }
21827 } else {
21828 fastpathTV.DecMapFloat32Int16V(rv2i(rv).(map[float32]int16), false, d)
21829 }
21830}
21831func (f fastpathT) DecMapFloat32Int16X(vp *map[float32]int16, d *Decoder) {
21832 v, changed := f.DecMapFloat32Int16V(*vp, true, d)
21833 if changed {
21834 *vp = v
21835 }
21836}
21837func (_ fastpathT) DecMapFloat32Int16V(v map[float32]int16, canChange bool,
21838 d *Decoder) (_ map[float32]int16, changed bool) {
21839 dd, esep := d.d, d.hh.hasElemSeparators()
21840 containerLen := dd.ReadMapStart()
21841 if canChange && v == nil {
21842 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
21843 v = make(map[float32]int16, xlen)
21844 changed = true
21845 }
21846 if containerLen == 0 {
21847 dd.ReadMapEnd()
21848 return v, changed
21849 }
21850 var mk float32
21851 var mv int16
21852 hasLen := containerLen > 0
21853 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21854 if esep {
21855 dd.ReadMapElemKey()
21856 }
21857 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21858 if esep {
21859 dd.ReadMapElemValue()
21860 }
21861 if dd.TryDecodeAsNil() {
21862 if v == nil {
21863 } else if d.h.DeleteOnNilMapValue {
21864 delete(v, mk)
21865 } else {
21866 v[mk] = 0
21867 }
21868 continue
21869 }
21870 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
21871 if v != nil {
21872 v[mk] = mv
21873 }
21874 }
21875 dd.ReadMapEnd()
21876 return v, changed
21877}
21878
21879func (d *Decoder) fastpathDecMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
21880 if rv.Kind() == reflect.Ptr {
21881 vp := rv2i(rv).(*map[float32]int32)
21882 v, changed := fastpathTV.DecMapFloat32Int32V(*vp, true, d)
21883 if changed {
21884 *vp = v
21885 }
21886 } else {
21887 fastpathTV.DecMapFloat32Int32V(rv2i(rv).(map[float32]int32), false, d)
21888 }
21889}
21890func (f fastpathT) DecMapFloat32Int32X(vp *map[float32]int32, d *Decoder) {
21891 v, changed := f.DecMapFloat32Int32V(*vp, true, d)
21892 if changed {
21893 *vp = v
21894 }
21895}
21896func (_ fastpathT) DecMapFloat32Int32V(v map[float32]int32, canChange bool,
21897 d *Decoder) (_ map[float32]int32, changed bool) {
21898 dd, esep := d.d, d.hh.hasElemSeparators()
21899 containerLen := dd.ReadMapStart()
21900 if canChange && v == nil {
21901 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
21902 v = make(map[float32]int32, xlen)
21903 changed = true
21904 }
21905 if containerLen == 0 {
21906 dd.ReadMapEnd()
21907 return v, changed
21908 }
21909 var mk float32
21910 var mv int32
21911 hasLen := containerLen > 0
21912 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21913 if esep {
21914 dd.ReadMapElemKey()
21915 }
21916 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21917 if esep {
21918 dd.ReadMapElemValue()
21919 }
21920 if dd.TryDecodeAsNil() {
21921 if v == nil {
21922 } else if d.h.DeleteOnNilMapValue {
21923 delete(v, mk)
21924 } else {
21925 v[mk] = 0
21926 }
21927 continue
21928 }
21929 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
21930 if v != nil {
21931 v[mk] = mv
21932 }
21933 }
21934 dd.ReadMapEnd()
21935 return v, changed
21936}
21937
21938func (d *Decoder) fastpathDecMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
21939 if rv.Kind() == reflect.Ptr {
21940 vp := rv2i(rv).(*map[float32]int64)
21941 v, changed := fastpathTV.DecMapFloat32Int64V(*vp, true, d)
21942 if changed {
21943 *vp = v
21944 }
21945 } else {
21946 fastpathTV.DecMapFloat32Int64V(rv2i(rv).(map[float32]int64), false, d)
21947 }
21948}
21949func (f fastpathT) DecMapFloat32Int64X(vp *map[float32]int64, d *Decoder) {
21950 v, changed := f.DecMapFloat32Int64V(*vp, true, d)
21951 if changed {
21952 *vp = v
21953 }
21954}
21955func (_ fastpathT) DecMapFloat32Int64V(v map[float32]int64, canChange bool,
21956 d *Decoder) (_ map[float32]int64, changed bool) {
21957 dd, esep := d.d, d.hh.hasElemSeparators()
21958 containerLen := dd.ReadMapStart()
21959 if canChange && v == nil {
21960 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
21961 v = make(map[float32]int64, xlen)
21962 changed = true
21963 }
21964 if containerLen == 0 {
21965 dd.ReadMapEnd()
21966 return v, changed
21967 }
21968 var mk float32
21969 var mv int64
21970 hasLen := containerLen > 0
21971 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
21972 if esep {
21973 dd.ReadMapElemKey()
21974 }
21975 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
21976 if esep {
21977 dd.ReadMapElemValue()
21978 }
21979 if dd.TryDecodeAsNil() {
21980 if v == nil {
21981 } else if d.h.DeleteOnNilMapValue {
21982 delete(v, mk)
21983 } else {
21984 v[mk] = 0
21985 }
21986 continue
21987 }
21988 mv = dd.DecodeInt64()
21989 if v != nil {
21990 v[mk] = mv
21991 }
21992 }
21993 dd.ReadMapEnd()
21994 return v, changed
21995}
21996
21997func (d *Decoder) fastpathDecMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
21998 if rv.Kind() == reflect.Ptr {
21999 vp := rv2i(rv).(*map[float32]float32)
22000 v, changed := fastpathTV.DecMapFloat32Float32V(*vp, true, d)
22001 if changed {
22002 *vp = v
22003 }
22004 } else {
22005 fastpathTV.DecMapFloat32Float32V(rv2i(rv).(map[float32]float32), false, d)
22006 }
22007}
22008func (f fastpathT) DecMapFloat32Float32X(vp *map[float32]float32, d *Decoder) {
22009 v, changed := f.DecMapFloat32Float32V(*vp, true, d)
22010 if changed {
22011 *vp = v
22012 }
22013}
22014func (_ fastpathT) DecMapFloat32Float32V(v map[float32]float32, canChange bool,
22015 d *Decoder) (_ map[float32]float32, 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]float32, xlen)
22021 changed = true
22022 }
22023 if containerLen == 0 {
22024 dd.ReadMapEnd()
22025 return v, changed
22026 }
22027 var mk float32
22028 var mv float32
22029 hasLen := containerLen > 0
22030 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22031 if esep {
22032 dd.ReadMapElemKey()
22033 }
22034 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22035 if esep {
22036 dd.ReadMapElemValue()
22037 }
22038 if dd.TryDecodeAsNil() {
22039 if v == nil {
22040 } else if d.h.DeleteOnNilMapValue {
22041 delete(v, mk)
22042 } else {
22043 v[mk] = 0
22044 }
22045 continue
22046 }
22047 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22048 if v != nil {
22049 v[mk] = mv
22050 }
22051 }
22052 dd.ReadMapEnd()
22053 return v, changed
22054}
22055
22056func (d *Decoder) fastpathDecMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
22057 if rv.Kind() == reflect.Ptr {
22058 vp := rv2i(rv).(*map[float32]float64)
22059 v, changed := fastpathTV.DecMapFloat32Float64V(*vp, true, d)
22060 if changed {
22061 *vp = v
22062 }
22063 } else {
22064 fastpathTV.DecMapFloat32Float64V(rv2i(rv).(map[float32]float64), false, d)
22065 }
22066}
22067func (f fastpathT) DecMapFloat32Float64X(vp *map[float32]float64, d *Decoder) {
22068 v, changed := f.DecMapFloat32Float64V(*vp, true, d)
22069 if changed {
22070 *vp = v
22071 }
22072}
22073func (_ fastpathT) DecMapFloat32Float64V(v map[float32]float64, canChange bool,
22074 d *Decoder) (_ map[float32]float64, changed bool) {
22075 dd, esep := d.d, d.hh.hasElemSeparators()
22076 containerLen := dd.ReadMapStart()
22077 if canChange && v == nil {
22078 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
22079 v = make(map[float32]float64, xlen)
22080 changed = true
22081 }
22082 if containerLen == 0 {
22083 dd.ReadMapEnd()
22084 return v, changed
22085 }
22086 var mk float32
22087 var mv float64
22088 hasLen := containerLen > 0
22089 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22090 if esep {
22091 dd.ReadMapElemKey()
22092 }
22093 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22094 if esep {
22095 dd.ReadMapElemValue()
22096 }
22097 if dd.TryDecodeAsNil() {
22098 if v == nil {
22099 } else if d.h.DeleteOnNilMapValue {
22100 delete(v, mk)
22101 } else {
22102 v[mk] = 0
22103 }
22104 continue
22105 }
22106 mv = dd.DecodeFloat64()
22107 if v != nil {
22108 v[mk] = mv
22109 }
22110 }
22111 dd.ReadMapEnd()
22112 return v, changed
22113}
22114
22115func (d *Decoder) fastpathDecMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
22116 if rv.Kind() == reflect.Ptr {
22117 vp := rv2i(rv).(*map[float32]bool)
22118 v, changed := fastpathTV.DecMapFloat32BoolV(*vp, true, d)
22119 if changed {
22120 *vp = v
22121 }
22122 } else {
22123 fastpathTV.DecMapFloat32BoolV(rv2i(rv).(map[float32]bool), false, d)
22124 }
22125}
22126func (f fastpathT) DecMapFloat32BoolX(vp *map[float32]bool, d *Decoder) {
22127 v, changed := f.DecMapFloat32BoolV(*vp, true, d)
22128 if changed {
22129 *vp = v
22130 }
22131}
22132func (_ fastpathT) DecMapFloat32BoolV(v map[float32]bool, canChange bool,
22133 d *Decoder) (_ map[float32]bool, changed bool) {
22134 dd, esep := d.d, d.hh.hasElemSeparators()
22135 containerLen := dd.ReadMapStart()
22136 if canChange && v == nil {
22137 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
22138 v = make(map[float32]bool, xlen)
22139 changed = true
22140 }
22141 if containerLen == 0 {
22142 dd.ReadMapEnd()
22143 return v, changed
22144 }
22145 var mk float32
22146 var mv bool
22147 hasLen := containerLen > 0
22148 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22149 if esep {
22150 dd.ReadMapElemKey()
22151 }
22152 mk = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22153 if esep {
22154 dd.ReadMapElemValue()
22155 }
22156 if dd.TryDecodeAsNil() {
22157 if v == nil {
22158 } else if d.h.DeleteOnNilMapValue {
22159 delete(v, mk)
22160 } else {
22161 v[mk] = false
22162 }
22163 continue
22164 }
22165 mv = dd.DecodeBool()
22166 if v != nil {
22167 v[mk] = mv
22168 }
22169 }
22170 dd.ReadMapEnd()
22171 return v, changed
22172}
22173
22174func (d *Decoder) fastpathDecMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
22175 if rv.Kind() == reflect.Ptr {
22176 vp := rv2i(rv).(*map[float64]interface{})
22177 v, changed := fastpathTV.DecMapFloat64IntfV(*vp, true, d)
22178 if changed {
22179 *vp = v
22180 }
22181 } else {
22182 fastpathTV.DecMapFloat64IntfV(rv2i(rv).(map[float64]interface{}), false, d)
22183 }
22184}
22185func (f fastpathT) DecMapFloat64IntfX(vp *map[float64]interface{}, d *Decoder) {
22186 v, changed := f.DecMapFloat64IntfV(*vp, true, d)
22187 if changed {
22188 *vp = v
22189 }
22190}
22191func (_ fastpathT) DecMapFloat64IntfV(v map[float64]interface{}, canChange bool,
22192 d *Decoder) (_ map[float64]interface{}, changed bool) {
22193 dd, esep := d.d, d.hh.hasElemSeparators()
22194 containerLen := dd.ReadMapStart()
22195 if canChange && v == nil {
22196 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
22197 v = make(map[float64]interface{}, xlen)
22198 changed = true
22199 }
22200 if containerLen == 0 {
22201 dd.ReadMapEnd()
22202 return v, changed
22203 }
22204 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
22205 var mk float64
22206 var mv interface{}
22207 hasLen := containerLen > 0
22208 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22209 if esep {
22210 dd.ReadMapElemKey()
22211 }
22212 mk = dd.DecodeFloat64()
22213 if esep {
22214 dd.ReadMapElemValue()
22215 }
22216 if dd.TryDecodeAsNil() {
22217 if v == nil {
22218 } else if d.h.DeleteOnNilMapValue {
22219 delete(v, mk)
22220 } else {
22221 v[mk] = nil
22222 }
22223 continue
22224 }
22225 if mapGet {
22226 mv = v[mk]
22227 } else {
22228 mv = nil
22229 }
22230 d.decode(&mv)
22231 if v != nil {
22232 v[mk] = mv
22233 }
22234 }
22235 dd.ReadMapEnd()
22236 return v, changed
22237}
22238
22239func (d *Decoder) fastpathDecMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
22240 if rv.Kind() == reflect.Ptr {
22241 vp := rv2i(rv).(*map[float64]string)
22242 v, changed := fastpathTV.DecMapFloat64StringV(*vp, true, d)
22243 if changed {
22244 *vp = v
22245 }
22246 } else {
22247 fastpathTV.DecMapFloat64StringV(rv2i(rv).(map[float64]string), false, d)
22248 }
22249}
22250func (f fastpathT) DecMapFloat64StringX(vp *map[float64]string, d *Decoder) {
22251 v, changed := f.DecMapFloat64StringV(*vp, true, d)
22252 if changed {
22253 *vp = v
22254 }
22255}
22256func (_ fastpathT) DecMapFloat64StringV(v map[float64]string, canChange bool,
22257 d *Decoder) (_ map[float64]string, changed bool) {
22258 dd, esep := d.d, d.hh.hasElemSeparators()
22259 containerLen := dd.ReadMapStart()
22260 if canChange && v == nil {
22261 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
22262 v = make(map[float64]string, xlen)
22263 changed = true
22264 }
22265 if containerLen == 0 {
22266 dd.ReadMapEnd()
22267 return v, changed
22268 }
22269 var mk float64
22270 var mv string
22271 hasLen := containerLen > 0
22272 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22273 if esep {
22274 dd.ReadMapElemKey()
22275 }
22276 mk = dd.DecodeFloat64()
22277 if esep {
22278 dd.ReadMapElemValue()
22279 }
22280 if dd.TryDecodeAsNil() {
22281 if v == nil {
22282 } else if d.h.DeleteOnNilMapValue {
22283 delete(v, mk)
22284 } else {
22285 v[mk] = ""
22286 }
22287 continue
22288 }
22289 mv = dd.DecodeString()
22290 if v != nil {
22291 v[mk] = mv
22292 }
22293 }
22294 dd.ReadMapEnd()
22295 return v, changed
22296}
22297
22298func (d *Decoder) fastpathDecMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
22299 if rv.Kind() == reflect.Ptr {
22300 vp := rv2i(rv).(*map[float64]uint)
22301 v, changed := fastpathTV.DecMapFloat64UintV(*vp, true, d)
22302 if changed {
22303 *vp = v
22304 }
22305 } else {
22306 fastpathTV.DecMapFloat64UintV(rv2i(rv).(map[float64]uint), false, d)
22307 }
22308}
22309func (f fastpathT) DecMapFloat64UintX(vp *map[float64]uint, d *Decoder) {
22310 v, changed := f.DecMapFloat64UintV(*vp, true, d)
22311 if changed {
22312 *vp = v
22313 }
22314}
22315func (_ fastpathT) DecMapFloat64UintV(v map[float64]uint, canChange bool,
22316 d *Decoder) (_ map[float64]uint, changed bool) {
22317 dd, esep := d.d, d.hh.hasElemSeparators()
22318 containerLen := dd.ReadMapStart()
22319 if canChange && v == nil {
22320 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22321 v = make(map[float64]uint, xlen)
22322 changed = true
22323 }
22324 if containerLen == 0 {
22325 dd.ReadMapEnd()
22326 return v, changed
22327 }
22328 var mk float64
22329 var mv uint
22330 hasLen := containerLen > 0
22331 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22332 if esep {
22333 dd.ReadMapElemKey()
22334 }
22335 mk = dd.DecodeFloat64()
22336 if esep {
22337 dd.ReadMapElemValue()
22338 }
22339 if dd.TryDecodeAsNil() {
22340 if v == nil {
22341 } else if d.h.DeleteOnNilMapValue {
22342 delete(v, mk)
22343 } else {
22344 v[mk] = 0
22345 }
22346 continue
22347 }
22348 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
22349 if v != nil {
22350 v[mk] = mv
22351 }
22352 }
22353 dd.ReadMapEnd()
22354 return v, changed
22355}
22356
22357func (d *Decoder) fastpathDecMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
22358 if rv.Kind() == reflect.Ptr {
22359 vp := rv2i(rv).(*map[float64]uint8)
22360 v, changed := fastpathTV.DecMapFloat64Uint8V(*vp, true, d)
22361 if changed {
22362 *vp = v
22363 }
22364 } else {
22365 fastpathTV.DecMapFloat64Uint8V(rv2i(rv).(map[float64]uint8), false, d)
22366 }
22367}
22368func (f fastpathT) DecMapFloat64Uint8X(vp *map[float64]uint8, d *Decoder) {
22369 v, changed := f.DecMapFloat64Uint8V(*vp, true, d)
22370 if changed {
22371 *vp = v
22372 }
22373}
22374func (_ fastpathT) DecMapFloat64Uint8V(v map[float64]uint8, canChange bool,
22375 d *Decoder) (_ map[float64]uint8, changed bool) {
22376 dd, esep := d.d, d.hh.hasElemSeparators()
22377 containerLen := dd.ReadMapStart()
22378 if canChange && v == nil {
22379 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
22380 v = make(map[float64]uint8, xlen)
22381 changed = true
22382 }
22383 if containerLen == 0 {
22384 dd.ReadMapEnd()
22385 return v, changed
22386 }
22387 var mk float64
22388 var mv uint8
22389 hasLen := containerLen > 0
22390 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22391 if esep {
22392 dd.ReadMapElemKey()
22393 }
22394 mk = dd.DecodeFloat64()
22395 if esep {
22396 dd.ReadMapElemValue()
22397 }
22398 if dd.TryDecodeAsNil() {
22399 if v == nil {
22400 } else if d.h.DeleteOnNilMapValue {
22401 delete(v, mk)
22402 } else {
22403 v[mk] = 0
22404 }
22405 continue
22406 }
22407 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
22408 if v != nil {
22409 v[mk] = mv
22410 }
22411 }
22412 dd.ReadMapEnd()
22413 return v, changed
22414}
22415
22416func (d *Decoder) fastpathDecMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
22417 if rv.Kind() == reflect.Ptr {
22418 vp := rv2i(rv).(*map[float64]uint16)
22419 v, changed := fastpathTV.DecMapFloat64Uint16V(*vp, true, d)
22420 if changed {
22421 *vp = v
22422 }
22423 } else {
22424 fastpathTV.DecMapFloat64Uint16V(rv2i(rv).(map[float64]uint16), false, d)
22425 }
22426}
22427func (f fastpathT) DecMapFloat64Uint16X(vp *map[float64]uint16, d *Decoder) {
22428 v, changed := f.DecMapFloat64Uint16V(*vp, true, d)
22429 if changed {
22430 *vp = v
22431 }
22432}
22433func (_ fastpathT) DecMapFloat64Uint16V(v map[float64]uint16, canChange bool,
22434 d *Decoder) (_ map[float64]uint16, changed bool) {
22435 dd, esep := d.d, d.hh.hasElemSeparators()
22436 containerLen := dd.ReadMapStart()
22437 if canChange && v == nil {
22438 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
22439 v = make(map[float64]uint16, xlen)
22440 changed = true
22441 }
22442 if containerLen == 0 {
22443 dd.ReadMapEnd()
22444 return v, changed
22445 }
22446 var mk float64
22447 var mv uint16
22448 hasLen := containerLen > 0
22449 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22450 if esep {
22451 dd.ReadMapElemKey()
22452 }
22453 mk = dd.DecodeFloat64()
22454 if esep {
22455 dd.ReadMapElemValue()
22456 }
22457 if dd.TryDecodeAsNil() {
22458 if v == nil {
22459 } else if d.h.DeleteOnNilMapValue {
22460 delete(v, mk)
22461 } else {
22462 v[mk] = 0
22463 }
22464 continue
22465 }
22466 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
22467 if v != nil {
22468 v[mk] = mv
22469 }
22470 }
22471 dd.ReadMapEnd()
22472 return v, changed
22473}
22474
22475func (d *Decoder) fastpathDecMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
22476 if rv.Kind() == reflect.Ptr {
22477 vp := rv2i(rv).(*map[float64]uint32)
22478 v, changed := fastpathTV.DecMapFloat64Uint32V(*vp, true, d)
22479 if changed {
22480 *vp = v
22481 }
22482 } else {
22483 fastpathTV.DecMapFloat64Uint32V(rv2i(rv).(map[float64]uint32), false, d)
22484 }
22485}
22486func (f fastpathT) DecMapFloat64Uint32X(vp *map[float64]uint32, d *Decoder) {
22487 v, changed := f.DecMapFloat64Uint32V(*vp, true, d)
22488 if changed {
22489 *vp = v
22490 }
22491}
22492func (_ fastpathT) DecMapFloat64Uint32V(v map[float64]uint32, canChange bool,
22493 d *Decoder) (_ map[float64]uint32, changed bool) {
22494 dd, esep := d.d, d.hh.hasElemSeparators()
22495 containerLen := dd.ReadMapStart()
22496 if canChange && v == nil {
22497 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
22498 v = make(map[float64]uint32, xlen)
22499 changed = true
22500 }
22501 if containerLen == 0 {
22502 dd.ReadMapEnd()
22503 return v, changed
22504 }
22505 var mk float64
22506 var mv uint32
22507 hasLen := containerLen > 0
22508 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22509 if esep {
22510 dd.ReadMapElemKey()
22511 }
22512 mk = dd.DecodeFloat64()
22513 if esep {
22514 dd.ReadMapElemValue()
22515 }
22516 if dd.TryDecodeAsNil() {
22517 if v == nil {
22518 } else if d.h.DeleteOnNilMapValue {
22519 delete(v, mk)
22520 } else {
22521 v[mk] = 0
22522 }
22523 continue
22524 }
22525 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
22526 if v != nil {
22527 v[mk] = mv
22528 }
22529 }
22530 dd.ReadMapEnd()
22531 return v, changed
22532}
22533
22534func (d *Decoder) fastpathDecMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
22535 if rv.Kind() == reflect.Ptr {
22536 vp := rv2i(rv).(*map[float64]uint64)
22537 v, changed := fastpathTV.DecMapFloat64Uint64V(*vp, true, d)
22538 if changed {
22539 *vp = v
22540 }
22541 } else {
22542 fastpathTV.DecMapFloat64Uint64V(rv2i(rv).(map[float64]uint64), false, d)
22543 }
22544}
22545func (f fastpathT) DecMapFloat64Uint64X(vp *map[float64]uint64, d *Decoder) {
22546 v, changed := f.DecMapFloat64Uint64V(*vp, true, d)
22547 if changed {
22548 *vp = v
22549 }
22550}
22551func (_ fastpathT) DecMapFloat64Uint64V(v map[float64]uint64, canChange bool,
22552 d *Decoder) (_ map[float64]uint64, changed bool) {
22553 dd, esep := d.d, d.hh.hasElemSeparators()
22554 containerLen := dd.ReadMapStart()
22555 if canChange && v == nil {
22556 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22557 v = make(map[float64]uint64, xlen)
22558 changed = true
22559 }
22560 if containerLen == 0 {
22561 dd.ReadMapEnd()
22562 return v, changed
22563 }
22564 var mk float64
22565 var mv uint64
22566 hasLen := containerLen > 0
22567 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22568 if esep {
22569 dd.ReadMapElemKey()
22570 }
22571 mk = dd.DecodeFloat64()
22572 if esep {
22573 dd.ReadMapElemValue()
22574 }
22575 if dd.TryDecodeAsNil() {
22576 if v == nil {
22577 } else if d.h.DeleteOnNilMapValue {
22578 delete(v, mk)
22579 } else {
22580 v[mk] = 0
22581 }
22582 continue
22583 }
22584 mv = dd.DecodeUint64()
22585 if v != nil {
22586 v[mk] = mv
22587 }
22588 }
22589 dd.ReadMapEnd()
22590 return v, changed
22591}
22592
22593func (d *Decoder) fastpathDecMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
22594 if rv.Kind() == reflect.Ptr {
22595 vp := rv2i(rv).(*map[float64]uintptr)
22596 v, changed := fastpathTV.DecMapFloat64UintptrV(*vp, true, d)
22597 if changed {
22598 *vp = v
22599 }
22600 } else {
22601 fastpathTV.DecMapFloat64UintptrV(rv2i(rv).(map[float64]uintptr), false, d)
22602 }
22603}
22604func (f fastpathT) DecMapFloat64UintptrX(vp *map[float64]uintptr, d *Decoder) {
22605 v, changed := f.DecMapFloat64UintptrV(*vp, true, d)
22606 if changed {
22607 *vp = v
22608 }
22609}
22610func (_ fastpathT) DecMapFloat64UintptrV(v map[float64]uintptr, canChange bool,
22611 d *Decoder) (_ map[float64]uintptr, changed bool) {
22612 dd, esep := d.d, d.hh.hasElemSeparators()
22613 containerLen := dd.ReadMapStart()
22614 if canChange && v == nil {
22615 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22616 v = make(map[float64]uintptr, xlen)
22617 changed = true
22618 }
22619 if containerLen == 0 {
22620 dd.ReadMapEnd()
22621 return v, changed
22622 }
22623 var mk float64
22624 var mv uintptr
22625 hasLen := containerLen > 0
22626 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22627 if esep {
22628 dd.ReadMapElemKey()
22629 }
22630 mk = dd.DecodeFloat64()
22631 if esep {
22632 dd.ReadMapElemValue()
22633 }
22634 if dd.TryDecodeAsNil() {
22635 if v == nil {
22636 } else if d.h.DeleteOnNilMapValue {
22637 delete(v, mk)
22638 } else {
22639 v[mk] = 0
22640 }
22641 continue
22642 }
22643 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
22644 if v != nil {
22645 v[mk] = mv
22646 }
22647 }
22648 dd.ReadMapEnd()
22649 return v, changed
22650}
22651
22652func (d *Decoder) fastpathDecMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
22653 if rv.Kind() == reflect.Ptr {
22654 vp := rv2i(rv).(*map[float64]int)
22655 v, changed := fastpathTV.DecMapFloat64IntV(*vp, true, d)
22656 if changed {
22657 *vp = v
22658 }
22659 } else {
22660 fastpathTV.DecMapFloat64IntV(rv2i(rv).(map[float64]int), false, d)
22661 }
22662}
22663func (f fastpathT) DecMapFloat64IntX(vp *map[float64]int, d *Decoder) {
22664 v, changed := f.DecMapFloat64IntV(*vp, true, d)
22665 if changed {
22666 *vp = v
22667 }
22668}
22669func (_ fastpathT) DecMapFloat64IntV(v map[float64]int, canChange bool,
22670 d *Decoder) (_ map[float64]int, changed bool) {
22671 dd, esep := d.d, d.hh.hasElemSeparators()
22672 containerLen := dd.ReadMapStart()
22673 if canChange && v == nil {
22674 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22675 v = make(map[float64]int, xlen)
22676 changed = true
22677 }
22678 if containerLen == 0 {
22679 dd.ReadMapEnd()
22680 return v, changed
22681 }
22682 var mk float64
22683 var mv int
22684 hasLen := containerLen > 0
22685 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22686 if esep {
22687 dd.ReadMapElemKey()
22688 }
22689 mk = dd.DecodeFloat64()
22690 if esep {
22691 dd.ReadMapElemValue()
22692 }
22693 if dd.TryDecodeAsNil() {
22694 if v == nil {
22695 } else if d.h.DeleteOnNilMapValue {
22696 delete(v, mk)
22697 } else {
22698 v[mk] = 0
22699 }
22700 continue
22701 }
22702 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
22703 if v != nil {
22704 v[mk] = mv
22705 }
22706 }
22707 dd.ReadMapEnd()
22708 return v, changed
22709}
22710
22711func (d *Decoder) fastpathDecMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
22712 if rv.Kind() == reflect.Ptr {
22713 vp := rv2i(rv).(*map[float64]int8)
22714 v, changed := fastpathTV.DecMapFloat64Int8V(*vp, true, d)
22715 if changed {
22716 *vp = v
22717 }
22718 } else {
22719 fastpathTV.DecMapFloat64Int8V(rv2i(rv).(map[float64]int8), false, d)
22720 }
22721}
22722func (f fastpathT) DecMapFloat64Int8X(vp *map[float64]int8, d *Decoder) {
22723 v, changed := f.DecMapFloat64Int8V(*vp, true, d)
22724 if changed {
22725 *vp = v
22726 }
22727}
22728func (_ fastpathT) DecMapFloat64Int8V(v map[float64]int8, canChange bool,
22729 d *Decoder) (_ map[float64]int8, changed bool) {
22730 dd, esep := d.d, d.hh.hasElemSeparators()
22731 containerLen := dd.ReadMapStart()
22732 if canChange && v == nil {
22733 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
22734 v = make(map[float64]int8, xlen)
22735 changed = true
22736 }
22737 if containerLen == 0 {
22738 dd.ReadMapEnd()
22739 return v, changed
22740 }
22741 var mk float64
22742 var mv int8
22743 hasLen := containerLen > 0
22744 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22745 if esep {
22746 dd.ReadMapElemKey()
22747 }
22748 mk = dd.DecodeFloat64()
22749 if esep {
22750 dd.ReadMapElemValue()
22751 }
22752 if dd.TryDecodeAsNil() {
22753 if v == nil {
22754 } else if d.h.DeleteOnNilMapValue {
22755 delete(v, mk)
22756 } else {
22757 v[mk] = 0
22758 }
22759 continue
22760 }
22761 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
22762 if v != nil {
22763 v[mk] = mv
22764 }
22765 }
22766 dd.ReadMapEnd()
22767 return v, changed
22768}
22769
22770func (d *Decoder) fastpathDecMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
22771 if rv.Kind() == reflect.Ptr {
22772 vp := rv2i(rv).(*map[float64]int16)
22773 v, changed := fastpathTV.DecMapFloat64Int16V(*vp, true, d)
22774 if changed {
22775 *vp = v
22776 }
22777 } else {
22778 fastpathTV.DecMapFloat64Int16V(rv2i(rv).(map[float64]int16), false, d)
22779 }
22780}
22781func (f fastpathT) DecMapFloat64Int16X(vp *map[float64]int16, d *Decoder) {
22782 v, changed := f.DecMapFloat64Int16V(*vp, true, d)
22783 if changed {
22784 *vp = v
22785 }
22786}
22787func (_ fastpathT) DecMapFloat64Int16V(v map[float64]int16, canChange bool,
22788 d *Decoder) (_ map[float64]int16, changed bool) {
22789 dd, esep := d.d, d.hh.hasElemSeparators()
22790 containerLen := dd.ReadMapStart()
22791 if canChange && v == nil {
22792 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
22793 v = make(map[float64]int16, xlen)
22794 changed = true
22795 }
22796 if containerLen == 0 {
22797 dd.ReadMapEnd()
22798 return v, changed
22799 }
22800 var mk float64
22801 var mv int16
22802 hasLen := containerLen > 0
22803 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22804 if esep {
22805 dd.ReadMapElemKey()
22806 }
22807 mk = dd.DecodeFloat64()
22808 if esep {
22809 dd.ReadMapElemValue()
22810 }
22811 if dd.TryDecodeAsNil() {
22812 if v == nil {
22813 } else if d.h.DeleteOnNilMapValue {
22814 delete(v, mk)
22815 } else {
22816 v[mk] = 0
22817 }
22818 continue
22819 }
22820 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
22821 if v != nil {
22822 v[mk] = mv
22823 }
22824 }
22825 dd.ReadMapEnd()
22826 return v, changed
22827}
22828
22829func (d *Decoder) fastpathDecMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
22830 if rv.Kind() == reflect.Ptr {
22831 vp := rv2i(rv).(*map[float64]int32)
22832 v, changed := fastpathTV.DecMapFloat64Int32V(*vp, true, d)
22833 if changed {
22834 *vp = v
22835 }
22836 } else {
22837 fastpathTV.DecMapFloat64Int32V(rv2i(rv).(map[float64]int32), false, d)
22838 }
22839}
22840func (f fastpathT) DecMapFloat64Int32X(vp *map[float64]int32, d *Decoder) {
22841 v, changed := f.DecMapFloat64Int32V(*vp, true, d)
22842 if changed {
22843 *vp = v
22844 }
22845}
22846func (_ fastpathT) DecMapFloat64Int32V(v map[float64]int32, canChange bool,
22847 d *Decoder) (_ map[float64]int32, changed bool) {
22848 dd, esep := d.d, d.hh.hasElemSeparators()
22849 containerLen := dd.ReadMapStart()
22850 if canChange && v == nil {
22851 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
22852 v = make(map[float64]int32, xlen)
22853 changed = true
22854 }
22855 if containerLen == 0 {
22856 dd.ReadMapEnd()
22857 return v, changed
22858 }
22859 var mk float64
22860 var mv int32
22861 hasLen := containerLen > 0
22862 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22863 if esep {
22864 dd.ReadMapElemKey()
22865 }
22866 mk = dd.DecodeFloat64()
22867 if esep {
22868 dd.ReadMapElemValue()
22869 }
22870 if dd.TryDecodeAsNil() {
22871 if v == nil {
22872 } else if d.h.DeleteOnNilMapValue {
22873 delete(v, mk)
22874 } else {
22875 v[mk] = 0
22876 }
22877 continue
22878 }
22879 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
22880 if v != nil {
22881 v[mk] = mv
22882 }
22883 }
22884 dd.ReadMapEnd()
22885 return v, changed
22886}
22887
22888func (d *Decoder) fastpathDecMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
22889 if rv.Kind() == reflect.Ptr {
22890 vp := rv2i(rv).(*map[float64]int64)
22891 v, changed := fastpathTV.DecMapFloat64Int64V(*vp, true, d)
22892 if changed {
22893 *vp = v
22894 }
22895 } else {
22896 fastpathTV.DecMapFloat64Int64V(rv2i(rv).(map[float64]int64), false, d)
22897 }
22898}
22899func (f fastpathT) DecMapFloat64Int64X(vp *map[float64]int64, d *Decoder) {
22900 v, changed := f.DecMapFloat64Int64V(*vp, true, d)
22901 if changed {
22902 *vp = v
22903 }
22904}
22905func (_ fastpathT) DecMapFloat64Int64V(v map[float64]int64, canChange bool,
22906 d *Decoder) (_ map[float64]int64, changed bool) {
22907 dd, esep := d.d, d.hh.hasElemSeparators()
22908 containerLen := dd.ReadMapStart()
22909 if canChange && v == nil {
22910 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
22911 v = make(map[float64]int64, xlen)
22912 changed = true
22913 }
22914 if containerLen == 0 {
22915 dd.ReadMapEnd()
22916 return v, changed
22917 }
22918 var mk float64
22919 var mv int64
22920 hasLen := containerLen > 0
22921 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22922 if esep {
22923 dd.ReadMapElemKey()
22924 }
22925 mk = dd.DecodeFloat64()
22926 if esep {
22927 dd.ReadMapElemValue()
22928 }
22929 if dd.TryDecodeAsNil() {
22930 if v == nil {
22931 } else if d.h.DeleteOnNilMapValue {
22932 delete(v, mk)
22933 } else {
22934 v[mk] = 0
22935 }
22936 continue
22937 }
22938 mv = dd.DecodeInt64()
22939 if v != nil {
22940 v[mk] = mv
22941 }
22942 }
22943 dd.ReadMapEnd()
22944 return v, changed
22945}
22946
22947func (d *Decoder) fastpathDecMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
22948 if rv.Kind() == reflect.Ptr {
22949 vp := rv2i(rv).(*map[float64]float32)
22950 v, changed := fastpathTV.DecMapFloat64Float32V(*vp, true, d)
22951 if changed {
22952 *vp = v
22953 }
22954 } else {
22955 fastpathTV.DecMapFloat64Float32V(rv2i(rv).(map[float64]float32), false, d)
22956 }
22957}
22958func (f fastpathT) DecMapFloat64Float32X(vp *map[float64]float32, d *Decoder) {
22959 v, changed := f.DecMapFloat64Float32V(*vp, true, d)
22960 if changed {
22961 *vp = v
22962 }
22963}
22964func (_ fastpathT) DecMapFloat64Float32V(v map[float64]float32, canChange bool,
22965 d *Decoder) (_ map[float64]float32, changed bool) {
22966 dd, esep := d.d, d.hh.hasElemSeparators()
22967 containerLen := dd.ReadMapStart()
22968 if canChange && v == nil {
22969 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
22970 v = make(map[float64]float32, xlen)
22971 changed = true
22972 }
22973 if containerLen == 0 {
22974 dd.ReadMapEnd()
22975 return v, changed
22976 }
22977 var mk float64
22978 var mv float32
22979 hasLen := containerLen > 0
22980 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
22981 if esep {
22982 dd.ReadMapElemKey()
22983 }
22984 mk = dd.DecodeFloat64()
22985 if esep {
22986 dd.ReadMapElemValue()
22987 }
22988 if dd.TryDecodeAsNil() {
22989 if v == nil {
22990 } else if d.h.DeleteOnNilMapValue {
22991 delete(v, mk)
22992 } else {
22993 v[mk] = 0
22994 }
22995 continue
22996 }
22997 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
22998 if v != nil {
22999 v[mk] = mv
23000 }
23001 }
23002 dd.ReadMapEnd()
23003 return v, changed
23004}
23005
23006func (d *Decoder) fastpathDecMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
23007 if rv.Kind() == reflect.Ptr {
23008 vp := rv2i(rv).(*map[float64]float64)
23009 v, changed := fastpathTV.DecMapFloat64Float64V(*vp, true, d)
23010 if changed {
23011 *vp = v
23012 }
23013 } else {
23014 fastpathTV.DecMapFloat64Float64V(rv2i(rv).(map[float64]float64), false, d)
23015 }
23016}
23017func (f fastpathT) DecMapFloat64Float64X(vp *map[float64]float64, d *Decoder) {
23018 v, changed := f.DecMapFloat64Float64V(*vp, true, d)
23019 if changed {
23020 *vp = v
23021 }
23022}
23023func (_ fastpathT) DecMapFloat64Float64V(v map[float64]float64, canChange bool,
23024 d *Decoder) (_ map[float64]float64, changed bool) {
23025 dd, esep := d.d, d.hh.hasElemSeparators()
23026 containerLen := dd.ReadMapStart()
23027 if canChange && v == nil {
23028 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23029 v = make(map[float64]float64, xlen)
23030 changed = true
23031 }
23032 if containerLen == 0 {
23033 dd.ReadMapEnd()
23034 return v, changed
23035 }
23036 var mk float64
23037 var mv float64
23038 hasLen := containerLen > 0
23039 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23040 if esep {
23041 dd.ReadMapElemKey()
23042 }
23043 mk = dd.DecodeFloat64()
23044 if esep {
23045 dd.ReadMapElemValue()
23046 }
23047 if dd.TryDecodeAsNil() {
23048 if v == nil {
23049 } else if d.h.DeleteOnNilMapValue {
23050 delete(v, mk)
23051 } else {
23052 v[mk] = 0
23053 }
23054 continue
23055 }
23056 mv = dd.DecodeFloat64()
23057 if v != nil {
23058 v[mk] = mv
23059 }
23060 }
23061 dd.ReadMapEnd()
23062 return v, changed
23063}
23064
23065func (d *Decoder) fastpathDecMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
23066 if rv.Kind() == reflect.Ptr {
23067 vp := rv2i(rv).(*map[float64]bool)
23068 v, changed := fastpathTV.DecMapFloat64BoolV(*vp, true, d)
23069 if changed {
23070 *vp = v
23071 }
23072 } else {
23073 fastpathTV.DecMapFloat64BoolV(rv2i(rv).(map[float64]bool), false, d)
23074 }
23075}
23076func (f fastpathT) DecMapFloat64BoolX(vp *map[float64]bool, d *Decoder) {
23077 v, changed := f.DecMapFloat64BoolV(*vp, true, d)
23078 if changed {
23079 *vp = v
23080 }
23081}
23082func (_ fastpathT) DecMapFloat64BoolV(v map[float64]bool, canChange bool,
23083 d *Decoder) (_ map[float64]bool, changed bool) {
23084 dd, esep := d.d, d.hh.hasElemSeparators()
23085 containerLen := dd.ReadMapStart()
23086 if canChange && v == nil {
23087 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
23088 v = make(map[float64]bool, xlen)
23089 changed = true
23090 }
23091 if containerLen == 0 {
23092 dd.ReadMapEnd()
23093 return v, changed
23094 }
23095 var mk float64
23096 var mv bool
23097 hasLen := containerLen > 0
23098 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23099 if esep {
23100 dd.ReadMapElemKey()
23101 }
23102 mk = dd.DecodeFloat64()
23103 if esep {
23104 dd.ReadMapElemValue()
23105 }
23106 if dd.TryDecodeAsNil() {
23107 if v == nil {
23108 } else if d.h.DeleteOnNilMapValue {
23109 delete(v, mk)
23110 } else {
23111 v[mk] = false
23112 }
23113 continue
23114 }
23115 mv = dd.DecodeBool()
23116 if v != nil {
23117 v[mk] = mv
23118 }
23119 }
23120 dd.ReadMapEnd()
23121 return v, changed
23122}
23123
23124func (d *Decoder) fastpathDecMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
23125 if rv.Kind() == reflect.Ptr {
23126 vp := rv2i(rv).(*map[uint]interface{})
23127 v, changed := fastpathTV.DecMapUintIntfV(*vp, true, d)
23128 if changed {
23129 *vp = v
23130 }
23131 } else {
23132 fastpathTV.DecMapUintIntfV(rv2i(rv).(map[uint]interface{}), false, d)
23133 }
23134}
23135func (f fastpathT) DecMapUintIntfX(vp *map[uint]interface{}, d *Decoder) {
23136 v, changed := f.DecMapUintIntfV(*vp, true, d)
23137 if changed {
23138 *vp = v
23139 }
23140}
23141func (_ fastpathT) DecMapUintIntfV(v map[uint]interface{}, canChange bool,
23142 d *Decoder) (_ map[uint]interface{}, changed bool) {
23143 dd, esep := d.d, d.hh.hasElemSeparators()
23144 containerLen := dd.ReadMapStart()
23145 if canChange && v == nil {
23146 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
23147 v = make(map[uint]interface{}, xlen)
23148 changed = true
23149 }
23150 if containerLen == 0 {
23151 dd.ReadMapEnd()
23152 return v, changed
23153 }
23154 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
23155 var mk uint
23156 var mv interface{}
23157 hasLen := containerLen > 0
23158 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23159 if esep {
23160 dd.ReadMapElemKey()
23161 }
23162 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23163 if esep {
23164 dd.ReadMapElemValue()
23165 }
23166 if dd.TryDecodeAsNil() {
23167 if v == nil {
23168 } else if d.h.DeleteOnNilMapValue {
23169 delete(v, mk)
23170 } else {
23171 v[mk] = nil
23172 }
23173 continue
23174 }
23175 if mapGet {
23176 mv = v[mk]
23177 } else {
23178 mv = nil
23179 }
23180 d.decode(&mv)
23181 if v != nil {
23182 v[mk] = mv
23183 }
23184 }
23185 dd.ReadMapEnd()
23186 return v, changed
23187}
23188
23189func (d *Decoder) fastpathDecMapUintStringR(f *codecFnInfo, rv reflect.Value) {
23190 if rv.Kind() == reflect.Ptr {
23191 vp := rv2i(rv).(*map[uint]string)
23192 v, changed := fastpathTV.DecMapUintStringV(*vp, true, d)
23193 if changed {
23194 *vp = v
23195 }
23196 } else {
23197 fastpathTV.DecMapUintStringV(rv2i(rv).(map[uint]string), false, d)
23198 }
23199}
23200func (f fastpathT) DecMapUintStringX(vp *map[uint]string, d *Decoder) {
23201 v, changed := f.DecMapUintStringV(*vp, true, d)
23202 if changed {
23203 *vp = v
23204 }
23205}
23206func (_ fastpathT) DecMapUintStringV(v map[uint]string, canChange bool,
23207 d *Decoder) (_ map[uint]string, changed bool) {
23208 dd, esep := d.d, d.hh.hasElemSeparators()
23209 containerLen := dd.ReadMapStart()
23210 if canChange && v == nil {
23211 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
23212 v = make(map[uint]string, xlen)
23213 changed = true
23214 }
23215 if containerLen == 0 {
23216 dd.ReadMapEnd()
23217 return v, changed
23218 }
23219 var mk uint
23220 var mv string
23221 hasLen := containerLen > 0
23222 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23223 if esep {
23224 dd.ReadMapElemKey()
23225 }
23226 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23227 if esep {
23228 dd.ReadMapElemValue()
23229 }
23230 if dd.TryDecodeAsNil() {
23231 if v == nil {
23232 } else if d.h.DeleteOnNilMapValue {
23233 delete(v, mk)
23234 } else {
23235 v[mk] = ""
23236 }
23237 continue
23238 }
23239 mv = dd.DecodeString()
23240 if v != nil {
23241 v[mk] = mv
23242 }
23243 }
23244 dd.ReadMapEnd()
23245 return v, changed
23246}
23247
23248func (d *Decoder) fastpathDecMapUintUintR(f *codecFnInfo, rv reflect.Value) {
23249 if rv.Kind() == reflect.Ptr {
23250 vp := rv2i(rv).(*map[uint]uint)
23251 v, changed := fastpathTV.DecMapUintUintV(*vp, true, d)
23252 if changed {
23253 *vp = v
23254 }
23255 } else {
23256 fastpathTV.DecMapUintUintV(rv2i(rv).(map[uint]uint), false, d)
23257 }
23258}
23259func (f fastpathT) DecMapUintUintX(vp *map[uint]uint, d *Decoder) {
23260 v, changed := f.DecMapUintUintV(*vp, true, d)
23261 if changed {
23262 *vp = v
23263 }
23264}
23265func (_ fastpathT) DecMapUintUintV(v map[uint]uint, canChange bool,
23266 d *Decoder) (_ map[uint]uint, changed bool) {
23267 dd, esep := d.d, d.hh.hasElemSeparators()
23268 containerLen := dd.ReadMapStart()
23269 if canChange && v == nil {
23270 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23271 v = make(map[uint]uint, xlen)
23272 changed = true
23273 }
23274 if containerLen == 0 {
23275 dd.ReadMapEnd()
23276 return v, changed
23277 }
23278 var mk uint
23279 var mv uint
23280 hasLen := containerLen > 0
23281 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23282 if esep {
23283 dd.ReadMapElemKey()
23284 }
23285 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23286 if esep {
23287 dd.ReadMapElemValue()
23288 }
23289 if dd.TryDecodeAsNil() {
23290 if v == nil {
23291 } else if d.h.DeleteOnNilMapValue {
23292 delete(v, mk)
23293 } else {
23294 v[mk] = 0
23295 }
23296 continue
23297 }
23298 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23299 if v != nil {
23300 v[mk] = mv
23301 }
23302 }
23303 dd.ReadMapEnd()
23304 return v, changed
23305}
23306
23307func (d *Decoder) fastpathDecMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
23308 if rv.Kind() == reflect.Ptr {
23309 vp := rv2i(rv).(*map[uint]uint8)
23310 v, changed := fastpathTV.DecMapUintUint8V(*vp, true, d)
23311 if changed {
23312 *vp = v
23313 }
23314 } else {
23315 fastpathTV.DecMapUintUint8V(rv2i(rv).(map[uint]uint8), false, d)
23316 }
23317}
23318func (f fastpathT) DecMapUintUint8X(vp *map[uint]uint8, d *Decoder) {
23319 v, changed := f.DecMapUintUint8V(*vp, true, d)
23320 if changed {
23321 *vp = v
23322 }
23323}
23324func (_ fastpathT) DecMapUintUint8V(v map[uint]uint8, canChange bool,
23325 d *Decoder) (_ map[uint]uint8, changed bool) {
23326 dd, esep := d.d, d.hh.hasElemSeparators()
23327 containerLen := dd.ReadMapStart()
23328 if canChange && v == nil {
23329 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
23330 v = make(map[uint]uint8, xlen)
23331 changed = true
23332 }
23333 if containerLen == 0 {
23334 dd.ReadMapEnd()
23335 return v, changed
23336 }
23337 var mk uint
23338 var mv uint8
23339 hasLen := containerLen > 0
23340 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23341 if esep {
23342 dd.ReadMapElemKey()
23343 }
23344 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23345 if esep {
23346 dd.ReadMapElemValue()
23347 }
23348 if dd.TryDecodeAsNil() {
23349 if v == nil {
23350 } else if d.h.DeleteOnNilMapValue {
23351 delete(v, mk)
23352 } else {
23353 v[mk] = 0
23354 }
23355 continue
23356 }
23357 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
23358 if v != nil {
23359 v[mk] = mv
23360 }
23361 }
23362 dd.ReadMapEnd()
23363 return v, changed
23364}
23365
23366func (d *Decoder) fastpathDecMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
23367 if rv.Kind() == reflect.Ptr {
23368 vp := rv2i(rv).(*map[uint]uint16)
23369 v, changed := fastpathTV.DecMapUintUint16V(*vp, true, d)
23370 if changed {
23371 *vp = v
23372 }
23373 } else {
23374 fastpathTV.DecMapUintUint16V(rv2i(rv).(map[uint]uint16), false, d)
23375 }
23376}
23377func (f fastpathT) DecMapUintUint16X(vp *map[uint]uint16, d *Decoder) {
23378 v, changed := f.DecMapUintUint16V(*vp, true, d)
23379 if changed {
23380 *vp = v
23381 }
23382}
23383func (_ fastpathT) DecMapUintUint16V(v map[uint]uint16, canChange bool,
23384 d *Decoder) (_ map[uint]uint16, changed bool) {
23385 dd, esep := d.d, d.hh.hasElemSeparators()
23386 containerLen := dd.ReadMapStart()
23387 if canChange && v == nil {
23388 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
23389 v = make(map[uint]uint16, xlen)
23390 changed = true
23391 }
23392 if containerLen == 0 {
23393 dd.ReadMapEnd()
23394 return v, changed
23395 }
23396 var mk uint
23397 var mv uint16
23398 hasLen := containerLen > 0
23399 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23400 if esep {
23401 dd.ReadMapElemKey()
23402 }
23403 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23404 if esep {
23405 dd.ReadMapElemValue()
23406 }
23407 if dd.TryDecodeAsNil() {
23408 if v == nil {
23409 } else if d.h.DeleteOnNilMapValue {
23410 delete(v, mk)
23411 } else {
23412 v[mk] = 0
23413 }
23414 continue
23415 }
23416 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
23417 if v != nil {
23418 v[mk] = mv
23419 }
23420 }
23421 dd.ReadMapEnd()
23422 return v, changed
23423}
23424
23425func (d *Decoder) fastpathDecMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
23426 if rv.Kind() == reflect.Ptr {
23427 vp := rv2i(rv).(*map[uint]uint32)
23428 v, changed := fastpathTV.DecMapUintUint32V(*vp, true, d)
23429 if changed {
23430 *vp = v
23431 }
23432 } else {
23433 fastpathTV.DecMapUintUint32V(rv2i(rv).(map[uint]uint32), false, d)
23434 }
23435}
23436func (f fastpathT) DecMapUintUint32X(vp *map[uint]uint32, d *Decoder) {
23437 v, changed := f.DecMapUintUint32V(*vp, true, d)
23438 if changed {
23439 *vp = v
23440 }
23441}
23442func (_ fastpathT) DecMapUintUint32V(v map[uint]uint32, canChange bool,
23443 d *Decoder) (_ map[uint]uint32, changed bool) {
23444 dd, esep := d.d, d.hh.hasElemSeparators()
23445 containerLen := dd.ReadMapStart()
23446 if canChange && v == nil {
23447 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23448 v = make(map[uint]uint32, xlen)
23449 changed = true
23450 }
23451 if containerLen == 0 {
23452 dd.ReadMapEnd()
23453 return v, changed
23454 }
23455 var mk uint
23456 var mv uint32
23457 hasLen := containerLen > 0
23458 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23459 if esep {
23460 dd.ReadMapElemKey()
23461 }
23462 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23463 if esep {
23464 dd.ReadMapElemValue()
23465 }
23466 if dd.TryDecodeAsNil() {
23467 if v == nil {
23468 } else if d.h.DeleteOnNilMapValue {
23469 delete(v, mk)
23470 } else {
23471 v[mk] = 0
23472 }
23473 continue
23474 }
23475 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
23476 if v != nil {
23477 v[mk] = mv
23478 }
23479 }
23480 dd.ReadMapEnd()
23481 return v, changed
23482}
23483
23484func (d *Decoder) fastpathDecMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
23485 if rv.Kind() == reflect.Ptr {
23486 vp := rv2i(rv).(*map[uint]uint64)
23487 v, changed := fastpathTV.DecMapUintUint64V(*vp, true, d)
23488 if changed {
23489 *vp = v
23490 }
23491 } else {
23492 fastpathTV.DecMapUintUint64V(rv2i(rv).(map[uint]uint64), false, d)
23493 }
23494}
23495func (f fastpathT) DecMapUintUint64X(vp *map[uint]uint64, d *Decoder) {
23496 v, changed := f.DecMapUintUint64V(*vp, true, d)
23497 if changed {
23498 *vp = v
23499 }
23500}
23501func (_ fastpathT) DecMapUintUint64V(v map[uint]uint64, canChange bool,
23502 d *Decoder) (_ map[uint]uint64, changed bool) {
23503 dd, esep := d.d, d.hh.hasElemSeparators()
23504 containerLen := dd.ReadMapStart()
23505 if canChange && v == nil {
23506 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23507 v = make(map[uint]uint64, xlen)
23508 changed = true
23509 }
23510 if containerLen == 0 {
23511 dd.ReadMapEnd()
23512 return v, changed
23513 }
23514 var mk uint
23515 var mv uint64
23516 hasLen := containerLen > 0
23517 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23518 if esep {
23519 dd.ReadMapElemKey()
23520 }
23521 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23522 if esep {
23523 dd.ReadMapElemValue()
23524 }
23525 if dd.TryDecodeAsNil() {
23526 if v == nil {
23527 } else if d.h.DeleteOnNilMapValue {
23528 delete(v, mk)
23529 } else {
23530 v[mk] = 0
23531 }
23532 continue
23533 }
23534 mv = dd.DecodeUint64()
23535 if v != nil {
23536 v[mk] = mv
23537 }
23538 }
23539 dd.ReadMapEnd()
23540 return v, changed
23541}
23542
23543func (d *Decoder) fastpathDecMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
23544 if rv.Kind() == reflect.Ptr {
23545 vp := rv2i(rv).(*map[uint]uintptr)
23546 v, changed := fastpathTV.DecMapUintUintptrV(*vp, true, d)
23547 if changed {
23548 *vp = v
23549 }
23550 } else {
23551 fastpathTV.DecMapUintUintptrV(rv2i(rv).(map[uint]uintptr), false, d)
23552 }
23553}
23554func (f fastpathT) DecMapUintUintptrX(vp *map[uint]uintptr, d *Decoder) {
23555 v, changed := f.DecMapUintUintptrV(*vp, true, d)
23556 if changed {
23557 *vp = v
23558 }
23559}
23560func (_ fastpathT) DecMapUintUintptrV(v map[uint]uintptr, canChange bool,
23561 d *Decoder) (_ map[uint]uintptr, changed bool) {
23562 dd, esep := d.d, d.hh.hasElemSeparators()
23563 containerLen := dd.ReadMapStart()
23564 if canChange && v == nil {
23565 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23566 v = make(map[uint]uintptr, xlen)
23567 changed = true
23568 }
23569 if containerLen == 0 {
23570 dd.ReadMapEnd()
23571 return v, changed
23572 }
23573 var mk uint
23574 var mv uintptr
23575 hasLen := containerLen > 0
23576 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23577 if esep {
23578 dd.ReadMapElemKey()
23579 }
23580 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23581 if esep {
23582 dd.ReadMapElemValue()
23583 }
23584 if dd.TryDecodeAsNil() {
23585 if v == nil {
23586 } else if d.h.DeleteOnNilMapValue {
23587 delete(v, mk)
23588 } else {
23589 v[mk] = 0
23590 }
23591 continue
23592 }
23593 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23594 if v != nil {
23595 v[mk] = mv
23596 }
23597 }
23598 dd.ReadMapEnd()
23599 return v, changed
23600}
23601
23602func (d *Decoder) fastpathDecMapUintIntR(f *codecFnInfo, rv reflect.Value) {
23603 if rv.Kind() == reflect.Ptr {
23604 vp := rv2i(rv).(*map[uint]int)
23605 v, changed := fastpathTV.DecMapUintIntV(*vp, true, d)
23606 if changed {
23607 *vp = v
23608 }
23609 } else {
23610 fastpathTV.DecMapUintIntV(rv2i(rv).(map[uint]int), false, d)
23611 }
23612}
23613func (f fastpathT) DecMapUintIntX(vp *map[uint]int, d *Decoder) {
23614 v, changed := f.DecMapUintIntV(*vp, true, d)
23615 if changed {
23616 *vp = v
23617 }
23618}
23619func (_ fastpathT) DecMapUintIntV(v map[uint]int, canChange bool,
23620 d *Decoder) (_ map[uint]int, changed bool) {
23621 dd, esep := d.d, d.hh.hasElemSeparators()
23622 containerLen := dd.ReadMapStart()
23623 if canChange && v == nil {
23624 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23625 v = make(map[uint]int, xlen)
23626 changed = true
23627 }
23628 if containerLen == 0 {
23629 dd.ReadMapEnd()
23630 return v, changed
23631 }
23632 var mk uint
23633 var mv int
23634 hasLen := containerLen > 0
23635 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23636 if esep {
23637 dd.ReadMapElemKey()
23638 }
23639 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23640 if esep {
23641 dd.ReadMapElemValue()
23642 }
23643 if dd.TryDecodeAsNil() {
23644 if v == nil {
23645 } else if d.h.DeleteOnNilMapValue {
23646 delete(v, mk)
23647 } else {
23648 v[mk] = 0
23649 }
23650 continue
23651 }
23652 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
23653 if v != nil {
23654 v[mk] = mv
23655 }
23656 }
23657 dd.ReadMapEnd()
23658 return v, changed
23659}
23660
23661func (d *Decoder) fastpathDecMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
23662 if rv.Kind() == reflect.Ptr {
23663 vp := rv2i(rv).(*map[uint]int8)
23664 v, changed := fastpathTV.DecMapUintInt8V(*vp, true, d)
23665 if changed {
23666 *vp = v
23667 }
23668 } else {
23669 fastpathTV.DecMapUintInt8V(rv2i(rv).(map[uint]int8), false, d)
23670 }
23671}
23672func (f fastpathT) DecMapUintInt8X(vp *map[uint]int8, d *Decoder) {
23673 v, changed := f.DecMapUintInt8V(*vp, true, d)
23674 if changed {
23675 *vp = v
23676 }
23677}
23678func (_ fastpathT) DecMapUintInt8V(v map[uint]int8, canChange bool,
23679 d *Decoder) (_ map[uint]int8, changed bool) {
23680 dd, esep := d.d, d.hh.hasElemSeparators()
23681 containerLen := dd.ReadMapStart()
23682 if canChange && v == nil {
23683 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
23684 v = make(map[uint]int8, xlen)
23685 changed = true
23686 }
23687 if containerLen == 0 {
23688 dd.ReadMapEnd()
23689 return v, changed
23690 }
23691 var mk uint
23692 var mv int8
23693 hasLen := containerLen > 0
23694 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23695 if esep {
23696 dd.ReadMapElemKey()
23697 }
23698 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23699 if esep {
23700 dd.ReadMapElemValue()
23701 }
23702 if dd.TryDecodeAsNil() {
23703 if v == nil {
23704 } else if d.h.DeleteOnNilMapValue {
23705 delete(v, mk)
23706 } else {
23707 v[mk] = 0
23708 }
23709 continue
23710 }
23711 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
23712 if v != nil {
23713 v[mk] = mv
23714 }
23715 }
23716 dd.ReadMapEnd()
23717 return v, changed
23718}
23719
23720func (d *Decoder) fastpathDecMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
23721 if rv.Kind() == reflect.Ptr {
23722 vp := rv2i(rv).(*map[uint]int16)
23723 v, changed := fastpathTV.DecMapUintInt16V(*vp, true, d)
23724 if changed {
23725 *vp = v
23726 }
23727 } else {
23728 fastpathTV.DecMapUintInt16V(rv2i(rv).(map[uint]int16), false, d)
23729 }
23730}
23731func (f fastpathT) DecMapUintInt16X(vp *map[uint]int16, d *Decoder) {
23732 v, changed := f.DecMapUintInt16V(*vp, true, d)
23733 if changed {
23734 *vp = v
23735 }
23736}
23737func (_ fastpathT) DecMapUintInt16V(v map[uint]int16, canChange bool,
23738 d *Decoder) (_ map[uint]int16, changed bool) {
23739 dd, esep := d.d, d.hh.hasElemSeparators()
23740 containerLen := dd.ReadMapStart()
23741 if canChange && v == nil {
23742 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
23743 v = make(map[uint]int16, xlen)
23744 changed = true
23745 }
23746 if containerLen == 0 {
23747 dd.ReadMapEnd()
23748 return v, changed
23749 }
23750 var mk uint
23751 var mv int16
23752 hasLen := containerLen > 0
23753 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23754 if esep {
23755 dd.ReadMapElemKey()
23756 }
23757 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23758 if esep {
23759 dd.ReadMapElemValue()
23760 }
23761 if dd.TryDecodeAsNil() {
23762 if v == nil {
23763 } else if d.h.DeleteOnNilMapValue {
23764 delete(v, mk)
23765 } else {
23766 v[mk] = 0
23767 }
23768 continue
23769 }
23770 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
23771 if v != nil {
23772 v[mk] = mv
23773 }
23774 }
23775 dd.ReadMapEnd()
23776 return v, changed
23777}
23778
23779func (d *Decoder) fastpathDecMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
23780 if rv.Kind() == reflect.Ptr {
23781 vp := rv2i(rv).(*map[uint]int32)
23782 v, changed := fastpathTV.DecMapUintInt32V(*vp, true, d)
23783 if changed {
23784 *vp = v
23785 }
23786 } else {
23787 fastpathTV.DecMapUintInt32V(rv2i(rv).(map[uint]int32), false, d)
23788 }
23789}
23790func (f fastpathT) DecMapUintInt32X(vp *map[uint]int32, d *Decoder) {
23791 v, changed := f.DecMapUintInt32V(*vp, true, d)
23792 if changed {
23793 *vp = v
23794 }
23795}
23796func (_ fastpathT) DecMapUintInt32V(v map[uint]int32, canChange bool,
23797 d *Decoder) (_ map[uint]int32, changed bool) {
23798 dd, esep := d.d, d.hh.hasElemSeparators()
23799 containerLen := dd.ReadMapStart()
23800 if canChange && v == nil {
23801 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23802 v = make(map[uint]int32, xlen)
23803 changed = true
23804 }
23805 if containerLen == 0 {
23806 dd.ReadMapEnd()
23807 return v, changed
23808 }
23809 var mk uint
23810 var mv int32
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 = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
23830 if v != nil {
23831 v[mk] = mv
23832 }
23833 }
23834 dd.ReadMapEnd()
23835 return v, changed
23836}
23837
23838func (d *Decoder) fastpathDecMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
23839 if rv.Kind() == reflect.Ptr {
23840 vp := rv2i(rv).(*map[uint]int64)
23841 v, changed := fastpathTV.DecMapUintInt64V(*vp, true, d)
23842 if changed {
23843 *vp = v
23844 }
23845 } else {
23846 fastpathTV.DecMapUintInt64V(rv2i(rv).(map[uint]int64), false, d)
23847 }
23848}
23849func (f fastpathT) DecMapUintInt64X(vp *map[uint]int64, d *Decoder) {
23850 v, changed := f.DecMapUintInt64V(*vp, true, d)
23851 if changed {
23852 *vp = v
23853 }
23854}
23855func (_ fastpathT) DecMapUintInt64V(v map[uint]int64, canChange bool,
23856 d *Decoder) (_ map[uint]int64, changed bool) {
23857 dd, esep := d.d, d.hh.hasElemSeparators()
23858 containerLen := dd.ReadMapStart()
23859 if canChange && v == nil {
23860 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23861 v = make(map[uint]int64, xlen)
23862 changed = true
23863 }
23864 if containerLen == 0 {
23865 dd.ReadMapEnd()
23866 return v, changed
23867 }
23868 var mk uint
23869 var mv int64
23870 hasLen := containerLen > 0
23871 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23872 if esep {
23873 dd.ReadMapElemKey()
23874 }
23875 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23876 if esep {
23877 dd.ReadMapElemValue()
23878 }
23879 if dd.TryDecodeAsNil() {
23880 if v == nil {
23881 } else if d.h.DeleteOnNilMapValue {
23882 delete(v, mk)
23883 } else {
23884 v[mk] = 0
23885 }
23886 continue
23887 }
23888 mv = dd.DecodeInt64()
23889 if v != nil {
23890 v[mk] = mv
23891 }
23892 }
23893 dd.ReadMapEnd()
23894 return v, changed
23895}
23896
23897func (d *Decoder) fastpathDecMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
23898 if rv.Kind() == reflect.Ptr {
23899 vp := rv2i(rv).(*map[uint]float32)
23900 v, changed := fastpathTV.DecMapUintFloat32V(*vp, true, d)
23901 if changed {
23902 *vp = v
23903 }
23904 } else {
23905 fastpathTV.DecMapUintFloat32V(rv2i(rv).(map[uint]float32), false, d)
23906 }
23907}
23908func (f fastpathT) DecMapUintFloat32X(vp *map[uint]float32, d *Decoder) {
23909 v, changed := f.DecMapUintFloat32V(*vp, true, d)
23910 if changed {
23911 *vp = v
23912 }
23913}
23914func (_ fastpathT) DecMapUintFloat32V(v map[uint]float32, canChange bool,
23915 d *Decoder) (_ map[uint]float32, changed bool) {
23916 dd, esep := d.d, d.hh.hasElemSeparators()
23917 containerLen := dd.ReadMapStart()
23918 if canChange && v == nil {
23919 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
23920 v = make(map[uint]float32, xlen)
23921 changed = true
23922 }
23923 if containerLen == 0 {
23924 dd.ReadMapEnd()
23925 return v, changed
23926 }
23927 var mk uint
23928 var mv float32
23929 hasLen := containerLen > 0
23930 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23931 if esep {
23932 dd.ReadMapElemKey()
23933 }
23934 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23935 if esep {
23936 dd.ReadMapElemValue()
23937 }
23938 if dd.TryDecodeAsNil() {
23939 if v == nil {
23940 } else if d.h.DeleteOnNilMapValue {
23941 delete(v, mk)
23942 } else {
23943 v[mk] = 0
23944 }
23945 continue
23946 }
23947 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
23948 if v != nil {
23949 v[mk] = mv
23950 }
23951 }
23952 dd.ReadMapEnd()
23953 return v, changed
23954}
23955
23956func (d *Decoder) fastpathDecMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
23957 if rv.Kind() == reflect.Ptr {
23958 vp := rv2i(rv).(*map[uint]float64)
23959 v, changed := fastpathTV.DecMapUintFloat64V(*vp, true, d)
23960 if changed {
23961 *vp = v
23962 }
23963 } else {
23964 fastpathTV.DecMapUintFloat64V(rv2i(rv).(map[uint]float64), false, d)
23965 }
23966}
23967func (f fastpathT) DecMapUintFloat64X(vp *map[uint]float64, d *Decoder) {
23968 v, changed := f.DecMapUintFloat64V(*vp, true, d)
23969 if changed {
23970 *vp = v
23971 }
23972}
23973func (_ fastpathT) DecMapUintFloat64V(v map[uint]float64, canChange bool,
23974 d *Decoder) (_ map[uint]float64, changed bool) {
23975 dd, esep := d.d, d.hh.hasElemSeparators()
23976 containerLen := dd.ReadMapStart()
23977 if canChange && v == nil {
23978 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
23979 v = make(map[uint]float64, xlen)
23980 changed = true
23981 }
23982 if containerLen == 0 {
23983 dd.ReadMapEnd()
23984 return v, changed
23985 }
23986 var mk uint
23987 var mv float64
23988 hasLen := containerLen > 0
23989 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
23990 if esep {
23991 dd.ReadMapElemKey()
23992 }
23993 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
23994 if esep {
23995 dd.ReadMapElemValue()
23996 }
23997 if dd.TryDecodeAsNil() {
23998 if v == nil {
23999 } else if d.h.DeleteOnNilMapValue {
24000 delete(v, mk)
24001 } else {
24002 v[mk] = 0
24003 }
24004 continue
24005 }
24006 mv = dd.DecodeFloat64()
24007 if v != nil {
24008 v[mk] = mv
24009 }
24010 }
24011 dd.ReadMapEnd()
24012 return v, changed
24013}
24014
24015func (d *Decoder) fastpathDecMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
24016 if rv.Kind() == reflect.Ptr {
24017 vp := rv2i(rv).(*map[uint]bool)
24018 v, changed := fastpathTV.DecMapUintBoolV(*vp, true, d)
24019 if changed {
24020 *vp = v
24021 }
24022 } else {
24023 fastpathTV.DecMapUintBoolV(rv2i(rv).(map[uint]bool), false, d)
24024 }
24025}
24026func (f fastpathT) DecMapUintBoolX(vp *map[uint]bool, d *Decoder) {
24027 v, changed := f.DecMapUintBoolV(*vp, true, d)
24028 if changed {
24029 *vp = v
24030 }
24031}
24032func (_ fastpathT) DecMapUintBoolV(v map[uint]bool, canChange bool,
24033 d *Decoder) (_ map[uint]bool, changed bool) {
24034 dd, esep := d.d, d.hh.hasElemSeparators()
24035 containerLen := dd.ReadMapStart()
24036 if canChange && v == nil {
24037 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24038 v = make(map[uint]bool, xlen)
24039 changed = true
24040 }
24041 if containerLen == 0 {
24042 dd.ReadMapEnd()
24043 return v, changed
24044 }
24045 var mk uint
24046 var mv bool
24047 hasLen := containerLen > 0
24048 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24049 if esep {
24050 dd.ReadMapElemKey()
24051 }
24052 mk = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24053 if esep {
24054 dd.ReadMapElemValue()
24055 }
24056 if dd.TryDecodeAsNil() {
24057 if v == nil {
24058 } else if d.h.DeleteOnNilMapValue {
24059 delete(v, mk)
24060 } else {
24061 v[mk] = false
24062 }
24063 continue
24064 }
24065 mv = dd.DecodeBool()
24066 if v != nil {
24067 v[mk] = mv
24068 }
24069 }
24070 dd.ReadMapEnd()
24071 return v, changed
24072}
24073
24074func (d *Decoder) fastpathDecMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
24075 if rv.Kind() == reflect.Ptr {
24076 vp := rv2i(rv).(*map[uint8]interface{})
24077 v, changed := fastpathTV.DecMapUint8IntfV(*vp, true, d)
24078 if changed {
24079 *vp = v
24080 }
24081 } else {
24082 fastpathTV.DecMapUint8IntfV(rv2i(rv).(map[uint8]interface{}), false, d)
24083 }
24084}
24085func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, d *Decoder) {
24086 v, changed := f.DecMapUint8IntfV(*vp, true, d)
24087 if changed {
24088 *vp = v
24089 }
24090}
24091func (_ fastpathT) DecMapUint8IntfV(v map[uint8]interface{}, canChange bool,
24092 d *Decoder) (_ map[uint8]interface{}, changed bool) {
24093 dd, esep := d.d, d.hh.hasElemSeparators()
24094 containerLen := dd.ReadMapStart()
24095 if canChange && v == nil {
24096 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
24097 v = make(map[uint8]interface{}, xlen)
24098 changed = true
24099 }
24100 if containerLen == 0 {
24101 dd.ReadMapEnd()
24102 return v, changed
24103 }
24104 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
24105 var mk uint8
24106 var mv interface{}
24107 hasLen := containerLen > 0
24108 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24109 if esep {
24110 dd.ReadMapElemKey()
24111 }
24112 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24113 if esep {
24114 dd.ReadMapElemValue()
24115 }
24116 if dd.TryDecodeAsNil() {
24117 if v == nil {
24118 } else if d.h.DeleteOnNilMapValue {
24119 delete(v, mk)
24120 } else {
24121 v[mk] = nil
24122 }
24123 continue
24124 }
24125 if mapGet {
24126 mv = v[mk]
24127 } else {
24128 mv = nil
24129 }
24130 d.decode(&mv)
24131 if v != nil {
24132 v[mk] = mv
24133 }
24134 }
24135 dd.ReadMapEnd()
24136 return v, changed
24137}
24138
24139func (d *Decoder) fastpathDecMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
24140 if rv.Kind() == reflect.Ptr {
24141 vp := rv2i(rv).(*map[uint8]string)
24142 v, changed := fastpathTV.DecMapUint8StringV(*vp, true, d)
24143 if changed {
24144 *vp = v
24145 }
24146 } else {
24147 fastpathTV.DecMapUint8StringV(rv2i(rv).(map[uint8]string), false, d)
24148 }
24149}
24150func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, d *Decoder) {
24151 v, changed := f.DecMapUint8StringV(*vp, true, d)
24152 if changed {
24153 *vp = v
24154 }
24155}
24156func (_ fastpathT) DecMapUint8StringV(v map[uint8]string, canChange bool,
24157 d *Decoder) (_ map[uint8]string, changed bool) {
24158 dd, esep := d.d, d.hh.hasElemSeparators()
24159 containerLen := dd.ReadMapStart()
24160 if canChange && v == nil {
24161 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
24162 v = make(map[uint8]string, xlen)
24163 changed = true
24164 }
24165 if containerLen == 0 {
24166 dd.ReadMapEnd()
24167 return v, changed
24168 }
24169 var mk uint8
24170 var mv string
24171 hasLen := containerLen > 0
24172 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24173 if esep {
24174 dd.ReadMapElemKey()
24175 }
24176 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24177 if esep {
24178 dd.ReadMapElemValue()
24179 }
24180 if dd.TryDecodeAsNil() {
24181 if v == nil {
24182 } else if d.h.DeleteOnNilMapValue {
24183 delete(v, mk)
24184 } else {
24185 v[mk] = ""
24186 }
24187 continue
24188 }
24189 mv = dd.DecodeString()
24190 if v != nil {
24191 v[mk] = mv
24192 }
24193 }
24194 dd.ReadMapEnd()
24195 return v, changed
24196}
24197
24198func (d *Decoder) fastpathDecMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
24199 if rv.Kind() == reflect.Ptr {
24200 vp := rv2i(rv).(*map[uint8]uint)
24201 v, changed := fastpathTV.DecMapUint8UintV(*vp, true, d)
24202 if changed {
24203 *vp = v
24204 }
24205 } else {
24206 fastpathTV.DecMapUint8UintV(rv2i(rv).(map[uint8]uint), false, d)
24207 }
24208}
24209func (f fastpathT) DecMapUint8UintX(vp *map[uint8]uint, d *Decoder) {
24210 v, changed := f.DecMapUint8UintV(*vp, true, d)
24211 if changed {
24212 *vp = v
24213 }
24214}
24215func (_ fastpathT) DecMapUint8UintV(v map[uint8]uint, canChange bool,
24216 d *Decoder) (_ map[uint8]uint, changed bool) {
24217 dd, esep := d.d, d.hh.hasElemSeparators()
24218 containerLen := dd.ReadMapStart()
24219 if canChange && v == nil {
24220 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24221 v = make(map[uint8]uint, xlen)
24222 changed = true
24223 }
24224 if containerLen == 0 {
24225 dd.ReadMapEnd()
24226 return v, changed
24227 }
24228 var mk uint8
24229 var mv uint
24230 hasLen := containerLen > 0
24231 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24232 if esep {
24233 dd.ReadMapElemKey()
24234 }
24235 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24236 if esep {
24237 dd.ReadMapElemValue()
24238 }
24239 if dd.TryDecodeAsNil() {
24240 if v == nil {
24241 } else if d.h.DeleteOnNilMapValue {
24242 delete(v, mk)
24243 } else {
24244 v[mk] = 0
24245 }
24246 continue
24247 }
24248 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24249 if v != nil {
24250 v[mk] = mv
24251 }
24252 }
24253 dd.ReadMapEnd()
24254 return v, changed
24255}
24256
24257func (d *Decoder) fastpathDecMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
24258 if rv.Kind() == reflect.Ptr {
24259 vp := rv2i(rv).(*map[uint8]uint8)
24260 v, changed := fastpathTV.DecMapUint8Uint8V(*vp, true, d)
24261 if changed {
24262 *vp = v
24263 }
24264 } else {
24265 fastpathTV.DecMapUint8Uint8V(rv2i(rv).(map[uint8]uint8), false, d)
24266 }
24267}
24268func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, d *Decoder) {
24269 v, changed := f.DecMapUint8Uint8V(*vp, true, d)
24270 if changed {
24271 *vp = v
24272 }
24273}
24274func (_ fastpathT) DecMapUint8Uint8V(v map[uint8]uint8, canChange bool,
24275 d *Decoder) (_ map[uint8]uint8, changed bool) {
24276 dd, esep := d.d, d.hh.hasElemSeparators()
24277 containerLen := dd.ReadMapStart()
24278 if canChange && v == nil {
24279 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
24280 v = make(map[uint8]uint8, xlen)
24281 changed = true
24282 }
24283 if containerLen == 0 {
24284 dd.ReadMapEnd()
24285 return v, changed
24286 }
24287 var mk uint8
24288 var mv uint8
24289 hasLen := containerLen > 0
24290 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24291 if esep {
24292 dd.ReadMapElemKey()
24293 }
24294 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24295 if esep {
24296 dd.ReadMapElemValue()
24297 }
24298 if dd.TryDecodeAsNil() {
24299 if v == nil {
24300 } else if d.h.DeleteOnNilMapValue {
24301 delete(v, mk)
24302 } else {
24303 v[mk] = 0
24304 }
24305 continue
24306 }
24307 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24308 if v != nil {
24309 v[mk] = mv
24310 }
24311 }
24312 dd.ReadMapEnd()
24313 return v, changed
24314}
24315
24316func (d *Decoder) fastpathDecMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
24317 if rv.Kind() == reflect.Ptr {
24318 vp := rv2i(rv).(*map[uint8]uint16)
24319 v, changed := fastpathTV.DecMapUint8Uint16V(*vp, true, d)
24320 if changed {
24321 *vp = v
24322 }
24323 } else {
24324 fastpathTV.DecMapUint8Uint16V(rv2i(rv).(map[uint8]uint16), false, d)
24325 }
24326}
24327func (f fastpathT) DecMapUint8Uint16X(vp *map[uint8]uint16, d *Decoder) {
24328 v, changed := f.DecMapUint8Uint16V(*vp, true, d)
24329 if changed {
24330 *vp = v
24331 }
24332}
24333func (_ fastpathT) DecMapUint8Uint16V(v map[uint8]uint16, canChange bool,
24334 d *Decoder) (_ map[uint8]uint16, changed bool) {
24335 dd, esep := d.d, d.hh.hasElemSeparators()
24336 containerLen := dd.ReadMapStart()
24337 if canChange && v == nil {
24338 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
24339 v = make(map[uint8]uint16, xlen)
24340 changed = true
24341 }
24342 if containerLen == 0 {
24343 dd.ReadMapEnd()
24344 return v, changed
24345 }
24346 var mk uint8
24347 var mv uint16
24348 hasLen := containerLen > 0
24349 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24350 if esep {
24351 dd.ReadMapElemKey()
24352 }
24353 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24354 if esep {
24355 dd.ReadMapElemValue()
24356 }
24357 if dd.TryDecodeAsNil() {
24358 if v == nil {
24359 } else if d.h.DeleteOnNilMapValue {
24360 delete(v, mk)
24361 } else {
24362 v[mk] = 0
24363 }
24364 continue
24365 }
24366 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
24367 if v != nil {
24368 v[mk] = mv
24369 }
24370 }
24371 dd.ReadMapEnd()
24372 return v, changed
24373}
24374
24375func (d *Decoder) fastpathDecMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
24376 if rv.Kind() == reflect.Ptr {
24377 vp := rv2i(rv).(*map[uint8]uint32)
24378 v, changed := fastpathTV.DecMapUint8Uint32V(*vp, true, d)
24379 if changed {
24380 *vp = v
24381 }
24382 } else {
24383 fastpathTV.DecMapUint8Uint32V(rv2i(rv).(map[uint8]uint32), false, d)
24384 }
24385}
24386func (f fastpathT) DecMapUint8Uint32X(vp *map[uint8]uint32, d *Decoder) {
24387 v, changed := f.DecMapUint8Uint32V(*vp, true, d)
24388 if changed {
24389 *vp = v
24390 }
24391}
24392func (_ fastpathT) DecMapUint8Uint32V(v map[uint8]uint32, canChange bool,
24393 d *Decoder) (_ map[uint8]uint32, changed bool) {
24394 dd, esep := d.d, d.hh.hasElemSeparators()
24395 containerLen := dd.ReadMapStart()
24396 if canChange && v == nil {
24397 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
24398 v = make(map[uint8]uint32, xlen)
24399 changed = true
24400 }
24401 if containerLen == 0 {
24402 dd.ReadMapEnd()
24403 return v, changed
24404 }
24405 var mk uint8
24406 var mv uint32
24407 hasLen := containerLen > 0
24408 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24409 if esep {
24410 dd.ReadMapElemKey()
24411 }
24412 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24413 if esep {
24414 dd.ReadMapElemValue()
24415 }
24416 if dd.TryDecodeAsNil() {
24417 if v == nil {
24418 } else if d.h.DeleteOnNilMapValue {
24419 delete(v, mk)
24420 } else {
24421 v[mk] = 0
24422 }
24423 continue
24424 }
24425 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
24426 if v != nil {
24427 v[mk] = mv
24428 }
24429 }
24430 dd.ReadMapEnd()
24431 return v, changed
24432}
24433
24434func (d *Decoder) fastpathDecMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
24435 if rv.Kind() == reflect.Ptr {
24436 vp := rv2i(rv).(*map[uint8]uint64)
24437 v, changed := fastpathTV.DecMapUint8Uint64V(*vp, true, d)
24438 if changed {
24439 *vp = v
24440 }
24441 } else {
24442 fastpathTV.DecMapUint8Uint64V(rv2i(rv).(map[uint8]uint64), false, d)
24443 }
24444}
24445func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, d *Decoder) {
24446 v, changed := f.DecMapUint8Uint64V(*vp, true, d)
24447 if changed {
24448 *vp = v
24449 }
24450}
24451func (_ fastpathT) DecMapUint8Uint64V(v map[uint8]uint64, canChange bool,
24452 d *Decoder) (_ map[uint8]uint64, changed bool) {
24453 dd, esep := d.d, d.hh.hasElemSeparators()
24454 containerLen := dd.ReadMapStart()
24455 if canChange && v == nil {
24456 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24457 v = make(map[uint8]uint64, xlen)
24458 changed = true
24459 }
24460 if containerLen == 0 {
24461 dd.ReadMapEnd()
24462 return v, changed
24463 }
24464 var mk uint8
24465 var mv uint64
24466 hasLen := containerLen > 0
24467 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24468 if esep {
24469 dd.ReadMapElemKey()
24470 }
24471 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24472 if esep {
24473 dd.ReadMapElemValue()
24474 }
24475 if dd.TryDecodeAsNil() {
24476 if v == nil {
24477 } else if d.h.DeleteOnNilMapValue {
24478 delete(v, mk)
24479 } else {
24480 v[mk] = 0
24481 }
24482 continue
24483 }
24484 mv = dd.DecodeUint64()
24485 if v != nil {
24486 v[mk] = mv
24487 }
24488 }
24489 dd.ReadMapEnd()
24490 return v, changed
24491}
24492
24493func (d *Decoder) fastpathDecMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
24494 if rv.Kind() == reflect.Ptr {
24495 vp := rv2i(rv).(*map[uint8]uintptr)
24496 v, changed := fastpathTV.DecMapUint8UintptrV(*vp, true, d)
24497 if changed {
24498 *vp = v
24499 }
24500 } else {
24501 fastpathTV.DecMapUint8UintptrV(rv2i(rv).(map[uint8]uintptr), false, d)
24502 }
24503}
24504func (f fastpathT) DecMapUint8UintptrX(vp *map[uint8]uintptr, d *Decoder) {
24505 v, changed := f.DecMapUint8UintptrV(*vp, true, d)
24506 if changed {
24507 *vp = v
24508 }
24509}
24510func (_ fastpathT) DecMapUint8UintptrV(v map[uint8]uintptr, canChange bool,
24511 d *Decoder) (_ map[uint8]uintptr, changed bool) {
24512 dd, esep := d.d, d.hh.hasElemSeparators()
24513 containerLen := dd.ReadMapStart()
24514 if canChange && v == nil {
24515 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24516 v = make(map[uint8]uintptr, xlen)
24517 changed = true
24518 }
24519 if containerLen == 0 {
24520 dd.ReadMapEnd()
24521 return v, changed
24522 }
24523 var mk uint8
24524 var mv uintptr
24525 hasLen := containerLen > 0
24526 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24527 if esep {
24528 dd.ReadMapElemKey()
24529 }
24530 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24531 if esep {
24532 dd.ReadMapElemValue()
24533 }
24534 if dd.TryDecodeAsNil() {
24535 if v == nil {
24536 } else if d.h.DeleteOnNilMapValue {
24537 delete(v, mk)
24538 } else {
24539 v[mk] = 0
24540 }
24541 continue
24542 }
24543 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
24544 if v != nil {
24545 v[mk] = mv
24546 }
24547 }
24548 dd.ReadMapEnd()
24549 return v, changed
24550}
24551
24552func (d *Decoder) fastpathDecMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
24553 if rv.Kind() == reflect.Ptr {
24554 vp := rv2i(rv).(*map[uint8]int)
24555 v, changed := fastpathTV.DecMapUint8IntV(*vp, true, d)
24556 if changed {
24557 *vp = v
24558 }
24559 } else {
24560 fastpathTV.DecMapUint8IntV(rv2i(rv).(map[uint8]int), false, d)
24561 }
24562}
24563func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, d *Decoder) {
24564 v, changed := f.DecMapUint8IntV(*vp, true, d)
24565 if changed {
24566 *vp = v
24567 }
24568}
24569func (_ fastpathT) DecMapUint8IntV(v map[uint8]int, canChange bool,
24570 d *Decoder) (_ map[uint8]int, changed bool) {
24571 dd, esep := d.d, d.hh.hasElemSeparators()
24572 containerLen := dd.ReadMapStart()
24573 if canChange && v == nil {
24574 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24575 v = make(map[uint8]int, xlen)
24576 changed = true
24577 }
24578 if containerLen == 0 {
24579 dd.ReadMapEnd()
24580 return v, changed
24581 }
24582 var mk uint8
24583 var mv int
24584 hasLen := containerLen > 0
24585 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24586 if esep {
24587 dd.ReadMapElemKey()
24588 }
24589 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24590 if esep {
24591 dd.ReadMapElemValue()
24592 }
24593 if dd.TryDecodeAsNil() {
24594 if v == nil {
24595 } else if d.h.DeleteOnNilMapValue {
24596 delete(v, mk)
24597 } else {
24598 v[mk] = 0
24599 }
24600 continue
24601 }
24602 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
24603 if v != nil {
24604 v[mk] = mv
24605 }
24606 }
24607 dd.ReadMapEnd()
24608 return v, changed
24609}
24610
24611func (d *Decoder) fastpathDecMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
24612 if rv.Kind() == reflect.Ptr {
24613 vp := rv2i(rv).(*map[uint8]int8)
24614 v, changed := fastpathTV.DecMapUint8Int8V(*vp, true, d)
24615 if changed {
24616 *vp = v
24617 }
24618 } else {
24619 fastpathTV.DecMapUint8Int8V(rv2i(rv).(map[uint8]int8), false, d)
24620 }
24621}
24622func (f fastpathT) DecMapUint8Int8X(vp *map[uint8]int8, d *Decoder) {
24623 v, changed := f.DecMapUint8Int8V(*vp, true, d)
24624 if changed {
24625 *vp = v
24626 }
24627}
24628func (_ fastpathT) DecMapUint8Int8V(v map[uint8]int8, canChange bool,
24629 d *Decoder) (_ map[uint8]int8, changed bool) {
24630 dd, esep := d.d, d.hh.hasElemSeparators()
24631 containerLen := dd.ReadMapStart()
24632 if canChange && v == nil {
24633 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
24634 v = make(map[uint8]int8, xlen)
24635 changed = true
24636 }
24637 if containerLen == 0 {
24638 dd.ReadMapEnd()
24639 return v, changed
24640 }
24641 var mk uint8
24642 var mv int8
24643 hasLen := containerLen > 0
24644 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24645 if esep {
24646 dd.ReadMapElemKey()
24647 }
24648 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24649 if esep {
24650 dd.ReadMapElemValue()
24651 }
24652 if dd.TryDecodeAsNil() {
24653 if v == nil {
24654 } else if d.h.DeleteOnNilMapValue {
24655 delete(v, mk)
24656 } else {
24657 v[mk] = 0
24658 }
24659 continue
24660 }
24661 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
24662 if v != nil {
24663 v[mk] = mv
24664 }
24665 }
24666 dd.ReadMapEnd()
24667 return v, changed
24668}
24669
24670func (d *Decoder) fastpathDecMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
24671 if rv.Kind() == reflect.Ptr {
24672 vp := rv2i(rv).(*map[uint8]int16)
24673 v, changed := fastpathTV.DecMapUint8Int16V(*vp, true, d)
24674 if changed {
24675 *vp = v
24676 }
24677 } else {
24678 fastpathTV.DecMapUint8Int16V(rv2i(rv).(map[uint8]int16), false, d)
24679 }
24680}
24681func (f fastpathT) DecMapUint8Int16X(vp *map[uint8]int16, d *Decoder) {
24682 v, changed := f.DecMapUint8Int16V(*vp, true, d)
24683 if changed {
24684 *vp = v
24685 }
24686}
24687func (_ fastpathT) DecMapUint8Int16V(v map[uint8]int16, canChange bool,
24688 d *Decoder) (_ map[uint8]int16, changed bool) {
24689 dd, esep := d.d, d.hh.hasElemSeparators()
24690 containerLen := dd.ReadMapStart()
24691 if canChange && v == nil {
24692 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
24693 v = make(map[uint8]int16, xlen)
24694 changed = true
24695 }
24696 if containerLen == 0 {
24697 dd.ReadMapEnd()
24698 return v, changed
24699 }
24700 var mk uint8
24701 var mv int16
24702 hasLen := containerLen > 0
24703 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24704 if esep {
24705 dd.ReadMapElemKey()
24706 }
24707 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24708 if esep {
24709 dd.ReadMapElemValue()
24710 }
24711 if dd.TryDecodeAsNil() {
24712 if v == nil {
24713 } else if d.h.DeleteOnNilMapValue {
24714 delete(v, mk)
24715 } else {
24716 v[mk] = 0
24717 }
24718 continue
24719 }
24720 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
24721 if v != nil {
24722 v[mk] = mv
24723 }
24724 }
24725 dd.ReadMapEnd()
24726 return v, changed
24727}
24728
24729func (d *Decoder) fastpathDecMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
24730 if rv.Kind() == reflect.Ptr {
24731 vp := rv2i(rv).(*map[uint8]int32)
24732 v, changed := fastpathTV.DecMapUint8Int32V(*vp, true, d)
24733 if changed {
24734 *vp = v
24735 }
24736 } else {
24737 fastpathTV.DecMapUint8Int32V(rv2i(rv).(map[uint8]int32), false, d)
24738 }
24739}
24740func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, d *Decoder) {
24741 v, changed := f.DecMapUint8Int32V(*vp, true, d)
24742 if changed {
24743 *vp = v
24744 }
24745}
24746func (_ fastpathT) DecMapUint8Int32V(v map[uint8]int32, canChange bool,
24747 d *Decoder) (_ map[uint8]int32, changed bool) {
24748 dd, esep := d.d, d.hh.hasElemSeparators()
24749 containerLen := dd.ReadMapStart()
24750 if canChange && v == nil {
24751 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
24752 v = make(map[uint8]int32, xlen)
24753 changed = true
24754 }
24755 if containerLen == 0 {
24756 dd.ReadMapEnd()
24757 return v, changed
24758 }
24759 var mk uint8
24760 var mv int32
24761 hasLen := containerLen > 0
24762 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24763 if esep {
24764 dd.ReadMapElemKey()
24765 }
24766 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24767 if esep {
24768 dd.ReadMapElemValue()
24769 }
24770 if dd.TryDecodeAsNil() {
24771 if v == nil {
24772 } else if d.h.DeleteOnNilMapValue {
24773 delete(v, mk)
24774 } else {
24775 v[mk] = 0
24776 }
24777 continue
24778 }
24779 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
24780 if v != nil {
24781 v[mk] = mv
24782 }
24783 }
24784 dd.ReadMapEnd()
24785 return v, changed
24786}
24787
24788func (d *Decoder) fastpathDecMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
24789 if rv.Kind() == reflect.Ptr {
24790 vp := rv2i(rv).(*map[uint8]int64)
24791 v, changed := fastpathTV.DecMapUint8Int64V(*vp, true, d)
24792 if changed {
24793 *vp = v
24794 }
24795 } else {
24796 fastpathTV.DecMapUint8Int64V(rv2i(rv).(map[uint8]int64), false, d)
24797 }
24798}
24799func (f fastpathT) DecMapUint8Int64X(vp *map[uint8]int64, d *Decoder) {
24800 v, changed := f.DecMapUint8Int64V(*vp, true, d)
24801 if changed {
24802 *vp = v
24803 }
24804}
24805func (_ fastpathT) DecMapUint8Int64V(v map[uint8]int64, canChange bool,
24806 d *Decoder) (_ map[uint8]int64, changed bool) {
24807 dd, esep := d.d, d.hh.hasElemSeparators()
24808 containerLen := dd.ReadMapStart()
24809 if canChange && v == nil {
24810 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24811 v = make(map[uint8]int64, xlen)
24812 changed = true
24813 }
24814 if containerLen == 0 {
24815 dd.ReadMapEnd()
24816 return v, changed
24817 }
24818 var mk uint8
24819 var mv int64
24820 hasLen := containerLen > 0
24821 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24822 if esep {
24823 dd.ReadMapElemKey()
24824 }
24825 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24826 if esep {
24827 dd.ReadMapElemValue()
24828 }
24829 if dd.TryDecodeAsNil() {
24830 if v == nil {
24831 } else if d.h.DeleteOnNilMapValue {
24832 delete(v, mk)
24833 } else {
24834 v[mk] = 0
24835 }
24836 continue
24837 }
24838 mv = dd.DecodeInt64()
24839 if v != nil {
24840 v[mk] = mv
24841 }
24842 }
24843 dd.ReadMapEnd()
24844 return v, changed
24845}
24846
24847func (d *Decoder) fastpathDecMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
24848 if rv.Kind() == reflect.Ptr {
24849 vp := rv2i(rv).(*map[uint8]float32)
24850 v, changed := fastpathTV.DecMapUint8Float32V(*vp, true, d)
24851 if changed {
24852 *vp = v
24853 }
24854 } else {
24855 fastpathTV.DecMapUint8Float32V(rv2i(rv).(map[uint8]float32), false, d)
24856 }
24857}
24858func (f fastpathT) DecMapUint8Float32X(vp *map[uint8]float32, d *Decoder) {
24859 v, changed := f.DecMapUint8Float32V(*vp, true, d)
24860 if changed {
24861 *vp = v
24862 }
24863}
24864func (_ fastpathT) DecMapUint8Float32V(v map[uint8]float32, canChange bool,
24865 d *Decoder) (_ map[uint8]float32, changed bool) {
24866 dd, esep := d.d, d.hh.hasElemSeparators()
24867 containerLen := dd.ReadMapStart()
24868 if canChange && v == nil {
24869 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
24870 v = make(map[uint8]float32, xlen)
24871 changed = true
24872 }
24873 if containerLen == 0 {
24874 dd.ReadMapEnd()
24875 return v, changed
24876 }
24877 var mk uint8
24878 var mv float32
24879 hasLen := containerLen > 0
24880 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24881 if esep {
24882 dd.ReadMapElemKey()
24883 }
24884 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24885 if esep {
24886 dd.ReadMapElemValue()
24887 }
24888 if dd.TryDecodeAsNil() {
24889 if v == nil {
24890 } else if d.h.DeleteOnNilMapValue {
24891 delete(v, mk)
24892 } else {
24893 v[mk] = 0
24894 }
24895 continue
24896 }
24897 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
24898 if v != nil {
24899 v[mk] = mv
24900 }
24901 }
24902 dd.ReadMapEnd()
24903 return v, changed
24904}
24905
24906func (d *Decoder) fastpathDecMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
24907 if rv.Kind() == reflect.Ptr {
24908 vp := rv2i(rv).(*map[uint8]float64)
24909 v, changed := fastpathTV.DecMapUint8Float64V(*vp, true, d)
24910 if changed {
24911 *vp = v
24912 }
24913 } else {
24914 fastpathTV.DecMapUint8Float64V(rv2i(rv).(map[uint8]float64), false, d)
24915 }
24916}
24917func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, d *Decoder) {
24918 v, changed := f.DecMapUint8Float64V(*vp, true, d)
24919 if changed {
24920 *vp = v
24921 }
24922}
24923func (_ fastpathT) DecMapUint8Float64V(v map[uint8]float64, canChange bool,
24924 d *Decoder) (_ map[uint8]float64, changed bool) {
24925 dd, esep := d.d, d.hh.hasElemSeparators()
24926 containerLen := dd.ReadMapStart()
24927 if canChange && v == nil {
24928 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
24929 v = make(map[uint8]float64, xlen)
24930 changed = true
24931 }
24932 if containerLen == 0 {
24933 dd.ReadMapEnd()
24934 return v, changed
24935 }
24936 var mk uint8
24937 var mv float64
24938 hasLen := containerLen > 0
24939 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24940 if esep {
24941 dd.ReadMapElemKey()
24942 }
24943 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
24944 if esep {
24945 dd.ReadMapElemValue()
24946 }
24947 if dd.TryDecodeAsNil() {
24948 if v == nil {
24949 } else if d.h.DeleteOnNilMapValue {
24950 delete(v, mk)
24951 } else {
24952 v[mk] = 0
24953 }
24954 continue
24955 }
24956 mv = dd.DecodeFloat64()
24957 if v != nil {
24958 v[mk] = mv
24959 }
24960 }
24961 dd.ReadMapEnd()
24962 return v, changed
24963}
24964
24965func (d *Decoder) fastpathDecMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
24966 if rv.Kind() == reflect.Ptr {
24967 vp := rv2i(rv).(*map[uint8]bool)
24968 v, changed := fastpathTV.DecMapUint8BoolV(*vp, true, d)
24969 if changed {
24970 *vp = v
24971 }
24972 } else {
24973 fastpathTV.DecMapUint8BoolV(rv2i(rv).(map[uint8]bool), false, d)
24974 }
24975}
24976func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, d *Decoder) {
24977 v, changed := f.DecMapUint8BoolV(*vp, true, d)
24978 if changed {
24979 *vp = v
24980 }
24981}
24982func (_ fastpathT) DecMapUint8BoolV(v map[uint8]bool, canChange bool,
24983 d *Decoder) (_ map[uint8]bool, changed bool) {
24984 dd, esep := d.d, d.hh.hasElemSeparators()
24985 containerLen := dd.ReadMapStart()
24986 if canChange && v == nil {
24987 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
24988 v = make(map[uint8]bool, xlen)
24989 changed = true
24990 }
24991 if containerLen == 0 {
24992 dd.ReadMapEnd()
24993 return v, changed
24994 }
24995 var mk uint8
24996 var mv bool
24997 hasLen := containerLen > 0
24998 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
24999 if esep {
25000 dd.ReadMapElemKey()
25001 }
25002 mk = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25003 if esep {
25004 dd.ReadMapElemValue()
25005 }
25006 if dd.TryDecodeAsNil() {
25007 if v == nil {
25008 } else if d.h.DeleteOnNilMapValue {
25009 delete(v, mk)
25010 } else {
25011 v[mk] = false
25012 }
25013 continue
25014 }
25015 mv = dd.DecodeBool()
25016 if v != nil {
25017 v[mk] = mv
25018 }
25019 }
25020 dd.ReadMapEnd()
25021 return v, changed
25022}
25023
25024func (d *Decoder) fastpathDecMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
25025 if rv.Kind() == reflect.Ptr {
25026 vp := rv2i(rv).(*map[uint16]interface{})
25027 v, changed := fastpathTV.DecMapUint16IntfV(*vp, true, d)
25028 if changed {
25029 *vp = v
25030 }
25031 } else {
25032 fastpathTV.DecMapUint16IntfV(rv2i(rv).(map[uint16]interface{}), false, d)
25033 }
25034}
25035func (f fastpathT) DecMapUint16IntfX(vp *map[uint16]interface{}, d *Decoder) {
25036 v, changed := f.DecMapUint16IntfV(*vp, true, d)
25037 if changed {
25038 *vp = v
25039 }
25040}
25041func (_ fastpathT) DecMapUint16IntfV(v map[uint16]interface{}, canChange bool,
25042 d *Decoder) (_ map[uint16]interface{}, changed bool) {
25043 dd, esep := d.d, d.hh.hasElemSeparators()
25044 containerLen := dd.ReadMapStart()
25045 if canChange && v == nil {
25046 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
25047 v = make(map[uint16]interface{}, xlen)
25048 changed = true
25049 }
25050 if containerLen == 0 {
25051 dd.ReadMapEnd()
25052 return v, changed
25053 }
25054 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
25055 var mk uint16
25056 var mv interface{}
25057 hasLen := containerLen > 0
25058 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25059 if esep {
25060 dd.ReadMapElemKey()
25061 }
25062 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25063 if esep {
25064 dd.ReadMapElemValue()
25065 }
25066 if dd.TryDecodeAsNil() {
25067 if v == nil {
25068 } else if d.h.DeleteOnNilMapValue {
25069 delete(v, mk)
25070 } else {
25071 v[mk] = nil
25072 }
25073 continue
25074 }
25075 if mapGet {
25076 mv = v[mk]
25077 } else {
25078 mv = nil
25079 }
25080 d.decode(&mv)
25081 if v != nil {
25082 v[mk] = mv
25083 }
25084 }
25085 dd.ReadMapEnd()
25086 return v, changed
25087}
25088
25089func (d *Decoder) fastpathDecMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
25090 if rv.Kind() == reflect.Ptr {
25091 vp := rv2i(rv).(*map[uint16]string)
25092 v, changed := fastpathTV.DecMapUint16StringV(*vp, true, d)
25093 if changed {
25094 *vp = v
25095 }
25096 } else {
25097 fastpathTV.DecMapUint16StringV(rv2i(rv).(map[uint16]string), false, d)
25098 }
25099}
25100func (f fastpathT) DecMapUint16StringX(vp *map[uint16]string, d *Decoder) {
25101 v, changed := f.DecMapUint16StringV(*vp, true, d)
25102 if changed {
25103 *vp = v
25104 }
25105}
25106func (_ fastpathT) DecMapUint16StringV(v map[uint16]string, canChange bool,
25107 d *Decoder) (_ map[uint16]string, changed bool) {
25108 dd, esep := d.d, d.hh.hasElemSeparators()
25109 containerLen := dd.ReadMapStart()
25110 if canChange && v == nil {
25111 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
25112 v = make(map[uint16]string, xlen)
25113 changed = true
25114 }
25115 if containerLen == 0 {
25116 dd.ReadMapEnd()
25117 return v, changed
25118 }
25119 var mk uint16
25120 var mv string
25121 hasLen := containerLen > 0
25122 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25123 if esep {
25124 dd.ReadMapElemKey()
25125 }
25126 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25127 if esep {
25128 dd.ReadMapElemValue()
25129 }
25130 if dd.TryDecodeAsNil() {
25131 if v == nil {
25132 } else if d.h.DeleteOnNilMapValue {
25133 delete(v, mk)
25134 } else {
25135 v[mk] = ""
25136 }
25137 continue
25138 }
25139 mv = dd.DecodeString()
25140 if v != nil {
25141 v[mk] = mv
25142 }
25143 }
25144 dd.ReadMapEnd()
25145 return v, changed
25146}
25147
25148func (d *Decoder) fastpathDecMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
25149 if rv.Kind() == reflect.Ptr {
25150 vp := rv2i(rv).(*map[uint16]uint)
25151 v, changed := fastpathTV.DecMapUint16UintV(*vp, true, d)
25152 if changed {
25153 *vp = v
25154 }
25155 } else {
25156 fastpathTV.DecMapUint16UintV(rv2i(rv).(map[uint16]uint), false, d)
25157 }
25158}
25159func (f fastpathT) DecMapUint16UintX(vp *map[uint16]uint, d *Decoder) {
25160 v, changed := f.DecMapUint16UintV(*vp, true, d)
25161 if changed {
25162 *vp = v
25163 }
25164}
25165func (_ fastpathT) DecMapUint16UintV(v map[uint16]uint, canChange bool,
25166 d *Decoder) (_ map[uint16]uint, changed bool) {
25167 dd, esep := d.d, d.hh.hasElemSeparators()
25168 containerLen := dd.ReadMapStart()
25169 if canChange && v == nil {
25170 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25171 v = make(map[uint16]uint, xlen)
25172 changed = true
25173 }
25174 if containerLen == 0 {
25175 dd.ReadMapEnd()
25176 return v, changed
25177 }
25178 var mk uint16
25179 var mv uint
25180 hasLen := containerLen > 0
25181 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25182 if esep {
25183 dd.ReadMapElemKey()
25184 }
25185 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25186 if esep {
25187 dd.ReadMapElemValue()
25188 }
25189 if dd.TryDecodeAsNil() {
25190 if v == nil {
25191 } else if d.h.DeleteOnNilMapValue {
25192 delete(v, mk)
25193 } else {
25194 v[mk] = 0
25195 }
25196 continue
25197 }
25198 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
25199 if v != nil {
25200 v[mk] = mv
25201 }
25202 }
25203 dd.ReadMapEnd()
25204 return v, changed
25205}
25206
25207func (d *Decoder) fastpathDecMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
25208 if rv.Kind() == reflect.Ptr {
25209 vp := rv2i(rv).(*map[uint16]uint8)
25210 v, changed := fastpathTV.DecMapUint16Uint8V(*vp, true, d)
25211 if changed {
25212 *vp = v
25213 }
25214 } else {
25215 fastpathTV.DecMapUint16Uint8V(rv2i(rv).(map[uint16]uint8), false, d)
25216 }
25217}
25218func (f fastpathT) DecMapUint16Uint8X(vp *map[uint16]uint8, d *Decoder) {
25219 v, changed := f.DecMapUint16Uint8V(*vp, true, d)
25220 if changed {
25221 *vp = v
25222 }
25223}
25224func (_ fastpathT) DecMapUint16Uint8V(v map[uint16]uint8, canChange bool,
25225 d *Decoder) (_ map[uint16]uint8, changed bool) {
25226 dd, esep := d.d, d.hh.hasElemSeparators()
25227 containerLen := dd.ReadMapStart()
25228 if canChange && v == nil {
25229 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
25230 v = make(map[uint16]uint8, xlen)
25231 changed = true
25232 }
25233 if containerLen == 0 {
25234 dd.ReadMapEnd()
25235 return v, changed
25236 }
25237 var mk uint16
25238 var mv uint8
25239 hasLen := containerLen > 0
25240 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25241 if esep {
25242 dd.ReadMapElemKey()
25243 }
25244 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25245 if esep {
25246 dd.ReadMapElemValue()
25247 }
25248 if dd.TryDecodeAsNil() {
25249 if v == nil {
25250 } else if d.h.DeleteOnNilMapValue {
25251 delete(v, mk)
25252 } else {
25253 v[mk] = 0
25254 }
25255 continue
25256 }
25257 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
25258 if v != nil {
25259 v[mk] = mv
25260 }
25261 }
25262 dd.ReadMapEnd()
25263 return v, changed
25264}
25265
25266func (d *Decoder) fastpathDecMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
25267 if rv.Kind() == reflect.Ptr {
25268 vp := rv2i(rv).(*map[uint16]uint16)
25269 v, changed := fastpathTV.DecMapUint16Uint16V(*vp, true, d)
25270 if changed {
25271 *vp = v
25272 }
25273 } else {
25274 fastpathTV.DecMapUint16Uint16V(rv2i(rv).(map[uint16]uint16), false, d)
25275 }
25276}
25277func (f fastpathT) DecMapUint16Uint16X(vp *map[uint16]uint16, d *Decoder) {
25278 v, changed := f.DecMapUint16Uint16V(*vp, true, d)
25279 if changed {
25280 *vp = v
25281 }
25282}
25283func (_ fastpathT) DecMapUint16Uint16V(v map[uint16]uint16, canChange bool,
25284 d *Decoder) (_ map[uint16]uint16, changed bool) {
25285 dd, esep := d.d, d.hh.hasElemSeparators()
25286 containerLen := dd.ReadMapStart()
25287 if canChange && v == nil {
25288 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
25289 v = make(map[uint16]uint16, xlen)
25290 changed = true
25291 }
25292 if containerLen == 0 {
25293 dd.ReadMapEnd()
25294 return v, changed
25295 }
25296 var mk uint16
25297 var mv uint16
25298 hasLen := containerLen > 0
25299 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25300 if esep {
25301 dd.ReadMapElemKey()
25302 }
25303 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25304 if esep {
25305 dd.ReadMapElemValue()
25306 }
25307 if dd.TryDecodeAsNil() {
25308 if v == nil {
25309 } else if d.h.DeleteOnNilMapValue {
25310 delete(v, mk)
25311 } else {
25312 v[mk] = 0
25313 }
25314 continue
25315 }
25316 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25317 if v != nil {
25318 v[mk] = mv
25319 }
25320 }
25321 dd.ReadMapEnd()
25322 return v, changed
25323}
25324
25325func (d *Decoder) fastpathDecMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
25326 if rv.Kind() == reflect.Ptr {
25327 vp := rv2i(rv).(*map[uint16]uint32)
25328 v, changed := fastpathTV.DecMapUint16Uint32V(*vp, true, d)
25329 if changed {
25330 *vp = v
25331 }
25332 } else {
25333 fastpathTV.DecMapUint16Uint32V(rv2i(rv).(map[uint16]uint32), false, d)
25334 }
25335}
25336func (f fastpathT) DecMapUint16Uint32X(vp *map[uint16]uint32, d *Decoder) {
25337 v, changed := f.DecMapUint16Uint32V(*vp, true, d)
25338 if changed {
25339 *vp = v
25340 }
25341}
25342func (_ fastpathT) DecMapUint16Uint32V(v map[uint16]uint32, canChange bool,
25343 d *Decoder) (_ map[uint16]uint32, changed bool) {
25344 dd, esep := d.d, d.hh.hasElemSeparators()
25345 containerLen := dd.ReadMapStart()
25346 if canChange && v == nil {
25347 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
25348 v = make(map[uint16]uint32, xlen)
25349 changed = true
25350 }
25351 if containerLen == 0 {
25352 dd.ReadMapEnd()
25353 return v, changed
25354 }
25355 var mk uint16
25356 var mv uint32
25357 hasLen := containerLen > 0
25358 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25359 if esep {
25360 dd.ReadMapElemKey()
25361 }
25362 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25363 if esep {
25364 dd.ReadMapElemValue()
25365 }
25366 if dd.TryDecodeAsNil() {
25367 if v == nil {
25368 } else if d.h.DeleteOnNilMapValue {
25369 delete(v, mk)
25370 } else {
25371 v[mk] = 0
25372 }
25373 continue
25374 }
25375 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
25376 if v != nil {
25377 v[mk] = mv
25378 }
25379 }
25380 dd.ReadMapEnd()
25381 return v, changed
25382}
25383
25384func (d *Decoder) fastpathDecMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
25385 if rv.Kind() == reflect.Ptr {
25386 vp := rv2i(rv).(*map[uint16]uint64)
25387 v, changed := fastpathTV.DecMapUint16Uint64V(*vp, true, d)
25388 if changed {
25389 *vp = v
25390 }
25391 } else {
25392 fastpathTV.DecMapUint16Uint64V(rv2i(rv).(map[uint16]uint64), false, d)
25393 }
25394}
25395func (f fastpathT) DecMapUint16Uint64X(vp *map[uint16]uint64, d *Decoder) {
25396 v, changed := f.DecMapUint16Uint64V(*vp, true, d)
25397 if changed {
25398 *vp = v
25399 }
25400}
25401func (_ fastpathT) DecMapUint16Uint64V(v map[uint16]uint64, canChange bool,
25402 d *Decoder) (_ map[uint16]uint64, changed bool) {
25403 dd, esep := d.d, d.hh.hasElemSeparators()
25404 containerLen := dd.ReadMapStart()
25405 if canChange && v == nil {
25406 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25407 v = make(map[uint16]uint64, xlen)
25408 changed = true
25409 }
25410 if containerLen == 0 {
25411 dd.ReadMapEnd()
25412 return v, changed
25413 }
25414 var mk uint16
25415 var mv uint64
25416 hasLen := containerLen > 0
25417 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25418 if esep {
25419 dd.ReadMapElemKey()
25420 }
25421 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25422 if esep {
25423 dd.ReadMapElemValue()
25424 }
25425 if dd.TryDecodeAsNil() {
25426 if v == nil {
25427 } else if d.h.DeleteOnNilMapValue {
25428 delete(v, mk)
25429 } else {
25430 v[mk] = 0
25431 }
25432 continue
25433 }
25434 mv = dd.DecodeUint64()
25435 if v != nil {
25436 v[mk] = mv
25437 }
25438 }
25439 dd.ReadMapEnd()
25440 return v, changed
25441}
25442
25443func (d *Decoder) fastpathDecMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
25444 if rv.Kind() == reflect.Ptr {
25445 vp := rv2i(rv).(*map[uint16]uintptr)
25446 v, changed := fastpathTV.DecMapUint16UintptrV(*vp, true, d)
25447 if changed {
25448 *vp = v
25449 }
25450 } else {
25451 fastpathTV.DecMapUint16UintptrV(rv2i(rv).(map[uint16]uintptr), false, d)
25452 }
25453}
25454func (f fastpathT) DecMapUint16UintptrX(vp *map[uint16]uintptr, d *Decoder) {
25455 v, changed := f.DecMapUint16UintptrV(*vp, true, d)
25456 if changed {
25457 *vp = v
25458 }
25459}
25460func (_ fastpathT) DecMapUint16UintptrV(v map[uint16]uintptr, canChange bool,
25461 d *Decoder) (_ map[uint16]uintptr, changed bool) {
25462 dd, esep := d.d, d.hh.hasElemSeparators()
25463 containerLen := dd.ReadMapStart()
25464 if canChange && v == nil {
25465 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25466 v = make(map[uint16]uintptr, xlen)
25467 changed = true
25468 }
25469 if containerLen == 0 {
25470 dd.ReadMapEnd()
25471 return v, changed
25472 }
25473 var mk uint16
25474 var mv uintptr
25475 hasLen := containerLen > 0
25476 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25477 if esep {
25478 dd.ReadMapElemKey()
25479 }
25480 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25481 if esep {
25482 dd.ReadMapElemValue()
25483 }
25484 if dd.TryDecodeAsNil() {
25485 if v == nil {
25486 } else if d.h.DeleteOnNilMapValue {
25487 delete(v, mk)
25488 } else {
25489 v[mk] = 0
25490 }
25491 continue
25492 }
25493 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
25494 if v != nil {
25495 v[mk] = mv
25496 }
25497 }
25498 dd.ReadMapEnd()
25499 return v, changed
25500}
25501
25502func (d *Decoder) fastpathDecMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
25503 if rv.Kind() == reflect.Ptr {
25504 vp := rv2i(rv).(*map[uint16]int)
25505 v, changed := fastpathTV.DecMapUint16IntV(*vp, true, d)
25506 if changed {
25507 *vp = v
25508 }
25509 } else {
25510 fastpathTV.DecMapUint16IntV(rv2i(rv).(map[uint16]int), false, d)
25511 }
25512}
25513func (f fastpathT) DecMapUint16IntX(vp *map[uint16]int, d *Decoder) {
25514 v, changed := f.DecMapUint16IntV(*vp, true, d)
25515 if changed {
25516 *vp = v
25517 }
25518}
25519func (_ fastpathT) DecMapUint16IntV(v map[uint16]int, canChange bool,
25520 d *Decoder) (_ map[uint16]int, changed bool) {
25521 dd, esep := d.d, d.hh.hasElemSeparators()
25522 containerLen := dd.ReadMapStart()
25523 if canChange && v == nil {
25524 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25525 v = make(map[uint16]int, xlen)
25526 changed = true
25527 }
25528 if containerLen == 0 {
25529 dd.ReadMapEnd()
25530 return v, changed
25531 }
25532 var mk uint16
25533 var mv int
25534 hasLen := containerLen > 0
25535 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25536 if esep {
25537 dd.ReadMapElemKey()
25538 }
25539 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25540 if esep {
25541 dd.ReadMapElemValue()
25542 }
25543 if dd.TryDecodeAsNil() {
25544 if v == nil {
25545 } else if d.h.DeleteOnNilMapValue {
25546 delete(v, mk)
25547 } else {
25548 v[mk] = 0
25549 }
25550 continue
25551 }
25552 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
25553 if v != nil {
25554 v[mk] = mv
25555 }
25556 }
25557 dd.ReadMapEnd()
25558 return v, changed
25559}
25560
25561func (d *Decoder) fastpathDecMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
25562 if rv.Kind() == reflect.Ptr {
25563 vp := rv2i(rv).(*map[uint16]int8)
25564 v, changed := fastpathTV.DecMapUint16Int8V(*vp, true, d)
25565 if changed {
25566 *vp = v
25567 }
25568 } else {
25569 fastpathTV.DecMapUint16Int8V(rv2i(rv).(map[uint16]int8), false, d)
25570 }
25571}
25572func (f fastpathT) DecMapUint16Int8X(vp *map[uint16]int8, d *Decoder) {
25573 v, changed := f.DecMapUint16Int8V(*vp, true, d)
25574 if changed {
25575 *vp = v
25576 }
25577}
25578func (_ fastpathT) DecMapUint16Int8V(v map[uint16]int8, canChange bool,
25579 d *Decoder) (_ map[uint16]int8, changed bool) {
25580 dd, esep := d.d, d.hh.hasElemSeparators()
25581 containerLen := dd.ReadMapStart()
25582 if canChange && v == nil {
25583 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
25584 v = make(map[uint16]int8, xlen)
25585 changed = true
25586 }
25587 if containerLen == 0 {
25588 dd.ReadMapEnd()
25589 return v, changed
25590 }
25591 var mk uint16
25592 var mv int8
25593 hasLen := containerLen > 0
25594 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25595 if esep {
25596 dd.ReadMapElemKey()
25597 }
25598 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25599 if esep {
25600 dd.ReadMapElemValue()
25601 }
25602 if dd.TryDecodeAsNil() {
25603 if v == nil {
25604 } else if d.h.DeleteOnNilMapValue {
25605 delete(v, mk)
25606 } else {
25607 v[mk] = 0
25608 }
25609 continue
25610 }
25611 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
25612 if v != nil {
25613 v[mk] = mv
25614 }
25615 }
25616 dd.ReadMapEnd()
25617 return v, changed
25618}
25619
25620func (d *Decoder) fastpathDecMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
25621 if rv.Kind() == reflect.Ptr {
25622 vp := rv2i(rv).(*map[uint16]int16)
25623 v, changed := fastpathTV.DecMapUint16Int16V(*vp, true, d)
25624 if changed {
25625 *vp = v
25626 }
25627 } else {
25628 fastpathTV.DecMapUint16Int16V(rv2i(rv).(map[uint16]int16), false, d)
25629 }
25630}
25631func (f fastpathT) DecMapUint16Int16X(vp *map[uint16]int16, d *Decoder) {
25632 v, changed := f.DecMapUint16Int16V(*vp, true, d)
25633 if changed {
25634 *vp = v
25635 }
25636}
25637func (_ fastpathT) DecMapUint16Int16V(v map[uint16]int16, canChange bool,
25638 d *Decoder) (_ map[uint16]int16, 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, 4)
25643 v = make(map[uint16]int16, xlen)
25644 changed = true
25645 }
25646 if containerLen == 0 {
25647 dd.ReadMapEnd()
25648 return v, changed
25649 }
25650 var mk uint16
25651 var mv int16
25652 hasLen := containerLen > 0
25653 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25654 if esep {
25655 dd.ReadMapElemKey()
25656 }
25657 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25658 if esep {
25659 dd.ReadMapElemValue()
25660 }
25661 if dd.TryDecodeAsNil() {
25662 if v == nil {
25663 } else if d.h.DeleteOnNilMapValue {
25664 delete(v, mk)
25665 } else {
25666 v[mk] = 0
25667 }
25668 continue
25669 }
25670 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
25671 if v != nil {
25672 v[mk] = mv
25673 }
25674 }
25675 dd.ReadMapEnd()
25676 return v, changed
25677}
25678
25679func (d *Decoder) fastpathDecMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
25680 if rv.Kind() == reflect.Ptr {
25681 vp := rv2i(rv).(*map[uint16]int32)
25682 v, changed := fastpathTV.DecMapUint16Int32V(*vp, true, d)
25683 if changed {
25684 *vp = v
25685 }
25686 } else {
25687 fastpathTV.DecMapUint16Int32V(rv2i(rv).(map[uint16]int32), false, d)
25688 }
25689}
25690func (f fastpathT) DecMapUint16Int32X(vp *map[uint16]int32, d *Decoder) {
25691 v, changed := f.DecMapUint16Int32V(*vp, true, d)
25692 if changed {
25693 *vp = v
25694 }
25695}
25696func (_ fastpathT) DecMapUint16Int32V(v map[uint16]int32, canChange bool,
25697 d *Decoder) (_ map[uint16]int32, changed bool) {
25698 dd, esep := d.d, d.hh.hasElemSeparators()
25699 containerLen := dd.ReadMapStart()
25700 if canChange && v == nil {
25701 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
25702 v = make(map[uint16]int32, xlen)
25703 changed = true
25704 }
25705 if containerLen == 0 {
25706 dd.ReadMapEnd()
25707 return v, changed
25708 }
25709 var mk uint16
25710 var mv int32
25711 hasLen := containerLen > 0
25712 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25713 if esep {
25714 dd.ReadMapElemKey()
25715 }
25716 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25717 if esep {
25718 dd.ReadMapElemValue()
25719 }
25720 if dd.TryDecodeAsNil() {
25721 if v == nil {
25722 } else if d.h.DeleteOnNilMapValue {
25723 delete(v, mk)
25724 } else {
25725 v[mk] = 0
25726 }
25727 continue
25728 }
25729 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
25730 if v != nil {
25731 v[mk] = mv
25732 }
25733 }
25734 dd.ReadMapEnd()
25735 return v, changed
25736}
25737
25738func (d *Decoder) fastpathDecMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
25739 if rv.Kind() == reflect.Ptr {
25740 vp := rv2i(rv).(*map[uint16]int64)
25741 v, changed := fastpathTV.DecMapUint16Int64V(*vp, true, d)
25742 if changed {
25743 *vp = v
25744 }
25745 } else {
25746 fastpathTV.DecMapUint16Int64V(rv2i(rv).(map[uint16]int64), false, d)
25747 }
25748}
25749func (f fastpathT) DecMapUint16Int64X(vp *map[uint16]int64, d *Decoder) {
25750 v, changed := f.DecMapUint16Int64V(*vp, true, d)
25751 if changed {
25752 *vp = v
25753 }
25754}
25755func (_ fastpathT) DecMapUint16Int64V(v map[uint16]int64, canChange bool,
25756 d *Decoder) (_ map[uint16]int64, changed bool) {
25757 dd, esep := d.d, d.hh.hasElemSeparators()
25758 containerLen := dd.ReadMapStart()
25759 if canChange && v == nil {
25760 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25761 v = make(map[uint16]int64, xlen)
25762 changed = true
25763 }
25764 if containerLen == 0 {
25765 dd.ReadMapEnd()
25766 return v, changed
25767 }
25768 var mk uint16
25769 var mv int64
25770 hasLen := containerLen > 0
25771 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25772 if esep {
25773 dd.ReadMapElemKey()
25774 }
25775 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25776 if esep {
25777 dd.ReadMapElemValue()
25778 }
25779 if dd.TryDecodeAsNil() {
25780 if v == nil {
25781 } else if d.h.DeleteOnNilMapValue {
25782 delete(v, mk)
25783 } else {
25784 v[mk] = 0
25785 }
25786 continue
25787 }
25788 mv = dd.DecodeInt64()
25789 if v != nil {
25790 v[mk] = mv
25791 }
25792 }
25793 dd.ReadMapEnd()
25794 return v, changed
25795}
25796
25797func (d *Decoder) fastpathDecMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
25798 if rv.Kind() == reflect.Ptr {
25799 vp := rv2i(rv).(*map[uint16]float32)
25800 v, changed := fastpathTV.DecMapUint16Float32V(*vp, true, d)
25801 if changed {
25802 *vp = v
25803 }
25804 } else {
25805 fastpathTV.DecMapUint16Float32V(rv2i(rv).(map[uint16]float32), false, d)
25806 }
25807}
25808func (f fastpathT) DecMapUint16Float32X(vp *map[uint16]float32, d *Decoder) {
25809 v, changed := f.DecMapUint16Float32V(*vp, true, d)
25810 if changed {
25811 *vp = v
25812 }
25813}
25814func (_ fastpathT) DecMapUint16Float32V(v map[uint16]float32, canChange bool,
25815 d *Decoder) (_ map[uint16]float32, changed bool) {
25816 dd, esep := d.d, d.hh.hasElemSeparators()
25817 containerLen := dd.ReadMapStart()
25818 if canChange && v == nil {
25819 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
25820 v = make(map[uint16]float32, xlen)
25821 changed = true
25822 }
25823 if containerLen == 0 {
25824 dd.ReadMapEnd()
25825 return v, changed
25826 }
25827 var mk uint16
25828 var mv float32
25829 hasLen := containerLen > 0
25830 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25831 if esep {
25832 dd.ReadMapElemKey()
25833 }
25834 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25835 if esep {
25836 dd.ReadMapElemValue()
25837 }
25838 if dd.TryDecodeAsNil() {
25839 if v == nil {
25840 } else if d.h.DeleteOnNilMapValue {
25841 delete(v, mk)
25842 } else {
25843 v[mk] = 0
25844 }
25845 continue
25846 }
25847 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
25848 if v != nil {
25849 v[mk] = mv
25850 }
25851 }
25852 dd.ReadMapEnd()
25853 return v, changed
25854}
25855
25856func (d *Decoder) fastpathDecMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
25857 if rv.Kind() == reflect.Ptr {
25858 vp := rv2i(rv).(*map[uint16]float64)
25859 v, changed := fastpathTV.DecMapUint16Float64V(*vp, true, d)
25860 if changed {
25861 *vp = v
25862 }
25863 } else {
25864 fastpathTV.DecMapUint16Float64V(rv2i(rv).(map[uint16]float64), false, d)
25865 }
25866}
25867func (f fastpathT) DecMapUint16Float64X(vp *map[uint16]float64, d *Decoder) {
25868 v, changed := f.DecMapUint16Float64V(*vp, true, d)
25869 if changed {
25870 *vp = v
25871 }
25872}
25873func (_ fastpathT) DecMapUint16Float64V(v map[uint16]float64, canChange bool,
25874 d *Decoder) (_ map[uint16]float64, changed bool) {
25875 dd, esep := d.d, d.hh.hasElemSeparators()
25876 containerLen := dd.ReadMapStart()
25877 if canChange && v == nil {
25878 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
25879 v = make(map[uint16]float64, xlen)
25880 changed = true
25881 }
25882 if containerLen == 0 {
25883 dd.ReadMapEnd()
25884 return v, changed
25885 }
25886 var mk uint16
25887 var mv float64
25888 hasLen := containerLen > 0
25889 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25890 if esep {
25891 dd.ReadMapElemKey()
25892 }
25893 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25894 if esep {
25895 dd.ReadMapElemValue()
25896 }
25897 if dd.TryDecodeAsNil() {
25898 if v == nil {
25899 } else if d.h.DeleteOnNilMapValue {
25900 delete(v, mk)
25901 } else {
25902 v[mk] = 0
25903 }
25904 continue
25905 }
25906 mv = dd.DecodeFloat64()
25907 if v != nil {
25908 v[mk] = mv
25909 }
25910 }
25911 dd.ReadMapEnd()
25912 return v, changed
25913}
25914
25915func (d *Decoder) fastpathDecMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
25916 if rv.Kind() == reflect.Ptr {
25917 vp := rv2i(rv).(*map[uint16]bool)
25918 v, changed := fastpathTV.DecMapUint16BoolV(*vp, true, d)
25919 if changed {
25920 *vp = v
25921 }
25922 } else {
25923 fastpathTV.DecMapUint16BoolV(rv2i(rv).(map[uint16]bool), false, d)
25924 }
25925}
25926func (f fastpathT) DecMapUint16BoolX(vp *map[uint16]bool, d *Decoder) {
25927 v, changed := f.DecMapUint16BoolV(*vp, true, d)
25928 if changed {
25929 *vp = v
25930 }
25931}
25932func (_ fastpathT) DecMapUint16BoolV(v map[uint16]bool, canChange bool,
25933 d *Decoder) (_ map[uint16]bool, changed bool) {
25934 dd, esep := d.d, d.hh.hasElemSeparators()
25935 containerLen := dd.ReadMapStart()
25936 if canChange && v == nil {
25937 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
25938 v = make(map[uint16]bool, xlen)
25939 changed = true
25940 }
25941 if containerLen == 0 {
25942 dd.ReadMapEnd()
25943 return v, changed
25944 }
25945 var mk uint16
25946 var mv bool
25947 hasLen := containerLen > 0
25948 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
25949 if esep {
25950 dd.ReadMapElemKey()
25951 }
25952 mk = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
25953 if esep {
25954 dd.ReadMapElemValue()
25955 }
25956 if dd.TryDecodeAsNil() {
25957 if v == nil {
25958 } else if d.h.DeleteOnNilMapValue {
25959 delete(v, mk)
25960 } else {
25961 v[mk] = false
25962 }
25963 continue
25964 }
25965 mv = dd.DecodeBool()
25966 if v != nil {
25967 v[mk] = mv
25968 }
25969 }
25970 dd.ReadMapEnd()
25971 return v, changed
25972}
25973
25974func (d *Decoder) fastpathDecMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
25975 if rv.Kind() == reflect.Ptr {
25976 vp := rv2i(rv).(*map[uint32]interface{})
25977 v, changed := fastpathTV.DecMapUint32IntfV(*vp, true, d)
25978 if changed {
25979 *vp = v
25980 }
25981 } else {
25982 fastpathTV.DecMapUint32IntfV(rv2i(rv).(map[uint32]interface{}), false, d)
25983 }
25984}
25985func (f fastpathT) DecMapUint32IntfX(vp *map[uint32]interface{}, d *Decoder) {
25986 v, changed := f.DecMapUint32IntfV(*vp, true, d)
25987 if changed {
25988 *vp = v
25989 }
25990}
25991func (_ fastpathT) DecMapUint32IntfV(v map[uint32]interface{}, canChange bool,
25992 d *Decoder) (_ map[uint32]interface{}, changed bool) {
25993 dd, esep := d.d, d.hh.hasElemSeparators()
25994 containerLen := dd.ReadMapStart()
25995 if canChange && v == nil {
25996 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
25997 v = make(map[uint32]interface{}, xlen)
25998 changed = true
25999 }
26000 if containerLen == 0 {
26001 dd.ReadMapEnd()
26002 return v, changed
26003 }
26004 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
26005 var mk uint32
26006 var mv interface{}
26007 hasLen := containerLen > 0
26008 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26009 if esep {
26010 dd.ReadMapElemKey()
26011 }
26012 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26013 if esep {
26014 dd.ReadMapElemValue()
26015 }
26016 if dd.TryDecodeAsNil() {
26017 if v == nil {
26018 } else if d.h.DeleteOnNilMapValue {
26019 delete(v, mk)
26020 } else {
26021 v[mk] = nil
26022 }
26023 continue
26024 }
26025 if mapGet {
26026 mv = v[mk]
26027 } else {
26028 mv = nil
26029 }
26030 d.decode(&mv)
26031 if v != nil {
26032 v[mk] = mv
26033 }
26034 }
26035 dd.ReadMapEnd()
26036 return v, changed
26037}
26038
26039func (d *Decoder) fastpathDecMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
26040 if rv.Kind() == reflect.Ptr {
26041 vp := rv2i(rv).(*map[uint32]string)
26042 v, changed := fastpathTV.DecMapUint32StringV(*vp, true, d)
26043 if changed {
26044 *vp = v
26045 }
26046 } else {
26047 fastpathTV.DecMapUint32StringV(rv2i(rv).(map[uint32]string), false, d)
26048 }
26049}
26050func (f fastpathT) DecMapUint32StringX(vp *map[uint32]string, d *Decoder) {
26051 v, changed := f.DecMapUint32StringV(*vp, true, d)
26052 if changed {
26053 *vp = v
26054 }
26055}
26056func (_ fastpathT) DecMapUint32StringV(v map[uint32]string, canChange bool,
26057 d *Decoder) (_ map[uint32]string, changed bool) {
26058 dd, esep := d.d, d.hh.hasElemSeparators()
26059 containerLen := dd.ReadMapStart()
26060 if canChange && v == nil {
26061 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
26062 v = make(map[uint32]string, xlen)
26063 changed = true
26064 }
26065 if containerLen == 0 {
26066 dd.ReadMapEnd()
26067 return v, changed
26068 }
26069 var mk uint32
26070 var mv string
26071 hasLen := containerLen > 0
26072 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26073 if esep {
26074 dd.ReadMapElemKey()
26075 }
26076 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26077 if esep {
26078 dd.ReadMapElemValue()
26079 }
26080 if dd.TryDecodeAsNil() {
26081 if v == nil {
26082 } else if d.h.DeleteOnNilMapValue {
26083 delete(v, mk)
26084 } else {
26085 v[mk] = ""
26086 }
26087 continue
26088 }
26089 mv = dd.DecodeString()
26090 if v != nil {
26091 v[mk] = mv
26092 }
26093 }
26094 dd.ReadMapEnd()
26095 return v, changed
26096}
26097
26098func (d *Decoder) fastpathDecMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
26099 if rv.Kind() == reflect.Ptr {
26100 vp := rv2i(rv).(*map[uint32]uint)
26101 v, changed := fastpathTV.DecMapUint32UintV(*vp, true, d)
26102 if changed {
26103 *vp = v
26104 }
26105 } else {
26106 fastpathTV.DecMapUint32UintV(rv2i(rv).(map[uint32]uint), false, d)
26107 }
26108}
26109func (f fastpathT) DecMapUint32UintX(vp *map[uint32]uint, d *Decoder) {
26110 v, changed := f.DecMapUint32UintV(*vp, true, d)
26111 if changed {
26112 *vp = v
26113 }
26114}
26115func (_ fastpathT) DecMapUint32UintV(v map[uint32]uint, canChange bool,
26116 d *Decoder) (_ map[uint32]uint, changed bool) {
26117 dd, esep := d.d, d.hh.hasElemSeparators()
26118 containerLen := dd.ReadMapStart()
26119 if canChange && v == nil {
26120 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26121 v = make(map[uint32]uint, xlen)
26122 changed = true
26123 }
26124 if containerLen == 0 {
26125 dd.ReadMapEnd()
26126 return v, changed
26127 }
26128 var mk uint32
26129 var mv uint
26130 hasLen := containerLen > 0
26131 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26132 if esep {
26133 dd.ReadMapElemKey()
26134 }
26135 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26136 if esep {
26137 dd.ReadMapElemValue()
26138 }
26139 if dd.TryDecodeAsNil() {
26140 if v == nil {
26141 } else if d.h.DeleteOnNilMapValue {
26142 delete(v, mk)
26143 } else {
26144 v[mk] = 0
26145 }
26146 continue
26147 }
26148 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
26149 if v != nil {
26150 v[mk] = mv
26151 }
26152 }
26153 dd.ReadMapEnd()
26154 return v, changed
26155}
26156
26157func (d *Decoder) fastpathDecMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
26158 if rv.Kind() == reflect.Ptr {
26159 vp := rv2i(rv).(*map[uint32]uint8)
26160 v, changed := fastpathTV.DecMapUint32Uint8V(*vp, true, d)
26161 if changed {
26162 *vp = v
26163 }
26164 } else {
26165 fastpathTV.DecMapUint32Uint8V(rv2i(rv).(map[uint32]uint8), false, d)
26166 }
26167}
26168func (f fastpathT) DecMapUint32Uint8X(vp *map[uint32]uint8, d *Decoder) {
26169 v, changed := f.DecMapUint32Uint8V(*vp, true, d)
26170 if changed {
26171 *vp = v
26172 }
26173}
26174func (_ fastpathT) DecMapUint32Uint8V(v map[uint32]uint8, canChange bool,
26175 d *Decoder) (_ map[uint32]uint8, changed bool) {
26176 dd, esep := d.d, d.hh.hasElemSeparators()
26177 containerLen := dd.ReadMapStart()
26178 if canChange && v == nil {
26179 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
26180 v = make(map[uint32]uint8, xlen)
26181 changed = true
26182 }
26183 if containerLen == 0 {
26184 dd.ReadMapEnd()
26185 return v, changed
26186 }
26187 var mk uint32
26188 var mv uint8
26189 hasLen := containerLen > 0
26190 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26191 if esep {
26192 dd.ReadMapElemKey()
26193 }
26194 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26195 if esep {
26196 dd.ReadMapElemValue()
26197 }
26198 if dd.TryDecodeAsNil() {
26199 if v == nil {
26200 } else if d.h.DeleteOnNilMapValue {
26201 delete(v, mk)
26202 } else {
26203 v[mk] = 0
26204 }
26205 continue
26206 }
26207 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
26208 if v != nil {
26209 v[mk] = mv
26210 }
26211 }
26212 dd.ReadMapEnd()
26213 return v, changed
26214}
26215
26216func (d *Decoder) fastpathDecMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
26217 if rv.Kind() == reflect.Ptr {
26218 vp := rv2i(rv).(*map[uint32]uint16)
26219 v, changed := fastpathTV.DecMapUint32Uint16V(*vp, true, d)
26220 if changed {
26221 *vp = v
26222 }
26223 } else {
26224 fastpathTV.DecMapUint32Uint16V(rv2i(rv).(map[uint32]uint16), false, d)
26225 }
26226}
26227func (f fastpathT) DecMapUint32Uint16X(vp *map[uint32]uint16, d *Decoder) {
26228 v, changed := f.DecMapUint32Uint16V(*vp, true, d)
26229 if changed {
26230 *vp = v
26231 }
26232}
26233func (_ fastpathT) DecMapUint32Uint16V(v map[uint32]uint16, canChange bool,
26234 d *Decoder) (_ map[uint32]uint16, changed bool) {
26235 dd, esep := d.d, d.hh.hasElemSeparators()
26236 containerLen := dd.ReadMapStart()
26237 if canChange && v == nil {
26238 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
26239 v = make(map[uint32]uint16, xlen)
26240 changed = true
26241 }
26242 if containerLen == 0 {
26243 dd.ReadMapEnd()
26244 return v, changed
26245 }
26246 var mk uint32
26247 var mv uint16
26248 hasLen := containerLen > 0
26249 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26250 if esep {
26251 dd.ReadMapElemKey()
26252 }
26253 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26254 if esep {
26255 dd.ReadMapElemValue()
26256 }
26257 if dd.TryDecodeAsNil() {
26258 if v == nil {
26259 } else if d.h.DeleteOnNilMapValue {
26260 delete(v, mk)
26261 } else {
26262 v[mk] = 0
26263 }
26264 continue
26265 }
26266 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
26267 if v != nil {
26268 v[mk] = mv
26269 }
26270 }
26271 dd.ReadMapEnd()
26272 return v, changed
26273}
26274
26275func (d *Decoder) fastpathDecMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
26276 if rv.Kind() == reflect.Ptr {
26277 vp := rv2i(rv).(*map[uint32]uint32)
26278 v, changed := fastpathTV.DecMapUint32Uint32V(*vp, true, d)
26279 if changed {
26280 *vp = v
26281 }
26282 } else {
26283 fastpathTV.DecMapUint32Uint32V(rv2i(rv).(map[uint32]uint32), false, d)
26284 }
26285}
26286func (f fastpathT) DecMapUint32Uint32X(vp *map[uint32]uint32, d *Decoder) {
26287 v, changed := f.DecMapUint32Uint32V(*vp, true, d)
26288 if changed {
26289 *vp = v
26290 }
26291}
26292func (_ fastpathT) DecMapUint32Uint32V(v map[uint32]uint32, canChange bool,
26293 d *Decoder) (_ map[uint32]uint32, changed bool) {
26294 dd, esep := d.d, d.hh.hasElemSeparators()
26295 containerLen := dd.ReadMapStart()
26296 if canChange && v == nil {
26297 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
26298 v = make(map[uint32]uint32, xlen)
26299 changed = true
26300 }
26301 if containerLen == 0 {
26302 dd.ReadMapEnd()
26303 return v, changed
26304 }
26305 var mk uint32
26306 var mv uint32
26307 hasLen := containerLen > 0
26308 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26309 if esep {
26310 dd.ReadMapElemKey()
26311 }
26312 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26313 if esep {
26314 dd.ReadMapElemValue()
26315 }
26316 if dd.TryDecodeAsNil() {
26317 if v == nil {
26318 } else if d.h.DeleteOnNilMapValue {
26319 delete(v, mk)
26320 } else {
26321 v[mk] = 0
26322 }
26323 continue
26324 }
26325 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26326 if v != nil {
26327 v[mk] = mv
26328 }
26329 }
26330 dd.ReadMapEnd()
26331 return v, changed
26332}
26333
26334func (d *Decoder) fastpathDecMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
26335 if rv.Kind() == reflect.Ptr {
26336 vp := rv2i(rv).(*map[uint32]uint64)
26337 v, changed := fastpathTV.DecMapUint32Uint64V(*vp, true, d)
26338 if changed {
26339 *vp = v
26340 }
26341 } else {
26342 fastpathTV.DecMapUint32Uint64V(rv2i(rv).(map[uint32]uint64), false, d)
26343 }
26344}
26345func (f fastpathT) DecMapUint32Uint64X(vp *map[uint32]uint64, d *Decoder) {
26346 v, changed := f.DecMapUint32Uint64V(*vp, true, d)
26347 if changed {
26348 *vp = v
26349 }
26350}
26351func (_ fastpathT) DecMapUint32Uint64V(v map[uint32]uint64, canChange bool,
26352 d *Decoder) (_ map[uint32]uint64, changed bool) {
26353 dd, esep := d.d, d.hh.hasElemSeparators()
26354 containerLen := dd.ReadMapStart()
26355 if canChange && v == nil {
26356 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26357 v = make(map[uint32]uint64, xlen)
26358 changed = true
26359 }
26360 if containerLen == 0 {
26361 dd.ReadMapEnd()
26362 return v, changed
26363 }
26364 var mk uint32
26365 var mv uint64
26366 hasLen := containerLen > 0
26367 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26368 if esep {
26369 dd.ReadMapElemKey()
26370 }
26371 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26372 if esep {
26373 dd.ReadMapElemValue()
26374 }
26375 if dd.TryDecodeAsNil() {
26376 if v == nil {
26377 } else if d.h.DeleteOnNilMapValue {
26378 delete(v, mk)
26379 } else {
26380 v[mk] = 0
26381 }
26382 continue
26383 }
26384 mv = dd.DecodeUint64()
26385 if v != nil {
26386 v[mk] = mv
26387 }
26388 }
26389 dd.ReadMapEnd()
26390 return v, changed
26391}
26392
26393func (d *Decoder) fastpathDecMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
26394 if rv.Kind() == reflect.Ptr {
26395 vp := rv2i(rv).(*map[uint32]uintptr)
26396 v, changed := fastpathTV.DecMapUint32UintptrV(*vp, true, d)
26397 if changed {
26398 *vp = v
26399 }
26400 } else {
26401 fastpathTV.DecMapUint32UintptrV(rv2i(rv).(map[uint32]uintptr), false, d)
26402 }
26403}
26404func (f fastpathT) DecMapUint32UintptrX(vp *map[uint32]uintptr, d *Decoder) {
26405 v, changed := f.DecMapUint32UintptrV(*vp, true, d)
26406 if changed {
26407 *vp = v
26408 }
26409}
26410func (_ fastpathT) DecMapUint32UintptrV(v map[uint32]uintptr, canChange bool,
26411 d *Decoder) (_ map[uint32]uintptr, changed bool) {
26412 dd, esep := d.d, d.hh.hasElemSeparators()
26413 containerLen := dd.ReadMapStart()
26414 if canChange && v == nil {
26415 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26416 v = make(map[uint32]uintptr, xlen)
26417 changed = true
26418 }
26419 if containerLen == 0 {
26420 dd.ReadMapEnd()
26421 return v, changed
26422 }
26423 var mk uint32
26424 var mv uintptr
26425 hasLen := containerLen > 0
26426 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26427 if esep {
26428 dd.ReadMapElemKey()
26429 }
26430 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26431 if esep {
26432 dd.ReadMapElemValue()
26433 }
26434 if dd.TryDecodeAsNil() {
26435 if v == nil {
26436 } else if d.h.DeleteOnNilMapValue {
26437 delete(v, mk)
26438 } else {
26439 v[mk] = 0
26440 }
26441 continue
26442 }
26443 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
26444 if v != nil {
26445 v[mk] = mv
26446 }
26447 }
26448 dd.ReadMapEnd()
26449 return v, changed
26450}
26451
26452func (d *Decoder) fastpathDecMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
26453 if rv.Kind() == reflect.Ptr {
26454 vp := rv2i(rv).(*map[uint32]int)
26455 v, changed := fastpathTV.DecMapUint32IntV(*vp, true, d)
26456 if changed {
26457 *vp = v
26458 }
26459 } else {
26460 fastpathTV.DecMapUint32IntV(rv2i(rv).(map[uint32]int), false, d)
26461 }
26462}
26463func (f fastpathT) DecMapUint32IntX(vp *map[uint32]int, d *Decoder) {
26464 v, changed := f.DecMapUint32IntV(*vp, true, d)
26465 if changed {
26466 *vp = v
26467 }
26468}
26469func (_ fastpathT) DecMapUint32IntV(v map[uint32]int, canChange bool,
26470 d *Decoder) (_ map[uint32]int, changed bool) {
26471 dd, esep := d.d, d.hh.hasElemSeparators()
26472 containerLen := dd.ReadMapStart()
26473 if canChange && v == nil {
26474 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26475 v = make(map[uint32]int, xlen)
26476 changed = true
26477 }
26478 if containerLen == 0 {
26479 dd.ReadMapEnd()
26480 return v, changed
26481 }
26482 var mk uint32
26483 var mv int
26484 hasLen := containerLen > 0
26485 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26486 if esep {
26487 dd.ReadMapElemKey()
26488 }
26489 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26490 if esep {
26491 dd.ReadMapElemValue()
26492 }
26493 if dd.TryDecodeAsNil() {
26494 if v == nil {
26495 } else if d.h.DeleteOnNilMapValue {
26496 delete(v, mk)
26497 } else {
26498 v[mk] = 0
26499 }
26500 continue
26501 }
26502 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
26503 if v != nil {
26504 v[mk] = mv
26505 }
26506 }
26507 dd.ReadMapEnd()
26508 return v, changed
26509}
26510
26511func (d *Decoder) fastpathDecMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
26512 if rv.Kind() == reflect.Ptr {
26513 vp := rv2i(rv).(*map[uint32]int8)
26514 v, changed := fastpathTV.DecMapUint32Int8V(*vp, true, d)
26515 if changed {
26516 *vp = v
26517 }
26518 } else {
26519 fastpathTV.DecMapUint32Int8V(rv2i(rv).(map[uint32]int8), false, d)
26520 }
26521}
26522func (f fastpathT) DecMapUint32Int8X(vp *map[uint32]int8, d *Decoder) {
26523 v, changed := f.DecMapUint32Int8V(*vp, true, d)
26524 if changed {
26525 *vp = v
26526 }
26527}
26528func (_ fastpathT) DecMapUint32Int8V(v map[uint32]int8, canChange bool,
26529 d *Decoder) (_ map[uint32]int8, changed bool) {
26530 dd, esep := d.d, d.hh.hasElemSeparators()
26531 containerLen := dd.ReadMapStart()
26532 if canChange && v == nil {
26533 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
26534 v = make(map[uint32]int8, xlen)
26535 changed = true
26536 }
26537 if containerLen == 0 {
26538 dd.ReadMapEnd()
26539 return v, changed
26540 }
26541 var mk uint32
26542 var mv int8
26543 hasLen := containerLen > 0
26544 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26545 if esep {
26546 dd.ReadMapElemKey()
26547 }
26548 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26549 if esep {
26550 dd.ReadMapElemValue()
26551 }
26552 if dd.TryDecodeAsNil() {
26553 if v == nil {
26554 } else if d.h.DeleteOnNilMapValue {
26555 delete(v, mk)
26556 } else {
26557 v[mk] = 0
26558 }
26559 continue
26560 }
26561 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
26562 if v != nil {
26563 v[mk] = mv
26564 }
26565 }
26566 dd.ReadMapEnd()
26567 return v, changed
26568}
26569
26570func (d *Decoder) fastpathDecMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
26571 if rv.Kind() == reflect.Ptr {
26572 vp := rv2i(rv).(*map[uint32]int16)
26573 v, changed := fastpathTV.DecMapUint32Int16V(*vp, true, d)
26574 if changed {
26575 *vp = v
26576 }
26577 } else {
26578 fastpathTV.DecMapUint32Int16V(rv2i(rv).(map[uint32]int16), false, d)
26579 }
26580}
26581func (f fastpathT) DecMapUint32Int16X(vp *map[uint32]int16, d *Decoder) {
26582 v, changed := f.DecMapUint32Int16V(*vp, true, d)
26583 if changed {
26584 *vp = v
26585 }
26586}
26587func (_ fastpathT) DecMapUint32Int16V(v map[uint32]int16, canChange bool,
26588 d *Decoder) (_ map[uint32]int16, changed bool) {
26589 dd, esep := d.d, d.hh.hasElemSeparators()
26590 containerLen := dd.ReadMapStart()
26591 if canChange && v == nil {
26592 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
26593 v = make(map[uint32]int16, xlen)
26594 changed = true
26595 }
26596 if containerLen == 0 {
26597 dd.ReadMapEnd()
26598 return v, changed
26599 }
26600 var mk uint32
26601 var mv int16
26602 hasLen := containerLen > 0
26603 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26604 if esep {
26605 dd.ReadMapElemKey()
26606 }
26607 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26608 if esep {
26609 dd.ReadMapElemValue()
26610 }
26611 if dd.TryDecodeAsNil() {
26612 if v == nil {
26613 } else if d.h.DeleteOnNilMapValue {
26614 delete(v, mk)
26615 } else {
26616 v[mk] = 0
26617 }
26618 continue
26619 }
26620 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
26621 if v != nil {
26622 v[mk] = mv
26623 }
26624 }
26625 dd.ReadMapEnd()
26626 return v, changed
26627}
26628
26629func (d *Decoder) fastpathDecMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
26630 if rv.Kind() == reflect.Ptr {
26631 vp := rv2i(rv).(*map[uint32]int32)
26632 v, changed := fastpathTV.DecMapUint32Int32V(*vp, true, d)
26633 if changed {
26634 *vp = v
26635 }
26636 } else {
26637 fastpathTV.DecMapUint32Int32V(rv2i(rv).(map[uint32]int32), false, d)
26638 }
26639}
26640func (f fastpathT) DecMapUint32Int32X(vp *map[uint32]int32, d *Decoder) {
26641 v, changed := f.DecMapUint32Int32V(*vp, true, d)
26642 if changed {
26643 *vp = v
26644 }
26645}
26646func (_ fastpathT) DecMapUint32Int32V(v map[uint32]int32, canChange bool,
26647 d *Decoder) (_ map[uint32]int32, changed bool) {
26648 dd, esep := d.d, d.hh.hasElemSeparators()
26649 containerLen := dd.ReadMapStart()
26650 if canChange && v == nil {
26651 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
26652 v = make(map[uint32]int32, xlen)
26653 changed = true
26654 }
26655 if containerLen == 0 {
26656 dd.ReadMapEnd()
26657 return v, changed
26658 }
26659 var mk uint32
26660 var mv int32
26661 hasLen := containerLen > 0
26662 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26663 if esep {
26664 dd.ReadMapElemKey()
26665 }
26666 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26667 if esep {
26668 dd.ReadMapElemValue()
26669 }
26670 if dd.TryDecodeAsNil() {
26671 if v == nil {
26672 } else if d.h.DeleteOnNilMapValue {
26673 delete(v, mk)
26674 } else {
26675 v[mk] = 0
26676 }
26677 continue
26678 }
26679 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
26680 if v != nil {
26681 v[mk] = mv
26682 }
26683 }
26684 dd.ReadMapEnd()
26685 return v, changed
26686}
26687
26688func (d *Decoder) fastpathDecMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
26689 if rv.Kind() == reflect.Ptr {
26690 vp := rv2i(rv).(*map[uint32]int64)
26691 v, changed := fastpathTV.DecMapUint32Int64V(*vp, true, d)
26692 if changed {
26693 *vp = v
26694 }
26695 } else {
26696 fastpathTV.DecMapUint32Int64V(rv2i(rv).(map[uint32]int64), false, d)
26697 }
26698}
26699func (f fastpathT) DecMapUint32Int64X(vp *map[uint32]int64, d *Decoder) {
26700 v, changed := f.DecMapUint32Int64V(*vp, true, d)
26701 if changed {
26702 *vp = v
26703 }
26704}
26705func (_ fastpathT) DecMapUint32Int64V(v map[uint32]int64, canChange bool,
26706 d *Decoder) (_ map[uint32]int64, changed bool) {
26707 dd, esep := d.d, d.hh.hasElemSeparators()
26708 containerLen := dd.ReadMapStart()
26709 if canChange && v == nil {
26710 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26711 v = make(map[uint32]int64, xlen)
26712 changed = true
26713 }
26714 if containerLen == 0 {
26715 dd.ReadMapEnd()
26716 return v, changed
26717 }
26718 var mk uint32
26719 var mv int64
26720 hasLen := containerLen > 0
26721 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26722 if esep {
26723 dd.ReadMapElemKey()
26724 }
26725 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26726 if esep {
26727 dd.ReadMapElemValue()
26728 }
26729 if dd.TryDecodeAsNil() {
26730 if v == nil {
26731 } else if d.h.DeleteOnNilMapValue {
26732 delete(v, mk)
26733 } else {
26734 v[mk] = 0
26735 }
26736 continue
26737 }
26738 mv = dd.DecodeInt64()
26739 if v != nil {
26740 v[mk] = mv
26741 }
26742 }
26743 dd.ReadMapEnd()
26744 return v, changed
26745}
26746
26747func (d *Decoder) fastpathDecMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
26748 if rv.Kind() == reflect.Ptr {
26749 vp := rv2i(rv).(*map[uint32]float32)
26750 v, changed := fastpathTV.DecMapUint32Float32V(*vp, true, d)
26751 if changed {
26752 *vp = v
26753 }
26754 } else {
26755 fastpathTV.DecMapUint32Float32V(rv2i(rv).(map[uint32]float32), false, d)
26756 }
26757}
26758func (f fastpathT) DecMapUint32Float32X(vp *map[uint32]float32, d *Decoder) {
26759 v, changed := f.DecMapUint32Float32V(*vp, true, d)
26760 if changed {
26761 *vp = v
26762 }
26763}
26764func (_ fastpathT) DecMapUint32Float32V(v map[uint32]float32, canChange bool,
26765 d *Decoder) (_ map[uint32]float32, changed bool) {
26766 dd, esep := d.d, d.hh.hasElemSeparators()
26767 containerLen := dd.ReadMapStart()
26768 if canChange && v == nil {
26769 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
26770 v = make(map[uint32]float32, xlen)
26771 changed = true
26772 }
26773 if containerLen == 0 {
26774 dd.ReadMapEnd()
26775 return v, changed
26776 }
26777 var mk uint32
26778 var mv float32
26779 hasLen := containerLen > 0
26780 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26781 if esep {
26782 dd.ReadMapElemKey()
26783 }
26784 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26785 if esep {
26786 dd.ReadMapElemValue()
26787 }
26788 if dd.TryDecodeAsNil() {
26789 if v == nil {
26790 } else if d.h.DeleteOnNilMapValue {
26791 delete(v, mk)
26792 } else {
26793 v[mk] = 0
26794 }
26795 continue
26796 }
26797 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
26798 if v != nil {
26799 v[mk] = mv
26800 }
26801 }
26802 dd.ReadMapEnd()
26803 return v, changed
26804}
26805
26806func (d *Decoder) fastpathDecMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
26807 if rv.Kind() == reflect.Ptr {
26808 vp := rv2i(rv).(*map[uint32]float64)
26809 v, changed := fastpathTV.DecMapUint32Float64V(*vp, true, d)
26810 if changed {
26811 *vp = v
26812 }
26813 } else {
26814 fastpathTV.DecMapUint32Float64V(rv2i(rv).(map[uint32]float64), false, d)
26815 }
26816}
26817func (f fastpathT) DecMapUint32Float64X(vp *map[uint32]float64, d *Decoder) {
26818 v, changed := f.DecMapUint32Float64V(*vp, true, d)
26819 if changed {
26820 *vp = v
26821 }
26822}
26823func (_ fastpathT) DecMapUint32Float64V(v map[uint32]float64, canChange bool,
26824 d *Decoder) (_ map[uint32]float64, changed bool) {
26825 dd, esep := d.d, d.hh.hasElemSeparators()
26826 containerLen := dd.ReadMapStart()
26827 if canChange && v == nil {
26828 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
26829 v = make(map[uint32]float64, xlen)
26830 changed = true
26831 }
26832 if containerLen == 0 {
26833 dd.ReadMapEnd()
26834 return v, changed
26835 }
26836 var mk uint32
26837 var mv float64
26838 hasLen := containerLen > 0
26839 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26840 if esep {
26841 dd.ReadMapElemKey()
26842 }
26843 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26844 if esep {
26845 dd.ReadMapElemValue()
26846 }
26847 if dd.TryDecodeAsNil() {
26848 if v == nil {
26849 } else if d.h.DeleteOnNilMapValue {
26850 delete(v, mk)
26851 } else {
26852 v[mk] = 0
26853 }
26854 continue
26855 }
26856 mv = dd.DecodeFloat64()
26857 if v != nil {
26858 v[mk] = mv
26859 }
26860 }
26861 dd.ReadMapEnd()
26862 return v, changed
26863}
26864
26865func (d *Decoder) fastpathDecMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
26866 if rv.Kind() == reflect.Ptr {
26867 vp := rv2i(rv).(*map[uint32]bool)
26868 v, changed := fastpathTV.DecMapUint32BoolV(*vp, true, d)
26869 if changed {
26870 *vp = v
26871 }
26872 } else {
26873 fastpathTV.DecMapUint32BoolV(rv2i(rv).(map[uint32]bool), false, d)
26874 }
26875}
26876func (f fastpathT) DecMapUint32BoolX(vp *map[uint32]bool, d *Decoder) {
26877 v, changed := f.DecMapUint32BoolV(*vp, true, d)
26878 if changed {
26879 *vp = v
26880 }
26881}
26882func (_ fastpathT) DecMapUint32BoolV(v map[uint32]bool, canChange bool,
26883 d *Decoder) (_ map[uint32]bool, changed bool) {
26884 dd, esep := d.d, d.hh.hasElemSeparators()
26885 containerLen := dd.ReadMapStart()
26886 if canChange && v == nil {
26887 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
26888 v = make(map[uint32]bool, xlen)
26889 changed = true
26890 }
26891 if containerLen == 0 {
26892 dd.ReadMapEnd()
26893 return v, changed
26894 }
26895 var mk uint32
26896 var mv bool
26897 hasLen := containerLen > 0
26898 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26899 if esep {
26900 dd.ReadMapElemKey()
26901 }
26902 mk = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
26903 if esep {
26904 dd.ReadMapElemValue()
26905 }
26906 if dd.TryDecodeAsNil() {
26907 if v == nil {
26908 } else if d.h.DeleteOnNilMapValue {
26909 delete(v, mk)
26910 } else {
26911 v[mk] = false
26912 }
26913 continue
26914 }
26915 mv = dd.DecodeBool()
26916 if v != nil {
26917 v[mk] = mv
26918 }
26919 }
26920 dd.ReadMapEnd()
26921 return v, changed
26922}
26923
26924func (d *Decoder) fastpathDecMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
26925 if rv.Kind() == reflect.Ptr {
26926 vp := rv2i(rv).(*map[uint64]interface{})
26927 v, changed := fastpathTV.DecMapUint64IntfV(*vp, true, d)
26928 if changed {
26929 *vp = v
26930 }
26931 } else {
26932 fastpathTV.DecMapUint64IntfV(rv2i(rv).(map[uint64]interface{}), false, d)
26933 }
26934}
26935func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, d *Decoder) {
26936 v, changed := f.DecMapUint64IntfV(*vp, true, d)
26937 if changed {
26938 *vp = v
26939 }
26940}
26941func (_ fastpathT) DecMapUint64IntfV(v map[uint64]interface{}, canChange bool,
26942 d *Decoder) (_ map[uint64]interface{}, changed bool) {
26943 dd, esep := d.d, d.hh.hasElemSeparators()
26944 containerLen := dd.ReadMapStart()
26945 if canChange && v == nil {
26946 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
26947 v = make(map[uint64]interface{}, xlen)
26948 changed = true
26949 }
26950 if containerLen == 0 {
26951 dd.ReadMapEnd()
26952 return v, changed
26953 }
26954 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
26955 var mk uint64
26956 var mv interface{}
26957 hasLen := containerLen > 0
26958 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
26959 if esep {
26960 dd.ReadMapElemKey()
26961 }
26962 mk = dd.DecodeUint64()
26963 if esep {
26964 dd.ReadMapElemValue()
26965 }
26966 if dd.TryDecodeAsNil() {
26967 if v == nil {
26968 } else if d.h.DeleteOnNilMapValue {
26969 delete(v, mk)
26970 } else {
26971 v[mk] = nil
26972 }
26973 continue
26974 }
26975 if mapGet {
26976 mv = v[mk]
26977 } else {
26978 mv = nil
26979 }
26980 d.decode(&mv)
26981 if v != nil {
26982 v[mk] = mv
26983 }
26984 }
26985 dd.ReadMapEnd()
26986 return v, changed
26987}
26988
26989func (d *Decoder) fastpathDecMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
26990 if rv.Kind() == reflect.Ptr {
26991 vp := rv2i(rv).(*map[uint64]string)
26992 v, changed := fastpathTV.DecMapUint64StringV(*vp, true, d)
26993 if changed {
26994 *vp = v
26995 }
26996 } else {
26997 fastpathTV.DecMapUint64StringV(rv2i(rv).(map[uint64]string), false, d)
26998 }
26999}
27000func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, d *Decoder) {
27001 v, changed := f.DecMapUint64StringV(*vp, true, d)
27002 if changed {
27003 *vp = v
27004 }
27005}
27006func (_ fastpathT) DecMapUint64StringV(v map[uint64]string, canChange bool,
27007 d *Decoder) (_ map[uint64]string, changed bool) {
27008 dd, esep := d.d, d.hh.hasElemSeparators()
27009 containerLen := dd.ReadMapStart()
27010 if canChange && v == nil {
27011 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
27012 v = make(map[uint64]string, xlen)
27013 changed = true
27014 }
27015 if containerLen == 0 {
27016 dd.ReadMapEnd()
27017 return v, changed
27018 }
27019 var mk uint64
27020 var mv string
27021 hasLen := containerLen > 0
27022 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27023 if esep {
27024 dd.ReadMapElemKey()
27025 }
27026 mk = dd.DecodeUint64()
27027 if esep {
27028 dd.ReadMapElemValue()
27029 }
27030 if dd.TryDecodeAsNil() {
27031 if v == nil {
27032 } else if d.h.DeleteOnNilMapValue {
27033 delete(v, mk)
27034 } else {
27035 v[mk] = ""
27036 }
27037 continue
27038 }
27039 mv = dd.DecodeString()
27040 if v != nil {
27041 v[mk] = mv
27042 }
27043 }
27044 dd.ReadMapEnd()
27045 return v, changed
27046}
27047
27048func (d *Decoder) fastpathDecMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
27049 if rv.Kind() == reflect.Ptr {
27050 vp := rv2i(rv).(*map[uint64]uint)
27051 v, changed := fastpathTV.DecMapUint64UintV(*vp, true, d)
27052 if changed {
27053 *vp = v
27054 }
27055 } else {
27056 fastpathTV.DecMapUint64UintV(rv2i(rv).(map[uint64]uint), false, d)
27057 }
27058}
27059func (f fastpathT) DecMapUint64UintX(vp *map[uint64]uint, d *Decoder) {
27060 v, changed := f.DecMapUint64UintV(*vp, true, d)
27061 if changed {
27062 *vp = v
27063 }
27064}
27065func (_ fastpathT) DecMapUint64UintV(v map[uint64]uint, canChange bool,
27066 d *Decoder) (_ map[uint64]uint, changed bool) {
27067 dd, esep := d.d, d.hh.hasElemSeparators()
27068 containerLen := dd.ReadMapStart()
27069 if canChange && v == nil {
27070 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27071 v = make(map[uint64]uint, xlen)
27072 changed = true
27073 }
27074 if containerLen == 0 {
27075 dd.ReadMapEnd()
27076 return v, changed
27077 }
27078 var mk uint64
27079 var mv uint
27080 hasLen := containerLen > 0
27081 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27082 if esep {
27083 dd.ReadMapElemKey()
27084 }
27085 mk = dd.DecodeUint64()
27086 if esep {
27087 dd.ReadMapElemValue()
27088 }
27089 if dd.TryDecodeAsNil() {
27090 if v == nil {
27091 } else if d.h.DeleteOnNilMapValue {
27092 delete(v, mk)
27093 } else {
27094 v[mk] = 0
27095 }
27096 continue
27097 }
27098 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
27099 if v != nil {
27100 v[mk] = mv
27101 }
27102 }
27103 dd.ReadMapEnd()
27104 return v, changed
27105}
27106
27107func (d *Decoder) fastpathDecMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
27108 if rv.Kind() == reflect.Ptr {
27109 vp := rv2i(rv).(*map[uint64]uint8)
27110 v, changed := fastpathTV.DecMapUint64Uint8V(*vp, true, d)
27111 if changed {
27112 *vp = v
27113 }
27114 } else {
27115 fastpathTV.DecMapUint64Uint8V(rv2i(rv).(map[uint64]uint8), false, d)
27116 }
27117}
27118func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, d *Decoder) {
27119 v, changed := f.DecMapUint64Uint8V(*vp, true, d)
27120 if changed {
27121 *vp = v
27122 }
27123}
27124func (_ fastpathT) DecMapUint64Uint8V(v map[uint64]uint8, canChange bool,
27125 d *Decoder) (_ map[uint64]uint8, changed bool) {
27126 dd, esep := d.d, d.hh.hasElemSeparators()
27127 containerLen := dd.ReadMapStart()
27128 if canChange && v == nil {
27129 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
27130 v = make(map[uint64]uint8, xlen)
27131 changed = true
27132 }
27133 if containerLen == 0 {
27134 dd.ReadMapEnd()
27135 return v, changed
27136 }
27137 var mk uint64
27138 var mv uint8
27139 hasLen := containerLen > 0
27140 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27141 if esep {
27142 dd.ReadMapElemKey()
27143 }
27144 mk = dd.DecodeUint64()
27145 if esep {
27146 dd.ReadMapElemValue()
27147 }
27148 if dd.TryDecodeAsNil() {
27149 if v == nil {
27150 } else if d.h.DeleteOnNilMapValue {
27151 delete(v, mk)
27152 } else {
27153 v[mk] = 0
27154 }
27155 continue
27156 }
27157 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
27158 if v != nil {
27159 v[mk] = mv
27160 }
27161 }
27162 dd.ReadMapEnd()
27163 return v, changed
27164}
27165
27166func (d *Decoder) fastpathDecMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
27167 if rv.Kind() == reflect.Ptr {
27168 vp := rv2i(rv).(*map[uint64]uint16)
27169 v, changed := fastpathTV.DecMapUint64Uint16V(*vp, true, d)
27170 if changed {
27171 *vp = v
27172 }
27173 } else {
27174 fastpathTV.DecMapUint64Uint16V(rv2i(rv).(map[uint64]uint16), false, d)
27175 }
27176}
27177func (f fastpathT) DecMapUint64Uint16X(vp *map[uint64]uint16, d *Decoder) {
27178 v, changed := f.DecMapUint64Uint16V(*vp, true, d)
27179 if changed {
27180 *vp = v
27181 }
27182}
27183func (_ fastpathT) DecMapUint64Uint16V(v map[uint64]uint16, canChange bool,
27184 d *Decoder) (_ map[uint64]uint16, changed bool) {
27185 dd, esep := d.d, d.hh.hasElemSeparators()
27186 containerLen := dd.ReadMapStart()
27187 if canChange && v == nil {
27188 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
27189 v = make(map[uint64]uint16, xlen)
27190 changed = true
27191 }
27192 if containerLen == 0 {
27193 dd.ReadMapEnd()
27194 return v, changed
27195 }
27196 var mk uint64
27197 var mv uint16
27198 hasLen := containerLen > 0
27199 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27200 if esep {
27201 dd.ReadMapElemKey()
27202 }
27203 mk = dd.DecodeUint64()
27204 if esep {
27205 dd.ReadMapElemValue()
27206 }
27207 if dd.TryDecodeAsNil() {
27208 if v == nil {
27209 } else if d.h.DeleteOnNilMapValue {
27210 delete(v, mk)
27211 } else {
27212 v[mk] = 0
27213 }
27214 continue
27215 }
27216 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
27217 if v != nil {
27218 v[mk] = mv
27219 }
27220 }
27221 dd.ReadMapEnd()
27222 return v, changed
27223}
27224
27225func (d *Decoder) fastpathDecMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
27226 if rv.Kind() == reflect.Ptr {
27227 vp := rv2i(rv).(*map[uint64]uint32)
27228 v, changed := fastpathTV.DecMapUint64Uint32V(*vp, true, d)
27229 if changed {
27230 *vp = v
27231 }
27232 } else {
27233 fastpathTV.DecMapUint64Uint32V(rv2i(rv).(map[uint64]uint32), false, d)
27234 }
27235}
27236func (f fastpathT) DecMapUint64Uint32X(vp *map[uint64]uint32, d *Decoder) {
27237 v, changed := f.DecMapUint64Uint32V(*vp, true, d)
27238 if changed {
27239 *vp = v
27240 }
27241}
27242func (_ fastpathT) DecMapUint64Uint32V(v map[uint64]uint32, canChange bool,
27243 d *Decoder) (_ map[uint64]uint32, changed bool) {
27244 dd, esep := d.d, d.hh.hasElemSeparators()
27245 containerLen := dd.ReadMapStart()
27246 if canChange && v == nil {
27247 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
27248 v = make(map[uint64]uint32, xlen)
27249 changed = true
27250 }
27251 if containerLen == 0 {
27252 dd.ReadMapEnd()
27253 return v, changed
27254 }
27255 var mk uint64
27256 var mv uint32
27257 hasLen := containerLen > 0
27258 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27259 if esep {
27260 dd.ReadMapElemKey()
27261 }
27262 mk = dd.DecodeUint64()
27263 if esep {
27264 dd.ReadMapElemValue()
27265 }
27266 if dd.TryDecodeAsNil() {
27267 if v == nil {
27268 } else if d.h.DeleteOnNilMapValue {
27269 delete(v, mk)
27270 } else {
27271 v[mk] = 0
27272 }
27273 continue
27274 }
27275 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
27276 if v != nil {
27277 v[mk] = mv
27278 }
27279 }
27280 dd.ReadMapEnd()
27281 return v, changed
27282}
27283
27284func (d *Decoder) fastpathDecMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
27285 if rv.Kind() == reflect.Ptr {
27286 vp := rv2i(rv).(*map[uint64]uint64)
27287 v, changed := fastpathTV.DecMapUint64Uint64V(*vp, true, d)
27288 if changed {
27289 *vp = v
27290 }
27291 } else {
27292 fastpathTV.DecMapUint64Uint64V(rv2i(rv).(map[uint64]uint64), false, d)
27293 }
27294}
27295func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, d *Decoder) {
27296 v, changed := f.DecMapUint64Uint64V(*vp, true, d)
27297 if changed {
27298 *vp = v
27299 }
27300}
27301func (_ fastpathT) DecMapUint64Uint64V(v map[uint64]uint64, canChange bool,
27302 d *Decoder) (_ map[uint64]uint64, changed bool) {
27303 dd, esep := d.d, d.hh.hasElemSeparators()
27304 containerLen := dd.ReadMapStart()
27305 if canChange && v == nil {
27306 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27307 v = make(map[uint64]uint64, xlen)
27308 changed = true
27309 }
27310 if containerLen == 0 {
27311 dd.ReadMapEnd()
27312 return v, changed
27313 }
27314 var mk uint64
27315 var mv uint64
27316 hasLen := containerLen > 0
27317 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27318 if esep {
27319 dd.ReadMapElemKey()
27320 }
27321 mk = dd.DecodeUint64()
27322 if esep {
27323 dd.ReadMapElemValue()
27324 }
27325 if dd.TryDecodeAsNil() {
27326 if v == nil {
27327 } else if d.h.DeleteOnNilMapValue {
27328 delete(v, mk)
27329 } else {
27330 v[mk] = 0
27331 }
27332 continue
27333 }
27334 mv = dd.DecodeUint64()
27335 if v != nil {
27336 v[mk] = mv
27337 }
27338 }
27339 dd.ReadMapEnd()
27340 return v, changed
27341}
27342
27343func (d *Decoder) fastpathDecMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
27344 if rv.Kind() == reflect.Ptr {
27345 vp := rv2i(rv).(*map[uint64]uintptr)
27346 v, changed := fastpathTV.DecMapUint64UintptrV(*vp, true, d)
27347 if changed {
27348 *vp = v
27349 }
27350 } else {
27351 fastpathTV.DecMapUint64UintptrV(rv2i(rv).(map[uint64]uintptr), false, d)
27352 }
27353}
27354func (f fastpathT) DecMapUint64UintptrX(vp *map[uint64]uintptr, d *Decoder) {
27355 v, changed := f.DecMapUint64UintptrV(*vp, true, d)
27356 if changed {
27357 *vp = v
27358 }
27359}
27360func (_ fastpathT) DecMapUint64UintptrV(v map[uint64]uintptr, canChange bool,
27361 d *Decoder) (_ map[uint64]uintptr, changed bool) {
27362 dd, esep := d.d, d.hh.hasElemSeparators()
27363 containerLen := dd.ReadMapStart()
27364 if canChange && v == nil {
27365 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27366 v = make(map[uint64]uintptr, xlen)
27367 changed = true
27368 }
27369 if containerLen == 0 {
27370 dd.ReadMapEnd()
27371 return v, changed
27372 }
27373 var mk uint64
27374 var mv uintptr
27375 hasLen := containerLen > 0
27376 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27377 if esep {
27378 dd.ReadMapElemKey()
27379 }
27380 mk = dd.DecodeUint64()
27381 if esep {
27382 dd.ReadMapElemValue()
27383 }
27384 if dd.TryDecodeAsNil() {
27385 if v == nil {
27386 } else if d.h.DeleteOnNilMapValue {
27387 delete(v, mk)
27388 } else {
27389 v[mk] = 0
27390 }
27391 continue
27392 }
27393 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
27394 if v != nil {
27395 v[mk] = mv
27396 }
27397 }
27398 dd.ReadMapEnd()
27399 return v, changed
27400}
27401
27402func (d *Decoder) fastpathDecMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
27403 if rv.Kind() == reflect.Ptr {
27404 vp := rv2i(rv).(*map[uint64]int)
27405 v, changed := fastpathTV.DecMapUint64IntV(*vp, true, d)
27406 if changed {
27407 *vp = v
27408 }
27409 } else {
27410 fastpathTV.DecMapUint64IntV(rv2i(rv).(map[uint64]int), false, d)
27411 }
27412}
27413func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, d *Decoder) {
27414 v, changed := f.DecMapUint64IntV(*vp, true, d)
27415 if changed {
27416 *vp = v
27417 }
27418}
27419func (_ fastpathT) DecMapUint64IntV(v map[uint64]int, canChange bool,
27420 d *Decoder) (_ map[uint64]int, changed bool) {
27421 dd, esep := d.d, d.hh.hasElemSeparators()
27422 containerLen := dd.ReadMapStart()
27423 if canChange && v == nil {
27424 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27425 v = make(map[uint64]int, xlen)
27426 changed = true
27427 }
27428 if containerLen == 0 {
27429 dd.ReadMapEnd()
27430 return v, changed
27431 }
27432 var mk uint64
27433 var mv int
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 = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
27453 if v != nil {
27454 v[mk] = mv
27455 }
27456 }
27457 dd.ReadMapEnd()
27458 return v, changed
27459}
27460
27461func (d *Decoder) fastpathDecMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
27462 if rv.Kind() == reflect.Ptr {
27463 vp := rv2i(rv).(*map[uint64]int8)
27464 v, changed := fastpathTV.DecMapUint64Int8V(*vp, true, d)
27465 if changed {
27466 *vp = v
27467 }
27468 } else {
27469 fastpathTV.DecMapUint64Int8V(rv2i(rv).(map[uint64]int8), false, d)
27470 }
27471}
27472func (f fastpathT) DecMapUint64Int8X(vp *map[uint64]int8, d *Decoder) {
27473 v, changed := f.DecMapUint64Int8V(*vp, true, d)
27474 if changed {
27475 *vp = v
27476 }
27477}
27478func (_ fastpathT) DecMapUint64Int8V(v map[uint64]int8, canChange bool,
27479 d *Decoder) (_ map[uint64]int8, changed bool) {
27480 dd, esep := d.d, d.hh.hasElemSeparators()
27481 containerLen := dd.ReadMapStart()
27482 if canChange && v == nil {
27483 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
27484 v = make(map[uint64]int8, xlen)
27485 changed = true
27486 }
27487 if containerLen == 0 {
27488 dd.ReadMapEnd()
27489 return v, changed
27490 }
27491 var mk uint64
27492 var mv int8
27493 hasLen := containerLen > 0
27494 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27495 if esep {
27496 dd.ReadMapElemKey()
27497 }
27498 mk = dd.DecodeUint64()
27499 if esep {
27500 dd.ReadMapElemValue()
27501 }
27502 if dd.TryDecodeAsNil() {
27503 if v == nil {
27504 } else if d.h.DeleteOnNilMapValue {
27505 delete(v, mk)
27506 } else {
27507 v[mk] = 0
27508 }
27509 continue
27510 }
27511 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
27512 if v != nil {
27513 v[mk] = mv
27514 }
27515 }
27516 dd.ReadMapEnd()
27517 return v, changed
27518}
27519
27520func (d *Decoder) fastpathDecMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
27521 if rv.Kind() == reflect.Ptr {
27522 vp := rv2i(rv).(*map[uint64]int16)
27523 v, changed := fastpathTV.DecMapUint64Int16V(*vp, true, d)
27524 if changed {
27525 *vp = v
27526 }
27527 } else {
27528 fastpathTV.DecMapUint64Int16V(rv2i(rv).(map[uint64]int16), false, d)
27529 }
27530}
27531func (f fastpathT) DecMapUint64Int16X(vp *map[uint64]int16, d *Decoder) {
27532 v, changed := f.DecMapUint64Int16V(*vp, true, d)
27533 if changed {
27534 *vp = v
27535 }
27536}
27537func (_ fastpathT) DecMapUint64Int16V(v map[uint64]int16, canChange bool,
27538 d *Decoder) (_ map[uint64]int16, changed bool) {
27539 dd, esep := d.d, d.hh.hasElemSeparators()
27540 containerLen := dd.ReadMapStart()
27541 if canChange && v == nil {
27542 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
27543 v = make(map[uint64]int16, xlen)
27544 changed = true
27545 }
27546 if containerLen == 0 {
27547 dd.ReadMapEnd()
27548 return v, changed
27549 }
27550 var mk uint64
27551 var mv int16
27552 hasLen := containerLen > 0
27553 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27554 if esep {
27555 dd.ReadMapElemKey()
27556 }
27557 mk = dd.DecodeUint64()
27558 if esep {
27559 dd.ReadMapElemValue()
27560 }
27561 if dd.TryDecodeAsNil() {
27562 if v == nil {
27563 } else if d.h.DeleteOnNilMapValue {
27564 delete(v, mk)
27565 } else {
27566 v[mk] = 0
27567 }
27568 continue
27569 }
27570 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
27571 if v != nil {
27572 v[mk] = mv
27573 }
27574 }
27575 dd.ReadMapEnd()
27576 return v, changed
27577}
27578
27579func (d *Decoder) fastpathDecMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
27580 if rv.Kind() == reflect.Ptr {
27581 vp := rv2i(rv).(*map[uint64]int32)
27582 v, changed := fastpathTV.DecMapUint64Int32V(*vp, true, d)
27583 if changed {
27584 *vp = v
27585 }
27586 } else {
27587 fastpathTV.DecMapUint64Int32V(rv2i(rv).(map[uint64]int32), false, d)
27588 }
27589}
27590func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, d *Decoder) {
27591 v, changed := f.DecMapUint64Int32V(*vp, true, d)
27592 if changed {
27593 *vp = v
27594 }
27595}
27596func (_ fastpathT) DecMapUint64Int32V(v map[uint64]int32, canChange bool,
27597 d *Decoder) (_ map[uint64]int32, changed bool) {
27598 dd, esep := d.d, d.hh.hasElemSeparators()
27599 containerLen := dd.ReadMapStart()
27600 if canChange && v == nil {
27601 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
27602 v = make(map[uint64]int32, xlen)
27603 changed = true
27604 }
27605 if containerLen == 0 {
27606 dd.ReadMapEnd()
27607 return v, changed
27608 }
27609 var mk uint64
27610 var mv int32
27611 hasLen := containerLen > 0
27612 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27613 if esep {
27614 dd.ReadMapElemKey()
27615 }
27616 mk = dd.DecodeUint64()
27617 if esep {
27618 dd.ReadMapElemValue()
27619 }
27620 if dd.TryDecodeAsNil() {
27621 if v == nil {
27622 } else if d.h.DeleteOnNilMapValue {
27623 delete(v, mk)
27624 } else {
27625 v[mk] = 0
27626 }
27627 continue
27628 }
27629 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
27630 if v != nil {
27631 v[mk] = mv
27632 }
27633 }
27634 dd.ReadMapEnd()
27635 return v, changed
27636}
27637
27638func (d *Decoder) fastpathDecMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
27639 if rv.Kind() == reflect.Ptr {
27640 vp := rv2i(rv).(*map[uint64]int64)
27641 v, changed := fastpathTV.DecMapUint64Int64V(*vp, true, d)
27642 if changed {
27643 *vp = v
27644 }
27645 } else {
27646 fastpathTV.DecMapUint64Int64V(rv2i(rv).(map[uint64]int64), false, d)
27647 }
27648}
27649func (f fastpathT) DecMapUint64Int64X(vp *map[uint64]int64, d *Decoder) {
27650 v, changed := f.DecMapUint64Int64V(*vp, true, d)
27651 if changed {
27652 *vp = v
27653 }
27654}
27655func (_ fastpathT) DecMapUint64Int64V(v map[uint64]int64, canChange bool,
27656 d *Decoder) (_ map[uint64]int64, changed bool) {
27657 dd, esep := d.d, d.hh.hasElemSeparators()
27658 containerLen := dd.ReadMapStart()
27659 if canChange && v == nil {
27660 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27661 v = make(map[uint64]int64, xlen)
27662 changed = true
27663 }
27664 if containerLen == 0 {
27665 dd.ReadMapEnd()
27666 return v, changed
27667 }
27668 var mk uint64
27669 var mv int64
27670 hasLen := containerLen > 0
27671 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27672 if esep {
27673 dd.ReadMapElemKey()
27674 }
27675 mk = dd.DecodeUint64()
27676 if esep {
27677 dd.ReadMapElemValue()
27678 }
27679 if dd.TryDecodeAsNil() {
27680 if v == nil {
27681 } else if d.h.DeleteOnNilMapValue {
27682 delete(v, mk)
27683 } else {
27684 v[mk] = 0
27685 }
27686 continue
27687 }
27688 mv = dd.DecodeInt64()
27689 if v != nil {
27690 v[mk] = mv
27691 }
27692 }
27693 dd.ReadMapEnd()
27694 return v, changed
27695}
27696
27697func (d *Decoder) fastpathDecMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
27698 if rv.Kind() == reflect.Ptr {
27699 vp := rv2i(rv).(*map[uint64]float32)
27700 v, changed := fastpathTV.DecMapUint64Float32V(*vp, true, d)
27701 if changed {
27702 *vp = v
27703 }
27704 } else {
27705 fastpathTV.DecMapUint64Float32V(rv2i(rv).(map[uint64]float32), false, d)
27706 }
27707}
27708func (f fastpathT) DecMapUint64Float32X(vp *map[uint64]float32, d *Decoder) {
27709 v, changed := f.DecMapUint64Float32V(*vp, true, d)
27710 if changed {
27711 *vp = v
27712 }
27713}
27714func (_ fastpathT) DecMapUint64Float32V(v map[uint64]float32, canChange bool,
27715 d *Decoder) (_ map[uint64]float32, changed bool) {
27716 dd, esep := d.d, d.hh.hasElemSeparators()
27717 containerLen := dd.ReadMapStart()
27718 if canChange && v == nil {
27719 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
27720 v = make(map[uint64]float32, xlen)
27721 changed = true
27722 }
27723 if containerLen == 0 {
27724 dd.ReadMapEnd()
27725 return v, changed
27726 }
27727 var mk uint64
27728 var mv float32
27729 hasLen := containerLen > 0
27730 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27731 if esep {
27732 dd.ReadMapElemKey()
27733 }
27734 mk = dd.DecodeUint64()
27735 if esep {
27736 dd.ReadMapElemValue()
27737 }
27738 if dd.TryDecodeAsNil() {
27739 if v == nil {
27740 } else if d.h.DeleteOnNilMapValue {
27741 delete(v, mk)
27742 } else {
27743 v[mk] = 0
27744 }
27745 continue
27746 }
27747 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
27748 if v != nil {
27749 v[mk] = mv
27750 }
27751 }
27752 dd.ReadMapEnd()
27753 return v, changed
27754}
27755
27756func (d *Decoder) fastpathDecMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
27757 if rv.Kind() == reflect.Ptr {
27758 vp := rv2i(rv).(*map[uint64]float64)
27759 v, changed := fastpathTV.DecMapUint64Float64V(*vp, true, d)
27760 if changed {
27761 *vp = v
27762 }
27763 } else {
27764 fastpathTV.DecMapUint64Float64V(rv2i(rv).(map[uint64]float64), false, d)
27765 }
27766}
27767func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, d *Decoder) {
27768 v, changed := f.DecMapUint64Float64V(*vp, true, d)
27769 if changed {
27770 *vp = v
27771 }
27772}
27773func (_ fastpathT) DecMapUint64Float64V(v map[uint64]float64, canChange bool,
27774 d *Decoder) (_ map[uint64]float64, changed bool) {
27775 dd, esep := d.d, d.hh.hasElemSeparators()
27776 containerLen := dd.ReadMapStart()
27777 if canChange && v == nil {
27778 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
27779 v = make(map[uint64]float64, xlen)
27780 changed = true
27781 }
27782 if containerLen == 0 {
27783 dd.ReadMapEnd()
27784 return v, changed
27785 }
27786 var mk uint64
27787 var mv float64
27788 hasLen := containerLen > 0
27789 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27790 if esep {
27791 dd.ReadMapElemKey()
27792 }
27793 mk = dd.DecodeUint64()
27794 if esep {
27795 dd.ReadMapElemValue()
27796 }
27797 if dd.TryDecodeAsNil() {
27798 if v == nil {
27799 } else if d.h.DeleteOnNilMapValue {
27800 delete(v, mk)
27801 } else {
27802 v[mk] = 0
27803 }
27804 continue
27805 }
27806 mv = dd.DecodeFloat64()
27807 if v != nil {
27808 v[mk] = mv
27809 }
27810 }
27811 dd.ReadMapEnd()
27812 return v, changed
27813}
27814
27815func (d *Decoder) fastpathDecMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
27816 if rv.Kind() == reflect.Ptr {
27817 vp := rv2i(rv).(*map[uint64]bool)
27818 v, changed := fastpathTV.DecMapUint64BoolV(*vp, true, d)
27819 if changed {
27820 *vp = v
27821 }
27822 } else {
27823 fastpathTV.DecMapUint64BoolV(rv2i(rv).(map[uint64]bool), false, d)
27824 }
27825}
27826func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, d *Decoder) {
27827 v, changed := f.DecMapUint64BoolV(*vp, true, d)
27828 if changed {
27829 *vp = v
27830 }
27831}
27832func (_ fastpathT) DecMapUint64BoolV(v map[uint64]bool, canChange bool,
27833 d *Decoder) (_ map[uint64]bool, changed bool) {
27834 dd, esep := d.d, d.hh.hasElemSeparators()
27835 containerLen := dd.ReadMapStart()
27836 if canChange && v == nil {
27837 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
27838 v = make(map[uint64]bool, xlen)
27839 changed = true
27840 }
27841 if containerLen == 0 {
27842 dd.ReadMapEnd()
27843 return v, changed
27844 }
27845 var mk uint64
27846 var mv bool
27847 hasLen := containerLen > 0
27848 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27849 if esep {
27850 dd.ReadMapElemKey()
27851 }
27852 mk = dd.DecodeUint64()
27853 if esep {
27854 dd.ReadMapElemValue()
27855 }
27856 if dd.TryDecodeAsNil() {
27857 if v == nil {
27858 } else if d.h.DeleteOnNilMapValue {
27859 delete(v, mk)
27860 } else {
27861 v[mk] = false
27862 }
27863 continue
27864 }
27865 mv = dd.DecodeBool()
27866 if v != nil {
27867 v[mk] = mv
27868 }
27869 }
27870 dd.ReadMapEnd()
27871 return v, changed
27872}
27873
27874func (d *Decoder) fastpathDecMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
27875 if rv.Kind() == reflect.Ptr {
27876 vp := rv2i(rv).(*map[uintptr]interface{})
27877 v, changed := fastpathTV.DecMapUintptrIntfV(*vp, true, d)
27878 if changed {
27879 *vp = v
27880 }
27881 } else {
27882 fastpathTV.DecMapUintptrIntfV(rv2i(rv).(map[uintptr]interface{}), false, d)
27883 }
27884}
27885func (f fastpathT) DecMapUintptrIntfX(vp *map[uintptr]interface{}, d *Decoder) {
27886 v, changed := f.DecMapUintptrIntfV(*vp, true, d)
27887 if changed {
27888 *vp = v
27889 }
27890}
27891func (_ fastpathT) DecMapUintptrIntfV(v map[uintptr]interface{}, canChange bool,
27892 d *Decoder) (_ map[uintptr]interface{}, changed bool) {
27893 dd, esep := d.d, d.hh.hasElemSeparators()
27894 containerLen := dd.ReadMapStart()
27895 if canChange && v == nil {
27896 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
27897 v = make(map[uintptr]interface{}, xlen)
27898 changed = true
27899 }
27900 if containerLen == 0 {
27901 dd.ReadMapEnd()
27902 return v, changed
27903 }
27904 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
27905 var mk uintptr
27906 var mv interface{}
27907 hasLen := containerLen > 0
27908 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27909 if esep {
27910 dd.ReadMapElemKey()
27911 }
27912 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
27913 if esep {
27914 dd.ReadMapElemValue()
27915 }
27916 if dd.TryDecodeAsNil() {
27917 if v == nil {
27918 } else if d.h.DeleteOnNilMapValue {
27919 delete(v, mk)
27920 } else {
27921 v[mk] = nil
27922 }
27923 continue
27924 }
27925 if mapGet {
27926 mv = v[mk]
27927 } else {
27928 mv = nil
27929 }
27930 d.decode(&mv)
27931 if v != nil {
27932 v[mk] = mv
27933 }
27934 }
27935 dd.ReadMapEnd()
27936 return v, changed
27937}
27938
27939func (d *Decoder) fastpathDecMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
27940 if rv.Kind() == reflect.Ptr {
27941 vp := rv2i(rv).(*map[uintptr]string)
27942 v, changed := fastpathTV.DecMapUintptrStringV(*vp, true, d)
27943 if changed {
27944 *vp = v
27945 }
27946 } else {
27947 fastpathTV.DecMapUintptrStringV(rv2i(rv).(map[uintptr]string), false, d)
27948 }
27949}
27950func (f fastpathT) DecMapUintptrStringX(vp *map[uintptr]string, d *Decoder) {
27951 v, changed := f.DecMapUintptrStringV(*vp, true, d)
27952 if changed {
27953 *vp = v
27954 }
27955}
27956func (_ fastpathT) DecMapUintptrStringV(v map[uintptr]string, canChange bool,
27957 d *Decoder) (_ map[uintptr]string, changed bool) {
27958 dd, esep := d.d, d.hh.hasElemSeparators()
27959 containerLen := dd.ReadMapStart()
27960 if canChange && v == nil {
27961 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
27962 v = make(map[uintptr]string, xlen)
27963 changed = true
27964 }
27965 if containerLen == 0 {
27966 dd.ReadMapEnd()
27967 return v, changed
27968 }
27969 var mk uintptr
27970 var mv string
27971 hasLen := containerLen > 0
27972 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
27973 if esep {
27974 dd.ReadMapElemKey()
27975 }
27976 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
27977 if esep {
27978 dd.ReadMapElemValue()
27979 }
27980 if dd.TryDecodeAsNil() {
27981 if v == nil {
27982 } else if d.h.DeleteOnNilMapValue {
27983 delete(v, mk)
27984 } else {
27985 v[mk] = ""
27986 }
27987 continue
27988 }
27989 mv = dd.DecodeString()
27990 if v != nil {
27991 v[mk] = mv
27992 }
27993 }
27994 dd.ReadMapEnd()
27995 return v, changed
27996}
27997
27998func (d *Decoder) fastpathDecMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
27999 if rv.Kind() == reflect.Ptr {
28000 vp := rv2i(rv).(*map[uintptr]uint)
28001 v, changed := fastpathTV.DecMapUintptrUintV(*vp, true, d)
28002 if changed {
28003 *vp = v
28004 }
28005 } else {
28006 fastpathTV.DecMapUintptrUintV(rv2i(rv).(map[uintptr]uint), false, d)
28007 }
28008}
28009func (f fastpathT) DecMapUintptrUintX(vp *map[uintptr]uint, d *Decoder) {
28010 v, changed := f.DecMapUintptrUintV(*vp, true, d)
28011 if changed {
28012 *vp = v
28013 }
28014}
28015func (_ fastpathT) DecMapUintptrUintV(v map[uintptr]uint, canChange bool,
28016 d *Decoder) (_ map[uintptr]uint, changed bool) {
28017 dd, esep := d.d, d.hh.hasElemSeparators()
28018 containerLen := dd.ReadMapStart()
28019 if canChange && v == nil {
28020 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28021 v = make(map[uintptr]uint, xlen)
28022 changed = true
28023 }
28024 if containerLen == 0 {
28025 dd.ReadMapEnd()
28026 return v, changed
28027 }
28028 var mk uintptr
28029 var mv uint
28030 hasLen := containerLen > 0
28031 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28032 if esep {
28033 dd.ReadMapElemKey()
28034 }
28035 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28036 if esep {
28037 dd.ReadMapElemValue()
28038 }
28039 if dd.TryDecodeAsNil() {
28040 if v == nil {
28041 } else if d.h.DeleteOnNilMapValue {
28042 delete(v, mk)
28043 } else {
28044 v[mk] = 0
28045 }
28046 continue
28047 }
28048 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28049 if v != nil {
28050 v[mk] = mv
28051 }
28052 }
28053 dd.ReadMapEnd()
28054 return v, changed
28055}
28056
28057func (d *Decoder) fastpathDecMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
28058 if rv.Kind() == reflect.Ptr {
28059 vp := rv2i(rv).(*map[uintptr]uint8)
28060 v, changed := fastpathTV.DecMapUintptrUint8V(*vp, true, d)
28061 if changed {
28062 *vp = v
28063 }
28064 } else {
28065 fastpathTV.DecMapUintptrUint8V(rv2i(rv).(map[uintptr]uint8), false, d)
28066 }
28067}
28068func (f fastpathT) DecMapUintptrUint8X(vp *map[uintptr]uint8, d *Decoder) {
28069 v, changed := f.DecMapUintptrUint8V(*vp, true, d)
28070 if changed {
28071 *vp = v
28072 }
28073}
28074func (_ fastpathT) DecMapUintptrUint8V(v map[uintptr]uint8, canChange bool,
28075 d *Decoder) (_ map[uintptr]uint8, changed bool) {
28076 dd, esep := d.d, d.hh.hasElemSeparators()
28077 containerLen := dd.ReadMapStart()
28078 if canChange && v == nil {
28079 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
28080 v = make(map[uintptr]uint8, xlen)
28081 changed = true
28082 }
28083 if containerLen == 0 {
28084 dd.ReadMapEnd()
28085 return v, changed
28086 }
28087 var mk uintptr
28088 var mv uint8
28089 hasLen := containerLen > 0
28090 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28091 if esep {
28092 dd.ReadMapElemKey()
28093 }
28094 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28095 if esep {
28096 dd.ReadMapElemValue()
28097 }
28098 if dd.TryDecodeAsNil() {
28099 if v == nil {
28100 } else if d.h.DeleteOnNilMapValue {
28101 delete(v, mk)
28102 } else {
28103 v[mk] = 0
28104 }
28105 continue
28106 }
28107 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
28108 if v != nil {
28109 v[mk] = mv
28110 }
28111 }
28112 dd.ReadMapEnd()
28113 return v, changed
28114}
28115
28116func (d *Decoder) fastpathDecMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
28117 if rv.Kind() == reflect.Ptr {
28118 vp := rv2i(rv).(*map[uintptr]uint16)
28119 v, changed := fastpathTV.DecMapUintptrUint16V(*vp, true, d)
28120 if changed {
28121 *vp = v
28122 }
28123 } else {
28124 fastpathTV.DecMapUintptrUint16V(rv2i(rv).(map[uintptr]uint16), false, d)
28125 }
28126}
28127func (f fastpathT) DecMapUintptrUint16X(vp *map[uintptr]uint16, d *Decoder) {
28128 v, changed := f.DecMapUintptrUint16V(*vp, true, d)
28129 if changed {
28130 *vp = v
28131 }
28132}
28133func (_ fastpathT) DecMapUintptrUint16V(v map[uintptr]uint16, canChange bool,
28134 d *Decoder) (_ map[uintptr]uint16, changed bool) {
28135 dd, esep := d.d, d.hh.hasElemSeparators()
28136 containerLen := dd.ReadMapStart()
28137 if canChange && v == nil {
28138 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
28139 v = make(map[uintptr]uint16, xlen)
28140 changed = true
28141 }
28142 if containerLen == 0 {
28143 dd.ReadMapEnd()
28144 return v, changed
28145 }
28146 var mk uintptr
28147 var mv uint16
28148 hasLen := containerLen > 0
28149 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28150 if esep {
28151 dd.ReadMapElemKey()
28152 }
28153 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28154 if esep {
28155 dd.ReadMapElemValue()
28156 }
28157 if dd.TryDecodeAsNil() {
28158 if v == nil {
28159 } else if d.h.DeleteOnNilMapValue {
28160 delete(v, mk)
28161 } else {
28162 v[mk] = 0
28163 }
28164 continue
28165 }
28166 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
28167 if v != nil {
28168 v[mk] = mv
28169 }
28170 }
28171 dd.ReadMapEnd()
28172 return v, changed
28173}
28174
28175func (d *Decoder) fastpathDecMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
28176 if rv.Kind() == reflect.Ptr {
28177 vp := rv2i(rv).(*map[uintptr]uint32)
28178 v, changed := fastpathTV.DecMapUintptrUint32V(*vp, true, d)
28179 if changed {
28180 *vp = v
28181 }
28182 } else {
28183 fastpathTV.DecMapUintptrUint32V(rv2i(rv).(map[uintptr]uint32), false, d)
28184 }
28185}
28186func (f fastpathT) DecMapUintptrUint32X(vp *map[uintptr]uint32, d *Decoder) {
28187 v, changed := f.DecMapUintptrUint32V(*vp, true, d)
28188 if changed {
28189 *vp = v
28190 }
28191}
28192func (_ fastpathT) DecMapUintptrUint32V(v map[uintptr]uint32, canChange bool,
28193 d *Decoder) (_ map[uintptr]uint32, changed bool) {
28194 dd, esep := d.d, d.hh.hasElemSeparators()
28195 containerLen := dd.ReadMapStart()
28196 if canChange && v == nil {
28197 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
28198 v = make(map[uintptr]uint32, xlen)
28199 changed = true
28200 }
28201 if containerLen == 0 {
28202 dd.ReadMapEnd()
28203 return v, changed
28204 }
28205 var mk uintptr
28206 var mv uint32
28207 hasLen := containerLen > 0
28208 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28209 if esep {
28210 dd.ReadMapElemKey()
28211 }
28212 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28213 if esep {
28214 dd.ReadMapElemValue()
28215 }
28216 if dd.TryDecodeAsNil() {
28217 if v == nil {
28218 } else if d.h.DeleteOnNilMapValue {
28219 delete(v, mk)
28220 } else {
28221 v[mk] = 0
28222 }
28223 continue
28224 }
28225 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
28226 if v != nil {
28227 v[mk] = mv
28228 }
28229 }
28230 dd.ReadMapEnd()
28231 return v, changed
28232}
28233
28234func (d *Decoder) fastpathDecMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
28235 if rv.Kind() == reflect.Ptr {
28236 vp := rv2i(rv).(*map[uintptr]uint64)
28237 v, changed := fastpathTV.DecMapUintptrUint64V(*vp, true, d)
28238 if changed {
28239 *vp = v
28240 }
28241 } else {
28242 fastpathTV.DecMapUintptrUint64V(rv2i(rv).(map[uintptr]uint64), false, d)
28243 }
28244}
28245func (f fastpathT) DecMapUintptrUint64X(vp *map[uintptr]uint64, d *Decoder) {
28246 v, changed := f.DecMapUintptrUint64V(*vp, true, d)
28247 if changed {
28248 *vp = v
28249 }
28250}
28251func (_ fastpathT) DecMapUintptrUint64V(v map[uintptr]uint64, canChange bool,
28252 d *Decoder) (_ map[uintptr]uint64, changed bool) {
28253 dd, esep := d.d, d.hh.hasElemSeparators()
28254 containerLen := dd.ReadMapStart()
28255 if canChange && v == nil {
28256 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28257 v = make(map[uintptr]uint64, xlen)
28258 changed = true
28259 }
28260 if containerLen == 0 {
28261 dd.ReadMapEnd()
28262 return v, changed
28263 }
28264 var mk uintptr
28265 var mv uint64
28266 hasLen := containerLen > 0
28267 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28268 if esep {
28269 dd.ReadMapElemKey()
28270 }
28271 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28272 if esep {
28273 dd.ReadMapElemValue()
28274 }
28275 if dd.TryDecodeAsNil() {
28276 if v == nil {
28277 } else if d.h.DeleteOnNilMapValue {
28278 delete(v, mk)
28279 } else {
28280 v[mk] = 0
28281 }
28282 continue
28283 }
28284 mv = dd.DecodeUint64()
28285 if v != nil {
28286 v[mk] = mv
28287 }
28288 }
28289 dd.ReadMapEnd()
28290 return v, changed
28291}
28292
28293func (d *Decoder) fastpathDecMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
28294 if rv.Kind() == reflect.Ptr {
28295 vp := rv2i(rv).(*map[uintptr]uintptr)
28296 v, changed := fastpathTV.DecMapUintptrUintptrV(*vp, true, d)
28297 if changed {
28298 *vp = v
28299 }
28300 } else {
28301 fastpathTV.DecMapUintptrUintptrV(rv2i(rv).(map[uintptr]uintptr), false, d)
28302 }
28303}
28304func (f fastpathT) DecMapUintptrUintptrX(vp *map[uintptr]uintptr, d *Decoder) {
28305 v, changed := f.DecMapUintptrUintptrV(*vp, true, d)
28306 if changed {
28307 *vp = v
28308 }
28309}
28310func (_ fastpathT) DecMapUintptrUintptrV(v map[uintptr]uintptr, canChange bool,
28311 d *Decoder) (_ map[uintptr]uintptr, changed bool) {
28312 dd, esep := d.d, d.hh.hasElemSeparators()
28313 containerLen := dd.ReadMapStart()
28314 if canChange && v == nil {
28315 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28316 v = make(map[uintptr]uintptr, xlen)
28317 changed = true
28318 }
28319 if containerLen == 0 {
28320 dd.ReadMapEnd()
28321 return v, changed
28322 }
28323 var mk uintptr
28324 var mv uintptr
28325 hasLen := containerLen > 0
28326 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28327 if esep {
28328 dd.ReadMapElemKey()
28329 }
28330 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28331 if esep {
28332 dd.ReadMapElemValue()
28333 }
28334 if dd.TryDecodeAsNil() {
28335 if v == nil {
28336 } else if d.h.DeleteOnNilMapValue {
28337 delete(v, mk)
28338 } else {
28339 v[mk] = 0
28340 }
28341 continue
28342 }
28343 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28344 if v != nil {
28345 v[mk] = mv
28346 }
28347 }
28348 dd.ReadMapEnd()
28349 return v, changed
28350}
28351
28352func (d *Decoder) fastpathDecMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
28353 if rv.Kind() == reflect.Ptr {
28354 vp := rv2i(rv).(*map[uintptr]int)
28355 v, changed := fastpathTV.DecMapUintptrIntV(*vp, true, d)
28356 if changed {
28357 *vp = v
28358 }
28359 } else {
28360 fastpathTV.DecMapUintptrIntV(rv2i(rv).(map[uintptr]int), false, d)
28361 }
28362}
28363func (f fastpathT) DecMapUintptrIntX(vp *map[uintptr]int, d *Decoder) {
28364 v, changed := f.DecMapUintptrIntV(*vp, true, d)
28365 if changed {
28366 *vp = v
28367 }
28368}
28369func (_ fastpathT) DecMapUintptrIntV(v map[uintptr]int, canChange bool,
28370 d *Decoder) (_ map[uintptr]int, changed bool) {
28371 dd, esep := d.d, d.hh.hasElemSeparators()
28372 containerLen := dd.ReadMapStart()
28373 if canChange && v == nil {
28374 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28375 v = make(map[uintptr]int, xlen)
28376 changed = true
28377 }
28378 if containerLen == 0 {
28379 dd.ReadMapEnd()
28380 return v, changed
28381 }
28382 var mk uintptr
28383 var mv int
28384 hasLen := containerLen > 0
28385 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28386 if esep {
28387 dd.ReadMapElemKey()
28388 }
28389 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28390 if esep {
28391 dd.ReadMapElemValue()
28392 }
28393 if dd.TryDecodeAsNil() {
28394 if v == nil {
28395 } else if d.h.DeleteOnNilMapValue {
28396 delete(v, mk)
28397 } else {
28398 v[mk] = 0
28399 }
28400 continue
28401 }
28402 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
28403 if v != nil {
28404 v[mk] = mv
28405 }
28406 }
28407 dd.ReadMapEnd()
28408 return v, changed
28409}
28410
28411func (d *Decoder) fastpathDecMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
28412 if rv.Kind() == reflect.Ptr {
28413 vp := rv2i(rv).(*map[uintptr]int8)
28414 v, changed := fastpathTV.DecMapUintptrInt8V(*vp, true, d)
28415 if changed {
28416 *vp = v
28417 }
28418 } else {
28419 fastpathTV.DecMapUintptrInt8V(rv2i(rv).(map[uintptr]int8), false, d)
28420 }
28421}
28422func (f fastpathT) DecMapUintptrInt8X(vp *map[uintptr]int8, d *Decoder) {
28423 v, changed := f.DecMapUintptrInt8V(*vp, true, d)
28424 if changed {
28425 *vp = v
28426 }
28427}
28428func (_ fastpathT) DecMapUintptrInt8V(v map[uintptr]int8, canChange bool,
28429 d *Decoder) (_ map[uintptr]int8, changed bool) {
28430 dd, esep := d.d, d.hh.hasElemSeparators()
28431 containerLen := dd.ReadMapStart()
28432 if canChange && v == nil {
28433 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
28434 v = make(map[uintptr]int8, xlen)
28435 changed = true
28436 }
28437 if containerLen == 0 {
28438 dd.ReadMapEnd()
28439 return v, changed
28440 }
28441 var mk uintptr
28442 var mv int8
28443 hasLen := containerLen > 0
28444 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28445 if esep {
28446 dd.ReadMapElemKey()
28447 }
28448 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28449 if esep {
28450 dd.ReadMapElemValue()
28451 }
28452 if dd.TryDecodeAsNil() {
28453 if v == nil {
28454 } else if d.h.DeleteOnNilMapValue {
28455 delete(v, mk)
28456 } else {
28457 v[mk] = 0
28458 }
28459 continue
28460 }
28461 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
28462 if v != nil {
28463 v[mk] = mv
28464 }
28465 }
28466 dd.ReadMapEnd()
28467 return v, changed
28468}
28469
28470func (d *Decoder) fastpathDecMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
28471 if rv.Kind() == reflect.Ptr {
28472 vp := rv2i(rv).(*map[uintptr]int16)
28473 v, changed := fastpathTV.DecMapUintptrInt16V(*vp, true, d)
28474 if changed {
28475 *vp = v
28476 }
28477 } else {
28478 fastpathTV.DecMapUintptrInt16V(rv2i(rv).(map[uintptr]int16), false, d)
28479 }
28480}
28481func (f fastpathT) DecMapUintptrInt16X(vp *map[uintptr]int16, d *Decoder) {
28482 v, changed := f.DecMapUintptrInt16V(*vp, true, d)
28483 if changed {
28484 *vp = v
28485 }
28486}
28487func (_ fastpathT) DecMapUintptrInt16V(v map[uintptr]int16, canChange bool,
28488 d *Decoder) (_ map[uintptr]int16, changed bool) {
28489 dd, esep := d.d, d.hh.hasElemSeparators()
28490 containerLen := dd.ReadMapStart()
28491 if canChange && v == nil {
28492 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
28493 v = make(map[uintptr]int16, xlen)
28494 changed = true
28495 }
28496 if containerLen == 0 {
28497 dd.ReadMapEnd()
28498 return v, changed
28499 }
28500 var mk uintptr
28501 var mv int16
28502 hasLen := containerLen > 0
28503 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28504 if esep {
28505 dd.ReadMapElemKey()
28506 }
28507 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28508 if esep {
28509 dd.ReadMapElemValue()
28510 }
28511 if dd.TryDecodeAsNil() {
28512 if v == nil {
28513 } else if d.h.DeleteOnNilMapValue {
28514 delete(v, mk)
28515 } else {
28516 v[mk] = 0
28517 }
28518 continue
28519 }
28520 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
28521 if v != nil {
28522 v[mk] = mv
28523 }
28524 }
28525 dd.ReadMapEnd()
28526 return v, changed
28527}
28528
28529func (d *Decoder) fastpathDecMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
28530 if rv.Kind() == reflect.Ptr {
28531 vp := rv2i(rv).(*map[uintptr]int32)
28532 v, changed := fastpathTV.DecMapUintptrInt32V(*vp, true, d)
28533 if changed {
28534 *vp = v
28535 }
28536 } else {
28537 fastpathTV.DecMapUintptrInt32V(rv2i(rv).(map[uintptr]int32), false, d)
28538 }
28539}
28540func (f fastpathT) DecMapUintptrInt32X(vp *map[uintptr]int32, d *Decoder) {
28541 v, changed := f.DecMapUintptrInt32V(*vp, true, d)
28542 if changed {
28543 *vp = v
28544 }
28545}
28546func (_ fastpathT) DecMapUintptrInt32V(v map[uintptr]int32, canChange bool,
28547 d *Decoder) (_ map[uintptr]int32, changed bool) {
28548 dd, esep := d.d, d.hh.hasElemSeparators()
28549 containerLen := dd.ReadMapStart()
28550 if canChange && v == nil {
28551 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
28552 v = make(map[uintptr]int32, xlen)
28553 changed = true
28554 }
28555 if containerLen == 0 {
28556 dd.ReadMapEnd()
28557 return v, changed
28558 }
28559 var mk uintptr
28560 var mv int32
28561 hasLen := containerLen > 0
28562 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28563 if esep {
28564 dd.ReadMapElemKey()
28565 }
28566 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28567 if esep {
28568 dd.ReadMapElemValue()
28569 }
28570 if dd.TryDecodeAsNil() {
28571 if v == nil {
28572 } else if d.h.DeleteOnNilMapValue {
28573 delete(v, mk)
28574 } else {
28575 v[mk] = 0
28576 }
28577 continue
28578 }
28579 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
28580 if v != nil {
28581 v[mk] = mv
28582 }
28583 }
28584 dd.ReadMapEnd()
28585 return v, changed
28586}
28587
28588func (d *Decoder) fastpathDecMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
28589 if rv.Kind() == reflect.Ptr {
28590 vp := rv2i(rv).(*map[uintptr]int64)
28591 v, changed := fastpathTV.DecMapUintptrInt64V(*vp, true, d)
28592 if changed {
28593 *vp = v
28594 }
28595 } else {
28596 fastpathTV.DecMapUintptrInt64V(rv2i(rv).(map[uintptr]int64), false, d)
28597 }
28598}
28599func (f fastpathT) DecMapUintptrInt64X(vp *map[uintptr]int64, d *Decoder) {
28600 v, changed := f.DecMapUintptrInt64V(*vp, true, d)
28601 if changed {
28602 *vp = v
28603 }
28604}
28605func (_ fastpathT) DecMapUintptrInt64V(v map[uintptr]int64, canChange bool,
28606 d *Decoder) (_ map[uintptr]int64, changed bool) {
28607 dd, esep := d.d, d.hh.hasElemSeparators()
28608 containerLen := dd.ReadMapStart()
28609 if canChange && v == nil {
28610 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28611 v = make(map[uintptr]int64, xlen)
28612 changed = true
28613 }
28614 if containerLen == 0 {
28615 dd.ReadMapEnd()
28616 return v, changed
28617 }
28618 var mk uintptr
28619 var mv int64
28620 hasLen := containerLen > 0
28621 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28622 if esep {
28623 dd.ReadMapElemKey()
28624 }
28625 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28626 if esep {
28627 dd.ReadMapElemValue()
28628 }
28629 if dd.TryDecodeAsNil() {
28630 if v == nil {
28631 } else if d.h.DeleteOnNilMapValue {
28632 delete(v, mk)
28633 } else {
28634 v[mk] = 0
28635 }
28636 continue
28637 }
28638 mv = dd.DecodeInt64()
28639 if v != nil {
28640 v[mk] = mv
28641 }
28642 }
28643 dd.ReadMapEnd()
28644 return v, changed
28645}
28646
28647func (d *Decoder) fastpathDecMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
28648 if rv.Kind() == reflect.Ptr {
28649 vp := rv2i(rv).(*map[uintptr]float32)
28650 v, changed := fastpathTV.DecMapUintptrFloat32V(*vp, true, d)
28651 if changed {
28652 *vp = v
28653 }
28654 } else {
28655 fastpathTV.DecMapUintptrFloat32V(rv2i(rv).(map[uintptr]float32), false, d)
28656 }
28657}
28658func (f fastpathT) DecMapUintptrFloat32X(vp *map[uintptr]float32, d *Decoder) {
28659 v, changed := f.DecMapUintptrFloat32V(*vp, true, d)
28660 if changed {
28661 *vp = v
28662 }
28663}
28664func (_ fastpathT) DecMapUintptrFloat32V(v map[uintptr]float32, canChange bool,
28665 d *Decoder) (_ map[uintptr]float32, changed bool) {
28666 dd, esep := d.d, d.hh.hasElemSeparators()
28667 containerLen := dd.ReadMapStart()
28668 if canChange && v == nil {
28669 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
28670 v = make(map[uintptr]float32, xlen)
28671 changed = true
28672 }
28673 if containerLen == 0 {
28674 dd.ReadMapEnd()
28675 return v, changed
28676 }
28677 var mk uintptr
28678 var mv float32
28679 hasLen := containerLen > 0
28680 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28681 if esep {
28682 dd.ReadMapElemKey()
28683 }
28684 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28685 if esep {
28686 dd.ReadMapElemValue()
28687 }
28688 if dd.TryDecodeAsNil() {
28689 if v == nil {
28690 } else if d.h.DeleteOnNilMapValue {
28691 delete(v, mk)
28692 } else {
28693 v[mk] = 0
28694 }
28695 continue
28696 }
28697 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
28698 if v != nil {
28699 v[mk] = mv
28700 }
28701 }
28702 dd.ReadMapEnd()
28703 return v, changed
28704}
28705
28706func (d *Decoder) fastpathDecMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
28707 if rv.Kind() == reflect.Ptr {
28708 vp := rv2i(rv).(*map[uintptr]float64)
28709 v, changed := fastpathTV.DecMapUintptrFloat64V(*vp, true, d)
28710 if changed {
28711 *vp = v
28712 }
28713 } else {
28714 fastpathTV.DecMapUintptrFloat64V(rv2i(rv).(map[uintptr]float64), false, d)
28715 }
28716}
28717func (f fastpathT) DecMapUintptrFloat64X(vp *map[uintptr]float64, d *Decoder) {
28718 v, changed := f.DecMapUintptrFloat64V(*vp, true, d)
28719 if changed {
28720 *vp = v
28721 }
28722}
28723func (_ fastpathT) DecMapUintptrFloat64V(v map[uintptr]float64, canChange bool,
28724 d *Decoder) (_ map[uintptr]float64, changed bool) {
28725 dd, esep := d.d, d.hh.hasElemSeparators()
28726 containerLen := dd.ReadMapStart()
28727 if canChange && v == nil {
28728 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28729 v = make(map[uintptr]float64, xlen)
28730 changed = true
28731 }
28732 if containerLen == 0 {
28733 dd.ReadMapEnd()
28734 return v, changed
28735 }
28736 var mk uintptr
28737 var mv float64
28738 hasLen := containerLen > 0
28739 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28740 if esep {
28741 dd.ReadMapElemKey()
28742 }
28743 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28744 if esep {
28745 dd.ReadMapElemValue()
28746 }
28747 if dd.TryDecodeAsNil() {
28748 if v == nil {
28749 } else if d.h.DeleteOnNilMapValue {
28750 delete(v, mk)
28751 } else {
28752 v[mk] = 0
28753 }
28754 continue
28755 }
28756 mv = dd.DecodeFloat64()
28757 if v != nil {
28758 v[mk] = mv
28759 }
28760 }
28761 dd.ReadMapEnd()
28762 return v, changed
28763}
28764
28765func (d *Decoder) fastpathDecMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
28766 if rv.Kind() == reflect.Ptr {
28767 vp := rv2i(rv).(*map[uintptr]bool)
28768 v, changed := fastpathTV.DecMapUintptrBoolV(*vp, true, d)
28769 if changed {
28770 *vp = v
28771 }
28772 } else {
28773 fastpathTV.DecMapUintptrBoolV(rv2i(rv).(map[uintptr]bool), false, d)
28774 }
28775}
28776func (f fastpathT) DecMapUintptrBoolX(vp *map[uintptr]bool, d *Decoder) {
28777 v, changed := f.DecMapUintptrBoolV(*vp, true, d)
28778 if changed {
28779 *vp = v
28780 }
28781}
28782func (_ fastpathT) DecMapUintptrBoolV(v map[uintptr]bool, canChange bool,
28783 d *Decoder) (_ map[uintptr]bool, changed bool) {
28784 dd, esep := d.d, d.hh.hasElemSeparators()
28785 containerLen := dd.ReadMapStart()
28786 if canChange && v == nil {
28787 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
28788 v = make(map[uintptr]bool, xlen)
28789 changed = true
28790 }
28791 if containerLen == 0 {
28792 dd.ReadMapEnd()
28793 return v, changed
28794 }
28795 var mk uintptr
28796 var mv bool
28797 hasLen := containerLen > 0
28798 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28799 if esep {
28800 dd.ReadMapElemKey()
28801 }
28802 mk = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28803 if esep {
28804 dd.ReadMapElemValue()
28805 }
28806 if dd.TryDecodeAsNil() {
28807 if v == nil {
28808 } else if d.h.DeleteOnNilMapValue {
28809 delete(v, mk)
28810 } else {
28811 v[mk] = false
28812 }
28813 continue
28814 }
28815 mv = dd.DecodeBool()
28816 if v != nil {
28817 v[mk] = mv
28818 }
28819 }
28820 dd.ReadMapEnd()
28821 return v, changed
28822}
28823
28824func (d *Decoder) fastpathDecMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
28825 if rv.Kind() == reflect.Ptr {
28826 vp := rv2i(rv).(*map[int]interface{})
28827 v, changed := fastpathTV.DecMapIntIntfV(*vp, true, d)
28828 if changed {
28829 *vp = v
28830 }
28831 } else {
28832 fastpathTV.DecMapIntIntfV(rv2i(rv).(map[int]interface{}), false, d)
28833 }
28834}
28835func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, d *Decoder) {
28836 v, changed := f.DecMapIntIntfV(*vp, true, d)
28837 if changed {
28838 *vp = v
28839 }
28840}
28841func (_ fastpathT) DecMapIntIntfV(v map[int]interface{}, canChange bool,
28842 d *Decoder) (_ map[int]interface{}, changed bool) {
28843 dd, esep := d.d, d.hh.hasElemSeparators()
28844 containerLen := dd.ReadMapStart()
28845 if canChange && v == nil {
28846 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
28847 v = make(map[int]interface{}, xlen)
28848 changed = true
28849 }
28850 if containerLen == 0 {
28851 dd.ReadMapEnd()
28852 return v, changed
28853 }
28854 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
28855 var mk int
28856 var mv interface{}
28857 hasLen := containerLen > 0
28858 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28859 if esep {
28860 dd.ReadMapElemKey()
28861 }
28862 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
28863 if esep {
28864 dd.ReadMapElemValue()
28865 }
28866 if dd.TryDecodeAsNil() {
28867 if v == nil {
28868 } else if d.h.DeleteOnNilMapValue {
28869 delete(v, mk)
28870 } else {
28871 v[mk] = nil
28872 }
28873 continue
28874 }
28875 if mapGet {
28876 mv = v[mk]
28877 } else {
28878 mv = nil
28879 }
28880 d.decode(&mv)
28881 if v != nil {
28882 v[mk] = mv
28883 }
28884 }
28885 dd.ReadMapEnd()
28886 return v, changed
28887}
28888
28889func (d *Decoder) fastpathDecMapIntStringR(f *codecFnInfo, rv reflect.Value) {
28890 if rv.Kind() == reflect.Ptr {
28891 vp := rv2i(rv).(*map[int]string)
28892 v, changed := fastpathTV.DecMapIntStringV(*vp, true, d)
28893 if changed {
28894 *vp = v
28895 }
28896 } else {
28897 fastpathTV.DecMapIntStringV(rv2i(rv).(map[int]string), false, d)
28898 }
28899}
28900func (f fastpathT) DecMapIntStringX(vp *map[int]string, d *Decoder) {
28901 v, changed := f.DecMapIntStringV(*vp, true, d)
28902 if changed {
28903 *vp = v
28904 }
28905}
28906func (_ fastpathT) DecMapIntStringV(v map[int]string, canChange bool,
28907 d *Decoder) (_ map[int]string, changed bool) {
28908 dd, esep := d.d, d.hh.hasElemSeparators()
28909 containerLen := dd.ReadMapStart()
28910 if canChange && v == nil {
28911 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
28912 v = make(map[int]string, xlen)
28913 changed = true
28914 }
28915 if containerLen == 0 {
28916 dd.ReadMapEnd()
28917 return v, changed
28918 }
28919 var mk int
28920 var mv string
28921 hasLen := containerLen > 0
28922 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28923 if esep {
28924 dd.ReadMapElemKey()
28925 }
28926 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
28927 if esep {
28928 dd.ReadMapElemValue()
28929 }
28930 if dd.TryDecodeAsNil() {
28931 if v == nil {
28932 } else if d.h.DeleteOnNilMapValue {
28933 delete(v, mk)
28934 } else {
28935 v[mk] = ""
28936 }
28937 continue
28938 }
28939 mv = dd.DecodeString()
28940 if v != nil {
28941 v[mk] = mv
28942 }
28943 }
28944 dd.ReadMapEnd()
28945 return v, changed
28946}
28947
28948func (d *Decoder) fastpathDecMapIntUintR(f *codecFnInfo, rv reflect.Value) {
28949 if rv.Kind() == reflect.Ptr {
28950 vp := rv2i(rv).(*map[int]uint)
28951 v, changed := fastpathTV.DecMapIntUintV(*vp, true, d)
28952 if changed {
28953 *vp = v
28954 }
28955 } else {
28956 fastpathTV.DecMapIntUintV(rv2i(rv).(map[int]uint), false, d)
28957 }
28958}
28959func (f fastpathT) DecMapIntUintX(vp *map[int]uint, d *Decoder) {
28960 v, changed := f.DecMapIntUintV(*vp, true, d)
28961 if changed {
28962 *vp = v
28963 }
28964}
28965func (_ fastpathT) DecMapIntUintV(v map[int]uint, canChange bool,
28966 d *Decoder) (_ map[int]uint, changed bool) {
28967 dd, esep := d.d, d.hh.hasElemSeparators()
28968 containerLen := dd.ReadMapStart()
28969 if canChange && v == nil {
28970 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
28971 v = make(map[int]uint, xlen)
28972 changed = true
28973 }
28974 if containerLen == 0 {
28975 dd.ReadMapEnd()
28976 return v, changed
28977 }
28978 var mk int
28979 var mv uint
28980 hasLen := containerLen > 0
28981 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
28982 if esep {
28983 dd.ReadMapElemKey()
28984 }
28985 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
28986 if esep {
28987 dd.ReadMapElemValue()
28988 }
28989 if dd.TryDecodeAsNil() {
28990 if v == nil {
28991 } else if d.h.DeleteOnNilMapValue {
28992 delete(v, mk)
28993 } else {
28994 v[mk] = 0
28995 }
28996 continue
28997 }
28998 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
28999 if v != nil {
29000 v[mk] = mv
29001 }
29002 }
29003 dd.ReadMapEnd()
29004 return v, changed
29005}
29006
29007func (d *Decoder) fastpathDecMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
29008 if rv.Kind() == reflect.Ptr {
29009 vp := rv2i(rv).(*map[int]uint8)
29010 v, changed := fastpathTV.DecMapIntUint8V(*vp, true, d)
29011 if changed {
29012 *vp = v
29013 }
29014 } else {
29015 fastpathTV.DecMapIntUint8V(rv2i(rv).(map[int]uint8), false, d)
29016 }
29017}
29018func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, d *Decoder) {
29019 v, changed := f.DecMapIntUint8V(*vp, true, d)
29020 if changed {
29021 *vp = v
29022 }
29023}
29024func (_ fastpathT) DecMapIntUint8V(v map[int]uint8, canChange bool,
29025 d *Decoder) (_ map[int]uint8, changed bool) {
29026 dd, esep := d.d, d.hh.hasElemSeparators()
29027 containerLen := dd.ReadMapStart()
29028 if canChange && v == nil {
29029 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
29030 v = make(map[int]uint8, xlen)
29031 changed = true
29032 }
29033 if containerLen == 0 {
29034 dd.ReadMapEnd()
29035 return v, changed
29036 }
29037 var mk int
29038 var mv uint8
29039 hasLen := containerLen > 0
29040 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29041 if esep {
29042 dd.ReadMapElemKey()
29043 }
29044 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29045 if esep {
29046 dd.ReadMapElemValue()
29047 }
29048 if dd.TryDecodeAsNil() {
29049 if v == nil {
29050 } else if d.h.DeleteOnNilMapValue {
29051 delete(v, mk)
29052 } else {
29053 v[mk] = 0
29054 }
29055 continue
29056 }
29057 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
29058 if v != nil {
29059 v[mk] = mv
29060 }
29061 }
29062 dd.ReadMapEnd()
29063 return v, changed
29064}
29065
29066func (d *Decoder) fastpathDecMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
29067 if rv.Kind() == reflect.Ptr {
29068 vp := rv2i(rv).(*map[int]uint16)
29069 v, changed := fastpathTV.DecMapIntUint16V(*vp, true, d)
29070 if changed {
29071 *vp = v
29072 }
29073 } else {
29074 fastpathTV.DecMapIntUint16V(rv2i(rv).(map[int]uint16), false, d)
29075 }
29076}
29077func (f fastpathT) DecMapIntUint16X(vp *map[int]uint16, d *Decoder) {
29078 v, changed := f.DecMapIntUint16V(*vp, true, d)
29079 if changed {
29080 *vp = v
29081 }
29082}
29083func (_ fastpathT) DecMapIntUint16V(v map[int]uint16, canChange bool,
29084 d *Decoder) (_ map[int]uint16, changed bool) {
29085 dd, esep := d.d, d.hh.hasElemSeparators()
29086 containerLen := dd.ReadMapStart()
29087 if canChange && v == nil {
29088 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
29089 v = make(map[int]uint16, xlen)
29090 changed = true
29091 }
29092 if containerLen == 0 {
29093 dd.ReadMapEnd()
29094 return v, changed
29095 }
29096 var mk int
29097 var mv uint16
29098 hasLen := containerLen > 0
29099 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29100 if esep {
29101 dd.ReadMapElemKey()
29102 }
29103 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29104 if esep {
29105 dd.ReadMapElemValue()
29106 }
29107 if dd.TryDecodeAsNil() {
29108 if v == nil {
29109 } else if d.h.DeleteOnNilMapValue {
29110 delete(v, mk)
29111 } else {
29112 v[mk] = 0
29113 }
29114 continue
29115 }
29116 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
29117 if v != nil {
29118 v[mk] = mv
29119 }
29120 }
29121 dd.ReadMapEnd()
29122 return v, changed
29123}
29124
29125func (d *Decoder) fastpathDecMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
29126 if rv.Kind() == reflect.Ptr {
29127 vp := rv2i(rv).(*map[int]uint32)
29128 v, changed := fastpathTV.DecMapIntUint32V(*vp, true, d)
29129 if changed {
29130 *vp = v
29131 }
29132 } else {
29133 fastpathTV.DecMapIntUint32V(rv2i(rv).(map[int]uint32), false, d)
29134 }
29135}
29136func (f fastpathT) DecMapIntUint32X(vp *map[int]uint32, d *Decoder) {
29137 v, changed := f.DecMapIntUint32V(*vp, true, d)
29138 if changed {
29139 *vp = v
29140 }
29141}
29142func (_ fastpathT) DecMapIntUint32V(v map[int]uint32, canChange bool,
29143 d *Decoder) (_ map[int]uint32, changed bool) {
29144 dd, esep := d.d, d.hh.hasElemSeparators()
29145 containerLen := dd.ReadMapStart()
29146 if canChange && v == nil {
29147 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29148 v = make(map[int]uint32, xlen)
29149 changed = true
29150 }
29151 if containerLen == 0 {
29152 dd.ReadMapEnd()
29153 return v, changed
29154 }
29155 var mk int
29156 var mv uint32
29157 hasLen := containerLen > 0
29158 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29159 if esep {
29160 dd.ReadMapElemKey()
29161 }
29162 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29163 if esep {
29164 dd.ReadMapElemValue()
29165 }
29166 if dd.TryDecodeAsNil() {
29167 if v == nil {
29168 } else if d.h.DeleteOnNilMapValue {
29169 delete(v, mk)
29170 } else {
29171 v[mk] = 0
29172 }
29173 continue
29174 }
29175 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
29176 if v != nil {
29177 v[mk] = mv
29178 }
29179 }
29180 dd.ReadMapEnd()
29181 return v, changed
29182}
29183
29184func (d *Decoder) fastpathDecMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
29185 if rv.Kind() == reflect.Ptr {
29186 vp := rv2i(rv).(*map[int]uint64)
29187 v, changed := fastpathTV.DecMapIntUint64V(*vp, true, d)
29188 if changed {
29189 *vp = v
29190 }
29191 } else {
29192 fastpathTV.DecMapIntUint64V(rv2i(rv).(map[int]uint64), false, d)
29193 }
29194}
29195func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, d *Decoder) {
29196 v, changed := f.DecMapIntUint64V(*vp, true, d)
29197 if changed {
29198 *vp = v
29199 }
29200}
29201func (_ fastpathT) DecMapIntUint64V(v map[int]uint64, canChange bool,
29202 d *Decoder) (_ map[int]uint64, changed bool) {
29203 dd, esep := d.d, d.hh.hasElemSeparators()
29204 containerLen := dd.ReadMapStart()
29205 if canChange && v == nil {
29206 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29207 v = make(map[int]uint64, xlen)
29208 changed = true
29209 }
29210 if containerLen == 0 {
29211 dd.ReadMapEnd()
29212 return v, changed
29213 }
29214 var mk int
29215 var mv uint64
29216 hasLen := containerLen > 0
29217 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29218 if esep {
29219 dd.ReadMapElemKey()
29220 }
29221 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29222 if esep {
29223 dd.ReadMapElemValue()
29224 }
29225 if dd.TryDecodeAsNil() {
29226 if v == nil {
29227 } else if d.h.DeleteOnNilMapValue {
29228 delete(v, mk)
29229 } else {
29230 v[mk] = 0
29231 }
29232 continue
29233 }
29234 mv = dd.DecodeUint64()
29235 if v != nil {
29236 v[mk] = mv
29237 }
29238 }
29239 dd.ReadMapEnd()
29240 return v, changed
29241}
29242
29243func (d *Decoder) fastpathDecMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
29244 if rv.Kind() == reflect.Ptr {
29245 vp := rv2i(rv).(*map[int]uintptr)
29246 v, changed := fastpathTV.DecMapIntUintptrV(*vp, true, d)
29247 if changed {
29248 *vp = v
29249 }
29250 } else {
29251 fastpathTV.DecMapIntUintptrV(rv2i(rv).(map[int]uintptr), false, d)
29252 }
29253}
29254func (f fastpathT) DecMapIntUintptrX(vp *map[int]uintptr, d *Decoder) {
29255 v, changed := f.DecMapIntUintptrV(*vp, true, d)
29256 if changed {
29257 *vp = v
29258 }
29259}
29260func (_ fastpathT) DecMapIntUintptrV(v map[int]uintptr, canChange bool,
29261 d *Decoder) (_ map[int]uintptr, 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, 16)
29266 v = make(map[int]uintptr, xlen)
29267 changed = true
29268 }
29269 if containerLen == 0 {
29270 dd.ReadMapEnd()
29271 return v, changed
29272 }
29273 var mk int
29274 var mv uintptr
29275 hasLen := containerLen > 0
29276 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29277 if esep {
29278 dd.ReadMapElemKey()
29279 }
29280 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29281 if esep {
29282 dd.ReadMapElemValue()
29283 }
29284 if dd.TryDecodeAsNil() {
29285 if v == nil {
29286 } else if d.h.DeleteOnNilMapValue {
29287 delete(v, mk)
29288 } else {
29289 v[mk] = 0
29290 }
29291 continue
29292 }
29293 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29294 if v != nil {
29295 v[mk] = mv
29296 }
29297 }
29298 dd.ReadMapEnd()
29299 return v, changed
29300}
29301
29302func (d *Decoder) fastpathDecMapIntIntR(f *codecFnInfo, rv reflect.Value) {
29303 if rv.Kind() == reflect.Ptr {
29304 vp := rv2i(rv).(*map[int]int)
29305 v, changed := fastpathTV.DecMapIntIntV(*vp, true, d)
29306 if changed {
29307 *vp = v
29308 }
29309 } else {
29310 fastpathTV.DecMapIntIntV(rv2i(rv).(map[int]int), false, d)
29311 }
29312}
29313func (f fastpathT) DecMapIntIntX(vp *map[int]int, d *Decoder) {
29314 v, changed := f.DecMapIntIntV(*vp, true, d)
29315 if changed {
29316 *vp = v
29317 }
29318}
29319func (_ fastpathT) DecMapIntIntV(v map[int]int, canChange bool,
29320 d *Decoder) (_ map[int]int, changed bool) {
29321 dd, esep := d.d, d.hh.hasElemSeparators()
29322 containerLen := dd.ReadMapStart()
29323 if canChange && v == nil {
29324 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29325 v = make(map[int]int, xlen)
29326 changed = true
29327 }
29328 if containerLen == 0 {
29329 dd.ReadMapEnd()
29330 return v, changed
29331 }
29332 var mk int
29333 var mv int
29334 hasLen := containerLen > 0
29335 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29336 if esep {
29337 dd.ReadMapElemKey()
29338 }
29339 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29340 if esep {
29341 dd.ReadMapElemValue()
29342 }
29343 if dd.TryDecodeAsNil() {
29344 if v == nil {
29345 } else if d.h.DeleteOnNilMapValue {
29346 delete(v, mk)
29347 } else {
29348 v[mk] = 0
29349 }
29350 continue
29351 }
29352 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29353 if v != nil {
29354 v[mk] = mv
29355 }
29356 }
29357 dd.ReadMapEnd()
29358 return v, changed
29359}
29360
29361func (d *Decoder) fastpathDecMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
29362 if rv.Kind() == reflect.Ptr {
29363 vp := rv2i(rv).(*map[int]int8)
29364 v, changed := fastpathTV.DecMapIntInt8V(*vp, true, d)
29365 if changed {
29366 *vp = v
29367 }
29368 } else {
29369 fastpathTV.DecMapIntInt8V(rv2i(rv).(map[int]int8), false, d)
29370 }
29371}
29372func (f fastpathT) DecMapIntInt8X(vp *map[int]int8, d *Decoder) {
29373 v, changed := f.DecMapIntInt8V(*vp, true, d)
29374 if changed {
29375 *vp = v
29376 }
29377}
29378func (_ fastpathT) DecMapIntInt8V(v map[int]int8, canChange bool,
29379 d *Decoder) (_ map[int]int8, changed bool) {
29380 dd, esep := d.d, d.hh.hasElemSeparators()
29381 containerLen := dd.ReadMapStart()
29382 if canChange && v == nil {
29383 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
29384 v = make(map[int]int8, xlen)
29385 changed = true
29386 }
29387 if containerLen == 0 {
29388 dd.ReadMapEnd()
29389 return v, changed
29390 }
29391 var mk int
29392 var mv int8
29393 hasLen := containerLen > 0
29394 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29395 if esep {
29396 dd.ReadMapElemKey()
29397 }
29398 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29399 if esep {
29400 dd.ReadMapElemValue()
29401 }
29402 if dd.TryDecodeAsNil() {
29403 if v == nil {
29404 } else if d.h.DeleteOnNilMapValue {
29405 delete(v, mk)
29406 } else {
29407 v[mk] = 0
29408 }
29409 continue
29410 }
29411 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
29412 if v != nil {
29413 v[mk] = mv
29414 }
29415 }
29416 dd.ReadMapEnd()
29417 return v, changed
29418}
29419
29420func (d *Decoder) fastpathDecMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
29421 if rv.Kind() == reflect.Ptr {
29422 vp := rv2i(rv).(*map[int]int16)
29423 v, changed := fastpathTV.DecMapIntInt16V(*vp, true, d)
29424 if changed {
29425 *vp = v
29426 }
29427 } else {
29428 fastpathTV.DecMapIntInt16V(rv2i(rv).(map[int]int16), false, d)
29429 }
29430}
29431func (f fastpathT) DecMapIntInt16X(vp *map[int]int16, d *Decoder) {
29432 v, changed := f.DecMapIntInt16V(*vp, true, d)
29433 if changed {
29434 *vp = v
29435 }
29436}
29437func (_ fastpathT) DecMapIntInt16V(v map[int]int16, canChange bool,
29438 d *Decoder) (_ map[int]int16, changed bool) {
29439 dd, esep := d.d, d.hh.hasElemSeparators()
29440 containerLen := dd.ReadMapStart()
29441 if canChange && v == nil {
29442 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
29443 v = make(map[int]int16, xlen)
29444 changed = true
29445 }
29446 if containerLen == 0 {
29447 dd.ReadMapEnd()
29448 return v, changed
29449 }
29450 var mk int
29451 var mv int16
29452 hasLen := containerLen > 0
29453 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29454 if esep {
29455 dd.ReadMapElemKey()
29456 }
29457 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29458 if esep {
29459 dd.ReadMapElemValue()
29460 }
29461 if dd.TryDecodeAsNil() {
29462 if v == nil {
29463 } else if d.h.DeleteOnNilMapValue {
29464 delete(v, mk)
29465 } else {
29466 v[mk] = 0
29467 }
29468 continue
29469 }
29470 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
29471 if v != nil {
29472 v[mk] = mv
29473 }
29474 }
29475 dd.ReadMapEnd()
29476 return v, changed
29477}
29478
29479func (d *Decoder) fastpathDecMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
29480 if rv.Kind() == reflect.Ptr {
29481 vp := rv2i(rv).(*map[int]int32)
29482 v, changed := fastpathTV.DecMapIntInt32V(*vp, true, d)
29483 if changed {
29484 *vp = v
29485 }
29486 } else {
29487 fastpathTV.DecMapIntInt32V(rv2i(rv).(map[int]int32), false, d)
29488 }
29489}
29490func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, d *Decoder) {
29491 v, changed := f.DecMapIntInt32V(*vp, true, d)
29492 if changed {
29493 *vp = v
29494 }
29495}
29496func (_ fastpathT) DecMapIntInt32V(v map[int]int32, canChange bool,
29497 d *Decoder) (_ map[int]int32, changed bool) {
29498 dd, esep := d.d, d.hh.hasElemSeparators()
29499 containerLen := dd.ReadMapStart()
29500 if canChange && v == nil {
29501 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29502 v = make(map[int]int32, xlen)
29503 changed = true
29504 }
29505 if containerLen == 0 {
29506 dd.ReadMapEnd()
29507 return v, changed
29508 }
29509 var mk int
29510 var mv int32
29511 hasLen := containerLen > 0
29512 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29513 if esep {
29514 dd.ReadMapElemKey()
29515 }
29516 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29517 if esep {
29518 dd.ReadMapElemValue()
29519 }
29520 if dd.TryDecodeAsNil() {
29521 if v == nil {
29522 } else if d.h.DeleteOnNilMapValue {
29523 delete(v, mk)
29524 } else {
29525 v[mk] = 0
29526 }
29527 continue
29528 }
29529 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
29530 if v != nil {
29531 v[mk] = mv
29532 }
29533 }
29534 dd.ReadMapEnd()
29535 return v, changed
29536}
29537
29538func (d *Decoder) fastpathDecMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
29539 if rv.Kind() == reflect.Ptr {
29540 vp := rv2i(rv).(*map[int]int64)
29541 v, changed := fastpathTV.DecMapIntInt64V(*vp, true, d)
29542 if changed {
29543 *vp = v
29544 }
29545 } else {
29546 fastpathTV.DecMapIntInt64V(rv2i(rv).(map[int]int64), false, d)
29547 }
29548}
29549func (f fastpathT) DecMapIntInt64X(vp *map[int]int64, d *Decoder) {
29550 v, changed := f.DecMapIntInt64V(*vp, true, d)
29551 if changed {
29552 *vp = v
29553 }
29554}
29555func (_ fastpathT) DecMapIntInt64V(v map[int]int64, canChange bool,
29556 d *Decoder) (_ map[int]int64, changed bool) {
29557 dd, esep := d.d, d.hh.hasElemSeparators()
29558 containerLen := dd.ReadMapStart()
29559 if canChange && v == nil {
29560 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29561 v = make(map[int]int64, xlen)
29562 changed = true
29563 }
29564 if containerLen == 0 {
29565 dd.ReadMapEnd()
29566 return v, changed
29567 }
29568 var mk int
29569 var mv int64
29570 hasLen := containerLen > 0
29571 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29572 if esep {
29573 dd.ReadMapElemKey()
29574 }
29575 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29576 if esep {
29577 dd.ReadMapElemValue()
29578 }
29579 if dd.TryDecodeAsNil() {
29580 if v == nil {
29581 } else if d.h.DeleteOnNilMapValue {
29582 delete(v, mk)
29583 } else {
29584 v[mk] = 0
29585 }
29586 continue
29587 }
29588 mv = dd.DecodeInt64()
29589 if v != nil {
29590 v[mk] = mv
29591 }
29592 }
29593 dd.ReadMapEnd()
29594 return v, changed
29595}
29596
29597func (d *Decoder) fastpathDecMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
29598 if rv.Kind() == reflect.Ptr {
29599 vp := rv2i(rv).(*map[int]float32)
29600 v, changed := fastpathTV.DecMapIntFloat32V(*vp, true, d)
29601 if changed {
29602 *vp = v
29603 }
29604 } else {
29605 fastpathTV.DecMapIntFloat32V(rv2i(rv).(map[int]float32), false, d)
29606 }
29607}
29608func (f fastpathT) DecMapIntFloat32X(vp *map[int]float32, d *Decoder) {
29609 v, changed := f.DecMapIntFloat32V(*vp, true, d)
29610 if changed {
29611 *vp = v
29612 }
29613}
29614func (_ fastpathT) DecMapIntFloat32V(v map[int]float32, canChange bool,
29615 d *Decoder) (_ map[int]float32, changed bool) {
29616 dd, esep := d.d, d.hh.hasElemSeparators()
29617 containerLen := dd.ReadMapStart()
29618 if canChange && v == nil {
29619 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
29620 v = make(map[int]float32, xlen)
29621 changed = true
29622 }
29623 if containerLen == 0 {
29624 dd.ReadMapEnd()
29625 return v, changed
29626 }
29627 var mk int
29628 var mv float32
29629 hasLen := containerLen > 0
29630 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29631 if esep {
29632 dd.ReadMapElemKey()
29633 }
29634 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29635 if esep {
29636 dd.ReadMapElemValue()
29637 }
29638 if dd.TryDecodeAsNil() {
29639 if v == nil {
29640 } else if d.h.DeleteOnNilMapValue {
29641 delete(v, mk)
29642 } else {
29643 v[mk] = 0
29644 }
29645 continue
29646 }
29647 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
29648 if v != nil {
29649 v[mk] = mv
29650 }
29651 }
29652 dd.ReadMapEnd()
29653 return v, changed
29654}
29655
29656func (d *Decoder) fastpathDecMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
29657 if rv.Kind() == reflect.Ptr {
29658 vp := rv2i(rv).(*map[int]float64)
29659 v, changed := fastpathTV.DecMapIntFloat64V(*vp, true, d)
29660 if changed {
29661 *vp = v
29662 }
29663 } else {
29664 fastpathTV.DecMapIntFloat64V(rv2i(rv).(map[int]float64), false, d)
29665 }
29666}
29667func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, d *Decoder) {
29668 v, changed := f.DecMapIntFloat64V(*vp, true, d)
29669 if changed {
29670 *vp = v
29671 }
29672}
29673func (_ fastpathT) DecMapIntFloat64V(v map[int]float64, canChange bool,
29674 d *Decoder) (_ map[int]float64, changed bool) {
29675 dd, esep := d.d, d.hh.hasElemSeparators()
29676 containerLen := dd.ReadMapStart()
29677 if canChange && v == nil {
29678 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
29679 v = make(map[int]float64, xlen)
29680 changed = true
29681 }
29682 if containerLen == 0 {
29683 dd.ReadMapEnd()
29684 return v, changed
29685 }
29686 var mk int
29687 var mv float64
29688 hasLen := containerLen > 0
29689 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29690 if esep {
29691 dd.ReadMapElemKey()
29692 }
29693 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29694 if esep {
29695 dd.ReadMapElemValue()
29696 }
29697 if dd.TryDecodeAsNil() {
29698 if v == nil {
29699 } else if d.h.DeleteOnNilMapValue {
29700 delete(v, mk)
29701 } else {
29702 v[mk] = 0
29703 }
29704 continue
29705 }
29706 mv = dd.DecodeFloat64()
29707 if v != nil {
29708 v[mk] = mv
29709 }
29710 }
29711 dd.ReadMapEnd()
29712 return v, changed
29713}
29714
29715func (d *Decoder) fastpathDecMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
29716 if rv.Kind() == reflect.Ptr {
29717 vp := rv2i(rv).(*map[int]bool)
29718 v, changed := fastpathTV.DecMapIntBoolV(*vp, true, d)
29719 if changed {
29720 *vp = v
29721 }
29722 } else {
29723 fastpathTV.DecMapIntBoolV(rv2i(rv).(map[int]bool), false, d)
29724 }
29725}
29726func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, d *Decoder) {
29727 v, changed := f.DecMapIntBoolV(*vp, true, d)
29728 if changed {
29729 *vp = v
29730 }
29731}
29732func (_ fastpathT) DecMapIntBoolV(v map[int]bool, canChange bool,
29733 d *Decoder) (_ map[int]bool, changed bool) {
29734 dd, esep := d.d, d.hh.hasElemSeparators()
29735 containerLen := dd.ReadMapStart()
29736 if canChange && v == nil {
29737 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
29738 v = make(map[int]bool, xlen)
29739 changed = true
29740 }
29741 if containerLen == 0 {
29742 dd.ReadMapEnd()
29743 return v, changed
29744 }
29745 var mk int
29746 var mv bool
29747 hasLen := containerLen > 0
29748 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29749 if esep {
29750 dd.ReadMapElemKey()
29751 }
29752 mk = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
29753 if esep {
29754 dd.ReadMapElemValue()
29755 }
29756 if dd.TryDecodeAsNil() {
29757 if v == nil {
29758 } else if d.h.DeleteOnNilMapValue {
29759 delete(v, mk)
29760 } else {
29761 v[mk] = false
29762 }
29763 continue
29764 }
29765 mv = dd.DecodeBool()
29766 if v != nil {
29767 v[mk] = mv
29768 }
29769 }
29770 dd.ReadMapEnd()
29771 return v, changed
29772}
29773
29774func (d *Decoder) fastpathDecMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
29775 if rv.Kind() == reflect.Ptr {
29776 vp := rv2i(rv).(*map[int8]interface{})
29777 v, changed := fastpathTV.DecMapInt8IntfV(*vp, true, d)
29778 if changed {
29779 *vp = v
29780 }
29781 } else {
29782 fastpathTV.DecMapInt8IntfV(rv2i(rv).(map[int8]interface{}), false, d)
29783 }
29784}
29785func (f fastpathT) DecMapInt8IntfX(vp *map[int8]interface{}, d *Decoder) {
29786 v, changed := f.DecMapInt8IntfV(*vp, true, d)
29787 if changed {
29788 *vp = v
29789 }
29790}
29791func (_ fastpathT) DecMapInt8IntfV(v map[int8]interface{}, canChange bool,
29792 d *Decoder) (_ map[int8]interface{}, changed bool) {
29793 dd, esep := d.d, d.hh.hasElemSeparators()
29794 containerLen := dd.ReadMapStart()
29795 if canChange && v == nil {
29796 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
29797 v = make(map[int8]interface{}, xlen)
29798 changed = true
29799 }
29800 if containerLen == 0 {
29801 dd.ReadMapEnd()
29802 return v, changed
29803 }
29804 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
29805 var mk int8
29806 var mv interface{}
29807 hasLen := containerLen > 0
29808 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29809 if esep {
29810 dd.ReadMapElemKey()
29811 }
29812 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
29813 if esep {
29814 dd.ReadMapElemValue()
29815 }
29816 if dd.TryDecodeAsNil() {
29817 if v == nil {
29818 } else if d.h.DeleteOnNilMapValue {
29819 delete(v, mk)
29820 } else {
29821 v[mk] = nil
29822 }
29823 continue
29824 }
29825 if mapGet {
29826 mv = v[mk]
29827 } else {
29828 mv = nil
29829 }
29830 d.decode(&mv)
29831 if v != nil {
29832 v[mk] = mv
29833 }
29834 }
29835 dd.ReadMapEnd()
29836 return v, changed
29837}
29838
29839func (d *Decoder) fastpathDecMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
29840 if rv.Kind() == reflect.Ptr {
29841 vp := rv2i(rv).(*map[int8]string)
29842 v, changed := fastpathTV.DecMapInt8StringV(*vp, true, d)
29843 if changed {
29844 *vp = v
29845 }
29846 } else {
29847 fastpathTV.DecMapInt8StringV(rv2i(rv).(map[int8]string), false, d)
29848 }
29849}
29850func (f fastpathT) DecMapInt8StringX(vp *map[int8]string, d *Decoder) {
29851 v, changed := f.DecMapInt8StringV(*vp, true, d)
29852 if changed {
29853 *vp = v
29854 }
29855}
29856func (_ fastpathT) DecMapInt8StringV(v map[int8]string, canChange bool,
29857 d *Decoder) (_ map[int8]string, changed bool) {
29858 dd, esep := d.d, d.hh.hasElemSeparators()
29859 containerLen := dd.ReadMapStart()
29860 if canChange && v == nil {
29861 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
29862 v = make(map[int8]string, xlen)
29863 changed = true
29864 }
29865 if containerLen == 0 {
29866 dd.ReadMapEnd()
29867 return v, changed
29868 }
29869 var mk int8
29870 var mv string
29871 hasLen := containerLen > 0
29872 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29873 if esep {
29874 dd.ReadMapElemKey()
29875 }
29876 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
29877 if esep {
29878 dd.ReadMapElemValue()
29879 }
29880 if dd.TryDecodeAsNil() {
29881 if v == nil {
29882 } else if d.h.DeleteOnNilMapValue {
29883 delete(v, mk)
29884 } else {
29885 v[mk] = ""
29886 }
29887 continue
29888 }
29889 mv = dd.DecodeString()
29890 if v != nil {
29891 v[mk] = mv
29892 }
29893 }
29894 dd.ReadMapEnd()
29895 return v, changed
29896}
29897
29898func (d *Decoder) fastpathDecMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
29899 if rv.Kind() == reflect.Ptr {
29900 vp := rv2i(rv).(*map[int8]uint)
29901 v, changed := fastpathTV.DecMapInt8UintV(*vp, true, d)
29902 if changed {
29903 *vp = v
29904 }
29905 } else {
29906 fastpathTV.DecMapInt8UintV(rv2i(rv).(map[int8]uint), false, d)
29907 }
29908}
29909func (f fastpathT) DecMapInt8UintX(vp *map[int8]uint, d *Decoder) {
29910 v, changed := f.DecMapInt8UintV(*vp, true, d)
29911 if changed {
29912 *vp = v
29913 }
29914}
29915func (_ fastpathT) DecMapInt8UintV(v map[int8]uint, canChange bool,
29916 d *Decoder) (_ map[int8]uint, changed bool) {
29917 dd, esep := d.d, d.hh.hasElemSeparators()
29918 containerLen := dd.ReadMapStart()
29919 if canChange && v == nil {
29920 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
29921 v = make(map[int8]uint, xlen)
29922 changed = true
29923 }
29924 if containerLen == 0 {
29925 dd.ReadMapEnd()
29926 return v, changed
29927 }
29928 var mk int8
29929 var mv uint
29930 hasLen := containerLen > 0
29931 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29932 if esep {
29933 dd.ReadMapElemKey()
29934 }
29935 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
29936 if esep {
29937 dd.ReadMapElemValue()
29938 }
29939 if dd.TryDecodeAsNil() {
29940 if v == nil {
29941 } else if d.h.DeleteOnNilMapValue {
29942 delete(v, mk)
29943 } else {
29944 v[mk] = 0
29945 }
29946 continue
29947 }
29948 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
29949 if v != nil {
29950 v[mk] = mv
29951 }
29952 }
29953 dd.ReadMapEnd()
29954 return v, changed
29955}
29956
29957func (d *Decoder) fastpathDecMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
29958 if rv.Kind() == reflect.Ptr {
29959 vp := rv2i(rv).(*map[int8]uint8)
29960 v, changed := fastpathTV.DecMapInt8Uint8V(*vp, true, d)
29961 if changed {
29962 *vp = v
29963 }
29964 } else {
29965 fastpathTV.DecMapInt8Uint8V(rv2i(rv).(map[int8]uint8), false, d)
29966 }
29967}
29968func (f fastpathT) DecMapInt8Uint8X(vp *map[int8]uint8, d *Decoder) {
29969 v, changed := f.DecMapInt8Uint8V(*vp, true, d)
29970 if changed {
29971 *vp = v
29972 }
29973}
29974func (_ fastpathT) DecMapInt8Uint8V(v map[int8]uint8, canChange bool,
29975 d *Decoder) (_ map[int8]uint8, changed bool) {
29976 dd, esep := d.d, d.hh.hasElemSeparators()
29977 containerLen := dd.ReadMapStart()
29978 if canChange && v == nil {
29979 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
29980 v = make(map[int8]uint8, xlen)
29981 changed = true
29982 }
29983 if containerLen == 0 {
29984 dd.ReadMapEnd()
29985 return v, changed
29986 }
29987 var mk int8
29988 var mv uint8
29989 hasLen := containerLen > 0
29990 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
29991 if esep {
29992 dd.ReadMapElemKey()
29993 }
29994 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
29995 if esep {
29996 dd.ReadMapElemValue()
29997 }
29998 if dd.TryDecodeAsNil() {
29999 if v == nil {
30000 } else if d.h.DeleteOnNilMapValue {
30001 delete(v, mk)
30002 } else {
30003 v[mk] = 0
30004 }
30005 continue
30006 }
30007 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
30008 if v != nil {
30009 v[mk] = mv
30010 }
30011 }
30012 dd.ReadMapEnd()
30013 return v, changed
30014}
30015
30016func (d *Decoder) fastpathDecMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
30017 if rv.Kind() == reflect.Ptr {
30018 vp := rv2i(rv).(*map[int8]uint16)
30019 v, changed := fastpathTV.DecMapInt8Uint16V(*vp, true, d)
30020 if changed {
30021 *vp = v
30022 }
30023 } else {
30024 fastpathTV.DecMapInt8Uint16V(rv2i(rv).(map[int8]uint16), false, d)
30025 }
30026}
30027func (f fastpathT) DecMapInt8Uint16X(vp *map[int8]uint16, d *Decoder) {
30028 v, changed := f.DecMapInt8Uint16V(*vp, true, d)
30029 if changed {
30030 *vp = v
30031 }
30032}
30033func (_ fastpathT) DecMapInt8Uint16V(v map[int8]uint16, canChange bool,
30034 d *Decoder) (_ map[int8]uint16, changed bool) {
30035 dd, esep := d.d, d.hh.hasElemSeparators()
30036 containerLen := dd.ReadMapStart()
30037 if canChange && v == nil {
30038 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
30039 v = make(map[int8]uint16, xlen)
30040 changed = true
30041 }
30042 if containerLen == 0 {
30043 dd.ReadMapEnd()
30044 return v, changed
30045 }
30046 var mk int8
30047 var mv uint16
30048 hasLen := containerLen > 0
30049 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30050 if esep {
30051 dd.ReadMapElemKey()
30052 }
30053 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30054 if esep {
30055 dd.ReadMapElemValue()
30056 }
30057 if dd.TryDecodeAsNil() {
30058 if v == nil {
30059 } else if d.h.DeleteOnNilMapValue {
30060 delete(v, mk)
30061 } else {
30062 v[mk] = 0
30063 }
30064 continue
30065 }
30066 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
30067 if v != nil {
30068 v[mk] = mv
30069 }
30070 }
30071 dd.ReadMapEnd()
30072 return v, changed
30073}
30074
30075func (d *Decoder) fastpathDecMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
30076 if rv.Kind() == reflect.Ptr {
30077 vp := rv2i(rv).(*map[int8]uint32)
30078 v, changed := fastpathTV.DecMapInt8Uint32V(*vp, true, d)
30079 if changed {
30080 *vp = v
30081 }
30082 } else {
30083 fastpathTV.DecMapInt8Uint32V(rv2i(rv).(map[int8]uint32), false, d)
30084 }
30085}
30086func (f fastpathT) DecMapInt8Uint32X(vp *map[int8]uint32, d *Decoder) {
30087 v, changed := f.DecMapInt8Uint32V(*vp, true, d)
30088 if changed {
30089 *vp = v
30090 }
30091}
30092func (_ fastpathT) DecMapInt8Uint32V(v map[int8]uint32, canChange bool,
30093 d *Decoder) (_ map[int8]uint32, changed bool) {
30094 dd, esep := d.d, d.hh.hasElemSeparators()
30095 containerLen := dd.ReadMapStart()
30096 if canChange && v == nil {
30097 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
30098 v = make(map[int8]uint32, xlen)
30099 changed = true
30100 }
30101 if containerLen == 0 {
30102 dd.ReadMapEnd()
30103 return v, changed
30104 }
30105 var mk int8
30106 var mv uint32
30107 hasLen := containerLen > 0
30108 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30109 if esep {
30110 dd.ReadMapElemKey()
30111 }
30112 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30113 if esep {
30114 dd.ReadMapElemValue()
30115 }
30116 if dd.TryDecodeAsNil() {
30117 if v == nil {
30118 } else if d.h.DeleteOnNilMapValue {
30119 delete(v, mk)
30120 } else {
30121 v[mk] = 0
30122 }
30123 continue
30124 }
30125 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
30126 if v != nil {
30127 v[mk] = mv
30128 }
30129 }
30130 dd.ReadMapEnd()
30131 return v, changed
30132}
30133
30134func (d *Decoder) fastpathDecMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
30135 if rv.Kind() == reflect.Ptr {
30136 vp := rv2i(rv).(*map[int8]uint64)
30137 v, changed := fastpathTV.DecMapInt8Uint64V(*vp, true, d)
30138 if changed {
30139 *vp = v
30140 }
30141 } else {
30142 fastpathTV.DecMapInt8Uint64V(rv2i(rv).(map[int8]uint64), false, d)
30143 }
30144}
30145func (f fastpathT) DecMapInt8Uint64X(vp *map[int8]uint64, d *Decoder) {
30146 v, changed := f.DecMapInt8Uint64V(*vp, true, d)
30147 if changed {
30148 *vp = v
30149 }
30150}
30151func (_ fastpathT) DecMapInt8Uint64V(v map[int8]uint64, canChange bool,
30152 d *Decoder) (_ map[int8]uint64, changed bool) {
30153 dd, esep := d.d, d.hh.hasElemSeparators()
30154 containerLen := dd.ReadMapStart()
30155 if canChange && v == nil {
30156 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30157 v = make(map[int8]uint64, xlen)
30158 changed = true
30159 }
30160 if containerLen == 0 {
30161 dd.ReadMapEnd()
30162 return v, changed
30163 }
30164 var mk int8
30165 var mv uint64
30166 hasLen := containerLen > 0
30167 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30168 if esep {
30169 dd.ReadMapElemKey()
30170 }
30171 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30172 if esep {
30173 dd.ReadMapElemValue()
30174 }
30175 if dd.TryDecodeAsNil() {
30176 if v == nil {
30177 } else if d.h.DeleteOnNilMapValue {
30178 delete(v, mk)
30179 } else {
30180 v[mk] = 0
30181 }
30182 continue
30183 }
30184 mv = dd.DecodeUint64()
30185 if v != nil {
30186 v[mk] = mv
30187 }
30188 }
30189 dd.ReadMapEnd()
30190 return v, changed
30191}
30192
30193func (d *Decoder) fastpathDecMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
30194 if rv.Kind() == reflect.Ptr {
30195 vp := rv2i(rv).(*map[int8]uintptr)
30196 v, changed := fastpathTV.DecMapInt8UintptrV(*vp, true, d)
30197 if changed {
30198 *vp = v
30199 }
30200 } else {
30201 fastpathTV.DecMapInt8UintptrV(rv2i(rv).(map[int8]uintptr), false, d)
30202 }
30203}
30204func (f fastpathT) DecMapInt8UintptrX(vp *map[int8]uintptr, d *Decoder) {
30205 v, changed := f.DecMapInt8UintptrV(*vp, true, d)
30206 if changed {
30207 *vp = v
30208 }
30209}
30210func (_ fastpathT) DecMapInt8UintptrV(v map[int8]uintptr, canChange bool,
30211 d *Decoder) (_ map[int8]uintptr, changed bool) {
30212 dd, esep := d.d, d.hh.hasElemSeparators()
30213 containerLen := dd.ReadMapStart()
30214 if canChange && v == nil {
30215 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30216 v = make(map[int8]uintptr, xlen)
30217 changed = true
30218 }
30219 if containerLen == 0 {
30220 dd.ReadMapEnd()
30221 return v, changed
30222 }
30223 var mk int8
30224 var mv uintptr
30225 hasLen := containerLen > 0
30226 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30227 if esep {
30228 dd.ReadMapElemKey()
30229 }
30230 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30231 if esep {
30232 dd.ReadMapElemValue()
30233 }
30234 if dd.TryDecodeAsNil() {
30235 if v == nil {
30236 } else if d.h.DeleteOnNilMapValue {
30237 delete(v, mk)
30238 } else {
30239 v[mk] = 0
30240 }
30241 continue
30242 }
30243 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
30244 if v != nil {
30245 v[mk] = mv
30246 }
30247 }
30248 dd.ReadMapEnd()
30249 return v, changed
30250}
30251
30252func (d *Decoder) fastpathDecMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
30253 if rv.Kind() == reflect.Ptr {
30254 vp := rv2i(rv).(*map[int8]int)
30255 v, changed := fastpathTV.DecMapInt8IntV(*vp, true, d)
30256 if changed {
30257 *vp = v
30258 }
30259 } else {
30260 fastpathTV.DecMapInt8IntV(rv2i(rv).(map[int8]int), false, d)
30261 }
30262}
30263func (f fastpathT) DecMapInt8IntX(vp *map[int8]int, d *Decoder) {
30264 v, changed := f.DecMapInt8IntV(*vp, true, d)
30265 if changed {
30266 *vp = v
30267 }
30268}
30269func (_ fastpathT) DecMapInt8IntV(v map[int8]int, canChange bool,
30270 d *Decoder) (_ map[int8]int, changed bool) {
30271 dd, esep := d.d, d.hh.hasElemSeparators()
30272 containerLen := dd.ReadMapStart()
30273 if canChange && v == nil {
30274 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30275 v = make(map[int8]int, xlen)
30276 changed = true
30277 }
30278 if containerLen == 0 {
30279 dd.ReadMapEnd()
30280 return v, changed
30281 }
30282 var mk int8
30283 var mv int
30284 hasLen := containerLen > 0
30285 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30286 if esep {
30287 dd.ReadMapElemKey()
30288 }
30289 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30290 if esep {
30291 dd.ReadMapElemValue()
30292 }
30293 if dd.TryDecodeAsNil() {
30294 if v == nil {
30295 } else if d.h.DeleteOnNilMapValue {
30296 delete(v, mk)
30297 } else {
30298 v[mk] = 0
30299 }
30300 continue
30301 }
30302 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
30303 if v != nil {
30304 v[mk] = mv
30305 }
30306 }
30307 dd.ReadMapEnd()
30308 return v, changed
30309}
30310
30311func (d *Decoder) fastpathDecMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
30312 if rv.Kind() == reflect.Ptr {
30313 vp := rv2i(rv).(*map[int8]int8)
30314 v, changed := fastpathTV.DecMapInt8Int8V(*vp, true, d)
30315 if changed {
30316 *vp = v
30317 }
30318 } else {
30319 fastpathTV.DecMapInt8Int8V(rv2i(rv).(map[int8]int8), false, d)
30320 }
30321}
30322func (f fastpathT) DecMapInt8Int8X(vp *map[int8]int8, d *Decoder) {
30323 v, changed := f.DecMapInt8Int8V(*vp, true, d)
30324 if changed {
30325 *vp = v
30326 }
30327}
30328func (_ fastpathT) DecMapInt8Int8V(v map[int8]int8, canChange bool,
30329 d *Decoder) (_ map[int8]int8, changed bool) {
30330 dd, esep := d.d, d.hh.hasElemSeparators()
30331 containerLen := dd.ReadMapStart()
30332 if canChange && v == nil {
30333 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
30334 v = make(map[int8]int8, xlen)
30335 changed = true
30336 }
30337 if containerLen == 0 {
30338 dd.ReadMapEnd()
30339 return v, changed
30340 }
30341 var mk int8
30342 var mv int8
30343 hasLen := containerLen > 0
30344 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30345 if esep {
30346 dd.ReadMapElemKey()
30347 }
30348 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30349 if esep {
30350 dd.ReadMapElemValue()
30351 }
30352 if dd.TryDecodeAsNil() {
30353 if v == nil {
30354 } else if d.h.DeleteOnNilMapValue {
30355 delete(v, mk)
30356 } else {
30357 v[mk] = 0
30358 }
30359 continue
30360 }
30361 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30362 if v != nil {
30363 v[mk] = mv
30364 }
30365 }
30366 dd.ReadMapEnd()
30367 return v, changed
30368}
30369
30370func (d *Decoder) fastpathDecMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
30371 if rv.Kind() == reflect.Ptr {
30372 vp := rv2i(rv).(*map[int8]int16)
30373 v, changed := fastpathTV.DecMapInt8Int16V(*vp, true, d)
30374 if changed {
30375 *vp = v
30376 }
30377 } else {
30378 fastpathTV.DecMapInt8Int16V(rv2i(rv).(map[int8]int16), false, d)
30379 }
30380}
30381func (f fastpathT) DecMapInt8Int16X(vp *map[int8]int16, d *Decoder) {
30382 v, changed := f.DecMapInt8Int16V(*vp, true, d)
30383 if changed {
30384 *vp = v
30385 }
30386}
30387func (_ fastpathT) DecMapInt8Int16V(v map[int8]int16, canChange bool,
30388 d *Decoder) (_ map[int8]int16, changed bool) {
30389 dd, esep := d.d, d.hh.hasElemSeparators()
30390 containerLen := dd.ReadMapStart()
30391 if canChange && v == nil {
30392 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
30393 v = make(map[int8]int16, xlen)
30394 changed = true
30395 }
30396 if containerLen == 0 {
30397 dd.ReadMapEnd()
30398 return v, changed
30399 }
30400 var mk int8
30401 var mv int16
30402 hasLen := containerLen > 0
30403 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30404 if esep {
30405 dd.ReadMapElemKey()
30406 }
30407 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30408 if esep {
30409 dd.ReadMapElemValue()
30410 }
30411 if dd.TryDecodeAsNil() {
30412 if v == nil {
30413 } else if d.h.DeleteOnNilMapValue {
30414 delete(v, mk)
30415 } else {
30416 v[mk] = 0
30417 }
30418 continue
30419 }
30420 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
30421 if v != nil {
30422 v[mk] = mv
30423 }
30424 }
30425 dd.ReadMapEnd()
30426 return v, changed
30427}
30428
30429func (d *Decoder) fastpathDecMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
30430 if rv.Kind() == reflect.Ptr {
30431 vp := rv2i(rv).(*map[int8]int32)
30432 v, changed := fastpathTV.DecMapInt8Int32V(*vp, true, d)
30433 if changed {
30434 *vp = v
30435 }
30436 } else {
30437 fastpathTV.DecMapInt8Int32V(rv2i(rv).(map[int8]int32), false, d)
30438 }
30439}
30440func (f fastpathT) DecMapInt8Int32X(vp *map[int8]int32, d *Decoder) {
30441 v, changed := f.DecMapInt8Int32V(*vp, true, d)
30442 if changed {
30443 *vp = v
30444 }
30445}
30446func (_ fastpathT) DecMapInt8Int32V(v map[int8]int32, canChange bool,
30447 d *Decoder) (_ map[int8]int32, changed bool) {
30448 dd, esep := d.d, d.hh.hasElemSeparators()
30449 containerLen := dd.ReadMapStart()
30450 if canChange && v == nil {
30451 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
30452 v = make(map[int8]int32, xlen)
30453 changed = true
30454 }
30455 if containerLen == 0 {
30456 dd.ReadMapEnd()
30457 return v, changed
30458 }
30459 var mk int8
30460 var mv int32
30461 hasLen := containerLen > 0
30462 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30463 if esep {
30464 dd.ReadMapElemKey()
30465 }
30466 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30467 if esep {
30468 dd.ReadMapElemValue()
30469 }
30470 if dd.TryDecodeAsNil() {
30471 if v == nil {
30472 } else if d.h.DeleteOnNilMapValue {
30473 delete(v, mk)
30474 } else {
30475 v[mk] = 0
30476 }
30477 continue
30478 }
30479 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
30480 if v != nil {
30481 v[mk] = mv
30482 }
30483 }
30484 dd.ReadMapEnd()
30485 return v, changed
30486}
30487
30488func (d *Decoder) fastpathDecMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
30489 if rv.Kind() == reflect.Ptr {
30490 vp := rv2i(rv).(*map[int8]int64)
30491 v, changed := fastpathTV.DecMapInt8Int64V(*vp, true, d)
30492 if changed {
30493 *vp = v
30494 }
30495 } else {
30496 fastpathTV.DecMapInt8Int64V(rv2i(rv).(map[int8]int64), false, d)
30497 }
30498}
30499func (f fastpathT) DecMapInt8Int64X(vp *map[int8]int64, d *Decoder) {
30500 v, changed := f.DecMapInt8Int64V(*vp, true, d)
30501 if changed {
30502 *vp = v
30503 }
30504}
30505func (_ fastpathT) DecMapInt8Int64V(v map[int8]int64, canChange bool,
30506 d *Decoder) (_ map[int8]int64, changed bool) {
30507 dd, esep := d.d, d.hh.hasElemSeparators()
30508 containerLen := dd.ReadMapStart()
30509 if canChange && v == nil {
30510 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30511 v = make(map[int8]int64, xlen)
30512 changed = true
30513 }
30514 if containerLen == 0 {
30515 dd.ReadMapEnd()
30516 return v, changed
30517 }
30518 var mk int8
30519 var mv int64
30520 hasLen := containerLen > 0
30521 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30522 if esep {
30523 dd.ReadMapElemKey()
30524 }
30525 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30526 if esep {
30527 dd.ReadMapElemValue()
30528 }
30529 if dd.TryDecodeAsNil() {
30530 if v == nil {
30531 } else if d.h.DeleteOnNilMapValue {
30532 delete(v, mk)
30533 } else {
30534 v[mk] = 0
30535 }
30536 continue
30537 }
30538 mv = dd.DecodeInt64()
30539 if v != nil {
30540 v[mk] = mv
30541 }
30542 }
30543 dd.ReadMapEnd()
30544 return v, changed
30545}
30546
30547func (d *Decoder) fastpathDecMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
30548 if rv.Kind() == reflect.Ptr {
30549 vp := rv2i(rv).(*map[int8]float32)
30550 v, changed := fastpathTV.DecMapInt8Float32V(*vp, true, d)
30551 if changed {
30552 *vp = v
30553 }
30554 } else {
30555 fastpathTV.DecMapInt8Float32V(rv2i(rv).(map[int8]float32), false, d)
30556 }
30557}
30558func (f fastpathT) DecMapInt8Float32X(vp *map[int8]float32, d *Decoder) {
30559 v, changed := f.DecMapInt8Float32V(*vp, true, d)
30560 if changed {
30561 *vp = v
30562 }
30563}
30564func (_ fastpathT) DecMapInt8Float32V(v map[int8]float32, canChange bool,
30565 d *Decoder) (_ map[int8]float32, changed bool) {
30566 dd, esep := d.d, d.hh.hasElemSeparators()
30567 containerLen := dd.ReadMapStart()
30568 if canChange && v == nil {
30569 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
30570 v = make(map[int8]float32, xlen)
30571 changed = true
30572 }
30573 if containerLen == 0 {
30574 dd.ReadMapEnd()
30575 return v, changed
30576 }
30577 var mk int8
30578 var mv float32
30579 hasLen := containerLen > 0
30580 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30581 if esep {
30582 dd.ReadMapElemKey()
30583 }
30584 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30585 if esep {
30586 dd.ReadMapElemValue()
30587 }
30588 if dd.TryDecodeAsNil() {
30589 if v == nil {
30590 } else if d.h.DeleteOnNilMapValue {
30591 delete(v, mk)
30592 } else {
30593 v[mk] = 0
30594 }
30595 continue
30596 }
30597 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
30598 if v != nil {
30599 v[mk] = mv
30600 }
30601 }
30602 dd.ReadMapEnd()
30603 return v, changed
30604}
30605
30606func (d *Decoder) fastpathDecMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
30607 if rv.Kind() == reflect.Ptr {
30608 vp := rv2i(rv).(*map[int8]float64)
30609 v, changed := fastpathTV.DecMapInt8Float64V(*vp, true, d)
30610 if changed {
30611 *vp = v
30612 }
30613 } else {
30614 fastpathTV.DecMapInt8Float64V(rv2i(rv).(map[int8]float64), false, d)
30615 }
30616}
30617func (f fastpathT) DecMapInt8Float64X(vp *map[int8]float64, d *Decoder) {
30618 v, changed := f.DecMapInt8Float64V(*vp, true, d)
30619 if changed {
30620 *vp = v
30621 }
30622}
30623func (_ fastpathT) DecMapInt8Float64V(v map[int8]float64, canChange bool,
30624 d *Decoder) (_ map[int8]float64, changed bool) {
30625 dd, esep := d.d, d.hh.hasElemSeparators()
30626 containerLen := dd.ReadMapStart()
30627 if canChange && v == nil {
30628 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
30629 v = make(map[int8]float64, xlen)
30630 changed = true
30631 }
30632 if containerLen == 0 {
30633 dd.ReadMapEnd()
30634 return v, changed
30635 }
30636 var mk int8
30637 var mv float64
30638 hasLen := containerLen > 0
30639 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30640 if esep {
30641 dd.ReadMapElemKey()
30642 }
30643 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30644 if esep {
30645 dd.ReadMapElemValue()
30646 }
30647 if dd.TryDecodeAsNil() {
30648 if v == nil {
30649 } else if d.h.DeleteOnNilMapValue {
30650 delete(v, mk)
30651 } else {
30652 v[mk] = 0
30653 }
30654 continue
30655 }
30656 mv = dd.DecodeFloat64()
30657 if v != nil {
30658 v[mk] = mv
30659 }
30660 }
30661 dd.ReadMapEnd()
30662 return v, changed
30663}
30664
30665func (d *Decoder) fastpathDecMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
30666 if rv.Kind() == reflect.Ptr {
30667 vp := rv2i(rv).(*map[int8]bool)
30668 v, changed := fastpathTV.DecMapInt8BoolV(*vp, true, d)
30669 if changed {
30670 *vp = v
30671 }
30672 } else {
30673 fastpathTV.DecMapInt8BoolV(rv2i(rv).(map[int8]bool), false, d)
30674 }
30675}
30676func (f fastpathT) DecMapInt8BoolX(vp *map[int8]bool, d *Decoder) {
30677 v, changed := f.DecMapInt8BoolV(*vp, true, d)
30678 if changed {
30679 *vp = v
30680 }
30681}
30682func (_ fastpathT) DecMapInt8BoolV(v map[int8]bool, canChange bool,
30683 d *Decoder) (_ map[int8]bool, changed bool) {
30684 dd, esep := d.d, d.hh.hasElemSeparators()
30685 containerLen := dd.ReadMapStart()
30686 if canChange && v == nil {
30687 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
30688 v = make(map[int8]bool, xlen)
30689 changed = true
30690 }
30691 if containerLen == 0 {
30692 dd.ReadMapEnd()
30693 return v, changed
30694 }
30695 var mk int8
30696 var mv bool
30697 hasLen := containerLen > 0
30698 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30699 if esep {
30700 dd.ReadMapElemKey()
30701 }
30702 mk = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
30703 if esep {
30704 dd.ReadMapElemValue()
30705 }
30706 if dd.TryDecodeAsNil() {
30707 if v == nil {
30708 } else if d.h.DeleteOnNilMapValue {
30709 delete(v, mk)
30710 } else {
30711 v[mk] = false
30712 }
30713 continue
30714 }
30715 mv = dd.DecodeBool()
30716 if v != nil {
30717 v[mk] = mv
30718 }
30719 }
30720 dd.ReadMapEnd()
30721 return v, changed
30722}
30723
30724func (d *Decoder) fastpathDecMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
30725 if rv.Kind() == reflect.Ptr {
30726 vp := rv2i(rv).(*map[int16]interface{})
30727 v, changed := fastpathTV.DecMapInt16IntfV(*vp, true, d)
30728 if changed {
30729 *vp = v
30730 }
30731 } else {
30732 fastpathTV.DecMapInt16IntfV(rv2i(rv).(map[int16]interface{}), false, d)
30733 }
30734}
30735func (f fastpathT) DecMapInt16IntfX(vp *map[int16]interface{}, d *Decoder) {
30736 v, changed := f.DecMapInt16IntfV(*vp, true, d)
30737 if changed {
30738 *vp = v
30739 }
30740}
30741func (_ fastpathT) DecMapInt16IntfV(v map[int16]interface{}, canChange bool,
30742 d *Decoder) (_ map[int16]interface{}, changed bool) {
30743 dd, esep := d.d, d.hh.hasElemSeparators()
30744 containerLen := dd.ReadMapStart()
30745 if canChange && v == nil {
30746 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
30747 v = make(map[int16]interface{}, xlen)
30748 changed = true
30749 }
30750 if containerLen == 0 {
30751 dd.ReadMapEnd()
30752 return v, changed
30753 }
30754 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
30755 var mk int16
30756 var mv interface{}
30757 hasLen := containerLen > 0
30758 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30759 if esep {
30760 dd.ReadMapElemKey()
30761 }
30762 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
30763 if esep {
30764 dd.ReadMapElemValue()
30765 }
30766 if dd.TryDecodeAsNil() {
30767 if v == nil {
30768 } else if d.h.DeleteOnNilMapValue {
30769 delete(v, mk)
30770 } else {
30771 v[mk] = nil
30772 }
30773 continue
30774 }
30775 if mapGet {
30776 mv = v[mk]
30777 } else {
30778 mv = nil
30779 }
30780 d.decode(&mv)
30781 if v != nil {
30782 v[mk] = mv
30783 }
30784 }
30785 dd.ReadMapEnd()
30786 return v, changed
30787}
30788
30789func (d *Decoder) fastpathDecMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
30790 if rv.Kind() == reflect.Ptr {
30791 vp := rv2i(rv).(*map[int16]string)
30792 v, changed := fastpathTV.DecMapInt16StringV(*vp, true, d)
30793 if changed {
30794 *vp = v
30795 }
30796 } else {
30797 fastpathTV.DecMapInt16StringV(rv2i(rv).(map[int16]string), false, d)
30798 }
30799}
30800func (f fastpathT) DecMapInt16StringX(vp *map[int16]string, d *Decoder) {
30801 v, changed := f.DecMapInt16StringV(*vp, true, d)
30802 if changed {
30803 *vp = v
30804 }
30805}
30806func (_ fastpathT) DecMapInt16StringV(v map[int16]string, canChange bool,
30807 d *Decoder) (_ map[int16]string, changed bool) {
30808 dd, esep := d.d, d.hh.hasElemSeparators()
30809 containerLen := dd.ReadMapStart()
30810 if canChange && v == nil {
30811 xlen := decInferLen(containerLen, d.h.MaxInitLen, 18)
30812 v = make(map[int16]string, xlen)
30813 changed = true
30814 }
30815 if containerLen == 0 {
30816 dd.ReadMapEnd()
30817 return v, changed
30818 }
30819 var mk int16
30820 var mv string
30821 hasLen := containerLen > 0
30822 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30823 if esep {
30824 dd.ReadMapElemKey()
30825 }
30826 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
30827 if esep {
30828 dd.ReadMapElemValue()
30829 }
30830 if dd.TryDecodeAsNil() {
30831 if v == nil {
30832 } else if d.h.DeleteOnNilMapValue {
30833 delete(v, mk)
30834 } else {
30835 v[mk] = ""
30836 }
30837 continue
30838 }
30839 mv = dd.DecodeString()
30840 if v != nil {
30841 v[mk] = mv
30842 }
30843 }
30844 dd.ReadMapEnd()
30845 return v, changed
30846}
30847
30848func (d *Decoder) fastpathDecMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
30849 if rv.Kind() == reflect.Ptr {
30850 vp := rv2i(rv).(*map[int16]uint)
30851 v, changed := fastpathTV.DecMapInt16UintV(*vp, true, d)
30852 if changed {
30853 *vp = v
30854 }
30855 } else {
30856 fastpathTV.DecMapInt16UintV(rv2i(rv).(map[int16]uint), false, d)
30857 }
30858}
30859func (f fastpathT) DecMapInt16UintX(vp *map[int16]uint, d *Decoder) {
30860 v, changed := f.DecMapInt16UintV(*vp, true, d)
30861 if changed {
30862 *vp = v
30863 }
30864}
30865func (_ fastpathT) DecMapInt16UintV(v map[int16]uint, canChange bool,
30866 d *Decoder) (_ map[int16]uint, changed bool) {
30867 dd, esep := d.d, d.hh.hasElemSeparators()
30868 containerLen := dd.ReadMapStart()
30869 if canChange && v == nil {
30870 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
30871 v = make(map[int16]uint, xlen)
30872 changed = true
30873 }
30874 if containerLen == 0 {
30875 dd.ReadMapEnd()
30876 return v, changed
30877 }
30878 var mk int16
30879 var mv uint
30880 hasLen := containerLen > 0
30881 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30882 if esep {
30883 dd.ReadMapElemKey()
30884 }
30885 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
30886 if esep {
30887 dd.ReadMapElemValue()
30888 }
30889 if dd.TryDecodeAsNil() {
30890 if v == nil {
30891 } else if d.h.DeleteOnNilMapValue {
30892 delete(v, mk)
30893 } else {
30894 v[mk] = 0
30895 }
30896 continue
30897 }
30898 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
30899 if v != nil {
30900 v[mk] = mv
30901 }
30902 }
30903 dd.ReadMapEnd()
30904 return v, changed
30905}
30906
30907func (d *Decoder) fastpathDecMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
30908 if rv.Kind() == reflect.Ptr {
30909 vp := rv2i(rv).(*map[int16]uint8)
30910 v, changed := fastpathTV.DecMapInt16Uint8V(*vp, true, d)
30911 if changed {
30912 *vp = v
30913 }
30914 } else {
30915 fastpathTV.DecMapInt16Uint8V(rv2i(rv).(map[int16]uint8), false, d)
30916 }
30917}
30918func (f fastpathT) DecMapInt16Uint8X(vp *map[int16]uint8, d *Decoder) {
30919 v, changed := f.DecMapInt16Uint8V(*vp, true, d)
30920 if changed {
30921 *vp = v
30922 }
30923}
30924func (_ fastpathT) DecMapInt16Uint8V(v map[int16]uint8, canChange bool,
30925 d *Decoder) (_ map[int16]uint8, changed bool) {
30926 dd, esep := d.d, d.hh.hasElemSeparators()
30927 containerLen := dd.ReadMapStart()
30928 if canChange && v == nil {
30929 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
30930 v = make(map[int16]uint8, xlen)
30931 changed = true
30932 }
30933 if containerLen == 0 {
30934 dd.ReadMapEnd()
30935 return v, changed
30936 }
30937 var mk int16
30938 var mv uint8
30939 hasLen := containerLen > 0
30940 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
30941 if esep {
30942 dd.ReadMapElemKey()
30943 }
30944 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
30945 if esep {
30946 dd.ReadMapElemValue()
30947 }
30948 if dd.TryDecodeAsNil() {
30949 if v == nil {
30950 } else if d.h.DeleteOnNilMapValue {
30951 delete(v, mk)
30952 } else {
30953 v[mk] = 0
30954 }
30955 continue
30956 }
30957 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
30958 if v != nil {
30959 v[mk] = mv
30960 }
30961 }
30962 dd.ReadMapEnd()
30963 return v, changed
30964}
30965
30966func (d *Decoder) fastpathDecMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
30967 if rv.Kind() == reflect.Ptr {
30968 vp := rv2i(rv).(*map[int16]uint16)
30969 v, changed := fastpathTV.DecMapInt16Uint16V(*vp, true, d)
30970 if changed {
30971 *vp = v
30972 }
30973 } else {
30974 fastpathTV.DecMapInt16Uint16V(rv2i(rv).(map[int16]uint16), false, d)
30975 }
30976}
30977func (f fastpathT) DecMapInt16Uint16X(vp *map[int16]uint16, d *Decoder) {
30978 v, changed := f.DecMapInt16Uint16V(*vp, true, d)
30979 if changed {
30980 *vp = v
30981 }
30982}
30983func (_ fastpathT) DecMapInt16Uint16V(v map[int16]uint16, canChange bool,
30984 d *Decoder) (_ map[int16]uint16, changed bool) {
30985 dd, esep := d.d, d.hh.hasElemSeparators()
30986 containerLen := dd.ReadMapStart()
30987 if canChange && v == nil {
30988 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
30989 v = make(map[int16]uint16, xlen)
30990 changed = true
30991 }
30992 if containerLen == 0 {
30993 dd.ReadMapEnd()
30994 return v, changed
30995 }
30996 var mk int16
30997 var mv uint16
30998 hasLen := containerLen > 0
30999 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31000 if esep {
31001 dd.ReadMapElemKey()
31002 }
31003 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31004 if esep {
31005 dd.ReadMapElemValue()
31006 }
31007 if dd.TryDecodeAsNil() {
31008 if v == nil {
31009 } else if d.h.DeleteOnNilMapValue {
31010 delete(v, mk)
31011 } else {
31012 v[mk] = 0
31013 }
31014 continue
31015 }
31016 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
31017 if v != nil {
31018 v[mk] = mv
31019 }
31020 }
31021 dd.ReadMapEnd()
31022 return v, changed
31023}
31024
31025func (d *Decoder) fastpathDecMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
31026 if rv.Kind() == reflect.Ptr {
31027 vp := rv2i(rv).(*map[int16]uint32)
31028 v, changed := fastpathTV.DecMapInt16Uint32V(*vp, true, d)
31029 if changed {
31030 *vp = v
31031 }
31032 } else {
31033 fastpathTV.DecMapInt16Uint32V(rv2i(rv).(map[int16]uint32), false, d)
31034 }
31035}
31036func (f fastpathT) DecMapInt16Uint32X(vp *map[int16]uint32, d *Decoder) {
31037 v, changed := f.DecMapInt16Uint32V(*vp, true, d)
31038 if changed {
31039 *vp = v
31040 }
31041}
31042func (_ fastpathT) DecMapInt16Uint32V(v map[int16]uint32, canChange bool,
31043 d *Decoder) (_ map[int16]uint32, changed bool) {
31044 dd, esep := d.d, d.hh.hasElemSeparators()
31045 containerLen := dd.ReadMapStart()
31046 if canChange && v == nil {
31047 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
31048 v = make(map[int16]uint32, xlen)
31049 changed = true
31050 }
31051 if containerLen == 0 {
31052 dd.ReadMapEnd()
31053 return v, changed
31054 }
31055 var mk int16
31056 var mv uint32
31057 hasLen := containerLen > 0
31058 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31059 if esep {
31060 dd.ReadMapElemKey()
31061 }
31062 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31063 if esep {
31064 dd.ReadMapElemValue()
31065 }
31066 if dd.TryDecodeAsNil() {
31067 if v == nil {
31068 } else if d.h.DeleteOnNilMapValue {
31069 delete(v, mk)
31070 } else {
31071 v[mk] = 0
31072 }
31073 continue
31074 }
31075 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
31076 if v != nil {
31077 v[mk] = mv
31078 }
31079 }
31080 dd.ReadMapEnd()
31081 return v, changed
31082}
31083
31084func (d *Decoder) fastpathDecMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
31085 if rv.Kind() == reflect.Ptr {
31086 vp := rv2i(rv).(*map[int16]uint64)
31087 v, changed := fastpathTV.DecMapInt16Uint64V(*vp, true, d)
31088 if changed {
31089 *vp = v
31090 }
31091 } else {
31092 fastpathTV.DecMapInt16Uint64V(rv2i(rv).(map[int16]uint64), false, d)
31093 }
31094}
31095func (f fastpathT) DecMapInt16Uint64X(vp *map[int16]uint64, d *Decoder) {
31096 v, changed := f.DecMapInt16Uint64V(*vp, true, d)
31097 if changed {
31098 *vp = v
31099 }
31100}
31101func (_ fastpathT) DecMapInt16Uint64V(v map[int16]uint64, canChange bool,
31102 d *Decoder) (_ map[int16]uint64, changed bool) {
31103 dd, esep := d.d, d.hh.hasElemSeparators()
31104 containerLen := dd.ReadMapStart()
31105 if canChange && v == nil {
31106 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31107 v = make(map[int16]uint64, xlen)
31108 changed = true
31109 }
31110 if containerLen == 0 {
31111 dd.ReadMapEnd()
31112 return v, changed
31113 }
31114 var mk int16
31115 var mv uint64
31116 hasLen := containerLen > 0
31117 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31118 if esep {
31119 dd.ReadMapElemKey()
31120 }
31121 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31122 if esep {
31123 dd.ReadMapElemValue()
31124 }
31125 if dd.TryDecodeAsNil() {
31126 if v == nil {
31127 } else if d.h.DeleteOnNilMapValue {
31128 delete(v, mk)
31129 } else {
31130 v[mk] = 0
31131 }
31132 continue
31133 }
31134 mv = dd.DecodeUint64()
31135 if v != nil {
31136 v[mk] = mv
31137 }
31138 }
31139 dd.ReadMapEnd()
31140 return v, changed
31141}
31142
31143func (d *Decoder) fastpathDecMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
31144 if rv.Kind() == reflect.Ptr {
31145 vp := rv2i(rv).(*map[int16]uintptr)
31146 v, changed := fastpathTV.DecMapInt16UintptrV(*vp, true, d)
31147 if changed {
31148 *vp = v
31149 }
31150 } else {
31151 fastpathTV.DecMapInt16UintptrV(rv2i(rv).(map[int16]uintptr), false, d)
31152 }
31153}
31154func (f fastpathT) DecMapInt16UintptrX(vp *map[int16]uintptr, d *Decoder) {
31155 v, changed := f.DecMapInt16UintptrV(*vp, true, d)
31156 if changed {
31157 *vp = v
31158 }
31159}
31160func (_ fastpathT) DecMapInt16UintptrV(v map[int16]uintptr, canChange bool,
31161 d *Decoder) (_ map[int16]uintptr, changed bool) {
31162 dd, esep := d.d, d.hh.hasElemSeparators()
31163 containerLen := dd.ReadMapStart()
31164 if canChange && v == nil {
31165 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31166 v = make(map[int16]uintptr, xlen)
31167 changed = true
31168 }
31169 if containerLen == 0 {
31170 dd.ReadMapEnd()
31171 return v, changed
31172 }
31173 var mk int16
31174 var mv uintptr
31175 hasLen := containerLen > 0
31176 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31177 if esep {
31178 dd.ReadMapElemKey()
31179 }
31180 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31181 if esep {
31182 dd.ReadMapElemValue()
31183 }
31184 if dd.TryDecodeAsNil() {
31185 if v == nil {
31186 } else if d.h.DeleteOnNilMapValue {
31187 delete(v, mk)
31188 } else {
31189 v[mk] = 0
31190 }
31191 continue
31192 }
31193 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
31194 if v != nil {
31195 v[mk] = mv
31196 }
31197 }
31198 dd.ReadMapEnd()
31199 return v, changed
31200}
31201
31202func (d *Decoder) fastpathDecMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
31203 if rv.Kind() == reflect.Ptr {
31204 vp := rv2i(rv).(*map[int16]int)
31205 v, changed := fastpathTV.DecMapInt16IntV(*vp, true, d)
31206 if changed {
31207 *vp = v
31208 }
31209 } else {
31210 fastpathTV.DecMapInt16IntV(rv2i(rv).(map[int16]int), false, d)
31211 }
31212}
31213func (f fastpathT) DecMapInt16IntX(vp *map[int16]int, d *Decoder) {
31214 v, changed := f.DecMapInt16IntV(*vp, true, d)
31215 if changed {
31216 *vp = v
31217 }
31218}
31219func (_ fastpathT) DecMapInt16IntV(v map[int16]int, canChange bool,
31220 d *Decoder) (_ map[int16]int, changed bool) {
31221 dd, esep := d.d, d.hh.hasElemSeparators()
31222 containerLen := dd.ReadMapStart()
31223 if canChange && v == nil {
31224 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31225 v = make(map[int16]int, xlen)
31226 changed = true
31227 }
31228 if containerLen == 0 {
31229 dd.ReadMapEnd()
31230 return v, changed
31231 }
31232 var mk int16
31233 var mv int
31234 hasLen := containerLen > 0
31235 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31236 if esep {
31237 dd.ReadMapElemKey()
31238 }
31239 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31240 if esep {
31241 dd.ReadMapElemValue()
31242 }
31243 if dd.TryDecodeAsNil() {
31244 if v == nil {
31245 } else if d.h.DeleteOnNilMapValue {
31246 delete(v, mk)
31247 } else {
31248 v[mk] = 0
31249 }
31250 continue
31251 }
31252 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
31253 if v != nil {
31254 v[mk] = mv
31255 }
31256 }
31257 dd.ReadMapEnd()
31258 return v, changed
31259}
31260
31261func (d *Decoder) fastpathDecMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
31262 if rv.Kind() == reflect.Ptr {
31263 vp := rv2i(rv).(*map[int16]int8)
31264 v, changed := fastpathTV.DecMapInt16Int8V(*vp, true, d)
31265 if changed {
31266 *vp = v
31267 }
31268 } else {
31269 fastpathTV.DecMapInt16Int8V(rv2i(rv).(map[int16]int8), false, d)
31270 }
31271}
31272func (f fastpathT) DecMapInt16Int8X(vp *map[int16]int8, d *Decoder) {
31273 v, changed := f.DecMapInt16Int8V(*vp, true, d)
31274 if changed {
31275 *vp = v
31276 }
31277}
31278func (_ fastpathT) DecMapInt16Int8V(v map[int16]int8, canChange bool,
31279 d *Decoder) (_ map[int16]int8, changed bool) {
31280 dd, esep := d.d, d.hh.hasElemSeparators()
31281 containerLen := dd.ReadMapStart()
31282 if canChange && v == nil {
31283 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
31284 v = make(map[int16]int8, xlen)
31285 changed = true
31286 }
31287 if containerLen == 0 {
31288 dd.ReadMapEnd()
31289 return v, changed
31290 }
31291 var mk int16
31292 var mv int8
31293 hasLen := containerLen > 0
31294 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31295 if esep {
31296 dd.ReadMapElemKey()
31297 }
31298 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31299 if esep {
31300 dd.ReadMapElemValue()
31301 }
31302 if dd.TryDecodeAsNil() {
31303 if v == nil {
31304 } else if d.h.DeleteOnNilMapValue {
31305 delete(v, mk)
31306 } else {
31307 v[mk] = 0
31308 }
31309 continue
31310 }
31311 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
31312 if v != nil {
31313 v[mk] = mv
31314 }
31315 }
31316 dd.ReadMapEnd()
31317 return v, changed
31318}
31319
31320func (d *Decoder) fastpathDecMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
31321 if rv.Kind() == reflect.Ptr {
31322 vp := rv2i(rv).(*map[int16]int16)
31323 v, changed := fastpathTV.DecMapInt16Int16V(*vp, true, d)
31324 if changed {
31325 *vp = v
31326 }
31327 } else {
31328 fastpathTV.DecMapInt16Int16V(rv2i(rv).(map[int16]int16), false, d)
31329 }
31330}
31331func (f fastpathT) DecMapInt16Int16X(vp *map[int16]int16, d *Decoder) {
31332 v, changed := f.DecMapInt16Int16V(*vp, true, d)
31333 if changed {
31334 *vp = v
31335 }
31336}
31337func (_ fastpathT) DecMapInt16Int16V(v map[int16]int16, canChange bool,
31338 d *Decoder) (_ map[int16]int16, changed bool) {
31339 dd, esep := d.d, d.hh.hasElemSeparators()
31340 containerLen := dd.ReadMapStart()
31341 if canChange && v == nil {
31342 xlen := decInferLen(containerLen, d.h.MaxInitLen, 4)
31343 v = make(map[int16]int16, xlen)
31344 changed = true
31345 }
31346 if containerLen == 0 {
31347 dd.ReadMapEnd()
31348 return v, changed
31349 }
31350 var mk int16
31351 var mv int16
31352 hasLen := containerLen > 0
31353 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31354 if esep {
31355 dd.ReadMapElemKey()
31356 }
31357 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31358 if esep {
31359 dd.ReadMapElemValue()
31360 }
31361 if dd.TryDecodeAsNil() {
31362 if v == nil {
31363 } else if d.h.DeleteOnNilMapValue {
31364 delete(v, mk)
31365 } else {
31366 v[mk] = 0
31367 }
31368 continue
31369 }
31370 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31371 if v != nil {
31372 v[mk] = mv
31373 }
31374 }
31375 dd.ReadMapEnd()
31376 return v, changed
31377}
31378
31379func (d *Decoder) fastpathDecMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
31380 if rv.Kind() == reflect.Ptr {
31381 vp := rv2i(rv).(*map[int16]int32)
31382 v, changed := fastpathTV.DecMapInt16Int32V(*vp, true, d)
31383 if changed {
31384 *vp = v
31385 }
31386 } else {
31387 fastpathTV.DecMapInt16Int32V(rv2i(rv).(map[int16]int32), false, d)
31388 }
31389}
31390func (f fastpathT) DecMapInt16Int32X(vp *map[int16]int32, d *Decoder) {
31391 v, changed := f.DecMapInt16Int32V(*vp, true, d)
31392 if changed {
31393 *vp = v
31394 }
31395}
31396func (_ fastpathT) DecMapInt16Int32V(v map[int16]int32, canChange bool,
31397 d *Decoder) (_ map[int16]int32, changed bool) {
31398 dd, esep := d.d, d.hh.hasElemSeparators()
31399 containerLen := dd.ReadMapStart()
31400 if canChange && v == nil {
31401 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
31402 v = make(map[int16]int32, xlen)
31403 changed = true
31404 }
31405 if containerLen == 0 {
31406 dd.ReadMapEnd()
31407 return v, changed
31408 }
31409 var mk int16
31410 var mv int32
31411 hasLen := containerLen > 0
31412 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31413 if esep {
31414 dd.ReadMapElemKey()
31415 }
31416 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31417 if esep {
31418 dd.ReadMapElemValue()
31419 }
31420 if dd.TryDecodeAsNil() {
31421 if v == nil {
31422 } else if d.h.DeleteOnNilMapValue {
31423 delete(v, mk)
31424 } else {
31425 v[mk] = 0
31426 }
31427 continue
31428 }
31429 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
31430 if v != nil {
31431 v[mk] = mv
31432 }
31433 }
31434 dd.ReadMapEnd()
31435 return v, changed
31436}
31437
31438func (d *Decoder) fastpathDecMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
31439 if rv.Kind() == reflect.Ptr {
31440 vp := rv2i(rv).(*map[int16]int64)
31441 v, changed := fastpathTV.DecMapInt16Int64V(*vp, true, d)
31442 if changed {
31443 *vp = v
31444 }
31445 } else {
31446 fastpathTV.DecMapInt16Int64V(rv2i(rv).(map[int16]int64), false, d)
31447 }
31448}
31449func (f fastpathT) DecMapInt16Int64X(vp *map[int16]int64, d *Decoder) {
31450 v, changed := f.DecMapInt16Int64V(*vp, true, d)
31451 if changed {
31452 *vp = v
31453 }
31454}
31455func (_ fastpathT) DecMapInt16Int64V(v map[int16]int64, canChange bool,
31456 d *Decoder) (_ map[int16]int64, changed bool) {
31457 dd, esep := d.d, d.hh.hasElemSeparators()
31458 containerLen := dd.ReadMapStart()
31459 if canChange && v == nil {
31460 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31461 v = make(map[int16]int64, xlen)
31462 changed = true
31463 }
31464 if containerLen == 0 {
31465 dd.ReadMapEnd()
31466 return v, changed
31467 }
31468 var mk int16
31469 var mv int64
31470 hasLen := containerLen > 0
31471 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31472 if esep {
31473 dd.ReadMapElemKey()
31474 }
31475 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31476 if esep {
31477 dd.ReadMapElemValue()
31478 }
31479 if dd.TryDecodeAsNil() {
31480 if v == nil {
31481 } else if d.h.DeleteOnNilMapValue {
31482 delete(v, mk)
31483 } else {
31484 v[mk] = 0
31485 }
31486 continue
31487 }
31488 mv = dd.DecodeInt64()
31489 if v != nil {
31490 v[mk] = mv
31491 }
31492 }
31493 dd.ReadMapEnd()
31494 return v, changed
31495}
31496
31497func (d *Decoder) fastpathDecMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
31498 if rv.Kind() == reflect.Ptr {
31499 vp := rv2i(rv).(*map[int16]float32)
31500 v, changed := fastpathTV.DecMapInt16Float32V(*vp, true, d)
31501 if changed {
31502 *vp = v
31503 }
31504 } else {
31505 fastpathTV.DecMapInt16Float32V(rv2i(rv).(map[int16]float32), false, d)
31506 }
31507}
31508func (f fastpathT) DecMapInt16Float32X(vp *map[int16]float32, d *Decoder) {
31509 v, changed := f.DecMapInt16Float32V(*vp, true, d)
31510 if changed {
31511 *vp = v
31512 }
31513}
31514func (_ fastpathT) DecMapInt16Float32V(v map[int16]float32, canChange bool,
31515 d *Decoder) (_ map[int16]float32, changed bool) {
31516 dd, esep := d.d, d.hh.hasElemSeparators()
31517 containerLen := dd.ReadMapStart()
31518 if canChange && v == nil {
31519 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
31520 v = make(map[int16]float32, xlen)
31521 changed = true
31522 }
31523 if containerLen == 0 {
31524 dd.ReadMapEnd()
31525 return v, changed
31526 }
31527 var mk int16
31528 var mv float32
31529 hasLen := containerLen > 0
31530 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31531 if esep {
31532 dd.ReadMapElemKey()
31533 }
31534 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31535 if esep {
31536 dd.ReadMapElemValue()
31537 }
31538 if dd.TryDecodeAsNil() {
31539 if v == nil {
31540 } else if d.h.DeleteOnNilMapValue {
31541 delete(v, mk)
31542 } else {
31543 v[mk] = 0
31544 }
31545 continue
31546 }
31547 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
31548 if v != nil {
31549 v[mk] = mv
31550 }
31551 }
31552 dd.ReadMapEnd()
31553 return v, changed
31554}
31555
31556func (d *Decoder) fastpathDecMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
31557 if rv.Kind() == reflect.Ptr {
31558 vp := rv2i(rv).(*map[int16]float64)
31559 v, changed := fastpathTV.DecMapInt16Float64V(*vp, true, d)
31560 if changed {
31561 *vp = v
31562 }
31563 } else {
31564 fastpathTV.DecMapInt16Float64V(rv2i(rv).(map[int16]float64), false, d)
31565 }
31566}
31567func (f fastpathT) DecMapInt16Float64X(vp *map[int16]float64, d *Decoder) {
31568 v, changed := f.DecMapInt16Float64V(*vp, true, d)
31569 if changed {
31570 *vp = v
31571 }
31572}
31573func (_ fastpathT) DecMapInt16Float64V(v map[int16]float64, canChange bool,
31574 d *Decoder) (_ map[int16]float64, changed bool) {
31575 dd, esep := d.d, d.hh.hasElemSeparators()
31576 containerLen := dd.ReadMapStart()
31577 if canChange && v == nil {
31578 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
31579 v = make(map[int16]float64, xlen)
31580 changed = true
31581 }
31582 if containerLen == 0 {
31583 dd.ReadMapEnd()
31584 return v, changed
31585 }
31586 var mk int16
31587 var mv float64
31588 hasLen := containerLen > 0
31589 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31590 if esep {
31591 dd.ReadMapElemKey()
31592 }
31593 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31594 if esep {
31595 dd.ReadMapElemValue()
31596 }
31597 if dd.TryDecodeAsNil() {
31598 if v == nil {
31599 } else if d.h.DeleteOnNilMapValue {
31600 delete(v, mk)
31601 } else {
31602 v[mk] = 0
31603 }
31604 continue
31605 }
31606 mv = dd.DecodeFloat64()
31607 if v != nil {
31608 v[mk] = mv
31609 }
31610 }
31611 dd.ReadMapEnd()
31612 return v, changed
31613}
31614
31615func (d *Decoder) fastpathDecMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
31616 if rv.Kind() == reflect.Ptr {
31617 vp := rv2i(rv).(*map[int16]bool)
31618 v, changed := fastpathTV.DecMapInt16BoolV(*vp, true, d)
31619 if changed {
31620 *vp = v
31621 }
31622 } else {
31623 fastpathTV.DecMapInt16BoolV(rv2i(rv).(map[int16]bool), false, d)
31624 }
31625}
31626func (f fastpathT) DecMapInt16BoolX(vp *map[int16]bool, d *Decoder) {
31627 v, changed := f.DecMapInt16BoolV(*vp, true, d)
31628 if changed {
31629 *vp = v
31630 }
31631}
31632func (_ fastpathT) DecMapInt16BoolV(v map[int16]bool, canChange bool,
31633 d *Decoder) (_ map[int16]bool, changed bool) {
31634 dd, esep := d.d, d.hh.hasElemSeparators()
31635 containerLen := dd.ReadMapStart()
31636 if canChange && v == nil {
31637 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
31638 v = make(map[int16]bool, xlen)
31639 changed = true
31640 }
31641 if containerLen == 0 {
31642 dd.ReadMapEnd()
31643 return v, changed
31644 }
31645 var mk int16
31646 var mv bool
31647 hasLen := containerLen > 0
31648 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31649 if esep {
31650 dd.ReadMapElemKey()
31651 }
31652 mk = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
31653 if esep {
31654 dd.ReadMapElemValue()
31655 }
31656 if dd.TryDecodeAsNil() {
31657 if v == nil {
31658 } else if d.h.DeleteOnNilMapValue {
31659 delete(v, mk)
31660 } else {
31661 v[mk] = false
31662 }
31663 continue
31664 }
31665 mv = dd.DecodeBool()
31666 if v != nil {
31667 v[mk] = mv
31668 }
31669 }
31670 dd.ReadMapEnd()
31671 return v, changed
31672}
31673
31674func (d *Decoder) fastpathDecMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
31675 if rv.Kind() == reflect.Ptr {
31676 vp := rv2i(rv).(*map[int32]interface{})
31677 v, changed := fastpathTV.DecMapInt32IntfV(*vp, true, d)
31678 if changed {
31679 *vp = v
31680 }
31681 } else {
31682 fastpathTV.DecMapInt32IntfV(rv2i(rv).(map[int32]interface{}), false, d)
31683 }
31684}
31685func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, d *Decoder) {
31686 v, changed := f.DecMapInt32IntfV(*vp, true, d)
31687 if changed {
31688 *vp = v
31689 }
31690}
31691func (_ fastpathT) DecMapInt32IntfV(v map[int32]interface{}, canChange bool,
31692 d *Decoder) (_ map[int32]interface{}, changed bool) {
31693 dd, esep := d.d, d.hh.hasElemSeparators()
31694 containerLen := dd.ReadMapStart()
31695 if canChange && v == nil {
31696 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
31697 v = make(map[int32]interface{}, xlen)
31698 changed = true
31699 }
31700 if containerLen == 0 {
31701 dd.ReadMapEnd()
31702 return v, changed
31703 }
31704 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
31705 var mk int32
31706 var mv interface{}
31707 hasLen := containerLen > 0
31708 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31709 if esep {
31710 dd.ReadMapElemKey()
31711 }
31712 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
31713 if esep {
31714 dd.ReadMapElemValue()
31715 }
31716 if dd.TryDecodeAsNil() {
31717 if v == nil {
31718 } else if d.h.DeleteOnNilMapValue {
31719 delete(v, mk)
31720 } else {
31721 v[mk] = nil
31722 }
31723 continue
31724 }
31725 if mapGet {
31726 mv = v[mk]
31727 } else {
31728 mv = nil
31729 }
31730 d.decode(&mv)
31731 if v != nil {
31732 v[mk] = mv
31733 }
31734 }
31735 dd.ReadMapEnd()
31736 return v, changed
31737}
31738
31739func (d *Decoder) fastpathDecMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
31740 if rv.Kind() == reflect.Ptr {
31741 vp := rv2i(rv).(*map[int32]string)
31742 v, changed := fastpathTV.DecMapInt32StringV(*vp, true, d)
31743 if changed {
31744 *vp = v
31745 }
31746 } else {
31747 fastpathTV.DecMapInt32StringV(rv2i(rv).(map[int32]string), false, d)
31748 }
31749}
31750func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, d *Decoder) {
31751 v, changed := f.DecMapInt32StringV(*vp, true, d)
31752 if changed {
31753 *vp = v
31754 }
31755}
31756func (_ fastpathT) DecMapInt32StringV(v map[int32]string, canChange bool,
31757 d *Decoder) (_ map[int32]string, changed bool) {
31758 dd, esep := d.d, d.hh.hasElemSeparators()
31759 containerLen := dd.ReadMapStart()
31760 if canChange && v == nil {
31761 xlen := decInferLen(containerLen, d.h.MaxInitLen, 20)
31762 v = make(map[int32]string, xlen)
31763 changed = true
31764 }
31765 if containerLen == 0 {
31766 dd.ReadMapEnd()
31767 return v, changed
31768 }
31769 var mk int32
31770 var mv string
31771 hasLen := containerLen > 0
31772 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31773 if esep {
31774 dd.ReadMapElemKey()
31775 }
31776 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
31777 if esep {
31778 dd.ReadMapElemValue()
31779 }
31780 if dd.TryDecodeAsNil() {
31781 if v == nil {
31782 } else if d.h.DeleteOnNilMapValue {
31783 delete(v, mk)
31784 } else {
31785 v[mk] = ""
31786 }
31787 continue
31788 }
31789 mv = dd.DecodeString()
31790 if v != nil {
31791 v[mk] = mv
31792 }
31793 }
31794 dd.ReadMapEnd()
31795 return v, changed
31796}
31797
31798func (d *Decoder) fastpathDecMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
31799 if rv.Kind() == reflect.Ptr {
31800 vp := rv2i(rv).(*map[int32]uint)
31801 v, changed := fastpathTV.DecMapInt32UintV(*vp, true, d)
31802 if changed {
31803 *vp = v
31804 }
31805 } else {
31806 fastpathTV.DecMapInt32UintV(rv2i(rv).(map[int32]uint), false, d)
31807 }
31808}
31809func (f fastpathT) DecMapInt32UintX(vp *map[int32]uint, d *Decoder) {
31810 v, changed := f.DecMapInt32UintV(*vp, true, d)
31811 if changed {
31812 *vp = v
31813 }
31814}
31815func (_ fastpathT) DecMapInt32UintV(v map[int32]uint, canChange bool,
31816 d *Decoder) (_ map[int32]uint, changed bool) {
31817 dd, esep := d.d, d.hh.hasElemSeparators()
31818 containerLen := dd.ReadMapStart()
31819 if canChange && v == nil {
31820 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
31821 v = make(map[int32]uint, xlen)
31822 changed = true
31823 }
31824 if containerLen == 0 {
31825 dd.ReadMapEnd()
31826 return v, changed
31827 }
31828 var mk int32
31829 var mv uint
31830 hasLen := containerLen > 0
31831 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31832 if esep {
31833 dd.ReadMapElemKey()
31834 }
31835 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
31836 if esep {
31837 dd.ReadMapElemValue()
31838 }
31839 if dd.TryDecodeAsNil() {
31840 if v == nil {
31841 } else if d.h.DeleteOnNilMapValue {
31842 delete(v, mk)
31843 } else {
31844 v[mk] = 0
31845 }
31846 continue
31847 }
31848 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
31849 if v != nil {
31850 v[mk] = mv
31851 }
31852 }
31853 dd.ReadMapEnd()
31854 return v, changed
31855}
31856
31857func (d *Decoder) fastpathDecMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
31858 if rv.Kind() == reflect.Ptr {
31859 vp := rv2i(rv).(*map[int32]uint8)
31860 v, changed := fastpathTV.DecMapInt32Uint8V(*vp, true, d)
31861 if changed {
31862 *vp = v
31863 }
31864 } else {
31865 fastpathTV.DecMapInt32Uint8V(rv2i(rv).(map[int32]uint8), false, d)
31866 }
31867}
31868func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, d *Decoder) {
31869 v, changed := f.DecMapInt32Uint8V(*vp, true, d)
31870 if changed {
31871 *vp = v
31872 }
31873}
31874func (_ fastpathT) DecMapInt32Uint8V(v map[int32]uint8, canChange bool,
31875 d *Decoder) (_ map[int32]uint8, changed bool) {
31876 dd, esep := d.d, d.hh.hasElemSeparators()
31877 containerLen := dd.ReadMapStart()
31878 if canChange && v == nil {
31879 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
31880 v = make(map[int32]uint8, xlen)
31881 changed = true
31882 }
31883 if containerLen == 0 {
31884 dd.ReadMapEnd()
31885 return v, changed
31886 }
31887 var mk int32
31888 var mv uint8
31889 hasLen := containerLen > 0
31890 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31891 if esep {
31892 dd.ReadMapElemKey()
31893 }
31894 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
31895 if esep {
31896 dd.ReadMapElemValue()
31897 }
31898 if dd.TryDecodeAsNil() {
31899 if v == nil {
31900 } else if d.h.DeleteOnNilMapValue {
31901 delete(v, mk)
31902 } else {
31903 v[mk] = 0
31904 }
31905 continue
31906 }
31907 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
31908 if v != nil {
31909 v[mk] = mv
31910 }
31911 }
31912 dd.ReadMapEnd()
31913 return v, changed
31914}
31915
31916func (d *Decoder) fastpathDecMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
31917 if rv.Kind() == reflect.Ptr {
31918 vp := rv2i(rv).(*map[int32]uint16)
31919 v, changed := fastpathTV.DecMapInt32Uint16V(*vp, true, d)
31920 if changed {
31921 *vp = v
31922 }
31923 } else {
31924 fastpathTV.DecMapInt32Uint16V(rv2i(rv).(map[int32]uint16), false, d)
31925 }
31926}
31927func (f fastpathT) DecMapInt32Uint16X(vp *map[int32]uint16, d *Decoder) {
31928 v, changed := f.DecMapInt32Uint16V(*vp, true, d)
31929 if changed {
31930 *vp = v
31931 }
31932}
31933func (_ fastpathT) DecMapInt32Uint16V(v map[int32]uint16, canChange bool,
31934 d *Decoder) (_ map[int32]uint16, changed bool) {
31935 dd, esep := d.d, d.hh.hasElemSeparators()
31936 containerLen := dd.ReadMapStart()
31937 if canChange && v == nil {
31938 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
31939 v = make(map[int32]uint16, xlen)
31940 changed = true
31941 }
31942 if containerLen == 0 {
31943 dd.ReadMapEnd()
31944 return v, changed
31945 }
31946 var mk int32
31947 var mv uint16
31948 hasLen := containerLen > 0
31949 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
31950 if esep {
31951 dd.ReadMapElemKey()
31952 }
31953 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
31954 if esep {
31955 dd.ReadMapElemValue()
31956 }
31957 if dd.TryDecodeAsNil() {
31958 if v == nil {
31959 } else if d.h.DeleteOnNilMapValue {
31960 delete(v, mk)
31961 } else {
31962 v[mk] = 0
31963 }
31964 continue
31965 }
31966 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
31967 if v != nil {
31968 v[mk] = mv
31969 }
31970 }
31971 dd.ReadMapEnd()
31972 return v, changed
31973}
31974
31975func (d *Decoder) fastpathDecMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
31976 if rv.Kind() == reflect.Ptr {
31977 vp := rv2i(rv).(*map[int32]uint32)
31978 v, changed := fastpathTV.DecMapInt32Uint32V(*vp, true, d)
31979 if changed {
31980 *vp = v
31981 }
31982 } else {
31983 fastpathTV.DecMapInt32Uint32V(rv2i(rv).(map[int32]uint32), false, d)
31984 }
31985}
31986func (f fastpathT) DecMapInt32Uint32X(vp *map[int32]uint32, d *Decoder) {
31987 v, changed := f.DecMapInt32Uint32V(*vp, true, d)
31988 if changed {
31989 *vp = v
31990 }
31991}
31992func (_ fastpathT) DecMapInt32Uint32V(v map[int32]uint32, canChange bool,
31993 d *Decoder) (_ map[int32]uint32, changed bool) {
31994 dd, esep := d.d, d.hh.hasElemSeparators()
31995 containerLen := dd.ReadMapStart()
31996 if canChange && v == nil {
31997 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
31998 v = make(map[int32]uint32, xlen)
31999 changed = true
32000 }
32001 if containerLen == 0 {
32002 dd.ReadMapEnd()
32003 return v, changed
32004 }
32005 var mk int32
32006 var mv uint32
32007 hasLen := containerLen > 0
32008 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32009 if esep {
32010 dd.ReadMapElemKey()
32011 }
32012 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32013 if esep {
32014 dd.ReadMapElemValue()
32015 }
32016 if dd.TryDecodeAsNil() {
32017 if v == nil {
32018 } else if d.h.DeleteOnNilMapValue {
32019 delete(v, mk)
32020 } else {
32021 v[mk] = 0
32022 }
32023 continue
32024 }
32025 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
32026 if v != nil {
32027 v[mk] = mv
32028 }
32029 }
32030 dd.ReadMapEnd()
32031 return v, changed
32032}
32033
32034func (d *Decoder) fastpathDecMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
32035 if rv.Kind() == reflect.Ptr {
32036 vp := rv2i(rv).(*map[int32]uint64)
32037 v, changed := fastpathTV.DecMapInt32Uint64V(*vp, true, d)
32038 if changed {
32039 *vp = v
32040 }
32041 } else {
32042 fastpathTV.DecMapInt32Uint64V(rv2i(rv).(map[int32]uint64), false, d)
32043 }
32044}
32045func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, d *Decoder) {
32046 v, changed := f.DecMapInt32Uint64V(*vp, true, d)
32047 if changed {
32048 *vp = v
32049 }
32050}
32051func (_ fastpathT) DecMapInt32Uint64V(v map[int32]uint64, canChange bool,
32052 d *Decoder) (_ map[int32]uint64, changed bool) {
32053 dd, esep := d.d, d.hh.hasElemSeparators()
32054 containerLen := dd.ReadMapStart()
32055 if canChange && v == nil {
32056 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32057 v = make(map[int32]uint64, xlen)
32058 changed = true
32059 }
32060 if containerLen == 0 {
32061 dd.ReadMapEnd()
32062 return v, changed
32063 }
32064 var mk int32
32065 var mv uint64
32066 hasLen := containerLen > 0
32067 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32068 if esep {
32069 dd.ReadMapElemKey()
32070 }
32071 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32072 if esep {
32073 dd.ReadMapElemValue()
32074 }
32075 if dd.TryDecodeAsNil() {
32076 if v == nil {
32077 } else if d.h.DeleteOnNilMapValue {
32078 delete(v, mk)
32079 } else {
32080 v[mk] = 0
32081 }
32082 continue
32083 }
32084 mv = dd.DecodeUint64()
32085 if v != nil {
32086 v[mk] = mv
32087 }
32088 }
32089 dd.ReadMapEnd()
32090 return v, changed
32091}
32092
32093func (d *Decoder) fastpathDecMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
32094 if rv.Kind() == reflect.Ptr {
32095 vp := rv2i(rv).(*map[int32]uintptr)
32096 v, changed := fastpathTV.DecMapInt32UintptrV(*vp, true, d)
32097 if changed {
32098 *vp = v
32099 }
32100 } else {
32101 fastpathTV.DecMapInt32UintptrV(rv2i(rv).(map[int32]uintptr), false, d)
32102 }
32103}
32104func (f fastpathT) DecMapInt32UintptrX(vp *map[int32]uintptr, d *Decoder) {
32105 v, changed := f.DecMapInt32UintptrV(*vp, true, d)
32106 if changed {
32107 *vp = v
32108 }
32109}
32110func (_ fastpathT) DecMapInt32UintptrV(v map[int32]uintptr, canChange bool,
32111 d *Decoder) (_ map[int32]uintptr, changed bool) {
32112 dd, esep := d.d, d.hh.hasElemSeparators()
32113 containerLen := dd.ReadMapStart()
32114 if canChange && v == nil {
32115 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32116 v = make(map[int32]uintptr, xlen)
32117 changed = true
32118 }
32119 if containerLen == 0 {
32120 dd.ReadMapEnd()
32121 return v, changed
32122 }
32123 var mk int32
32124 var mv uintptr
32125 hasLen := containerLen > 0
32126 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32127 if esep {
32128 dd.ReadMapElemKey()
32129 }
32130 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32131 if esep {
32132 dd.ReadMapElemValue()
32133 }
32134 if dd.TryDecodeAsNil() {
32135 if v == nil {
32136 } else if d.h.DeleteOnNilMapValue {
32137 delete(v, mk)
32138 } else {
32139 v[mk] = 0
32140 }
32141 continue
32142 }
32143 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
32144 if v != nil {
32145 v[mk] = mv
32146 }
32147 }
32148 dd.ReadMapEnd()
32149 return v, changed
32150}
32151
32152func (d *Decoder) fastpathDecMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
32153 if rv.Kind() == reflect.Ptr {
32154 vp := rv2i(rv).(*map[int32]int)
32155 v, changed := fastpathTV.DecMapInt32IntV(*vp, true, d)
32156 if changed {
32157 *vp = v
32158 }
32159 } else {
32160 fastpathTV.DecMapInt32IntV(rv2i(rv).(map[int32]int), false, d)
32161 }
32162}
32163func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, d *Decoder) {
32164 v, changed := f.DecMapInt32IntV(*vp, true, d)
32165 if changed {
32166 *vp = v
32167 }
32168}
32169func (_ fastpathT) DecMapInt32IntV(v map[int32]int, canChange bool,
32170 d *Decoder) (_ map[int32]int, changed bool) {
32171 dd, esep := d.d, d.hh.hasElemSeparators()
32172 containerLen := dd.ReadMapStart()
32173 if canChange && v == nil {
32174 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32175 v = make(map[int32]int, xlen)
32176 changed = true
32177 }
32178 if containerLen == 0 {
32179 dd.ReadMapEnd()
32180 return v, changed
32181 }
32182 var mk int32
32183 var mv int
32184 hasLen := containerLen > 0
32185 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32186 if esep {
32187 dd.ReadMapElemKey()
32188 }
32189 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32190 if esep {
32191 dd.ReadMapElemValue()
32192 }
32193 if dd.TryDecodeAsNil() {
32194 if v == nil {
32195 } else if d.h.DeleteOnNilMapValue {
32196 delete(v, mk)
32197 } else {
32198 v[mk] = 0
32199 }
32200 continue
32201 }
32202 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
32203 if v != nil {
32204 v[mk] = mv
32205 }
32206 }
32207 dd.ReadMapEnd()
32208 return v, changed
32209}
32210
32211func (d *Decoder) fastpathDecMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
32212 if rv.Kind() == reflect.Ptr {
32213 vp := rv2i(rv).(*map[int32]int8)
32214 v, changed := fastpathTV.DecMapInt32Int8V(*vp, true, d)
32215 if changed {
32216 *vp = v
32217 }
32218 } else {
32219 fastpathTV.DecMapInt32Int8V(rv2i(rv).(map[int32]int8), false, d)
32220 }
32221}
32222func (f fastpathT) DecMapInt32Int8X(vp *map[int32]int8, d *Decoder) {
32223 v, changed := f.DecMapInt32Int8V(*vp, true, d)
32224 if changed {
32225 *vp = v
32226 }
32227}
32228func (_ fastpathT) DecMapInt32Int8V(v map[int32]int8, canChange bool,
32229 d *Decoder) (_ map[int32]int8, changed bool) {
32230 dd, esep := d.d, d.hh.hasElemSeparators()
32231 containerLen := dd.ReadMapStart()
32232 if canChange && v == nil {
32233 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
32234 v = make(map[int32]int8, xlen)
32235 changed = true
32236 }
32237 if containerLen == 0 {
32238 dd.ReadMapEnd()
32239 return v, changed
32240 }
32241 var mk int32
32242 var mv int8
32243 hasLen := containerLen > 0
32244 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32245 if esep {
32246 dd.ReadMapElemKey()
32247 }
32248 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32249 if esep {
32250 dd.ReadMapElemValue()
32251 }
32252 if dd.TryDecodeAsNil() {
32253 if v == nil {
32254 } else if d.h.DeleteOnNilMapValue {
32255 delete(v, mk)
32256 } else {
32257 v[mk] = 0
32258 }
32259 continue
32260 }
32261 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
32262 if v != nil {
32263 v[mk] = mv
32264 }
32265 }
32266 dd.ReadMapEnd()
32267 return v, changed
32268}
32269
32270func (d *Decoder) fastpathDecMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
32271 if rv.Kind() == reflect.Ptr {
32272 vp := rv2i(rv).(*map[int32]int16)
32273 v, changed := fastpathTV.DecMapInt32Int16V(*vp, true, d)
32274 if changed {
32275 *vp = v
32276 }
32277 } else {
32278 fastpathTV.DecMapInt32Int16V(rv2i(rv).(map[int32]int16), false, d)
32279 }
32280}
32281func (f fastpathT) DecMapInt32Int16X(vp *map[int32]int16, d *Decoder) {
32282 v, changed := f.DecMapInt32Int16V(*vp, true, d)
32283 if changed {
32284 *vp = v
32285 }
32286}
32287func (_ fastpathT) DecMapInt32Int16V(v map[int32]int16, canChange bool,
32288 d *Decoder) (_ map[int32]int16, changed bool) {
32289 dd, esep := d.d, d.hh.hasElemSeparators()
32290 containerLen := dd.ReadMapStart()
32291 if canChange && v == nil {
32292 xlen := decInferLen(containerLen, d.h.MaxInitLen, 6)
32293 v = make(map[int32]int16, xlen)
32294 changed = true
32295 }
32296 if containerLen == 0 {
32297 dd.ReadMapEnd()
32298 return v, changed
32299 }
32300 var mk int32
32301 var mv int16
32302 hasLen := containerLen > 0
32303 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32304 if esep {
32305 dd.ReadMapElemKey()
32306 }
32307 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32308 if esep {
32309 dd.ReadMapElemValue()
32310 }
32311 if dd.TryDecodeAsNil() {
32312 if v == nil {
32313 } else if d.h.DeleteOnNilMapValue {
32314 delete(v, mk)
32315 } else {
32316 v[mk] = 0
32317 }
32318 continue
32319 }
32320 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
32321 if v != nil {
32322 v[mk] = mv
32323 }
32324 }
32325 dd.ReadMapEnd()
32326 return v, changed
32327}
32328
32329func (d *Decoder) fastpathDecMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
32330 if rv.Kind() == reflect.Ptr {
32331 vp := rv2i(rv).(*map[int32]int32)
32332 v, changed := fastpathTV.DecMapInt32Int32V(*vp, true, d)
32333 if changed {
32334 *vp = v
32335 }
32336 } else {
32337 fastpathTV.DecMapInt32Int32V(rv2i(rv).(map[int32]int32), false, d)
32338 }
32339}
32340func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, d *Decoder) {
32341 v, changed := f.DecMapInt32Int32V(*vp, true, d)
32342 if changed {
32343 *vp = v
32344 }
32345}
32346func (_ fastpathT) DecMapInt32Int32V(v map[int32]int32, canChange bool,
32347 d *Decoder) (_ map[int32]int32, changed bool) {
32348 dd, esep := d.d, d.hh.hasElemSeparators()
32349 containerLen := dd.ReadMapStart()
32350 if canChange && v == nil {
32351 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
32352 v = make(map[int32]int32, xlen)
32353 changed = true
32354 }
32355 if containerLen == 0 {
32356 dd.ReadMapEnd()
32357 return v, changed
32358 }
32359 var mk int32
32360 var mv int32
32361 hasLen := containerLen > 0
32362 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32363 if esep {
32364 dd.ReadMapElemKey()
32365 }
32366 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32367 if esep {
32368 dd.ReadMapElemValue()
32369 }
32370 if dd.TryDecodeAsNil() {
32371 if v == nil {
32372 } else if d.h.DeleteOnNilMapValue {
32373 delete(v, mk)
32374 } else {
32375 v[mk] = 0
32376 }
32377 continue
32378 }
32379 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32380 if v != nil {
32381 v[mk] = mv
32382 }
32383 }
32384 dd.ReadMapEnd()
32385 return v, changed
32386}
32387
32388func (d *Decoder) fastpathDecMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
32389 if rv.Kind() == reflect.Ptr {
32390 vp := rv2i(rv).(*map[int32]int64)
32391 v, changed := fastpathTV.DecMapInt32Int64V(*vp, true, d)
32392 if changed {
32393 *vp = v
32394 }
32395 } else {
32396 fastpathTV.DecMapInt32Int64V(rv2i(rv).(map[int32]int64), false, d)
32397 }
32398}
32399func (f fastpathT) DecMapInt32Int64X(vp *map[int32]int64, d *Decoder) {
32400 v, changed := f.DecMapInt32Int64V(*vp, true, d)
32401 if changed {
32402 *vp = v
32403 }
32404}
32405func (_ fastpathT) DecMapInt32Int64V(v map[int32]int64, canChange bool,
32406 d *Decoder) (_ map[int32]int64, changed bool) {
32407 dd, esep := d.d, d.hh.hasElemSeparators()
32408 containerLen := dd.ReadMapStart()
32409 if canChange && v == nil {
32410 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32411 v = make(map[int32]int64, xlen)
32412 changed = true
32413 }
32414 if containerLen == 0 {
32415 dd.ReadMapEnd()
32416 return v, changed
32417 }
32418 var mk int32
32419 var mv int64
32420 hasLen := containerLen > 0
32421 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32422 if esep {
32423 dd.ReadMapElemKey()
32424 }
32425 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32426 if esep {
32427 dd.ReadMapElemValue()
32428 }
32429 if dd.TryDecodeAsNil() {
32430 if v == nil {
32431 } else if d.h.DeleteOnNilMapValue {
32432 delete(v, mk)
32433 } else {
32434 v[mk] = 0
32435 }
32436 continue
32437 }
32438 mv = dd.DecodeInt64()
32439 if v != nil {
32440 v[mk] = mv
32441 }
32442 }
32443 dd.ReadMapEnd()
32444 return v, changed
32445}
32446
32447func (d *Decoder) fastpathDecMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
32448 if rv.Kind() == reflect.Ptr {
32449 vp := rv2i(rv).(*map[int32]float32)
32450 v, changed := fastpathTV.DecMapInt32Float32V(*vp, true, d)
32451 if changed {
32452 *vp = v
32453 }
32454 } else {
32455 fastpathTV.DecMapInt32Float32V(rv2i(rv).(map[int32]float32), false, d)
32456 }
32457}
32458func (f fastpathT) DecMapInt32Float32X(vp *map[int32]float32, d *Decoder) {
32459 v, changed := f.DecMapInt32Float32V(*vp, true, d)
32460 if changed {
32461 *vp = v
32462 }
32463}
32464func (_ fastpathT) DecMapInt32Float32V(v map[int32]float32, canChange bool,
32465 d *Decoder) (_ map[int32]float32, changed bool) {
32466 dd, esep := d.d, d.hh.hasElemSeparators()
32467 containerLen := dd.ReadMapStart()
32468 if canChange && v == nil {
32469 xlen := decInferLen(containerLen, d.h.MaxInitLen, 8)
32470 v = make(map[int32]float32, xlen)
32471 changed = true
32472 }
32473 if containerLen == 0 {
32474 dd.ReadMapEnd()
32475 return v, changed
32476 }
32477 var mk int32
32478 var mv float32
32479 hasLen := containerLen > 0
32480 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32481 if esep {
32482 dd.ReadMapElemKey()
32483 }
32484 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32485 if esep {
32486 dd.ReadMapElemValue()
32487 }
32488 if dd.TryDecodeAsNil() {
32489 if v == nil {
32490 } else if d.h.DeleteOnNilMapValue {
32491 delete(v, mk)
32492 } else {
32493 v[mk] = 0
32494 }
32495 continue
32496 }
32497 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
32498 if v != nil {
32499 v[mk] = mv
32500 }
32501 }
32502 dd.ReadMapEnd()
32503 return v, changed
32504}
32505
32506func (d *Decoder) fastpathDecMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
32507 if rv.Kind() == reflect.Ptr {
32508 vp := rv2i(rv).(*map[int32]float64)
32509 v, changed := fastpathTV.DecMapInt32Float64V(*vp, true, d)
32510 if changed {
32511 *vp = v
32512 }
32513 } else {
32514 fastpathTV.DecMapInt32Float64V(rv2i(rv).(map[int32]float64), false, d)
32515 }
32516}
32517func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, d *Decoder) {
32518 v, changed := f.DecMapInt32Float64V(*vp, true, d)
32519 if changed {
32520 *vp = v
32521 }
32522}
32523func (_ fastpathT) DecMapInt32Float64V(v map[int32]float64, canChange bool,
32524 d *Decoder) (_ map[int32]float64, changed bool) {
32525 dd, esep := d.d, d.hh.hasElemSeparators()
32526 containerLen := dd.ReadMapStart()
32527 if canChange && v == nil {
32528 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32529 v = make(map[int32]float64, xlen)
32530 changed = true
32531 }
32532 if containerLen == 0 {
32533 dd.ReadMapEnd()
32534 return v, changed
32535 }
32536 var mk int32
32537 var mv float64
32538 hasLen := containerLen > 0
32539 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32540 if esep {
32541 dd.ReadMapElemKey()
32542 }
32543 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32544 if esep {
32545 dd.ReadMapElemValue()
32546 }
32547 if dd.TryDecodeAsNil() {
32548 if v == nil {
32549 } else if d.h.DeleteOnNilMapValue {
32550 delete(v, mk)
32551 } else {
32552 v[mk] = 0
32553 }
32554 continue
32555 }
32556 mv = dd.DecodeFloat64()
32557 if v != nil {
32558 v[mk] = mv
32559 }
32560 }
32561 dd.ReadMapEnd()
32562 return v, changed
32563}
32564
32565func (d *Decoder) fastpathDecMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
32566 if rv.Kind() == reflect.Ptr {
32567 vp := rv2i(rv).(*map[int32]bool)
32568 v, changed := fastpathTV.DecMapInt32BoolV(*vp, true, d)
32569 if changed {
32570 *vp = v
32571 }
32572 } else {
32573 fastpathTV.DecMapInt32BoolV(rv2i(rv).(map[int32]bool), false, d)
32574 }
32575}
32576func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, d *Decoder) {
32577 v, changed := f.DecMapInt32BoolV(*vp, true, d)
32578 if changed {
32579 *vp = v
32580 }
32581}
32582func (_ fastpathT) DecMapInt32BoolV(v map[int32]bool, canChange bool,
32583 d *Decoder) (_ map[int32]bool, changed bool) {
32584 dd, esep := d.d, d.hh.hasElemSeparators()
32585 containerLen := dd.ReadMapStart()
32586 if canChange && v == nil {
32587 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
32588 v = make(map[int32]bool, xlen)
32589 changed = true
32590 }
32591 if containerLen == 0 {
32592 dd.ReadMapEnd()
32593 return v, changed
32594 }
32595 var mk int32
32596 var mv bool
32597 hasLen := containerLen > 0
32598 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32599 if esep {
32600 dd.ReadMapElemKey()
32601 }
32602 mk = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
32603 if esep {
32604 dd.ReadMapElemValue()
32605 }
32606 if dd.TryDecodeAsNil() {
32607 if v == nil {
32608 } else if d.h.DeleteOnNilMapValue {
32609 delete(v, mk)
32610 } else {
32611 v[mk] = false
32612 }
32613 continue
32614 }
32615 mv = dd.DecodeBool()
32616 if v != nil {
32617 v[mk] = mv
32618 }
32619 }
32620 dd.ReadMapEnd()
32621 return v, changed
32622}
32623
32624func (d *Decoder) fastpathDecMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
32625 if rv.Kind() == reflect.Ptr {
32626 vp := rv2i(rv).(*map[int64]interface{})
32627 v, changed := fastpathTV.DecMapInt64IntfV(*vp, true, d)
32628 if changed {
32629 *vp = v
32630 }
32631 } else {
32632 fastpathTV.DecMapInt64IntfV(rv2i(rv).(map[int64]interface{}), false, d)
32633 }
32634}
32635func (f fastpathT) DecMapInt64IntfX(vp *map[int64]interface{}, d *Decoder) {
32636 v, changed := f.DecMapInt64IntfV(*vp, true, d)
32637 if changed {
32638 *vp = v
32639 }
32640}
32641func (_ fastpathT) DecMapInt64IntfV(v map[int64]interface{}, canChange bool,
32642 d *Decoder) (_ map[int64]interface{}, changed bool) {
32643 dd, esep := d.d, d.hh.hasElemSeparators()
32644 containerLen := dd.ReadMapStart()
32645 if canChange && v == nil {
32646 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
32647 v = make(map[int64]interface{}, xlen)
32648 changed = true
32649 }
32650 if containerLen == 0 {
32651 dd.ReadMapEnd()
32652 return v, changed
32653 }
32654 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
32655 var mk int64
32656 var mv interface{}
32657 hasLen := containerLen > 0
32658 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32659 if esep {
32660 dd.ReadMapElemKey()
32661 }
32662 mk = dd.DecodeInt64()
32663 if esep {
32664 dd.ReadMapElemValue()
32665 }
32666 if dd.TryDecodeAsNil() {
32667 if v == nil {
32668 } else if d.h.DeleteOnNilMapValue {
32669 delete(v, mk)
32670 } else {
32671 v[mk] = nil
32672 }
32673 continue
32674 }
32675 if mapGet {
32676 mv = v[mk]
32677 } else {
32678 mv = nil
32679 }
32680 d.decode(&mv)
32681 if v != nil {
32682 v[mk] = mv
32683 }
32684 }
32685 dd.ReadMapEnd()
32686 return v, changed
32687}
32688
32689func (d *Decoder) fastpathDecMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
32690 if rv.Kind() == reflect.Ptr {
32691 vp := rv2i(rv).(*map[int64]string)
32692 v, changed := fastpathTV.DecMapInt64StringV(*vp, true, d)
32693 if changed {
32694 *vp = v
32695 }
32696 } else {
32697 fastpathTV.DecMapInt64StringV(rv2i(rv).(map[int64]string), false, d)
32698 }
32699}
32700func (f fastpathT) DecMapInt64StringX(vp *map[int64]string, d *Decoder) {
32701 v, changed := f.DecMapInt64StringV(*vp, true, d)
32702 if changed {
32703 *vp = v
32704 }
32705}
32706func (_ fastpathT) DecMapInt64StringV(v map[int64]string, canChange bool,
32707 d *Decoder) (_ map[int64]string, changed bool) {
32708 dd, esep := d.d, d.hh.hasElemSeparators()
32709 containerLen := dd.ReadMapStart()
32710 if canChange && v == nil {
32711 xlen := decInferLen(containerLen, d.h.MaxInitLen, 24)
32712 v = make(map[int64]string, xlen)
32713 changed = true
32714 }
32715 if containerLen == 0 {
32716 dd.ReadMapEnd()
32717 return v, changed
32718 }
32719 var mk int64
32720 var mv string
32721 hasLen := containerLen > 0
32722 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32723 if esep {
32724 dd.ReadMapElemKey()
32725 }
32726 mk = dd.DecodeInt64()
32727 if esep {
32728 dd.ReadMapElemValue()
32729 }
32730 if dd.TryDecodeAsNil() {
32731 if v == nil {
32732 } else if d.h.DeleteOnNilMapValue {
32733 delete(v, mk)
32734 } else {
32735 v[mk] = ""
32736 }
32737 continue
32738 }
32739 mv = dd.DecodeString()
32740 if v != nil {
32741 v[mk] = mv
32742 }
32743 }
32744 dd.ReadMapEnd()
32745 return v, changed
32746}
32747
32748func (d *Decoder) fastpathDecMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
32749 if rv.Kind() == reflect.Ptr {
32750 vp := rv2i(rv).(*map[int64]uint)
32751 v, changed := fastpathTV.DecMapInt64UintV(*vp, true, d)
32752 if changed {
32753 *vp = v
32754 }
32755 } else {
32756 fastpathTV.DecMapInt64UintV(rv2i(rv).(map[int64]uint), false, d)
32757 }
32758}
32759func (f fastpathT) DecMapInt64UintX(vp *map[int64]uint, d *Decoder) {
32760 v, changed := f.DecMapInt64UintV(*vp, true, d)
32761 if changed {
32762 *vp = v
32763 }
32764}
32765func (_ fastpathT) DecMapInt64UintV(v map[int64]uint, canChange bool,
32766 d *Decoder) (_ map[int64]uint, changed bool) {
32767 dd, esep := d.d, d.hh.hasElemSeparators()
32768 containerLen := dd.ReadMapStart()
32769 if canChange && v == nil {
32770 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
32771 v = make(map[int64]uint, xlen)
32772 changed = true
32773 }
32774 if containerLen == 0 {
32775 dd.ReadMapEnd()
32776 return v, changed
32777 }
32778 var mk int64
32779 var mv uint
32780 hasLen := containerLen > 0
32781 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32782 if esep {
32783 dd.ReadMapElemKey()
32784 }
32785 mk = dd.DecodeInt64()
32786 if esep {
32787 dd.ReadMapElemValue()
32788 }
32789 if dd.TryDecodeAsNil() {
32790 if v == nil {
32791 } else if d.h.DeleteOnNilMapValue {
32792 delete(v, mk)
32793 } else {
32794 v[mk] = 0
32795 }
32796 continue
32797 }
32798 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
32799 if v != nil {
32800 v[mk] = mv
32801 }
32802 }
32803 dd.ReadMapEnd()
32804 return v, changed
32805}
32806
32807func (d *Decoder) fastpathDecMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
32808 if rv.Kind() == reflect.Ptr {
32809 vp := rv2i(rv).(*map[int64]uint8)
32810 v, changed := fastpathTV.DecMapInt64Uint8V(*vp, true, d)
32811 if changed {
32812 *vp = v
32813 }
32814 } else {
32815 fastpathTV.DecMapInt64Uint8V(rv2i(rv).(map[int64]uint8), false, d)
32816 }
32817}
32818func (f fastpathT) DecMapInt64Uint8X(vp *map[int64]uint8, d *Decoder) {
32819 v, changed := f.DecMapInt64Uint8V(*vp, true, d)
32820 if changed {
32821 *vp = v
32822 }
32823}
32824func (_ fastpathT) DecMapInt64Uint8V(v map[int64]uint8, canChange bool,
32825 d *Decoder) (_ map[int64]uint8, changed bool) {
32826 dd, esep := d.d, d.hh.hasElemSeparators()
32827 containerLen := dd.ReadMapStart()
32828 if canChange && v == nil {
32829 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
32830 v = make(map[int64]uint8, xlen)
32831 changed = true
32832 }
32833 if containerLen == 0 {
32834 dd.ReadMapEnd()
32835 return v, changed
32836 }
32837 var mk int64
32838 var mv uint8
32839 hasLen := containerLen > 0
32840 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32841 if esep {
32842 dd.ReadMapElemKey()
32843 }
32844 mk = dd.DecodeInt64()
32845 if esep {
32846 dd.ReadMapElemValue()
32847 }
32848 if dd.TryDecodeAsNil() {
32849 if v == nil {
32850 } else if d.h.DeleteOnNilMapValue {
32851 delete(v, mk)
32852 } else {
32853 v[mk] = 0
32854 }
32855 continue
32856 }
32857 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
32858 if v != nil {
32859 v[mk] = mv
32860 }
32861 }
32862 dd.ReadMapEnd()
32863 return v, changed
32864}
32865
32866func (d *Decoder) fastpathDecMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
32867 if rv.Kind() == reflect.Ptr {
32868 vp := rv2i(rv).(*map[int64]uint16)
32869 v, changed := fastpathTV.DecMapInt64Uint16V(*vp, true, d)
32870 if changed {
32871 *vp = v
32872 }
32873 } else {
32874 fastpathTV.DecMapInt64Uint16V(rv2i(rv).(map[int64]uint16), false, d)
32875 }
32876}
32877func (f fastpathT) DecMapInt64Uint16X(vp *map[int64]uint16, d *Decoder) {
32878 v, changed := f.DecMapInt64Uint16V(*vp, true, d)
32879 if changed {
32880 *vp = v
32881 }
32882}
32883func (_ fastpathT) DecMapInt64Uint16V(v map[int64]uint16, canChange bool,
32884 d *Decoder) (_ map[int64]uint16, changed bool) {
32885 dd, esep := d.d, d.hh.hasElemSeparators()
32886 containerLen := dd.ReadMapStart()
32887 if canChange && v == nil {
32888 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
32889 v = make(map[int64]uint16, xlen)
32890 changed = true
32891 }
32892 if containerLen == 0 {
32893 dd.ReadMapEnd()
32894 return v, changed
32895 }
32896 var mk int64
32897 var mv uint16
32898 hasLen := containerLen > 0
32899 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32900 if esep {
32901 dd.ReadMapElemKey()
32902 }
32903 mk = dd.DecodeInt64()
32904 if esep {
32905 dd.ReadMapElemValue()
32906 }
32907 if dd.TryDecodeAsNil() {
32908 if v == nil {
32909 } else if d.h.DeleteOnNilMapValue {
32910 delete(v, mk)
32911 } else {
32912 v[mk] = 0
32913 }
32914 continue
32915 }
32916 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
32917 if v != nil {
32918 v[mk] = mv
32919 }
32920 }
32921 dd.ReadMapEnd()
32922 return v, changed
32923}
32924
32925func (d *Decoder) fastpathDecMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
32926 if rv.Kind() == reflect.Ptr {
32927 vp := rv2i(rv).(*map[int64]uint32)
32928 v, changed := fastpathTV.DecMapInt64Uint32V(*vp, true, d)
32929 if changed {
32930 *vp = v
32931 }
32932 } else {
32933 fastpathTV.DecMapInt64Uint32V(rv2i(rv).(map[int64]uint32), false, d)
32934 }
32935}
32936func (f fastpathT) DecMapInt64Uint32X(vp *map[int64]uint32, d *Decoder) {
32937 v, changed := f.DecMapInt64Uint32V(*vp, true, d)
32938 if changed {
32939 *vp = v
32940 }
32941}
32942func (_ fastpathT) DecMapInt64Uint32V(v map[int64]uint32, canChange bool,
32943 d *Decoder) (_ map[int64]uint32, changed bool) {
32944 dd, esep := d.d, d.hh.hasElemSeparators()
32945 containerLen := dd.ReadMapStart()
32946 if canChange && v == nil {
32947 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
32948 v = make(map[int64]uint32, xlen)
32949 changed = true
32950 }
32951 if containerLen == 0 {
32952 dd.ReadMapEnd()
32953 return v, changed
32954 }
32955 var mk int64
32956 var mv uint32
32957 hasLen := containerLen > 0
32958 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
32959 if esep {
32960 dd.ReadMapElemKey()
32961 }
32962 mk = dd.DecodeInt64()
32963 if esep {
32964 dd.ReadMapElemValue()
32965 }
32966 if dd.TryDecodeAsNil() {
32967 if v == nil {
32968 } else if d.h.DeleteOnNilMapValue {
32969 delete(v, mk)
32970 } else {
32971 v[mk] = 0
32972 }
32973 continue
32974 }
32975 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
32976 if v != nil {
32977 v[mk] = mv
32978 }
32979 }
32980 dd.ReadMapEnd()
32981 return v, changed
32982}
32983
32984func (d *Decoder) fastpathDecMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
32985 if rv.Kind() == reflect.Ptr {
32986 vp := rv2i(rv).(*map[int64]uint64)
32987 v, changed := fastpathTV.DecMapInt64Uint64V(*vp, true, d)
32988 if changed {
32989 *vp = v
32990 }
32991 } else {
32992 fastpathTV.DecMapInt64Uint64V(rv2i(rv).(map[int64]uint64), false, d)
32993 }
32994}
32995func (f fastpathT) DecMapInt64Uint64X(vp *map[int64]uint64, d *Decoder) {
32996 v, changed := f.DecMapInt64Uint64V(*vp, true, d)
32997 if changed {
32998 *vp = v
32999 }
33000}
33001func (_ fastpathT) DecMapInt64Uint64V(v map[int64]uint64, canChange bool,
33002 d *Decoder) (_ map[int64]uint64, changed bool) {
33003 dd, esep := d.d, d.hh.hasElemSeparators()
33004 containerLen := dd.ReadMapStart()
33005 if canChange && v == nil {
33006 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33007 v = make(map[int64]uint64, xlen)
33008 changed = true
33009 }
33010 if containerLen == 0 {
33011 dd.ReadMapEnd()
33012 return v, changed
33013 }
33014 var mk int64
33015 var mv uint64
33016 hasLen := containerLen > 0
33017 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33018 if esep {
33019 dd.ReadMapElemKey()
33020 }
33021 mk = dd.DecodeInt64()
33022 if esep {
33023 dd.ReadMapElemValue()
33024 }
33025 if dd.TryDecodeAsNil() {
33026 if v == nil {
33027 } else if d.h.DeleteOnNilMapValue {
33028 delete(v, mk)
33029 } else {
33030 v[mk] = 0
33031 }
33032 continue
33033 }
33034 mv = dd.DecodeUint64()
33035 if v != nil {
33036 v[mk] = mv
33037 }
33038 }
33039 dd.ReadMapEnd()
33040 return v, changed
33041}
33042
33043func (d *Decoder) fastpathDecMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
33044 if rv.Kind() == reflect.Ptr {
33045 vp := rv2i(rv).(*map[int64]uintptr)
33046 v, changed := fastpathTV.DecMapInt64UintptrV(*vp, true, d)
33047 if changed {
33048 *vp = v
33049 }
33050 } else {
33051 fastpathTV.DecMapInt64UintptrV(rv2i(rv).(map[int64]uintptr), false, d)
33052 }
33053}
33054func (f fastpathT) DecMapInt64UintptrX(vp *map[int64]uintptr, d *Decoder) {
33055 v, changed := f.DecMapInt64UintptrV(*vp, true, d)
33056 if changed {
33057 *vp = v
33058 }
33059}
33060func (_ fastpathT) DecMapInt64UintptrV(v map[int64]uintptr, canChange bool,
33061 d *Decoder) (_ map[int64]uintptr, 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, 16)
33066 v = make(map[int64]uintptr, xlen)
33067 changed = true
33068 }
33069 if containerLen == 0 {
33070 dd.ReadMapEnd()
33071 return v, changed
33072 }
33073 var mk int64
33074 var mv uintptr
33075 hasLen := containerLen > 0
33076 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33077 if esep {
33078 dd.ReadMapElemKey()
33079 }
33080 mk = dd.DecodeInt64()
33081 if esep {
33082 dd.ReadMapElemValue()
33083 }
33084 if dd.TryDecodeAsNil() {
33085 if v == nil {
33086 } else if d.h.DeleteOnNilMapValue {
33087 delete(v, mk)
33088 } else {
33089 v[mk] = 0
33090 }
33091 continue
33092 }
33093 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
33094 if v != nil {
33095 v[mk] = mv
33096 }
33097 }
33098 dd.ReadMapEnd()
33099 return v, changed
33100}
33101
33102func (d *Decoder) fastpathDecMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
33103 if rv.Kind() == reflect.Ptr {
33104 vp := rv2i(rv).(*map[int64]int)
33105 v, changed := fastpathTV.DecMapInt64IntV(*vp, true, d)
33106 if changed {
33107 *vp = v
33108 }
33109 } else {
33110 fastpathTV.DecMapInt64IntV(rv2i(rv).(map[int64]int), false, d)
33111 }
33112}
33113func (f fastpathT) DecMapInt64IntX(vp *map[int64]int, d *Decoder) {
33114 v, changed := f.DecMapInt64IntV(*vp, true, d)
33115 if changed {
33116 *vp = v
33117 }
33118}
33119func (_ fastpathT) DecMapInt64IntV(v map[int64]int, canChange bool,
33120 d *Decoder) (_ map[int64]int, changed bool) {
33121 dd, esep := d.d, d.hh.hasElemSeparators()
33122 containerLen := dd.ReadMapStart()
33123 if canChange && v == nil {
33124 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33125 v = make(map[int64]int, xlen)
33126 changed = true
33127 }
33128 if containerLen == 0 {
33129 dd.ReadMapEnd()
33130 return v, changed
33131 }
33132 var mk int64
33133 var mv int
33134 hasLen := containerLen > 0
33135 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33136 if esep {
33137 dd.ReadMapElemKey()
33138 }
33139 mk = dd.DecodeInt64()
33140 if esep {
33141 dd.ReadMapElemValue()
33142 }
33143 if dd.TryDecodeAsNil() {
33144 if v == nil {
33145 } else if d.h.DeleteOnNilMapValue {
33146 delete(v, mk)
33147 } else {
33148 v[mk] = 0
33149 }
33150 continue
33151 }
33152 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
33153 if v != nil {
33154 v[mk] = mv
33155 }
33156 }
33157 dd.ReadMapEnd()
33158 return v, changed
33159}
33160
33161func (d *Decoder) fastpathDecMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
33162 if rv.Kind() == reflect.Ptr {
33163 vp := rv2i(rv).(*map[int64]int8)
33164 v, changed := fastpathTV.DecMapInt64Int8V(*vp, true, d)
33165 if changed {
33166 *vp = v
33167 }
33168 } else {
33169 fastpathTV.DecMapInt64Int8V(rv2i(rv).(map[int64]int8), false, d)
33170 }
33171}
33172func (f fastpathT) DecMapInt64Int8X(vp *map[int64]int8, d *Decoder) {
33173 v, changed := f.DecMapInt64Int8V(*vp, true, d)
33174 if changed {
33175 *vp = v
33176 }
33177}
33178func (_ fastpathT) DecMapInt64Int8V(v map[int64]int8, canChange bool,
33179 d *Decoder) (_ map[int64]int8, changed bool) {
33180 dd, esep := d.d, d.hh.hasElemSeparators()
33181 containerLen := dd.ReadMapStart()
33182 if canChange && v == nil {
33183 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
33184 v = make(map[int64]int8, xlen)
33185 changed = true
33186 }
33187 if containerLen == 0 {
33188 dd.ReadMapEnd()
33189 return v, changed
33190 }
33191 var mk int64
33192 var mv int8
33193 hasLen := containerLen > 0
33194 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33195 if esep {
33196 dd.ReadMapElemKey()
33197 }
33198 mk = dd.DecodeInt64()
33199 if esep {
33200 dd.ReadMapElemValue()
33201 }
33202 if dd.TryDecodeAsNil() {
33203 if v == nil {
33204 } else if d.h.DeleteOnNilMapValue {
33205 delete(v, mk)
33206 } else {
33207 v[mk] = 0
33208 }
33209 continue
33210 }
33211 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
33212 if v != nil {
33213 v[mk] = mv
33214 }
33215 }
33216 dd.ReadMapEnd()
33217 return v, changed
33218}
33219
33220func (d *Decoder) fastpathDecMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
33221 if rv.Kind() == reflect.Ptr {
33222 vp := rv2i(rv).(*map[int64]int16)
33223 v, changed := fastpathTV.DecMapInt64Int16V(*vp, true, d)
33224 if changed {
33225 *vp = v
33226 }
33227 } else {
33228 fastpathTV.DecMapInt64Int16V(rv2i(rv).(map[int64]int16), false, d)
33229 }
33230}
33231func (f fastpathT) DecMapInt64Int16X(vp *map[int64]int16, d *Decoder) {
33232 v, changed := f.DecMapInt64Int16V(*vp, true, d)
33233 if changed {
33234 *vp = v
33235 }
33236}
33237func (_ fastpathT) DecMapInt64Int16V(v map[int64]int16, canChange bool,
33238 d *Decoder) (_ map[int64]int16, changed bool) {
33239 dd, esep := d.d, d.hh.hasElemSeparators()
33240 containerLen := dd.ReadMapStart()
33241 if canChange && v == nil {
33242 xlen := decInferLen(containerLen, d.h.MaxInitLen, 10)
33243 v = make(map[int64]int16, xlen)
33244 changed = true
33245 }
33246 if containerLen == 0 {
33247 dd.ReadMapEnd()
33248 return v, changed
33249 }
33250 var mk int64
33251 var mv int16
33252 hasLen := containerLen > 0
33253 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33254 if esep {
33255 dd.ReadMapElemKey()
33256 }
33257 mk = dd.DecodeInt64()
33258 if esep {
33259 dd.ReadMapElemValue()
33260 }
33261 if dd.TryDecodeAsNil() {
33262 if v == nil {
33263 } else if d.h.DeleteOnNilMapValue {
33264 delete(v, mk)
33265 } else {
33266 v[mk] = 0
33267 }
33268 continue
33269 }
33270 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
33271 if v != nil {
33272 v[mk] = mv
33273 }
33274 }
33275 dd.ReadMapEnd()
33276 return v, changed
33277}
33278
33279func (d *Decoder) fastpathDecMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
33280 if rv.Kind() == reflect.Ptr {
33281 vp := rv2i(rv).(*map[int64]int32)
33282 v, changed := fastpathTV.DecMapInt64Int32V(*vp, true, d)
33283 if changed {
33284 *vp = v
33285 }
33286 } else {
33287 fastpathTV.DecMapInt64Int32V(rv2i(rv).(map[int64]int32), false, d)
33288 }
33289}
33290func (f fastpathT) DecMapInt64Int32X(vp *map[int64]int32, d *Decoder) {
33291 v, changed := f.DecMapInt64Int32V(*vp, true, d)
33292 if changed {
33293 *vp = v
33294 }
33295}
33296func (_ fastpathT) DecMapInt64Int32V(v map[int64]int32, canChange bool,
33297 d *Decoder) (_ map[int64]int32, changed bool) {
33298 dd, esep := d.d, d.hh.hasElemSeparators()
33299 containerLen := dd.ReadMapStart()
33300 if canChange && v == nil {
33301 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
33302 v = make(map[int64]int32, xlen)
33303 changed = true
33304 }
33305 if containerLen == 0 {
33306 dd.ReadMapEnd()
33307 return v, changed
33308 }
33309 var mk int64
33310 var mv int32
33311 hasLen := containerLen > 0
33312 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33313 if esep {
33314 dd.ReadMapElemKey()
33315 }
33316 mk = dd.DecodeInt64()
33317 if esep {
33318 dd.ReadMapElemValue()
33319 }
33320 if dd.TryDecodeAsNil() {
33321 if v == nil {
33322 } else if d.h.DeleteOnNilMapValue {
33323 delete(v, mk)
33324 } else {
33325 v[mk] = 0
33326 }
33327 continue
33328 }
33329 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
33330 if v != nil {
33331 v[mk] = mv
33332 }
33333 }
33334 dd.ReadMapEnd()
33335 return v, changed
33336}
33337
33338func (d *Decoder) fastpathDecMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
33339 if rv.Kind() == reflect.Ptr {
33340 vp := rv2i(rv).(*map[int64]int64)
33341 v, changed := fastpathTV.DecMapInt64Int64V(*vp, true, d)
33342 if changed {
33343 *vp = v
33344 }
33345 } else {
33346 fastpathTV.DecMapInt64Int64V(rv2i(rv).(map[int64]int64), false, d)
33347 }
33348}
33349func (f fastpathT) DecMapInt64Int64X(vp *map[int64]int64, d *Decoder) {
33350 v, changed := f.DecMapInt64Int64V(*vp, true, d)
33351 if changed {
33352 *vp = v
33353 }
33354}
33355func (_ fastpathT) DecMapInt64Int64V(v map[int64]int64, canChange bool,
33356 d *Decoder) (_ map[int64]int64, changed bool) {
33357 dd, esep := d.d, d.hh.hasElemSeparators()
33358 containerLen := dd.ReadMapStart()
33359 if canChange && v == nil {
33360 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33361 v = make(map[int64]int64, xlen)
33362 changed = true
33363 }
33364 if containerLen == 0 {
33365 dd.ReadMapEnd()
33366 return v, changed
33367 }
33368 var mk int64
33369 var mv int64
33370 hasLen := containerLen > 0
33371 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33372 if esep {
33373 dd.ReadMapElemKey()
33374 }
33375 mk = dd.DecodeInt64()
33376 if esep {
33377 dd.ReadMapElemValue()
33378 }
33379 if dd.TryDecodeAsNil() {
33380 if v == nil {
33381 } else if d.h.DeleteOnNilMapValue {
33382 delete(v, mk)
33383 } else {
33384 v[mk] = 0
33385 }
33386 continue
33387 }
33388 mv = dd.DecodeInt64()
33389 if v != nil {
33390 v[mk] = mv
33391 }
33392 }
33393 dd.ReadMapEnd()
33394 return v, changed
33395}
33396
33397func (d *Decoder) fastpathDecMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
33398 if rv.Kind() == reflect.Ptr {
33399 vp := rv2i(rv).(*map[int64]float32)
33400 v, changed := fastpathTV.DecMapInt64Float32V(*vp, true, d)
33401 if changed {
33402 *vp = v
33403 }
33404 } else {
33405 fastpathTV.DecMapInt64Float32V(rv2i(rv).(map[int64]float32), false, d)
33406 }
33407}
33408func (f fastpathT) DecMapInt64Float32X(vp *map[int64]float32, d *Decoder) {
33409 v, changed := f.DecMapInt64Float32V(*vp, true, d)
33410 if changed {
33411 *vp = v
33412 }
33413}
33414func (_ fastpathT) DecMapInt64Float32V(v map[int64]float32, canChange bool,
33415 d *Decoder) (_ map[int64]float32, changed bool) {
33416 dd, esep := d.d, d.hh.hasElemSeparators()
33417 containerLen := dd.ReadMapStart()
33418 if canChange && v == nil {
33419 xlen := decInferLen(containerLen, d.h.MaxInitLen, 12)
33420 v = make(map[int64]float32, xlen)
33421 changed = true
33422 }
33423 if containerLen == 0 {
33424 dd.ReadMapEnd()
33425 return v, changed
33426 }
33427 var mk int64
33428 var mv float32
33429 hasLen := containerLen > 0
33430 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33431 if esep {
33432 dd.ReadMapElemKey()
33433 }
33434 mk = dd.DecodeInt64()
33435 if esep {
33436 dd.ReadMapElemValue()
33437 }
33438 if dd.TryDecodeAsNil() {
33439 if v == nil {
33440 } else if d.h.DeleteOnNilMapValue {
33441 delete(v, mk)
33442 } else {
33443 v[mk] = 0
33444 }
33445 continue
33446 }
33447 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
33448 if v != nil {
33449 v[mk] = mv
33450 }
33451 }
33452 dd.ReadMapEnd()
33453 return v, changed
33454}
33455
33456func (d *Decoder) fastpathDecMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
33457 if rv.Kind() == reflect.Ptr {
33458 vp := rv2i(rv).(*map[int64]float64)
33459 v, changed := fastpathTV.DecMapInt64Float64V(*vp, true, d)
33460 if changed {
33461 *vp = v
33462 }
33463 } else {
33464 fastpathTV.DecMapInt64Float64V(rv2i(rv).(map[int64]float64), false, d)
33465 }
33466}
33467func (f fastpathT) DecMapInt64Float64X(vp *map[int64]float64, d *Decoder) {
33468 v, changed := f.DecMapInt64Float64V(*vp, true, d)
33469 if changed {
33470 *vp = v
33471 }
33472}
33473func (_ fastpathT) DecMapInt64Float64V(v map[int64]float64, canChange bool,
33474 d *Decoder) (_ map[int64]float64, changed bool) {
33475 dd, esep := d.d, d.hh.hasElemSeparators()
33476 containerLen := dd.ReadMapStart()
33477 if canChange && v == nil {
33478 xlen := decInferLen(containerLen, d.h.MaxInitLen, 16)
33479 v = make(map[int64]float64, xlen)
33480 changed = true
33481 }
33482 if containerLen == 0 {
33483 dd.ReadMapEnd()
33484 return v, changed
33485 }
33486 var mk int64
33487 var mv float64
33488 hasLen := containerLen > 0
33489 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33490 if esep {
33491 dd.ReadMapElemKey()
33492 }
33493 mk = dd.DecodeInt64()
33494 if esep {
33495 dd.ReadMapElemValue()
33496 }
33497 if dd.TryDecodeAsNil() {
33498 if v == nil {
33499 } else if d.h.DeleteOnNilMapValue {
33500 delete(v, mk)
33501 } else {
33502 v[mk] = 0
33503 }
33504 continue
33505 }
33506 mv = dd.DecodeFloat64()
33507 if v != nil {
33508 v[mk] = mv
33509 }
33510 }
33511 dd.ReadMapEnd()
33512 return v, changed
33513}
33514
33515func (d *Decoder) fastpathDecMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
33516 if rv.Kind() == reflect.Ptr {
33517 vp := rv2i(rv).(*map[int64]bool)
33518 v, changed := fastpathTV.DecMapInt64BoolV(*vp, true, d)
33519 if changed {
33520 *vp = v
33521 }
33522 } else {
33523 fastpathTV.DecMapInt64BoolV(rv2i(rv).(map[int64]bool), false, d)
33524 }
33525}
33526func (f fastpathT) DecMapInt64BoolX(vp *map[int64]bool, d *Decoder) {
33527 v, changed := f.DecMapInt64BoolV(*vp, true, d)
33528 if changed {
33529 *vp = v
33530 }
33531}
33532func (_ fastpathT) DecMapInt64BoolV(v map[int64]bool, canChange bool,
33533 d *Decoder) (_ map[int64]bool, changed bool) {
33534 dd, esep := d.d, d.hh.hasElemSeparators()
33535 containerLen := dd.ReadMapStart()
33536 if canChange && v == nil {
33537 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
33538 v = make(map[int64]bool, xlen)
33539 changed = true
33540 }
33541 if containerLen == 0 {
33542 dd.ReadMapEnd()
33543 return v, changed
33544 }
33545 var mk int64
33546 var mv bool
33547 hasLen := containerLen > 0
33548 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33549 if esep {
33550 dd.ReadMapElemKey()
33551 }
33552 mk = dd.DecodeInt64()
33553 if esep {
33554 dd.ReadMapElemValue()
33555 }
33556 if dd.TryDecodeAsNil() {
33557 if v == nil {
33558 } else if d.h.DeleteOnNilMapValue {
33559 delete(v, mk)
33560 } else {
33561 v[mk] = false
33562 }
33563 continue
33564 }
33565 mv = dd.DecodeBool()
33566 if v != nil {
33567 v[mk] = mv
33568 }
33569 }
33570 dd.ReadMapEnd()
33571 return v, changed
33572}
33573
33574func (d *Decoder) fastpathDecMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
33575 if rv.Kind() == reflect.Ptr {
33576 vp := rv2i(rv).(*map[bool]interface{})
33577 v, changed := fastpathTV.DecMapBoolIntfV(*vp, true, d)
33578 if changed {
33579 *vp = v
33580 }
33581 } else {
33582 fastpathTV.DecMapBoolIntfV(rv2i(rv).(map[bool]interface{}), false, d)
33583 }
33584}
33585func (f fastpathT) DecMapBoolIntfX(vp *map[bool]interface{}, d *Decoder) {
33586 v, changed := f.DecMapBoolIntfV(*vp, true, d)
33587 if changed {
33588 *vp = v
33589 }
33590}
33591func (_ fastpathT) DecMapBoolIntfV(v map[bool]interface{}, canChange bool,
33592 d *Decoder) (_ map[bool]interface{}, changed bool) {
33593 dd, esep := d.d, d.hh.hasElemSeparators()
33594 containerLen := dd.ReadMapStart()
33595 if canChange && v == nil {
33596 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
33597 v = make(map[bool]interface{}, xlen)
33598 changed = true
33599 }
33600 if containerLen == 0 {
33601 dd.ReadMapEnd()
33602 return v, changed
33603 }
33604 mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
33605 var mk bool
33606 var mv interface{}
33607 hasLen := containerLen > 0
33608 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33609 if esep {
33610 dd.ReadMapElemKey()
33611 }
33612 mk = dd.DecodeBool()
33613 if esep {
33614 dd.ReadMapElemValue()
33615 }
33616 if dd.TryDecodeAsNil() {
33617 if v == nil {
33618 } else if d.h.DeleteOnNilMapValue {
33619 delete(v, mk)
33620 } else {
33621 v[mk] = nil
33622 }
33623 continue
33624 }
33625 if mapGet {
33626 mv = v[mk]
33627 } else {
33628 mv = nil
33629 }
33630 d.decode(&mv)
33631 if v != nil {
33632 v[mk] = mv
33633 }
33634 }
33635 dd.ReadMapEnd()
33636 return v, changed
33637}
33638
33639func (d *Decoder) fastpathDecMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
33640 if rv.Kind() == reflect.Ptr {
33641 vp := rv2i(rv).(*map[bool]string)
33642 v, changed := fastpathTV.DecMapBoolStringV(*vp, true, d)
33643 if changed {
33644 *vp = v
33645 }
33646 } else {
33647 fastpathTV.DecMapBoolStringV(rv2i(rv).(map[bool]string), false, d)
33648 }
33649}
33650func (f fastpathT) DecMapBoolStringX(vp *map[bool]string, d *Decoder) {
33651 v, changed := f.DecMapBoolStringV(*vp, true, d)
33652 if changed {
33653 *vp = v
33654 }
33655}
33656func (_ fastpathT) DecMapBoolStringV(v map[bool]string, canChange bool,
33657 d *Decoder) (_ map[bool]string, changed bool) {
33658 dd, esep := d.d, d.hh.hasElemSeparators()
33659 containerLen := dd.ReadMapStart()
33660 if canChange && v == nil {
33661 xlen := decInferLen(containerLen, d.h.MaxInitLen, 17)
33662 v = make(map[bool]string, xlen)
33663 changed = true
33664 }
33665 if containerLen == 0 {
33666 dd.ReadMapEnd()
33667 return v, changed
33668 }
33669 var mk bool
33670 var mv string
33671 hasLen := containerLen > 0
33672 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33673 if esep {
33674 dd.ReadMapElemKey()
33675 }
33676 mk = dd.DecodeBool()
33677 if esep {
33678 dd.ReadMapElemValue()
33679 }
33680 if dd.TryDecodeAsNil() {
33681 if v == nil {
33682 } else if d.h.DeleteOnNilMapValue {
33683 delete(v, mk)
33684 } else {
33685 v[mk] = ""
33686 }
33687 continue
33688 }
33689 mv = dd.DecodeString()
33690 if v != nil {
33691 v[mk] = mv
33692 }
33693 }
33694 dd.ReadMapEnd()
33695 return v, changed
33696}
33697
33698func (d *Decoder) fastpathDecMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
33699 if rv.Kind() == reflect.Ptr {
33700 vp := rv2i(rv).(*map[bool]uint)
33701 v, changed := fastpathTV.DecMapBoolUintV(*vp, true, d)
33702 if changed {
33703 *vp = v
33704 }
33705 } else {
33706 fastpathTV.DecMapBoolUintV(rv2i(rv).(map[bool]uint), false, d)
33707 }
33708}
33709func (f fastpathT) DecMapBoolUintX(vp *map[bool]uint, d *Decoder) {
33710 v, changed := f.DecMapBoolUintV(*vp, true, d)
33711 if changed {
33712 *vp = v
33713 }
33714}
33715func (_ fastpathT) DecMapBoolUintV(v map[bool]uint, canChange bool,
33716 d *Decoder) (_ map[bool]uint, changed bool) {
33717 dd, esep := d.d, d.hh.hasElemSeparators()
33718 containerLen := dd.ReadMapStart()
33719 if canChange && v == nil {
33720 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
33721 v = make(map[bool]uint, xlen)
33722 changed = true
33723 }
33724 if containerLen == 0 {
33725 dd.ReadMapEnd()
33726 return v, changed
33727 }
33728 var mk bool
33729 var mv uint
33730 hasLen := containerLen > 0
33731 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33732 if esep {
33733 dd.ReadMapElemKey()
33734 }
33735 mk = dd.DecodeBool()
33736 if esep {
33737 dd.ReadMapElemValue()
33738 }
33739 if dd.TryDecodeAsNil() {
33740 if v == nil {
33741 } else if d.h.DeleteOnNilMapValue {
33742 delete(v, mk)
33743 } else {
33744 v[mk] = 0
33745 }
33746 continue
33747 }
33748 mv = uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
33749 if v != nil {
33750 v[mk] = mv
33751 }
33752 }
33753 dd.ReadMapEnd()
33754 return v, changed
33755}
33756
33757func (d *Decoder) fastpathDecMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
33758 if rv.Kind() == reflect.Ptr {
33759 vp := rv2i(rv).(*map[bool]uint8)
33760 v, changed := fastpathTV.DecMapBoolUint8V(*vp, true, d)
33761 if changed {
33762 *vp = v
33763 }
33764 } else {
33765 fastpathTV.DecMapBoolUint8V(rv2i(rv).(map[bool]uint8), false, d)
33766 }
33767}
33768func (f fastpathT) DecMapBoolUint8X(vp *map[bool]uint8, d *Decoder) {
33769 v, changed := f.DecMapBoolUint8V(*vp, true, d)
33770 if changed {
33771 *vp = v
33772 }
33773}
33774func (_ fastpathT) DecMapBoolUint8V(v map[bool]uint8, canChange bool,
33775 d *Decoder) (_ map[bool]uint8, changed bool) {
33776 dd, esep := d.d, d.hh.hasElemSeparators()
33777 containerLen := dd.ReadMapStart()
33778 if canChange && v == nil {
33779 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
33780 v = make(map[bool]uint8, xlen)
33781 changed = true
33782 }
33783 if containerLen == 0 {
33784 dd.ReadMapEnd()
33785 return v, changed
33786 }
33787 var mk bool
33788 var mv uint8
33789 hasLen := containerLen > 0
33790 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33791 if esep {
33792 dd.ReadMapElemKey()
33793 }
33794 mk = dd.DecodeBool()
33795 if esep {
33796 dd.ReadMapElemValue()
33797 }
33798 if dd.TryDecodeAsNil() {
33799 if v == nil {
33800 } else if d.h.DeleteOnNilMapValue {
33801 delete(v, mk)
33802 } else {
33803 v[mk] = 0
33804 }
33805 continue
33806 }
33807 mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
33808 if v != nil {
33809 v[mk] = mv
33810 }
33811 }
33812 dd.ReadMapEnd()
33813 return v, changed
33814}
33815
33816func (d *Decoder) fastpathDecMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
33817 if rv.Kind() == reflect.Ptr {
33818 vp := rv2i(rv).(*map[bool]uint16)
33819 v, changed := fastpathTV.DecMapBoolUint16V(*vp, true, d)
33820 if changed {
33821 *vp = v
33822 }
33823 } else {
33824 fastpathTV.DecMapBoolUint16V(rv2i(rv).(map[bool]uint16), false, d)
33825 }
33826}
33827func (f fastpathT) DecMapBoolUint16X(vp *map[bool]uint16, d *Decoder) {
33828 v, changed := f.DecMapBoolUint16V(*vp, true, d)
33829 if changed {
33830 *vp = v
33831 }
33832}
33833func (_ fastpathT) DecMapBoolUint16V(v map[bool]uint16, canChange bool,
33834 d *Decoder) (_ map[bool]uint16, changed bool) {
33835 dd, esep := d.d, d.hh.hasElemSeparators()
33836 containerLen := dd.ReadMapStart()
33837 if canChange && v == nil {
33838 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
33839 v = make(map[bool]uint16, xlen)
33840 changed = true
33841 }
33842 if containerLen == 0 {
33843 dd.ReadMapEnd()
33844 return v, changed
33845 }
33846 var mk bool
33847 var mv uint16
33848 hasLen := containerLen > 0
33849 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33850 if esep {
33851 dd.ReadMapElemKey()
33852 }
33853 mk = dd.DecodeBool()
33854 if esep {
33855 dd.ReadMapElemValue()
33856 }
33857 if dd.TryDecodeAsNil() {
33858 if v == nil {
33859 } else if d.h.DeleteOnNilMapValue {
33860 delete(v, mk)
33861 } else {
33862 v[mk] = 0
33863 }
33864 continue
33865 }
33866 mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 16))
33867 if v != nil {
33868 v[mk] = mv
33869 }
33870 }
33871 dd.ReadMapEnd()
33872 return v, changed
33873}
33874
33875func (d *Decoder) fastpathDecMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
33876 if rv.Kind() == reflect.Ptr {
33877 vp := rv2i(rv).(*map[bool]uint32)
33878 v, changed := fastpathTV.DecMapBoolUint32V(*vp, true, d)
33879 if changed {
33880 *vp = v
33881 }
33882 } else {
33883 fastpathTV.DecMapBoolUint32V(rv2i(rv).(map[bool]uint32), false, d)
33884 }
33885}
33886func (f fastpathT) DecMapBoolUint32X(vp *map[bool]uint32, d *Decoder) {
33887 v, changed := f.DecMapBoolUint32V(*vp, true, d)
33888 if changed {
33889 *vp = v
33890 }
33891}
33892func (_ fastpathT) DecMapBoolUint32V(v map[bool]uint32, canChange bool,
33893 d *Decoder) (_ map[bool]uint32, changed bool) {
33894 dd, esep := d.d, d.hh.hasElemSeparators()
33895 containerLen := dd.ReadMapStart()
33896 if canChange && v == nil {
33897 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
33898 v = make(map[bool]uint32, xlen)
33899 changed = true
33900 }
33901 if containerLen == 0 {
33902 dd.ReadMapEnd()
33903 return v, changed
33904 }
33905 var mk bool
33906 var mv uint32
33907 hasLen := containerLen > 0
33908 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33909 if esep {
33910 dd.ReadMapElemKey()
33911 }
33912 mk = dd.DecodeBool()
33913 if esep {
33914 dd.ReadMapElemValue()
33915 }
33916 if dd.TryDecodeAsNil() {
33917 if v == nil {
33918 } else if d.h.DeleteOnNilMapValue {
33919 delete(v, mk)
33920 } else {
33921 v[mk] = 0
33922 }
33923 continue
33924 }
33925 mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 32))
33926 if v != nil {
33927 v[mk] = mv
33928 }
33929 }
33930 dd.ReadMapEnd()
33931 return v, changed
33932}
33933
33934func (d *Decoder) fastpathDecMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
33935 if rv.Kind() == reflect.Ptr {
33936 vp := rv2i(rv).(*map[bool]uint64)
33937 v, changed := fastpathTV.DecMapBoolUint64V(*vp, true, d)
33938 if changed {
33939 *vp = v
33940 }
33941 } else {
33942 fastpathTV.DecMapBoolUint64V(rv2i(rv).(map[bool]uint64), false, d)
33943 }
33944}
33945func (f fastpathT) DecMapBoolUint64X(vp *map[bool]uint64, d *Decoder) {
33946 v, changed := f.DecMapBoolUint64V(*vp, true, d)
33947 if changed {
33948 *vp = v
33949 }
33950}
33951func (_ fastpathT) DecMapBoolUint64V(v map[bool]uint64, canChange bool,
33952 d *Decoder) (_ map[bool]uint64, changed bool) {
33953 dd, esep := d.d, d.hh.hasElemSeparators()
33954 containerLen := dd.ReadMapStart()
33955 if canChange && v == nil {
33956 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
33957 v = make(map[bool]uint64, xlen)
33958 changed = true
33959 }
33960 if containerLen == 0 {
33961 dd.ReadMapEnd()
33962 return v, changed
33963 }
33964 var mk bool
33965 var mv uint64
33966 hasLen := containerLen > 0
33967 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
33968 if esep {
33969 dd.ReadMapElemKey()
33970 }
33971 mk = dd.DecodeBool()
33972 if esep {
33973 dd.ReadMapElemValue()
33974 }
33975 if dd.TryDecodeAsNil() {
33976 if v == nil {
33977 } else if d.h.DeleteOnNilMapValue {
33978 delete(v, mk)
33979 } else {
33980 v[mk] = 0
33981 }
33982 continue
33983 }
33984 mv = dd.DecodeUint64()
33985 if v != nil {
33986 v[mk] = mv
33987 }
33988 }
33989 dd.ReadMapEnd()
33990 return v, changed
33991}
33992
33993func (d *Decoder) fastpathDecMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
33994 if rv.Kind() == reflect.Ptr {
33995 vp := rv2i(rv).(*map[bool]uintptr)
33996 v, changed := fastpathTV.DecMapBoolUintptrV(*vp, true, d)
33997 if changed {
33998 *vp = v
33999 }
34000 } else {
34001 fastpathTV.DecMapBoolUintptrV(rv2i(rv).(map[bool]uintptr), false, d)
34002 }
34003}
34004func (f fastpathT) DecMapBoolUintptrX(vp *map[bool]uintptr, d *Decoder) {
34005 v, changed := f.DecMapBoolUintptrV(*vp, true, d)
34006 if changed {
34007 *vp = v
34008 }
34009}
34010func (_ fastpathT) DecMapBoolUintptrV(v map[bool]uintptr, canChange bool,
34011 d *Decoder) (_ map[bool]uintptr, changed bool) {
34012 dd, esep := d.d, d.hh.hasElemSeparators()
34013 containerLen := dd.ReadMapStart()
34014 if canChange && v == nil {
34015 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34016 v = make(map[bool]uintptr, xlen)
34017 changed = true
34018 }
34019 if containerLen == 0 {
34020 dd.ReadMapEnd()
34021 return v, changed
34022 }
34023 var mk bool
34024 var mv uintptr
34025 hasLen := containerLen > 0
34026 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34027 if esep {
34028 dd.ReadMapElemKey()
34029 }
34030 mk = dd.DecodeBool()
34031 if esep {
34032 dd.ReadMapElemValue()
34033 }
34034 if dd.TryDecodeAsNil() {
34035 if v == nil {
34036 } else if d.h.DeleteOnNilMapValue {
34037 delete(v, mk)
34038 } else {
34039 v[mk] = 0
34040 }
34041 continue
34042 }
34043 mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
34044 if v != nil {
34045 v[mk] = mv
34046 }
34047 }
34048 dd.ReadMapEnd()
34049 return v, changed
34050}
34051
34052func (d *Decoder) fastpathDecMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
34053 if rv.Kind() == reflect.Ptr {
34054 vp := rv2i(rv).(*map[bool]int)
34055 v, changed := fastpathTV.DecMapBoolIntV(*vp, true, d)
34056 if changed {
34057 *vp = v
34058 }
34059 } else {
34060 fastpathTV.DecMapBoolIntV(rv2i(rv).(map[bool]int), false, d)
34061 }
34062}
34063func (f fastpathT) DecMapBoolIntX(vp *map[bool]int, d *Decoder) {
34064 v, changed := f.DecMapBoolIntV(*vp, true, d)
34065 if changed {
34066 *vp = v
34067 }
34068}
34069func (_ fastpathT) DecMapBoolIntV(v map[bool]int, canChange bool,
34070 d *Decoder) (_ map[bool]int, changed bool) {
34071 dd, esep := d.d, d.hh.hasElemSeparators()
34072 containerLen := dd.ReadMapStart()
34073 if canChange && v == nil {
34074 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34075 v = make(map[bool]int, xlen)
34076 changed = true
34077 }
34078 if containerLen == 0 {
34079 dd.ReadMapEnd()
34080 return v, changed
34081 }
34082 var mk bool
34083 var mv int
34084 hasLen := containerLen > 0
34085 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34086 if esep {
34087 dd.ReadMapElemKey()
34088 }
34089 mk = dd.DecodeBool()
34090 if esep {
34091 dd.ReadMapElemValue()
34092 }
34093 if dd.TryDecodeAsNil() {
34094 if v == nil {
34095 } else if d.h.DeleteOnNilMapValue {
34096 delete(v, mk)
34097 } else {
34098 v[mk] = 0
34099 }
34100 continue
34101 }
34102 mv = int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
34103 if v != nil {
34104 v[mk] = mv
34105 }
34106 }
34107 dd.ReadMapEnd()
34108 return v, changed
34109}
34110
34111func (d *Decoder) fastpathDecMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
34112 if rv.Kind() == reflect.Ptr {
34113 vp := rv2i(rv).(*map[bool]int8)
34114 v, changed := fastpathTV.DecMapBoolInt8V(*vp, true, d)
34115 if changed {
34116 *vp = v
34117 }
34118 } else {
34119 fastpathTV.DecMapBoolInt8V(rv2i(rv).(map[bool]int8), false, d)
34120 }
34121}
34122func (f fastpathT) DecMapBoolInt8X(vp *map[bool]int8, d *Decoder) {
34123 v, changed := f.DecMapBoolInt8V(*vp, true, d)
34124 if changed {
34125 *vp = v
34126 }
34127}
34128func (_ fastpathT) DecMapBoolInt8V(v map[bool]int8, canChange bool,
34129 d *Decoder) (_ map[bool]int8, changed bool) {
34130 dd, esep := d.d, d.hh.hasElemSeparators()
34131 containerLen := dd.ReadMapStart()
34132 if canChange && v == nil {
34133 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
34134 v = make(map[bool]int8, xlen)
34135 changed = true
34136 }
34137 if containerLen == 0 {
34138 dd.ReadMapEnd()
34139 return v, changed
34140 }
34141 var mk bool
34142 var mv int8
34143 hasLen := containerLen > 0
34144 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34145 if esep {
34146 dd.ReadMapElemKey()
34147 }
34148 mk = dd.DecodeBool()
34149 if esep {
34150 dd.ReadMapElemValue()
34151 }
34152 if dd.TryDecodeAsNil() {
34153 if v == nil {
34154 } else if d.h.DeleteOnNilMapValue {
34155 delete(v, mk)
34156 } else {
34157 v[mk] = 0
34158 }
34159 continue
34160 }
34161 mv = int8(chkOvf.IntV(dd.DecodeInt64(), 8))
34162 if v != nil {
34163 v[mk] = mv
34164 }
34165 }
34166 dd.ReadMapEnd()
34167 return v, changed
34168}
34169
34170func (d *Decoder) fastpathDecMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
34171 if rv.Kind() == reflect.Ptr {
34172 vp := rv2i(rv).(*map[bool]int16)
34173 v, changed := fastpathTV.DecMapBoolInt16V(*vp, true, d)
34174 if changed {
34175 *vp = v
34176 }
34177 } else {
34178 fastpathTV.DecMapBoolInt16V(rv2i(rv).(map[bool]int16), false, d)
34179 }
34180}
34181func (f fastpathT) DecMapBoolInt16X(vp *map[bool]int16, d *Decoder) {
34182 v, changed := f.DecMapBoolInt16V(*vp, true, d)
34183 if changed {
34184 *vp = v
34185 }
34186}
34187func (_ fastpathT) DecMapBoolInt16V(v map[bool]int16, canChange bool,
34188 d *Decoder) (_ map[bool]int16, changed bool) {
34189 dd, esep := d.d, d.hh.hasElemSeparators()
34190 containerLen := dd.ReadMapStart()
34191 if canChange && v == nil {
34192 xlen := decInferLen(containerLen, d.h.MaxInitLen, 3)
34193 v = make(map[bool]int16, xlen)
34194 changed = true
34195 }
34196 if containerLen == 0 {
34197 dd.ReadMapEnd()
34198 return v, changed
34199 }
34200 var mk bool
34201 var mv int16
34202 hasLen := containerLen > 0
34203 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34204 if esep {
34205 dd.ReadMapElemKey()
34206 }
34207 mk = dd.DecodeBool()
34208 if esep {
34209 dd.ReadMapElemValue()
34210 }
34211 if dd.TryDecodeAsNil() {
34212 if v == nil {
34213 } else if d.h.DeleteOnNilMapValue {
34214 delete(v, mk)
34215 } else {
34216 v[mk] = 0
34217 }
34218 continue
34219 }
34220 mv = int16(chkOvf.IntV(dd.DecodeInt64(), 16))
34221 if v != nil {
34222 v[mk] = mv
34223 }
34224 }
34225 dd.ReadMapEnd()
34226 return v, changed
34227}
34228
34229func (d *Decoder) fastpathDecMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
34230 if rv.Kind() == reflect.Ptr {
34231 vp := rv2i(rv).(*map[bool]int32)
34232 v, changed := fastpathTV.DecMapBoolInt32V(*vp, true, d)
34233 if changed {
34234 *vp = v
34235 }
34236 } else {
34237 fastpathTV.DecMapBoolInt32V(rv2i(rv).(map[bool]int32), false, d)
34238 }
34239}
34240func (f fastpathT) DecMapBoolInt32X(vp *map[bool]int32, d *Decoder) {
34241 v, changed := f.DecMapBoolInt32V(*vp, true, d)
34242 if changed {
34243 *vp = v
34244 }
34245}
34246func (_ fastpathT) DecMapBoolInt32V(v map[bool]int32, canChange bool,
34247 d *Decoder) (_ map[bool]int32, changed bool) {
34248 dd, esep := d.d, d.hh.hasElemSeparators()
34249 containerLen := dd.ReadMapStart()
34250 if canChange && v == nil {
34251 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
34252 v = make(map[bool]int32, xlen)
34253 changed = true
34254 }
34255 if containerLen == 0 {
34256 dd.ReadMapEnd()
34257 return v, changed
34258 }
34259 var mk bool
34260 var mv int32
34261 hasLen := containerLen > 0
34262 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34263 if esep {
34264 dd.ReadMapElemKey()
34265 }
34266 mk = dd.DecodeBool()
34267 if esep {
34268 dd.ReadMapElemValue()
34269 }
34270 if dd.TryDecodeAsNil() {
34271 if v == nil {
34272 } else if d.h.DeleteOnNilMapValue {
34273 delete(v, mk)
34274 } else {
34275 v[mk] = 0
34276 }
34277 continue
34278 }
34279 mv = int32(chkOvf.IntV(dd.DecodeInt64(), 32))
34280 if v != nil {
34281 v[mk] = mv
34282 }
34283 }
34284 dd.ReadMapEnd()
34285 return v, changed
34286}
34287
34288func (d *Decoder) fastpathDecMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
34289 if rv.Kind() == reflect.Ptr {
34290 vp := rv2i(rv).(*map[bool]int64)
34291 v, changed := fastpathTV.DecMapBoolInt64V(*vp, true, d)
34292 if changed {
34293 *vp = v
34294 }
34295 } else {
34296 fastpathTV.DecMapBoolInt64V(rv2i(rv).(map[bool]int64), false, d)
34297 }
34298}
34299func (f fastpathT) DecMapBoolInt64X(vp *map[bool]int64, d *Decoder) {
34300 v, changed := f.DecMapBoolInt64V(*vp, true, d)
34301 if changed {
34302 *vp = v
34303 }
34304}
34305func (_ fastpathT) DecMapBoolInt64V(v map[bool]int64, canChange bool,
34306 d *Decoder) (_ map[bool]int64, changed bool) {
34307 dd, esep := d.d, d.hh.hasElemSeparators()
34308 containerLen := dd.ReadMapStart()
34309 if canChange && v == nil {
34310 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34311 v = make(map[bool]int64, xlen)
34312 changed = true
34313 }
34314 if containerLen == 0 {
34315 dd.ReadMapEnd()
34316 return v, changed
34317 }
34318 var mk bool
34319 var mv int64
34320 hasLen := containerLen > 0
34321 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34322 if esep {
34323 dd.ReadMapElemKey()
34324 }
34325 mk = dd.DecodeBool()
34326 if esep {
34327 dd.ReadMapElemValue()
34328 }
34329 if dd.TryDecodeAsNil() {
34330 if v == nil {
34331 } else if d.h.DeleteOnNilMapValue {
34332 delete(v, mk)
34333 } else {
34334 v[mk] = 0
34335 }
34336 continue
34337 }
34338 mv = dd.DecodeInt64()
34339 if v != nil {
34340 v[mk] = mv
34341 }
34342 }
34343 dd.ReadMapEnd()
34344 return v, changed
34345}
34346
34347func (d *Decoder) fastpathDecMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
34348 if rv.Kind() == reflect.Ptr {
34349 vp := rv2i(rv).(*map[bool]float32)
34350 v, changed := fastpathTV.DecMapBoolFloat32V(*vp, true, d)
34351 if changed {
34352 *vp = v
34353 }
34354 } else {
34355 fastpathTV.DecMapBoolFloat32V(rv2i(rv).(map[bool]float32), false, d)
34356 }
34357}
34358func (f fastpathT) DecMapBoolFloat32X(vp *map[bool]float32, d *Decoder) {
34359 v, changed := f.DecMapBoolFloat32V(*vp, true, d)
34360 if changed {
34361 *vp = v
34362 }
34363}
34364func (_ fastpathT) DecMapBoolFloat32V(v map[bool]float32, canChange bool,
34365 d *Decoder) (_ map[bool]float32, changed bool) {
34366 dd, esep := d.d, d.hh.hasElemSeparators()
34367 containerLen := dd.ReadMapStart()
34368 if canChange && v == nil {
34369 xlen := decInferLen(containerLen, d.h.MaxInitLen, 5)
34370 v = make(map[bool]float32, xlen)
34371 changed = true
34372 }
34373 if containerLen == 0 {
34374 dd.ReadMapEnd()
34375 return v, changed
34376 }
34377 var mk bool
34378 var mv float32
34379 hasLen := containerLen > 0
34380 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34381 if esep {
34382 dd.ReadMapElemKey()
34383 }
34384 mk = dd.DecodeBool()
34385 if esep {
34386 dd.ReadMapElemValue()
34387 }
34388 if dd.TryDecodeAsNil() {
34389 if v == nil {
34390 } else if d.h.DeleteOnNilMapValue {
34391 delete(v, mk)
34392 } else {
34393 v[mk] = 0
34394 }
34395 continue
34396 }
34397 mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
34398 if v != nil {
34399 v[mk] = mv
34400 }
34401 }
34402 dd.ReadMapEnd()
34403 return v, changed
34404}
34405
34406func (d *Decoder) fastpathDecMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
34407 if rv.Kind() == reflect.Ptr {
34408 vp := rv2i(rv).(*map[bool]float64)
34409 v, changed := fastpathTV.DecMapBoolFloat64V(*vp, true, d)
34410 if changed {
34411 *vp = v
34412 }
34413 } else {
34414 fastpathTV.DecMapBoolFloat64V(rv2i(rv).(map[bool]float64), false, d)
34415 }
34416}
34417func (f fastpathT) DecMapBoolFloat64X(vp *map[bool]float64, d *Decoder) {
34418 v, changed := f.DecMapBoolFloat64V(*vp, true, d)
34419 if changed {
34420 *vp = v
34421 }
34422}
34423func (_ fastpathT) DecMapBoolFloat64V(v map[bool]float64, canChange bool,
34424 d *Decoder) (_ map[bool]float64, changed bool) {
34425 dd, esep := d.d, d.hh.hasElemSeparators()
34426 containerLen := dd.ReadMapStart()
34427 if canChange && v == nil {
34428 xlen := decInferLen(containerLen, d.h.MaxInitLen, 9)
34429 v = make(map[bool]float64, xlen)
34430 changed = true
34431 }
34432 if containerLen == 0 {
34433 dd.ReadMapEnd()
34434 return v, changed
34435 }
34436 var mk bool
34437 var mv float64
34438 hasLen := containerLen > 0
34439 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34440 if esep {
34441 dd.ReadMapElemKey()
34442 }
34443 mk = dd.DecodeBool()
34444 if esep {
34445 dd.ReadMapElemValue()
34446 }
34447 if dd.TryDecodeAsNil() {
34448 if v == nil {
34449 } else if d.h.DeleteOnNilMapValue {
34450 delete(v, mk)
34451 } else {
34452 v[mk] = 0
34453 }
34454 continue
34455 }
34456 mv = dd.DecodeFloat64()
34457 if v != nil {
34458 v[mk] = mv
34459 }
34460 }
34461 dd.ReadMapEnd()
34462 return v, changed
34463}
34464
34465func (d *Decoder) fastpathDecMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
34466 if rv.Kind() == reflect.Ptr {
34467 vp := rv2i(rv).(*map[bool]bool)
34468 v, changed := fastpathTV.DecMapBoolBoolV(*vp, true, d)
34469 if changed {
34470 *vp = v
34471 }
34472 } else {
34473 fastpathTV.DecMapBoolBoolV(rv2i(rv).(map[bool]bool), false, d)
34474 }
34475}
34476func (f fastpathT) DecMapBoolBoolX(vp *map[bool]bool, d *Decoder) {
34477 v, changed := f.DecMapBoolBoolV(*vp, true, d)
34478 if changed {
34479 *vp = v
34480 }
34481}
34482func (_ fastpathT) DecMapBoolBoolV(v map[bool]bool, canChange bool,
34483 d *Decoder) (_ map[bool]bool, changed bool) {
34484 dd, esep := d.d, d.hh.hasElemSeparators()
34485 containerLen := dd.ReadMapStart()
34486 if canChange && v == nil {
34487 xlen := decInferLen(containerLen, d.h.MaxInitLen, 2)
34488 v = make(map[bool]bool, xlen)
34489 changed = true
34490 }
34491 if containerLen == 0 {
34492 dd.ReadMapEnd()
34493 return v, changed
34494 }
34495 var mk bool
34496 var mv bool
34497 hasLen := containerLen > 0
34498 for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
34499 if esep {
34500 dd.ReadMapElemKey()
34501 }
34502 mk = dd.DecodeBool()
34503 if esep {
34504 dd.ReadMapElemValue()
34505 }
34506 if dd.TryDecodeAsNil() {
34507 if v == nil {
34508 } else if d.h.DeleteOnNilMapValue {
34509 delete(v, mk)
34510 } else {
34511 v[mk] = false
34512 }
34513 continue
34514 }
34515 mv = dd.DecodeBool()
34516 if v != nil {
34517 v[mk] = mv
34518 }
34519 }
34520 dd.ReadMapEnd()
34521 return v, changed
34522}