1
2
3
4 package proto2_maps
5
6 import (
7 bytes "bytes"
8 compress_gzip "compress/gzip"
9 encoding_binary "encoding/binary"
10 fmt "fmt"
11 _ "github.com/gogo/protobuf/gogoproto"
12 github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
13 proto "github.com/gogo/protobuf/proto"
14 github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
15 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
16 github_com_gogo_protobuf_test "github.com/gogo/protobuf/test"
17 github_com_gogo_protobuf_test_custom "github.com/gogo/protobuf/test/custom"
18 io "io"
19 io_ioutil "io/ioutil"
20 math "math"
21 math_bits "math/bits"
22 reflect "reflect"
23 strconv "strconv"
24 strings "strings"
25 )
26
27
28 var _ = proto.Marshal
29 var _ = fmt.Errorf
30 var _ = math.Inf
31
32
33
34
35
36 const _ = proto.GoGoProtoPackageIsVersion3
37
38 type MapEnum int32
39
40 const (
41 MA MapEnum = 0
42 MB MapEnum = 1
43 MC MapEnum = 2
44 )
45
46 var MapEnum_name = map[int32]string{
47 0: "MA",
48 1: "MB",
49 2: "MC",
50 }
51
52 var MapEnum_value = map[string]int32{
53 "MA": 0,
54 "MB": 1,
55 "MC": 2,
56 }
57
58 func (x MapEnum) Enum() *MapEnum {
59 p := new(MapEnum)
60 *p = x
61 return p
62 }
63
64 func (x MapEnum) MarshalJSON() ([]byte, error) {
65 return proto.MarshalJSONEnum(MapEnum_name, int32(x))
66 }
67
68 func (x *MapEnum) UnmarshalJSON(data []byte) error {
69 value, err := proto.UnmarshalJSONEnum(MapEnum_value, data, "MapEnum")
70 if err != nil {
71 return err
72 }
73 *x = MapEnum(value)
74 return nil
75 }
76
77 func (MapEnum) EnumDescriptor() ([]byte, []int) {
78 return fileDescriptor_0549d724f3f4db02, []int{0}
79 }
80
81 type FloatingPoint struct {
82 F *float64 `protobuf:"fixed64,1,opt,name=f" json:"f,omitempty"`
83 XXX_NoUnkeyedLiteral struct{} `json:"-"`
84 XXX_unrecognized []byte `json:"-"`
85 XXX_sizecache int32 `json:"-"`
86 }
87
88 func (m *FloatingPoint) Reset() { *m = FloatingPoint{} }
89 func (*FloatingPoint) ProtoMessage() {}
90 func (*FloatingPoint) Descriptor() ([]byte, []int) {
91 return fileDescriptor_0549d724f3f4db02, []int{0}
92 }
93 func (m *FloatingPoint) XXX_Unmarshal(b []byte) error {
94 return m.Unmarshal(b)
95 }
96 func (m *FloatingPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
97 if deterministic {
98 return xxx_messageInfo_FloatingPoint.Marshal(b, m, deterministic)
99 } else {
100 b = b[:cap(b)]
101 n, err := m.MarshalToSizedBuffer(b)
102 if err != nil {
103 return nil, err
104 }
105 return b[:n], nil
106 }
107 }
108 func (m *FloatingPoint) XXX_Merge(src proto.Message) {
109 xxx_messageInfo_FloatingPoint.Merge(m, src)
110 }
111 func (m *FloatingPoint) XXX_Size() int {
112 return m.Size()
113 }
114 func (m *FloatingPoint) XXX_DiscardUnknown() {
115 xxx_messageInfo_FloatingPoint.DiscardUnknown(m)
116 }
117
118 var xxx_messageInfo_FloatingPoint proto.InternalMessageInfo
119
120 type CustomMap struct {
121 Nullable128S map[string]*github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,1,rep,name=Nullable128s,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Nullable128s,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
122 Uint128S map[string]github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Uint128s,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Uint128s" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
123 NullableIds map[string]*github_com_gogo_protobuf_test.Uuid `protobuf:"bytes,3,rep,name=NullableIds,customtype=github.com/gogo/protobuf/test.Uuid" json:"NullableIds,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
124 Ids map[string]github_com_gogo_protobuf_test.Uuid `protobuf:"bytes,4,rep,name=Ids,customtype=github.com/gogo/protobuf/test.Uuid" json:"Ids" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
125 XXX_NoUnkeyedLiteral struct{} `json:"-"`
126 XXX_unrecognized []byte `json:"-"`
127 XXX_sizecache int32 `json:"-"`
128 }
129
130 func (m *CustomMap) Reset() { *m = CustomMap{} }
131 func (*CustomMap) ProtoMessage() {}
132 func (*CustomMap) Descriptor() ([]byte, []int) {
133 return fileDescriptor_0549d724f3f4db02, []int{1}
134 }
135 func (m *CustomMap) XXX_Unmarshal(b []byte) error {
136 return m.Unmarshal(b)
137 }
138 func (m *CustomMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
139 if deterministic {
140 return xxx_messageInfo_CustomMap.Marshal(b, m, deterministic)
141 } else {
142 b = b[:cap(b)]
143 n, err := m.MarshalToSizedBuffer(b)
144 if err != nil {
145 return nil, err
146 }
147 return b[:n], nil
148 }
149 }
150 func (m *CustomMap) XXX_Merge(src proto.Message) {
151 xxx_messageInfo_CustomMap.Merge(m, src)
152 }
153 func (m *CustomMap) XXX_Size() int {
154 return m.Size()
155 }
156 func (m *CustomMap) XXX_DiscardUnknown() {
157 xxx_messageInfo_CustomMap.DiscardUnknown(m)
158 }
159
160 var xxx_messageInfo_CustomMap proto.InternalMessageInfo
161
162 type AllMaps struct {
163 StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
164 StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
165 Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
166 Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
167 Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
168 Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
169 Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
170 Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
171 Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
172 Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
173 Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
174 Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
175 BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
176 StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
177 StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
178 StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"`
179 StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
180 XXX_NoUnkeyedLiteral struct{} `json:"-"`
181 XXX_unrecognized []byte `json:"-"`
182 XXX_sizecache int32 `json:"-"`
183 }
184
185 func (m *AllMaps) Reset() { *m = AllMaps{} }
186 func (*AllMaps) ProtoMessage() {}
187 func (*AllMaps) Descriptor() ([]byte, []int) {
188 return fileDescriptor_0549d724f3f4db02, []int{2}
189 }
190 func (m *AllMaps) XXX_Unmarshal(b []byte) error {
191 return m.Unmarshal(b)
192 }
193 func (m *AllMaps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
194 if deterministic {
195 return xxx_messageInfo_AllMaps.Marshal(b, m, deterministic)
196 } else {
197 b = b[:cap(b)]
198 n, err := m.MarshalToSizedBuffer(b)
199 if err != nil {
200 return nil, err
201 }
202 return b[:n], nil
203 }
204 }
205 func (m *AllMaps) XXX_Merge(src proto.Message) {
206 xxx_messageInfo_AllMaps.Merge(m, src)
207 }
208 func (m *AllMaps) XXX_Size() int {
209 return m.Size()
210 }
211 func (m *AllMaps) XXX_DiscardUnknown() {
212 xxx_messageInfo_AllMaps.DiscardUnknown(m)
213 }
214
215 var xxx_messageInfo_AllMaps proto.InternalMessageInfo
216
217 type AllMapsOrdered struct {
218 StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
219 StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
220 Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
221 Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
222 Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
223 Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
224 Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
225 Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
226 Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
227 Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
228 Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
229 Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
230 BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
231 StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
232 StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
233 StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"`
234 StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
235 XXX_NoUnkeyedLiteral struct{} `json:"-"`
236 XXX_unrecognized []byte `json:"-"`
237 XXX_sizecache int32 `json:"-"`
238 }
239
240 func (m *AllMapsOrdered) Reset() { *m = AllMapsOrdered{} }
241 func (*AllMapsOrdered) ProtoMessage() {}
242 func (*AllMapsOrdered) Descriptor() ([]byte, []int) {
243 return fileDescriptor_0549d724f3f4db02, []int{3}
244 }
245 func (m *AllMapsOrdered) XXX_Unmarshal(b []byte) error {
246 return m.Unmarshal(b)
247 }
248 func (m *AllMapsOrdered) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
249 b = b[:cap(b)]
250 n, err := m.MarshalToSizedBuffer(b)
251 if err != nil {
252 return nil, err
253 }
254 return b[:n], nil
255 }
256 func (m *AllMapsOrdered) XXX_Merge(src proto.Message) {
257 xxx_messageInfo_AllMapsOrdered.Merge(m, src)
258 }
259 func (m *AllMapsOrdered) XXX_Size() int {
260 return m.Size()
261 }
262 func (m *AllMapsOrdered) XXX_DiscardUnknown() {
263 xxx_messageInfo_AllMapsOrdered.DiscardUnknown(m)
264 }
265
266 var xxx_messageInfo_AllMapsOrdered proto.InternalMessageInfo
267
268 func init() {
269 proto.RegisterEnum("proto2.maps.MapEnum", MapEnum_name, MapEnum_value)
270 proto.RegisterType((*FloatingPoint)(nil), "proto2.maps.FloatingPoint")
271 proto.RegisterType((*CustomMap)(nil), "proto2.maps.CustomMap")
272 proto.RegisterMapType((map[string]github_com_gogo_protobuf_test.Uuid)(nil), "proto2.maps.CustomMap.IdsEntry")
273 proto.RegisterMapType((map[string]*github_com_gogo_protobuf_test_custom.Uint128)(nil), "proto2.maps.CustomMap.Nullable128sEntry")
274 proto.RegisterMapType((map[string]*github_com_gogo_protobuf_test.Uuid)(nil), "proto2.maps.CustomMap.NullableIdsEntry")
275 proto.RegisterMapType((map[string]github_com_gogo_protobuf_test_custom.Uint128)(nil), "proto2.maps.CustomMap.Uint128sEntry")
276 proto.RegisterType((*AllMaps)(nil), "proto2.maps.AllMaps")
277 proto.RegisterMapType((map[bool]bool)(nil), "proto2.maps.AllMaps.BoolMapEntry")
278 proto.RegisterMapType((map[uint32]uint32)(nil), "proto2.maps.AllMaps.Fixed32MapEntry")
279 proto.RegisterMapType((map[uint64]uint64)(nil), "proto2.maps.AllMaps.Fixed64MapEntry")
280 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMaps.Int32MapEntry")
281 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMaps.Int64MapEntry")
282 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMaps.Sfixed32MapEntry")
283 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMaps.Sfixed64MapEntry")
284 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMaps.Sint32MapEntry")
285 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMaps.Sint64MapEntry")
286 proto.RegisterMapType((map[string]string)(nil), "proto2.maps.AllMaps.StringMapEntry")
287 proto.RegisterMapType((map[string][]byte)(nil), "proto2.maps.AllMaps.StringToBytesMapEntry")
288 proto.RegisterMapType((map[string]float64)(nil), "proto2.maps.AllMaps.StringToDoubleMapEntry")
289 proto.RegisterMapType((map[string]MapEnum)(nil), "proto2.maps.AllMaps.StringToEnumMapEntry")
290 proto.RegisterMapType((map[string]float32)(nil), "proto2.maps.AllMaps.StringToFloatMapEntry")
291 proto.RegisterMapType((map[string]*FloatingPoint)(nil), "proto2.maps.AllMaps.StringToMsgMapEntry")
292 proto.RegisterMapType((map[uint32]uint32)(nil), "proto2.maps.AllMaps.Uint32MapEntry")
293 proto.RegisterMapType((map[uint64]uint64)(nil), "proto2.maps.AllMaps.Uint64MapEntry")
294 proto.RegisterType((*AllMapsOrdered)(nil), "proto2.maps.AllMapsOrdered")
295 proto.RegisterMapType((map[bool]bool)(nil), "proto2.maps.AllMapsOrdered.BoolMapEntry")
296 proto.RegisterMapType((map[uint32]uint32)(nil), "proto2.maps.AllMapsOrdered.Fixed32MapEntry")
297 proto.RegisterMapType((map[uint64]uint64)(nil), "proto2.maps.AllMapsOrdered.Fixed64MapEntry")
298 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMapsOrdered.Int32MapEntry")
299 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMapsOrdered.Int64MapEntry")
300 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMapsOrdered.Sfixed32MapEntry")
301 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMapsOrdered.Sfixed64MapEntry")
302 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMapsOrdered.Sint32MapEntry")
303 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMapsOrdered.Sint64MapEntry")
304 proto.RegisterMapType((map[string]string)(nil), "proto2.maps.AllMapsOrdered.StringMapEntry")
305 proto.RegisterMapType((map[string][]byte)(nil), "proto2.maps.AllMapsOrdered.StringToBytesMapEntry")
306 proto.RegisterMapType((map[string]float64)(nil), "proto2.maps.AllMapsOrdered.StringToDoubleMapEntry")
307 proto.RegisterMapType((map[string]MapEnum)(nil), "proto2.maps.AllMapsOrdered.StringToEnumMapEntry")
308 proto.RegisterMapType((map[string]float32)(nil), "proto2.maps.AllMapsOrdered.StringToFloatMapEntry")
309 proto.RegisterMapType((map[string]*FloatingPoint)(nil), "proto2.maps.AllMapsOrdered.StringToMsgMapEntry")
310 proto.RegisterMapType((map[uint32]uint32)(nil), "proto2.maps.AllMapsOrdered.Uint32MapEntry")
311 proto.RegisterMapType((map[uint64]uint64)(nil), "proto2.maps.AllMapsOrdered.Uint64MapEntry")
312 }
313
314 func init() { proto.RegisterFile("combos/both/mapsproto2.proto", fileDescriptor_0549d724f3f4db02) }
315
316 var fileDescriptor_0549d724f3f4db02 = []byte{
317
318 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x97, 0xcb, 0x6f, 0x1a, 0x57,
319 0x14, 0xc6, 0xb9, 0x3c, 0x0c, 0x5c, 0xde, 0x37, 0x69, 0x85, 0x50, 0x7b, 0x71, 0xe8, 0x8b, 0x90,
320 0x14, 0x6c, 0x1a, 0x45, 0x96, 0xd3, 0xa6, 0x32, 0xb6, 0x53, 0xac, 0x14, 0x37, 0x82, 0xa6, 0x2f,
321 0xc9, 0x52, 0xc1, 0x3c, 0x82, 0x0a, 0x0c, 0x65, 0x86, 0xa8, 0xde, 0x54, 0xf9, 0x33, 0xba, 0xed,
322 0xae, 0xcb, 0x2e, 0xbb, 0xec, 0xd2, 0x52, 0x37, 0x59, 0x46, 0x51, 0x65, 0x85, 0xe9, 0x26, 0xcb,
323 0x2c, 0xb3, 0xac, 0xe6, 0xce, 0x83, 0x3b, 0x33, 0x67, 0x66, 0xa0, 0xab, 0x2e, 0xbc, 0xc2, 0x77,
324 0x38, 0xdf, 0xef, 0x3b, 0x33, 0x73, 0xef, 0xe1, 0x33, 0x7e, 0xeb, 0x54, 0x18, 0x77, 0x04, 0xb1,
325 0xd2, 0x11, 0xa4, 0x47, 0x95, 0x71, 0x7b, 0x2a, 0x4e, 0x67, 0x82, 0x24, 0x54, 0xcb, 0xec, 0x83,
326 0xc4, 0xb4, 0x95, 0xf2, 0x45, 0xee, 0xc3, 0xc1, 0x50, 0x7a, 0x34, 0xef, 0x94, 0x4f, 0x85, 0x71,
327 0x65, 0x20, 0x0c, 0x84, 0x0a, 0xfb, 0xb2, 0x33, 0xef, 0xb3, 0x15, 0x5b, 0xb0, 0xbf, 0x54, 0x6d,
328 0xe1, 0x6d, 0x9c, 0xb8, 0x37, 0x12, 0xda, 0xd2, 0x70, 0x32, 0x78, 0x20, 0x0c, 0x27, 0x12, 0x89,
329 0x63, 0xd4, 0xcf, 0xa2, 0x4d, 0x54, 0x44, 0x4d, 0xd4, 0x2f, 0xfc, 0x15, 0xc2, 0xd1, 0xfd, 0xb9,
330 0x28, 0x09, 0xe3, 0x46, 0x7b, 0x4a, 0x7e, 0xc6, 0xf1, 0xe3, 0xf9, 0x68, 0xd4, 0xee, 0x8c, 0x7a,
331 0xdb, 0xd5, 0x1d, 0x31, 0x8b, 0x36, 0x03, 0xc5, 0x58, 0xb5, 0x58, 0xe6, 0xfc, 0xcb, 0x46, 0x75,
332 0x99, 0x2f, 0x3d, 0x9c, 0x48, 0xb3, 0xb3, 0xda, 0xd6, 0xf3, 0x8b, 0xfc, 0x4d, 0xc7, 0xfe, 0xa4,
333 0x9e, 0x28, 0x55, 0x4e, 0x99, 0xbc, 0xfc, 0x70, 0x38, 0x91, 0xb6, 0xab, 0x3b, 0x4d, 0x93, 0x1f,
334 0x79, 0x8c, 0x23, 0xda, 0x17, 0x62, 0xd6, 0xcf, 0xbc, 0xdf, 0x75, 0xf0, 0xd6, 0xcb, 0x54, 0xdf,
335 0x5b, 0xe7, 0x17, 0x79, 0xdf, 0xda, 0xde, 0x86, 0x17, 0xf9, 0x11, 0xc7, 0xf4, 0x3e, 0x8e, 0xba,
336 0x62, 0x36, 0xc0, 0xac, 0x3f, 0xf0, 0xb8, 0xed, 0xa3, 0xae, 0xe6, 0xfe, 0xfe, 0xf3, 0x8b, 0x7c,
337 0xc1, 0xd5, 0xb9, 0xfc, 0x70, 0x3e, 0xec, 0x36, 0x79, 0x0f, 0x72, 0x82, 0x03, 0x8a, 0x55, 0x90,
338 0x59, 0xe5, 0x1d, 0xac, 0x0c, 0x8b, 0x92, 0x76, 0x83, 0xab, 0xd8, 0x28, 0xdc, 0xdc, 0xa7, 0x38,
339 0x63, 0x7b, 0x3d, 0x24, 0x8d, 0x03, 0x3f, 0xf4, 0xce, 0xd8, 0xcb, 0x8f, 0x36, 0x95, 0x3f, 0xc9,
340 0x55, 0x1c, 0x7a, 0xdc, 0x1e, 0xcd, 0x7b, 0x59, 0xff, 0x26, 0x2a, 0xc6, 0x9b, 0xea, 0x62, 0xd7,
341 0xbf, 0x83, 0x72, 0x77, 0x70, 0xc2, 0xf4, 0x8c, 0xd7, 0x12, 0xdf, 0xc5, 0x69, 0xeb, 0x53, 0x5a,
342 0x4b, 0x7f, 0x1b, 0x47, 0xfe, 0x8b, 0xae, 0xf0, 0x8c, 0xe0, 0xf0, 0xde, 0x68, 0xd4, 0x68, 0x4f,
343 0x45, 0xf2, 0x2d, 0xce, 0xb4, 0xa4, 0xd9, 0x70, 0x32, 0xf8, 0x52, 0x38, 0x10, 0xe6, 0x9d, 0x51,
344 0xaf, 0xd1, 0x9e, 0x6a, 0x1b, 0xfa, 0x86, 0xe9, 0x71, 0x6b, 0x82, 0xb2, 0xad, 0x9a, 0xf9, 0x37,
345 0xed, 0x14, 0xf2, 0x15, 0x4e, 0xeb, 0x17, 0xd9, 0xd9, 0x52, 0xc8, 0xea, 0x76, 0x2d, 0xb9, 0x92,
346 0xf5, 0x62, 0x15, 0x6c, 0x63, 0x90, 0xbb, 0x38, 0x72, 0x34, 0x91, 0x3e, 0xaa, 0x2a, 0x3c, 0x75,
347 0x0f, 0x16, 0x40, 0x9e, 0x5e, 0xa4, 0x72, 0x0c, 0x8d, 0xa6, 0xbf, 0x7d, 0x4b, 0xd1, 0x07, 0xdd,
348 0xf5, 0xac, 0x68, 0xa9, 0x67, 0x4b, 0xb2, 0x87, 0xa3, 0xca, 0x3b, 0x57, 0x1b, 0x08, 0x31, 0xc0,
349 0x3b, 0x20, 0xc0, 0xa8, 0x52, 0x09, 0x4b, 0x95, 0x8e, 0x50, 0x7b, 0xd8, 0xf0, 0x40, 0x70, 0x4d,
350 0x2c, 0x55, 0x0a, 0xa2, 0x65, 0x74, 0x11, 0x76, 0x41, 0xb4, 0x2c, 0x5d, 0xb4, 0xf8, 0x2e, 0x5a,
351 0x46, 0x17, 0x11, 0x0f, 0x04, 0xdf, 0x85, 0xb1, 0x26, 0x07, 0x18, 0xdf, 0x1b, 0xfe, 0xd4, 0xeb,
352 0xaa, 0x6d, 0x44, 0x81, 0x61, 0xa4, 0x33, 0x96, 0x65, 0x2a, 0x84, 0xd3, 0x91, 0xcf, 0x70, 0xac,
353 0xd5, 0x5f, 0x62, 0x30, 0xc3, 0xbc, 0x07, 0xb7, 0xd2, 0xb7, 0x70, 0x78, 0xa5, 0xd1, 0x8e, 0x7a,
354 0x4b, 0x31, 0xaf, 0x76, 0xb8, 0x7b, 0xe2, 0x74, 0xcb, 0x76, 0x54, 0x4c, 0xdc, 0xb3, 0x1d, 0x8e,
355 0xc3, 0x2b, 0xc9, 0x1d, 0x1c, 0xae, 0x09, 0x82, 0x52, 0x99, 0x4d, 0x30, 0xc8, 0x35, 0x10, 0xa2,
356 0xd5, 0xa8, 0x00, 0x5d, 0xc1, 0xde, 0x0e, 0xdb, 0xfa, 0x8a, 0x3c, 0xe9, 0xf6, 0x76, 0xf4, 0x2a,
357 0xfd, 0xed, 0xe8, 0x6b, 0xfe, 0x04, 0xd6, 0xce, 0xa4, 0x9e, 0xa8, 0x90, 0x52, 0x2b, 0x9c, 0x40,
358 0xbd, 0xd8, 0x72, 0x02, 0xf5, 0xcb, 0xa4, 0x85, 0x53, 0xfa, 0xb5, 0xc3, 0xc9, 0x5c, 0x99, 0xc1,
359 0xd9, 0x34, 0xc3, 0x5e, 0x77, 0xc5, 0x6a, 0xb5, 0x2a, 0xd5, 0x4a, 0x20, 0x0f, 0x70, 0x52, 0xbf,
360 0xd4, 0x10, 0xd9, 0x4d, 0x67, 0x80, 0xdf, 0x55, 0x2b, 0x53, 0x2d, 0x55, 0x91, 0x16, 0x7d, 0xee,
361 0x00, 0xbf, 0x09, 0x4f, 0x2b, 0xaf, 0x69, 0x89, 0xf8, 0x29, 0xbb, 0x8f, 0xdf, 0x00, 0x27, 0x93,
362 0x17, 0xc4, 0x6f, 0xf9, 0x9d, 0x30, 0x8d, 0x23, 0x5e, 0x1c, 0x02, 0xc4, 0x21, 0xbb, 0x78, 0xb9,
363 0xc9, 0x78, 0x71, 0x00, 0x10, 0x07, 0x78, 0xf1, 0xc7, 0x38, 0x69, 0x9e, 0x43, 0xbc, 0x3a, 0x01,
364 0xa8, 0x13, 0x80, 0x1a, 0xf6, 0x0e, 0x02, 0xea, 0xa0, 0x45, 0xdd, 0x72, 0xf4, 0xce, 0x00, 0xea,
365 0x0c, 0xa0, 0x86, 0xbd, 0x09, 0xa0, 0x26, 0xbc, 0xfa, 0x13, 0x9c, 0xb2, 0x8c, 0x1c, 0x5e, 0x1e,
366 0x06, 0xe4, 0x61, 0xcb, 0x6f, 0xb3, 0x75, 0xd4, 0xf0, 0xfa, 0x14, 0xa0, 0x4f, 0x41, 0xf6, 0x70,
367 0xf7, 0x1b, 0x80, 0x7c, 0x03, 0xb4, 0x87, 0xf5, 0x69, 0x40, 0x9f, 0xe6, 0xf5, 0xbb, 0x38, 0xce,
368 0x4f, 0x15, 0x5e, 0x1b, 0x01, 0xb4, 0x11, 0xeb, 0x73, 0x37, 0x8d, 0x14, 0xaf, 0x9d, 0x1e, 0x75,
369 0x38, 0x2e, 0xa6, 0x31, 0xb2, 0x56, 0xb2, 0xf9, 0x06, 0x5f, 0x85, 0x86, 0x06, 0xc0, 0x28, 0xf1,
370 0x8c, 0x64, 0xf5, 0xaa, 0x69, 0x58, 0x30, 0xdd, 0x7c, 0xcc, 0x93, 0x4f, 0xf0, 0x15, 0x60, 0x74,
371 0x00, 0xe0, 0x2d, 0x1e, 0x1c, 0xab, 0xe6, 0x4c, 0x60, 0xd3, 0xff, 0x0a, 0x7c, 0xb4, 0xfa, 0xfb,
372 0x0a, 0x4e, 0x6a, 0x23, 0xea, 0x8b, 0x59, 0xb7, 0x37, 0xeb, 0x75, 0xc9, 0xf7, 0xce, 0x09, 0xab,
373 0x0a, 0x8d, 0x36, 0x4d, 0xb7, 0x46, 0xd0, 0x3a, 0x71, 0x0c, 0x5a, 0xdb, 0xab, 0x18, 0x78, 0xe5,
374 0xad, 0x43, 0x5b, 0xde, 0xba, 0xee, 0x86, 0x75, 0x8a, 0x5d, 0x87, 0xb6, 0xd8, 0xe5, 0x85, 0x01,
375 0xd3, 0x57, 0xdd, 0x9e, 0xbe, 0x4a, 0x6e, 0x1c, 0xe7, 0x10, 0x56, 0xb7, 0x87, 0x30, 0x4f, 0x12,
376 0x9c, 0xc5, 0xea, 0xf6, 0x2c, 0xe6, 0x4a, 0x72, 0x8e, 0x64, 0x75, 0x7b, 0x24, 0xf3, 0x24, 0xc1,
377 0xc9, 0xec, 0x3e, 0x90, 0xcc, 0x6e, 0xb8, 0xa1, 0xdc, 0x02, 0xda, 0x31, 0x14, 0xd0, 0x6e, 0xba,
378 0x36, 0xe6, 0x9a, 0xd3, 0xee, 0x03, 0x39, 0xcd, 0xbb, 0x39, 0x87, 0xb8, 0x76, 0x0c, 0xc5, 0xb5,
379 0x15, 0x9a, 0x73, 0x4a, 0x6d, 0x35, 0x6b, 0x6a, 0x2b, 0xba, 0xb1, 0xe0, 0xf0, 0x56, 0xb7, 0x87,
380 0xb7, 0x92, 0xf7, 0x59, 0x84, 0x32, 0xdc, 0x89, 0x63, 0x86, 0x5b, 0xe9, 0x70, 0x7b, 0x45, 0xb9,
381 0xef, 0x9c, 0xa2, 0xdc, 0xd6, 0x2a, 0x74, 0xf7, 0x44, 0xf7, 0xb5, 0x43, 0xa2, 0xab, 0xac, 0x82,
382 0xbe, 0x0c, 0x76, 0x97, 0xc1, 0xee, 0x32, 0xd8, 0x5d, 0x06, 0xbb, 0xff, 0x47, 0xb0, 0xdb, 0x0d,
383 0xfe, 0xf2, 0x6b, 0x1e, 0x95, 0xae, 0xe1, 0xb0, 0x66, 0x4d, 0x36, 0xb0, 0xbf, 0xb1, 0x97, 0xf6,
384 0xb1, 0xcf, 0x5a, 0x1a, 0xb1, 0xcf, 0xfd, 0xb4, 0xbf, 0xf6, 0xf9, 0xf9, 0x82, 0xfa, 0x9e, 0x2e,
385 0xa8, 0xef, 0xd9, 0x82, 0xfa, 0x5e, 0x2c, 0x28, 0x7a, 0xb9, 0xa0, 0xe8, 0xd5, 0x82, 0xa2, 0xd7,
386 0x0b, 0x8a, 0x9e, 0xc8, 0x14, 0xfd, 0x26, 0x53, 0xf4, 0xbb, 0x4c, 0xd1, 0x1f, 0x32, 0x45, 0x7f,
387 0xca, 0x14, 0x9d, 0xcb, 0x14, 0x3d, 0x95, 0x29, 0x7a, 0x21, 0x53, 0xf4, 0x52, 0xa6, 0xbe, 0x57,
388 0x32, 0x45, 0xaf, 0x65, 0xea, 0x7b, 0xf2, 0x0f, 0xf5, 0xfd, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xfa,
389 0x87, 0xd5, 0x9e, 0xf2, 0x16, 0x00, 0x00,
390 }
391
392 func (this *FloatingPoint) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
393 return Mapsproto2Description()
394 }
395 func (this *CustomMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
396 return Mapsproto2Description()
397 }
398 func (this *AllMaps) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
399 return Mapsproto2Description()
400 }
401 func (this *AllMapsOrdered) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
402 return Mapsproto2Description()
403 }
404 func Mapsproto2Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
405 d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
406 var gzipped = []byte{
407
408 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0x5b, 0x6c, 0x23, 0xd7,
409 0x79, 0xd6, 0xf0, 0x22, 0x91, 0x3f, 0x29, 0x6a, 0x34, 0x92, 0xd7, 0xb4, 0x12, 0x6b, 0x77, 0xe5,
410 0x9b, 0xbc, 0x6b, 0x4b, 0xb6, 0xbc, 0xbb, 0x5e, 0x73, 0x63, 0xbb, 0x94, 0xc4, 0xd5, 0xca, 0xd6,
411 0x2d, 0x43, 0xc9, 0xb7, 0xc0, 0x98, 0x8e, 0x86, 0x47, 0xd4, 0x78, 0xc9, 0x19, 0x7a, 0x66, 0xb8,
412 0x6b, 0x19, 0x45, 0xb1, 0x85, 0x7b, 0x41, 0xd0, 0xfb, 0x05, 0xa8, 0xe3, 0x3a, 0x6e, 0x9d, 0xa2,
413 0x71, 0x9a, 0xde, 0x92, 0x5e, 0xd2, 0x24, 0x7d, 0xc9, 0x4b, 0x5a, 0x03, 0x05, 0x8a, 0xe4, 0x2d,
414 0x08, 0x02, 0xc3, 0xab, 0x18, 0xa8, 0xdb, 0xba, 0xad, 0x9b, 0xfa, 0xc1, 0x80, 0x5f, 0x8a, 0x73,
415 0x1b, 0x9e, 0x19, 0x0e, 0x39, 0x94, 0x01, 0x3b, 0x7d, 0xf0, 0xd3, 0x6a, 0xce, 0xf9, 0xbf, 0xef,
416 0xfc, 0xf3, 0x9f, 0xff, 0xfc, 0xe7, 0x3b, 0x67, 0xb8, 0xf0, 0x7a, 0x09, 0x4e, 0xd4, 0x6d, 0xbb,
417 0xde, 0x40, 0xf3, 0x2d, 0xc7, 0xf6, 0xec, 0xdd, 0xf6, 0xde, 0x7c, 0x0d, 0xb9, 0x86, 0x63, 0xb6,
418 0x3c, 0xdb, 0x99, 0x23, 0x6d, 0xca, 0x18, 0xb5, 0x98, 0xe3, 0x16, 0x33, 0xeb, 0x30, 0x7e, 0xd1,
419 0x6c, 0xa0, 0x65, 0xdf, 0xb0, 0x8a, 0x3c, 0xe5, 0x3c, 0xa4, 0xf6, 0xcc, 0x06, 0x2a, 0x4a, 0x27,
420 0x92, 0xb3, 0xb9, 0x85, 0x5b, 0xe7, 0x42, 0xa0, 0xb9, 0x20, 0x62, 0x0b, 0x37, 0xab, 0x04, 0x31,
421 0xf3, 0x56, 0x0a, 0x26, 0x22, 0x7a, 0x15, 0x05, 0x52, 0x96, 0xde, 0xc4, 0x8c, 0xd2, 0x6c, 0x56,
422 0x25, 0x7f, 0x2b, 0x45, 0x18, 0x69, 0xe9, 0xc6, 0x65, 0xbd, 0x8e, 0x8a, 0x09, 0xd2, 0xcc, 0x1f,
423 0x95, 0x69, 0x80, 0x1a, 0x6a, 0x21, 0xab, 0x86, 0x2c, 0xe3, 0xa0, 0x98, 0x3c, 0x91, 0x9c, 0xcd,
424 0xaa, 0x42, 0x8b, 0x72, 0x1a, 0xc6, 0x5b, 0xed, 0xdd, 0x86, 0x69, 0x68, 0x82, 0x19, 0x9c, 0x48,
425 0xce, 0xa6, 0x55, 0x99, 0x76, 0x2c, 0x77, 0x8c, 0xef, 0x80, 0xb1, 0xab, 0x48, 0xbf, 0x2c, 0x9a,
426 0xe6, 0x88, 0x69, 0x01, 0x37, 0x0b, 0x86, 0x4b, 0x90, 0x6f, 0x22, 0xd7, 0xd5, 0xeb, 0x48, 0xf3,
427 0x0e, 0x5a, 0xa8, 0x98, 0x22, 0x6f, 0x7f, 0xa2, 0xeb, 0xed, 0xc3, 0x6f, 0x9e, 0x63, 0xa8, 0xed,
428 0x83, 0x16, 0x52, 0xca, 0x90, 0x45, 0x56, 0xbb, 0x49, 0x19, 0xd2, 0x3d, 0xe2, 0x57, 0xb1, 0xda,
429 0xcd, 0x30, 0x4b, 0x06, 0xc3, 0x18, 0xc5, 0x88, 0x8b, 0x9c, 0x2b, 0xa6, 0x81, 0x8a, 0xc3, 0x84,
430 0xe0, 0x8e, 0x2e, 0x82, 0x2a, 0xed, 0x0f, 0x73, 0x70, 0x9c, 0xb2, 0x04, 0x59, 0xf4, 0x9c, 0x87,
431 0x2c, 0xd7, 0xb4, 0xad, 0xe2, 0x08, 0x21, 0xb9, 0x2d, 0x62, 0x16, 0x51, 0xa3, 0x16, 0xa6, 0xe8,
432 0xe0, 0x94, 0x73, 0x30, 0x62, 0xb7, 0x3c, 0xd3, 0xb6, 0xdc, 0x62, 0xe6, 0x84, 0x34, 0x9b, 0x5b,
433 0xf8, 0x74, 0x64, 0x22, 0x6c, 0x52, 0x1b, 0x95, 0x1b, 0x2b, 0xab, 0x20, 0xbb, 0x76, 0xdb, 0x31,
434 0x90, 0x66, 0xd8, 0x35, 0xa4, 0x99, 0xd6, 0x9e, 0x5d, 0xcc, 0x12, 0x82, 0xe3, 0xdd, 0x2f, 0x42,
435 0x0c, 0x97, 0xec, 0x1a, 0x5a, 0xb5, 0xf6, 0x6c, 0xb5, 0xe0, 0x06, 0x9e, 0x95, 0x63, 0x30, 0xec,
436 0x1e, 0x58, 0x9e, 0xfe, 0x5c, 0x31, 0x4f, 0x32, 0x84, 0x3d, 0xcd, 0x7c, 0x6b, 0x18, 0xc6, 0x06,
437 0x49, 0xb1, 0x0b, 0x90, 0xde, 0xc3, 0x6f, 0x59, 0x4c, 0x1c, 0x25, 0x06, 0x14, 0x13, 0x0c, 0xe2,
438 0xf0, 0x87, 0x0c, 0x62, 0x19, 0x72, 0x16, 0x72, 0x3d, 0x54, 0xa3, 0x19, 0x91, 0x1c, 0x30, 0xa7,
439 0x80, 0x82, 0xba, 0x53, 0x2a, 0xf5, 0xa1, 0x52, 0xea, 0x09, 0x18, 0xf3, 0x5d, 0xd2, 0x1c, 0xdd,
440 0xaa, 0xf3, 0xdc, 0x9c, 0x8f, 0xf3, 0x64, 0xae, 0xc2, 0x71, 0x2a, 0x86, 0xa9, 0x05, 0x14, 0x78,
441 0x56, 0x96, 0x01, 0x6c, 0x0b, 0xd9, 0x7b, 0x5a, 0x0d, 0x19, 0x8d, 0x62, 0xa6, 0x47, 0x94, 0x36,
442 0xb1, 0x49, 0x57, 0x94, 0x6c, 0xda, 0x6a, 0x34, 0x94, 0x07, 0x3a, 0xa9, 0x36, 0xd2, 0x23, 0x53,
443 0xd6, 0xe9, 0x22, 0xeb, 0xca, 0xb6, 0x1d, 0x28, 0x38, 0x08, 0xe7, 0x3d, 0xaa, 0xb1, 0x37, 0xcb,
444 0x12, 0x27, 0xe6, 0x62, 0xdf, 0x4c, 0x65, 0x30, 0xfa, 0x62, 0xa3, 0x8e, 0xf8, 0xa8, 0xdc, 0x02,
445 0x7e, 0x83, 0x46, 0xd2, 0x0a, 0x48, 0x15, 0xca, 0xf3, 0xc6, 0x0d, 0xbd, 0x89, 0xa6, 0x9e, 0x87,
446 0x42, 0x30, 0x3c, 0xca, 0x24, 0xa4, 0x5d, 0x4f, 0x77, 0x3c, 0x92, 0x85, 0x69, 0x95, 0x3e, 0x28,
447 0x32, 0x24, 0x91, 0x55, 0x23, 0x55, 0x2e, 0xad, 0xe2, 0x3f, 0x95, 0x9f, 0xe9, 0xbc, 0x70, 0x92,
448 0xbc, 0xf0, 0xed, 0xdd, 0x33, 0x1a, 0x60, 0x0e, 0xbf, 0xf7, 0xd4, 0xfd, 0x30, 0x1a, 0x78, 0x81,
449 0x41, 0x87, 0x9e, 0xf9, 0x39, 0xb8, 0x21, 0x92, 0x5a, 0x79, 0x02, 0x26, 0xdb, 0x96, 0x69, 0x79,
450 0xc8, 0x69, 0x39, 0x08, 0x67, 0x2c, 0x1d, 0xaa, 0xf8, 0xaf, 0x23, 0x3d, 0x72, 0x6e, 0x47, 0xb4,
451 0xa6, 0x2c, 0xea, 0x44, 0xbb, 0xbb, 0xf1, 0x54, 0x36, 0xf3, 0xf6, 0x88, 0x7c, 0xed, 0xda, 0xb5,
452 0x6b, 0x89, 0x99, 0x17, 0x87, 0x61, 0x32, 0x6a, 0xcd, 0x44, 0x2e, 0xdf, 0x63, 0x30, 0x6c, 0xb5,
453 0x9b, 0xbb, 0xc8, 0x21, 0x41, 0x4a, 0xab, 0xec, 0x49, 0x29, 0x43, 0xba, 0xa1, 0xef, 0xa2, 0x46,
454 0x31, 0x75, 0x42, 0x9a, 0x2d, 0x2c, 0x9c, 0x1e, 0x68, 0x55, 0xce, 0xad, 0x61, 0x88, 0x4a, 0x91,
455 0xca, 0x43, 0x90, 0x62, 0x25, 0x1a, 0x33, 0x9c, 0x1a, 0x8c, 0x01, 0xaf, 0x25, 0x95, 0xe0, 0x94,
456 0x4f, 0x41, 0x16, 0xff, 0x4b, 0x73, 0x63, 0x98, 0xf8, 0x9c, 0xc1, 0x0d, 0x38, 0x2f, 0x94, 0x29,
457 0xc8, 0x90, 0x65, 0x52, 0x43, 0x7c, 0x6b, 0xf3, 0x9f, 0x71, 0x62, 0xd5, 0xd0, 0x9e, 0xde, 0x6e,
458 0x78, 0xda, 0x15, 0xbd, 0xd1, 0x46, 0x24, 0xe1, 0xb3, 0x6a, 0x9e, 0x35, 0x3e, 0x86, 0xdb, 0x94,
459 0xe3, 0x90, 0xa3, 0xab, 0xca, 0xb4, 0x6a, 0xe8, 0x39, 0x52, 0x3d, 0xd3, 0x2a, 0x5d, 0x68, 0xab,
460 0xb8, 0x05, 0x0f, 0xff, 0x8c, 0x6b, 0x5b, 0x3c, 0x35, 0xc9, 0x10, 0xb8, 0x81, 0x0c, 0x7f, 0x7f,
461 0xb8, 0x70, 0xdf, 0x1c, 0xfd, 0x7a, 0xe1, 0x9c, 0x9a, 0xf9, 0x46, 0x02, 0x52, 0xa4, 0x5e, 0x8c,
462 0x41, 0x6e, 0xfb, 0xc9, 0xad, 0x8a, 0xb6, 0xbc, 0xb9, 0xb3, 0xb8, 0x56, 0x91, 0x25, 0xa5, 0x00,
463 0x40, 0x1a, 0x2e, 0xae, 0x6d, 0x96, 0xb7, 0xe5, 0x84, 0xff, 0xbc, 0xba, 0xb1, 0x7d, 0xee, 0x8c,
464 0x9c, 0xf4, 0x01, 0x3b, 0xb4, 0x21, 0x25, 0x1a, 0xdc, 0xb7, 0x20, 0xa7, 0x15, 0x19, 0xf2, 0x94,
465 0x60, 0xf5, 0x89, 0xca, 0xf2, 0xb9, 0x33, 0xf2, 0x70, 0xb0, 0xe5, 0xbe, 0x05, 0x79, 0x44, 0x19,
466 0x85, 0x2c, 0x69, 0x59, 0xdc, 0xdc, 0x5c, 0x93, 0x33, 0x3e, 0x67, 0x75, 0x5b, 0x5d, 0xdd, 0x58,
467 0x91, 0xb3, 0x3e, 0xe7, 0x8a, 0xba, 0xb9, 0xb3, 0x25, 0x83, 0xcf, 0xb0, 0x5e, 0xa9, 0x56, 0xcb,
468 0x2b, 0x15, 0x39, 0xe7, 0x5b, 0x2c, 0x3e, 0xb9, 0x5d, 0xa9, 0xca, 0xf9, 0x80, 0x5b, 0xf7, 0x2d,
469 0xc8, 0xa3, 0xfe, 0x10, 0x95, 0x8d, 0x9d, 0x75, 0xb9, 0xa0, 0x8c, 0xc3, 0x28, 0x1d, 0x82, 0x3b,
470 0x31, 0x16, 0x6a, 0x3a, 0x77, 0x46, 0x96, 0x3b, 0x8e, 0x50, 0x96, 0xf1, 0x40, 0xc3, 0xb9, 0x33,
471 0xb2, 0x32, 0xb3, 0x04, 0x69, 0x92, 0x5d, 0x8a, 0x02, 0x85, 0xb5, 0xf2, 0x62, 0x65, 0x4d, 0xdb,
472 0xdc, 0xda, 0x5e, 0xdd, 0xdc, 0x28, 0xaf, 0xc9, 0x52, 0xa7, 0x4d, 0xad, 0x7c, 0x76, 0x67, 0x55,
473 0xad, 0x2c, 0xcb, 0x09, 0xb1, 0x6d, 0xab, 0x52, 0xde, 0xae, 0x2c, 0xcb, 0xc9, 0x19, 0x03, 0x26,
474 0xa3, 0xea, 0x64, 0xe4, 0xca, 0x10, 0xa6, 0x38, 0xd1, 0x63, 0x8a, 0x09, 0x57, 0xd7, 0x14, 0xff,
475 0x38, 0x01, 0x13, 0x11, 0x7b, 0x45, 0xe4, 0x20, 0x0f, 0x43, 0x9a, 0xa6, 0x28, 0xdd, 0x3d, 0xef,
476 0x8c, 0xdc, 0x74, 0x48, 0xc2, 0x76, 0xed, 0xa0, 0x04, 0x27, 0x2a, 0x88, 0x64, 0x0f, 0x05, 0x81,
477 0x29, 0xba, 0x6a, 0xfa, 0xd3, 0x5d, 0x35, 0x9d, 0x6e, 0x7b, 0xe7, 0x06, 0xd9, 0xf6, 0x48, 0xdb,
478 0xd1, 0x6a, 0x7b, 0x3a, 0xa2, 0xb6, 0x5f, 0x80, 0xf1, 0x2e, 0xa2, 0x81, 0x6b, 0xec, 0x0b, 0x12,
479 0x14, 0x7b, 0x05, 0x27, 0xa6, 0xd2, 0x25, 0x02, 0x95, 0xee, 0x42, 0x38, 0x82, 0x27, 0x7b, 0x4f,
480 0x42, 0xd7, 0x5c, 0xbf, 0x26, 0xc1, 0xb1, 0x68, 0xa5, 0x18, 0xe9, 0xc3, 0x43, 0x30, 0xdc, 0x44,
481 0xde, 0xbe, 0xcd, 0xd5, 0xd2, 0xed, 0x11, 0x7b, 0x30, 0xee, 0x0e, 0x4f, 0x36, 0x43, 0x89, 0x9b,
482 0x78, 0xb2, 0x97, 0xdc, 0xa3, 0xde, 0x74, 0x79, 0xfa, 0xf9, 0x04, 0xdc, 0x10, 0x49, 0x1e, 0xe9,
483 0xe8, 0xcd, 0x00, 0xa6, 0xd5, 0x6a, 0x7b, 0x54, 0x11, 0xd1, 0x02, 0x9b, 0x25, 0x2d, 0xa4, 0x78,
484 0xe1, 0xe2, 0xd9, 0xf6, 0xfc, 0xfe, 0x24, 0xe9, 0x07, 0xda, 0x44, 0x0c, 0xce, 0x77, 0x1c, 0x4d,
485 0x11, 0x47, 0xa7, 0x7b, 0xbc, 0x69, 0x57, 0x62, 0xde, 0x03, 0xb2, 0xd1, 0x30, 0x91, 0xe5, 0x69,
486 0xae, 0xe7, 0x20, 0xbd, 0x69, 0x5a, 0x75, 0xb2, 0x83, 0x64, 0x4a, 0xe9, 0x3d, 0xbd, 0xe1, 0x22,
487 0x75, 0x8c, 0x76, 0x57, 0x79, 0x2f, 0x46, 0x90, 0x04, 0x72, 0x04, 0xc4, 0x70, 0x00, 0x41, 0xbb,
488 0x7d, 0xc4, 0xcc, 0xaf, 0x65, 0x21, 0x27, 0xe8, 0x6a, 0xe5, 0x24, 0xe4, 0x9f, 0xd1, 0xaf, 0xe8,
489 0x1a, 0x3f, 0x2b, 0xd1, 0x48, 0xe4, 0x70, 0xdb, 0x16, 0x3b, 0x2f, 0xdd, 0x03, 0x93, 0xc4, 0xc4,
490 0x6e, 0x7b, 0xc8, 0xd1, 0x8c, 0x86, 0xee, 0xba, 0x24, 0x68, 0x19, 0x62, 0xaa, 0xe0, 0xbe, 0x4d,
491 0xdc, 0xb5, 0xc4, 0x7b, 0x94, 0xb3, 0x30, 0x41, 0x10, 0xcd, 0x76, 0xc3, 0x33, 0x5b, 0x0d, 0xa4,
492 0xe1, 0xd3, 0x9b, 0x4b, 0x76, 0x12, 0xdf, 0xb3, 0x71, 0x6c, 0xb1, 0xce, 0x0c, 0xb0, 0x47, 0xae,
493 0xb2, 0x0c, 0x37, 0x13, 0x58, 0x1d, 0x59, 0xc8, 0xd1, 0x3d, 0xa4, 0xa1, 0x67, 0xdb, 0x7a, 0xc3,
494 0xd5, 0x74, 0xab, 0xa6, 0xed, 0xeb, 0xee, 0x7e, 0x71, 0x12, 0x13, 0x2c, 0x26, 0x8a, 0x92, 0x7a,
495 0x13, 0x36, 0x5c, 0x61, 0x76, 0x15, 0x62, 0x56, 0xb6, 0x6a, 0x97, 0x74, 0x77, 0x5f, 0x29, 0xc1,
496 0x31, 0xc2, 0xe2, 0x7a, 0x8e, 0x69, 0xd5, 0x35, 0x63, 0x1f, 0x19, 0x97, 0xb5, 0xb6, 0xb7, 0x77,
497 0xbe, 0xf8, 0x29, 0x71, 0x7c, 0xe2, 0x61, 0x95, 0xd8, 0x2c, 0x61, 0x93, 0x1d, 0x6f, 0xef, 0xbc,
498 0x52, 0x85, 0x3c, 0x9e, 0x8c, 0xa6, 0xf9, 0x3c, 0xd2, 0xf6, 0x6c, 0x87, 0x6c, 0x8d, 0x85, 0x88,
499 0xd2, 0x24, 0x44, 0x70, 0x6e, 0x93, 0x01, 0xd6, 0xed, 0x1a, 0x2a, 0xa5, 0xab, 0x5b, 0x95, 0xca,
500 0xb2, 0x9a, 0xe3, 0x2c, 0x17, 0x6d, 0x07, 0x27, 0x54, 0xdd, 0xf6, 0x03, 0x9c, 0xa3, 0x09, 0x55,
501 0xb7, 0x79, 0x78, 0xcf, 0xc2, 0x84, 0x61, 0xd0, 0x77, 0x36, 0x0d, 0x8d, 0x9d, 0xb1, 0xdc, 0xa2,
502 0x1c, 0x08, 0x96, 0x61, 0xac, 0x50, 0x03, 0x96, 0xe3, 0xae, 0xf2, 0x00, 0xdc, 0xd0, 0x09, 0x96,
503 0x08, 0x1c, 0xef, 0x7a, 0xcb, 0x30, 0xf4, 0x2c, 0x4c, 0xb4, 0x0e, 0xba, 0x81, 0x4a, 0x60, 0xc4,
504 0xd6, 0x41, 0x18, 0x76, 0x3f, 0x4c, 0xb6, 0xf6, 0x5b, 0xdd, 0xb8, 0x53, 0x22, 0x4e, 0x69, 0xed,
505 0xb7, 0xc2, 0xc0, 0xdb, 0xc8, 0x81, 0xdb, 0x41, 0x86, 0xee, 0xa1, 0x5a, 0xf1, 0x46, 0xd1, 0x5c,
506 0xe8, 0x50, 0xe6, 0x41, 0x36, 0x0c, 0x0d, 0x59, 0xfa, 0x6e, 0x03, 0x69, 0xba, 0x83, 0x2c, 0xdd,
507 0x2d, 0x1e, 0x17, 0x8d, 0x0b, 0x86, 0x51, 0x21, 0xbd, 0x65, 0xd2, 0xa9, 0x9c, 0x82, 0x71, 0x7b,
508 0xf7, 0x19, 0x83, 0xa6, 0xa4, 0xd6, 0x72, 0xd0, 0x9e, 0xf9, 0x5c, 0xf1, 0x56, 0x12, 0xdf, 0x31,
509 0xdc, 0x41, 0x12, 0x72, 0x8b, 0x34, 0x2b, 0x77, 0x82, 0x6c, 0xb8, 0xfb, 0xba, 0xd3, 0x22, 0x35,
510 0xd9, 0x6d, 0xe9, 0x06, 0x2a, 0xde, 0x46, 0x4d, 0x69, 0xfb, 0x06, 0x6f, 0xc6, 0x4b, 0xc2, 0xbd,
511 0x6a, 0xee, 0x79, 0x9c, 0xf1, 0x0e, 0xba, 0x24, 0x48, 0x1b, 0x63, 0x9b, 0x05, 0x19, 0x87, 0x22,
512 0x30, 0xf0, 0x2c, 0x31, 0x2b, 0xb4, 0xf6, 0x5b, 0xe2, 0xb8, 0xb7, 0xc0, 0x28, 0xb6, 0xec, 0x0c,
513 0x7a, 0x27, 0x15, 0x64, 0xad, 0x7d, 0x61, 0xc4, 0x33, 0x70, 0x0c, 0x1b, 0x35, 0x91, 0xa7, 0xd7,
514 0x74, 0x4f, 0x17, 0xac, 0xef, 0x22, 0xd6, 0x38, 0xee, 0xeb, 0xac, 0x33, 0xe0, 0xa7, 0xd3, 0xde,
515 0x3d, 0xf0, 0x33, 0xeb, 0x6e, 0xea, 0x27, 0x6e, 0xe3, 0xb9, 0xf5, 0x91, 0x89, 0xee, 0x99, 0x12,
516 0xe4, 0xc5, 0xc4, 0x57, 0xb2, 0x40, 0x53, 0x5f, 0x96, 0xb0, 0x0a, 0x5a, 0xda, 0x5c, 0xc6, 0xfa,
517 0xe5, 0xa9, 0x8a, 0x9c, 0xc0, 0x3a, 0x6a, 0x6d, 0x75, 0xbb, 0xa2, 0xa9, 0x3b, 0x1b, 0xdb, 0xab,
518 0xeb, 0x15, 0x39, 0x29, 0x0a, 0xf6, 0xef, 0x26, 0xa0, 0x10, 0x3c, 0x7b, 0x29, 0x9f, 0x81, 0x1b,
519 0xf9, 0x45, 0x89, 0x8b, 0x3c, 0xed, 0xaa, 0xe9, 0x90, 0xb5, 0xd8, 0xd4, 0xe9, 0xbe, 0xe8, 0x67,
520 0xc3, 0x24, 0xb3, 0xaa, 0x22, 0xef, 0x71, 0xd3, 0xc1, 0x2b, 0xad, 0xa9, 0x7b, 0xca, 0x1a, 0x1c,
521 0xb7, 0x6c, 0xcd, 0xf5, 0x74, 0xab, 0xa6, 0x3b, 0x35, 0xad, 0x73, 0x45, 0xa5, 0xe9, 0x86, 0x81,
522 0x5c, 0xd7, 0xa6, 0x7b, 0xa0, 0xcf, 0xf2, 0x69, 0xcb, 0xae, 0x32, 0xe3, 0xce, 0xe6, 0x50, 0x66,
523 0xa6, 0xa1, 0xcc, 0x4d, 0xf6, 0xca, 0xdc, 0x4f, 0x41, 0xb6, 0xa9, 0xb7, 0x34, 0x64, 0x79, 0xce,
524 0x01, 0x51, 0xdc, 0x19, 0x35, 0xd3, 0xd4, 0x5b, 0x15, 0xfc, 0xfc, 0xf1, 0x1c, 0x7c, 0x7e, 0x94,
525 0x84, 0xbc, 0xa8, 0xba, 0xf1, 0x21, 0xc6, 0x20, 0x1b, 0x94, 0x44, 0x4a, 0xd8, 0x2d, 0x7d, 0x35,
526 0xfa, 0xdc, 0x12, 0xde, 0xb9, 0x4a, 0xc3, 0x54, 0x0b, 0xab, 0x14, 0x89, 0x55, 0x03, 0x4e, 0x2d,
527 0x44, 0xb5, 0x47, 0x46, 0x65, 0x4f, 0xca, 0x0a, 0x0c, 0x3f, 0xe3, 0x12, 0xee, 0x61, 0xc2, 0x7d,
528 0x6b, 0x7f, 0xee, 0x47, 0xaa, 0x84, 0x3c, 0xfb, 0x48, 0x55, 0xdb, 0xd8, 0x54, 0xd7, 0xcb, 0x6b,
529 0x2a, 0x83, 0x2b, 0x37, 0x41, 0xaa, 0xa1, 0x3f, 0x7f, 0x10, 0xdc, 0xe3, 0x48, 0xd3, 0xa0, 0x81,
530 0xbf, 0x09, 0x52, 0x57, 0x91, 0x7e, 0x39, 0xb8, 0xb3, 0x90, 0xa6, 0x8f, 0x30, 0xf5, 0xe7, 0x21,
531 0x4d, 0xe2, 0xa5, 0x00, 0xb0, 0x88, 0xc9, 0x43, 0x4a, 0x06, 0x52, 0x4b, 0x9b, 0x2a, 0x4e, 0x7f,
532 0x19, 0xf2, 0xb4, 0x55, 0xdb, 0x5a, 0xad, 0x2c, 0x55, 0xe4, 0xc4, 0xcc, 0x59, 0x18, 0xa6, 0x41,
533 0xc0, 0x4b, 0xc3, 0x0f, 0x83, 0x3c, 0xc4, 0x1e, 0x19, 0x87, 0xc4, 0x7b, 0x77, 0xd6, 0x17, 0x2b,
534 0xaa, 0x9c, 0x10, 0xa7, 0xd7, 0x85, 0xbc, 0x28, 0xb8, 0x3f, 0x9e, 0x9c, 0xfa, 0xb6, 0x04, 0x39,
535 0x41, 0x40, 0x63, 0xe5, 0xa3, 0x37, 0x1a, 0xf6, 0x55, 0x4d, 0x6f, 0x98, 0xba, 0xcb, 0x92, 0x02,
536 0x48, 0x53, 0x19, 0xb7, 0x0c, 0x3a, 0x69, 0x1f, 0x8b, 0xf3, 0xaf, 0x48, 0x20, 0x87, 0xb5, 0x6b,
537 0xc8, 0x41, 0xe9, 0xa7, 0xea, 0xe0, 0xcb, 0x12, 0x14, 0x82, 0x82, 0x35, 0xe4, 0xde, 0xc9, 0x9f,
538 0xaa, 0x7b, 0x6f, 0x26, 0x60, 0x34, 0x20, 0x53, 0x07, 0xf5, 0xee, 0x59, 0x18, 0x37, 0x6b, 0xa8,
539 0xd9, 0xb2, 0x3d, 0x64, 0x19, 0x07, 0x5a, 0x03, 0x5d, 0x41, 0x8d, 0xe2, 0x0c, 0x29, 0x14, 0xf3,
540 0xfd, 0x85, 0xf0, 0xdc, 0x6a, 0x07, 0xb7, 0x86, 0x61, 0xa5, 0x89, 0xd5, 0xe5, 0xca, 0xfa, 0xd6,
541 0xe6, 0x76, 0x65, 0x63, 0xe9, 0x49, 0x6d, 0x67, 0xe3, 0xd1, 0x8d, 0xcd, 0xc7, 0x37, 0x54, 0xd9,
542 0x0c, 0x99, 0x7d, 0x84, 0x4b, 0x7d, 0x0b, 0xe4, 0xb0, 0x53, 0xca, 0x8d, 0x10, 0xe5, 0x96, 0x3c,
543 0xa4, 0x4c, 0xc0, 0xd8, 0xc6, 0xa6, 0x56, 0x5d, 0x5d, 0xae, 0x68, 0x95, 0x8b, 0x17, 0x2b, 0x4b,
544 0xdb, 0x55, 0x7a, 0xb5, 0xe1, 0x5b, 0x6f, 0x07, 0x17, 0xf5, 0x4b, 0x49, 0x98, 0x88, 0xf0, 0x44,
545 0x29, 0xb3, 0x43, 0x09, 0x3d, 0x27, 0xdd, 0x3d, 0x88, 0xf7, 0x73, 0x58, 0x15, 0x6c, 0xe9, 0x8e,
546 0xc7, 0xce, 0x30, 0x77, 0x02, 0x8e, 0x92, 0xe5, 0x99, 0x7b, 0x26, 0x72, 0xd8, 0x4d, 0x10, 0x3d,
547 0xa9, 0x8c, 0x75, 0xda, 0xe9, 0x65, 0xd0, 0x5d, 0xa0, 0xb4, 0x6c, 0xd7, 0xf4, 0xcc, 0x2b, 0x48,
548 0x33, 0x2d, 0x7e, 0x6d, 0x84, 0x4f, 0x2e, 0x29, 0x55, 0xe6, 0x3d, 0xab, 0x96, 0xe7, 0x5b, 0x5b,
549 0xa8, 0xae, 0x87, 0xac, 0x71, 0x01, 0x4f, 0xaa, 0x32, 0xef, 0xf1, 0xad, 0x4f, 0x42, 0xbe, 0x66,
550 0xb7, 0xb1, 0x9c, 0xa3, 0x76, 0x78, 0xbf, 0x90, 0xd4, 0x1c, 0x6d, 0xf3, 0x4d, 0x98, 0x50, 0xef,
551 0xdc, 0x57, 0xe5, 0xd5, 0x1c, 0x6d, 0xa3, 0x26, 0x77, 0xc0, 0x98, 0x5e, 0xaf, 0x3b, 0x98, 0x9c,
552 0x13, 0xd1, 0xa3, 0x47, 0xc1, 0x6f, 0x26, 0x86, 0x53, 0x8f, 0x40, 0x86, 0xc7, 0x01, 0x6f, 0xc9,
553 0x38, 0x12, 0x5a, 0x8b, 0x9e, 0xa7, 0x13, 0xb3, 0x59, 0x35, 0x63, 0xf1, 0xce, 0x93, 0x90, 0x37,
554 0x5d, 0xad, 0x73, 0xfd, 0x9e, 0x38, 0x91, 0x98, 0xcd, 0xa8, 0x39, 0xd3, 0xf5, 0xaf, 0x2e, 0x67,
555 0x5e, 0x4b, 0x40, 0x21, 0xf8, 0xf9, 0x40, 0x59, 0x86, 0x4c, 0xc3, 0x36, 0x74, 0x92, 0x5a, 0xf4,
556 0xdb, 0xd5, 0x6c, 0xcc, 0x17, 0x87, 0xb9, 0x35, 0x66, 0xaf, 0xfa, 0xc8, 0xa9, 0x7f, 0x91, 0x20,
557 0xc3, 0x9b, 0x95, 0x63, 0x90, 0x6a, 0xe9, 0xde, 0x3e, 0xa1, 0x4b, 0x2f, 0x26, 0x64, 0x49, 0x25,
558 0xcf, 0xb8, 0xdd, 0x6d, 0xe9, 0x16, 0x49, 0x01, 0xd6, 0x8e, 0x9f, 0xf1, 0xbc, 0x36, 0x90, 0x5e,
559 0x23, 0xe7, 0x1a, 0xbb, 0xd9, 0x44, 0x96, 0xe7, 0xf2, 0x79, 0x65, 0xed, 0x4b, 0xac, 0x59, 0x39,
560 0x0d, 0xe3, 0x9e, 0xa3, 0x9b, 0x8d, 0x80, 0x6d, 0x8a, 0xd8, 0xca, 0xbc, 0xc3, 0x37, 0x2e, 0xc1,
561 0x4d, 0x9c, 0xb7, 0x86, 0x3c, 0xdd, 0xd8, 0x47, 0xb5, 0x0e, 0x68, 0x98, 0xdc, 0x5f, 0xdc, 0xc8,
562 0x0c, 0x96, 0x59, 0x3f, 0xc7, 0xce, 0x7c, 0x5f, 0x82, 0x71, 0x7e, 0x12, 0xab, 0xf9, 0xc1, 0x5a,
563 0x07, 0xd0, 0x2d, 0xcb, 0xf6, 0xc4, 0x70, 0x75, 0xa7, 0x72, 0x17, 0x6e, 0xae, 0xec, 0x83, 0x54,
564 0x81, 0x60, 0xaa, 0x09, 0xd0, 0xe9, 0xe9, 0x19, 0xb6, 0xe3, 0x90, 0x63, 0xdf, 0x86, 0xc8, 0x07,
565 0x46, 0x7a, 0x76, 0x07, 0xda, 0x84, 0x8f, 0x6c, 0xca, 0x24, 0xa4, 0x77, 0x51, 0xdd, 0xb4, 0xd8,
566 0x8d, 0x2f, 0x7d, 0xe0, 0x37, 0x2c, 0x29, 0xff, 0x86, 0x65, 0xf1, 0x73, 0x30, 0x61, 0xd8, 0xcd,
567 0xb0, 0xbb, 0x8b, 0x72, 0xe8, 0xfe, 0xc0, 0xbd, 0x24, 0x3d, 0x05, 0x1d, 0x89, 0xf9, 0xbe, 0x24,
568 0x7d, 0x29, 0x91, 0x5c, 0xd9, 0x5a, 0xfc, 0x6a, 0x62, 0x6a, 0x85, 0x42, 0xb7, 0xf8, 0x9b, 0xaa,
569 0x68, 0xaf, 0x81, 0x0c, 0xec, 0x3d, 0x7c, 0xf9, 0x34, 0xdc, 0x5d, 0x37, 0xbd, 0xfd, 0xf6, 0xee,
570 0x9c, 0x61, 0x37, 0xe7, 0xeb, 0x76, 0xdd, 0xee, 0x7c, 0x53, 0xc5, 0x4f, 0xe4, 0x81, 0xfc, 0xc5,
571 0xbe, 0xab, 0x66, 0xfd, 0xd6, 0xa9, 0xd8, 0x8f, 0xb0, 0xa5, 0x0d, 0x98, 0x60, 0xc6, 0x1a, 0xf9,
572 0xb0, 0x43, 0x8f, 0x27, 0x4a, 0xdf, 0xcb, 0xb1, 0xe2, 0xd7, 0xdf, 0x22, 0xdb, 0xb5, 0x3a, 0xce,
573 0xa0, 0xb8, 0x8f, 0x9e, 0x60, 0x4a, 0x2a, 0xdc, 0x10, 0xe0, 0xa3, 0x4b, 0x13, 0x39, 0x31, 0x8c,
574 0xdf, 0x65, 0x8c, 0x13, 0x02, 0x63, 0x95, 0x41, 0x4b, 0x4b, 0x30, 0x7a, 0x14, 0xae, 0x7f, 0x64,
575 0x5c, 0x79, 0x24, 0x92, 0xac, 0xc0, 0x18, 0x21, 0x31, 0xda, 0xae, 0x67, 0x37, 0x49, 0xdd, 0xeb,
576 0x4f, 0xf3, 0x4f, 0x6f, 0xd1, 0xb5, 0x52, 0xc0, 0xb0, 0x25, 0x1f, 0x55, 0x2a, 0x01, 0xf9, 0x96,
577 0x55, 0x43, 0x46, 0x23, 0x86, 0xe1, 0x75, 0xe6, 0x88, 0x6f, 0x5f, 0x7a, 0x0c, 0x26, 0xf1, 0xdf,
578 0xa4, 0x2c, 0x89, 0x9e, 0xc4, 0xdf, 0xa4, 0x15, 0xbf, 0xff, 0x02, 0x5d, 0x8e, 0x13, 0x3e, 0x81,
579 0xe0, 0x93, 0x30, 0x8b, 0x75, 0xe4, 0x79, 0xc8, 0x71, 0x35, 0xbd, 0x11, 0xe5, 0x9e, 0x70, 0x15,
580 0x51, 0xfc, 0xc2, 0x3b, 0xc1, 0x59, 0x5c, 0xa1, 0xc8, 0x72, 0xa3, 0x51, 0xda, 0x81, 0x1b, 0x23,
581 0xb2, 0x62, 0x00, 0xce, 0x97, 0x18, 0xe7, 0x64, 0x57, 0x66, 0x60, 0xda, 0x2d, 0xe0, 0xed, 0xfe,
582 0x5c, 0x0e, 0xc0, 0xf9, 0x07, 0x8c, 0x53, 0x61, 0x58, 0x3e, 0xa5, 0x98, 0xf1, 0x11, 0x18, 0xbf,
583 0x82, 0x9c, 0x5d, 0xdb, 0x65, 0xd7, 0x3f, 0x03, 0xd0, 0xbd, 0xcc, 0xe8, 0xc6, 0x18, 0x90, 0xdc,
584 0x07, 0x61, 0xae, 0x07, 0x20, 0xb3, 0xa7, 0x1b, 0x68, 0x00, 0x8a, 0x2f, 0x32, 0x8a, 0x11, 0x6c,
585 0x8f, 0xa1, 0x65, 0xc8, 0xd7, 0x6d, 0xb6, 0x33, 0xc5, 0xc3, 0x5f, 0x61, 0xf0, 0x1c, 0xc7, 0x30,
586 0x8a, 0x96, 0xdd, 0x6a, 0x37, 0xf0, 0xb6, 0x15, 0x4f, 0xf1, 0x87, 0x9c, 0x82, 0x63, 0x18, 0xc5,
587 0x11, 0xc2, 0xfa, 0x47, 0x9c, 0xc2, 0x15, 0xe2, 0xf9, 0x30, 0xe4, 0x6c, 0xab, 0x71, 0x60, 0x5b,
588 0x83, 0x38, 0xf1, 0x2a, 0x63, 0x00, 0x06, 0xc1, 0x04, 0x17, 0x20, 0x3b, 0xe8, 0x44, 0xfc, 0xc9,
589 0x3b, 0x7c, 0x79, 0xf0, 0x19, 0x58, 0x81, 0x31, 0x5e, 0xa0, 0x4c, 0xdb, 0x1a, 0x80, 0xe2, 0xcb,
590 0x8c, 0xa2, 0x20, 0xc0, 0xd8, 0x6b, 0x78, 0xc8, 0xf5, 0xea, 0x68, 0x10, 0x92, 0xd7, 0xf8, 0x6b,
591 0x30, 0x08, 0x0b, 0xe5, 0x2e, 0xb2, 0x8c, 0xfd, 0xc1, 0x18, 0xbe, 0xc2, 0x43, 0xc9, 0x31, 0x98,
592 0x62, 0x09, 0x46, 0x9b, 0xba, 0xe3, 0xee, 0xeb, 0x8d, 0x81, 0xa6, 0xe3, 0x4f, 0x19, 0x47, 0xde,
593 0x07, 0xb1, 0x88, 0xb4, 0xad, 0xa3, 0xd0, 0x7c, 0x95, 0x47, 0x44, 0x80, 0xb1, 0xa5, 0xe7, 0x7a,
594 0xe4, 0xae, 0xec, 0x28, 0x6c, 0x7f, 0xc6, 0x97, 0x1e, 0xc5, 0xae, 0x8b, 0x8c, 0x17, 0x20, 0xeb,
595 0x9a, 0xcf, 0x0f, 0x44, 0xf3, 0xe7, 0x7c, 0xa6, 0x09, 0x00, 0x83, 0x9f, 0x84, 0x9b, 0x22, 0xb7,
596 0x89, 0x01, 0xc8, 0xfe, 0x82, 0x91, 0x1d, 0x8b, 0xd8, 0x2a, 0x58, 0x49, 0x38, 0x2a, 0xe5, 0x5f,
597 0xf2, 0x92, 0x80, 0x42, 0x5c, 0x5b, 0xf8, 0xac, 0xe0, 0xea, 0x7b, 0x47, 0x8b, 0xda, 0x5f, 0xf1,
598 0xa8, 0x51, 0x6c, 0x20, 0x6a, 0xdb, 0x70, 0x8c, 0x31, 0x1e, 0x6d, 0x5e, 0xbf, 0xc6, 0x0b, 0x2b,
599 0x45, 0xef, 0x04, 0x67, 0xf7, 0x73, 0x30, 0xe5, 0x87, 0x93, 0x8b, 0x52, 0x57, 0x6b, 0xea, 0xad,
600 0x01, 0x98, 0xbf, 0xce, 0x98, 0x79, 0xc5, 0xf7, 0x55, 0xad, 0xbb, 0xae, 0xb7, 0x30, 0xf9, 0x13,
601 0x50, 0xe4, 0xe4, 0x6d, 0xcb, 0x41, 0x86, 0x5d, 0xb7, 0xcc, 0xe7, 0x51, 0x6d, 0x00, 0xea, 0xbf,
602 0x0e, 0x4d, 0xd5, 0x8e, 0x00, 0xc7, 0xcc, 0xab, 0x20, 0xfb, 0x5a, 0x45, 0x33, 0x9b, 0x2d, 0xdb,
603 0xf1, 0x62, 0x18, 0xff, 0x86, 0xcf, 0x94, 0x8f, 0x5b, 0x25, 0xb0, 0x52, 0x05, 0x0a, 0xe4, 0x71,
604 0xd0, 0x94, 0xfc, 0x5b, 0x46, 0x34, 0xda, 0x41, 0xb1, 0xc2, 0x61, 0xd8, 0xcd, 0x96, 0xee, 0x0c,
605 0x52, 0xff, 0xfe, 0x8e, 0x17, 0x0e, 0x06, 0x61, 0x85, 0xc3, 0x3b, 0x68, 0x21, 0xbc, 0xdb, 0x0f,
606 0xc0, 0xf0, 0x0d, 0x5e, 0x38, 0x38, 0x86, 0x51, 0x70, 0xc1, 0x30, 0x00, 0xc5, 0xdf, 0x73, 0x0a,
607 0x8e, 0xc1, 0x14, 0x9f, 0xed, 0x6c, 0xb4, 0x0e, 0xaa, 0x9b, 0xae, 0xe7, 0x50, 0x29, 0xdc, 0x9f,
608 0xea, 0x9b, 0xef, 0x04, 0x45, 0x98, 0x2a, 0x40, 0x71, 0x25, 0x62, 0x57, 0xa8, 0xe4, 0xa4, 0x14,
609 0xef, 0xd8, 0xb7, 0x78, 0x25, 0x12, 0x60, 0xd8, 0x37, 0x41, 0x21, 0xe2, 0xb0, 0x1b, 0xf8, 0x7c,
610 0x30, 0x00, 0xdd, 0xb7, 0x43, 0xce, 0x55, 0x39, 0x16, 0x73, 0x0a, 0xfa, 0xa7, 0x6d, 0x5d, 0x46,
611 0x07, 0x03, 0x65, 0xe7, 0x3f, 0x84, 0xf4, 0xcf, 0x0e, 0x45, 0xd2, 0x1a, 0x32, 0x16, 0xd2, 0x53,
612 0x4a, 0xdc, 0xaf, 0x80, 0x8a, 0xbf, 0xf0, 0x1e, 0x7b, 0xdf, 0xa0, 0x9c, 0x2a, 0xad, 0xe1, 0x24,
613 0x0f, 0x8a, 0x9e, 0x78, 0xb2, 0x17, 0xde, 0xf3, 0xf3, 0x3c, 0xa0, 0x79, 0x4a, 0x17, 0x61, 0x34,
614 0x20, 0x78, 0xe2, 0xa9, 0x7e, 0x91, 0x51, 0xe5, 0x45, 0xbd, 0x53, 0x3a, 0x0b, 0x29, 0x2c, 0x5e,
615 0xe2, 0xe1, 0xbf, 0xc4, 0xe0, 0xc4, 0xbc, 0xf4, 0x20, 0x64, 0xb8, 0x68, 0x89, 0x87, 0xfe, 0x32,
616 0x83, 0xfa, 0x10, 0x0c, 0xe7, 0x82, 0x25, 0x1e, 0xfe, 0x2b, 0x1c, 0xce, 0x21, 0x18, 0x3e, 0x78,
617 0x08, 0xbf, 0xf3, 0xab, 0x29, 0xb6, 0xe9, 0xf0, 0xd8, 0x5d, 0x80, 0x11, 0xa6, 0x54, 0xe2, 0xd1,
618 0x9f, 0x67, 0x83, 0x73, 0x44, 0xe9, 0x7e, 0x48, 0x0f, 0x18, 0xf0, 0x5f, 0x67, 0x50, 0x6a, 0x5f,
619 0x5a, 0x82, 0x9c, 0xa0, 0x4e, 0xe2, 0xe1, 0xbf, 0xc1, 0xe0, 0x22, 0x0a, 0xbb, 0xce, 0xd4, 0x49,
620 0x3c, 0xc1, 0x6f, 0x72, 0xd7, 0x19, 0x02, 0x87, 0x8d, 0x0b, 0x93, 0x78, 0xf4, 0x6f, 0xf1, 0xa8,
621 0x73, 0x48, 0xe9, 0x61, 0xc8, 0xfa, 0x9b, 0x4d, 0x3c, 0xfe, 0xb7, 0x19, 0xbe, 0x83, 0xc1, 0x11,
622 0x10, 0x36, 0xbb, 0x78, 0x8a, 0xdf, 0xe1, 0x11, 0x10, 0x50, 0x78, 0x19, 0x85, 0x05, 0x4c, 0x3c,
623 0xd3, 0xef, 0xf2, 0x65, 0x14, 0xd2, 0x2f, 0x78, 0x36, 0x49, 0xcd, 0x8f, 0xa7, 0xf8, 0x3d, 0x3e,
624 0x9b, 0xc4, 0x1e, 0xbb, 0x11, 0x56, 0x04, 0xf1, 0x1c, 0xbf, 0xcf, 0xdd, 0x08, 0x09, 0x82, 0xd2,
625 0x16, 0x28, 0xdd, 0x6a, 0x20, 0x9e, 0xef, 0x45, 0xc6, 0x37, 0xde, 0x25, 0x06, 0x4a, 0x8f, 0xc3,
626 0xb1, 0x68, 0x25, 0x10, 0xcf, 0xfa, 0x85, 0xf7, 0x42, 0x67, 0x37, 0x51, 0x08, 0x94, 0xb6, 0x3b,
627 0x5b, 0x8a, 0xa8, 0x02, 0xe2, 0x69, 0x5f, 0x7a, 0x2f, 0x58, 0xb8, 0x45, 0x11, 0x50, 0x2a, 0x03,
628 0x74, 0x36, 0xe0, 0x78, 0xae, 0x97, 0x19, 0x97, 0x00, 0xc2, 0x4b, 0x83, 0xed, 0xbf, 0xf1, 0xf8,
629 0x2f, 0xf2, 0xa5, 0xc1, 0x10, 0x78, 0x69, 0xf0, 0xad, 0x37, 0x1e, 0xfd, 0x0a, 0x5f, 0x1a, 0x1c,
630 0x82, 0x33, 0x5b, 0xd8, 0xdd, 0xe2, 0x19, 0x5e, 0xe5, 0x99, 0x2d, 0xa0, 0x4a, 0x1b, 0x30, 0xde,
631 0xb5, 0x21, 0xc6, 0x53, 0x7d, 0x89, 0x51, 0xc9, 0xe1, 0xfd, 0x50, 0xdc, 0xbc, 0xd8, 0x66, 0x18,
632 0xcf, 0xf6, 0xc7, 0xa1, 0xcd, 0x8b, 0xed, 0x85, 0xa5, 0x0b, 0x90, 0xb1, 0xda, 0x8d, 0x06, 0x5e,
633 0x3c, 0x4a, 0xff, 0x5f, 0xee, 0x15, 0xff, 0xed, 0x03, 0x16, 0x1d, 0x0e, 0x28, 0x9d, 0x85, 0x34,
634 0x6a, 0xee, 0xa2, 0x5a, 0x1c, 0xf2, 0xdf, 0x3f, 0xe0, 0x05, 0x13, 0x5b, 0x97, 0x1e, 0x06, 0xa0,
635 0x57, 0x23, 0xe4, 0xb3, 0x5f, 0x0c, 0xf6, 0x3f, 0x3e, 0x60, 0xbf, 0xa9, 0xe9, 0x40, 0x3a, 0x04,
636 0xf4, 0x17, 0x3a, 0xfd, 0x09, 0xde, 0x09, 0x12, 0x90, 0x19, 0x79, 0x00, 0x46, 0x9e, 0x71, 0x6d,
637 0xcb, 0xd3, 0xeb, 0x71, 0xe8, 0xff, 0x64, 0x68, 0x6e, 0x8f, 0x03, 0xd6, 0xb4, 0x1d, 0xe4, 0xe9,
638 0x75, 0x37, 0x0e, 0xfb, 0x5f, 0x0c, 0xeb, 0x03, 0x30, 0xd8, 0xd0, 0x5d, 0x6f, 0x90, 0xf7, 0xfe,
639 0x6f, 0x0e, 0xe6, 0x00, 0xec, 0x34, 0xfe, 0xfb, 0x32, 0x3a, 0x88, 0xc3, 0xbe, 0xcb, 0x9d, 0x66,
640 0xf6, 0xa5, 0x07, 0x21, 0x8b, 0xff, 0xa4, 0x3f, 0x94, 0x8b, 0x01, 0xff, 0x0f, 0x03, 0x77, 0x10,
641 0x78, 0x64, 0xd7, 0xab, 0x79, 0x66, 0x7c, 0xb0, 0x7f, 0xc2, 0x66, 0x9a, 0xdb, 0x97, 0xca, 0x90,
642 0x73, 0xbd, 0x5a, 0xad, 0xcd, 0xf4, 0x69, 0x0c, 0xfc, 0x7f, 0x3f, 0xf0, 0xaf, 0x2c, 0x7c, 0x0c,
643 0x9e, 0xed, 0xab, 0x97, 0xbd, 0x96, 0x4d, 0x3e, 0x73, 0xc4, 0x31, 0xbc, 0xc7, 0x18, 0x04, 0xc8,
644 0x62, 0x25, 0xfa, 0xfa, 0x16, 0x56, 0xec, 0x15, 0x9b, 0x5e, 0xdc, 0x3e, 0x35, 0x13, 0x7f, 0x03,
645 0x0b, 0x3f, 0xb9, 0x1b, 0x3e, 0x6d, 0xd8, 0xcd, 0x5d, 0xdb, 0x9d, 0xdf, 0xb5, 0xbd, 0xfd, 0xf9,
646 0xa6, 0xde, 0x72, 0x49, 0xcf, 0x02, 0xbb, 0x97, 0xcd, 0xb1, 0x27, 0xdc, 0x31, 0x75, 0xb4, 0x3b,
647 0xdd, 0x99, 0x9b, 0x61, 0xf4, 0x62, 0xc3, 0xd6, 0x3d, 0xd3, 0xaa, 0x6f, 0x61, 0xb7, 0x95, 0x3c,
648 0x48, 0x7b, 0xe4, 0x9b, 0xa4, 0xa4, 0x4a, 0x7b, 0x33, 0xff, 0x9c, 0x86, 0x2c, 0xbd, 0x0e, 0x5c,
649 0xd7, 0x5b, 0xca, 0xcf, 0x43, 0x7e, 0x83, 0xad, 0xc1, 0x7b, 0x17, 0xce, 0xbb, 0xfe, 0xe7, 0x07,
650 0x61, 0xfc, 0x39, 0xdf, 0x7a, 0x4e, 0x34, 0x25, 0xbf, 0x41, 0x58, 0xbc, 0xe7, 0x87, 0x6f, 0x1c,
651 0xbf, 0xab, 0xa7, 0x7f, 0x58, 0x55, 0xcc, 0xd3, 0xc5, 0x32, 0xb7, 0x63, 0x5a, 0xde, 0xbd, 0x0b,
652 0xe7, 0xd5, 0xc0, 0x78, 0xca, 0x15, 0xc8, 0xb0, 0x0e, 0x97, 0x7d, 0x96, 0xba, 0xb5, 0xc7, 0xd8,
653 0xdc, 0x8c, 0x8e, 0x7b, 0xe6, 0xf5, 0x37, 0x8e, 0x0f, 0x1d, 0x79, 0x6c, 0x7f, 0x2c, 0xe5, 0x59,
654 0xc8, 0x71, 0x3f, 0x56, 0x6b, 0x2e, 0xfb, 0xff, 0x0d, 0x77, 0xc4, 0xbc, 0xf6, 0x6a, 0x8d, 0x8d,
655 0x7e, 0xfb, 0x0f, 0xdf, 0x38, 0x3e, 0xd3, 0x77, 0xe4, 0xb9, 0x9d, 0xb6, 0x59, 0x53, 0xc5, 0x31,
656 0x94, 0xa7, 0x21, 0x89, 0x87, 0xa2, 0x3f, 0x09, 0x3d, 0xde, 0x63, 0x28, 0x7f, 0x88, 0x53, 0xec,
657 0x05, 0x07, 0x19, 0x06, 0xf3, 0x4e, 0x3d, 0x0c, 0xe3, 0x5d, 0xd3, 0xa3, 0xc8, 0x90, 0xbc, 0x8c,
658 0x0e, 0xd8, 0x6f, 0xef, 0xf0, 0x9f, 0xca, 0x64, 0xe7, 0xc7, 0xb1, 0xd2, 0x6c, 0x9e, 0xfd, 0xe2,
659 0xb5, 0x94, 0x38, 0x2f, 0x4d, 0x5d, 0x80, 0xd1, 0x40, 0x8c, 0x8f, 0x04, 0x7e, 0x08, 0xe4, 0x70,
660 0x94, 0x8e, 0x84, 0x3f, 0x07, 0x99, 0x0f, 0x83, 0x9b, 0xf9, 0x81, 0x02, 0x23, 0xe5, 0x46, 0x63,
661 0x5d, 0x6f, 0xb9, 0xca, 0x93, 0x30, 0x4e, 0xcf, 0x3e, 0xdb, 0xf6, 0x32, 0xf9, 0x10, 0xb8, 0xae,
662 0xb7, 0x58, 0x42, 0x9f, 0x0e, 0x84, 0x9b, 0x01, 0xe6, 0xba, 0xac, 0xc9, 0xf8, 0x6a, 0x37, 0x8b,
663 0xf2, 0x18, 0xc8, 0xbc, 0x91, 0xac, 0x2d, 0xcc, 0x4c, 0xd3, 0xf5, 0x54, 0x5f, 0x66, 0x6e, 0x4c,
664 0x89, 0xbb, 0x38, 0x94, 0x87, 0x20, 0xb3, 0x6a, 0x79, 0xf7, 0x2d, 0x60, 0x3e, 0x9a, 0x83, 0x33,
665 0x91, 0x7c, 0xdc, 0x88, 0xf2, 0xf8, 0x18, 0x86, 0x3f, 0x77, 0x06, 0xe3, 0x53, 0xfd, 0xf1, 0xc4,
666 0xa8, 0x83, 0x27, 0x8f, 0x4a, 0x19, 0xb2, 0x78, 0xce, 0xa9, 0x03, 0xf4, 0xbf, 0xd6, 0xdc, 0x12,
667 0x49, 0xe0, 0x5b, 0x51, 0x86, 0x0e, 0x8a, 0x53, 0x50, 0x1f, 0x86, 0x63, 0x28, 0x04, 0x27, 0x3a,
668 0x28, 0x4c, 0x51, 0xf5, 0xbd, 0x18, 0xe9, 0x43, 0x51, 0x0d, 0x79, 0x51, 0x15, 0xbd, 0xa8, 0xfa,
669 0x5e, 0x64, 0x62, 0x28, 0x44, 0x2f, 0xfc, 0x67, 0x65, 0x19, 0xe0, 0xa2, 0xf9, 0x1c, 0xaa, 0x51,
670 0x37, 0xb2, 0x11, 0xc5, 0x88, 0x73, 0x74, 0xcc, 0x28, 0x89, 0x80, 0x53, 0x56, 0x20, 0x57, 0xdd,
671 0xeb, 0xd0, 0x00, 0xfb, 0x9f, 0x45, 0x91, 0xae, 0xec, 0x85, 0x78, 0x44, 0xa4, 0xef, 0x0e, 0x7d,
672 0xa5, 0x5c, 0x9c, 0x3b, 0xc2, 0x3b, 0x09, 0xb8, 0x8e, 0x3b, 0x94, 0x26, 0x1f, 0xeb, 0x8e, 0xc0,
673 0x23, 0x22, 0x95, 0x0b, 0x30, 0xb2, 0x68, 0xdb, 0xd8, 0xb2, 0x38, 0x4a, 0x48, 0x4e, 0x46, 0x92,
674 0x30, 0x1b, 0x4a, 0xc0, 0x11, 0x64, 0x76, 0x48, 0xea, 0x63, 0x78, 0xa1, 0xdf, 0xec, 0x70, 0x2b,
675 0x3e, 0x3b, 0xfc, 0x59, 0x5c, 0x81, 0x8b, 0x07, 0x1e, 0xc2, 0xe7, 0x8c, 0xe2, 0xd8, 0x00, 0x2b,
676 0x90, 0x1b, 0x87, 0x56, 0x20, 0x6f, 0x56, 0xaa, 0x30, 0xc6, 0xdb, 0x2a, 0x56, 0x1b, 0xd7, 0xe0,
677 0xa2, 0xcc, 0xfe, 0xdb, 0x40, 0x3f, 0x5a, 0x66, 0x4b, 0x59, 0xc3, 0x0c, 0xca, 0x16, 0x14, 0x78,
678 0xd3, 0xba, 0x4b, 0x5e, 0x7a, 0x3c, 0x62, 0x5f, 0x0d, 0x73, 0x52, 0x53, 0x4a, 0x19, 0xc2, 0x4f,
679 0x2d, 0xc3, 0xb1, 0xe8, 0x6a, 0x15, 0x57, 0x2d, 0x25, 0xb1, 0xca, 0x2e, 0xc1, 0x0d, 0x91, 0x95,
680 0x29, 0x8e, 0x24, 0x11, 0xda, 0x27, 0x02, 0xe5, 0x48, 0x04, 0xa7, 0x23, 0xc0, 0xe9, 0x6e, 0x70,
681 0x27, 0xc9, 0x44, 0x70, 0x32, 0x02, 0x9c, 0x14, 0xc1, 0x9f, 0x81, 0x42, 0xb0, 0x0e, 0x89, 0xe8,
682 0xd1, 0x08, 0xf4, 0x68, 0x04, 0x3a, 0x7a, 0xec, 0x54, 0x04, 0x3a, 0x15, 0x42, 0x57, 0x7b, 0x8e,
683 0x3d, 0x1e, 0x81, 0x1e, 0x8f, 0x40, 0x47, 0x8f, 0xad, 0x44, 0xa0, 0x15, 0x11, 0xfd, 0x20, 0x8c,
684 0x85, 0x4a, 0x8e, 0x08, 0x1f, 0x89, 0x80, 0x8f, 0x84, 0xf6, 0xe6, 0x70, 0xa9, 0x11, 0xf1, 0x63,
685 0x11, 0xf8, 0xb1, 0xa8, 0xe1, 0xa3, 0xbd, 0x1f, 0x8e, 0x80, 0x0f, 0x47, 0x0e, 0x1f, 0x8d, 0x97,
686 0x23, 0xf0, 0xb2, 0x88, 0x2f, 0x41, 0x5e, 0xac, 0x2a, 0x22, 0x36, 0x13, 0x81, 0xcd, 0x84, 0xe3,
687 0x1e, 0x28, 0x29, 0x71, 0x99, 0x9e, 0xed, 0xb1, 0x5c, 0x02, 0x65, 0xe4, 0x48, 0xca, 0xe6, 0x09,
688 0x98, 0x8c, 0x2a, 0x1a, 0x11, 0x1c, 0xa7, 0x44, 0x8e, 0xc2, 0xc2, 0x64, 0xa0, 0x58, 0x10, 0x5c,
689 0xbb, 0x29, 0x32, 0x3f, 0x0d, 0x13, 0x11, 0xa5, 0x23, 0x82, 0xf8, 0x1e, 0x91, 0x38, 0xb7, 0x30,
690 0x15, 0x20, 0x0e, 0x9c, 0x15, 0x44, 0x69, 0xf5, 0xa3, 0x09, 0x28, 0xb0, 0x12, 0xb5, 0xe9, 0xd4,
691 0x90, 0x83, 0x6a, 0xca, 0xcf, 0xf6, 0x56, 0x58, 0x0b, 0x51, 0xa5, 0x8d, 0xe1, 0x8e, 0x20, 0xb4,
692 0x9e, 0xee, 0x29, 0xb4, 0xee, 0x1d, 0x64, 0x80, 0x38, 0xbd, 0x55, 0xe9, 0xd2, 0x5b, 0x77, 0xf6,
693 0xa3, 0xed, 0x25, 0xbb, 0x2a, 0x5d, 0xb2, 0x2b, 0x8e, 0x26, 0x52, 0x7d, 0x5d, 0xea, 0x56, 0x5f,
694 0xa7, 0xfa, 0xf1, 0xf4, 0x16, 0x61, 0x97, 0xba, 0x45, 0x58, 0x2c, 0x53, 0xb4, 0x16, 0xbb, 0xd4,
695 0xad, 0xc5, 0xfa, 0x32, 0xf5, 0x96, 0x64, 0x97, 0xba, 0x25, 0x59, 0x2c, 0x53, 0xb4, 0x32, 0x7b,
696 0x34, 0x42, 0x99, 0x9d, 0xee, 0x47, 0xd5, 0x4f, 0xa0, 0x6d, 0x44, 0x09, 0xb4, 0xbb, 0xfa, 0x3a,
697 0xd6, 0x57, 0xa7, 0x3d, 0x1a, 0xa1, 0xd3, 0xe2, 0x9d, 0xeb, 0x21, 0xd7, 0x36, 0xa2, 0xe4, 0xda,
698 0x00, 0xce, 0xf5, 0x52, 0x6d, 0x8b, 0x61, 0xd5, 0x36, 0xdb, 0x8f, 0x2b, 0x5a, 0xbc, 0x5d, 0xea,
699 0x16, 0x6f, 0xa7, 0xe2, 0xd7, 0x62, 0x94, 0x86, 0x7b, 0xba, 0xa7, 0x86, 0x1b, 0x68, 0x71, 0xc7,
700 0x49, 0xb9, 0xa7, 0x7a, 0x49, 0xb9, 0x7b, 0x06, 0x61, 0xef, 0xaf, 0xe8, 0x1e, 0xef, 0xa1, 0xe8,
701 0xe6, 0x07, 0xa1, 0xfe, 0x44, 0xd8, 0x7d, 0x22, 0xec, 0x3e, 0x11, 0x76, 0x9f, 0x08, 0xbb, 0xff,
702 0x1f, 0xc2, 0xae, 0x94, 0x7a, 0xf1, 0xd5, 0xe3, 0xd2, 0xa9, 0x93, 0x30, 0xc2, 0x86, 0x56, 0x86,
703 0x21, 0xb1, 0x5e, 0x96, 0x87, 0xc8, 0xbf, 0x8b, 0xb2, 0x44, 0xfe, 0x5d, 0x92, 0x13, 0x8b, 0x6b,
704 0xaf, 0x5f, 0x9f, 0x1e, 0xfa, 0xde, 0xf5, 0xe9, 0xa1, 0x1f, 0x5c, 0x9f, 0x1e, 0x7a, 0xf3, 0xfa,
705 0xb4, 0xf4, 0xf6, 0xf5, 0x69, 0xe9, 0xdd, 0xeb, 0xd3, 0xd2, 0xfb, 0xd7, 0xa7, 0xa5, 0x6b, 0x87,
706 0xd3, 0xd2, 0x57, 0x0e, 0xa7, 0xa5, 0xaf, 0x1d, 0x4e, 0x4b, 0xdf, 0x3c, 0x9c, 0x96, 0xbe, 0x73,
707 0x38, 0x2d, 0xbd, 0x7e, 0x38, 0x2d, 0x7d, 0xef, 0x70, 0x5a, 0x7a, 0xf3, 0x70, 0x5a, 0x7a, 0xfb,
708 0x70, 0x7a, 0xe8, 0xdd, 0xc3, 0x69, 0xe9, 0xfd, 0xc3, 0xe9, 0xa1, 0x6b, 0x3f, 0x9e, 0x1e, 0xfa,
709 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd1, 0x2a, 0xe1, 0x89, 0xe9, 0x49, 0x00, 0x00,
710 }
711 r := bytes.NewReader(gzipped)
712 gzipr, err := compress_gzip.NewReader(r)
713 if err != nil {
714 panic(err)
715 }
716 ungzipped, err := io_ioutil.ReadAll(gzipr)
717 if err != nil {
718 panic(err)
719 }
720 if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
721 panic(err)
722 }
723 return d
724 }
725 func (x MapEnum) String() string {
726 s, ok := MapEnum_name[int32(x)]
727 if ok {
728 return s
729 }
730 return strconv.Itoa(int(x))
731 }
732 func (this *FloatingPoint) VerboseEqual(that interface{}) error {
733 if that == nil {
734 if this == nil {
735 return nil
736 }
737 return fmt.Errorf("that == nil && this != nil")
738 }
739
740 that1, ok := that.(*FloatingPoint)
741 if !ok {
742 that2, ok := that.(FloatingPoint)
743 if ok {
744 that1 = &that2
745 } else {
746 return fmt.Errorf("that is not of type *FloatingPoint")
747 }
748 }
749 if that1 == nil {
750 if this == nil {
751 return nil
752 }
753 return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil")
754 } else if this == nil {
755 return fmt.Errorf("that is type *FloatingPoint but is not nil && this == nil")
756 }
757 if this.F != nil && that1.F != nil {
758 if *this.F != *that1.F {
759 return fmt.Errorf("F this(%v) Not Equal that(%v)", *this.F, *that1.F)
760 }
761 } else if this.F != nil {
762 return fmt.Errorf("this.F == nil && that.F != nil")
763 } else if that1.F != nil {
764 return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F)
765 }
766 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
767 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
768 }
769 return nil
770 }
771 func (this *FloatingPoint) Equal(that interface{}) bool {
772 if that == nil {
773 return this == nil
774 }
775
776 that1, ok := that.(*FloatingPoint)
777 if !ok {
778 that2, ok := that.(FloatingPoint)
779 if ok {
780 that1 = &that2
781 } else {
782 return false
783 }
784 }
785 if that1 == nil {
786 return this == nil
787 } else if this == nil {
788 return false
789 }
790 if this.F != nil && that1.F != nil {
791 if *this.F != *that1.F {
792 return false
793 }
794 } else if this.F != nil {
795 return false
796 } else if that1.F != nil {
797 return false
798 }
799 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
800 return false
801 }
802 return true
803 }
804 func (this *CustomMap) VerboseEqual(that interface{}) error {
805 if that == nil {
806 if this == nil {
807 return nil
808 }
809 return fmt.Errorf("that == nil && this != nil")
810 }
811
812 that1, ok := that.(*CustomMap)
813 if !ok {
814 that2, ok := that.(CustomMap)
815 if ok {
816 that1 = &that2
817 } else {
818 return fmt.Errorf("that is not of type *CustomMap")
819 }
820 }
821 if that1 == nil {
822 if this == nil {
823 return nil
824 }
825 return fmt.Errorf("that is type *CustomMap but is nil && this != nil")
826 } else if this == nil {
827 return fmt.Errorf("that is type *CustomMap but is not nil && this == nil")
828 }
829 if len(this.Nullable128S) != len(that1.Nullable128S) {
830 return fmt.Errorf("Nullable128S this(%v) Not Equal that(%v)", len(this.Nullable128S), len(that1.Nullable128S))
831 }
832 for i := range this.Nullable128S {
833 if !this.Nullable128S[i].Equal(*that1.Nullable128S[i]) {
834 return fmt.Errorf("Nullable128S this[%v](%v) Not Equal that[%v](%v)", i, this.Nullable128S[i], i, that1.Nullable128S[i])
835 }
836 }
837 if len(this.Uint128S) != len(that1.Uint128S) {
838 return fmt.Errorf("Uint128S this(%v) Not Equal that(%v)", len(this.Uint128S), len(that1.Uint128S))
839 }
840 for i := range this.Uint128S {
841 if !this.Uint128S[i].Equal(that1.Uint128S[i]) {
842 return fmt.Errorf("Uint128S this[%v](%v) Not Equal that[%v](%v)", i, this.Uint128S[i], i, that1.Uint128S[i])
843 }
844 }
845 if len(this.NullableIds) != len(that1.NullableIds) {
846 return fmt.Errorf("NullableIds this(%v) Not Equal that(%v)", len(this.NullableIds), len(that1.NullableIds))
847 }
848 for i := range this.NullableIds {
849 if !this.NullableIds[i].Equal(*that1.NullableIds[i]) {
850 return fmt.Errorf("NullableIds this[%v](%v) Not Equal that[%v](%v)", i, this.NullableIds[i], i, that1.NullableIds[i])
851 }
852 }
853 if len(this.Ids) != len(that1.Ids) {
854 return fmt.Errorf("Ids this(%v) Not Equal that(%v)", len(this.Ids), len(that1.Ids))
855 }
856 for i := range this.Ids {
857 if !this.Ids[i].Equal(that1.Ids[i]) {
858 return fmt.Errorf("Ids this[%v](%v) Not Equal that[%v](%v)", i, this.Ids[i], i, that1.Ids[i])
859 }
860 }
861 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
862 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
863 }
864 return nil
865 }
866 func (this *CustomMap) Equal(that interface{}) bool {
867 if that == nil {
868 return this == nil
869 }
870
871 that1, ok := that.(*CustomMap)
872 if !ok {
873 that2, ok := that.(CustomMap)
874 if ok {
875 that1 = &that2
876 } else {
877 return false
878 }
879 }
880 if that1 == nil {
881 return this == nil
882 } else if this == nil {
883 return false
884 }
885 if len(this.Nullable128S) != len(that1.Nullable128S) {
886 return false
887 }
888 for i := range this.Nullable128S {
889 if !this.Nullable128S[i].Equal(*that1.Nullable128S[i]) {
890 return false
891 }
892 }
893 if len(this.Uint128S) != len(that1.Uint128S) {
894 return false
895 }
896 for i := range this.Uint128S {
897 if !this.Uint128S[i].Equal(that1.Uint128S[i]) {
898 return false
899 }
900 }
901 if len(this.NullableIds) != len(that1.NullableIds) {
902 return false
903 }
904 for i := range this.NullableIds {
905 if !this.NullableIds[i].Equal(*that1.NullableIds[i]) {
906 return false
907 }
908 }
909 if len(this.Ids) != len(that1.Ids) {
910 return false
911 }
912 for i := range this.Ids {
913 if !this.Ids[i].Equal(that1.Ids[i]) {
914 return false
915 }
916 }
917 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
918 return false
919 }
920 return true
921 }
922 func (this *AllMaps) VerboseEqual(that interface{}) error {
923 if that == nil {
924 if this == nil {
925 return nil
926 }
927 return fmt.Errorf("that == nil && this != nil")
928 }
929
930 that1, ok := that.(*AllMaps)
931 if !ok {
932 that2, ok := that.(AllMaps)
933 if ok {
934 that1 = &that2
935 } else {
936 return fmt.Errorf("that is not of type *AllMaps")
937 }
938 }
939 if that1 == nil {
940 if this == nil {
941 return nil
942 }
943 return fmt.Errorf("that is type *AllMaps but is nil && this != nil")
944 } else if this == nil {
945 return fmt.Errorf("that is type *AllMaps but is not nil && this == nil")
946 }
947 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
948 return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap))
949 }
950 for i := range this.StringToDoubleMap {
951 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
952 return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i])
953 }
954 }
955 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
956 return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap))
957 }
958 for i := range this.StringToFloatMap {
959 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
960 return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i])
961 }
962 }
963 if len(this.Int32Map) != len(that1.Int32Map) {
964 return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map))
965 }
966 for i := range this.Int32Map {
967 if this.Int32Map[i] != that1.Int32Map[i] {
968 return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i])
969 }
970 }
971 if len(this.Int64Map) != len(that1.Int64Map) {
972 return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map))
973 }
974 for i := range this.Int64Map {
975 if this.Int64Map[i] != that1.Int64Map[i] {
976 return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i])
977 }
978 }
979 if len(this.Uint32Map) != len(that1.Uint32Map) {
980 return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map))
981 }
982 for i := range this.Uint32Map {
983 if this.Uint32Map[i] != that1.Uint32Map[i] {
984 return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i])
985 }
986 }
987 if len(this.Uint64Map) != len(that1.Uint64Map) {
988 return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map))
989 }
990 for i := range this.Uint64Map {
991 if this.Uint64Map[i] != that1.Uint64Map[i] {
992 return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i])
993 }
994 }
995 if len(this.Sint32Map) != len(that1.Sint32Map) {
996 return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map))
997 }
998 for i := range this.Sint32Map {
999 if this.Sint32Map[i] != that1.Sint32Map[i] {
1000 return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i])
1001 }
1002 }
1003 if len(this.Sint64Map) != len(that1.Sint64Map) {
1004 return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map))
1005 }
1006 for i := range this.Sint64Map {
1007 if this.Sint64Map[i] != that1.Sint64Map[i] {
1008 return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i])
1009 }
1010 }
1011 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1012 return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map))
1013 }
1014 for i := range this.Fixed32Map {
1015 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1016 return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i])
1017 }
1018 }
1019 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1020 return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map))
1021 }
1022 for i := range this.Sfixed32Map {
1023 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1024 return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i])
1025 }
1026 }
1027 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1028 return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map))
1029 }
1030 for i := range this.Fixed64Map {
1031 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1032 return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i])
1033 }
1034 }
1035 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1036 return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map))
1037 }
1038 for i := range this.Sfixed64Map {
1039 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1040 return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i])
1041 }
1042 }
1043 if len(this.BoolMap) != len(that1.BoolMap) {
1044 return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap))
1045 }
1046 for i := range this.BoolMap {
1047 if this.BoolMap[i] != that1.BoolMap[i] {
1048 return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i])
1049 }
1050 }
1051 if len(this.StringMap) != len(that1.StringMap) {
1052 return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap))
1053 }
1054 for i := range this.StringMap {
1055 if this.StringMap[i] != that1.StringMap[i] {
1056 return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i])
1057 }
1058 }
1059 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1060 return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap))
1061 }
1062 for i := range this.StringToBytesMap {
1063 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1064 return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i])
1065 }
1066 }
1067 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1068 return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap))
1069 }
1070 for i := range this.StringToEnumMap {
1071 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1072 return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i])
1073 }
1074 }
1075 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1076 return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap))
1077 }
1078 for i := range this.StringToMsgMap {
1079 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1080 return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i])
1081 }
1082 }
1083 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1084 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1085 }
1086 return nil
1087 }
1088 func (this *AllMaps) Equal(that interface{}) bool {
1089 if that == nil {
1090 return this == nil
1091 }
1092
1093 that1, ok := that.(*AllMaps)
1094 if !ok {
1095 that2, ok := that.(AllMaps)
1096 if ok {
1097 that1 = &that2
1098 } else {
1099 return false
1100 }
1101 }
1102 if that1 == nil {
1103 return this == nil
1104 } else if this == nil {
1105 return false
1106 }
1107 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1108 return false
1109 }
1110 for i := range this.StringToDoubleMap {
1111 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1112 return false
1113 }
1114 }
1115 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1116 return false
1117 }
1118 for i := range this.StringToFloatMap {
1119 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1120 return false
1121 }
1122 }
1123 if len(this.Int32Map) != len(that1.Int32Map) {
1124 return false
1125 }
1126 for i := range this.Int32Map {
1127 if this.Int32Map[i] != that1.Int32Map[i] {
1128 return false
1129 }
1130 }
1131 if len(this.Int64Map) != len(that1.Int64Map) {
1132 return false
1133 }
1134 for i := range this.Int64Map {
1135 if this.Int64Map[i] != that1.Int64Map[i] {
1136 return false
1137 }
1138 }
1139 if len(this.Uint32Map) != len(that1.Uint32Map) {
1140 return false
1141 }
1142 for i := range this.Uint32Map {
1143 if this.Uint32Map[i] != that1.Uint32Map[i] {
1144 return false
1145 }
1146 }
1147 if len(this.Uint64Map) != len(that1.Uint64Map) {
1148 return false
1149 }
1150 for i := range this.Uint64Map {
1151 if this.Uint64Map[i] != that1.Uint64Map[i] {
1152 return false
1153 }
1154 }
1155 if len(this.Sint32Map) != len(that1.Sint32Map) {
1156 return false
1157 }
1158 for i := range this.Sint32Map {
1159 if this.Sint32Map[i] != that1.Sint32Map[i] {
1160 return false
1161 }
1162 }
1163 if len(this.Sint64Map) != len(that1.Sint64Map) {
1164 return false
1165 }
1166 for i := range this.Sint64Map {
1167 if this.Sint64Map[i] != that1.Sint64Map[i] {
1168 return false
1169 }
1170 }
1171 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1172 return false
1173 }
1174 for i := range this.Fixed32Map {
1175 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1176 return false
1177 }
1178 }
1179 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1180 return false
1181 }
1182 for i := range this.Sfixed32Map {
1183 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1184 return false
1185 }
1186 }
1187 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1188 return false
1189 }
1190 for i := range this.Fixed64Map {
1191 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1192 return false
1193 }
1194 }
1195 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1196 return false
1197 }
1198 for i := range this.Sfixed64Map {
1199 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1200 return false
1201 }
1202 }
1203 if len(this.BoolMap) != len(that1.BoolMap) {
1204 return false
1205 }
1206 for i := range this.BoolMap {
1207 if this.BoolMap[i] != that1.BoolMap[i] {
1208 return false
1209 }
1210 }
1211 if len(this.StringMap) != len(that1.StringMap) {
1212 return false
1213 }
1214 for i := range this.StringMap {
1215 if this.StringMap[i] != that1.StringMap[i] {
1216 return false
1217 }
1218 }
1219 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1220 return false
1221 }
1222 for i := range this.StringToBytesMap {
1223 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1224 return false
1225 }
1226 }
1227 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1228 return false
1229 }
1230 for i := range this.StringToEnumMap {
1231 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1232 return false
1233 }
1234 }
1235 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1236 return false
1237 }
1238 for i := range this.StringToMsgMap {
1239 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1240 return false
1241 }
1242 }
1243 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1244 return false
1245 }
1246 return true
1247 }
1248 func (this *AllMapsOrdered) VerboseEqual(that interface{}) error {
1249 if that == nil {
1250 if this == nil {
1251 return nil
1252 }
1253 return fmt.Errorf("that == nil && this != nil")
1254 }
1255
1256 that1, ok := that.(*AllMapsOrdered)
1257 if !ok {
1258 that2, ok := that.(AllMapsOrdered)
1259 if ok {
1260 that1 = &that2
1261 } else {
1262 return fmt.Errorf("that is not of type *AllMapsOrdered")
1263 }
1264 }
1265 if that1 == nil {
1266 if this == nil {
1267 return nil
1268 }
1269 return fmt.Errorf("that is type *AllMapsOrdered but is nil && this != nil")
1270 } else if this == nil {
1271 return fmt.Errorf("that is type *AllMapsOrdered but is not nil && this == nil")
1272 }
1273 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1274 return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap))
1275 }
1276 for i := range this.StringToDoubleMap {
1277 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1278 return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i])
1279 }
1280 }
1281 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1282 return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap))
1283 }
1284 for i := range this.StringToFloatMap {
1285 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1286 return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i])
1287 }
1288 }
1289 if len(this.Int32Map) != len(that1.Int32Map) {
1290 return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map))
1291 }
1292 for i := range this.Int32Map {
1293 if this.Int32Map[i] != that1.Int32Map[i] {
1294 return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i])
1295 }
1296 }
1297 if len(this.Int64Map) != len(that1.Int64Map) {
1298 return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map))
1299 }
1300 for i := range this.Int64Map {
1301 if this.Int64Map[i] != that1.Int64Map[i] {
1302 return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i])
1303 }
1304 }
1305 if len(this.Uint32Map) != len(that1.Uint32Map) {
1306 return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map))
1307 }
1308 for i := range this.Uint32Map {
1309 if this.Uint32Map[i] != that1.Uint32Map[i] {
1310 return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i])
1311 }
1312 }
1313 if len(this.Uint64Map) != len(that1.Uint64Map) {
1314 return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map))
1315 }
1316 for i := range this.Uint64Map {
1317 if this.Uint64Map[i] != that1.Uint64Map[i] {
1318 return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i])
1319 }
1320 }
1321 if len(this.Sint32Map) != len(that1.Sint32Map) {
1322 return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map))
1323 }
1324 for i := range this.Sint32Map {
1325 if this.Sint32Map[i] != that1.Sint32Map[i] {
1326 return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i])
1327 }
1328 }
1329 if len(this.Sint64Map) != len(that1.Sint64Map) {
1330 return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map))
1331 }
1332 for i := range this.Sint64Map {
1333 if this.Sint64Map[i] != that1.Sint64Map[i] {
1334 return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i])
1335 }
1336 }
1337 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1338 return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map))
1339 }
1340 for i := range this.Fixed32Map {
1341 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1342 return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i])
1343 }
1344 }
1345 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1346 return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map))
1347 }
1348 for i := range this.Sfixed32Map {
1349 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1350 return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i])
1351 }
1352 }
1353 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1354 return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map))
1355 }
1356 for i := range this.Fixed64Map {
1357 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1358 return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i])
1359 }
1360 }
1361 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1362 return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map))
1363 }
1364 for i := range this.Sfixed64Map {
1365 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1366 return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i])
1367 }
1368 }
1369 if len(this.BoolMap) != len(that1.BoolMap) {
1370 return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap))
1371 }
1372 for i := range this.BoolMap {
1373 if this.BoolMap[i] != that1.BoolMap[i] {
1374 return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i])
1375 }
1376 }
1377 if len(this.StringMap) != len(that1.StringMap) {
1378 return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap))
1379 }
1380 for i := range this.StringMap {
1381 if this.StringMap[i] != that1.StringMap[i] {
1382 return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i])
1383 }
1384 }
1385 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1386 return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap))
1387 }
1388 for i := range this.StringToBytesMap {
1389 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1390 return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i])
1391 }
1392 }
1393 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1394 return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap))
1395 }
1396 for i := range this.StringToEnumMap {
1397 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1398 return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i])
1399 }
1400 }
1401 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1402 return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap))
1403 }
1404 for i := range this.StringToMsgMap {
1405 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1406 return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i])
1407 }
1408 }
1409 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1410 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1411 }
1412 return nil
1413 }
1414 func (this *AllMapsOrdered) Equal(that interface{}) bool {
1415 if that == nil {
1416 return this == nil
1417 }
1418
1419 that1, ok := that.(*AllMapsOrdered)
1420 if !ok {
1421 that2, ok := that.(AllMapsOrdered)
1422 if ok {
1423 that1 = &that2
1424 } else {
1425 return false
1426 }
1427 }
1428 if that1 == nil {
1429 return this == nil
1430 } else if this == nil {
1431 return false
1432 }
1433 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1434 return false
1435 }
1436 for i := range this.StringToDoubleMap {
1437 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1438 return false
1439 }
1440 }
1441 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1442 return false
1443 }
1444 for i := range this.StringToFloatMap {
1445 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1446 return false
1447 }
1448 }
1449 if len(this.Int32Map) != len(that1.Int32Map) {
1450 return false
1451 }
1452 for i := range this.Int32Map {
1453 if this.Int32Map[i] != that1.Int32Map[i] {
1454 return false
1455 }
1456 }
1457 if len(this.Int64Map) != len(that1.Int64Map) {
1458 return false
1459 }
1460 for i := range this.Int64Map {
1461 if this.Int64Map[i] != that1.Int64Map[i] {
1462 return false
1463 }
1464 }
1465 if len(this.Uint32Map) != len(that1.Uint32Map) {
1466 return false
1467 }
1468 for i := range this.Uint32Map {
1469 if this.Uint32Map[i] != that1.Uint32Map[i] {
1470 return false
1471 }
1472 }
1473 if len(this.Uint64Map) != len(that1.Uint64Map) {
1474 return false
1475 }
1476 for i := range this.Uint64Map {
1477 if this.Uint64Map[i] != that1.Uint64Map[i] {
1478 return false
1479 }
1480 }
1481 if len(this.Sint32Map) != len(that1.Sint32Map) {
1482 return false
1483 }
1484 for i := range this.Sint32Map {
1485 if this.Sint32Map[i] != that1.Sint32Map[i] {
1486 return false
1487 }
1488 }
1489 if len(this.Sint64Map) != len(that1.Sint64Map) {
1490 return false
1491 }
1492 for i := range this.Sint64Map {
1493 if this.Sint64Map[i] != that1.Sint64Map[i] {
1494 return false
1495 }
1496 }
1497 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1498 return false
1499 }
1500 for i := range this.Fixed32Map {
1501 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1502 return false
1503 }
1504 }
1505 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1506 return false
1507 }
1508 for i := range this.Sfixed32Map {
1509 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1510 return false
1511 }
1512 }
1513 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1514 return false
1515 }
1516 for i := range this.Fixed64Map {
1517 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1518 return false
1519 }
1520 }
1521 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1522 return false
1523 }
1524 for i := range this.Sfixed64Map {
1525 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1526 return false
1527 }
1528 }
1529 if len(this.BoolMap) != len(that1.BoolMap) {
1530 return false
1531 }
1532 for i := range this.BoolMap {
1533 if this.BoolMap[i] != that1.BoolMap[i] {
1534 return false
1535 }
1536 }
1537 if len(this.StringMap) != len(that1.StringMap) {
1538 return false
1539 }
1540 for i := range this.StringMap {
1541 if this.StringMap[i] != that1.StringMap[i] {
1542 return false
1543 }
1544 }
1545 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1546 return false
1547 }
1548 for i := range this.StringToBytesMap {
1549 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1550 return false
1551 }
1552 }
1553 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1554 return false
1555 }
1556 for i := range this.StringToEnumMap {
1557 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1558 return false
1559 }
1560 }
1561 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1562 return false
1563 }
1564 for i := range this.StringToMsgMap {
1565 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1566 return false
1567 }
1568 }
1569 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1570 return false
1571 }
1572 return true
1573 }
1574
1575 type FloatingPointFace interface {
1576 Proto() github_com_gogo_protobuf_proto.Message
1577 GetF() *float64
1578 }
1579
1580 func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message {
1581 return this
1582 }
1583
1584 func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message {
1585 return NewFloatingPointFromFace(this)
1586 }
1587
1588 func (this *FloatingPoint) GetF() *float64 {
1589 return this.F
1590 }
1591
1592 func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint {
1593 this := &FloatingPoint{}
1594 this.F = that.GetF()
1595 return this
1596 }
1597
1598 type CustomMapFace interface {
1599 Proto() github_com_gogo_protobuf_proto.Message
1600 GetNullable128S() map[string]*github_com_gogo_protobuf_test_custom.Uint128
1601 GetUint128S() map[string]github_com_gogo_protobuf_test_custom.Uint128
1602 GetNullableIds() map[string]*github_com_gogo_protobuf_test.Uuid
1603 GetIds() map[string]github_com_gogo_protobuf_test.Uuid
1604 }
1605
1606 func (this *CustomMap) Proto() github_com_gogo_protobuf_proto.Message {
1607 return this
1608 }
1609
1610 func (this *CustomMap) TestProto() github_com_gogo_protobuf_proto.Message {
1611 return NewCustomMapFromFace(this)
1612 }
1613
1614 func (this *CustomMap) GetNullable128S() map[string]*github_com_gogo_protobuf_test_custom.Uint128 {
1615 return this.Nullable128S
1616 }
1617
1618 func (this *CustomMap) GetUint128S() map[string]github_com_gogo_protobuf_test_custom.Uint128 {
1619 return this.Uint128S
1620 }
1621
1622 func (this *CustomMap) GetNullableIds() map[string]*github_com_gogo_protobuf_test.Uuid {
1623 return this.NullableIds
1624 }
1625
1626 func (this *CustomMap) GetIds() map[string]github_com_gogo_protobuf_test.Uuid {
1627 return this.Ids
1628 }
1629
1630 func NewCustomMapFromFace(that CustomMapFace) *CustomMap {
1631 this := &CustomMap{}
1632 this.Nullable128S = that.GetNullable128S()
1633 this.Uint128S = that.GetUint128S()
1634 this.NullableIds = that.GetNullableIds()
1635 this.Ids = that.GetIds()
1636 return this
1637 }
1638
1639 type AllMapsFace interface {
1640 Proto() github_com_gogo_protobuf_proto.Message
1641 GetStringToDoubleMap() map[string]float64
1642 GetStringToFloatMap() map[string]float32
1643 GetInt32Map() map[int32]int32
1644 GetInt64Map() map[int64]int64
1645 GetUint32Map() map[uint32]uint32
1646 GetUint64Map() map[uint64]uint64
1647 GetSint32Map() map[int32]int32
1648 GetSint64Map() map[int64]int64
1649 GetFixed32Map() map[uint32]uint32
1650 GetSfixed32Map() map[int32]int32
1651 GetFixed64Map() map[uint64]uint64
1652 GetSfixed64Map() map[int64]int64
1653 GetBoolMap() map[bool]bool
1654 GetStringMap() map[string]string
1655 GetStringToBytesMap() map[string][]byte
1656 GetStringToEnumMap() map[string]MapEnum
1657 GetStringToMsgMap() map[string]*FloatingPoint
1658 }
1659
1660 func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message {
1661 return this
1662 }
1663
1664 func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message {
1665 return NewAllMapsFromFace(this)
1666 }
1667
1668 func (this *AllMaps) GetStringToDoubleMap() map[string]float64 {
1669 return this.StringToDoubleMap
1670 }
1671
1672 func (this *AllMaps) GetStringToFloatMap() map[string]float32 {
1673 return this.StringToFloatMap
1674 }
1675
1676 func (this *AllMaps) GetInt32Map() map[int32]int32 {
1677 return this.Int32Map
1678 }
1679
1680 func (this *AllMaps) GetInt64Map() map[int64]int64 {
1681 return this.Int64Map
1682 }
1683
1684 func (this *AllMaps) GetUint32Map() map[uint32]uint32 {
1685 return this.Uint32Map
1686 }
1687
1688 func (this *AllMaps) GetUint64Map() map[uint64]uint64 {
1689 return this.Uint64Map
1690 }
1691
1692 func (this *AllMaps) GetSint32Map() map[int32]int32 {
1693 return this.Sint32Map
1694 }
1695
1696 func (this *AllMaps) GetSint64Map() map[int64]int64 {
1697 return this.Sint64Map
1698 }
1699
1700 func (this *AllMaps) GetFixed32Map() map[uint32]uint32 {
1701 return this.Fixed32Map
1702 }
1703
1704 func (this *AllMaps) GetSfixed32Map() map[int32]int32 {
1705 return this.Sfixed32Map
1706 }
1707
1708 func (this *AllMaps) GetFixed64Map() map[uint64]uint64 {
1709 return this.Fixed64Map
1710 }
1711
1712 func (this *AllMaps) GetSfixed64Map() map[int64]int64 {
1713 return this.Sfixed64Map
1714 }
1715
1716 func (this *AllMaps) GetBoolMap() map[bool]bool {
1717 return this.BoolMap
1718 }
1719
1720 func (this *AllMaps) GetStringMap() map[string]string {
1721 return this.StringMap
1722 }
1723
1724 func (this *AllMaps) GetStringToBytesMap() map[string][]byte {
1725 return this.StringToBytesMap
1726 }
1727
1728 func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum {
1729 return this.StringToEnumMap
1730 }
1731
1732 func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint {
1733 return this.StringToMsgMap
1734 }
1735
1736 func NewAllMapsFromFace(that AllMapsFace) *AllMaps {
1737 this := &AllMaps{}
1738 this.StringToDoubleMap = that.GetStringToDoubleMap()
1739 this.StringToFloatMap = that.GetStringToFloatMap()
1740 this.Int32Map = that.GetInt32Map()
1741 this.Int64Map = that.GetInt64Map()
1742 this.Uint32Map = that.GetUint32Map()
1743 this.Uint64Map = that.GetUint64Map()
1744 this.Sint32Map = that.GetSint32Map()
1745 this.Sint64Map = that.GetSint64Map()
1746 this.Fixed32Map = that.GetFixed32Map()
1747 this.Sfixed32Map = that.GetSfixed32Map()
1748 this.Fixed64Map = that.GetFixed64Map()
1749 this.Sfixed64Map = that.GetSfixed64Map()
1750 this.BoolMap = that.GetBoolMap()
1751 this.StringMap = that.GetStringMap()
1752 this.StringToBytesMap = that.GetStringToBytesMap()
1753 this.StringToEnumMap = that.GetStringToEnumMap()
1754 this.StringToMsgMap = that.GetStringToMsgMap()
1755 return this
1756 }
1757
1758 type AllMapsOrderedFace interface {
1759 Proto() github_com_gogo_protobuf_proto.Message
1760 GetStringToDoubleMap() map[string]float64
1761 GetStringToFloatMap() map[string]float32
1762 GetInt32Map() map[int32]int32
1763 GetInt64Map() map[int64]int64
1764 GetUint32Map() map[uint32]uint32
1765 GetUint64Map() map[uint64]uint64
1766 GetSint32Map() map[int32]int32
1767 GetSint64Map() map[int64]int64
1768 GetFixed32Map() map[uint32]uint32
1769 GetSfixed32Map() map[int32]int32
1770 GetFixed64Map() map[uint64]uint64
1771 GetSfixed64Map() map[int64]int64
1772 GetBoolMap() map[bool]bool
1773 GetStringMap() map[string]string
1774 GetStringToBytesMap() map[string][]byte
1775 GetStringToEnumMap() map[string]MapEnum
1776 GetStringToMsgMap() map[string]*FloatingPoint
1777 }
1778
1779 func (this *AllMapsOrdered) Proto() github_com_gogo_protobuf_proto.Message {
1780 return this
1781 }
1782
1783 func (this *AllMapsOrdered) TestProto() github_com_gogo_protobuf_proto.Message {
1784 return NewAllMapsOrderedFromFace(this)
1785 }
1786
1787 func (this *AllMapsOrdered) GetStringToDoubleMap() map[string]float64 {
1788 return this.StringToDoubleMap
1789 }
1790
1791 func (this *AllMapsOrdered) GetStringToFloatMap() map[string]float32 {
1792 return this.StringToFloatMap
1793 }
1794
1795 func (this *AllMapsOrdered) GetInt32Map() map[int32]int32 {
1796 return this.Int32Map
1797 }
1798
1799 func (this *AllMapsOrdered) GetInt64Map() map[int64]int64 {
1800 return this.Int64Map
1801 }
1802
1803 func (this *AllMapsOrdered) GetUint32Map() map[uint32]uint32 {
1804 return this.Uint32Map
1805 }
1806
1807 func (this *AllMapsOrdered) GetUint64Map() map[uint64]uint64 {
1808 return this.Uint64Map
1809 }
1810
1811 func (this *AllMapsOrdered) GetSint32Map() map[int32]int32 {
1812 return this.Sint32Map
1813 }
1814
1815 func (this *AllMapsOrdered) GetSint64Map() map[int64]int64 {
1816 return this.Sint64Map
1817 }
1818
1819 func (this *AllMapsOrdered) GetFixed32Map() map[uint32]uint32 {
1820 return this.Fixed32Map
1821 }
1822
1823 func (this *AllMapsOrdered) GetSfixed32Map() map[int32]int32 {
1824 return this.Sfixed32Map
1825 }
1826
1827 func (this *AllMapsOrdered) GetFixed64Map() map[uint64]uint64 {
1828 return this.Fixed64Map
1829 }
1830
1831 func (this *AllMapsOrdered) GetSfixed64Map() map[int64]int64 {
1832 return this.Sfixed64Map
1833 }
1834
1835 func (this *AllMapsOrdered) GetBoolMap() map[bool]bool {
1836 return this.BoolMap
1837 }
1838
1839 func (this *AllMapsOrdered) GetStringMap() map[string]string {
1840 return this.StringMap
1841 }
1842
1843 func (this *AllMapsOrdered) GetStringToBytesMap() map[string][]byte {
1844 return this.StringToBytesMap
1845 }
1846
1847 func (this *AllMapsOrdered) GetStringToEnumMap() map[string]MapEnum {
1848 return this.StringToEnumMap
1849 }
1850
1851 func (this *AllMapsOrdered) GetStringToMsgMap() map[string]*FloatingPoint {
1852 return this.StringToMsgMap
1853 }
1854
1855 func NewAllMapsOrderedFromFace(that AllMapsOrderedFace) *AllMapsOrdered {
1856 this := &AllMapsOrdered{}
1857 this.StringToDoubleMap = that.GetStringToDoubleMap()
1858 this.StringToFloatMap = that.GetStringToFloatMap()
1859 this.Int32Map = that.GetInt32Map()
1860 this.Int64Map = that.GetInt64Map()
1861 this.Uint32Map = that.GetUint32Map()
1862 this.Uint64Map = that.GetUint64Map()
1863 this.Sint32Map = that.GetSint32Map()
1864 this.Sint64Map = that.GetSint64Map()
1865 this.Fixed32Map = that.GetFixed32Map()
1866 this.Sfixed32Map = that.GetSfixed32Map()
1867 this.Fixed64Map = that.GetFixed64Map()
1868 this.Sfixed64Map = that.GetSfixed64Map()
1869 this.BoolMap = that.GetBoolMap()
1870 this.StringMap = that.GetStringMap()
1871 this.StringToBytesMap = that.GetStringToBytesMap()
1872 this.StringToEnumMap = that.GetStringToEnumMap()
1873 this.StringToMsgMap = that.GetStringToMsgMap()
1874 return this
1875 }
1876
1877 func (this *FloatingPoint) GoString() string {
1878 if this == nil {
1879 return "nil"
1880 }
1881 s := make([]string, 0, 5)
1882 s = append(s, "&proto2_maps.FloatingPoint{")
1883 if this.F != nil {
1884 s = append(s, "F: "+valueToGoStringMapsproto2(this.F, "float64")+",\n")
1885 }
1886 if this.XXX_unrecognized != nil {
1887 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1888 }
1889 s = append(s, "}")
1890 return strings.Join(s, "")
1891 }
1892 func (this *CustomMap) GoString() string {
1893 if this == nil {
1894 return "nil"
1895 }
1896 s := make([]string, 0, 8)
1897 s = append(s, "&proto2_maps.CustomMap{")
1898 keysForNullable128S := make([]string, 0, len(this.Nullable128S))
1899 for k := range this.Nullable128S {
1900 keysForNullable128S = append(keysForNullable128S, k)
1901 }
1902 github_com_gogo_protobuf_sortkeys.Strings(keysForNullable128S)
1903 mapStringForNullable128S := "map[string]*github_com_gogo_protobuf_test_custom.Uint128{"
1904 for _, k := range keysForNullable128S {
1905 mapStringForNullable128S += fmt.Sprintf("%#v: %#v,", k, this.Nullable128S[k])
1906 }
1907 mapStringForNullable128S += "}"
1908 if this.Nullable128S != nil {
1909 s = append(s, "Nullable128S: "+mapStringForNullable128S+",\n")
1910 }
1911 keysForUint128S := make([]string, 0, len(this.Uint128S))
1912 for k := range this.Uint128S {
1913 keysForUint128S = append(keysForUint128S, k)
1914 }
1915 github_com_gogo_protobuf_sortkeys.Strings(keysForUint128S)
1916 mapStringForUint128S := "map[string]github_com_gogo_protobuf_test_custom.Uint128{"
1917 for _, k := range keysForUint128S {
1918 mapStringForUint128S += fmt.Sprintf("%#v: %#v,", k, this.Uint128S[k])
1919 }
1920 mapStringForUint128S += "}"
1921 if this.Uint128S != nil {
1922 s = append(s, "Uint128S: "+mapStringForUint128S+",\n")
1923 }
1924 keysForNullableIds := make([]string, 0, len(this.NullableIds))
1925 for k := range this.NullableIds {
1926 keysForNullableIds = append(keysForNullableIds, k)
1927 }
1928 github_com_gogo_protobuf_sortkeys.Strings(keysForNullableIds)
1929 mapStringForNullableIds := "map[string]*github_com_gogo_protobuf_test.Uuid{"
1930 for _, k := range keysForNullableIds {
1931 mapStringForNullableIds += fmt.Sprintf("%#v: %#v,", k, this.NullableIds[k])
1932 }
1933 mapStringForNullableIds += "}"
1934 if this.NullableIds != nil {
1935 s = append(s, "NullableIds: "+mapStringForNullableIds+",\n")
1936 }
1937 keysForIds := make([]string, 0, len(this.Ids))
1938 for k := range this.Ids {
1939 keysForIds = append(keysForIds, k)
1940 }
1941 github_com_gogo_protobuf_sortkeys.Strings(keysForIds)
1942 mapStringForIds := "map[string]github_com_gogo_protobuf_test.Uuid{"
1943 for _, k := range keysForIds {
1944 mapStringForIds += fmt.Sprintf("%#v: %#v,", k, this.Ids[k])
1945 }
1946 mapStringForIds += "}"
1947 if this.Ids != nil {
1948 s = append(s, "Ids: "+mapStringForIds+",\n")
1949 }
1950 if this.XXX_unrecognized != nil {
1951 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1952 }
1953 s = append(s, "}")
1954 return strings.Join(s, "")
1955 }
1956 func (this *AllMaps) GoString() string {
1957 if this == nil {
1958 return "nil"
1959 }
1960 s := make([]string, 0, 21)
1961 s = append(s, "&proto2_maps.AllMaps{")
1962 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
1963 for k := range this.StringToDoubleMap {
1964 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
1965 }
1966 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
1967 mapStringForStringToDoubleMap := "map[string]float64{"
1968 for _, k := range keysForStringToDoubleMap {
1969 mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k])
1970 }
1971 mapStringForStringToDoubleMap += "}"
1972 if this.StringToDoubleMap != nil {
1973 s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n")
1974 }
1975 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
1976 for k := range this.StringToFloatMap {
1977 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
1978 }
1979 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
1980 mapStringForStringToFloatMap := "map[string]float32{"
1981 for _, k := range keysForStringToFloatMap {
1982 mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k])
1983 }
1984 mapStringForStringToFloatMap += "}"
1985 if this.StringToFloatMap != nil {
1986 s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n")
1987 }
1988 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
1989 for k := range this.Int32Map {
1990 keysForInt32Map = append(keysForInt32Map, k)
1991 }
1992 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
1993 mapStringForInt32Map := "map[int32]int32{"
1994 for _, k := range keysForInt32Map {
1995 mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k])
1996 }
1997 mapStringForInt32Map += "}"
1998 if this.Int32Map != nil {
1999 s = append(s, "Int32Map: "+mapStringForInt32Map+",\n")
2000 }
2001 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
2002 for k := range this.Int64Map {
2003 keysForInt64Map = append(keysForInt64Map, k)
2004 }
2005 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
2006 mapStringForInt64Map := "map[int64]int64{"
2007 for _, k := range keysForInt64Map {
2008 mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k])
2009 }
2010 mapStringForInt64Map += "}"
2011 if this.Int64Map != nil {
2012 s = append(s, "Int64Map: "+mapStringForInt64Map+",\n")
2013 }
2014 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
2015 for k := range this.Uint32Map {
2016 keysForUint32Map = append(keysForUint32Map, k)
2017 }
2018 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
2019 mapStringForUint32Map := "map[uint32]uint32{"
2020 for _, k := range keysForUint32Map {
2021 mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k])
2022 }
2023 mapStringForUint32Map += "}"
2024 if this.Uint32Map != nil {
2025 s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n")
2026 }
2027 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
2028 for k := range this.Uint64Map {
2029 keysForUint64Map = append(keysForUint64Map, k)
2030 }
2031 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
2032 mapStringForUint64Map := "map[uint64]uint64{"
2033 for _, k := range keysForUint64Map {
2034 mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k])
2035 }
2036 mapStringForUint64Map += "}"
2037 if this.Uint64Map != nil {
2038 s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n")
2039 }
2040 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
2041 for k := range this.Sint32Map {
2042 keysForSint32Map = append(keysForSint32Map, k)
2043 }
2044 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
2045 mapStringForSint32Map := "map[int32]int32{"
2046 for _, k := range keysForSint32Map {
2047 mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k])
2048 }
2049 mapStringForSint32Map += "}"
2050 if this.Sint32Map != nil {
2051 s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n")
2052 }
2053 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
2054 for k := range this.Sint64Map {
2055 keysForSint64Map = append(keysForSint64Map, k)
2056 }
2057 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
2058 mapStringForSint64Map := "map[int64]int64{"
2059 for _, k := range keysForSint64Map {
2060 mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k])
2061 }
2062 mapStringForSint64Map += "}"
2063 if this.Sint64Map != nil {
2064 s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n")
2065 }
2066 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
2067 for k := range this.Fixed32Map {
2068 keysForFixed32Map = append(keysForFixed32Map, k)
2069 }
2070 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
2071 mapStringForFixed32Map := "map[uint32]uint32{"
2072 for _, k := range keysForFixed32Map {
2073 mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k])
2074 }
2075 mapStringForFixed32Map += "}"
2076 if this.Fixed32Map != nil {
2077 s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n")
2078 }
2079 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
2080 for k := range this.Sfixed32Map {
2081 keysForSfixed32Map = append(keysForSfixed32Map, k)
2082 }
2083 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
2084 mapStringForSfixed32Map := "map[int32]int32{"
2085 for _, k := range keysForSfixed32Map {
2086 mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k])
2087 }
2088 mapStringForSfixed32Map += "}"
2089 if this.Sfixed32Map != nil {
2090 s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n")
2091 }
2092 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
2093 for k := range this.Fixed64Map {
2094 keysForFixed64Map = append(keysForFixed64Map, k)
2095 }
2096 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
2097 mapStringForFixed64Map := "map[uint64]uint64{"
2098 for _, k := range keysForFixed64Map {
2099 mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k])
2100 }
2101 mapStringForFixed64Map += "}"
2102 if this.Fixed64Map != nil {
2103 s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n")
2104 }
2105 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
2106 for k := range this.Sfixed64Map {
2107 keysForSfixed64Map = append(keysForSfixed64Map, k)
2108 }
2109 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
2110 mapStringForSfixed64Map := "map[int64]int64{"
2111 for _, k := range keysForSfixed64Map {
2112 mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k])
2113 }
2114 mapStringForSfixed64Map += "}"
2115 if this.Sfixed64Map != nil {
2116 s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n")
2117 }
2118 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
2119 for k := range this.BoolMap {
2120 keysForBoolMap = append(keysForBoolMap, k)
2121 }
2122 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
2123 mapStringForBoolMap := "map[bool]bool{"
2124 for _, k := range keysForBoolMap {
2125 mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k])
2126 }
2127 mapStringForBoolMap += "}"
2128 if this.BoolMap != nil {
2129 s = append(s, "BoolMap: "+mapStringForBoolMap+",\n")
2130 }
2131 keysForStringMap := make([]string, 0, len(this.StringMap))
2132 for k := range this.StringMap {
2133 keysForStringMap = append(keysForStringMap, k)
2134 }
2135 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
2136 mapStringForStringMap := "map[string]string{"
2137 for _, k := range keysForStringMap {
2138 mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k])
2139 }
2140 mapStringForStringMap += "}"
2141 if this.StringMap != nil {
2142 s = append(s, "StringMap: "+mapStringForStringMap+",\n")
2143 }
2144 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
2145 for k := range this.StringToBytesMap {
2146 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
2147 }
2148 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
2149 mapStringForStringToBytesMap := "map[string][]byte{"
2150 for _, k := range keysForStringToBytesMap {
2151 mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k])
2152 }
2153 mapStringForStringToBytesMap += "}"
2154 if this.StringToBytesMap != nil {
2155 s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n")
2156 }
2157 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
2158 for k := range this.StringToEnumMap {
2159 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
2160 }
2161 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
2162 mapStringForStringToEnumMap := "map[string]MapEnum{"
2163 for _, k := range keysForStringToEnumMap {
2164 mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k])
2165 }
2166 mapStringForStringToEnumMap += "}"
2167 if this.StringToEnumMap != nil {
2168 s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n")
2169 }
2170 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
2171 for k := range this.StringToMsgMap {
2172 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
2173 }
2174 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
2175 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
2176 for _, k := range keysForStringToMsgMap {
2177 mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k])
2178 }
2179 mapStringForStringToMsgMap += "}"
2180 if this.StringToMsgMap != nil {
2181 s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n")
2182 }
2183 if this.XXX_unrecognized != nil {
2184 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
2185 }
2186 s = append(s, "}")
2187 return strings.Join(s, "")
2188 }
2189 func (this *AllMapsOrdered) GoString() string {
2190 if this == nil {
2191 return "nil"
2192 }
2193 s := make([]string, 0, 21)
2194 s = append(s, "&proto2_maps.AllMapsOrdered{")
2195 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
2196 for k := range this.StringToDoubleMap {
2197 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
2198 }
2199 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
2200 mapStringForStringToDoubleMap := "map[string]float64{"
2201 for _, k := range keysForStringToDoubleMap {
2202 mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k])
2203 }
2204 mapStringForStringToDoubleMap += "}"
2205 if this.StringToDoubleMap != nil {
2206 s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n")
2207 }
2208 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
2209 for k := range this.StringToFloatMap {
2210 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
2211 }
2212 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
2213 mapStringForStringToFloatMap := "map[string]float32{"
2214 for _, k := range keysForStringToFloatMap {
2215 mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k])
2216 }
2217 mapStringForStringToFloatMap += "}"
2218 if this.StringToFloatMap != nil {
2219 s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n")
2220 }
2221 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
2222 for k := range this.Int32Map {
2223 keysForInt32Map = append(keysForInt32Map, k)
2224 }
2225 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
2226 mapStringForInt32Map := "map[int32]int32{"
2227 for _, k := range keysForInt32Map {
2228 mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k])
2229 }
2230 mapStringForInt32Map += "}"
2231 if this.Int32Map != nil {
2232 s = append(s, "Int32Map: "+mapStringForInt32Map+",\n")
2233 }
2234 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
2235 for k := range this.Int64Map {
2236 keysForInt64Map = append(keysForInt64Map, k)
2237 }
2238 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
2239 mapStringForInt64Map := "map[int64]int64{"
2240 for _, k := range keysForInt64Map {
2241 mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k])
2242 }
2243 mapStringForInt64Map += "}"
2244 if this.Int64Map != nil {
2245 s = append(s, "Int64Map: "+mapStringForInt64Map+",\n")
2246 }
2247 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
2248 for k := range this.Uint32Map {
2249 keysForUint32Map = append(keysForUint32Map, k)
2250 }
2251 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
2252 mapStringForUint32Map := "map[uint32]uint32{"
2253 for _, k := range keysForUint32Map {
2254 mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k])
2255 }
2256 mapStringForUint32Map += "}"
2257 if this.Uint32Map != nil {
2258 s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n")
2259 }
2260 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
2261 for k := range this.Uint64Map {
2262 keysForUint64Map = append(keysForUint64Map, k)
2263 }
2264 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
2265 mapStringForUint64Map := "map[uint64]uint64{"
2266 for _, k := range keysForUint64Map {
2267 mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k])
2268 }
2269 mapStringForUint64Map += "}"
2270 if this.Uint64Map != nil {
2271 s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n")
2272 }
2273 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
2274 for k := range this.Sint32Map {
2275 keysForSint32Map = append(keysForSint32Map, k)
2276 }
2277 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
2278 mapStringForSint32Map := "map[int32]int32{"
2279 for _, k := range keysForSint32Map {
2280 mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k])
2281 }
2282 mapStringForSint32Map += "}"
2283 if this.Sint32Map != nil {
2284 s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n")
2285 }
2286 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
2287 for k := range this.Sint64Map {
2288 keysForSint64Map = append(keysForSint64Map, k)
2289 }
2290 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
2291 mapStringForSint64Map := "map[int64]int64{"
2292 for _, k := range keysForSint64Map {
2293 mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k])
2294 }
2295 mapStringForSint64Map += "}"
2296 if this.Sint64Map != nil {
2297 s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n")
2298 }
2299 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
2300 for k := range this.Fixed32Map {
2301 keysForFixed32Map = append(keysForFixed32Map, k)
2302 }
2303 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
2304 mapStringForFixed32Map := "map[uint32]uint32{"
2305 for _, k := range keysForFixed32Map {
2306 mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k])
2307 }
2308 mapStringForFixed32Map += "}"
2309 if this.Fixed32Map != nil {
2310 s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n")
2311 }
2312 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
2313 for k := range this.Sfixed32Map {
2314 keysForSfixed32Map = append(keysForSfixed32Map, k)
2315 }
2316 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
2317 mapStringForSfixed32Map := "map[int32]int32{"
2318 for _, k := range keysForSfixed32Map {
2319 mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k])
2320 }
2321 mapStringForSfixed32Map += "}"
2322 if this.Sfixed32Map != nil {
2323 s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n")
2324 }
2325 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
2326 for k := range this.Fixed64Map {
2327 keysForFixed64Map = append(keysForFixed64Map, k)
2328 }
2329 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
2330 mapStringForFixed64Map := "map[uint64]uint64{"
2331 for _, k := range keysForFixed64Map {
2332 mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k])
2333 }
2334 mapStringForFixed64Map += "}"
2335 if this.Fixed64Map != nil {
2336 s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n")
2337 }
2338 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
2339 for k := range this.Sfixed64Map {
2340 keysForSfixed64Map = append(keysForSfixed64Map, k)
2341 }
2342 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
2343 mapStringForSfixed64Map := "map[int64]int64{"
2344 for _, k := range keysForSfixed64Map {
2345 mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k])
2346 }
2347 mapStringForSfixed64Map += "}"
2348 if this.Sfixed64Map != nil {
2349 s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n")
2350 }
2351 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
2352 for k := range this.BoolMap {
2353 keysForBoolMap = append(keysForBoolMap, k)
2354 }
2355 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
2356 mapStringForBoolMap := "map[bool]bool{"
2357 for _, k := range keysForBoolMap {
2358 mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k])
2359 }
2360 mapStringForBoolMap += "}"
2361 if this.BoolMap != nil {
2362 s = append(s, "BoolMap: "+mapStringForBoolMap+",\n")
2363 }
2364 keysForStringMap := make([]string, 0, len(this.StringMap))
2365 for k := range this.StringMap {
2366 keysForStringMap = append(keysForStringMap, k)
2367 }
2368 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
2369 mapStringForStringMap := "map[string]string{"
2370 for _, k := range keysForStringMap {
2371 mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k])
2372 }
2373 mapStringForStringMap += "}"
2374 if this.StringMap != nil {
2375 s = append(s, "StringMap: "+mapStringForStringMap+",\n")
2376 }
2377 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
2378 for k := range this.StringToBytesMap {
2379 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
2380 }
2381 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
2382 mapStringForStringToBytesMap := "map[string][]byte{"
2383 for _, k := range keysForStringToBytesMap {
2384 mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k])
2385 }
2386 mapStringForStringToBytesMap += "}"
2387 if this.StringToBytesMap != nil {
2388 s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n")
2389 }
2390 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
2391 for k := range this.StringToEnumMap {
2392 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
2393 }
2394 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
2395 mapStringForStringToEnumMap := "map[string]MapEnum{"
2396 for _, k := range keysForStringToEnumMap {
2397 mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k])
2398 }
2399 mapStringForStringToEnumMap += "}"
2400 if this.StringToEnumMap != nil {
2401 s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n")
2402 }
2403 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
2404 for k := range this.StringToMsgMap {
2405 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
2406 }
2407 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
2408 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
2409 for _, k := range keysForStringToMsgMap {
2410 mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k])
2411 }
2412 mapStringForStringToMsgMap += "}"
2413 if this.StringToMsgMap != nil {
2414 s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n")
2415 }
2416 if this.XXX_unrecognized != nil {
2417 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
2418 }
2419 s = append(s, "}")
2420 return strings.Join(s, "")
2421 }
2422 func valueToGoStringMapsproto2(v interface{}, typ string) string {
2423 rv := reflect.ValueOf(v)
2424 if rv.IsNil() {
2425 return "nil"
2426 }
2427 pv := reflect.Indirect(rv).Interface()
2428 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
2429 }
2430 func (m *FloatingPoint) Marshal() (dAtA []byte, err error) {
2431 size := m.Size()
2432 dAtA = make([]byte, size)
2433 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2434 if err != nil {
2435 return nil, err
2436 }
2437 return dAtA[:n], nil
2438 }
2439
2440 func (m *FloatingPoint) MarshalTo(dAtA []byte) (int, error) {
2441 size := m.Size()
2442 return m.MarshalToSizedBuffer(dAtA[:size])
2443 }
2444
2445 func (m *FloatingPoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2446 i := len(dAtA)
2447 _ = i
2448 var l int
2449 _ = l
2450 if m.XXX_unrecognized != nil {
2451 i -= len(m.XXX_unrecognized)
2452 copy(dAtA[i:], m.XXX_unrecognized)
2453 }
2454 if m.F != nil {
2455 i -= 8
2456 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.F))))
2457 i--
2458 dAtA[i] = 0x9
2459 }
2460 return len(dAtA) - i, nil
2461 }
2462
2463 func (m *CustomMap) Marshal() (dAtA []byte, err error) {
2464 size := m.Size()
2465 dAtA = make([]byte, size)
2466 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2467 if err != nil {
2468 return nil, err
2469 }
2470 return dAtA[:n], nil
2471 }
2472
2473 func (m *CustomMap) MarshalTo(dAtA []byte) (int, error) {
2474 size := m.Size()
2475 return m.MarshalToSizedBuffer(dAtA[:size])
2476 }
2477
2478 func (m *CustomMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2479 i := len(dAtA)
2480 _ = i
2481 var l int
2482 _ = l
2483 if m.XXX_unrecognized != nil {
2484 i -= len(m.XXX_unrecognized)
2485 copy(dAtA[i:], m.XXX_unrecognized)
2486 }
2487 if len(m.Ids) > 0 {
2488 for k := range m.Ids {
2489 v := m.Ids[k]
2490 baseI := i
2491 {
2492 size := v.Size()
2493 i -= size
2494 if _, err := v.MarshalTo(dAtA[i:]); err != nil {
2495 return 0, err
2496 }
2497 i = encodeVarintMapsproto2(dAtA, i, uint64(size))
2498 }
2499 i--
2500 dAtA[i] = 0x12
2501 i -= len(k)
2502 copy(dAtA[i:], k)
2503 i = encodeVarintMapsproto2(dAtA, i, uint64(len(k)))
2504 i--
2505 dAtA[i] = 0xa
2506 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2507 i--
2508 dAtA[i] = 0x22
2509 }
2510 }
2511 if len(m.NullableIds) > 0 {
2512 for k := range m.NullableIds {
2513 v := m.NullableIds[k]
2514 baseI := i
2515 if v != nil {
2516 {
2517 size := v.Size()
2518 i -= size
2519 if _, err := v.MarshalTo(dAtA[i:]); err != nil {
2520 return 0, err
2521 }
2522 i = encodeVarintMapsproto2(dAtA, i, uint64(size))
2523 }
2524 i--
2525 dAtA[i] = 0x12
2526 }
2527 i -= len(k)
2528 copy(dAtA[i:], k)
2529 i = encodeVarintMapsproto2(dAtA, i, uint64(len(k)))
2530 i--
2531 dAtA[i] = 0xa
2532 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2533 i--
2534 dAtA[i] = 0x1a
2535 }
2536 }
2537 if len(m.Uint128S) > 0 {
2538 for k := range m.Uint128S {
2539 v := m.Uint128S[k]
2540 baseI := i
2541 {
2542 size := v.Size()
2543 i -= size
2544 if _, err := v.MarshalTo(dAtA[i:]); err != nil {
2545 return 0, err
2546 }
2547 i = encodeVarintMapsproto2(dAtA, i, uint64(size))
2548 }
2549 i--
2550 dAtA[i] = 0x12
2551 i -= len(k)
2552 copy(dAtA[i:], k)
2553 i = encodeVarintMapsproto2(dAtA, i, uint64(len(k)))
2554 i--
2555 dAtA[i] = 0xa
2556 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2557 i--
2558 dAtA[i] = 0x12
2559 }
2560 }
2561 if len(m.Nullable128S) > 0 {
2562 for k := range m.Nullable128S {
2563 v := m.Nullable128S[k]
2564 baseI := i
2565 if v != nil {
2566 {
2567 size := v.Size()
2568 i -= size
2569 if _, err := v.MarshalTo(dAtA[i:]); err != nil {
2570 return 0, err
2571 }
2572 i = encodeVarintMapsproto2(dAtA, i, uint64(size))
2573 }
2574 i--
2575 dAtA[i] = 0x12
2576 }
2577 i -= len(k)
2578 copy(dAtA[i:], k)
2579 i = encodeVarintMapsproto2(dAtA, i, uint64(len(k)))
2580 i--
2581 dAtA[i] = 0xa
2582 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2583 i--
2584 dAtA[i] = 0xa
2585 }
2586 }
2587 return len(dAtA) - i, nil
2588 }
2589
2590 func (m *AllMaps) Marshal() (dAtA []byte, err error) {
2591 size := m.Size()
2592 dAtA = make([]byte, size)
2593 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2594 if err != nil {
2595 return nil, err
2596 }
2597 return dAtA[:n], nil
2598 }
2599
2600 func (m *AllMaps) MarshalTo(dAtA []byte) (int, error) {
2601 size := m.Size()
2602 return m.MarshalToSizedBuffer(dAtA[:size])
2603 }
2604
2605 func (m *AllMaps) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2606 i := len(dAtA)
2607 _ = i
2608 var l int
2609 _ = l
2610 if m.XXX_unrecognized != nil {
2611 i -= len(m.XXX_unrecognized)
2612 copy(dAtA[i:], m.XXX_unrecognized)
2613 }
2614 if len(m.StringToMsgMap) > 0 {
2615 for k := range m.StringToMsgMap {
2616 v := m.StringToMsgMap[k]
2617 baseI := i
2618 if v != nil {
2619 {
2620 size, err := v.MarshalToSizedBuffer(dAtA[:i])
2621 if err != nil {
2622 return 0, err
2623 }
2624 i -= size
2625 i = encodeVarintMapsproto2(dAtA, i, uint64(size))
2626 }
2627 i--
2628 dAtA[i] = 0x12
2629 }
2630 i -= len(k)
2631 copy(dAtA[i:], k)
2632 i = encodeVarintMapsproto2(dAtA, i, uint64(len(k)))
2633 i--
2634 dAtA[i] = 0xa
2635 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2636 i--
2637 dAtA[i] = 0x1
2638 i--
2639 dAtA[i] = 0x8a
2640 }
2641 }
2642 if len(m.StringToEnumMap) > 0 {
2643 for k := range m.StringToEnumMap {
2644 v := m.StringToEnumMap[k]
2645 baseI := i
2646 i = encodeVarintMapsproto2(dAtA, i, uint64(v))
2647 i--
2648 dAtA[i] = 0x10
2649 i -= len(k)
2650 copy(dAtA[i:], k)
2651 i = encodeVarintMapsproto2(dAtA, i, uint64(len(k)))
2652 i--
2653 dAtA[i] = 0xa
2654 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2655 i--
2656 dAtA[i] = 0x1
2657 i--
2658 dAtA[i] = 0x82
2659 }
2660 }
2661 if len(m.StringToBytesMap) > 0 {
2662 for k := range m.StringToBytesMap {
2663 v := m.StringToBytesMap[k]
2664 baseI := i
2665 if v != nil {
2666 i -= len(v)
2667 copy(dAtA[i:], v)
2668 i = encodeVarintMapsproto2(dAtA, i, uint64(len(v)))
2669 i--
2670 dAtA[i] = 0x12
2671 }
2672 i -= len(k)
2673 copy(dAtA[i:], k)
2674 i = encodeVarintMapsproto2(dAtA, i, uint64(len(k)))
2675 i--
2676 dAtA[i] = 0xa
2677 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2678 i--
2679 dAtA[i] = 0x7a
2680 }
2681 }
2682 if len(m.StringMap) > 0 {
2683 for k := range m.StringMap {
2684 v := m.StringMap[k]
2685 baseI := i
2686 i -= len(v)
2687 copy(dAtA[i:], v)
2688 i = encodeVarintMapsproto2(dAtA, i, uint64(len(v)))
2689 i--
2690 dAtA[i] = 0x12
2691 i -= len(k)
2692 copy(dAtA[i:], k)
2693 i = encodeVarintMapsproto2(dAtA, i, uint64(len(k)))
2694 i--
2695 dAtA[i] = 0xa
2696 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2697 i--
2698 dAtA[i] = 0x72
2699 }
2700 }
2701 if len(m.BoolMap) > 0 {
2702 for k := range m.BoolMap {
2703 v := m.BoolMap[k]
2704 baseI := i
2705 i--
2706 if v {
2707 dAtA[i] = 1
2708 } else {
2709 dAtA[i] = 0
2710 }
2711 i--
2712 dAtA[i] = 0x10
2713 i--
2714 if k {
2715 dAtA[i] = 1
2716 } else {
2717 dAtA[i] = 0
2718 }
2719 i--
2720 dAtA[i] = 0x8
2721 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2722 i--
2723 dAtA[i] = 0x6a
2724 }
2725 }
2726 if len(m.Sfixed64Map) > 0 {
2727 for k := range m.Sfixed64Map {
2728 v := m.Sfixed64Map[k]
2729 baseI := i
2730 i -= 8
2731 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
2732 i--
2733 dAtA[i] = 0x11
2734 i -= 8
2735 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(k))
2736 i--
2737 dAtA[i] = 0x9
2738 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2739 i--
2740 dAtA[i] = 0x62
2741 }
2742 }
2743 if len(m.Fixed64Map) > 0 {
2744 for k := range m.Fixed64Map {
2745 v := m.Fixed64Map[k]
2746 baseI := i
2747 i -= 8
2748 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
2749 i--
2750 dAtA[i] = 0x11
2751 i -= 8
2752 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(k))
2753 i--
2754 dAtA[i] = 0x9
2755 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2756 i--
2757 dAtA[i] = 0x5a
2758 }
2759 }
2760 if len(m.Sfixed32Map) > 0 {
2761 for k := range m.Sfixed32Map {
2762 v := m.Sfixed32Map[k]
2763 baseI := i
2764 i -= 4
2765 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
2766 i--
2767 dAtA[i] = 0x15
2768 i -= 4
2769 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(k))
2770 i--
2771 dAtA[i] = 0xd
2772 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2773 i--
2774 dAtA[i] = 0x52
2775 }
2776 }
2777 if len(m.Fixed32Map) > 0 {
2778 for k := range m.Fixed32Map {
2779 v := m.Fixed32Map[k]
2780 baseI := i
2781 i -= 4
2782 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
2783 i--
2784 dAtA[i] = 0x15
2785 i -= 4
2786 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(k))
2787 i--
2788 dAtA[i] = 0xd
2789 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2790 i--
2791 dAtA[i] = 0x4a
2792 }
2793 }
2794 if len(m.Sint64Map) > 0 {
2795 for k := range m.Sint64Map {
2796 v := m.Sint64Map[k]
2797 baseI := i
2798 i = encodeVarintMapsproto2(dAtA, i, uint64((uint64(v)<<1)^uint64((v>>63))))
2799 i--
2800 dAtA[i] = 0x10
2801 i = encodeVarintMapsproto2(dAtA, i, uint64((uint64(k)<<1)^uint64((k>>63))))
2802 i--
2803 dAtA[i] = 0x8
2804 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2805 i--
2806 dAtA[i] = 0x42
2807 }
2808 }
2809 if len(m.Sint32Map) > 0 {
2810 for k := range m.Sint32Map {
2811 v := m.Sint32Map[k]
2812 baseI := i
2813 i = encodeVarintMapsproto2(dAtA, i, uint64((uint32(v)<<1)^uint32((v>>31))))
2814 i--
2815 dAtA[i] = 0x10
2816 i = encodeVarintMapsproto2(dAtA, i, uint64((uint32(k)<<1)^uint32((k>>31))))
2817 i--
2818 dAtA[i] = 0x8
2819 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2820 i--
2821 dAtA[i] = 0x3a
2822 }
2823 }
2824 if len(m.Uint64Map) > 0 {
2825 for k := range m.Uint64Map {
2826 v := m.Uint64Map[k]
2827 baseI := i
2828 i = encodeVarintMapsproto2(dAtA, i, uint64(v))
2829 i--
2830 dAtA[i] = 0x10
2831 i = encodeVarintMapsproto2(dAtA, i, uint64(k))
2832 i--
2833 dAtA[i] = 0x8
2834 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2835 i--
2836 dAtA[i] = 0x32
2837 }
2838 }
2839 if len(m.Uint32Map) > 0 {
2840 for k := range m.Uint32Map {
2841 v := m.Uint32Map[k]
2842 baseI := i
2843 i = encodeVarintMapsproto2(dAtA, i, uint64(v))
2844 i--
2845 dAtA[i] = 0x10
2846 i = encodeVarintMapsproto2(dAtA, i, uint64(k))
2847 i--
2848 dAtA[i] = 0x8
2849 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2850 i--
2851 dAtA[i] = 0x2a
2852 }
2853 }
2854 if len(m.Int64Map) > 0 {
2855 for k := range m.Int64Map {
2856 v := m.Int64Map[k]
2857 baseI := i
2858 i = encodeVarintMapsproto2(dAtA, i, uint64(v))
2859 i--
2860 dAtA[i] = 0x10
2861 i = encodeVarintMapsproto2(dAtA, i, uint64(k))
2862 i--
2863 dAtA[i] = 0x8
2864 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2865 i--
2866 dAtA[i] = 0x22
2867 }
2868 }
2869 if len(m.Int32Map) > 0 {
2870 for k := range m.Int32Map {
2871 v := m.Int32Map[k]
2872 baseI := i
2873 i = encodeVarintMapsproto2(dAtA, i, uint64(v))
2874 i--
2875 dAtA[i] = 0x10
2876 i = encodeVarintMapsproto2(dAtA, i, uint64(k))
2877 i--
2878 dAtA[i] = 0x8
2879 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2880 i--
2881 dAtA[i] = 0x1a
2882 }
2883 }
2884 if len(m.StringToFloatMap) > 0 {
2885 for k := range m.StringToFloatMap {
2886 v := m.StringToFloatMap[k]
2887 baseI := i
2888 i -= 4
2889 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(v))))
2890 i--
2891 dAtA[i] = 0x15
2892 i -= len(k)
2893 copy(dAtA[i:], k)
2894 i = encodeVarintMapsproto2(dAtA, i, uint64(len(k)))
2895 i--
2896 dAtA[i] = 0xa
2897 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2898 i--
2899 dAtA[i] = 0x12
2900 }
2901 }
2902 if len(m.StringToDoubleMap) > 0 {
2903 for k := range m.StringToDoubleMap {
2904 v := m.StringToDoubleMap[k]
2905 baseI := i
2906 i -= 8
2907 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
2908 i--
2909 dAtA[i] = 0x11
2910 i -= len(k)
2911 copy(dAtA[i:], k)
2912 i = encodeVarintMapsproto2(dAtA, i, uint64(len(k)))
2913 i--
2914 dAtA[i] = 0xa
2915 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2916 i--
2917 dAtA[i] = 0xa
2918 }
2919 }
2920 return len(dAtA) - i, nil
2921 }
2922
2923 func (m *AllMapsOrdered) Marshal() (dAtA []byte, err error) {
2924 size := m.Size()
2925 dAtA = make([]byte, size)
2926 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2927 if err != nil {
2928 return nil, err
2929 }
2930 return dAtA[:n], nil
2931 }
2932
2933 func (m *AllMapsOrdered) MarshalTo(dAtA []byte) (int, error) {
2934 size := m.Size()
2935 return m.MarshalToSizedBuffer(dAtA[:size])
2936 }
2937
2938 func (m *AllMapsOrdered) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2939 i := len(dAtA)
2940 _ = i
2941 var l int
2942 _ = l
2943 if m.XXX_unrecognized != nil {
2944 i -= len(m.XXX_unrecognized)
2945 copy(dAtA[i:], m.XXX_unrecognized)
2946 }
2947 if len(m.StringToMsgMap) > 0 {
2948 keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap))
2949 for k := range m.StringToMsgMap {
2950 keysForStringToMsgMap = append(keysForStringToMsgMap, string(k))
2951 }
2952 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
2953 for iNdEx := len(keysForStringToMsgMap) - 1; iNdEx >= 0; iNdEx-- {
2954 v := m.StringToMsgMap[string(keysForStringToMsgMap[iNdEx])]
2955 baseI := i
2956 if v != nil {
2957 {
2958 size, err := v.MarshalToSizedBuffer(dAtA[:i])
2959 if err != nil {
2960 return 0, err
2961 }
2962 i -= size
2963 i = encodeVarintMapsproto2(dAtA, i, uint64(size))
2964 }
2965 i--
2966 dAtA[i] = 0x12
2967 }
2968 i -= len(keysForStringToMsgMap[iNdEx])
2969 copy(dAtA[i:], keysForStringToMsgMap[iNdEx])
2970 i = encodeVarintMapsproto2(dAtA, i, uint64(len(keysForStringToMsgMap[iNdEx])))
2971 i--
2972 dAtA[i] = 0xa
2973 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2974 i--
2975 dAtA[i] = 0x1
2976 i--
2977 dAtA[i] = 0x8a
2978 }
2979 }
2980 if len(m.StringToEnumMap) > 0 {
2981 keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap))
2982 for k := range m.StringToEnumMap {
2983 keysForStringToEnumMap = append(keysForStringToEnumMap, string(k))
2984 }
2985 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
2986 for iNdEx := len(keysForStringToEnumMap) - 1; iNdEx >= 0; iNdEx-- {
2987 v := m.StringToEnumMap[string(keysForStringToEnumMap[iNdEx])]
2988 baseI := i
2989 i = encodeVarintMapsproto2(dAtA, i, uint64(v))
2990 i--
2991 dAtA[i] = 0x10
2992 i -= len(keysForStringToEnumMap[iNdEx])
2993 copy(dAtA[i:], keysForStringToEnumMap[iNdEx])
2994 i = encodeVarintMapsproto2(dAtA, i, uint64(len(keysForStringToEnumMap[iNdEx])))
2995 i--
2996 dAtA[i] = 0xa
2997 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
2998 i--
2999 dAtA[i] = 0x1
3000 i--
3001 dAtA[i] = 0x82
3002 }
3003 }
3004 if len(m.StringToBytesMap) > 0 {
3005 keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap))
3006 for k := range m.StringToBytesMap {
3007 keysForStringToBytesMap = append(keysForStringToBytesMap, string(k))
3008 }
3009 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
3010 for iNdEx := len(keysForStringToBytesMap) - 1; iNdEx >= 0; iNdEx-- {
3011 v := m.StringToBytesMap[string(keysForStringToBytesMap[iNdEx])]
3012 baseI := i
3013 if v != nil {
3014 i -= len(v)
3015 copy(dAtA[i:], v)
3016 i = encodeVarintMapsproto2(dAtA, i, uint64(len(v)))
3017 i--
3018 dAtA[i] = 0x12
3019 }
3020 i -= len(keysForStringToBytesMap[iNdEx])
3021 copy(dAtA[i:], keysForStringToBytesMap[iNdEx])
3022 i = encodeVarintMapsproto2(dAtA, i, uint64(len(keysForStringToBytesMap[iNdEx])))
3023 i--
3024 dAtA[i] = 0xa
3025 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3026 i--
3027 dAtA[i] = 0x7a
3028 }
3029 }
3030 if len(m.StringMap) > 0 {
3031 keysForStringMap := make([]string, 0, len(m.StringMap))
3032 for k := range m.StringMap {
3033 keysForStringMap = append(keysForStringMap, string(k))
3034 }
3035 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
3036 for iNdEx := len(keysForStringMap) - 1; iNdEx >= 0; iNdEx-- {
3037 v := m.StringMap[string(keysForStringMap[iNdEx])]
3038 baseI := i
3039 i -= len(v)
3040 copy(dAtA[i:], v)
3041 i = encodeVarintMapsproto2(dAtA, i, uint64(len(v)))
3042 i--
3043 dAtA[i] = 0x12
3044 i -= len(keysForStringMap[iNdEx])
3045 copy(dAtA[i:], keysForStringMap[iNdEx])
3046 i = encodeVarintMapsproto2(dAtA, i, uint64(len(keysForStringMap[iNdEx])))
3047 i--
3048 dAtA[i] = 0xa
3049 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3050 i--
3051 dAtA[i] = 0x72
3052 }
3053 }
3054 if len(m.BoolMap) > 0 {
3055 keysForBoolMap := make([]bool, 0, len(m.BoolMap))
3056 for k := range m.BoolMap {
3057 keysForBoolMap = append(keysForBoolMap, bool(k))
3058 }
3059 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
3060 for iNdEx := len(keysForBoolMap) - 1; iNdEx >= 0; iNdEx-- {
3061 v := m.BoolMap[bool(keysForBoolMap[iNdEx])]
3062 baseI := i
3063 i--
3064 if v {
3065 dAtA[i] = 1
3066 } else {
3067 dAtA[i] = 0
3068 }
3069 i--
3070 dAtA[i] = 0x10
3071 i--
3072 if keysForBoolMap[iNdEx] {
3073 dAtA[i] = 1
3074 } else {
3075 dAtA[i] = 0
3076 }
3077 i--
3078 dAtA[i] = 0x8
3079 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3080 i--
3081 dAtA[i] = 0x6a
3082 }
3083 }
3084 if len(m.Sfixed64Map) > 0 {
3085 keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map))
3086 for k := range m.Sfixed64Map {
3087 keysForSfixed64Map = append(keysForSfixed64Map, int64(k))
3088 }
3089 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
3090 for iNdEx := len(keysForSfixed64Map) - 1; iNdEx >= 0; iNdEx-- {
3091 v := m.Sfixed64Map[int64(keysForSfixed64Map[iNdEx])]
3092 baseI := i
3093 i -= 8
3094 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
3095 i--
3096 dAtA[i] = 0x11
3097 i -= 8
3098 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(keysForSfixed64Map[iNdEx]))
3099 i--
3100 dAtA[i] = 0x9
3101 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3102 i--
3103 dAtA[i] = 0x62
3104 }
3105 }
3106 if len(m.Fixed64Map) > 0 {
3107 keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map))
3108 for k := range m.Fixed64Map {
3109 keysForFixed64Map = append(keysForFixed64Map, uint64(k))
3110 }
3111 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
3112 for iNdEx := len(keysForFixed64Map) - 1; iNdEx >= 0; iNdEx-- {
3113 v := m.Fixed64Map[uint64(keysForFixed64Map[iNdEx])]
3114 baseI := i
3115 i -= 8
3116 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
3117 i--
3118 dAtA[i] = 0x11
3119 i -= 8
3120 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(keysForFixed64Map[iNdEx]))
3121 i--
3122 dAtA[i] = 0x9
3123 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3124 i--
3125 dAtA[i] = 0x5a
3126 }
3127 }
3128 if len(m.Sfixed32Map) > 0 {
3129 keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map))
3130 for k := range m.Sfixed32Map {
3131 keysForSfixed32Map = append(keysForSfixed32Map, int32(k))
3132 }
3133 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
3134 for iNdEx := len(keysForSfixed32Map) - 1; iNdEx >= 0; iNdEx-- {
3135 v := m.Sfixed32Map[int32(keysForSfixed32Map[iNdEx])]
3136 baseI := i
3137 i -= 4
3138 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
3139 i--
3140 dAtA[i] = 0x15
3141 i -= 4
3142 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(keysForSfixed32Map[iNdEx]))
3143 i--
3144 dAtA[i] = 0xd
3145 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3146 i--
3147 dAtA[i] = 0x52
3148 }
3149 }
3150 if len(m.Fixed32Map) > 0 {
3151 keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map))
3152 for k := range m.Fixed32Map {
3153 keysForFixed32Map = append(keysForFixed32Map, uint32(k))
3154 }
3155 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
3156 for iNdEx := len(keysForFixed32Map) - 1; iNdEx >= 0; iNdEx-- {
3157 v := m.Fixed32Map[uint32(keysForFixed32Map[iNdEx])]
3158 baseI := i
3159 i -= 4
3160 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
3161 i--
3162 dAtA[i] = 0x15
3163 i -= 4
3164 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(keysForFixed32Map[iNdEx]))
3165 i--
3166 dAtA[i] = 0xd
3167 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3168 i--
3169 dAtA[i] = 0x4a
3170 }
3171 }
3172 if len(m.Sint64Map) > 0 {
3173 keysForSint64Map := make([]int64, 0, len(m.Sint64Map))
3174 for k := range m.Sint64Map {
3175 keysForSint64Map = append(keysForSint64Map, int64(k))
3176 }
3177 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
3178 for iNdEx := len(keysForSint64Map) - 1; iNdEx >= 0; iNdEx-- {
3179 v := m.Sint64Map[int64(keysForSint64Map[iNdEx])]
3180 baseI := i
3181 i = encodeVarintMapsproto2(dAtA, i, uint64((uint64(v)<<1)^uint64((v>>63))))
3182 i--
3183 dAtA[i] = 0x10
3184 i = encodeVarintMapsproto2(dAtA, i, uint64((uint64(keysForSint64Map[iNdEx])<<1)^uint64((keysForSint64Map[iNdEx]>>63))))
3185 i--
3186 dAtA[i] = 0x8
3187 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3188 i--
3189 dAtA[i] = 0x42
3190 }
3191 }
3192 if len(m.Sint32Map) > 0 {
3193 keysForSint32Map := make([]int32, 0, len(m.Sint32Map))
3194 for k := range m.Sint32Map {
3195 keysForSint32Map = append(keysForSint32Map, int32(k))
3196 }
3197 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
3198 for iNdEx := len(keysForSint32Map) - 1; iNdEx >= 0; iNdEx-- {
3199 v := m.Sint32Map[int32(keysForSint32Map[iNdEx])]
3200 baseI := i
3201 i = encodeVarintMapsproto2(dAtA, i, uint64((uint32(v)<<1)^uint32((v>>31))))
3202 i--
3203 dAtA[i] = 0x10
3204 i = encodeVarintMapsproto2(dAtA, i, uint64((uint32(keysForSint32Map[iNdEx])<<1)^uint32((keysForSint32Map[iNdEx]>>31))))
3205 i--
3206 dAtA[i] = 0x8
3207 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3208 i--
3209 dAtA[i] = 0x3a
3210 }
3211 }
3212 if len(m.Uint64Map) > 0 {
3213 keysForUint64Map := make([]uint64, 0, len(m.Uint64Map))
3214 for k := range m.Uint64Map {
3215 keysForUint64Map = append(keysForUint64Map, uint64(k))
3216 }
3217 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
3218 for iNdEx := len(keysForUint64Map) - 1; iNdEx >= 0; iNdEx-- {
3219 v := m.Uint64Map[uint64(keysForUint64Map[iNdEx])]
3220 baseI := i
3221 i = encodeVarintMapsproto2(dAtA, i, uint64(v))
3222 i--
3223 dAtA[i] = 0x10
3224 i = encodeVarintMapsproto2(dAtA, i, uint64(keysForUint64Map[iNdEx]))
3225 i--
3226 dAtA[i] = 0x8
3227 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3228 i--
3229 dAtA[i] = 0x32
3230 }
3231 }
3232 if len(m.Uint32Map) > 0 {
3233 keysForUint32Map := make([]uint32, 0, len(m.Uint32Map))
3234 for k := range m.Uint32Map {
3235 keysForUint32Map = append(keysForUint32Map, uint32(k))
3236 }
3237 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
3238 for iNdEx := len(keysForUint32Map) - 1; iNdEx >= 0; iNdEx-- {
3239 v := m.Uint32Map[uint32(keysForUint32Map[iNdEx])]
3240 baseI := i
3241 i = encodeVarintMapsproto2(dAtA, i, uint64(v))
3242 i--
3243 dAtA[i] = 0x10
3244 i = encodeVarintMapsproto2(dAtA, i, uint64(keysForUint32Map[iNdEx]))
3245 i--
3246 dAtA[i] = 0x8
3247 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3248 i--
3249 dAtA[i] = 0x2a
3250 }
3251 }
3252 if len(m.Int64Map) > 0 {
3253 keysForInt64Map := make([]int64, 0, len(m.Int64Map))
3254 for k := range m.Int64Map {
3255 keysForInt64Map = append(keysForInt64Map, int64(k))
3256 }
3257 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
3258 for iNdEx := len(keysForInt64Map) - 1; iNdEx >= 0; iNdEx-- {
3259 v := m.Int64Map[int64(keysForInt64Map[iNdEx])]
3260 baseI := i
3261 i = encodeVarintMapsproto2(dAtA, i, uint64(v))
3262 i--
3263 dAtA[i] = 0x10
3264 i = encodeVarintMapsproto2(dAtA, i, uint64(keysForInt64Map[iNdEx]))
3265 i--
3266 dAtA[i] = 0x8
3267 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3268 i--
3269 dAtA[i] = 0x22
3270 }
3271 }
3272 if len(m.Int32Map) > 0 {
3273 keysForInt32Map := make([]int32, 0, len(m.Int32Map))
3274 for k := range m.Int32Map {
3275 keysForInt32Map = append(keysForInt32Map, int32(k))
3276 }
3277 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
3278 for iNdEx := len(keysForInt32Map) - 1; iNdEx >= 0; iNdEx-- {
3279 v := m.Int32Map[int32(keysForInt32Map[iNdEx])]
3280 baseI := i
3281 i = encodeVarintMapsproto2(dAtA, i, uint64(v))
3282 i--
3283 dAtA[i] = 0x10
3284 i = encodeVarintMapsproto2(dAtA, i, uint64(keysForInt32Map[iNdEx]))
3285 i--
3286 dAtA[i] = 0x8
3287 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3288 i--
3289 dAtA[i] = 0x1a
3290 }
3291 }
3292 if len(m.StringToFloatMap) > 0 {
3293 keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap))
3294 for k := range m.StringToFloatMap {
3295 keysForStringToFloatMap = append(keysForStringToFloatMap, string(k))
3296 }
3297 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
3298 for iNdEx := len(keysForStringToFloatMap) - 1; iNdEx >= 0; iNdEx-- {
3299 v := m.StringToFloatMap[string(keysForStringToFloatMap[iNdEx])]
3300 baseI := i
3301 i -= 4
3302 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(v))))
3303 i--
3304 dAtA[i] = 0x15
3305 i -= len(keysForStringToFloatMap[iNdEx])
3306 copy(dAtA[i:], keysForStringToFloatMap[iNdEx])
3307 i = encodeVarintMapsproto2(dAtA, i, uint64(len(keysForStringToFloatMap[iNdEx])))
3308 i--
3309 dAtA[i] = 0xa
3310 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3311 i--
3312 dAtA[i] = 0x12
3313 }
3314 }
3315 if len(m.StringToDoubleMap) > 0 {
3316 keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap))
3317 for k := range m.StringToDoubleMap {
3318 keysForStringToDoubleMap = append(keysForStringToDoubleMap, string(k))
3319 }
3320 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
3321 for iNdEx := len(keysForStringToDoubleMap) - 1; iNdEx >= 0; iNdEx-- {
3322 v := m.StringToDoubleMap[string(keysForStringToDoubleMap[iNdEx])]
3323 baseI := i
3324 i -= 8
3325 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
3326 i--
3327 dAtA[i] = 0x11
3328 i -= len(keysForStringToDoubleMap[iNdEx])
3329 copy(dAtA[i:], keysForStringToDoubleMap[iNdEx])
3330 i = encodeVarintMapsproto2(dAtA, i, uint64(len(keysForStringToDoubleMap[iNdEx])))
3331 i--
3332 dAtA[i] = 0xa
3333 i = encodeVarintMapsproto2(dAtA, i, uint64(baseI-i))
3334 i--
3335 dAtA[i] = 0xa
3336 }
3337 }
3338 return len(dAtA) - i, nil
3339 }
3340
3341 func encodeVarintMapsproto2(dAtA []byte, offset int, v uint64) int {
3342 offset -= sovMapsproto2(v)
3343 base := offset
3344 for v >= 1<<7 {
3345 dAtA[offset] = uint8(v&0x7f | 0x80)
3346 v >>= 7
3347 offset++
3348 }
3349 dAtA[offset] = uint8(v)
3350 return base
3351 }
3352 func NewPopulatedFloatingPoint(r randyMapsproto2, easy bool) *FloatingPoint {
3353 this := &FloatingPoint{}
3354 if r.Intn(5) != 0 {
3355 v1 := float64(r.Float64())
3356 if r.Intn(2) == 0 {
3357 v1 *= -1
3358 }
3359 this.F = &v1
3360 }
3361 if !easy && r.Intn(10) != 0 {
3362 this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 2)
3363 }
3364 return this
3365 }
3366
3367 func NewPopulatedCustomMap(r randyMapsproto2, easy bool) *CustomMap {
3368 this := &CustomMap{}
3369 if r.Intn(5) != 0 {
3370 v2 := r.Intn(10)
3371 this.Nullable128S = make(map[string]*github_com_gogo_protobuf_test_custom.Uint128)
3372 for i := 0; i < v2; i++ {
3373 this.Nullable128S[randStringMapsproto2(r)] = (*github_com_gogo_protobuf_test_custom.Uint128)(github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r))
3374 }
3375 }
3376 if r.Intn(5) != 0 {
3377 v3 := r.Intn(10)
3378 this.Uint128S = make(map[string]github_com_gogo_protobuf_test_custom.Uint128)
3379 for i := 0; i < v3; i++ {
3380 this.Uint128S[randStringMapsproto2(r)] = (github_com_gogo_protobuf_test_custom.Uint128)(*github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r))
3381 }
3382 }
3383 if r.Intn(5) != 0 {
3384 v4 := r.Intn(10)
3385 this.NullableIds = make(map[string]*github_com_gogo_protobuf_test.Uuid)
3386 for i := 0; i < v4; i++ {
3387 this.NullableIds[randStringMapsproto2(r)] = (*github_com_gogo_protobuf_test.Uuid)(github_com_gogo_protobuf_test.NewPopulatedUuid(r))
3388 }
3389 }
3390 if r.Intn(5) != 0 {
3391 v5 := r.Intn(10)
3392 this.Ids = make(map[string]github_com_gogo_protobuf_test.Uuid)
3393 for i := 0; i < v5; i++ {
3394 this.Ids[randStringMapsproto2(r)] = (github_com_gogo_protobuf_test.Uuid)(*github_com_gogo_protobuf_test.NewPopulatedUuid(r))
3395 }
3396 }
3397 if !easy && r.Intn(10) != 0 {
3398 this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 5)
3399 }
3400 return this
3401 }
3402
3403 func NewPopulatedAllMaps(r randyMapsproto2, easy bool) *AllMaps {
3404 this := &AllMaps{}
3405 if r.Intn(5) != 0 {
3406 v6 := r.Intn(10)
3407 this.StringToDoubleMap = make(map[string]float64)
3408 for i := 0; i < v6; i++ {
3409 v7 := randStringMapsproto2(r)
3410 this.StringToDoubleMap[v7] = float64(r.Float64())
3411 if r.Intn(2) == 0 {
3412 this.StringToDoubleMap[v7] *= -1
3413 }
3414 }
3415 }
3416 if r.Intn(5) != 0 {
3417 v8 := r.Intn(10)
3418 this.StringToFloatMap = make(map[string]float32)
3419 for i := 0; i < v8; i++ {
3420 v9 := randStringMapsproto2(r)
3421 this.StringToFloatMap[v9] = float32(r.Float32())
3422 if r.Intn(2) == 0 {
3423 this.StringToFloatMap[v9] *= -1
3424 }
3425 }
3426 }
3427 if r.Intn(5) != 0 {
3428 v10 := r.Intn(10)
3429 this.Int32Map = make(map[int32]int32)
3430 for i := 0; i < v10; i++ {
3431 v11 := int32(r.Int31())
3432 this.Int32Map[v11] = int32(r.Int31())
3433 if r.Intn(2) == 0 {
3434 this.Int32Map[v11] *= -1
3435 }
3436 }
3437 }
3438 if r.Intn(5) != 0 {
3439 v12 := r.Intn(10)
3440 this.Int64Map = make(map[int64]int64)
3441 for i := 0; i < v12; i++ {
3442 v13 := int64(r.Int63())
3443 this.Int64Map[v13] = int64(r.Int63())
3444 if r.Intn(2) == 0 {
3445 this.Int64Map[v13] *= -1
3446 }
3447 }
3448 }
3449 if r.Intn(5) != 0 {
3450 v14 := r.Intn(10)
3451 this.Uint32Map = make(map[uint32]uint32)
3452 for i := 0; i < v14; i++ {
3453 v15 := uint32(r.Uint32())
3454 this.Uint32Map[v15] = uint32(r.Uint32())
3455 }
3456 }
3457 if r.Intn(5) != 0 {
3458 v16 := r.Intn(10)
3459 this.Uint64Map = make(map[uint64]uint64)
3460 for i := 0; i < v16; i++ {
3461 v17 := uint64(uint64(r.Uint32()))
3462 this.Uint64Map[v17] = uint64(uint64(r.Uint32()))
3463 }
3464 }
3465 if r.Intn(5) != 0 {
3466 v18 := r.Intn(10)
3467 this.Sint32Map = make(map[int32]int32)
3468 for i := 0; i < v18; i++ {
3469 v19 := int32(r.Int31())
3470 this.Sint32Map[v19] = int32(r.Int31())
3471 if r.Intn(2) == 0 {
3472 this.Sint32Map[v19] *= -1
3473 }
3474 }
3475 }
3476 if r.Intn(5) != 0 {
3477 v20 := r.Intn(10)
3478 this.Sint64Map = make(map[int64]int64)
3479 for i := 0; i < v20; i++ {
3480 v21 := int64(r.Int63())
3481 this.Sint64Map[v21] = int64(r.Int63())
3482 if r.Intn(2) == 0 {
3483 this.Sint64Map[v21] *= -1
3484 }
3485 }
3486 }
3487 if r.Intn(5) != 0 {
3488 v22 := r.Intn(10)
3489 this.Fixed32Map = make(map[uint32]uint32)
3490 for i := 0; i < v22; i++ {
3491 v23 := uint32(r.Uint32())
3492 this.Fixed32Map[v23] = uint32(r.Uint32())
3493 }
3494 }
3495 if r.Intn(5) != 0 {
3496 v24 := r.Intn(10)
3497 this.Sfixed32Map = make(map[int32]int32)
3498 for i := 0; i < v24; i++ {
3499 v25 := int32(r.Int31())
3500 this.Sfixed32Map[v25] = int32(r.Int31())
3501 if r.Intn(2) == 0 {
3502 this.Sfixed32Map[v25] *= -1
3503 }
3504 }
3505 }
3506 if r.Intn(5) != 0 {
3507 v26 := r.Intn(10)
3508 this.Fixed64Map = make(map[uint64]uint64)
3509 for i := 0; i < v26; i++ {
3510 v27 := uint64(uint64(r.Uint32()))
3511 this.Fixed64Map[v27] = uint64(uint64(r.Uint32()))
3512 }
3513 }
3514 if r.Intn(5) != 0 {
3515 v28 := r.Intn(10)
3516 this.Sfixed64Map = make(map[int64]int64)
3517 for i := 0; i < v28; i++ {
3518 v29 := int64(r.Int63())
3519 this.Sfixed64Map[v29] = int64(r.Int63())
3520 if r.Intn(2) == 0 {
3521 this.Sfixed64Map[v29] *= -1
3522 }
3523 }
3524 }
3525 if r.Intn(5) != 0 {
3526 v30 := r.Intn(10)
3527 this.BoolMap = make(map[bool]bool)
3528 for i := 0; i < v30; i++ {
3529 v31 := bool(bool(r.Intn(2) == 0))
3530 this.BoolMap[v31] = bool(bool(r.Intn(2) == 0))
3531 }
3532 }
3533 if r.Intn(5) != 0 {
3534 v32 := r.Intn(10)
3535 this.StringMap = make(map[string]string)
3536 for i := 0; i < v32; i++ {
3537 this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r)
3538 }
3539 }
3540 if r.Intn(5) != 0 {
3541 v33 := r.Intn(10)
3542 this.StringToBytesMap = make(map[string][]byte)
3543 for i := 0; i < v33; i++ {
3544 v34 := r.Intn(100)
3545 v35 := randStringMapsproto2(r)
3546 this.StringToBytesMap[v35] = make([]byte, v34)
3547 for i := 0; i < v34; i++ {
3548 this.StringToBytesMap[v35][i] = byte(r.Intn(256))
3549 }
3550 }
3551 }
3552 if r.Intn(5) != 0 {
3553 v36 := r.Intn(10)
3554 this.StringToEnumMap = make(map[string]MapEnum)
3555 for i := 0; i < v36; i++ {
3556 this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)])
3557 }
3558 }
3559 if r.Intn(5) != 0 {
3560 v37 := r.Intn(10)
3561 this.StringToMsgMap = make(map[string]*FloatingPoint)
3562 for i := 0; i < v37; i++ {
3563 this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy)
3564 }
3565 }
3566 if !easy && r.Intn(10) != 0 {
3567 this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18)
3568 }
3569 return this
3570 }
3571
3572 func NewPopulatedAllMapsOrdered(r randyMapsproto2, easy bool) *AllMapsOrdered {
3573 this := &AllMapsOrdered{}
3574 if r.Intn(5) != 0 {
3575 v38 := r.Intn(10)
3576 this.StringToDoubleMap = make(map[string]float64)
3577 for i := 0; i < v38; i++ {
3578 v39 := randStringMapsproto2(r)
3579 this.StringToDoubleMap[v39] = float64(r.Float64())
3580 if r.Intn(2) == 0 {
3581 this.StringToDoubleMap[v39] *= -1
3582 }
3583 }
3584 }
3585 if r.Intn(5) != 0 {
3586 v40 := r.Intn(10)
3587 this.StringToFloatMap = make(map[string]float32)
3588 for i := 0; i < v40; i++ {
3589 v41 := randStringMapsproto2(r)
3590 this.StringToFloatMap[v41] = float32(r.Float32())
3591 if r.Intn(2) == 0 {
3592 this.StringToFloatMap[v41] *= -1
3593 }
3594 }
3595 }
3596 if r.Intn(5) != 0 {
3597 v42 := r.Intn(10)
3598 this.Int32Map = make(map[int32]int32)
3599 for i := 0; i < v42; i++ {
3600 v43 := int32(r.Int31())
3601 this.Int32Map[v43] = int32(r.Int31())
3602 if r.Intn(2) == 0 {
3603 this.Int32Map[v43] *= -1
3604 }
3605 }
3606 }
3607 if r.Intn(5) != 0 {
3608 v44 := r.Intn(10)
3609 this.Int64Map = make(map[int64]int64)
3610 for i := 0; i < v44; i++ {
3611 v45 := int64(r.Int63())
3612 this.Int64Map[v45] = int64(r.Int63())
3613 if r.Intn(2) == 0 {
3614 this.Int64Map[v45] *= -1
3615 }
3616 }
3617 }
3618 if r.Intn(5) != 0 {
3619 v46 := r.Intn(10)
3620 this.Uint32Map = make(map[uint32]uint32)
3621 for i := 0; i < v46; i++ {
3622 v47 := uint32(r.Uint32())
3623 this.Uint32Map[v47] = uint32(r.Uint32())
3624 }
3625 }
3626 if r.Intn(5) != 0 {
3627 v48 := r.Intn(10)
3628 this.Uint64Map = make(map[uint64]uint64)
3629 for i := 0; i < v48; i++ {
3630 v49 := uint64(uint64(r.Uint32()))
3631 this.Uint64Map[v49] = uint64(uint64(r.Uint32()))
3632 }
3633 }
3634 if r.Intn(5) != 0 {
3635 v50 := r.Intn(10)
3636 this.Sint32Map = make(map[int32]int32)
3637 for i := 0; i < v50; i++ {
3638 v51 := int32(r.Int31())
3639 this.Sint32Map[v51] = int32(r.Int31())
3640 if r.Intn(2) == 0 {
3641 this.Sint32Map[v51] *= -1
3642 }
3643 }
3644 }
3645 if r.Intn(5) != 0 {
3646 v52 := r.Intn(10)
3647 this.Sint64Map = make(map[int64]int64)
3648 for i := 0; i < v52; i++ {
3649 v53 := int64(r.Int63())
3650 this.Sint64Map[v53] = int64(r.Int63())
3651 if r.Intn(2) == 0 {
3652 this.Sint64Map[v53] *= -1
3653 }
3654 }
3655 }
3656 if r.Intn(5) != 0 {
3657 v54 := r.Intn(10)
3658 this.Fixed32Map = make(map[uint32]uint32)
3659 for i := 0; i < v54; i++ {
3660 v55 := uint32(r.Uint32())
3661 this.Fixed32Map[v55] = uint32(r.Uint32())
3662 }
3663 }
3664 if r.Intn(5) != 0 {
3665 v56 := r.Intn(10)
3666 this.Sfixed32Map = make(map[int32]int32)
3667 for i := 0; i < v56; i++ {
3668 v57 := int32(r.Int31())
3669 this.Sfixed32Map[v57] = int32(r.Int31())
3670 if r.Intn(2) == 0 {
3671 this.Sfixed32Map[v57] *= -1
3672 }
3673 }
3674 }
3675 if r.Intn(5) != 0 {
3676 v58 := r.Intn(10)
3677 this.Fixed64Map = make(map[uint64]uint64)
3678 for i := 0; i < v58; i++ {
3679 v59 := uint64(uint64(r.Uint32()))
3680 this.Fixed64Map[v59] = uint64(uint64(r.Uint32()))
3681 }
3682 }
3683 if r.Intn(5) != 0 {
3684 v60 := r.Intn(10)
3685 this.Sfixed64Map = make(map[int64]int64)
3686 for i := 0; i < v60; i++ {
3687 v61 := int64(r.Int63())
3688 this.Sfixed64Map[v61] = int64(r.Int63())
3689 if r.Intn(2) == 0 {
3690 this.Sfixed64Map[v61] *= -1
3691 }
3692 }
3693 }
3694 if r.Intn(5) != 0 {
3695 v62 := r.Intn(10)
3696 this.BoolMap = make(map[bool]bool)
3697 for i := 0; i < v62; i++ {
3698 v63 := bool(bool(r.Intn(2) == 0))
3699 this.BoolMap[v63] = bool(bool(r.Intn(2) == 0))
3700 }
3701 }
3702 if r.Intn(5) != 0 {
3703 v64 := r.Intn(10)
3704 this.StringMap = make(map[string]string)
3705 for i := 0; i < v64; i++ {
3706 this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r)
3707 }
3708 }
3709 if r.Intn(5) != 0 {
3710 v65 := r.Intn(10)
3711 this.StringToBytesMap = make(map[string][]byte)
3712 for i := 0; i < v65; i++ {
3713 v66 := r.Intn(100)
3714 v67 := randStringMapsproto2(r)
3715 this.StringToBytesMap[v67] = make([]byte, v66)
3716 for i := 0; i < v66; i++ {
3717 this.StringToBytesMap[v67][i] = byte(r.Intn(256))
3718 }
3719 }
3720 }
3721 if r.Intn(5) != 0 {
3722 v68 := r.Intn(10)
3723 this.StringToEnumMap = make(map[string]MapEnum)
3724 for i := 0; i < v68; i++ {
3725 this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)])
3726 }
3727 }
3728 if r.Intn(5) != 0 {
3729 v69 := r.Intn(10)
3730 this.StringToMsgMap = make(map[string]*FloatingPoint)
3731 for i := 0; i < v69; i++ {
3732 this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy)
3733 }
3734 }
3735 if !easy && r.Intn(10) != 0 {
3736 this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18)
3737 }
3738 return this
3739 }
3740
3741 type randyMapsproto2 interface {
3742 Float32() float32
3743 Float64() float64
3744 Int63() int64
3745 Int31() int32
3746 Uint32() uint32
3747 Intn(n int) int
3748 }
3749
3750 func randUTF8RuneMapsproto2(r randyMapsproto2) rune {
3751 ru := r.Intn(62)
3752 if ru < 10 {
3753 return rune(ru + 48)
3754 } else if ru < 36 {
3755 return rune(ru + 55)
3756 }
3757 return rune(ru + 61)
3758 }
3759 func randStringMapsproto2(r randyMapsproto2) string {
3760 v70 := r.Intn(100)
3761 tmps := make([]rune, v70)
3762 for i := 0; i < v70; i++ {
3763 tmps[i] = randUTF8RuneMapsproto2(r)
3764 }
3765 return string(tmps)
3766 }
3767 func randUnrecognizedMapsproto2(r randyMapsproto2, maxFieldNumber int) (dAtA []byte) {
3768 l := r.Intn(5)
3769 for i := 0; i < l; i++ {
3770 wire := r.Intn(4)
3771 if wire == 3 {
3772 wire = 5
3773 }
3774 fieldNumber := maxFieldNumber + r.Intn(100)
3775 dAtA = randFieldMapsproto2(dAtA, r, fieldNumber, wire)
3776 }
3777 return dAtA
3778 }
3779 func randFieldMapsproto2(dAtA []byte, r randyMapsproto2, fieldNumber int, wire int) []byte {
3780 key := uint32(fieldNumber)<<3 | uint32(wire)
3781 switch wire {
3782 case 0:
3783 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(key))
3784 v71 := r.Int63()
3785 if r.Intn(2) == 0 {
3786 v71 *= -1
3787 }
3788 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(v71))
3789 case 1:
3790 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(key))
3791 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
3792 case 2:
3793 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(key))
3794 ll := r.Intn(100)
3795 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(ll))
3796 for j := 0; j < ll; j++ {
3797 dAtA = append(dAtA, byte(r.Intn(256)))
3798 }
3799 default:
3800 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(key))
3801 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
3802 }
3803 return dAtA
3804 }
3805 func encodeVarintPopulateMapsproto2(dAtA []byte, v uint64) []byte {
3806 for v >= 1<<7 {
3807 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
3808 v >>= 7
3809 }
3810 dAtA = append(dAtA, uint8(v))
3811 return dAtA
3812 }
3813 func (m *FloatingPoint) Size() (n int) {
3814 if m == nil {
3815 return 0
3816 }
3817 var l int
3818 _ = l
3819 if m.F != nil {
3820 n += 9
3821 }
3822 if m.XXX_unrecognized != nil {
3823 n += len(m.XXX_unrecognized)
3824 }
3825 return n
3826 }
3827
3828 func (m *CustomMap) Size() (n int) {
3829 if m == nil {
3830 return 0
3831 }
3832 var l int
3833 _ = l
3834 if len(m.Nullable128S) > 0 {
3835 for k, v := range m.Nullable128S {
3836 _ = k
3837 _ = v
3838 l = 0
3839 if v != nil {
3840 l = v.Size()
3841 l += 1 + sovMapsproto2(uint64(l))
3842 }
3843 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
3844 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3845 }
3846 }
3847 if len(m.Uint128S) > 0 {
3848 for k, v := range m.Uint128S {
3849 _ = k
3850 _ = v
3851 l = 0
3852 l = v.Size()
3853 l += 1 + sovMapsproto2(uint64(l))
3854 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
3855 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3856 }
3857 }
3858 if len(m.NullableIds) > 0 {
3859 for k, v := range m.NullableIds {
3860 _ = k
3861 _ = v
3862 l = 0
3863 if v != nil {
3864 l = v.Size()
3865 l += 1 + sovMapsproto2(uint64(l))
3866 }
3867 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
3868 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3869 }
3870 }
3871 if len(m.Ids) > 0 {
3872 for k, v := range m.Ids {
3873 _ = k
3874 _ = v
3875 l = 0
3876 l = v.Size()
3877 l += 1 + sovMapsproto2(uint64(l))
3878 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
3879 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3880 }
3881 }
3882 if m.XXX_unrecognized != nil {
3883 n += len(m.XXX_unrecognized)
3884 }
3885 return n
3886 }
3887
3888 func (m *AllMaps) Size() (n int) {
3889 if m == nil {
3890 return 0
3891 }
3892 var l int
3893 _ = l
3894 if len(m.StringToDoubleMap) > 0 {
3895 for k, v := range m.StringToDoubleMap {
3896 _ = k
3897 _ = v
3898 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8
3899 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3900 }
3901 }
3902 if len(m.StringToFloatMap) > 0 {
3903 for k, v := range m.StringToFloatMap {
3904 _ = k
3905 _ = v
3906 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4
3907 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3908 }
3909 }
3910 if len(m.Int32Map) > 0 {
3911 for k, v := range m.Int32Map {
3912 _ = k
3913 _ = v
3914 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
3915 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3916 }
3917 }
3918 if len(m.Int64Map) > 0 {
3919 for k, v := range m.Int64Map {
3920 _ = k
3921 _ = v
3922 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
3923 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3924 }
3925 }
3926 if len(m.Uint32Map) > 0 {
3927 for k, v := range m.Uint32Map {
3928 _ = k
3929 _ = v
3930 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
3931 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3932 }
3933 }
3934 if len(m.Uint64Map) > 0 {
3935 for k, v := range m.Uint64Map {
3936 _ = k
3937 _ = v
3938 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
3939 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3940 }
3941 }
3942 if len(m.Sint32Map) > 0 {
3943 for k, v := range m.Sint32Map {
3944 _ = k
3945 _ = v
3946 mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v))
3947 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3948 }
3949 }
3950 if len(m.Sint64Map) > 0 {
3951 for k, v := range m.Sint64Map {
3952 _ = k
3953 _ = v
3954 mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v))
3955 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3956 }
3957 }
3958 if len(m.Fixed32Map) > 0 {
3959 for k, v := range m.Fixed32Map {
3960 _ = k
3961 _ = v
3962 mapEntrySize := 1 + 4 + 1 + 4
3963 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3964 }
3965 }
3966 if len(m.Sfixed32Map) > 0 {
3967 for k, v := range m.Sfixed32Map {
3968 _ = k
3969 _ = v
3970 mapEntrySize := 1 + 4 + 1 + 4
3971 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3972 }
3973 }
3974 if len(m.Fixed64Map) > 0 {
3975 for k, v := range m.Fixed64Map {
3976 _ = k
3977 _ = v
3978 mapEntrySize := 1 + 8 + 1 + 8
3979 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3980 }
3981 }
3982 if len(m.Sfixed64Map) > 0 {
3983 for k, v := range m.Sfixed64Map {
3984 _ = k
3985 _ = v
3986 mapEntrySize := 1 + 8 + 1 + 8
3987 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3988 }
3989 }
3990 if len(m.BoolMap) > 0 {
3991 for k, v := range m.BoolMap {
3992 _ = k
3993 _ = v
3994 mapEntrySize := 1 + 1 + 1 + 1
3995 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3996 }
3997 }
3998 if len(m.StringMap) > 0 {
3999 for k, v := range m.StringMap {
4000 _ = k
4001 _ = v
4002 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v)))
4003 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4004 }
4005 }
4006 if len(m.StringToBytesMap) > 0 {
4007 for k, v := range m.StringToBytesMap {
4008 _ = k
4009 _ = v
4010 l = 0
4011 if v != nil {
4012 l = 1 + len(v) + sovMapsproto2(uint64(len(v)))
4013 }
4014 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
4015 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4016 }
4017 }
4018 if len(m.StringToEnumMap) > 0 {
4019 for k, v := range m.StringToEnumMap {
4020 _ = k
4021 _ = v
4022 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v))
4023 n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize))
4024 }
4025 }
4026 if len(m.StringToMsgMap) > 0 {
4027 for k, v := range m.StringToMsgMap {
4028 _ = k
4029 _ = v
4030 l = 0
4031 if v != nil {
4032 l = v.Size()
4033 l += 1 + sovMapsproto2(uint64(l))
4034 }
4035 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
4036 n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize))
4037 }
4038 }
4039 if m.XXX_unrecognized != nil {
4040 n += len(m.XXX_unrecognized)
4041 }
4042 return n
4043 }
4044
4045 func (m *AllMapsOrdered) Size() (n int) {
4046 if m == nil {
4047 return 0
4048 }
4049 var l int
4050 _ = l
4051 if len(m.StringToDoubleMap) > 0 {
4052 for k, v := range m.StringToDoubleMap {
4053 _ = k
4054 _ = v
4055 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8
4056 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4057 }
4058 }
4059 if len(m.StringToFloatMap) > 0 {
4060 for k, v := range m.StringToFloatMap {
4061 _ = k
4062 _ = v
4063 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4
4064 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4065 }
4066 }
4067 if len(m.Int32Map) > 0 {
4068 for k, v := range m.Int32Map {
4069 _ = k
4070 _ = v
4071 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
4072 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4073 }
4074 }
4075 if len(m.Int64Map) > 0 {
4076 for k, v := range m.Int64Map {
4077 _ = k
4078 _ = v
4079 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
4080 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4081 }
4082 }
4083 if len(m.Uint32Map) > 0 {
4084 for k, v := range m.Uint32Map {
4085 _ = k
4086 _ = v
4087 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
4088 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4089 }
4090 }
4091 if len(m.Uint64Map) > 0 {
4092 for k, v := range m.Uint64Map {
4093 _ = k
4094 _ = v
4095 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
4096 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4097 }
4098 }
4099 if len(m.Sint32Map) > 0 {
4100 for k, v := range m.Sint32Map {
4101 _ = k
4102 _ = v
4103 mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v))
4104 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4105 }
4106 }
4107 if len(m.Sint64Map) > 0 {
4108 for k, v := range m.Sint64Map {
4109 _ = k
4110 _ = v
4111 mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v))
4112 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4113 }
4114 }
4115 if len(m.Fixed32Map) > 0 {
4116 for k, v := range m.Fixed32Map {
4117 _ = k
4118 _ = v
4119 mapEntrySize := 1 + 4 + 1 + 4
4120 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4121 }
4122 }
4123 if len(m.Sfixed32Map) > 0 {
4124 for k, v := range m.Sfixed32Map {
4125 _ = k
4126 _ = v
4127 mapEntrySize := 1 + 4 + 1 + 4
4128 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4129 }
4130 }
4131 if len(m.Fixed64Map) > 0 {
4132 for k, v := range m.Fixed64Map {
4133 _ = k
4134 _ = v
4135 mapEntrySize := 1 + 8 + 1 + 8
4136 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4137 }
4138 }
4139 if len(m.Sfixed64Map) > 0 {
4140 for k, v := range m.Sfixed64Map {
4141 _ = k
4142 _ = v
4143 mapEntrySize := 1 + 8 + 1 + 8
4144 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4145 }
4146 }
4147 if len(m.BoolMap) > 0 {
4148 for k, v := range m.BoolMap {
4149 _ = k
4150 _ = v
4151 mapEntrySize := 1 + 1 + 1 + 1
4152 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4153 }
4154 }
4155 if len(m.StringMap) > 0 {
4156 for k, v := range m.StringMap {
4157 _ = k
4158 _ = v
4159 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v)))
4160 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4161 }
4162 }
4163 if len(m.StringToBytesMap) > 0 {
4164 for k, v := range m.StringToBytesMap {
4165 _ = k
4166 _ = v
4167 l = 0
4168 if v != nil {
4169 l = 1 + len(v) + sovMapsproto2(uint64(len(v)))
4170 }
4171 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
4172 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
4173 }
4174 }
4175 if len(m.StringToEnumMap) > 0 {
4176 for k, v := range m.StringToEnumMap {
4177 _ = k
4178 _ = v
4179 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v))
4180 n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize))
4181 }
4182 }
4183 if len(m.StringToMsgMap) > 0 {
4184 for k, v := range m.StringToMsgMap {
4185 _ = k
4186 _ = v
4187 l = 0
4188 if v != nil {
4189 l = v.Size()
4190 l += 1 + sovMapsproto2(uint64(l))
4191 }
4192 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
4193 n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize))
4194 }
4195 }
4196 if m.XXX_unrecognized != nil {
4197 n += len(m.XXX_unrecognized)
4198 }
4199 return n
4200 }
4201
4202 func sovMapsproto2(x uint64) (n int) {
4203 return (math_bits.Len64(x|1) + 6) / 7
4204 }
4205 func sozMapsproto2(x uint64) (n int) {
4206 return sovMapsproto2(uint64((x << 1) ^ uint64((int64(x) >> 63))))
4207 }
4208 func (this *FloatingPoint) String() string {
4209 if this == nil {
4210 return "nil"
4211 }
4212 s := strings.Join([]string{`&FloatingPoint{`,
4213 `F:` + valueToStringMapsproto2(this.F) + `,`,
4214 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4215 `}`,
4216 }, "")
4217 return s
4218 }
4219 func (this *CustomMap) String() string {
4220 if this == nil {
4221 return "nil"
4222 }
4223 keysForNullable128S := make([]string, 0, len(this.Nullable128S))
4224 for k := range this.Nullable128S {
4225 keysForNullable128S = append(keysForNullable128S, k)
4226 }
4227 github_com_gogo_protobuf_sortkeys.Strings(keysForNullable128S)
4228 mapStringForNullable128S := "map[string]*github_com_gogo_protobuf_test_custom.Uint128{"
4229 for _, k := range keysForNullable128S {
4230 mapStringForNullable128S += fmt.Sprintf("%v: %v,", k, this.Nullable128S[k])
4231 }
4232 mapStringForNullable128S += "}"
4233 keysForUint128S := make([]string, 0, len(this.Uint128S))
4234 for k := range this.Uint128S {
4235 keysForUint128S = append(keysForUint128S, k)
4236 }
4237 github_com_gogo_protobuf_sortkeys.Strings(keysForUint128S)
4238 mapStringForUint128S := "map[string]github_com_gogo_protobuf_test_custom.Uint128{"
4239 for _, k := range keysForUint128S {
4240 mapStringForUint128S += fmt.Sprintf("%v: %v,", k, this.Uint128S[k])
4241 }
4242 mapStringForUint128S += "}"
4243 keysForNullableIds := make([]string, 0, len(this.NullableIds))
4244 for k := range this.NullableIds {
4245 keysForNullableIds = append(keysForNullableIds, k)
4246 }
4247 github_com_gogo_protobuf_sortkeys.Strings(keysForNullableIds)
4248 mapStringForNullableIds := "map[string]*github_com_gogo_protobuf_test.Uuid{"
4249 for _, k := range keysForNullableIds {
4250 mapStringForNullableIds += fmt.Sprintf("%v: %v,", k, this.NullableIds[k])
4251 }
4252 mapStringForNullableIds += "}"
4253 keysForIds := make([]string, 0, len(this.Ids))
4254 for k := range this.Ids {
4255 keysForIds = append(keysForIds, k)
4256 }
4257 github_com_gogo_protobuf_sortkeys.Strings(keysForIds)
4258 mapStringForIds := "map[string]github_com_gogo_protobuf_test.Uuid{"
4259 for _, k := range keysForIds {
4260 mapStringForIds += fmt.Sprintf("%v: %v,", k, this.Ids[k])
4261 }
4262 mapStringForIds += "}"
4263 s := strings.Join([]string{`&CustomMap{`,
4264 `Nullable128S:` + mapStringForNullable128S + `,`,
4265 `Uint128S:` + mapStringForUint128S + `,`,
4266 `NullableIds:` + mapStringForNullableIds + `,`,
4267 `Ids:` + mapStringForIds + `,`,
4268 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4269 `}`,
4270 }, "")
4271 return s
4272 }
4273 func (this *AllMaps) String() string {
4274 if this == nil {
4275 return "nil"
4276 }
4277 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
4278 for k := range this.StringToDoubleMap {
4279 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
4280 }
4281 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
4282 mapStringForStringToDoubleMap := "map[string]float64{"
4283 for _, k := range keysForStringToDoubleMap {
4284 mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k])
4285 }
4286 mapStringForStringToDoubleMap += "}"
4287 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
4288 for k := range this.StringToFloatMap {
4289 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
4290 }
4291 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
4292 mapStringForStringToFloatMap := "map[string]float32{"
4293 for _, k := range keysForStringToFloatMap {
4294 mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k])
4295 }
4296 mapStringForStringToFloatMap += "}"
4297 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
4298 for k := range this.Int32Map {
4299 keysForInt32Map = append(keysForInt32Map, k)
4300 }
4301 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
4302 mapStringForInt32Map := "map[int32]int32{"
4303 for _, k := range keysForInt32Map {
4304 mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k])
4305 }
4306 mapStringForInt32Map += "}"
4307 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
4308 for k := range this.Int64Map {
4309 keysForInt64Map = append(keysForInt64Map, k)
4310 }
4311 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
4312 mapStringForInt64Map := "map[int64]int64{"
4313 for _, k := range keysForInt64Map {
4314 mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k])
4315 }
4316 mapStringForInt64Map += "}"
4317 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
4318 for k := range this.Uint32Map {
4319 keysForUint32Map = append(keysForUint32Map, k)
4320 }
4321 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
4322 mapStringForUint32Map := "map[uint32]uint32{"
4323 for _, k := range keysForUint32Map {
4324 mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k])
4325 }
4326 mapStringForUint32Map += "}"
4327 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
4328 for k := range this.Uint64Map {
4329 keysForUint64Map = append(keysForUint64Map, k)
4330 }
4331 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
4332 mapStringForUint64Map := "map[uint64]uint64{"
4333 for _, k := range keysForUint64Map {
4334 mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k])
4335 }
4336 mapStringForUint64Map += "}"
4337 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
4338 for k := range this.Sint32Map {
4339 keysForSint32Map = append(keysForSint32Map, k)
4340 }
4341 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
4342 mapStringForSint32Map := "map[int32]int32{"
4343 for _, k := range keysForSint32Map {
4344 mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k])
4345 }
4346 mapStringForSint32Map += "}"
4347 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
4348 for k := range this.Sint64Map {
4349 keysForSint64Map = append(keysForSint64Map, k)
4350 }
4351 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
4352 mapStringForSint64Map := "map[int64]int64{"
4353 for _, k := range keysForSint64Map {
4354 mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k])
4355 }
4356 mapStringForSint64Map += "}"
4357 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
4358 for k := range this.Fixed32Map {
4359 keysForFixed32Map = append(keysForFixed32Map, k)
4360 }
4361 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
4362 mapStringForFixed32Map := "map[uint32]uint32{"
4363 for _, k := range keysForFixed32Map {
4364 mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k])
4365 }
4366 mapStringForFixed32Map += "}"
4367 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
4368 for k := range this.Sfixed32Map {
4369 keysForSfixed32Map = append(keysForSfixed32Map, k)
4370 }
4371 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
4372 mapStringForSfixed32Map := "map[int32]int32{"
4373 for _, k := range keysForSfixed32Map {
4374 mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k])
4375 }
4376 mapStringForSfixed32Map += "}"
4377 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
4378 for k := range this.Fixed64Map {
4379 keysForFixed64Map = append(keysForFixed64Map, k)
4380 }
4381 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
4382 mapStringForFixed64Map := "map[uint64]uint64{"
4383 for _, k := range keysForFixed64Map {
4384 mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k])
4385 }
4386 mapStringForFixed64Map += "}"
4387 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
4388 for k := range this.Sfixed64Map {
4389 keysForSfixed64Map = append(keysForSfixed64Map, k)
4390 }
4391 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
4392 mapStringForSfixed64Map := "map[int64]int64{"
4393 for _, k := range keysForSfixed64Map {
4394 mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k])
4395 }
4396 mapStringForSfixed64Map += "}"
4397 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
4398 for k := range this.BoolMap {
4399 keysForBoolMap = append(keysForBoolMap, k)
4400 }
4401 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
4402 mapStringForBoolMap := "map[bool]bool{"
4403 for _, k := range keysForBoolMap {
4404 mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k])
4405 }
4406 mapStringForBoolMap += "}"
4407 keysForStringMap := make([]string, 0, len(this.StringMap))
4408 for k := range this.StringMap {
4409 keysForStringMap = append(keysForStringMap, k)
4410 }
4411 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
4412 mapStringForStringMap := "map[string]string{"
4413 for _, k := range keysForStringMap {
4414 mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k])
4415 }
4416 mapStringForStringMap += "}"
4417 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
4418 for k := range this.StringToBytesMap {
4419 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
4420 }
4421 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
4422 mapStringForStringToBytesMap := "map[string][]byte{"
4423 for _, k := range keysForStringToBytesMap {
4424 mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k])
4425 }
4426 mapStringForStringToBytesMap += "}"
4427 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
4428 for k := range this.StringToEnumMap {
4429 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
4430 }
4431 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
4432 mapStringForStringToEnumMap := "map[string]MapEnum{"
4433 for _, k := range keysForStringToEnumMap {
4434 mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k])
4435 }
4436 mapStringForStringToEnumMap += "}"
4437 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
4438 for k := range this.StringToMsgMap {
4439 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
4440 }
4441 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
4442 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
4443 for _, k := range keysForStringToMsgMap {
4444 mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k])
4445 }
4446 mapStringForStringToMsgMap += "}"
4447 s := strings.Join([]string{`&AllMaps{`,
4448 `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`,
4449 `StringToFloatMap:` + mapStringForStringToFloatMap + `,`,
4450 `Int32Map:` + mapStringForInt32Map + `,`,
4451 `Int64Map:` + mapStringForInt64Map + `,`,
4452 `Uint32Map:` + mapStringForUint32Map + `,`,
4453 `Uint64Map:` + mapStringForUint64Map + `,`,
4454 `Sint32Map:` + mapStringForSint32Map + `,`,
4455 `Sint64Map:` + mapStringForSint64Map + `,`,
4456 `Fixed32Map:` + mapStringForFixed32Map + `,`,
4457 `Sfixed32Map:` + mapStringForSfixed32Map + `,`,
4458 `Fixed64Map:` + mapStringForFixed64Map + `,`,
4459 `Sfixed64Map:` + mapStringForSfixed64Map + `,`,
4460 `BoolMap:` + mapStringForBoolMap + `,`,
4461 `StringMap:` + mapStringForStringMap + `,`,
4462 `StringToBytesMap:` + mapStringForStringToBytesMap + `,`,
4463 `StringToEnumMap:` + mapStringForStringToEnumMap + `,`,
4464 `StringToMsgMap:` + mapStringForStringToMsgMap + `,`,
4465 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4466 `}`,
4467 }, "")
4468 return s
4469 }
4470 func (this *AllMapsOrdered) String() string {
4471 if this == nil {
4472 return "nil"
4473 }
4474 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
4475 for k := range this.StringToDoubleMap {
4476 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
4477 }
4478 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
4479 mapStringForStringToDoubleMap := "map[string]float64{"
4480 for _, k := range keysForStringToDoubleMap {
4481 mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k])
4482 }
4483 mapStringForStringToDoubleMap += "}"
4484 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
4485 for k := range this.StringToFloatMap {
4486 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
4487 }
4488 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
4489 mapStringForStringToFloatMap := "map[string]float32{"
4490 for _, k := range keysForStringToFloatMap {
4491 mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k])
4492 }
4493 mapStringForStringToFloatMap += "}"
4494 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
4495 for k := range this.Int32Map {
4496 keysForInt32Map = append(keysForInt32Map, k)
4497 }
4498 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
4499 mapStringForInt32Map := "map[int32]int32{"
4500 for _, k := range keysForInt32Map {
4501 mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k])
4502 }
4503 mapStringForInt32Map += "}"
4504 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
4505 for k := range this.Int64Map {
4506 keysForInt64Map = append(keysForInt64Map, k)
4507 }
4508 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
4509 mapStringForInt64Map := "map[int64]int64{"
4510 for _, k := range keysForInt64Map {
4511 mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k])
4512 }
4513 mapStringForInt64Map += "}"
4514 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
4515 for k := range this.Uint32Map {
4516 keysForUint32Map = append(keysForUint32Map, k)
4517 }
4518 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
4519 mapStringForUint32Map := "map[uint32]uint32{"
4520 for _, k := range keysForUint32Map {
4521 mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k])
4522 }
4523 mapStringForUint32Map += "}"
4524 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
4525 for k := range this.Uint64Map {
4526 keysForUint64Map = append(keysForUint64Map, k)
4527 }
4528 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
4529 mapStringForUint64Map := "map[uint64]uint64{"
4530 for _, k := range keysForUint64Map {
4531 mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k])
4532 }
4533 mapStringForUint64Map += "}"
4534 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
4535 for k := range this.Sint32Map {
4536 keysForSint32Map = append(keysForSint32Map, k)
4537 }
4538 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
4539 mapStringForSint32Map := "map[int32]int32{"
4540 for _, k := range keysForSint32Map {
4541 mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k])
4542 }
4543 mapStringForSint32Map += "}"
4544 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
4545 for k := range this.Sint64Map {
4546 keysForSint64Map = append(keysForSint64Map, k)
4547 }
4548 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
4549 mapStringForSint64Map := "map[int64]int64{"
4550 for _, k := range keysForSint64Map {
4551 mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k])
4552 }
4553 mapStringForSint64Map += "}"
4554 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
4555 for k := range this.Fixed32Map {
4556 keysForFixed32Map = append(keysForFixed32Map, k)
4557 }
4558 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
4559 mapStringForFixed32Map := "map[uint32]uint32{"
4560 for _, k := range keysForFixed32Map {
4561 mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k])
4562 }
4563 mapStringForFixed32Map += "}"
4564 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
4565 for k := range this.Sfixed32Map {
4566 keysForSfixed32Map = append(keysForSfixed32Map, k)
4567 }
4568 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
4569 mapStringForSfixed32Map := "map[int32]int32{"
4570 for _, k := range keysForSfixed32Map {
4571 mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k])
4572 }
4573 mapStringForSfixed32Map += "}"
4574 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
4575 for k := range this.Fixed64Map {
4576 keysForFixed64Map = append(keysForFixed64Map, k)
4577 }
4578 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
4579 mapStringForFixed64Map := "map[uint64]uint64{"
4580 for _, k := range keysForFixed64Map {
4581 mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k])
4582 }
4583 mapStringForFixed64Map += "}"
4584 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
4585 for k := range this.Sfixed64Map {
4586 keysForSfixed64Map = append(keysForSfixed64Map, k)
4587 }
4588 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
4589 mapStringForSfixed64Map := "map[int64]int64{"
4590 for _, k := range keysForSfixed64Map {
4591 mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k])
4592 }
4593 mapStringForSfixed64Map += "}"
4594 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
4595 for k := range this.BoolMap {
4596 keysForBoolMap = append(keysForBoolMap, k)
4597 }
4598 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
4599 mapStringForBoolMap := "map[bool]bool{"
4600 for _, k := range keysForBoolMap {
4601 mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k])
4602 }
4603 mapStringForBoolMap += "}"
4604 keysForStringMap := make([]string, 0, len(this.StringMap))
4605 for k := range this.StringMap {
4606 keysForStringMap = append(keysForStringMap, k)
4607 }
4608 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
4609 mapStringForStringMap := "map[string]string{"
4610 for _, k := range keysForStringMap {
4611 mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k])
4612 }
4613 mapStringForStringMap += "}"
4614 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
4615 for k := range this.StringToBytesMap {
4616 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
4617 }
4618 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
4619 mapStringForStringToBytesMap := "map[string][]byte{"
4620 for _, k := range keysForStringToBytesMap {
4621 mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k])
4622 }
4623 mapStringForStringToBytesMap += "}"
4624 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
4625 for k := range this.StringToEnumMap {
4626 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
4627 }
4628 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
4629 mapStringForStringToEnumMap := "map[string]MapEnum{"
4630 for _, k := range keysForStringToEnumMap {
4631 mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k])
4632 }
4633 mapStringForStringToEnumMap += "}"
4634 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
4635 for k := range this.StringToMsgMap {
4636 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
4637 }
4638 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
4639 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
4640 for _, k := range keysForStringToMsgMap {
4641 mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k])
4642 }
4643 mapStringForStringToMsgMap += "}"
4644 s := strings.Join([]string{`&AllMapsOrdered{`,
4645 `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`,
4646 `StringToFloatMap:` + mapStringForStringToFloatMap + `,`,
4647 `Int32Map:` + mapStringForInt32Map + `,`,
4648 `Int64Map:` + mapStringForInt64Map + `,`,
4649 `Uint32Map:` + mapStringForUint32Map + `,`,
4650 `Uint64Map:` + mapStringForUint64Map + `,`,
4651 `Sint32Map:` + mapStringForSint32Map + `,`,
4652 `Sint64Map:` + mapStringForSint64Map + `,`,
4653 `Fixed32Map:` + mapStringForFixed32Map + `,`,
4654 `Sfixed32Map:` + mapStringForSfixed32Map + `,`,
4655 `Fixed64Map:` + mapStringForFixed64Map + `,`,
4656 `Sfixed64Map:` + mapStringForSfixed64Map + `,`,
4657 `BoolMap:` + mapStringForBoolMap + `,`,
4658 `StringMap:` + mapStringForStringMap + `,`,
4659 `StringToBytesMap:` + mapStringForStringToBytesMap + `,`,
4660 `StringToEnumMap:` + mapStringForStringToEnumMap + `,`,
4661 `StringToMsgMap:` + mapStringForStringToMsgMap + `,`,
4662 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4663 `}`,
4664 }, "")
4665 return s
4666 }
4667 func valueToStringMapsproto2(v interface{}) string {
4668 rv := reflect.ValueOf(v)
4669 if rv.IsNil() {
4670 return "nil"
4671 }
4672 pv := reflect.Indirect(rv).Interface()
4673 return fmt.Sprintf("*%v", pv)
4674 }
4675 func (m *FloatingPoint) Unmarshal(dAtA []byte) error {
4676 l := len(dAtA)
4677 iNdEx := 0
4678 for iNdEx < l {
4679 preIndex := iNdEx
4680 var wire uint64
4681 for shift := uint(0); ; shift += 7 {
4682 if shift >= 64 {
4683 return ErrIntOverflowMapsproto2
4684 }
4685 if iNdEx >= l {
4686 return io.ErrUnexpectedEOF
4687 }
4688 b := dAtA[iNdEx]
4689 iNdEx++
4690 wire |= uint64(b&0x7F) << shift
4691 if b < 0x80 {
4692 break
4693 }
4694 }
4695 fieldNum := int32(wire >> 3)
4696 wireType := int(wire & 0x7)
4697 if wireType == 4 {
4698 return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group")
4699 }
4700 if fieldNum <= 0 {
4701 return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire)
4702 }
4703 switch fieldNum {
4704 case 1:
4705 if wireType != 1 {
4706 return fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
4707 }
4708 var v uint64
4709 if (iNdEx + 8) > l {
4710 return io.ErrUnexpectedEOF
4711 }
4712 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
4713 iNdEx += 8
4714 v2 := float64(math.Float64frombits(v))
4715 m.F = &v2
4716 default:
4717 iNdEx = preIndex
4718 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4719 if err != nil {
4720 return err
4721 }
4722 if (skippy < 0) || (iNdEx+skippy) < 0 {
4723 return ErrInvalidLengthMapsproto2
4724 }
4725 if (iNdEx + skippy) > l {
4726 return io.ErrUnexpectedEOF
4727 }
4728 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4729 iNdEx += skippy
4730 }
4731 }
4732
4733 if iNdEx > l {
4734 return io.ErrUnexpectedEOF
4735 }
4736 return nil
4737 }
4738 func (m *CustomMap) Unmarshal(dAtA []byte) error {
4739 l := len(dAtA)
4740 iNdEx := 0
4741 for iNdEx < l {
4742 preIndex := iNdEx
4743 var wire uint64
4744 for shift := uint(0); ; shift += 7 {
4745 if shift >= 64 {
4746 return ErrIntOverflowMapsproto2
4747 }
4748 if iNdEx >= l {
4749 return io.ErrUnexpectedEOF
4750 }
4751 b := dAtA[iNdEx]
4752 iNdEx++
4753 wire |= uint64(b&0x7F) << shift
4754 if b < 0x80 {
4755 break
4756 }
4757 }
4758 fieldNum := int32(wire >> 3)
4759 wireType := int(wire & 0x7)
4760 if wireType == 4 {
4761 return fmt.Errorf("proto: CustomMap: wiretype end group for non-group")
4762 }
4763 if fieldNum <= 0 {
4764 return fmt.Errorf("proto: CustomMap: illegal tag %d (wire type %d)", fieldNum, wire)
4765 }
4766 switch fieldNum {
4767 case 1:
4768 if wireType != 2 {
4769 return fmt.Errorf("proto: wrong wireType = %d for field Nullable128S", wireType)
4770 }
4771 var msglen int
4772 for shift := uint(0); ; shift += 7 {
4773 if shift >= 64 {
4774 return ErrIntOverflowMapsproto2
4775 }
4776 if iNdEx >= l {
4777 return io.ErrUnexpectedEOF
4778 }
4779 b := dAtA[iNdEx]
4780 iNdEx++
4781 msglen |= int(b&0x7F) << shift
4782 if b < 0x80 {
4783 break
4784 }
4785 }
4786 if msglen < 0 {
4787 return ErrInvalidLengthMapsproto2
4788 }
4789 postIndex := iNdEx + msglen
4790 if postIndex < 0 {
4791 return ErrInvalidLengthMapsproto2
4792 }
4793 if postIndex > l {
4794 return io.ErrUnexpectedEOF
4795 }
4796 if m.Nullable128S == nil {
4797 m.Nullable128S = make(map[string]*github_com_gogo_protobuf_test_custom.Uint128)
4798 }
4799 var mapkey string
4800 var mapvalue1 github_com_gogo_protobuf_test_custom.Uint128
4801 var mapvalue = &mapvalue1
4802 for iNdEx < postIndex {
4803 entryPreIndex := iNdEx
4804 var wire uint64
4805 for shift := uint(0); ; shift += 7 {
4806 if shift >= 64 {
4807 return ErrIntOverflowMapsproto2
4808 }
4809 if iNdEx >= l {
4810 return io.ErrUnexpectedEOF
4811 }
4812 b := dAtA[iNdEx]
4813 iNdEx++
4814 wire |= uint64(b&0x7F) << shift
4815 if b < 0x80 {
4816 break
4817 }
4818 }
4819 fieldNum := int32(wire >> 3)
4820 if fieldNum == 1 {
4821 var stringLenmapkey uint64
4822 for shift := uint(0); ; shift += 7 {
4823 if shift >= 64 {
4824 return ErrIntOverflowMapsproto2
4825 }
4826 if iNdEx >= l {
4827 return io.ErrUnexpectedEOF
4828 }
4829 b := dAtA[iNdEx]
4830 iNdEx++
4831 stringLenmapkey |= uint64(b&0x7F) << shift
4832 if b < 0x80 {
4833 break
4834 }
4835 }
4836 intStringLenmapkey := int(stringLenmapkey)
4837 if intStringLenmapkey < 0 {
4838 return ErrInvalidLengthMapsproto2
4839 }
4840 postStringIndexmapkey := iNdEx + intStringLenmapkey
4841 if postStringIndexmapkey < 0 {
4842 return ErrInvalidLengthMapsproto2
4843 }
4844 if postStringIndexmapkey > l {
4845 return io.ErrUnexpectedEOF
4846 }
4847 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
4848 iNdEx = postStringIndexmapkey
4849 } else if fieldNum == 2 {
4850 var mapbyteLen uint64
4851 for shift := uint(0); ; shift += 7 {
4852 if shift >= 64 {
4853 return ErrIntOverflowMapsproto2
4854 }
4855 if iNdEx >= l {
4856 return io.ErrUnexpectedEOF
4857 }
4858 b := dAtA[iNdEx]
4859 iNdEx++
4860 mapbyteLen |= uint64(b&0x7F) << shift
4861 if b < 0x80 {
4862 break
4863 }
4864 }
4865 intMapbyteLen := int(mapbyteLen)
4866 if intMapbyteLen < 0 {
4867 return ErrInvalidLengthMapsproto2
4868 }
4869 postbytesIndex := iNdEx + intMapbyteLen
4870 if postbytesIndex < 0 {
4871 return ErrInvalidLengthMapsproto2
4872 }
4873 if postbytesIndex > l {
4874 return io.ErrUnexpectedEOF
4875 }
4876 if err := mapvalue.Unmarshal(dAtA[iNdEx:postbytesIndex]); err != nil {
4877 return err
4878 }
4879 iNdEx = postbytesIndex
4880 } else {
4881 iNdEx = entryPreIndex
4882 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4883 if err != nil {
4884 return err
4885 }
4886 if (skippy < 0) || (iNdEx+skippy) < 0 {
4887 return ErrInvalidLengthMapsproto2
4888 }
4889 if (iNdEx + skippy) > postIndex {
4890 return io.ErrUnexpectedEOF
4891 }
4892 iNdEx += skippy
4893 }
4894 }
4895 m.Nullable128S[mapkey] = ((*github_com_gogo_protobuf_test_custom.Uint128)(mapvalue))
4896 iNdEx = postIndex
4897 case 2:
4898 if wireType != 2 {
4899 return fmt.Errorf("proto: wrong wireType = %d for field Uint128S", wireType)
4900 }
4901 var msglen int
4902 for shift := uint(0); ; shift += 7 {
4903 if shift >= 64 {
4904 return ErrIntOverflowMapsproto2
4905 }
4906 if iNdEx >= l {
4907 return io.ErrUnexpectedEOF
4908 }
4909 b := dAtA[iNdEx]
4910 iNdEx++
4911 msglen |= int(b&0x7F) << shift
4912 if b < 0x80 {
4913 break
4914 }
4915 }
4916 if msglen < 0 {
4917 return ErrInvalidLengthMapsproto2
4918 }
4919 postIndex := iNdEx + msglen
4920 if postIndex < 0 {
4921 return ErrInvalidLengthMapsproto2
4922 }
4923 if postIndex > l {
4924 return io.ErrUnexpectedEOF
4925 }
4926 if m.Uint128S == nil {
4927 m.Uint128S = make(map[string]github_com_gogo_protobuf_test_custom.Uint128)
4928 }
4929 var mapkey string
4930 var mapvalue1 github_com_gogo_protobuf_test_custom.Uint128
4931 var mapvalue = &mapvalue1
4932 for iNdEx < postIndex {
4933 entryPreIndex := iNdEx
4934 var wire uint64
4935 for shift := uint(0); ; shift += 7 {
4936 if shift >= 64 {
4937 return ErrIntOverflowMapsproto2
4938 }
4939 if iNdEx >= l {
4940 return io.ErrUnexpectedEOF
4941 }
4942 b := dAtA[iNdEx]
4943 iNdEx++
4944 wire |= uint64(b&0x7F) << shift
4945 if b < 0x80 {
4946 break
4947 }
4948 }
4949 fieldNum := int32(wire >> 3)
4950 if fieldNum == 1 {
4951 var stringLenmapkey uint64
4952 for shift := uint(0); ; shift += 7 {
4953 if shift >= 64 {
4954 return ErrIntOverflowMapsproto2
4955 }
4956 if iNdEx >= l {
4957 return io.ErrUnexpectedEOF
4958 }
4959 b := dAtA[iNdEx]
4960 iNdEx++
4961 stringLenmapkey |= uint64(b&0x7F) << shift
4962 if b < 0x80 {
4963 break
4964 }
4965 }
4966 intStringLenmapkey := int(stringLenmapkey)
4967 if intStringLenmapkey < 0 {
4968 return ErrInvalidLengthMapsproto2
4969 }
4970 postStringIndexmapkey := iNdEx + intStringLenmapkey
4971 if postStringIndexmapkey < 0 {
4972 return ErrInvalidLengthMapsproto2
4973 }
4974 if postStringIndexmapkey > l {
4975 return io.ErrUnexpectedEOF
4976 }
4977 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
4978 iNdEx = postStringIndexmapkey
4979 } else if fieldNum == 2 {
4980 var mapbyteLen uint64
4981 for shift := uint(0); ; shift += 7 {
4982 if shift >= 64 {
4983 return ErrIntOverflowMapsproto2
4984 }
4985 if iNdEx >= l {
4986 return io.ErrUnexpectedEOF
4987 }
4988 b := dAtA[iNdEx]
4989 iNdEx++
4990 mapbyteLen |= uint64(b&0x7F) << shift
4991 if b < 0x80 {
4992 break
4993 }
4994 }
4995 intMapbyteLen := int(mapbyteLen)
4996 if intMapbyteLen < 0 {
4997 return ErrInvalidLengthMapsproto2
4998 }
4999 postbytesIndex := iNdEx + intMapbyteLen
5000 if postbytesIndex < 0 {
5001 return ErrInvalidLengthMapsproto2
5002 }
5003 if postbytesIndex > l {
5004 return io.ErrUnexpectedEOF
5005 }
5006 if err := mapvalue.Unmarshal(dAtA[iNdEx:postbytesIndex]); err != nil {
5007 return err
5008 }
5009 iNdEx = postbytesIndex
5010 } else {
5011 iNdEx = entryPreIndex
5012 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5013 if err != nil {
5014 return err
5015 }
5016 if (skippy < 0) || (iNdEx+skippy) < 0 {
5017 return ErrInvalidLengthMapsproto2
5018 }
5019 if (iNdEx + skippy) > postIndex {
5020 return io.ErrUnexpectedEOF
5021 }
5022 iNdEx += skippy
5023 }
5024 }
5025 m.Uint128S[mapkey] = ((github_com_gogo_protobuf_test_custom.Uint128)(*mapvalue))
5026 iNdEx = postIndex
5027 case 3:
5028 if wireType != 2 {
5029 return fmt.Errorf("proto: wrong wireType = %d for field NullableIds", wireType)
5030 }
5031 var msglen int
5032 for shift := uint(0); ; shift += 7 {
5033 if shift >= 64 {
5034 return ErrIntOverflowMapsproto2
5035 }
5036 if iNdEx >= l {
5037 return io.ErrUnexpectedEOF
5038 }
5039 b := dAtA[iNdEx]
5040 iNdEx++
5041 msglen |= int(b&0x7F) << shift
5042 if b < 0x80 {
5043 break
5044 }
5045 }
5046 if msglen < 0 {
5047 return ErrInvalidLengthMapsproto2
5048 }
5049 postIndex := iNdEx + msglen
5050 if postIndex < 0 {
5051 return ErrInvalidLengthMapsproto2
5052 }
5053 if postIndex > l {
5054 return io.ErrUnexpectedEOF
5055 }
5056 if m.NullableIds == nil {
5057 m.NullableIds = make(map[string]*github_com_gogo_protobuf_test.Uuid)
5058 }
5059 var mapkey string
5060 var mapvalue1 github_com_gogo_protobuf_test.Uuid
5061 var mapvalue = &mapvalue1
5062 for iNdEx < postIndex {
5063 entryPreIndex := iNdEx
5064 var wire uint64
5065 for shift := uint(0); ; shift += 7 {
5066 if shift >= 64 {
5067 return ErrIntOverflowMapsproto2
5068 }
5069 if iNdEx >= l {
5070 return io.ErrUnexpectedEOF
5071 }
5072 b := dAtA[iNdEx]
5073 iNdEx++
5074 wire |= uint64(b&0x7F) << shift
5075 if b < 0x80 {
5076 break
5077 }
5078 }
5079 fieldNum := int32(wire >> 3)
5080 if fieldNum == 1 {
5081 var stringLenmapkey uint64
5082 for shift := uint(0); ; shift += 7 {
5083 if shift >= 64 {
5084 return ErrIntOverflowMapsproto2
5085 }
5086 if iNdEx >= l {
5087 return io.ErrUnexpectedEOF
5088 }
5089 b := dAtA[iNdEx]
5090 iNdEx++
5091 stringLenmapkey |= uint64(b&0x7F) << shift
5092 if b < 0x80 {
5093 break
5094 }
5095 }
5096 intStringLenmapkey := int(stringLenmapkey)
5097 if intStringLenmapkey < 0 {
5098 return ErrInvalidLengthMapsproto2
5099 }
5100 postStringIndexmapkey := iNdEx + intStringLenmapkey
5101 if postStringIndexmapkey < 0 {
5102 return ErrInvalidLengthMapsproto2
5103 }
5104 if postStringIndexmapkey > l {
5105 return io.ErrUnexpectedEOF
5106 }
5107 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5108 iNdEx = postStringIndexmapkey
5109 } else if fieldNum == 2 {
5110 var mapbyteLen uint64
5111 for shift := uint(0); ; shift += 7 {
5112 if shift >= 64 {
5113 return ErrIntOverflowMapsproto2
5114 }
5115 if iNdEx >= l {
5116 return io.ErrUnexpectedEOF
5117 }
5118 b := dAtA[iNdEx]
5119 iNdEx++
5120 mapbyteLen |= uint64(b&0x7F) << shift
5121 if b < 0x80 {
5122 break
5123 }
5124 }
5125 intMapbyteLen := int(mapbyteLen)
5126 if intMapbyteLen < 0 {
5127 return ErrInvalidLengthMapsproto2
5128 }
5129 postbytesIndex := iNdEx + intMapbyteLen
5130 if postbytesIndex < 0 {
5131 return ErrInvalidLengthMapsproto2
5132 }
5133 if postbytesIndex > l {
5134 return io.ErrUnexpectedEOF
5135 }
5136 if err := mapvalue.Unmarshal(dAtA[iNdEx:postbytesIndex]); err != nil {
5137 return err
5138 }
5139 iNdEx = postbytesIndex
5140 } else {
5141 iNdEx = entryPreIndex
5142 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5143 if err != nil {
5144 return err
5145 }
5146 if (skippy < 0) || (iNdEx+skippy) < 0 {
5147 return ErrInvalidLengthMapsproto2
5148 }
5149 if (iNdEx + skippy) > postIndex {
5150 return io.ErrUnexpectedEOF
5151 }
5152 iNdEx += skippy
5153 }
5154 }
5155 m.NullableIds[mapkey] = ((*github_com_gogo_protobuf_test.Uuid)(mapvalue))
5156 iNdEx = postIndex
5157 case 4:
5158 if wireType != 2 {
5159 return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
5160 }
5161 var msglen int
5162 for shift := uint(0); ; shift += 7 {
5163 if shift >= 64 {
5164 return ErrIntOverflowMapsproto2
5165 }
5166 if iNdEx >= l {
5167 return io.ErrUnexpectedEOF
5168 }
5169 b := dAtA[iNdEx]
5170 iNdEx++
5171 msglen |= int(b&0x7F) << shift
5172 if b < 0x80 {
5173 break
5174 }
5175 }
5176 if msglen < 0 {
5177 return ErrInvalidLengthMapsproto2
5178 }
5179 postIndex := iNdEx + msglen
5180 if postIndex < 0 {
5181 return ErrInvalidLengthMapsproto2
5182 }
5183 if postIndex > l {
5184 return io.ErrUnexpectedEOF
5185 }
5186 if m.Ids == nil {
5187 m.Ids = make(map[string]github_com_gogo_protobuf_test.Uuid)
5188 }
5189 var mapkey string
5190 var mapvalue1 github_com_gogo_protobuf_test.Uuid
5191 var mapvalue = &mapvalue1
5192 for iNdEx < postIndex {
5193 entryPreIndex := iNdEx
5194 var wire uint64
5195 for shift := uint(0); ; shift += 7 {
5196 if shift >= 64 {
5197 return ErrIntOverflowMapsproto2
5198 }
5199 if iNdEx >= l {
5200 return io.ErrUnexpectedEOF
5201 }
5202 b := dAtA[iNdEx]
5203 iNdEx++
5204 wire |= uint64(b&0x7F) << shift
5205 if b < 0x80 {
5206 break
5207 }
5208 }
5209 fieldNum := int32(wire >> 3)
5210 if fieldNum == 1 {
5211 var stringLenmapkey uint64
5212 for shift := uint(0); ; shift += 7 {
5213 if shift >= 64 {
5214 return ErrIntOverflowMapsproto2
5215 }
5216 if iNdEx >= l {
5217 return io.ErrUnexpectedEOF
5218 }
5219 b := dAtA[iNdEx]
5220 iNdEx++
5221 stringLenmapkey |= uint64(b&0x7F) << shift
5222 if b < 0x80 {
5223 break
5224 }
5225 }
5226 intStringLenmapkey := int(stringLenmapkey)
5227 if intStringLenmapkey < 0 {
5228 return ErrInvalidLengthMapsproto2
5229 }
5230 postStringIndexmapkey := iNdEx + intStringLenmapkey
5231 if postStringIndexmapkey < 0 {
5232 return ErrInvalidLengthMapsproto2
5233 }
5234 if postStringIndexmapkey > l {
5235 return io.ErrUnexpectedEOF
5236 }
5237 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5238 iNdEx = postStringIndexmapkey
5239 } else if fieldNum == 2 {
5240 var mapbyteLen uint64
5241 for shift := uint(0); ; shift += 7 {
5242 if shift >= 64 {
5243 return ErrIntOverflowMapsproto2
5244 }
5245 if iNdEx >= l {
5246 return io.ErrUnexpectedEOF
5247 }
5248 b := dAtA[iNdEx]
5249 iNdEx++
5250 mapbyteLen |= uint64(b&0x7F) << shift
5251 if b < 0x80 {
5252 break
5253 }
5254 }
5255 intMapbyteLen := int(mapbyteLen)
5256 if intMapbyteLen < 0 {
5257 return ErrInvalidLengthMapsproto2
5258 }
5259 postbytesIndex := iNdEx + intMapbyteLen
5260 if postbytesIndex < 0 {
5261 return ErrInvalidLengthMapsproto2
5262 }
5263 if postbytesIndex > l {
5264 return io.ErrUnexpectedEOF
5265 }
5266 if err := mapvalue.Unmarshal(dAtA[iNdEx:postbytesIndex]); err != nil {
5267 return err
5268 }
5269 iNdEx = postbytesIndex
5270 } else {
5271 iNdEx = entryPreIndex
5272 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5273 if err != nil {
5274 return err
5275 }
5276 if (skippy < 0) || (iNdEx+skippy) < 0 {
5277 return ErrInvalidLengthMapsproto2
5278 }
5279 if (iNdEx + skippy) > postIndex {
5280 return io.ErrUnexpectedEOF
5281 }
5282 iNdEx += skippy
5283 }
5284 }
5285 m.Ids[mapkey] = ((github_com_gogo_protobuf_test.Uuid)(*mapvalue))
5286 iNdEx = postIndex
5287 default:
5288 iNdEx = preIndex
5289 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5290 if err != nil {
5291 return err
5292 }
5293 if (skippy < 0) || (iNdEx+skippy) < 0 {
5294 return ErrInvalidLengthMapsproto2
5295 }
5296 if (iNdEx + skippy) > l {
5297 return io.ErrUnexpectedEOF
5298 }
5299 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5300 iNdEx += skippy
5301 }
5302 }
5303
5304 if iNdEx > l {
5305 return io.ErrUnexpectedEOF
5306 }
5307 return nil
5308 }
5309 func (m *AllMaps) Unmarshal(dAtA []byte) error {
5310 l := len(dAtA)
5311 iNdEx := 0
5312 for iNdEx < l {
5313 preIndex := iNdEx
5314 var wire uint64
5315 for shift := uint(0); ; shift += 7 {
5316 if shift >= 64 {
5317 return ErrIntOverflowMapsproto2
5318 }
5319 if iNdEx >= l {
5320 return io.ErrUnexpectedEOF
5321 }
5322 b := dAtA[iNdEx]
5323 iNdEx++
5324 wire |= uint64(b&0x7F) << shift
5325 if b < 0x80 {
5326 break
5327 }
5328 }
5329 fieldNum := int32(wire >> 3)
5330 wireType := int(wire & 0x7)
5331 if wireType == 4 {
5332 return fmt.Errorf("proto: AllMaps: wiretype end group for non-group")
5333 }
5334 if fieldNum <= 0 {
5335 return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire)
5336 }
5337 switch fieldNum {
5338 case 1:
5339 if wireType != 2 {
5340 return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType)
5341 }
5342 var msglen int
5343 for shift := uint(0); ; shift += 7 {
5344 if shift >= 64 {
5345 return ErrIntOverflowMapsproto2
5346 }
5347 if iNdEx >= l {
5348 return io.ErrUnexpectedEOF
5349 }
5350 b := dAtA[iNdEx]
5351 iNdEx++
5352 msglen |= int(b&0x7F) << shift
5353 if b < 0x80 {
5354 break
5355 }
5356 }
5357 if msglen < 0 {
5358 return ErrInvalidLengthMapsproto2
5359 }
5360 postIndex := iNdEx + msglen
5361 if postIndex < 0 {
5362 return ErrInvalidLengthMapsproto2
5363 }
5364 if postIndex > l {
5365 return io.ErrUnexpectedEOF
5366 }
5367 if m.StringToDoubleMap == nil {
5368 m.StringToDoubleMap = make(map[string]float64)
5369 }
5370 var mapkey string
5371 var mapvalue float64
5372 for iNdEx < postIndex {
5373 entryPreIndex := iNdEx
5374 var wire uint64
5375 for shift := uint(0); ; shift += 7 {
5376 if shift >= 64 {
5377 return ErrIntOverflowMapsproto2
5378 }
5379 if iNdEx >= l {
5380 return io.ErrUnexpectedEOF
5381 }
5382 b := dAtA[iNdEx]
5383 iNdEx++
5384 wire |= uint64(b&0x7F) << shift
5385 if b < 0x80 {
5386 break
5387 }
5388 }
5389 fieldNum := int32(wire >> 3)
5390 if fieldNum == 1 {
5391 var stringLenmapkey uint64
5392 for shift := uint(0); ; shift += 7 {
5393 if shift >= 64 {
5394 return ErrIntOverflowMapsproto2
5395 }
5396 if iNdEx >= l {
5397 return io.ErrUnexpectedEOF
5398 }
5399 b := dAtA[iNdEx]
5400 iNdEx++
5401 stringLenmapkey |= uint64(b&0x7F) << shift
5402 if b < 0x80 {
5403 break
5404 }
5405 }
5406 intStringLenmapkey := int(stringLenmapkey)
5407 if intStringLenmapkey < 0 {
5408 return ErrInvalidLengthMapsproto2
5409 }
5410 postStringIndexmapkey := iNdEx + intStringLenmapkey
5411 if postStringIndexmapkey < 0 {
5412 return ErrInvalidLengthMapsproto2
5413 }
5414 if postStringIndexmapkey > l {
5415 return io.ErrUnexpectedEOF
5416 }
5417 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5418 iNdEx = postStringIndexmapkey
5419 } else if fieldNum == 2 {
5420 var mapvaluetemp uint64
5421 if (iNdEx + 8) > l {
5422 return io.ErrUnexpectedEOF
5423 }
5424 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
5425 iNdEx += 8
5426 mapvalue = math.Float64frombits(mapvaluetemp)
5427 } else {
5428 iNdEx = entryPreIndex
5429 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5430 if err != nil {
5431 return err
5432 }
5433 if (skippy < 0) || (iNdEx+skippy) < 0 {
5434 return ErrInvalidLengthMapsproto2
5435 }
5436 if (iNdEx + skippy) > postIndex {
5437 return io.ErrUnexpectedEOF
5438 }
5439 iNdEx += skippy
5440 }
5441 }
5442 m.StringToDoubleMap[mapkey] = mapvalue
5443 iNdEx = postIndex
5444 case 2:
5445 if wireType != 2 {
5446 return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType)
5447 }
5448 var msglen int
5449 for shift := uint(0); ; shift += 7 {
5450 if shift >= 64 {
5451 return ErrIntOverflowMapsproto2
5452 }
5453 if iNdEx >= l {
5454 return io.ErrUnexpectedEOF
5455 }
5456 b := dAtA[iNdEx]
5457 iNdEx++
5458 msglen |= int(b&0x7F) << shift
5459 if b < 0x80 {
5460 break
5461 }
5462 }
5463 if msglen < 0 {
5464 return ErrInvalidLengthMapsproto2
5465 }
5466 postIndex := iNdEx + msglen
5467 if postIndex < 0 {
5468 return ErrInvalidLengthMapsproto2
5469 }
5470 if postIndex > l {
5471 return io.ErrUnexpectedEOF
5472 }
5473 if m.StringToFloatMap == nil {
5474 m.StringToFloatMap = make(map[string]float32)
5475 }
5476 var mapkey string
5477 var mapvalue float32
5478 for iNdEx < postIndex {
5479 entryPreIndex := iNdEx
5480 var wire uint64
5481 for shift := uint(0); ; shift += 7 {
5482 if shift >= 64 {
5483 return ErrIntOverflowMapsproto2
5484 }
5485 if iNdEx >= l {
5486 return io.ErrUnexpectedEOF
5487 }
5488 b := dAtA[iNdEx]
5489 iNdEx++
5490 wire |= uint64(b&0x7F) << shift
5491 if b < 0x80 {
5492 break
5493 }
5494 }
5495 fieldNum := int32(wire >> 3)
5496 if fieldNum == 1 {
5497 var stringLenmapkey uint64
5498 for shift := uint(0); ; shift += 7 {
5499 if shift >= 64 {
5500 return ErrIntOverflowMapsproto2
5501 }
5502 if iNdEx >= l {
5503 return io.ErrUnexpectedEOF
5504 }
5505 b := dAtA[iNdEx]
5506 iNdEx++
5507 stringLenmapkey |= uint64(b&0x7F) << shift
5508 if b < 0x80 {
5509 break
5510 }
5511 }
5512 intStringLenmapkey := int(stringLenmapkey)
5513 if intStringLenmapkey < 0 {
5514 return ErrInvalidLengthMapsproto2
5515 }
5516 postStringIndexmapkey := iNdEx + intStringLenmapkey
5517 if postStringIndexmapkey < 0 {
5518 return ErrInvalidLengthMapsproto2
5519 }
5520 if postStringIndexmapkey > l {
5521 return io.ErrUnexpectedEOF
5522 }
5523 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5524 iNdEx = postStringIndexmapkey
5525 } else if fieldNum == 2 {
5526 var mapvaluetemp uint32
5527 if (iNdEx + 4) > l {
5528 return io.ErrUnexpectedEOF
5529 }
5530 mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
5531 iNdEx += 4
5532 mapvalue = math.Float32frombits(mapvaluetemp)
5533 } else {
5534 iNdEx = entryPreIndex
5535 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5536 if err != nil {
5537 return err
5538 }
5539 if (skippy < 0) || (iNdEx+skippy) < 0 {
5540 return ErrInvalidLengthMapsproto2
5541 }
5542 if (iNdEx + skippy) > postIndex {
5543 return io.ErrUnexpectedEOF
5544 }
5545 iNdEx += skippy
5546 }
5547 }
5548 m.StringToFloatMap[mapkey] = mapvalue
5549 iNdEx = postIndex
5550 case 3:
5551 if wireType != 2 {
5552 return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType)
5553 }
5554 var msglen int
5555 for shift := uint(0); ; shift += 7 {
5556 if shift >= 64 {
5557 return ErrIntOverflowMapsproto2
5558 }
5559 if iNdEx >= l {
5560 return io.ErrUnexpectedEOF
5561 }
5562 b := dAtA[iNdEx]
5563 iNdEx++
5564 msglen |= int(b&0x7F) << shift
5565 if b < 0x80 {
5566 break
5567 }
5568 }
5569 if msglen < 0 {
5570 return ErrInvalidLengthMapsproto2
5571 }
5572 postIndex := iNdEx + msglen
5573 if postIndex < 0 {
5574 return ErrInvalidLengthMapsproto2
5575 }
5576 if postIndex > l {
5577 return io.ErrUnexpectedEOF
5578 }
5579 if m.Int32Map == nil {
5580 m.Int32Map = make(map[int32]int32)
5581 }
5582 var mapkey int32
5583 var mapvalue int32
5584 for iNdEx < postIndex {
5585 entryPreIndex := iNdEx
5586 var wire uint64
5587 for shift := uint(0); ; shift += 7 {
5588 if shift >= 64 {
5589 return ErrIntOverflowMapsproto2
5590 }
5591 if iNdEx >= l {
5592 return io.ErrUnexpectedEOF
5593 }
5594 b := dAtA[iNdEx]
5595 iNdEx++
5596 wire |= uint64(b&0x7F) << shift
5597 if b < 0x80 {
5598 break
5599 }
5600 }
5601 fieldNum := int32(wire >> 3)
5602 if fieldNum == 1 {
5603 for shift := uint(0); ; shift += 7 {
5604 if shift >= 64 {
5605 return ErrIntOverflowMapsproto2
5606 }
5607 if iNdEx >= l {
5608 return io.ErrUnexpectedEOF
5609 }
5610 b := dAtA[iNdEx]
5611 iNdEx++
5612 mapkey |= int32(b&0x7F) << shift
5613 if b < 0x80 {
5614 break
5615 }
5616 }
5617 } else if fieldNum == 2 {
5618 for shift := uint(0); ; shift += 7 {
5619 if shift >= 64 {
5620 return ErrIntOverflowMapsproto2
5621 }
5622 if iNdEx >= l {
5623 return io.ErrUnexpectedEOF
5624 }
5625 b := dAtA[iNdEx]
5626 iNdEx++
5627 mapvalue |= int32(b&0x7F) << shift
5628 if b < 0x80 {
5629 break
5630 }
5631 }
5632 } else {
5633 iNdEx = entryPreIndex
5634 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5635 if err != nil {
5636 return err
5637 }
5638 if (skippy < 0) || (iNdEx+skippy) < 0 {
5639 return ErrInvalidLengthMapsproto2
5640 }
5641 if (iNdEx + skippy) > postIndex {
5642 return io.ErrUnexpectedEOF
5643 }
5644 iNdEx += skippy
5645 }
5646 }
5647 m.Int32Map[mapkey] = mapvalue
5648 iNdEx = postIndex
5649 case 4:
5650 if wireType != 2 {
5651 return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType)
5652 }
5653 var msglen int
5654 for shift := uint(0); ; shift += 7 {
5655 if shift >= 64 {
5656 return ErrIntOverflowMapsproto2
5657 }
5658 if iNdEx >= l {
5659 return io.ErrUnexpectedEOF
5660 }
5661 b := dAtA[iNdEx]
5662 iNdEx++
5663 msglen |= int(b&0x7F) << shift
5664 if b < 0x80 {
5665 break
5666 }
5667 }
5668 if msglen < 0 {
5669 return ErrInvalidLengthMapsproto2
5670 }
5671 postIndex := iNdEx + msglen
5672 if postIndex < 0 {
5673 return ErrInvalidLengthMapsproto2
5674 }
5675 if postIndex > l {
5676 return io.ErrUnexpectedEOF
5677 }
5678 if m.Int64Map == nil {
5679 m.Int64Map = make(map[int64]int64)
5680 }
5681 var mapkey int64
5682 var mapvalue int64
5683 for iNdEx < postIndex {
5684 entryPreIndex := iNdEx
5685 var wire uint64
5686 for shift := uint(0); ; shift += 7 {
5687 if shift >= 64 {
5688 return ErrIntOverflowMapsproto2
5689 }
5690 if iNdEx >= l {
5691 return io.ErrUnexpectedEOF
5692 }
5693 b := dAtA[iNdEx]
5694 iNdEx++
5695 wire |= uint64(b&0x7F) << shift
5696 if b < 0x80 {
5697 break
5698 }
5699 }
5700 fieldNum := int32(wire >> 3)
5701 if fieldNum == 1 {
5702 for shift := uint(0); ; shift += 7 {
5703 if shift >= 64 {
5704 return ErrIntOverflowMapsproto2
5705 }
5706 if iNdEx >= l {
5707 return io.ErrUnexpectedEOF
5708 }
5709 b := dAtA[iNdEx]
5710 iNdEx++
5711 mapkey |= int64(b&0x7F) << shift
5712 if b < 0x80 {
5713 break
5714 }
5715 }
5716 } else if fieldNum == 2 {
5717 for shift := uint(0); ; shift += 7 {
5718 if shift >= 64 {
5719 return ErrIntOverflowMapsproto2
5720 }
5721 if iNdEx >= l {
5722 return io.ErrUnexpectedEOF
5723 }
5724 b := dAtA[iNdEx]
5725 iNdEx++
5726 mapvalue |= int64(b&0x7F) << shift
5727 if b < 0x80 {
5728 break
5729 }
5730 }
5731 } else {
5732 iNdEx = entryPreIndex
5733 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5734 if err != nil {
5735 return err
5736 }
5737 if (skippy < 0) || (iNdEx+skippy) < 0 {
5738 return ErrInvalidLengthMapsproto2
5739 }
5740 if (iNdEx + skippy) > postIndex {
5741 return io.ErrUnexpectedEOF
5742 }
5743 iNdEx += skippy
5744 }
5745 }
5746 m.Int64Map[mapkey] = mapvalue
5747 iNdEx = postIndex
5748 case 5:
5749 if wireType != 2 {
5750 return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType)
5751 }
5752 var msglen int
5753 for shift := uint(0); ; shift += 7 {
5754 if shift >= 64 {
5755 return ErrIntOverflowMapsproto2
5756 }
5757 if iNdEx >= l {
5758 return io.ErrUnexpectedEOF
5759 }
5760 b := dAtA[iNdEx]
5761 iNdEx++
5762 msglen |= int(b&0x7F) << shift
5763 if b < 0x80 {
5764 break
5765 }
5766 }
5767 if msglen < 0 {
5768 return ErrInvalidLengthMapsproto2
5769 }
5770 postIndex := iNdEx + msglen
5771 if postIndex < 0 {
5772 return ErrInvalidLengthMapsproto2
5773 }
5774 if postIndex > l {
5775 return io.ErrUnexpectedEOF
5776 }
5777 if m.Uint32Map == nil {
5778 m.Uint32Map = make(map[uint32]uint32)
5779 }
5780 var mapkey uint32
5781 var mapvalue uint32
5782 for iNdEx < postIndex {
5783 entryPreIndex := iNdEx
5784 var wire uint64
5785 for shift := uint(0); ; shift += 7 {
5786 if shift >= 64 {
5787 return ErrIntOverflowMapsproto2
5788 }
5789 if iNdEx >= l {
5790 return io.ErrUnexpectedEOF
5791 }
5792 b := dAtA[iNdEx]
5793 iNdEx++
5794 wire |= uint64(b&0x7F) << shift
5795 if b < 0x80 {
5796 break
5797 }
5798 }
5799 fieldNum := int32(wire >> 3)
5800 if fieldNum == 1 {
5801 for shift := uint(0); ; shift += 7 {
5802 if shift >= 64 {
5803 return ErrIntOverflowMapsproto2
5804 }
5805 if iNdEx >= l {
5806 return io.ErrUnexpectedEOF
5807 }
5808 b := dAtA[iNdEx]
5809 iNdEx++
5810 mapkey |= uint32(b&0x7F) << shift
5811 if b < 0x80 {
5812 break
5813 }
5814 }
5815 } else if fieldNum == 2 {
5816 for shift := uint(0); ; shift += 7 {
5817 if shift >= 64 {
5818 return ErrIntOverflowMapsproto2
5819 }
5820 if iNdEx >= l {
5821 return io.ErrUnexpectedEOF
5822 }
5823 b := dAtA[iNdEx]
5824 iNdEx++
5825 mapvalue |= uint32(b&0x7F) << shift
5826 if b < 0x80 {
5827 break
5828 }
5829 }
5830 } else {
5831 iNdEx = entryPreIndex
5832 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5833 if err != nil {
5834 return err
5835 }
5836 if (skippy < 0) || (iNdEx+skippy) < 0 {
5837 return ErrInvalidLengthMapsproto2
5838 }
5839 if (iNdEx + skippy) > postIndex {
5840 return io.ErrUnexpectedEOF
5841 }
5842 iNdEx += skippy
5843 }
5844 }
5845 m.Uint32Map[mapkey] = mapvalue
5846 iNdEx = postIndex
5847 case 6:
5848 if wireType != 2 {
5849 return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType)
5850 }
5851 var msglen int
5852 for shift := uint(0); ; shift += 7 {
5853 if shift >= 64 {
5854 return ErrIntOverflowMapsproto2
5855 }
5856 if iNdEx >= l {
5857 return io.ErrUnexpectedEOF
5858 }
5859 b := dAtA[iNdEx]
5860 iNdEx++
5861 msglen |= int(b&0x7F) << shift
5862 if b < 0x80 {
5863 break
5864 }
5865 }
5866 if msglen < 0 {
5867 return ErrInvalidLengthMapsproto2
5868 }
5869 postIndex := iNdEx + msglen
5870 if postIndex < 0 {
5871 return ErrInvalidLengthMapsproto2
5872 }
5873 if postIndex > l {
5874 return io.ErrUnexpectedEOF
5875 }
5876 if m.Uint64Map == nil {
5877 m.Uint64Map = make(map[uint64]uint64)
5878 }
5879 var mapkey uint64
5880 var mapvalue uint64
5881 for iNdEx < postIndex {
5882 entryPreIndex := iNdEx
5883 var wire uint64
5884 for shift := uint(0); ; shift += 7 {
5885 if shift >= 64 {
5886 return ErrIntOverflowMapsproto2
5887 }
5888 if iNdEx >= l {
5889 return io.ErrUnexpectedEOF
5890 }
5891 b := dAtA[iNdEx]
5892 iNdEx++
5893 wire |= uint64(b&0x7F) << shift
5894 if b < 0x80 {
5895 break
5896 }
5897 }
5898 fieldNum := int32(wire >> 3)
5899 if fieldNum == 1 {
5900 for shift := uint(0); ; shift += 7 {
5901 if shift >= 64 {
5902 return ErrIntOverflowMapsproto2
5903 }
5904 if iNdEx >= l {
5905 return io.ErrUnexpectedEOF
5906 }
5907 b := dAtA[iNdEx]
5908 iNdEx++
5909 mapkey |= uint64(b&0x7F) << shift
5910 if b < 0x80 {
5911 break
5912 }
5913 }
5914 } else if fieldNum == 2 {
5915 for shift := uint(0); ; shift += 7 {
5916 if shift >= 64 {
5917 return ErrIntOverflowMapsproto2
5918 }
5919 if iNdEx >= l {
5920 return io.ErrUnexpectedEOF
5921 }
5922 b := dAtA[iNdEx]
5923 iNdEx++
5924 mapvalue |= uint64(b&0x7F) << shift
5925 if b < 0x80 {
5926 break
5927 }
5928 }
5929 } else {
5930 iNdEx = entryPreIndex
5931 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5932 if err != nil {
5933 return err
5934 }
5935 if (skippy < 0) || (iNdEx+skippy) < 0 {
5936 return ErrInvalidLengthMapsproto2
5937 }
5938 if (iNdEx + skippy) > postIndex {
5939 return io.ErrUnexpectedEOF
5940 }
5941 iNdEx += skippy
5942 }
5943 }
5944 m.Uint64Map[mapkey] = mapvalue
5945 iNdEx = postIndex
5946 case 7:
5947 if wireType != 2 {
5948 return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType)
5949 }
5950 var msglen int
5951 for shift := uint(0); ; shift += 7 {
5952 if shift >= 64 {
5953 return ErrIntOverflowMapsproto2
5954 }
5955 if iNdEx >= l {
5956 return io.ErrUnexpectedEOF
5957 }
5958 b := dAtA[iNdEx]
5959 iNdEx++
5960 msglen |= int(b&0x7F) << shift
5961 if b < 0x80 {
5962 break
5963 }
5964 }
5965 if msglen < 0 {
5966 return ErrInvalidLengthMapsproto2
5967 }
5968 postIndex := iNdEx + msglen
5969 if postIndex < 0 {
5970 return ErrInvalidLengthMapsproto2
5971 }
5972 if postIndex > l {
5973 return io.ErrUnexpectedEOF
5974 }
5975 if m.Sint32Map == nil {
5976 m.Sint32Map = make(map[int32]int32)
5977 }
5978 var mapkey int32
5979 var mapvalue int32
5980 for iNdEx < postIndex {
5981 entryPreIndex := iNdEx
5982 var wire uint64
5983 for shift := uint(0); ; shift += 7 {
5984 if shift >= 64 {
5985 return ErrIntOverflowMapsproto2
5986 }
5987 if iNdEx >= l {
5988 return io.ErrUnexpectedEOF
5989 }
5990 b := dAtA[iNdEx]
5991 iNdEx++
5992 wire |= uint64(b&0x7F) << shift
5993 if b < 0x80 {
5994 break
5995 }
5996 }
5997 fieldNum := int32(wire >> 3)
5998 if fieldNum == 1 {
5999 var mapkeytemp int32
6000 for shift := uint(0); ; shift += 7 {
6001 if shift >= 64 {
6002 return ErrIntOverflowMapsproto2
6003 }
6004 if iNdEx >= l {
6005 return io.ErrUnexpectedEOF
6006 }
6007 b := dAtA[iNdEx]
6008 iNdEx++
6009 mapkeytemp |= int32(b&0x7F) << shift
6010 if b < 0x80 {
6011 break
6012 }
6013 }
6014 mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
6015 mapkey = int32(mapkeytemp)
6016 } else if fieldNum == 2 {
6017 var mapvaluetemp int32
6018 for shift := uint(0); ; shift += 7 {
6019 if shift >= 64 {
6020 return ErrIntOverflowMapsproto2
6021 }
6022 if iNdEx >= l {
6023 return io.ErrUnexpectedEOF
6024 }
6025 b := dAtA[iNdEx]
6026 iNdEx++
6027 mapvaluetemp |= int32(b&0x7F) << shift
6028 if b < 0x80 {
6029 break
6030 }
6031 }
6032 mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
6033 mapvalue = int32(mapvaluetemp)
6034 } else {
6035 iNdEx = entryPreIndex
6036 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6037 if err != nil {
6038 return err
6039 }
6040 if (skippy < 0) || (iNdEx+skippy) < 0 {
6041 return ErrInvalidLengthMapsproto2
6042 }
6043 if (iNdEx + skippy) > postIndex {
6044 return io.ErrUnexpectedEOF
6045 }
6046 iNdEx += skippy
6047 }
6048 }
6049 m.Sint32Map[mapkey] = mapvalue
6050 iNdEx = postIndex
6051 case 8:
6052 if wireType != 2 {
6053 return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType)
6054 }
6055 var msglen int
6056 for shift := uint(0); ; shift += 7 {
6057 if shift >= 64 {
6058 return ErrIntOverflowMapsproto2
6059 }
6060 if iNdEx >= l {
6061 return io.ErrUnexpectedEOF
6062 }
6063 b := dAtA[iNdEx]
6064 iNdEx++
6065 msglen |= int(b&0x7F) << shift
6066 if b < 0x80 {
6067 break
6068 }
6069 }
6070 if msglen < 0 {
6071 return ErrInvalidLengthMapsproto2
6072 }
6073 postIndex := iNdEx + msglen
6074 if postIndex < 0 {
6075 return ErrInvalidLengthMapsproto2
6076 }
6077 if postIndex > l {
6078 return io.ErrUnexpectedEOF
6079 }
6080 if m.Sint64Map == nil {
6081 m.Sint64Map = make(map[int64]int64)
6082 }
6083 var mapkey int64
6084 var mapvalue int64
6085 for iNdEx < postIndex {
6086 entryPreIndex := iNdEx
6087 var wire uint64
6088 for shift := uint(0); ; shift += 7 {
6089 if shift >= 64 {
6090 return ErrIntOverflowMapsproto2
6091 }
6092 if iNdEx >= l {
6093 return io.ErrUnexpectedEOF
6094 }
6095 b := dAtA[iNdEx]
6096 iNdEx++
6097 wire |= uint64(b&0x7F) << shift
6098 if b < 0x80 {
6099 break
6100 }
6101 }
6102 fieldNum := int32(wire >> 3)
6103 if fieldNum == 1 {
6104 var mapkeytemp uint64
6105 for shift := uint(0); ; shift += 7 {
6106 if shift >= 64 {
6107 return ErrIntOverflowMapsproto2
6108 }
6109 if iNdEx >= l {
6110 return io.ErrUnexpectedEOF
6111 }
6112 b := dAtA[iNdEx]
6113 iNdEx++
6114 mapkeytemp |= uint64(b&0x7F) << shift
6115 if b < 0x80 {
6116 break
6117 }
6118 }
6119 mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
6120 mapkey = int64(mapkeytemp)
6121 } else if fieldNum == 2 {
6122 var mapvaluetemp uint64
6123 for shift := uint(0); ; shift += 7 {
6124 if shift >= 64 {
6125 return ErrIntOverflowMapsproto2
6126 }
6127 if iNdEx >= l {
6128 return io.ErrUnexpectedEOF
6129 }
6130 b := dAtA[iNdEx]
6131 iNdEx++
6132 mapvaluetemp |= uint64(b&0x7F) << shift
6133 if b < 0x80 {
6134 break
6135 }
6136 }
6137 mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
6138 mapvalue = int64(mapvaluetemp)
6139 } else {
6140 iNdEx = entryPreIndex
6141 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6142 if err != nil {
6143 return err
6144 }
6145 if (skippy < 0) || (iNdEx+skippy) < 0 {
6146 return ErrInvalidLengthMapsproto2
6147 }
6148 if (iNdEx + skippy) > postIndex {
6149 return io.ErrUnexpectedEOF
6150 }
6151 iNdEx += skippy
6152 }
6153 }
6154 m.Sint64Map[mapkey] = mapvalue
6155 iNdEx = postIndex
6156 case 9:
6157 if wireType != 2 {
6158 return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType)
6159 }
6160 var msglen int
6161 for shift := uint(0); ; shift += 7 {
6162 if shift >= 64 {
6163 return ErrIntOverflowMapsproto2
6164 }
6165 if iNdEx >= l {
6166 return io.ErrUnexpectedEOF
6167 }
6168 b := dAtA[iNdEx]
6169 iNdEx++
6170 msglen |= int(b&0x7F) << shift
6171 if b < 0x80 {
6172 break
6173 }
6174 }
6175 if msglen < 0 {
6176 return ErrInvalidLengthMapsproto2
6177 }
6178 postIndex := iNdEx + msglen
6179 if postIndex < 0 {
6180 return ErrInvalidLengthMapsproto2
6181 }
6182 if postIndex > l {
6183 return io.ErrUnexpectedEOF
6184 }
6185 if m.Fixed32Map == nil {
6186 m.Fixed32Map = make(map[uint32]uint32)
6187 }
6188 var mapkey uint32
6189 var mapvalue uint32
6190 for iNdEx < postIndex {
6191 entryPreIndex := iNdEx
6192 var wire uint64
6193 for shift := uint(0); ; shift += 7 {
6194 if shift >= 64 {
6195 return ErrIntOverflowMapsproto2
6196 }
6197 if iNdEx >= l {
6198 return io.ErrUnexpectedEOF
6199 }
6200 b := dAtA[iNdEx]
6201 iNdEx++
6202 wire |= uint64(b&0x7F) << shift
6203 if b < 0x80 {
6204 break
6205 }
6206 }
6207 fieldNum := int32(wire >> 3)
6208 if fieldNum == 1 {
6209 if (iNdEx + 4) > l {
6210 return io.ErrUnexpectedEOF
6211 }
6212 mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6213 iNdEx += 4
6214 } else if fieldNum == 2 {
6215 if (iNdEx + 4) > l {
6216 return io.ErrUnexpectedEOF
6217 }
6218 mapvalue = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6219 iNdEx += 4
6220 } else {
6221 iNdEx = entryPreIndex
6222 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6223 if err != nil {
6224 return err
6225 }
6226 if (skippy < 0) || (iNdEx+skippy) < 0 {
6227 return ErrInvalidLengthMapsproto2
6228 }
6229 if (iNdEx + skippy) > postIndex {
6230 return io.ErrUnexpectedEOF
6231 }
6232 iNdEx += skippy
6233 }
6234 }
6235 m.Fixed32Map[mapkey] = mapvalue
6236 iNdEx = postIndex
6237 case 10:
6238 if wireType != 2 {
6239 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType)
6240 }
6241 var msglen int
6242 for shift := uint(0); ; shift += 7 {
6243 if shift >= 64 {
6244 return ErrIntOverflowMapsproto2
6245 }
6246 if iNdEx >= l {
6247 return io.ErrUnexpectedEOF
6248 }
6249 b := dAtA[iNdEx]
6250 iNdEx++
6251 msglen |= int(b&0x7F) << shift
6252 if b < 0x80 {
6253 break
6254 }
6255 }
6256 if msglen < 0 {
6257 return ErrInvalidLengthMapsproto2
6258 }
6259 postIndex := iNdEx + msglen
6260 if postIndex < 0 {
6261 return ErrInvalidLengthMapsproto2
6262 }
6263 if postIndex > l {
6264 return io.ErrUnexpectedEOF
6265 }
6266 if m.Sfixed32Map == nil {
6267 m.Sfixed32Map = make(map[int32]int32)
6268 }
6269 var mapkey int32
6270 var mapvalue int32
6271 for iNdEx < postIndex {
6272 entryPreIndex := iNdEx
6273 var wire uint64
6274 for shift := uint(0); ; shift += 7 {
6275 if shift >= 64 {
6276 return ErrIntOverflowMapsproto2
6277 }
6278 if iNdEx >= l {
6279 return io.ErrUnexpectedEOF
6280 }
6281 b := dAtA[iNdEx]
6282 iNdEx++
6283 wire |= uint64(b&0x7F) << shift
6284 if b < 0x80 {
6285 break
6286 }
6287 }
6288 fieldNum := int32(wire >> 3)
6289 if fieldNum == 1 {
6290 if (iNdEx + 4) > l {
6291 return io.ErrUnexpectedEOF
6292 }
6293 mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6294 iNdEx += 4
6295 } else if fieldNum == 2 {
6296 if (iNdEx + 4) > l {
6297 return io.ErrUnexpectedEOF
6298 }
6299 mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6300 iNdEx += 4
6301 } else {
6302 iNdEx = entryPreIndex
6303 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6304 if err != nil {
6305 return err
6306 }
6307 if (skippy < 0) || (iNdEx+skippy) < 0 {
6308 return ErrInvalidLengthMapsproto2
6309 }
6310 if (iNdEx + skippy) > postIndex {
6311 return io.ErrUnexpectedEOF
6312 }
6313 iNdEx += skippy
6314 }
6315 }
6316 m.Sfixed32Map[mapkey] = mapvalue
6317 iNdEx = postIndex
6318 case 11:
6319 if wireType != 2 {
6320 return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType)
6321 }
6322 var msglen int
6323 for shift := uint(0); ; shift += 7 {
6324 if shift >= 64 {
6325 return ErrIntOverflowMapsproto2
6326 }
6327 if iNdEx >= l {
6328 return io.ErrUnexpectedEOF
6329 }
6330 b := dAtA[iNdEx]
6331 iNdEx++
6332 msglen |= int(b&0x7F) << shift
6333 if b < 0x80 {
6334 break
6335 }
6336 }
6337 if msglen < 0 {
6338 return ErrInvalidLengthMapsproto2
6339 }
6340 postIndex := iNdEx + msglen
6341 if postIndex < 0 {
6342 return ErrInvalidLengthMapsproto2
6343 }
6344 if postIndex > l {
6345 return io.ErrUnexpectedEOF
6346 }
6347 if m.Fixed64Map == nil {
6348 m.Fixed64Map = make(map[uint64]uint64)
6349 }
6350 var mapkey uint64
6351 var mapvalue uint64
6352 for iNdEx < postIndex {
6353 entryPreIndex := iNdEx
6354 var wire uint64
6355 for shift := uint(0); ; shift += 7 {
6356 if shift >= 64 {
6357 return ErrIntOverflowMapsproto2
6358 }
6359 if iNdEx >= l {
6360 return io.ErrUnexpectedEOF
6361 }
6362 b := dAtA[iNdEx]
6363 iNdEx++
6364 wire |= uint64(b&0x7F) << shift
6365 if b < 0x80 {
6366 break
6367 }
6368 }
6369 fieldNum := int32(wire >> 3)
6370 if fieldNum == 1 {
6371 if (iNdEx + 8) > l {
6372 return io.ErrUnexpectedEOF
6373 }
6374 mapkey = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
6375 iNdEx += 8
6376 } else if fieldNum == 2 {
6377 if (iNdEx + 8) > l {
6378 return io.ErrUnexpectedEOF
6379 }
6380 mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
6381 iNdEx += 8
6382 } else {
6383 iNdEx = entryPreIndex
6384 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6385 if err != nil {
6386 return err
6387 }
6388 if (skippy < 0) || (iNdEx+skippy) < 0 {
6389 return ErrInvalidLengthMapsproto2
6390 }
6391 if (iNdEx + skippy) > postIndex {
6392 return io.ErrUnexpectedEOF
6393 }
6394 iNdEx += skippy
6395 }
6396 }
6397 m.Fixed64Map[mapkey] = mapvalue
6398 iNdEx = postIndex
6399 case 12:
6400 if wireType != 2 {
6401 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType)
6402 }
6403 var msglen int
6404 for shift := uint(0); ; shift += 7 {
6405 if shift >= 64 {
6406 return ErrIntOverflowMapsproto2
6407 }
6408 if iNdEx >= l {
6409 return io.ErrUnexpectedEOF
6410 }
6411 b := dAtA[iNdEx]
6412 iNdEx++
6413 msglen |= int(b&0x7F) << shift
6414 if b < 0x80 {
6415 break
6416 }
6417 }
6418 if msglen < 0 {
6419 return ErrInvalidLengthMapsproto2
6420 }
6421 postIndex := iNdEx + msglen
6422 if postIndex < 0 {
6423 return ErrInvalidLengthMapsproto2
6424 }
6425 if postIndex > l {
6426 return io.ErrUnexpectedEOF
6427 }
6428 if m.Sfixed64Map == nil {
6429 m.Sfixed64Map = make(map[int64]int64)
6430 }
6431 var mapkey int64
6432 var mapvalue int64
6433 for iNdEx < postIndex {
6434 entryPreIndex := iNdEx
6435 var wire uint64
6436 for shift := uint(0); ; shift += 7 {
6437 if shift >= 64 {
6438 return ErrIntOverflowMapsproto2
6439 }
6440 if iNdEx >= l {
6441 return io.ErrUnexpectedEOF
6442 }
6443 b := dAtA[iNdEx]
6444 iNdEx++
6445 wire |= uint64(b&0x7F) << shift
6446 if b < 0x80 {
6447 break
6448 }
6449 }
6450 fieldNum := int32(wire >> 3)
6451 if fieldNum == 1 {
6452 if (iNdEx + 8) > l {
6453 return io.ErrUnexpectedEOF
6454 }
6455 mapkey = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
6456 iNdEx += 8
6457 } else if fieldNum == 2 {
6458 if (iNdEx + 8) > l {
6459 return io.ErrUnexpectedEOF
6460 }
6461 mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
6462 iNdEx += 8
6463 } else {
6464 iNdEx = entryPreIndex
6465 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6466 if err != nil {
6467 return err
6468 }
6469 if (skippy < 0) || (iNdEx+skippy) < 0 {
6470 return ErrInvalidLengthMapsproto2
6471 }
6472 if (iNdEx + skippy) > postIndex {
6473 return io.ErrUnexpectedEOF
6474 }
6475 iNdEx += skippy
6476 }
6477 }
6478 m.Sfixed64Map[mapkey] = mapvalue
6479 iNdEx = postIndex
6480 case 13:
6481 if wireType != 2 {
6482 return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType)
6483 }
6484 var msglen int
6485 for shift := uint(0); ; shift += 7 {
6486 if shift >= 64 {
6487 return ErrIntOverflowMapsproto2
6488 }
6489 if iNdEx >= l {
6490 return io.ErrUnexpectedEOF
6491 }
6492 b := dAtA[iNdEx]
6493 iNdEx++
6494 msglen |= int(b&0x7F) << shift
6495 if b < 0x80 {
6496 break
6497 }
6498 }
6499 if msglen < 0 {
6500 return ErrInvalidLengthMapsproto2
6501 }
6502 postIndex := iNdEx + msglen
6503 if postIndex < 0 {
6504 return ErrInvalidLengthMapsproto2
6505 }
6506 if postIndex > l {
6507 return io.ErrUnexpectedEOF
6508 }
6509 if m.BoolMap == nil {
6510 m.BoolMap = make(map[bool]bool)
6511 }
6512 var mapkey bool
6513 var mapvalue bool
6514 for iNdEx < postIndex {
6515 entryPreIndex := iNdEx
6516 var wire uint64
6517 for shift := uint(0); ; shift += 7 {
6518 if shift >= 64 {
6519 return ErrIntOverflowMapsproto2
6520 }
6521 if iNdEx >= l {
6522 return io.ErrUnexpectedEOF
6523 }
6524 b := dAtA[iNdEx]
6525 iNdEx++
6526 wire |= uint64(b&0x7F) << shift
6527 if b < 0x80 {
6528 break
6529 }
6530 }
6531 fieldNum := int32(wire >> 3)
6532 if fieldNum == 1 {
6533 var mapkeytemp int
6534 for shift := uint(0); ; shift += 7 {
6535 if shift >= 64 {
6536 return ErrIntOverflowMapsproto2
6537 }
6538 if iNdEx >= l {
6539 return io.ErrUnexpectedEOF
6540 }
6541 b := dAtA[iNdEx]
6542 iNdEx++
6543 mapkeytemp |= int(b&0x7F) << shift
6544 if b < 0x80 {
6545 break
6546 }
6547 }
6548 mapkey = bool(mapkeytemp != 0)
6549 } else if fieldNum == 2 {
6550 var mapvaluetemp int
6551 for shift := uint(0); ; shift += 7 {
6552 if shift >= 64 {
6553 return ErrIntOverflowMapsproto2
6554 }
6555 if iNdEx >= l {
6556 return io.ErrUnexpectedEOF
6557 }
6558 b := dAtA[iNdEx]
6559 iNdEx++
6560 mapvaluetemp |= int(b&0x7F) << shift
6561 if b < 0x80 {
6562 break
6563 }
6564 }
6565 mapvalue = bool(mapvaluetemp != 0)
6566 } else {
6567 iNdEx = entryPreIndex
6568 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6569 if err != nil {
6570 return err
6571 }
6572 if (skippy < 0) || (iNdEx+skippy) < 0 {
6573 return ErrInvalidLengthMapsproto2
6574 }
6575 if (iNdEx + skippy) > postIndex {
6576 return io.ErrUnexpectedEOF
6577 }
6578 iNdEx += skippy
6579 }
6580 }
6581 m.BoolMap[mapkey] = mapvalue
6582 iNdEx = postIndex
6583 case 14:
6584 if wireType != 2 {
6585 return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType)
6586 }
6587 var msglen int
6588 for shift := uint(0); ; shift += 7 {
6589 if shift >= 64 {
6590 return ErrIntOverflowMapsproto2
6591 }
6592 if iNdEx >= l {
6593 return io.ErrUnexpectedEOF
6594 }
6595 b := dAtA[iNdEx]
6596 iNdEx++
6597 msglen |= int(b&0x7F) << shift
6598 if b < 0x80 {
6599 break
6600 }
6601 }
6602 if msglen < 0 {
6603 return ErrInvalidLengthMapsproto2
6604 }
6605 postIndex := iNdEx + msglen
6606 if postIndex < 0 {
6607 return ErrInvalidLengthMapsproto2
6608 }
6609 if postIndex > l {
6610 return io.ErrUnexpectedEOF
6611 }
6612 if m.StringMap == nil {
6613 m.StringMap = make(map[string]string)
6614 }
6615 var mapkey string
6616 var mapvalue string
6617 for iNdEx < postIndex {
6618 entryPreIndex := iNdEx
6619 var wire uint64
6620 for shift := uint(0); ; shift += 7 {
6621 if shift >= 64 {
6622 return ErrIntOverflowMapsproto2
6623 }
6624 if iNdEx >= l {
6625 return io.ErrUnexpectedEOF
6626 }
6627 b := dAtA[iNdEx]
6628 iNdEx++
6629 wire |= uint64(b&0x7F) << shift
6630 if b < 0x80 {
6631 break
6632 }
6633 }
6634 fieldNum := int32(wire >> 3)
6635 if fieldNum == 1 {
6636 var stringLenmapkey uint64
6637 for shift := uint(0); ; shift += 7 {
6638 if shift >= 64 {
6639 return ErrIntOverflowMapsproto2
6640 }
6641 if iNdEx >= l {
6642 return io.ErrUnexpectedEOF
6643 }
6644 b := dAtA[iNdEx]
6645 iNdEx++
6646 stringLenmapkey |= uint64(b&0x7F) << shift
6647 if b < 0x80 {
6648 break
6649 }
6650 }
6651 intStringLenmapkey := int(stringLenmapkey)
6652 if intStringLenmapkey < 0 {
6653 return ErrInvalidLengthMapsproto2
6654 }
6655 postStringIndexmapkey := iNdEx + intStringLenmapkey
6656 if postStringIndexmapkey < 0 {
6657 return ErrInvalidLengthMapsproto2
6658 }
6659 if postStringIndexmapkey > l {
6660 return io.ErrUnexpectedEOF
6661 }
6662 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6663 iNdEx = postStringIndexmapkey
6664 } else if fieldNum == 2 {
6665 var stringLenmapvalue uint64
6666 for shift := uint(0); ; shift += 7 {
6667 if shift >= 64 {
6668 return ErrIntOverflowMapsproto2
6669 }
6670 if iNdEx >= l {
6671 return io.ErrUnexpectedEOF
6672 }
6673 b := dAtA[iNdEx]
6674 iNdEx++
6675 stringLenmapvalue |= uint64(b&0x7F) << shift
6676 if b < 0x80 {
6677 break
6678 }
6679 }
6680 intStringLenmapvalue := int(stringLenmapvalue)
6681 if intStringLenmapvalue < 0 {
6682 return ErrInvalidLengthMapsproto2
6683 }
6684 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
6685 if postStringIndexmapvalue < 0 {
6686 return ErrInvalidLengthMapsproto2
6687 }
6688 if postStringIndexmapvalue > l {
6689 return io.ErrUnexpectedEOF
6690 }
6691 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
6692 iNdEx = postStringIndexmapvalue
6693 } else {
6694 iNdEx = entryPreIndex
6695 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6696 if err != nil {
6697 return err
6698 }
6699 if (skippy < 0) || (iNdEx+skippy) < 0 {
6700 return ErrInvalidLengthMapsproto2
6701 }
6702 if (iNdEx + skippy) > postIndex {
6703 return io.ErrUnexpectedEOF
6704 }
6705 iNdEx += skippy
6706 }
6707 }
6708 m.StringMap[mapkey] = mapvalue
6709 iNdEx = postIndex
6710 case 15:
6711 if wireType != 2 {
6712 return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType)
6713 }
6714 var msglen int
6715 for shift := uint(0); ; shift += 7 {
6716 if shift >= 64 {
6717 return ErrIntOverflowMapsproto2
6718 }
6719 if iNdEx >= l {
6720 return io.ErrUnexpectedEOF
6721 }
6722 b := dAtA[iNdEx]
6723 iNdEx++
6724 msglen |= int(b&0x7F) << shift
6725 if b < 0x80 {
6726 break
6727 }
6728 }
6729 if msglen < 0 {
6730 return ErrInvalidLengthMapsproto2
6731 }
6732 postIndex := iNdEx + msglen
6733 if postIndex < 0 {
6734 return ErrInvalidLengthMapsproto2
6735 }
6736 if postIndex > l {
6737 return io.ErrUnexpectedEOF
6738 }
6739 if m.StringToBytesMap == nil {
6740 m.StringToBytesMap = make(map[string][]byte)
6741 }
6742 var mapkey string
6743 mapvalue := []byte{}
6744 for iNdEx < postIndex {
6745 entryPreIndex := iNdEx
6746 var wire uint64
6747 for shift := uint(0); ; shift += 7 {
6748 if shift >= 64 {
6749 return ErrIntOverflowMapsproto2
6750 }
6751 if iNdEx >= l {
6752 return io.ErrUnexpectedEOF
6753 }
6754 b := dAtA[iNdEx]
6755 iNdEx++
6756 wire |= uint64(b&0x7F) << shift
6757 if b < 0x80 {
6758 break
6759 }
6760 }
6761 fieldNum := int32(wire >> 3)
6762 if fieldNum == 1 {
6763 var stringLenmapkey uint64
6764 for shift := uint(0); ; shift += 7 {
6765 if shift >= 64 {
6766 return ErrIntOverflowMapsproto2
6767 }
6768 if iNdEx >= l {
6769 return io.ErrUnexpectedEOF
6770 }
6771 b := dAtA[iNdEx]
6772 iNdEx++
6773 stringLenmapkey |= uint64(b&0x7F) << shift
6774 if b < 0x80 {
6775 break
6776 }
6777 }
6778 intStringLenmapkey := int(stringLenmapkey)
6779 if intStringLenmapkey < 0 {
6780 return ErrInvalidLengthMapsproto2
6781 }
6782 postStringIndexmapkey := iNdEx + intStringLenmapkey
6783 if postStringIndexmapkey < 0 {
6784 return ErrInvalidLengthMapsproto2
6785 }
6786 if postStringIndexmapkey > l {
6787 return io.ErrUnexpectedEOF
6788 }
6789 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6790 iNdEx = postStringIndexmapkey
6791 } else if fieldNum == 2 {
6792 var mapbyteLen uint64
6793 for shift := uint(0); ; shift += 7 {
6794 if shift >= 64 {
6795 return ErrIntOverflowMapsproto2
6796 }
6797 if iNdEx >= l {
6798 return io.ErrUnexpectedEOF
6799 }
6800 b := dAtA[iNdEx]
6801 iNdEx++
6802 mapbyteLen |= uint64(b&0x7F) << shift
6803 if b < 0x80 {
6804 break
6805 }
6806 }
6807 intMapbyteLen := int(mapbyteLen)
6808 if intMapbyteLen < 0 {
6809 return ErrInvalidLengthMapsproto2
6810 }
6811 postbytesIndex := iNdEx + intMapbyteLen
6812 if postbytesIndex < 0 {
6813 return ErrInvalidLengthMapsproto2
6814 }
6815 if postbytesIndex > l {
6816 return io.ErrUnexpectedEOF
6817 }
6818 mapvalue = make([]byte, mapbyteLen)
6819 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
6820 iNdEx = postbytesIndex
6821 } else {
6822 iNdEx = entryPreIndex
6823 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6824 if err != nil {
6825 return err
6826 }
6827 if (skippy < 0) || (iNdEx+skippy) < 0 {
6828 return ErrInvalidLengthMapsproto2
6829 }
6830 if (iNdEx + skippy) > postIndex {
6831 return io.ErrUnexpectedEOF
6832 }
6833 iNdEx += skippy
6834 }
6835 }
6836 m.StringToBytesMap[mapkey] = mapvalue
6837 iNdEx = postIndex
6838 case 16:
6839 if wireType != 2 {
6840 return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType)
6841 }
6842 var msglen int
6843 for shift := uint(0); ; shift += 7 {
6844 if shift >= 64 {
6845 return ErrIntOverflowMapsproto2
6846 }
6847 if iNdEx >= l {
6848 return io.ErrUnexpectedEOF
6849 }
6850 b := dAtA[iNdEx]
6851 iNdEx++
6852 msglen |= int(b&0x7F) << shift
6853 if b < 0x80 {
6854 break
6855 }
6856 }
6857 if msglen < 0 {
6858 return ErrInvalidLengthMapsproto2
6859 }
6860 postIndex := iNdEx + msglen
6861 if postIndex < 0 {
6862 return ErrInvalidLengthMapsproto2
6863 }
6864 if postIndex > l {
6865 return io.ErrUnexpectedEOF
6866 }
6867 if m.StringToEnumMap == nil {
6868 m.StringToEnumMap = make(map[string]MapEnum)
6869 }
6870 var mapkey string
6871 var mapvalue MapEnum
6872 for iNdEx < postIndex {
6873 entryPreIndex := iNdEx
6874 var wire uint64
6875 for shift := uint(0); ; shift += 7 {
6876 if shift >= 64 {
6877 return ErrIntOverflowMapsproto2
6878 }
6879 if iNdEx >= l {
6880 return io.ErrUnexpectedEOF
6881 }
6882 b := dAtA[iNdEx]
6883 iNdEx++
6884 wire |= uint64(b&0x7F) << shift
6885 if b < 0x80 {
6886 break
6887 }
6888 }
6889 fieldNum := int32(wire >> 3)
6890 if fieldNum == 1 {
6891 var stringLenmapkey uint64
6892 for shift := uint(0); ; shift += 7 {
6893 if shift >= 64 {
6894 return ErrIntOverflowMapsproto2
6895 }
6896 if iNdEx >= l {
6897 return io.ErrUnexpectedEOF
6898 }
6899 b := dAtA[iNdEx]
6900 iNdEx++
6901 stringLenmapkey |= uint64(b&0x7F) << shift
6902 if b < 0x80 {
6903 break
6904 }
6905 }
6906 intStringLenmapkey := int(stringLenmapkey)
6907 if intStringLenmapkey < 0 {
6908 return ErrInvalidLengthMapsproto2
6909 }
6910 postStringIndexmapkey := iNdEx + intStringLenmapkey
6911 if postStringIndexmapkey < 0 {
6912 return ErrInvalidLengthMapsproto2
6913 }
6914 if postStringIndexmapkey > l {
6915 return io.ErrUnexpectedEOF
6916 }
6917 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6918 iNdEx = postStringIndexmapkey
6919 } else if fieldNum == 2 {
6920 for shift := uint(0); ; shift += 7 {
6921 if shift >= 64 {
6922 return ErrIntOverflowMapsproto2
6923 }
6924 if iNdEx >= l {
6925 return io.ErrUnexpectedEOF
6926 }
6927 b := dAtA[iNdEx]
6928 iNdEx++
6929 mapvalue |= MapEnum(b&0x7F) << shift
6930 if b < 0x80 {
6931 break
6932 }
6933 }
6934 } else {
6935 iNdEx = entryPreIndex
6936 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6937 if err != nil {
6938 return err
6939 }
6940 if (skippy < 0) || (iNdEx+skippy) < 0 {
6941 return ErrInvalidLengthMapsproto2
6942 }
6943 if (iNdEx + skippy) > postIndex {
6944 return io.ErrUnexpectedEOF
6945 }
6946 iNdEx += skippy
6947 }
6948 }
6949 m.StringToEnumMap[mapkey] = mapvalue
6950 iNdEx = postIndex
6951 case 17:
6952 if wireType != 2 {
6953 return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType)
6954 }
6955 var msglen int
6956 for shift := uint(0); ; shift += 7 {
6957 if shift >= 64 {
6958 return ErrIntOverflowMapsproto2
6959 }
6960 if iNdEx >= l {
6961 return io.ErrUnexpectedEOF
6962 }
6963 b := dAtA[iNdEx]
6964 iNdEx++
6965 msglen |= int(b&0x7F) << shift
6966 if b < 0x80 {
6967 break
6968 }
6969 }
6970 if msglen < 0 {
6971 return ErrInvalidLengthMapsproto2
6972 }
6973 postIndex := iNdEx + msglen
6974 if postIndex < 0 {
6975 return ErrInvalidLengthMapsproto2
6976 }
6977 if postIndex > l {
6978 return io.ErrUnexpectedEOF
6979 }
6980 if m.StringToMsgMap == nil {
6981 m.StringToMsgMap = make(map[string]*FloatingPoint)
6982 }
6983 var mapkey string
6984 var mapvalue *FloatingPoint
6985 for iNdEx < postIndex {
6986 entryPreIndex := iNdEx
6987 var wire uint64
6988 for shift := uint(0); ; shift += 7 {
6989 if shift >= 64 {
6990 return ErrIntOverflowMapsproto2
6991 }
6992 if iNdEx >= l {
6993 return io.ErrUnexpectedEOF
6994 }
6995 b := dAtA[iNdEx]
6996 iNdEx++
6997 wire |= uint64(b&0x7F) << shift
6998 if b < 0x80 {
6999 break
7000 }
7001 }
7002 fieldNum := int32(wire >> 3)
7003 if fieldNum == 1 {
7004 var stringLenmapkey uint64
7005 for shift := uint(0); ; shift += 7 {
7006 if shift >= 64 {
7007 return ErrIntOverflowMapsproto2
7008 }
7009 if iNdEx >= l {
7010 return io.ErrUnexpectedEOF
7011 }
7012 b := dAtA[iNdEx]
7013 iNdEx++
7014 stringLenmapkey |= uint64(b&0x7F) << shift
7015 if b < 0x80 {
7016 break
7017 }
7018 }
7019 intStringLenmapkey := int(stringLenmapkey)
7020 if intStringLenmapkey < 0 {
7021 return ErrInvalidLengthMapsproto2
7022 }
7023 postStringIndexmapkey := iNdEx + intStringLenmapkey
7024 if postStringIndexmapkey < 0 {
7025 return ErrInvalidLengthMapsproto2
7026 }
7027 if postStringIndexmapkey > l {
7028 return io.ErrUnexpectedEOF
7029 }
7030 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7031 iNdEx = postStringIndexmapkey
7032 } else if fieldNum == 2 {
7033 var mapmsglen int
7034 for shift := uint(0); ; shift += 7 {
7035 if shift >= 64 {
7036 return ErrIntOverflowMapsproto2
7037 }
7038 if iNdEx >= l {
7039 return io.ErrUnexpectedEOF
7040 }
7041 b := dAtA[iNdEx]
7042 iNdEx++
7043 mapmsglen |= int(b&0x7F) << shift
7044 if b < 0x80 {
7045 break
7046 }
7047 }
7048 if mapmsglen < 0 {
7049 return ErrInvalidLengthMapsproto2
7050 }
7051 postmsgIndex := iNdEx + mapmsglen
7052 if postmsgIndex < 0 {
7053 return ErrInvalidLengthMapsproto2
7054 }
7055 if postmsgIndex > l {
7056 return io.ErrUnexpectedEOF
7057 }
7058 mapvalue = &FloatingPoint{}
7059 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
7060 return err
7061 }
7062 iNdEx = postmsgIndex
7063 } else {
7064 iNdEx = entryPreIndex
7065 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7066 if err != nil {
7067 return err
7068 }
7069 if (skippy < 0) || (iNdEx+skippy) < 0 {
7070 return ErrInvalidLengthMapsproto2
7071 }
7072 if (iNdEx + skippy) > postIndex {
7073 return io.ErrUnexpectedEOF
7074 }
7075 iNdEx += skippy
7076 }
7077 }
7078 m.StringToMsgMap[mapkey] = mapvalue
7079 iNdEx = postIndex
7080 default:
7081 iNdEx = preIndex
7082 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7083 if err != nil {
7084 return err
7085 }
7086 if (skippy < 0) || (iNdEx+skippy) < 0 {
7087 return ErrInvalidLengthMapsproto2
7088 }
7089 if (iNdEx + skippy) > l {
7090 return io.ErrUnexpectedEOF
7091 }
7092 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7093 iNdEx += skippy
7094 }
7095 }
7096
7097 if iNdEx > l {
7098 return io.ErrUnexpectedEOF
7099 }
7100 return nil
7101 }
7102 func (m *AllMapsOrdered) Unmarshal(dAtA []byte) error {
7103 l := len(dAtA)
7104 iNdEx := 0
7105 for iNdEx < l {
7106 preIndex := iNdEx
7107 var wire uint64
7108 for shift := uint(0); ; shift += 7 {
7109 if shift >= 64 {
7110 return ErrIntOverflowMapsproto2
7111 }
7112 if iNdEx >= l {
7113 return io.ErrUnexpectedEOF
7114 }
7115 b := dAtA[iNdEx]
7116 iNdEx++
7117 wire |= uint64(b&0x7F) << shift
7118 if b < 0x80 {
7119 break
7120 }
7121 }
7122 fieldNum := int32(wire >> 3)
7123 wireType := int(wire & 0x7)
7124 if wireType == 4 {
7125 return fmt.Errorf("proto: AllMapsOrdered: wiretype end group for non-group")
7126 }
7127 if fieldNum <= 0 {
7128 return fmt.Errorf("proto: AllMapsOrdered: illegal tag %d (wire type %d)", fieldNum, wire)
7129 }
7130 switch fieldNum {
7131 case 1:
7132 if wireType != 2 {
7133 return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType)
7134 }
7135 var msglen int
7136 for shift := uint(0); ; shift += 7 {
7137 if shift >= 64 {
7138 return ErrIntOverflowMapsproto2
7139 }
7140 if iNdEx >= l {
7141 return io.ErrUnexpectedEOF
7142 }
7143 b := dAtA[iNdEx]
7144 iNdEx++
7145 msglen |= int(b&0x7F) << shift
7146 if b < 0x80 {
7147 break
7148 }
7149 }
7150 if msglen < 0 {
7151 return ErrInvalidLengthMapsproto2
7152 }
7153 postIndex := iNdEx + msglen
7154 if postIndex < 0 {
7155 return ErrInvalidLengthMapsproto2
7156 }
7157 if postIndex > l {
7158 return io.ErrUnexpectedEOF
7159 }
7160 if m.StringToDoubleMap == nil {
7161 m.StringToDoubleMap = make(map[string]float64)
7162 }
7163 var mapkey string
7164 var mapvalue float64
7165 for iNdEx < postIndex {
7166 entryPreIndex := iNdEx
7167 var wire uint64
7168 for shift := uint(0); ; shift += 7 {
7169 if shift >= 64 {
7170 return ErrIntOverflowMapsproto2
7171 }
7172 if iNdEx >= l {
7173 return io.ErrUnexpectedEOF
7174 }
7175 b := dAtA[iNdEx]
7176 iNdEx++
7177 wire |= uint64(b&0x7F) << shift
7178 if b < 0x80 {
7179 break
7180 }
7181 }
7182 fieldNum := int32(wire >> 3)
7183 if fieldNum == 1 {
7184 var stringLenmapkey uint64
7185 for shift := uint(0); ; shift += 7 {
7186 if shift >= 64 {
7187 return ErrIntOverflowMapsproto2
7188 }
7189 if iNdEx >= l {
7190 return io.ErrUnexpectedEOF
7191 }
7192 b := dAtA[iNdEx]
7193 iNdEx++
7194 stringLenmapkey |= uint64(b&0x7F) << shift
7195 if b < 0x80 {
7196 break
7197 }
7198 }
7199 intStringLenmapkey := int(stringLenmapkey)
7200 if intStringLenmapkey < 0 {
7201 return ErrInvalidLengthMapsproto2
7202 }
7203 postStringIndexmapkey := iNdEx + intStringLenmapkey
7204 if postStringIndexmapkey < 0 {
7205 return ErrInvalidLengthMapsproto2
7206 }
7207 if postStringIndexmapkey > l {
7208 return io.ErrUnexpectedEOF
7209 }
7210 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7211 iNdEx = postStringIndexmapkey
7212 } else if fieldNum == 2 {
7213 var mapvaluetemp uint64
7214 if (iNdEx + 8) > l {
7215 return io.ErrUnexpectedEOF
7216 }
7217 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7218 iNdEx += 8
7219 mapvalue = math.Float64frombits(mapvaluetemp)
7220 } else {
7221 iNdEx = entryPreIndex
7222 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7223 if err != nil {
7224 return err
7225 }
7226 if (skippy < 0) || (iNdEx+skippy) < 0 {
7227 return ErrInvalidLengthMapsproto2
7228 }
7229 if (iNdEx + skippy) > postIndex {
7230 return io.ErrUnexpectedEOF
7231 }
7232 iNdEx += skippy
7233 }
7234 }
7235 m.StringToDoubleMap[mapkey] = mapvalue
7236 iNdEx = postIndex
7237 case 2:
7238 if wireType != 2 {
7239 return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType)
7240 }
7241 var msglen int
7242 for shift := uint(0); ; shift += 7 {
7243 if shift >= 64 {
7244 return ErrIntOverflowMapsproto2
7245 }
7246 if iNdEx >= l {
7247 return io.ErrUnexpectedEOF
7248 }
7249 b := dAtA[iNdEx]
7250 iNdEx++
7251 msglen |= int(b&0x7F) << shift
7252 if b < 0x80 {
7253 break
7254 }
7255 }
7256 if msglen < 0 {
7257 return ErrInvalidLengthMapsproto2
7258 }
7259 postIndex := iNdEx + msglen
7260 if postIndex < 0 {
7261 return ErrInvalidLengthMapsproto2
7262 }
7263 if postIndex > l {
7264 return io.ErrUnexpectedEOF
7265 }
7266 if m.StringToFloatMap == nil {
7267 m.StringToFloatMap = make(map[string]float32)
7268 }
7269 var mapkey string
7270 var mapvalue float32
7271 for iNdEx < postIndex {
7272 entryPreIndex := iNdEx
7273 var wire uint64
7274 for shift := uint(0); ; shift += 7 {
7275 if shift >= 64 {
7276 return ErrIntOverflowMapsproto2
7277 }
7278 if iNdEx >= l {
7279 return io.ErrUnexpectedEOF
7280 }
7281 b := dAtA[iNdEx]
7282 iNdEx++
7283 wire |= uint64(b&0x7F) << shift
7284 if b < 0x80 {
7285 break
7286 }
7287 }
7288 fieldNum := int32(wire >> 3)
7289 if fieldNum == 1 {
7290 var stringLenmapkey uint64
7291 for shift := uint(0); ; shift += 7 {
7292 if shift >= 64 {
7293 return ErrIntOverflowMapsproto2
7294 }
7295 if iNdEx >= l {
7296 return io.ErrUnexpectedEOF
7297 }
7298 b := dAtA[iNdEx]
7299 iNdEx++
7300 stringLenmapkey |= uint64(b&0x7F) << shift
7301 if b < 0x80 {
7302 break
7303 }
7304 }
7305 intStringLenmapkey := int(stringLenmapkey)
7306 if intStringLenmapkey < 0 {
7307 return ErrInvalidLengthMapsproto2
7308 }
7309 postStringIndexmapkey := iNdEx + intStringLenmapkey
7310 if postStringIndexmapkey < 0 {
7311 return ErrInvalidLengthMapsproto2
7312 }
7313 if postStringIndexmapkey > l {
7314 return io.ErrUnexpectedEOF
7315 }
7316 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7317 iNdEx = postStringIndexmapkey
7318 } else if fieldNum == 2 {
7319 var mapvaluetemp uint32
7320 if (iNdEx + 4) > l {
7321 return io.ErrUnexpectedEOF
7322 }
7323 mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
7324 iNdEx += 4
7325 mapvalue = math.Float32frombits(mapvaluetemp)
7326 } else {
7327 iNdEx = entryPreIndex
7328 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7329 if err != nil {
7330 return err
7331 }
7332 if (skippy < 0) || (iNdEx+skippy) < 0 {
7333 return ErrInvalidLengthMapsproto2
7334 }
7335 if (iNdEx + skippy) > postIndex {
7336 return io.ErrUnexpectedEOF
7337 }
7338 iNdEx += skippy
7339 }
7340 }
7341 m.StringToFloatMap[mapkey] = mapvalue
7342 iNdEx = postIndex
7343 case 3:
7344 if wireType != 2 {
7345 return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType)
7346 }
7347 var msglen int
7348 for shift := uint(0); ; shift += 7 {
7349 if shift >= 64 {
7350 return ErrIntOverflowMapsproto2
7351 }
7352 if iNdEx >= l {
7353 return io.ErrUnexpectedEOF
7354 }
7355 b := dAtA[iNdEx]
7356 iNdEx++
7357 msglen |= int(b&0x7F) << shift
7358 if b < 0x80 {
7359 break
7360 }
7361 }
7362 if msglen < 0 {
7363 return ErrInvalidLengthMapsproto2
7364 }
7365 postIndex := iNdEx + msglen
7366 if postIndex < 0 {
7367 return ErrInvalidLengthMapsproto2
7368 }
7369 if postIndex > l {
7370 return io.ErrUnexpectedEOF
7371 }
7372 if m.Int32Map == nil {
7373 m.Int32Map = make(map[int32]int32)
7374 }
7375 var mapkey int32
7376 var mapvalue int32
7377 for iNdEx < postIndex {
7378 entryPreIndex := iNdEx
7379 var wire uint64
7380 for shift := uint(0); ; shift += 7 {
7381 if shift >= 64 {
7382 return ErrIntOverflowMapsproto2
7383 }
7384 if iNdEx >= l {
7385 return io.ErrUnexpectedEOF
7386 }
7387 b := dAtA[iNdEx]
7388 iNdEx++
7389 wire |= uint64(b&0x7F) << shift
7390 if b < 0x80 {
7391 break
7392 }
7393 }
7394 fieldNum := int32(wire >> 3)
7395 if fieldNum == 1 {
7396 for shift := uint(0); ; shift += 7 {
7397 if shift >= 64 {
7398 return ErrIntOverflowMapsproto2
7399 }
7400 if iNdEx >= l {
7401 return io.ErrUnexpectedEOF
7402 }
7403 b := dAtA[iNdEx]
7404 iNdEx++
7405 mapkey |= int32(b&0x7F) << shift
7406 if b < 0x80 {
7407 break
7408 }
7409 }
7410 } else if fieldNum == 2 {
7411 for shift := uint(0); ; shift += 7 {
7412 if shift >= 64 {
7413 return ErrIntOverflowMapsproto2
7414 }
7415 if iNdEx >= l {
7416 return io.ErrUnexpectedEOF
7417 }
7418 b := dAtA[iNdEx]
7419 iNdEx++
7420 mapvalue |= int32(b&0x7F) << shift
7421 if b < 0x80 {
7422 break
7423 }
7424 }
7425 } else {
7426 iNdEx = entryPreIndex
7427 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7428 if err != nil {
7429 return err
7430 }
7431 if (skippy < 0) || (iNdEx+skippy) < 0 {
7432 return ErrInvalidLengthMapsproto2
7433 }
7434 if (iNdEx + skippy) > postIndex {
7435 return io.ErrUnexpectedEOF
7436 }
7437 iNdEx += skippy
7438 }
7439 }
7440 m.Int32Map[mapkey] = mapvalue
7441 iNdEx = postIndex
7442 case 4:
7443 if wireType != 2 {
7444 return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType)
7445 }
7446 var msglen int
7447 for shift := uint(0); ; shift += 7 {
7448 if shift >= 64 {
7449 return ErrIntOverflowMapsproto2
7450 }
7451 if iNdEx >= l {
7452 return io.ErrUnexpectedEOF
7453 }
7454 b := dAtA[iNdEx]
7455 iNdEx++
7456 msglen |= int(b&0x7F) << shift
7457 if b < 0x80 {
7458 break
7459 }
7460 }
7461 if msglen < 0 {
7462 return ErrInvalidLengthMapsproto2
7463 }
7464 postIndex := iNdEx + msglen
7465 if postIndex < 0 {
7466 return ErrInvalidLengthMapsproto2
7467 }
7468 if postIndex > l {
7469 return io.ErrUnexpectedEOF
7470 }
7471 if m.Int64Map == nil {
7472 m.Int64Map = make(map[int64]int64)
7473 }
7474 var mapkey int64
7475 var mapvalue int64
7476 for iNdEx < postIndex {
7477 entryPreIndex := iNdEx
7478 var wire uint64
7479 for shift := uint(0); ; shift += 7 {
7480 if shift >= 64 {
7481 return ErrIntOverflowMapsproto2
7482 }
7483 if iNdEx >= l {
7484 return io.ErrUnexpectedEOF
7485 }
7486 b := dAtA[iNdEx]
7487 iNdEx++
7488 wire |= uint64(b&0x7F) << shift
7489 if b < 0x80 {
7490 break
7491 }
7492 }
7493 fieldNum := int32(wire >> 3)
7494 if fieldNum == 1 {
7495 for shift := uint(0); ; shift += 7 {
7496 if shift >= 64 {
7497 return ErrIntOverflowMapsproto2
7498 }
7499 if iNdEx >= l {
7500 return io.ErrUnexpectedEOF
7501 }
7502 b := dAtA[iNdEx]
7503 iNdEx++
7504 mapkey |= int64(b&0x7F) << shift
7505 if b < 0x80 {
7506 break
7507 }
7508 }
7509 } else if fieldNum == 2 {
7510 for shift := uint(0); ; shift += 7 {
7511 if shift >= 64 {
7512 return ErrIntOverflowMapsproto2
7513 }
7514 if iNdEx >= l {
7515 return io.ErrUnexpectedEOF
7516 }
7517 b := dAtA[iNdEx]
7518 iNdEx++
7519 mapvalue |= int64(b&0x7F) << shift
7520 if b < 0x80 {
7521 break
7522 }
7523 }
7524 } else {
7525 iNdEx = entryPreIndex
7526 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7527 if err != nil {
7528 return err
7529 }
7530 if (skippy < 0) || (iNdEx+skippy) < 0 {
7531 return ErrInvalidLengthMapsproto2
7532 }
7533 if (iNdEx + skippy) > postIndex {
7534 return io.ErrUnexpectedEOF
7535 }
7536 iNdEx += skippy
7537 }
7538 }
7539 m.Int64Map[mapkey] = mapvalue
7540 iNdEx = postIndex
7541 case 5:
7542 if wireType != 2 {
7543 return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType)
7544 }
7545 var msglen int
7546 for shift := uint(0); ; shift += 7 {
7547 if shift >= 64 {
7548 return ErrIntOverflowMapsproto2
7549 }
7550 if iNdEx >= l {
7551 return io.ErrUnexpectedEOF
7552 }
7553 b := dAtA[iNdEx]
7554 iNdEx++
7555 msglen |= int(b&0x7F) << shift
7556 if b < 0x80 {
7557 break
7558 }
7559 }
7560 if msglen < 0 {
7561 return ErrInvalidLengthMapsproto2
7562 }
7563 postIndex := iNdEx + msglen
7564 if postIndex < 0 {
7565 return ErrInvalidLengthMapsproto2
7566 }
7567 if postIndex > l {
7568 return io.ErrUnexpectedEOF
7569 }
7570 if m.Uint32Map == nil {
7571 m.Uint32Map = make(map[uint32]uint32)
7572 }
7573 var mapkey uint32
7574 var mapvalue uint32
7575 for iNdEx < postIndex {
7576 entryPreIndex := iNdEx
7577 var wire uint64
7578 for shift := uint(0); ; shift += 7 {
7579 if shift >= 64 {
7580 return ErrIntOverflowMapsproto2
7581 }
7582 if iNdEx >= l {
7583 return io.ErrUnexpectedEOF
7584 }
7585 b := dAtA[iNdEx]
7586 iNdEx++
7587 wire |= uint64(b&0x7F) << shift
7588 if b < 0x80 {
7589 break
7590 }
7591 }
7592 fieldNum := int32(wire >> 3)
7593 if fieldNum == 1 {
7594 for shift := uint(0); ; shift += 7 {
7595 if shift >= 64 {
7596 return ErrIntOverflowMapsproto2
7597 }
7598 if iNdEx >= l {
7599 return io.ErrUnexpectedEOF
7600 }
7601 b := dAtA[iNdEx]
7602 iNdEx++
7603 mapkey |= uint32(b&0x7F) << shift
7604 if b < 0x80 {
7605 break
7606 }
7607 }
7608 } else if fieldNum == 2 {
7609 for shift := uint(0); ; shift += 7 {
7610 if shift >= 64 {
7611 return ErrIntOverflowMapsproto2
7612 }
7613 if iNdEx >= l {
7614 return io.ErrUnexpectedEOF
7615 }
7616 b := dAtA[iNdEx]
7617 iNdEx++
7618 mapvalue |= uint32(b&0x7F) << shift
7619 if b < 0x80 {
7620 break
7621 }
7622 }
7623 } else {
7624 iNdEx = entryPreIndex
7625 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7626 if err != nil {
7627 return err
7628 }
7629 if (skippy < 0) || (iNdEx+skippy) < 0 {
7630 return ErrInvalidLengthMapsproto2
7631 }
7632 if (iNdEx + skippy) > postIndex {
7633 return io.ErrUnexpectedEOF
7634 }
7635 iNdEx += skippy
7636 }
7637 }
7638 m.Uint32Map[mapkey] = mapvalue
7639 iNdEx = postIndex
7640 case 6:
7641 if wireType != 2 {
7642 return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType)
7643 }
7644 var msglen int
7645 for shift := uint(0); ; shift += 7 {
7646 if shift >= 64 {
7647 return ErrIntOverflowMapsproto2
7648 }
7649 if iNdEx >= l {
7650 return io.ErrUnexpectedEOF
7651 }
7652 b := dAtA[iNdEx]
7653 iNdEx++
7654 msglen |= int(b&0x7F) << shift
7655 if b < 0x80 {
7656 break
7657 }
7658 }
7659 if msglen < 0 {
7660 return ErrInvalidLengthMapsproto2
7661 }
7662 postIndex := iNdEx + msglen
7663 if postIndex < 0 {
7664 return ErrInvalidLengthMapsproto2
7665 }
7666 if postIndex > l {
7667 return io.ErrUnexpectedEOF
7668 }
7669 if m.Uint64Map == nil {
7670 m.Uint64Map = make(map[uint64]uint64)
7671 }
7672 var mapkey uint64
7673 var mapvalue uint64
7674 for iNdEx < postIndex {
7675 entryPreIndex := iNdEx
7676 var wire uint64
7677 for shift := uint(0); ; shift += 7 {
7678 if shift >= 64 {
7679 return ErrIntOverflowMapsproto2
7680 }
7681 if iNdEx >= l {
7682 return io.ErrUnexpectedEOF
7683 }
7684 b := dAtA[iNdEx]
7685 iNdEx++
7686 wire |= uint64(b&0x7F) << shift
7687 if b < 0x80 {
7688 break
7689 }
7690 }
7691 fieldNum := int32(wire >> 3)
7692 if fieldNum == 1 {
7693 for shift := uint(0); ; shift += 7 {
7694 if shift >= 64 {
7695 return ErrIntOverflowMapsproto2
7696 }
7697 if iNdEx >= l {
7698 return io.ErrUnexpectedEOF
7699 }
7700 b := dAtA[iNdEx]
7701 iNdEx++
7702 mapkey |= uint64(b&0x7F) << shift
7703 if b < 0x80 {
7704 break
7705 }
7706 }
7707 } else if fieldNum == 2 {
7708 for shift := uint(0); ; shift += 7 {
7709 if shift >= 64 {
7710 return ErrIntOverflowMapsproto2
7711 }
7712 if iNdEx >= l {
7713 return io.ErrUnexpectedEOF
7714 }
7715 b := dAtA[iNdEx]
7716 iNdEx++
7717 mapvalue |= uint64(b&0x7F) << shift
7718 if b < 0x80 {
7719 break
7720 }
7721 }
7722 } else {
7723 iNdEx = entryPreIndex
7724 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7725 if err != nil {
7726 return err
7727 }
7728 if (skippy < 0) || (iNdEx+skippy) < 0 {
7729 return ErrInvalidLengthMapsproto2
7730 }
7731 if (iNdEx + skippy) > postIndex {
7732 return io.ErrUnexpectedEOF
7733 }
7734 iNdEx += skippy
7735 }
7736 }
7737 m.Uint64Map[mapkey] = mapvalue
7738 iNdEx = postIndex
7739 case 7:
7740 if wireType != 2 {
7741 return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType)
7742 }
7743 var msglen int
7744 for shift := uint(0); ; shift += 7 {
7745 if shift >= 64 {
7746 return ErrIntOverflowMapsproto2
7747 }
7748 if iNdEx >= l {
7749 return io.ErrUnexpectedEOF
7750 }
7751 b := dAtA[iNdEx]
7752 iNdEx++
7753 msglen |= int(b&0x7F) << shift
7754 if b < 0x80 {
7755 break
7756 }
7757 }
7758 if msglen < 0 {
7759 return ErrInvalidLengthMapsproto2
7760 }
7761 postIndex := iNdEx + msglen
7762 if postIndex < 0 {
7763 return ErrInvalidLengthMapsproto2
7764 }
7765 if postIndex > l {
7766 return io.ErrUnexpectedEOF
7767 }
7768 if m.Sint32Map == nil {
7769 m.Sint32Map = make(map[int32]int32)
7770 }
7771 var mapkey int32
7772 var mapvalue int32
7773 for iNdEx < postIndex {
7774 entryPreIndex := iNdEx
7775 var wire uint64
7776 for shift := uint(0); ; shift += 7 {
7777 if shift >= 64 {
7778 return ErrIntOverflowMapsproto2
7779 }
7780 if iNdEx >= l {
7781 return io.ErrUnexpectedEOF
7782 }
7783 b := dAtA[iNdEx]
7784 iNdEx++
7785 wire |= uint64(b&0x7F) << shift
7786 if b < 0x80 {
7787 break
7788 }
7789 }
7790 fieldNum := int32(wire >> 3)
7791 if fieldNum == 1 {
7792 var mapkeytemp int32
7793 for shift := uint(0); ; shift += 7 {
7794 if shift >= 64 {
7795 return ErrIntOverflowMapsproto2
7796 }
7797 if iNdEx >= l {
7798 return io.ErrUnexpectedEOF
7799 }
7800 b := dAtA[iNdEx]
7801 iNdEx++
7802 mapkeytemp |= int32(b&0x7F) << shift
7803 if b < 0x80 {
7804 break
7805 }
7806 }
7807 mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
7808 mapkey = int32(mapkeytemp)
7809 } else if fieldNum == 2 {
7810 var mapvaluetemp int32
7811 for shift := uint(0); ; shift += 7 {
7812 if shift >= 64 {
7813 return ErrIntOverflowMapsproto2
7814 }
7815 if iNdEx >= l {
7816 return io.ErrUnexpectedEOF
7817 }
7818 b := dAtA[iNdEx]
7819 iNdEx++
7820 mapvaluetemp |= int32(b&0x7F) << shift
7821 if b < 0x80 {
7822 break
7823 }
7824 }
7825 mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
7826 mapvalue = int32(mapvaluetemp)
7827 } else {
7828 iNdEx = entryPreIndex
7829 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7830 if err != nil {
7831 return err
7832 }
7833 if (skippy < 0) || (iNdEx+skippy) < 0 {
7834 return ErrInvalidLengthMapsproto2
7835 }
7836 if (iNdEx + skippy) > postIndex {
7837 return io.ErrUnexpectedEOF
7838 }
7839 iNdEx += skippy
7840 }
7841 }
7842 m.Sint32Map[mapkey] = mapvalue
7843 iNdEx = postIndex
7844 case 8:
7845 if wireType != 2 {
7846 return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType)
7847 }
7848 var msglen int
7849 for shift := uint(0); ; shift += 7 {
7850 if shift >= 64 {
7851 return ErrIntOverflowMapsproto2
7852 }
7853 if iNdEx >= l {
7854 return io.ErrUnexpectedEOF
7855 }
7856 b := dAtA[iNdEx]
7857 iNdEx++
7858 msglen |= int(b&0x7F) << shift
7859 if b < 0x80 {
7860 break
7861 }
7862 }
7863 if msglen < 0 {
7864 return ErrInvalidLengthMapsproto2
7865 }
7866 postIndex := iNdEx + msglen
7867 if postIndex < 0 {
7868 return ErrInvalidLengthMapsproto2
7869 }
7870 if postIndex > l {
7871 return io.ErrUnexpectedEOF
7872 }
7873 if m.Sint64Map == nil {
7874 m.Sint64Map = make(map[int64]int64)
7875 }
7876 var mapkey int64
7877 var mapvalue int64
7878 for iNdEx < postIndex {
7879 entryPreIndex := iNdEx
7880 var wire uint64
7881 for shift := uint(0); ; shift += 7 {
7882 if shift >= 64 {
7883 return ErrIntOverflowMapsproto2
7884 }
7885 if iNdEx >= l {
7886 return io.ErrUnexpectedEOF
7887 }
7888 b := dAtA[iNdEx]
7889 iNdEx++
7890 wire |= uint64(b&0x7F) << shift
7891 if b < 0x80 {
7892 break
7893 }
7894 }
7895 fieldNum := int32(wire >> 3)
7896 if fieldNum == 1 {
7897 var mapkeytemp uint64
7898 for shift := uint(0); ; shift += 7 {
7899 if shift >= 64 {
7900 return ErrIntOverflowMapsproto2
7901 }
7902 if iNdEx >= l {
7903 return io.ErrUnexpectedEOF
7904 }
7905 b := dAtA[iNdEx]
7906 iNdEx++
7907 mapkeytemp |= uint64(b&0x7F) << shift
7908 if b < 0x80 {
7909 break
7910 }
7911 }
7912 mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
7913 mapkey = int64(mapkeytemp)
7914 } else if fieldNum == 2 {
7915 var mapvaluetemp uint64
7916 for shift := uint(0); ; shift += 7 {
7917 if shift >= 64 {
7918 return ErrIntOverflowMapsproto2
7919 }
7920 if iNdEx >= l {
7921 return io.ErrUnexpectedEOF
7922 }
7923 b := dAtA[iNdEx]
7924 iNdEx++
7925 mapvaluetemp |= uint64(b&0x7F) << shift
7926 if b < 0x80 {
7927 break
7928 }
7929 }
7930 mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
7931 mapvalue = int64(mapvaluetemp)
7932 } else {
7933 iNdEx = entryPreIndex
7934 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7935 if err != nil {
7936 return err
7937 }
7938 if (skippy < 0) || (iNdEx+skippy) < 0 {
7939 return ErrInvalidLengthMapsproto2
7940 }
7941 if (iNdEx + skippy) > postIndex {
7942 return io.ErrUnexpectedEOF
7943 }
7944 iNdEx += skippy
7945 }
7946 }
7947 m.Sint64Map[mapkey] = mapvalue
7948 iNdEx = postIndex
7949 case 9:
7950 if wireType != 2 {
7951 return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType)
7952 }
7953 var msglen int
7954 for shift := uint(0); ; shift += 7 {
7955 if shift >= 64 {
7956 return ErrIntOverflowMapsproto2
7957 }
7958 if iNdEx >= l {
7959 return io.ErrUnexpectedEOF
7960 }
7961 b := dAtA[iNdEx]
7962 iNdEx++
7963 msglen |= int(b&0x7F) << shift
7964 if b < 0x80 {
7965 break
7966 }
7967 }
7968 if msglen < 0 {
7969 return ErrInvalidLengthMapsproto2
7970 }
7971 postIndex := iNdEx + msglen
7972 if postIndex < 0 {
7973 return ErrInvalidLengthMapsproto2
7974 }
7975 if postIndex > l {
7976 return io.ErrUnexpectedEOF
7977 }
7978 if m.Fixed32Map == nil {
7979 m.Fixed32Map = make(map[uint32]uint32)
7980 }
7981 var mapkey uint32
7982 var mapvalue uint32
7983 for iNdEx < postIndex {
7984 entryPreIndex := iNdEx
7985 var wire uint64
7986 for shift := uint(0); ; shift += 7 {
7987 if shift >= 64 {
7988 return ErrIntOverflowMapsproto2
7989 }
7990 if iNdEx >= l {
7991 return io.ErrUnexpectedEOF
7992 }
7993 b := dAtA[iNdEx]
7994 iNdEx++
7995 wire |= uint64(b&0x7F) << shift
7996 if b < 0x80 {
7997 break
7998 }
7999 }
8000 fieldNum := int32(wire >> 3)
8001 if fieldNum == 1 {
8002 if (iNdEx + 4) > l {
8003 return io.ErrUnexpectedEOF
8004 }
8005 mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8006 iNdEx += 4
8007 } else if fieldNum == 2 {
8008 if (iNdEx + 4) > l {
8009 return io.ErrUnexpectedEOF
8010 }
8011 mapvalue = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8012 iNdEx += 4
8013 } else {
8014 iNdEx = entryPreIndex
8015 skippy, err := skipMapsproto2(dAtA[iNdEx:])
8016 if err != nil {
8017 return err
8018 }
8019 if (skippy < 0) || (iNdEx+skippy) < 0 {
8020 return ErrInvalidLengthMapsproto2
8021 }
8022 if (iNdEx + skippy) > postIndex {
8023 return io.ErrUnexpectedEOF
8024 }
8025 iNdEx += skippy
8026 }
8027 }
8028 m.Fixed32Map[mapkey] = mapvalue
8029 iNdEx = postIndex
8030 case 10:
8031 if wireType != 2 {
8032 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType)
8033 }
8034 var msglen int
8035 for shift := uint(0); ; shift += 7 {
8036 if shift >= 64 {
8037 return ErrIntOverflowMapsproto2
8038 }
8039 if iNdEx >= l {
8040 return io.ErrUnexpectedEOF
8041 }
8042 b := dAtA[iNdEx]
8043 iNdEx++
8044 msglen |= int(b&0x7F) << shift
8045 if b < 0x80 {
8046 break
8047 }
8048 }
8049 if msglen < 0 {
8050 return ErrInvalidLengthMapsproto2
8051 }
8052 postIndex := iNdEx + msglen
8053 if postIndex < 0 {
8054 return ErrInvalidLengthMapsproto2
8055 }
8056 if postIndex > l {
8057 return io.ErrUnexpectedEOF
8058 }
8059 if m.Sfixed32Map == nil {
8060 m.Sfixed32Map = make(map[int32]int32)
8061 }
8062 var mapkey int32
8063 var mapvalue int32
8064 for iNdEx < postIndex {
8065 entryPreIndex := iNdEx
8066 var wire uint64
8067 for shift := uint(0); ; shift += 7 {
8068 if shift >= 64 {
8069 return ErrIntOverflowMapsproto2
8070 }
8071 if iNdEx >= l {
8072 return io.ErrUnexpectedEOF
8073 }
8074 b := dAtA[iNdEx]
8075 iNdEx++
8076 wire |= uint64(b&0x7F) << shift
8077 if b < 0x80 {
8078 break
8079 }
8080 }
8081 fieldNum := int32(wire >> 3)
8082 if fieldNum == 1 {
8083 if (iNdEx + 4) > l {
8084 return io.ErrUnexpectedEOF
8085 }
8086 mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8087 iNdEx += 4
8088 } else if fieldNum == 2 {
8089 if (iNdEx + 4) > l {
8090 return io.ErrUnexpectedEOF
8091 }
8092 mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8093 iNdEx += 4
8094 } else {
8095 iNdEx = entryPreIndex
8096 skippy, err := skipMapsproto2(dAtA[iNdEx:])
8097 if err != nil {
8098 return err
8099 }
8100 if (skippy < 0) || (iNdEx+skippy) < 0 {
8101 return ErrInvalidLengthMapsproto2
8102 }
8103 if (iNdEx + skippy) > postIndex {
8104 return io.ErrUnexpectedEOF
8105 }
8106 iNdEx += skippy
8107 }
8108 }
8109 m.Sfixed32Map[mapkey] = mapvalue
8110 iNdEx = postIndex
8111 case 11:
8112 if wireType != 2 {
8113 return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType)
8114 }
8115 var msglen int
8116 for shift := uint(0); ; shift += 7 {
8117 if shift >= 64 {
8118 return ErrIntOverflowMapsproto2
8119 }
8120 if iNdEx >= l {
8121 return io.ErrUnexpectedEOF
8122 }
8123 b := dAtA[iNdEx]
8124 iNdEx++
8125 msglen |= int(b&0x7F) << shift
8126 if b < 0x80 {
8127 break
8128 }
8129 }
8130 if msglen < 0 {
8131 return ErrInvalidLengthMapsproto2
8132 }
8133 postIndex := iNdEx + msglen
8134 if postIndex < 0 {
8135 return ErrInvalidLengthMapsproto2
8136 }
8137 if postIndex > l {
8138 return io.ErrUnexpectedEOF
8139 }
8140 if m.Fixed64Map == nil {
8141 m.Fixed64Map = make(map[uint64]uint64)
8142 }
8143 var mapkey uint64
8144 var mapvalue uint64
8145 for iNdEx < postIndex {
8146 entryPreIndex := iNdEx
8147 var wire uint64
8148 for shift := uint(0); ; shift += 7 {
8149 if shift >= 64 {
8150 return ErrIntOverflowMapsproto2
8151 }
8152 if iNdEx >= l {
8153 return io.ErrUnexpectedEOF
8154 }
8155 b := dAtA[iNdEx]
8156 iNdEx++
8157 wire |= uint64(b&0x7F) << shift
8158 if b < 0x80 {
8159 break
8160 }
8161 }
8162 fieldNum := int32(wire >> 3)
8163 if fieldNum == 1 {
8164 if (iNdEx + 8) > l {
8165 return io.ErrUnexpectedEOF
8166 }
8167 mapkey = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8168 iNdEx += 8
8169 } else if fieldNum == 2 {
8170 if (iNdEx + 8) > l {
8171 return io.ErrUnexpectedEOF
8172 }
8173 mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8174 iNdEx += 8
8175 } else {
8176 iNdEx = entryPreIndex
8177 skippy, err := skipMapsproto2(dAtA[iNdEx:])
8178 if err != nil {
8179 return err
8180 }
8181 if (skippy < 0) || (iNdEx+skippy) < 0 {
8182 return ErrInvalidLengthMapsproto2
8183 }
8184 if (iNdEx + skippy) > postIndex {
8185 return io.ErrUnexpectedEOF
8186 }
8187 iNdEx += skippy
8188 }
8189 }
8190 m.Fixed64Map[mapkey] = mapvalue
8191 iNdEx = postIndex
8192 case 12:
8193 if wireType != 2 {
8194 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType)
8195 }
8196 var msglen int
8197 for shift := uint(0); ; shift += 7 {
8198 if shift >= 64 {
8199 return ErrIntOverflowMapsproto2
8200 }
8201 if iNdEx >= l {
8202 return io.ErrUnexpectedEOF
8203 }
8204 b := dAtA[iNdEx]
8205 iNdEx++
8206 msglen |= int(b&0x7F) << shift
8207 if b < 0x80 {
8208 break
8209 }
8210 }
8211 if msglen < 0 {
8212 return ErrInvalidLengthMapsproto2
8213 }
8214 postIndex := iNdEx + msglen
8215 if postIndex < 0 {
8216 return ErrInvalidLengthMapsproto2
8217 }
8218 if postIndex > l {
8219 return io.ErrUnexpectedEOF
8220 }
8221 if m.Sfixed64Map == nil {
8222 m.Sfixed64Map = make(map[int64]int64)
8223 }
8224 var mapkey int64
8225 var mapvalue int64
8226 for iNdEx < postIndex {
8227 entryPreIndex := iNdEx
8228 var wire uint64
8229 for shift := uint(0); ; shift += 7 {
8230 if shift >= 64 {
8231 return ErrIntOverflowMapsproto2
8232 }
8233 if iNdEx >= l {
8234 return io.ErrUnexpectedEOF
8235 }
8236 b := dAtA[iNdEx]
8237 iNdEx++
8238 wire |= uint64(b&0x7F) << shift
8239 if b < 0x80 {
8240 break
8241 }
8242 }
8243 fieldNum := int32(wire >> 3)
8244 if fieldNum == 1 {
8245 if (iNdEx + 8) > l {
8246 return io.ErrUnexpectedEOF
8247 }
8248 mapkey = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8249 iNdEx += 8
8250 } else if fieldNum == 2 {
8251 if (iNdEx + 8) > l {
8252 return io.ErrUnexpectedEOF
8253 }
8254 mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8255 iNdEx += 8
8256 } else {
8257 iNdEx = entryPreIndex
8258 skippy, err := skipMapsproto2(dAtA[iNdEx:])
8259 if err != nil {
8260 return err
8261 }
8262 if (skippy < 0) || (iNdEx+skippy) < 0 {
8263 return ErrInvalidLengthMapsproto2
8264 }
8265 if (iNdEx + skippy) > postIndex {
8266 return io.ErrUnexpectedEOF
8267 }
8268 iNdEx += skippy
8269 }
8270 }
8271 m.Sfixed64Map[mapkey] = mapvalue
8272 iNdEx = postIndex
8273 case 13:
8274 if wireType != 2 {
8275 return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType)
8276 }
8277 var msglen int
8278 for shift := uint(0); ; shift += 7 {
8279 if shift >= 64 {
8280 return ErrIntOverflowMapsproto2
8281 }
8282 if iNdEx >= l {
8283 return io.ErrUnexpectedEOF
8284 }
8285 b := dAtA[iNdEx]
8286 iNdEx++
8287 msglen |= int(b&0x7F) << shift
8288 if b < 0x80 {
8289 break
8290 }
8291 }
8292 if msglen < 0 {
8293 return ErrInvalidLengthMapsproto2
8294 }
8295 postIndex := iNdEx + msglen
8296 if postIndex < 0 {
8297 return ErrInvalidLengthMapsproto2
8298 }
8299 if postIndex > l {
8300 return io.ErrUnexpectedEOF
8301 }
8302 if m.BoolMap == nil {
8303 m.BoolMap = make(map[bool]bool)
8304 }
8305 var mapkey bool
8306 var mapvalue bool
8307 for iNdEx < postIndex {
8308 entryPreIndex := iNdEx
8309 var wire uint64
8310 for shift := uint(0); ; shift += 7 {
8311 if shift >= 64 {
8312 return ErrIntOverflowMapsproto2
8313 }
8314 if iNdEx >= l {
8315 return io.ErrUnexpectedEOF
8316 }
8317 b := dAtA[iNdEx]
8318 iNdEx++
8319 wire |= uint64(b&0x7F) << shift
8320 if b < 0x80 {
8321 break
8322 }
8323 }
8324 fieldNum := int32(wire >> 3)
8325 if fieldNum == 1 {
8326 var mapkeytemp int
8327 for shift := uint(0); ; shift += 7 {
8328 if shift >= 64 {
8329 return ErrIntOverflowMapsproto2
8330 }
8331 if iNdEx >= l {
8332 return io.ErrUnexpectedEOF
8333 }
8334 b := dAtA[iNdEx]
8335 iNdEx++
8336 mapkeytemp |= int(b&0x7F) << shift
8337 if b < 0x80 {
8338 break
8339 }
8340 }
8341 mapkey = bool(mapkeytemp != 0)
8342 } else if fieldNum == 2 {
8343 var mapvaluetemp int
8344 for shift := uint(0); ; shift += 7 {
8345 if shift >= 64 {
8346 return ErrIntOverflowMapsproto2
8347 }
8348 if iNdEx >= l {
8349 return io.ErrUnexpectedEOF
8350 }
8351 b := dAtA[iNdEx]
8352 iNdEx++
8353 mapvaluetemp |= int(b&0x7F) << shift
8354 if b < 0x80 {
8355 break
8356 }
8357 }
8358 mapvalue = bool(mapvaluetemp != 0)
8359 } else {
8360 iNdEx = entryPreIndex
8361 skippy, err := skipMapsproto2(dAtA[iNdEx:])
8362 if err != nil {
8363 return err
8364 }
8365 if (skippy < 0) || (iNdEx+skippy) < 0 {
8366 return ErrInvalidLengthMapsproto2
8367 }
8368 if (iNdEx + skippy) > postIndex {
8369 return io.ErrUnexpectedEOF
8370 }
8371 iNdEx += skippy
8372 }
8373 }
8374 m.BoolMap[mapkey] = mapvalue
8375 iNdEx = postIndex
8376 case 14:
8377 if wireType != 2 {
8378 return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType)
8379 }
8380 var msglen int
8381 for shift := uint(0); ; shift += 7 {
8382 if shift >= 64 {
8383 return ErrIntOverflowMapsproto2
8384 }
8385 if iNdEx >= l {
8386 return io.ErrUnexpectedEOF
8387 }
8388 b := dAtA[iNdEx]
8389 iNdEx++
8390 msglen |= int(b&0x7F) << shift
8391 if b < 0x80 {
8392 break
8393 }
8394 }
8395 if msglen < 0 {
8396 return ErrInvalidLengthMapsproto2
8397 }
8398 postIndex := iNdEx + msglen
8399 if postIndex < 0 {
8400 return ErrInvalidLengthMapsproto2
8401 }
8402 if postIndex > l {
8403 return io.ErrUnexpectedEOF
8404 }
8405 if m.StringMap == nil {
8406 m.StringMap = make(map[string]string)
8407 }
8408 var mapkey string
8409 var mapvalue string
8410 for iNdEx < postIndex {
8411 entryPreIndex := iNdEx
8412 var wire uint64
8413 for shift := uint(0); ; shift += 7 {
8414 if shift >= 64 {
8415 return ErrIntOverflowMapsproto2
8416 }
8417 if iNdEx >= l {
8418 return io.ErrUnexpectedEOF
8419 }
8420 b := dAtA[iNdEx]
8421 iNdEx++
8422 wire |= uint64(b&0x7F) << shift
8423 if b < 0x80 {
8424 break
8425 }
8426 }
8427 fieldNum := int32(wire >> 3)
8428 if fieldNum == 1 {
8429 var stringLenmapkey uint64
8430 for shift := uint(0); ; shift += 7 {
8431 if shift >= 64 {
8432 return ErrIntOverflowMapsproto2
8433 }
8434 if iNdEx >= l {
8435 return io.ErrUnexpectedEOF
8436 }
8437 b := dAtA[iNdEx]
8438 iNdEx++
8439 stringLenmapkey |= uint64(b&0x7F) << shift
8440 if b < 0x80 {
8441 break
8442 }
8443 }
8444 intStringLenmapkey := int(stringLenmapkey)
8445 if intStringLenmapkey < 0 {
8446 return ErrInvalidLengthMapsproto2
8447 }
8448 postStringIndexmapkey := iNdEx + intStringLenmapkey
8449 if postStringIndexmapkey < 0 {
8450 return ErrInvalidLengthMapsproto2
8451 }
8452 if postStringIndexmapkey > l {
8453 return io.ErrUnexpectedEOF
8454 }
8455 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8456 iNdEx = postStringIndexmapkey
8457 } else if fieldNum == 2 {
8458 var stringLenmapvalue uint64
8459 for shift := uint(0); ; shift += 7 {
8460 if shift >= 64 {
8461 return ErrIntOverflowMapsproto2
8462 }
8463 if iNdEx >= l {
8464 return io.ErrUnexpectedEOF
8465 }
8466 b := dAtA[iNdEx]
8467 iNdEx++
8468 stringLenmapvalue |= uint64(b&0x7F) << shift
8469 if b < 0x80 {
8470 break
8471 }
8472 }
8473 intStringLenmapvalue := int(stringLenmapvalue)
8474 if intStringLenmapvalue < 0 {
8475 return ErrInvalidLengthMapsproto2
8476 }
8477 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
8478 if postStringIndexmapvalue < 0 {
8479 return ErrInvalidLengthMapsproto2
8480 }
8481 if postStringIndexmapvalue > l {
8482 return io.ErrUnexpectedEOF
8483 }
8484 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
8485 iNdEx = postStringIndexmapvalue
8486 } else {
8487 iNdEx = entryPreIndex
8488 skippy, err := skipMapsproto2(dAtA[iNdEx:])
8489 if err != nil {
8490 return err
8491 }
8492 if (skippy < 0) || (iNdEx+skippy) < 0 {
8493 return ErrInvalidLengthMapsproto2
8494 }
8495 if (iNdEx + skippy) > postIndex {
8496 return io.ErrUnexpectedEOF
8497 }
8498 iNdEx += skippy
8499 }
8500 }
8501 m.StringMap[mapkey] = mapvalue
8502 iNdEx = postIndex
8503 case 15:
8504 if wireType != 2 {
8505 return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType)
8506 }
8507 var msglen int
8508 for shift := uint(0); ; shift += 7 {
8509 if shift >= 64 {
8510 return ErrIntOverflowMapsproto2
8511 }
8512 if iNdEx >= l {
8513 return io.ErrUnexpectedEOF
8514 }
8515 b := dAtA[iNdEx]
8516 iNdEx++
8517 msglen |= int(b&0x7F) << shift
8518 if b < 0x80 {
8519 break
8520 }
8521 }
8522 if msglen < 0 {
8523 return ErrInvalidLengthMapsproto2
8524 }
8525 postIndex := iNdEx + msglen
8526 if postIndex < 0 {
8527 return ErrInvalidLengthMapsproto2
8528 }
8529 if postIndex > l {
8530 return io.ErrUnexpectedEOF
8531 }
8532 if m.StringToBytesMap == nil {
8533 m.StringToBytesMap = make(map[string][]byte)
8534 }
8535 var mapkey string
8536 mapvalue := []byte{}
8537 for iNdEx < postIndex {
8538 entryPreIndex := iNdEx
8539 var wire uint64
8540 for shift := uint(0); ; shift += 7 {
8541 if shift >= 64 {
8542 return ErrIntOverflowMapsproto2
8543 }
8544 if iNdEx >= l {
8545 return io.ErrUnexpectedEOF
8546 }
8547 b := dAtA[iNdEx]
8548 iNdEx++
8549 wire |= uint64(b&0x7F) << shift
8550 if b < 0x80 {
8551 break
8552 }
8553 }
8554 fieldNum := int32(wire >> 3)
8555 if fieldNum == 1 {
8556 var stringLenmapkey uint64
8557 for shift := uint(0); ; shift += 7 {
8558 if shift >= 64 {
8559 return ErrIntOverflowMapsproto2
8560 }
8561 if iNdEx >= l {
8562 return io.ErrUnexpectedEOF
8563 }
8564 b := dAtA[iNdEx]
8565 iNdEx++
8566 stringLenmapkey |= uint64(b&0x7F) << shift
8567 if b < 0x80 {
8568 break
8569 }
8570 }
8571 intStringLenmapkey := int(stringLenmapkey)
8572 if intStringLenmapkey < 0 {
8573 return ErrInvalidLengthMapsproto2
8574 }
8575 postStringIndexmapkey := iNdEx + intStringLenmapkey
8576 if postStringIndexmapkey < 0 {
8577 return ErrInvalidLengthMapsproto2
8578 }
8579 if postStringIndexmapkey > l {
8580 return io.ErrUnexpectedEOF
8581 }
8582 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8583 iNdEx = postStringIndexmapkey
8584 } else if fieldNum == 2 {
8585 var mapbyteLen uint64
8586 for shift := uint(0); ; shift += 7 {
8587 if shift >= 64 {
8588 return ErrIntOverflowMapsproto2
8589 }
8590 if iNdEx >= l {
8591 return io.ErrUnexpectedEOF
8592 }
8593 b := dAtA[iNdEx]
8594 iNdEx++
8595 mapbyteLen |= uint64(b&0x7F) << shift
8596 if b < 0x80 {
8597 break
8598 }
8599 }
8600 intMapbyteLen := int(mapbyteLen)
8601 if intMapbyteLen < 0 {
8602 return ErrInvalidLengthMapsproto2
8603 }
8604 postbytesIndex := iNdEx + intMapbyteLen
8605 if postbytesIndex < 0 {
8606 return ErrInvalidLengthMapsproto2
8607 }
8608 if postbytesIndex > l {
8609 return io.ErrUnexpectedEOF
8610 }
8611 mapvalue = make([]byte, mapbyteLen)
8612 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
8613 iNdEx = postbytesIndex
8614 } else {
8615 iNdEx = entryPreIndex
8616 skippy, err := skipMapsproto2(dAtA[iNdEx:])
8617 if err != nil {
8618 return err
8619 }
8620 if (skippy < 0) || (iNdEx+skippy) < 0 {
8621 return ErrInvalidLengthMapsproto2
8622 }
8623 if (iNdEx + skippy) > postIndex {
8624 return io.ErrUnexpectedEOF
8625 }
8626 iNdEx += skippy
8627 }
8628 }
8629 m.StringToBytesMap[mapkey] = mapvalue
8630 iNdEx = postIndex
8631 case 16:
8632 if wireType != 2 {
8633 return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType)
8634 }
8635 var msglen int
8636 for shift := uint(0); ; shift += 7 {
8637 if shift >= 64 {
8638 return ErrIntOverflowMapsproto2
8639 }
8640 if iNdEx >= l {
8641 return io.ErrUnexpectedEOF
8642 }
8643 b := dAtA[iNdEx]
8644 iNdEx++
8645 msglen |= int(b&0x7F) << shift
8646 if b < 0x80 {
8647 break
8648 }
8649 }
8650 if msglen < 0 {
8651 return ErrInvalidLengthMapsproto2
8652 }
8653 postIndex := iNdEx + msglen
8654 if postIndex < 0 {
8655 return ErrInvalidLengthMapsproto2
8656 }
8657 if postIndex > l {
8658 return io.ErrUnexpectedEOF
8659 }
8660 if m.StringToEnumMap == nil {
8661 m.StringToEnumMap = make(map[string]MapEnum)
8662 }
8663 var mapkey string
8664 var mapvalue MapEnum
8665 for iNdEx < postIndex {
8666 entryPreIndex := iNdEx
8667 var wire uint64
8668 for shift := uint(0); ; shift += 7 {
8669 if shift >= 64 {
8670 return ErrIntOverflowMapsproto2
8671 }
8672 if iNdEx >= l {
8673 return io.ErrUnexpectedEOF
8674 }
8675 b := dAtA[iNdEx]
8676 iNdEx++
8677 wire |= uint64(b&0x7F) << shift
8678 if b < 0x80 {
8679 break
8680 }
8681 }
8682 fieldNum := int32(wire >> 3)
8683 if fieldNum == 1 {
8684 var stringLenmapkey uint64
8685 for shift := uint(0); ; shift += 7 {
8686 if shift >= 64 {
8687 return ErrIntOverflowMapsproto2
8688 }
8689 if iNdEx >= l {
8690 return io.ErrUnexpectedEOF
8691 }
8692 b := dAtA[iNdEx]
8693 iNdEx++
8694 stringLenmapkey |= uint64(b&0x7F) << shift
8695 if b < 0x80 {
8696 break
8697 }
8698 }
8699 intStringLenmapkey := int(stringLenmapkey)
8700 if intStringLenmapkey < 0 {
8701 return ErrInvalidLengthMapsproto2
8702 }
8703 postStringIndexmapkey := iNdEx + intStringLenmapkey
8704 if postStringIndexmapkey < 0 {
8705 return ErrInvalidLengthMapsproto2
8706 }
8707 if postStringIndexmapkey > l {
8708 return io.ErrUnexpectedEOF
8709 }
8710 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8711 iNdEx = postStringIndexmapkey
8712 } else if fieldNum == 2 {
8713 for shift := uint(0); ; shift += 7 {
8714 if shift >= 64 {
8715 return ErrIntOverflowMapsproto2
8716 }
8717 if iNdEx >= l {
8718 return io.ErrUnexpectedEOF
8719 }
8720 b := dAtA[iNdEx]
8721 iNdEx++
8722 mapvalue |= MapEnum(b&0x7F) << shift
8723 if b < 0x80 {
8724 break
8725 }
8726 }
8727 } else {
8728 iNdEx = entryPreIndex
8729 skippy, err := skipMapsproto2(dAtA[iNdEx:])
8730 if err != nil {
8731 return err
8732 }
8733 if (skippy < 0) || (iNdEx+skippy) < 0 {
8734 return ErrInvalidLengthMapsproto2
8735 }
8736 if (iNdEx + skippy) > postIndex {
8737 return io.ErrUnexpectedEOF
8738 }
8739 iNdEx += skippy
8740 }
8741 }
8742 m.StringToEnumMap[mapkey] = mapvalue
8743 iNdEx = postIndex
8744 case 17:
8745 if wireType != 2 {
8746 return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType)
8747 }
8748 var msglen int
8749 for shift := uint(0); ; shift += 7 {
8750 if shift >= 64 {
8751 return ErrIntOverflowMapsproto2
8752 }
8753 if iNdEx >= l {
8754 return io.ErrUnexpectedEOF
8755 }
8756 b := dAtA[iNdEx]
8757 iNdEx++
8758 msglen |= int(b&0x7F) << shift
8759 if b < 0x80 {
8760 break
8761 }
8762 }
8763 if msglen < 0 {
8764 return ErrInvalidLengthMapsproto2
8765 }
8766 postIndex := iNdEx + msglen
8767 if postIndex < 0 {
8768 return ErrInvalidLengthMapsproto2
8769 }
8770 if postIndex > l {
8771 return io.ErrUnexpectedEOF
8772 }
8773 if m.StringToMsgMap == nil {
8774 m.StringToMsgMap = make(map[string]*FloatingPoint)
8775 }
8776 var mapkey string
8777 var mapvalue *FloatingPoint
8778 for iNdEx < postIndex {
8779 entryPreIndex := iNdEx
8780 var wire uint64
8781 for shift := uint(0); ; shift += 7 {
8782 if shift >= 64 {
8783 return ErrIntOverflowMapsproto2
8784 }
8785 if iNdEx >= l {
8786 return io.ErrUnexpectedEOF
8787 }
8788 b := dAtA[iNdEx]
8789 iNdEx++
8790 wire |= uint64(b&0x7F) << shift
8791 if b < 0x80 {
8792 break
8793 }
8794 }
8795 fieldNum := int32(wire >> 3)
8796 if fieldNum == 1 {
8797 var stringLenmapkey uint64
8798 for shift := uint(0); ; shift += 7 {
8799 if shift >= 64 {
8800 return ErrIntOverflowMapsproto2
8801 }
8802 if iNdEx >= l {
8803 return io.ErrUnexpectedEOF
8804 }
8805 b := dAtA[iNdEx]
8806 iNdEx++
8807 stringLenmapkey |= uint64(b&0x7F) << shift
8808 if b < 0x80 {
8809 break
8810 }
8811 }
8812 intStringLenmapkey := int(stringLenmapkey)
8813 if intStringLenmapkey < 0 {
8814 return ErrInvalidLengthMapsproto2
8815 }
8816 postStringIndexmapkey := iNdEx + intStringLenmapkey
8817 if postStringIndexmapkey < 0 {
8818 return ErrInvalidLengthMapsproto2
8819 }
8820 if postStringIndexmapkey > l {
8821 return io.ErrUnexpectedEOF
8822 }
8823 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8824 iNdEx = postStringIndexmapkey
8825 } else if fieldNum == 2 {
8826 var mapmsglen int
8827 for shift := uint(0); ; shift += 7 {
8828 if shift >= 64 {
8829 return ErrIntOverflowMapsproto2
8830 }
8831 if iNdEx >= l {
8832 return io.ErrUnexpectedEOF
8833 }
8834 b := dAtA[iNdEx]
8835 iNdEx++
8836 mapmsglen |= int(b&0x7F) << shift
8837 if b < 0x80 {
8838 break
8839 }
8840 }
8841 if mapmsglen < 0 {
8842 return ErrInvalidLengthMapsproto2
8843 }
8844 postmsgIndex := iNdEx + mapmsglen
8845 if postmsgIndex < 0 {
8846 return ErrInvalidLengthMapsproto2
8847 }
8848 if postmsgIndex > l {
8849 return io.ErrUnexpectedEOF
8850 }
8851 mapvalue = &FloatingPoint{}
8852 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
8853 return err
8854 }
8855 iNdEx = postmsgIndex
8856 } else {
8857 iNdEx = entryPreIndex
8858 skippy, err := skipMapsproto2(dAtA[iNdEx:])
8859 if err != nil {
8860 return err
8861 }
8862 if (skippy < 0) || (iNdEx+skippy) < 0 {
8863 return ErrInvalidLengthMapsproto2
8864 }
8865 if (iNdEx + skippy) > postIndex {
8866 return io.ErrUnexpectedEOF
8867 }
8868 iNdEx += skippy
8869 }
8870 }
8871 m.StringToMsgMap[mapkey] = mapvalue
8872 iNdEx = postIndex
8873 default:
8874 iNdEx = preIndex
8875 skippy, err := skipMapsproto2(dAtA[iNdEx:])
8876 if err != nil {
8877 return err
8878 }
8879 if (skippy < 0) || (iNdEx+skippy) < 0 {
8880 return ErrInvalidLengthMapsproto2
8881 }
8882 if (iNdEx + skippy) > l {
8883 return io.ErrUnexpectedEOF
8884 }
8885 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
8886 iNdEx += skippy
8887 }
8888 }
8889
8890 if iNdEx > l {
8891 return io.ErrUnexpectedEOF
8892 }
8893 return nil
8894 }
8895 func skipMapsproto2(dAtA []byte) (n int, err error) {
8896 l := len(dAtA)
8897 iNdEx := 0
8898 depth := 0
8899 for iNdEx < l {
8900 var wire uint64
8901 for shift := uint(0); ; shift += 7 {
8902 if shift >= 64 {
8903 return 0, ErrIntOverflowMapsproto2
8904 }
8905 if iNdEx >= l {
8906 return 0, io.ErrUnexpectedEOF
8907 }
8908 b := dAtA[iNdEx]
8909 iNdEx++
8910 wire |= (uint64(b) & 0x7F) << shift
8911 if b < 0x80 {
8912 break
8913 }
8914 }
8915 wireType := int(wire & 0x7)
8916 switch wireType {
8917 case 0:
8918 for shift := uint(0); ; shift += 7 {
8919 if shift >= 64 {
8920 return 0, ErrIntOverflowMapsproto2
8921 }
8922 if iNdEx >= l {
8923 return 0, io.ErrUnexpectedEOF
8924 }
8925 iNdEx++
8926 if dAtA[iNdEx-1] < 0x80 {
8927 break
8928 }
8929 }
8930 case 1:
8931 iNdEx += 8
8932 case 2:
8933 var length int
8934 for shift := uint(0); ; shift += 7 {
8935 if shift >= 64 {
8936 return 0, ErrIntOverflowMapsproto2
8937 }
8938 if iNdEx >= l {
8939 return 0, io.ErrUnexpectedEOF
8940 }
8941 b := dAtA[iNdEx]
8942 iNdEx++
8943 length |= (int(b) & 0x7F) << shift
8944 if b < 0x80 {
8945 break
8946 }
8947 }
8948 if length < 0 {
8949 return 0, ErrInvalidLengthMapsproto2
8950 }
8951 iNdEx += length
8952 case 3:
8953 depth++
8954 case 4:
8955 if depth == 0 {
8956 return 0, ErrUnexpectedEndOfGroupMapsproto2
8957 }
8958 depth--
8959 case 5:
8960 iNdEx += 4
8961 default:
8962 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
8963 }
8964 if iNdEx < 0 {
8965 return 0, ErrInvalidLengthMapsproto2
8966 }
8967 if depth == 0 {
8968 return iNdEx, nil
8969 }
8970 }
8971 return 0, io.ErrUnexpectedEOF
8972 }
8973
8974 var (
8975 ErrInvalidLengthMapsproto2 = fmt.Errorf("proto: negative length found during unmarshaling")
8976 ErrIntOverflowMapsproto2 = fmt.Errorf("proto: integer overflow")
8977 ErrUnexpectedEndOfGroupMapsproto2 = fmt.Errorf("proto: unexpected end of group")
8978 )
8979
View as plain text