1
2
3
4 package theproto3
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 both "github.com/gogo/protobuf/test/combos/both"
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 (MapEnum) EnumDescriptor() ([]byte, []int) {
59 return fileDescriptor_198d1a76dbed8ec1, []int{0}
60 }
61
62 type Message_Humour int32
63
64 const (
65 UNKNOWN Message_Humour = 0
66 PUNS Message_Humour = 1
67 SLAPSTICK Message_Humour = 2
68 BILL_BAILEY Message_Humour = 3
69 )
70
71 var Message_Humour_name = map[int32]string{
72 0: "UNKNOWN",
73 1: "PUNS",
74 2: "SLAPSTICK",
75 3: "BILL_BAILEY",
76 }
77
78 var Message_Humour_value = map[string]int32{
79 "UNKNOWN": 0,
80 "PUNS": 1,
81 "SLAPSTICK": 2,
82 "BILL_BAILEY": 3,
83 }
84
85 func (Message_Humour) EnumDescriptor() ([]byte, []int) {
86 return fileDescriptor_198d1a76dbed8ec1, []int{0, 0}
87 }
88
89 type Message struct {
90 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
91 Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,proto3,enum=theproto3.Message_Humour" json:"hilarity,omitempty"`
92 HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,json=heightInCm,proto3" json:"height_in_cm,omitempty"`
93 Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
94 ResultCount int64 `protobuf:"varint,7,opt,name=result_count,json=resultCount,proto3" json:"result_count,omitempty"`
95 TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,json=trueScotsman,proto3" json:"true_scotsman,omitempty"`
96 Score float32 `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"`
97 Key []uint64 `protobuf:"varint,5,rep,packed,name=key,proto3" json:"key,omitempty"`
98 Nested *Nested `protobuf:"bytes,6,opt,name=nested,proto3" json:"nested,omitempty"`
99 Terrain map[int64]*Nested `protobuf:"bytes,10,rep,name=terrain,proto3" json:"terrain,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
100 Proto2Field *both.NinOptNative `protobuf:"bytes,11,opt,name=proto2_field,json=proto2Field,proto3" json:"proto2_field,omitempty"`
101 Proto2Value map[int64]*both.NinOptEnum `protobuf:"bytes,13,rep,name=proto2_value,json=proto2Value,proto3" json:"proto2_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
102 XXX_NoUnkeyedLiteral struct{} `json:"-"`
103 XXX_unrecognized []byte `json:"-"`
104 XXX_sizecache int32 `json:"-"`
105 }
106
107 func (m *Message) Reset() { *m = Message{} }
108 func (*Message) ProtoMessage() {}
109 func (*Message) Descriptor() ([]byte, []int) {
110 return fileDescriptor_198d1a76dbed8ec1, []int{0}
111 }
112 func (m *Message) XXX_Unmarshal(b []byte) error {
113 return m.Unmarshal(b)
114 }
115 func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
116 if deterministic {
117 return xxx_messageInfo_Message.Marshal(b, m, deterministic)
118 } else {
119 b = b[:cap(b)]
120 n, err := m.MarshalToSizedBuffer(b)
121 if err != nil {
122 return nil, err
123 }
124 return b[:n], nil
125 }
126 }
127 func (m *Message) XXX_Merge(src proto.Message) {
128 xxx_messageInfo_Message.Merge(m, src)
129 }
130 func (m *Message) XXX_Size() int {
131 return m.Size()
132 }
133 func (m *Message) XXX_DiscardUnknown() {
134 xxx_messageInfo_Message.DiscardUnknown(m)
135 }
136
137 var xxx_messageInfo_Message proto.InternalMessageInfo
138
139 type Nested struct {
140 Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"`
141 XXX_NoUnkeyedLiteral struct{} `json:"-"`
142 XXX_unrecognized []byte `json:"-"`
143 XXX_sizecache int32 `json:"-"`
144 }
145
146 func (m *Nested) Reset() { *m = Nested{} }
147 func (*Nested) ProtoMessage() {}
148 func (*Nested) Descriptor() ([]byte, []int) {
149 return fileDescriptor_198d1a76dbed8ec1, []int{1}
150 }
151 func (m *Nested) XXX_Unmarshal(b []byte) error {
152 return m.Unmarshal(b)
153 }
154 func (m *Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
155 if deterministic {
156 return xxx_messageInfo_Nested.Marshal(b, m, deterministic)
157 } else {
158 b = b[:cap(b)]
159 n, err := m.MarshalToSizedBuffer(b)
160 if err != nil {
161 return nil, err
162 }
163 return b[:n], nil
164 }
165 }
166 func (m *Nested) XXX_Merge(src proto.Message) {
167 xxx_messageInfo_Nested.Merge(m, src)
168 }
169 func (m *Nested) XXX_Size() int {
170 return m.Size()
171 }
172 func (m *Nested) XXX_DiscardUnknown() {
173 xxx_messageInfo_Nested.DiscardUnknown(m)
174 }
175
176 var xxx_messageInfo_Nested proto.InternalMessageInfo
177
178 type AllMaps struct {
179 StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap,proto3" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
180 StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap,proto3" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
181 Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map,proto3" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
182 Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map,proto3" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
183 Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map,proto3" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
184 Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map,proto3" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
185 Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map,proto3" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"`
186 Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map,proto3" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
187 Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map,proto3" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
188 Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map,proto3" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
189 Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map,proto3" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
190 Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map,proto3" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
191 BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap,proto3" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
192 StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap,proto3" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
193 StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap,proto3" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
194 StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap,proto3" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"`
195 StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap,proto3" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
196 XXX_NoUnkeyedLiteral struct{} `json:"-"`
197 XXX_unrecognized []byte `json:"-"`
198 XXX_sizecache int32 `json:"-"`
199 }
200
201 func (m *AllMaps) Reset() { *m = AllMaps{} }
202 func (*AllMaps) ProtoMessage() {}
203 func (*AllMaps) Descriptor() ([]byte, []int) {
204 return fileDescriptor_198d1a76dbed8ec1, []int{2}
205 }
206 func (m *AllMaps) XXX_Unmarshal(b []byte) error {
207 return m.Unmarshal(b)
208 }
209 func (m *AllMaps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
210 if deterministic {
211 return xxx_messageInfo_AllMaps.Marshal(b, m, deterministic)
212 } else {
213 b = b[:cap(b)]
214 n, err := m.MarshalToSizedBuffer(b)
215 if err != nil {
216 return nil, err
217 }
218 return b[:n], nil
219 }
220 }
221 func (m *AllMaps) XXX_Merge(src proto.Message) {
222 xxx_messageInfo_AllMaps.Merge(m, src)
223 }
224 func (m *AllMaps) XXX_Size() int {
225 return m.Size()
226 }
227 func (m *AllMaps) XXX_DiscardUnknown() {
228 xxx_messageInfo_AllMaps.DiscardUnknown(m)
229 }
230
231 var xxx_messageInfo_AllMaps proto.InternalMessageInfo
232
233 type AllMapsOrdered struct {
234 StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap,proto3" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
235 StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap,proto3" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
236 Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map,proto3" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
237 Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map,proto3" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
238 Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map,proto3" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
239 Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map,proto3" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
240 Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map,proto3" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"`
241 Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map,proto3" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
242 Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map,proto3" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
243 Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map,proto3" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
244 Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map,proto3" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
245 Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map,proto3" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
246 BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap,proto3" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
247 StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap,proto3" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
248 StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap,proto3" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
249 StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap,proto3" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"`
250 StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap,proto3" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
251 XXX_NoUnkeyedLiteral struct{} `json:"-"`
252 XXX_unrecognized []byte `json:"-"`
253 XXX_sizecache int32 `json:"-"`
254 }
255
256 func (m *AllMapsOrdered) Reset() { *m = AllMapsOrdered{} }
257 func (*AllMapsOrdered) ProtoMessage() {}
258 func (*AllMapsOrdered) Descriptor() ([]byte, []int) {
259 return fileDescriptor_198d1a76dbed8ec1, []int{3}
260 }
261 func (m *AllMapsOrdered) XXX_Unmarshal(b []byte) error {
262 return m.Unmarshal(b)
263 }
264 func (m *AllMapsOrdered) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
265 b = b[:cap(b)]
266 n, err := m.MarshalToSizedBuffer(b)
267 if err != nil {
268 return nil, err
269 }
270 return b[:n], nil
271 }
272 func (m *AllMapsOrdered) XXX_Merge(src proto.Message) {
273 xxx_messageInfo_AllMapsOrdered.Merge(m, src)
274 }
275 func (m *AllMapsOrdered) XXX_Size() int {
276 return m.Size()
277 }
278 func (m *AllMapsOrdered) XXX_DiscardUnknown() {
279 xxx_messageInfo_AllMapsOrdered.DiscardUnknown(m)
280 }
281
282 var xxx_messageInfo_AllMapsOrdered proto.InternalMessageInfo
283
284 type MessageWithMap struct {
285 NameMapping map[int32]string `protobuf:"bytes,1,rep,name=name_mapping,json=nameMapping,proto3" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
286 MsgMapping map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping,json=msgMapping,proto3" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
287 ByteMapping map[bool][]byte `protobuf:"bytes,3,rep,name=byte_mapping,json=byteMapping,proto3" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
288 XXX_NoUnkeyedLiteral struct{} `json:"-"`
289 XXX_unrecognized []byte `json:"-"`
290 XXX_sizecache int32 `json:"-"`
291 }
292
293 func (m *MessageWithMap) Reset() { *m = MessageWithMap{} }
294 func (*MessageWithMap) ProtoMessage() {}
295 func (*MessageWithMap) Descriptor() ([]byte, []int) {
296 return fileDescriptor_198d1a76dbed8ec1, []int{4}
297 }
298 func (m *MessageWithMap) XXX_Unmarshal(b []byte) error {
299 return m.Unmarshal(b)
300 }
301 func (m *MessageWithMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
302 if deterministic {
303 return xxx_messageInfo_MessageWithMap.Marshal(b, m, deterministic)
304 } else {
305 b = b[:cap(b)]
306 n, err := m.MarshalToSizedBuffer(b)
307 if err != nil {
308 return nil, err
309 }
310 return b[:n], nil
311 }
312 }
313 func (m *MessageWithMap) XXX_Merge(src proto.Message) {
314 xxx_messageInfo_MessageWithMap.Merge(m, src)
315 }
316 func (m *MessageWithMap) XXX_Size() int {
317 return m.Size()
318 }
319 func (m *MessageWithMap) XXX_DiscardUnknown() {
320 xxx_messageInfo_MessageWithMap.DiscardUnknown(m)
321 }
322
323 var xxx_messageInfo_MessageWithMap proto.InternalMessageInfo
324
325 type FloatingPoint struct {
326 F float64 `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"`
327 XXX_NoUnkeyedLiteral struct{} `json:"-"`
328 XXX_unrecognized []byte `json:"-"`
329 XXX_sizecache int32 `json:"-"`
330 }
331
332 func (m *FloatingPoint) Reset() { *m = FloatingPoint{} }
333 func (*FloatingPoint) ProtoMessage() {}
334 func (*FloatingPoint) Descriptor() ([]byte, []int) {
335 return fileDescriptor_198d1a76dbed8ec1, []int{5}
336 }
337 func (m *FloatingPoint) XXX_Unmarshal(b []byte) error {
338 return m.Unmarshal(b)
339 }
340 func (m *FloatingPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
341 if deterministic {
342 return xxx_messageInfo_FloatingPoint.Marshal(b, m, deterministic)
343 } else {
344 b = b[:cap(b)]
345 n, err := m.MarshalToSizedBuffer(b)
346 if err != nil {
347 return nil, err
348 }
349 return b[:n], nil
350 }
351 }
352 func (m *FloatingPoint) XXX_Merge(src proto.Message) {
353 xxx_messageInfo_FloatingPoint.Merge(m, src)
354 }
355 func (m *FloatingPoint) XXX_Size() int {
356 return m.Size()
357 }
358 func (m *FloatingPoint) XXX_DiscardUnknown() {
359 xxx_messageInfo_FloatingPoint.DiscardUnknown(m)
360 }
361
362 var xxx_messageInfo_FloatingPoint proto.InternalMessageInfo
363
364 type Uint128Pair struct {
365 Left github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,1,opt,name=left,proto3,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"left"`
366 Right *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=right,proto3,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"right,omitempty"`
367 XXX_NoUnkeyedLiteral struct{} `json:"-"`
368 XXX_unrecognized []byte `json:"-"`
369 XXX_sizecache int32 `json:"-"`
370 }
371
372 func (m *Uint128Pair) Reset() { *m = Uint128Pair{} }
373 func (*Uint128Pair) ProtoMessage() {}
374 func (*Uint128Pair) Descriptor() ([]byte, []int) {
375 return fileDescriptor_198d1a76dbed8ec1, []int{6}
376 }
377 func (m *Uint128Pair) XXX_Unmarshal(b []byte) error {
378 return m.Unmarshal(b)
379 }
380 func (m *Uint128Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
381 if deterministic {
382 return xxx_messageInfo_Uint128Pair.Marshal(b, m, deterministic)
383 } else {
384 b = b[:cap(b)]
385 n, err := m.MarshalToSizedBuffer(b)
386 if err != nil {
387 return nil, err
388 }
389 return b[:n], nil
390 }
391 }
392 func (m *Uint128Pair) XXX_Merge(src proto.Message) {
393 xxx_messageInfo_Uint128Pair.Merge(m, src)
394 }
395 func (m *Uint128Pair) XXX_Size() int {
396 return m.Size()
397 }
398 func (m *Uint128Pair) XXX_DiscardUnknown() {
399 xxx_messageInfo_Uint128Pair.DiscardUnknown(m)
400 }
401
402 var xxx_messageInfo_Uint128Pair proto.InternalMessageInfo
403
404 type ContainsNestedMap struct {
405 XXX_NoUnkeyedLiteral struct{} `json:"-"`
406 XXX_unrecognized []byte `json:"-"`
407 XXX_sizecache int32 `json:"-"`
408 }
409
410 func (m *ContainsNestedMap) Reset() { *m = ContainsNestedMap{} }
411 func (*ContainsNestedMap) ProtoMessage() {}
412 func (*ContainsNestedMap) Descriptor() ([]byte, []int) {
413 return fileDescriptor_198d1a76dbed8ec1, []int{7}
414 }
415 func (m *ContainsNestedMap) XXX_Unmarshal(b []byte) error {
416 return m.Unmarshal(b)
417 }
418 func (m *ContainsNestedMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
419 if deterministic {
420 return xxx_messageInfo_ContainsNestedMap.Marshal(b, m, deterministic)
421 } else {
422 b = b[:cap(b)]
423 n, err := m.MarshalToSizedBuffer(b)
424 if err != nil {
425 return nil, err
426 }
427 return b[:n], nil
428 }
429 }
430 func (m *ContainsNestedMap) XXX_Merge(src proto.Message) {
431 xxx_messageInfo_ContainsNestedMap.Merge(m, src)
432 }
433 func (m *ContainsNestedMap) XXX_Size() int {
434 return m.Size()
435 }
436 func (m *ContainsNestedMap) XXX_DiscardUnknown() {
437 xxx_messageInfo_ContainsNestedMap.DiscardUnknown(m)
438 }
439
440 var xxx_messageInfo_ContainsNestedMap proto.InternalMessageInfo
441
442 type ContainsNestedMap_NestedMap struct {
443 NestedMapField map[string]float64 `protobuf:"bytes,1,rep,name=NestedMapField,proto3" json:"NestedMapField,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
444 XXX_NoUnkeyedLiteral struct{} `json:"-"`
445 XXX_unrecognized []byte `json:"-"`
446 XXX_sizecache int32 `json:"-"`
447 }
448
449 func (m *ContainsNestedMap_NestedMap) Reset() { *m = ContainsNestedMap_NestedMap{} }
450 func (*ContainsNestedMap_NestedMap) ProtoMessage() {}
451 func (*ContainsNestedMap_NestedMap) Descriptor() ([]byte, []int) {
452 return fileDescriptor_198d1a76dbed8ec1, []int{7, 0}
453 }
454 func (m *ContainsNestedMap_NestedMap) XXX_Unmarshal(b []byte) error {
455 return m.Unmarshal(b)
456 }
457 func (m *ContainsNestedMap_NestedMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
458 if deterministic {
459 return xxx_messageInfo_ContainsNestedMap_NestedMap.Marshal(b, m, deterministic)
460 } else {
461 b = b[:cap(b)]
462 n, err := m.MarshalToSizedBuffer(b)
463 if err != nil {
464 return nil, err
465 }
466 return b[:n], nil
467 }
468 }
469 func (m *ContainsNestedMap_NestedMap) XXX_Merge(src proto.Message) {
470 xxx_messageInfo_ContainsNestedMap_NestedMap.Merge(m, src)
471 }
472 func (m *ContainsNestedMap_NestedMap) XXX_Size() int {
473 return m.Size()
474 }
475 func (m *ContainsNestedMap_NestedMap) XXX_DiscardUnknown() {
476 xxx_messageInfo_ContainsNestedMap_NestedMap.DiscardUnknown(m)
477 }
478
479 var xxx_messageInfo_ContainsNestedMap_NestedMap proto.InternalMessageInfo
480
481 type NotPacked struct {
482 Key []uint64 `protobuf:"varint,5,rep,name=key,proto3" json:"key,omitempty"`
483 XXX_NoUnkeyedLiteral struct{} `json:"-"`
484 XXX_unrecognized []byte `json:"-"`
485 XXX_sizecache int32 `json:"-"`
486 }
487
488 func (m *NotPacked) Reset() { *m = NotPacked{} }
489 func (*NotPacked) ProtoMessage() {}
490 func (*NotPacked) Descriptor() ([]byte, []int) {
491 return fileDescriptor_198d1a76dbed8ec1, []int{8}
492 }
493 func (m *NotPacked) XXX_Unmarshal(b []byte) error {
494 return m.Unmarshal(b)
495 }
496 func (m *NotPacked) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
497 if deterministic {
498 return xxx_messageInfo_NotPacked.Marshal(b, m, deterministic)
499 } else {
500 b = b[:cap(b)]
501 n, err := m.MarshalToSizedBuffer(b)
502 if err != nil {
503 return nil, err
504 }
505 return b[:n], nil
506 }
507 }
508 func (m *NotPacked) XXX_Merge(src proto.Message) {
509 xxx_messageInfo_NotPacked.Merge(m, src)
510 }
511 func (m *NotPacked) XXX_Size() int {
512 return m.Size()
513 }
514 func (m *NotPacked) XXX_DiscardUnknown() {
515 xxx_messageInfo_NotPacked.DiscardUnknown(m)
516 }
517
518 var xxx_messageInfo_NotPacked proto.InternalMessageInfo
519
520 func init() {
521 proto.RegisterEnum("theproto3.MapEnum", MapEnum_name, MapEnum_value)
522 proto.RegisterEnum("theproto3.Message_Humour", Message_Humour_name, Message_Humour_value)
523 proto.RegisterType((*Message)(nil), "theproto3.Message")
524 proto.RegisterMapType((map[int64]*both.NinOptEnum)(nil), "theproto3.Message.Proto2ValueEntry")
525 proto.RegisterMapType((map[int64]*Nested)(nil), "theproto3.Message.TerrainEntry")
526 proto.RegisterType((*Nested)(nil), "theproto3.Nested")
527 proto.RegisterType((*AllMaps)(nil), "theproto3.AllMaps")
528 proto.RegisterMapType((map[bool]bool)(nil), "theproto3.AllMaps.BoolMapEntry")
529 proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMaps.Fixed32MapEntry")
530 proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMaps.Fixed64MapEntry")
531 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMaps.Int32MapEntry")
532 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMaps.Int64MapEntry")
533 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMaps.Sfixed32MapEntry")
534 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMaps.Sfixed64MapEntry")
535 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMaps.Sint32MapEntry")
536 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMaps.Sint64MapEntry")
537 proto.RegisterMapType((map[string]string)(nil), "theproto3.AllMaps.StringMapEntry")
538 proto.RegisterMapType((map[string][]byte)(nil), "theproto3.AllMaps.StringToBytesMapEntry")
539 proto.RegisterMapType((map[string]float64)(nil), "theproto3.AllMaps.StringToDoubleMapEntry")
540 proto.RegisterMapType((map[string]MapEnum)(nil), "theproto3.AllMaps.StringToEnumMapEntry")
541 proto.RegisterMapType((map[string]float32)(nil), "theproto3.AllMaps.StringToFloatMapEntry")
542 proto.RegisterMapType((map[string]*FloatingPoint)(nil), "theproto3.AllMaps.StringToMsgMapEntry")
543 proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMaps.Uint32MapEntry")
544 proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMaps.Uint64MapEntry")
545 proto.RegisterType((*AllMapsOrdered)(nil), "theproto3.AllMapsOrdered")
546 proto.RegisterMapType((map[bool]bool)(nil), "theproto3.AllMapsOrdered.BoolMapEntry")
547 proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMapsOrdered.Fixed32MapEntry")
548 proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMapsOrdered.Fixed64MapEntry")
549 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMapsOrdered.Int32MapEntry")
550 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMapsOrdered.Int64MapEntry")
551 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMapsOrdered.Sfixed32MapEntry")
552 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMapsOrdered.Sfixed64MapEntry")
553 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMapsOrdered.Sint32MapEntry")
554 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMapsOrdered.Sint64MapEntry")
555 proto.RegisterMapType((map[string]string)(nil), "theproto3.AllMapsOrdered.StringMapEntry")
556 proto.RegisterMapType((map[string][]byte)(nil), "theproto3.AllMapsOrdered.StringToBytesMapEntry")
557 proto.RegisterMapType((map[string]float64)(nil), "theproto3.AllMapsOrdered.StringToDoubleMapEntry")
558 proto.RegisterMapType((map[string]MapEnum)(nil), "theproto3.AllMapsOrdered.StringToEnumMapEntry")
559 proto.RegisterMapType((map[string]float32)(nil), "theproto3.AllMapsOrdered.StringToFloatMapEntry")
560 proto.RegisterMapType((map[string]*FloatingPoint)(nil), "theproto3.AllMapsOrdered.StringToMsgMapEntry")
561 proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMapsOrdered.Uint32MapEntry")
562 proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMapsOrdered.Uint64MapEntry")
563 proto.RegisterType((*MessageWithMap)(nil), "theproto3.MessageWithMap")
564 proto.RegisterMapType((map[bool][]byte)(nil), "theproto3.MessageWithMap.ByteMappingEntry")
565 proto.RegisterMapType((map[int64]*FloatingPoint)(nil), "theproto3.MessageWithMap.MsgMappingEntry")
566 proto.RegisterMapType((map[int32]string)(nil), "theproto3.MessageWithMap.NameMappingEntry")
567 proto.RegisterType((*FloatingPoint)(nil), "theproto3.FloatingPoint")
568 proto.RegisterType((*Uint128Pair)(nil), "theproto3.Uint128Pair")
569 proto.RegisterType((*ContainsNestedMap)(nil), "theproto3.ContainsNestedMap")
570 proto.RegisterType((*ContainsNestedMap_NestedMap)(nil), "theproto3.ContainsNestedMap.NestedMap")
571 proto.RegisterMapType((map[string]float64)(nil), "theproto3.ContainsNestedMap.NestedMap.NestedMapFieldEntry")
572 proto.RegisterType((*NotPacked)(nil), "theproto3.NotPacked")
573 }
574
575 func init() { proto.RegisterFile("combos/both/theproto3.proto", fileDescriptor_198d1a76dbed8ec1) }
576
577 var fileDescriptor_198d1a76dbed8ec1 = []byte{
578
579 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x99, 0xcf, 0x6f, 0xdb, 0x46,
580 0x16, 0xc7, 0x35, 0xfa, 0xad, 0xa7, 0x1f, 0xa6, 0x27, 0xd9, 0x85, 0xd6, 0x8b, 0xa5, 0x65, 0x05,
581 0x48, 0x94, 0x60, 0x23, 0x67, 0x9d, 0x64, 0x37, 0xeb, 0xa6, 0x4d, 0x2d, 0xc5, 0x42, 0xdc, 0xd8,
582 0x8a, 0x2b, 0xd9, 0x71, 0x8b, 0x00, 0x35, 0x28, 0x9b, 0x96, 0x88, 0x48, 0xa4, 0x21, 0x8e, 0x82,
583 0xfa, 0x96, 0x3f, 0xa3, 0xb7, 0xa2, 0xb7, 0x1e, 0x8b, 0x1c, 0x8a, 0x1e, 0xdb, 0x9b, 0x8f, 0x01,
584 0x7a, 0x29, 0x7a, 0x08, 0x62, 0xf5, 0x92, 0x63, 0x8e, 0x39, 0x16, 0x33, 0x43, 0x49, 0x23, 0x72,
585 0x28, 0x36, 0xbd, 0xf4, 0xe2, 0x93, 0x38, 0xcf, 0xef, 0xfb, 0x99, 0xc7, 0xe1, 0xcc, 0xe3, 0x17,
586 0x34, 0xfc, 0xf3, 0xc0, 0xea, 0xb5, 0x2c, 0x7b, 0xb9, 0x65, 0x91, 0xce, 0x32, 0xe9, 0xe8, 0xc7,
587 0x7d, 0x8b, 0x58, 0x37, 0xcb, 0xec, 0x07, 0xa7, 0xc6, 0x81, 0x85, 0xeb, 0x6d, 0x83, 0x74, 0x06,
588 0xad, 0xf2, 0x81, 0xd5, 0x5b, 0x6e, 0x5b, 0x6d, 0x6b, 0x99, 0xc5, 0x5b, 0x83, 0x23, 0x36, 0x62,
589 0x03, 0x76, 0xc5, 0x95, 0x0b, 0xff, 0xf3, 0x4d, 0x27, 0xba, 0x4d, 0x96, 0x5d, 0x93, 0xd2, 0x18,
590 0x17, 0x16, 0x7f, 0x8a, 0x41, 0x62, 0x4b, 0xb7, 0x6d, 0xad, 0xad, 0x63, 0x0c, 0x51, 0x53, 0xeb,
591 0xe9, 0x79, 0x54, 0x40, 0xa5, 0x54, 0x83, 0x5d, 0xe3, 0xdb, 0x90, 0xec, 0x18, 0x5d, 0xad, 0x6f,
592 0x90, 0x93, 0x7c, 0xb8, 0x80, 0x4a, 0xb9, 0x95, 0x7f, 0x94, 0x27, 0x65, 0x3b, 0xca, 0xf2, 0x83,
593 0x41, 0xcf, 0x1a, 0xf4, 0x1b, 0xe3, 0x54, 0x5c, 0x80, 0x4c, 0x47, 0x37, 0xda, 0x1d, 0xb2, 0x6f,
594 0x98, 0xfb, 0x07, 0xbd, 0x7c, 0xa4, 0x80, 0x4a, 0xd9, 0x06, 0xf0, 0xd8, 0x86, 0x59, 0xed, 0xd1,
595 0xc9, 0x0e, 0x35, 0xa2, 0xe5, 0xa3, 0x05, 0x54, 0xca, 0x34, 0xd8, 0x35, 0x5e, 0x82, 0x4c, 0x5f,
596 0xb7, 0x07, 0x5d, 0xb2, 0x7f, 0x60, 0x0d, 0x4c, 0x92, 0x4f, 0x14, 0x50, 0x29, 0xd2, 0x48, 0xf3,
597 0x58, 0x95, 0x86, 0xf0, 0x25, 0xc8, 0x92, 0xfe, 0x40, 0xdf, 0xb7, 0x0f, 0x2c, 0x62, 0xf7, 0x34,
598 0x33, 0x9f, 0x2c, 0xa0, 0x52, 0xb2, 0x91, 0xa1, 0xc1, 0xa6, 0x13, 0xc3, 0x17, 0x21, 0x66, 0x1f,
599 0x58, 0x7d, 0x3d, 0x9f, 0x2a, 0xa0, 0x52, 0xb8, 0xc1, 0x07, 0x58, 0x81, 0xc8, 0x53, 0xfd, 0x24,
600 0x1f, 0x2b, 0x44, 0x4a, 0xd1, 0x06, 0xbd, 0xc4, 0x57, 0x21, 0x6e, 0xea, 0x36, 0xd1, 0x0f, 0xf3,
601 0xf1, 0x02, 0x2a, 0xa5, 0x57, 0xe6, 0x85, 0x5b, 0xab, 0xb3, 0x3f, 0x34, 0x9c, 0x04, 0xfc, 0x7f,
602 0x48, 0x10, 0xbd, 0xdf, 0xd7, 0x0c, 0x33, 0x0f, 0x85, 0x48, 0x29, 0xbd, 0xb2, 0x28, 0x59, 0x86,
603 0x1d, 0x9e, 0xb1, 0x6e, 0x92, 0xfe, 0x49, 0x63, 0x94, 0x8f, 0x6f, 0x43, 0x86, 0xe5, 0xad, 0xec,
604 0x1f, 0x19, 0x7a, 0xf7, 0x30, 0x9f, 0x66, 0x73, 0xe1, 0x32, 0x7b, 0x0a, 0x75, 0xc3, 0x7c, 0x74,
605 0x4c, 0xea, 0x1a, 0x31, 0x9e, 0xe9, 0x8d, 0x34, 0xcf, 0xab, 0xd1, 0x34, 0x5c, 0x1b, 0xcb, 0x9e,
606 0x69, 0xdd, 0x81, 0x9e, 0xcf, 0xb2, 0x69, 0x2f, 0x49, 0xa6, 0xdd, 0x66, 0x69, 0x8f, 0x69, 0x16,
607 0x9f, 0xda, 0xe1, 0xb0, 0xc8, 0xc2, 0x16, 0x64, 0xc4, 0xba, 0x46, 0xcb, 0x80, 0xd8, 0xda, 0xb2,
608 0x65, 0xb8, 0x02, 0x31, 0x3e, 0x45, 0xd8, 0x6f, 0x15, 0xf8, 0xdf, 0x57, 0xc3, 0x77, 0xd0, 0xc2,
609 0x36, 0x28, 0xee, 0xf9, 0x24, 0xc8, 0xcb, 0xd3, 0x48, 0x45, 0xbc, 0xd9, 0x75, 0x73, 0xd0, 0x13,
610 0x88, 0xc5, 0x7b, 0x10, 0xe7, 0xfb, 0x07, 0xa7, 0x21, 0xb1, 0x5b, 0x7f, 0x58, 0x7f, 0xb4, 0x57,
611 0x57, 0x42, 0x38, 0x09, 0xd1, 0xed, 0xdd, 0x7a, 0x53, 0x41, 0x38, 0x0b, 0xa9, 0xe6, 0xe6, 0xda,
612 0x76, 0x73, 0x67, 0xa3, 0xfa, 0x50, 0x09, 0xe3, 0x39, 0x48, 0x57, 0x36, 0x36, 0x37, 0xf7, 0x2b,
613 0x6b, 0x1b, 0x9b, 0xeb, 0x9f, 0x2b, 0x91, 0xa2, 0x0a, 0x71, 0x5e, 0x27, 0x7d, 0xf0, 0xad, 0x81,
614 0x69, 0x9e, 0x38, 0x5b, 0x98, 0x0f, 0x8a, 0x2f, 0x30, 0x24, 0xd6, 0xba, 0xdd, 0x2d, 0xed, 0xd8,
615 0xc6, 0x7b, 0x30, 0xdf, 0x24, 0x7d, 0xc3, 0x6c, 0xef, 0x58, 0xf7, 0xad, 0x41, 0xab, 0xab, 0x6f,
616 0x69, 0xc7, 0x79, 0xc4, 0x96, 0xf6, 0xaa, 0x70, 0xdf, 0x4e, 0x7a, 0xd9, 0x93, 0xcb, 0x17, 0xd8,
617 0xcb, 0xc0, 0x3b, 0xa0, 0x8c, 0x82, 0xb5, 0xae, 0xa5, 0x11, 0xca, 0x0d, 0x33, 0x6e, 0x69, 0x06,
618 0x77, 0x94, 0xca, 0xb1, 0x1e, 0x02, 0xbe, 0x0b, 0xc9, 0x0d, 0x93, 0xdc, 0x5c, 0xa1, 0xb4, 0x08,
619 0xa3, 0x15, 0x24, 0xb4, 0x51, 0x0a, 0xa7, 0x8c, 0x15, 0x8e, 0xfa, 0xbf, 0xb7, 0xa8, 0x3a, 0x3a,
620 0x4b, 0xcd, 0x52, 0x26, 0x6a, 0x36, 0xc4, 0xf7, 0x20, 0xb5, 0x6b, 0x8c, 0x26, 0x8f, 0x31, 0xf9,
621 0x92, 0x44, 0x3e, 0xce, 0xe1, 0xfa, 0x89, 0x66, 0x04, 0xe0, 0xf3, 0xc7, 0x67, 0x02, 0x84, 0x02,
622 0x26, 0x1a, 0x0a, 0x68, 0x8e, 0x2b, 0x48, 0xf8, 0x02, 0x9a, 0xae, 0x0a, 0x9a, 0x62, 0x05, 0xcd,
623 0x71, 0x05, 0xc9, 0x99, 0x00, 0xb1, 0x82, 0xf1, 0x18, 0x57, 0x00, 0x6a, 0xc6, 0x97, 0xfa, 0x21,
624 0x2f, 0x21, 0xc5, 0x08, 0x45, 0x09, 0x61, 0x92, 0xc4, 0x11, 0x82, 0x0a, 0xaf, 0x43, 0xba, 0x79,
625 0x34, 0x81, 0x80, 0xe7, 0x1c, 0x8f, 0xcb, 0x38, 0x72, 0x51, 0x44, 0xdd, 0xb8, 0x14, 0x7e, 0x33,
626 0xe9, 0xd9, 0xa5, 0x08, 0x77, 0x23, 0xa8, 0x26, 0xa5, 0x70, 0x48, 0x26, 0xa0, 0x14, 0x81, 0x22,
627 0xea, 0x68, 0x33, 0xac, 0x58, 0x16, 0xcd, 0x74, 0xba, 0xd2, 0xa2, 0x04, 0xe1, 0x64, 0x38, 0xcd,
628 0xd0, 0x19, 0xb1, 0x27, 0xc2, 0x36, 0x39, 0x15, 0xe7, 0xfc, 0x9f, 0xc8, 0x28, 0x67, 0xf4, 0x44,
629 0x46, 0x63, 0xf1, 0x9c, 0x55, 0x4e, 0x88, 0x6e, 0x53, 0xce, 0x5c, 0xe0, 0x39, 0x1b, 0xa5, 0xba,
630 0xce, 0xd9, 0x28, 0x8c, 0x3f, 0x85, 0xb9, 0x51, 0x8c, 0xb6, 0x27, 0x0a, 0x55, 0x18, 0xf4, 0xca,
631 0x0c, 0xa8, 0x93, 0xc9, 0x99, 0x6e, 0x3d, 0xae, 0x43, 0x6e, 0x14, 0xda, 0xb2, 0xd9, 0xed, 0xce,
632 0x33, 0xe2, 0xe5, 0x19, 0x44, 0x9e, 0xc8, 0x81, 0x2e, 0xf5, 0xc2, 0x7d, 0xf8, 0xbb, 0xbc, 0x1b,
633 0x89, 0xed, 0x37, 0xc5, 0xdb, 0xef, 0x45, 0xb1, 0xfd, 0x22, 0xb1, 0x7d, 0x57, 0xe1, 0x6f, 0xd2,
634 0xde, 0x13, 0x04, 0x09, 0x8b, 0x90, 0x0f, 0x20, 0x3b, 0xd5, 0x72, 0x44, 0x71, 0x4c, 0x22, 0x8e,
635 0x79, 0xc5, 0x93, 0xad, 0x25, 0x79, 0x7b, 0x4c, 0x89, 0x23, 0xa2, 0xf8, 0x2e, 0xe4, 0xa6, 0xfb,
636 0x8d, 0xa8, 0xce, 0x4a, 0xd4, 0x59, 0x89, 0x5a, 0x3e, 0x77, 0x54, 0xa2, 0x8e, 0xba, 0xd4, 0x4d,
637 0xdf, 0xb9, 0xe7, 0x25, 0xea, 0x79, 0x89, 0x5a, 0x3e, 0x37, 0x96, 0xa8, 0xb1, 0xa8, 0xfe, 0x10,
638 0xe6, 0x5c, 0x2d, 0x46, 0x94, 0x27, 0x24, 0xf2, 0x84, 0x28, 0xff, 0x08, 0x14, 0x77, 0x73, 0x11,
639 0xf5, 0x73, 0x12, 0xfd, 0x9c, 0x6c, 0x7a, 0x79, 0xf5, 0x71, 0x89, 0x3c, 0x2e, 0x9d, 0x5e, 0xae,
640 0x57, 0x24, 0x7a, 0x45, 0xd4, 0xaf, 0x42, 0x46, 0xec, 0x26, 0xa2, 0x36, 0x29, 0xd1, 0x26, 0xdd,
641 0xeb, 0x3e, 0xd5, 0x4c, 0x82, 0x76, 0x7a, 0xca, 0xe7, 0xb8, 0x4c, 0xb5, 0x90, 0x20, 0x48, 0x46,
642 0x84, 0x3c, 0x86, 0x8b, 0xb2, 0x96, 0x21, 0x61, 0x94, 0x44, 0x46, 0x8e, 0x7a, 0xc4, 0x89, 0xd9,
643 0xa3, 0xaa, 0x29, 0xe3, 0xb4, 0xf0, 0x04, 0x2e, 0x48, 0x1a, 0x87, 0x04, 0x5b, 0x9e, 0x76, 0x63,
644 0x79, 0x01, 0xcb, 0x9a, 0x80, 0x61, 0xb6, 0xb7, 0x2d, 0xc3, 0x24, 0xa2, 0x2b, 0xfb, 0xfe, 0x02,
645 0xe4, 0x9c, 0xf6, 0xf4, 0xa8, 0x7f, 0xa8, 0xf7, 0xf5, 0x43, 0xfc, 0x85, 0xbf, 0x77, 0xba, 0xe1,
646 0x6d, 0x6a, 0x8e, 0xea, 0x3d, 0x2c, 0xd4, 0x13, 0x5f, 0x0b, 0xb5, 0x1c, 0x8c, 0x0f, 0x72, 0x52,
647 0x55, 0x8f, 0x93, 0xba, 0xe2, 0x0f, 0xf5, 0x33, 0x54, 0x55, 0x8f, 0xa1, 0x9a, 0x0d, 0x91, 0xfa,
648 0xaa, 0x9a, 0xd7, 0x57, 0x95, 0xfc, 0x29, 0xfe, 0xf6, 0xaa, 0xe6, 0xb5, 0x57, 0x01, 0x1c, 0xb9,
649 0xcb, 0xaa, 0x79, 0x5d, 0xd6, 0x0c, 0x8e, 0xbf, 0xd9, 0xaa, 0x79, 0xcd, 0x56, 0x00, 0x47, 0xee,
650 0xb9, 0x36, 0x24, 0x9e, 0xeb, 0xaa, 0x3f, 0x68, 0x96, 0xf5, 0xda, 0x94, 0x59, 0xaf, 0x6b, 0x33,
651 0x8a, 0x9a, 0xe9, 0xc0, 0x36, 0x24, 0x0e, 0x2c, 0xa8, 0x30, 0x1f, 0x23, 0xb6, 0x29, 0x33, 0x62,
652 0x81, 0x85, 0xf9, 0xf9, 0xb1, 0x8f, 0xdd, 0x7e, 0xec, 0xb2, 0x3f, 0x49, 0x6e, 0xcb, 0x6a, 0x5e,
653 0x5b, 0x56, 0x0a, 0x3a, 0x73, 0x32, 0x77, 0xf6, 0xc4, 0xd7, 0x9d, 0xfd, 0x81, 0x23, 0x1c, 0x64,
654 0xd2, 0x3e, 0xf3, 0x33, 0x69, 0xe5, 0x60, 0xf6, 0x6c, 0xaf, 0xb6, 0xeb, 0xe3, 0xd5, 0xae, 0x07,
655 0x83, 0xcf, 0x2d, 0xdb, 0xb9, 0x65, 0x3b, 0xb7, 0x6c, 0xe7, 0x96, 0xed, 0xaf, 0xb7, 0x6c, 0xab,
656 0xd1, 0xaf, 0xbe, 0x59, 0x44, 0xc5, 0x9f, 0x23, 0x90, 0x73, 0xbe, 0x0c, 0xee, 0x19, 0xa4, 0x43,
657 0xdb, 0xdb, 0x16, 0x64, 0x4c, 0xad, 0xa7, 0xef, 0xf7, 0xb4, 0xe3, 0x63, 0xc3, 0x6c, 0x3b, 0x9e,
658 0xed, 0x9a, 0xf7, 0x53, 0xa2, 0x23, 0x28, 0xd7, 0xb5, 0x1e, 0xed, 0x55, 0x34, 0xd9, 0x79, 0xdd,
659 0x98, 0x93, 0x08, 0xfe, 0x04, 0xd2, 0x3d, 0xbb, 0x3d, 0xa6, 0x85, 0x3d, 0x2f, 0x42, 0x17, 0x8d,
660 0xdf, 0xe9, 0x04, 0x06, 0xbd, 0x71, 0x80, 0x96, 0xd6, 0x3a, 0x21, 0x93, 0xd2, 0x22, 0x41, 0xa5,
661 0xd1, 0x67, 0x3a, 0x5d, 0x5a, 0x6b, 0x12, 0xa1, 0xdb, 0xd6, 0x5d, 0x7b, 0x50, 0xa7, 0x9b, 0xda,
662 0x3c, 0x7b, 0x30, 0xe7, 0xaa, 0x56, 0x72, 0xe6, 0xff, 0xc4, 0xb3, 0xa1, 0x85, 0xb9, 0x2b, 0x0f,
663 0x3a, 0x13, 0xe2, 0x86, 0x2c, 0xfe, 0x0b, 0xb2, 0x53, 0x6c, 0x9c, 0x01, 0x74, 0xc4, 0xa4, 0xa8,
664 0x81, 0x8e, 0x8a, 0x5f, 0x23, 0x48, 0xd3, 0x3e, 0xf9, 0x9f, 0x95, 0x3b, 0xdb, 0x9a, 0xd1, 0xc7,
665 0x0f, 0x20, 0xda, 0xd5, 0x8f, 0x08, 0x4b, 0xc8, 0x54, 0x6e, 0x9d, 0xbe, 0x5a, 0x0c, 0xfd, 0xfa,
666 0x6a, 0xf1, 0xdf, 0x01, 0xff, 0x25, 0x18, 0xd8, 0xc4, 0xea, 0x95, 0x1d, 0x4e, 0x83, 0x11, 0x70,
667 0x0d, 0x62, 0x7d, 0xa3, 0xdd, 0x21, 0xbc, 0xa4, 0xca, 0x8d, 0xf7, 0xc6, 0x70, 0x79, 0xf1, 0x14,
668 0xc1, 0x7c, 0xd5, 0x32, 0x89, 0x66, 0x98, 0x36, 0xff, 0x5a, 0x4b, 0xdf, 0x90, 0x2f, 0x10, 0xa4,
669 0xc6, 0x23, 0xdc, 0x82, 0xdc, 0x78, 0xc0, 0x3e, 0x82, 0x3b, 0x3b, 0x75, 0x55, 0x58, 0x61, 0x0f,
670 0xa3, 0x2c, 0xb9, 0x62, 0x62, 0xe7, 0x9d, 0x3c, 0x1d, 0x5c, 0x58, 0x83, 0x0b, 0x92, 0xb4, 0xf7,
671 0x79, 0x21, 0x17, 0x97, 0x20, 0x55, 0xb7, 0xc8, 0xb6, 0x76, 0xf0, 0x94, 0x7d, 0x72, 0x9e, 0xfc,
672 0x57, 0xa1, 0x12, 0x56, 0x42, 0x4c, 0x7c, 0x6d, 0x09, 0x12, 0xce, 0xe9, 0xc7, 0x71, 0x08, 0x6f,
673 0xad, 0x29, 0x21, 0xf6, 0x5b, 0x51, 0x10, 0xfb, 0xad, 0x2a, 0xe1, 0xca, 0xe6, 0xe9, 0x99, 0x1a,
674 0x7a, 0x79, 0xa6, 0x86, 0x7e, 0x39, 0x53, 0x43, 0xaf, 0xcf, 0x54, 0xf4, 0xe6, 0x4c, 0x45, 0x6f,
675 0xcf, 0x54, 0xf4, 0xee, 0x4c, 0x45, 0xcf, 0x87, 0x2a, 0xfa, 0x76, 0xa8, 0xa2, 0xef, 0x86, 0x2a,
676 0xfa, 0x61, 0xa8, 0xa2, 0x1f, 0x87, 0x2a, 0x3a, 0x1d, 0xaa, 0xe8, 0xe5, 0x50, 0x45, 0xaf, 0x87,
677 0x2a, 0x7a, 0x33, 0x54, 0x43, 0x6f, 0x87, 0x2a, 0x7a, 0x37, 0x54, 0x43, 0xcf, 0x7f, 0x53, 0x43,
678 0xad, 0x38, 0x5f, 0x9e, 0xdf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xea, 0x4a, 0x44, 0x79, 0x60, 0x1a,
679 0x00, 0x00,
680 }
681
682 func (this *Message) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
683 return Theproto3Description()
684 }
685 func (this *Nested) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
686 return Theproto3Description()
687 }
688 func (this *AllMaps) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
689 return Theproto3Description()
690 }
691 func (this *AllMapsOrdered) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
692 return Theproto3Description()
693 }
694 func (this *MessageWithMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
695 return Theproto3Description()
696 }
697 func (this *FloatingPoint) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
698 return Theproto3Description()
699 }
700 func (this *Uint128Pair) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
701 return Theproto3Description()
702 }
703 func (this *ContainsNestedMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
704 return Theproto3Description()
705 }
706 func (this *ContainsNestedMap_NestedMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
707 return Theproto3Description()
708 }
709 func (this *NotPacked) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
710 return Theproto3Description()
711 }
712 func Theproto3Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
713 d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
714 var gzipped = []byte{
715
716 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x5b, 0x70, 0x23, 0xd7,
717 0x99, 0xde, 0x34, 0x1a, 0x20, 0x81, 0x1f, 0x20, 0xd9, 0x6c, 0xce, 0x50, 0x10, 0x35, 0x22, 0x67,
718 0xa0, 0xd1, 0x88, 0xa2, 0x25, 0x0e, 0x87, 0xc3, 0xb9, 0x61, 0x2c, 0x69, 0x01, 0x10, 0x1c, 0x71,
719 0x4c, 0x82, 0x74, 0x93, 0xb4, 0x34, 0x56, 0x12, 0x54, 0x13, 0x68, 0x92, 0x90, 0x80, 0x6e, 0x2c,
720 0xba, 0x21, 0x89, 0xaa, 0x54, 0x4a, 0x59, 0x27, 0x1b, 0x6f, 0xee, 0xc9, 0x26, 0x15, 0xaf, 0xe3,
721 0x8b, 0xbc, 0x5b, 0xbb, 0xf6, 0x6e, 0x6e, 0x5e, 0x67, 0xe3, 0xec, 0x3a, 0xa9, 0xac, 0xf2, 0xe0,
722 0x64, 0xf2, 0x92, 0xf2, 0x26, 0x2f, 0x29, 0x57, 0x4a, 0x65, 0x8d, 0x9d, 0x8a, 0x93, 0x38, 0x89,
723 0xb3, 0x51, 0x55, 0x5c, 0xe5, 0x7d, 0x48, 0x9d, 0x5b, 0xf7, 0x39, 0x07, 0x0d, 0x34, 0x38, 0x92,
724 0x6c, 0x3f, 0xf8, 0x65, 0x06, 0x7d, 0xce, 0xff, 0x7d, 0xfd, 0xf7, 0x7f, 0x39, 0xe7, 0xef, 0x73,
725 0x0e, 0x40, 0xb8, 0x97, 0x87, 0x73, 0x87, 0x8e, 0x73, 0xd8, 0xb4, 0x2e, 0xb5, 0x3b, 0x8e, 0xe7,
726 0xec, 0x77, 0x0f, 0x2e, 0xd5, 0x2d, 0xb7, 0xd6, 0x69, 0xb4, 0x3d, 0xa7, 0xb3, 0x88, 0xdb, 0xf4,
727 0x09, 0x22, 0xb1, 0xc8, 0x24, 0x72, 0x9b, 0x30, 0xb9, 0xd6, 0x68, 0x5a, 0xab, 0xbe, 0xe0, 0x8e,
728 0xe5, 0xe9, 0x37, 0x20, 0x7e, 0xd0, 0x68, 0x5a, 0x59, 0xe5, 0x9c, 0x3a, 0x9f, 0x5e, 0xbe, 0xb0,
729 0x28, 0x81, 0x16, 0x45, 0xc4, 0x36, 0x6a, 0x36, 0x30, 0x22, 0xf7, 0xbd, 0x38, 0x4c, 0x85, 0xf4,
730 0xea, 0x3a, 0xc4, 0x6d, 0xb3, 0x85, 0x18, 0x95, 0xf9, 0x94, 0x81, 0x3f, 0xeb, 0x59, 0x18, 0x6d,
731 0x9b, 0xb5, 0x57, 0xcc, 0x43, 0x2b, 0x1b, 0xc3, 0xcd, 0xec, 0x52, 0x9f, 0x05, 0xa8, 0x5b, 0x6d,
732 0xcb, 0xae, 0x5b, 0x76, 0xed, 0x38, 0xab, 0x9e, 0x53, 0xe7, 0x53, 0x06, 0xd7, 0xa2, 0x7f, 0x04,
733 0x26, 0xdb, 0xdd, 0xfd, 0x66, 0xa3, 0x56, 0xe5, 0xc4, 0xe0, 0x9c, 0x3a, 0x9f, 0x30, 0x34, 0xd2,
734 0xb1, 0x1a, 0x08, 0x3f, 0x01, 0x13, 0xaf, 0x59, 0xe6, 0x2b, 0xbc, 0x68, 0x1a, 0x8b, 0x8e, 0xa3,
735 0x66, 0x4e, 0xb0, 0x04, 0x99, 0x96, 0xe5, 0xba, 0xe6, 0xa1, 0x55, 0xf5, 0x8e, 0xdb, 0x56, 0x36,
736 0x8e, 0x9f, 0xfe, 0x5c, 0xcf, 0xd3, 0xcb, 0x4f, 0x9e, 0xa6, 0xa8, 0xdd, 0xe3, 0xb6, 0xa5, 0x17,
737 0x20, 0x65, 0xd9, 0xdd, 0x16, 0x61, 0x48, 0xf4, 0xb1, 0x5f, 0xd9, 0xee, 0xb6, 0x64, 0x96, 0x24,
738 0x82, 0x51, 0x8a, 0x51, 0xd7, 0xea, 0xbc, 0xda, 0xa8, 0x59, 0xd9, 0x11, 0x4c, 0xf0, 0x44, 0x0f,
739 0xc1, 0x0e, 0xe9, 0x97, 0x39, 0x18, 0x4e, 0x2f, 0x41, 0xca, 0x7a, 0xdd, 0xb3, 0x6c, 0xb7, 0xe1,
740 0xd8, 0xd9, 0x51, 0x4c, 0xf2, 0x78, 0x88, 0x17, 0xad, 0x66, 0x5d, 0xa6, 0x08, 0x70, 0xfa, 0x35,
741 0x18, 0x75, 0xda, 0x5e, 0xc3, 0xb1, 0xdd, 0x6c, 0xf2, 0x9c, 0x32, 0x9f, 0x5e, 0x3e, 0x1b, 0x1a,
742 0x08, 0x5b, 0x44, 0xc6, 0x60, 0xc2, 0xfa, 0x3a, 0x68, 0xae, 0xd3, 0xed, 0xd4, 0xac, 0x6a, 0xcd,
743 0xa9, 0x5b, 0xd5, 0x86, 0x7d, 0xe0, 0x64, 0x53, 0x98, 0x60, 0xae, 0xf7, 0x41, 0xb0, 0x60, 0xc9,
744 0xa9, 0x5b, 0xeb, 0xf6, 0x81, 0x63, 0x8c, 0xbb, 0xc2, 0xb5, 0x3e, 0x0d, 0x23, 0xee, 0xb1, 0xed,
745 0x99, 0xaf, 0x67, 0x33, 0x38, 0x42, 0xe8, 0x55, 0xee, 0x0f, 0x46, 0x60, 0x62, 0x98, 0x10, 0xbb,
746 0x05, 0x89, 0x03, 0xf4, 0x94, 0xd9, 0xd8, 0x49, 0x6c, 0x40, 0x30, 0xa2, 0x11, 0x47, 0x1e, 0xd0,
747 0x88, 0x05, 0x48, 0xdb, 0x96, 0xeb, 0x59, 0x75, 0x12, 0x11, 0xea, 0x90, 0x31, 0x05, 0x04, 0xd4,
748 0x1b, 0x52, 0xf1, 0x07, 0x0a, 0xa9, 0x17, 0x61, 0xc2, 0x57, 0xa9, 0xda, 0x31, 0xed, 0x43, 0x16,
749 0x9b, 0x97, 0xa2, 0x34, 0x59, 0x2c, 0x33, 0x9c, 0x81, 0x60, 0xc6, 0xb8, 0x25, 0x5c, 0xeb, 0xab,
750 0x00, 0x8e, 0x6d, 0x39, 0x07, 0xd5, 0xba, 0x55, 0x6b, 0x66, 0x93, 0x7d, 0xac, 0xb4, 0x85, 0x44,
751 0x7a, 0xac, 0xe4, 0x90, 0xd6, 0x5a, 0x53, 0xbf, 0x19, 0x84, 0xda, 0x68, 0x9f, 0x48, 0xd9, 0x24,
752 0x49, 0xd6, 0x13, 0x6d, 0x7b, 0x30, 0xde, 0xb1, 0x50, 0xdc, 0x5b, 0x75, 0xfa, 0x64, 0x29, 0xac,
753 0xc4, 0x62, 0xe4, 0x93, 0x19, 0x14, 0x46, 0x1e, 0x6c, 0xac, 0xc3, 0x5f, 0xea, 0x8f, 0x81, 0xdf,
754 0x50, 0xc5, 0x61, 0x05, 0x78, 0x14, 0xca, 0xb0, 0xc6, 0x8a, 0xd9, 0xb2, 0x66, 0xde, 0x80, 0x71,
755 0xd1, 0x3c, 0xfa, 0x69, 0x48, 0xb8, 0x9e, 0xd9, 0xf1, 0x70, 0x14, 0x26, 0x0c, 0x72, 0xa1, 0x6b,
756 0xa0, 0x5a, 0x76, 0x1d, 0x8f, 0x72, 0x09, 0x03, 0x7d, 0xd4, 0x7f, 0x21, 0x78, 0x60, 0x15, 0x3f,
757 0xf0, 0xc5, 0x5e, 0x8f, 0x0a, 0xcc, 0xf2, 0x73, 0xcf, 0x5c, 0x87, 0x31, 0xe1, 0x01, 0x86, 0xbd,
758 0x75, 0xee, 0xcf, 0xc2, 0x99, 0x50, 0x6a, 0xfd, 0x45, 0x38, 0xdd, 0xb5, 0x1b, 0xb6, 0x67, 0x75,
759 0xda, 0x1d, 0x0b, 0x45, 0x2c, 0xb9, 0x55, 0xf6, 0xbf, 0x8e, 0xf6, 0x89, 0xb9, 0x3d, 0x5e, 0x9a,
760 0xb0, 0x18, 0x53, 0xdd, 0xde, 0xc6, 0x85, 0x54, 0xf2, 0xfb, 0xa3, 0xda, 0x9b, 0x6f, 0xbe, 0xf9,
761 0x66, 0x2c, 0xf7, 0x99, 0x11, 0x38, 0x1d, 0x96, 0x33, 0xa1, 0xe9, 0x3b, 0x0d, 0x23, 0x76, 0xb7,
762 0xb5, 0x6f, 0x75, 0xb0, 0x91, 0x12, 0x06, 0xbd, 0xd2, 0x0b, 0x90, 0x68, 0x9a, 0xfb, 0x56, 0x33,
763 0x1b, 0x3f, 0xa7, 0xcc, 0x8f, 0x2f, 0x7f, 0x64, 0xa8, 0xac, 0x5c, 0xdc, 0x40, 0x10, 0x83, 0x20,
764 0xf5, 0x67, 0x21, 0x4e, 0x87, 0x68, 0xc4, 0xb0, 0x30, 0x1c, 0x03, 0xca, 0x25, 0x03, 0xe3, 0xf4,
765 0x47, 0x20, 0x85, 0xfe, 0x27, 0xb1, 0x31, 0x82, 0x75, 0x4e, 0xa2, 0x06, 0x14, 0x17, 0xfa, 0x0c,
766 0x24, 0x71, 0x9a, 0xd4, 0x2d, 0x36, 0xb5, 0xf9, 0xd7, 0x28, 0xb0, 0xea, 0xd6, 0x81, 0xd9, 0x6d,
767 0x7a, 0xd5, 0x57, 0xcd, 0x66, 0xd7, 0xc2, 0x01, 0x9f, 0x32, 0x32, 0xb4, 0xf1, 0x13, 0xa8, 0x4d,
768 0x9f, 0x83, 0x34, 0xc9, 0xaa, 0x86, 0x5d, 0xb7, 0x5e, 0xc7, 0xa3, 0x67, 0xc2, 0x20, 0x89, 0xb6,
769 0x8e, 0x5a, 0xd0, 0xed, 0x5f, 0x76, 0x1d, 0x9b, 0x85, 0x26, 0xbe, 0x05, 0x6a, 0xc0, 0xb7, 0xbf,
770 0x2e, 0x0f, 0xdc, 0x8f, 0x86, 0x3f, 0x9e, 0x1c, 0x53, 0xb9, 0xaf, 0xc7, 0x20, 0x8e, 0xc7, 0x8b,
771 0x09, 0x48, 0xef, 0xde, 0xdd, 0x2e, 0x57, 0x57, 0xb7, 0xf6, 0x8a, 0x1b, 0x65, 0x4d, 0xd1, 0xc7,
772 0x01, 0x70, 0xc3, 0xda, 0xc6, 0x56, 0x61, 0x57, 0x8b, 0xf9, 0xd7, 0xeb, 0x95, 0xdd, 0x6b, 0x2b,
773 0x9a, 0xea, 0x03, 0xf6, 0x48, 0x43, 0x9c, 0x17, 0xb8, 0xb2, 0xac, 0x25, 0x74, 0x0d, 0x32, 0x84,
774 0x60, 0xfd, 0xc5, 0xf2, 0xea, 0xb5, 0x15, 0x6d, 0x44, 0x6c, 0xb9, 0xb2, 0xac, 0x8d, 0xea, 0x63,
775 0x90, 0xc2, 0x2d, 0xc5, 0xad, 0xad, 0x0d, 0x2d, 0xe9, 0x73, 0xee, 0xec, 0x1a, 0xeb, 0x95, 0xdb,
776 0x5a, 0xca, 0xe7, 0xbc, 0x6d, 0x6c, 0xed, 0x6d, 0x6b, 0xe0, 0x33, 0x6c, 0x96, 0x77, 0x76, 0x0a,
777 0xb7, 0xcb, 0x5a, 0xda, 0x97, 0x28, 0xde, 0xdd, 0x2d, 0xef, 0x68, 0x19, 0x41, 0xad, 0x2b, 0xcb,
778 0xda, 0x98, 0x7f, 0x8b, 0x72, 0x65, 0x6f, 0x53, 0x1b, 0xd7, 0x27, 0x61, 0x8c, 0xdc, 0x82, 0x29,
779 0x31, 0x21, 0x35, 0x5d, 0x5b, 0xd1, 0xb4, 0x40, 0x11, 0xc2, 0x32, 0x29, 0x34, 0x5c, 0x5b, 0xd1,
780 0xf4, 0x5c, 0x09, 0x12, 0x38, 0xba, 0x74, 0x1d, 0xc6, 0x37, 0x0a, 0xc5, 0xf2, 0x46, 0x75, 0x6b,
781 0x7b, 0x77, 0x7d, 0xab, 0x52, 0xd8, 0xd0, 0x94, 0xa0, 0xcd, 0x28, 0x7f, 0x7c, 0x6f, 0xdd, 0x28,
782 0xaf, 0x6a, 0x31, 0xbe, 0x6d, 0xbb, 0x5c, 0xd8, 0x2d, 0xaf, 0x6a, 0x6a, 0xae, 0x06, 0xa7, 0xc3,
783 0xc6, 0xc9, 0xd0, 0xcc, 0xe0, 0x5c, 0x1c, 0xeb, 0xe3, 0x62, 0xcc, 0xd5, 0xe3, 0xe2, 0xef, 0xc6,
784 0x60, 0x2a, 0x64, 0xae, 0x08, 0xbd, 0xc9, 0x73, 0x90, 0x20, 0x21, 0x4a, 0x66, 0xcf, 0x27, 0x43,
785 0x27, 0x1d, 0x1c, 0xb0, 0x3d, 0x33, 0x28, 0xc6, 0xf1, 0x15, 0x84, 0xda, 0xa7, 0x82, 0x40, 0x14,
786 0x3d, 0x63, 0xfa, 0x9f, 0xee, 0x19, 0xd3, 0xc9, 0xb4, 0x77, 0x6d, 0x98, 0x69, 0x0f, 0xb7, 0x9d,
787 0x6c, 0x6c, 0x4f, 0x84, 0x8c, 0xed, 0xb7, 0x60, 0xb2, 0x87, 0x68, 0xe8, 0x31, 0xf6, 0x53, 0x0a,
788 0x64, 0xfb, 0x19, 0x27, 0x62, 0xa4, 0x8b, 0x09, 0x23, 0xdd, 0x2d, 0xd9, 0x82, 0xe7, 0xfb, 0x3b,
789 0xa1, 0xc7, 0xd7, 0x5f, 0x56, 0x60, 0x3a, 0xbc, 0x52, 0x0c, 0xd5, 0xe1, 0x59, 0x18, 0x69, 0x59,
790 0xde, 0x91, 0xc3, 0xaa, 0xa5, 0x8b, 0x21, 0x73, 0x30, 0xea, 0x96, 0x9d, 0x4d, 0x51, 0xfc, 0x24,
791 0xae, 0xf6, 0x2b, 0xf7, 0x88, 0x36, 0x3d, 0x9a, 0xfe, 0x4a, 0x0c, 0xce, 0x84, 0x92, 0x87, 0x2a,
792 0xfa, 0x28, 0x40, 0xc3, 0x6e, 0x77, 0x3d, 0x52, 0x11, 0x91, 0x01, 0x36, 0x85, 0x5b, 0xf0, 0xe0,
793 0x85, 0x06, 0xcf, 0xae, 0xe7, 0xf7, 0xab, 0xb8, 0x1f, 0x48, 0x13, 0x16, 0xb8, 0x11, 0x28, 0x1a,
794 0xc7, 0x8a, 0xce, 0xf6, 0x79, 0xd2, 0x9e, 0xc0, 0x5c, 0x02, 0xad, 0xd6, 0x6c, 0x58, 0xb6, 0x57,
795 0x75, 0xbd, 0x8e, 0x65, 0xb6, 0x1a, 0xf6, 0x21, 0x9e, 0x41, 0x92, 0xf9, 0xc4, 0x81, 0xd9, 0x74,
796 0x2d, 0x63, 0x82, 0x74, 0xef, 0xb0, 0x5e, 0x84, 0xc0, 0x01, 0xd4, 0xe1, 0x10, 0x23, 0x02, 0x82,
797 0x74, 0xfb, 0x88, 0xdc, 0x5f, 0x4d, 0x41, 0x9a, 0xab, 0xab, 0xf5, 0xf3, 0x90, 0x79, 0xd9, 0x7c,
798 0xd5, 0xac, 0xb2, 0x77, 0x25, 0x62, 0x89, 0x34, 0x6a, 0xdb, 0xa6, 0xef, 0x4b, 0x4b, 0x70, 0x1a,
799 0x8b, 0x38, 0x5d, 0xcf, 0xea, 0x54, 0x6b, 0x4d, 0xd3, 0x75, 0xb1, 0xd1, 0x92, 0x58, 0x54, 0x47,
800 0x7d, 0x5b, 0xa8, 0xab, 0xc4, 0x7a, 0xf4, 0xab, 0x30, 0x85, 0x11, 0xad, 0x6e, 0xd3, 0x6b, 0xb4,
801 0x9b, 0x56, 0x15, 0xbd, 0xbd, 0xb9, 0x78, 0x26, 0xf1, 0x35, 0x9b, 0x44, 0x12, 0x9b, 0x54, 0x00,
802 0x69, 0xe4, 0xea, 0xab, 0xf0, 0x28, 0x86, 0x1d, 0x5a, 0xb6, 0xd5, 0x31, 0x3d, 0xab, 0x6a, 0xfd,
803 0x62, 0xd7, 0x6c, 0xba, 0x55, 0xd3, 0xae, 0x57, 0x8f, 0x4c, 0xf7, 0x28, 0x7b, 0x1a, 0x11, 0x14,
804 0x63, 0x59, 0xc5, 0x78, 0x18, 0x09, 0xde, 0xa6, 0x72, 0x65, 0x2c, 0x56, 0xb0, 0xeb, 0xcf, 0x9b,
805 0xee, 0x91, 0x9e, 0x87, 0x69, 0xcc, 0xe2, 0x7a, 0x9d, 0x86, 0x7d, 0x58, 0xad, 0x1d, 0x59, 0xb5,
806 0x57, 0xaa, 0x5d, 0xef, 0xe0, 0x46, 0xf6, 0x11, 0xfe, 0xfe, 0x58, 0xc3, 0x1d, 0x2c, 0x53, 0x42,
807 0x22, 0x7b, 0xde, 0xc1, 0x0d, 0x7d, 0x07, 0x32, 0xc8, 0x19, 0xad, 0xc6, 0x1b, 0x56, 0xf5, 0xc0,
808 0xe9, 0xe0, 0xa9, 0x71, 0x3c, 0x64, 0x68, 0xe2, 0x2c, 0xb8, 0xb8, 0x45, 0x01, 0x9b, 0x4e, 0xdd,
809 0xca, 0x27, 0x76, 0xb6, 0xcb, 0xe5, 0x55, 0x23, 0xcd, 0x58, 0xd6, 0x9c, 0x0e, 0x0a, 0xa8, 0x43,
810 0xc7, 0x37, 0x70, 0x9a, 0x04, 0xd4, 0xa1, 0xc3, 0xcc, 0x7b, 0x15, 0xa6, 0x6a, 0x35, 0xf2, 0xcc,
811 0x8d, 0x5a, 0x95, 0xbe, 0x63, 0xb9, 0x59, 0x4d, 0x30, 0x56, 0xad, 0x76, 0x9b, 0x08, 0xd0, 0x18,
812 0x77, 0xf5, 0x9b, 0x70, 0x26, 0x30, 0x16, 0x0f, 0x9c, 0xec, 0x79, 0x4a, 0x19, 0x7a, 0x15, 0xa6,
813 0xda, 0xc7, 0xbd, 0x40, 0x5d, 0xb8, 0x63, 0xfb, 0x58, 0x86, 0x5d, 0x87, 0xd3, 0xed, 0xa3, 0x76,
814 0x2f, 0x6e, 0x81, 0xc7, 0xe9, 0xed, 0xa3, 0xb6, 0x0c, 0x7c, 0x1c, 0xbf, 0x70, 0x77, 0xac, 0x9a,
815 0xe9, 0x59, 0xf5, 0xec, 0x43, 0xbc, 0x38, 0xd7, 0xa1, 0x5f, 0x02, 0xad, 0x56, 0xab, 0x5a, 0xb6,
816 0xb9, 0xdf, 0xb4, 0xaa, 0x66, 0xc7, 0xb2, 0x4d, 0x37, 0x3b, 0xc7, 0x0b, 0x8f, 0xd7, 0x6a, 0x65,
817 0xdc, 0x5b, 0xc0, 0x9d, 0xfa, 0x02, 0x4c, 0x3a, 0xfb, 0x2f, 0xd7, 0x48, 0x48, 0x56, 0xdb, 0x1d,
818 0xeb, 0xa0, 0xf1, 0x7a, 0xf6, 0x02, 0xb6, 0xef, 0x04, 0xea, 0xc0, 0x01, 0xb9, 0x8d, 0x9b, 0xf5,
819 0x27, 0x41, 0xab, 0xb9, 0x47, 0x66, 0xa7, 0x8d, 0xc7, 0x64, 0xb7, 0x6d, 0xd6, 0xac, 0xec, 0xe3,
820 0x44, 0x94, 0xb4, 0x57, 0x58, 0x33, 0x4a, 0x09, 0xf7, 0xb5, 0xc6, 0x81, 0xc7, 0x18, 0x9f, 0x20,
821 0x29, 0x81, 0xdb, 0x28, 0xdb, 0x3c, 0x68, 0xc8, 0x14, 0xc2, 0x8d, 0xe7, 0xb1, 0xd8, 0x78, 0xfb,
822 0xa8, 0xcd, 0xdf, 0xf7, 0x31, 0x18, 0x43, 0x92, 0xc1, 0x4d, 0x9f, 0x24, 0x05, 0x59, 0xfb, 0x88,
823 0xbb, 0xe3, 0x0a, 0x4c, 0x23, 0xa1, 0x96, 0xe5, 0x99, 0x75, 0xd3, 0x33, 0x39, 0xe9, 0xa7, 0xb0,
824 0x34, 0xb2, 0xfb, 0x26, 0xed, 0x14, 0xf4, 0xec, 0x74, 0xf7, 0x8f, 0xfd, 0xc8, 0x7a, 0x9a, 0xe8,
825 0x89, 0xda, 0x58, 0x6c, 0x7d, 0x68, 0x45, 0x77, 0x2e, 0x0f, 0x19, 0x3e, 0xf0, 0xf5, 0x14, 0x90,
826 0xd0, 0xd7, 0x14, 0x54, 0x05, 0x95, 0xb6, 0x56, 0x51, 0xfd, 0xf2, 0xc9, 0xb2, 0x16, 0x43, 0x75,
827 0xd4, 0xc6, 0xfa, 0x6e, 0xb9, 0x6a, 0xec, 0x55, 0x76, 0xd7, 0x37, 0xcb, 0x9a, 0xca, 0x17, 0xec,
828 0xdf, 0x8c, 0xc1, 0xb8, 0xf8, 0xee, 0xa5, 0x7f, 0x14, 0x1e, 0x62, 0x0b, 0x25, 0xae, 0xe5, 0x55,
829 0x5f, 0x6b, 0x74, 0x70, 0x2e, 0xb6, 0x4c, 0x32, 0x2f, 0xfa, 0xd1, 0x70, 0x9a, 0x4a, 0xed, 0x58,
830 0xde, 0x0b, 0x8d, 0x0e, 0xca, 0xb4, 0x96, 0xe9, 0xe9, 0x1b, 0x30, 0x67, 0x3b, 0x55, 0xd7, 0x33,
831 0xed, 0xba, 0xd9, 0xa9, 0x57, 0x83, 0x25, 0xaa, 0xaa, 0x59, 0xab, 0x59, 0xae, 0xeb, 0x90, 0x39,
832 0xd0, 0x67, 0x39, 0x6b, 0x3b, 0x3b, 0x54, 0x38, 0x98, 0x1c, 0x0a, 0x54, 0x54, 0x8a, 0x5c, 0xb5,
833 0x5f, 0xe4, 0x3e, 0x02, 0xa9, 0x96, 0xd9, 0xae, 0x5a, 0xb6, 0xd7, 0x39, 0xc6, 0x15, 0x77, 0xd2,
834 0x48, 0xb6, 0xcc, 0x76, 0x19, 0x5d, 0xff, 0x64, 0x5e, 0x7c, 0xfe, 0xb3, 0x0a, 0x19, 0xbe, 0xea,
835 0x46, 0x2f, 0x31, 0x35, 0x3c, 0x41, 0x29, 0x78, 0x08, 0x7b, 0x6c, 0x60, 0x8d, 0xbe, 0x58, 0x42,
836 0x33, 0x57, 0x7e, 0x84, 0xd4, 0xc2, 0x06, 0x41, 0xa2, 0xaa, 0x01, 0x85, 0x96, 0x45, 0x6a, 0x8f,
837 0xa4, 0x41, 0xaf, 0xf4, 0xdb, 0x30, 0xf2, 0xb2, 0x8b, 0xb9, 0x47, 0x30, 0xf7, 0x85, 0xc1, 0xdc,
838 0x77, 0x76, 0x30, 0x79, 0xea, 0xce, 0x4e, 0xb5, 0xb2, 0x65, 0x6c, 0x16, 0x36, 0x0c, 0x0a, 0xd7,
839 0x1f, 0x86, 0x78, 0xd3, 0x7c, 0xe3, 0x58, 0x9c, 0xe3, 0x70, 0xd3, 0xb0, 0x86, 0x7f, 0x18, 0xe2,
840 0xaf, 0x59, 0xe6, 0x2b, 0xe2, 0xcc, 0x82, 0x9b, 0x3e, 0xc4, 0xd0, 0xbf, 0x04, 0x09, 0x6c, 0x2f,
841 0x1d, 0x80, 0x5a, 0x4c, 0x3b, 0xa5, 0x27, 0x21, 0x5e, 0xda, 0x32, 0x50, 0xf8, 0x6b, 0x90, 0x21,
842 0xad, 0xd5, 0xed, 0xf5, 0x72, 0xa9, 0xac, 0xc5, 0x72, 0x57, 0x61, 0x84, 0x18, 0x01, 0xa5, 0x86,
843 0x6f, 0x06, 0xed, 0x14, 0xbd, 0xa4, 0x1c, 0x0a, 0xeb, 0xdd, 0xdb, 0x2c, 0x96, 0x0d, 0x2d, 0xc6,
844 0xbb, 0xd7, 0x85, 0x0c, 0x5f, 0x70, 0xff, 0x64, 0x62, 0xea, 0x1b, 0x0a, 0xa4, 0xb9, 0x02, 0x1a,
845 0x55, 0x3e, 0x66, 0xb3, 0xe9, 0xbc, 0x56, 0x35, 0x9b, 0x0d, 0xd3, 0xa5, 0x41, 0x01, 0xb8, 0xa9,
846 0x80, 0x5a, 0x86, 0x75, 0xda, 0x4f, 0x44, 0xf9, 0x2f, 0x28, 0xa0, 0xc9, 0xb5, 0xab, 0xa4, 0xa0,
847 0xf2, 0x53, 0x55, 0xf0, 0x73, 0x0a, 0x8c, 0x8b, 0x05, 0xab, 0xa4, 0xde, 0xf9, 0x9f, 0xaa, 0x7a,
848 0xdf, 0x89, 0xc1, 0x98, 0x50, 0xa6, 0x0e, 0xab, 0xdd, 0x2f, 0xc2, 0x64, 0xa3, 0x6e, 0xb5, 0xda,
849 0x8e, 0x67, 0xd9, 0xb5, 0xe3, 0x6a, 0xd3, 0x7a, 0xd5, 0x6a, 0x66, 0x73, 0x78, 0xa0, 0xb8, 0x34,
850 0xb8, 0x10, 0x5e, 0x5c, 0x0f, 0x70, 0x1b, 0x08, 0x96, 0x9f, 0x5a, 0x5f, 0x2d, 0x6f, 0x6e, 0x6f,
851 0xed, 0x96, 0x2b, 0xa5, 0xbb, 0xd5, 0xbd, 0xca, 0xc7, 0x2a, 0x5b, 0x2f, 0x54, 0x0c, 0xad, 0x21,
852 0x89, 0x7d, 0x88, 0xa9, 0xbe, 0x0d, 0x9a, 0xac, 0x94, 0xfe, 0x10, 0x84, 0xa9, 0xa5, 0x9d, 0xd2,
853 0xa7, 0x60, 0xa2, 0xb2, 0x55, 0xdd, 0x59, 0x5f, 0x2d, 0x57, 0xcb, 0x6b, 0x6b, 0xe5, 0xd2, 0xee,
854 0x0e, 0x59, 0xda, 0xf0, 0xa5, 0x77, 0xc5, 0xa4, 0xfe, 0xac, 0x0a, 0x53, 0x21, 0x9a, 0xe8, 0x05,
855 0xfa, 0x52, 0x42, 0xde, 0x93, 0x9e, 0x1e, 0x46, 0xfb, 0x45, 0x54, 0x15, 0x6c, 0x9b, 0x1d, 0x8f,
856 0xbe, 0xc3, 0x3c, 0x09, 0xc8, 0x4a, 0xb6, 0xd7, 0x38, 0x68, 0x58, 0x1d, 0xba, 0x12, 0x44, 0xde,
857 0x54, 0x26, 0x82, 0x76, 0xb2, 0x18, 0xf4, 0x14, 0xe8, 0x6d, 0xc7, 0x6d, 0x78, 0x8d, 0x57, 0xad,
858 0x6a, 0xc3, 0x66, 0xcb, 0x46, 0xe8, 0xcd, 0x25, 0x6e, 0x68, 0xac, 0x67, 0xdd, 0xf6, 0x7c, 0x69,
859 0xdb, 0x3a, 0x34, 0x25, 0x69, 0x34, 0x80, 0xab, 0x86, 0xc6, 0x7a, 0x7c, 0xe9, 0xf3, 0x90, 0xa9,
860 0x3b, 0x5d, 0x54, 0xce, 0x11, 0x39, 0x34, 0x5f, 0x28, 0x46, 0x9a, 0xb4, 0xf9, 0x22, 0xb4, 0x50,
861 0x0f, 0xd6, 0xab, 0x32, 0x46, 0x9a, 0xb4, 0x11, 0x91, 0x27, 0x60, 0xc2, 0x3c, 0x3c, 0xec, 0x20,
862 0x72, 0x46, 0x44, 0x5e, 0x3d, 0xc6, 0xfd, 0x66, 0x2c, 0x38, 0x73, 0x07, 0x92, 0xcc, 0x0e, 0x68,
863 0x4a, 0x46, 0x96, 0xa8, 0xb6, 0xc9, 0xfb, 0x74, 0x6c, 0x3e, 0x65, 0x24, 0x6d, 0xd6, 0x79, 0x1e,
864 0x32, 0x0d, 0xb7, 0x1a, 0x2c, 0xbf, 0xc7, 0xce, 0xc5, 0xe6, 0x93, 0x46, 0xba, 0xe1, 0xfa, 0x4b,
865 0x97, 0xb9, 0x2f, 0xc7, 0x60, 0x5c, 0xdc, 0x3e, 0xd0, 0x57, 0x21, 0xd9, 0x74, 0x6a, 0x26, 0x0e,
866 0x2d, 0xb2, 0x77, 0x35, 0x1f, 0xb1, 0xe3, 0xb0, 0xb8, 0x41, 0xe5, 0x0d, 0x1f, 0x39, 0xf3, 0xef,
867 0x15, 0x48, 0xb2, 0x66, 0x7d, 0x1a, 0xe2, 0x6d, 0xd3, 0x3b, 0xc2, 0x74, 0x89, 0x62, 0x4c, 0x53,
868 0x0c, 0x7c, 0x8d, 0xda, 0xdd, 0xb6, 0x69, 0xe3, 0x10, 0xa0, 0xed, 0xe8, 0x1a, 0xf9, 0xb5, 0x69,
869 0x99, 0x75, 0xfc, 0x5e, 0xe3, 0xb4, 0x5a, 0x96, 0xed, 0xb9, 0xcc, 0xaf, 0xb4, 0xbd, 0x44, 0x9b,
870 0xf5, 0x8f, 0xc0, 0xa4, 0xd7, 0x31, 0x1b, 0x4d, 0x41, 0x36, 0x8e, 0x65, 0x35, 0xd6, 0xe1, 0x0b,
871 0xe7, 0xe1, 0x61, 0xc6, 0x5b, 0xb7, 0x3c, 0xb3, 0x76, 0x64, 0xd5, 0x03, 0xd0, 0x08, 0x5e, 0xbf,
872 0x78, 0x88, 0x0a, 0xac, 0xd2, 0x7e, 0x86, 0xcd, 0xfd, 0x91, 0x02, 0x93, 0xec, 0x4d, 0xac, 0xee,
873 0x1b, 0x6b, 0x13, 0xc0, 0xb4, 0x6d, 0xc7, 0xe3, 0xcd, 0xd5, 0x1b, 0xca, 0x3d, 0xb8, 0xc5, 0x82,
874 0x0f, 0x32, 0x38, 0x82, 0x99, 0x16, 0x40, 0xd0, 0xd3, 0xd7, 0x6c, 0x73, 0x90, 0xa6, 0x7b, 0x43,
875 0x78, 0x83, 0x91, 0xbc, 0xbb, 0x03, 0x69, 0x42, 0xaf, 0x6c, 0xfa, 0x69, 0x48, 0xec, 0x5b, 0x87,
876 0x0d, 0x9b, 0xae, 0xf8, 0x92, 0x0b, 0xb6, 0xc2, 0x12, 0xf7, 0x57, 0x58, 0x8a, 0x2f, 0xc1, 0x54,
877 0xcd, 0x69, 0xc9, 0xea, 0x16, 0x35, 0x69, 0xfd, 0xc0, 0x7d, 0x5e, 0xf9, 0x24, 0x04, 0x25, 0xe6,
878 0x8f, 0x14, 0xe5, 0xd7, 0x63, 0xea, 0xed, 0xed, 0xe2, 0xef, 0xc4, 0x66, 0x6e, 0x13, 0xe8, 0x36,
879 0x7b, 0x52, 0xc3, 0x3a, 0x68, 0x5a, 0x35, 0xa4, 0x3d, 0xfc, 0xd6, 0x47, 0xe0, 0xe9, 0xc3, 0x86,
880 0x77, 0xd4, 0xdd, 0x5f, 0xac, 0x39, 0xad, 0x4b, 0x87, 0xce, 0xa1, 0x13, 0xec, 0xa9, 0xa2, 0x2b,
881 0x7c, 0x81, 0x3f, 0xd1, 0x7d, 0xd5, 0x94, 0xdf, 0x3a, 0x13, 0xb9, 0x09, 0x9b, 0xaf, 0xc0, 0x14,
882 0x15, 0xae, 0xe2, 0x8d, 0x1d, 0xf2, 0x7a, 0xa2, 0x0f, 0x5c, 0x1c, 0xcb, 0xfe, 0xee, 0xf7, 0xf0,
883 0x74, 0x6d, 0x4c, 0x52, 0x28, 0xea, 0x23, 0x6f, 0x30, 0x79, 0x03, 0xce, 0x08, 0x7c, 0x24, 0x35,
884 0xad, 0x4e, 0x04, 0xe3, 0x37, 0x29, 0xe3, 0x14, 0xc7, 0xb8, 0x43, 0xa1, 0xf9, 0x12, 0x8c, 0x9d,
885 0x84, 0xeb, 0xdf, 0x50, 0xae, 0x8c, 0xc5, 0x93, 0xdc, 0x86, 0x09, 0x4c, 0x52, 0xeb, 0xba, 0x9e,
886 0xd3, 0xc2, 0xe3, 0xde, 0x60, 0x9a, 0x7f, 0xfb, 0x3d, 0x92, 0x2b, 0xe3, 0x08, 0x56, 0xf2, 0x51,
887 0xf9, 0x3c, 0xe0, 0xbd, 0xac, 0xba, 0x55, 0x6b, 0x46, 0x30, 0xdc, 0xa3, 0x8a, 0xf8, 0xf2, 0xf9,
888 0x4f, 0xc0, 0x69, 0xf4, 0x19, 0x0f, 0x4b, 0xbc, 0x26, 0xd1, 0x2b, 0x69, 0xd9, 0x3f, 0xfa, 0x14,
889 0x49, 0xc7, 0x29, 0x9f, 0x80, 0xd3, 0x89, 0xf3, 0xe2, 0xa1, 0xe5, 0x79, 0x56, 0xc7, 0xad, 0x9a,
890 0xcd, 0x30, 0xf5, 0xb8, 0xa5, 0x88, 0xec, 0xaf, 0xfd, 0x40, 0xf4, 0xe2, 0x6d, 0x82, 0x2c, 0x34,
891 0x9b, 0xf9, 0x3d, 0x78, 0x28, 0x24, 0x2a, 0x86, 0xe0, 0xfc, 0x2c, 0xe5, 0x3c, 0xdd, 0x13, 0x19,
892 0x88, 0x76, 0x1b, 0x58, 0xbb, 0xef, 0xcb, 0x21, 0x38, 0xff, 0x3e, 0xe5, 0xd4, 0x29, 0x96, 0xb9,
893 0x14, 0x31, 0xde, 0x81, 0xc9, 0x57, 0xad, 0xce, 0xbe, 0xe3, 0xd2, 0xe5, 0x9f, 0x21, 0xe8, 0x3e,
894 0x47, 0xe9, 0x26, 0x28, 0x10, 0xaf, 0x07, 0x21, 0xae, 0x9b, 0x90, 0x3c, 0x30, 0x6b, 0xd6, 0x10,
895 0x14, 0x9f, 0xa7, 0x14, 0xa3, 0x48, 0x1e, 0x41, 0x0b, 0x90, 0x39, 0x74, 0xe8, 0xcc, 0x14, 0x0d,
896 0xff, 0x02, 0x85, 0xa7, 0x19, 0x86, 0x52, 0xb4, 0x9d, 0x76, 0xb7, 0x89, 0xa6, 0xad, 0x68, 0x8a,
897 0x2f, 0x32, 0x0a, 0x86, 0xa1, 0x14, 0x27, 0x30, 0xeb, 0x5b, 0x8c, 0xc2, 0xe5, 0xec, 0xf9, 0x1c,
898 0xa4, 0x1d, 0xbb, 0x79, 0xec, 0xd8, 0xc3, 0x28, 0xf1, 0x25, 0xca, 0x00, 0x14, 0x82, 0x08, 0x6e,
899 0x41, 0x6a, 0x58, 0x47, 0xfc, 0xe6, 0x0f, 0x58, 0x7a, 0x30, 0x0f, 0xdc, 0x86, 0x09, 0x36, 0x40,
900 0x35, 0x1c, 0x7b, 0x08, 0x8a, 0xdf, 0xa2, 0x14, 0xe3, 0x1c, 0x8c, 0x3e, 0x86, 0x67, 0xb9, 0xde,
901 0xa1, 0x35, 0x0c, 0xc9, 0x97, 0xd9, 0x63, 0x50, 0x08, 0x35, 0xe5, 0xbe, 0x65, 0xd7, 0x8e, 0x86,
902 0x63, 0xf8, 0x0a, 0x33, 0x25, 0xc3, 0x20, 0x8a, 0x12, 0x8c, 0xb5, 0xcc, 0x8e, 0x7b, 0x64, 0x36,
903 0x87, 0x72, 0xc7, 0x6f, 0x53, 0x8e, 0x8c, 0x0f, 0xa2, 0x16, 0xe9, 0xda, 0x27, 0xa1, 0xf9, 0x1d,
904 0x66, 0x11, 0x0e, 0x46, 0x53, 0xcf, 0xf5, 0xf0, 0x5a, 0xd9, 0x49, 0xd8, 0xfe, 0x01, 0x4b, 0x3d,
905 0x82, 0xdd, 0xe4, 0x19, 0x6f, 0x41, 0xca, 0x6d, 0xbc, 0x31, 0x14, 0xcd, 0x3f, 0x64, 0x9e, 0xc6,
906 0x00, 0x04, 0xbe, 0x0b, 0x0f, 0x87, 0x4e, 0x13, 0x43, 0x90, 0xfd, 0x23, 0x4a, 0x36, 0x1d, 0x32,
907 0x55, 0xd0, 0x21, 0xe1, 0xa4, 0x94, 0xff, 0x98, 0x0d, 0x09, 0x96, 0xc4, 0xb5, 0x8d, 0xde, 0x15,
908 0x5c, 0xf3, 0xe0, 0x64, 0x56, 0xfb, 0x27, 0xcc, 0x6a, 0x04, 0x2b, 0x58, 0x6d, 0x17, 0xa6, 0x29,
909 0xe3, 0xc9, 0xfc, 0xfa, 0x55, 0x36, 0xb0, 0x12, 0xf4, 0x9e, 0xe8, 0xdd, 0x97, 0x60, 0xc6, 0x37,
910 0x27, 0x2b, 0x4a, 0xdd, 0x6a, 0xcb, 0x6c, 0x0f, 0xc1, 0xfc, 0xbb, 0x94, 0x99, 0x8d, 0xf8, 0x7e,
911 0x55, 0xeb, 0x6e, 0x9a, 0x6d, 0x44, 0xfe, 0x22, 0x64, 0x19, 0x79, 0xd7, 0xee, 0x58, 0x35, 0xe7,
912 0xd0, 0x6e, 0xbc, 0x61, 0xd5, 0x87, 0xa0, 0xfe, 0x9a, 0xe4, 0xaa, 0x3d, 0x0e, 0x8e, 0x98, 0xd7,
913 0x41, 0xf3, 0x6b, 0x95, 0x6a, 0xa3, 0xd5, 0x76, 0x3a, 0x5e, 0x04, 0xe3, 0x3f, 0x65, 0x9e, 0xf2,
914 0x71, 0xeb, 0x18, 0x96, 0x2f, 0xc3, 0x38, 0xbe, 0x1c, 0x36, 0x24, 0x7f, 0x8f, 0x12, 0x8d, 0x05,
915 0x28, 0x3a, 0x70, 0xd4, 0x9c, 0x56, 0xdb, 0xec, 0x0c, 0x33, 0xfe, 0xfd, 0x33, 0x36, 0x70, 0x50,
916 0x08, 0x1d, 0x38, 0xbc, 0xe3, 0xb6, 0x85, 0x66, 0xfb, 0x21, 0x18, 0xbe, 0xce, 0x06, 0x0e, 0x86,
917 0xa1, 0x14, 0xac, 0x60, 0x18, 0x82, 0xe2, 0x9f, 0x33, 0x0a, 0x86, 0x41, 0x14, 0x1f, 0x0f, 0x26,
918 0xda, 0x8e, 0x75, 0xd8, 0x70, 0xbd, 0x0e, 0x29, 0x85, 0x07, 0x53, 0xfd, 0xfe, 0x0f, 0xc4, 0x22,
919 0xcc, 0xe0, 0xa0, 0x68, 0x24, 0xa2, 0x4b, 0xa8, 0xf8, 0x4d, 0x29, 0x5a, 0xb1, 0x3f, 0x60, 0x23,
920 0x11, 0x07, 0x43, 0xba, 0x71, 0x15, 0x22, 0x32, 0x7b, 0x0d, 0xbd, 0x1f, 0x0c, 0x41, 0xf7, 0x0d,
921 0x49, 0xb9, 0x1d, 0x86, 0x45, 0x9c, 0x5c, 0xfd, 0xd3, 0xb5, 0x5f, 0xb1, 0x8e, 0x87, 0x8a, 0xce,
922 0x7f, 0x21, 0xd5, 0x3f, 0x7b, 0x04, 0x49, 0xc6, 0x90, 0x09, 0xa9, 0x9e, 0xd2, 0xa3, 0x4e, 0x01,
923 0x65, 0xff, 0xfc, 0x7b, 0xf4, 0x79, 0xc5, 0x72, 0x2a, 0xbf, 0x81, 0x82, 0x5c, 0x2c, 0x7a, 0xa2,
924 0xc9, 0x3e, 0xf5, 0x9e, 0x1f, 0xe7, 0x42, 0xcd, 0x93, 0x5f, 0x83, 0x31, 0xa1, 0xe0, 0x89, 0xa6,
925 0xfa, 0x0b, 0x94, 0x2a, 0xc3, 0xd7, 0x3b, 0xf9, 0xab, 0x10, 0x47, 0xc5, 0x4b, 0x34, 0xfc, 0x2f,
926 0x52, 0x38, 0x16, 0xcf, 0x3f, 0x03, 0x49, 0x56, 0xb4, 0x44, 0x43, 0x7f, 0x99, 0x42, 0x7d, 0x08,
927 0x82, 0xb3, 0x82, 0x25, 0x1a, 0xfe, 0x97, 0x18, 0x9c, 0x41, 0x10, 0x7c, 0x78, 0x13, 0xbe, 0xfd,
928 0x57, 0xe2, 0x74, 0xd2, 0x61, 0xb6, 0xbb, 0x05, 0xa3, 0xb4, 0x52, 0x89, 0x46, 0xff, 0x0a, 0xbd,
929 0x39, 0x43, 0xe4, 0xaf, 0x43, 0x62, 0x48, 0x83, 0xff, 0x35, 0x0a, 0x25, 0xf2, 0xf9, 0x12, 0xa4,
930 0xb9, 0xea, 0x24, 0x1a, 0xfe, 0xd7, 0x29, 0x9c, 0x47, 0x21, 0xd5, 0x69, 0x75, 0x12, 0x4d, 0xf0,
931 0x37, 0x98, 0xea, 0x14, 0x81, 0xcc, 0xc6, 0x0a, 0x93, 0x68, 0xf4, 0xdf, 0x64, 0x56, 0x67, 0x90,
932 0xfc, 0x73, 0x90, 0xf2, 0x27, 0x9b, 0x68, 0xfc, 0xdf, 0xa2, 0xf8, 0x00, 0x83, 0x2c, 0xc0, 0x4d,
933 0x76, 0xd1, 0x14, 0x7f, 0x9b, 0x59, 0x80, 0x43, 0xa1, 0x34, 0x92, 0x0b, 0x98, 0x68, 0xa6, 0x5f,
934 0x65, 0x69, 0x24, 0xd5, 0x2f, 0xc8, 0x9b, 0x78, 0xcc, 0x8f, 0xa6, 0xf8, 0x3b, 0xcc, 0x9b, 0x58,
935 0x1e, 0xa9, 0x21, 0x57, 0x04, 0xd1, 0x1c, 0x7f, 0x8f, 0xa9, 0x21, 0x15, 0x04, 0xf9, 0x6d, 0xd0,
936 0x7b, 0xab, 0x81, 0x68, 0xbe, 0xcf, 0x50, 0xbe, 0xc9, 0x9e, 0x62, 0x20, 0xff, 0x02, 0x4c, 0x87,
937 0x57, 0x02, 0xd1, 0xac, 0xbf, 0xf6, 0x9e, 0xf4, 0xee, 0xc6, 0x17, 0x02, 0xf9, 0xdd, 0x60, 0x4a,
938 0xe1, 0xab, 0x80, 0x68, 0xda, 0xcf, 0xbe, 0x27, 0x0e, 0xdc, 0x7c, 0x11, 0x90, 0x2f, 0x00, 0x04,
939 0x13, 0x70, 0x34, 0xd7, 0xe7, 0x28, 0x17, 0x07, 0x42, 0xa9, 0x41, 0xe7, 0xdf, 0x68, 0xfc, 0xe7,
940 0x59, 0x6a, 0x50, 0x04, 0x4a, 0x0d, 0x36, 0xf5, 0x46, 0xa3, 0xbf, 0xc0, 0x52, 0x83, 0x41, 0x50,
941 0x64, 0x73, 0xb3, 0x5b, 0x34, 0xc3, 0x97, 0x58, 0x64, 0x73, 0xa8, 0x7c, 0x05, 0x26, 0x7b, 0x26,
942 0xc4, 0x68, 0xaa, 0x5f, 0xa7, 0x54, 0x9a, 0x3c, 0x1f, 0xf2, 0x93, 0x17, 0x9d, 0x0c, 0xa3, 0xd9,
943 0x7e, 0x43, 0x9a, 0xbc, 0xe8, 0x5c, 0x98, 0xbf, 0x05, 0x49, 0xbb, 0xdb, 0x6c, 0xa2, 0xe4, 0xd1,
944 0x07, 0x9f, 0xdc, 0xcb, 0xfe, 0xb7, 0x1f, 0x53, 0xeb, 0x30, 0x40, 0xfe, 0x2a, 0x24, 0xac, 0xd6,
945 0xbe, 0x55, 0x8f, 0x42, 0xfe, 0xf7, 0x1f, 0xb3, 0x01, 0x13, 0x49, 0xe7, 0x9f, 0x03, 0x20, 0x4b,
946 0x23, 0x78, 0xdb, 0x2f, 0x02, 0xfb, 0x3f, 0x7e, 0x4c, 0xcf, 0xd4, 0x04, 0x90, 0x80, 0x80, 0x9c,
947 0xd0, 0x19, 0x4c, 0xf0, 0x03, 0x91, 0x00, 0x7b, 0xe4, 0x26, 0x8c, 0xbe, 0xec, 0x3a, 0xb6, 0x67,
948 0x1e, 0x46, 0xa1, 0xff, 0x27, 0x45, 0x33, 0x79, 0x64, 0xb0, 0x96, 0xd3, 0xb1, 0x3c, 0xf3, 0xd0,
949 0x8d, 0xc2, 0xfe, 0x2f, 0x8a, 0xf5, 0x01, 0x08, 0x5c, 0x33, 0x5d, 0x6f, 0x98, 0xe7, 0xfe, 0xdf,
950 0x0c, 0xcc, 0x00, 0x48, 0x69, 0xf4, 0xf9, 0x15, 0xeb, 0x38, 0x0a, 0xfb, 0x43, 0xa6, 0x34, 0x95,
951 0xcf, 0x3f, 0x03, 0x29, 0xf4, 0x91, 0x1c, 0x94, 0x8b, 0x00, 0xff, 0x1f, 0x0a, 0x0e, 0x10, 0xe8,
952 0xce, 0xae, 0x57, 0xf7, 0x1a, 0xd1, 0xc6, 0xfe, 0x63, 0xea, 0x69, 0x26, 0x9f, 0x2f, 0x40, 0xda,
953 0xf5, 0xea, 0xf5, 0x2e, 0xad, 0x4f, 0x23, 0xe0, 0xff, 0xf7, 0xc7, 0xfe, 0x92, 0x85, 0x8f, 0x41,
954 0xde, 0x7e, 0xed, 0x15, 0xaf, 0xed, 0xe0, 0x6d, 0x8e, 0x28, 0x86, 0xf7, 0x28, 0x03, 0x07, 0x29,
955 0x96, 0xc3, 0x97, 0x6f, 0xe1, 0xb6, 0x73, 0xdb, 0x21, 0x0b, 0xb7, 0x9f, 0xcc, 0x45, 0xaf, 0xc0,
956 0xc2, 0x7f, 0x69, 0xc2, 0xf5, 0xbe, 0x62, 0x68, 0x2a, 0xbe, 0x54, 0x73, 0x5a, 0xfb, 0x8e, 0x7b,
957 0x69, 0xdf, 0xf1, 0x8e, 0x2e, 0x79, 0x47, 0x16, 0x6a, 0xa3, 0x4b, 0xb6, 0x71, 0xf4, 0x79, 0xe6,
958 0x64, 0xeb, 0xbc, 0x78, 0x17, 0xbf, 0xd2, 0x40, 0x8f, 0x56, 0xc1, 0x1b, 0x29, 0xfa, 0x59, 0x18,
959 0xc1, 0x0f, 0x7b, 0x19, 0x6f, 0x56, 0x2a, 0xc5, 0xf8, 0xbd, 0x77, 0xe6, 0x4e, 0x19, 0xb4, 0xcd,
960 0xef, 0x5d, 0xc6, 0x2b, 0xdd, 0x31, 0xa1, 0x77, 0xd9, 0xef, 0xbd, 0x42, 0x16, 0xbb, 0x85, 0xde,
961 0x2b, 0x7e, 0xef, 0x0a, 0x5e, 0xf6, 0x56, 0x85, 0xde, 0x15, 0xbf, 0xf7, 0x2a, 0xde, 0xda, 0x19,
962 0x13, 0x7a, 0xaf, 0xfa, 0xbd, 0xd7, 0xf0, 0x86, 0x4e, 0x5c, 0xe8, 0xbd, 0xe6, 0xf7, 0x5e, 0xc7,
963 0x7b, 0x39, 0x93, 0x42, 0xef, 0x75, 0xbf, 0xf7, 0x06, 0xde, 0xc3, 0xd1, 0x85, 0xde, 0x1b, 0x7e,
964 0xef, 0x4d, 0x7c, 0xf2, 0x6a, 0x54, 0xe8, 0xbd, 0xa9, 0xcf, 0xc2, 0x28, 0x79, 0xf2, 0x25, 0xbc,
965 0xe1, 0x3f, 0x41, 0xbb, 0x59, 0x63, 0xd0, 0x7f, 0x19, 0x9f, 0xb2, 0x1a, 0x11, 0xfb, 0x2f, 0x07,
966 0xfd, 0xcb, 0xf8, 0x0b, 0x1f, 0x9a, 0xd8, 0xbf, 0x1c, 0xf4, 0x5f, 0xc9, 0x8e, 0xe1, 0x93, 0x66,
967 0x42, 0xff, 0x95, 0xa0, 0x7f, 0x25, 0x3b, 0x8e, 0x32, 0x46, 0xec, 0x5f, 0x09, 0xfa, 0xaf, 0x66,
968 0x27, 0xce, 0x29, 0xf3, 0x19, 0xb1, 0xff, 0x6a, 0xee, 0x97, 0xb0, 0x7b, 0xed, 0xc0, 0xbd, 0xd3,
969 0xa2, 0x7b, 0x7d, 0xc7, 0x4e, 0x8b, 0x8e, 0xf5, 0x5d, 0x3a, 0x2d, 0xba, 0xd4, 0x77, 0xe6, 0xb4,
970 0xe8, 0x4c, 0xdf, 0x8d, 0xd3, 0xa2, 0x1b, 0x7d, 0x07, 0x4e, 0x8b, 0x0e, 0xf4, 0x5d, 0x37, 0x2d,
971 0xba, 0xce, 0x77, 0xda, 0xb4, 0xe8, 0x34, 0xdf, 0x5d, 0xd3, 0xa2, 0xbb, 0x7c, 0x47, 0x65, 0x25,
972 0x47, 0x05, 0x2e, 0xca, 0x4a, 0x2e, 0x0a, 0x9c, 0x93, 0x95, 0x9c, 0x13, 0xb8, 0x25, 0x2b, 0xb9,
973 0x25, 0x70, 0x48, 0x56, 0x72, 0x48, 0xe0, 0x8a, 0xac, 0xe4, 0x8a, 0xc0, 0x09, 0x34, 0xc7, 0x0c,
974 0xab, 0x1d, 0x92, 0x63, 0xea, 0xc0, 0x1c, 0x53, 0x07, 0xe6, 0x98, 0x3a, 0x30, 0xc7, 0xd4, 0x81,
975 0x39, 0xa6, 0x0e, 0xcc, 0x31, 0x75, 0x60, 0x8e, 0xa9, 0x03, 0x73, 0x4c, 0x1d, 0x98, 0x63, 0xea,
976 0xe0, 0x1c, 0x53, 0x23, 0x72, 0x4c, 0x8d, 0xc8, 0x31, 0x35, 0x22, 0xc7, 0xd4, 0x88, 0x1c, 0x53,
977 0x23, 0x72, 0x4c, 0xed, 0x9b, 0x63, 0x81, 0x7b, 0xa7, 0x45, 0xf7, 0x86, 0xe6, 0x98, 0xda, 0x27,
978 0xc7, 0xd4, 0x3e, 0x39, 0xa6, 0xf6, 0xc9, 0x31, 0xb5, 0x4f, 0x8e, 0xa9, 0x7d, 0x72, 0x4c, 0xed,
979 0x93, 0x63, 0x6a, 0x9f, 0x1c, 0x53, 0xfb, 0xe5, 0x98, 0xda, 0x37, 0xc7, 0xd4, 0xbe, 0x39, 0xa6,
980 0xf6, 0xcd, 0x31, 0xb5, 0x6f, 0x8e, 0xa9, 0x7d, 0x73, 0x4c, 0xe5, 0x73, 0xec, 0x5f, 0xaa, 0xa0,
981 0x93, 0x1c, 0xdb, 0xc6, 0x47, 0xc6, 0xa8, 0x2b, 0x66, 0xa5, 0x4c, 0x1b, 0x41, 0xae, 0xd3, 0x02,
982 0x97, 0xcc, 0x4a, 0xb9, 0x26, 0xf6, 0x2f, 0xfb, 0xfd, 0x2c, 0xdb, 0xc4, 0xfe, 0x2b, 0x7e, 0x3f,
983 0xcb, 0x37, 0xb1, 0x7f, 0xc5, 0xef, 0x67, 0x19, 0x27, 0xf6, 0x5f, 0xf5, 0xfb, 0x59, 0xce, 0x89,
984 0xfd, 0xd7, 0xfc, 0x7e, 0x96, 0x75, 0x62, 0xff, 0x75, 0xbf, 0x9f, 0xe5, 0x9d, 0xd8, 0x7f, 0xc3,
985 0xef, 0x67, 0x99, 0x27, 0xf6, 0xdf, 0xd4, 0xcf, 0xc9, 0xb9, 0xc7, 0x04, 0x7c, 0xd7, 0x9e, 0x93,
986 0xb3, 0x4f, 0x92, 0xb8, 0x1c, 0x48, 0xb0, 0xfc, 0x93, 0x24, 0x96, 0x03, 0x09, 0x96, 0x81, 0x92,
987 0xc4, 0x95, 0xdc, 0xa7, 0xb1, 0xfb, 0x6c, 0xd9, 0x7d, 0x33, 0x92, 0xfb, 0x62, 0x9c, 0xeb, 0x66,
988 0x24, 0xd7, 0xc5, 0x38, 0xb7, 0xcd, 0x48, 0x6e, 0x8b, 0x71, 0x2e, 0x9b, 0x91, 0x5c, 0x16, 0xe3,
989 0xdc, 0x35, 0x23, 0xb9, 0x2b, 0xc6, 0xb9, 0x6a, 0x46, 0x72, 0x55, 0x8c, 0x73, 0xd3, 0x8c, 0xe4,
990 0xa6, 0x18, 0xe7, 0xa2, 0x19, 0xc9, 0x45, 0x31, 0xce, 0x3d, 0x33, 0x92, 0x7b, 0x62, 0x9c, 0x6b,
991 0xce, 0xca, 0xae, 0x89, 0xf1, 0x6e, 0x39, 0x2b, 0xbb, 0x25, 0xc6, 0xbb, 0xe4, 0xac, 0xec, 0x92,
992 0x18, 0xef, 0x8e, 0xb3, 0xb2, 0x3b, 0x62, 0xbc, 0x2b, 0xfe, 0x24, 0xc6, 0x2a, 0xc2, 0x1d, 0xaf,
993 0xd3, 0xad, 0x79, 0xef, 0xab, 0x22, 0x5c, 0x12, 0xca, 0x87, 0xf4, 0xb2, 0xbe, 0x88, 0x0b, 0x56,
994 0xbe, 0xe2, 0x94, 0x66, 0xb0, 0x25, 0xa1, 0xb0, 0xe0, 0x10, 0x76, 0x38, 0x62, 0xe5, 0x7d, 0xd5,
995 0x86, 0x4b, 0x42, 0x99, 0x11, 0xad, 0xdf, 0x8d, 0x0f, 0xbd, 0x62, 0x7b, 0x3b, 0xc6, 0x2a, 0x36,
996 0x6a, 0xfe, 0x93, 0x56, 0x6c, 0x0b, 0xd1, 0x26, 0xf7, 0x8d, 0xbd, 0x10, 0x6d, 0xec, 0x9e, 0x59,
997 0x67, 0xd8, 0x0a, 0x6e, 0x21, 0xda, 0xb4, 0xbe, 0x51, 0x3f, 0xd8, 0x7a, 0x8b, 0x46, 0xb0, 0x61,
998 0xb5, 0x43, 0x22, 0xf8, 0xa4, 0xf5, 0xd6, 0x92, 0x30, 0x94, 0x9c, 0x34, 0x82, 0xd5, 0x13, 0x47,
999 0xf0, 0x49, 0x2b, 0xaf, 0x25, 0x61, 0x78, 0x39, 0x71, 0x04, 0x7f, 0x08, 0xf5, 0x10, 0x8d, 0xe0,
1000 0xc0, 0xfc, 0x27, 0xad, 0x87, 0x16, 0xa2, 0x4d, 0x1e, 0x1a, 0xc1, 0xea, 0x09, 0x22, 0x78, 0x98,
1001 0xfa, 0x68, 0x21, 0xda, 0xb4, 0xe1, 0x11, 0xfc, 0xbe, 0xab, 0x99, 0x2f, 0x2a, 0x30, 0x59, 0x69,
1002 0xd4, 0xcb, 0xad, 0x7d, 0xab, 0x5e, 0xb7, 0xea, 0xd4, 0x8e, 0x4b, 0xc2, 0x48, 0xd0, 0xc7, 0xd5,
1003 0xdf, 0x7a, 0x67, 0x2e, 0xb0, 0xf0, 0x55, 0x48, 0x12, 0x9b, 0x2e, 0x2d, 0x65, 0xef, 0x29, 0x11,
1004 0x23, 0x9c, 0x2f, 0xaa, 0x9f, 0x67, 0xb0, 0xcb, 0x4b, 0xd9, 0xff, 0xa0, 0x70, 0xa3, 0x9c, 0xdf,
1005 0x9c, 0xfb, 0x55, 0xac, 0xa1, 0xfd, 0xbe, 0x35, 0xbc, 0x34, 0x94, 0x86, 0x9c, 0x6e, 0x8f, 0xf4,
1006 0xe8, 0xc6, 0x69, 0xd5, 0x85, 0x89, 0x4a, 0xa3, 0x5e, 0xc1, 0x3f, 0x35, 0x30, 0x8c, 0x4a, 0x44,
1007 0x46, 0x1a, 0x0f, 0x96, 0x84, 0xb0, 0xe4, 0x11, 0x7e, 0x48, 0x8b, 0x63, 0x44, 0xae, 0x81, 0x6e,
1008 0x6b, 0x0b, 0xb7, 0x5d, 0xe8, 0x77, 0xdb, 0x60, 0x64, 0xf7, 0x6f, 0xb8, 0xd0, 0xef, 0x86, 0x41,
1009 0x0e, 0xf9, 0xb7, 0x7a, 0x9d, 0x4d, 0xce, 0xe4, 0xe0, 0x96, 0x7e, 0x16, 0x62, 0xeb, 0xe4, 0x5c,
1010 0x79, 0xa6, 0x98, 0x41, 0x4a, 0x7d, 0xfb, 0x9d, 0xb9, 0xf8, 0x5e, 0xb7, 0x51, 0x37, 0x62, 0xeb,
1011 0x75, 0xfd, 0x0e, 0x24, 0x3e, 0x41, 0xbf, 0xf0, 0x8a, 0x04, 0x56, 0xa8, 0xc0, 0x53, 0x11, 0x4b,
1012 0x4c, 0x98, 0x7a, 0x71, 0xaf, 0x61, 0x7b, 0x97, 0x97, 0x6f, 0x18, 0x84, 0x22, 0xf7, 0xa7, 0x00,
1013 0xc8, 0x3d, 0x57, 0x4d, 0xf7, 0x48, 0xaf, 0x30, 0x66, 0x72, 0xeb, 0x1b, 0xdf, 0x7e, 0x67, 0x6e,
1014 0x65, 0x18, 0xd6, 0xa7, 0xeb, 0xa6, 0x7b, 0xf4, 0xb4, 0x77, 0xdc, 0xb6, 0x16, 0x8b, 0xc7, 0x9e,
1015 0xe5, 0x32, 0xf6, 0x36, 0x9b, 0xf5, 0xe8, 0x73, 0x65, 0xb9, 0xe7, 0x4a, 0x0a, 0xcf, 0xb4, 0x26,
1016 0x3e, 0xd3, 0xd2, 0x83, 0x3e, 0xcf, 0xeb, 0x6c, 0x92, 0x90, 0x2c, 0xa9, 0x46, 0x59, 0x52, 0x7d,
1017 0xbf, 0x96, 0x6c, 0xb3, 0xf1, 0x51, 0x7a, 0x56, 0x75, 0xd0, 0xb3, 0xaa, 0xef, 0xe7, 0x59, 0xff,
1018 0x1f, 0xc9, 0x56, 0x3f, 0x9f, 0xf6, 0x6c, 0x72, 0xa6, 0xf5, 0x67, 0x6b, 0x2d, 0xe8, 0x03, 0xad,
1019 0x02, 0xf2, 0xf1, 0x7b, 0x6f, 0xcd, 0x29, 0xb9, 0x2f, 0xc6, 0xd8, 0x93, 0x93, 0x44, 0x7a, 0xb0,
1020 0x27, 0xff, 0x59, 0xa9, 0xa9, 0x3e, 0x0c, 0x0b, 0x7d, 0x41, 0x81, 0xe9, 0x9e, 0x91, 0x9c, 0x98,
1021 0xe9, 0x83, 0x1d, 0xce, 0xed, 0x93, 0x0e, 0xe7, 0x54, 0xc1, 0xdf, 0x53, 0xe0, 0xb4, 0x34, 0xbc,
1022 0x12, 0xf5, 0x2e, 0x49, 0xea, 0x3d, 0xd4, 0x7b, 0x27, 0x2c, 0xc8, 0x69, 0xc7, 0xbb, 0x57, 0x02,
1023 0x70, 0xcc, 0xbe, 0xdf, 0x57, 0x24, 0xbf, 0x9f, 0xf5, 0x01, 0x21, 0xe6, 0x62, 0x11, 0x40, 0xd5,
1024 0x76, 0x20, 0xbe, 0xdb, 0xb1, 0x2c, 0x7d, 0x16, 0x62, 0x5b, 0x1d, 0xaa, 0xe1, 0x38, 0xc1, 0x6f,
1025 0x75, 0x8a, 0x1d, 0xd3, 0xae, 0x1d, 0x19, 0xb1, 0xad, 0x8e, 0x7e, 0x1e, 0xd4, 0x02, 0xfd, 0xb2,
1026 0x7d, 0x7a, 0x79, 0x82, 0x08, 0x14, 0xec, 0x3a, 0x95, 0x40, 0x7d, 0xfa, 0x2c, 0xc4, 0x37, 0x2c,
1027 0xf3, 0x80, 0x2a, 0x01, 0x44, 0x06, 0xb5, 0x18, 0xb8, 0x9d, 0xde, 0xf0, 0x45, 0x48, 0x32, 0x62,
1028 0xfd, 0x02, 0x42, 0x1c, 0x78, 0xf4, 0xb6, 0x14, 0x81, 0xd4, 0xa1, 0x33, 0x17, 0xee, 0xd5, 0x2f,
1029 0x42, 0xc2, 0x68, 0x1c, 0x1e, 0x79, 0xf4, 0xe6, 0xbd, 0x62, 0xa4, 0x3b, 0x77, 0x17, 0x52, 0xbe,
1030 0x46, 0x1f, 0x30, 0xf5, 0x2a, 0x79, 0x34, 0x7d, 0x86, 0x9f, 0x4f, 0xd8, 0xba, 0x25, 0x69, 0xd2,
1031 0xcf, 0x41, 0x72, 0xc7, 0xeb, 0x04, 0x83, 0x3e, 0xab, 0x48, 0xfd, 0xd6, 0xdc, 0x2f, 0x29, 0x90,
1032 0x5c, 0xb5, 0xac, 0x36, 0x36, 0xf8, 0xe3, 0x10, 0x5f, 0x75, 0x5e, 0xb3, 0xa9, 0x82, 0x93, 0xd4,
1033 0xa2, 0xa8, 0x9b, 0xda, 0x14, 0x77, 0xeb, 0x8f, 0xf3, 0x76, 0x9f, 0xf2, 0xed, 0xce, 0xc9, 0x61,
1034 0xdb, 0xe7, 0x04, 0xdb, 0x53, 0x07, 0x22, 0xa1, 0x1e, 0xfb, 0x5f, 0x87, 0x34, 0x77, 0x17, 0x7d,
1035 0x9e, 0xaa, 0x11, 0x93, 0x81, 0xbc, 0xad, 0x90, 0x44, 0xce, 0x82, 0x31, 0xe1, 0xc6, 0x08, 0xca,
1036 0x99, 0xb8, 0x0f, 0x14, 0x9b, 0x79, 0x41, 0x34, 0x73, 0xb8, 0x28, 0x35, 0xf5, 0x12, 0xb1, 0x11,
1037 0x36, 0xf7, 0x05, 0x12, 0x9c, 0xfd, 0x9d, 0x88, 0x3e, 0xe7, 0x12, 0xa0, 0x56, 0x1a, 0xcd, 0xdc,
1038 0x33, 0x00, 0x24, 0xe5, 0xcb, 0x76, 0xb7, 0x25, 0x65, 0xdd, 0x38, 0x33, 0xf0, 0xee, 0x91, 0xb5,
1039 0x6b, 0xb9, 0x58, 0x44, 0xac, 0xa7, 0xd0, 0x00, 0x03, 0x24, 0xc5, 0x30, 0xfe, 0xc9, 0x48, 0x7c,
1040 0x68, 0x25, 0x86, 0x44, 0xb3, 0x44, 0xf4, 0xae, 0xe5, 0x15, 0x6c, 0xc7, 0x3b, 0xb2, 0x3a, 0x12,
1041 0x62, 0x59, 0xbf, 0x22, 0x24, 0xec, 0xf8, 0xf2, 0x23, 0x3e, 0xa2, 0x2f, 0xe8, 0x4a, 0xee, 0xab,
1042 0x58, 0x41, 0x54, 0x0a, 0xf4, 0x3c, 0xa0, 0x3a, 0xc4, 0x03, 0xea, 0xd7, 0x84, 0xfa, 0x6d, 0x80,
1043 0x9a, 0xd2, 0xab, 0xe5, 0x4d, 0xe1, 0x3d, 0x67, 0xb0, 0xb2, 0xe2, 0x3b, 0x26, 0xb3, 0x29, 0x53,
1044 0xf9, 0xc9, 0x48, 0x95, 0xfb, 0x54, 0xb7, 0x27, 0xb5, 0xa9, 0x3a, 0xac, 0x4d, 0xbf, 0xe1, 0x57,
1045 0x1c, 0xe4, 0x17, 0x4d, 0xf0, 0x6f, 0x01, 0xe9, 0x4f, 0x45, 0xfa, 0x3e, 0xaf, 0x94, 0x7c, 0x55,
1046 0x57, 0x86, 0x75, 0x7f, 0x3e, 0x56, 0x2c, 0xfa, 0xea, 0x5e, 0x3f, 0x41, 0x08, 0xe4, 0x63, 0xa5,
1047 0x92, 0x3f, 0x6c, 0x27, 0x3f, 0xfd, 0xd6, 0x9c, 0xf2, 0x95, 0xb7, 0xe6, 0x4e, 0xe5, 0x7e, 0x5b,
1048 0x81, 0x49, 0x2a, 0xc9, 0x05, 0xee, 0xd3, 0x92, 0xf2, 0x67, 0xd8, 0x98, 0x11, 0x66, 0x81, 0x9f,
1049 0x58, 0xf0, 0x7e, 0x53, 0x81, 0x6c, 0x8f, 0xae, 0xcc, 0xde, 0x4b, 0x43, 0xa9, 0x9c, 0x57, 0xca,
1050 0x3f, 0x7d, 0x9b, 0xdf, 0x85, 0xc4, 0x6e, 0xa3, 0x65, 0x75, 0xd0, 0x4c, 0x80, 0x3e, 0x10, 0x95,
1051 0xd9, 0x66, 0x0e, 0x69, 0x62, 0x7d, 0x44, 0x39, 0xa1, 0x6f, 0x59, 0xcf, 0x42, 0x7c, 0xd5, 0xf4,
1052 0x4c, 0xac, 0x41, 0xc6, 0x1f, 0x5f, 0x4d, 0xcf, 0xcc, 0x5d, 0x81, 0xcc, 0xe6, 0x31, 0x3e, 0x88,
1053 0x54, 0xc7, 0x67, 0x50, 0xc4, 0xea, 0x8f, 0xd5, 0xab, 0x97, 0x17, 0x12, 0xc9, 0xba, 0x76, 0x4f,
1054 0xc9, 0xc7, 0xb1, 0x3e, 0xaf, 0xc2, 0xf8, 0x16, 0x52, 0x1b, 0xe3, 0x30, 0xec, 0x1c, 0x28, 0x9b,
1055 0x62, 0x21, 0xc4, 0xb3, 0x1a, 0xca, 0xa6, 0x54, 0x3e, 0xaa, 0xbe, 0x79, 0xa4, 0xb2, 0x4d, 0xf5,
1056 0xcb, 0xb6, 0x85, 0x78, 0x72, 0x5c, 0x9b, 0x5c, 0x88, 0x27, 0x41, 0x1b, 0xa3, 0xf7, 0xfd, 0x77,
1057 0x2a, 0x68, 0xa4, 0xd4, 0x59, 0xb5, 0x0e, 0x1a, 0x76, 0xc3, 0xeb, 0xad, 0x57, 0x7d, 0x8d, 0xf5,
1058 0xe7, 0x20, 0x85, 0x4c, 0xba, 0x46, 0x7f, 0x12, 0x10, 0x99, 0xfe, 0x3c, 0x2d, 0x51, 0x24, 0x0a,
1059 0xda, 0x80, 0x43, 0x27, 0xc0, 0xe8, 0x6b, 0xa0, 0x56, 0x2a, 0x9b, 0x74, 0x72, 0x5b, 0x19, 0x08,
1060 0xa5, 0x87, 0x7d, 0xe8, 0x15, 0x6d, 0x73, 0x0f, 0x0d, 0x44, 0xa0, 0xaf, 0x40, 0xac, 0xb2, 0x49,
1061 0x0b, 0xde, 0x0b, 0xc3, 0xd0, 0x18, 0xb1, 0xca, 0xe6, 0xcc, 0xbf, 0x52, 0x60, 0x4c, 0x68, 0xd5,
1062 0x73, 0x90, 0x21, 0x0d, 0xdc, 0xe3, 0x8e, 0x18, 0x42, 0x1b, 0xd3, 0x39, 0xf6, 0x3e, 0x75, 0x9e,
1063 0x29, 0xc0, 0x84, 0xd4, 0xae, 0x2f, 0x82, 0xce, 0x37, 0x51, 0x25, 0xc8, 0xcf, 0x91, 0x85, 0xf4,
1064 0xe4, 0x1e, 0x05, 0x08, 0xec, 0xea, 0xff, 0x8a, 0x56, 0xa5, 0xbc, 0xb3, 0x5b, 0x5e, 0xd5, 0x94,
1065 0xdc, 0xd7, 0x15, 0x48, 0xd3, 0xb2, 0xb5, 0xe6, 0xb4, 0x2d, 0xbd, 0x08, 0x4a, 0x81, 0x46, 0xd0,
1066 0x83, 0xe9, 0xad, 0x14, 0xf4, 0x4b, 0xa0, 0x14, 0x87, 0x77, 0xb5, 0x52, 0xd4, 0x97, 0x41, 0x29,
1067 0x51, 0x07, 0x0f, 0xe7, 0x19, 0xa5, 0x94, 0xfb, 0x63, 0x15, 0xa6, 0xf8, 0x32, 0x9a, 0x8d, 0x27,
1068 0xe7, 0xc5, 0xf7, 0xa6, 0x7c, 0xea, 0xf2, 0xf2, 0x95, 0x95, 0x45, 0xf4, 0x8f, 0x1f, 0x92, 0x39,
1069 0xf1, 0x15, 0x2a, 0x0f, 0xbe, 0xc8, 0xe5, 0x7e, 0xe7, 0x44, 0xf2, 0x71, 0x8e, 0xa1, 0xe7, 0x9c,
1070 0x88, 0xd0, 0xdb, 0x73, 0x4e, 0x44, 0xe8, 0xed, 0x39, 0x27, 0x22, 0xf4, 0xf6, 0xec, 0x05, 0x08,
1071 0xbd, 0x3d, 0xe7, 0x44, 0x84, 0xde, 0x9e, 0x73, 0x22, 0x42, 0x6f, 0xef, 0x39, 0x11, 0xda, 0xdd,
1072 0xf7, 0x9c, 0x88, 0xd8, 0xdf, 0x7b, 0x4e, 0x44, 0xec, 0xef, 0x3d, 0x27, 0x92, 0x8f, 0x7b, 0x9d,
1073 0xae, 0xd5, 0x7f, 0xd7, 0x41, 0xc4, 0x0f, 0x7a, 0x09, 0x0c, 0x46, 0xe0, 0x2d, 0x98, 0x20, 0x0b,
1074 0x12, 0x25, 0xc7, 0xf6, 0xcc, 0x86, 0x6d, 0x75, 0xf4, 0x8f, 0x42, 0x86, 0x34, 0x91, 0xd7, 0x9c,
1075 0xb0, 0xd7, 0x40, 0xd2, 0x4f, 0xc7, 0x5b, 0x41, 0x3a, 0xf7, 0x27, 0x71, 0x98, 0x26, 0x0d, 0x15,
1076 0xb3, 0x65, 0x09, 0xa7, 0x8c, 0x2e, 0x4a, 0x7b, 0x4a, 0xe3, 0x08, 0x7e, 0xff, 0x9d, 0x39, 0xd2,
1077 0x5a, 0xf0, 0xa3, 0xe9, 0xa2, 0xb4, 0xbb, 0x24, 0xca, 0x05, 0x13, 0xd0, 0x45, 0xe9, 0xe4, 0x91,
1078 0x28, 0xe7, 0xcf, 0x37, 0xbe, 0x1c, 0x3b, 0x83, 0x24, 0xca, 0xad, 0xfa, 0x51, 0x76, 0x51, 0x3a,
1079 0x8d, 0x24, 0xca, 0x95, 0xfd, 0x78, 0xbb, 0x28, 0xed, 0x3d, 0x89, 0x72, 0x6b, 0x7e, 0xe4, 0x5d,
1080 0x94, 0x76, 0xa1, 0x44, 0xb9, 0xdb, 0x7e, 0x0c, 0x5e, 0x94, 0xce, 0x2a, 0x89, 0x72, 0xcf, 0xfb,
1081 0xd1, 0x78, 0x51, 0x3a, 0xb5, 0x24, 0xca, 0xad, 0xfb, 0x71, 0x39, 0x2f, 0x9f, 0x5f, 0x12, 0x05,
1082 0xef, 0x04, 0x11, 0x3a, 0x2f, 0x9f, 0x64, 0x12, 0x25, 0x3f, 0x16, 0xc4, 0xea, 0xbc, 0x7c, 0xa6,
1083 0x49, 0x94, 0xdc, 0x08, 0xa2, 0x76, 0x5e, 0xde, 0x2b, 0x13, 0x25, 0x37, 0x83, 0xf8, 0x9d, 0x97,
1084 0x77, 0xcd, 0x44, 0xc9, 0x4a, 0x10, 0xc9, 0xf3, 0xf2, 0xfe, 0x99, 0x28, 0xb9, 0x15, 0x2c, 0xa2,
1085 0xff, 0xa1, 0x14, 0x7e, 0xdc, 0x29, 0xa8, 0x9c, 0x14, 0x7e, 0x10, 0x12, 0x7a, 0xd2, 0x40, 0xc6,
1086 0xc9, 0x04, 0x61, 0x97, 0x93, 0xc2, 0x0e, 0x42, 0x42, 0x2e, 0x27, 0x85, 0x1c, 0x84, 0x84, 0x5b,
1087 0x4e, 0x0a, 0x37, 0x08, 0x09, 0xb5, 0x9c, 0x14, 0x6a, 0x10, 0x12, 0x66, 0x39, 0x29, 0xcc, 0x20,
1088 0x24, 0xc4, 0x72, 0x52, 0x88, 0x41, 0x48, 0x78, 0xe5, 0xa4, 0xf0, 0x82, 0x90, 0xd0, 0xba, 0x20,
1089 0x87, 0x16, 0x84, 0x85, 0xd5, 0x05, 0x39, 0xac, 0x20, 0x2c, 0xa4, 0x1e, 0x93, 0x43, 0x2a, 0x75,
1090 0xff, 0x9d, 0xb9, 0x04, 0x6a, 0xe2, 0xa2, 0xe9, 0x82, 0x1c, 0x4d, 0x10, 0x16, 0x49, 0x17, 0xe4,
1091 0x48, 0x82, 0xb0, 0x28, 0xba, 0x20, 0x47, 0x11, 0x84, 0x45, 0xd0, 0xdb, 0x72, 0x04, 0x05, 0x67,
1092 0x7c, 0x72, 0xd2, 0x96, 0x62, 0x54, 0x04, 0xa9, 0x43, 0x44, 0x90, 0x3a, 0x44, 0x04, 0xa9, 0x43,
1093 0x44, 0x90, 0x3a, 0x44, 0x04, 0xa9, 0x43, 0x44, 0x90, 0x3a, 0x44, 0x04, 0xa9, 0x43, 0x44, 0x90,
1094 0x3a, 0x4c, 0x04, 0xa9, 0x43, 0x45, 0x90, 0xda, 0x2f, 0x82, 0x2e, 0xc8, 0x27, 0x1e, 0x20, 0x6c,
1095 0x40, 0xba, 0x20, 0x6f, 0x7d, 0x46, 0x87, 0x90, 0x3a, 0x54, 0x08, 0xa9, 0xfd, 0x42, 0xe8, 0x0f,
1096 0x55, 0x98, 0x12, 0x42, 0x88, 0xee, 0x0f, 0x7d, 0x50, 0x23, 0xd0, 0xb5, 0x21, 0x0e, 0x58, 0x84,
1097 0xc5, 0xd4, 0xb5, 0x21, 0x36, 0xa9, 0x07, 0xc5, 0x59, 0xef, 0x28, 0x54, 0x1e, 0x62, 0x14, 0x5a,
1098 0xf3, 0x63, 0xe8, 0xda, 0x10, 0x07, 0x2f, 0x7a, 0x63, 0xef, 0xc6, 0xa0, 0x41, 0xe0, 0xf9, 0xa1,
1099 0x06, 0x81, 0xf5, 0xa1, 0x06, 0x81, 0x3b, 0x81, 0x07, 0x7f, 0x39, 0x06, 0xa7, 0x03, 0x0f, 0x92,
1100 0x4f, 0xf8, 0x97, 0xb5, 0x72, 0xdc, 0x16, 0x95, 0xce, 0xb6, 0x6d, 0x38, 0x37, 0xc6, 0xd6, 0xeb,
1101 0xfa, 0xb6, 0xb8, 0x59, 0x95, 0x3f, 0xe9, 0x06, 0x0e, 0xe7, 0x71, 0xba, 0x18, 0x7a, 0x01, 0xd4,
1102 0xf5, 0xba, 0x8b, 0x47, 0x8b, 0xb0, 0xdb, 0x96, 0x0c, 0xd4, 0xad, 0x1b, 0x30, 0x82, 0xc5, 0x5d,
1103 0xec, 0xde, 0xf7, 0x73, 0xe3, 0x55, 0x83, 0x32, 0xe5, 0xde, 0x56, 0xe0, 0x9c, 0x10, 0xca, 0x1f,
1104 0xcc, 0x96, 0xc1, 0xad, 0xa1, 0xb6, 0x0c, 0x84, 0x04, 0x09, 0xb6, 0x0f, 0x9e, 0xe8, 0xdd, 0xa9,
1105 0xe6, 0xb3, 0x44, 0xde, 0x4a, 0xf8, 0x73, 0x30, 0x1e, 0x3c, 0x01, 0x7e, 0x67, 0xbb, 0x1a, 0xbd,
1106 0x9a, 0x19, 0x96, 0x9a, 0x57, 0xa5, 0x55, 0xb4, 0x81, 0x30, 0x3f, 0x5b, 0x73, 0x79, 0x98, 0xa8,
1107 0x88, 0x5f, 0x89, 0x8a, 0x5a, 0x8c, 0x48, 0xa2, 0xd2, 0xfc, 0xde, 0x97, 0xe6, 0x4e, 0xe5, 0x9e,
1108 0x82, 0x0c, 0xff, 0xad, 0x27, 0x09, 0x98, 0x62, 0xc0, 0x7c, 0xfc, 0x5b, 0x48, 0xfa, 0xef, 0x2a,
1109 0x70, 0x86, 0x17, 0x7f, 0xa1, 0xe1, 0x1d, 0xad, 0xdb, 0xa8, 0xa6, 0x7f, 0x06, 0x92, 0x16, 0x75,
1110 0x1c, 0xfd, 0x91, 0x1c, 0xfa, 0x1e, 0x19, 0x2a, 0xbe, 0x88, 0xff, 0x35, 0x7c, 0x88, 0xb4, 0xc6,
1111 0xc1, 0x6e, 0xbb, 0x3c, 0xf3, 0x38, 0x24, 0x08, 0xbf, 0xa8, 0xd7, 0x98, 0xa4, 0xd7, 0x6f, 0x86,
1112 0xe8, 0x85, 0xe3, 0x48, 0xbf, 0x23, 0xe8, 0xc5, 0xbd, 0xae, 0x86, 0x8a, 0x2f, 0xb2, 0xe0, 0x2b,
1113 0x26, 0x51, 0xfd, 0x87, 0x23, 0x2a, 0x5a, 0xc9, 0x79, 0x48, 0x96, 0x65, 0x99, 0x70, 0x3d, 0x57,
1114 0x21, 0x5e, 0x71, 0xea, 0xf8, 0xe7, 0x7b, 0xf0, 0x0f, 0x61, 0x53, 0x23, 0xd3, 0x5f, 0xc5, 0xbe,
1115 0x08, 0xc9, 0xd2, 0x51, 0xa3, 0x59, 0xef, 0x58, 0x36, 0xdd, 0xb3, 0xa7, 0x4b, 0xe8, 0x08, 0x63,
1116 0xf8, 0x7d, 0xb9, 0x12, 0x4c, 0x56, 0x1c, 0xbb, 0x78, 0xec, 0xf1, 0xe3, 0xc6, 0xa2, 0x94, 0x22,
1117 0x74, 0xcf, 0x07, 0x7f, 0x4b, 0x04, 0x09, 0x14, 0x13, 0xdf, 0x7e, 0x67, 0x4e, 0xd9, 0xf5, 0xd7,
1118 0xcf, 0x37, 0xe1, 0x21, 0x9a, 0x3e, 0x3d, 0x54, 0xcb, 0x51, 0x54, 0x29, 0xba, 0x4f, 0xcd, 0xd1,
1119 0xad, 0x23, 0x3a, 0x3b, 0x94, 0xee, 0xc1, 0x34, 0x43, 0x45, 0xd1, 0x40, 0xcd, 0xd4, 0x13, 0x69,
1120 0x16, 0x4a, 0xb7, 0x18, 0x45, 0x27, 0x69, 0xf6, 0x18, 0xa4, 0xfc, 0x3e, 0x2e, 0x1a, 0xf8, 0x4c,
1121 0x59, 0x5e, 0xc8, 0x41, 0x9a, 0x4b, 0x58, 0x3d, 0x01, 0x4a, 0x41, 0x3b, 0x85, 0xfe, 0x2b, 0x6a,
1122 0x0a, 0xfa, 0xaf, 0xa4, 0xc5, 0x16, 0x1e, 0x87, 0x09, 0x69, 0xfd, 0x12, 0xf5, 0xac, 0x6a, 0x80,
1123 0xfe, 0x2b, 0x6b, 0xe9, 0x99, 0xf8, 0xa7, 0x7f, 0x63, 0xf6, 0xd4, 0xc2, 0x2d, 0xd0, 0x7b, 0x57,
1124 0x3a, 0xf5, 0x11, 0x88, 0x15, 0x10, 0xe5, 0x43, 0x10, 0x2b, 0x16, 0x35, 0x65, 0x66, 0xe2, 0x2f,
1125 0x7f, 0xfe, 0x5c, 0xba, 0x88, 0xbf, 0xd2, 0x7d, 0xd7, 0xf2, 0x8a, 0x45, 0x0a, 0x7e, 0x16, 0xce,
1126 0x84, 0xae, 0x94, 0x22, 0x7c, 0xa9, 0x44, 0xf0, 0xab, 0xab, 0x3d, 0xf8, 0xd5, 0x55, 0x8c, 0x57,
1127 0xf2, 0x6c, 0xc7, 0xb9, 0xa0, 0x87, 0xac, 0x4b, 0x66, 0xeb, 0xdc, 0x0e, 0x77, 0x21, 0xff, 0x2c,
1128 0x95, 0x2d, 0x86, 0xca, 0x5a, 0x11, 0x3b, 0xd6, 0xc5, 0x7c, 0x89, 0xe2, 0x4b, 0xa1, 0xf8, 0x03,
1129 0x69, 0x5b, 0x55, 0x9c, 0x21, 0x28, 0x49, 0xc9, 0x57, 0x78, 0x35, 0x94, 0xe4, 0x88, 0x3b, 0xec,
1130 0xbe, 0xea, 0x2b, 0x5c, 0x0e, 0x95, 0x6d, 0x44, 0x1c, 0xfa, 0x2a, 0xe7, 0x2f, 0xd1, 0x49, 0xbe,
1131 0x70, 0x59, 0x3f, 0xc3, 0x72, 0x54, 0x18, 0x81, 0xa9, 0x81, 0x98, 0x54, 0xbe, 0x44, 0x01, 0xc5,
1132 0xbe, 0x80, 0xfe, 0x56, 0x62, 0xc8, 0xfc, 0xf3, 0x94, 0xa4, 0xd4, 0x97, 0x24, 0xc2, 0x54, 0x0c,
1133 0x5e, 0xdc, 0xbd, 0xf7, 0xee, 0xec, 0xa9, 0x6f, 0xbd, 0x3b, 0x7b, 0xea, 0x3f, 0xbd, 0x3b, 0x7b,
1134 0xea, 0x3b, 0xef, 0xce, 0x2a, 0xdf, 0x7f, 0x77, 0x56, 0xf9, 0xe1, 0xbb, 0xb3, 0xca, 0x8f, 0xde,
1135 0x9d, 0x55, 0xde, 0xbc, 0x3f, 0xab, 0x7c, 0xe5, 0xfe, 0xac, 0xf2, 0xd5, 0xfb, 0xb3, 0xca, 0xef,
1136 0xdf, 0x9f, 0x55, 0xde, 0xbe, 0x3f, 0xab, 0xdc, 0xbb, 0x3f, 0xab, 0x7c, 0xeb, 0xfe, 0xac, 0xf2,
1137 0x9d, 0xfb, 0xb3, 0xca, 0xf7, 0xef, 0xcf, 0x9e, 0xfa, 0xe1, 0xfd, 0x59, 0xe5, 0x47, 0xf7, 0x67,
1138 0x4f, 0xbd, 0xf9, 0xdd, 0xd9, 0x53, 0x6f, 0x7d, 0x77, 0xf6, 0xd4, 0x57, 0xbe, 0x3b, 0xab, 0xc0,
1139 0x77, 0x56, 0xe0, 0x11, 0xe9, 0x9b, 0x64, 0xb8, 0x1a, 0xb8, 0xc2, 0x7e, 0xfe, 0xcb, 0x6f, 0x38,
1140 0xe1, 0x17, 0xca, 0x66, 0x1e, 0xf4, 0xeb, 0x6b, 0xb9, 0x7f, 0x9d, 0x80, 0x51, 0xb6, 0x0c, 0x1c,
1141 0xf6, 0x23, 0xe9, 0x57, 0x21, 0x79, 0xd4, 0x68, 0x9a, 0x9d, 0x86, 0x77, 0x4c, 0xd7, 0x3f, 0x1f,
1142 0x5e, 0x0c, 0xd4, 0x66, 0x2b, 0xa6, 0xcf, 0x77, 0x5b, 0x4e, 0xb7, 0x63, 0xf8, 0xa2, 0xfa, 0x39,
1143 0xc8, 0x1c, 0x59, 0x8d, 0xc3, 0x23, 0xaf, 0xda, 0xb0, 0xab, 0xb5, 0x16, 0x2e, 0x93, 0xc7, 0x0c,
1144 0x20, 0x6d, 0xeb, 0x76, 0xa9, 0x85, 0x6e, 0x56, 0x37, 0x3d, 0x13, 0xbf, 0x9e, 0x67, 0x0c, 0xfc,
1145 0x19, 0xff, 0xd0, 0xb1, 0xe5, 0x76, 0x9b, 0x5e, 0xb5, 0xe6, 0x74, 0x6d, 0x0f, 0x17, 0xb2, 0xaa,
1146 0x91, 0x26, 0x6d, 0x25, 0xd4, 0xa4, 0x3f, 0x06, 0x63, 0x5e, 0xa7, 0x6b, 0x55, 0xdd, 0x9a, 0xe3,
1147 0xb9, 0x2d, 0xd3, 0xc6, 0x85, 0x6c, 0xd2, 0xc8, 0xa0, 0xc6, 0x1d, 0xda, 0x86, 0x7f, 0x5f, 0xbf,
1148 0xe6, 0x74, 0x2c, 0xfc, 0x1e, 0x1d, 0x33, 0xc8, 0x85, 0xae, 0x81, 0xfa, 0x8a, 0x75, 0x8c, 0xdf,
1149 0xd4, 0xe2, 0x06, 0xfa, 0xa8, 0x3f, 0x09, 0x23, 0xe4, 0x0f, 0xe4, 0xe0, 0xb2, 0x1a, 0xef, 0x5a,
1150 0xfb, 0x8f, 0x46, 0x56, 0x67, 0x0d, 0x2a, 0xa0, 0xdf, 0x84, 0x51, 0xcf, 0xea, 0x74, 0xcc, 0x86,
1151 0x8d, 0xdf, 0x9a, 0xd2, 0xcb, 0x73, 0x21, 0x66, 0xd8, 0x25, 0x12, 0xf8, 0xe7, 0x80, 0x0d, 0x26,
1152 0xaf, 0x5f, 0x85, 0x0c, 0x96, 0x5b, 0xae, 0x92, 0x3f, 0x22, 0x94, 0xee, 0x1b, 0xc8, 0x69, 0x22,
1153 0xc7, 0x36, 0x09, 0x18, 0x8c, 0xfc, 0x14, 0xe2, 0x18, 0xbe, 0xed, 0x63, 0x21, 0xb7, 0xc5, 0x63,
1154 0xee, 0x32, 0xae, 0x17, 0xc9, 0xad, 0x29, 0x0f, 0xf9, 0xb1, 0xc4, 0x4d, 0xc8, 0xf0, 0x7a, 0x31,
1155 0x33, 0x90, 0xba, 0x07, 0x9b, 0xe1, 0x89, 0xe0, 0x0f, 0x34, 0xf4, 0xb1, 0x02, 0xe9, 0xcf, 0xc7,
1156 0x6e, 0x28, 0x33, 0xdb, 0xa0, 0xc9, 0xf7, 0x0b, 0xa1, 0xbc, 0x28, 0x52, 0x6a, 0xfc, 0xc3, 0xe2,
1157 0x25, 0xf2, 0x80, 0x31, 0xf7, 0x1c, 0x8c, 0x90, 0xf8, 0xd1, 0xd3, 0x30, 0x1a, 0xfc, 0xca, 0x66,
1158 0x12, 0xe2, 0xdb, 0x7b, 0x95, 0x1d, 0xf2, 0x73, 0xb9, 0x3b, 0x1b, 0x85, 0xed, 0x9d, 0xdd, 0xf5,
1159 0xd2, 0xc7, 0xb4, 0x98, 0x3e, 0x01, 0xe9, 0xe2, 0xfa, 0xc6, 0x46, 0xb5, 0x58, 0x58, 0xdf, 0x28,
1160 0xdf, 0xd5, 0xd4, 0xdc, 0x2c, 0x8c, 0x10, 0x3d, 0xf1, 0xcf, 0xfe, 0x75, 0x6d, 0xfb, 0x98, 0xd5,
1161 0x0d, 0xf8, 0x22, 0xf7, 0x35, 0x1d, 0x46, 0x0b, 0xcd, 0xe6, 0xa6, 0xd9, 0x76, 0xf5, 0x17, 0x60,
1162 0x92, 0xfc, 0x20, 0xc7, 0xae, 0xb3, 0x8a, 0x7f, 0x9d, 0x12, 0x8d, 0x0a, 0x0a, 0xfd, 0xc3, 0x14,
1163 0xc1, 0x73, 0x53, 0xf1, 0xc5, 0x1e, 0x59, 0x62, 0xe0, 0x5e, 0x0e, 0x7d, 0x17, 0x34, 0xd6, 0xb8,
1164 0xd6, 0x74, 0x4c, 0x0f, 0xf1, 0xc6, 0xe8, 0x8f, 0x47, 0xf6, 0xe7, 0x65, 0xa2, 0x84, 0xb6, 0x87,
1165 0x41, 0xff, 0x28, 0x24, 0xd7, 0x6d, 0xef, 0xca, 0x32, 0x62, 0x63, 0x7f, 0xf4, 0xa9, 0x97, 0x8d,
1166 0x89, 0x10, 0x16, 0x1f, 0x41, 0xd1, 0xd7, 0x56, 0x10, 0x3a, 0x3e, 0x08, 0x8d, 0x45, 0x02, 0x34,
1167 0xbe, 0xd4, 0x9f, 0x83, 0x14, 0x7a, 0x2d, 0x21, 0x37, 0x4f, 0xb0, 0x9a, 0xb5, 0x07, 0xee, 0xcb,
1168 0x10, 0x7c, 0x80, 0x61, 0x04, 0xe4, 0xfe, 0x23, 0x03, 0x09, 0x38, 0x05, 0x02, 0x0c, 0x22, 0xd8,
1169 0xf1, 0x35, 0x18, 0xed, 0x4b, 0xb0, 0x23, 0x69, 0xb0, 0xc3, 0x6b, 0xb0, 0xe3, 0x6b, 0x90, 0x1c,
1170 0x48, 0xc0, 0x6b, 0xe0, 0x5f, 0xeb, 0x45, 0x80, 0xb5, 0xc6, 0xeb, 0x56, 0x9d, 0xa8, 0x40, 0xfe,
1171 0x24, 0x54, 0x2e, 0x84, 0x21, 0x10, 0x22, 0x14, 0x1c, 0x4a, 0x2f, 0x43, 0x7a, 0xe7, 0x20, 0x20,
1172 0x81, 0x9e, 0x3c, 0xf6, 0xd5, 0x38, 0x90, 0x58, 0x78, 0x9c, 0xaf, 0x0a, 0x79, 0x98, 0xf4, 0x60,
1173 0x55, 0xb8, 0xa7, 0xe1, 0x50, 0x81, 0x2a, 0x84, 0x24, 0x13, 0xa1, 0x0a, 0xc7, 0xc2, 0xe3, 0xd0,
1174 0x60, 0x58, 0x74, 0x1c, 0x24, 0x49, 0x47, 0xa5, 0xb9, 0x10, 0x0a, 0x2a, 0x41, 0x07, 0x43, 0x7a,
1175 0x85, 0x3d, 0x82, 0x83, 0x1c, 0x81, 0xc7, 0xfb, 0x7b, 0x84, 0xc9, 0x30, 0x8f, 0xb0, 0x6b, 0x3e,
1176 0xcf, 0xf0, 0x51, 0x56, 0xc4, 0x33, 0x11, 0x99, 0x67, 0x4c, 0x54, 0xca, 0x33, 0xd6, 0xac, 0x7f,
1177 0x1c, 0x26, 0x58, 0x1b, 0x1a, 0x9e, 0x10, 0xa9, 0x46, 0xff, 0x68, 0x5e, 0x7f, 0x52, 0x2a, 0x49,
1178 0x38, 0x65, 0xbc, 0x5e, 0x81, 0x71, 0xd6, 0xb4, 0xe9, 0xe2, 0xc7, 0x9d, 0xa4, 0x7f, 0x0f, 0xa5,
1179 0x3f, 0x23, 0x11, 0x24, 0x84, 0x12, 0x7a, 0x66, 0x15, 0xa6, 0xc3, 0x47, 0x23, 0x7e, 0xf8, 0x4d,
1180 0x91, 0xe1, 0xf7, 0x34, 0x3f, 0xfc, 0x2a, 0xfc, 0xf0, 0x5d, 0x82, 0x33, 0xa1, 0x63, 0x4f, 0x14,
1181 0x49, 0x8c, 0x27, 0xb9, 0x05, 0x63, 0xc2, 0x90, 0xc3, 0x83, 0x13, 0x21, 0xe0, 0x44, 0x2f, 0x38,
1182 0x08, 0xad, 0x90, 0xd9, 0x43, 0x00, 0xab, 0x3c, 0xf8, 0xa3, 0x30, 0x2e, 0x8e, 0x37, 0x3c, 0x7a,
1183 0x2c, 0x04, 0x3d, 0x16, 0x82, 0x0e, 0xbf, 0x77, 0x3c, 0x04, 0x1d, 0x97, 0xd0, 0x3b, 0x7d, 0xef,
1184 0x3d, 0x19, 0x82, 0x9e, 0x0c, 0x41, 0x87, 0xdf, 0x5b, 0x0f, 0x41, 0xeb, 0x3c, 0xfa, 0x19, 0x98,
1185 0x90, 0x86, 0x18, 0x1e, 0x3e, 0x1a, 0x02, 0x1f, 0xe5, 0xe1, 0xcf, 0x82, 0x26, 0x0f, 0x2e, 0x3c,
1186 0x7e, 0x22, 0x04, 0x3f, 0x11, 0x76, 0xfb, 0x70, 0xed, 0x47, 0x42, 0xe0, 0x23, 0xa1, 0xb7, 0x0f,
1187 0xc7, 0x6b, 0x21, 0x78, 0x8d, 0xc7, 0xe7, 0x21, 0xc3, 0x8f, 0x26, 0x3c, 0x36, 0x19, 0x82, 0x4d,
1188 0xca, 0x76, 0x17, 0x06, 0x93, 0xa8, 0x48, 0x4f, 0xf5, 0x49, 0x17, 0x61, 0x08, 0x89, 0x22, 0xc9,
1189 0xf0, 0x24, 0x9f, 0x80, 0xd3, 0x61, 0x43, 0x46, 0x08, 0xc7, 0x3c, 0xcf, 0x31, 0x8e, 0x6a, 0xc4,
1190 0xa0, 0xd8, 0x33, 0xdb, 0x52, 0xe1, 0x34, 0xf3, 0x12, 0x4c, 0x85, 0x0c, 0x1c, 0x21, 0xb4, 0x8b,
1191 0x62, 0x35, 0x96, 0xe5, 0x68, 0xf1, 0x20, 0xd0, 0xb0, 0x0f, 0xb7, 0x9d, 0x86, 0xed, 0xf1, 0x55,
1192 0xd9, 0xd7, 0xa7, 0x60, 0x9c, 0x0e, 0x4f, 0x5b, 0x9d, 0xba, 0xd5, 0xb1, 0xea, 0xfa, 0x9f, 0xe9,
1193 0x5f, 0x3b, 0x2d, 0xf5, 0x0e, 0x6a, 0x14, 0x75, 0x82, 0x12, 0xea, 0xa5, 0xbe, 0x25, 0xd4, 0xa5,
1194 0x68, 0xfa, 0xa8, 0x4a, 0xaa, 0xd4, 0x53, 0x49, 0x3d, 0xd1, 0x9f, 0xb4, 0x5f, 0x41, 0x55, 0xea,
1195 0x29, 0xa8, 0x06, 0x93, 0x84, 0xd6, 0x55, 0x6b, 0xbd, 0x75, 0xd5, 0x7c, 0x7f, 0x96, 0xfe, 0xe5,
1196 0xd5, 0x5a, 0x6f, 0x79, 0x15, 0xc1, 0x13, 0x5e, 0x65, 0xad, 0xf5, 0x56, 0x59, 0x03, 0x78, 0xfa,
1197 0x17, 0x5b, 0x6b, 0xbd, 0xc5, 0x56, 0x04, 0x4f, 0x78, 0xcd, 0xb5, 0x1e, 0x52, 0x73, 0x3d, 0xd9,
1198 0x9f, 0x68, 0x50, 0xe9, 0xb5, 0x11, 0x56, 0x7a, 0x2d, 0x0c, 0x50, 0x6a, 0x60, 0x05, 0xb6, 0x1e,
1199 0x52, 0x81, 0x45, 0x29, 0xd6, 0xa7, 0x10, 0xdb, 0x08, 0x2b, 0xc4, 0x22, 0x15, 0xeb, 0x57, 0x8f,
1200 0xfd, 0x82, 0x5c, 0x8f, 0x5d, 0xec, 0xcf, 0x14, 0x5e, 0x96, 0xad, 0xf5, 0x96, 0x65, 0xf3, 0x51,
1201 0x39, 0x17, 0x56, 0x9d, 0xbd, 0xd4, 0xb7, 0x3a, 0x1b, 0x22, 0x85, 0xa3, 0x8a, 0xb4, 0x17, 0xfb,
1202 0x15, 0x69, 0x8b, 0xd1, 0xdc, 0x83, 0x6b, 0xb5, 0xbd, 0x3e, 0xb5, 0xda, 0xd3, 0xd1, 0xc4, 0x3f,
1203 0x2f, 0xd9, 0x7e, 0x5e, 0xb2, 0xfd, 0xbc, 0x64, 0xfb, 0x79, 0xc9, 0xf6, 0xd3, 0x2f, 0xd9, 0xf2,
1204 0xf1, 0xcf, 0x7c, 0x69, 0x4e, 0xc9, 0xfd, 0x47, 0xd5, 0xff, 0x4b, 0x6b, 0x2f, 0x34, 0xbc, 0x23,
1205 0x34, 0xbc, 0x6d, 0x42, 0x06, 0xff, 0xf2, 0x6f, 0xcb, 0x6c, 0xb7, 0x1b, 0xf6, 0x21, 0xad, 0xd9,
1206 0x16, 0x7a, 0x97, 0x12, 0x29, 0x00, 0xff, 0x95, 0x99, 0x4d, 0x22, 0x4c, 0xa7, 0x1b, 0x3b, 0x68,
1207 0xd1, 0xef, 0x40, 0xba, 0xe5, 0x1e, 0xfa, 0x6c, 0xb1, 0x9e, 0x89, 0x50, 0x62, 0x23, 0x4f, 0x1a,
1208 0x90, 0x41, 0xcb, 0x6f, 0x40, 0xaa, 0xed, 0x1f, 0x7b, 0x81, 0x6a, 0x6a, 0x94, 0x6a, 0xc8, 0xa7,
1209 0xa2, 0x6a, 0xfb, 0x41, 0x0b, 0x0a, 0x5b, 0x59, 0xf7, 0xa8, 0x91, 0x4e, 0x08, 0x9e, 0x17, 0x60,
1210 0x42, 0xd2, 0x36, 0x24, 0xe7, 0x1f, 0xc0, 0x37, 0x48, 0x31, 0x59, 0xf3, 0xa8, 0x9c, 0xe0, 0x03,
1211 0x32, 0xf7, 0x28, 0x8c, 0x09, 0xdc, 0x7a, 0x06, 0x94, 0x03, 0xfa, 0x3d, 0x4a, 0xe5, 0x20, 0xf7,
1212 0x45, 0x05, 0xd2, 0xf4, 0x0c, 0xc1, 0xb6, 0xd9, 0xe8, 0xe8, 0xcf, 0x43, 0xbc, 0xc9, 0xbe, 0xcb,
1213 0xf4, 0xa0, 0xdf, 0x9b, 0xc5, 0x0c, 0xfa, 0x1a, 0x24, 0x3a, 0xfe, 0x77, 0x9d, 0x1e, 0xe8, 0xcb,
1214 0xb0, 0x18, 0x9e, 0xbb, 0xa7, 0xc0, 0x24, 0x3d, 0xe2, 0xea, 0xd2, 0x93, 0xcf, 0x66, 0x7b, 0xe6,
1215 0x6b, 0x0a, 0xa4, 0xfc, 0x2b, 0x7d, 0x1f, 0xc6, 0xfd, 0x0b, 0x72, 0xba, 0x9e, 0x44, 0x6a, 0x9e,
1216 0xb3, 0x70, 0x0f, 0xc7, 0x62, 0xc8, 0x27, 0xb2, 0x0b, 0x45, 0xe6, 0x64, 0xb1, 0x71, 0xa6, 0x00,
1217 0x53, 0x21, 0x62, 0x27, 0x99, 0x90, 0x73, 0xe7, 0x21, 0x55, 0x71, 0x3c, 0xf2, 0x93, 0x39, 0xfa,
1218 0x69, 0x6e, 0x57, 0xa1, 0x18, 0xd3, 0x4e, 0x61, 0xf0, 0xc2, 0x79, 0x18, 0xa5, 0xd9, 0xaf, 0x8f,
1219 0x40, 0x6c, 0xb3, 0xa0, 0x9d, 0xc2, 0xff, 0x17, 0x35, 0x05, 0xff, 0x5f, 0xd2, 0x62, 0xc5, 0x8d,
1220 0x0f, 0x72, 0x8b, 0x69, 0x7f, 0x84, 0x98, 0xe7, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0xfc, 0x29,
1221 0xc0, 0x35, 0xbf, 0x83, 0x00, 0x00,
1222 }
1223 r := bytes.NewReader(gzipped)
1224 gzipr, err := compress_gzip.NewReader(r)
1225 if err != nil {
1226 panic(err)
1227 }
1228 ungzipped, err := io_ioutil.ReadAll(gzipr)
1229 if err != nil {
1230 panic(err)
1231 }
1232 if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
1233 panic(err)
1234 }
1235 return d
1236 }
1237 func (x MapEnum) String() string {
1238 s, ok := MapEnum_name[int32(x)]
1239 if ok {
1240 return s
1241 }
1242 return strconv.Itoa(int(x))
1243 }
1244 func (x Message_Humour) String() string {
1245 s, ok := Message_Humour_name[int32(x)]
1246 if ok {
1247 return s
1248 }
1249 return strconv.Itoa(int(x))
1250 }
1251 func (this *Message) VerboseEqual(that interface{}) error {
1252 if that == nil {
1253 if this == nil {
1254 return nil
1255 }
1256 return fmt.Errorf("that == nil && this != nil")
1257 }
1258
1259 that1, ok := that.(*Message)
1260 if !ok {
1261 that2, ok := that.(Message)
1262 if ok {
1263 that1 = &that2
1264 } else {
1265 return fmt.Errorf("that is not of type *Message")
1266 }
1267 }
1268 if that1 == nil {
1269 if this == nil {
1270 return nil
1271 }
1272 return fmt.Errorf("that is type *Message but is nil && this != nil")
1273 } else if this == nil {
1274 return fmt.Errorf("that is type *Message but is not nil && this == nil")
1275 }
1276 if this.Name != that1.Name {
1277 return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name)
1278 }
1279 if this.Hilarity != that1.Hilarity {
1280 return fmt.Errorf("Hilarity this(%v) Not Equal that(%v)", this.Hilarity, that1.Hilarity)
1281 }
1282 if this.HeightInCm != that1.HeightInCm {
1283 return fmt.Errorf("HeightInCm this(%v) Not Equal that(%v)", this.HeightInCm, that1.HeightInCm)
1284 }
1285 if !bytes.Equal(this.Data, that1.Data) {
1286 return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
1287 }
1288 if this.ResultCount != that1.ResultCount {
1289 return fmt.Errorf("ResultCount this(%v) Not Equal that(%v)", this.ResultCount, that1.ResultCount)
1290 }
1291 if this.TrueScotsman != that1.TrueScotsman {
1292 return fmt.Errorf("TrueScotsman this(%v) Not Equal that(%v)", this.TrueScotsman, that1.TrueScotsman)
1293 }
1294 if this.Score != that1.Score {
1295 return fmt.Errorf("Score this(%v) Not Equal that(%v)", this.Score, that1.Score)
1296 }
1297 if len(this.Key) != len(that1.Key) {
1298 return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key))
1299 }
1300 for i := range this.Key {
1301 if this.Key[i] != that1.Key[i] {
1302 return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i])
1303 }
1304 }
1305 if !this.Nested.Equal(that1.Nested) {
1306 return fmt.Errorf("Nested this(%v) Not Equal that(%v)", this.Nested, that1.Nested)
1307 }
1308 if len(this.Terrain) != len(that1.Terrain) {
1309 return fmt.Errorf("Terrain this(%v) Not Equal that(%v)", len(this.Terrain), len(that1.Terrain))
1310 }
1311 for i := range this.Terrain {
1312 if !this.Terrain[i].Equal(that1.Terrain[i]) {
1313 return fmt.Errorf("Terrain this[%v](%v) Not Equal that[%v](%v)", i, this.Terrain[i], i, that1.Terrain[i])
1314 }
1315 }
1316 if !this.Proto2Field.Equal(that1.Proto2Field) {
1317 return fmt.Errorf("Proto2Field this(%v) Not Equal that(%v)", this.Proto2Field, that1.Proto2Field)
1318 }
1319 if len(this.Proto2Value) != len(that1.Proto2Value) {
1320 return fmt.Errorf("Proto2Value this(%v) Not Equal that(%v)", len(this.Proto2Value), len(that1.Proto2Value))
1321 }
1322 for i := range this.Proto2Value {
1323 if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) {
1324 return fmt.Errorf("Proto2Value this[%v](%v) Not Equal that[%v](%v)", i, this.Proto2Value[i], i, that1.Proto2Value[i])
1325 }
1326 }
1327 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1328 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1329 }
1330 return nil
1331 }
1332 func (this *Message) Equal(that interface{}) bool {
1333 if that == nil {
1334 return this == nil
1335 }
1336
1337 that1, ok := that.(*Message)
1338 if !ok {
1339 that2, ok := that.(Message)
1340 if ok {
1341 that1 = &that2
1342 } else {
1343 return false
1344 }
1345 }
1346 if that1 == nil {
1347 return this == nil
1348 } else if this == nil {
1349 return false
1350 }
1351 if this.Name != that1.Name {
1352 return false
1353 }
1354 if this.Hilarity != that1.Hilarity {
1355 return false
1356 }
1357 if this.HeightInCm != that1.HeightInCm {
1358 return false
1359 }
1360 if !bytes.Equal(this.Data, that1.Data) {
1361 return false
1362 }
1363 if this.ResultCount != that1.ResultCount {
1364 return false
1365 }
1366 if this.TrueScotsman != that1.TrueScotsman {
1367 return false
1368 }
1369 if this.Score != that1.Score {
1370 return false
1371 }
1372 if len(this.Key) != len(that1.Key) {
1373 return false
1374 }
1375 for i := range this.Key {
1376 if this.Key[i] != that1.Key[i] {
1377 return false
1378 }
1379 }
1380 if !this.Nested.Equal(that1.Nested) {
1381 return false
1382 }
1383 if len(this.Terrain) != len(that1.Terrain) {
1384 return false
1385 }
1386 for i := range this.Terrain {
1387 if !this.Terrain[i].Equal(that1.Terrain[i]) {
1388 return false
1389 }
1390 }
1391 if !this.Proto2Field.Equal(that1.Proto2Field) {
1392 return false
1393 }
1394 if len(this.Proto2Value) != len(that1.Proto2Value) {
1395 return false
1396 }
1397 for i := range this.Proto2Value {
1398 if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) {
1399 return false
1400 }
1401 }
1402 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1403 return false
1404 }
1405 return true
1406 }
1407 func (this *Nested) VerboseEqual(that interface{}) error {
1408 if that == nil {
1409 if this == nil {
1410 return nil
1411 }
1412 return fmt.Errorf("that == nil && this != nil")
1413 }
1414
1415 that1, ok := that.(*Nested)
1416 if !ok {
1417 that2, ok := that.(Nested)
1418 if ok {
1419 that1 = &that2
1420 } else {
1421 return fmt.Errorf("that is not of type *Nested")
1422 }
1423 }
1424 if that1 == nil {
1425 if this == nil {
1426 return nil
1427 }
1428 return fmt.Errorf("that is type *Nested but is nil && this != nil")
1429 } else if this == nil {
1430 return fmt.Errorf("that is type *Nested but is not nil && this == nil")
1431 }
1432 if this.Bunny != that1.Bunny {
1433 return fmt.Errorf("Bunny this(%v) Not Equal that(%v)", this.Bunny, that1.Bunny)
1434 }
1435 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1436 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1437 }
1438 return nil
1439 }
1440 func (this *Nested) Equal(that interface{}) bool {
1441 if that == nil {
1442 return this == nil
1443 }
1444
1445 that1, ok := that.(*Nested)
1446 if !ok {
1447 that2, ok := that.(Nested)
1448 if ok {
1449 that1 = &that2
1450 } else {
1451 return false
1452 }
1453 }
1454 if that1 == nil {
1455 return this == nil
1456 } else if this == nil {
1457 return false
1458 }
1459 if this.Bunny != that1.Bunny {
1460 return false
1461 }
1462 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1463 return false
1464 }
1465 return true
1466 }
1467 func (this *AllMaps) VerboseEqual(that interface{}) error {
1468 if that == nil {
1469 if this == nil {
1470 return nil
1471 }
1472 return fmt.Errorf("that == nil && this != nil")
1473 }
1474
1475 that1, ok := that.(*AllMaps)
1476 if !ok {
1477 that2, ok := that.(AllMaps)
1478 if ok {
1479 that1 = &that2
1480 } else {
1481 return fmt.Errorf("that is not of type *AllMaps")
1482 }
1483 }
1484 if that1 == nil {
1485 if this == nil {
1486 return nil
1487 }
1488 return fmt.Errorf("that is type *AllMaps but is nil && this != nil")
1489 } else if this == nil {
1490 return fmt.Errorf("that is type *AllMaps but is not nil && this == nil")
1491 }
1492 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1493 return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap))
1494 }
1495 for i := range this.StringToDoubleMap {
1496 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1497 return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i])
1498 }
1499 }
1500 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1501 return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap))
1502 }
1503 for i := range this.StringToFloatMap {
1504 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1505 return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i])
1506 }
1507 }
1508 if len(this.Int32Map) != len(that1.Int32Map) {
1509 return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map))
1510 }
1511 for i := range this.Int32Map {
1512 if this.Int32Map[i] != that1.Int32Map[i] {
1513 return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i])
1514 }
1515 }
1516 if len(this.Int64Map) != len(that1.Int64Map) {
1517 return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map))
1518 }
1519 for i := range this.Int64Map {
1520 if this.Int64Map[i] != that1.Int64Map[i] {
1521 return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i])
1522 }
1523 }
1524 if len(this.Uint32Map) != len(that1.Uint32Map) {
1525 return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map))
1526 }
1527 for i := range this.Uint32Map {
1528 if this.Uint32Map[i] != that1.Uint32Map[i] {
1529 return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i])
1530 }
1531 }
1532 if len(this.Uint64Map) != len(that1.Uint64Map) {
1533 return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map))
1534 }
1535 for i := range this.Uint64Map {
1536 if this.Uint64Map[i] != that1.Uint64Map[i] {
1537 return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i])
1538 }
1539 }
1540 if len(this.Sint32Map) != len(that1.Sint32Map) {
1541 return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map))
1542 }
1543 for i := range this.Sint32Map {
1544 if this.Sint32Map[i] != that1.Sint32Map[i] {
1545 return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i])
1546 }
1547 }
1548 if len(this.Sint64Map) != len(that1.Sint64Map) {
1549 return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map))
1550 }
1551 for i := range this.Sint64Map {
1552 if this.Sint64Map[i] != that1.Sint64Map[i] {
1553 return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i])
1554 }
1555 }
1556 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1557 return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map))
1558 }
1559 for i := range this.Fixed32Map {
1560 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1561 return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i])
1562 }
1563 }
1564 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1565 return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map))
1566 }
1567 for i := range this.Sfixed32Map {
1568 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1569 return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i])
1570 }
1571 }
1572 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1573 return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map))
1574 }
1575 for i := range this.Fixed64Map {
1576 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1577 return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i])
1578 }
1579 }
1580 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1581 return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map))
1582 }
1583 for i := range this.Sfixed64Map {
1584 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1585 return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i])
1586 }
1587 }
1588 if len(this.BoolMap) != len(that1.BoolMap) {
1589 return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap))
1590 }
1591 for i := range this.BoolMap {
1592 if this.BoolMap[i] != that1.BoolMap[i] {
1593 return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i])
1594 }
1595 }
1596 if len(this.StringMap) != len(that1.StringMap) {
1597 return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap))
1598 }
1599 for i := range this.StringMap {
1600 if this.StringMap[i] != that1.StringMap[i] {
1601 return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i])
1602 }
1603 }
1604 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1605 return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap))
1606 }
1607 for i := range this.StringToBytesMap {
1608 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1609 return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i])
1610 }
1611 }
1612 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1613 return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap))
1614 }
1615 for i := range this.StringToEnumMap {
1616 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1617 return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i])
1618 }
1619 }
1620 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1621 return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap))
1622 }
1623 for i := range this.StringToMsgMap {
1624 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1625 return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i])
1626 }
1627 }
1628 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1629 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1630 }
1631 return nil
1632 }
1633 func (this *AllMaps) Equal(that interface{}) bool {
1634 if that == nil {
1635 return this == nil
1636 }
1637
1638 that1, ok := that.(*AllMaps)
1639 if !ok {
1640 that2, ok := that.(AllMaps)
1641 if ok {
1642 that1 = &that2
1643 } else {
1644 return false
1645 }
1646 }
1647 if that1 == nil {
1648 return this == nil
1649 } else if this == nil {
1650 return false
1651 }
1652 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1653 return false
1654 }
1655 for i := range this.StringToDoubleMap {
1656 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1657 return false
1658 }
1659 }
1660 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1661 return false
1662 }
1663 for i := range this.StringToFloatMap {
1664 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1665 return false
1666 }
1667 }
1668 if len(this.Int32Map) != len(that1.Int32Map) {
1669 return false
1670 }
1671 for i := range this.Int32Map {
1672 if this.Int32Map[i] != that1.Int32Map[i] {
1673 return false
1674 }
1675 }
1676 if len(this.Int64Map) != len(that1.Int64Map) {
1677 return false
1678 }
1679 for i := range this.Int64Map {
1680 if this.Int64Map[i] != that1.Int64Map[i] {
1681 return false
1682 }
1683 }
1684 if len(this.Uint32Map) != len(that1.Uint32Map) {
1685 return false
1686 }
1687 for i := range this.Uint32Map {
1688 if this.Uint32Map[i] != that1.Uint32Map[i] {
1689 return false
1690 }
1691 }
1692 if len(this.Uint64Map) != len(that1.Uint64Map) {
1693 return false
1694 }
1695 for i := range this.Uint64Map {
1696 if this.Uint64Map[i] != that1.Uint64Map[i] {
1697 return false
1698 }
1699 }
1700 if len(this.Sint32Map) != len(that1.Sint32Map) {
1701 return false
1702 }
1703 for i := range this.Sint32Map {
1704 if this.Sint32Map[i] != that1.Sint32Map[i] {
1705 return false
1706 }
1707 }
1708 if len(this.Sint64Map) != len(that1.Sint64Map) {
1709 return false
1710 }
1711 for i := range this.Sint64Map {
1712 if this.Sint64Map[i] != that1.Sint64Map[i] {
1713 return false
1714 }
1715 }
1716 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1717 return false
1718 }
1719 for i := range this.Fixed32Map {
1720 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1721 return false
1722 }
1723 }
1724 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1725 return false
1726 }
1727 for i := range this.Sfixed32Map {
1728 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1729 return false
1730 }
1731 }
1732 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1733 return false
1734 }
1735 for i := range this.Fixed64Map {
1736 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1737 return false
1738 }
1739 }
1740 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1741 return false
1742 }
1743 for i := range this.Sfixed64Map {
1744 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1745 return false
1746 }
1747 }
1748 if len(this.BoolMap) != len(that1.BoolMap) {
1749 return false
1750 }
1751 for i := range this.BoolMap {
1752 if this.BoolMap[i] != that1.BoolMap[i] {
1753 return false
1754 }
1755 }
1756 if len(this.StringMap) != len(that1.StringMap) {
1757 return false
1758 }
1759 for i := range this.StringMap {
1760 if this.StringMap[i] != that1.StringMap[i] {
1761 return false
1762 }
1763 }
1764 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1765 return false
1766 }
1767 for i := range this.StringToBytesMap {
1768 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1769 return false
1770 }
1771 }
1772 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1773 return false
1774 }
1775 for i := range this.StringToEnumMap {
1776 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1777 return false
1778 }
1779 }
1780 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1781 return false
1782 }
1783 for i := range this.StringToMsgMap {
1784 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1785 return false
1786 }
1787 }
1788 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1789 return false
1790 }
1791 return true
1792 }
1793 func (this *AllMapsOrdered) VerboseEqual(that interface{}) error {
1794 if that == nil {
1795 if this == nil {
1796 return nil
1797 }
1798 return fmt.Errorf("that == nil && this != nil")
1799 }
1800
1801 that1, ok := that.(*AllMapsOrdered)
1802 if !ok {
1803 that2, ok := that.(AllMapsOrdered)
1804 if ok {
1805 that1 = &that2
1806 } else {
1807 return fmt.Errorf("that is not of type *AllMapsOrdered")
1808 }
1809 }
1810 if that1 == nil {
1811 if this == nil {
1812 return nil
1813 }
1814 return fmt.Errorf("that is type *AllMapsOrdered but is nil && this != nil")
1815 } else if this == nil {
1816 return fmt.Errorf("that is type *AllMapsOrdered but is not nil && this == nil")
1817 }
1818 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1819 return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap))
1820 }
1821 for i := range this.StringToDoubleMap {
1822 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1823 return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i])
1824 }
1825 }
1826 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1827 return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap))
1828 }
1829 for i := range this.StringToFloatMap {
1830 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1831 return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i])
1832 }
1833 }
1834 if len(this.Int32Map) != len(that1.Int32Map) {
1835 return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map))
1836 }
1837 for i := range this.Int32Map {
1838 if this.Int32Map[i] != that1.Int32Map[i] {
1839 return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i])
1840 }
1841 }
1842 if len(this.Int64Map) != len(that1.Int64Map) {
1843 return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map))
1844 }
1845 for i := range this.Int64Map {
1846 if this.Int64Map[i] != that1.Int64Map[i] {
1847 return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i])
1848 }
1849 }
1850 if len(this.Uint32Map) != len(that1.Uint32Map) {
1851 return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map))
1852 }
1853 for i := range this.Uint32Map {
1854 if this.Uint32Map[i] != that1.Uint32Map[i] {
1855 return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i])
1856 }
1857 }
1858 if len(this.Uint64Map) != len(that1.Uint64Map) {
1859 return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map))
1860 }
1861 for i := range this.Uint64Map {
1862 if this.Uint64Map[i] != that1.Uint64Map[i] {
1863 return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i])
1864 }
1865 }
1866 if len(this.Sint32Map) != len(that1.Sint32Map) {
1867 return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map))
1868 }
1869 for i := range this.Sint32Map {
1870 if this.Sint32Map[i] != that1.Sint32Map[i] {
1871 return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i])
1872 }
1873 }
1874 if len(this.Sint64Map) != len(that1.Sint64Map) {
1875 return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map))
1876 }
1877 for i := range this.Sint64Map {
1878 if this.Sint64Map[i] != that1.Sint64Map[i] {
1879 return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i])
1880 }
1881 }
1882 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1883 return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map))
1884 }
1885 for i := range this.Fixed32Map {
1886 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1887 return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i])
1888 }
1889 }
1890 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1891 return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map))
1892 }
1893 for i := range this.Sfixed32Map {
1894 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1895 return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i])
1896 }
1897 }
1898 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1899 return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map))
1900 }
1901 for i := range this.Fixed64Map {
1902 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1903 return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i])
1904 }
1905 }
1906 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1907 return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map))
1908 }
1909 for i := range this.Sfixed64Map {
1910 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1911 return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i])
1912 }
1913 }
1914 if len(this.BoolMap) != len(that1.BoolMap) {
1915 return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap))
1916 }
1917 for i := range this.BoolMap {
1918 if this.BoolMap[i] != that1.BoolMap[i] {
1919 return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i])
1920 }
1921 }
1922 if len(this.StringMap) != len(that1.StringMap) {
1923 return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap))
1924 }
1925 for i := range this.StringMap {
1926 if this.StringMap[i] != that1.StringMap[i] {
1927 return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i])
1928 }
1929 }
1930 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1931 return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap))
1932 }
1933 for i := range this.StringToBytesMap {
1934 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1935 return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i])
1936 }
1937 }
1938 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1939 return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap))
1940 }
1941 for i := range this.StringToEnumMap {
1942 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1943 return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i])
1944 }
1945 }
1946 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1947 return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap))
1948 }
1949 for i := range this.StringToMsgMap {
1950 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1951 return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i])
1952 }
1953 }
1954 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1955 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1956 }
1957 return nil
1958 }
1959 func (this *AllMapsOrdered) Equal(that interface{}) bool {
1960 if that == nil {
1961 return this == nil
1962 }
1963
1964 that1, ok := that.(*AllMapsOrdered)
1965 if !ok {
1966 that2, ok := that.(AllMapsOrdered)
1967 if ok {
1968 that1 = &that2
1969 } else {
1970 return false
1971 }
1972 }
1973 if that1 == nil {
1974 return this == nil
1975 } else if this == nil {
1976 return false
1977 }
1978 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1979 return false
1980 }
1981 for i := range this.StringToDoubleMap {
1982 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1983 return false
1984 }
1985 }
1986 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1987 return false
1988 }
1989 for i := range this.StringToFloatMap {
1990 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1991 return false
1992 }
1993 }
1994 if len(this.Int32Map) != len(that1.Int32Map) {
1995 return false
1996 }
1997 for i := range this.Int32Map {
1998 if this.Int32Map[i] != that1.Int32Map[i] {
1999 return false
2000 }
2001 }
2002 if len(this.Int64Map) != len(that1.Int64Map) {
2003 return false
2004 }
2005 for i := range this.Int64Map {
2006 if this.Int64Map[i] != that1.Int64Map[i] {
2007 return false
2008 }
2009 }
2010 if len(this.Uint32Map) != len(that1.Uint32Map) {
2011 return false
2012 }
2013 for i := range this.Uint32Map {
2014 if this.Uint32Map[i] != that1.Uint32Map[i] {
2015 return false
2016 }
2017 }
2018 if len(this.Uint64Map) != len(that1.Uint64Map) {
2019 return false
2020 }
2021 for i := range this.Uint64Map {
2022 if this.Uint64Map[i] != that1.Uint64Map[i] {
2023 return false
2024 }
2025 }
2026 if len(this.Sint32Map) != len(that1.Sint32Map) {
2027 return false
2028 }
2029 for i := range this.Sint32Map {
2030 if this.Sint32Map[i] != that1.Sint32Map[i] {
2031 return false
2032 }
2033 }
2034 if len(this.Sint64Map) != len(that1.Sint64Map) {
2035 return false
2036 }
2037 for i := range this.Sint64Map {
2038 if this.Sint64Map[i] != that1.Sint64Map[i] {
2039 return false
2040 }
2041 }
2042 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
2043 return false
2044 }
2045 for i := range this.Fixed32Map {
2046 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
2047 return false
2048 }
2049 }
2050 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
2051 return false
2052 }
2053 for i := range this.Sfixed32Map {
2054 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
2055 return false
2056 }
2057 }
2058 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
2059 return false
2060 }
2061 for i := range this.Fixed64Map {
2062 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
2063 return false
2064 }
2065 }
2066 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
2067 return false
2068 }
2069 for i := range this.Sfixed64Map {
2070 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
2071 return false
2072 }
2073 }
2074 if len(this.BoolMap) != len(that1.BoolMap) {
2075 return false
2076 }
2077 for i := range this.BoolMap {
2078 if this.BoolMap[i] != that1.BoolMap[i] {
2079 return false
2080 }
2081 }
2082 if len(this.StringMap) != len(that1.StringMap) {
2083 return false
2084 }
2085 for i := range this.StringMap {
2086 if this.StringMap[i] != that1.StringMap[i] {
2087 return false
2088 }
2089 }
2090 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
2091 return false
2092 }
2093 for i := range this.StringToBytesMap {
2094 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
2095 return false
2096 }
2097 }
2098 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
2099 return false
2100 }
2101 for i := range this.StringToEnumMap {
2102 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
2103 return false
2104 }
2105 }
2106 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
2107 return false
2108 }
2109 for i := range this.StringToMsgMap {
2110 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
2111 return false
2112 }
2113 }
2114 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2115 return false
2116 }
2117 return true
2118 }
2119 func (this *MessageWithMap) VerboseEqual(that interface{}) error {
2120 if that == nil {
2121 if this == nil {
2122 return nil
2123 }
2124 return fmt.Errorf("that == nil && this != nil")
2125 }
2126
2127 that1, ok := that.(*MessageWithMap)
2128 if !ok {
2129 that2, ok := that.(MessageWithMap)
2130 if ok {
2131 that1 = &that2
2132 } else {
2133 return fmt.Errorf("that is not of type *MessageWithMap")
2134 }
2135 }
2136 if that1 == nil {
2137 if this == nil {
2138 return nil
2139 }
2140 return fmt.Errorf("that is type *MessageWithMap but is nil && this != nil")
2141 } else if this == nil {
2142 return fmt.Errorf("that is type *MessageWithMap but is not nil && this == nil")
2143 }
2144 if len(this.NameMapping) != len(that1.NameMapping) {
2145 return fmt.Errorf("NameMapping this(%v) Not Equal that(%v)", len(this.NameMapping), len(that1.NameMapping))
2146 }
2147 for i := range this.NameMapping {
2148 if this.NameMapping[i] != that1.NameMapping[i] {
2149 return fmt.Errorf("NameMapping this[%v](%v) Not Equal that[%v](%v)", i, this.NameMapping[i], i, that1.NameMapping[i])
2150 }
2151 }
2152 if len(this.MsgMapping) != len(that1.MsgMapping) {
2153 return fmt.Errorf("MsgMapping this(%v) Not Equal that(%v)", len(this.MsgMapping), len(that1.MsgMapping))
2154 }
2155 for i := range this.MsgMapping {
2156 if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) {
2157 return fmt.Errorf("MsgMapping this[%v](%v) Not Equal that[%v](%v)", i, this.MsgMapping[i], i, that1.MsgMapping[i])
2158 }
2159 }
2160 if len(this.ByteMapping) != len(that1.ByteMapping) {
2161 return fmt.Errorf("ByteMapping this(%v) Not Equal that(%v)", len(this.ByteMapping), len(that1.ByteMapping))
2162 }
2163 for i := range this.ByteMapping {
2164 if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) {
2165 return fmt.Errorf("ByteMapping this[%v](%v) Not Equal that[%v](%v)", i, this.ByteMapping[i], i, that1.ByteMapping[i])
2166 }
2167 }
2168 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2169 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2170 }
2171 return nil
2172 }
2173 func (this *MessageWithMap) Equal(that interface{}) bool {
2174 if that == nil {
2175 return this == nil
2176 }
2177
2178 that1, ok := that.(*MessageWithMap)
2179 if !ok {
2180 that2, ok := that.(MessageWithMap)
2181 if ok {
2182 that1 = &that2
2183 } else {
2184 return false
2185 }
2186 }
2187 if that1 == nil {
2188 return this == nil
2189 } else if this == nil {
2190 return false
2191 }
2192 if len(this.NameMapping) != len(that1.NameMapping) {
2193 return false
2194 }
2195 for i := range this.NameMapping {
2196 if this.NameMapping[i] != that1.NameMapping[i] {
2197 return false
2198 }
2199 }
2200 if len(this.MsgMapping) != len(that1.MsgMapping) {
2201 return false
2202 }
2203 for i := range this.MsgMapping {
2204 if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) {
2205 return false
2206 }
2207 }
2208 if len(this.ByteMapping) != len(that1.ByteMapping) {
2209 return false
2210 }
2211 for i := range this.ByteMapping {
2212 if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) {
2213 return false
2214 }
2215 }
2216 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2217 return false
2218 }
2219 return true
2220 }
2221 func (this *FloatingPoint) VerboseEqual(that interface{}) error {
2222 if that == nil {
2223 if this == nil {
2224 return nil
2225 }
2226 return fmt.Errorf("that == nil && this != nil")
2227 }
2228
2229 that1, ok := that.(*FloatingPoint)
2230 if !ok {
2231 that2, ok := that.(FloatingPoint)
2232 if ok {
2233 that1 = &that2
2234 } else {
2235 return fmt.Errorf("that is not of type *FloatingPoint")
2236 }
2237 }
2238 if that1 == nil {
2239 if this == nil {
2240 return nil
2241 }
2242 return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil")
2243 } else if this == nil {
2244 return fmt.Errorf("that is type *FloatingPoint but is not nil && this == nil")
2245 }
2246 if this.F != that1.F {
2247 return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F)
2248 }
2249 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2250 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2251 }
2252 return nil
2253 }
2254 func (this *FloatingPoint) Equal(that interface{}) bool {
2255 if that == nil {
2256 return this == nil
2257 }
2258
2259 that1, ok := that.(*FloatingPoint)
2260 if !ok {
2261 that2, ok := that.(FloatingPoint)
2262 if ok {
2263 that1 = &that2
2264 } else {
2265 return false
2266 }
2267 }
2268 if that1 == nil {
2269 return this == nil
2270 } else if this == nil {
2271 return false
2272 }
2273 if this.F != that1.F {
2274 return false
2275 }
2276 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2277 return false
2278 }
2279 return true
2280 }
2281 func (this *Uint128Pair) VerboseEqual(that interface{}) error {
2282 if that == nil {
2283 if this == nil {
2284 return nil
2285 }
2286 return fmt.Errorf("that == nil && this != nil")
2287 }
2288
2289 that1, ok := that.(*Uint128Pair)
2290 if !ok {
2291 that2, ok := that.(Uint128Pair)
2292 if ok {
2293 that1 = &that2
2294 } else {
2295 return fmt.Errorf("that is not of type *Uint128Pair")
2296 }
2297 }
2298 if that1 == nil {
2299 if this == nil {
2300 return nil
2301 }
2302 return fmt.Errorf("that is type *Uint128Pair but is nil && this != nil")
2303 } else if this == nil {
2304 return fmt.Errorf("that is type *Uint128Pair but is not nil && this == nil")
2305 }
2306 if !this.Left.Equal(that1.Left) {
2307 return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left)
2308 }
2309 if that1.Right == nil {
2310 if this.Right != nil {
2311 return fmt.Errorf("this.Right != nil && that1.Right == nil")
2312 }
2313 } else if !this.Right.Equal(*that1.Right) {
2314 return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right)
2315 }
2316 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2317 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2318 }
2319 return nil
2320 }
2321 func (this *Uint128Pair) Equal(that interface{}) bool {
2322 if that == nil {
2323 return this == nil
2324 }
2325
2326 that1, ok := that.(*Uint128Pair)
2327 if !ok {
2328 that2, ok := that.(Uint128Pair)
2329 if ok {
2330 that1 = &that2
2331 } else {
2332 return false
2333 }
2334 }
2335 if that1 == nil {
2336 return this == nil
2337 } else if this == nil {
2338 return false
2339 }
2340 if !this.Left.Equal(that1.Left) {
2341 return false
2342 }
2343 if that1.Right == nil {
2344 if this.Right != nil {
2345 return false
2346 }
2347 } else if !this.Right.Equal(*that1.Right) {
2348 return false
2349 }
2350 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2351 return false
2352 }
2353 return true
2354 }
2355 func (this *ContainsNestedMap) VerboseEqual(that interface{}) error {
2356 if that == nil {
2357 if this == nil {
2358 return nil
2359 }
2360 return fmt.Errorf("that == nil && this != nil")
2361 }
2362
2363 that1, ok := that.(*ContainsNestedMap)
2364 if !ok {
2365 that2, ok := that.(ContainsNestedMap)
2366 if ok {
2367 that1 = &that2
2368 } else {
2369 return fmt.Errorf("that is not of type *ContainsNestedMap")
2370 }
2371 }
2372 if that1 == nil {
2373 if this == nil {
2374 return nil
2375 }
2376 return fmt.Errorf("that is type *ContainsNestedMap but is nil && this != nil")
2377 } else if this == nil {
2378 return fmt.Errorf("that is type *ContainsNestedMap but is not nil && this == nil")
2379 }
2380 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2381 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2382 }
2383 return nil
2384 }
2385 func (this *ContainsNestedMap) Equal(that interface{}) bool {
2386 if that == nil {
2387 return this == nil
2388 }
2389
2390 that1, ok := that.(*ContainsNestedMap)
2391 if !ok {
2392 that2, ok := that.(ContainsNestedMap)
2393 if ok {
2394 that1 = &that2
2395 } else {
2396 return false
2397 }
2398 }
2399 if that1 == nil {
2400 return this == nil
2401 } else if this == nil {
2402 return false
2403 }
2404 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2405 return false
2406 }
2407 return true
2408 }
2409 func (this *ContainsNestedMap_NestedMap) VerboseEqual(that interface{}) error {
2410 if that == nil {
2411 if this == nil {
2412 return nil
2413 }
2414 return fmt.Errorf("that == nil && this != nil")
2415 }
2416
2417 that1, ok := that.(*ContainsNestedMap_NestedMap)
2418 if !ok {
2419 that2, ok := that.(ContainsNestedMap_NestedMap)
2420 if ok {
2421 that1 = &that2
2422 } else {
2423 return fmt.Errorf("that is not of type *ContainsNestedMap_NestedMap")
2424 }
2425 }
2426 if that1 == nil {
2427 if this == nil {
2428 return nil
2429 }
2430 return fmt.Errorf("that is type *ContainsNestedMap_NestedMap but is nil && this != nil")
2431 } else if this == nil {
2432 return fmt.Errorf("that is type *ContainsNestedMap_NestedMap but is not nil && this == nil")
2433 }
2434 if len(this.NestedMapField) != len(that1.NestedMapField) {
2435 return fmt.Errorf("NestedMapField this(%v) Not Equal that(%v)", len(this.NestedMapField), len(that1.NestedMapField))
2436 }
2437 for i := range this.NestedMapField {
2438 if this.NestedMapField[i] != that1.NestedMapField[i] {
2439 return fmt.Errorf("NestedMapField this[%v](%v) Not Equal that[%v](%v)", i, this.NestedMapField[i], i, that1.NestedMapField[i])
2440 }
2441 }
2442 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2443 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2444 }
2445 return nil
2446 }
2447 func (this *ContainsNestedMap_NestedMap) Equal(that interface{}) bool {
2448 if that == nil {
2449 return this == nil
2450 }
2451
2452 that1, ok := that.(*ContainsNestedMap_NestedMap)
2453 if !ok {
2454 that2, ok := that.(ContainsNestedMap_NestedMap)
2455 if ok {
2456 that1 = &that2
2457 } else {
2458 return false
2459 }
2460 }
2461 if that1 == nil {
2462 return this == nil
2463 } else if this == nil {
2464 return false
2465 }
2466 if len(this.NestedMapField) != len(that1.NestedMapField) {
2467 return false
2468 }
2469 for i := range this.NestedMapField {
2470 if this.NestedMapField[i] != that1.NestedMapField[i] {
2471 return false
2472 }
2473 }
2474 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2475 return false
2476 }
2477 return true
2478 }
2479 func (this *NotPacked) VerboseEqual(that interface{}) error {
2480 if that == nil {
2481 if this == nil {
2482 return nil
2483 }
2484 return fmt.Errorf("that == nil && this != nil")
2485 }
2486
2487 that1, ok := that.(*NotPacked)
2488 if !ok {
2489 that2, ok := that.(NotPacked)
2490 if ok {
2491 that1 = &that2
2492 } else {
2493 return fmt.Errorf("that is not of type *NotPacked")
2494 }
2495 }
2496 if that1 == nil {
2497 if this == nil {
2498 return nil
2499 }
2500 return fmt.Errorf("that is type *NotPacked but is nil && this != nil")
2501 } else if this == nil {
2502 return fmt.Errorf("that is type *NotPacked but is not nil && this == nil")
2503 }
2504 if len(this.Key) != len(that1.Key) {
2505 return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key))
2506 }
2507 for i := range this.Key {
2508 if this.Key[i] != that1.Key[i] {
2509 return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i])
2510 }
2511 }
2512 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2513 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2514 }
2515 return nil
2516 }
2517 func (this *NotPacked) Equal(that interface{}) bool {
2518 if that == nil {
2519 return this == nil
2520 }
2521
2522 that1, ok := that.(*NotPacked)
2523 if !ok {
2524 that2, ok := that.(NotPacked)
2525 if ok {
2526 that1 = &that2
2527 } else {
2528 return false
2529 }
2530 }
2531 if that1 == nil {
2532 return this == nil
2533 } else if this == nil {
2534 return false
2535 }
2536 if len(this.Key) != len(that1.Key) {
2537 return false
2538 }
2539 for i := range this.Key {
2540 if this.Key[i] != that1.Key[i] {
2541 return false
2542 }
2543 }
2544 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2545 return false
2546 }
2547 return true
2548 }
2549
2550 type MessageFace interface {
2551 Proto() github_com_gogo_protobuf_proto.Message
2552 GetName() string
2553 GetHilarity() Message_Humour
2554 GetHeightInCm() uint32
2555 GetData() []byte
2556 GetResultCount() int64
2557 GetTrueScotsman() bool
2558 GetScore() float32
2559 GetKey() []uint64
2560 GetNested() *Nested
2561 GetTerrain() map[int64]*Nested
2562 GetProto2Field() *both.NinOptNative
2563 GetProto2Value() map[int64]*both.NinOptEnum
2564 }
2565
2566 func (this *Message) Proto() github_com_gogo_protobuf_proto.Message {
2567 return this
2568 }
2569
2570 func (this *Message) TestProto() github_com_gogo_protobuf_proto.Message {
2571 return NewMessageFromFace(this)
2572 }
2573
2574 func (this *Message) GetName() string {
2575 return this.Name
2576 }
2577
2578 func (this *Message) GetHilarity() Message_Humour {
2579 return this.Hilarity
2580 }
2581
2582 func (this *Message) GetHeightInCm() uint32 {
2583 return this.HeightInCm
2584 }
2585
2586 func (this *Message) GetData() []byte {
2587 return this.Data
2588 }
2589
2590 func (this *Message) GetResultCount() int64 {
2591 return this.ResultCount
2592 }
2593
2594 func (this *Message) GetTrueScotsman() bool {
2595 return this.TrueScotsman
2596 }
2597
2598 func (this *Message) GetScore() float32 {
2599 return this.Score
2600 }
2601
2602 func (this *Message) GetKey() []uint64 {
2603 return this.Key
2604 }
2605
2606 func (this *Message) GetNested() *Nested {
2607 return this.Nested
2608 }
2609
2610 func (this *Message) GetTerrain() map[int64]*Nested {
2611 return this.Terrain
2612 }
2613
2614 func (this *Message) GetProto2Field() *both.NinOptNative {
2615 return this.Proto2Field
2616 }
2617
2618 func (this *Message) GetProto2Value() map[int64]*both.NinOptEnum {
2619 return this.Proto2Value
2620 }
2621
2622 func NewMessageFromFace(that MessageFace) *Message {
2623 this := &Message{}
2624 this.Name = that.GetName()
2625 this.Hilarity = that.GetHilarity()
2626 this.HeightInCm = that.GetHeightInCm()
2627 this.Data = that.GetData()
2628 this.ResultCount = that.GetResultCount()
2629 this.TrueScotsman = that.GetTrueScotsman()
2630 this.Score = that.GetScore()
2631 this.Key = that.GetKey()
2632 this.Nested = that.GetNested()
2633 this.Terrain = that.GetTerrain()
2634 this.Proto2Field = that.GetProto2Field()
2635 this.Proto2Value = that.GetProto2Value()
2636 return this
2637 }
2638
2639 type NestedFace interface {
2640 Proto() github_com_gogo_protobuf_proto.Message
2641 GetBunny() string
2642 }
2643
2644 func (this *Nested) Proto() github_com_gogo_protobuf_proto.Message {
2645 return this
2646 }
2647
2648 func (this *Nested) TestProto() github_com_gogo_protobuf_proto.Message {
2649 return NewNestedFromFace(this)
2650 }
2651
2652 func (this *Nested) GetBunny() string {
2653 return this.Bunny
2654 }
2655
2656 func NewNestedFromFace(that NestedFace) *Nested {
2657 this := &Nested{}
2658 this.Bunny = that.GetBunny()
2659 return this
2660 }
2661
2662 type AllMapsFace interface {
2663 Proto() github_com_gogo_protobuf_proto.Message
2664 GetStringToDoubleMap() map[string]float64
2665 GetStringToFloatMap() map[string]float32
2666 GetInt32Map() map[int32]int32
2667 GetInt64Map() map[int64]int64
2668 GetUint32Map() map[uint32]uint32
2669 GetUint64Map() map[uint64]uint64
2670 GetSint32Map() map[int32]int32
2671 GetSint64Map() map[int64]int64
2672 GetFixed32Map() map[uint32]uint32
2673 GetSfixed32Map() map[int32]int32
2674 GetFixed64Map() map[uint64]uint64
2675 GetSfixed64Map() map[int64]int64
2676 GetBoolMap() map[bool]bool
2677 GetStringMap() map[string]string
2678 GetStringToBytesMap() map[string][]byte
2679 GetStringToEnumMap() map[string]MapEnum
2680 GetStringToMsgMap() map[string]*FloatingPoint
2681 }
2682
2683 func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message {
2684 return this
2685 }
2686
2687 func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message {
2688 return NewAllMapsFromFace(this)
2689 }
2690
2691 func (this *AllMaps) GetStringToDoubleMap() map[string]float64 {
2692 return this.StringToDoubleMap
2693 }
2694
2695 func (this *AllMaps) GetStringToFloatMap() map[string]float32 {
2696 return this.StringToFloatMap
2697 }
2698
2699 func (this *AllMaps) GetInt32Map() map[int32]int32 {
2700 return this.Int32Map
2701 }
2702
2703 func (this *AllMaps) GetInt64Map() map[int64]int64 {
2704 return this.Int64Map
2705 }
2706
2707 func (this *AllMaps) GetUint32Map() map[uint32]uint32 {
2708 return this.Uint32Map
2709 }
2710
2711 func (this *AllMaps) GetUint64Map() map[uint64]uint64 {
2712 return this.Uint64Map
2713 }
2714
2715 func (this *AllMaps) GetSint32Map() map[int32]int32 {
2716 return this.Sint32Map
2717 }
2718
2719 func (this *AllMaps) GetSint64Map() map[int64]int64 {
2720 return this.Sint64Map
2721 }
2722
2723 func (this *AllMaps) GetFixed32Map() map[uint32]uint32 {
2724 return this.Fixed32Map
2725 }
2726
2727 func (this *AllMaps) GetSfixed32Map() map[int32]int32 {
2728 return this.Sfixed32Map
2729 }
2730
2731 func (this *AllMaps) GetFixed64Map() map[uint64]uint64 {
2732 return this.Fixed64Map
2733 }
2734
2735 func (this *AllMaps) GetSfixed64Map() map[int64]int64 {
2736 return this.Sfixed64Map
2737 }
2738
2739 func (this *AllMaps) GetBoolMap() map[bool]bool {
2740 return this.BoolMap
2741 }
2742
2743 func (this *AllMaps) GetStringMap() map[string]string {
2744 return this.StringMap
2745 }
2746
2747 func (this *AllMaps) GetStringToBytesMap() map[string][]byte {
2748 return this.StringToBytesMap
2749 }
2750
2751 func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum {
2752 return this.StringToEnumMap
2753 }
2754
2755 func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint {
2756 return this.StringToMsgMap
2757 }
2758
2759 func NewAllMapsFromFace(that AllMapsFace) *AllMaps {
2760 this := &AllMaps{}
2761 this.StringToDoubleMap = that.GetStringToDoubleMap()
2762 this.StringToFloatMap = that.GetStringToFloatMap()
2763 this.Int32Map = that.GetInt32Map()
2764 this.Int64Map = that.GetInt64Map()
2765 this.Uint32Map = that.GetUint32Map()
2766 this.Uint64Map = that.GetUint64Map()
2767 this.Sint32Map = that.GetSint32Map()
2768 this.Sint64Map = that.GetSint64Map()
2769 this.Fixed32Map = that.GetFixed32Map()
2770 this.Sfixed32Map = that.GetSfixed32Map()
2771 this.Fixed64Map = that.GetFixed64Map()
2772 this.Sfixed64Map = that.GetSfixed64Map()
2773 this.BoolMap = that.GetBoolMap()
2774 this.StringMap = that.GetStringMap()
2775 this.StringToBytesMap = that.GetStringToBytesMap()
2776 this.StringToEnumMap = that.GetStringToEnumMap()
2777 this.StringToMsgMap = that.GetStringToMsgMap()
2778 return this
2779 }
2780
2781 type AllMapsOrderedFace interface {
2782 Proto() github_com_gogo_protobuf_proto.Message
2783 GetStringToDoubleMap() map[string]float64
2784 GetStringToFloatMap() map[string]float32
2785 GetInt32Map() map[int32]int32
2786 GetInt64Map() map[int64]int64
2787 GetUint32Map() map[uint32]uint32
2788 GetUint64Map() map[uint64]uint64
2789 GetSint32Map() map[int32]int32
2790 GetSint64Map() map[int64]int64
2791 GetFixed32Map() map[uint32]uint32
2792 GetSfixed32Map() map[int32]int32
2793 GetFixed64Map() map[uint64]uint64
2794 GetSfixed64Map() map[int64]int64
2795 GetBoolMap() map[bool]bool
2796 GetStringMap() map[string]string
2797 GetStringToBytesMap() map[string][]byte
2798 GetStringToEnumMap() map[string]MapEnum
2799 GetStringToMsgMap() map[string]*FloatingPoint
2800 }
2801
2802 func (this *AllMapsOrdered) Proto() github_com_gogo_protobuf_proto.Message {
2803 return this
2804 }
2805
2806 func (this *AllMapsOrdered) TestProto() github_com_gogo_protobuf_proto.Message {
2807 return NewAllMapsOrderedFromFace(this)
2808 }
2809
2810 func (this *AllMapsOrdered) GetStringToDoubleMap() map[string]float64 {
2811 return this.StringToDoubleMap
2812 }
2813
2814 func (this *AllMapsOrdered) GetStringToFloatMap() map[string]float32 {
2815 return this.StringToFloatMap
2816 }
2817
2818 func (this *AllMapsOrdered) GetInt32Map() map[int32]int32 {
2819 return this.Int32Map
2820 }
2821
2822 func (this *AllMapsOrdered) GetInt64Map() map[int64]int64 {
2823 return this.Int64Map
2824 }
2825
2826 func (this *AllMapsOrdered) GetUint32Map() map[uint32]uint32 {
2827 return this.Uint32Map
2828 }
2829
2830 func (this *AllMapsOrdered) GetUint64Map() map[uint64]uint64 {
2831 return this.Uint64Map
2832 }
2833
2834 func (this *AllMapsOrdered) GetSint32Map() map[int32]int32 {
2835 return this.Sint32Map
2836 }
2837
2838 func (this *AllMapsOrdered) GetSint64Map() map[int64]int64 {
2839 return this.Sint64Map
2840 }
2841
2842 func (this *AllMapsOrdered) GetFixed32Map() map[uint32]uint32 {
2843 return this.Fixed32Map
2844 }
2845
2846 func (this *AllMapsOrdered) GetSfixed32Map() map[int32]int32 {
2847 return this.Sfixed32Map
2848 }
2849
2850 func (this *AllMapsOrdered) GetFixed64Map() map[uint64]uint64 {
2851 return this.Fixed64Map
2852 }
2853
2854 func (this *AllMapsOrdered) GetSfixed64Map() map[int64]int64 {
2855 return this.Sfixed64Map
2856 }
2857
2858 func (this *AllMapsOrdered) GetBoolMap() map[bool]bool {
2859 return this.BoolMap
2860 }
2861
2862 func (this *AllMapsOrdered) GetStringMap() map[string]string {
2863 return this.StringMap
2864 }
2865
2866 func (this *AllMapsOrdered) GetStringToBytesMap() map[string][]byte {
2867 return this.StringToBytesMap
2868 }
2869
2870 func (this *AllMapsOrdered) GetStringToEnumMap() map[string]MapEnum {
2871 return this.StringToEnumMap
2872 }
2873
2874 func (this *AllMapsOrdered) GetStringToMsgMap() map[string]*FloatingPoint {
2875 return this.StringToMsgMap
2876 }
2877
2878 func NewAllMapsOrderedFromFace(that AllMapsOrderedFace) *AllMapsOrdered {
2879 this := &AllMapsOrdered{}
2880 this.StringToDoubleMap = that.GetStringToDoubleMap()
2881 this.StringToFloatMap = that.GetStringToFloatMap()
2882 this.Int32Map = that.GetInt32Map()
2883 this.Int64Map = that.GetInt64Map()
2884 this.Uint32Map = that.GetUint32Map()
2885 this.Uint64Map = that.GetUint64Map()
2886 this.Sint32Map = that.GetSint32Map()
2887 this.Sint64Map = that.GetSint64Map()
2888 this.Fixed32Map = that.GetFixed32Map()
2889 this.Sfixed32Map = that.GetSfixed32Map()
2890 this.Fixed64Map = that.GetFixed64Map()
2891 this.Sfixed64Map = that.GetSfixed64Map()
2892 this.BoolMap = that.GetBoolMap()
2893 this.StringMap = that.GetStringMap()
2894 this.StringToBytesMap = that.GetStringToBytesMap()
2895 this.StringToEnumMap = that.GetStringToEnumMap()
2896 this.StringToMsgMap = that.GetStringToMsgMap()
2897 return this
2898 }
2899
2900 type MessageWithMapFace interface {
2901 Proto() github_com_gogo_protobuf_proto.Message
2902 GetNameMapping() map[int32]string
2903 GetMsgMapping() map[int64]*FloatingPoint
2904 GetByteMapping() map[bool][]byte
2905 }
2906
2907 func (this *MessageWithMap) Proto() github_com_gogo_protobuf_proto.Message {
2908 return this
2909 }
2910
2911 func (this *MessageWithMap) TestProto() github_com_gogo_protobuf_proto.Message {
2912 return NewMessageWithMapFromFace(this)
2913 }
2914
2915 func (this *MessageWithMap) GetNameMapping() map[int32]string {
2916 return this.NameMapping
2917 }
2918
2919 func (this *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint {
2920 return this.MsgMapping
2921 }
2922
2923 func (this *MessageWithMap) GetByteMapping() map[bool][]byte {
2924 return this.ByteMapping
2925 }
2926
2927 func NewMessageWithMapFromFace(that MessageWithMapFace) *MessageWithMap {
2928 this := &MessageWithMap{}
2929 this.NameMapping = that.GetNameMapping()
2930 this.MsgMapping = that.GetMsgMapping()
2931 this.ByteMapping = that.GetByteMapping()
2932 return this
2933 }
2934
2935 type FloatingPointFace interface {
2936 Proto() github_com_gogo_protobuf_proto.Message
2937 GetF() float64
2938 }
2939
2940 func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message {
2941 return this
2942 }
2943
2944 func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message {
2945 return NewFloatingPointFromFace(this)
2946 }
2947
2948 func (this *FloatingPoint) GetF() float64 {
2949 return this.F
2950 }
2951
2952 func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint {
2953 this := &FloatingPoint{}
2954 this.F = that.GetF()
2955 return this
2956 }
2957
2958 type Uint128PairFace interface {
2959 Proto() github_com_gogo_protobuf_proto.Message
2960 GetLeft() github_com_gogo_protobuf_test_custom.Uint128
2961 GetRight() *github_com_gogo_protobuf_test_custom.Uint128
2962 }
2963
2964 func (this *Uint128Pair) Proto() github_com_gogo_protobuf_proto.Message {
2965 return this
2966 }
2967
2968 func (this *Uint128Pair) TestProto() github_com_gogo_protobuf_proto.Message {
2969 return NewUint128PairFromFace(this)
2970 }
2971
2972 func (this *Uint128Pair) GetLeft() github_com_gogo_protobuf_test_custom.Uint128 {
2973 return this.Left
2974 }
2975
2976 func (this *Uint128Pair) GetRight() *github_com_gogo_protobuf_test_custom.Uint128 {
2977 return this.Right
2978 }
2979
2980 func NewUint128PairFromFace(that Uint128PairFace) *Uint128Pair {
2981 this := &Uint128Pair{}
2982 this.Left = that.GetLeft()
2983 this.Right = that.GetRight()
2984 return this
2985 }
2986
2987 type ContainsNestedMapFace interface {
2988 Proto() github_com_gogo_protobuf_proto.Message
2989 }
2990
2991 func (this *ContainsNestedMap) Proto() github_com_gogo_protobuf_proto.Message {
2992 return this
2993 }
2994
2995 func (this *ContainsNestedMap) TestProto() github_com_gogo_protobuf_proto.Message {
2996 return NewContainsNestedMapFromFace(this)
2997 }
2998
2999 func NewContainsNestedMapFromFace(that ContainsNestedMapFace) *ContainsNestedMap {
3000 this := &ContainsNestedMap{}
3001 return this
3002 }
3003
3004 type ContainsNestedMap_NestedMapFace interface {
3005 Proto() github_com_gogo_protobuf_proto.Message
3006 GetNestedMapField() map[string]float64
3007 }
3008
3009 func (this *ContainsNestedMap_NestedMap) Proto() github_com_gogo_protobuf_proto.Message {
3010 return this
3011 }
3012
3013 func (this *ContainsNestedMap_NestedMap) TestProto() github_com_gogo_protobuf_proto.Message {
3014 return NewContainsNestedMap_NestedMapFromFace(this)
3015 }
3016
3017 func (this *ContainsNestedMap_NestedMap) GetNestedMapField() map[string]float64 {
3018 return this.NestedMapField
3019 }
3020
3021 func NewContainsNestedMap_NestedMapFromFace(that ContainsNestedMap_NestedMapFace) *ContainsNestedMap_NestedMap {
3022 this := &ContainsNestedMap_NestedMap{}
3023 this.NestedMapField = that.GetNestedMapField()
3024 return this
3025 }
3026
3027 type NotPackedFace interface {
3028 Proto() github_com_gogo_protobuf_proto.Message
3029 GetKey() []uint64
3030 }
3031
3032 func (this *NotPacked) Proto() github_com_gogo_protobuf_proto.Message {
3033 return this
3034 }
3035
3036 func (this *NotPacked) TestProto() github_com_gogo_protobuf_proto.Message {
3037 return NewNotPackedFromFace(this)
3038 }
3039
3040 func (this *NotPacked) GetKey() []uint64 {
3041 return this.Key
3042 }
3043
3044 func NewNotPackedFromFace(that NotPackedFace) *NotPacked {
3045 this := &NotPacked{}
3046 this.Key = that.GetKey()
3047 return this
3048 }
3049
3050 func (this *Message) GoString() string {
3051 if this == nil {
3052 return "nil"
3053 }
3054 s := make([]string, 0, 16)
3055 s = append(s, "&theproto3.Message{")
3056 s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
3057 s = append(s, "Hilarity: "+fmt.Sprintf("%#v", this.Hilarity)+",\n")
3058 s = append(s, "HeightInCm: "+fmt.Sprintf("%#v", this.HeightInCm)+",\n")
3059 s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
3060 s = append(s, "ResultCount: "+fmt.Sprintf("%#v", this.ResultCount)+",\n")
3061 s = append(s, "TrueScotsman: "+fmt.Sprintf("%#v", this.TrueScotsman)+",\n")
3062 s = append(s, "Score: "+fmt.Sprintf("%#v", this.Score)+",\n")
3063 s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
3064 if this.Nested != nil {
3065 s = append(s, "Nested: "+fmt.Sprintf("%#v", this.Nested)+",\n")
3066 }
3067 keysForTerrain := make([]int64, 0, len(this.Terrain))
3068 for k := range this.Terrain {
3069 keysForTerrain = append(keysForTerrain, k)
3070 }
3071 github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain)
3072 mapStringForTerrain := "map[int64]*Nested{"
3073 for _, k := range keysForTerrain {
3074 mapStringForTerrain += fmt.Sprintf("%#v: %#v,", k, this.Terrain[k])
3075 }
3076 mapStringForTerrain += "}"
3077 if this.Terrain != nil {
3078 s = append(s, "Terrain: "+mapStringForTerrain+",\n")
3079 }
3080 if this.Proto2Field != nil {
3081 s = append(s, "Proto2Field: "+fmt.Sprintf("%#v", this.Proto2Field)+",\n")
3082 }
3083 keysForProto2Value := make([]int64, 0, len(this.Proto2Value))
3084 for k := range this.Proto2Value {
3085 keysForProto2Value = append(keysForProto2Value, k)
3086 }
3087 github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value)
3088 mapStringForProto2Value := "map[int64]*both.NinOptEnum{"
3089 for _, k := range keysForProto2Value {
3090 mapStringForProto2Value += fmt.Sprintf("%#v: %#v,", k, this.Proto2Value[k])
3091 }
3092 mapStringForProto2Value += "}"
3093 if this.Proto2Value != nil {
3094 s = append(s, "Proto2Value: "+mapStringForProto2Value+",\n")
3095 }
3096 if this.XXX_unrecognized != nil {
3097 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3098 }
3099 s = append(s, "}")
3100 return strings.Join(s, "")
3101 }
3102 func (this *Nested) GoString() string {
3103 if this == nil {
3104 return "nil"
3105 }
3106 s := make([]string, 0, 5)
3107 s = append(s, "&theproto3.Nested{")
3108 s = append(s, "Bunny: "+fmt.Sprintf("%#v", this.Bunny)+",\n")
3109 if this.XXX_unrecognized != nil {
3110 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3111 }
3112 s = append(s, "}")
3113 return strings.Join(s, "")
3114 }
3115 func (this *AllMaps) GoString() string {
3116 if this == nil {
3117 return "nil"
3118 }
3119 s := make([]string, 0, 21)
3120 s = append(s, "&theproto3.AllMaps{")
3121 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
3122 for k := range this.StringToDoubleMap {
3123 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
3124 }
3125 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
3126 mapStringForStringToDoubleMap := "map[string]float64{"
3127 for _, k := range keysForStringToDoubleMap {
3128 mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k])
3129 }
3130 mapStringForStringToDoubleMap += "}"
3131 if this.StringToDoubleMap != nil {
3132 s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n")
3133 }
3134 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
3135 for k := range this.StringToFloatMap {
3136 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
3137 }
3138 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
3139 mapStringForStringToFloatMap := "map[string]float32{"
3140 for _, k := range keysForStringToFloatMap {
3141 mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k])
3142 }
3143 mapStringForStringToFloatMap += "}"
3144 if this.StringToFloatMap != nil {
3145 s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n")
3146 }
3147 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
3148 for k := range this.Int32Map {
3149 keysForInt32Map = append(keysForInt32Map, k)
3150 }
3151 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
3152 mapStringForInt32Map := "map[int32]int32{"
3153 for _, k := range keysForInt32Map {
3154 mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k])
3155 }
3156 mapStringForInt32Map += "}"
3157 if this.Int32Map != nil {
3158 s = append(s, "Int32Map: "+mapStringForInt32Map+",\n")
3159 }
3160 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
3161 for k := range this.Int64Map {
3162 keysForInt64Map = append(keysForInt64Map, k)
3163 }
3164 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
3165 mapStringForInt64Map := "map[int64]int64{"
3166 for _, k := range keysForInt64Map {
3167 mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k])
3168 }
3169 mapStringForInt64Map += "}"
3170 if this.Int64Map != nil {
3171 s = append(s, "Int64Map: "+mapStringForInt64Map+",\n")
3172 }
3173 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
3174 for k := range this.Uint32Map {
3175 keysForUint32Map = append(keysForUint32Map, k)
3176 }
3177 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
3178 mapStringForUint32Map := "map[uint32]uint32{"
3179 for _, k := range keysForUint32Map {
3180 mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k])
3181 }
3182 mapStringForUint32Map += "}"
3183 if this.Uint32Map != nil {
3184 s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n")
3185 }
3186 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
3187 for k := range this.Uint64Map {
3188 keysForUint64Map = append(keysForUint64Map, k)
3189 }
3190 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
3191 mapStringForUint64Map := "map[uint64]uint64{"
3192 for _, k := range keysForUint64Map {
3193 mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k])
3194 }
3195 mapStringForUint64Map += "}"
3196 if this.Uint64Map != nil {
3197 s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n")
3198 }
3199 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
3200 for k := range this.Sint32Map {
3201 keysForSint32Map = append(keysForSint32Map, k)
3202 }
3203 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
3204 mapStringForSint32Map := "map[int32]int32{"
3205 for _, k := range keysForSint32Map {
3206 mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k])
3207 }
3208 mapStringForSint32Map += "}"
3209 if this.Sint32Map != nil {
3210 s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n")
3211 }
3212 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
3213 for k := range this.Sint64Map {
3214 keysForSint64Map = append(keysForSint64Map, k)
3215 }
3216 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
3217 mapStringForSint64Map := "map[int64]int64{"
3218 for _, k := range keysForSint64Map {
3219 mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k])
3220 }
3221 mapStringForSint64Map += "}"
3222 if this.Sint64Map != nil {
3223 s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n")
3224 }
3225 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
3226 for k := range this.Fixed32Map {
3227 keysForFixed32Map = append(keysForFixed32Map, k)
3228 }
3229 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
3230 mapStringForFixed32Map := "map[uint32]uint32{"
3231 for _, k := range keysForFixed32Map {
3232 mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k])
3233 }
3234 mapStringForFixed32Map += "}"
3235 if this.Fixed32Map != nil {
3236 s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n")
3237 }
3238 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
3239 for k := range this.Sfixed32Map {
3240 keysForSfixed32Map = append(keysForSfixed32Map, k)
3241 }
3242 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
3243 mapStringForSfixed32Map := "map[int32]int32{"
3244 for _, k := range keysForSfixed32Map {
3245 mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k])
3246 }
3247 mapStringForSfixed32Map += "}"
3248 if this.Sfixed32Map != nil {
3249 s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n")
3250 }
3251 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
3252 for k := range this.Fixed64Map {
3253 keysForFixed64Map = append(keysForFixed64Map, k)
3254 }
3255 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
3256 mapStringForFixed64Map := "map[uint64]uint64{"
3257 for _, k := range keysForFixed64Map {
3258 mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k])
3259 }
3260 mapStringForFixed64Map += "}"
3261 if this.Fixed64Map != nil {
3262 s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n")
3263 }
3264 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
3265 for k := range this.Sfixed64Map {
3266 keysForSfixed64Map = append(keysForSfixed64Map, k)
3267 }
3268 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
3269 mapStringForSfixed64Map := "map[int64]int64{"
3270 for _, k := range keysForSfixed64Map {
3271 mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k])
3272 }
3273 mapStringForSfixed64Map += "}"
3274 if this.Sfixed64Map != nil {
3275 s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n")
3276 }
3277 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
3278 for k := range this.BoolMap {
3279 keysForBoolMap = append(keysForBoolMap, k)
3280 }
3281 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
3282 mapStringForBoolMap := "map[bool]bool{"
3283 for _, k := range keysForBoolMap {
3284 mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k])
3285 }
3286 mapStringForBoolMap += "}"
3287 if this.BoolMap != nil {
3288 s = append(s, "BoolMap: "+mapStringForBoolMap+",\n")
3289 }
3290 keysForStringMap := make([]string, 0, len(this.StringMap))
3291 for k := range this.StringMap {
3292 keysForStringMap = append(keysForStringMap, k)
3293 }
3294 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
3295 mapStringForStringMap := "map[string]string{"
3296 for _, k := range keysForStringMap {
3297 mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k])
3298 }
3299 mapStringForStringMap += "}"
3300 if this.StringMap != nil {
3301 s = append(s, "StringMap: "+mapStringForStringMap+",\n")
3302 }
3303 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
3304 for k := range this.StringToBytesMap {
3305 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
3306 }
3307 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
3308 mapStringForStringToBytesMap := "map[string][]byte{"
3309 for _, k := range keysForStringToBytesMap {
3310 mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k])
3311 }
3312 mapStringForStringToBytesMap += "}"
3313 if this.StringToBytesMap != nil {
3314 s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n")
3315 }
3316 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
3317 for k := range this.StringToEnumMap {
3318 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
3319 }
3320 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
3321 mapStringForStringToEnumMap := "map[string]MapEnum{"
3322 for _, k := range keysForStringToEnumMap {
3323 mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k])
3324 }
3325 mapStringForStringToEnumMap += "}"
3326 if this.StringToEnumMap != nil {
3327 s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n")
3328 }
3329 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
3330 for k := range this.StringToMsgMap {
3331 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
3332 }
3333 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
3334 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
3335 for _, k := range keysForStringToMsgMap {
3336 mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k])
3337 }
3338 mapStringForStringToMsgMap += "}"
3339 if this.StringToMsgMap != nil {
3340 s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n")
3341 }
3342 if this.XXX_unrecognized != nil {
3343 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3344 }
3345 s = append(s, "}")
3346 return strings.Join(s, "")
3347 }
3348 func (this *AllMapsOrdered) GoString() string {
3349 if this == nil {
3350 return "nil"
3351 }
3352 s := make([]string, 0, 21)
3353 s = append(s, "&theproto3.AllMapsOrdered{")
3354 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
3355 for k := range this.StringToDoubleMap {
3356 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
3357 }
3358 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
3359 mapStringForStringToDoubleMap := "map[string]float64{"
3360 for _, k := range keysForStringToDoubleMap {
3361 mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k])
3362 }
3363 mapStringForStringToDoubleMap += "}"
3364 if this.StringToDoubleMap != nil {
3365 s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n")
3366 }
3367 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
3368 for k := range this.StringToFloatMap {
3369 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
3370 }
3371 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
3372 mapStringForStringToFloatMap := "map[string]float32{"
3373 for _, k := range keysForStringToFloatMap {
3374 mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k])
3375 }
3376 mapStringForStringToFloatMap += "}"
3377 if this.StringToFloatMap != nil {
3378 s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n")
3379 }
3380 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
3381 for k := range this.Int32Map {
3382 keysForInt32Map = append(keysForInt32Map, k)
3383 }
3384 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
3385 mapStringForInt32Map := "map[int32]int32{"
3386 for _, k := range keysForInt32Map {
3387 mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k])
3388 }
3389 mapStringForInt32Map += "}"
3390 if this.Int32Map != nil {
3391 s = append(s, "Int32Map: "+mapStringForInt32Map+",\n")
3392 }
3393 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
3394 for k := range this.Int64Map {
3395 keysForInt64Map = append(keysForInt64Map, k)
3396 }
3397 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
3398 mapStringForInt64Map := "map[int64]int64{"
3399 for _, k := range keysForInt64Map {
3400 mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k])
3401 }
3402 mapStringForInt64Map += "}"
3403 if this.Int64Map != nil {
3404 s = append(s, "Int64Map: "+mapStringForInt64Map+",\n")
3405 }
3406 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
3407 for k := range this.Uint32Map {
3408 keysForUint32Map = append(keysForUint32Map, k)
3409 }
3410 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
3411 mapStringForUint32Map := "map[uint32]uint32{"
3412 for _, k := range keysForUint32Map {
3413 mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k])
3414 }
3415 mapStringForUint32Map += "}"
3416 if this.Uint32Map != nil {
3417 s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n")
3418 }
3419 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
3420 for k := range this.Uint64Map {
3421 keysForUint64Map = append(keysForUint64Map, k)
3422 }
3423 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
3424 mapStringForUint64Map := "map[uint64]uint64{"
3425 for _, k := range keysForUint64Map {
3426 mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k])
3427 }
3428 mapStringForUint64Map += "}"
3429 if this.Uint64Map != nil {
3430 s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n")
3431 }
3432 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
3433 for k := range this.Sint32Map {
3434 keysForSint32Map = append(keysForSint32Map, k)
3435 }
3436 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
3437 mapStringForSint32Map := "map[int32]int32{"
3438 for _, k := range keysForSint32Map {
3439 mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k])
3440 }
3441 mapStringForSint32Map += "}"
3442 if this.Sint32Map != nil {
3443 s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n")
3444 }
3445 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
3446 for k := range this.Sint64Map {
3447 keysForSint64Map = append(keysForSint64Map, k)
3448 }
3449 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
3450 mapStringForSint64Map := "map[int64]int64{"
3451 for _, k := range keysForSint64Map {
3452 mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k])
3453 }
3454 mapStringForSint64Map += "}"
3455 if this.Sint64Map != nil {
3456 s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n")
3457 }
3458 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
3459 for k := range this.Fixed32Map {
3460 keysForFixed32Map = append(keysForFixed32Map, k)
3461 }
3462 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
3463 mapStringForFixed32Map := "map[uint32]uint32{"
3464 for _, k := range keysForFixed32Map {
3465 mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k])
3466 }
3467 mapStringForFixed32Map += "}"
3468 if this.Fixed32Map != nil {
3469 s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n")
3470 }
3471 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
3472 for k := range this.Sfixed32Map {
3473 keysForSfixed32Map = append(keysForSfixed32Map, k)
3474 }
3475 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
3476 mapStringForSfixed32Map := "map[int32]int32{"
3477 for _, k := range keysForSfixed32Map {
3478 mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k])
3479 }
3480 mapStringForSfixed32Map += "}"
3481 if this.Sfixed32Map != nil {
3482 s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n")
3483 }
3484 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
3485 for k := range this.Fixed64Map {
3486 keysForFixed64Map = append(keysForFixed64Map, k)
3487 }
3488 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
3489 mapStringForFixed64Map := "map[uint64]uint64{"
3490 for _, k := range keysForFixed64Map {
3491 mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k])
3492 }
3493 mapStringForFixed64Map += "}"
3494 if this.Fixed64Map != nil {
3495 s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n")
3496 }
3497 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
3498 for k := range this.Sfixed64Map {
3499 keysForSfixed64Map = append(keysForSfixed64Map, k)
3500 }
3501 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
3502 mapStringForSfixed64Map := "map[int64]int64{"
3503 for _, k := range keysForSfixed64Map {
3504 mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k])
3505 }
3506 mapStringForSfixed64Map += "}"
3507 if this.Sfixed64Map != nil {
3508 s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n")
3509 }
3510 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
3511 for k := range this.BoolMap {
3512 keysForBoolMap = append(keysForBoolMap, k)
3513 }
3514 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
3515 mapStringForBoolMap := "map[bool]bool{"
3516 for _, k := range keysForBoolMap {
3517 mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k])
3518 }
3519 mapStringForBoolMap += "}"
3520 if this.BoolMap != nil {
3521 s = append(s, "BoolMap: "+mapStringForBoolMap+",\n")
3522 }
3523 keysForStringMap := make([]string, 0, len(this.StringMap))
3524 for k := range this.StringMap {
3525 keysForStringMap = append(keysForStringMap, k)
3526 }
3527 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
3528 mapStringForStringMap := "map[string]string{"
3529 for _, k := range keysForStringMap {
3530 mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k])
3531 }
3532 mapStringForStringMap += "}"
3533 if this.StringMap != nil {
3534 s = append(s, "StringMap: "+mapStringForStringMap+",\n")
3535 }
3536 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
3537 for k := range this.StringToBytesMap {
3538 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
3539 }
3540 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
3541 mapStringForStringToBytesMap := "map[string][]byte{"
3542 for _, k := range keysForStringToBytesMap {
3543 mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k])
3544 }
3545 mapStringForStringToBytesMap += "}"
3546 if this.StringToBytesMap != nil {
3547 s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n")
3548 }
3549 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
3550 for k := range this.StringToEnumMap {
3551 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
3552 }
3553 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
3554 mapStringForStringToEnumMap := "map[string]MapEnum{"
3555 for _, k := range keysForStringToEnumMap {
3556 mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k])
3557 }
3558 mapStringForStringToEnumMap += "}"
3559 if this.StringToEnumMap != nil {
3560 s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n")
3561 }
3562 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
3563 for k := range this.StringToMsgMap {
3564 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
3565 }
3566 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
3567 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
3568 for _, k := range keysForStringToMsgMap {
3569 mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k])
3570 }
3571 mapStringForStringToMsgMap += "}"
3572 if this.StringToMsgMap != nil {
3573 s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n")
3574 }
3575 if this.XXX_unrecognized != nil {
3576 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3577 }
3578 s = append(s, "}")
3579 return strings.Join(s, "")
3580 }
3581 func (this *MessageWithMap) GoString() string {
3582 if this == nil {
3583 return "nil"
3584 }
3585 s := make([]string, 0, 7)
3586 s = append(s, "&theproto3.MessageWithMap{")
3587 keysForNameMapping := make([]int32, 0, len(this.NameMapping))
3588 for k := range this.NameMapping {
3589 keysForNameMapping = append(keysForNameMapping, k)
3590 }
3591 github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping)
3592 mapStringForNameMapping := "map[int32]string{"
3593 for _, k := range keysForNameMapping {
3594 mapStringForNameMapping += fmt.Sprintf("%#v: %#v,", k, this.NameMapping[k])
3595 }
3596 mapStringForNameMapping += "}"
3597 if this.NameMapping != nil {
3598 s = append(s, "NameMapping: "+mapStringForNameMapping+",\n")
3599 }
3600 keysForMsgMapping := make([]int64, 0, len(this.MsgMapping))
3601 for k := range this.MsgMapping {
3602 keysForMsgMapping = append(keysForMsgMapping, k)
3603 }
3604 github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping)
3605 mapStringForMsgMapping := "map[int64]*FloatingPoint{"
3606 for _, k := range keysForMsgMapping {
3607 mapStringForMsgMapping += fmt.Sprintf("%#v: %#v,", k, this.MsgMapping[k])
3608 }
3609 mapStringForMsgMapping += "}"
3610 if this.MsgMapping != nil {
3611 s = append(s, "MsgMapping: "+mapStringForMsgMapping+",\n")
3612 }
3613 keysForByteMapping := make([]bool, 0, len(this.ByteMapping))
3614 for k := range this.ByteMapping {
3615 keysForByteMapping = append(keysForByteMapping, k)
3616 }
3617 github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping)
3618 mapStringForByteMapping := "map[bool][]byte{"
3619 for _, k := range keysForByteMapping {
3620 mapStringForByteMapping += fmt.Sprintf("%#v: %#v,", k, this.ByteMapping[k])
3621 }
3622 mapStringForByteMapping += "}"
3623 if this.ByteMapping != nil {
3624 s = append(s, "ByteMapping: "+mapStringForByteMapping+",\n")
3625 }
3626 if this.XXX_unrecognized != nil {
3627 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3628 }
3629 s = append(s, "}")
3630 return strings.Join(s, "")
3631 }
3632 func (this *FloatingPoint) GoString() string {
3633 if this == nil {
3634 return "nil"
3635 }
3636 s := make([]string, 0, 5)
3637 s = append(s, "&theproto3.FloatingPoint{")
3638 s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n")
3639 if this.XXX_unrecognized != nil {
3640 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3641 }
3642 s = append(s, "}")
3643 return strings.Join(s, "")
3644 }
3645 func (this *Uint128Pair) GoString() string {
3646 if this == nil {
3647 return "nil"
3648 }
3649 s := make([]string, 0, 6)
3650 s = append(s, "&theproto3.Uint128Pair{")
3651 s = append(s, "Left: "+fmt.Sprintf("%#v", this.Left)+",\n")
3652 s = append(s, "Right: "+fmt.Sprintf("%#v", this.Right)+",\n")
3653 if this.XXX_unrecognized != nil {
3654 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3655 }
3656 s = append(s, "}")
3657 return strings.Join(s, "")
3658 }
3659 func (this *ContainsNestedMap) GoString() string {
3660 if this == nil {
3661 return "nil"
3662 }
3663 s := make([]string, 0, 4)
3664 s = append(s, "&theproto3.ContainsNestedMap{")
3665 if this.XXX_unrecognized != nil {
3666 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3667 }
3668 s = append(s, "}")
3669 return strings.Join(s, "")
3670 }
3671 func (this *ContainsNestedMap_NestedMap) GoString() string {
3672 if this == nil {
3673 return "nil"
3674 }
3675 s := make([]string, 0, 5)
3676 s = append(s, "&theproto3.ContainsNestedMap_NestedMap{")
3677 keysForNestedMapField := make([]string, 0, len(this.NestedMapField))
3678 for k := range this.NestedMapField {
3679 keysForNestedMapField = append(keysForNestedMapField, k)
3680 }
3681 github_com_gogo_protobuf_sortkeys.Strings(keysForNestedMapField)
3682 mapStringForNestedMapField := "map[string]float64{"
3683 for _, k := range keysForNestedMapField {
3684 mapStringForNestedMapField += fmt.Sprintf("%#v: %#v,", k, this.NestedMapField[k])
3685 }
3686 mapStringForNestedMapField += "}"
3687 if this.NestedMapField != nil {
3688 s = append(s, "NestedMapField: "+mapStringForNestedMapField+",\n")
3689 }
3690 if this.XXX_unrecognized != nil {
3691 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3692 }
3693 s = append(s, "}")
3694 return strings.Join(s, "")
3695 }
3696 func (this *NotPacked) GoString() string {
3697 if this == nil {
3698 return "nil"
3699 }
3700 s := make([]string, 0, 5)
3701 s = append(s, "&theproto3.NotPacked{")
3702 s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
3703 if this.XXX_unrecognized != nil {
3704 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3705 }
3706 s = append(s, "}")
3707 return strings.Join(s, "")
3708 }
3709 func valueToGoStringTheproto3(v interface{}, typ string) string {
3710 rv := reflect.ValueOf(v)
3711 if rv.IsNil() {
3712 return "nil"
3713 }
3714 pv := reflect.Indirect(rv).Interface()
3715 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
3716 }
3717 func (m *Message) Marshal() (dAtA []byte, err error) {
3718 size := m.Size()
3719 dAtA = make([]byte, size)
3720 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3721 if err != nil {
3722 return nil, err
3723 }
3724 return dAtA[:n], nil
3725 }
3726
3727 func (m *Message) MarshalTo(dAtA []byte) (int, error) {
3728 size := m.Size()
3729 return m.MarshalToSizedBuffer(dAtA[:size])
3730 }
3731
3732 func (m *Message) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3733 i := len(dAtA)
3734 _ = i
3735 var l int
3736 _ = l
3737 if m.XXX_unrecognized != nil {
3738 i -= len(m.XXX_unrecognized)
3739 copy(dAtA[i:], m.XXX_unrecognized)
3740 }
3741 if len(m.Proto2Value) > 0 {
3742 for k := range m.Proto2Value {
3743 v := m.Proto2Value[k]
3744 baseI := i
3745 if v != nil {
3746 {
3747 size, err := v.MarshalToSizedBuffer(dAtA[:i])
3748 if err != nil {
3749 return 0, err
3750 }
3751 i -= size
3752 i = encodeVarintTheproto3(dAtA, i, uint64(size))
3753 }
3754 i--
3755 dAtA[i] = 0x12
3756 }
3757 i = encodeVarintTheproto3(dAtA, i, uint64(k))
3758 i--
3759 dAtA[i] = 0x8
3760 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
3761 i--
3762 dAtA[i] = 0x6a
3763 }
3764 }
3765 if m.Proto2Field != nil {
3766 {
3767 size, err := m.Proto2Field.MarshalToSizedBuffer(dAtA[:i])
3768 if err != nil {
3769 return 0, err
3770 }
3771 i -= size
3772 i = encodeVarintTheproto3(dAtA, i, uint64(size))
3773 }
3774 i--
3775 dAtA[i] = 0x5a
3776 }
3777 if len(m.Terrain) > 0 {
3778 for k := range m.Terrain {
3779 v := m.Terrain[k]
3780 baseI := i
3781 if v != nil {
3782 {
3783 size, err := v.MarshalToSizedBuffer(dAtA[:i])
3784 if err != nil {
3785 return 0, err
3786 }
3787 i -= size
3788 i = encodeVarintTheproto3(dAtA, i, uint64(size))
3789 }
3790 i--
3791 dAtA[i] = 0x12
3792 }
3793 i = encodeVarintTheproto3(dAtA, i, uint64(k))
3794 i--
3795 dAtA[i] = 0x8
3796 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
3797 i--
3798 dAtA[i] = 0x52
3799 }
3800 }
3801 if m.Score != 0 {
3802 i -= 4
3803 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Score))))
3804 i--
3805 dAtA[i] = 0x4d
3806 }
3807 if m.TrueScotsman {
3808 i--
3809 if m.TrueScotsman {
3810 dAtA[i] = 1
3811 } else {
3812 dAtA[i] = 0
3813 }
3814 i--
3815 dAtA[i] = 0x40
3816 }
3817 if m.ResultCount != 0 {
3818 i = encodeVarintTheproto3(dAtA, i, uint64(m.ResultCount))
3819 i--
3820 dAtA[i] = 0x38
3821 }
3822 if m.Nested != nil {
3823 {
3824 size, err := m.Nested.MarshalToSizedBuffer(dAtA[:i])
3825 if err != nil {
3826 return 0, err
3827 }
3828 i -= size
3829 i = encodeVarintTheproto3(dAtA, i, uint64(size))
3830 }
3831 i--
3832 dAtA[i] = 0x32
3833 }
3834 if len(m.Key) > 0 {
3835 dAtA6 := make([]byte, len(m.Key)*10)
3836 var j5 int
3837 for _, num := range m.Key {
3838 for num >= 1<<7 {
3839 dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
3840 num >>= 7
3841 j5++
3842 }
3843 dAtA6[j5] = uint8(num)
3844 j5++
3845 }
3846 i -= j5
3847 copy(dAtA[i:], dAtA6[:j5])
3848 i = encodeVarintTheproto3(dAtA, i, uint64(j5))
3849 i--
3850 dAtA[i] = 0x2a
3851 }
3852 if len(m.Data) > 0 {
3853 i -= len(m.Data)
3854 copy(dAtA[i:], m.Data)
3855 i = encodeVarintTheproto3(dAtA, i, uint64(len(m.Data)))
3856 i--
3857 dAtA[i] = 0x22
3858 }
3859 if m.HeightInCm != 0 {
3860 i = encodeVarintTheproto3(dAtA, i, uint64(m.HeightInCm))
3861 i--
3862 dAtA[i] = 0x18
3863 }
3864 if m.Hilarity != 0 {
3865 i = encodeVarintTheproto3(dAtA, i, uint64(m.Hilarity))
3866 i--
3867 dAtA[i] = 0x10
3868 }
3869 if len(m.Name) > 0 {
3870 i -= len(m.Name)
3871 copy(dAtA[i:], m.Name)
3872 i = encodeVarintTheproto3(dAtA, i, uint64(len(m.Name)))
3873 i--
3874 dAtA[i] = 0xa
3875 }
3876 return len(dAtA) - i, nil
3877 }
3878
3879 func (m *Nested) Marshal() (dAtA []byte, err error) {
3880 size := m.Size()
3881 dAtA = make([]byte, size)
3882 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3883 if err != nil {
3884 return nil, err
3885 }
3886 return dAtA[:n], nil
3887 }
3888
3889 func (m *Nested) MarshalTo(dAtA []byte) (int, error) {
3890 size := m.Size()
3891 return m.MarshalToSizedBuffer(dAtA[:size])
3892 }
3893
3894 func (m *Nested) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3895 i := len(dAtA)
3896 _ = i
3897 var l int
3898 _ = l
3899 if m.XXX_unrecognized != nil {
3900 i -= len(m.XXX_unrecognized)
3901 copy(dAtA[i:], m.XXX_unrecognized)
3902 }
3903 if len(m.Bunny) > 0 {
3904 i -= len(m.Bunny)
3905 copy(dAtA[i:], m.Bunny)
3906 i = encodeVarintTheproto3(dAtA, i, uint64(len(m.Bunny)))
3907 i--
3908 dAtA[i] = 0xa
3909 }
3910 return len(dAtA) - i, nil
3911 }
3912
3913 func (m *AllMaps) Marshal() (dAtA []byte, err error) {
3914 size := m.Size()
3915 dAtA = make([]byte, size)
3916 n, err := m.MarshalToSizedBuffer(dAtA[:size])
3917 if err != nil {
3918 return nil, err
3919 }
3920 return dAtA[:n], nil
3921 }
3922
3923 func (m *AllMaps) MarshalTo(dAtA []byte) (int, error) {
3924 size := m.Size()
3925 return m.MarshalToSizedBuffer(dAtA[:size])
3926 }
3927
3928 func (m *AllMaps) MarshalToSizedBuffer(dAtA []byte) (int, error) {
3929 i := len(dAtA)
3930 _ = i
3931 var l int
3932 _ = l
3933 if m.XXX_unrecognized != nil {
3934 i -= len(m.XXX_unrecognized)
3935 copy(dAtA[i:], m.XXX_unrecognized)
3936 }
3937 if len(m.StringToMsgMap) > 0 {
3938 for k := range m.StringToMsgMap {
3939 v := m.StringToMsgMap[k]
3940 baseI := i
3941 if v != nil {
3942 {
3943 size, err := v.MarshalToSizedBuffer(dAtA[:i])
3944 if err != nil {
3945 return 0, err
3946 }
3947 i -= size
3948 i = encodeVarintTheproto3(dAtA, i, uint64(size))
3949 }
3950 i--
3951 dAtA[i] = 0x12
3952 }
3953 i -= len(k)
3954 copy(dAtA[i:], k)
3955 i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
3956 i--
3957 dAtA[i] = 0xa
3958 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
3959 i--
3960 dAtA[i] = 0x1
3961 i--
3962 dAtA[i] = 0x8a
3963 }
3964 }
3965 if len(m.StringToEnumMap) > 0 {
3966 for k := range m.StringToEnumMap {
3967 v := m.StringToEnumMap[k]
3968 baseI := i
3969 i = encodeVarintTheproto3(dAtA, i, uint64(v))
3970 i--
3971 dAtA[i] = 0x10
3972 i -= len(k)
3973 copy(dAtA[i:], k)
3974 i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
3975 i--
3976 dAtA[i] = 0xa
3977 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
3978 i--
3979 dAtA[i] = 0x1
3980 i--
3981 dAtA[i] = 0x82
3982 }
3983 }
3984 if len(m.StringToBytesMap) > 0 {
3985 for k := range m.StringToBytesMap {
3986 v := m.StringToBytesMap[k]
3987 baseI := i
3988 if len(v) > 0 {
3989 i -= len(v)
3990 copy(dAtA[i:], v)
3991 i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
3992 i--
3993 dAtA[i] = 0x12
3994 }
3995 i -= len(k)
3996 copy(dAtA[i:], k)
3997 i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
3998 i--
3999 dAtA[i] = 0xa
4000 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4001 i--
4002 dAtA[i] = 0x7a
4003 }
4004 }
4005 if len(m.StringMap) > 0 {
4006 for k := range m.StringMap {
4007 v := m.StringMap[k]
4008 baseI := i
4009 i -= len(v)
4010 copy(dAtA[i:], v)
4011 i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
4012 i--
4013 dAtA[i] = 0x12
4014 i -= len(k)
4015 copy(dAtA[i:], k)
4016 i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
4017 i--
4018 dAtA[i] = 0xa
4019 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4020 i--
4021 dAtA[i] = 0x72
4022 }
4023 }
4024 if len(m.BoolMap) > 0 {
4025 for k := range m.BoolMap {
4026 v := m.BoolMap[k]
4027 baseI := i
4028 i--
4029 if v {
4030 dAtA[i] = 1
4031 } else {
4032 dAtA[i] = 0
4033 }
4034 i--
4035 dAtA[i] = 0x10
4036 i--
4037 if k {
4038 dAtA[i] = 1
4039 } else {
4040 dAtA[i] = 0
4041 }
4042 i--
4043 dAtA[i] = 0x8
4044 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4045 i--
4046 dAtA[i] = 0x6a
4047 }
4048 }
4049 if len(m.Sfixed64Map) > 0 {
4050 for k := range m.Sfixed64Map {
4051 v := m.Sfixed64Map[k]
4052 baseI := i
4053 i -= 8
4054 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
4055 i--
4056 dAtA[i] = 0x11
4057 i -= 8
4058 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(k))
4059 i--
4060 dAtA[i] = 0x9
4061 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4062 i--
4063 dAtA[i] = 0x62
4064 }
4065 }
4066 if len(m.Fixed64Map) > 0 {
4067 for k := range m.Fixed64Map {
4068 v := m.Fixed64Map[k]
4069 baseI := i
4070 i -= 8
4071 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
4072 i--
4073 dAtA[i] = 0x11
4074 i -= 8
4075 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(k))
4076 i--
4077 dAtA[i] = 0x9
4078 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4079 i--
4080 dAtA[i] = 0x5a
4081 }
4082 }
4083 if len(m.Sfixed32Map) > 0 {
4084 for k := range m.Sfixed32Map {
4085 v := m.Sfixed32Map[k]
4086 baseI := i
4087 i -= 4
4088 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
4089 i--
4090 dAtA[i] = 0x15
4091 i -= 4
4092 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(k))
4093 i--
4094 dAtA[i] = 0xd
4095 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4096 i--
4097 dAtA[i] = 0x52
4098 }
4099 }
4100 if len(m.Fixed32Map) > 0 {
4101 for k := range m.Fixed32Map {
4102 v := m.Fixed32Map[k]
4103 baseI := i
4104 i -= 4
4105 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
4106 i--
4107 dAtA[i] = 0x15
4108 i -= 4
4109 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(k))
4110 i--
4111 dAtA[i] = 0xd
4112 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4113 i--
4114 dAtA[i] = 0x4a
4115 }
4116 }
4117 if len(m.Sint64Map) > 0 {
4118 for k := range m.Sint64Map {
4119 v := m.Sint64Map[k]
4120 baseI := i
4121 i = encodeVarintTheproto3(dAtA, i, uint64((uint64(v)<<1)^uint64((v>>63))))
4122 i--
4123 dAtA[i] = 0x10
4124 i = encodeVarintTheproto3(dAtA, i, uint64((uint64(k)<<1)^uint64((k>>63))))
4125 i--
4126 dAtA[i] = 0x8
4127 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4128 i--
4129 dAtA[i] = 0x42
4130 }
4131 }
4132 if len(m.Sint32Map) > 0 {
4133 for k := range m.Sint32Map {
4134 v := m.Sint32Map[k]
4135 baseI := i
4136 i = encodeVarintTheproto3(dAtA, i, uint64((uint32(v)<<1)^uint32((v>>31))))
4137 i--
4138 dAtA[i] = 0x10
4139 i = encodeVarintTheproto3(dAtA, i, uint64((uint32(k)<<1)^uint32((k>>31))))
4140 i--
4141 dAtA[i] = 0x8
4142 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4143 i--
4144 dAtA[i] = 0x3a
4145 }
4146 }
4147 if len(m.Uint64Map) > 0 {
4148 for k := range m.Uint64Map {
4149 v := m.Uint64Map[k]
4150 baseI := i
4151 i = encodeVarintTheproto3(dAtA, i, uint64(v))
4152 i--
4153 dAtA[i] = 0x10
4154 i = encodeVarintTheproto3(dAtA, i, uint64(k))
4155 i--
4156 dAtA[i] = 0x8
4157 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4158 i--
4159 dAtA[i] = 0x32
4160 }
4161 }
4162 if len(m.Uint32Map) > 0 {
4163 for k := range m.Uint32Map {
4164 v := m.Uint32Map[k]
4165 baseI := i
4166 i = encodeVarintTheproto3(dAtA, i, uint64(v))
4167 i--
4168 dAtA[i] = 0x10
4169 i = encodeVarintTheproto3(dAtA, i, uint64(k))
4170 i--
4171 dAtA[i] = 0x8
4172 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4173 i--
4174 dAtA[i] = 0x2a
4175 }
4176 }
4177 if len(m.Int64Map) > 0 {
4178 for k := range m.Int64Map {
4179 v := m.Int64Map[k]
4180 baseI := i
4181 i = encodeVarintTheproto3(dAtA, i, uint64(v))
4182 i--
4183 dAtA[i] = 0x10
4184 i = encodeVarintTheproto3(dAtA, i, uint64(k))
4185 i--
4186 dAtA[i] = 0x8
4187 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4188 i--
4189 dAtA[i] = 0x22
4190 }
4191 }
4192 if len(m.Int32Map) > 0 {
4193 for k := range m.Int32Map {
4194 v := m.Int32Map[k]
4195 baseI := i
4196 i = encodeVarintTheproto3(dAtA, i, uint64(v))
4197 i--
4198 dAtA[i] = 0x10
4199 i = encodeVarintTheproto3(dAtA, i, uint64(k))
4200 i--
4201 dAtA[i] = 0x8
4202 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4203 i--
4204 dAtA[i] = 0x1a
4205 }
4206 }
4207 if len(m.StringToFloatMap) > 0 {
4208 for k := range m.StringToFloatMap {
4209 v := m.StringToFloatMap[k]
4210 baseI := i
4211 i -= 4
4212 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(v))))
4213 i--
4214 dAtA[i] = 0x15
4215 i -= len(k)
4216 copy(dAtA[i:], k)
4217 i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
4218 i--
4219 dAtA[i] = 0xa
4220 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4221 i--
4222 dAtA[i] = 0x12
4223 }
4224 }
4225 if len(m.StringToDoubleMap) > 0 {
4226 for k := range m.StringToDoubleMap {
4227 v := m.StringToDoubleMap[k]
4228 baseI := i
4229 i -= 8
4230 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
4231 i--
4232 dAtA[i] = 0x11
4233 i -= len(k)
4234 copy(dAtA[i:], k)
4235 i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
4236 i--
4237 dAtA[i] = 0xa
4238 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4239 i--
4240 dAtA[i] = 0xa
4241 }
4242 }
4243 return len(dAtA) - i, nil
4244 }
4245
4246 func (m *AllMapsOrdered) Marshal() (dAtA []byte, err error) {
4247 size := m.Size()
4248 dAtA = make([]byte, size)
4249 n, err := m.MarshalToSizedBuffer(dAtA[:size])
4250 if err != nil {
4251 return nil, err
4252 }
4253 return dAtA[:n], nil
4254 }
4255
4256 func (m *AllMapsOrdered) MarshalTo(dAtA []byte) (int, error) {
4257 size := m.Size()
4258 return m.MarshalToSizedBuffer(dAtA[:size])
4259 }
4260
4261 func (m *AllMapsOrdered) MarshalToSizedBuffer(dAtA []byte) (int, error) {
4262 i := len(dAtA)
4263 _ = i
4264 var l int
4265 _ = l
4266 if m.XXX_unrecognized != nil {
4267 i -= len(m.XXX_unrecognized)
4268 copy(dAtA[i:], m.XXX_unrecognized)
4269 }
4270 if len(m.StringToMsgMap) > 0 {
4271 keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap))
4272 for k := range m.StringToMsgMap {
4273 keysForStringToMsgMap = append(keysForStringToMsgMap, string(k))
4274 }
4275 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
4276 for iNdEx := len(keysForStringToMsgMap) - 1; iNdEx >= 0; iNdEx-- {
4277 v := m.StringToMsgMap[string(keysForStringToMsgMap[iNdEx])]
4278 baseI := i
4279 if v != nil {
4280 {
4281 size, err := v.MarshalToSizedBuffer(dAtA[:i])
4282 if err != nil {
4283 return 0, err
4284 }
4285 i -= size
4286 i = encodeVarintTheproto3(dAtA, i, uint64(size))
4287 }
4288 i--
4289 dAtA[i] = 0x12
4290 }
4291 i -= len(keysForStringToMsgMap[iNdEx])
4292 copy(dAtA[i:], keysForStringToMsgMap[iNdEx])
4293 i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringToMsgMap[iNdEx])))
4294 i--
4295 dAtA[i] = 0xa
4296 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4297 i--
4298 dAtA[i] = 0x1
4299 i--
4300 dAtA[i] = 0x8a
4301 }
4302 }
4303 if len(m.StringToEnumMap) > 0 {
4304 keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap))
4305 for k := range m.StringToEnumMap {
4306 keysForStringToEnumMap = append(keysForStringToEnumMap, string(k))
4307 }
4308 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
4309 for iNdEx := len(keysForStringToEnumMap) - 1; iNdEx >= 0; iNdEx-- {
4310 v := m.StringToEnumMap[string(keysForStringToEnumMap[iNdEx])]
4311 baseI := i
4312 i = encodeVarintTheproto3(dAtA, i, uint64(v))
4313 i--
4314 dAtA[i] = 0x10
4315 i -= len(keysForStringToEnumMap[iNdEx])
4316 copy(dAtA[i:], keysForStringToEnumMap[iNdEx])
4317 i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringToEnumMap[iNdEx])))
4318 i--
4319 dAtA[i] = 0xa
4320 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4321 i--
4322 dAtA[i] = 0x1
4323 i--
4324 dAtA[i] = 0x82
4325 }
4326 }
4327 if len(m.StringToBytesMap) > 0 {
4328 keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap))
4329 for k := range m.StringToBytesMap {
4330 keysForStringToBytesMap = append(keysForStringToBytesMap, string(k))
4331 }
4332 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
4333 for iNdEx := len(keysForStringToBytesMap) - 1; iNdEx >= 0; iNdEx-- {
4334 v := m.StringToBytesMap[string(keysForStringToBytesMap[iNdEx])]
4335 baseI := i
4336 if len(v) > 0 {
4337 i -= len(v)
4338 copy(dAtA[i:], v)
4339 i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
4340 i--
4341 dAtA[i] = 0x12
4342 }
4343 i -= len(keysForStringToBytesMap[iNdEx])
4344 copy(dAtA[i:], keysForStringToBytesMap[iNdEx])
4345 i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringToBytesMap[iNdEx])))
4346 i--
4347 dAtA[i] = 0xa
4348 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4349 i--
4350 dAtA[i] = 0x7a
4351 }
4352 }
4353 if len(m.StringMap) > 0 {
4354 keysForStringMap := make([]string, 0, len(m.StringMap))
4355 for k := range m.StringMap {
4356 keysForStringMap = append(keysForStringMap, string(k))
4357 }
4358 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
4359 for iNdEx := len(keysForStringMap) - 1; iNdEx >= 0; iNdEx-- {
4360 v := m.StringMap[string(keysForStringMap[iNdEx])]
4361 baseI := i
4362 i -= len(v)
4363 copy(dAtA[i:], v)
4364 i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
4365 i--
4366 dAtA[i] = 0x12
4367 i -= len(keysForStringMap[iNdEx])
4368 copy(dAtA[i:], keysForStringMap[iNdEx])
4369 i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringMap[iNdEx])))
4370 i--
4371 dAtA[i] = 0xa
4372 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4373 i--
4374 dAtA[i] = 0x72
4375 }
4376 }
4377 if len(m.BoolMap) > 0 {
4378 keysForBoolMap := make([]bool, 0, len(m.BoolMap))
4379 for k := range m.BoolMap {
4380 keysForBoolMap = append(keysForBoolMap, bool(k))
4381 }
4382 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
4383 for iNdEx := len(keysForBoolMap) - 1; iNdEx >= 0; iNdEx-- {
4384 v := m.BoolMap[bool(keysForBoolMap[iNdEx])]
4385 baseI := i
4386 i--
4387 if v {
4388 dAtA[i] = 1
4389 } else {
4390 dAtA[i] = 0
4391 }
4392 i--
4393 dAtA[i] = 0x10
4394 i--
4395 if keysForBoolMap[iNdEx] {
4396 dAtA[i] = 1
4397 } else {
4398 dAtA[i] = 0
4399 }
4400 i--
4401 dAtA[i] = 0x8
4402 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4403 i--
4404 dAtA[i] = 0x6a
4405 }
4406 }
4407 if len(m.Sfixed64Map) > 0 {
4408 keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map))
4409 for k := range m.Sfixed64Map {
4410 keysForSfixed64Map = append(keysForSfixed64Map, int64(k))
4411 }
4412 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
4413 for iNdEx := len(keysForSfixed64Map) - 1; iNdEx >= 0; iNdEx-- {
4414 v := m.Sfixed64Map[int64(keysForSfixed64Map[iNdEx])]
4415 baseI := i
4416 i -= 8
4417 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
4418 i--
4419 dAtA[i] = 0x11
4420 i -= 8
4421 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(keysForSfixed64Map[iNdEx]))
4422 i--
4423 dAtA[i] = 0x9
4424 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4425 i--
4426 dAtA[i] = 0x62
4427 }
4428 }
4429 if len(m.Fixed64Map) > 0 {
4430 keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map))
4431 for k := range m.Fixed64Map {
4432 keysForFixed64Map = append(keysForFixed64Map, uint64(k))
4433 }
4434 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
4435 for iNdEx := len(keysForFixed64Map) - 1; iNdEx >= 0; iNdEx-- {
4436 v := m.Fixed64Map[uint64(keysForFixed64Map[iNdEx])]
4437 baseI := i
4438 i -= 8
4439 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
4440 i--
4441 dAtA[i] = 0x11
4442 i -= 8
4443 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(keysForFixed64Map[iNdEx]))
4444 i--
4445 dAtA[i] = 0x9
4446 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4447 i--
4448 dAtA[i] = 0x5a
4449 }
4450 }
4451 if len(m.Sfixed32Map) > 0 {
4452 keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map))
4453 for k := range m.Sfixed32Map {
4454 keysForSfixed32Map = append(keysForSfixed32Map, int32(k))
4455 }
4456 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
4457 for iNdEx := len(keysForSfixed32Map) - 1; iNdEx >= 0; iNdEx-- {
4458 v := m.Sfixed32Map[int32(keysForSfixed32Map[iNdEx])]
4459 baseI := i
4460 i -= 4
4461 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
4462 i--
4463 dAtA[i] = 0x15
4464 i -= 4
4465 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(keysForSfixed32Map[iNdEx]))
4466 i--
4467 dAtA[i] = 0xd
4468 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4469 i--
4470 dAtA[i] = 0x52
4471 }
4472 }
4473 if len(m.Fixed32Map) > 0 {
4474 keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map))
4475 for k := range m.Fixed32Map {
4476 keysForFixed32Map = append(keysForFixed32Map, uint32(k))
4477 }
4478 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
4479 for iNdEx := len(keysForFixed32Map) - 1; iNdEx >= 0; iNdEx-- {
4480 v := m.Fixed32Map[uint32(keysForFixed32Map[iNdEx])]
4481 baseI := i
4482 i -= 4
4483 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
4484 i--
4485 dAtA[i] = 0x15
4486 i -= 4
4487 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(keysForFixed32Map[iNdEx]))
4488 i--
4489 dAtA[i] = 0xd
4490 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4491 i--
4492 dAtA[i] = 0x4a
4493 }
4494 }
4495 if len(m.Sint64Map) > 0 {
4496 keysForSint64Map := make([]int64, 0, len(m.Sint64Map))
4497 for k := range m.Sint64Map {
4498 keysForSint64Map = append(keysForSint64Map, int64(k))
4499 }
4500 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
4501 for iNdEx := len(keysForSint64Map) - 1; iNdEx >= 0; iNdEx-- {
4502 v := m.Sint64Map[int64(keysForSint64Map[iNdEx])]
4503 baseI := i
4504 i = encodeVarintTheproto3(dAtA, i, uint64((uint64(v)<<1)^uint64((v>>63))))
4505 i--
4506 dAtA[i] = 0x10
4507 i = encodeVarintTheproto3(dAtA, i, uint64((uint64(keysForSint64Map[iNdEx])<<1)^uint64((keysForSint64Map[iNdEx]>>63))))
4508 i--
4509 dAtA[i] = 0x8
4510 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4511 i--
4512 dAtA[i] = 0x42
4513 }
4514 }
4515 if len(m.Sint32Map) > 0 {
4516 keysForSint32Map := make([]int32, 0, len(m.Sint32Map))
4517 for k := range m.Sint32Map {
4518 keysForSint32Map = append(keysForSint32Map, int32(k))
4519 }
4520 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
4521 for iNdEx := len(keysForSint32Map) - 1; iNdEx >= 0; iNdEx-- {
4522 v := m.Sint32Map[int32(keysForSint32Map[iNdEx])]
4523 baseI := i
4524 i = encodeVarintTheproto3(dAtA, i, uint64((uint32(v)<<1)^uint32((v>>31))))
4525 i--
4526 dAtA[i] = 0x10
4527 i = encodeVarintTheproto3(dAtA, i, uint64((uint32(keysForSint32Map[iNdEx])<<1)^uint32((keysForSint32Map[iNdEx]>>31))))
4528 i--
4529 dAtA[i] = 0x8
4530 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4531 i--
4532 dAtA[i] = 0x3a
4533 }
4534 }
4535 if len(m.Uint64Map) > 0 {
4536 keysForUint64Map := make([]uint64, 0, len(m.Uint64Map))
4537 for k := range m.Uint64Map {
4538 keysForUint64Map = append(keysForUint64Map, uint64(k))
4539 }
4540 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
4541 for iNdEx := len(keysForUint64Map) - 1; iNdEx >= 0; iNdEx-- {
4542 v := m.Uint64Map[uint64(keysForUint64Map[iNdEx])]
4543 baseI := i
4544 i = encodeVarintTheproto3(dAtA, i, uint64(v))
4545 i--
4546 dAtA[i] = 0x10
4547 i = encodeVarintTheproto3(dAtA, i, uint64(keysForUint64Map[iNdEx]))
4548 i--
4549 dAtA[i] = 0x8
4550 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4551 i--
4552 dAtA[i] = 0x32
4553 }
4554 }
4555 if len(m.Uint32Map) > 0 {
4556 keysForUint32Map := make([]uint32, 0, len(m.Uint32Map))
4557 for k := range m.Uint32Map {
4558 keysForUint32Map = append(keysForUint32Map, uint32(k))
4559 }
4560 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
4561 for iNdEx := len(keysForUint32Map) - 1; iNdEx >= 0; iNdEx-- {
4562 v := m.Uint32Map[uint32(keysForUint32Map[iNdEx])]
4563 baseI := i
4564 i = encodeVarintTheproto3(dAtA, i, uint64(v))
4565 i--
4566 dAtA[i] = 0x10
4567 i = encodeVarintTheproto3(dAtA, i, uint64(keysForUint32Map[iNdEx]))
4568 i--
4569 dAtA[i] = 0x8
4570 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4571 i--
4572 dAtA[i] = 0x2a
4573 }
4574 }
4575 if len(m.Int64Map) > 0 {
4576 keysForInt64Map := make([]int64, 0, len(m.Int64Map))
4577 for k := range m.Int64Map {
4578 keysForInt64Map = append(keysForInt64Map, int64(k))
4579 }
4580 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
4581 for iNdEx := len(keysForInt64Map) - 1; iNdEx >= 0; iNdEx-- {
4582 v := m.Int64Map[int64(keysForInt64Map[iNdEx])]
4583 baseI := i
4584 i = encodeVarintTheproto3(dAtA, i, uint64(v))
4585 i--
4586 dAtA[i] = 0x10
4587 i = encodeVarintTheproto3(dAtA, i, uint64(keysForInt64Map[iNdEx]))
4588 i--
4589 dAtA[i] = 0x8
4590 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4591 i--
4592 dAtA[i] = 0x22
4593 }
4594 }
4595 if len(m.Int32Map) > 0 {
4596 keysForInt32Map := make([]int32, 0, len(m.Int32Map))
4597 for k := range m.Int32Map {
4598 keysForInt32Map = append(keysForInt32Map, int32(k))
4599 }
4600 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
4601 for iNdEx := len(keysForInt32Map) - 1; iNdEx >= 0; iNdEx-- {
4602 v := m.Int32Map[int32(keysForInt32Map[iNdEx])]
4603 baseI := i
4604 i = encodeVarintTheproto3(dAtA, i, uint64(v))
4605 i--
4606 dAtA[i] = 0x10
4607 i = encodeVarintTheproto3(dAtA, i, uint64(keysForInt32Map[iNdEx]))
4608 i--
4609 dAtA[i] = 0x8
4610 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4611 i--
4612 dAtA[i] = 0x1a
4613 }
4614 }
4615 if len(m.StringToFloatMap) > 0 {
4616 keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap))
4617 for k := range m.StringToFloatMap {
4618 keysForStringToFloatMap = append(keysForStringToFloatMap, string(k))
4619 }
4620 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
4621 for iNdEx := len(keysForStringToFloatMap) - 1; iNdEx >= 0; iNdEx-- {
4622 v := m.StringToFloatMap[string(keysForStringToFloatMap[iNdEx])]
4623 baseI := i
4624 i -= 4
4625 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(v))))
4626 i--
4627 dAtA[i] = 0x15
4628 i -= len(keysForStringToFloatMap[iNdEx])
4629 copy(dAtA[i:], keysForStringToFloatMap[iNdEx])
4630 i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringToFloatMap[iNdEx])))
4631 i--
4632 dAtA[i] = 0xa
4633 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4634 i--
4635 dAtA[i] = 0x12
4636 }
4637 }
4638 if len(m.StringToDoubleMap) > 0 {
4639 keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap))
4640 for k := range m.StringToDoubleMap {
4641 keysForStringToDoubleMap = append(keysForStringToDoubleMap, string(k))
4642 }
4643 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
4644 for iNdEx := len(keysForStringToDoubleMap) - 1; iNdEx >= 0; iNdEx-- {
4645 v := m.StringToDoubleMap[string(keysForStringToDoubleMap[iNdEx])]
4646 baseI := i
4647 i -= 8
4648 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
4649 i--
4650 dAtA[i] = 0x11
4651 i -= len(keysForStringToDoubleMap[iNdEx])
4652 copy(dAtA[i:], keysForStringToDoubleMap[iNdEx])
4653 i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringToDoubleMap[iNdEx])))
4654 i--
4655 dAtA[i] = 0xa
4656 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4657 i--
4658 dAtA[i] = 0xa
4659 }
4660 }
4661 return len(dAtA) - i, nil
4662 }
4663
4664 func (m *MessageWithMap) Marshal() (dAtA []byte, err error) {
4665 size := m.Size()
4666 dAtA = make([]byte, size)
4667 n, err := m.MarshalToSizedBuffer(dAtA[:size])
4668 if err != nil {
4669 return nil, err
4670 }
4671 return dAtA[:n], nil
4672 }
4673
4674 func (m *MessageWithMap) MarshalTo(dAtA []byte) (int, error) {
4675 size := m.Size()
4676 return m.MarshalToSizedBuffer(dAtA[:size])
4677 }
4678
4679 func (m *MessageWithMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
4680 i := len(dAtA)
4681 _ = i
4682 var l int
4683 _ = l
4684 if m.XXX_unrecognized != nil {
4685 i -= len(m.XXX_unrecognized)
4686 copy(dAtA[i:], m.XXX_unrecognized)
4687 }
4688 if len(m.ByteMapping) > 0 {
4689 for k := range m.ByteMapping {
4690 v := m.ByteMapping[k]
4691 baseI := i
4692 if len(v) > 0 {
4693 i -= len(v)
4694 copy(dAtA[i:], v)
4695 i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
4696 i--
4697 dAtA[i] = 0x12
4698 }
4699 i--
4700 if k {
4701 dAtA[i] = 1
4702 } else {
4703 dAtA[i] = 0
4704 }
4705 i--
4706 dAtA[i] = 0x8
4707 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4708 i--
4709 dAtA[i] = 0x1a
4710 }
4711 }
4712 if len(m.MsgMapping) > 0 {
4713 for k := range m.MsgMapping {
4714 v := m.MsgMapping[k]
4715 baseI := i
4716 if v != nil {
4717 {
4718 size, err := v.MarshalToSizedBuffer(dAtA[:i])
4719 if err != nil {
4720 return 0, err
4721 }
4722 i -= size
4723 i = encodeVarintTheproto3(dAtA, i, uint64(size))
4724 }
4725 i--
4726 dAtA[i] = 0x12
4727 }
4728 i = encodeVarintTheproto3(dAtA, i, uint64((uint64(k)<<1)^uint64((k>>63))))
4729 i--
4730 dAtA[i] = 0x8
4731 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4732 i--
4733 dAtA[i] = 0x12
4734 }
4735 }
4736 if len(m.NameMapping) > 0 {
4737 for k := range m.NameMapping {
4738 v := m.NameMapping[k]
4739 baseI := i
4740 i -= len(v)
4741 copy(dAtA[i:], v)
4742 i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
4743 i--
4744 dAtA[i] = 0x12
4745 i = encodeVarintTheproto3(dAtA, i, uint64(k))
4746 i--
4747 dAtA[i] = 0x8
4748 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4749 i--
4750 dAtA[i] = 0xa
4751 }
4752 }
4753 return len(dAtA) - i, nil
4754 }
4755
4756 func (m *FloatingPoint) Marshal() (dAtA []byte, err error) {
4757 size := m.Size()
4758 dAtA = make([]byte, size)
4759 n, err := m.MarshalToSizedBuffer(dAtA[:size])
4760 if err != nil {
4761 return nil, err
4762 }
4763 return dAtA[:n], nil
4764 }
4765
4766 func (m *FloatingPoint) MarshalTo(dAtA []byte) (int, error) {
4767 size := m.Size()
4768 return m.MarshalToSizedBuffer(dAtA[:size])
4769 }
4770
4771 func (m *FloatingPoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
4772 i := len(dAtA)
4773 _ = i
4774 var l int
4775 _ = l
4776 if m.XXX_unrecognized != nil {
4777 i -= len(m.XXX_unrecognized)
4778 copy(dAtA[i:], m.XXX_unrecognized)
4779 }
4780 if m.F != 0 {
4781 i -= 8
4782 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.F))))
4783 i--
4784 dAtA[i] = 0x9
4785 }
4786 return len(dAtA) - i, nil
4787 }
4788
4789 func (m *Uint128Pair) Marshal() (dAtA []byte, err error) {
4790 size := m.Size()
4791 dAtA = make([]byte, size)
4792 n, err := m.MarshalToSizedBuffer(dAtA[:size])
4793 if err != nil {
4794 return nil, err
4795 }
4796 return dAtA[:n], nil
4797 }
4798
4799 func (m *Uint128Pair) MarshalTo(dAtA []byte) (int, error) {
4800 size := m.Size()
4801 return m.MarshalToSizedBuffer(dAtA[:size])
4802 }
4803
4804 func (m *Uint128Pair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
4805 i := len(dAtA)
4806 _ = i
4807 var l int
4808 _ = l
4809 if m.XXX_unrecognized != nil {
4810 i -= len(m.XXX_unrecognized)
4811 copy(dAtA[i:], m.XXX_unrecognized)
4812 }
4813 if m.Right != nil {
4814 {
4815 size := m.Right.Size()
4816 i -= size
4817 if _, err := m.Right.MarshalTo(dAtA[i:]); err != nil {
4818 return 0, err
4819 }
4820 i = encodeVarintTheproto3(dAtA, i, uint64(size))
4821 }
4822 i--
4823 dAtA[i] = 0x12
4824 }
4825 {
4826 size := m.Left.Size()
4827 i -= size
4828 if _, err := m.Left.MarshalTo(dAtA[i:]); err != nil {
4829 return 0, err
4830 }
4831 i = encodeVarintTheproto3(dAtA, i, uint64(size))
4832 }
4833 i--
4834 dAtA[i] = 0xa
4835 return len(dAtA) - i, nil
4836 }
4837
4838 func (m *ContainsNestedMap) Marshal() (dAtA []byte, err error) {
4839 size := m.Size()
4840 dAtA = make([]byte, size)
4841 n, err := m.MarshalToSizedBuffer(dAtA[:size])
4842 if err != nil {
4843 return nil, err
4844 }
4845 return dAtA[:n], nil
4846 }
4847
4848 func (m *ContainsNestedMap) MarshalTo(dAtA []byte) (int, error) {
4849 size := m.Size()
4850 return m.MarshalToSizedBuffer(dAtA[:size])
4851 }
4852
4853 func (m *ContainsNestedMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
4854 i := len(dAtA)
4855 _ = i
4856 var l int
4857 _ = l
4858 if m.XXX_unrecognized != nil {
4859 i -= len(m.XXX_unrecognized)
4860 copy(dAtA[i:], m.XXX_unrecognized)
4861 }
4862 return len(dAtA) - i, nil
4863 }
4864
4865 func (m *ContainsNestedMap_NestedMap) Marshal() (dAtA []byte, err error) {
4866 size := m.Size()
4867 dAtA = make([]byte, size)
4868 n, err := m.MarshalToSizedBuffer(dAtA[:size])
4869 if err != nil {
4870 return nil, err
4871 }
4872 return dAtA[:n], nil
4873 }
4874
4875 func (m *ContainsNestedMap_NestedMap) MarshalTo(dAtA []byte) (int, error) {
4876 size := m.Size()
4877 return m.MarshalToSizedBuffer(dAtA[:size])
4878 }
4879
4880 func (m *ContainsNestedMap_NestedMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
4881 i := len(dAtA)
4882 _ = i
4883 var l int
4884 _ = l
4885 if m.XXX_unrecognized != nil {
4886 i -= len(m.XXX_unrecognized)
4887 copy(dAtA[i:], m.XXX_unrecognized)
4888 }
4889 if len(m.NestedMapField) > 0 {
4890 for k := range m.NestedMapField {
4891 v := m.NestedMapField[k]
4892 baseI := i
4893 i -= 8
4894 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
4895 i--
4896 dAtA[i] = 0x11
4897 i -= len(k)
4898 copy(dAtA[i:], k)
4899 i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
4900 i--
4901 dAtA[i] = 0xa
4902 i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
4903 i--
4904 dAtA[i] = 0xa
4905 }
4906 }
4907 return len(dAtA) - i, nil
4908 }
4909
4910 func (m *NotPacked) Marshal() (dAtA []byte, err error) {
4911 size := m.Size()
4912 dAtA = make([]byte, size)
4913 n, err := m.MarshalToSizedBuffer(dAtA[:size])
4914 if err != nil {
4915 return nil, err
4916 }
4917 return dAtA[:n], nil
4918 }
4919
4920 func (m *NotPacked) MarshalTo(dAtA []byte) (int, error) {
4921 size := m.Size()
4922 return m.MarshalToSizedBuffer(dAtA[:size])
4923 }
4924
4925 func (m *NotPacked) MarshalToSizedBuffer(dAtA []byte) (int, error) {
4926 i := len(dAtA)
4927 _ = i
4928 var l int
4929 _ = l
4930 if m.XXX_unrecognized != nil {
4931 i -= len(m.XXX_unrecognized)
4932 copy(dAtA[i:], m.XXX_unrecognized)
4933 }
4934 if len(m.Key) > 0 {
4935 for iNdEx := len(m.Key) - 1; iNdEx >= 0; iNdEx-- {
4936 i = encodeVarintTheproto3(dAtA, i, uint64(m.Key[iNdEx]))
4937 i--
4938 dAtA[i] = 0x28
4939 }
4940 }
4941 return len(dAtA) - i, nil
4942 }
4943
4944 func encodeVarintTheproto3(dAtA []byte, offset int, v uint64) int {
4945 offset -= sovTheproto3(v)
4946 base := offset
4947 for v >= 1<<7 {
4948 dAtA[offset] = uint8(v&0x7f | 0x80)
4949 v >>= 7
4950 offset++
4951 }
4952 dAtA[offset] = uint8(v)
4953 return base
4954 }
4955 func NewPopulatedMessage(r randyTheproto3, easy bool) *Message {
4956 this := &Message{}
4957 this.Name = string(randStringTheproto3(r))
4958 this.Hilarity = Message_Humour([]int32{0, 1, 2, 3}[r.Intn(4)])
4959 this.HeightInCm = uint32(r.Uint32())
4960 v1 := r.Intn(100)
4961 this.Data = make([]byte, v1)
4962 for i := 0; i < v1; i++ {
4963 this.Data[i] = byte(r.Intn(256))
4964 }
4965 v2 := r.Intn(10)
4966 this.Key = make([]uint64, v2)
4967 for i := 0; i < v2; i++ {
4968 this.Key[i] = uint64(uint64(r.Uint32()))
4969 }
4970 if r.Intn(5) != 0 {
4971 this.Nested = NewPopulatedNested(r, easy)
4972 }
4973 this.ResultCount = int64(r.Int63())
4974 if r.Intn(2) == 0 {
4975 this.ResultCount *= -1
4976 }
4977 this.TrueScotsman = bool(bool(r.Intn(2) == 0))
4978 this.Score = float32(r.Float32())
4979 if r.Intn(2) == 0 {
4980 this.Score *= -1
4981 }
4982 if r.Intn(5) != 0 {
4983 v3 := r.Intn(10)
4984 this.Terrain = make(map[int64]*Nested)
4985 for i := 0; i < v3; i++ {
4986 this.Terrain[int64(r.Int63())] = NewPopulatedNested(r, easy)
4987 }
4988 }
4989 if r.Intn(5) != 0 {
4990 this.Proto2Field = both.NewPopulatedNinOptNative(r, easy)
4991 }
4992 if r.Intn(5) != 0 {
4993 v4 := r.Intn(10)
4994 this.Proto2Value = make(map[int64]*both.NinOptEnum)
4995 for i := 0; i < v4; i++ {
4996 this.Proto2Value[int64(r.Int63())] = both.NewPopulatedNinOptEnum(r, easy)
4997 }
4998 }
4999 if !easy && r.Intn(10) != 0 {
5000 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 14)
5001 }
5002 return this
5003 }
5004
5005 func NewPopulatedNested(r randyTheproto3, easy bool) *Nested {
5006 this := &Nested{}
5007 this.Bunny = string(randStringTheproto3(r))
5008 if !easy && r.Intn(10) != 0 {
5009 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 2)
5010 }
5011 return this
5012 }
5013
5014 func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps {
5015 this := &AllMaps{}
5016 if r.Intn(5) != 0 {
5017 v5 := r.Intn(10)
5018 this.StringToDoubleMap = make(map[string]float64)
5019 for i := 0; i < v5; i++ {
5020 v6 := randStringTheproto3(r)
5021 this.StringToDoubleMap[v6] = float64(r.Float64())
5022 if r.Intn(2) == 0 {
5023 this.StringToDoubleMap[v6] *= -1
5024 }
5025 }
5026 }
5027 if r.Intn(5) != 0 {
5028 v7 := r.Intn(10)
5029 this.StringToFloatMap = make(map[string]float32)
5030 for i := 0; i < v7; i++ {
5031 v8 := randStringTheproto3(r)
5032 this.StringToFloatMap[v8] = float32(r.Float32())
5033 if r.Intn(2) == 0 {
5034 this.StringToFloatMap[v8] *= -1
5035 }
5036 }
5037 }
5038 if r.Intn(5) != 0 {
5039 v9 := r.Intn(10)
5040 this.Int32Map = make(map[int32]int32)
5041 for i := 0; i < v9; i++ {
5042 v10 := int32(r.Int31())
5043 this.Int32Map[v10] = int32(r.Int31())
5044 if r.Intn(2) == 0 {
5045 this.Int32Map[v10] *= -1
5046 }
5047 }
5048 }
5049 if r.Intn(5) != 0 {
5050 v11 := r.Intn(10)
5051 this.Int64Map = make(map[int64]int64)
5052 for i := 0; i < v11; i++ {
5053 v12 := int64(r.Int63())
5054 this.Int64Map[v12] = int64(r.Int63())
5055 if r.Intn(2) == 0 {
5056 this.Int64Map[v12] *= -1
5057 }
5058 }
5059 }
5060 if r.Intn(5) != 0 {
5061 v13 := r.Intn(10)
5062 this.Uint32Map = make(map[uint32]uint32)
5063 for i := 0; i < v13; i++ {
5064 v14 := uint32(r.Uint32())
5065 this.Uint32Map[v14] = uint32(r.Uint32())
5066 }
5067 }
5068 if r.Intn(5) != 0 {
5069 v15 := r.Intn(10)
5070 this.Uint64Map = make(map[uint64]uint64)
5071 for i := 0; i < v15; i++ {
5072 v16 := uint64(uint64(r.Uint32()))
5073 this.Uint64Map[v16] = uint64(uint64(r.Uint32()))
5074 }
5075 }
5076 if r.Intn(5) != 0 {
5077 v17 := r.Intn(10)
5078 this.Sint32Map = make(map[int32]int32)
5079 for i := 0; i < v17; i++ {
5080 v18 := int32(r.Int31())
5081 this.Sint32Map[v18] = int32(r.Int31())
5082 if r.Intn(2) == 0 {
5083 this.Sint32Map[v18] *= -1
5084 }
5085 }
5086 }
5087 if r.Intn(5) != 0 {
5088 v19 := r.Intn(10)
5089 this.Sint64Map = make(map[int64]int64)
5090 for i := 0; i < v19; i++ {
5091 v20 := int64(r.Int63())
5092 this.Sint64Map[v20] = int64(r.Int63())
5093 if r.Intn(2) == 0 {
5094 this.Sint64Map[v20] *= -1
5095 }
5096 }
5097 }
5098 if r.Intn(5) != 0 {
5099 v21 := r.Intn(10)
5100 this.Fixed32Map = make(map[uint32]uint32)
5101 for i := 0; i < v21; i++ {
5102 v22 := uint32(r.Uint32())
5103 this.Fixed32Map[v22] = uint32(r.Uint32())
5104 }
5105 }
5106 if r.Intn(5) != 0 {
5107 v23 := r.Intn(10)
5108 this.Sfixed32Map = make(map[int32]int32)
5109 for i := 0; i < v23; i++ {
5110 v24 := int32(r.Int31())
5111 this.Sfixed32Map[v24] = int32(r.Int31())
5112 if r.Intn(2) == 0 {
5113 this.Sfixed32Map[v24] *= -1
5114 }
5115 }
5116 }
5117 if r.Intn(5) != 0 {
5118 v25 := r.Intn(10)
5119 this.Fixed64Map = make(map[uint64]uint64)
5120 for i := 0; i < v25; i++ {
5121 v26 := uint64(uint64(r.Uint32()))
5122 this.Fixed64Map[v26] = uint64(uint64(r.Uint32()))
5123 }
5124 }
5125 if r.Intn(5) != 0 {
5126 v27 := r.Intn(10)
5127 this.Sfixed64Map = make(map[int64]int64)
5128 for i := 0; i < v27; i++ {
5129 v28 := int64(r.Int63())
5130 this.Sfixed64Map[v28] = int64(r.Int63())
5131 if r.Intn(2) == 0 {
5132 this.Sfixed64Map[v28] *= -1
5133 }
5134 }
5135 }
5136 if r.Intn(5) != 0 {
5137 v29 := r.Intn(10)
5138 this.BoolMap = make(map[bool]bool)
5139 for i := 0; i < v29; i++ {
5140 v30 := bool(bool(r.Intn(2) == 0))
5141 this.BoolMap[v30] = bool(bool(r.Intn(2) == 0))
5142 }
5143 }
5144 if r.Intn(5) != 0 {
5145 v31 := r.Intn(10)
5146 this.StringMap = make(map[string]string)
5147 for i := 0; i < v31; i++ {
5148 this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r)
5149 }
5150 }
5151 if r.Intn(5) != 0 {
5152 v32 := r.Intn(10)
5153 this.StringToBytesMap = make(map[string][]byte)
5154 for i := 0; i < v32; i++ {
5155 v33 := r.Intn(100)
5156 v34 := randStringTheproto3(r)
5157 this.StringToBytesMap[v34] = make([]byte, v33)
5158 for i := 0; i < v33; i++ {
5159 this.StringToBytesMap[v34][i] = byte(r.Intn(256))
5160 }
5161 }
5162 }
5163 if r.Intn(5) != 0 {
5164 v35 := r.Intn(10)
5165 this.StringToEnumMap = make(map[string]MapEnum)
5166 for i := 0; i < v35; i++ {
5167 this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)])
5168 }
5169 }
5170 if r.Intn(5) != 0 {
5171 v36 := r.Intn(10)
5172 this.StringToMsgMap = make(map[string]*FloatingPoint)
5173 for i := 0; i < v36; i++ {
5174 this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy)
5175 }
5176 }
5177 if !easy && r.Intn(10) != 0 {
5178 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 18)
5179 }
5180 return this
5181 }
5182
5183 func NewPopulatedAllMapsOrdered(r randyTheproto3, easy bool) *AllMapsOrdered {
5184 this := &AllMapsOrdered{}
5185 if r.Intn(5) != 0 {
5186 v37 := r.Intn(10)
5187 this.StringToDoubleMap = make(map[string]float64)
5188 for i := 0; i < v37; i++ {
5189 v38 := randStringTheproto3(r)
5190 this.StringToDoubleMap[v38] = float64(r.Float64())
5191 if r.Intn(2) == 0 {
5192 this.StringToDoubleMap[v38] *= -1
5193 }
5194 }
5195 }
5196 if r.Intn(5) != 0 {
5197 v39 := r.Intn(10)
5198 this.StringToFloatMap = make(map[string]float32)
5199 for i := 0; i < v39; i++ {
5200 v40 := randStringTheproto3(r)
5201 this.StringToFloatMap[v40] = float32(r.Float32())
5202 if r.Intn(2) == 0 {
5203 this.StringToFloatMap[v40] *= -1
5204 }
5205 }
5206 }
5207 if r.Intn(5) != 0 {
5208 v41 := r.Intn(10)
5209 this.Int32Map = make(map[int32]int32)
5210 for i := 0; i < v41; i++ {
5211 v42 := int32(r.Int31())
5212 this.Int32Map[v42] = int32(r.Int31())
5213 if r.Intn(2) == 0 {
5214 this.Int32Map[v42] *= -1
5215 }
5216 }
5217 }
5218 if r.Intn(5) != 0 {
5219 v43 := r.Intn(10)
5220 this.Int64Map = make(map[int64]int64)
5221 for i := 0; i < v43; i++ {
5222 v44 := int64(r.Int63())
5223 this.Int64Map[v44] = int64(r.Int63())
5224 if r.Intn(2) == 0 {
5225 this.Int64Map[v44] *= -1
5226 }
5227 }
5228 }
5229 if r.Intn(5) != 0 {
5230 v45 := r.Intn(10)
5231 this.Uint32Map = make(map[uint32]uint32)
5232 for i := 0; i < v45; i++ {
5233 v46 := uint32(r.Uint32())
5234 this.Uint32Map[v46] = uint32(r.Uint32())
5235 }
5236 }
5237 if r.Intn(5) != 0 {
5238 v47 := r.Intn(10)
5239 this.Uint64Map = make(map[uint64]uint64)
5240 for i := 0; i < v47; i++ {
5241 v48 := uint64(uint64(r.Uint32()))
5242 this.Uint64Map[v48] = uint64(uint64(r.Uint32()))
5243 }
5244 }
5245 if r.Intn(5) != 0 {
5246 v49 := r.Intn(10)
5247 this.Sint32Map = make(map[int32]int32)
5248 for i := 0; i < v49; i++ {
5249 v50 := int32(r.Int31())
5250 this.Sint32Map[v50] = int32(r.Int31())
5251 if r.Intn(2) == 0 {
5252 this.Sint32Map[v50] *= -1
5253 }
5254 }
5255 }
5256 if r.Intn(5) != 0 {
5257 v51 := r.Intn(10)
5258 this.Sint64Map = make(map[int64]int64)
5259 for i := 0; i < v51; i++ {
5260 v52 := int64(r.Int63())
5261 this.Sint64Map[v52] = int64(r.Int63())
5262 if r.Intn(2) == 0 {
5263 this.Sint64Map[v52] *= -1
5264 }
5265 }
5266 }
5267 if r.Intn(5) != 0 {
5268 v53 := r.Intn(10)
5269 this.Fixed32Map = make(map[uint32]uint32)
5270 for i := 0; i < v53; i++ {
5271 v54 := uint32(r.Uint32())
5272 this.Fixed32Map[v54] = uint32(r.Uint32())
5273 }
5274 }
5275 if r.Intn(5) != 0 {
5276 v55 := r.Intn(10)
5277 this.Sfixed32Map = make(map[int32]int32)
5278 for i := 0; i < v55; i++ {
5279 v56 := int32(r.Int31())
5280 this.Sfixed32Map[v56] = int32(r.Int31())
5281 if r.Intn(2) == 0 {
5282 this.Sfixed32Map[v56] *= -1
5283 }
5284 }
5285 }
5286 if r.Intn(5) != 0 {
5287 v57 := r.Intn(10)
5288 this.Fixed64Map = make(map[uint64]uint64)
5289 for i := 0; i < v57; i++ {
5290 v58 := uint64(uint64(r.Uint32()))
5291 this.Fixed64Map[v58] = uint64(uint64(r.Uint32()))
5292 }
5293 }
5294 if r.Intn(5) != 0 {
5295 v59 := r.Intn(10)
5296 this.Sfixed64Map = make(map[int64]int64)
5297 for i := 0; i < v59; i++ {
5298 v60 := int64(r.Int63())
5299 this.Sfixed64Map[v60] = int64(r.Int63())
5300 if r.Intn(2) == 0 {
5301 this.Sfixed64Map[v60] *= -1
5302 }
5303 }
5304 }
5305 if r.Intn(5) != 0 {
5306 v61 := r.Intn(10)
5307 this.BoolMap = make(map[bool]bool)
5308 for i := 0; i < v61; i++ {
5309 v62 := bool(bool(r.Intn(2) == 0))
5310 this.BoolMap[v62] = bool(bool(r.Intn(2) == 0))
5311 }
5312 }
5313 if r.Intn(5) != 0 {
5314 v63 := r.Intn(10)
5315 this.StringMap = make(map[string]string)
5316 for i := 0; i < v63; i++ {
5317 this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r)
5318 }
5319 }
5320 if r.Intn(5) != 0 {
5321 v64 := r.Intn(10)
5322 this.StringToBytesMap = make(map[string][]byte)
5323 for i := 0; i < v64; i++ {
5324 v65 := r.Intn(100)
5325 v66 := randStringTheproto3(r)
5326 this.StringToBytesMap[v66] = make([]byte, v65)
5327 for i := 0; i < v65; i++ {
5328 this.StringToBytesMap[v66][i] = byte(r.Intn(256))
5329 }
5330 }
5331 }
5332 if r.Intn(5) != 0 {
5333 v67 := r.Intn(10)
5334 this.StringToEnumMap = make(map[string]MapEnum)
5335 for i := 0; i < v67; i++ {
5336 this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)])
5337 }
5338 }
5339 if r.Intn(5) != 0 {
5340 v68 := r.Intn(10)
5341 this.StringToMsgMap = make(map[string]*FloatingPoint)
5342 for i := 0; i < v68; i++ {
5343 this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy)
5344 }
5345 }
5346 if !easy && r.Intn(10) != 0 {
5347 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 18)
5348 }
5349 return this
5350 }
5351
5352 func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap {
5353 this := &MessageWithMap{}
5354 if r.Intn(5) != 0 {
5355 v69 := r.Intn(10)
5356 this.NameMapping = make(map[int32]string)
5357 for i := 0; i < v69; i++ {
5358 this.NameMapping[int32(r.Int31())] = randStringTheproto3(r)
5359 }
5360 }
5361 if r.Intn(5) != 0 {
5362 v70 := r.Intn(10)
5363 this.MsgMapping = make(map[int64]*FloatingPoint)
5364 for i := 0; i < v70; i++ {
5365 this.MsgMapping[int64(r.Int63())] = NewPopulatedFloatingPoint(r, easy)
5366 }
5367 }
5368 if r.Intn(5) != 0 {
5369 v71 := r.Intn(10)
5370 this.ByteMapping = make(map[bool][]byte)
5371 for i := 0; i < v71; i++ {
5372 v72 := r.Intn(100)
5373 v73 := bool(bool(r.Intn(2) == 0))
5374 this.ByteMapping[v73] = make([]byte, v72)
5375 for i := 0; i < v72; i++ {
5376 this.ByteMapping[v73][i] = byte(r.Intn(256))
5377 }
5378 }
5379 }
5380 if !easy && r.Intn(10) != 0 {
5381 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 4)
5382 }
5383 return this
5384 }
5385
5386 func NewPopulatedFloatingPoint(r randyTheproto3, easy bool) *FloatingPoint {
5387 this := &FloatingPoint{}
5388 this.F = float64(r.Float64())
5389 if r.Intn(2) == 0 {
5390 this.F *= -1
5391 }
5392 if !easy && r.Intn(10) != 0 {
5393 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 2)
5394 }
5395 return this
5396 }
5397
5398 func NewPopulatedUint128Pair(r randyTheproto3, easy bool) *Uint128Pair {
5399 this := &Uint128Pair{}
5400 v74 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
5401 this.Left = *v74
5402 this.Right = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
5403 if !easy && r.Intn(10) != 0 {
5404 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 3)
5405 }
5406 return this
5407 }
5408
5409 func NewPopulatedContainsNestedMap(r randyTheproto3, easy bool) *ContainsNestedMap {
5410 this := &ContainsNestedMap{}
5411 if !easy && r.Intn(10) != 0 {
5412 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 1)
5413 }
5414 return this
5415 }
5416
5417 func NewPopulatedContainsNestedMap_NestedMap(r randyTheproto3, easy bool) *ContainsNestedMap_NestedMap {
5418 this := &ContainsNestedMap_NestedMap{}
5419 if r.Intn(5) != 0 {
5420 v75 := r.Intn(10)
5421 this.NestedMapField = make(map[string]float64)
5422 for i := 0; i < v75; i++ {
5423 v76 := randStringTheproto3(r)
5424 this.NestedMapField[v76] = float64(r.Float64())
5425 if r.Intn(2) == 0 {
5426 this.NestedMapField[v76] *= -1
5427 }
5428 }
5429 }
5430 if !easy && r.Intn(10) != 0 {
5431 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 2)
5432 }
5433 return this
5434 }
5435
5436 func NewPopulatedNotPacked(r randyTheproto3, easy bool) *NotPacked {
5437 this := &NotPacked{}
5438 v77 := r.Intn(10)
5439 this.Key = make([]uint64, v77)
5440 for i := 0; i < v77; i++ {
5441 this.Key[i] = uint64(uint64(r.Uint32()))
5442 }
5443 if !easy && r.Intn(10) != 0 {
5444 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 6)
5445 }
5446 return this
5447 }
5448
5449 type randyTheproto3 interface {
5450 Float32() float32
5451 Float64() float64
5452 Int63() int64
5453 Int31() int32
5454 Uint32() uint32
5455 Intn(n int) int
5456 }
5457
5458 func randUTF8RuneTheproto3(r randyTheproto3) rune {
5459 ru := r.Intn(62)
5460 if ru < 10 {
5461 return rune(ru + 48)
5462 } else if ru < 36 {
5463 return rune(ru + 55)
5464 }
5465 return rune(ru + 61)
5466 }
5467 func randStringTheproto3(r randyTheproto3) string {
5468 v78 := r.Intn(100)
5469 tmps := make([]rune, v78)
5470 for i := 0; i < v78; i++ {
5471 tmps[i] = randUTF8RuneTheproto3(r)
5472 }
5473 return string(tmps)
5474 }
5475 func randUnrecognizedTheproto3(r randyTheproto3, maxFieldNumber int) (dAtA []byte) {
5476 l := r.Intn(5)
5477 for i := 0; i < l; i++ {
5478 wire := r.Intn(4)
5479 if wire == 3 {
5480 wire = 5
5481 }
5482 fieldNumber := maxFieldNumber + r.Intn(100)
5483 dAtA = randFieldTheproto3(dAtA, r, fieldNumber, wire)
5484 }
5485 return dAtA
5486 }
5487 func randFieldTheproto3(dAtA []byte, r randyTheproto3, fieldNumber int, wire int) []byte {
5488 key := uint32(fieldNumber)<<3 | uint32(wire)
5489 switch wire {
5490 case 0:
5491 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
5492 v79 := r.Int63()
5493 if r.Intn(2) == 0 {
5494 v79 *= -1
5495 }
5496 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(v79))
5497 case 1:
5498 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
5499 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)))
5500 case 2:
5501 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
5502 ll := r.Intn(100)
5503 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(ll))
5504 for j := 0; j < ll; j++ {
5505 dAtA = append(dAtA, byte(r.Intn(256)))
5506 }
5507 default:
5508 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
5509 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
5510 }
5511 return dAtA
5512 }
5513 func encodeVarintPopulateTheproto3(dAtA []byte, v uint64) []byte {
5514 for v >= 1<<7 {
5515 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
5516 v >>= 7
5517 }
5518 dAtA = append(dAtA, uint8(v))
5519 return dAtA
5520 }
5521 func (m *Message) Size() (n int) {
5522 if m == nil {
5523 return 0
5524 }
5525 var l int
5526 _ = l
5527 l = len(m.Name)
5528 if l > 0 {
5529 n += 1 + l + sovTheproto3(uint64(l))
5530 }
5531 if m.Hilarity != 0 {
5532 n += 1 + sovTheproto3(uint64(m.Hilarity))
5533 }
5534 if m.HeightInCm != 0 {
5535 n += 1 + sovTheproto3(uint64(m.HeightInCm))
5536 }
5537 l = len(m.Data)
5538 if l > 0 {
5539 n += 1 + l + sovTheproto3(uint64(l))
5540 }
5541 if len(m.Key) > 0 {
5542 l = 0
5543 for _, e := range m.Key {
5544 l += sovTheproto3(uint64(e))
5545 }
5546 n += 1 + sovTheproto3(uint64(l)) + l
5547 }
5548 if m.Nested != nil {
5549 l = m.Nested.Size()
5550 n += 1 + l + sovTheproto3(uint64(l))
5551 }
5552 if m.ResultCount != 0 {
5553 n += 1 + sovTheproto3(uint64(m.ResultCount))
5554 }
5555 if m.TrueScotsman {
5556 n += 2
5557 }
5558 if m.Score != 0 {
5559 n += 5
5560 }
5561 if len(m.Terrain) > 0 {
5562 for k, v := range m.Terrain {
5563 _ = k
5564 _ = v
5565 l = 0
5566 if v != nil {
5567 l = v.Size()
5568 l += 1 + sovTheproto3(uint64(l))
5569 }
5570 mapEntrySize := 1 + sovTheproto3(uint64(k)) + l
5571 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5572 }
5573 }
5574 if m.Proto2Field != nil {
5575 l = m.Proto2Field.Size()
5576 n += 1 + l + sovTheproto3(uint64(l))
5577 }
5578 if len(m.Proto2Value) > 0 {
5579 for k, v := range m.Proto2Value {
5580 _ = k
5581 _ = v
5582 l = 0
5583 if v != nil {
5584 l = v.Size()
5585 l += 1 + sovTheproto3(uint64(l))
5586 }
5587 mapEntrySize := 1 + sovTheproto3(uint64(k)) + l
5588 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5589 }
5590 }
5591 if m.XXX_unrecognized != nil {
5592 n += len(m.XXX_unrecognized)
5593 }
5594 return n
5595 }
5596
5597 func (m *Nested) Size() (n int) {
5598 if m == nil {
5599 return 0
5600 }
5601 var l int
5602 _ = l
5603 l = len(m.Bunny)
5604 if l > 0 {
5605 n += 1 + l + sovTheproto3(uint64(l))
5606 }
5607 if m.XXX_unrecognized != nil {
5608 n += len(m.XXX_unrecognized)
5609 }
5610 return n
5611 }
5612
5613 func (m *AllMaps) Size() (n int) {
5614 if m == nil {
5615 return 0
5616 }
5617 var l int
5618 _ = l
5619 if len(m.StringToDoubleMap) > 0 {
5620 for k, v := range m.StringToDoubleMap {
5621 _ = k
5622 _ = v
5623 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
5624 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5625 }
5626 }
5627 if len(m.StringToFloatMap) > 0 {
5628 for k, v := range m.StringToFloatMap {
5629 _ = k
5630 _ = v
5631 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4
5632 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5633 }
5634 }
5635 if len(m.Int32Map) > 0 {
5636 for k, v := range m.Int32Map {
5637 _ = k
5638 _ = v
5639 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
5640 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5641 }
5642 }
5643 if len(m.Int64Map) > 0 {
5644 for k, v := range m.Int64Map {
5645 _ = k
5646 _ = v
5647 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
5648 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5649 }
5650 }
5651 if len(m.Uint32Map) > 0 {
5652 for k, v := range m.Uint32Map {
5653 _ = k
5654 _ = v
5655 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
5656 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5657 }
5658 }
5659 if len(m.Uint64Map) > 0 {
5660 for k, v := range m.Uint64Map {
5661 _ = k
5662 _ = v
5663 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
5664 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5665 }
5666 }
5667 if len(m.Sint32Map) > 0 {
5668 for k, v := range m.Sint32Map {
5669 _ = k
5670 _ = v
5671 mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
5672 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5673 }
5674 }
5675 if len(m.Sint64Map) > 0 {
5676 for k, v := range m.Sint64Map {
5677 _ = k
5678 _ = v
5679 mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
5680 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5681 }
5682 }
5683 if len(m.Fixed32Map) > 0 {
5684 for k, v := range m.Fixed32Map {
5685 _ = k
5686 _ = v
5687 mapEntrySize := 1 + 4 + 1 + 4
5688 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5689 }
5690 }
5691 if len(m.Sfixed32Map) > 0 {
5692 for k, v := range m.Sfixed32Map {
5693 _ = k
5694 _ = v
5695 mapEntrySize := 1 + 4 + 1 + 4
5696 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5697 }
5698 }
5699 if len(m.Fixed64Map) > 0 {
5700 for k, v := range m.Fixed64Map {
5701 _ = k
5702 _ = v
5703 mapEntrySize := 1 + 8 + 1 + 8
5704 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5705 }
5706 }
5707 if len(m.Sfixed64Map) > 0 {
5708 for k, v := range m.Sfixed64Map {
5709 _ = k
5710 _ = v
5711 mapEntrySize := 1 + 8 + 1 + 8
5712 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5713 }
5714 }
5715 if len(m.BoolMap) > 0 {
5716 for k, v := range m.BoolMap {
5717 _ = k
5718 _ = v
5719 mapEntrySize := 1 + 1 + 1 + 1
5720 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5721 }
5722 }
5723 if len(m.StringMap) > 0 {
5724 for k, v := range m.StringMap {
5725 _ = k
5726 _ = v
5727 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v)))
5728 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5729 }
5730 }
5731 if len(m.StringToBytesMap) > 0 {
5732 for k, v := range m.StringToBytesMap {
5733 _ = k
5734 _ = v
5735 l = 0
5736 if len(v) > 0 {
5737 l = 1 + len(v) + sovTheproto3(uint64(len(v)))
5738 }
5739 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
5740 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5741 }
5742 }
5743 if len(m.StringToEnumMap) > 0 {
5744 for k, v := range m.StringToEnumMap {
5745 _ = k
5746 _ = v
5747 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v))
5748 n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
5749 }
5750 }
5751 if len(m.StringToMsgMap) > 0 {
5752 for k, v := range m.StringToMsgMap {
5753 _ = k
5754 _ = v
5755 l = 0
5756 if v != nil {
5757 l = v.Size()
5758 l += 1 + sovTheproto3(uint64(l))
5759 }
5760 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
5761 n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
5762 }
5763 }
5764 if m.XXX_unrecognized != nil {
5765 n += len(m.XXX_unrecognized)
5766 }
5767 return n
5768 }
5769
5770 func (m *AllMapsOrdered) Size() (n int) {
5771 if m == nil {
5772 return 0
5773 }
5774 var l int
5775 _ = l
5776 if len(m.StringToDoubleMap) > 0 {
5777 for k, v := range m.StringToDoubleMap {
5778 _ = k
5779 _ = v
5780 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
5781 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5782 }
5783 }
5784 if len(m.StringToFloatMap) > 0 {
5785 for k, v := range m.StringToFloatMap {
5786 _ = k
5787 _ = v
5788 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4
5789 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5790 }
5791 }
5792 if len(m.Int32Map) > 0 {
5793 for k, v := range m.Int32Map {
5794 _ = k
5795 _ = v
5796 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
5797 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5798 }
5799 }
5800 if len(m.Int64Map) > 0 {
5801 for k, v := range m.Int64Map {
5802 _ = k
5803 _ = v
5804 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
5805 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5806 }
5807 }
5808 if len(m.Uint32Map) > 0 {
5809 for k, v := range m.Uint32Map {
5810 _ = k
5811 _ = v
5812 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
5813 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5814 }
5815 }
5816 if len(m.Uint64Map) > 0 {
5817 for k, v := range m.Uint64Map {
5818 _ = k
5819 _ = v
5820 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
5821 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5822 }
5823 }
5824 if len(m.Sint32Map) > 0 {
5825 for k, v := range m.Sint32Map {
5826 _ = k
5827 _ = v
5828 mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
5829 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5830 }
5831 }
5832 if len(m.Sint64Map) > 0 {
5833 for k, v := range m.Sint64Map {
5834 _ = k
5835 _ = v
5836 mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
5837 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5838 }
5839 }
5840 if len(m.Fixed32Map) > 0 {
5841 for k, v := range m.Fixed32Map {
5842 _ = k
5843 _ = v
5844 mapEntrySize := 1 + 4 + 1 + 4
5845 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5846 }
5847 }
5848 if len(m.Sfixed32Map) > 0 {
5849 for k, v := range m.Sfixed32Map {
5850 _ = k
5851 _ = v
5852 mapEntrySize := 1 + 4 + 1 + 4
5853 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5854 }
5855 }
5856 if len(m.Fixed64Map) > 0 {
5857 for k, v := range m.Fixed64Map {
5858 _ = k
5859 _ = v
5860 mapEntrySize := 1 + 8 + 1 + 8
5861 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5862 }
5863 }
5864 if len(m.Sfixed64Map) > 0 {
5865 for k, v := range m.Sfixed64Map {
5866 _ = k
5867 _ = v
5868 mapEntrySize := 1 + 8 + 1 + 8
5869 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5870 }
5871 }
5872 if len(m.BoolMap) > 0 {
5873 for k, v := range m.BoolMap {
5874 _ = k
5875 _ = v
5876 mapEntrySize := 1 + 1 + 1 + 1
5877 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5878 }
5879 }
5880 if len(m.StringMap) > 0 {
5881 for k, v := range m.StringMap {
5882 _ = k
5883 _ = v
5884 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v)))
5885 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5886 }
5887 }
5888 if len(m.StringToBytesMap) > 0 {
5889 for k, v := range m.StringToBytesMap {
5890 _ = k
5891 _ = v
5892 l = 0
5893 if len(v) > 0 {
5894 l = 1 + len(v) + sovTheproto3(uint64(len(v)))
5895 }
5896 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
5897 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5898 }
5899 }
5900 if len(m.StringToEnumMap) > 0 {
5901 for k, v := range m.StringToEnumMap {
5902 _ = k
5903 _ = v
5904 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v))
5905 n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
5906 }
5907 }
5908 if len(m.StringToMsgMap) > 0 {
5909 for k, v := range m.StringToMsgMap {
5910 _ = k
5911 _ = v
5912 l = 0
5913 if v != nil {
5914 l = v.Size()
5915 l += 1 + sovTheproto3(uint64(l))
5916 }
5917 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
5918 n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
5919 }
5920 }
5921 if m.XXX_unrecognized != nil {
5922 n += len(m.XXX_unrecognized)
5923 }
5924 return n
5925 }
5926
5927 func (m *MessageWithMap) Size() (n int) {
5928 if m == nil {
5929 return 0
5930 }
5931 var l int
5932 _ = l
5933 if len(m.NameMapping) > 0 {
5934 for k, v := range m.NameMapping {
5935 _ = k
5936 _ = v
5937 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v)))
5938 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5939 }
5940 }
5941 if len(m.MsgMapping) > 0 {
5942 for k, v := range m.MsgMapping {
5943 _ = k
5944 _ = v
5945 l = 0
5946 if v != nil {
5947 l = v.Size()
5948 l += 1 + sovTheproto3(uint64(l))
5949 }
5950 mapEntrySize := 1 + sozTheproto3(uint64(k)) + l
5951 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5952 }
5953 }
5954 if len(m.ByteMapping) > 0 {
5955 for k, v := range m.ByteMapping {
5956 _ = k
5957 _ = v
5958 l = 0
5959 if len(v) > 0 {
5960 l = 1 + len(v) + sovTheproto3(uint64(len(v)))
5961 }
5962 mapEntrySize := 1 + 1 + l
5963 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
5964 }
5965 }
5966 if m.XXX_unrecognized != nil {
5967 n += len(m.XXX_unrecognized)
5968 }
5969 return n
5970 }
5971
5972 func (m *FloatingPoint) Size() (n int) {
5973 if m == nil {
5974 return 0
5975 }
5976 var l int
5977 _ = l
5978 if m.F != 0 {
5979 n += 9
5980 }
5981 if m.XXX_unrecognized != nil {
5982 n += len(m.XXX_unrecognized)
5983 }
5984 return n
5985 }
5986
5987 func (m *Uint128Pair) Size() (n int) {
5988 if m == nil {
5989 return 0
5990 }
5991 var l int
5992 _ = l
5993 l = m.Left.Size()
5994 n += 1 + l + sovTheproto3(uint64(l))
5995 if m.Right != nil {
5996 l = m.Right.Size()
5997 n += 1 + l + sovTheproto3(uint64(l))
5998 }
5999 if m.XXX_unrecognized != nil {
6000 n += len(m.XXX_unrecognized)
6001 }
6002 return n
6003 }
6004
6005 func (m *ContainsNestedMap) Size() (n int) {
6006 if m == nil {
6007 return 0
6008 }
6009 var l int
6010 _ = l
6011 if m.XXX_unrecognized != nil {
6012 n += len(m.XXX_unrecognized)
6013 }
6014 return n
6015 }
6016
6017 func (m *ContainsNestedMap_NestedMap) Size() (n int) {
6018 if m == nil {
6019 return 0
6020 }
6021 var l int
6022 _ = l
6023 if len(m.NestedMapField) > 0 {
6024 for k, v := range m.NestedMapField {
6025 _ = k
6026 _ = v
6027 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
6028 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
6029 }
6030 }
6031 if m.XXX_unrecognized != nil {
6032 n += len(m.XXX_unrecognized)
6033 }
6034 return n
6035 }
6036
6037 func (m *NotPacked) Size() (n int) {
6038 if m == nil {
6039 return 0
6040 }
6041 var l int
6042 _ = l
6043 if len(m.Key) > 0 {
6044 for _, e := range m.Key {
6045 n += 1 + sovTheproto3(uint64(e))
6046 }
6047 }
6048 if m.XXX_unrecognized != nil {
6049 n += len(m.XXX_unrecognized)
6050 }
6051 return n
6052 }
6053
6054 func sovTheproto3(x uint64) (n int) {
6055 return (math_bits.Len64(x|1) + 6) / 7
6056 }
6057 func sozTheproto3(x uint64) (n int) {
6058 return sovTheproto3(uint64((x << 1) ^ uint64((int64(x) >> 63))))
6059 }
6060 func (this *Message) String() string {
6061 if this == nil {
6062 return "nil"
6063 }
6064 keysForTerrain := make([]int64, 0, len(this.Terrain))
6065 for k := range this.Terrain {
6066 keysForTerrain = append(keysForTerrain, k)
6067 }
6068 github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain)
6069 mapStringForTerrain := "map[int64]*Nested{"
6070 for _, k := range keysForTerrain {
6071 mapStringForTerrain += fmt.Sprintf("%v: %v,", k, this.Terrain[k])
6072 }
6073 mapStringForTerrain += "}"
6074 keysForProto2Value := make([]int64, 0, len(this.Proto2Value))
6075 for k := range this.Proto2Value {
6076 keysForProto2Value = append(keysForProto2Value, k)
6077 }
6078 github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value)
6079 mapStringForProto2Value := "map[int64]*both.NinOptEnum{"
6080 for _, k := range keysForProto2Value {
6081 mapStringForProto2Value += fmt.Sprintf("%v: %v,", k, this.Proto2Value[k])
6082 }
6083 mapStringForProto2Value += "}"
6084 s := strings.Join([]string{`&Message{`,
6085 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
6086 `Hilarity:` + fmt.Sprintf("%v", this.Hilarity) + `,`,
6087 `HeightInCm:` + fmt.Sprintf("%v", this.HeightInCm) + `,`,
6088 `Data:` + fmt.Sprintf("%v", this.Data) + `,`,
6089 `Key:` + fmt.Sprintf("%v", this.Key) + `,`,
6090 `Nested:` + strings.Replace(this.Nested.String(), "Nested", "Nested", 1) + `,`,
6091 `ResultCount:` + fmt.Sprintf("%v", this.ResultCount) + `,`,
6092 `TrueScotsman:` + fmt.Sprintf("%v", this.TrueScotsman) + `,`,
6093 `Score:` + fmt.Sprintf("%v", this.Score) + `,`,
6094 `Terrain:` + mapStringForTerrain + `,`,
6095 `Proto2Field:` + strings.Replace(fmt.Sprintf("%v", this.Proto2Field), "NinOptNative", "both.NinOptNative", 1) + `,`,
6096 `Proto2Value:` + mapStringForProto2Value + `,`,
6097 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
6098 `}`,
6099 }, "")
6100 return s
6101 }
6102 func (this *Nested) String() string {
6103 if this == nil {
6104 return "nil"
6105 }
6106 s := strings.Join([]string{`&Nested{`,
6107 `Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`,
6108 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
6109 `}`,
6110 }, "")
6111 return s
6112 }
6113 func (this *AllMaps) String() string {
6114 if this == nil {
6115 return "nil"
6116 }
6117 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
6118 for k := range this.StringToDoubleMap {
6119 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
6120 }
6121 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
6122 mapStringForStringToDoubleMap := "map[string]float64{"
6123 for _, k := range keysForStringToDoubleMap {
6124 mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k])
6125 }
6126 mapStringForStringToDoubleMap += "}"
6127 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
6128 for k := range this.StringToFloatMap {
6129 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
6130 }
6131 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
6132 mapStringForStringToFloatMap := "map[string]float32{"
6133 for _, k := range keysForStringToFloatMap {
6134 mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k])
6135 }
6136 mapStringForStringToFloatMap += "}"
6137 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
6138 for k := range this.Int32Map {
6139 keysForInt32Map = append(keysForInt32Map, k)
6140 }
6141 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
6142 mapStringForInt32Map := "map[int32]int32{"
6143 for _, k := range keysForInt32Map {
6144 mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k])
6145 }
6146 mapStringForInt32Map += "}"
6147 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
6148 for k := range this.Int64Map {
6149 keysForInt64Map = append(keysForInt64Map, k)
6150 }
6151 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
6152 mapStringForInt64Map := "map[int64]int64{"
6153 for _, k := range keysForInt64Map {
6154 mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k])
6155 }
6156 mapStringForInt64Map += "}"
6157 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
6158 for k := range this.Uint32Map {
6159 keysForUint32Map = append(keysForUint32Map, k)
6160 }
6161 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
6162 mapStringForUint32Map := "map[uint32]uint32{"
6163 for _, k := range keysForUint32Map {
6164 mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k])
6165 }
6166 mapStringForUint32Map += "}"
6167 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
6168 for k := range this.Uint64Map {
6169 keysForUint64Map = append(keysForUint64Map, k)
6170 }
6171 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
6172 mapStringForUint64Map := "map[uint64]uint64{"
6173 for _, k := range keysForUint64Map {
6174 mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k])
6175 }
6176 mapStringForUint64Map += "}"
6177 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
6178 for k := range this.Sint32Map {
6179 keysForSint32Map = append(keysForSint32Map, k)
6180 }
6181 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
6182 mapStringForSint32Map := "map[int32]int32{"
6183 for _, k := range keysForSint32Map {
6184 mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k])
6185 }
6186 mapStringForSint32Map += "}"
6187 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
6188 for k := range this.Sint64Map {
6189 keysForSint64Map = append(keysForSint64Map, k)
6190 }
6191 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
6192 mapStringForSint64Map := "map[int64]int64{"
6193 for _, k := range keysForSint64Map {
6194 mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k])
6195 }
6196 mapStringForSint64Map += "}"
6197 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
6198 for k := range this.Fixed32Map {
6199 keysForFixed32Map = append(keysForFixed32Map, k)
6200 }
6201 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
6202 mapStringForFixed32Map := "map[uint32]uint32{"
6203 for _, k := range keysForFixed32Map {
6204 mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k])
6205 }
6206 mapStringForFixed32Map += "}"
6207 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
6208 for k := range this.Sfixed32Map {
6209 keysForSfixed32Map = append(keysForSfixed32Map, k)
6210 }
6211 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
6212 mapStringForSfixed32Map := "map[int32]int32{"
6213 for _, k := range keysForSfixed32Map {
6214 mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k])
6215 }
6216 mapStringForSfixed32Map += "}"
6217 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
6218 for k := range this.Fixed64Map {
6219 keysForFixed64Map = append(keysForFixed64Map, k)
6220 }
6221 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
6222 mapStringForFixed64Map := "map[uint64]uint64{"
6223 for _, k := range keysForFixed64Map {
6224 mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k])
6225 }
6226 mapStringForFixed64Map += "}"
6227 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
6228 for k := range this.Sfixed64Map {
6229 keysForSfixed64Map = append(keysForSfixed64Map, k)
6230 }
6231 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
6232 mapStringForSfixed64Map := "map[int64]int64{"
6233 for _, k := range keysForSfixed64Map {
6234 mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k])
6235 }
6236 mapStringForSfixed64Map += "}"
6237 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
6238 for k := range this.BoolMap {
6239 keysForBoolMap = append(keysForBoolMap, k)
6240 }
6241 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
6242 mapStringForBoolMap := "map[bool]bool{"
6243 for _, k := range keysForBoolMap {
6244 mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k])
6245 }
6246 mapStringForBoolMap += "}"
6247 keysForStringMap := make([]string, 0, len(this.StringMap))
6248 for k := range this.StringMap {
6249 keysForStringMap = append(keysForStringMap, k)
6250 }
6251 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
6252 mapStringForStringMap := "map[string]string{"
6253 for _, k := range keysForStringMap {
6254 mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k])
6255 }
6256 mapStringForStringMap += "}"
6257 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
6258 for k := range this.StringToBytesMap {
6259 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
6260 }
6261 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
6262 mapStringForStringToBytesMap := "map[string][]byte{"
6263 for _, k := range keysForStringToBytesMap {
6264 mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k])
6265 }
6266 mapStringForStringToBytesMap += "}"
6267 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
6268 for k := range this.StringToEnumMap {
6269 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
6270 }
6271 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
6272 mapStringForStringToEnumMap := "map[string]MapEnum{"
6273 for _, k := range keysForStringToEnumMap {
6274 mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k])
6275 }
6276 mapStringForStringToEnumMap += "}"
6277 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
6278 for k := range this.StringToMsgMap {
6279 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
6280 }
6281 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
6282 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
6283 for _, k := range keysForStringToMsgMap {
6284 mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k])
6285 }
6286 mapStringForStringToMsgMap += "}"
6287 s := strings.Join([]string{`&AllMaps{`,
6288 `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`,
6289 `StringToFloatMap:` + mapStringForStringToFloatMap + `,`,
6290 `Int32Map:` + mapStringForInt32Map + `,`,
6291 `Int64Map:` + mapStringForInt64Map + `,`,
6292 `Uint32Map:` + mapStringForUint32Map + `,`,
6293 `Uint64Map:` + mapStringForUint64Map + `,`,
6294 `Sint32Map:` + mapStringForSint32Map + `,`,
6295 `Sint64Map:` + mapStringForSint64Map + `,`,
6296 `Fixed32Map:` + mapStringForFixed32Map + `,`,
6297 `Sfixed32Map:` + mapStringForSfixed32Map + `,`,
6298 `Fixed64Map:` + mapStringForFixed64Map + `,`,
6299 `Sfixed64Map:` + mapStringForSfixed64Map + `,`,
6300 `BoolMap:` + mapStringForBoolMap + `,`,
6301 `StringMap:` + mapStringForStringMap + `,`,
6302 `StringToBytesMap:` + mapStringForStringToBytesMap + `,`,
6303 `StringToEnumMap:` + mapStringForStringToEnumMap + `,`,
6304 `StringToMsgMap:` + mapStringForStringToMsgMap + `,`,
6305 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
6306 `}`,
6307 }, "")
6308 return s
6309 }
6310 func (this *AllMapsOrdered) String() string {
6311 if this == nil {
6312 return "nil"
6313 }
6314 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
6315 for k := range this.StringToDoubleMap {
6316 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
6317 }
6318 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
6319 mapStringForStringToDoubleMap := "map[string]float64{"
6320 for _, k := range keysForStringToDoubleMap {
6321 mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k])
6322 }
6323 mapStringForStringToDoubleMap += "}"
6324 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
6325 for k := range this.StringToFloatMap {
6326 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
6327 }
6328 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
6329 mapStringForStringToFloatMap := "map[string]float32{"
6330 for _, k := range keysForStringToFloatMap {
6331 mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k])
6332 }
6333 mapStringForStringToFloatMap += "}"
6334 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
6335 for k := range this.Int32Map {
6336 keysForInt32Map = append(keysForInt32Map, k)
6337 }
6338 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
6339 mapStringForInt32Map := "map[int32]int32{"
6340 for _, k := range keysForInt32Map {
6341 mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k])
6342 }
6343 mapStringForInt32Map += "}"
6344 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
6345 for k := range this.Int64Map {
6346 keysForInt64Map = append(keysForInt64Map, k)
6347 }
6348 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
6349 mapStringForInt64Map := "map[int64]int64{"
6350 for _, k := range keysForInt64Map {
6351 mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k])
6352 }
6353 mapStringForInt64Map += "}"
6354 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
6355 for k := range this.Uint32Map {
6356 keysForUint32Map = append(keysForUint32Map, k)
6357 }
6358 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
6359 mapStringForUint32Map := "map[uint32]uint32{"
6360 for _, k := range keysForUint32Map {
6361 mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k])
6362 }
6363 mapStringForUint32Map += "}"
6364 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
6365 for k := range this.Uint64Map {
6366 keysForUint64Map = append(keysForUint64Map, k)
6367 }
6368 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
6369 mapStringForUint64Map := "map[uint64]uint64{"
6370 for _, k := range keysForUint64Map {
6371 mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k])
6372 }
6373 mapStringForUint64Map += "}"
6374 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
6375 for k := range this.Sint32Map {
6376 keysForSint32Map = append(keysForSint32Map, k)
6377 }
6378 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
6379 mapStringForSint32Map := "map[int32]int32{"
6380 for _, k := range keysForSint32Map {
6381 mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k])
6382 }
6383 mapStringForSint32Map += "}"
6384 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
6385 for k := range this.Sint64Map {
6386 keysForSint64Map = append(keysForSint64Map, k)
6387 }
6388 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
6389 mapStringForSint64Map := "map[int64]int64{"
6390 for _, k := range keysForSint64Map {
6391 mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k])
6392 }
6393 mapStringForSint64Map += "}"
6394 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
6395 for k := range this.Fixed32Map {
6396 keysForFixed32Map = append(keysForFixed32Map, k)
6397 }
6398 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
6399 mapStringForFixed32Map := "map[uint32]uint32{"
6400 for _, k := range keysForFixed32Map {
6401 mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k])
6402 }
6403 mapStringForFixed32Map += "}"
6404 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
6405 for k := range this.Sfixed32Map {
6406 keysForSfixed32Map = append(keysForSfixed32Map, k)
6407 }
6408 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
6409 mapStringForSfixed32Map := "map[int32]int32{"
6410 for _, k := range keysForSfixed32Map {
6411 mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k])
6412 }
6413 mapStringForSfixed32Map += "}"
6414 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
6415 for k := range this.Fixed64Map {
6416 keysForFixed64Map = append(keysForFixed64Map, k)
6417 }
6418 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
6419 mapStringForFixed64Map := "map[uint64]uint64{"
6420 for _, k := range keysForFixed64Map {
6421 mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k])
6422 }
6423 mapStringForFixed64Map += "}"
6424 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
6425 for k := range this.Sfixed64Map {
6426 keysForSfixed64Map = append(keysForSfixed64Map, k)
6427 }
6428 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
6429 mapStringForSfixed64Map := "map[int64]int64{"
6430 for _, k := range keysForSfixed64Map {
6431 mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k])
6432 }
6433 mapStringForSfixed64Map += "}"
6434 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
6435 for k := range this.BoolMap {
6436 keysForBoolMap = append(keysForBoolMap, k)
6437 }
6438 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
6439 mapStringForBoolMap := "map[bool]bool{"
6440 for _, k := range keysForBoolMap {
6441 mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k])
6442 }
6443 mapStringForBoolMap += "}"
6444 keysForStringMap := make([]string, 0, len(this.StringMap))
6445 for k := range this.StringMap {
6446 keysForStringMap = append(keysForStringMap, k)
6447 }
6448 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
6449 mapStringForStringMap := "map[string]string{"
6450 for _, k := range keysForStringMap {
6451 mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k])
6452 }
6453 mapStringForStringMap += "}"
6454 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
6455 for k := range this.StringToBytesMap {
6456 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
6457 }
6458 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
6459 mapStringForStringToBytesMap := "map[string][]byte{"
6460 for _, k := range keysForStringToBytesMap {
6461 mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k])
6462 }
6463 mapStringForStringToBytesMap += "}"
6464 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
6465 for k := range this.StringToEnumMap {
6466 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
6467 }
6468 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
6469 mapStringForStringToEnumMap := "map[string]MapEnum{"
6470 for _, k := range keysForStringToEnumMap {
6471 mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k])
6472 }
6473 mapStringForStringToEnumMap += "}"
6474 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
6475 for k := range this.StringToMsgMap {
6476 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
6477 }
6478 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
6479 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
6480 for _, k := range keysForStringToMsgMap {
6481 mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k])
6482 }
6483 mapStringForStringToMsgMap += "}"
6484 s := strings.Join([]string{`&AllMapsOrdered{`,
6485 `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`,
6486 `StringToFloatMap:` + mapStringForStringToFloatMap + `,`,
6487 `Int32Map:` + mapStringForInt32Map + `,`,
6488 `Int64Map:` + mapStringForInt64Map + `,`,
6489 `Uint32Map:` + mapStringForUint32Map + `,`,
6490 `Uint64Map:` + mapStringForUint64Map + `,`,
6491 `Sint32Map:` + mapStringForSint32Map + `,`,
6492 `Sint64Map:` + mapStringForSint64Map + `,`,
6493 `Fixed32Map:` + mapStringForFixed32Map + `,`,
6494 `Sfixed32Map:` + mapStringForSfixed32Map + `,`,
6495 `Fixed64Map:` + mapStringForFixed64Map + `,`,
6496 `Sfixed64Map:` + mapStringForSfixed64Map + `,`,
6497 `BoolMap:` + mapStringForBoolMap + `,`,
6498 `StringMap:` + mapStringForStringMap + `,`,
6499 `StringToBytesMap:` + mapStringForStringToBytesMap + `,`,
6500 `StringToEnumMap:` + mapStringForStringToEnumMap + `,`,
6501 `StringToMsgMap:` + mapStringForStringToMsgMap + `,`,
6502 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
6503 `}`,
6504 }, "")
6505 return s
6506 }
6507 func (this *MessageWithMap) String() string {
6508 if this == nil {
6509 return "nil"
6510 }
6511 keysForNameMapping := make([]int32, 0, len(this.NameMapping))
6512 for k := range this.NameMapping {
6513 keysForNameMapping = append(keysForNameMapping, k)
6514 }
6515 github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping)
6516 mapStringForNameMapping := "map[int32]string{"
6517 for _, k := range keysForNameMapping {
6518 mapStringForNameMapping += fmt.Sprintf("%v: %v,", k, this.NameMapping[k])
6519 }
6520 mapStringForNameMapping += "}"
6521 keysForMsgMapping := make([]int64, 0, len(this.MsgMapping))
6522 for k := range this.MsgMapping {
6523 keysForMsgMapping = append(keysForMsgMapping, k)
6524 }
6525 github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping)
6526 mapStringForMsgMapping := "map[int64]*FloatingPoint{"
6527 for _, k := range keysForMsgMapping {
6528 mapStringForMsgMapping += fmt.Sprintf("%v: %v,", k, this.MsgMapping[k])
6529 }
6530 mapStringForMsgMapping += "}"
6531 keysForByteMapping := make([]bool, 0, len(this.ByteMapping))
6532 for k := range this.ByteMapping {
6533 keysForByteMapping = append(keysForByteMapping, k)
6534 }
6535 github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping)
6536 mapStringForByteMapping := "map[bool][]byte{"
6537 for _, k := range keysForByteMapping {
6538 mapStringForByteMapping += fmt.Sprintf("%v: %v,", k, this.ByteMapping[k])
6539 }
6540 mapStringForByteMapping += "}"
6541 s := strings.Join([]string{`&MessageWithMap{`,
6542 `NameMapping:` + mapStringForNameMapping + `,`,
6543 `MsgMapping:` + mapStringForMsgMapping + `,`,
6544 `ByteMapping:` + mapStringForByteMapping + `,`,
6545 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
6546 `}`,
6547 }, "")
6548 return s
6549 }
6550 func (this *FloatingPoint) String() string {
6551 if this == nil {
6552 return "nil"
6553 }
6554 s := strings.Join([]string{`&FloatingPoint{`,
6555 `F:` + fmt.Sprintf("%v", this.F) + `,`,
6556 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
6557 `}`,
6558 }, "")
6559 return s
6560 }
6561 func (this *Uint128Pair) String() string {
6562 if this == nil {
6563 return "nil"
6564 }
6565 s := strings.Join([]string{`&Uint128Pair{`,
6566 `Left:` + fmt.Sprintf("%v", this.Left) + `,`,
6567 `Right:` + fmt.Sprintf("%v", this.Right) + `,`,
6568 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
6569 `}`,
6570 }, "")
6571 return s
6572 }
6573 func (this *ContainsNestedMap) String() string {
6574 if this == nil {
6575 return "nil"
6576 }
6577 s := strings.Join([]string{`&ContainsNestedMap{`,
6578 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
6579 `}`,
6580 }, "")
6581 return s
6582 }
6583 func (this *ContainsNestedMap_NestedMap) String() string {
6584 if this == nil {
6585 return "nil"
6586 }
6587 keysForNestedMapField := make([]string, 0, len(this.NestedMapField))
6588 for k := range this.NestedMapField {
6589 keysForNestedMapField = append(keysForNestedMapField, k)
6590 }
6591 github_com_gogo_protobuf_sortkeys.Strings(keysForNestedMapField)
6592 mapStringForNestedMapField := "map[string]float64{"
6593 for _, k := range keysForNestedMapField {
6594 mapStringForNestedMapField += fmt.Sprintf("%v: %v,", k, this.NestedMapField[k])
6595 }
6596 mapStringForNestedMapField += "}"
6597 s := strings.Join([]string{`&ContainsNestedMap_NestedMap{`,
6598 `NestedMapField:` + mapStringForNestedMapField + `,`,
6599 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
6600 `}`,
6601 }, "")
6602 return s
6603 }
6604 func (this *NotPacked) String() string {
6605 if this == nil {
6606 return "nil"
6607 }
6608 s := strings.Join([]string{`&NotPacked{`,
6609 `Key:` + fmt.Sprintf("%v", this.Key) + `,`,
6610 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
6611 `}`,
6612 }, "")
6613 return s
6614 }
6615 func valueToStringTheproto3(v interface{}) string {
6616 rv := reflect.ValueOf(v)
6617 if rv.IsNil() {
6618 return "nil"
6619 }
6620 pv := reflect.Indirect(rv).Interface()
6621 return fmt.Sprintf("*%v", pv)
6622 }
6623 func (m *Message) Unmarshal(dAtA []byte) error {
6624 l := len(dAtA)
6625 iNdEx := 0
6626 for iNdEx < l {
6627 preIndex := iNdEx
6628 var wire uint64
6629 for shift := uint(0); ; shift += 7 {
6630 if shift >= 64 {
6631 return ErrIntOverflowTheproto3
6632 }
6633 if iNdEx >= l {
6634 return io.ErrUnexpectedEOF
6635 }
6636 b := dAtA[iNdEx]
6637 iNdEx++
6638 wire |= uint64(b&0x7F) << shift
6639 if b < 0x80 {
6640 break
6641 }
6642 }
6643 fieldNum := int32(wire >> 3)
6644 wireType := int(wire & 0x7)
6645 if wireType == 4 {
6646 return fmt.Errorf("proto: Message: wiretype end group for non-group")
6647 }
6648 if fieldNum <= 0 {
6649 return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire)
6650 }
6651 switch fieldNum {
6652 case 1:
6653 if wireType != 2 {
6654 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6655 }
6656 var stringLen uint64
6657 for shift := uint(0); ; shift += 7 {
6658 if shift >= 64 {
6659 return ErrIntOverflowTheproto3
6660 }
6661 if iNdEx >= l {
6662 return io.ErrUnexpectedEOF
6663 }
6664 b := dAtA[iNdEx]
6665 iNdEx++
6666 stringLen |= uint64(b&0x7F) << shift
6667 if b < 0x80 {
6668 break
6669 }
6670 }
6671 intStringLen := int(stringLen)
6672 if intStringLen < 0 {
6673 return ErrInvalidLengthTheproto3
6674 }
6675 postIndex := iNdEx + intStringLen
6676 if postIndex < 0 {
6677 return ErrInvalidLengthTheproto3
6678 }
6679 if postIndex > l {
6680 return io.ErrUnexpectedEOF
6681 }
6682 m.Name = string(dAtA[iNdEx:postIndex])
6683 iNdEx = postIndex
6684 case 2:
6685 if wireType != 0 {
6686 return fmt.Errorf("proto: wrong wireType = %d for field Hilarity", wireType)
6687 }
6688 m.Hilarity = 0
6689 for shift := uint(0); ; shift += 7 {
6690 if shift >= 64 {
6691 return ErrIntOverflowTheproto3
6692 }
6693 if iNdEx >= l {
6694 return io.ErrUnexpectedEOF
6695 }
6696 b := dAtA[iNdEx]
6697 iNdEx++
6698 m.Hilarity |= Message_Humour(b&0x7F) << shift
6699 if b < 0x80 {
6700 break
6701 }
6702 }
6703 case 3:
6704 if wireType != 0 {
6705 return fmt.Errorf("proto: wrong wireType = %d for field HeightInCm", wireType)
6706 }
6707 m.HeightInCm = 0
6708 for shift := uint(0); ; shift += 7 {
6709 if shift >= 64 {
6710 return ErrIntOverflowTheproto3
6711 }
6712 if iNdEx >= l {
6713 return io.ErrUnexpectedEOF
6714 }
6715 b := dAtA[iNdEx]
6716 iNdEx++
6717 m.HeightInCm |= uint32(b&0x7F) << shift
6718 if b < 0x80 {
6719 break
6720 }
6721 }
6722 case 4:
6723 if wireType != 2 {
6724 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
6725 }
6726 var byteLen int
6727 for shift := uint(0); ; shift += 7 {
6728 if shift >= 64 {
6729 return ErrIntOverflowTheproto3
6730 }
6731 if iNdEx >= l {
6732 return io.ErrUnexpectedEOF
6733 }
6734 b := dAtA[iNdEx]
6735 iNdEx++
6736 byteLen |= int(b&0x7F) << shift
6737 if b < 0x80 {
6738 break
6739 }
6740 }
6741 if byteLen < 0 {
6742 return ErrInvalidLengthTheproto3
6743 }
6744 postIndex := iNdEx + byteLen
6745 if postIndex < 0 {
6746 return ErrInvalidLengthTheproto3
6747 }
6748 if postIndex > l {
6749 return io.ErrUnexpectedEOF
6750 }
6751 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
6752 if m.Data == nil {
6753 m.Data = []byte{}
6754 }
6755 iNdEx = postIndex
6756 case 5:
6757 if wireType == 0 {
6758 var v uint64
6759 for shift := uint(0); ; shift += 7 {
6760 if shift >= 64 {
6761 return ErrIntOverflowTheproto3
6762 }
6763 if iNdEx >= l {
6764 return io.ErrUnexpectedEOF
6765 }
6766 b := dAtA[iNdEx]
6767 iNdEx++
6768 v |= uint64(b&0x7F) << shift
6769 if b < 0x80 {
6770 break
6771 }
6772 }
6773 m.Key = append(m.Key, v)
6774 } else if wireType == 2 {
6775 var packedLen int
6776 for shift := uint(0); ; shift += 7 {
6777 if shift >= 64 {
6778 return ErrIntOverflowTheproto3
6779 }
6780 if iNdEx >= l {
6781 return io.ErrUnexpectedEOF
6782 }
6783 b := dAtA[iNdEx]
6784 iNdEx++
6785 packedLen |= int(b&0x7F) << shift
6786 if b < 0x80 {
6787 break
6788 }
6789 }
6790 if packedLen < 0 {
6791 return ErrInvalidLengthTheproto3
6792 }
6793 postIndex := iNdEx + packedLen
6794 if postIndex < 0 {
6795 return ErrInvalidLengthTheproto3
6796 }
6797 if postIndex > l {
6798 return io.ErrUnexpectedEOF
6799 }
6800 var elementCount int
6801 var count int
6802 for _, integer := range dAtA[iNdEx:postIndex] {
6803 if integer < 128 {
6804 count++
6805 }
6806 }
6807 elementCount = count
6808 if elementCount != 0 && len(m.Key) == 0 {
6809 m.Key = make([]uint64, 0, elementCount)
6810 }
6811 for iNdEx < postIndex {
6812 var v uint64
6813 for shift := uint(0); ; shift += 7 {
6814 if shift >= 64 {
6815 return ErrIntOverflowTheproto3
6816 }
6817 if iNdEx >= l {
6818 return io.ErrUnexpectedEOF
6819 }
6820 b := dAtA[iNdEx]
6821 iNdEx++
6822 v |= uint64(b&0x7F) << shift
6823 if b < 0x80 {
6824 break
6825 }
6826 }
6827 m.Key = append(m.Key, v)
6828 }
6829 } else {
6830 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
6831 }
6832 case 6:
6833 if wireType != 2 {
6834 return fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType)
6835 }
6836 var msglen int
6837 for shift := uint(0); ; shift += 7 {
6838 if shift >= 64 {
6839 return ErrIntOverflowTheproto3
6840 }
6841 if iNdEx >= l {
6842 return io.ErrUnexpectedEOF
6843 }
6844 b := dAtA[iNdEx]
6845 iNdEx++
6846 msglen |= int(b&0x7F) << shift
6847 if b < 0x80 {
6848 break
6849 }
6850 }
6851 if msglen < 0 {
6852 return ErrInvalidLengthTheproto3
6853 }
6854 postIndex := iNdEx + msglen
6855 if postIndex < 0 {
6856 return ErrInvalidLengthTheproto3
6857 }
6858 if postIndex > l {
6859 return io.ErrUnexpectedEOF
6860 }
6861 if m.Nested == nil {
6862 m.Nested = &Nested{}
6863 }
6864 if err := m.Nested.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6865 return err
6866 }
6867 iNdEx = postIndex
6868 case 7:
6869 if wireType != 0 {
6870 return fmt.Errorf("proto: wrong wireType = %d for field ResultCount", wireType)
6871 }
6872 m.ResultCount = 0
6873 for shift := uint(0); ; shift += 7 {
6874 if shift >= 64 {
6875 return ErrIntOverflowTheproto3
6876 }
6877 if iNdEx >= l {
6878 return io.ErrUnexpectedEOF
6879 }
6880 b := dAtA[iNdEx]
6881 iNdEx++
6882 m.ResultCount |= int64(b&0x7F) << shift
6883 if b < 0x80 {
6884 break
6885 }
6886 }
6887 case 8:
6888 if wireType != 0 {
6889 return fmt.Errorf("proto: wrong wireType = %d for field TrueScotsman", wireType)
6890 }
6891 var v int
6892 for shift := uint(0); ; shift += 7 {
6893 if shift >= 64 {
6894 return ErrIntOverflowTheproto3
6895 }
6896 if iNdEx >= l {
6897 return io.ErrUnexpectedEOF
6898 }
6899 b := dAtA[iNdEx]
6900 iNdEx++
6901 v |= int(b&0x7F) << shift
6902 if b < 0x80 {
6903 break
6904 }
6905 }
6906 m.TrueScotsman = bool(v != 0)
6907 case 9:
6908 if wireType != 5 {
6909 return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType)
6910 }
6911 var v uint32
6912 if (iNdEx + 4) > l {
6913 return io.ErrUnexpectedEOF
6914 }
6915 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6916 iNdEx += 4
6917 m.Score = float32(math.Float32frombits(v))
6918 case 10:
6919 if wireType != 2 {
6920 return fmt.Errorf("proto: wrong wireType = %d for field Terrain", wireType)
6921 }
6922 var msglen int
6923 for shift := uint(0); ; shift += 7 {
6924 if shift >= 64 {
6925 return ErrIntOverflowTheproto3
6926 }
6927 if iNdEx >= l {
6928 return io.ErrUnexpectedEOF
6929 }
6930 b := dAtA[iNdEx]
6931 iNdEx++
6932 msglen |= int(b&0x7F) << shift
6933 if b < 0x80 {
6934 break
6935 }
6936 }
6937 if msglen < 0 {
6938 return ErrInvalidLengthTheproto3
6939 }
6940 postIndex := iNdEx + msglen
6941 if postIndex < 0 {
6942 return ErrInvalidLengthTheproto3
6943 }
6944 if postIndex > l {
6945 return io.ErrUnexpectedEOF
6946 }
6947 if m.Terrain == nil {
6948 m.Terrain = make(map[int64]*Nested)
6949 }
6950 var mapkey int64
6951 var mapvalue *Nested
6952 for iNdEx < postIndex {
6953 entryPreIndex := iNdEx
6954 var wire uint64
6955 for shift := uint(0); ; shift += 7 {
6956 if shift >= 64 {
6957 return ErrIntOverflowTheproto3
6958 }
6959 if iNdEx >= l {
6960 return io.ErrUnexpectedEOF
6961 }
6962 b := dAtA[iNdEx]
6963 iNdEx++
6964 wire |= uint64(b&0x7F) << shift
6965 if b < 0x80 {
6966 break
6967 }
6968 }
6969 fieldNum := int32(wire >> 3)
6970 if fieldNum == 1 {
6971 for shift := uint(0); ; shift += 7 {
6972 if shift >= 64 {
6973 return ErrIntOverflowTheproto3
6974 }
6975 if iNdEx >= l {
6976 return io.ErrUnexpectedEOF
6977 }
6978 b := dAtA[iNdEx]
6979 iNdEx++
6980 mapkey |= int64(b&0x7F) << shift
6981 if b < 0x80 {
6982 break
6983 }
6984 }
6985 } else if fieldNum == 2 {
6986 var mapmsglen int
6987 for shift := uint(0); ; shift += 7 {
6988 if shift >= 64 {
6989 return ErrIntOverflowTheproto3
6990 }
6991 if iNdEx >= l {
6992 return io.ErrUnexpectedEOF
6993 }
6994 b := dAtA[iNdEx]
6995 iNdEx++
6996 mapmsglen |= int(b&0x7F) << shift
6997 if b < 0x80 {
6998 break
6999 }
7000 }
7001 if mapmsglen < 0 {
7002 return ErrInvalidLengthTheproto3
7003 }
7004 postmsgIndex := iNdEx + mapmsglen
7005 if postmsgIndex < 0 {
7006 return ErrInvalidLengthTheproto3
7007 }
7008 if postmsgIndex > l {
7009 return io.ErrUnexpectedEOF
7010 }
7011 mapvalue = &Nested{}
7012 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
7013 return err
7014 }
7015 iNdEx = postmsgIndex
7016 } else {
7017 iNdEx = entryPreIndex
7018 skippy, err := skipTheproto3(dAtA[iNdEx:])
7019 if err != nil {
7020 return err
7021 }
7022 if (skippy < 0) || (iNdEx+skippy) < 0 {
7023 return ErrInvalidLengthTheproto3
7024 }
7025 if (iNdEx + skippy) > postIndex {
7026 return io.ErrUnexpectedEOF
7027 }
7028 iNdEx += skippy
7029 }
7030 }
7031 m.Terrain[mapkey] = mapvalue
7032 iNdEx = postIndex
7033 case 11:
7034 if wireType != 2 {
7035 return fmt.Errorf("proto: wrong wireType = %d for field Proto2Field", wireType)
7036 }
7037 var msglen int
7038 for shift := uint(0); ; shift += 7 {
7039 if shift >= 64 {
7040 return ErrIntOverflowTheproto3
7041 }
7042 if iNdEx >= l {
7043 return io.ErrUnexpectedEOF
7044 }
7045 b := dAtA[iNdEx]
7046 iNdEx++
7047 msglen |= int(b&0x7F) << shift
7048 if b < 0x80 {
7049 break
7050 }
7051 }
7052 if msglen < 0 {
7053 return ErrInvalidLengthTheproto3
7054 }
7055 postIndex := iNdEx + msglen
7056 if postIndex < 0 {
7057 return ErrInvalidLengthTheproto3
7058 }
7059 if postIndex > l {
7060 return io.ErrUnexpectedEOF
7061 }
7062 if m.Proto2Field == nil {
7063 m.Proto2Field = &both.NinOptNative{}
7064 }
7065 if err := m.Proto2Field.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7066 return err
7067 }
7068 iNdEx = postIndex
7069 case 13:
7070 if wireType != 2 {
7071 return fmt.Errorf("proto: wrong wireType = %d for field Proto2Value", wireType)
7072 }
7073 var msglen int
7074 for shift := uint(0); ; shift += 7 {
7075 if shift >= 64 {
7076 return ErrIntOverflowTheproto3
7077 }
7078 if iNdEx >= l {
7079 return io.ErrUnexpectedEOF
7080 }
7081 b := dAtA[iNdEx]
7082 iNdEx++
7083 msglen |= int(b&0x7F) << shift
7084 if b < 0x80 {
7085 break
7086 }
7087 }
7088 if msglen < 0 {
7089 return ErrInvalidLengthTheproto3
7090 }
7091 postIndex := iNdEx + msglen
7092 if postIndex < 0 {
7093 return ErrInvalidLengthTheproto3
7094 }
7095 if postIndex > l {
7096 return io.ErrUnexpectedEOF
7097 }
7098 if m.Proto2Value == nil {
7099 m.Proto2Value = make(map[int64]*both.NinOptEnum)
7100 }
7101 var mapkey int64
7102 var mapvalue *both.NinOptEnum
7103 for iNdEx < postIndex {
7104 entryPreIndex := iNdEx
7105 var wire uint64
7106 for shift := uint(0); ; shift += 7 {
7107 if shift >= 64 {
7108 return ErrIntOverflowTheproto3
7109 }
7110 if iNdEx >= l {
7111 return io.ErrUnexpectedEOF
7112 }
7113 b := dAtA[iNdEx]
7114 iNdEx++
7115 wire |= uint64(b&0x7F) << shift
7116 if b < 0x80 {
7117 break
7118 }
7119 }
7120 fieldNum := int32(wire >> 3)
7121 if fieldNum == 1 {
7122 for shift := uint(0); ; shift += 7 {
7123 if shift >= 64 {
7124 return ErrIntOverflowTheproto3
7125 }
7126 if iNdEx >= l {
7127 return io.ErrUnexpectedEOF
7128 }
7129 b := dAtA[iNdEx]
7130 iNdEx++
7131 mapkey |= int64(b&0x7F) << shift
7132 if b < 0x80 {
7133 break
7134 }
7135 }
7136 } else if fieldNum == 2 {
7137 var mapmsglen int
7138 for shift := uint(0); ; shift += 7 {
7139 if shift >= 64 {
7140 return ErrIntOverflowTheproto3
7141 }
7142 if iNdEx >= l {
7143 return io.ErrUnexpectedEOF
7144 }
7145 b := dAtA[iNdEx]
7146 iNdEx++
7147 mapmsglen |= int(b&0x7F) << shift
7148 if b < 0x80 {
7149 break
7150 }
7151 }
7152 if mapmsglen < 0 {
7153 return ErrInvalidLengthTheproto3
7154 }
7155 postmsgIndex := iNdEx + mapmsglen
7156 if postmsgIndex < 0 {
7157 return ErrInvalidLengthTheproto3
7158 }
7159 if postmsgIndex > l {
7160 return io.ErrUnexpectedEOF
7161 }
7162 mapvalue = &both.NinOptEnum{}
7163 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
7164 return err
7165 }
7166 iNdEx = postmsgIndex
7167 } else {
7168 iNdEx = entryPreIndex
7169 skippy, err := skipTheproto3(dAtA[iNdEx:])
7170 if err != nil {
7171 return err
7172 }
7173 if (skippy < 0) || (iNdEx+skippy) < 0 {
7174 return ErrInvalidLengthTheproto3
7175 }
7176 if (iNdEx + skippy) > postIndex {
7177 return io.ErrUnexpectedEOF
7178 }
7179 iNdEx += skippy
7180 }
7181 }
7182 m.Proto2Value[mapkey] = mapvalue
7183 iNdEx = postIndex
7184 default:
7185 iNdEx = preIndex
7186 skippy, err := skipTheproto3(dAtA[iNdEx:])
7187 if err != nil {
7188 return err
7189 }
7190 if (skippy < 0) || (iNdEx+skippy) < 0 {
7191 return ErrInvalidLengthTheproto3
7192 }
7193 if (iNdEx + skippy) > l {
7194 return io.ErrUnexpectedEOF
7195 }
7196 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7197 iNdEx += skippy
7198 }
7199 }
7200
7201 if iNdEx > l {
7202 return io.ErrUnexpectedEOF
7203 }
7204 return nil
7205 }
7206 func (m *Nested) Unmarshal(dAtA []byte) error {
7207 l := len(dAtA)
7208 iNdEx := 0
7209 for iNdEx < l {
7210 preIndex := iNdEx
7211 var wire uint64
7212 for shift := uint(0); ; shift += 7 {
7213 if shift >= 64 {
7214 return ErrIntOverflowTheproto3
7215 }
7216 if iNdEx >= l {
7217 return io.ErrUnexpectedEOF
7218 }
7219 b := dAtA[iNdEx]
7220 iNdEx++
7221 wire |= uint64(b&0x7F) << shift
7222 if b < 0x80 {
7223 break
7224 }
7225 }
7226 fieldNum := int32(wire >> 3)
7227 wireType := int(wire & 0x7)
7228 if wireType == 4 {
7229 return fmt.Errorf("proto: Nested: wiretype end group for non-group")
7230 }
7231 if fieldNum <= 0 {
7232 return fmt.Errorf("proto: Nested: illegal tag %d (wire type %d)", fieldNum, wire)
7233 }
7234 switch fieldNum {
7235 case 1:
7236 if wireType != 2 {
7237 return fmt.Errorf("proto: wrong wireType = %d for field Bunny", wireType)
7238 }
7239 var stringLen uint64
7240 for shift := uint(0); ; shift += 7 {
7241 if shift >= 64 {
7242 return ErrIntOverflowTheproto3
7243 }
7244 if iNdEx >= l {
7245 return io.ErrUnexpectedEOF
7246 }
7247 b := dAtA[iNdEx]
7248 iNdEx++
7249 stringLen |= uint64(b&0x7F) << shift
7250 if b < 0x80 {
7251 break
7252 }
7253 }
7254 intStringLen := int(stringLen)
7255 if intStringLen < 0 {
7256 return ErrInvalidLengthTheproto3
7257 }
7258 postIndex := iNdEx + intStringLen
7259 if postIndex < 0 {
7260 return ErrInvalidLengthTheproto3
7261 }
7262 if postIndex > l {
7263 return io.ErrUnexpectedEOF
7264 }
7265 m.Bunny = string(dAtA[iNdEx:postIndex])
7266 iNdEx = postIndex
7267 default:
7268 iNdEx = preIndex
7269 skippy, err := skipTheproto3(dAtA[iNdEx:])
7270 if err != nil {
7271 return err
7272 }
7273 if (skippy < 0) || (iNdEx+skippy) < 0 {
7274 return ErrInvalidLengthTheproto3
7275 }
7276 if (iNdEx + skippy) > l {
7277 return io.ErrUnexpectedEOF
7278 }
7279 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7280 iNdEx += skippy
7281 }
7282 }
7283
7284 if iNdEx > l {
7285 return io.ErrUnexpectedEOF
7286 }
7287 return nil
7288 }
7289 func (m *AllMaps) Unmarshal(dAtA []byte) error {
7290 l := len(dAtA)
7291 iNdEx := 0
7292 for iNdEx < l {
7293 preIndex := iNdEx
7294 var wire uint64
7295 for shift := uint(0); ; shift += 7 {
7296 if shift >= 64 {
7297 return ErrIntOverflowTheproto3
7298 }
7299 if iNdEx >= l {
7300 return io.ErrUnexpectedEOF
7301 }
7302 b := dAtA[iNdEx]
7303 iNdEx++
7304 wire |= uint64(b&0x7F) << shift
7305 if b < 0x80 {
7306 break
7307 }
7308 }
7309 fieldNum := int32(wire >> 3)
7310 wireType := int(wire & 0x7)
7311 if wireType == 4 {
7312 return fmt.Errorf("proto: AllMaps: wiretype end group for non-group")
7313 }
7314 if fieldNum <= 0 {
7315 return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire)
7316 }
7317 switch fieldNum {
7318 case 1:
7319 if wireType != 2 {
7320 return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType)
7321 }
7322 var msglen int
7323 for shift := uint(0); ; shift += 7 {
7324 if shift >= 64 {
7325 return ErrIntOverflowTheproto3
7326 }
7327 if iNdEx >= l {
7328 return io.ErrUnexpectedEOF
7329 }
7330 b := dAtA[iNdEx]
7331 iNdEx++
7332 msglen |= int(b&0x7F) << shift
7333 if b < 0x80 {
7334 break
7335 }
7336 }
7337 if msglen < 0 {
7338 return ErrInvalidLengthTheproto3
7339 }
7340 postIndex := iNdEx + msglen
7341 if postIndex < 0 {
7342 return ErrInvalidLengthTheproto3
7343 }
7344 if postIndex > l {
7345 return io.ErrUnexpectedEOF
7346 }
7347 if m.StringToDoubleMap == nil {
7348 m.StringToDoubleMap = make(map[string]float64)
7349 }
7350 var mapkey string
7351 var mapvalue float64
7352 for iNdEx < postIndex {
7353 entryPreIndex := iNdEx
7354 var wire uint64
7355 for shift := uint(0); ; shift += 7 {
7356 if shift >= 64 {
7357 return ErrIntOverflowTheproto3
7358 }
7359 if iNdEx >= l {
7360 return io.ErrUnexpectedEOF
7361 }
7362 b := dAtA[iNdEx]
7363 iNdEx++
7364 wire |= uint64(b&0x7F) << shift
7365 if b < 0x80 {
7366 break
7367 }
7368 }
7369 fieldNum := int32(wire >> 3)
7370 if fieldNum == 1 {
7371 var stringLenmapkey uint64
7372 for shift := uint(0); ; shift += 7 {
7373 if shift >= 64 {
7374 return ErrIntOverflowTheproto3
7375 }
7376 if iNdEx >= l {
7377 return io.ErrUnexpectedEOF
7378 }
7379 b := dAtA[iNdEx]
7380 iNdEx++
7381 stringLenmapkey |= uint64(b&0x7F) << shift
7382 if b < 0x80 {
7383 break
7384 }
7385 }
7386 intStringLenmapkey := int(stringLenmapkey)
7387 if intStringLenmapkey < 0 {
7388 return ErrInvalidLengthTheproto3
7389 }
7390 postStringIndexmapkey := iNdEx + intStringLenmapkey
7391 if postStringIndexmapkey < 0 {
7392 return ErrInvalidLengthTheproto3
7393 }
7394 if postStringIndexmapkey > l {
7395 return io.ErrUnexpectedEOF
7396 }
7397 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7398 iNdEx = postStringIndexmapkey
7399 } else if fieldNum == 2 {
7400 var mapvaluetemp uint64
7401 if (iNdEx + 8) > l {
7402 return io.ErrUnexpectedEOF
7403 }
7404 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7405 iNdEx += 8
7406 mapvalue = math.Float64frombits(mapvaluetemp)
7407 } else {
7408 iNdEx = entryPreIndex
7409 skippy, err := skipTheproto3(dAtA[iNdEx:])
7410 if err != nil {
7411 return err
7412 }
7413 if (skippy < 0) || (iNdEx+skippy) < 0 {
7414 return ErrInvalidLengthTheproto3
7415 }
7416 if (iNdEx + skippy) > postIndex {
7417 return io.ErrUnexpectedEOF
7418 }
7419 iNdEx += skippy
7420 }
7421 }
7422 m.StringToDoubleMap[mapkey] = mapvalue
7423 iNdEx = postIndex
7424 case 2:
7425 if wireType != 2 {
7426 return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType)
7427 }
7428 var msglen int
7429 for shift := uint(0); ; shift += 7 {
7430 if shift >= 64 {
7431 return ErrIntOverflowTheproto3
7432 }
7433 if iNdEx >= l {
7434 return io.ErrUnexpectedEOF
7435 }
7436 b := dAtA[iNdEx]
7437 iNdEx++
7438 msglen |= int(b&0x7F) << shift
7439 if b < 0x80 {
7440 break
7441 }
7442 }
7443 if msglen < 0 {
7444 return ErrInvalidLengthTheproto3
7445 }
7446 postIndex := iNdEx + msglen
7447 if postIndex < 0 {
7448 return ErrInvalidLengthTheproto3
7449 }
7450 if postIndex > l {
7451 return io.ErrUnexpectedEOF
7452 }
7453 if m.StringToFloatMap == nil {
7454 m.StringToFloatMap = make(map[string]float32)
7455 }
7456 var mapkey string
7457 var mapvalue float32
7458 for iNdEx < postIndex {
7459 entryPreIndex := iNdEx
7460 var wire uint64
7461 for shift := uint(0); ; shift += 7 {
7462 if shift >= 64 {
7463 return ErrIntOverflowTheproto3
7464 }
7465 if iNdEx >= l {
7466 return io.ErrUnexpectedEOF
7467 }
7468 b := dAtA[iNdEx]
7469 iNdEx++
7470 wire |= uint64(b&0x7F) << shift
7471 if b < 0x80 {
7472 break
7473 }
7474 }
7475 fieldNum := int32(wire >> 3)
7476 if fieldNum == 1 {
7477 var stringLenmapkey uint64
7478 for shift := uint(0); ; shift += 7 {
7479 if shift >= 64 {
7480 return ErrIntOverflowTheproto3
7481 }
7482 if iNdEx >= l {
7483 return io.ErrUnexpectedEOF
7484 }
7485 b := dAtA[iNdEx]
7486 iNdEx++
7487 stringLenmapkey |= uint64(b&0x7F) << shift
7488 if b < 0x80 {
7489 break
7490 }
7491 }
7492 intStringLenmapkey := int(stringLenmapkey)
7493 if intStringLenmapkey < 0 {
7494 return ErrInvalidLengthTheproto3
7495 }
7496 postStringIndexmapkey := iNdEx + intStringLenmapkey
7497 if postStringIndexmapkey < 0 {
7498 return ErrInvalidLengthTheproto3
7499 }
7500 if postStringIndexmapkey > l {
7501 return io.ErrUnexpectedEOF
7502 }
7503 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7504 iNdEx = postStringIndexmapkey
7505 } else if fieldNum == 2 {
7506 var mapvaluetemp uint32
7507 if (iNdEx + 4) > l {
7508 return io.ErrUnexpectedEOF
7509 }
7510 mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
7511 iNdEx += 4
7512 mapvalue = math.Float32frombits(mapvaluetemp)
7513 } else {
7514 iNdEx = entryPreIndex
7515 skippy, err := skipTheproto3(dAtA[iNdEx:])
7516 if err != nil {
7517 return err
7518 }
7519 if (skippy < 0) || (iNdEx+skippy) < 0 {
7520 return ErrInvalidLengthTheproto3
7521 }
7522 if (iNdEx + skippy) > postIndex {
7523 return io.ErrUnexpectedEOF
7524 }
7525 iNdEx += skippy
7526 }
7527 }
7528 m.StringToFloatMap[mapkey] = mapvalue
7529 iNdEx = postIndex
7530 case 3:
7531 if wireType != 2 {
7532 return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType)
7533 }
7534 var msglen int
7535 for shift := uint(0); ; shift += 7 {
7536 if shift >= 64 {
7537 return ErrIntOverflowTheproto3
7538 }
7539 if iNdEx >= l {
7540 return io.ErrUnexpectedEOF
7541 }
7542 b := dAtA[iNdEx]
7543 iNdEx++
7544 msglen |= int(b&0x7F) << shift
7545 if b < 0x80 {
7546 break
7547 }
7548 }
7549 if msglen < 0 {
7550 return ErrInvalidLengthTheproto3
7551 }
7552 postIndex := iNdEx + msglen
7553 if postIndex < 0 {
7554 return ErrInvalidLengthTheproto3
7555 }
7556 if postIndex > l {
7557 return io.ErrUnexpectedEOF
7558 }
7559 if m.Int32Map == nil {
7560 m.Int32Map = make(map[int32]int32)
7561 }
7562 var mapkey int32
7563 var mapvalue int32
7564 for iNdEx < postIndex {
7565 entryPreIndex := iNdEx
7566 var wire uint64
7567 for shift := uint(0); ; shift += 7 {
7568 if shift >= 64 {
7569 return ErrIntOverflowTheproto3
7570 }
7571 if iNdEx >= l {
7572 return io.ErrUnexpectedEOF
7573 }
7574 b := dAtA[iNdEx]
7575 iNdEx++
7576 wire |= uint64(b&0x7F) << shift
7577 if b < 0x80 {
7578 break
7579 }
7580 }
7581 fieldNum := int32(wire >> 3)
7582 if fieldNum == 1 {
7583 for shift := uint(0); ; shift += 7 {
7584 if shift >= 64 {
7585 return ErrIntOverflowTheproto3
7586 }
7587 if iNdEx >= l {
7588 return io.ErrUnexpectedEOF
7589 }
7590 b := dAtA[iNdEx]
7591 iNdEx++
7592 mapkey |= int32(b&0x7F) << shift
7593 if b < 0x80 {
7594 break
7595 }
7596 }
7597 } else if fieldNum == 2 {
7598 for shift := uint(0); ; shift += 7 {
7599 if shift >= 64 {
7600 return ErrIntOverflowTheproto3
7601 }
7602 if iNdEx >= l {
7603 return io.ErrUnexpectedEOF
7604 }
7605 b := dAtA[iNdEx]
7606 iNdEx++
7607 mapvalue |= int32(b&0x7F) << shift
7608 if b < 0x80 {
7609 break
7610 }
7611 }
7612 } else {
7613 iNdEx = entryPreIndex
7614 skippy, err := skipTheproto3(dAtA[iNdEx:])
7615 if err != nil {
7616 return err
7617 }
7618 if (skippy < 0) || (iNdEx+skippy) < 0 {
7619 return ErrInvalidLengthTheproto3
7620 }
7621 if (iNdEx + skippy) > postIndex {
7622 return io.ErrUnexpectedEOF
7623 }
7624 iNdEx += skippy
7625 }
7626 }
7627 m.Int32Map[mapkey] = mapvalue
7628 iNdEx = postIndex
7629 case 4:
7630 if wireType != 2 {
7631 return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType)
7632 }
7633 var msglen int
7634 for shift := uint(0); ; shift += 7 {
7635 if shift >= 64 {
7636 return ErrIntOverflowTheproto3
7637 }
7638 if iNdEx >= l {
7639 return io.ErrUnexpectedEOF
7640 }
7641 b := dAtA[iNdEx]
7642 iNdEx++
7643 msglen |= int(b&0x7F) << shift
7644 if b < 0x80 {
7645 break
7646 }
7647 }
7648 if msglen < 0 {
7649 return ErrInvalidLengthTheproto3
7650 }
7651 postIndex := iNdEx + msglen
7652 if postIndex < 0 {
7653 return ErrInvalidLengthTheproto3
7654 }
7655 if postIndex > l {
7656 return io.ErrUnexpectedEOF
7657 }
7658 if m.Int64Map == nil {
7659 m.Int64Map = make(map[int64]int64)
7660 }
7661 var mapkey int64
7662 var mapvalue int64
7663 for iNdEx < postIndex {
7664 entryPreIndex := iNdEx
7665 var wire uint64
7666 for shift := uint(0); ; shift += 7 {
7667 if shift >= 64 {
7668 return ErrIntOverflowTheproto3
7669 }
7670 if iNdEx >= l {
7671 return io.ErrUnexpectedEOF
7672 }
7673 b := dAtA[iNdEx]
7674 iNdEx++
7675 wire |= uint64(b&0x7F) << shift
7676 if b < 0x80 {
7677 break
7678 }
7679 }
7680 fieldNum := int32(wire >> 3)
7681 if fieldNum == 1 {
7682 for shift := uint(0); ; shift += 7 {
7683 if shift >= 64 {
7684 return ErrIntOverflowTheproto3
7685 }
7686 if iNdEx >= l {
7687 return io.ErrUnexpectedEOF
7688 }
7689 b := dAtA[iNdEx]
7690 iNdEx++
7691 mapkey |= int64(b&0x7F) << shift
7692 if b < 0x80 {
7693 break
7694 }
7695 }
7696 } else if fieldNum == 2 {
7697 for shift := uint(0); ; shift += 7 {
7698 if shift >= 64 {
7699 return ErrIntOverflowTheproto3
7700 }
7701 if iNdEx >= l {
7702 return io.ErrUnexpectedEOF
7703 }
7704 b := dAtA[iNdEx]
7705 iNdEx++
7706 mapvalue |= int64(b&0x7F) << shift
7707 if b < 0x80 {
7708 break
7709 }
7710 }
7711 } else {
7712 iNdEx = entryPreIndex
7713 skippy, err := skipTheproto3(dAtA[iNdEx:])
7714 if err != nil {
7715 return err
7716 }
7717 if (skippy < 0) || (iNdEx+skippy) < 0 {
7718 return ErrInvalidLengthTheproto3
7719 }
7720 if (iNdEx + skippy) > postIndex {
7721 return io.ErrUnexpectedEOF
7722 }
7723 iNdEx += skippy
7724 }
7725 }
7726 m.Int64Map[mapkey] = mapvalue
7727 iNdEx = postIndex
7728 case 5:
7729 if wireType != 2 {
7730 return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType)
7731 }
7732 var msglen int
7733 for shift := uint(0); ; shift += 7 {
7734 if shift >= 64 {
7735 return ErrIntOverflowTheproto3
7736 }
7737 if iNdEx >= l {
7738 return io.ErrUnexpectedEOF
7739 }
7740 b := dAtA[iNdEx]
7741 iNdEx++
7742 msglen |= int(b&0x7F) << shift
7743 if b < 0x80 {
7744 break
7745 }
7746 }
7747 if msglen < 0 {
7748 return ErrInvalidLengthTheproto3
7749 }
7750 postIndex := iNdEx + msglen
7751 if postIndex < 0 {
7752 return ErrInvalidLengthTheproto3
7753 }
7754 if postIndex > l {
7755 return io.ErrUnexpectedEOF
7756 }
7757 if m.Uint32Map == nil {
7758 m.Uint32Map = make(map[uint32]uint32)
7759 }
7760 var mapkey uint32
7761 var mapvalue uint32
7762 for iNdEx < postIndex {
7763 entryPreIndex := iNdEx
7764 var wire uint64
7765 for shift := uint(0); ; shift += 7 {
7766 if shift >= 64 {
7767 return ErrIntOverflowTheproto3
7768 }
7769 if iNdEx >= l {
7770 return io.ErrUnexpectedEOF
7771 }
7772 b := dAtA[iNdEx]
7773 iNdEx++
7774 wire |= uint64(b&0x7F) << shift
7775 if b < 0x80 {
7776 break
7777 }
7778 }
7779 fieldNum := int32(wire >> 3)
7780 if fieldNum == 1 {
7781 for shift := uint(0); ; shift += 7 {
7782 if shift >= 64 {
7783 return ErrIntOverflowTheproto3
7784 }
7785 if iNdEx >= l {
7786 return io.ErrUnexpectedEOF
7787 }
7788 b := dAtA[iNdEx]
7789 iNdEx++
7790 mapkey |= uint32(b&0x7F) << shift
7791 if b < 0x80 {
7792 break
7793 }
7794 }
7795 } else if fieldNum == 2 {
7796 for shift := uint(0); ; shift += 7 {
7797 if shift >= 64 {
7798 return ErrIntOverflowTheproto3
7799 }
7800 if iNdEx >= l {
7801 return io.ErrUnexpectedEOF
7802 }
7803 b := dAtA[iNdEx]
7804 iNdEx++
7805 mapvalue |= uint32(b&0x7F) << shift
7806 if b < 0x80 {
7807 break
7808 }
7809 }
7810 } else {
7811 iNdEx = entryPreIndex
7812 skippy, err := skipTheproto3(dAtA[iNdEx:])
7813 if err != nil {
7814 return err
7815 }
7816 if (skippy < 0) || (iNdEx+skippy) < 0 {
7817 return ErrInvalidLengthTheproto3
7818 }
7819 if (iNdEx + skippy) > postIndex {
7820 return io.ErrUnexpectedEOF
7821 }
7822 iNdEx += skippy
7823 }
7824 }
7825 m.Uint32Map[mapkey] = mapvalue
7826 iNdEx = postIndex
7827 case 6:
7828 if wireType != 2 {
7829 return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType)
7830 }
7831 var msglen int
7832 for shift := uint(0); ; shift += 7 {
7833 if shift >= 64 {
7834 return ErrIntOverflowTheproto3
7835 }
7836 if iNdEx >= l {
7837 return io.ErrUnexpectedEOF
7838 }
7839 b := dAtA[iNdEx]
7840 iNdEx++
7841 msglen |= int(b&0x7F) << shift
7842 if b < 0x80 {
7843 break
7844 }
7845 }
7846 if msglen < 0 {
7847 return ErrInvalidLengthTheproto3
7848 }
7849 postIndex := iNdEx + msglen
7850 if postIndex < 0 {
7851 return ErrInvalidLengthTheproto3
7852 }
7853 if postIndex > l {
7854 return io.ErrUnexpectedEOF
7855 }
7856 if m.Uint64Map == nil {
7857 m.Uint64Map = make(map[uint64]uint64)
7858 }
7859 var mapkey uint64
7860 var mapvalue uint64
7861 for iNdEx < postIndex {
7862 entryPreIndex := iNdEx
7863 var wire uint64
7864 for shift := uint(0); ; shift += 7 {
7865 if shift >= 64 {
7866 return ErrIntOverflowTheproto3
7867 }
7868 if iNdEx >= l {
7869 return io.ErrUnexpectedEOF
7870 }
7871 b := dAtA[iNdEx]
7872 iNdEx++
7873 wire |= uint64(b&0x7F) << shift
7874 if b < 0x80 {
7875 break
7876 }
7877 }
7878 fieldNum := int32(wire >> 3)
7879 if fieldNum == 1 {
7880 for shift := uint(0); ; shift += 7 {
7881 if shift >= 64 {
7882 return ErrIntOverflowTheproto3
7883 }
7884 if iNdEx >= l {
7885 return io.ErrUnexpectedEOF
7886 }
7887 b := dAtA[iNdEx]
7888 iNdEx++
7889 mapkey |= uint64(b&0x7F) << shift
7890 if b < 0x80 {
7891 break
7892 }
7893 }
7894 } else if fieldNum == 2 {
7895 for shift := uint(0); ; shift += 7 {
7896 if shift >= 64 {
7897 return ErrIntOverflowTheproto3
7898 }
7899 if iNdEx >= l {
7900 return io.ErrUnexpectedEOF
7901 }
7902 b := dAtA[iNdEx]
7903 iNdEx++
7904 mapvalue |= uint64(b&0x7F) << shift
7905 if b < 0x80 {
7906 break
7907 }
7908 }
7909 } else {
7910 iNdEx = entryPreIndex
7911 skippy, err := skipTheproto3(dAtA[iNdEx:])
7912 if err != nil {
7913 return err
7914 }
7915 if (skippy < 0) || (iNdEx+skippy) < 0 {
7916 return ErrInvalidLengthTheproto3
7917 }
7918 if (iNdEx + skippy) > postIndex {
7919 return io.ErrUnexpectedEOF
7920 }
7921 iNdEx += skippy
7922 }
7923 }
7924 m.Uint64Map[mapkey] = mapvalue
7925 iNdEx = postIndex
7926 case 7:
7927 if wireType != 2 {
7928 return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType)
7929 }
7930 var msglen int
7931 for shift := uint(0); ; shift += 7 {
7932 if shift >= 64 {
7933 return ErrIntOverflowTheproto3
7934 }
7935 if iNdEx >= l {
7936 return io.ErrUnexpectedEOF
7937 }
7938 b := dAtA[iNdEx]
7939 iNdEx++
7940 msglen |= int(b&0x7F) << shift
7941 if b < 0x80 {
7942 break
7943 }
7944 }
7945 if msglen < 0 {
7946 return ErrInvalidLengthTheproto3
7947 }
7948 postIndex := iNdEx + msglen
7949 if postIndex < 0 {
7950 return ErrInvalidLengthTheproto3
7951 }
7952 if postIndex > l {
7953 return io.ErrUnexpectedEOF
7954 }
7955 if m.Sint32Map == nil {
7956 m.Sint32Map = make(map[int32]int32)
7957 }
7958 var mapkey int32
7959 var mapvalue int32
7960 for iNdEx < postIndex {
7961 entryPreIndex := iNdEx
7962 var wire uint64
7963 for shift := uint(0); ; shift += 7 {
7964 if shift >= 64 {
7965 return ErrIntOverflowTheproto3
7966 }
7967 if iNdEx >= l {
7968 return io.ErrUnexpectedEOF
7969 }
7970 b := dAtA[iNdEx]
7971 iNdEx++
7972 wire |= uint64(b&0x7F) << shift
7973 if b < 0x80 {
7974 break
7975 }
7976 }
7977 fieldNum := int32(wire >> 3)
7978 if fieldNum == 1 {
7979 var mapkeytemp int32
7980 for shift := uint(0); ; shift += 7 {
7981 if shift >= 64 {
7982 return ErrIntOverflowTheproto3
7983 }
7984 if iNdEx >= l {
7985 return io.ErrUnexpectedEOF
7986 }
7987 b := dAtA[iNdEx]
7988 iNdEx++
7989 mapkeytemp |= int32(b&0x7F) << shift
7990 if b < 0x80 {
7991 break
7992 }
7993 }
7994 mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
7995 mapkey = int32(mapkeytemp)
7996 } else if fieldNum == 2 {
7997 var mapvaluetemp int32
7998 for shift := uint(0); ; shift += 7 {
7999 if shift >= 64 {
8000 return ErrIntOverflowTheproto3
8001 }
8002 if iNdEx >= l {
8003 return io.ErrUnexpectedEOF
8004 }
8005 b := dAtA[iNdEx]
8006 iNdEx++
8007 mapvaluetemp |= int32(b&0x7F) << shift
8008 if b < 0x80 {
8009 break
8010 }
8011 }
8012 mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
8013 mapvalue = int32(mapvaluetemp)
8014 } else {
8015 iNdEx = entryPreIndex
8016 skippy, err := skipTheproto3(dAtA[iNdEx:])
8017 if err != nil {
8018 return err
8019 }
8020 if (skippy < 0) || (iNdEx+skippy) < 0 {
8021 return ErrInvalidLengthTheproto3
8022 }
8023 if (iNdEx + skippy) > postIndex {
8024 return io.ErrUnexpectedEOF
8025 }
8026 iNdEx += skippy
8027 }
8028 }
8029 m.Sint32Map[mapkey] = mapvalue
8030 iNdEx = postIndex
8031 case 8:
8032 if wireType != 2 {
8033 return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType)
8034 }
8035 var msglen int
8036 for shift := uint(0); ; shift += 7 {
8037 if shift >= 64 {
8038 return ErrIntOverflowTheproto3
8039 }
8040 if iNdEx >= l {
8041 return io.ErrUnexpectedEOF
8042 }
8043 b := dAtA[iNdEx]
8044 iNdEx++
8045 msglen |= int(b&0x7F) << shift
8046 if b < 0x80 {
8047 break
8048 }
8049 }
8050 if msglen < 0 {
8051 return ErrInvalidLengthTheproto3
8052 }
8053 postIndex := iNdEx + msglen
8054 if postIndex < 0 {
8055 return ErrInvalidLengthTheproto3
8056 }
8057 if postIndex > l {
8058 return io.ErrUnexpectedEOF
8059 }
8060 if m.Sint64Map == nil {
8061 m.Sint64Map = make(map[int64]int64)
8062 }
8063 var mapkey int64
8064 var mapvalue int64
8065 for iNdEx < postIndex {
8066 entryPreIndex := iNdEx
8067 var wire uint64
8068 for shift := uint(0); ; shift += 7 {
8069 if shift >= 64 {
8070 return ErrIntOverflowTheproto3
8071 }
8072 if iNdEx >= l {
8073 return io.ErrUnexpectedEOF
8074 }
8075 b := dAtA[iNdEx]
8076 iNdEx++
8077 wire |= uint64(b&0x7F) << shift
8078 if b < 0x80 {
8079 break
8080 }
8081 }
8082 fieldNum := int32(wire >> 3)
8083 if fieldNum == 1 {
8084 var mapkeytemp uint64
8085 for shift := uint(0); ; shift += 7 {
8086 if shift >= 64 {
8087 return ErrIntOverflowTheproto3
8088 }
8089 if iNdEx >= l {
8090 return io.ErrUnexpectedEOF
8091 }
8092 b := dAtA[iNdEx]
8093 iNdEx++
8094 mapkeytemp |= uint64(b&0x7F) << shift
8095 if b < 0x80 {
8096 break
8097 }
8098 }
8099 mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
8100 mapkey = int64(mapkeytemp)
8101 } else if fieldNum == 2 {
8102 var mapvaluetemp uint64
8103 for shift := uint(0); ; shift += 7 {
8104 if shift >= 64 {
8105 return ErrIntOverflowTheproto3
8106 }
8107 if iNdEx >= l {
8108 return io.ErrUnexpectedEOF
8109 }
8110 b := dAtA[iNdEx]
8111 iNdEx++
8112 mapvaluetemp |= uint64(b&0x7F) << shift
8113 if b < 0x80 {
8114 break
8115 }
8116 }
8117 mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
8118 mapvalue = int64(mapvaluetemp)
8119 } else {
8120 iNdEx = entryPreIndex
8121 skippy, err := skipTheproto3(dAtA[iNdEx:])
8122 if err != nil {
8123 return err
8124 }
8125 if (skippy < 0) || (iNdEx+skippy) < 0 {
8126 return ErrInvalidLengthTheproto3
8127 }
8128 if (iNdEx + skippy) > postIndex {
8129 return io.ErrUnexpectedEOF
8130 }
8131 iNdEx += skippy
8132 }
8133 }
8134 m.Sint64Map[mapkey] = mapvalue
8135 iNdEx = postIndex
8136 case 9:
8137 if wireType != 2 {
8138 return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType)
8139 }
8140 var msglen int
8141 for shift := uint(0); ; shift += 7 {
8142 if shift >= 64 {
8143 return ErrIntOverflowTheproto3
8144 }
8145 if iNdEx >= l {
8146 return io.ErrUnexpectedEOF
8147 }
8148 b := dAtA[iNdEx]
8149 iNdEx++
8150 msglen |= int(b&0x7F) << shift
8151 if b < 0x80 {
8152 break
8153 }
8154 }
8155 if msglen < 0 {
8156 return ErrInvalidLengthTheproto3
8157 }
8158 postIndex := iNdEx + msglen
8159 if postIndex < 0 {
8160 return ErrInvalidLengthTheproto3
8161 }
8162 if postIndex > l {
8163 return io.ErrUnexpectedEOF
8164 }
8165 if m.Fixed32Map == nil {
8166 m.Fixed32Map = make(map[uint32]uint32)
8167 }
8168 var mapkey uint32
8169 var mapvalue uint32
8170 for iNdEx < postIndex {
8171 entryPreIndex := iNdEx
8172 var wire uint64
8173 for shift := uint(0); ; shift += 7 {
8174 if shift >= 64 {
8175 return ErrIntOverflowTheproto3
8176 }
8177 if iNdEx >= l {
8178 return io.ErrUnexpectedEOF
8179 }
8180 b := dAtA[iNdEx]
8181 iNdEx++
8182 wire |= uint64(b&0x7F) << shift
8183 if b < 0x80 {
8184 break
8185 }
8186 }
8187 fieldNum := int32(wire >> 3)
8188 if fieldNum == 1 {
8189 if (iNdEx + 4) > l {
8190 return io.ErrUnexpectedEOF
8191 }
8192 mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8193 iNdEx += 4
8194 } else if fieldNum == 2 {
8195 if (iNdEx + 4) > l {
8196 return io.ErrUnexpectedEOF
8197 }
8198 mapvalue = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8199 iNdEx += 4
8200 } else {
8201 iNdEx = entryPreIndex
8202 skippy, err := skipTheproto3(dAtA[iNdEx:])
8203 if err != nil {
8204 return err
8205 }
8206 if (skippy < 0) || (iNdEx+skippy) < 0 {
8207 return ErrInvalidLengthTheproto3
8208 }
8209 if (iNdEx + skippy) > postIndex {
8210 return io.ErrUnexpectedEOF
8211 }
8212 iNdEx += skippy
8213 }
8214 }
8215 m.Fixed32Map[mapkey] = mapvalue
8216 iNdEx = postIndex
8217 case 10:
8218 if wireType != 2 {
8219 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType)
8220 }
8221 var msglen int
8222 for shift := uint(0); ; shift += 7 {
8223 if shift >= 64 {
8224 return ErrIntOverflowTheproto3
8225 }
8226 if iNdEx >= l {
8227 return io.ErrUnexpectedEOF
8228 }
8229 b := dAtA[iNdEx]
8230 iNdEx++
8231 msglen |= int(b&0x7F) << shift
8232 if b < 0x80 {
8233 break
8234 }
8235 }
8236 if msglen < 0 {
8237 return ErrInvalidLengthTheproto3
8238 }
8239 postIndex := iNdEx + msglen
8240 if postIndex < 0 {
8241 return ErrInvalidLengthTheproto3
8242 }
8243 if postIndex > l {
8244 return io.ErrUnexpectedEOF
8245 }
8246 if m.Sfixed32Map == nil {
8247 m.Sfixed32Map = make(map[int32]int32)
8248 }
8249 var mapkey int32
8250 var mapvalue int32
8251 for iNdEx < postIndex {
8252 entryPreIndex := iNdEx
8253 var wire uint64
8254 for shift := uint(0); ; shift += 7 {
8255 if shift >= 64 {
8256 return ErrIntOverflowTheproto3
8257 }
8258 if iNdEx >= l {
8259 return io.ErrUnexpectedEOF
8260 }
8261 b := dAtA[iNdEx]
8262 iNdEx++
8263 wire |= uint64(b&0x7F) << shift
8264 if b < 0x80 {
8265 break
8266 }
8267 }
8268 fieldNum := int32(wire >> 3)
8269 if fieldNum == 1 {
8270 if (iNdEx + 4) > l {
8271 return io.ErrUnexpectedEOF
8272 }
8273 mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8274 iNdEx += 4
8275 } else if fieldNum == 2 {
8276 if (iNdEx + 4) > l {
8277 return io.ErrUnexpectedEOF
8278 }
8279 mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8280 iNdEx += 4
8281 } else {
8282 iNdEx = entryPreIndex
8283 skippy, err := skipTheproto3(dAtA[iNdEx:])
8284 if err != nil {
8285 return err
8286 }
8287 if (skippy < 0) || (iNdEx+skippy) < 0 {
8288 return ErrInvalidLengthTheproto3
8289 }
8290 if (iNdEx + skippy) > postIndex {
8291 return io.ErrUnexpectedEOF
8292 }
8293 iNdEx += skippy
8294 }
8295 }
8296 m.Sfixed32Map[mapkey] = mapvalue
8297 iNdEx = postIndex
8298 case 11:
8299 if wireType != 2 {
8300 return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType)
8301 }
8302 var msglen int
8303 for shift := uint(0); ; shift += 7 {
8304 if shift >= 64 {
8305 return ErrIntOverflowTheproto3
8306 }
8307 if iNdEx >= l {
8308 return io.ErrUnexpectedEOF
8309 }
8310 b := dAtA[iNdEx]
8311 iNdEx++
8312 msglen |= int(b&0x7F) << shift
8313 if b < 0x80 {
8314 break
8315 }
8316 }
8317 if msglen < 0 {
8318 return ErrInvalidLengthTheproto3
8319 }
8320 postIndex := iNdEx + msglen
8321 if postIndex < 0 {
8322 return ErrInvalidLengthTheproto3
8323 }
8324 if postIndex > l {
8325 return io.ErrUnexpectedEOF
8326 }
8327 if m.Fixed64Map == nil {
8328 m.Fixed64Map = make(map[uint64]uint64)
8329 }
8330 var mapkey uint64
8331 var mapvalue uint64
8332 for iNdEx < postIndex {
8333 entryPreIndex := iNdEx
8334 var wire uint64
8335 for shift := uint(0); ; shift += 7 {
8336 if shift >= 64 {
8337 return ErrIntOverflowTheproto3
8338 }
8339 if iNdEx >= l {
8340 return io.ErrUnexpectedEOF
8341 }
8342 b := dAtA[iNdEx]
8343 iNdEx++
8344 wire |= uint64(b&0x7F) << shift
8345 if b < 0x80 {
8346 break
8347 }
8348 }
8349 fieldNum := int32(wire >> 3)
8350 if fieldNum == 1 {
8351 if (iNdEx + 8) > l {
8352 return io.ErrUnexpectedEOF
8353 }
8354 mapkey = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8355 iNdEx += 8
8356 } else if fieldNum == 2 {
8357 if (iNdEx + 8) > l {
8358 return io.ErrUnexpectedEOF
8359 }
8360 mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8361 iNdEx += 8
8362 } else {
8363 iNdEx = entryPreIndex
8364 skippy, err := skipTheproto3(dAtA[iNdEx:])
8365 if err != nil {
8366 return err
8367 }
8368 if (skippy < 0) || (iNdEx+skippy) < 0 {
8369 return ErrInvalidLengthTheproto3
8370 }
8371 if (iNdEx + skippy) > postIndex {
8372 return io.ErrUnexpectedEOF
8373 }
8374 iNdEx += skippy
8375 }
8376 }
8377 m.Fixed64Map[mapkey] = mapvalue
8378 iNdEx = postIndex
8379 case 12:
8380 if wireType != 2 {
8381 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType)
8382 }
8383 var msglen int
8384 for shift := uint(0); ; shift += 7 {
8385 if shift >= 64 {
8386 return ErrIntOverflowTheproto3
8387 }
8388 if iNdEx >= l {
8389 return io.ErrUnexpectedEOF
8390 }
8391 b := dAtA[iNdEx]
8392 iNdEx++
8393 msglen |= int(b&0x7F) << shift
8394 if b < 0x80 {
8395 break
8396 }
8397 }
8398 if msglen < 0 {
8399 return ErrInvalidLengthTheproto3
8400 }
8401 postIndex := iNdEx + msglen
8402 if postIndex < 0 {
8403 return ErrInvalidLengthTheproto3
8404 }
8405 if postIndex > l {
8406 return io.ErrUnexpectedEOF
8407 }
8408 if m.Sfixed64Map == nil {
8409 m.Sfixed64Map = make(map[int64]int64)
8410 }
8411 var mapkey int64
8412 var mapvalue int64
8413 for iNdEx < postIndex {
8414 entryPreIndex := iNdEx
8415 var wire uint64
8416 for shift := uint(0); ; shift += 7 {
8417 if shift >= 64 {
8418 return ErrIntOverflowTheproto3
8419 }
8420 if iNdEx >= l {
8421 return io.ErrUnexpectedEOF
8422 }
8423 b := dAtA[iNdEx]
8424 iNdEx++
8425 wire |= uint64(b&0x7F) << shift
8426 if b < 0x80 {
8427 break
8428 }
8429 }
8430 fieldNum := int32(wire >> 3)
8431 if fieldNum == 1 {
8432 if (iNdEx + 8) > l {
8433 return io.ErrUnexpectedEOF
8434 }
8435 mapkey = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8436 iNdEx += 8
8437 } else if fieldNum == 2 {
8438 if (iNdEx + 8) > l {
8439 return io.ErrUnexpectedEOF
8440 }
8441 mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8442 iNdEx += 8
8443 } else {
8444 iNdEx = entryPreIndex
8445 skippy, err := skipTheproto3(dAtA[iNdEx:])
8446 if err != nil {
8447 return err
8448 }
8449 if (skippy < 0) || (iNdEx+skippy) < 0 {
8450 return ErrInvalidLengthTheproto3
8451 }
8452 if (iNdEx + skippy) > postIndex {
8453 return io.ErrUnexpectedEOF
8454 }
8455 iNdEx += skippy
8456 }
8457 }
8458 m.Sfixed64Map[mapkey] = mapvalue
8459 iNdEx = postIndex
8460 case 13:
8461 if wireType != 2 {
8462 return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType)
8463 }
8464 var msglen int
8465 for shift := uint(0); ; shift += 7 {
8466 if shift >= 64 {
8467 return ErrIntOverflowTheproto3
8468 }
8469 if iNdEx >= l {
8470 return io.ErrUnexpectedEOF
8471 }
8472 b := dAtA[iNdEx]
8473 iNdEx++
8474 msglen |= int(b&0x7F) << shift
8475 if b < 0x80 {
8476 break
8477 }
8478 }
8479 if msglen < 0 {
8480 return ErrInvalidLengthTheproto3
8481 }
8482 postIndex := iNdEx + msglen
8483 if postIndex < 0 {
8484 return ErrInvalidLengthTheproto3
8485 }
8486 if postIndex > l {
8487 return io.ErrUnexpectedEOF
8488 }
8489 if m.BoolMap == nil {
8490 m.BoolMap = make(map[bool]bool)
8491 }
8492 var mapkey bool
8493 var mapvalue bool
8494 for iNdEx < postIndex {
8495 entryPreIndex := iNdEx
8496 var wire uint64
8497 for shift := uint(0); ; shift += 7 {
8498 if shift >= 64 {
8499 return ErrIntOverflowTheproto3
8500 }
8501 if iNdEx >= l {
8502 return io.ErrUnexpectedEOF
8503 }
8504 b := dAtA[iNdEx]
8505 iNdEx++
8506 wire |= uint64(b&0x7F) << shift
8507 if b < 0x80 {
8508 break
8509 }
8510 }
8511 fieldNum := int32(wire >> 3)
8512 if fieldNum == 1 {
8513 var mapkeytemp int
8514 for shift := uint(0); ; shift += 7 {
8515 if shift >= 64 {
8516 return ErrIntOverflowTheproto3
8517 }
8518 if iNdEx >= l {
8519 return io.ErrUnexpectedEOF
8520 }
8521 b := dAtA[iNdEx]
8522 iNdEx++
8523 mapkeytemp |= int(b&0x7F) << shift
8524 if b < 0x80 {
8525 break
8526 }
8527 }
8528 mapkey = bool(mapkeytemp != 0)
8529 } else if fieldNum == 2 {
8530 var mapvaluetemp int
8531 for shift := uint(0); ; shift += 7 {
8532 if shift >= 64 {
8533 return ErrIntOverflowTheproto3
8534 }
8535 if iNdEx >= l {
8536 return io.ErrUnexpectedEOF
8537 }
8538 b := dAtA[iNdEx]
8539 iNdEx++
8540 mapvaluetemp |= int(b&0x7F) << shift
8541 if b < 0x80 {
8542 break
8543 }
8544 }
8545 mapvalue = bool(mapvaluetemp != 0)
8546 } else {
8547 iNdEx = entryPreIndex
8548 skippy, err := skipTheproto3(dAtA[iNdEx:])
8549 if err != nil {
8550 return err
8551 }
8552 if (skippy < 0) || (iNdEx+skippy) < 0 {
8553 return ErrInvalidLengthTheproto3
8554 }
8555 if (iNdEx + skippy) > postIndex {
8556 return io.ErrUnexpectedEOF
8557 }
8558 iNdEx += skippy
8559 }
8560 }
8561 m.BoolMap[mapkey] = mapvalue
8562 iNdEx = postIndex
8563 case 14:
8564 if wireType != 2 {
8565 return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType)
8566 }
8567 var msglen int
8568 for shift := uint(0); ; shift += 7 {
8569 if shift >= 64 {
8570 return ErrIntOverflowTheproto3
8571 }
8572 if iNdEx >= l {
8573 return io.ErrUnexpectedEOF
8574 }
8575 b := dAtA[iNdEx]
8576 iNdEx++
8577 msglen |= int(b&0x7F) << shift
8578 if b < 0x80 {
8579 break
8580 }
8581 }
8582 if msglen < 0 {
8583 return ErrInvalidLengthTheproto3
8584 }
8585 postIndex := iNdEx + msglen
8586 if postIndex < 0 {
8587 return ErrInvalidLengthTheproto3
8588 }
8589 if postIndex > l {
8590 return io.ErrUnexpectedEOF
8591 }
8592 if m.StringMap == nil {
8593 m.StringMap = make(map[string]string)
8594 }
8595 var mapkey string
8596 var mapvalue string
8597 for iNdEx < postIndex {
8598 entryPreIndex := iNdEx
8599 var wire uint64
8600 for shift := uint(0); ; shift += 7 {
8601 if shift >= 64 {
8602 return ErrIntOverflowTheproto3
8603 }
8604 if iNdEx >= l {
8605 return io.ErrUnexpectedEOF
8606 }
8607 b := dAtA[iNdEx]
8608 iNdEx++
8609 wire |= uint64(b&0x7F) << shift
8610 if b < 0x80 {
8611 break
8612 }
8613 }
8614 fieldNum := int32(wire >> 3)
8615 if fieldNum == 1 {
8616 var stringLenmapkey uint64
8617 for shift := uint(0); ; shift += 7 {
8618 if shift >= 64 {
8619 return ErrIntOverflowTheproto3
8620 }
8621 if iNdEx >= l {
8622 return io.ErrUnexpectedEOF
8623 }
8624 b := dAtA[iNdEx]
8625 iNdEx++
8626 stringLenmapkey |= uint64(b&0x7F) << shift
8627 if b < 0x80 {
8628 break
8629 }
8630 }
8631 intStringLenmapkey := int(stringLenmapkey)
8632 if intStringLenmapkey < 0 {
8633 return ErrInvalidLengthTheproto3
8634 }
8635 postStringIndexmapkey := iNdEx + intStringLenmapkey
8636 if postStringIndexmapkey < 0 {
8637 return ErrInvalidLengthTheproto3
8638 }
8639 if postStringIndexmapkey > l {
8640 return io.ErrUnexpectedEOF
8641 }
8642 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8643 iNdEx = postStringIndexmapkey
8644 } else if fieldNum == 2 {
8645 var stringLenmapvalue uint64
8646 for shift := uint(0); ; shift += 7 {
8647 if shift >= 64 {
8648 return ErrIntOverflowTheproto3
8649 }
8650 if iNdEx >= l {
8651 return io.ErrUnexpectedEOF
8652 }
8653 b := dAtA[iNdEx]
8654 iNdEx++
8655 stringLenmapvalue |= uint64(b&0x7F) << shift
8656 if b < 0x80 {
8657 break
8658 }
8659 }
8660 intStringLenmapvalue := int(stringLenmapvalue)
8661 if intStringLenmapvalue < 0 {
8662 return ErrInvalidLengthTheproto3
8663 }
8664 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
8665 if postStringIndexmapvalue < 0 {
8666 return ErrInvalidLengthTheproto3
8667 }
8668 if postStringIndexmapvalue > l {
8669 return io.ErrUnexpectedEOF
8670 }
8671 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
8672 iNdEx = postStringIndexmapvalue
8673 } else {
8674 iNdEx = entryPreIndex
8675 skippy, err := skipTheproto3(dAtA[iNdEx:])
8676 if err != nil {
8677 return err
8678 }
8679 if (skippy < 0) || (iNdEx+skippy) < 0 {
8680 return ErrInvalidLengthTheproto3
8681 }
8682 if (iNdEx + skippy) > postIndex {
8683 return io.ErrUnexpectedEOF
8684 }
8685 iNdEx += skippy
8686 }
8687 }
8688 m.StringMap[mapkey] = mapvalue
8689 iNdEx = postIndex
8690 case 15:
8691 if wireType != 2 {
8692 return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType)
8693 }
8694 var msglen int
8695 for shift := uint(0); ; shift += 7 {
8696 if shift >= 64 {
8697 return ErrIntOverflowTheproto3
8698 }
8699 if iNdEx >= l {
8700 return io.ErrUnexpectedEOF
8701 }
8702 b := dAtA[iNdEx]
8703 iNdEx++
8704 msglen |= int(b&0x7F) << shift
8705 if b < 0x80 {
8706 break
8707 }
8708 }
8709 if msglen < 0 {
8710 return ErrInvalidLengthTheproto3
8711 }
8712 postIndex := iNdEx + msglen
8713 if postIndex < 0 {
8714 return ErrInvalidLengthTheproto3
8715 }
8716 if postIndex > l {
8717 return io.ErrUnexpectedEOF
8718 }
8719 if m.StringToBytesMap == nil {
8720 m.StringToBytesMap = make(map[string][]byte)
8721 }
8722 var mapkey string
8723 mapvalue := []byte{}
8724 for iNdEx < postIndex {
8725 entryPreIndex := iNdEx
8726 var wire uint64
8727 for shift := uint(0); ; shift += 7 {
8728 if shift >= 64 {
8729 return ErrIntOverflowTheproto3
8730 }
8731 if iNdEx >= l {
8732 return io.ErrUnexpectedEOF
8733 }
8734 b := dAtA[iNdEx]
8735 iNdEx++
8736 wire |= uint64(b&0x7F) << shift
8737 if b < 0x80 {
8738 break
8739 }
8740 }
8741 fieldNum := int32(wire >> 3)
8742 if fieldNum == 1 {
8743 var stringLenmapkey uint64
8744 for shift := uint(0); ; shift += 7 {
8745 if shift >= 64 {
8746 return ErrIntOverflowTheproto3
8747 }
8748 if iNdEx >= l {
8749 return io.ErrUnexpectedEOF
8750 }
8751 b := dAtA[iNdEx]
8752 iNdEx++
8753 stringLenmapkey |= uint64(b&0x7F) << shift
8754 if b < 0x80 {
8755 break
8756 }
8757 }
8758 intStringLenmapkey := int(stringLenmapkey)
8759 if intStringLenmapkey < 0 {
8760 return ErrInvalidLengthTheproto3
8761 }
8762 postStringIndexmapkey := iNdEx + intStringLenmapkey
8763 if postStringIndexmapkey < 0 {
8764 return ErrInvalidLengthTheproto3
8765 }
8766 if postStringIndexmapkey > l {
8767 return io.ErrUnexpectedEOF
8768 }
8769 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8770 iNdEx = postStringIndexmapkey
8771 } else if fieldNum == 2 {
8772 var mapbyteLen uint64
8773 for shift := uint(0); ; shift += 7 {
8774 if shift >= 64 {
8775 return ErrIntOverflowTheproto3
8776 }
8777 if iNdEx >= l {
8778 return io.ErrUnexpectedEOF
8779 }
8780 b := dAtA[iNdEx]
8781 iNdEx++
8782 mapbyteLen |= uint64(b&0x7F) << shift
8783 if b < 0x80 {
8784 break
8785 }
8786 }
8787 intMapbyteLen := int(mapbyteLen)
8788 if intMapbyteLen < 0 {
8789 return ErrInvalidLengthTheproto3
8790 }
8791 postbytesIndex := iNdEx + intMapbyteLen
8792 if postbytesIndex < 0 {
8793 return ErrInvalidLengthTheproto3
8794 }
8795 if postbytesIndex > l {
8796 return io.ErrUnexpectedEOF
8797 }
8798 mapvalue = make([]byte, mapbyteLen)
8799 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
8800 iNdEx = postbytesIndex
8801 } else {
8802 iNdEx = entryPreIndex
8803 skippy, err := skipTheproto3(dAtA[iNdEx:])
8804 if err != nil {
8805 return err
8806 }
8807 if (skippy < 0) || (iNdEx+skippy) < 0 {
8808 return ErrInvalidLengthTheproto3
8809 }
8810 if (iNdEx + skippy) > postIndex {
8811 return io.ErrUnexpectedEOF
8812 }
8813 iNdEx += skippy
8814 }
8815 }
8816 m.StringToBytesMap[mapkey] = mapvalue
8817 iNdEx = postIndex
8818 case 16:
8819 if wireType != 2 {
8820 return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType)
8821 }
8822 var msglen int
8823 for shift := uint(0); ; shift += 7 {
8824 if shift >= 64 {
8825 return ErrIntOverflowTheproto3
8826 }
8827 if iNdEx >= l {
8828 return io.ErrUnexpectedEOF
8829 }
8830 b := dAtA[iNdEx]
8831 iNdEx++
8832 msglen |= int(b&0x7F) << shift
8833 if b < 0x80 {
8834 break
8835 }
8836 }
8837 if msglen < 0 {
8838 return ErrInvalidLengthTheproto3
8839 }
8840 postIndex := iNdEx + msglen
8841 if postIndex < 0 {
8842 return ErrInvalidLengthTheproto3
8843 }
8844 if postIndex > l {
8845 return io.ErrUnexpectedEOF
8846 }
8847 if m.StringToEnumMap == nil {
8848 m.StringToEnumMap = make(map[string]MapEnum)
8849 }
8850 var mapkey string
8851 var mapvalue MapEnum
8852 for iNdEx < postIndex {
8853 entryPreIndex := iNdEx
8854 var wire uint64
8855 for shift := uint(0); ; shift += 7 {
8856 if shift >= 64 {
8857 return ErrIntOverflowTheproto3
8858 }
8859 if iNdEx >= l {
8860 return io.ErrUnexpectedEOF
8861 }
8862 b := dAtA[iNdEx]
8863 iNdEx++
8864 wire |= uint64(b&0x7F) << shift
8865 if b < 0x80 {
8866 break
8867 }
8868 }
8869 fieldNum := int32(wire >> 3)
8870 if fieldNum == 1 {
8871 var stringLenmapkey uint64
8872 for shift := uint(0); ; shift += 7 {
8873 if shift >= 64 {
8874 return ErrIntOverflowTheproto3
8875 }
8876 if iNdEx >= l {
8877 return io.ErrUnexpectedEOF
8878 }
8879 b := dAtA[iNdEx]
8880 iNdEx++
8881 stringLenmapkey |= uint64(b&0x7F) << shift
8882 if b < 0x80 {
8883 break
8884 }
8885 }
8886 intStringLenmapkey := int(stringLenmapkey)
8887 if intStringLenmapkey < 0 {
8888 return ErrInvalidLengthTheproto3
8889 }
8890 postStringIndexmapkey := iNdEx + intStringLenmapkey
8891 if postStringIndexmapkey < 0 {
8892 return ErrInvalidLengthTheproto3
8893 }
8894 if postStringIndexmapkey > l {
8895 return io.ErrUnexpectedEOF
8896 }
8897 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
8898 iNdEx = postStringIndexmapkey
8899 } else if fieldNum == 2 {
8900 for shift := uint(0); ; shift += 7 {
8901 if shift >= 64 {
8902 return ErrIntOverflowTheproto3
8903 }
8904 if iNdEx >= l {
8905 return io.ErrUnexpectedEOF
8906 }
8907 b := dAtA[iNdEx]
8908 iNdEx++
8909 mapvalue |= MapEnum(b&0x7F) << shift
8910 if b < 0x80 {
8911 break
8912 }
8913 }
8914 } else {
8915 iNdEx = entryPreIndex
8916 skippy, err := skipTheproto3(dAtA[iNdEx:])
8917 if err != nil {
8918 return err
8919 }
8920 if (skippy < 0) || (iNdEx+skippy) < 0 {
8921 return ErrInvalidLengthTheproto3
8922 }
8923 if (iNdEx + skippy) > postIndex {
8924 return io.ErrUnexpectedEOF
8925 }
8926 iNdEx += skippy
8927 }
8928 }
8929 m.StringToEnumMap[mapkey] = mapvalue
8930 iNdEx = postIndex
8931 case 17:
8932 if wireType != 2 {
8933 return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType)
8934 }
8935 var msglen int
8936 for shift := uint(0); ; shift += 7 {
8937 if shift >= 64 {
8938 return ErrIntOverflowTheproto3
8939 }
8940 if iNdEx >= l {
8941 return io.ErrUnexpectedEOF
8942 }
8943 b := dAtA[iNdEx]
8944 iNdEx++
8945 msglen |= int(b&0x7F) << shift
8946 if b < 0x80 {
8947 break
8948 }
8949 }
8950 if msglen < 0 {
8951 return ErrInvalidLengthTheproto3
8952 }
8953 postIndex := iNdEx + msglen
8954 if postIndex < 0 {
8955 return ErrInvalidLengthTheproto3
8956 }
8957 if postIndex > l {
8958 return io.ErrUnexpectedEOF
8959 }
8960 if m.StringToMsgMap == nil {
8961 m.StringToMsgMap = make(map[string]*FloatingPoint)
8962 }
8963 var mapkey string
8964 var mapvalue *FloatingPoint
8965 for iNdEx < postIndex {
8966 entryPreIndex := iNdEx
8967 var wire uint64
8968 for shift := uint(0); ; shift += 7 {
8969 if shift >= 64 {
8970 return ErrIntOverflowTheproto3
8971 }
8972 if iNdEx >= l {
8973 return io.ErrUnexpectedEOF
8974 }
8975 b := dAtA[iNdEx]
8976 iNdEx++
8977 wire |= uint64(b&0x7F) << shift
8978 if b < 0x80 {
8979 break
8980 }
8981 }
8982 fieldNum := int32(wire >> 3)
8983 if fieldNum == 1 {
8984 var stringLenmapkey uint64
8985 for shift := uint(0); ; shift += 7 {
8986 if shift >= 64 {
8987 return ErrIntOverflowTheproto3
8988 }
8989 if iNdEx >= l {
8990 return io.ErrUnexpectedEOF
8991 }
8992 b := dAtA[iNdEx]
8993 iNdEx++
8994 stringLenmapkey |= uint64(b&0x7F) << shift
8995 if b < 0x80 {
8996 break
8997 }
8998 }
8999 intStringLenmapkey := int(stringLenmapkey)
9000 if intStringLenmapkey < 0 {
9001 return ErrInvalidLengthTheproto3
9002 }
9003 postStringIndexmapkey := iNdEx + intStringLenmapkey
9004 if postStringIndexmapkey < 0 {
9005 return ErrInvalidLengthTheproto3
9006 }
9007 if postStringIndexmapkey > l {
9008 return io.ErrUnexpectedEOF
9009 }
9010 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
9011 iNdEx = postStringIndexmapkey
9012 } else if fieldNum == 2 {
9013 var mapmsglen int
9014 for shift := uint(0); ; shift += 7 {
9015 if shift >= 64 {
9016 return ErrIntOverflowTheproto3
9017 }
9018 if iNdEx >= l {
9019 return io.ErrUnexpectedEOF
9020 }
9021 b := dAtA[iNdEx]
9022 iNdEx++
9023 mapmsglen |= int(b&0x7F) << shift
9024 if b < 0x80 {
9025 break
9026 }
9027 }
9028 if mapmsglen < 0 {
9029 return ErrInvalidLengthTheproto3
9030 }
9031 postmsgIndex := iNdEx + mapmsglen
9032 if postmsgIndex < 0 {
9033 return ErrInvalidLengthTheproto3
9034 }
9035 if postmsgIndex > l {
9036 return io.ErrUnexpectedEOF
9037 }
9038 mapvalue = &FloatingPoint{}
9039 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
9040 return err
9041 }
9042 iNdEx = postmsgIndex
9043 } else {
9044 iNdEx = entryPreIndex
9045 skippy, err := skipTheproto3(dAtA[iNdEx:])
9046 if err != nil {
9047 return err
9048 }
9049 if (skippy < 0) || (iNdEx+skippy) < 0 {
9050 return ErrInvalidLengthTheproto3
9051 }
9052 if (iNdEx + skippy) > postIndex {
9053 return io.ErrUnexpectedEOF
9054 }
9055 iNdEx += skippy
9056 }
9057 }
9058 m.StringToMsgMap[mapkey] = mapvalue
9059 iNdEx = postIndex
9060 default:
9061 iNdEx = preIndex
9062 skippy, err := skipTheproto3(dAtA[iNdEx:])
9063 if err != nil {
9064 return err
9065 }
9066 if (skippy < 0) || (iNdEx+skippy) < 0 {
9067 return ErrInvalidLengthTheproto3
9068 }
9069 if (iNdEx + skippy) > l {
9070 return io.ErrUnexpectedEOF
9071 }
9072 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9073 iNdEx += skippy
9074 }
9075 }
9076
9077 if iNdEx > l {
9078 return io.ErrUnexpectedEOF
9079 }
9080 return nil
9081 }
9082 func (m *AllMapsOrdered) Unmarshal(dAtA []byte) error {
9083 l := len(dAtA)
9084 iNdEx := 0
9085 for iNdEx < l {
9086 preIndex := iNdEx
9087 var wire uint64
9088 for shift := uint(0); ; shift += 7 {
9089 if shift >= 64 {
9090 return ErrIntOverflowTheproto3
9091 }
9092 if iNdEx >= l {
9093 return io.ErrUnexpectedEOF
9094 }
9095 b := dAtA[iNdEx]
9096 iNdEx++
9097 wire |= uint64(b&0x7F) << shift
9098 if b < 0x80 {
9099 break
9100 }
9101 }
9102 fieldNum := int32(wire >> 3)
9103 wireType := int(wire & 0x7)
9104 if wireType == 4 {
9105 return fmt.Errorf("proto: AllMapsOrdered: wiretype end group for non-group")
9106 }
9107 if fieldNum <= 0 {
9108 return fmt.Errorf("proto: AllMapsOrdered: illegal tag %d (wire type %d)", fieldNum, wire)
9109 }
9110 switch fieldNum {
9111 case 1:
9112 if wireType != 2 {
9113 return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType)
9114 }
9115 var msglen int
9116 for shift := uint(0); ; shift += 7 {
9117 if shift >= 64 {
9118 return ErrIntOverflowTheproto3
9119 }
9120 if iNdEx >= l {
9121 return io.ErrUnexpectedEOF
9122 }
9123 b := dAtA[iNdEx]
9124 iNdEx++
9125 msglen |= int(b&0x7F) << shift
9126 if b < 0x80 {
9127 break
9128 }
9129 }
9130 if msglen < 0 {
9131 return ErrInvalidLengthTheproto3
9132 }
9133 postIndex := iNdEx + msglen
9134 if postIndex < 0 {
9135 return ErrInvalidLengthTheproto3
9136 }
9137 if postIndex > l {
9138 return io.ErrUnexpectedEOF
9139 }
9140 if m.StringToDoubleMap == nil {
9141 m.StringToDoubleMap = make(map[string]float64)
9142 }
9143 var mapkey string
9144 var mapvalue float64
9145 for iNdEx < postIndex {
9146 entryPreIndex := iNdEx
9147 var wire uint64
9148 for shift := uint(0); ; shift += 7 {
9149 if shift >= 64 {
9150 return ErrIntOverflowTheproto3
9151 }
9152 if iNdEx >= l {
9153 return io.ErrUnexpectedEOF
9154 }
9155 b := dAtA[iNdEx]
9156 iNdEx++
9157 wire |= uint64(b&0x7F) << shift
9158 if b < 0x80 {
9159 break
9160 }
9161 }
9162 fieldNum := int32(wire >> 3)
9163 if fieldNum == 1 {
9164 var stringLenmapkey uint64
9165 for shift := uint(0); ; shift += 7 {
9166 if shift >= 64 {
9167 return ErrIntOverflowTheproto3
9168 }
9169 if iNdEx >= l {
9170 return io.ErrUnexpectedEOF
9171 }
9172 b := dAtA[iNdEx]
9173 iNdEx++
9174 stringLenmapkey |= uint64(b&0x7F) << shift
9175 if b < 0x80 {
9176 break
9177 }
9178 }
9179 intStringLenmapkey := int(stringLenmapkey)
9180 if intStringLenmapkey < 0 {
9181 return ErrInvalidLengthTheproto3
9182 }
9183 postStringIndexmapkey := iNdEx + intStringLenmapkey
9184 if postStringIndexmapkey < 0 {
9185 return ErrInvalidLengthTheproto3
9186 }
9187 if postStringIndexmapkey > l {
9188 return io.ErrUnexpectedEOF
9189 }
9190 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
9191 iNdEx = postStringIndexmapkey
9192 } else if fieldNum == 2 {
9193 var mapvaluetemp uint64
9194 if (iNdEx + 8) > l {
9195 return io.ErrUnexpectedEOF
9196 }
9197 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
9198 iNdEx += 8
9199 mapvalue = math.Float64frombits(mapvaluetemp)
9200 } else {
9201 iNdEx = entryPreIndex
9202 skippy, err := skipTheproto3(dAtA[iNdEx:])
9203 if err != nil {
9204 return err
9205 }
9206 if (skippy < 0) || (iNdEx+skippy) < 0 {
9207 return ErrInvalidLengthTheproto3
9208 }
9209 if (iNdEx + skippy) > postIndex {
9210 return io.ErrUnexpectedEOF
9211 }
9212 iNdEx += skippy
9213 }
9214 }
9215 m.StringToDoubleMap[mapkey] = mapvalue
9216 iNdEx = postIndex
9217 case 2:
9218 if wireType != 2 {
9219 return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType)
9220 }
9221 var msglen int
9222 for shift := uint(0); ; shift += 7 {
9223 if shift >= 64 {
9224 return ErrIntOverflowTheproto3
9225 }
9226 if iNdEx >= l {
9227 return io.ErrUnexpectedEOF
9228 }
9229 b := dAtA[iNdEx]
9230 iNdEx++
9231 msglen |= int(b&0x7F) << shift
9232 if b < 0x80 {
9233 break
9234 }
9235 }
9236 if msglen < 0 {
9237 return ErrInvalidLengthTheproto3
9238 }
9239 postIndex := iNdEx + msglen
9240 if postIndex < 0 {
9241 return ErrInvalidLengthTheproto3
9242 }
9243 if postIndex > l {
9244 return io.ErrUnexpectedEOF
9245 }
9246 if m.StringToFloatMap == nil {
9247 m.StringToFloatMap = make(map[string]float32)
9248 }
9249 var mapkey string
9250 var mapvalue float32
9251 for iNdEx < postIndex {
9252 entryPreIndex := iNdEx
9253 var wire uint64
9254 for shift := uint(0); ; shift += 7 {
9255 if shift >= 64 {
9256 return ErrIntOverflowTheproto3
9257 }
9258 if iNdEx >= l {
9259 return io.ErrUnexpectedEOF
9260 }
9261 b := dAtA[iNdEx]
9262 iNdEx++
9263 wire |= uint64(b&0x7F) << shift
9264 if b < 0x80 {
9265 break
9266 }
9267 }
9268 fieldNum := int32(wire >> 3)
9269 if fieldNum == 1 {
9270 var stringLenmapkey uint64
9271 for shift := uint(0); ; shift += 7 {
9272 if shift >= 64 {
9273 return ErrIntOverflowTheproto3
9274 }
9275 if iNdEx >= l {
9276 return io.ErrUnexpectedEOF
9277 }
9278 b := dAtA[iNdEx]
9279 iNdEx++
9280 stringLenmapkey |= uint64(b&0x7F) << shift
9281 if b < 0x80 {
9282 break
9283 }
9284 }
9285 intStringLenmapkey := int(stringLenmapkey)
9286 if intStringLenmapkey < 0 {
9287 return ErrInvalidLengthTheproto3
9288 }
9289 postStringIndexmapkey := iNdEx + intStringLenmapkey
9290 if postStringIndexmapkey < 0 {
9291 return ErrInvalidLengthTheproto3
9292 }
9293 if postStringIndexmapkey > l {
9294 return io.ErrUnexpectedEOF
9295 }
9296 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
9297 iNdEx = postStringIndexmapkey
9298 } else if fieldNum == 2 {
9299 var mapvaluetemp uint32
9300 if (iNdEx + 4) > l {
9301 return io.ErrUnexpectedEOF
9302 }
9303 mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
9304 iNdEx += 4
9305 mapvalue = math.Float32frombits(mapvaluetemp)
9306 } else {
9307 iNdEx = entryPreIndex
9308 skippy, err := skipTheproto3(dAtA[iNdEx:])
9309 if err != nil {
9310 return err
9311 }
9312 if (skippy < 0) || (iNdEx+skippy) < 0 {
9313 return ErrInvalidLengthTheproto3
9314 }
9315 if (iNdEx + skippy) > postIndex {
9316 return io.ErrUnexpectedEOF
9317 }
9318 iNdEx += skippy
9319 }
9320 }
9321 m.StringToFloatMap[mapkey] = mapvalue
9322 iNdEx = postIndex
9323 case 3:
9324 if wireType != 2 {
9325 return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType)
9326 }
9327 var msglen int
9328 for shift := uint(0); ; shift += 7 {
9329 if shift >= 64 {
9330 return ErrIntOverflowTheproto3
9331 }
9332 if iNdEx >= l {
9333 return io.ErrUnexpectedEOF
9334 }
9335 b := dAtA[iNdEx]
9336 iNdEx++
9337 msglen |= int(b&0x7F) << shift
9338 if b < 0x80 {
9339 break
9340 }
9341 }
9342 if msglen < 0 {
9343 return ErrInvalidLengthTheproto3
9344 }
9345 postIndex := iNdEx + msglen
9346 if postIndex < 0 {
9347 return ErrInvalidLengthTheproto3
9348 }
9349 if postIndex > l {
9350 return io.ErrUnexpectedEOF
9351 }
9352 if m.Int32Map == nil {
9353 m.Int32Map = make(map[int32]int32)
9354 }
9355 var mapkey int32
9356 var mapvalue int32
9357 for iNdEx < postIndex {
9358 entryPreIndex := iNdEx
9359 var wire uint64
9360 for shift := uint(0); ; shift += 7 {
9361 if shift >= 64 {
9362 return ErrIntOverflowTheproto3
9363 }
9364 if iNdEx >= l {
9365 return io.ErrUnexpectedEOF
9366 }
9367 b := dAtA[iNdEx]
9368 iNdEx++
9369 wire |= uint64(b&0x7F) << shift
9370 if b < 0x80 {
9371 break
9372 }
9373 }
9374 fieldNum := int32(wire >> 3)
9375 if fieldNum == 1 {
9376 for shift := uint(0); ; shift += 7 {
9377 if shift >= 64 {
9378 return ErrIntOverflowTheproto3
9379 }
9380 if iNdEx >= l {
9381 return io.ErrUnexpectedEOF
9382 }
9383 b := dAtA[iNdEx]
9384 iNdEx++
9385 mapkey |= int32(b&0x7F) << shift
9386 if b < 0x80 {
9387 break
9388 }
9389 }
9390 } else if fieldNum == 2 {
9391 for shift := uint(0); ; shift += 7 {
9392 if shift >= 64 {
9393 return ErrIntOverflowTheproto3
9394 }
9395 if iNdEx >= l {
9396 return io.ErrUnexpectedEOF
9397 }
9398 b := dAtA[iNdEx]
9399 iNdEx++
9400 mapvalue |= int32(b&0x7F) << shift
9401 if b < 0x80 {
9402 break
9403 }
9404 }
9405 } else {
9406 iNdEx = entryPreIndex
9407 skippy, err := skipTheproto3(dAtA[iNdEx:])
9408 if err != nil {
9409 return err
9410 }
9411 if (skippy < 0) || (iNdEx+skippy) < 0 {
9412 return ErrInvalidLengthTheproto3
9413 }
9414 if (iNdEx + skippy) > postIndex {
9415 return io.ErrUnexpectedEOF
9416 }
9417 iNdEx += skippy
9418 }
9419 }
9420 m.Int32Map[mapkey] = mapvalue
9421 iNdEx = postIndex
9422 case 4:
9423 if wireType != 2 {
9424 return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType)
9425 }
9426 var msglen int
9427 for shift := uint(0); ; shift += 7 {
9428 if shift >= 64 {
9429 return ErrIntOverflowTheproto3
9430 }
9431 if iNdEx >= l {
9432 return io.ErrUnexpectedEOF
9433 }
9434 b := dAtA[iNdEx]
9435 iNdEx++
9436 msglen |= int(b&0x7F) << shift
9437 if b < 0x80 {
9438 break
9439 }
9440 }
9441 if msglen < 0 {
9442 return ErrInvalidLengthTheproto3
9443 }
9444 postIndex := iNdEx + msglen
9445 if postIndex < 0 {
9446 return ErrInvalidLengthTheproto3
9447 }
9448 if postIndex > l {
9449 return io.ErrUnexpectedEOF
9450 }
9451 if m.Int64Map == nil {
9452 m.Int64Map = make(map[int64]int64)
9453 }
9454 var mapkey int64
9455 var mapvalue int64
9456 for iNdEx < postIndex {
9457 entryPreIndex := iNdEx
9458 var wire uint64
9459 for shift := uint(0); ; shift += 7 {
9460 if shift >= 64 {
9461 return ErrIntOverflowTheproto3
9462 }
9463 if iNdEx >= l {
9464 return io.ErrUnexpectedEOF
9465 }
9466 b := dAtA[iNdEx]
9467 iNdEx++
9468 wire |= uint64(b&0x7F) << shift
9469 if b < 0x80 {
9470 break
9471 }
9472 }
9473 fieldNum := int32(wire >> 3)
9474 if fieldNum == 1 {
9475 for shift := uint(0); ; shift += 7 {
9476 if shift >= 64 {
9477 return ErrIntOverflowTheproto3
9478 }
9479 if iNdEx >= l {
9480 return io.ErrUnexpectedEOF
9481 }
9482 b := dAtA[iNdEx]
9483 iNdEx++
9484 mapkey |= int64(b&0x7F) << shift
9485 if b < 0x80 {
9486 break
9487 }
9488 }
9489 } else if fieldNum == 2 {
9490 for shift := uint(0); ; shift += 7 {
9491 if shift >= 64 {
9492 return ErrIntOverflowTheproto3
9493 }
9494 if iNdEx >= l {
9495 return io.ErrUnexpectedEOF
9496 }
9497 b := dAtA[iNdEx]
9498 iNdEx++
9499 mapvalue |= int64(b&0x7F) << shift
9500 if b < 0x80 {
9501 break
9502 }
9503 }
9504 } else {
9505 iNdEx = entryPreIndex
9506 skippy, err := skipTheproto3(dAtA[iNdEx:])
9507 if err != nil {
9508 return err
9509 }
9510 if (skippy < 0) || (iNdEx+skippy) < 0 {
9511 return ErrInvalidLengthTheproto3
9512 }
9513 if (iNdEx + skippy) > postIndex {
9514 return io.ErrUnexpectedEOF
9515 }
9516 iNdEx += skippy
9517 }
9518 }
9519 m.Int64Map[mapkey] = mapvalue
9520 iNdEx = postIndex
9521 case 5:
9522 if wireType != 2 {
9523 return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType)
9524 }
9525 var msglen int
9526 for shift := uint(0); ; shift += 7 {
9527 if shift >= 64 {
9528 return ErrIntOverflowTheproto3
9529 }
9530 if iNdEx >= l {
9531 return io.ErrUnexpectedEOF
9532 }
9533 b := dAtA[iNdEx]
9534 iNdEx++
9535 msglen |= int(b&0x7F) << shift
9536 if b < 0x80 {
9537 break
9538 }
9539 }
9540 if msglen < 0 {
9541 return ErrInvalidLengthTheproto3
9542 }
9543 postIndex := iNdEx + msglen
9544 if postIndex < 0 {
9545 return ErrInvalidLengthTheproto3
9546 }
9547 if postIndex > l {
9548 return io.ErrUnexpectedEOF
9549 }
9550 if m.Uint32Map == nil {
9551 m.Uint32Map = make(map[uint32]uint32)
9552 }
9553 var mapkey uint32
9554 var mapvalue uint32
9555 for iNdEx < postIndex {
9556 entryPreIndex := iNdEx
9557 var wire uint64
9558 for shift := uint(0); ; shift += 7 {
9559 if shift >= 64 {
9560 return ErrIntOverflowTheproto3
9561 }
9562 if iNdEx >= l {
9563 return io.ErrUnexpectedEOF
9564 }
9565 b := dAtA[iNdEx]
9566 iNdEx++
9567 wire |= uint64(b&0x7F) << shift
9568 if b < 0x80 {
9569 break
9570 }
9571 }
9572 fieldNum := int32(wire >> 3)
9573 if fieldNum == 1 {
9574 for shift := uint(0); ; shift += 7 {
9575 if shift >= 64 {
9576 return ErrIntOverflowTheproto3
9577 }
9578 if iNdEx >= l {
9579 return io.ErrUnexpectedEOF
9580 }
9581 b := dAtA[iNdEx]
9582 iNdEx++
9583 mapkey |= uint32(b&0x7F) << shift
9584 if b < 0x80 {
9585 break
9586 }
9587 }
9588 } else if fieldNum == 2 {
9589 for shift := uint(0); ; shift += 7 {
9590 if shift >= 64 {
9591 return ErrIntOverflowTheproto3
9592 }
9593 if iNdEx >= l {
9594 return io.ErrUnexpectedEOF
9595 }
9596 b := dAtA[iNdEx]
9597 iNdEx++
9598 mapvalue |= uint32(b&0x7F) << shift
9599 if b < 0x80 {
9600 break
9601 }
9602 }
9603 } else {
9604 iNdEx = entryPreIndex
9605 skippy, err := skipTheproto3(dAtA[iNdEx:])
9606 if err != nil {
9607 return err
9608 }
9609 if (skippy < 0) || (iNdEx+skippy) < 0 {
9610 return ErrInvalidLengthTheproto3
9611 }
9612 if (iNdEx + skippy) > postIndex {
9613 return io.ErrUnexpectedEOF
9614 }
9615 iNdEx += skippy
9616 }
9617 }
9618 m.Uint32Map[mapkey] = mapvalue
9619 iNdEx = postIndex
9620 case 6:
9621 if wireType != 2 {
9622 return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType)
9623 }
9624 var msglen int
9625 for shift := uint(0); ; shift += 7 {
9626 if shift >= 64 {
9627 return ErrIntOverflowTheproto3
9628 }
9629 if iNdEx >= l {
9630 return io.ErrUnexpectedEOF
9631 }
9632 b := dAtA[iNdEx]
9633 iNdEx++
9634 msglen |= int(b&0x7F) << shift
9635 if b < 0x80 {
9636 break
9637 }
9638 }
9639 if msglen < 0 {
9640 return ErrInvalidLengthTheproto3
9641 }
9642 postIndex := iNdEx + msglen
9643 if postIndex < 0 {
9644 return ErrInvalidLengthTheproto3
9645 }
9646 if postIndex > l {
9647 return io.ErrUnexpectedEOF
9648 }
9649 if m.Uint64Map == nil {
9650 m.Uint64Map = make(map[uint64]uint64)
9651 }
9652 var mapkey uint64
9653 var mapvalue uint64
9654 for iNdEx < postIndex {
9655 entryPreIndex := iNdEx
9656 var wire uint64
9657 for shift := uint(0); ; shift += 7 {
9658 if shift >= 64 {
9659 return ErrIntOverflowTheproto3
9660 }
9661 if iNdEx >= l {
9662 return io.ErrUnexpectedEOF
9663 }
9664 b := dAtA[iNdEx]
9665 iNdEx++
9666 wire |= uint64(b&0x7F) << shift
9667 if b < 0x80 {
9668 break
9669 }
9670 }
9671 fieldNum := int32(wire >> 3)
9672 if fieldNum == 1 {
9673 for shift := uint(0); ; shift += 7 {
9674 if shift >= 64 {
9675 return ErrIntOverflowTheproto3
9676 }
9677 if iNdEx >= l {
9678 return io.ErrUnexpectedEOF
9679 }
9680 b := dAtA[iNdEx]
9681 iNdEx++
9682 mapkey |= uint64(b&0x7F) << shift
9683 if b < 0x80 {
9684 break
9685 }
9686 }
9687 } else if fieldNum == 2 {
9688 for shift := uint(0); ; shift += 7 {
9689 if shift >= 64 {
9690 return ErrIntOverflowTheproto3
9691 }
9692 if iNdEx >= l {
9693 return io.ErrUnexpectedEOF
9694 }
9695 b := dAtA[iNdEx]
9696 iNdEx++
9697 mapvalue |= uint64(b&0x7F) << shift
9698 if b < 0x80 {
9699 break
9700 }
9701 }
9702 } else {
9703 iNdEx = entryPreIndex
9704 skippy, err := skipTheproto3(dAtA[iNdEx:])
9705 if err != nil {
9706 return err
9707 }
9708 if (skippy < 0) || (iNdEx+skippy) < 0 {
9709 return ErrInvalidLengthTheproto3
9710 }
9711 if (iNdEx + skippy) > postIndex {
9712 return io.ErrUnexpectedEOF
9713 }
9714 iNdEx += skippy
9715 }
9716 }
9717 m.Uint64Map[mapkey] = mapvalue
9718 iNdEx = postIndex
9719 case 7:
9720 if wireType != 2 {
9721 return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType)
9722 }
9723 var msglen int
9724 for shift := uint(0); ; shift += 7 {
9725 if shift >= 64 {
9726 return ErrIntOverflowTheproto3
9727 }
9728 if iNdEx >= l {
9729 return io.ErrUnexpectedEOF
9730 }
9731 b := dAtA[iNdEx]
9732 iNdEx++
9733 msglen |= int(b&0x7F) << shift
9734 if b < 0x80 {
9735 break
9736 }
9737 }
9738 if msglen < 0 {
9739 return ErrInvalidLengthTheproto3
9740 }
9741 postIndex := iNdEx + msglen
9742 if postIndex < 0 {
9743 return ErrInvalidLengthTheproto3
9744 }
9745 if postIndex > l {
9746 return io.ErrUnexpectedEOF
9747 }
9748 if m.Sint32Map == nil {
9749 m.Sint32Map = make(map[int32]int32)
9750 }
9751 var mapkey int32
9752 var mapvalue int32
9753 for iNdEx < postIndex {
9754 entryPreIndex := iNdEx
9755 var wire uint64
9756 for shift := uint(0); ; shift += 7 {
9757 if shift >= 64 {
9758 return ErrIntOverflowTheproto3
9759 }
9760 if iNdEx >= l {
9761 return io.ErrUnexpectedEOF
9762 }
9763 b := dAtA[iNdEx]
9764 iNdEx++
9765 wire |= uint64(b&0x7F) << shift
9766 if b < 0x80 {
9767 break
9768 }
9769 }
9770 fieldNum := int32(wire >> 3)
9771 if fieldNum == 1 {
9772 var mapkeytemp int32
9773 for shift := uint(0); ; shift += 7 {
9774 if shift >= 64 {
9775 return ErrIntOverflowTheproto3
9776 }
9777 if iNdEx >= l {
9778 return io.ErrUnexpectedEOF
9779 }
9780 b := dAtA[iNdEx]
9781 iNdEx++
9782 mapkeytemp |= int32(b&0x7F) << shift
9783 if b < 0x80 {
9784 break
9785 }
9786 }
9787 mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
9788 mapkey = int32(mapkeytemp)
9789 } else if fieldNum == 2 {
9790 var mapvaluetemp int32
9791 for shift := uint(0); ; shift += 7 {
9792 if shift >= 64 {
9793 return ErrIntOverflowTheproto3
9794 }
9795 if iNdEx >= l {
9796 return io.ErrUnexpectedEOF
9797 }
9798 b := dAtA[iNdEx]
9799 iNdEx++
9800 mapvaluetemp |= int32(b&0x7F) << shift
9801 if b < 0x80 {
9802 break
9803 }
9804 }
9805 mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
9806 mapvalue = int32(mapvaluetemp)
9807 } else {
9808 iNdEx = entryPreIndex
9809 skippy, err := skipTheproto3(dAtA[iNdEx:])
9810 if err != nil {
9811 return err
9812 }
9813 if (skippy < 0) || (iNdEx+skippy) < 0 {
9814 return ErrInvalidLengthTheproto3
9815 }
9816 if (iNdEx + skippy) > postIndex {
9817 return io.ErrUnexpectedEOF
9818 }
9819 iNdEx += skippy
9820 }
9821 }
9822 m.Sint32Map[mapkey] = mapvalue
9823 iNdEx = postIndex
9824 case 8:
9825 if wireType != 2 {
9826 return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType)
9827 }
9828 var msglen int
9829 for shift := uint(0); ; shift += 7 {
9830 if shift >= 64 {
9831 return ErrIntOverflowTheproto3
9832 }
9833 if iNdEx >= l {
9834 return io.ErrUnexpectedEOF
9835 }
9836 b := dAtA[iNdEx]
9837 iNdEx++
9838 msglen |= int(b&0x7F) << shift
9839 if b < 0x80 {
9840 break
9841 }
9842 }
9843 if msglen < 0 {
9844 return ErrInvalidLengthTheproto3
9845 }
9846 postIndex := iNdEx + msglen
9847 if postIndex < 0 {
9848 return ErrInvalidLengthTheproto3
9849 }
9850 if postIndex > l {
9851 return io.ErrUnexpectedEOF
9852 }
9853 if m.Sint64Map == nil {
9854 m.Sint64Map = make(map[int64]int64)
9855 }
9856 var mapkey int64
9857 var mapvalue int64
9858 for iNdEx < postIndex {
9859 entryPreIndex := iNdEx
9860 var wire uint64
9861 for shift := uint(0); ; shift += 7 {
9862 if shift >= 64 {
9863 return ErrIntOverflowTheproto3
9864 }
9865 if iNdEx >= l {
9866 return io.ErrUnexpectedEOF
9867 }
9868 b := dAtA[iNdEx]
9869 iNdEx++
9870 wire |= uint64(b&0x7F) << shift
9871 if b < 0x80 {
9872 break
9873 }
9874 }
9875 fieldNum := int32(wire >> 3)
9876 if fieldNum == 1 {
9877 var mapkeytemp uint64
9878 for shift := uint(0); ; shift += 7 {
9879 if shift >= 64 {
9880 return ErrIntOverflowTheproto3
9881 }
9882 if iNdEx >= l {
9883 return io.ErrUnexpectedEOF
9884 }
9885 b := dAtA[iNdEx]
9886 iNdEx++
9887 mapkeytemp |= uint64(b&0x7F) << shift
9888 if b < 0x80 {
9889 break
9890 }
9891 }
9892 mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
9893 mapkey = int64(mapkeytemp)
9894 } else if fieldNum == 2 {
9895 var mapvaluetemp uint64
9896 for shift := uint(0); ; shift += 7 {
9897 if shift >= 64 {
9898 return ErrIntOverflowTheproto3
9899 }
9900 if iNdEx >= l {
9901 return io.ErrUnexpectedEOF
9902 }
9903 b := dAtA[iNdEx]
9904 iNdEx++
9905 mapvaluetemp |= uint64(b&0x7F) << shift
9906 if b < 0x80 {
9907 break
9908 }
9909 }
9910 mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
9911 mapvalue = int64(mapvaluetemp)
9912 } else {
9913 iNdEx = entryPreIndex
9914 skippy, err := skipTheproto3(dAtA[iNdEx:])
9915 if err != nil {
9916 return err
9917 }
9918 if (skippy < 0) || (iNdEx+skippy) < 0 {
9919 return ErrInvalidLengthTheproto3
9920 }
9921 if (iNdEx + skippy) > postIndex {
9922 return io.ErrUnexpectedEOF
9923 }
9924 iNdEx += skippy
9925 }
9926 }
9927 m.Sint64Map[mapkey] = mapvalue
9928 iNdEx = postIndex
9929 case 9:
9930 if wireType != 2 {
9931 return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType)
9932 }
9933 var msglen int
9934 for shift := uint(0); ; shift += 7 {
9935 if shift >= 64 {
9936 return ErrIntOverflowTheproto3
9937 }
9938 if iNdEx >= l {
9939 return io.ErrUnexpectedEOF
9940 }
9941 b := dAtA[iNdEx]
9942 iNdEx++
9943 msglen |= int(b&0x7F) << shift
9944 if b < 0x80 {
9945 break
9946 }
9947 }
9948 if msglen < 0 {
9949 return ErrInvalidLengthTheproto3
9950 }
9951 postIndex := iNdEx + msglen
9952 if postIndex < 0 {
9953 return ErrInvalidLengthTheproto3
9954 }
9955 if postIndex > l {
9956 return io.ErrUnexpectedEOF
9957 }
9958 if m.Fixed32Map == nil {
9959 m.Fixed32Map = make(map[uint32]uint32)
9960 }
9961 var mapkey uint32
9962 var mapvalue uint32
9963 for iNdEx < postIndex {
9964 entryPreIndex := iNdEx
9965 var wire uint64
9966 for shift := uint(0); ; shift += 7 {
9967 if shift >= 64 {
9968 return ErrIntOverflowTheproto3
9969 }
9970 if iNdEx >= l {
9971 return io.ErrUnexpectedEOF
9972 }
9973 b := dAtA[iNdEx]
9974 iNdEx++
9975 wire |= uint64(b&0x7F) << shift
9976 if b < 0x80 {
9977 break
9978 }
9979 }
9980 fieldNum := int32(wire >> 3)
9981 if fieldNum == 1 {
9982 if (iNdEx + 4) > l {
9983 return io.ErrUnexpectedEOF
9984 }
9985 mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
9986 iNdEx += 4
9987 } else if fieldNum == 2 {
9988 if (iNdEx + 4) > l {
9989 return io.ErrUnexpectedEOF
9990 }
9991 mapvalue = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
9992 iNdEx += 4
9993 } else {
9994 iNdEx = entryPreIndex
9995 skippy, err := skipTheproto3(dAtA[iNdEx:])
9996 if err != nil {
9997 return err
9998 }
9999 if (skippy < 0) || (iNdEx+skippy) < 0 {
10000 return ErrInvalidLengthTheproto3
10001 }
10002 if (iNdEx + skippy) > postIndex {
10003 return io.ErrUnexpectedEOF
10004 }
10005 iNdEx += skippy
10006 }
10007 }
10008 m.Fixed32Map[mapkey] = mapvalue
10009 iNdEx = postIndex
10010 case 10:
10011 if wireType != 2 {
10012 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType)
10013 }
10014 var msglen int
10015 for shift := uint(0); ; shift += 7 {
10016 if shift >= 64 {
10017 return ErrIntOverflowTheproto3
10018 }
10019 if iNdEx >= l {
10020 return io.ErrUnexpectedEOF
10021 }
10022 b := dAtA[iNdEx]
10023 iNdEx++
10024 msglen |= int(b&0x7F) << shift
10025 if b < 0x80 {
10026 break
10027 }
10028 }
10029 if msglen < 0 {
10030 return ErrInvalidLengthTheproto3
10031 }
10032 postIndex := iNdEx + msglen
10033 if postIndex < 0 {
10034 return ErrInvalidLengthTheproto3
10035 }
10036 if postIndex > l {
10037 return io.ErrUnexpectedEOF
10038 }
10039 if m.Sfixed32Map == nil {
10040 m.Sfixed32Map = make(map[int32]int32)
10041 }
10042 var mapkey int32
10043 var mapvalue int32
10044 for iNdEx < postIndex {
10045 entryPreIndex := iNdEx
10046 var wire uint64
10047 for shift := uint(0); ; shift += 7 {
10048 if shift >= 64 {
10049 return ErrIntOverflowTheproto3
10050 }
10051 if iNdEx >= l {
10052 return io.ErrUnexpectedEOF
10053 }
10054 b := dAtA[iNdEx]
10055 iNdEx++
10056 wire |= uint64(b&0x7F) << shift
10057 if b < 0x80 {
10058 break
10059 }
10060 }
10061 fieldNum := int32(wire >> 3)
10062 if fieldNum == 1 {
10063 if (iNdEx + 4) > l {
10064 return io.ErrUnexpectedEOF
10065 }
10066 mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
10067 iNdEx += 4
10068 } else if fieldNum == 2 {
10069 if (iNdEx + 4) > l {
10070 return io.ErrUnexpectedEOF
10071 }
10072 mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
10073 iNdEx += 4
10074 } else {
10075 iNdEx = entryPreIndex
10076 skippy, err := skipTheproto3(dAtA[iNdEx:])
10077 if err != nil {
10078 return err
10079 }
10080 if (skippy < 0) || (iNdEx+skippy) < 0 {
10081 return ErrInvalidLengthTheproto3
10082 }
10083 if (iNdEx + skippy) > postIndex {
10084 return io.ErrUnexpectedEOF
10085 }
10086 iNdEx += skippy
10087 }
10088 }
10089 m.Sfixed32Map[mapkey] = mapvalue
10090 iNdEx = postIndex
10091 case 11:
10092 if wireType != 2 {
10093 return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType)
10094 }
10095 var msglen int
10096 for shift := uint(0); ; shift += 7 {
10097 if shift >= 64 {
10098 return ErrIntOverflowTheproto3
10099 }
10100 if iNdEx >= l {
10101 return io.ErrUnexpectedEOF
10102 }
10103 b := dAtA[iNdEx]
10104 iNdEx++
10105 msglen |= int(b&0x7F) << shift
10106 if b < 0x80 {
10107 break
10108 }
10109 }
10110 if msglen < 0 {
10111 return ErrInvalidLengthTheproto3
10112 }
10113 postIndex := iNdEx + msglen
10114 if postIndex < 0 {
10115 return ErrInvalidLengthTheproto3
10116 }
10117 if postIndex > l {
10118 return io.ErrUnexpectedEOF
10119 }
10120 if m.Fixed64Map == nil {
10121 m.Fixed64Map = make(map[uint64]uint64)
10122 }
10123 var mapkey uint64
10124 var mapvalue uint64
10125 for iNdEx < postIndex {
10126 entryPreIndex := iNdEx
10127 var wire uint64
10128 for shift := uint(0); ; shift += 7 {
10129 if shift >= 64 {
10130 return ErrIntOverflowTheproto3
10131 }
10132 if iNdEx >= l {
10133 return io.ErrUnexpectedEOF
10134 }
10135 b := dAtA[iNdEx]
10136 iNdEx++
10137 wire |= uint64(b&0x7F) << shift
10138 if b < 0x80 {
10139 break
10140 }
10141 }
10142 fieldNum := int32(wire >> 3)
10143 if fieldNum == 1 {
10144 if (iNdEx + 8) > l {
10145 return io.ErrUnexpectedEOF
10146 }
10147 mapkey = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
10148 iNdEx += 8
10149 } else if fieldNum == 2 {
10150 if (iNdEx + 8) > l {
10151 return io.ErrUnexpectedEOF
10152 }
10153 mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
10154 iNdEx += 8
10155 } else {
10156 iNdEx = entryPreIndex
10157 skippy, err := skipTheproto3(dAtA[iNdEx:])
10158 if err != nil {
10159 return err
10160 }
10161 if (skippy < 0) || (iNdEx+skippy) < 0 {
10162 return ErrInvalidLengthTheproto3
10163 }
10164 if (iNdEx + skippy) > postIndex {
10165 return io.ErrUnexpectedEOF
10166 }
10167 iNdEx += skippy
10168 }
10169 }
10170 m.Fixed64Map[mapkey] = mapvalue
10171 iNdEx = postIndex
10172 case 12:
10173 if wireType != 2 {
10174 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType)
10175 }
10176 var msglen int
10177 for shift := uint(0); ; shift += 7 {
10178 if shift >= 64 {
10179 return ErrIntOverflowTheproto3
10180 }
10181 if iNdEx >= l {
10182 return io.ErrUnexpectedEOF
10183 }
10184 b := dAtA[iNdEx]
10185 iNdEx++
10186 msglen |= int(b&0x7F) << shift
10187 if b < 0x80 {
10188 break
10189 }
10190 }
10191 if msglen < 0 {
10192 return ErrInvalidLengthTheproto3
10193 }
10194 postIndex := iNdEx + msglen
10195 if postIndex < 0 {
10196 return ErrInvalidLengthTheproto3
10197 }
10198 if postIndex > l {
10199 return io.ErrUnexpectedEOF
10200 }
10201 if m.Sfixed64Map == nil {
10202 m.Sfixed64Map = make(map[int64]int64)
10203 }
10204 var mapkey int64
10205 var mapvalue int64
10206 for iNdEx < postIndex {
10207 entryPreIndex := iNdEx
10208 var wire uint64
10209 for shift := uint(0); ; shift += 7 {
10210 if shift >= 64 {
10211 return ErrIntOverflowTheproto3
10212 }
10213 if iNdEx >= l {
10214 return io.ErrUnexpectedEOF
10215 }
10216 b := dAtA[iNdEx]
10217 iNdEx++
10218 wire |= uint64(b&0x7F) << shift
10219 if b < 0x80 {
10220 break
10221 }
10222 }
10223 fieldNum := int32(wire >> 3)
10224 if fieldNum == 1 {
10225 if (iNdEx + 8) > l {
10226 return io.ErrUnexpectedEOF
10227 }
10228 mapkey = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
10229 iNdEx += 8
10230 } else if fieldNum == 2 {
10231 if (iNdEx + 8) > l {
10232 return io.ErrUnexpectedEOF
10233 }
10234 mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
10235 iNdEx += 8
10236 } else {
10237 iNdEx = entryPreIndex
10238 skippy, err := skipTheproto3(dAtA[iNdEx:])
10239 if err != nil {
10240 return err
10241 }
10242 if (skippy < 0) || (iNdEx+skippy) < 0 {
10243 return ErrInvalidLengthTheproto3
10244 }
10245 if (iNdEx + skippy) > postIndex {
10246 return io.ErrUnexpectedEOF
10247 }
10248 iNdEx += skippy
10249 }
10250 }
10251 m.Sfixed64Map[mapkey] = mapvalue
10252 iNdEx = postIndex
10253 case 13:
10254 if wireType != 2 {
10255 return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType)
10256 }
10257 var msglen int
10258 for shift := uint(0); ; shift += 7 {
10259 if shift >= 64 {
10260 return ErrIntOverflowTheproto3
10261 }
10262 if iNdEx >= l {
10263 return io.ErrUnexpectedEOF
10264 }
10265 b := dAtA[iNdEx]
10266 iNdEx++
10267 msglen |= int(b&0x7F) << shift
10268 if b < 0x80 {
10269 break
10270 }
10271 }
10272 if msglen < 0 {
10273 return ErrInvalidLengthTheproto3
10274 }
10275 postIndex := iNdEx + msglen
10276 if postIndex < 0 {
10277 return ErrInvalidLengthTheproto3
10278 }
10279 if postIndex > l {
10280 return io.ErrUnexpectedEOF
10281 }
10282 if m.BoolMap == nil {
10283 m.BoolMap = make(map[bool]bool)
10284 }
10285 var mapkey bool
10286 var mapvalue bool
10287 for iNdEx < postIndex {
10288 entryPreIndex := iNdEx
10289 var wire uint64
10290 for shift := uint(0); ; shift += 7 {
10291 if shift >= 64 {
10292 return ErrIntOverflowTheproto3
10293 }
10294 if iNdEx >= l {
10295 return io.ErrUnexpectedEOF
10296 }
10297 b := dAtA[iNdEx]
10298 iNdEx++
10299 wire |= uint64(b&0x7F) << shift
10300 if b < 0x80 {
10301 break
10302 }
10303 }
10304 fieldNum := int32(wire >> 3)
10305 if fieldNum == 1 {
10306 var mapkeytemp int
10307 for shift := uint(0); ; shift += 7 {
10308 if shift >= 64 {
10309 return ErrIntOverflowTheproto3
10310 }
10311 if iNdEx >= l {
10312 return io.ErrUnexpectedEOF
10313 }
10314 b := dAtA[iNdEx]
10315 iNdEx++
10316 mapkeytemp |= int(b&0x7F) << shift
10317 if b < 0x80 {
10318 break
10319 }
10320 }
10321 mapkey = bool(mapkeytemp != 0)
10322 } else if fieldNum == 2 {
10323 var mapvaluetemp int
10324 for shift := uint(0); ; shift += 7 {
10325 if shift >= 64 {
10326 return ErrIntOverflowTheproto3
10327 }
10328 if iNdEx >= l {
10329 return io.ErrUnexpectedEOF
10330 }
10331 b := dAtA[iNdEx]
10332 iNdEx++
10333 mapvaluetemp |= int(b&0x7F) << shift
10334 if b < 0x80 {
10335 break
10336 }
10337 }
10338 mapvalue = bool(mapvaluetemp != 0)
10339 } else {
10340 iNdEx = entryPreIndex
10341 skippy, err := skipTheproto3(dAtA[iNdEx:])
10342 if err != nil {
10343 return err
10344 }
10345 if (skippy < 0) || (iNdEx+skippy) < 0 {
10346 return ErrInvalidLengthTheproto3
10347 }
10348 if (iNdEx + skippy) > postIndex {
10349 return io.ErrUnexpectedEOF
10350 }
10351 iNdEx += skippy
10352 }
10353 }
10354 m.BoolMap[mapkey] = mapvalue
10355 iNdEx = postIndex
10356 case 14:
10357 if wireType != 2 {
10358 return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType)
10359 }
10360 var msglen int
10361 for shift := uint(0); ; shift += 7 {
10362 if shift >= 64 {
10363 return ErrIntOverflowTheproto3
10364 }
10365 if iNdEx >= l {
10366 return io.ErrUnexpectedEOF
10367 }
10368 b := dAtA[iNdEx]
10369 iNdEx++
10370 msglen |= int(b&0x7F) << shift
10371 if b < 0x80 {
10372 break
10373 }
10374 }
10375 if msglen < 0 {
10376 return ErrInvalidLengthTheproto3
10377 }
10378 postIndex := iNdEx + msglen
10379 if postIndex < 0 {
10380 return ErrInvalidLengthTheproto3
10381 }
10382 if postIndex > l {
10383 return io.ErrUnexpectedEOF
10384 }
10385 if m.StringMap == nil {
10386 m.StringMap = make(map[string]string)
10387 }
10388 var mapkey string
10389 var mapvalue string
10390 for iNdEx < postIndex {
10391 entryPreIndex := iNdEx
10392 var wire uint64
10393 for shift := uint(0); ; shift += 7 {
10394 if shift >= 64 {
10395 return ErrIntOverflowTheproto3
10396 }
10397 if iNdEx >= l {
10398 return io.ErrUnexpectedEOF
10399 }
10400 b := dAtA[iNdEx]
10401 iNdEx++
10402 wire |= uint64(b&0x7F) << shift
10403 if b < 0x80 {
10404 break
10405 }
10406 }
10407 fieldNum := int32(wire >> 3)
10408 if fieldNum == 1 {
10409 var stringLenmapkey uint64
10410 for shift := uint(0); ; shift += 7 {
10411 if shift >= 64 {
10412 return ErrIntOverflowTheproto3
10413 }
10414 if iNdEx >= l {
10415 return io.ErrUnexpectedEOF
10416 }
10417 b := dAtA[iNdEx]
10418 iNdEx++
10419 stringLenmapkey |= uint64(b&0x7F) << shift
10420 if b < 0x80 {
10421 break
10422 }
10423 }
10424 intStringLenmapkey := int(stringLenmapkey)
10425 if intStringLenmapkey < 0 {
10426 return ErrInvalidLengthTheproto3
10427 }
10428 postStringIndexmapkey := iNdEx + intStringLenmapkey
10429 if postStringIndexmapkey < 0 {
10430 return ErrInvalidLengthTheproto3
10431 }
10432 if postStringIndexmapkey > l {
10433 return io.ErrUnexpectedEOF
10434 }
10435 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
10436 iNdEx = postStringIndexmapkey
10437 } else if fieldNum == 2 {
10438 var stringLenmapvalue uint64
10439 for shift := uint(0); ; shift += 7 {
10440 if shift >= 64 {
10441 return ErrIntOverflowTheproto3
10442 }
10443 if iNdEx >= l {
10444 return io.ErrUnexpectedEOF
10445 }
10446 b := dAtA[iNdEx]
10447 iNdEx++
10448 stringLenmapvalue |= uint64(b&0x7F) << shift
10449 if b < 0x80 {
10450 break
10451 }
10452 }
10453 intStringLenmapvalue := int(stringLenmapvalue)
10454 if intStringLenmapvalue < 0 {
10455 return ErrInvalidLengthTheproto3
10456 }
10457 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
10458 if postStringIndexmapvalue < 0 {
10459 return ErrInvalidLengthTheproto3
10460 }
10461 if postStringIndexmapvalue > l {
10462 return io.ErrUnexpectedEOF
10463 }
10464 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
10465 iNdEx = postStringIndexmapvalue
10466 } else {
10467 iNdEx = entryPreIndex
10468 skippy, err := skipTheproto3(dAtA[iNdEx:])
10469 if err != nil {
10470 return err
10471 }
10472 if (skippy < 0) || (iNdEx+skippy) < 0 {
10473 return ErrInvalidLengthTheproto3
10474 }
10475 if (iNdEx + skippy) > postIndex {
10476 return io.ErrUnexpectedEOF
10477 }
10478 iNdEx += skippy
10479 }
10480 }
10481 m.StringMap[mapkey] = mapvalue
10482 iNdEx = postIndex
10483 case 15:
10484 if wireType != 2 {
10485 return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType)
10486 }
10487 var msglen int
10488 for shift := uint(0); ; shift += 7 {
10489 if shift >= 64 {
10490 return ErrIntOverflowTheproto3
10491 }
10492 if iNdEx >= l {
10493 return io.ErrUnexpectedEOF
10494 }
10495 b := dAtA[iNdEx]
10496 iNdEx++
10497 msglen |= int(b&0x7F) << shift
10498 if b < 0x80 {
10499 break
10500 }
10501 }
10502 if msglen < 0 {
10503 return ErrInvalidLengthTheproto3
10504 }
10505 postIndex := iNdEx + msglen
10506 if postIndex < 0 {
10507 return ErrInvalidLengthTheproto3
10508 }
10509 if postIndex > l {
10510 return io.ErrUnexpectedEOF
10511 }
10512 if m.StringToBytesMap == nil {
10513 m.StringToBytesMap = make(map[string][]byte)
10514 }
10515 var mapkey string
10516 mapvalue := []byte{}
10517 for iNdEx < postIndex {
10518 entryPreIndex := iNdEx
10519 var wire uint64
10520 for shift := uint(0); ; shift += 7 {
10521 if shift >= 64 {
10522 return ErrIntOverflowTheproto3
10523 }
10524 if iNdEx >= l {
10525 return io.ErrUnexpectedEOF
10526 }
10527 b := dAtA[iNdEx]
10528 iNdEx++
10529 wire |= uint64(b&0x7F) << shift
10530 if b < 0x80 {
10531 break
10532 }
10533 }
10534 fieldNum := int32(wire >> 3)
10535 if fieldNum == 1 {
10536 var stringLenmapkey uint64
10537 for shift := uint(0); ; shift += 7 {
10538 if shift >= 64 {
10539 return ErrIntOverflowTheproto3
10540 }
10541 if iNdEx >= l {
10542 return io.ErrUnexpectedEOF
10543 }
10544 b := dAtA[iNdEx]
10545 iNdEx++
10546 stringLenmapkey |= uint64(b&0x7F) << shift
10547 if b < 0x80 {
10548 break
10549 }
10550 }
10551 intStringLenmapkey := int(stringLenmapkey)
10552 if intStringLenmapkey < 0 {
10553 return ErrInvalidLengthTheproto3
10554 }
10555 postStringIndexmapkey := iNdEx + intStringLenmapkey
10556 if postStringIndexmapkey < 0 {
10557 return ErrInvalidLengthTheproto3
10558 }
10559 if postStringIndexmapkey > l {
10560 return io.ErrUnexpectedEOF
10561 }
10562 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
10563 iNdEx = postStringIndexmapkey
10564 } else if fieldNum == 2 {
10565 var mapbyteLen uint64
10566 for shift := uint(0); ; shift += 7 {
10567 if shift >= 64 {
10568 return ErrIntOverflowTheproto3
10569 }
10570 if iNdEx >= l {
10571 return io.ErrUnexpectedEOF
10572 }
10573 b := dAtA[iNdEx]
10574 iNdEx++
10575 mapbyteLen |= uint64(b&0x7F) << shift
10576 if b < 0x80 {
10577 break
10578 }
10579 }
10580 intMapbyteLen := int(mapbyteLen)
10581 if intMapbyteLen < 0 {
10582 return ErrInvalidLengthTheproto3
10583 }
10584 postbytesIndex := iNdEx + intMapbyteLen
10585 if postbytesIndex < 0 {
10586 return ErrInvalidLengthTheproto3
10587 }
10588 if postbytesIndex > l {
10589 return io.ErrUnexpectedEOF
10590 }
10591 mapvalue = make([]byte, mapbyteLen)
10592 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
10593 iNdEx = postbytesIndex
10594 } else {
10595 iNdEx = entryPreIndex
10596 skippy, err := skipTheproto3(dAtA[iNdEx:])
10597 if err != nil {
10598 return err
10599 }
10600 if (skippy < 0) || (iNdEx+skippy) < 0 {
10601 return ErrInvalidLengthTheproto3
10602 }
10603 if (iNdEx + skippy) > postIndex {
10604 return io.ErrUnexpectedEOF
10605 }
10606 iNdEx += skippy
10607 }
10608 }
10609 m.StringToBytesMap[mapkey] = mapvalue
10610 iNdEx = postIndex
10611 case 16:
10612 if wireType != 2 {
10613 return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType)
10614 }
10615 var msglen int
10616 for shift := uint(0); ; shift += 7 {
10617 if shift >= 64 {
10618 return ErrIntOverflowTheproto3
10619 }
10620 if iNdEx >= l {
10621 return io.ErrUnexpectedEOF
10622 }
10623 b := dAtA[iNdEx]
10624 iNdEx++
10625 msglen |= int(b&0x7F) << shift
10626 if b < 0x80 {
10627 break
10628 }
10629 }
10630 if msglen < 0 {
10631 return ErrInvalidLengthTheproto3
10632 }
10633 postIndex := iNdEx + msglen
10634 if postIndex < 0 {
10635 return ErrInvalidLengthTheproto3
10636 }
10637 if postIndex > l {
10638 return io.ErrUnexpectedEOF
10639 }
10640 if m.StringToEnumMap == nil {
10641 m.StringToEnumMap = make(map[string]MapEnum)
10642 }
10643 var mapkey string
10644 var mapvalue MapEnum
10645 for iNdEx < postIndex {
10646 entryPreIndex := iNdEx
10647 var wire uint64
10648 for shift := uint(0); ; shift += 7 {
10649 if shift >= 64 {
10650 return ErrIntOverflowTheproto3
10651 }
10652 if iNdEx >= l {
10653 return io.ErrUnexpectedEOF
10654 }
10655 b := dAtA[iNdEx]
10656 iNdEx++
10657 wire |= uint64(b&0x7F) << shift
10658 if b < 0x80 {
10659 break
10660 }
10661 }
10662 fieldNum := int32(wire >> 3)
10663 if fieldNum == 1 {
10664 var stringLenmapkey uint64
10665 for shift := uint(0); ; shift += 7 {
10666 if shift >= 64 {
10667 return ErrIntOverflowTheproto3
10668 }
10669 if iNdEx >= l {
10670 return io.ErrUnexpectedEOF
10671 }
10672 b := dAtA[iNdEx]
10673 iNdEx++
10674 stringLenmapkey |= uint64(b&0x7F) << shift
10675 if b < 0x80 {
10676 break
10677 }
10678 }
10679 intStringLenmapkey := int(stringLenmapkey)
10680 if intStringLenmapkey < 0 {
10681 return ErrInvalidLengthTheproto3
10682 }
10683 postStringIndexmapkey := iNdEx + intStringLenmapkey
10684 if postStringIndexmapkey < 0 {
10685 return ErrInvalidLengthTheproto3
10686 }
10687 if postStringIndexmapkey > l {
10688 return io.ErrUnexpectedEOF
10689 }
10690 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
10691 iNdEx = postStringIndexmapkey
10692 } else if fieldNum == 2 {
10693 for shift := uint(0); ; shift += 7 {
10694 if shift >= 64 {
10695 return ErrIntOverflowTheproto3
10696 }
10697 if iNdEx >= l {
10698 return io.ErrUnexpectedEOF
10699 }
10700 b := dAtA[iNdEx]
10701 iNdEx++
10702 mapvalue |= MapEnum(b&0x7F) << shift
10703 if b < 0x80 {
10704 break
10705 }
10706 }
10707 } else {
10708 iNdEx = entryPreIndex
10709 skippy, err := skipTheproto3(dAtA[iNdEx:])
10710 if err != nil {
10711 return err
10712 }
10713 if (skippy < 0) || (iNdEx+skippy) < 0 {
10714 return ErrInvalidLengthTheproto3
10715 }
10716 if (iNdEx + skippy) > postIndex {
10717 return io.ErrUnexpectedEOF
10718 }
10719 iNdEx += skippy
10720 }
10721 }
10722 m.StringToEnumMap[mapkey] = mapvalue
10723 iNdEx = postIndex
10724 case 17:
10725 if wireType != 2 {
10726 return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType)
10727 }
10728 var msglen int
10729 for shift := uint(0); ; shift += 7 {
10730 if shift >= 64 {
10731 return ErrIntOverflowTheproto3
10732 }
10733 if iNdEx >= l {
10734 return io.ErrUnexpectedEOF
10735 }
10736 b := dAtA[iNdEx]
10737 iNdEx++
10738 msglen |= int(b&0x7F) << shift
10739 if b < 0x80 {
10740 break
10741 }
10742 }
10743 if msglen < 0 {
10744 return ErrInvalidLengthTheproto3
10745 }
10746 postIndex := iNdEx + msglen
10747 if postIndex < 0 {
10748 return ErrInvalidLengthTheproto3
10749 }
10750 if postIndex > l {
10751 return io.ErrUnexpectedEOF
10752 }
10753 if m.StringToMsgMap == nil {
10754 m.StringToMsgMap = make(map[string]*FloatingPoint)
10755 }
10756 var mapkey string
10757 var mapvalue *FloatingPoint
10758 for iNdEx < postIndex {
10759 entryPreIndex := iNdEx
10760 var wire uint64
10761 for shift := uint(0); ; shift += 7 {
10762 if shift >= 64 {
10763 return ErrIntOverflowTheproto3
10764 }
10765 if iNdEx >= l {
10766 return io.ErrUnexpectedEOF
10767 }
10768 b := dAtA[iNdEx]
10769 iNdEx++
10770 wire |= uint64(b&0x7F) << shift
10771 if b < 0x80 {
10772 break
10773 }
10774 }
10775 fieldNum := int32(wire >> 3)
10776 if fieldNum == 1 {
10777 var stringLenmapkey uint64
10778 for shift := uint(0); ; shift += 7 {
10779 if shift >= 64 {
10780 return ErrIntOverflowTheproto3
10781 }
10782 if iNdEx >= l {
10783 return io.ErrUnexpectedEOF
10784 }
10785 b := dAtA[iNdEx]
10786 iNdEx++
10787 stringLenmapkey |= uint64(b&0x7F) << shift
10788 if b < 0x80 {
10789 break
10790 }
10791 }
10792 intStringLenmapkey := int(stringLenmapkey)
10793 if intStringLenmapkey < 0 {
10794 return ErrInvalidLengthTheproto3
10795 }
10796 postStringIndexmapkey := iNdEx + intStringLenmapkey
10797 if postStringIndexmapkey < 0 {
10798 return ErrInvalidLengthTheproto3
10799 }
10800 if postStringIndexmapkey > l {
10801 return io.ErrUnexpectedEOF
10802 }
10803 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
10804 iNdEx = postStringIndexmapkey
10805 } else if fieldNum == 2 {
10806 var mapmsglen int
10807 for shift := uint(0); ; shift += 7 {
10808 if shift >= 64 {
10809 return ErrIntOverflowTheproto3
10810 }
10811 if iNdEx >= l {
10812 return io.ErrUnexpectedEOF
10813 }
10814 b := dAtA[iNdEx]
10815 iNdEx++
10816 mapmsglen |= int(b&0x7F) << shift
10817 if b < 0x80 {
10818 break
10819 }
10820 }
10821 if mapmsglen < 0 {
10822 return ErrInvalidLengthTheproto3
10823 }
10824 postmsgIndex := iNdEx + mapmsglen
10825 if postmsgIndex < 0 {
10826 return ErrInvalidLengthTheproto3
10827 }
10828 if postmsgIndex > l {
10829 return io.ErrUnexpectedEOF
10830 }
10831 mapvalue = &FloatingPoint{}
10832 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
10833 return err
10834 }
10835 iNdEx = postmsgIndex
10836 } else {
10837 iNdEx = entryPreIndex
10838 skippy, err := skipTheproto3(dAtA[iNdEx:])
10839 if err != nil {
10840 return err
10841 }
10842 if (skippy < 0) || (iNdEx+skippy) < 0 {
10843 return ErrInvalidLengthTheproto3
10844 }
10845 if (iNdEx + skippy) > postIndex {
10846 return io.ErrUnexpectedEOF
10847 }
10848 iNdEx += skippy
10849 }
10850 }
10851 m.StringToMsgMap[mapkey] = mapvalue
10852 iNdEx = postIndex
10853 default:
10854 iNdEx = preIndex
10855 skippy, err := skipTheproto3(dAtA[iNdEx:])
10856 if err != nil {
10857 return err
10858 }
10859 if (skippy < 0) || (iNdEx+skippy) < 0 {
10860 return ErrInvalidLengthTheproto3
10861 }
10862 if (iNdEx + skippy) > l {
10863 return io.ErrUnexpectedEOF
10864 }
10865 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
10866 iNdEx += skippy
10867 }
10868 }
10869
10870 if iNdEx > l {
10871 return io.ErrUnexpectedEOF
10872 }
10873 return nil
10874 }
10875 func (m *MessageWithMap) Unmarshal(dAtA []byte) error {
10876 l := len(dAtA)
10877 iNdEx := 0
10878 for iNdEx < l {
10879 preIndex := iNdEx
10880 var wire uint64
10881 for shift := uint(0); ; shift += 7 {
10882 if shift >= 64 {
10883 return ErrIntOverflowTheproto3
10884 }
10885 if iNdEx >= l {
10886 return io.ErrUnexpectedEOF
10887 }
10888 b := dAtA[iNdEx]
10889 iNdEx++
10890 wire |= uint64(b&0x7F) << shift
10891 if b < 0x80 {
10892 break
10893 }
10894 }
10895 fieldNum := int32(wire >> 3)
10896 wireType := int(wire & 0x7)
10897 if wireType == 4 {
10898 return fmt.Errorf("proto: MessageWithMap: wiretype end group for non-group")
10899 }
10900 if fieldNum <= 0 {
10901 return fmt.Errorf("proto: MessageWithMap: illegal tag %d (wire type %d)", fieldNum, wire)
10902 }
10903 switch fieldNum {
10904 case 1:
10905 if wireType != 2 {
10906 return fmt.Errorf("proto: wrong wireType = %d for field NameMapping", wireType)
10907 }
10908 var msglen int
10909 for shift := uint(0); ; shift += 7 {
10910 if shift >= 64 {
10911 return ErrIntOverflowTheproto3
10912 }
10913 if iNdEx >= l {
10914 return io.ErrUnexpectedEOF
10915 }
10916 b := dAtA[iNdEx]
10917 iNdEx++
10918 msglen |= int(b&0x7F) << shift
10919 if b < 0x80 {
10920 break
10921 }
10922 }
10923 if msglen < 0 {
10924 return ErrInvalidLengthTheproto3
10925 }
10926 postIndex := iNdEx + msglen
10927 if postIndex < 0 {
10928 return ErrInvalidLengthTheproto3
10929 }
10930 if postIndex > l {
10931 return io.ErrUnexpectedEOF
10932 }
10933 if m.NameMapping == nil {
10934 m.NameMapping = make(map[int32]string)
10935 }
10936 var mapkey int32
10937 var mapvalue string
10938 for iNdEx < postIndex {
10939 entryPreIndex := iNdEx
10940 var wire uint64
10941 for shift := uint(0); ; shift += 7 {
10942 if shift >= 64 {
10943 return ErrIntOverflowTheproto3
10944 }
10945 if iNdEx >= l {
10946 return io.ErrUnexpectedEOF
10947 }
10948 b := dAtA[iNdEx]
10949 iNdEx++
10950 wire |= uint64(b&0x7F) << shift
10951 if b < 0x80 {
10952 break
10953 }
10954 }
10955 fieldNum := int32(wire >> 3)
10956 if fieldNum == 1 {
10957 for shift := uint(0); ; shift += 7 {
10958 if shift >= 64 {
10959 return ErrIntOverflowTheproto3
10960 }
10961 if iNdEx >= l {
10962 return io.ErrUnexpectedEOF
10963 }
10964 b := dAtA[iNdEx]
10965 iNdEx++
10966 mapkey |= int32(b&0x7F) << shift
10967 if b < 0x80 {
10968 break
10969 }
10970 }
10971 } else if fieldNum == 2 {
10972 var stringLenmapvalue uint64
10973 for shift := uint(0); ; shift += 7 {
10974 if shift >= 64 {
10975 return ErrIntOverflowTheproto3
10976 }
10977 if iNdEx >= l {
10978 return io.ErrUnexpectedEOF
10979 }
10980 b := dAtA[iNdEx]
10981 iNdEx++
10982 stringLenmapvalue |= uint64(b&0x7F) << shift
10983 if b < 0x80 {
10984 break
10985 }
10986 }
10987 intStringLenmapvalue := int(stringLenmapvalue)
10988 if intStringLenmapvalue < 0 {
10989 return ErrInvalidLengthTheproto3
10990 }
10991 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
10992 if postStringIndexmapvalue < 0 {
10993 return ErrInvalidLengthTheproto3
10994 }
10995 if postStringIndexmapvalue > l {
10996 return io.ErrUnexpectedEOF
10997 }
10998 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
10999 iNdEx = postStringIndexmapvalue
11000 } else {
11001 iNdEx = entryPreIndex
11002 skippy, err := skipTheproto3(dAtA[iNdEx:])
11003 if err != nil {
11004 return err
11005 }
11006 if (skippy < 0) || (iNdEx+skippy) < 0 {
11007 return ErrInvalidLengthTheproto3
11008 }
11009 if (iNdEx + skippy) > postIndex {
11010 return io.ErrUnexpectedEOF
11011 }
11012 iNdEx += skippy
11013 }
11014 }
11015 m.NameMapping[mapkey] = mapvalue
11016 iNdEx = postIndex
11017 case 2:
11018 if wireType != 2 {
11019 return fmt.Errorf("proto: wrong wireType = %d for field MsgMapping", wireType)
11020 }
11021 var msglen int
11022 for shift := uint(0); ; shift += 7 {
11023 if shift >= 64 {
11024 return ErrIntOverflowTheproto3
11025 }
11026 if iNdEx >= l {
11027 return io.ErrUnexpectedEOF
11028 }
11029 b := dAtA[iNdEx]
11030 iNdEx++
11031 msglen |= int(b&0x7F) << shift
11032 if b < 0x80 {
11033 break
11034 }
11035 }
11036 if msglen < 0 {
11037 return ErrInvalidLengthTheproto3
11038 }
11039 postIndex := iNdEx + msglen
11040 if postIndex < 0 {
11041 return ErrInvalidLengthTheproto3
11042 }
11043 if postIndex > l {
11044 return io.ErrUnexpectedEOF
11045 }
11046 if m.MsgMapping == nil {
11047 m.MsgMapping = make(map[int64]*FloatingPoint)
11048 }
11049 var mapkey int64
11050 var mapvalue *FloatingPoint
11051 for iNdEx < postIndex {
11052 entryPreIndex := iNdEx
11053 var wire uint64
11054 for shift := uint(0); ; shift += 7 {
11055 if shift >= 64 {
11056 return ErrIntOverflowTheproto3
11057 }
11058 if iNdEx >= l {
11059 return io.ErrUnexpectedEOF
11060 }
11061 b := dAtA[iNdEx]
11062 iNdEx++
11063 wire |= uint64(b&0x7F) << shift
11064 if b < 0x80 {
11065 break
11066 }
11067 }
11068 fieldNum := int32(wire >> 3)
11069 if fieldNum == 1 {
11070 var mapkeytemp uint64
11071 for shift := uint(0); ; shift += 7 {
11072 if shift >= 64 {
11073 return ErrIntOverflowTheproto3
11074 }
11075 if iNdEx >= l {
11076 return io.ErrUnexpectedEOF
11077 }
11078 b := dAtA[iNdEx]
11079 iNdEx++
11080 mapkeytemp |= uint64(b&0x7F) << shift
11081 if b < 0x80 {
11082 break
11083 }
11084 }
11085 mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
11086 mapkey = int64(mapkeytemp)
11087 } else if fieldNum == 2 {
11088 var mapmsglen int
11089 for shift := uint(0); ; shift += 7 {
11090 if shift >= 64 {
11091 return ErrIntOverflowTheproto3
11092 }
11093 if iNdEx >= l {
11094 return io.ErrUnexpectedEOF
11095 }
11096 b := dAtA[iNdEx]
11097 iNdEx++
11098 mapmsglen |= int(b&0x7F) << shift
11099 if b < 0x80 {
11100 break
11101 }
11102 }
11103 if mapmsglen < 0 {
11104 return ErrInvalidLengthTheproto3
11105 }
11106 postmsgIndex := iNdEx + mapmsglen
11107 if postmsgIndex < 0 {
11108 return ErrInvalidLengthTheproto3
11109 }
11110 if postmsgIndex > l {
11111 return io.ErrUnexpectedEOF
11112 }
11113 mapvalue = &FloatingPoint{}
11114 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
11115 return err
11116 }
11117 iNdEx = postmsgIndex
11118 } else {
11119 iNdEx = entryPreIndex
11120 skippy, err := skipTheproto3(dAtA[iNdEx:])
11121 if err != nil {
11122 return err
11123 }
11124 if (skippy < 0) || (iNdEx+skippy) < 0 {
11125 return ErrInvalidLengthTheproto3
11126 }
11127 if (iNdEx + skippy) > postIndex {
11128 return io.ErrUnexpectedEOF
11129 }
11130 iNdEx += skippy
11131 }
11132 }
11133 m.MsgMapping[mapkey] = mapvalue
11134 iNdEx = postIndex
11135 case 3:
11136 if wireType != 2 {
11137 return fmt.Errorf("proto: wrong wireType = %d for field ByteMapping", wireType)
11138 }
11139 var msglen int
11140 for shift := uint(0); ; shift += 7 {
11141 if shift >= 64 {
11142 return ErrIntOverflowTheproto3
11143 }
11144 if iNdEx >= l {
11145 return io.ErrUnexpectedEOF
11146 }
11147 b := dAtA[iNdEx]
11148 iNdEx++
11149 msglen |= int(b&0x7F) << shift
11150 if b < 0x80 {
11151 break
11152 }
11153 }
11154 if msglen < 0 {
11155 return ErrInvalidLengthTheproto3
11156 }
11157 postIndex := iNdEx + msglen
11158 if postIndex < 0 {
11159 return ErrInvalidLengthTheproto3
11160 }
11161 if postIndex > l {
11162 return io.ErrUnexpectedEOF
11163 }
11164 if m.ByteMapping == nil {
11165 m.ByteMapping = make(map[bool][]byte)
11166 }
11167 var mapkey bool
11168 mapvalue := []byte{}
11169 for iNdEx < postIndex {
11170 entryPreIndex := iNdEx
11171 var wire uint64
11172 for shift := uint(0); ; shift += 7 {
11173 if shift >= 64 {
11174 return ErrIntOverflowTheproto3
11175 }
11176 if iNdEx >= l {
11177 return io.ErrUnexpectedEOF
11178 }
11179 b := dAtA[iNdEx]
11180 iNdEx++
11181 wire |= uint64(b&0x7F) << shift
11182 if b < 0x80 {
11183 break
11184 }
11185 }
11186 fieldNum := int32(wire >> 3)
11187 if fieldNum == 1 {
11188 var mapkeytemp int
11189 for shift := uint(0); ; shift += 7 {
11190 if shift >= 64 {
11191 return ErrIntOverflowTheproto3
11192 }
11193 if iNdEx >= l {
11194 return io.ErrUnexpectedEOF
11195 }
11196 b := dAtA[iNdEx]
11197 iNdEx++
11198 mapkeytemp |= int(b&0x7F) << shift
11199 if b < 0x80 {
11200 break
11201 }
11202 }
11203 mapkey = bool(mapkeytemp != 0)
11204 } else if fieldNum == 2 {
11205 var mapbyteLen uint64
11206 for shift := uint(0); ; shift += 7 {
11207 if shift >= 64 {
11208 return ErrIntOverflowTheproto3
11209 }
11210 if iNdEx >= l {
11211 return io.ErrUnexpectedEOF
11212 }
11213 b := dAtA[iNdEx]
11214 iNdEx++
11215 mapbyteLen |= uint64(b&0x7F) << shift
11216 if b < 0x80 {
11217 break
11218 }
11219 }
11220 intMapbyteLen := int(mapbyteLen)
11221 if intMapbyteLen < 0 {
11222 return ErrInvalidLengthTheproto3
11223 }
11224 postbytesIndex := iNdEx + intMapbyteLen
11225 if postbytesIndex < 0 {
11226 return ErrInvalidLengthTheproto3
11227 }
11228 if postbytesIndex > l {
11229 return io.ErrUnexpectedEOF
11230 }
11231 mapvalue = make([]byte, mapbyteLen)
11232 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
11233 iNdEx = postbytesIndex
11234 } else {
11235 iNdEx = entryPreIndex
11236 skippy, err := skipTheproto3(dAtA[iNdEx:])
11237 if err != nil {
11238 return err
11239 }
11240 if (skippy < 0) || (iNdEx+skippy) < 0 {
11241 return ErrInvalidLengthTheproto3
11242 }
11243 if (iNdEx + skippy) > postIndex {
11244 return io.ErrUnexpectedEOF
11245 }
11246 iNdEx += skippy
11247 }
11248 }
11249 m.ByteMapping[mapkey] = mapvalue
11250 iNdEx = postIndex
11251 default:
11252 iNdEx = preIndex
11253 skippy, err := skipTheproto3(dAtA[iNdEx:])
11254 if err != nil {
11255 return err
11256 }
11257 if (skippy < 0) || (iNdEx+skippy) < 0 {
11258 return ErrInvalidLengthTheproto3
11259 }
11260 if (iNdEx + skippy) > l {
11261 return io.ErrUnexpectedEOF
11262 }
11263 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
11264 iNdEx += skippy
11265 }
11266 }
11267
11268 if iNdEx > l {
11269 return io.ErrUnexpectedEOF
11270 }
11271 return nil
11272 }
11273 func (m *FloatingPoint) Unmarshal(dAtA []byte) error {
11274 l := len(dAtA)
11275 iNdEx := 0
11276 for iNdEx < l {
11277 preIndex := iNdEx
11278 var wire uint64
11279 for shift := uint(0); ; shift += 7 {
11280 if shift >= 64 {
11281 return ErrIntOverflowTheproto3
11282 }
11283 if iNdEx >= l {
11284 return io.ErrUnexpectedEOF
11285 }
11286 b := dAtA[iNdEx]
11287 iNdEx++
11288 wire |= uint64(b&0x7F) << shift
11289 if b < 0x80 {
11290 break
11291 }
11292 }
11293 fieldNum := int32(wire >> 3)
11294 wireType := int(wire & 0x7)
11295 if wireType == 4 {
11296 return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group")
11297 }
11298 if fieldNum <= 0 {
11299 return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire)
11300 }
11301 switch fieldNum {
11302 case 1:
11303 if wireType != 1 {
11304 return fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
11305 }
11306 var v uint64
11307 if (iNdEx + 8) > l {
11308 return io.ErrUnexpectedEOF
11309 }
11310 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
11311 iNdEx += 8
11312 m.F = float64(math.Float64frombits(v))
11313 default:
11314 iNdEx = preIndex
11315 skippy, err := skipTheproto3(dAtA[iNdEx:])
11316 if err != nil {
11317 return err
11318 }
11319 if (skippy < 0) || (iNdEx+skippy) < 0 {
11320 return ErrInvalidLengthTheproto3
11321 }
11322 if (iNdEx + skippy) > l {
11323 return io.ErrUnexpectedEOF
11324 }
11325 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
11326 iNdEx += skippy
11327 }
11328 }
11329
11330 if iNdEx > l {
11331 return io.ErrUnexpectedEOF
11332 }
11333 return nil
11334 }
11335 func (m *Uint128Pair) Unmarshal(dAtA []byte) error {
11336 l := len(dAtA)
11337 iNdEx := 0
11338 for iNdEx < l {
11339 preIndex := iNdEx
11340 var wire uint64
11341 for shift := uint(0); ; shift += 7 {
11342 if shift >= 64 {
11343 return ErrIntOverflowTheproto3
11344 }
11345 if iNdEx >= l {
11346 return io.ErrUnexpectedEOF
11347 }
11348 b := dAtA[iNdEx]
11349 iNdEx++
11350 wire |= uint64(b&0x7F) << shift
11351 if b < 0x80 {
11352 break
11353 }
11354 }
11355 fieldNum := int32(wire >> 3)
11356 wireType := int(wire & 0x7)
11357 if wireType == 4 {
11358 return fmt.Errorf("proto: Uint128Pair: wiretype end group for non-group")
11359 }
11360 if fieldNum <= 0 {
11361 return fmt.Errorf("proto: Uint128Pair: illegal tag %d (wire type %d)", fieldNum, wire)
11362 }
11363 switch fieldNum {
11364 case 1:
11365 if wireType != 2 {
11366 return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
11367 }
11368 var byteLen int
11369 for shift := uint(0); ; shift += 7 {
11370 if shift >= 64 {
11371 return ErrIntOverflowTheproto3
11372 }
11373 if iNdEx >= l {
11374 return io.ErrUnexpectedEOF
11375 }
11376 b := dAtA[iNdEx]
11377 iNdEx++
11378 byteLen |= int(b&0x7F) << shift
11379 if b < 0x80 {
11380 break
11381 }
11382 }
11383 if byteLen < 0 {
11384 return ErrInvalidLengthTheproto3
11385 }
11386 postIndex := iNdEx + byteLen
11387 if postIndex < 0 {
11388 return ErrInvalidLengthTheproto3
11389 }
11390 if postIndex > l {
11391 return io.ErrUnexpectedEOF
11392 }
11393 if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11394 return err
11395 }
11396 iNdEx = postIndex
11397 case 2:
11398 if wireType != 2 {
11399 return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
11400 }
11401 var byteLen int
11402 for shift := uint(0); ; shift += 7 {
11403 if shift >= 64 {
11404 return ErrIntOverflowTheproto3
11405 }
11406 if iNdEx >= l {
11407 return io.ErrUnexpectedEOF
11408 }
11409 b := dAtA[iNdEx]
11410 iNdEx++
11411 byteLen |= int(b&0x7F) << shift
11412 if b < 0x80 {
11413 break
11414 }
11415 }
11416 if byteLen < 0 {
11417 return ErrInvalidLengthTheproto3
11418 }
11419 postIndex := iNdEx + byteLen
11420 if postIndex < 0 {
11421 return ErrInvalidLengthTheproto3
11422 }
11423 if postIndex > l {
11424 return io.ErrUnexpectedEOF
11425 }
11426 var v github_com_gogo_protobuf_test_custom.Uint128
11427 m.Right = &v
11428 if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11429 return err
11430 }
11431 iNdEx = postIndex
11432 default:
11433 iNdEx = preIndex
11434 skippy, err := skipTheproto3(dAtA[iNdEx:])
11435 if err != nil {
11436 return err
11437 }
11438 if (skippy < 0) || (iNdEx+skippy) < 0 {
11439 return ErrInvalidLengthTheproto3
11440 }
11441 if (iNdEx + skippy) > l {
11442 return io.ErrUnexpectedEOF
11443 }
11444 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
11445 iNdEx += skippy
11446 }
11447 }
11448
11449 if iNdEx > l {
11450 return io.ErrUnexpectedEOF
11451 }
11452 return nil
11453 }
11454 func (m *ContainsNestedMap) Unmarshal(dAtA []byte) error {
11455 l := len(dAtA)
11456 iNdEx := 0
11457 for iNdEx < l {
11458 preIndex := iNdEx
11459 var wire uint64
11460 for shift := uint(0); ; shift += 7 {
11461 if shift >= 64 {
11462 return ErrIntOverflowTheproto3
11463 }
11464 if iNdEx >= l {
11465 return io.ErrUnexpectedEOF
11466 }
11467 b := dAtA[iNdEx]
11468 iNdEx++
11469 wire |= uint64(b&0x7F) << shift
11470 if b < 0x80 {
11471 break
11472 }
11473 }
11474 fieldNum := int32(wire >> 3)
11475 wireType := int(wire & 0x7)
11476 if wireType == 4 {
11477 return fmt.Errorf("proto: ContainsNestedMap: wiretype end group for non-group")
11478 }
11479 if fieldNum <= 0 {
11480 return fmt.Errorf("proto: ContainsNestedMap: illegal tag %d (wire type %d)", fieldNum, wire)
11481 }
11482 switch fieldNum {
11483 default:
11484 iNdEx = preIndex
11485 skippy, err := skipTheproto3(dAtA[iNdEx:])
11486 if err != nil {
11487 return err
11488 }
11489 if (skippy < 0) || (iNdEx+skippy) < 0 {
11490 return ErrInvalidLengthTheproto3
11491 }
11492 if (iNdEx + skippy) > l {
11493 return io.ErrUnexpectedEOF
11494 }
11495 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
11496 iNdEx += skippy
11497 }
11498 }
11499
11500 if iNdEx > l {
11501 return io.ErrUnexpectedEOF
11502 }
11503 return nil
11504 }
11505 func (m *ContainsNestedMap_NestedMap) Unmarshal(dAtA []byte) error {
11506 l := len(dAtA)
11507 iNdEx := 0
11508 for iNdEx < l {
11509 preIndex := iNdEx
11510 var wire uint64
11511 for shift := uint(0); ; shift += 7 {
11512 if shift >= 64 {
11513 return ErrIntOverflowTheproto3
11514 }
11515 if iNdEx >= l {
11516 return io.ErrUnexpectedEOF
11517 }
11518 b := dAtA[iNdEx]
11519 iNdEx++
11520 wire |= uint64(b&0x7F) << shift
11521 if b < 0x80 {
11522 break
11523 }
11524 }
11525 fieldNum := int32(wire >> 3)
11526 wireType := int(wire & 0x7)
11527 if wireType == 4 {
11528 return fmt.Errorf("proto: NestedMap: wiretype end group for non-group")
11529 }
11530 if fieldNum <= 0 {
11531 return fmt.Errorf("proto: NestedMap: illegal tag %d (wire type %d)", fieldNum, wire)
11532 }
11533 switch fieldNum {
11534 case 1:
11535 if wireType != 2 {
11536 return fmt.Errorf("proto: wrong wireType = %d for field NestedMapField", wireType)
11537 }
11538 var msglen int
11539 for shift := uint(0); ; shift += 7 {
11540 if shift >= 64 {
11541 return ErrIntOverflowTheproto3
11542 }
11543 if iNdEx >= l {
11544 return io.ErrUnexpectedEOF
11545 }
11546 b := dAtA[iNdEx]
11547 iNdEx++
11548 msglen |= int(b&0x7F) << shift
11549 if b < 0x80 {
11550 break
11551 }
11552 }
11553 if msglen < 0 {
11554 return ErrInvalidLengthTheproto3
11555 }
11556 postIndex := iNdEx + msglen
11557 if postIndex < 0 {
11558 return ErrInvalidLengthTheproto3
11559 }
11560 if postIndex > l {
11561 return io.ErrUnexpectedEOF
11562 }
11563 if m.NestedMapField == nil {
11564 m.NestedMapField = make(map[string]float64)
11565 }
11566 var mapkey string
11567 var mapvalue float64
11568 for iNdEx < postIndex {
11569 entryPreIndex := iNdEx
11570 var wire uint64
11571 for shift := uint(0); ; shift += 7 {
11572 if shift >= 64 {
11573 return ErrIntOverflowTheproto3
11574 }
11575 if iNdEx >= l {
11576 return io.ErrUnexpectedEOF
11577 }
11578 b := dAtA[iNdEx]
11579 iNdEx++
11580 wire |= uint64(b&0x7F) << shift
11581 if b < 0x80 {
11582 break
11583 }
11584 }
11585 fieldNum := int32(wire >> 3)
11586 if fieldNum == 1 {
11587 var stringLenmapkey uint64
11588 for shift := uint(0); ; shift += 7 {
11589 if shift >= 64 {
11590 return ErrIntOverflowTheproto3
11591 }
11592 if iNdEx >= l {
11593 return io.ErrUnexpectedEOF
11594 }
11595 b := dAtA[iNdEx]
11596 iNdEx++
11597 stringLenmapkey |= uint64(b&0x7F) << shift
11598 if b < 0x80 {
11599 break
11600 }
11601 }
11602 intStringLenmapkey := int(stringLenmapkey)
11603 if intStringLenmapkey < 0 {
11604 return ErrInvalidLengthTheproto3
11605 }
11606 postStringIndexmapkey := iNdEx + intStringLenmapkey
11607 if postStringIndexmapkey < 0 {
11608 return ErrInvalidLengthTheproto3
11609 }
11610 if postStringIndexmapkey > l {
11611 return io.ErrUnexpectedEOF
11612 }
11613 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
11614 iNdEx = postStringIndexmapkey
11615 } else if fieldNum == 2 {
11616 var mapvaluetemp uint64
11617 if (iNdEx + 8) > l {
11618 return io.ErrUnexpectedEOF
11619 }
11620 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
11621 iNdEx += 8
11622 mapvalue = math.Float64frombits(mapvaluetemp)
11623 } else {
11624 iNdEx = entryPreIndex
11625 skippy, err := skipTheproto3(dAtA[iNdEx:])
11626 if err != nil {
11627 return err
11628 }
11629 if (skippy < 0) || (iNdEx+skippy) < 0 {
11630 return ErrInvalidLengthTheproto3
11631 }
11632 if (iNdEx + skippy) > postIndex {
11633 return io.ErrUnexpectedEOF
11634 }
11635 iNdEx += skippy
11636 }
11637 }
11638 m.NestedMapField[mapkey] = mapvalue
11639 iNdEx = postIndex
11640 default:
11641 iNdEx = preIndex
11642 skippy, err := skipTheproto3(dAtA[iNdEx:])
11643 if err != nil {
11644 return err
11645 }
11646 if (skippy < 0) || (iNdEx+skippy) < 0 {
11647 return ErrInvalidLengthTheproto3
11648 }
11649 if (iNdEx + skippy) > l {
11650 return io.ErrUnexpectedEOF
11651 }
11652 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
11653 iNdEx += skippy
11654 }
11655 }
11656
11657 if iNdEx > l {
11658 return io.ErrUnexpectedEOF
11659 }
11660 return nil
11661 }
11662 func (m *NotPacked) Unmarshal(dAtA []byte) error {
11663 l := len(dAtA)
11664 iNdEx := 0
11665 for iNdEx < l {
11666 preIndex := iNdEx
11667 var wire uint64
11668 for shift := uint(0); ; shift += 7 {
11669 if shift >= 64 {
11670 return ErrIntOverflowTheproto3
11671 }
11672 if iNdEx >= l {
11673 return io.ErrUnexpectedEOF
11674 }
11675 b := dAtA[iNdEx]
11676 iNdEx++
11677 wire |= uint64(b&0x7F) << shift
11678 if b < 0x80 {
11679 break
11680 }
11681 }
11682 fieldNum := int32(wire >> 3)
11683 wireType := int(wire & 0x7)
11684 if wireType == 4 {
11685 return fmt.Errorf("proto: NotPacked: wiretype end group for non-group")
11686 }
11687 if fieldNum <= 0 {
11688 return fmt.Errorf("proto: NotPacked: illegal tag %d (wire type %d)", fieldNum, wire)
11689 }
11690 switch fieldNum {
11691 case 5:
11692 if wireType == 0 {
11693 var v uint64
11694 for shift := uint(0); ; shift += 7 {
11695 if shift >= 64 {
11696 return ErrIntOverflowTheproto3
11697 }
11698 if iNdEx >= l {
11699 return io.ErrUnexpectedEOF
11700 }
11701 b := dAtA[iNdEx]
11702 iNdEx++
11703 v |= uint64(b&0x7F) << shift
11704 if b < 0x80 {
11705 break
11706 }
11707 }
11708 m.Key = append(m.Key, v)
11709 } else if wireType == 2 {
11710 var packedLen int
11711 for shift := uint(0); ; shift += 7 {
11712 if shift >= 64 {
11713 return ErrIntOverflowTheproto3
11714 }
11715 if iNdEx >= l {
11716 return io.ErrUnexpectedEOF
11717 }
11718 b := dAtA[iNdEx]
11719 iNdEx++
11720 packedLen |= int(b&0x7F) << shift
11721 if b < 0x80 {
11722 break
11723 }
11724 }
11725 if packedLen < 0 {
11726 return ErrInvalidLengthTheproto3
11727 }
11728 postIndex := iNdEx + packedLen
11729 if postIndex < 0 {
11730 return ErrInvalidLengthTheproto3
11731 }
11732 if postIndex > l {
11733 return io.ErrUnexpectedEOF
11734 }
11735 var elementCount int
11736 var count int
11737 for _, integer := range dAtA[iNdEx:postIndex] {
11738 if integer < 128 {
11739 count++
11740 }
11741 }
11742 elementCount = count
11743 if elementCount != 0 && len(m.Key) == 0 {
11744 m.Key = make([]uint64, 0, elementCount)
11745 }
11746 for iNdEx < postIndex {
11747 var v uint64
11748 for shift := uint(0); ; shift += 7 {
11749 if shift >= 64 {
11750 return ErrIntOverflowTheproto3
11751 }
11752 if iNdEx >= l {
11753 return io.ErrUnexpectedEOF
11754 }
11755 b := dAtA[iNdEx]
11756 iNdEx++
11757 v |= uint64(b&0x7F) << shift
11758 if b < 0x80 {
11759 break
11760 }
11761 }
11762 m.Key = append(m.Key, v)
11763 }
11764 } else {
11765 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
11766 }
11767 default:
11768 iNdEx = preIndex
11769 skippy, err := skipTheproto3(dAtA[iNdEx:])
11770 if err != nil {
11771 return err
11772 }
11773 if (skippy < 0) || (iNdEx+skippy) < 0 {
11774 return ErrInvalidLengthTheproto3
11775 }
11776 if (iNdEx + skippy) > l {
11777 return io.ErrUnexpectedEOF
11778 }
11779 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
11780 iNdEx += skippy
11781 }
11782 }
11783
11784 if iNdEx > l {
11785 return io.ErrUnexpectedEOF
11786 }
11787 return nil
11788 }
11789 func skipTheproto3(dAtA []byte) (n int, err error) {
11790 l := len(dAtA)
11791 iNdEx := 0
11792 depth := 0
11793 for iNdEx < l {
11794 var wire uint64
11795 for shift := uint(0); ; shift += 7 {
11796 if shift >= 64 {
11797 return 0, ErrIntOverflowTheproto3
11798 }
11799 if iNdEx >= l {
11800 return 0, io.ErrUnexpectedEOF
11801 }
11802 b := dAtA[iNdEx]
11803 iNdEx++
11804 wire |= (uint64(b) & 0x7F) << shift
11805 if b < 0x80 {
11806 break
11807 }
11808 }
11809 wireType := int(wire & 0x7)
11810 switch wireType {
11811 case 0:
11812 for shift := uint(0); ; shift += 7 {
11813 if shift >= 64 {
11814 return 0, ErrIntOverflowTheproto3
11815 }
11816 if iNdEx >= l {
11817 return 0, io.ErrUnexpectedEOF
11818 }
11819 iNdEx++
11820 if dAtA[iNdEx-1] < 0x80 {
11821 break
11822 }
11823 }
11824 case 1:
11825 iNdEx += 8
11826 case 2:
11827 var length int
11828 for shift := uint(0); ; shift += 7 {
11829 if shift >= 64 {
11830 return 0, ErrIntOverflowTheproto3
11831 }
11832 if iNdEx >= l {
11833 return 0, io.ErrUnexpectedEOF
11834 }
11835 b := dAtA[iNdEx]
11836 iNdEx++
11837 length |= (int(b) & 0x7F) << shift
11838 if b < 0x80 {
11839 break
11840 }
11841 }
11842 if length < 0 {
11843 return 0, ErrInvalidLengthTheproto3
11844 }
11845 iNdEx += length
11846 case 3:
11847 depth++
11848 case 4:
11849 if depth == 0 {
11850 return 0, ErrUnexpectedEndOfGroupTheproto3
11851 }
11852 depth--
11853 case 5:
11854 iNdEx += 4
11855 default:
11856 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
11857 }
11858 if iNdEx < 0 {
11859 return 0, ErrInvalidLengthTheproto3
11860 }
11861 if depth == 0 {
11862 return iNdEx, nil
11863 }
11864 }
11865 return 0, io.ErrUnexpectedEOF
11866 }
11867
11868 var (
11869 ErrInvalidLengthTheproto3 = fmt.Errorf("proto: negative length found during unmarshaling")
11870 ErrIntOverflowTheproto3 = fmt.Errorf("proto: integer overflow")
11871 ErrUnexpectedEndOfGroupTheproto3 = fmt.Errorf("proto: unexpected end of group")
11872 )
11873
View as plain text