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_e24bba79c1e35a1f, []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_e24bba79c1e35a1f, []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_e24bba79c1e35a1f, []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 return xxx_messageInfo_Message.Marshal(b, m, deterministic)
117 }
118 func (m *Message) XXX_Merge(src proto.Message) {
119 xxx_messageInfo_Message.Merge(m, src)
120 }
121 func (m *Message) XXX_Size() int {
122 return xxx_messageInfo_Message.Size(m)
123 }
124 func (m *Message) XXX_DiscardUnknown() {
125 xxx_messageInfo_Message.DiscardUnknown(m)
126 }
127
128 var xxx_messageInfo_Message proto.InternalMessageInfo
129
130 type Nested struct {
131 Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"`
132 XXX_NoUnkeyedLiteral struct{} `json:"-"`
133 XXX_unrecognized []byte `json:"-"`
134 XXX_sizecache int32 `json:"-"`
135 }
136
137 func (m *Nested) Reset() { *m = Nested{} }
138 func (*Nested) ProtoMessage() {}
139 func (*Nested) Descriptor() ([]byte, []int) {
140 return fileDescriptor_e24bba79c1e35a1f, []int{1}
141 }
142 func (m *Nested) XXX_Unmarshal(b []byte) error {
143 return m.Unmarshal(b)
144 }
145 func (m *Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
146 return xxx_messageInfo_Nested.Marshal(b, m, deterministic)
147 }
148 func (m *Nested) XXX_Merge(src proto.Message) {
149 xxx_messageInfo_Nested.Merge(m, src)
150 }
151 func (m *Nested) XXX_Size() int {
152 return xxx_messageInfo_Nested.Size(m)
153 }
154 func (m *Nested) XXX_DiscardUnknown() {
155 xxx_messageInfo_Nested.DiscardUnknown(m)
156 }
157
158 var xxx_messageInfo_Nested proto.InternalMessageInfo
159
160 type AllMaps struct {
161 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"`
162 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"`
163 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"`
164 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"`
165 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"`
166 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"`
167 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"`
168 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"`
169 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"`
170 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"`
171 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"`
172 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"`
173 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"`
174 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"`
175 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"`
176 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"`
177 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"`
178 XXX_NoUnkeyedLiteral struct{} `json:"-"`
179 XXX_unrecognized []byte `json:"-"`
180 XXX_sizecache int32 `json:"-"`
181 }
182
183 func (m *AllMaps) Reset() { *m = AllMaps{} }
184 func (*AllMaps) ProtoMessage() {}
185 func (*AllMaps) Descriptor() ([]byte, []int) {
186 return fileDescriptor_e24bba79c1e35a1f, []int{2}
187 }
188 func (m *AllMaps) XXX_Unmarshal(b []byte) error {
189 return m.Unmarshal(b)
190 }
191 func (m *AllMaps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
192 return xxx_messageInfo_AllMaps.Marshal(b, m, deterministic)
193 }
194 func (m *AllMaps) XXX_Merge(src proto.Message) {
195 xxx_messageInfo_AllMaps.Merge(m, src)
196 }
197 func (m *AllMaps) XXX_Size() int {
198 return xxx_messageInfo_AllMaps.Size(m)
199 }
200 func (m *AllMaps) XXX_DiscardUnknown() {
201 xxx_messageInfo_AllMaps.DiscardUnknown(m)
202 }
203
204 var xxx_messageInfo_AllMaps proto.InternalMessageInfo
205
206 type AllMapsOrdered struct {
207 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"`
208 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"`
209 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"`
210 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"`
211 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"`
212 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"`
213 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"`
214 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"`
215 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"`
216 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"`
217 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"`
218 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"`
219 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"`
220 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"`
221 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"`
222 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"`
223 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"`
224 XXX_NoUnkeyedLiteral struct{} `json:"-"`
225 XXX_unrecognized []byte `json:"-"`
226 XXX_sizecache int32 `json:"-"`
227 }
228
229 func (m *AllMapsOrdered) Reset() { *m = AllMapsOrdered{} }
230 func (*AllMapsOrdered) ProtoMessage() {}
231 func (*AllMapsOrdered) Descriptor() ([]byte, []int) {
232 return fileDescriptor_e24bba79c1e35a1f, []int{3}
233 }
234 func (m *AllMapsOrdered) XXX_Unmarshal(b []byte) error {
235 return m.Unmarshal(b)
236 }
237 func (m *AllMapsOrdered) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
238 return xxx_messageInfo_AllMapsOrdered.Marshal(b, m, deterministic)
239 }
240 func (m *AllMapsOrdered) XXX_Merge(src proto.Message) {
241 xxx_messageInfo_AllMapsOrdered.Merge(m, src)
242 }
243 func (m *AllMapsOrdered) XXX_Size() int {
244 return xxx_messageInfo_AllMapsOrdered.Size(m)
245 }
246 func (m *AllMapsOrdered) XXX_DiscardUnknown() {
247 xxx_messageInfo_AllMapsOrdered.DiscardUnknown(m)
248 }
249
250 var xxx_messageInfo_AllMapsOrdered proto.InternalMessageInfo
251
252 type MessageWithMap struct {
253 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"`
254 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"`
255 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"`
256 XXX_NoUnkeyedLiteral struct{} `json:"-"`
257 XXX_unrecognized []byte `json:"-"`
258 XXX_sizecache int32 `json:"-"`
259 }
260
261 func (m *MessageWithMap) Reset() { *m = MessageWithMap{} }
262 func (*MessageWithMap) ProtoMessage() {}
263 func (*MessageWithMap) Descriptor() ([]byte, []int) {
264 return fileDescriptor_e24bba79c1e35a1f, []int{4}
265 }
266 func (m *MessageWithMap) XXX_Unmarshal(b []byte) error {
267 return m.Unmarshal(b)
268 }
269 func (m *MessageWithMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
270 return xxx_messageInfo_MessageWithMap.Marshal(b, m, deterministic)
271 }
272 func (m *MessageWithMap) XXX_Merge(src proto.Message) {
273 xxx_messageInfo_MessageWithMap.Merge(m, src)
274 }
275 func (m *MessageWithMap) XXX_Size() int {
276 return xxx_messageInfo_MessageWithMap.Size(m)
277 }
278 func (m *MessageWithMap) XXX_DiscardUnknown() {
279 xxx_messageInfo_MessageWithMap.DiscardUnknown(m)
280 }
281
282 var xxx_messageInfo_MessageWithMap proto.InternalMessageInfo
283
284 type FloatingPoint struct {
285 F float64 `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"`
286 XXX_NoUnkeyedLiteral struct{} `json:"-"`
287 XXX_unrecognized []byte `json:"-"`
288 XXX_sizecache int32 `json:"-"`
289 }
290
291 func (m *FloatingPoint) Reset() { *m = FloatingPoint{} }
292 func (*FloatingPoint) ProtoMessage() {}
293 func (*FloatingPoint) Descriptor() ([]byte, []int) {
294 return fileDescriptor_e24bba79c1e35a1f, []int{5}
295 }
296 func (m *FloatingPoint) XXX_Unmarshal(b []byte) error {
297 return m.Unmarshal(b)
298 }
299 func (m *FloatingPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
300 return xxx_messageInfo_FloatingPoint.Marshal(b, m, deterministic)
301 }
302 func (m *FloatingPoint) XXX_Merge(src proto.Message) {
303 xxx_messageInfo_FloatingPoint.Merge(m, src)
304 }
305 func (m *FloatingPoint) XXX_Size() int {
306 return xxx_messageInfo_FloatingPoint.Size(m)
307 }
308 func (m *FloatingPoint) XXX_DiscardUnknown() {
309 xxx_messageInfo_FloatingPoint.DiscardUnknown(m)
310 }
311
312 var xxx_messageInfo_FloatingPoint proto.InternalMessageInfo
313
314 type Uint128Pair struct {
315 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"`
316 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"`
317 XXX_NoUnkeyedLiteral struct{} `json:"-"`
318 XXX_unrecognized []byte `json:"-"`
319 XXX_sizecache int32 `json:"-"`
320 }
321
322 func (m *Uint128Pair) Reset() { *m = Uint128Pair{} }
323 func (*Uint128Pair) ProtoMessage() {}
324 func (*Uint128Pair) Descriptor() ([]byte, []int) {
325 return fileDescriptor_e24bba79c1e35a1f, []int{6}
326 }
327 func (m *Uint128Pair) XXX_Unmarshal(b []byte) error {
328 return m.Unmarshal(b)
329 }
330 func (m *Uint128Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
331 return xxx_messageInfo_Uint128Pair.Marshal(b, m, deterministic)
332 }
333 func (m *Uint128Pair) XXX_Merge(src proto.Message) {
334 xxx_messageInfo_Uint128Pair.Merge(m, src)
335 }
336 func (m *Uint128Pair) XXX_Size() int {
337 return xxx_messageInfo_Uint128Pair.Size(m)
338 }
339 func (m *Uint128Pair) XXX_DiscardUnknown() {
340 xxx_messageInfo_Uint128Pair.DiscardUnknown(m)
341 }
342
343 var xxx_messageInfo_Uint128Pair proto.InternalMessageInfo
344
345 type ContainsNestedMap struct {
346 XXX_NoUnkeyedLiteral struct{} `json:"-"`
347 XXX_unrecognized []byte `json:"-"`
348 XXX_sizecache int32 `json:"-"`
349 }
350
351 func (m *ContainsNestedMap) Reset() { *m = ContainsNestedMap{} }
352 func (*ContainsNestedMap) ProtoMessage() {}
353 func (*ContainsNestedMap) Descriptor() ([]byte, []int) {
354 return fileDescriptor_e24bba79c1e35a1f, []int{7}
355 }
356 func (m *ContainsNestedMap) XXX_Unmarshal(b []byte) error {
357 return m.Unmarshal(b)
358 }
359 func (m *ContainsNestedMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
360 return xxx_messageInfo_ContainsNestedMap.Marshal(b, m, deterministic)
361 }
362 func (m *ContainsNestedMap) XXX_Merge(src proto.Message) {
363 xxx_messageInfo_ContainsNestedMap.Merge(m, src)
364 }
365 func (m *ContainsNestedMap) XXX_Size() int {
366 return xxx_messageInfo_ContainsNestedMap.Size(m)
367 }
368 func (m *ContainsNestedMap) XXX_DiscardUnknown() {
369 xxx_messageInfo_ContainsNestedMap.DiscardUnknown(m)
370 }
371
372 var xxx_messageInfo_ContainsNestedMap proto.InternalMessageInfo
373
374 type ContainsNestedMap_NestedMap struct {
375 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"`
376 XXX_NoUnkeyedLiteral struct{} `json:"-"`
377 XXX_unrecognized []byte `json:"-"`
378 XXX_sizecache int32 `json:"-"`
379 }
380
381 func (m *ContainsNestedMap_NestedMap) Reset() { *m = ContainsNestedMap_NestedMap{} }
382 func (*ContainsNestedMap_NestedMap) ProtoMessage() {}
383 func (*ContainsNestedMap_NestedMap) Descriptor() ([]byte, []int) {
384 return fileDescriptor_e24bba79c1e35a1f, []int{7, 0}
385 }
386 func (m *ContainsNestedMap_NestedMap) XXX_Unmarshal(b []byte) error {
387 return m.Unmarshal(b)
388 }
389 func (m *ContainsNestedMap_NestedMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
390 return xxx_messageInfo_ContainsNestedMap_NestedMap.Marshal(b, m, deterministic)
391 }
392 func (m *ContainsNestedMap_NestedMap) XXX_Merge(src proto.Message) {
393 xxx_messageInfo_ContainsNestedMap_NestedMap.Merge(m, src)
394 }
395 func (m *ContainsNestedMap_NestedMap) XXX_Size() int {
396 return xxx_messageInfo_ContainsNestedMap_NestedMap.Size(m)
397 }
398 func (m *ContainsNestedMap_NestedMap) XXX_DiscardUnknown() {
399 xxx_messageInfo_ContainsNestedMap_NestedMap.DiscardUnknown(m)
400 }
401
402 var xxx_messageInfo_ContainsNestedMap_NestedMap proto.InternalMessageInfo
403
404 type NotPacked struct {
405 Key []uint64 `protobuf:"varint,5,rep,name=key,proto3" json:"key,omitempty"`
406 XXX_NoUnkeyedLiteral struct{} `json:"-"`
407 XXX_unrecognized []byte `json:"-"`
408 XXX_sizecache int32 `json:"-"`
409 }
410
411 func (m *NotPacked) Reset() { *m = NotPacked{} }
412 func (*NotPacked) ProtoMessage() {}
413 func (*NotPacked) Descriptor() ([]byte, []int) {
414 return fileDescriptor_e24bba79c1e35a1f, []int{8}
415 }
416 func (m *NotPacked) XXX_Unmarshal(b []byte) error {
417 return m.Unmarshal(b)
418 }
419 func (m *NotPacked) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
420 return xxx_messageInfo_NotPacked.Marshal(b, m, deterministic)
421 }
422 func (m *NotPacked) XXX_Merge(src proto.Message) {
423 xxx_messageInfo_NotPacked.Merge(m, src)
424 }
425 func (m *NotPacked) XXX_Size() int {
426 return xxx_messageInfo_NotPacked.Size(m)
427 }
428 func (m *NotPacked) XXX_DiscardUnknown() {
429 xxx_messageInfo_NotPacked.DiscardUnknown(m)
430 }
431
432 var xxx_messageInfo_NotPacked proto.InternalMessageInfo
433
434 func init() {
435 proto.RegisterEnum("theproto3.MapEnum", MapEnum_name, MapEnum_value)
436 proto.RegisterEnum("theproto3.Message_Humour", Message_Humour_name, Message_Humour_value)
437 proto.RegisterType((*Message)(nil), "theproto3.Message")
438 proto.RegisterMapType((map[int64]*both.NinOptEnum)(nil), "theproto3.Message.Proto2ValueEntry")
439 proto.RegisterMapType((map[int64]*Nested)(nil), "theproto3.Message.TerrainEntry")
440 proto.RegisterType((*Nested)(nil), "theproto3.Nested")
441 proto.RegisterType((*AllMaps)(nil), "theproto3.AllMaps")
442 proto.RegisterMapType((map[bool]bool)(nil), "theproto3.AllMaps.BoolMapEntry")
443 proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMaps.Fixed32MapEntry")
444 proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMaps.Fixed64MapEntry")
445 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMaps.Int32MapEntry")
446 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMaps.Int64MapEntry")
447 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMaps.Sfixed32MapEntry")
448 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMaps.Sfixed64MapEntry")
449 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMaps.Sint32MapEntry")
450 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMaps.Sint64MapEntry")
451 proto.RegisterMapType((map[string]string)(nil), "theproto3.AllMaps.StringMapEntry")
452 proto.RegisterMapType((map[string][]byte)(nil), "theproto3.AllMaps.StringToBytesMapEntry")
453 proto.RegisterMapType((map[string]float64)(nil), "theproto3.AllMaps.StringToDoubleMapEntry")
454 proto.RegisterMapType((map[string]MapEnum)(nil), "theproto3.AllMaps.StringToEnumMapEntry")
455 proto.RegisterMapType((map[string]float32)(nil), "theproto3.AllMaps.StringToFloatMapEntry")
456 proto.RegisterMapType((map[string]*FloatingPoint)(nil), "theproto3.AllMaps.StringToMsgMapEntry")
457 proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMaps.Uint32MapEntry")
458 proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMaps.Uint64MapEntry")
459 proto.RegisterType((*AllMapsOrdered)(nil), "theproto3.AllMapsOrdered")
460 proto.RegisterMapType((map[bool]bool)(nil), "theproto3.AllMapsOrdered.BoolMapEntry")
461 proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMapsOrdered.Fixed32MapEntry")
462 proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMapsOrdered.Fixed64MapEntry")
463 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMapsOrdered.Int32MapEntry")
464 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMapsOrdered.Int64MapEntry")
465 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMapsOrdered.Sfixed32MapEntry")
466 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMapsOrdered.Sfixed64MapEntry")
467 proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMapsOrdered.Sint32MapEntry")
468 proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMapsOrdered.Sint64MapEntry")
469 proto.RegisterMapType((map[string]string)(nil), "theproto3.AllMapsOrdered.StringMapEntry")
470 proto.RegisterMapType((map[string][]byte)(nil), "theproto3.AllMapsOrdered.StringToBytesMapEntry")
471 proto.RegisterMapType((map[string]float64)(nil), "theproto3.AllMapsOrdered.StringToDoubleMapEntry")
472 proto.RegisterMapType((map[string]MapEnum)(nil), "theproto3.AllMapsOrdered.StringToEnumMapEntry")
473 proto.RegisterMapType((map[string]float32)(nil), "theproto3.AllMapsOrdered.StringToFloatMapEntry")
474 proto.RegisterMapType((map[string]*FloatingPoint)(nil), "theproto3.AllMapsOrdered.StringToMsgMapEntry")
475 proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMapsOrdered.Uint32MapEntry")
476 proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMapsOrdered.Uint64MapEntry")
477 proto.RegisterType((*MessageWithMap)(nil), "theproto3.MessageWithMap")
478 proto.RegisterMapType((map[bool][]byte)(nil), "theproto3.MessageWithMap.ByteMappingEntry")
479 proto.RegisterMapType((map[int64]*FloatingPoint)(nil), "theproto3.MessageWithMap.MsgMappingEntry")
480 proto.RegisterMapType((map[int32]string)(nil), "theproto3.MessageWithMap.NameMappingEntry")
481 proto.RegisterType((*FloatingPoint)(nil), "theproto3.FloatingPoint")
482 proto.RegisterType((*Uint128Pair)(nil), "theproto3.Uint128Pair")
483 proto.RegisterType((*ContainsNestedMap)(nil), "theproto3.ContainsNestedMap")
484 proto.RegisterType((*ContainsNestedMap_NestedMap)(nil), "theproto3.ContainsNestedMap.NestedMap")
485 proto.RegisterMapType((map[string]float64)(nil), "theproto3.ContainsNestedMap.NestedMap.NestedMapFieldEntry")
486 proto.RegisterType((*NotPacked)(nil), "theproto3.NotPacked")
487 }
488
489 func init() {
490 proto.RegisterFile("combos/unmarshaler/theproto3.proto", fileDescriptor_e24bba79c1e35a1f)
491 }
492
493 var fileDescriptor_e24bba79c1e35a1f = []byte{
494
495 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x99, 0xcf, 0x6f, 0xdb, 0x46,
496 0x16, 0xc7, 0x35, 0xfa, 0xad, 0xa7, 0x1f, 0xa6, 0x27, 0xd9, 0x85, 0xd6, 0xc0, 0xd2, 0xb2, 0x02,
497 0x24, 0x4a, 0xb0, 0x91, 0xb3, 0x4e, 0xb2, 0x9b, 0xba, 0x69, 0x53, 0x4b, 0xb1, 0x10, 0x37, 0xb6,
498 0xe2, 0x4a, 0x76, 0xdc, 0x22, 0x40, 0x0d, 0xca, 0xa6, 0x25, 0x22, 0x12, 0x69, 0x90, 0xa3, 0xa0,
499 0xbe, 0xe5, 0xcf, 0xe8, 0xad, 0xe8, 0xad, 0xc7, 0x22, 0x87, 0xa2, 0xc7, 0xf6, 0xe6, 0x63, 0x80,
500 0x5e, 0x8a, 0x1e, 0x82, 0x58, 0xbd, 0xe4, 0x98, 0x63, 0x8e, 0xc5, 0xcc, 0x50, 0xd2, 0x48, 0x1c,
501 0x8a, 0x4d, 0x2f, 0xbd, 0xf8, 0x24, 0xce, 0xf3, 0xfb, 0x7e, 0xe6, 0x71, 0x38, 0xf3, 0xf8, 0x05,
502 0x0d, 0xc5, 0x03, 0xab, 0xd7, 0xb2, 0x9c, 0xe5, 0xbe, 0xd9, 0xd3, 0x6c, 0xa7, 0xa3, 0x75, 0x75,
503 0x7b, 0x99, 0x74, 0xf4, 0x63, 0xdb, 0x22, 0xd6, 0xcd, 0x32, 0xfb, 0xc1, 0xa9, 0x51, 0x60, 0xe1,
504 0x7a, 0xdb, 0x20, 0x9d, 0x7e, 0xab, 0x7c, 0x60, 0xf5, 0x96, 0xdb, 0x56, 0xdb, 0x5a, 0x66, 0xf1,
505 0x56, 0xff, 0x88, 0x8d, 0xd8, 0x80, 0x5d, 0x71, 0xe5, 0xc2, 0xff, 0x7d, 0xd3, 0x89, 0xee, 0x90,
506 0x65, 0x77, 0xee, 0x96, 0x45, 0x3a, 0x74, 0x52, 0x1a, 0xe3, 0xc2, 0xe2, 0xcf, 0x31, 0x48, 0x6c,
507 0xe9, 0x8e, 0xa3, 0xb5, 0x75, 0x8c, 0x21, 0x6a, 0x6a, 0x3d, 0x3d, 0x8f, 0x0a, 0xa8, 0x94, 0x6a,
508 0xb0, 0x6b, 0x7c, 0x1b, 0x92, 0x1d, 0xa3, 0xab, 0xd9, 0x06, 0x39, 0xc9, 0x87, 0x0b, 0xa8, 0x94,
509 0x5b, 0xf9, 0x57, 0x79, 0x5c, 0xb6, 0xab, 0x2c, 0x3f, 0xe8, 0xf7, 0xac, 0xbe, 0xdd, 0x18, 0xa5,
510 0xe2, 0x02, 0x64, 0x3a, 0xba, 0xd1, 0xee, 0x90, 0x7d, 0xc3, 0xdc, 0x3f, 0xe8, 0xe5, 0x23, 0x05,
511 0x54, 0xca, 0x36, 0x80, 0xc7, 0x36, 0xcc, 0x6a, 0x8f, 0x4e, 0x76, 0xa8, 0x11, 0x2d, 0x1f, 0x2d,
512 0xa0, 0x52, 0xa6, 0xc1, 0xae, 0xf1, 0x12, 0x64, 0x6c, 0xdd, 0xe9, 0x77, 0xc9, 0xfe, 0x81, 0xd5,
513 0x37, 0x49, 0x3e, 0x51, 0x40, 0xa5, 0x48, 0x23, 0xcd, 0x63, 0x55, 0x1a, 0xc2, 0x97, 0x20, 0x4b,
514 0xec, 0xbe, 0xbe, 0xef, 0x1c, 0x58, 0xc4, 0xe9, 0x69, 0x66, 0x3e, 0x59, 0x40, 0xa5, 0x64, 0x23,
515 0x43, 0x83, 0x4d, 0x37, 0x86, 0x2f, 0x42, 0xcc, 0x39, 0xb0, 0x6c, 0x3d, 0x9f, 0x2a, 0xa0, 0x52,
516 0xb8, 0xc1, 0x07, 0x58, 0x81, 0xc8, 0x53, 0xfd, 0x24, 0x1f, 0x2b, 0x44, 0x4a, 0xd1, 0x06, 0xbd,
517 0xc4, 0x57, 0x21, 0x6e, 0xea, 0x0e, 0xd1, 0x0f, 0xf3, 0xf1, 0x02, 0x2a, 0xa5, 0x57, 0xe6, 0x85,
518 0x5b, 0xab, 0xb3, 0x3f, 0x34, 0xdc, 0x04, 0xfc, 0x01, 0x24, 0x88, 0x6e, 0xdb, 0x9a, 0x61, 0xe6,
519 0xa1, 0x10, 0x29, 0xa5, 0x57, 0x16, 0x25, 0xcb, 0xb0, 0xc3, 0x33, 0xd6, 0x4d, 0x62, 0x9f, 0x34,
520 0x86, 0xf9, 0xf8, 0x36, 0x64, 0x58, 0xde, 0xca, 0xfe, 0x91, 0xa1, 0x77, 0x0f, 0xf3, 0x69, 0x36,
521 0x17, 0x2e, 0xb3, 0xa7, 0x50, 0x37, 0xcc, 0x47, 0xc7, 0xa4, 0xae, 0x11, 0xe3, 0x99, 0xde, 0x48,
522 0xf3, 0xbc, 0x1a, 0x4d, 0xc3, 0xb5, 0x91, 0xec, 0x99, 0xd6, 0xed, 0xeb, 0xf9, 0x2c, 0x9b, 0xf6,
523 0x92, 0x64, 0xda, 0x6d, 0x96, 0xf6, 0x98, 0x66, 0xf1, 0xa9, 0x5d, 0x0e, 0x8b, 0x2c, 0x6c, 0x41,
524 0x46, 0xac, 0x6b, 0xb8, 0x0c, 0x88, 0xad, 0x2d, 0x5b, 0x86, 0x2b, 0x10, 0xe3, 0x53, 0x84, 0xfd,
525 0x56, 0x81, 0xff, 0x7d, 0x35, 0x7c, 0x07, 0x2d, 0x6c, 0x83, 0x32, 0x3d, 0x9f, 0x04, 0x79, 0x79,
526 0x12, 0xa9, 0x88, 0x37, 0xbb, 0x6e, 0xf6, 0x7b, 0x02, 0xb1, 0x78, 0x0f, 0xe2, 0x7c, 0xff, 0xe0,
527 0x34, 0x24, 0x76, 0xeb, 0x0f, 0xeb, 0x8f, 0xf6, 0xea, 0x4a, 0x08, 0x27, 0x21, 0xba, 0xbd, 0x5b,
528 0x6f, 0x2a, 0x08, 0x67, 0x21, 0xd5, 0xdc, 0x5c, 0xdb, 0x6e, 0xee, 0x6c, 0x54, 0x1f, 0x2a, 0x61,
529 0x3c, 0x07, 0xe9, 0xca, 0xc6, 0xe6, 0xe6, 0x7e, 0x65, 0x6d, 0x63, 0x73, 0xfd, 0x0b, 0x25, 0x52,
530 0x54, 0x21, 0xce, 0xeb, 0xa4, 0x0f, 0xbe, 0xd5, 0x37, 0xcd, 0x13, 0x77, 0x0b, 0xf3, 0x41, 0xf1,
531 0x05, 0x86, 0xc4, 0x5a, 0xb7, 0xbb, 0xa5, 0x1d, 0x3b, 0x78, 0x0f, 0xe6, 0x9b, 0xc4, 0x36, 0xcc,
532 0xf6, 0x8e, 0x75, 0xdf, 0xea, 0xb7, 0xba, 0xfa, 0x96, 0x76, 0x9c, 0x47, 0x6c, 0x69, 0xaf, 0x0a,
533 0xf7, 0xed, 0xa6, 0x97, 0x3d, 0xb9, 0x7c, 0x81, 0xbd, 0x0c, 0xbc, 0x03, 0xca, 0x30, 0x58, 0xeb,
534 0x5a, 0x1a, 0xa1, 0xdc, 0x30, 0xe3, 0x96, 0x66, 0x70, 0x87, 0xa9, 0x1c, 0xeb, 0x21, 0xe0, 0xbb,
535 0x90, 0xdc, 0x30, 0xc9, 0xcd, 0x15, 0x4a, 0x8b, 0x30, 0x5a, 0x41, 0x42, 0x1b, 0xa6, 0x70, 0xca,
536 0x48, 0xe1, 0xaa, 0xff, 0x77, 0x8b, 0xaa, 0xa3, 0xb3, 0xd4, 0x2c, 0x65, 0xac, 0x66, 0x43, 0x7c,
537 0x0f, 0x52, 0xbb, 0xc6, 0x70, 0xf2, 0x18, 0x93, 0x2f, 0x49, 0xe4, 0xa3, 0x1c, 0xae, 0x1f, 0x6b,
538 0x86, 0x00, 0x3e, 0x7f, 0x7c, 0x26, 0x40, 0x28, 0x60, 0xac, 0xa1, 0x80, 0xe6, 0xa8, 0x82, 0x84,
539 0x2f, 0xa0, 0x39, 0x55, 0x41, 0x53, 0xac, 0xa0, 0x39, 0xaa, 0x20, 0x39, 0x13, 0x20, 0x56, 0x30,
540 0x1a, 0xe3, 0x0a, 0x40, 0xcd, 0xf8, 0x4a, 0x3f, 0xe4, 0x25, 0xa4, 0x18, 0xa1, 0x28, 0x21, 0x8c,
541 0x93, 0x38, 0x42, 0x50, 0xe1, 0x75, 0x48, 0x37, 0x8f, 0xc6, 0x10, 0xf0, 0x9c, 0xe3, 0x51, 0x19,
542 0x47, 0x53, 0x14, 0x51, 0x37, 0x2a, 0x85, 0xdf, 0x4c, 0x7a, 0x76, 0x29, 0xc2, 0xdd, 0x08, 0xaa,
543 0x71, 0x29, 0x1c, 0x92, 0x09, 0x28, 0x45, 0xa0, 0x88, 0x3a, 0xda, 0x0c, 0x2b, 0x96, 0x45, 0x33,
544 0xdd, 0xae, 0xb4, 0x28, 0x41, 0xb8, 0x19, 0x6e, 0x33, 0x74, 0x47, 0xec, 0x89, 0xb0, 0x4d, 0x4e,
545 0xc5, 0x39, 0xff, 0x27, 0x32, 0xcc, 0x19, 0x3e, 0x91, 0xe1, 0x58, 0x3c, 0x67, 0x95, 0x13, 0xa2,
546 0x3b, 0x94, 0x33, 0x17, 0x78, 0xce, 0x86, 0xa9, 0x53, 0xe7, 0x6c, 0x18, 0xc6, 0x9f, 0xc1, 0xdc,
547 0x30, 0x46, 0xdb, 0x13, 0x85, 0x2a, 0x0c, 0x7a, 0x65, 0x06, 0xd4, 0xcd, 0xe4, 0xcc, 0x69, 0x3d,
548 0xae, 0x43, 0x6e, 0x18, 0xda, 0x72, 0xd8, 0xed, 0xce, 0x33, 0xe2, 0xe5, 0x19, 0x44, 0x9e, 0xc8,
549 0x81, 0x53, 0xea, 0x85, 0xfb, 0xf0, 0x4f, 0x79, 0x37, 0x12, 0xdb, 0x6f, 0x8a, 0xb7, 0xdf, 0x8b,
550 0x62, 0xfb, 0x45, 0x62, 0xfb, 0xae, 0xc2, 0x3f, 0xa4, 0xbd, 0x27, 0x08, 0x12, 0x16, 0x21, 0x1f,
551 0x42, 0x76, 0xa2, 0xe5, 0x88, 0xe2, 0x98, 0x44, 0x1c, 0xf3, 0x8a, 0xc7, 0x5b, 0x4b, 0xf2, 0xf6,
552 0x98, 0x10, 0x47, 0x44, 0xf1, 0x5d, 0xc8, 0x4d, 0xf6, 0x1b, 0x51, 0x9d, 0x95, 0xa8, 0xb3, 0x12,
553 0xb5, 0x7c, 0xee, 0xa8, 0x44, 0x1d, 0x9d, 0x52, 0x37, 0x7d, 0xe7, 0x9e, 0x97, 0xa8, 0xe7, 0x25,
554 0x6a, 0xf9, 0xdc, 0x58, 0xa2, 0xc6, 0xa2, 0xfa, 0x23, 0x98, 0x9b, 0x6a, 0x31, 0xa2, 0x3c, 0x21,
555 0x91, 0x27, 0x44, 0xf9, 0xc7, 0xa0, 0x4c, 0x37, 0x17, 0x51, 0x3f, 0x27, 0xd1, 0xcf, 0xc9, 0xa6,
556 0x97, 0x57, 0x1f, 0x97, 0xc8, 0xe3, 0xd2, 0xe9, 0xe5, 0x7a, 0x45, 0xa2, 0x57, 0x44, 0xfd, 0x2a,
557 0x64, 0xc4, 0x6e, 0x22, 0x6a, 0x93, 0x12, 0x6d, 0x72, 0x7a, 0xdd, 0x27, 0x9a, 0x49, 0xd0, 0x4e,
558 0x4f, 0xf9, 0x1c, 0x97, 0x89, 0x16, 0x12, 0x04, 0xc9, 0x88, 0x90, 0xc7, 0x70, 0x51, 0xd6, 0x32,
559 0x24, 0x8c, 0x92, 0xc8, 0xc8, 0x51, 0x8f, 0x38, 0x36, 0x7b, 0x54, 0x35, 0x61, 0x9c, 0x16, 0x9e,
560 0xc0, 0x05, 0x49, 0xe3, 0x90, 0x60, 0xcb, 0x93, 0x6e, 0x2c, 0x2f, 0x60, 0x59, 0x13, 0x30, 0xcc,
561 0xf6, 0xb6, 0x65, 0x98, 0x44, 0x74, 0x65, 0x3f, 0x5c, 0x80, 0x9c, 0xdb, 0x9e, 0x1e, 0xd9, 0x87,
562 0xba, 0xad, 0x1f, 0xe2, 0x2f, 0xfd, 0xbd, 0xd3, 0x0d, 0x6f, 0x53, 0x73, 0x55, 0xef, 0x61, 0xa1,
563 0x9e, 0xf8, 0x5a, 0xa8, 0xe5, 0x60, 0x7c, 0x90, 0x93, 0xaa, 0x7a, 0x9c, 0xd4, 0x15, 0x7f, 0xa8,
564 0x9f, 0xa1, 0xaa, 0x7a, 0x0c, 0xd5, 0x6c, 0x88, 0xd4, 0x57, 0xd5, 0xbc, 0xbe, 0xaa, 0xe4, 0x4f,
565 0xf1, 0xb7, 0x57, 0x35, 0xaf, 0xbd, 0x0a, 0xe0, 0xc8, 0x5d, 0x56, 0xcd, 0xeb, 0xb2, 0x66, 0x70,
566 0xfc, 0xcd, 0x56, 0xcd, 0x6b, 0xb6, 0x02, 0x38, 0x72, 0xcf, 0xb5, 0x21, 0xf1, 0x5c, 0x57, 0xfd,
567 0x41, 0xb3, 0xac, 0xd7, 0xa6, 0xcc, 0x7a, 0x5d, 0x9b, 0x51, 0xd4, 0x4c, 0x07, 0xb6, 0x21, 0x71,
568 0x60, 0x41, 0x85, 0xf9, 0x18, 0xb1, 0x4d, 0x99, 0x11, 0x0b, 0x2c, 0xcc, 0xcf, 0x8f, 0x7d, 0x32,
569 0xed, 0xc7, 0x2e, 0xfb, 0x93, 0xe4, 0xb6, 0xac, 0xe6, 0xb5, 0x65, 0xa5, 0xa0, 0x33, 0x27, 0x73,
570 0x67, 0x4f, 0x7c, 0xdd, 0xd9, 0x9f, 0x38, 0xc2, 0x41, 0x26, 0xed, 0x73, 0x3f, 0x93, 0x56, 0x0e,
571 0x66, 0xcf, 0xf6, 0x6a, 0xbb, 0x3e, 0x5e, 0xed, 0x7a, 0x30, 0xf8, 0xdc, 0xb2, 0x9d, 0x5b, 0xb6,
572 0x73, 0xcb, 0x76, 0x6e, 0xd9, 0xfe, 0x7e, 0xcb, 0xb6, 0x1a, 0xfd, 0xfa, 0xdb, 0x45, 0x54, 0xfc,
573 0x25, 0x02, 0x39, 0xf7, 0xcb, 0xe0, 0x9e, 0x41, 0x3a, 0xb4, 0xbd, 0x6d, 0x41, 0xc6, 0xd4, 0x7a,
574 0xfa, 0x7e, 0x4f, 0x3b, 0x3e, 0x36, 0xcc, 0xb6, 0xeb, 0xd9, 0xae, 0x79, 0x3f, 0x25, 0xba, 0x82,
575 0x72, 0x5d, 0xeb, 0xd1, 0x5e, 0x45, 0x93, 0xdd, 0xd7, 0x8d, 0x39, 0x8e, 0xe0, 0x4f, 0x21, 0xdd,
576 0x73, 0xda, 0x23, 0x5a, 0xd8, 0xf3, 0x22, 0x9c, 0xa2, 0xf1, 0x3b, 0x1d, 0xc3, 0xa0, 0x37, 0x0a,
577 0xd0, 0xd2, 0x5a, 0x27, 0x64, 0x5c, 0x5a, 0x24, 0xa8, 0x34, 0xfa, 0x4c, 0x27, 0x4b, 0x6b, 0x8d,
578 0x23, 0x74, 0xdb, 0x4e, 0xd7, 0x1e, 0xd4, 0xe9, 0x26, 0x36, 0xcf, 0x1e, 0xcc, 0x4d, 0x55, 0x2b,
579 0x39, 0xf3, 0x7f, 0xe1, 0xd9, 0xd0, 0xc2, 0xa6, 0x2b, 0x0f, 0x3a, 0x13, 0xe2, 0x86, 0x2c, 0xfe,
580 0x1b, 0xb2, 0x13, 0x6c, 0x9c, 0x01, 0x74, 0xc4, 0xa4, 0xa8, 0x81, 0x8e, 0x8a, 0xdf, 0x20, 0x48,
581 0xd3, 0x3e, 0xf9, 0xdf, 0x95, 0x3b, 0xdb, 0x9a, 0x61, 0xe3, 0x07, 0x10, 0xed, 0xea, 0x47, 0x84,
582 0x25, 0x64, 0x2a, 0xb7, 0x4e, 0x5f, 0x2d, 0x86, 0x7e, 0x7b, 0xb5, 0xf8, 0x9f, 0x80, 0xff, 0x12,
583 0xf4, 0x1d, 0x62, 0xf5, 0xca, 0x2e, 0xa7, 0xc1, 0x08, 0xb8, 0x06, 0x31, 0xdb, 0x68, 0x77, 0x08,
584 0x2f, 0xa9, 0x72, 0xe3, 0xbd, 0x31, 0x5c, 0x5e, 0x3c, 0x45, 0x30, 0x5f, 0xb5, 0x4c, 0xa2, 0x19,
585 0xa6, 0xc3, 0xbf, 0xd6, 0xd2, 0x37, 0xe4, 0x0b, 0x04, 0xa9, 0xd1, 0x08, 0xb7, 0x20, 0x37, 0x1a,
586 0xb0, 0x8f, 0xe0, 0xee, 0x4e, 0x5d, 0x15, 0x56, 0xd8, 0xc3, 0x28, 0x4b, 0xae, 0x98, 0xd8, 0x7d,
587 0x27, 0x4f, 0x06, 0x17, 0xd6, 0xe0, 0x82, 0x24, 0xed, 0x7d, 0x5e, 0xc8, 0xc5, 0x25, 0x48, 0xd5,
588 0x2d, 0xb2, 0xad, 0x1d, 0x3c, 0x65, 0x9f, 0x9c, 0xc7, 0xff, 0x55, 0xa8, 0x84, 0x95, 0x10, 0x13,
589 0x5f, 0x5b, 0x82, 0x84, 0x7b, 0xfa, 0x71, 0x1c, 0xc2, 0x5b, 0x6b, 0x4a, 0x88, 0xfd, 0x56, 0x14,
590 0xc4, 0x7e, 0xab, 0x4a, 0xb8, 0xb2, 0x79, 0x7a, 0xa6, 0x86, 0x5e, 0x9e, 0xa9, 0xa1, 0x5f, 0xcf,
591 0xd4, 0xd0, 0xeb, 0x33, 0x15, 0xbd, 0x39, 0x53, 0xd1, 0xdb, 0x33, 0x15, 0xbd, 0x3b, 0x53, 0xd1,
592 0xf3, 0x81, 0x8a, 0xbe, 0x1b, 0xa8, 0xe8, 0xfb, 0x81, 0x8a, 0x7e, 0x1c, 0xa8, 0xe8, 0xa7, 0x81,
593 0x8a, 0x4e, 0x07, 0x6a, 0xe8, 0xe5, 0x40, 0x45, 0xaf, 0x07, 0x2a, 0x7a, 0x33, 0x50, 0x43, 0x6f,
594 0x07, 0x2a, 0x7a, 0x37, 0x50, 0x43, 0xcf, 0x7f, 0x57, 0x43, 0xad, 0x38, 0x5f, 0x9e, 0x3f, 0x02,
595 0x00, 0x00, 0xff, 0xff, 0xda, 0xba, 0x48, 0xa4, 0x67, 0x1a, 0x00, 0x00,
596 }
597
598 func (this *Message) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
599 return Theproto3Description()
600 }
601 func (this *Nested) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
602 return Theproto3Description()
603 }
604 func (this *AllMaps) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
605 return Theproto3Description()
606 }
607 func (this *AllMapsOrdered) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
608 return Theproto3Description()
609 }
610 func (this *MessageWithMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
611 return Theproto3Description()
612 }
613 func (this *FloatingPoint) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
614 return Theproto3Description()
615 }
616 func (this *Uint128Pair) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
617 return Theproto3Description()
618 }
619 func (this *ContainsNestedMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
620 return Theproto3Description()
621 }
622 func (this *ContainsNestedMap_NestedMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
623 return Theproto3Description()
624 }
625 func (this *NotPacked) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
626 return Theproto3Description()
627 }
628 func Theproto3Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
629 d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
630 var gzipped = []byte{
631
632 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x5b, 0x70, 0x23, 0xd7,
633 0x99, 0x1e, 0x1b, 0x0d, 0x90, 0xc0, 0x0f, 0x90, 0x6c, 0x36, 0x67, 0x28, 0x88, 0x1a, 0x91, 0x33,
634 0xd0, 0x68, 0x44, 0xd1, 0x12, 0x67, 0x86, 0xc3, 0xb9, 0x61, 0x2c, 0x69, 0x01, 0x10, 0x1c, 0x71,
635 0x4c, 0x82, 0x74, 0x93, 0xb4, 0x34, 0x56, 0x12, 0x54, 0x13, 0x38, 0x24, 0x21, 0x01, 0xdd, 0x58,
636 0x74, 0x43, 0x12, 0x55, 0xa9, 0x94, 0xb2, 0x4e, 0x36, 0xde, 0xdc, 0x93, 0x4d, 0x2a, 0x5e, 0xc7,
637 0x17, 0x79, 0xb7, 0x76, 0xed, 0xdd, 0xdc, 0xbc, 0xce, 0xc6, 0xd9, 0x75, 0x52, 0x59, 0xe5, 0xc1,
638 0xc9, 0xe4, 0x25, 0xe5, 0x4d, 0x5e, 0x52, 0xae, 0x94, 0xca, 0x1a, 0x3b, 0xb5, 0x4e, 0xe2, 0x24,
639 0xce, 0x46, 0x55, 0x71, 0x95, 0xf7, 0x61, 0xeb, 0xdc, 0xba, 0x4f, 0x1f, 0x34, 0xd0, 0xe0, 0x48,
640 0xb2, 0xf7, 0xc1, 0x2f, 0x33, 0xe8, 0x73, 0xfe, 0xef, 0xeb, 0xbf, 0xff, 0xcb, 0x39, 0x7f, 0x9f,
641 0x73, 0x00, 0xc2, 0xbd, 0x3c, 0x9c, 0x3d, 0xb4, 0xed, 0xc3, 0x26, 0xba, 0xd8, 0xee, 0xd8, 0xae,
642 0xbd, 0xdf, 0x3d, 0xb8, 0x58, 0x47, 0x4e, 0xad, 0xd3, 0x68, 0xbb, 0x76, 0x67, 0x89, 0xb4, 0xe9,
643 0x93, 0x54, 0x62, 0x89, 0x4b, 0xe4, 0x36, 0x61, 0x6a, 0xad, 0xd1, 0x44, 0xab, 0x9e, 0xe0, 0x0e,
644 0x72, 0xf5, 0x1b, 0x10, 0x3f, 0x68, 0x34, 0x51, 0x56, 0x39, 0xab, 0x2e, 0xa4, 0x97, 0xcf, 0x2f,
645 0x49, 0xa0, 0xa5, 0x20, 0x62, 0x1b, 0x37, 0x1b, 0x04, 0x91, 0xfb, 0x5e, 0x1c, 0xa6, 0x43, 0x7a,
646 0x75, 0x1d, 0xe2, 0x96, 0xd9, 0xc2, 0x8c, 0xca, 0x42, 0xca, 0x20, 0x9f, 0xf5, 0x2c, 0x8c, 0xb5,
647 0xcd, 0xda, 0x2b, 0xe6, 0x21, 0xca, 0xc6, 0x48, 0x33, 0xbf, 0xd4, 0xe7, 0x00, 0xea, 0xa8, 0x8d,
648 0xac, 0x3a, 0xb2, 0x6a, 0xc7, 0x59, 0xf5, 0xac, 0xba, 0x90, 0x32, 0x84, 0x16, 0xfd, 0x23, 0x30,
649 0xd5, 0xee, 0xee, 0x37, 0x1b, 0xb5, 0xaa, 0x20, 0x06, 0x67, 0xd5, 0x85, 0x84, 0xa1, 0xd1, 0x8e,
650 0x55, 0x5f, 0xf8, 0x09, 0x98, 0x7c, 0x0d, 0x99, 0xaf, 0x88, 0xa2, 0x69, 0x22, 0x3a, 0x81, 0x9b,
651 0x05, 0xc1, 0x12, 0x64, 0x5a, 0xc8, 0x71, 0xcc, 0x43, 0x54, 0x75, 0x8f, 0xdb, 0x28, 0x1b, 0x27,
652 0x4f, 0x7f, 0xb6, 0xe7, 0xe9, 0xe5, 0x27, 0x4f, 0x33, 0xd4, 0xee, 0x71, 0x1b, 0xe9, 0x05, 0x48,
653 0x21, 0xab, 0xdb, 0xa2, 0x0c, 0x89, 0x3e, 0xf6, 0x2b, 0x5b, 0xdd, 0x96, 0xcc, 0x92, 0xc4, 0x30,
654 0x46, 0x31, 0xe6, 0xa0, 0xce, 0xab, 0x8d, 0x1a, 0xca, 0x8e, 0x12, 0x82, 0x27, 0x7a, 0x08, 0x76,
655 0x68, 0xbf, 0xcc, 0xc1, 0x71, 0x7a, 0x09, 0x52, 0xe8, 0x75, 0x17, 0x59, 0x4e, 0xc3, 0xb6, 0xb2,
656 0x63, 0x84, 0xe4, 0xf1, 0x10, 0x2f, 0xa2, 0x66, 0x5d, 0xa6, 0xf0, 0x71, 0xfa, 0x35, 0x18, 0xb3,
657 0xdb, 0x6e, 0xc3, 0xb6, 0x9c, 0x6c, 0xf2, 0xac, 0xb2, 0x90, 0x5e, 0x3e, 0x13, 0x1a, 0x08, 0x5b,
658 0x54, 0xc6, 0xe0, 0xc2, 0xfa, 0x3a, 0x68, 0x8e, 0xdd, 0xed, 0xd4, 0x50, 0xb5, 0x66, 0xd7, 0x51,
659 0xb5, 0x61, 0x1d, 0xd8, 0xd9, 0x14, 0x21, 0x98, 0xef, 0x7d, 0x10, 0x22, 0x58, 0xb2, 0xeb, 0x68,
660 0xdd, 0x3a, 0xb0, 0x8d, 0x09, 0x27, 0x70, 0xad, 0xcf, 0xc0, 0xa8, 0x73, 0x6c, 0xb9, 0xe6, 0xeb,
661 0xd9, 0x0c, 0x89, 0x10, 0x76, 0x95, 0xfb, 0xbd, 0x51, 0x98, 0x1c, 0x26, 0xc4, 0x6e, 0x41, 0xe2,
662 0x00, 0x3f, 0x65, 0x36, 0x76, 0x12, 0x1b, 0x50, 0x4c, 0xd0, 0x88, 0xa3, 0x0f, 0x68, 0xc4, 0x02,
663 0xa4, 0x2d, 0xe4, 0xb8, 0xa8, 0x4e, 0x23, 0x42, 0x1d, 0x32, 0xa6, 0x80, 0x82, 0x7a, 0x43, 0x2a,
664 0xfe, 0x40, 0x21, 0xf5, 0x22, 0x4c, 0x7a, 0x2a, 0x55, 0x3b, 0xa6, 0x75, 0xc8, 0x63, 0xf3, 0x62,
665 0x94, 0x26, 0x4b, 0x65, 0x8e, 0x33, 0x30, 0xcc, 0x98, 0x40, 0x81, 0x6b, 0x7d, 0x15, 0xc0, 0xb6,
666 0x90, 0x7d, 0x50, 0xad, 0xa3, 0x5a, 0x33, 0x9b, 0xec, 0x63, 0xa5, 0x2d, 0x2c, 0xd2, 0x63, 0x25,
667 0x9b, 0xb6, 0xd6, 0x9a, 0xfa, 0x4d, 0x3f, 0xd4, 0xc6, 0xfa, 0x44, 0xca, 0x26, 0x4d, 0xb2, 0x9e,
668 0x68, 0xdb, 0x83, 0x89, 0x0e, 0xc2, 0x71, 0x8f, 0xea, 0xec, 0xc9, 0x52, 0x44, 0x89, 0xa5, 0xc8,
669 0x27, 0x33, 0x18, 0x8c, 0x3e, 0xd8, 0x78, 0x47, 0xbc, 0xd4, 0x1f, 0x03, 0xaf, 0xa1, 0x4a, 0xc2,
670 0x0a, 0xc8, 0x28, 0x94, 0xe1, 0x8d, 0x15, 0xb3, 0x85, 0x66, 0xdf, 0x80, 0x89, 0xa0, 0x79, 0xf4,
671 0x53, 0x90, 0x70, 0x5c, 0xb3, 0xe3, 0x92, 0x28, 0x4c, 0x18, 0xf4, 0x42, 0xd7, 0x40, 0x45, 0x56,
672 0x9d, 0x8c, 0x72, 0x09, 0x03, 0x7f, 0xd4, 0x7f, 0xce, 0x7f, 0x60, 0x95, 0x3c, 0xf0, 0x85, 0x5e,
673 0x8f, 0x06, 0x98, 0xe5, 0xe7, 0x9e, 0xbd, 0x0e, 0xe3, 0x81, 0x07, 0x18, 0xf6, 0xd6, 0xb9, 0x3f,
674 0x0f, 0xa7, 0x43, 0xa9, 0xf5, 0x17, 0xe1, 0x54, 0xd7, 0x6a, 0x58, 0x2e, 0xea, 0xb4, 0x3b, 0x08,
675 0x47, 0x2c, 0xbd, 0x55, 0xf6, 0x0f, 0xc7, 0xfa, 0xc4, 0xdc, 0x9e, 0x28, 0x4d, 0x59, 0x8c, 0xe9,
676 0x6e, 0x6f, 0xe3, 0x62, 0x2a, 0xf9, 0xfd, 0x31, 0xed, 0xcd, 0x37, 0xdf, 0x7c, 0x33, 0x96, 0xfb,
677 0xcc, 0x28, 0x9c, 0x0a, 0xcb, 0x99, 0xd0, 0xf4, 0x9d, 0x81, 0x51, 0xab, 0xdb, 0xda, 0x47, 0x1d,
678 0x62, 0xa4, 0x84, 0xc1, 0xae, 0xf4, 0x02, 0x24, 0x9a, 0xe6, 0x3e, 0x6a, 0x66, 0xe3, 0x67, 0x95,
679 0x85, 0x89, 0xe5, 0x8f, 0x0c, 0x95, 0x95, 0x4b, 0x1b, 0x18, 0x62, 0x50, 0xa4, 0xfe, 0x2c, 0xc4,
680 0xd9, 0x10, 0x8d, 0x19, 0x16, 0x87, 0x63, 0xc0, 0xb9, 0x64, 0x10, 0x9c, 0xfe, 0x08, 0xa4, 0xf0,
681 0xff, 0x34, 0x36, 0x46, 0x89, 0xce, 0x49, 0xdc, 0x80, 0xe3, 0x42, 0x9f, 0x85, 0x24, 0x49, 0x93,
682 0x3a, 0xe2, 0x53, 0x9b, 0x77, 0x8d, 0x03, 0xab, 0x8e, 0x0e, 0xcc, 0x6e, 0xd3, 0xad, 0xbe, 0x6a,
683 0x36, 0xbb, 0x88, 0x04, 0x7c, 0xca, 0xc8, 0xb0, 0xc6, 0x4f, 0xe0, 0x36, 0x7d, 0x1e, 0xd2, 0x34,
684 0xab, 0x1a, 0x56, 0x1d, 0xbd, 0x4e, 0x46, 0xcf, 0x84, 0x41, 0x13, 0x6d, 0x1d, 0xb7, 0xe0, 0xdb,
685 0xbf, 0xec, 0xd8, 0x16, 0x0f, 0x4d, 0x72, 0x0b, 0xdc, 0x40, 0x6e, 0x7f, 0x5d, 0x1e, 0xb8, 0x1f,
686 0x0d, 0x7f, 0x3c, 0x39, 0xa6, 0x72, 0x5f, 0x8f, 0x41, 0x9c, 0x8c, 0x17, 0x93, 0x90, 0xde, 0xbd,
687 0xbb, 0x5d, 0xae, 0xae, 0x6e, 0xed, 0x15, 0x37, 0xca, 0x9a, 0xa2, 0x4f, 0x00, 0x90, 0x86, 0xb5,
688 0x8d, 0xad, 0xc2, 0xae, 0x16, 0xf3, 0xae, 0xd7, 0x2b, 0xbb, 0xd7, 0x56, 0x34, 0xd5, 0x03, 0xec,
689 0xd1, 0x86, 0xb8, 0x28, 0x70, 0x65, 0x59, 0x4b, 0xe8, 0x1a, 0x64, 0x28, 0xc1, 0xfa, 0x8b, 0xe5,
690 0xd5, 0x6b, 0x2b, 0xda, 0x68, 0xb0, 0xe5, 0xca, 0xb2, 0x36, 0xa6, 0x8f, 0x43, 0x8a, 0xb4, 0x14,
691 0xb7, 0xb6, 0x36, 0xb4, 0xa4, 0xc7, 0xb9, 0xb3, 0x6b, 0xac, 0x57, 0x6e, 0x6b, 0x29, 0x8f, 0xf3,
692 0xb6, 0xb1, 0xb5, 0xb7, 0xad, 0x81, 0xc7, 0xb0, 0x59, 0xde, 0xd9, 0x29, 0xdc, 0x2e, 0x6b, 0x69,
693 0x4f, 0xa2, 0x78, 0x77, 0xb7, 0xbc, 0xa3, 0x65, 0x02, 0x6a, 0x5d, 0x59, 0xd6, 0xc6, 0xbd, 0x5b,
694 0x94, 0x2b, 0x7b, 0x9b, 0xda, 0x84, 0x3e, 0x05, 0xe3, 0xf4, 0x16, 0x5c, 0x89, 0x49, 0xa9, 0xe9,
695 0xda, 0x8a, 0xa6, 0xf9, 0x8a, 0x50, 0x96, 0xa9, 0x40, 0xc3, 0xb5, 0x15, 0x4d, 0xcf, 0x95, 0x20,
696 0x41, 0xa2, 0x4b, 0xd7, 0x61, 0x62, 0xa3, 0x50, 0x2c, 0x6f, 0x54, 0xb7, 0xb6, 0x77, 0xd7, 0xb7,
697 0x2a, 0x85, 0x0d, 0x4d, 0xf1, 0xdb, 0x8c, 0xf2, 0xc7, 0xf7, 0xd6, 0x8d, 0xf2, 0xaa, 0x16, 0x13,
698 0xdb, 0xb6, 0xcb, 0x85, 0xdd, 0xf2, 0xaa, 0xa6, 0xe6, 0x6a, 0x70, 0x2a, 0x6c, 0x9c, 0x0c, 0xcd,
699 0x0c, 0xc1, 0xc5, 0xb1, 0x3e, 0x2e, 0x26, 0x5c, 0x3d, 0x2e, 0xfe, 0x6e, 0x0c, 0xa6, 0x43, 0xe6,
700 0x8a, 0xd0, 0x9b, 0x3c, 0x07, 0x09, 0x1a, 0xa2, 0x74, 0xf6, 0x7c, 0x32, 0x74, 0xd2, 0x21, 0x01,
701 0xdb, 0x33, 0x83, 0x12, 0x9c, 0x58, 0x41, 0xa8, 0x7d, 0x2a, 0x08, 0x4c, 0xd1, 0x33, 0xa6, 0xff,
702 0xd9, 0x9e, 0x31, 0x9d, 0x4e, 0x7b, 0xd7, 0x86, 0x99, 0xf6, 0x48, 0xdb, 0xc9, 0xc6, 0xf6, 0x44,
703 0xc8, 0xd8, 0x7e, 0x0b, 0xa6, 0x7a, 0x88, 0x86, 0x1e, 0x63, 0x3f, 0xa5, 0x40, 0xb6, 0x9f, 0x71,
704 0x22, 0x46, 0xba, 0x58, 0x60, 0xa4, 0xbb, 0x25, 0x5b, 0xf0, 0x5c, 0x7f, 0x27, 0xf4, 0xf8, 0xfa,
705 0xcb, 0x0a, 0xcc, 0x84, 0x57, 0x8a, 0xa1, 0x3a, 0x3c, 0x0b, 0xa3, 0x2d, 0xe4, 0x1e, 0xd9, 0xbc,
706 0x5a, 0xba, 0x10, 0x32, 0x07, 0xe3, 0x6e, 0xd9, 0xd9, 0x0c, 0x25, 0x4e, 0xe2, 0x6a, 0xbf, 0x72,
707 0x8f, 0x6a, 0xd3, 0xa3, 0xe9, 0x2f, 0xc5, 0xe0, 0x74, 0x28, 0x79, 0xa8, 0xa2, 0x8f, 0x02, 0x34,
708 0xac, 0x76, 0xd7, 0xa5, 0x15, 0x11, 0x1d, 0x60, 0x53, 0xa4, 0x85, 0x0c, 0x5e, 0x78, 0xf0, 0xec,
709 0xba, 0x5e, 0xbf, 0x4a, 0xfa, 0x81, 0x36, 0x11, 0x81, 0x1b, 0xbe, 0xa2, 0x71, 0xa2, 0xe8, 0x5c,
710 0x9f, 0x27, 0xed, 0x09, 0xcc, 0x4b, 0xa0, 0xd5, 0x9a, 0x0d, 0x64, 0xb9, 0x55, 0xc7, 0xed, 0x20,
711 0xb3, 0xd5, 0xb0, 0x0e, 0xc9, 0x0c, 0x92, 0xcc, 0x27, 0x0e, 0xcc, 0xa6, 0x83, 0x8c, 0x49, 0xda,
712 0xbd, 0xc3, 0x7b, 0x31, 0x82, 0x04, 0x50, 0x47, 0x40, 0x8c, 0x06, 0x10, 0xb4, 0xdb, 0x43, 0xe4,
713 0xfe, 0x7a, 0x0a, 0xd2, 0x42, 0x5d, 0xad, 0x9f, 0x83, 0xcc, 0xcb, 0xe6, 0xab, 0x66, 0x95, 0xbf,
714 0x2b, 0x51, 0x4b, 0xa4, 0x71, 0xdb, 0x36, 0x7b, 0x5f, 0xba, 0x04, 0xa7, 0x88, 0x88, 0xdd, 0x75,
715 0x51, 0xa7, 0x5a, 0x6b, 0x9a, 0x8e, 0x43, 0x8c, 0x96, 0x24, 0xa2, 0x3a, 0xee, 0xdb, 0xc2, 0x5d,
716 0x25, 0xde, 0xa3, 0x5f, 0x85, 0x69, 0x82, 0x68, 0x75, 0x9b, 0x6e, 0xa3, 0xdd, 0x44, 0x55, 0xfc,
717 0xf6, 0xe6, 0x90, 0x99, 0xc4, 0xd3, 0x6c, 0x0a, 0x4b, 0x6c, 0x32, 0x01, 0xac, 0x91, 0xa3, 0xaf,
718 0xc2, 0xa3, 0x04, 0x76, 0x88, 0x2c, 0xd4, 0x31, 0x5d, 0x54, 0x45, 0x3f, 0xdf, 0x35, 0x9b, 0x4e,
719 0xd5, 0xb4, 0xea, 0xd5, 0x23, 0xd3, 0x39, 0xca, 0x9e, 0xc2, 0x04, 0xc5, 0x58, 0x56, 0x31, 0x1e,
720 0xc6, 0x82, 0xb7, 0x99, 0x5c, 0x99, 0x88, 0x15, 0xac, 0xfa, 0xf3, 0xa6, 0x73, 0xa4, 0xe7, 0x61,
721 0x86, 0xb0, 0x38, 0x6e, 0xa7, 0x61, 0x1d, 0x56, 0x6b, 0x47, 0xa8, 0xf6, 0x4a, 0xb5, 0xeb, 0x1e,
722 0xdc, 0xc8, 0x3e, 0x22, 0xde, 0x9f, 0x68, 0xb8, 0x43, 0x64, 0x4a, 0x58, 0x64, 0xcf, 0x3d, 0xb8,
723 0xa1, 0xef, 0x40, 0x06, 0x3b, 0xa3, 0xd5, 0x78, 0x03, 0x55, 0x0f, 0xec, 0x0e, 0x99, 0x1a, 0x27,
724 0x42, 0x86, 0x26, 0xc1, 0x82, 0x4b, 0x5b, 0x0c, 0xb0, 0x69, 0xd7, 0x51, 0x3e, 0xb1, 0xb3, 0x5d,
725 0x2e, 0xaf, 0x1a, 0x69, 0xce, 0xb2, 0x66, 0x77, 0x70, 0x40, 0x1d, 0xda, 0x9e, 0x81, 0xd3, 0x34,
726 0xa0, 0x0e, 0x6d, 0x6e, 0xde, 0xab, 0x30, 0x5d, 0xab, 0xd1, 0x67, 0x6e, 0xd4, 0xaa, 0xec, 0x1d,
727 0xcb, 0xc9, 0x6a, 0x01, 0x63, 0xd5, 0x6a, 0xb7, 0xa9, 0x00, 0x8b, 0x71, 0x47, 0xbf, 0x09, 0xa7,
728 0x7d, 0x63, 0x89, 0xc0, 0xa9, 0x9e, 0xa7, 0x94, 0xa1, 0x57, 0x61, 0xba, 0x7d, 0xdc, 0x0b, 0xd4,
729 0x03, 0x77, 0x6c, 0x1f, 0xcb, 0xb0, 0xeb, 0x70, 0xaa, 0x7d, 0xd4, 0xee, 0xc5, 0x2d, 0x8a, 0x38,
730 0xbd, 0x7d, 0xd4, 0x96, 0x81, 0x8f, 0x93, 0x17, 0xee, 0x0e, 0xaa, 0x99, 0x2e, 0xaa, 0x67, 0x1f,
731 0x12, 0xc5, 0x85, 0x0e, 0xfd, 0x22, 0x68, 0xb5, 0x5a, 0x15, 0x59, 0xe6, 0x7e, 0x13, 0x55, 0xcd,
732 0x0e, 0xb2, 0x4c, 0x27, 0x3b, 0x2f, 0x0a, 0x4f, 0xd4, 0x6a, 0x65, 0xd2, 0x5b, 0x20, 0x9d, 0xfa,
733 0x22, 0x4c, 0xd9, 0xfb, 0x2f, 0xd7, 0x68, 0x48, 0x56, 0xdb, 0x1d, 0x74, 0xd0, 0x78, 0x3d, 0x7b,
734 0x9e, 0xd8, 0x77, 0x12, 0x77, 0x90, 0x80, 0xdc, 0x26, 0xcd, 0xfa, 0x93, 0xa0, 0xd5, 0x9c, 0x23,
735 0xb3, 0xd3, 0x26, 0x63, 0xb2, 0xd3, 0x36, 0x6b, 0x28, 0xfb, 0x38, 0x15, 0xa5, 0xed, 0x15, 0xde,
736 0x8c, 0x53, 0xc2, 0x79, 0xad, 0x71, 0xe0, 0x72, 0xc6, 0x27, 0x68, 0x4a, 0x90, 0x36, 0xc6, 0xb6,
737 0x00, 0x1a, 0x36, 0x45, 0xe0, 0xc6, 0x0b, 0x44, 0x6c, 0xa2, 0x7d, 0xd4, 0x16, 0xef, 0xfb, 0x18,
738 0x8c, 0x63, 0x49, 0xff, 0xa6, 0x4f, 0xd2, 0x82, 0xac, 0x7d, 0x24, 0xdc, 0x71, 0x05, 0x66, 0xb0,
739 0x50, 0x0b, 0xb9, 0x66, 0xdd, 0x74, 0x4d, 0x41, 0xfa, 0x29, 0x22, 0x8d, 0xed, 0xbe, 0xc9, 0x3a,
740 0x03, 0x7a, 0x76, 0xba, 0xfb, 0xc7, 0x5e, 0x64, 0x3d, 0x4d, 0xf5, 0xc4, 0x6d, 0x3c, 0xb6, 0x3e,
741 0xb4, 0xa2, 0x3b, 0x97, 0x87, 0x8c, 0x18, 0xf8, 0x7a, 0x0a, 0x68, 0xe8, 0x6b, 0x0a, 0xae, 0x82,
742 0x4a, 0x5b, 0xab, 0xb8, 0x7e, 0xf9, 0x64, 0x59, 0x8b, 0xe1, 0x3a, 0x6a, 0x63, 0x7d, 0xb7, 0x5c,
743 0x35, 0xf6, 0x2a, 0xbb, 0xeb, 0x9b, 0x65, 0x4d, 0x15, 0x0b, 0xf6, 0x6f, 0xc6, 0x60, 0x22, 0xf8,
744 0xee, 0xa5, 0x7f, 0x14, 0x1e, 0xe2, 0x0b, 0x25, 0x0e, 0x72, 0xab, 0xaf, 0x35, 0x3a, 0x24, 0x17,
745 0x5b, 0x26, 0x9d, 0x17, 0xbd, 0x68, 0x38, 0xc5, 0xa4, 0x76, 0x90, 0xfb, 0x42, 0xa3, 0x83, 0x33,
746 0xad, 0x65, 0xba, 0xfa, 0x06, 0xcc, 0x5b, 0x76, 0xd5, 0x71, 0x4d, 0xab, 0x6e, 0x76, 0xea, 0x55,
747 0x7f, 0x89, 0xaa, 0x6a, 0xd6, 0x6a, 0xc8, 0x71, 0x6c, 0x3a, 0x07, 0x7a, 0x2c, 0x67, 0x2c, 0x7b,
748 0x87, 0x09, 0xfb, 0x93, 0x43, 0x81, 0x89, 0x4a, 0x91, 0xab, 0xf6, 0x8b, 0xdc, 0x47, 0x20, 0xd5,
749 0x32, 0xdb, 0x55, 0x64, 0xb9, 0x9d, 0x63, 0x52, 0x71, 0x27, 0x8d, 0x64, 0xcb, 0x6c, 0x97, 0xf1,
750 0xf5, 0x4f, 0xe6, 0xc5, 0xe7, 0xbf, 0xaa, 0x90, 0x11, 0xab, 0x6e, 0xfc, 0x12, 0x53, 0x23, 0x13,
751 0x94, 0x42, 0x86, 0xb0, 0xc7, 0x06, 0xd6, 0xe8, 0x4b, 0x25, 0x3c, 0x73, 0xe5, 0x47, 0x69, 0x2d,
752 0x6c, 0x50, 0x24, 0xae, 0x1a, 0x70, 0x68, 0x21, 0x5a, 0x7b, 0x24, 0x0d, 0x76, 0xa5, 0xdf, 0x86,
753 0xd1, 0x97, 0x1d, 0xc2, 0x3d, 0x4a, 0xb8, 0xcf, 0x0f, 0xe6, 0xbe, 0xb3, 0x43, 0xc8, 0x53, 0x77,
754 0x76, 0xaa, 0x95, 0x2d, 0x63, 0xb3, 0xb0, 0x61, 0x30, 0xb8, 0xfe, 0x30, 0xc4, 0x9b, 0xe6, 0x1b,
755 0xc7, 0xc1, 0x39, 0x8e, 0x34, 0x0d, 0x6b, 0xf8, 0x87, 0x21, 0xfe, 0x1a, 0x32, 0x5f, 0x09, 0xce,
756 0x2c, 0xa4, 0xe9, 0x43, 0x0c, 0xfd, 0x8b, 0x90, 0x20, 0xf6, 0xd2, 0x01, 0x98, 0xc5, 0xb4, 0x11,
757 0x3d, 0x09, 0xf1, 0xd2, 0x96, 0x81, 0xc3, 0x5f, 0x83, 0x0c, 0x6d, 0xad, 0x6e, 0xaf, 0x97, 0x4b,
758 0x65, 0x2d, 0x96, 0xbb, 0x0a, 0xa3, 0xd4, 0x08, 0x38, 0x35, 0x3c, 0x33, 0x68, 0x23, 0xec, 0x92,
759 0x71, 0x28, 0xbc, 0x77, 0x6f, 0xb3, 0x58, 0x36, 0xb4, 0x98, 0xe8, 0x5e, 0x07, 0x32, 0x62, 0xc1,
760 0xfd, 0x93, 0x89, 0xa9, 0x6f, 0x28, 0x90, 0x16, 0x0a, 0x68, 0x5c, 0xf9, 0x98, 0xcd, 0xa6, 0xfd,
761 0x5a, 0xd5, 0x6c, 0x36, 0x4c, 0x87, 0x05, 0x05, 0x90, 0xa6, 0x02, 0x6e, 0x19, 0xd6, 0x69, 0x3f,
762 0x11, 0xe5, 0xbf, 0xa0, 0x80, 0x26, 0xd7, 0xae, 0x92, 0x82, 0xca, 0x4f, 0x55, 0xc1, 0xcf, 0x29,
763 0x30, 0x11, 0x2c, 0x58, 0x25, 0xf5, 0xce, 0xfd, 0x54, 0xd5, 0xfb, 0x4e, 0x0c, 0xc6, 0x03, 0x65,
764 0xea, 0xb0, 0xda, 0xfd, 0x3c, 0x4c, 0x35, 0xea, 0xa8, 0xd5, 0xb6, 0x5d, 0x64, 0xd5, 0x8e, 0xab,
765 0x4d, 0xf4, 0x2a, 0x6a, 0x66, 0x73, 0x64, 0xa0, 0xb8, 0x38, 0xb8, 0x10, 0x5e, 0x5a, 0xf7, 0x71,
766 0x1b, 0x18, 0x96, 0x9f, 0x5e, 0x5f, 0x2d, 0x6f, 0x6e, 0x6f, 0xed, 0x96, 0x2b, 0xa5, 0xbb, 0xd5,
767 0xbd, 0xca, 0xc7, 0x2a, 0x5b, 0x2f, 0x54, 0x0c, 0xad, 0x21, 0x89, 0x7d, 0x88, 0xa9, 0xbe, 0x0d,
768 0x9a, 0xac, 0x94, 0xfe, 0x10, 0x84, 0xa9, 0xa5, 0x8d, 0xe8, 0xd3, 0x30, 0x59, 0xd9, 0xaa, 0xee,
769 0xac, 0xaf, 0x96, 0xab, 0xe5, 0xb5, 0xb5, 0x72, 0x69, 0x77, 0x87, 0x2e, 0x6d, 0x78, 0xd2, 0xbb,
770 0xc1, 0xa4, 0xfe, 0xac, 0x0a, 0xd3, 0x21, 0x9a, 0xe8, 0x05, 0xf6, 0x52, 0x42, 0xdf, 0x93, 0x9e,
771 0x1e, 0x46, 0xfb, 0x25, 0x5c, 0x15, 0x6c, 0x9b, 0x1d, 0x97, 0xbd, 0xc3, 0x3c, 0x09, 0xd8, 0x4a,
772 0x96, 0xdb, 0x38, 0x68, 0xa0, 0x0e, 0x5b, 0x09, 0xa2, 0x6f, 0x2a, 0x93, 0x7e, 0x3b, 0x5d, 0x0c,
773 0x7a, 0x0a, 0xf4, 0xb6, 0xed, 0x34, 0xdc, 0xc6, 0xab, 0xa8, 0xda, 0xb0, 0xf8, 0xb2, 0x11, 0x7e,
774 0x73, 0x89, 0x1b, 0x1a, 0xef, 0x59, 0xb7, 0x5c, 0x4f, 0xda, 0x42, 0x87, 0xa6, 0x24, 0x8d, 0x07,
775 0x70, 0xd5, 0xd0, 0x78, 0x8f, 0x27, 0x7d, 0x0e, 0x32, 0x75, 0xbb, 0x8b, 0xcb, 0x39, 0x2a, 0x87,
776 0xe7, 0x0b, 0xc5, 0x48, 0xd3, 0x36, 0x4f, 0x84, 0x15, 0xea, 0xfe, 0x7a, 0x55, 0xc6, 0x48, 0xd3,
777 0x36, 0x2a, 0xf2, 0x04, 0x4c, 0x9a, 0x87, 0x87, 0x1d, 0x4c, 0xce, 0x89, 0xe8, 0xab, 0xc7, 0x84,
778 0xd7, 0x4c, 0x04, 0x67, 0xef, 0x40, 0x92, 0xdb, 0x01, 0x4f, 0xc9, 0xd8, 0x12, 0xd5, 0x36, 0x7d,
779 0x9f, 0x8e, 0x2d, 0xa4, 0x8c, 0xa4, 0xc5, 0x3b, 0xcf, 0x41, 0xa6, 0xe1, 0x54, 0xfd, 0xe5, 0xf7,
780 0xd8, 0xd9, 0xd8, 0x42, 0xd2, 0x48, 0x37, 0x1c, 0x6f, 0xe9, 0x32, 0xf7, 0xe5, 0x18, 0x4c, 0x04,
781 0xb7, 0x0f, 0xf4, 0x55, 0x48, 0x36, 0xed, 0x9a, 0x49, 0x42, 0x8b, 0xee, 0x5d, 0x2d, 0x44, 0xec,
782 0x38, 0x2c, 0x6d, 0x30, 0x79, 0xc3, 0x43, 0xce, 0xfe, 0x47, 0x05, 0x92, 0xbc, 0x59, 0x9f, 0x81,
783 0x78, 0xdb, 0x74, 0x8f, 0x08, 0x5d, 0xa2, 0x18, 0xd3, 0x14, 0x83, 0x5c, 0xe3, 0x76, 0xa7, 0x6d,
784 0x5a, 0x24, 0x04, 0x58, 0x3b, 0xbe, 0xc6, 0x7e, 0x6d, 0x22, 0xb3, 0x4e, 0xde, 0x6b, 0xec, 0x56,
785 0x0b, 0x59, 0xae, 0xc3, 0xfd, 0xca, 0xda, 0x4b, 0xac, 0x59, 0xff, 0x08, 0x4c, 0xb9, 0x1d, 0xb3,
786 0xd1, 0x0c, 0xc8, 0xc6, 0x89, 0xac, 0xc6, 0x3b, 0x3c, 0xe1, 0x3c, 0x3c, 0xcc, 0x79, 0xeb, 0xc8,
787 0x35, 0x6b, 0x47, 0xa8, 0xee, 0x83, 0x46, 0xc9, 0xfa, 0xc5, 0x43, 0x4c, 0x60, 0x95, 0xf5, 0x73,
788 0x6c, 0xee, 0x0f, 0x14, 0x98, 0xe2, 0x6f, 0x62, 0x75, 0xcf, 0x58, 0x9b, 0x00, 0xa6, 0x65, 0xd9,
789 0xae, 0x68, 0xae, 0xde, 0x50, 0xee, 0xc1, 0x2d, 0x15, 0x3c, 0x90, 0x21, 0x10, 0xcc, 0xb6, 0x00,
790 0xfc, 0x9e, 0xbe, 0x66, 0x9b, 0x87, 0x34, 0xdb, 0x1b, 0x22, 0x1b, 0x8c, 0xf4, 0xdd, 0x1d, 0x68,
791 0x13, 0x7e, 0x65, 0xd3, 0x4f, 0x41, 0x62, 0x1f, 0x1d, 0x36, 0x2c, 0xb6, 0xe2, 0x4b, 0x2f, 0xf8,
792 0x0a, 0x4b, 0xdc, 0x5b, 0x61, 0x29, 0xbe, 0x04, 0xd3, 0x35, 0xbb, 0x25, 0xab, 0x5b, 0xd4, 0xa4,
793 0xf5, 0x03, 0xe7, 0x79, 0xe5, 0x93, 0xe0, 0x97, 0x98, 0x3f, 0x52, 0x94, 0x5f, 0x8d, 0xa9, 0xb7,
794 0xb7, 0x8b, 0xbf, 0x15, 0x9b, 0xbd, 0x4d, 0xa1, 0xdb, 0xfc, 0x49, 0x0d, 0x74, 0xd0, 0x44, 0x35,
795 0xac, 0x3d, 0xfc, 0xc6, 0x47, 0xe0, 0xe9, 0xc3, 0x86, 0x7b, 0xd4, 0xdd, 0x5f, 0xaa, 0xd9, 0xad,
796 0x8b, 0x87, 0xf6, 0xa1, 0xed, 0xef, 0xa9, 0xe2, 0x2b, 0x72, 0x41, 0x3e, 0xb1, 0x7d, 0xd5, 0x94,
797 0xd7, 0x3a, 0x1b, 0xb9, 0x09, 0x9b, 0xaf, 0xc0, 0x34, 0x13, 0xae, 0x92, 0x8d, 0x1d, 0xfa, 0x7a,
798 0xa2, 0x0f, 0x5c, 0x1c, 0xcb, 0xfe, 0xf6, 0xf7, 0xc8, 0x74, 0x6d, 0x4c, 0x31, 0x28, 0xee, 0xa3,
799 0x6f, 0x30, 0x79, 0x03, 0x4e, 0x07, 0xf8, 0x68, 0x6a, 0xa2, 0x4e, 0x04, 0xe3, 0x37, 0x19, 0xe3,
800 0xb4, 0xc0, 0xb8, 0xc3, 0xa0, 0xf9, 0x12, 0x8c, 0x9f, 0x84, 0xeb, 0xdf, 0x31, 0xae, 0x0c, 0x12,
801 0x49, 0x6e, 0xc3, 0x24, 0x21, 0xa9, 0x75, 0x1d, 0xd7, 0x6e, 0x91, 0x71, 0x6f, 0x30, 0xcd, 0xbf,
802 0xff, 0x1e, 0xcd, 0x95, 0x09, 0x0c, 0x2b, 0x79, 0xa8, 0x7c, 0x1e, 0xc8, 0x5e, 0x56, 0x1d, 0xd5,
803 0x9a, 0x11, 0x0c, 0xf7, 0x98, 0x22, 0x9e, 0x7c, 0xfe, 0x13, 0x70, 0x0a, 0x7f, 0x26, 0xc3, 0x92,
804 0xa8, 0x49, 0xf4, 0x4a, 0x5a, 0xf6, 0x0f, 0x3e, 0x45, 0xd3, 0x71, 0xda, 0x23, 0x10, 0x74, 0x12,
805 0xbc, 0x78, 0x88, 0x5c, 0x17, 0x75, 0x9c, 0xaa, 0xd9, 0x0c, 0x53, 0x4f, 0x58, 0x8a, 0xc8, 0xfe,
806 0xca, 0x0f, 0x82, 0x5e, 0xbc, 0x4d, 0x91, 0x85, 0x66, 0x33, 0xbf, 0x07, 0x0f, 0x85, 0x44, 0xc5,
807 0x10, 0x9c, 0x9f, 0x65, 0x9c, 0xa7, 0x7a, 0x22, 0x03, 0xd3, 0x6e, 0x03, 0x6f, 0xf7, 0x7c, 0x39,
808 0x04, 0xe7, 0x3f, 0x64, 0x9c, 0x3a, 0xc3, 0x72, 0x97, 0x62, 0xc6, 0x3b, 0x30, 0xf5, 0x2a, 0xea,
809 0xec, 0xdb, 0x0e, 0x5b, 0xfe, 0x19, 0x82, 0xee, 0x73, 0x8c, 0x6e, 0x92, 0x01, 0xc9, 0x7a, 0x10,
810 0xe6, 0xba, 0x09, 0xc9, 0x03, 0xb3, 0x86, 0x86, 0xa0, 0xf8, 0x3c, 0xa3, 0x18, 0xc3, 0xf2, 0x18,
811 0x5a, 0x80, 0xcc, 0xa1, 0xcd, 0x66, 0xa6, 0x68, 0xf8, 0x17, 0x18, 0x3c, 0xcd, 0x31, 0x8c, 0xa2,
812 0x6d, 0xb7, 0xbb, 0x4d, 0x3c, 0x6d, 0x45, 0x53, 0x7c, 0x91, 0x53, 0x70, 0x0c, 0xa3, 0x38, 0x81,
813 0x59, 0xdf, 0xe2, 0x14, 0x8e, 0x60, 0xcf, 0xe7, 0x20, 0x6d, 0x5b, 0xcd, 0x63, 0xdb, 0x1a, 0x46,
814 0x89, 0x2f, 0x31, 0x06, 0x60, 0x10, 0x4c, 0x70, 0x0b, 0x52, 0xc3, 0x3a, 0xe2, 0xd7, 0x7f, 0xc0,
815 0xd3, 0x83, 0x7b, 0xe0, 0x36, 0x4c, 0xf2, 0x01, 0xaa, 0x61, 0x5b, 0x43, 0x50, 0xfc, 0x06, 0xa3,
816 0x98, 0x10, 0x60, 0xec, 0x31, 0x5c, 0xe4, 0xb8, 0x87, 0x68, 0x18, 0x92, 0x2f, 0xf3, 0xc7, 0x60,
817 0x10, 0x66, 0xca, 0x7d, 0x64, 0xd5, 0x8e, 0x86, 0x63, 0xf8, 0x0a, 0x37, 0x25, 0xc7, 0x60, 0x8a,
818 0x12, 0x8c, 0xb7, 0xcc, 0x8e, 0x73, 0x64, 0x36, 0x87, 0x72, 0xc7, 0x6f, 0x32, 0x8e, 0x8c, 0x07,
819 0x62, 0x16, 0xe9, 0x5a, 0x27, 0xa1, 0xf9, 0x2d, 0x6e, 0x11, 0x01, 0xc6, 0x52, 0xcf, 0x71, 0xc9,
820 0x5a, 0xd9, 0x49, 0xd8, 0xfe, 0x11, 0x4f, 0x3d, 0x8a, 0xdd, 0x14, 0x19, 0x6f, 0x41, 0xca, 0x69,
821 0xbc, 0x31, 0x14, 0xcd, 0x3f, 0xe6, 0x9e, 0x26, 0x00, 0x0c, 0xbe, 0x0b, 0x0f, 0x87, 0x4e, 0x13,
822 0x43, 0x90, 0xfd, 0x13, 0x46, 0x36, 0x13, 0x32, 0x55, 0xb0, 0x21, 0xe1, 0xa4, 0x94, 0xff, 0x94,
823 0x0f, 0x09, 0x48, 0xe2, 0xda, 0xc6, 0xef, 0x0a, 0x8e, 0x79, 0x70, 0x32, 0xab, 0xfd, 0x33, 0x6e,
824 0x35, 0x8a, 0x0d, 0x58, 0x6d, 0x17, 0x66, 0x18, 0xe3, 0xc9, 0xfc, 0xfa, 0x55, 0x3e, 0xb0, 0x52,
825 0xf4, 0x5e, 0xd0, 0xbb, 0x2f, 0xc1, 0xac, 0x67, 0x4e, 0x5e, 0x94, 0x3a, 0xd5, 0x96, 0xd9, 0x1e,
826 0x82, 0xf9, 0xb7, 0x19, 0x33, 0x1f, 0xf1, 0xbd, 0xaa, 0xd6, 0xd9, 0x34, 0xdb, 0x98, 0xfc, 0x45,
827 0xc8, 0x72, 0xf2, 0xae, 0xd5, 0x41, 0x35, 0xfb, 0xd0, 0x6a, 0xbc, 0x81, 0xea, 0x43, 0x50, 0x7f,
828 0x4d, 0x72, 0xd5, 0x9e, 0x00, 0xc7, 0xcc, 0xeb, 0xa0, 0x79, 0xb5, 0x4a, 0xb5, 0xd1, 0x6a, 0xdb,
829 0x1d, 0x37, 0x82, 0xf1, 0x9f, 0x73, 0x4f, 0x79, 0xb8, 0x75, 0x02, 0xcb, 0x97, 0x61, 0x82, 0x5c,
830 0x0e, 0x1b, 0x92, 0xbf, 0xc3, 0x88, 0xc6, 0x7d, 0x14, 0x1b, 0x38, 0x6a, 0x76, 0xab, 0x6d, 0x76,
831 0x86, 0x19, 0xff, 0xfe, 0x05, 0x1f, 0x38, 0x18, 0x84, 0x0d, 0x1c, 0xee, 0x71, 0x1b, 0xe1, 0xd9,
832 0x7e, 0x08, 0x86, 0xaf, 0xf3, 0x81, 0x83, 0x63, 0x18, 0x05, 0x2f, 0x18, 0x86, 0xa0, 0xf8, 0x97,
833 0x9c, 0x82, 0x63, 0x30, 0xc5, 0xc7, 0xfd, 0x89, 0xb6, 0x83, 0x0e, 0x1b, 0x8e, 0xdb, 0xa1, 0xa5,
834 0xf0, 0x60, 0xaa, 0xdf, 0xfd, 0x41, 0xb0, 0x08, 0x33, 0x04, 0x28, 0x1e, 0x89, 0xd8, 0x12, 0x2a,
835 0x79, 0x53, 0x8a, 0x56, 0xec, 0xf7, 0xf8, 0x48, 0x24, 0xc0, 0xb0, 0x6e, 0x42, 0x85, 0x88, 0xcd,
836 0x5e, 0xc3, 0xef, 0x07, 0x43, 0xd0, 0x7d, 0x43, 0x52, 0x6e, 0x87, 0x63, 0x31, 0xa7, 0x50, 0xff,
837 0x74, 0xad, 0x57, 0xd0, 0xf1, 0x50, 0xd1, 0xf9, 0xaf, 0xa4, 0xfa, 0x67, 0x8f, 0x22, 0xe9, 0x18,
838 0x32, 0x29, 0xd5, 0x53, 0x7a, 0xd4, 0x29, 0xa0, 0xec, 0x5f, 0x7c, 0x8f, 0x3d, 0x6f, 0xb0, 0x9c,
839 0xca, 0x6f, 0xe0, 0x20, 0x0f, 0x16, 0x3d, 0xd1, 0x64, 0x9f, 0x7a, 0xcf, 0x8b, 0xf3, 0x40, 0xcd,
840 0x93, 0x5f, 0x83, 0xf1, 0x40, 0xc1, 0x13, 0x4d, 0xf5, 0x97, 0x18, 0x55, 0x46, 0xac, 0x77, 0xf2,
841 0x57, 0x21, 0x8e, 0x8b, 0x97, 0x68, 0xf8, 0x5f, 0x66, 0x70, 0x22, 0x9e, 0x7f, 0x06, 0x92, 0xbc,
842 0x68, 0x89, 0x86, 0xfe, 0x22, 0x83, 0x7a, 0x10, 0x0c, 0xe7, 0x05, 0x4b, 0x34, 0xfc, 0xaf, 0x70,
843 0x38, 0x87, 0x60, 0xf8, 0xf0, 0x26, 0x7c, 0xfb, 0xaf, 0xc5, 0xd9, 0xa4, 0xc3, 0x6d, 0x77, 0x0b,
844 0xc6, 0x58, 0xa5, 0x12, 0x8d, 0xfe, 0x25, 0x76, 0x73, 0x8e, 0xc8, 0x5f, 0x87, 0xc4, 0x90, 0x06,
845 0xff, 0x1b, 0x0c, 0x4a, 0xe5, 0xf3, 0x25, 0x48, 0x0b, 0xd5, 0x49, 0x34, 0xfc, 0x6f, 0x32, 0xb8,
846 0x88, 0xc2, 0xaa, 0xb3, 0xea, 0x24, 0x9a, 0xe0, 0x6f, 0x71, 0xd5, 0x19, 0x02, 0x9b, 0x8d, 0x17,
847 0x26, 0xd1, 0xe8, 0xbf, 0xcd, 0xad, 0xce, 0x21, 0xf9, 0xe7, 0x20, 0xe5, 0x4d, 0x36, 0xd1, 0xf8,
848 0xbf, 0xc3, 0xf0, 0x3e, 0x06, 0x5b, 0x40, 0x98, 0xec, 0xa2, 0x29, 0xfe, 0x2e, 0xb7, 0x80, 0x80,
849 0xc2, 0x69, 0x24, 0x17, 0x30, 0xd1, 0x4c, 0xbf, 0xcc, 0xd3, 0x48, 0xaa, 0x5f, 0xb0, 0x37, 0xc9,
850 0x98, 0x1f, 0x4d, 0xf1, 0xf7, 0xb8, 0x37, 0x89, 0x3c, 0x56, 0x43, 0xae, 0x08, 0xa2, 0x39, 0xfe,
851 0x01, 0x57, 0x43, 0x2a, 0x08, 0xf2, 0xdb, 0xa0, 0xf7, 0x56, 0x03, 0xd1, 0x7c, 0x9f, 0x61, 0x7c,
852 0x53, 0x3d, 0xc5, 0x40, 0xfe, 0x05, 0x98, 0x09, 0xaf, 0x04, 0xa2, 0x59, 0x7f, 0xe5, 0x3d, 0xe9,
853 0xdd, 0x4d, 0x2c, 0x04, 0xf2, 0xbb, 0xfe, 0x94, 0x22, 0x56, 0x01, 0xd1, 0xb4, 0x9f, 0x7d, 0x2f,
854 0x38, 0x70, 0x8b, 0x45, 0x40, 0xbe, 0x00, 0xe0, 0x4f, 0xc0, 0xd1, 0x5c, 0x9f, 0x63, 0x5c, 0x02,
855 0x08, 0xa7, 0x06, 0x9b, 0x7f, 0xa3, 0xf1, 0x9f, 0xe7, 0xa9, 0xc1, 0x10, 0x38, 0x35, 0xf8, 0xd4,
856 0x1b, 0x8d, 0xfe, 0x02, 0x4f, 0x0d, 0x0e, 0xc1, 0x91, 0x2d, 0xcc, 0x6e, 0xd1, 0x0c, 0x5f, 0xe2,
857 0x91, 0x2d, 0xa0, 0xf2, 0x15, 0x98, 0xea, 0x99, 0x10, 0xa3, 0xa9, 0x7e, 0x95, 0x51, 0x69, 0xf2,
858 0x7c, 0x28, 0x4e, 0x5e, 0x6c, 0x32, 0x8c, 0x66, 0xfb, 0x35, 0x69, 0xf2, 0x62, 0x73, 0x61, 0xfe,
859 0x16, 0x24, 0xad, 0x6e, 0xb3, 0x89, 0x93, 0x47, 0x1f, 0x7c, 0x72, 0x2f, 0xfb, 0xdf, 0x7f, 0xcc,
860 0xac, 0xc3, 0x01, 0xf9, 0xab, 0x90, 0x40, 0xad, 0x7d, 0x54, 0x8f, 0x42, 0xfe, 0x8f, 0x1f, 0xf3,
861 0x01, 0x13, 0x4b, 0xe7, 0x9f, 0x03, 0xa0, 0x4b, 0x23, 0x64, 0xdb, 0x2f, 0x02, 0xfb, 0x3f, 0x7f,
862 0xcc, 0xce, 0xd4, 0xf8, 0x10, 0x9f, 0x80, 0x9e, 0xd0, 0x19, 0x4c, 0xf0, 0x83, 0x20, 0x01, 0xf1,
863 0xc8, 0x4d, 0x18, 0x7b, 0xd9, 0xb1, 0x2d, 0xd7, 0x3c, 0x8c, 0x42, 0xff, 0x2f, 0x86, 0xe6, 0xf2,
864 0xd8, 0x60, 0x2d, 0xbb, 0x83, 0x5c, 0xf3, 0xd0, 0x89, 0xc2, 0xfe, 0x6f, 0x86, 0xf5, 0x00, 0x18,
865 0x5c, 0x33, 0x1d, 0x77, 0x98, 0xe7, 0xfe, 0x3f, 0x1c, 0xcc, 0x01, 0x58, 0x69, 0xfc, 0xf9, 0x15,
866 0x74, 0x1c, 0x85, 0xfd, 0x21, 0x57, 0x9a, 0xc9, 0xe7, 0x9f, 0x81, 0x14, 0xfe, 0x48, 0x0f, 0xca,
867 0x45, 0x80, 0xff, 0x2f, 0x03, 0xfb, 0x08, 0x7c, 0x67, 0xc7, 0xad, 0xbb, 0x8d, 0x68, 0x63, 0xff,
868 0x11, 0xf3, 0x34, 0x97, 0xcf, 0x17, 0x20, 0xed, 0xb8, 0xf5, 0x7a, 0x97, 0xd5, 0xa7, 0x11, 0xf0,
869 0xff, 0xf7, 0x63, 0x6f, 0xc9, 0xc2, 0xc3, 0x60, 0x6f, 0xbf, 0xf6, 0x8a, 0xdb, 0xb6, 0xc9, 0x36,
870 0x47, 0x14, 0xc3, 0x7b, 0x8c, 0x41, 0x80, 0x14, 0xcb, 0xe1, 0xcb, 0xb7, 0x70, 0xdb, 0xbe, 0x6d,
871 0xd3, 0x85, 0xdb, 0x4f, 0xe6, 0xa2, 0x57, 0x60, 0xe1, 0xbf, 0x35, 0xe1, 0x7a, 0x5f, 0x31, 0x3c,
872 0x15, 0x5f, 0xac, 0xd9, 0xad, 0x7d, 0xdb, 0xb9, 0xb8, 0x6f, 0xbb, 0x47, 0x17, 0xdd, 0x23, 0x84,
873 0xdb, 0xd8, 0x92, 0x6d, 0x1c, 0x7f, 0x9e, 0x3d, 0xd9, 0x3a, 0x2f, 0xd9, 0xc5, 0xaf, 0x34, 0xf0,
874 0xa3, 0x55, 0xc8, 0x46, 0x8a, 0x7e, 0x06, 0x46, 0xc9, 0xc3, 0x5e, 0x26, 0x9b, 0x95, 0x4a, 0x31,
875 0x7e, 0xef, 0x9d, 0xf9, 0x11, 0x83, 0xb5, 0x79, 0xbd, 0xcb, 0x64, 0xa5, 0x3b, 0x16, 0xe8, 0x5d,
876 0xf6, 0x7a, 0xaf, 0xd0, 0xc5, 0xee, 0x40, 0xef, 0x15, 0xaf, 0x77, 0x85, 0x2c, 0x7b, 0xab, 0x81,
877 0xde, 0x15, 0xaf, 0xf7, 0x2a, 0xd9, 0xda, 0x19, 0x0f, 0xf4, 0x5e, 0xf5, 0x7a, 0xaf, 0x91, 0x0d,
878 0x9d, 0x78, 0xa0, 0xf7, 0x9a, 0xd7, 0x7b, 0x9d, 0xec, 0xe5, 0x4c, 0x05, 0x7a, 0xaf, 0x7b, 0xbd,
879 0x37, 0xc8, 0x1e, 0x8e, 0x1e, 0xe8, 0xbd, 0xe1, 0xf5, 0xde, 0x24, 0x27, 0xaf, 0xc6, 0x02, 0xbd,
880 0x37, 0xf5, 0x39, 0x18, 0xa3, 0x4f, 0x7e, 0x89, 0x6c, 0xf8, 0x4f, 0xb2, 0x6e, 0xde, 0xe8, 0xf7,
881 0x5f, 0x26, 0xa7, 0xac, 0x46, 0x83, 0xfd, 0x97, 0xfd, 0xfe, 0x65, 0xf2, 0x85, 0x0f, 0x2d, 0xd8,
882 0xbf, 0xec, 0xf7, 0x5f, 0xc9, 0x8e, 0x93, 0x93, 0x66, 0x81, 0xfe, 0x2b, 0x7e, 0xff, 0x4a, 0x76,
883 0x02, 0x67, 0x4c, 0xb0, 0x7f, 0xc5, 0xef, 0xbf, 0x9a, 0x9d, 0x3c, 0xab, 0x2c, 0x64, 0x82, 0xfd,
884 0x57, 0x73, 0xbf, 0x40, 0xdc, 0x6b, 0xf9, 0xee, 0x9d, 0x09, 0xba, 0xd7, 0x73, 0xec, 0x4c, 0xd0,
885 0xb1, 0x9e, 0x4b, 0x67, 0x82, 0x2e, 0xf5, 0x9c, 0x39, 0x13, 0x74, 0xa6, 0xe7, 0xc6, 0x99, 0xa0,
886 0x1b, 0x3d, 0x07, 0xce, 0x04, 0x1d, 0xe8, 0xb9, 0x6e, 0x26, 0xe8, 0x3a, 0xcf, 0x69, 0x33, 0x41,
887 0xa7, 0x79, 0xee, 0x9a, 0x09, 0xba, 0xcb, 0x73, 0x54, 0x56, 0x72, 0x94, 0xef, 0xa2, 0xac, 0xe4,
888 0x22, 0xdf, 0x39, 0x59, 0xc9, 0x39, 0xbe, 0x5b, 0xb2, 0x92, 0x5b, 0x7c, 0x87, 0x64, 0x25, 0x87,
889 0xf8, 0xae, 0xc8, 0x4a, 0xae, 0xf0, 0x9d, 0xc0, 0x72, 0xcc, 0x40, 0xed, 0x90, 0x1c, 0x53, 0x07,
890 0xe6, 0x98, 0x3a, 0x30, 0xc7, 0xd4, 0x81, 0x39, 0xa6, 0x0e, 0xcc, 0x31, 0x75, 0x60, 0x8e, 0xa9,
891 0x03, 0x73, 0x4c, 0x1d, 0x98, 0x63, 0xea, 0xc0, 0x1c, 0x53, 0x07, 0xe7, 0x98, 0x1a, 0x91, 0x63,
892 0x6a, 0x44, 0x8e, 0xa9, 0x11, 0x39, 0xa6, 0x46, 0xe4, 0x98, 0x1a, 0x91, 0x63, 0x6a, 0xdf, 0x1c,
893 0xf3, 0xdd, 0x3b, 0x13, 0x74, 0x6f, 0x68, 0x8e, 0xa9, 0x7d, 0x72, 0x4c, 0xed, 0x93, 0x63, 0x6a,
894 0x9f, 0x1c, 0x53, 0xfb, 0xe4, 0x98, 0xda, 0x27, 0xc7, 0xd4, 0x3e, 0x39, 0xa6, 0xf6, 0xc9, 0x31,
895 0xb5, 0x5f, 0x8e, 0xa9, 0x7d, 0x73, 0x4c, 0xed, 0x9b, 0x63, 0x6a, 0xdf, 0x1c, 0x53, 0xfb, 0xe6,
896 0x98, 0xda, 0x37, 0xc7, 0x54, 0x31, 0xc7, 0xfe, 0xb5, 0x0a, 0x3a, 0xcd, 0xb1, 0x6d, 0x72, 0x64,
897 0x8c, 0xb9, 0x62, 0x4e, 0xca, 0xb4, 0x51, 0xec, 0x3a, 0xcd, 0x77, 0xc9, 0x9c, 0x94, 0x6b, 0xc1,
898 0xfe, 0x65, 0xaf, 0x9f, 0x67, 0x5b, 0xb0, 0xff, 0x8a, 0xd7, 0xcf, 0xf3, 0x2d, 0xd8, 0xbf, 0xe2,
899 0xf5, 0xf3, 0x8c, 0x0b, 0xf6, 0x5f, 0xf5, 0xfa, 0x79, 0xce, 0x05, 0xfb, 0xaf, 0x79, 0xfd, 0x3c,
900 0xeb, 0x82, 0xfd, 0xd7, 0xbd, 0x7e, 0x9e, 0x77, 0xc1, 0xfe, 0x1b, 0x5e, 0x3f, 0xcf, 0xbc, 0x60,
901 0xff, 0x4d, 0xfd, 0xac, 0x9c, 0x7b, 0x5c, 0xc0, 0x73, 0xed, 0x59, 0x39, 0xfb, 0x24, 0x89, 0xcb,
902 0xbe, 0x04, 0xcf, 0x3f, 0x49, 0x62, 0xd9, 0x97, 0xe0, 0x19, 0x28, 0x49, 0x5c, 0xc9, 0x7d, 0x9a,
903 0xb8, 0xcf, 0x92, 0xdd, 0x37, 0x2b, 0xb9, 0x2f, 0x26, 0xb8, 0x6e, 0x56, 0x72, 0x5d, 0x4c, 0x70,
904 0xdb, 0xac, 0xe4, 0xb6, 0x98, 0xe0, 0xb2, 0x59, 0xc9, 0x65, 0x31, 0xc1, 0x5d, 0xb3, 0x92, 0xbb,
905 0x62, 0x82, 0xab, 0x66, 0x25, 0x57, 0xc5, 0x04, 0x37, 0xcd, 0x4a, 0x6e, 0x8a, 0x09, 0x2e, 0x9a,
906 0x95, 0x5c, 0x14, 0x13, 0xdc, 0x33, 0x2b, 0xb9, 0x27, 0x26, 0xb8, 0xe6, 0x8c, 0xec, 0x9a, 0x98,
907 0xe8, 0x96, 0x33, 0xb2, 0x5b, 0x62, 0xa2, 0x4b, 0xce, 0xc8, 0x2e, 0x89, 0x89, 0xee, 0x38, 0x23,
908 0xbb, 0x23, 0x26, 0xba, 0xe2, 0x8f, 0x63, 0xbc, 0x22, 0xdc, 0x71, 0x3b, 0xdd, 0x9a, 0xfb, 0xbe,
909 0x2a, 0xc2, 0x4b, 0x81, 0xf2, 0x21, 0xbd, 0xac, 0x2f, 0x91, 0x82, 0x55, 0xac, 0x38, 0xa5, 0x19,
910 0xec, 0x52, 0xa0, 0xb0, 0x10, 0x10, 0x56, 0x38, 0x62, 0xe5, 0x7d, 0xd5, 0x86, 0x97, 0x02, 0x65,
911 0x46, 0xb4, 0x7e, 0x37, 0x3e, 0xf4, 0x8a, 0xed, 0xed, 0x18, 0xaf, 0xd8, 0x98, 0xf9, 0x4f, 0x5a,
912 0xb1, 0x2d, 0x46, 0x9b, 0xdc, 0x33, 0xf6, 0x62, 0xb4, 0xb1, 0x7b, 0x66, 0x9d, 0x61, 0x2b, 0xb8,
913 0xc5, 0x68, 0xd3, 0x7a, 0x46, 0xfd, 0x60, 0xeb, 0x2d, 0x16, 0xc1, 0x06, 0x6a, 0x87, 0x44, 0xf0,
914 0x49, 0xeb, 0xad, 0x4b, 0x81, 0xa1, 0xe4, 0xa4, 0x11, 0xac, 0x9e, 0x38, 0x82, 0x4f, 0x5a, 0x79,
915 0x5d, 0x0a, 0x0c, 0x2f, 0x27, 0x8e, 0xe0, 0x0f, 0xa1, 0x1e, 0x62, 0x11, 0xec, 0x9b, 0xff, 0xa4,
916 0xf5, 0xd0, 0x62, 0xb4, 0xc9, 0x43, 0x23, 0x58, 0x3d, 0x41, 0x04, 0x0f, 0x53, 0x1f, 0x2d, 0x46,
917 0x9b, 0x36, 0x3c, 0x82, 0xdf, 0x77, 0x35, 0xf3, 0x45, 0x05, 0xa6, 0x2a, 0x8d, 0x7a, 0xb9, 0xb5,
918 0x8f, 0xea, 0x75, 0x54, 0x67, 0x76, 0xbc, 0x14, 0x18, 0x09, 0xfa, 0xb8, 0xfa, 0x5b, 0xef, 0xcc,
919 0xfb, 0x16, 0xbe, 0x0a, 0x49, 0x6a, 0xd3, 0x4b, 0x97, 0xb2, 0xf7, 0x94, 0x88, 0x11, 0xce, 0x13,
920 0xd5, 0xcf, 0x71, 0xd8, 0xe5, 0x4b, 0xd9, 0xff, 0xa4, 0x08, 0xa3, 0x9c, 0xd7, 0x9c, 0xfb, 0x65,
921 0xa2, 0xa1, 0xf5, 0xbe, 0x35, 0xbc, 0x38, 0x94, 0x86, 0x82, 0x6e, 0x8f, 0xf4, 0xe8, 0x26, 0x68,
922 0xd5, 0x85, 0xc9, 0x4a, 0xa3, 0x5e, 0x21, 0x3f, 0x35, 0x30, 0x8c, 0x4a, 0x54, 0x46, 0x1a, 0x0f,
923 0x2e, 0x05, 0xc2, 0x52, 0x44, 0x78, 0x21, 0x1d, 0x1c, 0x23, 0x72, 0x0d, 0x7c, 0x5b, 0x2b, 0x70,
924 0xdb, 0xc5, 0x7e, 0xb7, 0xf5, 0x47, 0x76, 0xef, 0x86, 0x8b, 0xfd, 0x6e, 0xe8, 0xe7, 0x90, 0x77,
925 0xab, 0xd7, 0xf9, 0xe4, 0x4c, 0x0f, 0x6e, 0xe9, 0x67, 0x20, 0xb6, 0x4e, 0xcf, 0x95, 0x67, 0x8a,
926 0x19, 0xac, 0xd4, 0xb7, 0xdf, 0x99, 0x8f, 0xef, 0x75, 0x1b, 0x75, 0x23, 0xb6, 0x5e, 0xd7, 0xef,
927 0x40, 0xe2, 0x13, 0xec, 0x0b, 0xaf, 0x58, 0x60, 0x85, 0x09, 0x3c, 0x15, 0xb1, 0xc4, 0x44, 0xa8,
928 0x97, 0xf6, 0x1a, 0x96, 0x7b, 0x79, 0xf9, 0x86, 0x41, 0x29, 0x72, 0x7f, 0x06, 0x80, 0xde, 0x73,
929 0xd5, 0x74, 0x8e, 0xf4, 0x0a, 0x67, 0xa6, 0xb7, 0xbe, 0xf1, 0xed, 0x77, 0xe6, 0x57, 0x86, 0x61,
930 0x7d, 0xba, 0x6e, 0x3a, 0x47, 0x4f, 0xbb, 0xc7, 0x6d, 0xb4, 0x54, 0x3c, 0x76, 0x91, 0xc3, 0xd9,
931 0xdb, 0x7c, 0xd6, 0x63, 0xcf, 0x95, 0x15, 0x9e, 0x2b, 0x19, 0x78, 0xa6, 0xb5, 0xe0, 0x33, 0x5d,
932 0x7a, 0xd0, 0xe7, 0x79, 0x9d, 0x4f, 0x12, 0x92, 0x25, 0xd5, 0x28, 0x4b, 0xaa, 0xef, 0xd7, 0x92,
933 0x6d, 0x3e, 0x3e, 0x4a, 0xcf, 0xaa, 0x0e, 0x7a, 0x56, 0xf5, 0xfd, 0x3c, 0xeb, 0xff, 0xa7, 0xd9,
934 0xea, 0xe5, 0xd3, 0x9e, 0x45, 0xcf, 0xb4, 0xfe, 0xe9, 0x5a, 0x0b, 0xfa, 0x40, 0xab, 0x80, 0x7c,
935 0xfc, 0xde, 0x5b, 0xf3, 0x4a, 0xee, 0x8b, 0x31, 0xfe, 0xe4, 0x34, 0x91, 0x1e, 0xec, 0xc9, 0xff,
936 0xb4, 0xd4, 0x54, 0x1f, 0x86, 0x85, 0xbe, 0xa0, 0xc0, 0x4c, 0xcf, 0x48, 0x4e, 0xcd, 0xf4, 0xc1,
937 0x0e, 0xe7, 0xd6, 0x49, 0x87, 0x73, 0xa6, 0xe0, 0xef, 0x28, 0x70, 0x4a, 0x1a, 0x5e, 0xa9, 0x7a,
938 0x17, 0x25, 0xf5, 0x1e, 0xea, 0xbd, 0x13, 0x11, 0x14, 0xb4, 0x13, 0xdd, 0x2b, 0x01, 0x04, 0x66,
939 0xcf, 0xef, 0x2b, 0x92, 0xdf, 0xcf, 0x78, 0x80, 0x10, 0x73, 0xf1, 0x08, 0x60, 0x6a, 0xdb, 0x10,
940 0xdf, 0xed, 0x20, 0xa4, 0xcf, 0x41, 0x6c, 0xab, 0xc3, 0x34, 0x9c, 0xa0, 0xf8, 0xad, 0x4e, 0xb1,
941 0x63, 0x5a, 0xb5, 0x23, 0x23, 0xb6, 0xd5, 0xd1, 0xcf, 0x81, 0x5a, 0x60, 0x5f, 0xb6, 0x4f, 0x2f,
942 0x4f, 0x52, 0x81, 0x82, 0x55, 0x67, 0x12, 0xb8, 0x4f, 0x9f, 0x83, 0xf8, 0x06, 0x32, 0x0f, 0x98,
943 0x12, 0x40, 0x65, 0x70, 0x8b, 0x41, 0xda, 0xd9, 0x0d, 0x5f, 0x84, 0x24, 0x27, 0xd6, 0xcf, 0x63,
944 0xc4, 0x81, 0xcb, 0x6e, 0xcb, 0x10, 0x58, 0x1d, 0x36, 0x73, 0x91, 0x5e, 0xfd, 0x02, 0x24, 0x8c,
945 0xc6, 0xe1, 0x91, 0xcb, 0x6e, 0xde, 0x2b, 0x46, 0xbb, 0x73, 0x77, 0x21, 0xe5, 0x69, 0xf4, 0x01,
946 0x53, 0xaf, 0xd2, 0x47, 0xd3, 0x67, 0xc5, 0xf9, 0x84, 0xaf, 0x5b, 0xd2, 0x26, 0xfd, 0x2c, 0x24,
947 0x77, 0xdc, 0x8e, 0x3f, 0xe8, 0xf3, 0x8a, 0xd4, 0x6b, 0xcd, 0xfd, 0x82, 0x02, 0xc9, 0x55, 0x84,
948 0xda, 0xc4, 0xe0, 0x8f, 0x43, 0x7c, 0xd5, 0x7e, 0xcd, 0x62, 0x0a, 0x4e, 0x31, 0x8b, 0xe2, 0x6e,
949 0x66, 0x53, 0xd2, 0xad, 0x3f, 0x2e, 0xda, 0x7d, 0xda, 0xb3, 0xbb, 0x20, 0x47, 0x6c, 0x9f, 0x0b,
950 0xd8, 0x9e, 0x39, 0x10, 0x0b, 0xf5, 0xd8, 0xff, 0x3a, 0xa4, 0x85, 0xbb, 0xe8, 0x0b, 0x4c, 0x8d,
951 0x98, 0x0c, 0x14, 0x6d, 0x85, 0x25, 0x72, 0x08, 0xc6, 0x03, 0x37, 0xc6, 0x50, 0xc1, 0xc4, 0x7d,
952 0xa0, 0xc4, 0xcc, 0x8b, 0x41, 0x33, 0x87, 0x8b, 0x32, 0x53, 0x5f, 0xa2, 0x36, 0x22, 0xe6, 0x3e,
953 0x4f, 0x83, 0xb3, 0xbf, 0x13, 0xf1, 0xe7, 0x5c, 0x02, 0xd4, 0x4a, 0xa3, 0x99, 0x7b, 0x06, 0x80,
954 0xa6, 0x7c, 0xd9, 0xea, 0xb6, 0xa4, 0xac, 0x9b, 0xe0, 0x06, 0xde, 0x3d, 0x42, 0xbb, 0xc8, 0x21,
955 0x22, 0xc1, 0x7a, 0x0a, 0x0f, 0x30, 0x40, 0x53, 0x8c, 0xe0, 0x9f, 0x8c, 0xc4, 0x87, 0x56, 0x62,
956 0x58, 0x34, 0x4b, 0x45, 0xef, 0x22, 0xb7, 0x60, 0xd9, 0xee, 0x11, 0xea, 0x48, 0x88, 0x65, 0xfd,
957 0x4a, 0x20, 0x61, 0x27, 0x96, 0x1f, 0xf1, 0x10, 0x7d, 0x41, 0x57, 0x72, 0x5f, 0x25, 0x0a, 0xe2,
958 0x52, 0xa0, 0xe7, 0x01, 0xd5, 0x21, 0x1e, 0x50, 0xbf, 0x16, 0xa8, 0xdf, 0x06, 0xa8, 0x29, 0xbd,
959 0x5a, 0xde, 0x0c, 0xbc, 0xe7, 0x0c, 0x56, 0x36, 0xf8, 0x8e, 0xc9, 0x6d, 0xca, 0x55, 0x7e, 0x32,
960 0x52, 0xe5, 0x3e, 0xd5, 0xed, 0x49, 0x6d, 0xaa, 0x0e, 0x6b, 0xd3, 0x6f, 0x78, 0x15, 0x07, 0xfd,
961 0x45, 0x13, 0xf2, 0x5b, 0x40, 0xfa, 0x53, 0x91, 0xbe, 0xcf, 0x2b, 0x25, 0x4f, 0xd5, 0x95, 0x61,
962 0xdd, 0x9f, 0x8f, 0x15, 0x8b, 0x9e, 0xba, 0xd7, 0x4f, 0x10, 0x02, 0xf9, 0x58, 0xa9, 0xe4, 0x0d,
963 0xdb, 0xc9, 0x4f, 0xbf, 0x35, 0xaf, 0x7c, 0xe5, 0xad, 0xf9, 0x91, 0xdc, 0x6f, 0x2a, 0x30, 0xc5,
964 0x24, 0x85, 0xc0, 0x7d, 0x5a, 0x52, 0xfe, 0x34, 0x1f, 0x33, 0xc2, 0x2c, 0xf0, 0x13, 0x0b, 0xde,
965 0x6f, 0x2a, 0x90, 0xed, 0xd1, 0x95, 0xdb, 0xfb, 0xd2, 0x50, 0x2a, 0xe7, 0x95, 0xf2, 0x4f, 0xdf,
966 0xe6, 0x77, 0x21, 0xb1, 0xdb, 0x68, 0xa1, 0x0e, 0x9e, 0x09, 0xf0, 0x07, 0xaa, 0x32, 0xdf, 0xcc,
967 0xa1, 0x4d, 0xbc, 0x8f, 0x2a, 0x17, 0xe8, 0x5b, 0xd6, 0xb3, 0x10, 0x5f, 0x35, 0x5d, 0x93, 0x68,
968 0x90, 0xf1, 0xc6, 0x57, 0xd3, 0x35, 0x73, 0x57, 0x20, 0xb3, 0x79, 0x4c, 0x0e, 0x22, 0xd5, 0xc9,
969 0x19, 0x94, 0x60, 0xf5, 0xc7, 0xeb, 0xd5, 0xcb, 0x8b, 0x89, 0x64, 0x5d, 0xbb, 0xa7, 0xe4, 0xe3,
970 0x44, 0x9f, 0x57, 0x61, 0x62, 0x0b, 0xab, 0x4d, 0x70, 0x04, 0x76, 0x16, 0x94, 0xcd, 0x60, 0x21,
971 0x24, 0xb2, 0x1a, 0xca, 0xa6, 0x54, 0x3e, 0xaa, 0x9e, 0x79, 0xa4, 0xb2, 0x4d, 0xf5, 0xca, 0xb6,
972 0xc5, 0x78, 0x72, 0x42, 0x9b, 0x5a, 0x8c, 0x27, 0x41, 0x1b, 0x67, 0xf7, 0xfd, 0x0f, 0x2a, 0x68,
973 0xb4, 0xd4, 0x59, 0x45, 0x07, 0x0d, 0xab, 0xe1, 0xf6, 0xd6, 0xab, 0x9e, 0xc6, 0xfa, 0x73, 0x90,
974 0xc2, 0x26, 0x5d, 0x63, 0x3f, 0x09, 0x88, 0x4d, 0x7f, 0x8e, 0x95, 0x28, 0x12, 0x05, 0x6b, 0x20,
975 0xa1, 0xe3, 0x63, 0xf4, 0x35, 0x50, 0x2b, 0x95, 0x4d, 0x36, 0xb9, 0xad, 0x0c, 0x84, 0xb2, 0xc3,
976 0x3e, 0xec, 0x8a, 0xb5, 0x39, 0x87, 0x06, 0x26, 0xd0, 0x57, 0x20, 0x56, 0xd9, 0x64, 0x05, 0xef,
977 0xf9, 0x61, 0x68, 0x8c, 0x58, 0x65, 0x73, 0xf6, 0xdf, 0x28, 0x30, 0x1e, 0x68, 0xd5, 0x73, 0x90,
978 0xa1, 0x0d, 0xc2, 0xe3, 0x8e, 0x1a, 0x81, 0x36, 0xae, 0x73, 0xec, 0x7d, 0xea, 0x3c, 0x5b, 0x80,
979 0x49, 0xa9, 0x5d, 0x5f, 0x02, 0x5d, 0x6c, 0x62, 0x4a, 0xd0, 0x9f, 0x23, 0x0b, 0xe9, 0xc9, 0x3d,
980 0x0a, 0xe0, 0xdb, 0xd5, 0xfb, 0x15, 0xad, 0x4a, 0x79, 0x67, 0xb7, 0xbc, 0xaa, 0x29, 0xb9, 0xaf,
981 0x2b, 0x90, 0x66, 0x65, 0x6b, 0xcd, 0x6e, 0x23, 0xbd, 0x08, 0x4a, 0x81, 0x45, 0xd0, 0x83, 0xe9,
982 0xad, 0x14, 0xf4, 0x8b, 0xa0, 0x14, 0x87, 0x77, 0xb5, 0x52, 0xd4, 0x97, 0x41, 0x29, 0x31, 0x07,
983 0x0f, 0xe7, 0x19, 0xa5, 0x94, 0xfb, 0x23, 0x15, 0xa6, 0xc5, 0x32, 0x9a, 0x8f, 0x27, 0xe7, 0x82,
984 0xef, 0x4d, 0xf9, 0xd4, 0xe5, 0xe5, 0x2b, 0x2b, 0x4b, 0xf8, 0x1f, 0x2f, 0x24, 0x73, 0xc1, 0x57,
985 0xa8, 0x3c, 0x78, 0x22, 0x97, 0xfb, 0x9d, 0x13, 0xc9, 0xc7, 0x05, 0x86, 0x9e, 0x73, 0x22, 0x81,
986 0xde, 0x9e, 0x73, 0x22, 0x81, 0xde, 0x9e, 0x73, 0x22, 0x81, 0xde, 0x9e, 0xbd, 0x80, 0x40, 0x6f,
987 0xcf, 0x39, 0x91, 0x40, 0x6f, 0xcf, 0x39, 0x91, 0x40, 0x6f, 0xef, 0x39, 0x11, 0xd6, 0xdd, 0xf7,
988 0x9c, 0x48, 0xb0, 0xbf, 0xf7, 0x9c, 0x48, 0xb0, 0xbf, 0xf7, 0x9c, 0x48, 0x3e, 0xee, 0x76, 0xba,
989 0xa8, 0xff, 0xae, 0x43, 0x10, 0x3f, 0xe8, 0x25, 0xd0, 0x1f, 0x81, 0xb7, 0x60, 0x92, 0x2e, 0x48,
990 0x94, 0x6c, 0xcb, 0x35, 0x1b, 0x16, 0xea, 0xe8, 0x1f, 0x85, 0x0c, 0x6d, 0xa2, 0xaf, 0x39, 0x61,
991 0xaf, 0x81, 0xb4, 0x9f, 0x8d, 0xb7, 0x01, 0xe9, 0xdc, 0x1f, 0xc7, 0x61, 0x86, 0x36, 0x54, 0xcc,
992 0x16, 0x0a, 0x9c, 0x32, 0xba, 0x20, 0xed, 0x29, 0x4d, 0x60, 0xf8, 0xfd, 0x77, 0xe6, 0x69, 0x6b,
993 0xc1, 0x8b, 0xa6, 0x0b, 0xd2, 0xee, 0x52, 0x50, 0xce, 0x9f, 0x80, 0x2e, 0x48, 0x27, 0x8f, 0x82,
994 0x72, 0xde, 0x7c, 0xe3, 0xc9, 0xf1, 0x33, 0x48, 0x41, 0xb9, 0x55, 0x2f, 0xca, 0x2e, 0x48, 0xa7,
995 0x91, 0x82, 0x72, 0x65, 0x2f, 0xde, 0x2e, 0x48, 0x7b, 0x4f, 0x41, 0xb9, 0x35, 0x2f, 0xf2, 0x2e,
996 0x48, 0xbb, 0x50, 0x41, 0xb9, 0xdb, 0x5e, 0x0c, 0x5e, 0x90, 0xce, 0x2a, 0x05, 0xe5, 0x9e, 0xf7,
997 0xa2, 0xf1, 0x82, 0x74, 0x6a, 0x29, 0x28, 0xb7, 0xee, 0xc5, 0xe5, 0x82, 0x7c, 0x7e, 0x29, 0x28,
998 0x78, 0xc7, 0x8f, 0xd0, 0x05, 0xf9, 0x24, 0x53, 0x50, 0xf2, 0x63, 0x7e, 0xac, 0x2e, 0xc8, 0x67,
999 0x9a, 0x82, 0x92, 0x1b, 0x7e, 0xd4, 0x2e, 0xc8, 0x7b, 0x65, 0x41, 0xc9, 0x4d, 0x3f, 0x7e, 0x17,
1000 0xe4, 0x5d, 0xb3, 0xa0, 0x64, 0xc5, 0x8f, 0xe4, 0x05, 0x79, 0xff, 0x2c, 0x28, 0xb9, 0xe5, 0x2f,
1001 0xa2, 0xff, 0xbe, 0x14, 0x7e, 0xc2, 0x29, 0xa8, 0x9c, 0x14, 0x7e, 0x10, 0x12, 0x7a, 0xd2, 0x40,
1002 0x26, 0xc8, 0xf8, 0x61, 0x97, 0x93, 0xc2, 0x0e, 0x42, 0x42, 0x2e, 0x27, 0x85, 0x1c, 0x84, 0x84,
1003 0x5b, 0x4e, 0x0a, 0x37, 0x08, 0x09, 0xb5, 0x9c, 0x14, 0x6a, 0x10, 0x12, 0x66, 0x39, 0x29, 0xcc,
1004 0x20, 0x24, 0xc4, 0x72, 0x52, 0x88, 0x41, 0x48, 0x78, 0xe5, 0xa4, 0xf0, 0x82, 0x90, 0xd0, 0x3a,
1005 0x2f, 0x87, 0x16, 0x84, 0x85, 0xd5, 0x79, 0x39, 0xac, 0x20, 0x2c, 0xa4, 0x1e, 0x93, 0x43, 0x2a,
1006 0x75, 0xff, 0x9d, 0xf9, 0x04, 0x6e, 0x12, 0xa2, 0xe9, 0xbc, 0x1c, 0x4d, 0x10, 0x16, 0x49, 0xe7,
1007 0xe5, 0x48, 0x82, 0xb0, 0x28, 0x3a, 0x2f, 0x47, 0x11, 0x84, 0x45, 0xd0, 0xdb, 0x72, 0x04, 0xf9,
1008 0x67, 0x7c, 0x72, 0xd2, 0x96, 0x62, 0x54, 0x04, 0xa9, 0x43, 0x44, 0x90, 0x3a, 0x44, 0x04, 0xa9,
1009 0x43, 0x44, 0x90, 0x3a, 0x44, 0x04, 0xa9, 0x43, 0x44, 0x90, 0x3a, 0x44, 0x04, 0xa9, 0x43, 0x44,
1010 0x90, 0x3a, 0x4c, 0x04, 0xa9, 0x43, 0x45, 0x90, 0xda, 0x2f, 0x82, 0xce, 0xcb, 0x27, 0x1e, 0x20,
1011 0x6c, 0x40, 0x3a, 0x2f, 0x6f, 0x7d, 0x46, 0x87, 0x90, 0x3a, 0x54, 0x08, 0xa9, 0xfd, 0x42, 0xe8,
1012 0xf7, 0x55, 0x98, 0x0e, 0x84, 0x10, 0xdb, 0x1f, 0xfa, 0xa0, 0x46, 0xa0, 0x6b, 0x43, 0x1c, 0xb0,
1013 0x08, 0x8b, 0xa9, 0x6b, 0x43, 0x6c, 0x52, 0x0f, 0x8a, 0xb3, 0xde, 0x51, 0xa8, 0x3c, 0xc4, 0x28,
1014 0xb4, 0xe6, 0xc5, 0xd0, 0xb5, 0x21, 0x0e, 0x5e, 0xf4, 0xc6, 0xde, 0x8d, 0x41, 0x83, 0xc0, 0xf3,
1015 0x43, 0x0d, 0x02, 0xeb, 0x43, 0x0d, 0x02, 0x77, 0x7c, 0x0f, 0xfe, 0x62, 0x0c, 0x4e, 0xf9, 0x1e,
1016 0xa4, 0x9f, 0xc8, 0x2f, 0x6b, 0xe5, 0x84, 0x2d, 0x2a, 0x9d, 0x6f, 0xdb, 0x08, 0x6e, 0x8c, 0xad,
1017 0xd7, 0xf5, 0xed, 0xe0, 0x66, 0x55, 0xfe, 0xa4, 0x1b, 0x38, 0x82, 0xc7, 0xd9, 0x62, 0xe8, 0x79,
1018 0x50, 0xd7, 0xeb, 0x0e, 0x19, 0x2d, 0xc2, 0x6e, 0x5b, 0x32, 0x70, 0xb7, 0x6e, 0xc0, 0x28, 0x11,
1019 0x77, 0x88, 0x7b, 0xdf, 0xcf, 0x8d, 0x57, 0x0d, 0xc6, 0x94, 0x7b, 0x5b, 0x81, 0xb3, 0x81, 0x50,
1020 0xfe, 0x60, 0xb6, 0x0c, 0x6e, 0x0d, 0xb5, 0x65, 0x10, 0x48, 0x10, 0x7f, 0xfb, 0xe0, 0x89, 0xde,
1021 0x9d, 0x6a, 0x31, 0x4b, 0xe4, 0xad, 0x84, 0xbf, 0x00, 0x13, 0xfe, 0x13, 0x90, 0x77, 0xb6, 0xab,
1022 0xd1, 0xab, 0x99, 0x61, 0xa9, 0x79, 0x55, 0x5a, 0x45, 0x1b, 0x08, 0xf3, 0xb2, 0x35, 0x97, 0x87,
1023 0xc9, 0x4a, 0xf0, 0x2b, 0x51, 0x51, 0x8b, 0x11, 0x49, 0x5c, 0x9a, 0xdf, 0xfb, 0xd2, 0xfc, 0x48,
1024 0xee, 0x29, 0xc8, 0x88, 0xdf, 0x7a, 0x92, 0x80, 0x29, 0x0e, 0xcc, 0xc7, 0xbf, 0x85, 0xa5, 0xff,
1025 0xbe, 0x02, 0xa7, 0x45, 0xf1, 0x17, 0x1a, 0xee, 0xd1, 0xba, 0x85, 0x6b, 0xfa, 0x67, 0x20, 0x89,
1026 0x98, 0xe3, 0xd8, 0x8f, 0xe4, 0xb0, 0xf7, 0xc8, 0x50, 0xf1, 0x25, 0xf2, 0xaf, 0xe1, 0x41, 0xa4,
1027 0x35, 0x0e, 0x7e, 0xdb, 0xe5, 0xd9, 0xc7, 0x21, 0x41, 0xf9, 0x83, 0x7a, 0x8d, 0x4b, 0x7a, 0xfd,
1028 0x7a, 0x88, 0x5e, 0x24, 0x8e, 0xf4, 0x3b, 0x01, 0xbd, 0x84, 0xd7, 0xd5, 0x50, 0xf1, 0x25, 0x1e,
1029 0x7c, 0xc5, 0x24, 0xae, 0xff, 0x48, 0x44, 0x45, 0x2b, 0xb9, 0x00, 0xc9, 0xb2, 0x2c, 0x13, 0xae,
1030 0xe7, 0x2a, 0xc4, 0x2b, 0x76, 0x9d, 0xfc, 0x7c, 0x0f, 0xf9, 0x21, 0x6c, 0x66, 0x64, 0xf6, 0xab,
1031 0xd8, 0x17, 0x20, 0x59, 0x3a, 0x6a, 0x34, 0xeb, 0x1d, 0x64, 0xb1, 0x3d, 0x7b, 0xb6, 0x84, 0x8e,
1032 0x31, 0x86, 0xd7, 0x97, 0x2b, 0xc1, 0x54, 0xc5, 0xb6, 0x8a, 0xc7, 0xae, 0x38, 0x6e, 0x2c, 0x49,
1033 0x29, 0xc2, 0xf6, 0x7c, 0xc8, 0xb7, 0x44, 0xb0, 0x40, 0x31, 0xf1, 0xed, 0x77, 0xe6, 0x95, 0x5d,
1034 0x6f, 0xfd, 0x7c, 0x13, 0x1e, 0x62, 0xe9, 0xd3, 0x43, 0xb5, 0x1c, 0x45, 0x95, 0x62, 0xfb, 0xd4,
1035 0x02, 0xdd, 0x3a, 0xa6, 0xb3, 0x42, 0xe9, 0x1e, 0x4c, 0x33, 0x5c, 0x14, 0x0d, 0xd4, 0x4c, 0x3d,
1036 0x91, 0x66, 0xa1, 0x74, 0x4b, 0x51, 0x74, 0x92, 0x66, 0x8f, 0x41, 0xca, 0xeb, 0x13, 0xa2, 0x41,
1037 0xcc, 0x94, 0xe5, 0xc5, 0x1c, 0xa4, 0x85, 0x84, 0xd5, 0x13, 0xa0, 0x14, 0xb4, 0x11, 0xfc, 0x5f,
1038 0x51, 0x53, 0xf0, 0x7f, 0x25, 0x2d, 0xb6, 0xf8, 0x38, 0x4c, 0x4a, 0xeb, 0x97, 0xb8, 0x67, 0x55,
1039 0x03, 0xfc, 0x5f, 0x59, 0x4b, 0xcf, 0xc6, 0x3f, 0xfd, 0x6b, 0x73, 0x23, 0x8b, 0xb7, 0x40, 0xef,
1040 0x5d, 0xe9, 0xd4, 0x47, 0x21, 0x56, 0xc0, 0x94, 0x0f, 0x41, 0xac, 0x58, 0xd4, 0x94, 0xd9, 0xc9,
1041 0xbf, 0xfa, 0xf9, 0xb3, 0xe9, 0x22, 0xf9, 0x4a, 0xf7, 0x5d, 0xe4, 0x16, 0x8b, 0x0c, 0xfc, 0x2c,
1042 0x9c, 0x0e, 0x5d, 0x29, 0xc5, 0xf8, 0x52, 0x89, 0xe2, 0x57, 0x57, 0x7b, 0xf0, 0xab, 0xab, 0x04,
1043 0xaf, 0xe4, 0xf9, 0x8e, 0x73, 0x41, 0x0f, 0x59, 0x97, 0xcc, 0xd6, 0x85, 0x1d, 0xee, 0x42, 0xfe,
1044 0x59, 0x26, 0x5b, 0x0c, 0x95, 0x45, 0x11, 0x3b, 0xd6, 0xc5, 0x7c, 0x89, 0xe1, 0x4b, 0xa1, 0xf8,
1045 0x03, 0x69, 0x5b, 0x35, 0x38, 0x43, 0x30, 0x92, 0x92, 0xa7, 0xf0, 0x6a, 0x28, 0xc9, 0x91, 0x70,
1046 0xd8, 0x7d, 0xd5, 0x53, 0xb8, 0x1c, 0x2a, 0xdb, 0x88, 0x38, 0xf4, 0x55, 0xce, 0x5f, 0x64, 0x93,
1047 0x7c, 0xe1, 0xb2, 0x7e, 0x9a, 0xe7, 0x68, 0x60, 0x04, 0x66, 0x06, 0xe2, 0x52, 0xf9, 0x12, 0x03,
1048 0x14, 0xfb, 0x02, 0xfa, 0x5b, 0x89, 0x23, 0xf3, 0xcf, 0x33, 0x92, 0x52, 0x5f, 0x92, 0x08, 0x53,
1049 0x71, 0x78, 0x71, 0xf7, 0xde, 0xbb, 0x73, 0x23, 0xdf, 0x7a, 0x77, 0x6e, 0xe4, 0xbf, 0xbc, 0x3b,
1050 0x37, 0xf2, 0x9d, 0x77, 0xe7, 0x94, 0xef, 0xbf, 0x3b, 0xa7, 0xfc, 0xf0, 0xdd, 0x39, 0xe5, 0x47,
1051 0xef, 0xce, 0x29, 0x6f, 0xde, 0x9f, 0x53, 0xbe, 0x72, 0x7f, 0x4e, 0xf9, 0xea, 0xfd, 0x39, 0xe5,
1052 0x77, 0xef, 0xcf, 0x29, 0x6f, 0xdf, 0x9f, 0x53, 0xee, 0xdd, 0x9f, 0x53, 0xbe, 0x75, 0x7f, 0x4e,
1053 0xf9, 0xce, 0xfd, 0x39, 0xe5, 0xfb, 0xf7, 0xe7, 0x46, 0x7e, 0x78, 0x7f, 0x4e, 0xf9, 0xd1, 0xfd,
1054 0xb9, 0x91, 0x37, 0xbf, 0x3b, 0x37, 0xf2, 0xd6, 0x77, 0xe7, 0x46, 0xbe, 0xf2, 0xdd, 0x39, 0x05,
1055 0xfe, 0x70, 0x05, 0x72, 0xec, 0x9b, 0x64, 0xc2, 0x97, 0x86, 0x2f, 0xba, 0x47, 0x88, 0x14, 0x05,
1056 0x57, 0xf8, 0xaf, 0x80, 0x79, 0x0d, 0x27, 0xfc, 0x5e, 0xd9, 0xec, 0x83, 0x7e, 0x8b, 0x2d, 0xf7,
1057 0x6f, 0x13, 0x30, 0xc6, 0x57, 0x83, 0xc3, 0x7e, 0x2b, 0xfd, 0x2a, 0x24, 0x8f, 0x1a, 0x4d, 0xb3,
1058 0xd3, 0x70, 0x8f, 0xd9, 0x32, 0xe8, 0xc3, 0x4b, 0xbe, 0xda, 0x7c, 0xe1, 0xf4, 0xf9, 0x6e, 0xcb,
1059 0xee, 0x76, 0x0c, 0x4f, 0x54, 0x3f, 0x0b, 0x99, 0x23, 0xd4, 0x38, 0x3c, 0x72, 0xab, 0x0d, 0xab,
1060 0x5a, 0x6b, 0x91, 0x6a, 0x79, 0xdc, 0x00, 0xda, 0xb6, 0x6e, 0x95, 0x5a, 0xf8, 0x66, 0x75, 0xd3,
1061 0x35, 0xc9, 0x5b, 0x7a, 0xc6, 0x20, 0x9f, 0xc9, 0xef, 0x1d, 0x23, 0xa7, 0xdb, 0x74, 0xab, 0x35,
1062 0xbb, 0x6b, 0xb9, 0xa4, 0x9e, 0x55, 0x8d, 0x34, 0x6d, 0x2b, 0xe1, 0x26, 0xfd, 0x31, 0x18, 0x77,
1063 0x3b, 0x5d, 0x54, 0x75, 0x6a, 0xb6, 0xeb, 0xb4, 0x4c, 0x8b, 0xd4, 0xb3, 0x49, 0x23, 0x83, 0x1b,
1064 0x77, 0x58, 0x1b, 0xf9, 0x99, 0xfd, 0x9a, 0xdd, 0x41, 0xe4, 0x75, 0x3a, 0x66, 0xd0, 0x0b, 0x5d,
1065 0x03, 0xf5, 0x15, 0x74, 0x4c, 0x5e, 0xd8, 0xe2, 0x06, 0xfe, 0xa8, 0x3f, 0x09, 0xa3, 0xf4, 0xef,
1066 0xe4, 0x90, 0xea, 0x9a, 0x6c, 0x5e, 0x7b, 0x8f, 0x46, 0x17, 0x69, 0x0d, 0x26, 0xa0, 0xdf, 0x84,
1067 0x31, 0x17, 0x75, 0x3a, 0x66, 0xc3, 0x22, 0x2f, 0x4f, 0xe9, 0xe5, 0xf9, 0x10, 0x33, 0xec, 0x52,
1068 0x09, 0xf2, 0xab, 0xc0, 0x06, 0x97, 0xd7, 0xaf, 0x42, 0x86, 0xc8, 0x2d, 0x57, 0xe9, 0xdf, 0x12,
1069 0x4a, 0xf7, 0x8d, 0xe7, 0x34, 0x95, 0xe3, 0x7b, 0x05, 0x1c, 0x46, 0x7f, 0x11, 0x71, 0x9c, 0xdc,
1070 0xf6, 0xb1, 0x90, 0xdb, 0x92, 0xa1, 0x77, 0x99, 0x94, 0x8d, 0xf4, 0xd6, 0x8c, 0x87, 0xfe, 0x66,
1071 0xe2, 0x26, 0x64, 0x44, 0xbd, 0xb8, 0x19, 0x68, 0xf9, 0x43, 0xcc, 0xf0, 0x84, 0xff, 0x77, 0x1a,
1072 0xfa, 0x58, 0x81, 0xf6, 0xe7, 0x63, 0x37, 0x94, 0xd9, 0x6d, 0xd0, 0xe4, 0xfb, 0x85, 0x50, 0x5e,
1073 0x08, 0x52, 0x6a, 0xe2, 0xc3, 0x92, 0x95, 0x72, 0x9f, 0x31, 0xf7, 0x1c, 0x8c, 0xd2, 0xf8, 0xd1,
1074 0xd3, 0x30, 0xe6, 0xff, 0xd8, 0x66, 0x12, 0xe2, 0xdb, 0x7b, 0x95, 0x1d, 0xfa, 0xab, 0xb9, 0x3b,
1075 0x1b, 0x85, 0xed, 0x9d, 0xdd, 0xf5, 0xd2, 0xc7, 0xb4, 0x98, 0x3e, 0x09, 0xe9, 0xe2, 0xfa, 0xc6,
1076 0x46, 0xb5, 0x58, 0x58, 0xdf, 0x28, 0xdf, 0xd5, 0xd4, 0xdc, 0x1c, 0x8c, 0x52, 0x3d, 0xc9, 0xaf,
1077 0xff, 0x75, 0x2d, 0xeb, 0x98, 0x97, 0x0f, 0xe4, 0x22, 0xf7, 0x35, 0x1d, 0xc6, 0x0a, 0xcd, 0xe6,
1078 0xa6, 0xd9, 0x76, 0xf4, 0x17, 0x60, 0x8a, 0xfe, 0x2e, 0xc7, 0xae, 0xbd, 0x4a, 0x7e, 0xa4, 0x12,
1079 0x0f, 0x0e, 0x0a, 0xfb, 0xfb, 0x14, 0xfe, 0x73, 0x33, 0xf1, 0xa5, 0x1e, 0x59, 0x6a, 0xe0, 0x5e,
1080 0x0e, 0x7d, 0x17, 0x34, 0xde, 0xb8, 0xd6, 0xb4, 0x4d, 0x17, 0xf3, 0xc6, 0xd8, 0x6f, 0x48, 0xf6,
1081 0xe7, 0xe5, 0xa2, 0x94, 0xb6, 0x87, 0x41, 0xff, 0x28, 0x24, 0xd7, 0x2d, 0xf7, 0xca, 0x32, 0x66,
1082 0xe3, 0x7f, 0xfb, 0xa9, 0x97, 0x8d, 0x8b, 0x50, 0x16, 0x0f, 0xc1, 0xd0, 0xd7, 0x56, 0x30, 0x3a,
1083 0x3e, 0x08, 0x4d, 0x44, 0x7c, 0x34, 0xb9, 0xd4, 0x9f, 0x83, 0x14, 0x7e, 0x3b, 0xa1, 0x37, 0x4f,
1084 0xf0, 0xd2, 0xb5, 0x07, 0xee, 0xc9, 0x50, 0xbc, 0x8f, 0xe1, 0x04, 0xf4, 0xfe, 0xa3, 0x03, 0x09,
1085 0x04, 0x05, 0x7c, 0x0c, 0x26, 0xd8, 0xf1, 0x34, 0x18, 0xeb, 0x4b, 0xb0, 0x23, 0x69, 0xb0, 0x23,
1086 0x6a, 0xb0, 0xe3, 0x69, 0x90, 0x1c, 0x48, 0x20, 0x6a, 0xe0, 0x5d, 0xeb, 0x45, 0x80, 0xb5, 0xc6,
1087 0xeb, 0xa8, 0x4e, 0x55, 0xa0, 0x7f, 0x19, 0x2a, 0x17, 0xc2, 0xe0, 0x0b, 0x51, 0x0a, 0x01, 0xa5,
1088 0x97, 0x21, 0xbd, 0x73, 0xe0, 0x93, 0x40, 0x4f, 0x1e, 0x7b, 0x6a, 0x1c, 0x48, 0x2c, 0x22, 0xce,
1089 0x53, 0x85, 0x3e, 0x4c, 0x7a, 0xb0, 0x2a, 0xc2, 0xd3, 0x08, 0x28, 0x5f, 0x15, 0x4a, 0x92, 0x89,
1090 0x50, 0x45, 0x60, 0x11, 0x71, 0x78, 0x30, 0x2c, 0xda, 0x36, 0x96, 0x64, 0xa3, 0xd2, 0x7c, 0x08,
1091 0x05, 0x93, 0x60, 0x83, 0x21, 0xbb, 0x22, 0x1e, 0x21, 0x41, 0x8e, 0xc1, 0x13, 0xfd, 0x3d, 0xc2,
1092 0x65, 0xb8, 0x47, 0xf8, 0xb5, 0x98, 0x67, 0xe4, 0x44, 0x2b, 0xe6, 0x99, 0x8c, 0xcc, 0x33, 0x2e,
1093 0x2a, 0xe5, 0x19, 0x6f, 0xd6, 0x3f, 0x0e, 0x93, 0xbc, 0x0d, 0x0f, 0x4f, 0x98, 0x54, 0x63, 0x7f,
1094 0x3b, 0xaf, 0x3f, 0x29, 0x93, 0xa4, 0x9c, 0x32, 0x5e, 0xaf, 0xc0, 0x04, 0x6f, 0xda, 0x74, 0xc8,
1095 0xe3, 0x4e, 0xb1, 0x3f, 0x8b, 0xd2, 0x9f, 0x91, 0x0a, 0x52, 0x42, 0x09, 0x3d, 0xbb, 0x0a, 0x33,
1096 0xe1, 0xa3, 0x91, 0x38, 0xfc, 0xa6, 0xe8, 0xf0, 0x7b, 0x4a, 0x1c, 0x7e, 0x15, 0x71, 0xf8, 0x2e,
1097 0xc1, 0xe9, 0xd0, 0xb1, 0x27, 0x8a, 0x24, 0x26, 0x92, 0xdc, 0x82, 0xf1, 0xc0, 0x90, 0x23, 0x82,
1098 0x13, 0x21, 0xe0, 0x44, 0x2f, 0xd8, 0x0f, 0xad, 0x90, 0xd9, 0x23, 0x00, 0x56, 0x45, 0xf0, 0x47,
1099 0x61, 0x22, 0x38, 0xde, 0x88, 0xe8, 0xf1, 0x10, 0xf4, 0x78, 0x08, 0x3a, 0xfc, 0xde, 0xf1, 0x10,
1100 0x74, 0x5c, 0x42, 0xef, 0xf4, 0xbd, 0xf7, 0x54, 0x08, 0x7a, 0x2a, 0x04, 0x1d, 0x7e, 0x6f, 0x3d,
1101 0x04, 0xad, 0x8b, 0xe8, 0x67, 0x60, 0x52, 0x1a, 0x62, 0x44, 0xf8, 0x58, 0x08, 0x7c, 0x4c, 0x84,
1102 0x3f, 0x0b, 0x9a, 0x3c, 0xb8, 0x88, 0xf8, 0xc9, 0x10, 0xfc, 0x64, 0xd8, 0xed, 0xc3, 0xb5, 0x1f,
1103 0x0d, 0x81, 0x8f, 0x86, 0xde, 0x3e, 0x1c, 0xaf, 0x85, 0xe0, 0x35, 0x11, 0x9f, 0x87, 0x8c, 0x38,
1104 0x9a, 0x88, 0xd8, 0x64, 0x08, 0x36, 0x29, 0xdb, 0x3d, 0x30, 0x98, 0x44, 0x45, 0x7a, 0xaa, 0x4f,
1105 0xba, 0x04, 0x86, 0x90, 0x28, 0x92, 0x8c, 0x48, 0xf2, 0x09, 0x38, 0x15, 0x36, 0x64, 0x84, 0x70,
1106 0x2c, 0x88, 0x1c, 0x13, 0xb8, 0x46, 0xf4, 0x8b, 0x3d, 0xb3, 0x2d, 0x15, 0x4e, 0xb3, 0x2f, 0xc1,
1107 0x74, 0xc8, 0xc0, 0x11, 0x42, 0xbb, 0x14, 0xac, 0xc6, 0xb2, 0x02, 0x2d, 0x19, 0x04, 0x1a, 0xd6,
1108 0xe1, 0xb6, 0xdd, 0xb0, 0x5c, 0xb1, 0x2a, 0xfb, 0xfa, 0x34, 0x4c, 0xb0, 0xe1, 0x69, 0xab, 0x53,
1109 0x47, 0x1d, 0x54, 0xd7, 0xff, 0x5c, 0xff, 0xda, 0xe9, 0x52, 0xef, 0xa0, 0xc6, 0x50, 0x27, 0x28,
1110 0xa1, 0x5e, 0xea, 0x5b, 0x42, 0x5d, 0x8c, 0xa6, 0x8f, 0xaa, 0xa4, 0x4a, 0x3d, 0x95, 0xd4, 0x13,
1111 0xfd, 0x49, 0xfb, 0x15, 0x54, 0xa5, 0x9e, 0x82, 0x6a, 0x30, 0x49, 0x68, 0x5d, 0xb5, 0xd6, 0x5b,
1112 0x57, 0x2d, 0xf4, 0x67, 0xe9, 0x5f, 0x5e, 0xad, 0xf5, 0x96, 0x57, 0x11, 0x3c, 0xe1, 0x55, 0xd6,
1113 0x5a, 0x6f, 0x95, 0x35, 0x80, 0xa7, 0x7f, 0xb1, 0xb5, 0xd6, 0x5b, 0x6c, 0x45, 0xf0, 0x84, 0xd7,
1114 0x5c, 0xeb, 0x21, 0x35, 0xd7, 0x93, 0xfd, 0x89, 0x06, 0x95, 0x5e, 0x1b, 0x61, 0xa5, 0xd7, 0xe2,
1115 0x00, 0xa5, 0x06, 0x56, 0x60, 0xeb, 0x21, 0x15, 0x58, 0x94, 0x62, 0x7d, 0x0a, 0xb1, 0x8d, 0xb0,
1116 0x42, 0x2c, 0x52, 0xb1, 0x7e, 0xf5, 0xd8, 0xcf, 0xc9, 0xf5, 0xd8, 0x85, 0xfe, 0x4c, 0xe1, 0x65,
1117 0xd9, 0x5a, 0x6f, 0x59, 0xb6, 0x10, 0x95, 0x73, 0x61, 0xd5, 0xd9, 0x4b, 0x7d, 0xab, 0xb3, 0x21,
1118 0x52, 0x38, 0xaa, 0x48, 0x7b, 0xb1, 0x5f, 0x91, 0xb6, 0x14, 0xcd, 0x3d, 0xb8, 0x56, 0xdb, 0xeb,
1119 0x53, 0xab, 0x3d, 0x1d, 0x4d, 0xfc, 0xb3, 0x92, 0xed, 0x67, 0x25, 0xdb, 0xcf, 0x4a, 0xb6, 0x9f,
1120 0x95, 0x6c, 0x3f, 0xfd, 0x92, 0x2d, 0x1f, 0xff, 0xcc, 0x97, 0xe6, 0x95, 0xdc, 0x7f, 0x56, 0xbd,
1121 0x3f, 0xb8, 0xf6, 0x42, 0xc3, 0x3d, 0xc2, 0xc3, 0xdb, 0x26, 0x64, 0xc8, 0x0f, 0x00, 0xb7, 0xcc,
1122 0x76, 0xbb, 0x61, 0x1d, 0xb2, 0x9a, 0x6d, 0xb1, 0x77, 0x29, 0x91, 0x01, 0xc8, 0x1f, 0x9b, 0xd9,
1123 0xa4, 0xc2, 0x6c, 0xba, 0xb1, 0xfc, 0x16, 0xfd, 0x0e, 0xa4, 0x5b, 0xce, 0xa1, 0xc7, 0x16, 0xeb,
1124 0x99, 0x08, 0x25, 0x36, 0xfa, 0xa4, 0x3e, 0x19, 0xb4, 0xbc, 0x06, 0xac, 0xda, 0xfe, 0xb1, 0xeb,
1125 0xab, 0xa6, 0x46, 0xa9, 0x86, 0x7d, 0x1a, 0x54, 0x6d, 0xdf, 0x6f, 0xc1, 0x61, 0x2b, 0xeb, 0x1e,
1126 0x35, 0xd2, 0x05, 0x82, 0xe7, 0x05, 0x98, 0x94, 0xb4, 0x0d, 0xc9, 0xf9, 0x07, 0xf0, 0x0d, 0x56,
1127 0x4c, 0xd6, 0x3c, 0x2a, 0x27, 0xc4, 0x80, 0xcc, 0x3d, 0x0a, 0xe3, 0x01, 0x6e, 0x3d, 0x03, 0xca,
1128 0x01, 0xfb, 0x3a, 0xa5, 0x72, 0x90, 0xfb, 0xa2, 0x02, 0x69, 0x76, 0x94, 0x60, 0xdb, 0x6c, 0x74,
1129 0xf4, 0xe7, 0x21, 0xde, 0xe4, 0x5f, 0x69, 0x7a, 0xd0, 0xaf, 0xcf, 0x12, 0x06, 0x7d, 0x0d, 0x12,
1130 0x1d, 0xef, 0x2b, 0x4f, 0x0f, 0xf4, 0x9d, 0x58, 0x02, 0xcf, 0xdd, 0x53, 0x60, 0x8a, 0x9d, 0x74,
1131 0x75, 0xd8, 0x01, 0x68, 0xb3, 0x3d, 0xfb, 0x35, 0x05, 0x52, 0xde, 0x95, 0xbe, 0x0f, 0x13, 0xde,
1132 0x05, 0x3d, 0x64, 0x4f, 0x23, 0x35, 0x2f, 0x58, 0xb8, 0x87, 0x63, 0x29, 0xe4, 0x13, 0xdd, 0x8c,
1133 0xa2, 0x73, 0x72, 0xb0, 0x71, 0xb6, 0x00, 0xd3, 0x21, 0x62, 0x27, 0x99, 0x90, 0x73, 0xe7, 0x20,
1134 0x55, 0xb1, 0x5d, 0xfa, 0xcb, 0x39, 0xfa, 0x29, 0x61, 0x57, 0xa1, 0x18, 0xd3, 0x46, 0x08, 0x78,
1135 0xf1, 0x1c, 0x8c, 0xb1, 0xec, 0xd7, 0x47, 0x21, 0xb6, 0x59, 0xd0, 0x46, 0xc8, 0xff, 0x45, 0x4d,
1136 0x21, 0xff, 0x97, 0xb4, 0x58, 0x71, 0xe3, 0x01, 0x76, 0x9a, 0x46, 0xfa, 0xed, 0x34, 0xed, 0x8f,
1137 0x52, 0xf3, 0xfc, 0x49, 0x00, 0x00, 0x00, 0xff, 0xff, 0x3d, 0x79, 0x7c, 0xa8, 0xc6, 0x83, 0x00,
1138 0x00,
1139 }
1140 r := bytes.NewReader(gzipped)
1141 gzipr, err := compress_gzip.NewReader(r)
1142 if err != nil {
1143 panic(err)
1144 }
1145 ungzipped, err := io_ioutil.ReadAll(gzipr)
1146 if err != nil {
1147 panic(err)
1148 }
1149 if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
1150 panic(err)
1151 }
1152 return d
1153 }
1154 func (x MapEnum) String() string {
1155 s, ok := MapEnum_name[int32(x)]
1156 if ok {
1157 return s
1158 }
1159 return strconv.Itoa(int(x))
1160 }
1161 func (x Message_Humour) String() string {
1162 s, ok := Message_Humour_name[int32(x)]
1163 if ok {
1164 return s
1165 }
1166 return strconv.Itoa(int(x))
1167 }
1168 func (this *Message) VerboseEqual(that interface{}) error {
1169 if that == nil {
1170 if this == nil {
1171 return nil
1172 }
1173 return fmt.Errorf("that == nil && this != nil")
1174 }
1175
1176 that1, ok := that.(*Message)
1177 if !ok {
1178 that2, ok := that.(Message)
1179 if ok {
1180 that1 = &that2
1181 } else {
1182 return fmt.Errorf("that is not of type *Message")
1183 }
1184 }
1185 if that1 == nil {
1186 if this == nil {
1187 return nil
1188 }
1189 return fmt.Errorf("that is type *Message but is nil && this != nil")
1190 } else if this == nil {
1191 return fmt.Errorf("that is type *Message but is not nil && this == nil")
1192 }
1193 if this.Name != that1.Name {
1194 return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name)
1195 }
1196 if this.Hilarity != that1.Hilarity {
1197 return fmt.Errorf("Hilarity this(%v) Not Equal that(%v)", this.Hilarity, that1.Hilarity)
1198 }
1199 if this.HeightInCm != that1.HeightInCm {
1200 return fmt.Errorf("HeightInCm this(%v) Not Equal that(%v)", this.HeightInCm, that1.HeightInCm)
1201 }
1202 if !bytes.Equal(this.Data, that1.Data) {
1203 return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
1204 }
1205 if this.ResultCount != that1.ResultCount {
1206 return fmt.Errorf("ResultCount this(%v) Not Equal that(%v)", this.ResultCount, that1.ResultCount)
1207 }
1208 if this.TrueScotsman != that1.TrueScotsman {
1209 return fmt.Errorf("TrueScotsman this(%v) Not Equal that(%v)", this.TrueScotsman, that1.TrueScotsman)
1210 }
1211 if this.Score != that1.Score {
1212 return fmt.Errorf("Score this(%v) Not Equal that(%v)", this.Score, that1.Score)
1213 }
1214 if len(this.Key) != len(that1.Key) {
1215 return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key))
1216 }
1217 for i := range this.Key {
1218 if this.Key[i] != that1.Key[i] {
1219 return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i])
1220 }
1221 }
1222 if !this.Nested.Equal(that1.Nested) {
1223 return fmt.Errorf("Nested this(%v) Not Equal that(%v)", this.Nested, that1.Nested)
1224 }
1225 if len(this.Terrain) != len(that1.Terrain) {
1226 return fmt.Errorf("Terrain this(%v) Not Equal that(%v)", len(this.Terrain), len(that1.Terrain))
1227 }
1228 for i := range this.Terrain {
1229 if !this.Terrain[i].Equal(that1.Terrain[i]) {
1230 return fmt.Errorf("Terrain this[%v](%v) Not Equal that[%v](%v)", i, this.Terrain[i], i, that1.Terrain[i])
1231 }
1232 }
1233 if !this.Proto2Field.Equal(that1.Proto2Field) {
1234 return fmt.Errorf("Proto2Field this(%v) Not Equal that(%v)", this.Proto2Field, that1.Proto2Field)
1235 }
1236 if len(this.Proto2Value) != len(that1.Proto2Value) {
1237 return fmt.Errorf("Proto2Value this(%v) Not Equal that(%v)", len(this.Proto2Value), len(that1.Proto2Value))
1238 }
1239 for i := range this.Proto2Value {
1240 if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) {
1241 return fmt.Errorf("Proto2Value this[%v](%v) Not Equal that[%v](%v)", i, this.Proto2Value[i], i, that1.Proto2Value[i])
1242 }
1243 }
1244 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1245 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1246 }
1247 return nil
1248 }
1249 func (this *Message) Equal(that interface{}) bool {
1250 if that == nil {
1251 return this == nil
1252 }
1253
1254 that1, ok := that.(*Message)
1255 if !ok {
1256 that2, ok := that.(Message)
1257 if ok {
1258 that1 = &that2
1259 } else {
1260 return false
1261 }
1262 }
1263 if that1 == nil {
1264 return this == nil
1265 } else if this == nil {
1266 return false
1267 }
1268 if this.Name != that1.Name {
1269 return false
1270 }
1271 if this.Hilarity != that1.Hilarity {
1272 return false
1273 }
1274 if this.HeightInCm != that1.HeightInCm {
1275 return false
1276 }
1277 if !bytes.Equal(this.Data, that1.Data) {
1278 return false
1279 }
1280 if this.ResultCount != that1.ResultCount {
1281 return false
1282 }
1283 if this.TrueScotsman != that1.TrueScotsman {
1284 return false
1285 }
1286 if this.Score != that1.Score {
1287 return false
1288 }
1289 if len(this.Key) != len(that1.Key) {
1290 return false
1291 }
1292 for i := range this.Key {
1293 if this.Key[i] != that1.Key[i] {
1294 return false
1295 }
1296 }
1297 if !this.Nested.Equal(that1.Nested) {
1298 return false
1299 }
1300 if len(this.Terrain) != len(that1.Terrain) {
1301 return false
1302 }
1303 for i := range this.Terrain {
1304 if !this.Terrain[i].Equal(that1.Terrain[i]) {
1305 return false
1306 }
1307 }
1308 if !this.Proto2Field.Equal(that1.Proto2Field) {
1309 return false
1310 }
1311 if len(this.Proto2Value) != len(that1.Proto2Value) {
1312 return false
1313 }
1314 for i := range this.Proto2Value {
1315 if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) {
1316 return false
1317 }
1318 }
1319 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1320 return false
1321 }
1322 return true
1323 }
1324 func (this *Nested) VerboseEqual(that interface{}) error {
1325 if that == nil {
1326 if this == nil {
1327 return nil
1328 }
1329 return fmt.Errorf("that == nil && this != nil")
1330 }
1331
1332 that1, ok := that.(*Nested)
1333 if !ok {
1334 that2, ok := that.(Nested)
1335 if ok {
1336 that1 = &that2
1337 } else {
1338 return fmt.Errorf("that is not of type *Nested")
1339 }
1340 }
1341 if that1 == nil {
1342 if this == nil {
1343 return nil
1344 }
1345 return fmt.Errorf("that is type *Nested but is nil && this != nil")
1346 } else if this == nil {
1347 return fmt.Errorf("that is type *Nested but is not nil && this == nil")
1348 }
1349 if this.Bunny != that1.Bunny {
1350 return fmt.Errorf("Bunny this(%v) Not Equal that(%v)", this.Bunny, that1.Bunny)
1351 }
1352 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1353 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1354 }
1355 return nil
1356 }
1357 func (this *Nested) Equal(that interface{}) bool {
1358 if that == nil {
1359 return this == nil
1360 }
1361
1362 that1, ok := that.(*Nested)
1363 if !ok {
1364 that2, ok := that.(Nested)
1365 if ok {
1366 that1 = &that2
1367 } else {
1368 return false
1369 }
1370 }
1371 if that1 == nil {
1372 return this == nil
1373 } else if this == nil {
1374 return false
1375 }
1376 if this.Bunny != that1.Bunny {
1377 return false
1378 }
1379 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1380 return false
1381 }
1382 return true
1383 }
1384 func (this *AllMaps) VerboseEqual(that interface{}) error {
1385 if that == nil {
1386 if this == nil {
1387 return nil
1388 }
1389 return fmt.Errorf("that == nil && this != nil")
1390 }
1391
1392 that1, ok := that.(*AllMaps)
1393 if !ok {
1394 that2, ok := that.(AllMaps)
1395 if ok {
1396 that1 = &that2
1397 } else {
1398 return fmt.Errorf("that is not of type *AllMaps")
1399 }
1400 }
1401 if that1 == nil {
1402 if this == nil {
1403 return nil
1404 }
1405 return fmt.Errorf("that is type *AllMaps but is nil && this != nil")
1406 } else if this == nil {
1407 return fmt.Errorf("that is type *AllMaps but is not nil && this == nil")
1408 }
1409 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1410 return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap))
1411 }
1412 for i := range this.StringToDoubleMap {
1413 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1414 return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i])
1415 }
1416 }
1417 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1418 return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap))
1419 }
1420 for i := range this.StringToFloatMap {
1421 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1422 return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i])
1423 }
1424 }
1425 if len(this.Int32Map) != len(that1.Int32Map) {
1426 return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map))
1427 }
1428 for i := range this.Int32Map {
1429 if this.Int32Map[i] != that1.Int32Map[i] {
1430 return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i])
1431 }
1432 }
1433 if len(this.Int64Map) != len(that1.Int64Map) {
1434 return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map))
1435 }
1436 for i := range this.Int64Map {
1437 if this.Int64Map[i] != that1.Int64Map[i] {
1438 return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i])
1439 }
1440 }
1441 if len(this.Uint32Map) != len(that1.Uint32Map) {
1442 return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map))
1443 }
1444 for i := range this.Uint32Map {
1445 if this.Uint32Map[i] != that1.Uint32Map[i] {
1446 return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i])
1447 }
1448 }
1449 if len(this.Uint64Map) != len(that1.Uint64Map) {
1450 return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map))
1451 }
1452 for i := range this.Uint64Map {
1453 if this.Uint64Map[i] != that1.Uint64Map[i] {
1454 return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i])
1455 }
1456 }
1457 if len(this.Sint32Map) != len(that1.Sint32Map) {
1458 return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map))
1459 }
1460 for i := range this.Sint32Map {
1461 if this.Sint32Map[i] != that1.Sint32Map[i] {
1462 return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i])
1463 }
1464 }
1465 if len(this.Sint64Map) != len(that1.Sint64Map) {
1466 return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map))
1467 }
1468 for i := range this.Sint64Map {
1469 if this.Sint64Map[i] != that1.Sint64Map[i] {
1470 return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i])
1471 }
1472 }
1473 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1474 return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map))
1475 }
1476 for i := range this.Fixed32Map {
1477 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1478 return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i])
1479 }
1480 }
1481 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1482 return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map))
1483 }
1484 for i := range this.Sfixed32Map {
1485 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1486 return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i])
1487 }
1488 }
1489 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1490 return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map))
1491 }
1492 for i := range this.Fixed64Map {
1493 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1494 return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i])
1495 }
1496 }
1497 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1498 return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map))
1499 }
1500 for i := range this.Sfixed64Map {
1501 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1502 return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i])
1503 }
1504 }
1505 if len(this.BoolMap) != len(that1.BoolMap) {
1506 return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap))
1507 }
1508 for i := range this.BoolMap {
1509 if this.BoolMap[i] != that1.BoolMap[i] {
1510 return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i])
1511 }
1512 }
1513 if len(this.StringMap) != len(that1.StringMap) {
1514 return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap))
1515 }
1516 for i := range this.StringMap {
1517 if this.StringMap[i] != that1.StringMap[i] {
1518 return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i])
1519 }
1520 }
1521 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1522 return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap))
1523 }
1524 for i := range this.StringToBytesMap {
1525 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1526 return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i])
1527 }
1528 }
1529 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1530 return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap))
1531 }
1532 for i := range this.StringToEnumMap {
1533 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1534 return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i])
1535 }
1536 }
1537 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1538 return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap))
1539 }
1540 for i := range this.StringToMsgMap {
1541 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1542 return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i])
1543 }
1544 }
1545 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1546 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1547 }
1548 return nil
1549 }
1550 func (this *AllMaps) Equal(that interface{}) bool {
1551 if that == nil {
1552 return this == nil
1553 }
1554
1555 that1, ok := that.(*AllMaps)
1556 if !ok {
1557 that2, ok := that.(AllMaps)
1558 if ok {
1559 that1 = &that2
1560 } else {
1561 return false
1562 }
1563 }
1564 if that1 == nil {
1565 return this == nil
1566 } else if this == nil {
1567 return false
1568 }
1569 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1570 return false
1571 }
1572 for i := range this.StringToDoubleMap {
1573 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1574 return false
1575 }
1576 }
1577 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1578 return false
1579 }
1580 for i := range this.StringToFloatMap {
1581 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1582 return false
1583 }
1584 }
1585 if len(this.Int32Map) != len(that1.Int32Map) {
1586 return false
1587 }
1588 for i := range this.Int32Map {
1589 if this.Int32Map[i] != that1.Int32Map[i] {
1590 return false
1591 }
1592 }
1593 if len(this.Int64Map) != len(that1.Int64Map) {
1594 return false
1595 }
1596 for i := range this.Int64Map {
1597 if this.Int64Map[i] != that1.Int64Map[i] {
1598 return false
1599 }
1600 }
1601 if len(this.Uint32Map) != len(that1.Uint32Map) {
1602 return false
1603 }
1604 for i := range this.Uint32Map {
1605 if this.Uint32Map[i] != that1.Uint32Map[i] {
1606 return false
1607 }
1608 }
1609 if len(this.Uint64Map) != len(that1.Uint64Map) {
1610 return false
1611 }
1612 for i := range this.Uint64Map {
1613 if this.Uint64Map[i] != that1.Uint64Map[i] {
1614 return false
1615 }
1616 }
1617 if len(this.Sint32Map) != len(that1.Sint32Map) {
1618 return false
1619 }
1620 for i := range this.Sint32Map {
1621 if this.Sint32Map[i] != that1.Sint32Map[i] {
1622 return false
1623 }
1624 }
1625 if len(this.Sint64Map) != len(that1.Sint64Map) {
1626 return false
1627 }
1628 for i := range this.Sint64Map {
1629 if this.Sint64Map[i] != that1.Sint64Map[i] {
1630 return false
1631 }
1632 }
1633 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1634 return false
1635 }
1636 for i := range this.Fixed32Map {
1637 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1638 return false
1639 }
1640 }
1641 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1642 return false
1643 }
1644 for i := range this.Sfixed32Map {
1645 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1646 return false
1647 }
1648 }
1649 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1650 return false
1651 }
1652 for i := range this.Fixed64Map {
1653 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1654 return false
1655 }
1656 }
1657 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1658 return false
1659 }
1660 for i := range this.Sfixed64Map {
1661 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1662 return false
1663 }
1664 }
1665 if len(this.BoolMap) != len(that1.BoolMap) {
1666 return false
1667 }
1668 for i := range this.BoolMap {
1669 if this.BoolMap[i] != that1.BoolMap[i] {
1670 return false
1671 }
1672 }
1673 if len(this.StringMap) != len(that1.StringMap) {
1674 return false
1675 }
1676 for i := range this.StringMap {
1677 if this.StringMap[i] != that1.StringMap[i] {
1678 return false
1679 }
1680 }
1681 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1682 return false
1683 }
1684 for i := range this.StringToBytesMap {
1685 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1686 return false
1687 }
1688 }
1689 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1690 return false
1691 }
1692 for i := range this.StringToEnumMap {
1693 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1694 return false
1695 }
1696 }
1697 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1698 return false
1699 }
1700 for i := range this.StringToMsgMap {
1701 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1702 return false
1703 }
1704 }
1705 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1706 return false
1707 }
1708 return true
1709 }
1710 func (this *AllMapsOrdered) VerboseEqual(that interface{}) error {
1711 if that == nil {
1712 if this == nil {
1713 return nil
1714 }
1715 return fmt.Errorf("that == nil && this != nil")
1716 }
1717
1718 that1, ok := that.(*AllMapsOrdered)
1719 if !ok {
1720 that2, ok := that.(AllMapsOrdered)
1721 if ok {
1722 that1 = &that2
1723 } else {
1724 return fmt.Errorf("that is not of type *AllMapsOrdered")
1725 }
1726 }
1727 if that1 == nil {
1728 if this == nil {
1729 return nil
1730 }
1731 return fmt.Errorf("that is type *AllMapsOrdered but is nil && this != nil")
1732 } else if this == nil {
1733 return fmt.Errorf("that is type *AllMapsOrdered but is not nil && this == nil")
1734 }
1735 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1736 return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap))
1737 }
1738 for i := range this.StringToDoubleMap {
1739 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1740 return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i])
1741 }
1742 }
1743 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1744 return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap))
1745 }
1746 for i := range this.StringToFloatMap {
1747 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1748 return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i])
1749 }
1750 }
1751 if len(this.Int32Map) != len(that1.Int32Map) {
1752 return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map))
1753 }
1754 for i := range this.Int32Map {
1755 if this.Int32Map[i] != that1.Int32Map[i] {
1756 return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i])
1757 }
1758 }
1759 if len(this.Int64Map) != len(that1.Int64Map) {
1760 return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map))
1761 }
1762 for i := range this.Int64Map {
1763 if this.Int64Map[i] != that1.Int64Map[i] {
1764 return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i])
1765 }
1766 }
1767 if len(this.Uint32Map) != len(that1.Uint32Map) {
1768 return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map))
1769 }
1770 for i := range this.Uint32Map {
1771 if this.Uint32Map[i] != that1.Uint32Map[i] {
1772 return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i])
1773 }
1774 }
1775 if len(this.Uint64Map) != len(that1.Uint64Map) {
1776 return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map))
1777 }
1778 for i := range this.Uint64Map {
1779 if this.Uint64Map[i] != that1.Uint64Map[i] {
1780 return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i])
1781 }
1782 }
1783 if len(this.Sint32Map) != len(that1.Sint32Map) {
1784 return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map))
1785 }
1786 for i := range this.Sint32Map {
1787 if this.Sint32Map[i] != that1.Sint32Map[i] {
1788 return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i])
1789 }
1790 }
1791 if len(this.Sint64Map) != len(that1.Sint64Map) {
1792 return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map))
1793 }
1794 for i := range this.Sint64Map {
1795 if this.Sint64Map[i] != that1.Sint64Map[i] {
1796 return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i])
1797 }
1798 }
1799 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1800 return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map))
1801 }
1802 for i := range this.Fixed32Map {
1803 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1804 return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i])
1805 }
1806 }
1807 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1808 return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map))
1809 }
1810 for i := range this.Sfixed32Map {
1811 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1812 return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i])
1813 }
1814 }
1815 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1816 return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map))
1817 }
1818 for i := range this.Fixed64Map {
1819 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1820 return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i])
1821 }
1822 }
1823 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1824 return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map))
1825 }
1826 for i := range this.Sfixed64Map {
1827 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1828 return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i])
1829 }
1830 }
1831 if len(this.BoolMap) != len(that1.BoolMap) {
1832 return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap))
1833 }
1834 for i := range this.BoolMap {
1835 if this.BoolMap[i] != that1.BoolMap[i] {
1836 return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i])
1837 }
1838 }
1839 if len(this.StringMap) != len(that1.StringMap) {
1840 return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap))
1841 }
1842 for i := range this.StringMap {
1843 if this.StringMap[i] != that1.StringMap[i] {
1844 return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i])
1845 }
1846 }
1847 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1848 return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap))
1849 }
1850 for i := range this.StringToBytesMap {
1851 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1852 return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i])
1853 }
1854 }
1855 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1856 return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap))
1857 }
1858 for i := range this.StringToEnumMap {
1859 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1860 return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i])
1861 }
1862 }
1863 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1864 return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap))
1865 }
1866 for i := range this.StringToMsgMap {
1867 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1868 return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i])
1869 }
1870 }
1871 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1872 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1873 }
1874 return nil
1875 }
1876 func (this *AllMapsOrdered) Equal(that interface{}) bool {
1877 if that == nil {
1878 return this == nil
1879 }
1880
1881 that1, ok := that.(*AllMapsOrdered)
1882 if !ok {
1883 that2, ok := that.(AllMapsOrdered)
1884 if ok {
1885 that1 = &that2
1886 } else {
1887 return false
1888 }
1889 }
1890 if that1 == nil {
1891 return this == nil
1892 } else if this == nil {
1893 return false
1894 }
1895 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1896 return false
1897 }
1898 for i := range this.StringToDoubleMap {
1899 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1900 return false
1901 }
1902 }
1903 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1904 return false
1905 }
1906 for i := range this.StringToFloatMap {
1907 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1908 return false
1909 }
1910 }
1911 if len(this.Int32Map) != len(that1.Int32Map) {
1912 return false
1913 }
1914 for i := range this.Int32Map {
1915 if this.Int32Map[i] != that1.Int32Map[i] {
1916 return false
1917 }
1918 }
1919 if len(this.Int64Map) != len(that1.Int64Map) {
1920 return false
1921 }
1922 for i := range this.Int64Map {
1923 if this.Int64Map[i] != that1.Int64Map[i] {
1924 return false
1925 }
1926 }
1927 if len(this.Uint32Map) != len(that1.Uint32Map) {
1928 return false
1929 }
1930 for i := range this.Uint32Map {
1931 if this.Uint32Map[i] != that1.Uint32Map[i] {
1932 return false
1933 }
1934 }
1935 if len(this.Uint64Map) != len(that1.Uint64Map) {
1936 return false
1937 }
1938 for i := range this.Uint64Map {
1939 if this.Uint64Map[i] != that1.Uint64Map[i] {
1940 return false
1941 }
1942 }
1943 if len(this.Sint32Map) != len(that1.Sint32Map) {
1944 return false
1945 }
1946 for i := range this.Sint32Map {
1947 if this.Sint32Map[i] != that1.Sint32Map[i] {
1948 return false
1949 }
1950 }
1951 if len(this.Sint64Map) != len(that1.Sint64Map) {
1952 return false
1953 }
1954 for i := range this.Sint64Map {
1955 if this.Sint64Map[i] != that1.Sint64Map[i] {
1956 return false
1957 }
1958 }
1959 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1960 return false
1961 }
1962 for i := range this.Fixed32Map {
1963 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1964 return false
1965 }
1966 }
1967 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1968 return false
1969 }
1970 for i := range this.Sfixed32Map {
1971 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1972 return false
1973 }
1974 }
1975 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1976 return false
1977 }
1978 for i := range this.Fixed64Map {
1979 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1980 return false
1981 }
1982 }
1983 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1984 return false
1985 }
1986 for i := range this.Sfixed64Map {
1987 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1988 return false
1989 }
1990 }
1991 if len(this.BoolMap) != len(that1.BoolMap) {
1992 return false
1993 }
1994 for i := range this.BoolMap {
1995 if this.BoolMap[i] != that1.BoolMap[i] {
1996 return false
1997 }
1998 }
1999 if len(this.StringMap) != len(that1.StringMap) {
2000 return false
2001 }
2002 for i := range this.StringMap {
2003 if this.StringMap[i] != that1.StringMap[i] {
2004 return false
2005 }
2006 }
2007 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
2008 return false
2009 }
2010 for i := range this.StringToBytesMap {
2011 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
2012 return false
2013 }
2014 }
2015 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
2016 return false
2017 }
2018 for i := range this.StringToEnumMap {
2019 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
2020 return false
2021 }
2022 }
2023 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
2024 return false
2025 }
2026 for i := range this.StringToMsgMap {
2027 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
2028 return false
2029 }
2030 }
2031 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2032 return false
2033 }
2034 return true
2035 }
2036 func (this *MessageWithMap) VerboseEqual(that interface{}) error {
2037 if that == nil {
2038 if this == nil {
2039 return nil
2040 }
2041 return fmt.Errorf("that == nil && this != nil")
2042 }
2043
2044 that1, ok := that.(*MessageWithMap)
2045 if !ok {
2046 that2, ok := that.(MessageWithMap)
2047 if ok {
2048 that1 = &that2
2049 } else {
2050 return fmt.Errorf("that is not of type *MessageWithMap")
2051 }
2052 }
2053 if that1 == nil {
2054 if this == nil {
2055 return nil
2056 }
2057 return fmt.Errorf("that is type *MessageWithMap but is nil && this != nil")
2058 } else if this == nil {
2059 return fmt.Errorf("that is type *MessageWithMap but is not nil && this == nil")
2060 }
2061 if len(this.NameMapping) != len(that1.NameMapping) {
2062 return fmt.Errorf("NameMapping this(%v) Not Equal that(%v)", len(this.NameMapping), len(that1.NameMapping))
2063 }
2064 for i := range this.NameMapping {
2065 if this.NameMapping[i] != that1.NameMapping[i] {
2066 return fmt.Errorf("NameMapping this[%v](%v) Not Equal that[%v](%v)", i, this.NameMapping[i], i, that1.NameMapping[i])
2067 }
2068 }
2069 if len(this.MsgMapping) != len(that1.MsgMapping) {
2070 return fmt.Errorf("MsgMapping this(%v) Not Equal that(%v)", len(this.MsgMapping), len(that1.MsgMapping))
2071 }
2072 for i := range this.MsgMapping {
2073 if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) {
2074 return fmt.Errorf("MsgMapping this[%v](%v) Not Equal that[%v](%v)", i, this.MsgMapping[i], i, that1.MsgMapping[i])
2075 }
2076 }
2077 if len(this.ByteMapping) != len(that1.ByteMapping) {
2078 return fmt.Errorf("ByteMapping this(%v) Not Equal that(%v)", len(this.ByteMapping), len(that1.ByteMapping))
2079 }
2080 for i := range this.ByteMapping {
2081 if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) {
2082 return fmt.Errorf("ByteMapping this[%v](%v) Not Equal that[%v](%v)", i, this.ByteMapping[i], i, that1.ByteMapping[i])
2083 }
2084 }
2085 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2086 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2087 }
2088 return nil
2089 }
2090 func (this *MessageWithMap) Equal(that interface{}) bool {
2091 if that == nil {
2092 return this == nil
2093 }
2094
2095 that1, ok := that.(*MessageWithMap)
2096 if !ok {
2097 that2, ok := that.(MessageWithMap)
2098 if ok {
2099 that1 = &that2
2100 } else {
2101 return false
2102 }
2103 }
2104 if that1 == nil {
2105 return this == nil
2106 } else if this == nil {
2107 return false
2108 }
2109 if len(this.NameMapping) != len(that1.NameMapping) {
2110 return false
2111 }
2112 for i := range this.NameMapping {
2113 if this.NameMapping[i] != that1.NameMapping[i] {
2114 return false
2115 }
2116 }
2117 if len(this.MsgMapping) != len(that1.MsgMapping) {
2118 return false
2119 }
2120 for i := range this.MsgMapping {
2121 if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) {
2122 return false
2123 }
2124 }
2125 if len(this.ByteMapping) != len(that1.ByteMapping) {
2126 return false
2127 }
2128 for i := range this.ByteMapping {
2129 if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) {
2130 return false
2131 }
2132 }
2133 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2134 return false
2135 }
2136 return true
2137 }
2138 func (this *FloatingPoint) VerboseEqual(that interface{}) error {
2139 if that == nil {
2140 if this == nil {
2141 return nil
2142 }
2143 return fmt.Errorf("that == nil && this != nil")
2144 }
2145
2146 that1, ok := that.(*FloatingPoint)
2147 if !ok {
2148 that2, ok := that.(FloatingPoint)
2149 if ok {
2150 that1 = &that2
2151 } else {
2152 return fmt.Errorf("that is not of type *FloatingPoint")
2153 }
2154 }
2155 if that1 == nil {
2156 if this == nil {
2157 return nil
2158 }
2159 return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil")
2160 } else if this == nil {
2161 return fmt.Errorf("that is type *FloatingPoint but is not nil && this == nil")
2162 }
2163 if this.F != that1.F {
2164 return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F)
2165 }
2166 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2167 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2168 }
2169 return nil
2170 }
2171 func (this *FloatingPoint) Equal(that interface{}) bool {
2172 if that == nil {
2173 return this == nil
2174 }
2175
2176 that1, ok := that.(*FloatingPoint)
2177 if !ok {
2178 that2, ok := that.(FloatingPoint)
2179 if ok {
2180 that1 = &that2
2181 } else {
2182 return false
2183 }
2184 }
2185 if that1 == nil {
2186 return this == nil
2187 } else if this == nil {
2188 return false
2189 }
2190 if this.F != that1.F {
2191 return false
2192 }
2193 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2194 return false
2195 }
2196 return true
2197 }
2198 func (this *Uint128Pair) VerboseEqual(that interface{}) error {
2199 if that == nil {
2200 if this == nil {
2201 return nil
2202 }
2203 return fmt.Errorf("that == nil && this != nil")
2204 }
2205
2206 that1, ok := that.(*Uint128Pair)
2207 if !ok {
2208 that2, ok := that.(Uint128Pair)
2209 if ok {
2210 that1 = &that2
2211 } else {
2212 return fmt.Errorf("that is not of type *Uint128Pair")
2213 }
2214 }
2215 if that1 == nil {
2216 if this == nil {
2217 return nil
2218 }
2219 return fmt.Errorf("that is type *Uint128Pair but is nil && this != nil")
2220 } else if this == nil {
2221 return fmt.Errorf("that is type *Uint128Pair but is not nil && this == nil")
2222 }
2223 if !this.Left.Equal(that1.Left) {
2224 return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left)
2225 }
2226 if that1.Right == nil {
2227 if this.Right != nil {
2228 return fmt.Errorf("this.Right != nil && that1.Right == nil")
2229 }
2230 } else if !this.Right.Equal(*that1.Right) {
2231 return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right)
2232 }
2233 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2234 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2235 }
2236 return nil
2237 }
2238 func (this *Uint128Pair) Equal(that interface{}) bool {
2239 if that == nil {
2240 return this == nil
2241 }
2242
2243 that1, ok := that.(*Uint128Pair)
2244 if !ok {
2245 that2, ok := that.(Uint128Pair)
2246 if ok {
2247 that1 = &that2
2248 } else {
2249 return false
2250 }
2251 }
2252 if that1 == nil {
2253 return this == nil
2254 } else if this == nil {
2255 return false
2256 }
2257 if !this.Left.Equal(that1.Left) {
2258 return false
2259 }
2260 if that1.Right == nil {
2261 if this.Right != nil {
2262 return false
2263 }
2264 } else if !this.Right.Equal(*that1.Right) {
2265 return false
2266 }
2267 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2268 return false
2269 }
2270 return true
2271 }
2272 func (this *ContainsNestedMap) VerboseEqual(that interface{}) error {
2273 if that == nil {
2274 if this == nil {
2275 return nil
2276 }
2277 return fmt.Errorf("that == nil && this != nil")
2278 }
2279
2280 that1, ok := that.(*ContainsNestedMap)
2281 if !ok {
2282 that2, ok := that.(ContainsNestedMap)
2283 if ok {
2284 that1 = &that2
2285 } else {
2286 return fmt.Errorf("that is not of type *ContainsNestedMap")
2287 }
2288 }
2289 if that1 == nil {
2290 if this == nil {
2291 return nil
2292 }
2293 return fmt.Errorf("that is type *ContainsNestedMap but is nil && this != nil")
2294 } else if this == nil {
2295 return fmt.Errorf("that is type *ContainsNestedMap but is not nil && this == nil")
2296 }
2297 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2298 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2299 }
2300 return nil
2301 }
2302 func (this *ContainsNestedMap) Equal(that interface{}) bool {
2303 if that == nil {
2304 return this == nil
2305 }
2306
2307 that1, ok := that.(*ContainsNestedMap)
2308 if !ok {
2309 that2, ok := that.(ContainsNestedMap)
2310 if ok {
2311 that1 = &that2
2312 } else {
2313 return false
2314 }
2315 }
2316 if that1 == nil {
2317 return this == nil
2318 } else if this == nil {
2319 return false
2320 }
2321 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2322 return false
2323 }
2324 return true
2325 }
2326 func (this *ContainsNestedMap_NestedMap) VerboseEqual(that interface{}) error {
2327 if that == nil {
2328 if this == nil {
2329 return nil
2330 }
2331 return fmt.Errorf("that == nil && this != nil")
2332 }
2333
2334 that1, ok := that.(*ContainsNestedMap_NestedMap)
2335 if !ok {
2336 that2, ok := that.(ContainsNestedMap_NestedMap)
2337 if ok {
2338 that1 = &that2
2339 } else {
2340 return fmt.Errorf("that is not of type *ContainsNestedMap_NestedMap")
2341 }
2342 }
2343 if that1 == nil {
2344 if this == nil {
2345 return nil
2346 }
2347 return fmt.Errorf("that is type *ContainsNestedMap_NestedMap but is nil && this != nil")
2348 } else if this == nil {
2349 return fmt.Errorf("that is type *ContainsNestedMap_NestedMap but is not nil && this == nil")
2350 }
2351 if len(this.NestedMapField) != len(that1.NestedMapField) {
2352 return fmt.Errorf("NestedMapField this(%v) Not Equal that(%v)", len(this.NestedMapField), len(that1.NestedMapField))
2353 }
2354 for i := range this.NestedMapField {
2355 if this.NestedMapField[i] != that1.NestedMapField[i] {
2356 return fmt.Errorf("NestedMapField this[%v](%v) Not Equal that[%v](%v)", i, this.NestedMapField[i], i, that1.NestedMapField[i])
2357 }
2358 }
2359 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2360 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2361 }
2362 return nil
2363 }
2364 func (this *ContainsNestedMap_NestedMap) Equal(that interface{}) bool {
2365 if that == nil {
2366 return this == nil
2367 }
2368
2369 that1, ok := that.(*ContainsNestedMap_NestedMap)
2370 if !ok {
2371 that2, ok := that.(ContainsNestedMap_NestedMap)
2372 if ok {
2373 that1 = &that2
2374 } else {
2375 return false
2376 }
2377 }
2378 if that1 == nil {
2379 return this == nil
2380 } else if this == nil {
2381 return false
2382 }
2383 if len(this.NestedMapField) != len(that1.NestedMapField) {
2384 return false
2385 }
2386 for i := range this.NestedMapField {
2387 if this.NestedMapField[i] != that1.NestedMapField[i] {
2388 return false
2389 }
2390 }
2391 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2392 return false
2393 }
2394 return true
2395 }
2396 func (this *NotPacked) VerboseEqual(that interface{}) error {
2397 if that == nil {
2398 if this == nil {
2399 return nil
2400 }
2401 return fmt.Errorf("that == nil && this != nil")
2402 }
2403
2404 that1, ok := that.(*NotPacked)
2405 if !ok {
2406 that2, ok := that.(NotPacked)
2407 if ok {
2408 that1 = &that2
2409 } else {
2410 return fmt.Errorf("that is not of type *NotPacked")
2411 }
2412 }
2413 if that1 == nil {
2414 if this == nil {
2415 return nil
2416 }
2417 return fmt.Errorf("that is type *NotPacked but is nil && this != nil")
2418 } else if this == nil {
2419 return fmt.Errorf("that is type *NotPacked but is not nil && this == nil")
2420 }
2421 if len(this.Key) != len(that1.Key) {
2422 return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key))
2423 }
2424 for i := range this.Key {
2425 if this.Key[i] != that1.Key[i] {
2426 return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i])
2427 }
2428 }
2429 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2430 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
2431 }
2432 return nil
2433 }
2434 func (this *NotPacked) Equal(that interface{}) bool {
2435 if that == nil {
2436 return this == nil
2437 }
2438
2439 that1, ok := that.(*NotPacked)
2440 if !ok {
2441 that2, ok := that.(NotPacked)
2442 if ok {
2443 that1 = &that2
2444 } else {
2445 return false
2446 }
2447 }
2448 if that1 == nil {
2449 return this == nil
2450 } else if this == nil {
2451 return false
2452 }
2453 if len(this.Key) != len(that1.Key) {
2454 return false
2455 }
2456 for i := range this.Key {
2457 if this.Key[i] != that1.Key[i] {
2458 return false
2459 }
2460 }
2461 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
2462 return false
2463 }
2464 return true
2465 }
2466
2467 type MessageFace interface {
2468 Proto() github_com_gogo_protobuf_proto.Message
2469 GetName() string
2470 GetHilarity() Message_Humour
2471 GetHeightInCm() uint32
2472 GetData() []byte
2473 GetResultCount() int64
2474 GetTrueScotsman() bool
2475 GetScore() float32
2476 GetKey() []uint64
2477 GetNested() *Nested
2478 GetTerrain() map[int64]*Nested
2479 GetProto2Field() *both.NinOptNative
2480 GetProto2Value() map[int64]*both.NinOptEnum
2481 }
2482
2483 func (this *Message) Proto() github_com_gogo_protobuf_proto.Message {
2484 return this
2485 }
2486
2487 func (this *Message) TestProto() github_com_gogo_protobuf_proto.Message {
2488 return NewMessageFromFace(this)
2489 }
2490
2491 func (this *Message) GetName() string {
2492 return this.Name
2493 }
2494
2495 func (this *Message) GetHilarity() Message_Humour {
2496 return this.Hilarity
2497 }
2498
2499 func (this *Message) GetHeightInCm() uint32 {
2500 return this.HeightInCm
2501 }
2502
2503 func (this *Message) GetData() []byte {
2504 return this.Data
2505 }
2506
2507 func (this *Message) GetResultCount() int64 {
2508 return this.ResultCount
2509 }
2510
2511 func (this *Message) GetTrueScotsman() bool {
2512 return this.TrueScotsman
2513 }
2514
2515 func (this *Message) GetScore() float32 {
2516 return this.Score
2517 }
2518
2519 func (this *Message) GetKey() []uint64 {
2520 return this.Key
2521 }
2522
2523 func (this *Message) GetNested() *Nested {
2524 return this.Nested
2525 }
2526
2527 func (this *Message) GetTerrain() map[int64]*Nested {
2528 return this.Terrain
2529 }
2530
2531 func (this *Message) GetProto2Field() *both.NinOptNative {
2532 return this.Proto2Field
2533 }
2534
2535 func (this *Message) GetProto2Value() map[int64]*both.NinOptEnum {
2536 return this.Proto2Value
2537 }
2538
2539 func NewMessageFromFace(that MessageFace) *Message {
2540 this := &Message{}
2541 this.Name = that.GetName()
2542 this.Hilarity = that.GetHilarity()
2543 this.HeightInCm = that.GetHeightInCm()
2544 this.Data = that.GetData()
2545 this.ResultCount = that.GetResultCount()
2546 this.TrueScotsman = that.GetTrueScotsman()
2547 this.Score = that.GetScore()
2548 this.Key = that.GetKey()
2549 this.Nested = that.GetNested()
2550 this.Terrain = that.GetTerrain()
2551 this.Proto2Field = that.GetProto2Field()
2552 this.Proto2Value = that.GetProto2Value()
2553 return this
2554 }
2555
2556 type NestedFace interface {
2557 Proto() github_com_gogo_protobuf_proto.Message
2558 GetBunny() string
2559 }
2560
2561 func (this *Nested) Proto() github_com_gogo_protobuf_proto.Message {
2562 return this
2563 }
2564
2565 func (this *Nested) TestProto() github_com_gogo_protobuf_proto.Message {
2566 return NewNestedFromFace(this)
2567 }
2568
2569 func (this *Nested) GetBunny() string {
2570 return this.Bunny
2571 }
2572
2573 func NewNestedFromFace(that NestedFace) *Nested {
2574 this := &Nested{}
2575 this.Bunny = that.GetBunny()
2576 return this
2577 }
2578
2579 type AllMapsFace interface {
2580 Proto() github_com_gogo_protobuf_proto.Message
2581 GetStringToDoubleMap() map[string]float64
2582 GetStringToFloatMap() map[string]float32
2583 GetInt32Map() map[int32]int32
2584 GetInt64Map() map[int64]int64
2585 GetUint32Map() map[uint32]uint32
2586 GetUint64Map() map[uint64]uint64
2587 GetSint32Map() map[int32]int32
2588 GetSint64Map() map[int64]int64
2589 GetFixed32Map() map[uint32]uint32
2590 GetSfixed32Map() map[int32]int32
2591 GetFixed64Map() map[uint64]uint64
2592 GetSfixed64Map() map[int64]int64
2593 GetBoolMap() map[bool]bool
2594 GetStringMap() map[string]string
2595 GetStringToBytesMap() map[string][]byte
2596 GetStringToEnumMap() map[string]MapEnum
2597 GetStringToMsgMap() map[string]*FloatingPoint
2598 }
2599
2600 func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message {
2601 return this
2602 }
2603
2604 func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message {
2605 return NewAllMapsFromFace(this)
2606 }
2607
2608 func (this *AllMaps) GetStringToDoubleMap() map[string]float64 {
2609 return this.StringToDoubleMap
2610 }
2611
2612 func (this *AllMaps) GetStringToFloatMap() map[string]float32 {
2613 return this.StringToFloatMap
2614 }
2615
2616 func (this *AllMaps) GetInt32Map() map[int32]int32 {
2617 return this.Int32Map
2618 }
2619
2620 func (this *AllMaps) GetInt64Map() map[int64]int64 {
2621 return this.Int64Map
2622 }
2623
2624 func (this *AllMaps) GetUint32Map() map[uint32]uint32 {
2625 return this.Uint32Map
2626 }
2627
2628 func (this *AllMaps) GetUint64Map() map[uint64]uint64 {
2629 return this.Uint64Map
2630 }
2631
2632 func (this *AllMaps) GetSint32Map() map[int32]int32 {
2633 return this.Sint32Map
2634 }
2635
2636 func (this *AllMaps) GetSint64Map() map[int64]int64 {
2637 return this.Sint64Map
2638 }
2639
2640 func (this *AllMaps) GetFixed32Map() map[uint32]uint32 {
2641 return this.Fixed32Map
2642 }
2643
2644 func (this *AllMaps) GetSfixed32Map() map[int32]int32 {
2645 return this.Sfixed32Map
2646 }
2647
2648 func (this *AllMaps) GetFixed64Map() map[uint64]uint64 {
2649 return this.Fixed64Map
2650 }
2651
2652 func (this *AllMaps) GetSfixed64Map() map[int64]int64 {
2653 return this.Sfixed64Map
2654 }
2655
2656 func (this *AllMaps) GetBoolMap() map[bool]bool {
2657 return this.BoolMap
2658 }
2659
2660 func (this *AllMaps) GetStringMap() map[string]string {
2661 return this.StringMap
2662 }
2663
2664 func (this *AllMaps) GetStringToBytesMap() map[string][]byte {
2665 return this.StringToBytesMap
2666 }
2667
2668 func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum {
2669 return this.StringToEnumMap
2670 }
2671
2672 func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint {
2673 return this.StringToMsgMap
2674 }
2675
2676 func NewAllMapsFromFace(that AllMapsFace) *AllMaps {
2677 this := &AllMaps{}
2678 this.StringToDoubleMap = that.GetStringToDoubleMap()
2679 this.StringToFloatMap = that.GetStringToFloatMap()
2680 this.Int32Map = that.GetInt32Map()
2681 this.Int64Map = that.GetInt64Map()
2682 this.Uint32Map = that.GetUint32Map()
2683 this.Uint64Map = that.GetUint64Map()
2684 this.Sint32Map = that.GetSint32Map()
2685 this.Sint64Map = that.GetSint64Map()
2686 this.Fixed32Map = that.GetFixed32Map()
2687 this.Sfixed32Map = that.GetSfixed32Map()
2688 this.Fixed64Map = that.GetFixed64Map()
2689 this.Sfixed64Map = that.GetSfixed64Map()
2690 this.BoolMap = that.GetBoolMap()
2691 this.StringMap = that.GetStringMap()
2692 this.StringToBytesMap = that.GetStringToBytesMap()
2693 this.StringToEnumMap = that.GetStringToEnumMap()
2694 this.StringToMsgMap = that.GetStringToMsgMap()
2695 return this
2696 }
2697
2698 type AllMapsOrderedFace interface {
2699 Proto() github_com_gogo_protobuf_proto.Message
2700 GetStringToDoubleMap() map[string]float64
2701 GetStringToFloatMap() map[string]float32
2702 GetInt32Map() map[int32]int32
2703 GetInt64Map() map[int64]int64
2704 GetUint32Map() map[uint32]uint32
2705 GetUint64Map() map[uint64]uint64
2706 GetSint32Map() map[int32]int32
2707 GetSint64Map() map[int64]int64
2708 GetFixed32Map() map[uint32]uint32
2709 GetSfixed32Map() map[int32]int32
2710 GetFixed64Map() map[uint64]uint64
2711 GetSfixed64Map() map[int64]int64
2712 GetBoolMap() map[bool]bool
2713 GetStringMap() map[string]string
2714 GetStringToBytesMap() map[string][]byte
2715 GetStringToEnumMap() map[string]MapEnum
2716 GetStringToMsgMap() map[string]*FloatingPoint
2717 }
2718
2719 func (this *AllMapsOrdered) Proto() github_com_gogo_protobuf_proto.Message {
2720 return this
2721 }
2722
2723 func (this *AllMapsOrdered) TestProto() github_com_gogo_protobuf_proto.Message {
2724 return NewAllMapsOrderedFromFace(this)
2725 }
2726
2727 func (this *AllMapsOrdered) GetStringToDoubleMap() map[string]float64 {
2728 return this.StringToDoubleMap
2729 }
2730
2731 func (this *AllMapsOrdered) GetStringToFloatMap() map[string]float32 {
2732 return this.StringToFloatMap
2733 }
2734
2735 func (this *AllMapsOrdered) GetInt32Map() map[int32]int32 {
2736 return this.Int32Map
2737 }
2738
2739 func (this *AllMapsOrdered) GetInt64Map() map[int64]int64 {
2740 return this.Int64Map
2741 }
2742
2743 func (this *AllMapsOrdered) GetUint32Map() map[uint32]uint32 {
2744 return this.Uint32Map
2745 }
2746
2747 func (this *AllMapsOrdered) GetUint64Map() map[uint64]uint64 {
2748 return this.Uint64Map
2749 }
2750
2751 func (this *AllMapsOrdered) GetSint32Map() map[int32]int32 {
2752 return this.Sint32Map
2753 }
2754
2755 func (this *AllMapsOrdered) GetSint64Map() map[int64]int64 {
2756 return this.Sint64Map
2757 }
2758
2759 func (this *AllMapsOrdered) GetFixed32Map() map[uint32]uint32 {
2760 return this.Fixed32Map
2761 }
2762
2763 func (this *AllMapsOrdered) GetSfixed32Map() map[int32]int32 {
2764 return this.Sfixed32Map
2765 }
2766
2767 func (this *AllMapsOrdered) GetFixed64Map() map[uint64]uint64 {
2768 return this.Fixed64Map
2769 }
2770
2771 func (this *AllMapsOrdered) GetSfixed64Map() map[int64]int64 {
2772 return this.Sfixed64Map
2773 }
2774
2775 func (this *AllMapsOrdered) GetBoolMap() map[bool]bool {
2776 return this.BoolMap
2777 }
2778
2779 func (this *AllMapsOrdered) GetStringMap() map[string]string {
2780 return this.StringMap
2781 }
2782
2783 func (this *AllMapsOrdered) GetStringToBytesMap() map[string][]byte {
2784 return this.StringToBytesMap
2785 }
2786
2787 func (this *AllMapsOrdered) GetStringToEnumMap() map[string]MapEnum {
2788 return this.StringToEnumMap
2789 }
2790
2791 func (this *AllMapsOrdered) GetStringToMsgMap() map[string]*FloatingPoint {
2792 return this.StringToMsgMap
2793 }
2794
2795 func NewAllMapsOrderedFromFace(that AllMapsOrderedFace) *AllMapsOrdered {
2796 this := &AllMapsOrdered{}
2797 this.StringToDoubleMap = that.GetStringToDoubleMap()
2798 this.StringToFloatMap = that.GetStringToFloatMap()
2799 this.Int32Map = that.GetInt32Map()
2800 this.Int64Map = that.GetInt64Map()
2801 this.Uint32Map = that.GetUint32Map()
2802 this.Uint64Map = that.GetUint64Map()
2803 this.Sint32Map = that.GetSint32Map()
2804 this.Sint64Map = that.GetSint64Map()
2805 this.Fixed32Map = that.GetFixed32Map()
2806 this.Sfixed32Map = that.GetSfixed32Map()
2807 this.Fixed64Map = that.GetFixed64Map()
2808 this.Sfixed64Map = that.GetSfixed64Map()
2809 this.BoolMap = that.GetBoolMap()
2810 this.StringMap = that.GetStringMap()
2811 this.StringToBytesMap = that.GetStringToBytesMap()
2812 this.StringToEnumMap = that.GetStringToEnumMap()
2813 this.StringToMsgMap = that.GetStringToMsgMap()
2814 return this
2815 }
2816
2817 type MessageWithMapFace interface {
2818 Proto() github_com_gogo_protobuf_proto.Message
2819 GetNameMapping() map[int32]string
2820 GetMsgMapping() map[int64]*FloatingPoint
2821 GetByteMapping() map[bool][]byte
2822 }
2823
2824 func (this *MessageWithMap) Proto() github_com_gogo_protobuf_proto.Message {
2825 return this
2826 }
2827
2828 func (this *MessageWithMap) TestProto() github_com_gogo_protobuf_proto.Message {
2829 return NewMessageWithMapFromFace(this)
2830 }
2831
2832 func (this *MessageWithMap) GetNameMapping() map[int32]string {
2833 return this.NameMapping
2834 }
2835
2836 func (this *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint {
2837 return this.MsgMapping
2838 }
2839
2840 func (this *MessageWithMap) GetByteMapping() map[bool][]byte {
2841 return this.ByteMapping
2842 }
2843
2844 func NewMessageWithMapFromFace(that MessageWithMapFace) *MessageWithMap {
2845 this := &MessageWithMap{}
2846 this.NameMapping = that.GetNameMapping()
2847 this.MsgMapping = that.GetMsgMapping()
2848 this.ByteMapping = that.GetByteMapping()
2849 return this
2850 }
2851
2852 type FloatingPointFace interface {
2853 Proto() github_com_gogo_protobuf_proto.Message
2854 GetF() float64
2855 }
2856
2857 func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message {
2858 return this
2859 }
2860
2861 func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message {
2862 return NewFloatingPointFromFace(this)
2863 }
2864
2865 func (this *FloatingPoint) GetF() float64 {
2866 return this.F
2867 }
2868
2869 func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint {
2870 this := &FloatingPoint{}
2871 this.F = that.GetF()
2872 return this
2873 }
2874
2875 type Uint128PairFace interface {
2876 Proto() github_com_gogo_protobuf_proto.Message
2877 GetLeft() github_com_gogo_protobuf_test_custom.Uint128
2878 GetRight() *github_com_gogo_protobuf_test_custom.Uint128
2879 }
2880
2881 func (this *Uint128Pair) Proto() github_com_gogo_protobuf_proto.Message {
2882 return this
2883 }
2884
2885 func (this *Uint128Pair) TestProto() github_com_gogo_protobuf_proto.Message {
2886 return NewUint128PairFromFace(this)
2887 }
2888
2889 func (this *Uint128Pair) GetLeft() github_com_gogo_protobuf_test_custom.Uint128 {
2890 return this.Left
2891 }
2892
2893 func (this *Uint128Pair) GetRight() *github_com_gogo_protobuf_test_custom.Uint128 {
2894 return this.Right
2895 }
2896
2897 func NewUint128PairFromFace(that Uint128PairFace) *Uint128Pair {
2898 this := &Uint128Pair{}
2899 this.Left = that.GetLeft()
2900 this.Right = that.GetRight()
2901 return this
2902 }
2903
2904 type ContainsNestedMapFace interface {
2905 Proto() github_com_gogo_protobuf_proto.Message
2906 }
2907
2908 func (this *ContainsNestedMap) Proto() github_com_gogo_protobuf_proto.Message {
2909 return this
2910 }
2911
2912 func (this *ContainsNestedMap) TestProto() github_com_gogo_protobuf_proto.Message {
2913 return NewContainsNestedMapFromFace(this)
2914 }
2915
2916 func NewContainsNestedMapFromFace(that ContainsNestedMapFace) *ContainsNestedMap {
2917 this := &ContainsNestedMap{}
2918 return this
2919 }
2920
2921 type ContainsNestedMap_NestedMapFace interface {
2922 Proto() github_com_gogo_protobuf_proto.Message
2923 GetNestedMapField() map[string]float64
2924 }
2925
2926 func (this *ContainsNestedMap_NestedMap) Proto() github_com_gogo_protobuf_proto.Message {
2927 return this
2928 }
2929
2930 func (this *ContainsNestedMap_NestedMap) TestProto() github_com_gogo_protobuf_proto.Message {
2931 return NewContainsNestedMap_NestedMapFromFace(this)
2932 }
2933
2934 func (this *ContainsNestedMap_NestedMap) GetNestedMapField() map[string]float64 {
2935 return this.NestedMapField
2936 }
2937
2938 func NewContainsNestedMap_NestedMapFromFace(that ContainsNestedMap_NestedMapFace) *ContainsNestedMap_NestedMap {
2939 this := &ContainsNestedMap_NestedMap{}
2940 this.NestedMapField = that.GetNestedMapField()
2941 return this
2942 }
2943
2944 type NotPackedFace interface {
2945 Proto() github_com_gogo_protobuf_proto.Message
2946 GetKey() []uint64
2947 }
2948
2949 func (this *NotPacked) Proto() github_com_gogo_protobuf_proto.Message {
2950 return this
2951 }
2952
2953 func (this *NotPacked) TestProto() github_com_gogo_protobuf_proto.Message {
2954 return NewNotPackedFromFace(this)
2955 }
2956
2957 func (this *NotPacked) GetKey() []uint64 {
2958 return this.Key
2959 }
2960
2961 func NewNotPackedFromFace(that NotPackedFace) *NotPacked {
2962 this := &NotPacked{}
2963 this.Key = that.GetKey()
2964 return this
2965 }
2966
2967 func (this *Message) GoString() string {
2968 if this == nil {
2969 return "nil"
2970 }
2971 s := make([]string, 0, 16)
2972 s = append(s, "&theproto3.Message{")
2973 s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
2974 s = append(s, "Hilarity: "+fmt.Sprintf("%#v", this.Hilarity)+",\n")
2975 s = append(s, "HeightInCm: "+fmt.Sprintf("%#v", this.HeightInCm)+",\n")
2976 s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
2977 s = append(s, "ResultCount: "+fmt.Sprintf("%#v", this.ResultCount)+",\n")
2978 s = append(s, "TrueScotsman: "+fmt.Sprintf("%#v", this.TrueScotsman)+",\n")
2979 s = append(s, "Score: "+fmt.Sprintf("%#v", this.Score)+",\n")
2980 s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
2981 if this.Nested != nil {
2982 s = append(s, "Nested: "+fmt.Sprintf("%#v", this.Nested)+",\n")
2983 }
2984 keysForTerrain := make([]int64, 0, len(this.Terrain))
2985 for k := range this.Terrain {
2986 keysForTerrain = append(keysForTerrain, k)
2987 }
2988 github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain)
2989 mapStringForTerrain := "map[int64]*Nested{"
2990 for _, k := range keysForTerrain {
2991 mapStringForTerrain += fmt.Sprintf("%#v: %#v,", k, this.Terrain[k])
2992 }
2993 mapStringForTerrain += "}"
2994 if this.Terrain != nil {
2995 s = append(s, "Terrain: "+mapStringForTerrain+",\n")
2996 }
2997 if this.Proto2Field != nil {
2998 s = append(s, "Proto2Field: "+fmt.Sprintf("%#v", this.Proto2Field)+",\n")
2999 }
3000 keysForProto2Value := make([]int64, 0, len(this.Proto2Value))
3001 for k := range this.Proto2Value {
3002 keysForProto2Value = append(keysForProto2Value, k)
3003 }
3004 github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value)
3005 mapStringForProto2Value := "map[int64]*both.NinOptEnum{"
3006 for _, k := range keysForProto2Value {
3007 mapStringForProto2Value += fmt.Sprintf("%#v: %#v,", k, this.Proto2Value[k])
3008 }
3009 mapStringForProto2Value += "}"
3010 if this.Proto2Value != nil {
3011 s = append(s, "Proto2Value: "+mapStringForProto2Value+",\n")
3012 }
3013 if this.XXX_unrecognized != nil {
3014 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3015 }
3016 s = append(s, "}")
3017 return strings.Join(s, "")
3018 }
3019 func (this *Nested) GoString() string {
3020 if this == nil {
3021 return "nil"
3022 }
3023 s := make([]string, 0, 5)
3024 s = append(s, "&theproto3.Nested{")
3025 s = append(s, "Bunny: "+fmt.Sprintf("%#v", this.Bunny)+",\n")
3026 if this.XXX_unrecognized != nil {
3027 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3028 }
3029 s = append(s, "}")
3030 return strings.Join(s, "")
3031 }
3032 func (this *AllMaps) GoString() string {
3033 if this == nil {
3034 return "nil"
3035 }
3036 s := make([]string, 0, 21)
3037 s = append(s, "&theproto3.AllMaps{")
3038 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
3039 for k := range this.StringToDoubleMap {
3040 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
3041 }
3042 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
3043 mapStringForStringToDoubleMap := "map[string]float64{"
3044 for _, k := range keysForStringToDoubleMap {
3045 mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k])
3046 }
3047 mapStringForStringToDoubleMap += "}"
3048 if this.StringToDoubleMap != nil {
3049 s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n")
3050 }
3051 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
3052 for k := range this.StringToFloatMap {
3053 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
3054 }
3055 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
3056 mapStringForStringToFloatMap := "map[string]float32{"
3057 for _, k := range keysForStringToFloatMap {
3058 mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k])
3059 }
3060 mapStringForStringToFloatMap += "}"
3061 if this.StringToFloatMap != nil {
3062 s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n")
3063 }
3064 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
3065 for k := range this.Int32Map {
3066 keysForInt32Map = append(keysForInt32Map, k)
3067 }
3068 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
3069 mapStringForInt32Map := "map[int32]int32{"
3070 for _, k := range keysForInt32Map {
3071 mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k])
3072 }
3073 mapStringForInt32Map += "}"
3074 if this.Int32Map != nil {
3075 s = append(s, "Int32Map: "+mapStringForInt32Map+",\n")
3076 }
3077 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
3078 for k := range this.Int64Map {
3079 keysForInt64Map = append(keysForInt64Map, k)
3080 }
3081 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
3082 mapStringForInt64Map := "map[int64]int64{"
3083 for _, k := range keysForInt64Map {
3084 mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k])
3085 }
3086 mapStringForInt64Map += "}"
3087 if this.Int64Map != nil {
3088 s = append(s, "Int64Map: "+mapStringForInt64Map+",\n")
3089 }
3090 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
3091 for k := range this.Uint32Map {
3092 keysForUint32Map = append(keysForUint32Map, k)
3093 }
3094 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
3095 mapStringForUint32Map := "map[uint32]uint32{"
3096 for _, k := range keysForUint32Map {
3097 mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k])
3098 }
3099 mapStringForUint32Map += "}"
3100 if this.Uint32Map != nil {
3101 s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n")
3102 }
3103 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
3104 for k := range this.Uint64Map {
3105 keysForUint64Map = append(keysForUint64Map, k)
3106 }
3107 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
3108 mapStringForUint64Map := "map[uint64]uint64{"
3109 for _, k := range keysForUint64Map {
3110 mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k])
3111 }
3112 mapStringForUint64Map += "}"
3113 if this.Uint64Map != nil {
3114 s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n")
3115 }
3116 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
3117 for k := range this.Sint32Map {
3118 keysForSint32Map = append(keysForSint32Map, k)
3119 }
3120 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
3121 mapStringForSint32Map := "map[int32]int32{"
3122 for _, k := range keysForSint32Map {
3123 mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k])
3124 }
3125 mapStringForSint32Map += "}"
3126 if this.Sint32Map != nil {
3127 s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n")
3128 }
3129 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
3130 for k := range this.Sint64Map {
3131 keysForSint64Map = append(keysForSint64Map, k)
3132 }
3133 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
3134 mapStringForSint64Map := "map[int64]int64{"
3135 for _, k := range keysForSint64Map {
3136 mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k])
3137 }
3138 mapStringForSint64Map += "}"
3139 if this.Sint64Map != nil {
3140 s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n")
3141 }
3142 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
3143 for k := range this.Fixed32Map {
3144 keysForFixed32Map = append(keysForFixed32Map, k)
3145 }
3146 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
3147 mapStringForFixed32Map := "map[uint32]uint32{"
3148 for _, k := range keysForFixed32Map {
3149 mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k])
3150 }
3151 mapStringForFixed32Map += "}"
3152 if this.Fixed32Map != nil {
3153 s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n")
3154 }
3155 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
3156 for k := range this.Sfixed32Map {
3157 keysForSfixed32Map = append(keysForSfixed32Map, k)
3158 }
3159 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
3160 mapStringForSfixed32Map := "map[int32]int32{"
3161 for _, k := range keysForSfixed32Map {
3162 mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k])
3163 }
3164 mapStringForSfixed32Map += "}"
3165 if this.Sfixed32Map != nil {
3166 s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n")
3167 }
3168 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
3169 for k := range this.Fixed64Map {
3170 keysForFixed64Map = append(keysForFixed64Map, k)
3171 }
3172 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
3173 mapStringForFixed64Map := "map[uint64]uint64{"
3174 for _, k := range keysForFixed64Map {
3175 mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k])
3176 }
3177 mapStringForFixed64Map += "}"
3178 if this.Fixed64Map != nil {
3179 s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n")
3180 }
3181 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
3182 for k := range this.Sfixed64Map {
3183 keysForSfixed64Map = append(keysForSfixed64Map, k)
3184 }
3185 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
3186 mapStringForSfixed64Map := "map[int64]int64{"
3187 for _, k := range keysForSfixed64Map {
3188 mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k])
3189 }
3190 mapStringForSfixed64Map += "}"
3191 if this.Sfixed64Map != nil {
3192 s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n")
3193 }
3194 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
3195 for k := range this.BoolMap {
3196 keysForBoolMap = append(keysForBoolMap, k)
3197 }
3198 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
3199 mapStringForBoolMap := "map[bool]bool{"
3200 for _, k := range keysForBoolMap {
3201 mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k])
3202 }
3203 mapStringForBoolMap += "}"
3204 if this.BoolMap != nil {
3205 s = append(s, "BoolMap: "+mapStringForBoolMap+",\n")
3206 }
3207 keysForStringMap := make([]string, 0, len(this.StringMap))
3208 for k := range this.StringMap {
3209 keysForStringMap = append(keysForStringMap, k)
3210 }
3211 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
3212 mapStringForStringMap := "map[string]string{"
3213 for _, k := range keysForStringMap {
3214 mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k])
3215 }
3216 mapStringForStringMap += "}"
3217 if this.StringMap != nil {
3218 s = append(s, "StringMap: "+mapStringForStringMap+",\n")
3219 }
3220 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
3221 for k := range this.StringToBytesMap {
3222 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
3223 }
3224 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
3225 mapStringForStringToBytesMap := "map[string][]byte{"
3226 for _, k := range keysForStringToBytesMap {
3227 mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k])
3228 }
3229 mapStringForStringToBytesMap += "}"
3230 if this.StringToBytesMap != nil {
3231 s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n")
3232 }
3233 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
3234 for k := range this.StringToEnumMap {
3235 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
3236 }
3237 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
3238 mapStringForStringToEnumMap := "map[string]MapEnum{"
3239 for _, k := range keysForStringToEnumMap {
3240 mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k])
3241 }
3242 mapStringForStringToEnumMap += "}"
3243 if this.StringToEnumMap != nil {
3244 s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n")
3245 }
3246 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
3247 for k := range this.StringToMsgMap {
3248 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
3249 }
3250 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
3251 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
3252 for _, k := range keysForStringToMsgMap {
3253 mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k])
3254 }
3255 mapStringForStringToMsgMap += "}"
3256 if this.StringToMsgMap != nil {
3257 s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n")
3258 }
3259 if this.XXX_unrecognized != nil {
3260 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3261 }
3262 s = append(s, "}")
3263 return strings.Join(s, "")
3264 }
3265 func (this *AllMapsOrdered) GoString() string {
3266 if this == nil {
3267 return "nil"
3268 }
3269 s := make([]string, 0, 21)
3270 s = append(s, "&theproto3.AllMapsOrdered{")
3271 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
3272 for k := range this.StringToDoubleMap {
3273 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
3274 }
3275 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
3276 mapStringForStringToDoubleMap := "map[string]float64{"
3277 for _, k := range keysForStringToDoubleMap {
3278 mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k])
3279 }
3280 mapStringForStringToDoubleMap += "}"
3281 if this.StringToDoubleMap != nil {
3282 s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n")
3283 }
3284 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
3285 for k := range this.StringToFloatMap {
3286 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
3287 }
3288 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
3289 mapStringForStringToFloatMap := "map[string]float32{"
3290 for _, k := range keysForStringToFloatMap {
3291 mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k])
3292 }
3293 mapStringForStringToFloatMap += "}"
3294 if this.StringToFloatMap != nil {
3295 s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n")
3296 }
3297 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
3298 for k := range this.Int32Map {
3299 keysForInt32Map = append(keysForInt32Map, k)
3300 }
3301 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
3302 mapStringForInt32Map := "map[int32]int32{"
3303 for _, k := range keysForInt32Map {
3304 mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k])
3305 }
3306 mapStringForInt32Map += "}"
3307 if this.Int32Map != nil {
3308 s = append(s, "Int32Map: "+mapStringForInt32Map+",\n")
3309 }
3310 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
3311 for k := range this.Int64Map {
3312 keysForInt64Map = append(keysForInt64Map, k)
3313 }
3314 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
3315 mapStringForInt64Map := "map[int64]int64{"
3316 for _, k := range keysForInt64Map {
3317 mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k])
3318 }
3319 mapStringForInt64Map += "}"
3320 if this.Int64Map != nil {
3321 s = append(s, "Int64Map: "+mapStringForInt64Map+",\n")
3322 }
3323 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
3324 for k := range this.Uint32Map {
3325 keysForUint32Map = append(keysForUint32Map, k)
3326 }
3327 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
3328 mapStringForUint32Map := "map[uint32]uint32{"
3329 for _, k := range keysForUint32Map {
3330 mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k])
3331 }
3332 mapStringForUint32Map += "}"
3333 if this.Uint32Map != nil {
3334 s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n")
3335 }
3336 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
3337 for k := range this.Uint64Map {
3338 keysForUint64Map = append(keysForUint64Map, k)
3339 }
3340 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
3341 mapStringForUint64Map := "map[uint64]uint64{"
3342 for _, k := range keysForUint64Map {
3343 mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k])
3344 }
3345 mapStringForUint64Map += "}"
3346 if this.Uint64Map != nil {
3347 s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n")
3348 }
3349 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
3350 for k := range this.Sint32Map {
3351 keysForSint32Map = append(keysForSint32Map, k)
3352 }
3353 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
3354 mapStringForSint32Map := "map[int32]int32{"
3355 for _, k := range keysForSint32Map {
3356 mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k])
3357 }
3358 mapStringForSint32Map += "}"
3359 if this.Sint32Map != nil {
3360 s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n")
3361 }
3362 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
3363 for k := range this.Sint64Map {
3364 keysForSint64Map = append(keysForSint64Map, k)
3365 }
3366 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
3367 mapStringForSint64Map := "map[int64]int64{"
3368 for _, k := range keysForSint64Map {
3369 mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k])
3370 }
3371 mapStringForSint64Map += "}"
3372 if this.Sint64Map != nil {
3373 s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n")
3374 }
3375 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
3376 for k := range this.Fixed32Map {
3377 keysForFixed32Map = append(keysForFixed32Map, k)
3378 }
3379 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
3380 mapStringForFixed32Map := "map[uint32]uint32{"
3381 for _, k := range keysForFixed32Map {
3382 mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k])
3383 }
3384 mapStringForFixed32Map += "}"
3385 if this.Fixed32Map != nil {
3386 s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n")
3387 }
3388 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
3389 for k := range this.Sfixed32Map {
3390 keysForSfixed32Map = append(keysForSfixed32Map, k)
3391 }
3392 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
3393 mapStringForSfixed32Map := "map[int32]int32{"
3394 for _, k := range keysForSfixed32Map {
3395 mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k])
3396 }
3397 mapStringForSfixed32Map += "}"
3398 if this.Sfixed32Map != nil {
3399 s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n")
3400 }
3401 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
3402 for k := range this.Fixed64Map {
3403 keysForFixed64Map = append(keysForFixed64Map, k)
3404 }
3405 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
3406 mapStringForFixed64Map := "map[uint64]uint64{"
3407 for _, k := range keysForFixed64Map {
3408 mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k])
3409 }
3410 mapStringForFixed64Map += "}"
3411 if this.Fixed64Map != nil {
3412 s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n")
3413 }
3414 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
3415 for k := range this.Sfixed64Map {
3416 keysForSfixed64Map = append(keysForSfixed64Map, k)
3417 }
3418 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
3419 mapStringForSfixed64Map := "map[int64]int64{"
3420 for _, k := range keysForSfixed64Map {
3421 mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k])
3422 }
3423 mapStringForSfixed64Map += "}"
3424 if this.Sfixed64Map != nil {
3425 s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n")
3426 }
3427 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
3428 for k := range this.BoolMap {
3429 keysForBoolMap = append(keysForBoolMap, k)
3430 }
3431 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
3432 mapStringForBoolMap := "map[bool]bool{"
3433 for _, k := range keysForBoolMap {
3434 mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k])
3435 }
3436 mapStringForBoolMap += "}"
3437 if this.BoolMap != nil {
3438 s = append(s, "BoolMap: "+mapStringForBoolMap+",\n")
3439 }
3440 keysForStringMap := make([]string, 0, len(this.StringMap))
3441 for k := range this.StringMap {
3442 keysForStringMap = append(keysForStringMap, k)
3443 }
3444 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
3445 mapStringForStringMap := "map[string]string{"
3446 for _, k := range keysForStringMap {
3447 mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k])
3448 }
3449 mapStringForStringMap += "}"
3450 if this.StringMap != nil {
3451 s = append(s, "StringMap: "+mapStringForStringMap+",\n")
3452 }
3453 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
3454 for k := range this.StringToBytesMap {
3455 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
3456 }
3457 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
3458 mapStringForStringToBytesMap := "map[string][]byte{"
3459 for _, k := range keysForStringToBytesMap {
3460 mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k])
3461 }
3462 mapStringForStringToBytesMap += "}"
3463 if this.StringToBytesMap != nil {
3464 s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n")
3465 }
3466 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
3467 for k := range this.StringToEnumMap {
3468 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
3469 }
3470 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
3471 mapStringForStringToEnumMap := "map[string]MapEnum{"
3472 for _, k := range keysForStringToEnumMap {
3473 mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k])
3474 }
3475 mapStringForStringToEnumMap += "}"
3476 if this.StringToEnumMap != nil {
3477 s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n")
3478 }
3479 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
3480 for k := range this.StringToMsgMap {
3481 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
3482 }
3483 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
3484 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
3485 for _, k := range keysForStringToMsgMap {
3486 mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k])
3487 }
3488 mapStringForStringToMsgMap += "}"
3489 if this.StringToMsgMap != nil {
3490 s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n")
3491 }
3492 if this.XXX_unrecognized != nil {
3493 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3494 }
3495 s = append(s, "}")
3496 return strings.Join(s, "")
3497 }
3498 func (this *MessageWithMap) GoString() string {
3499 if this == nil {
3500 return "nil"
3501 }
3502 s := make([]string, 0, 7)
3503 s = append(s, "&theproto3.MessageWithMap{")
3504 keysForNameMapping := make([]int32, 0, len(this.NameMapping))
3505 for k := range this.NameMapping {
3506 keysForNameMapping = append(keysForNameMapping, k)
3507 }
3508 github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping)
3509 mapStringForNameMapping := "map[int32]string{"
3510 for _, k := range keysForNameMapping {
3511 mapStringForNameMapping += fmt.Sprintf("%#v: %#v,", k, this.NameMapping[k])
3512 }
3513 mapStringForNameMapping += "}"
3514 if this.NameMapping != nil {
3515 s = append(s, "NameMapping: "+mapStringForNameMapping+",\n")
3516 }
3517 keysForMsgMapping := make([]int64, 0, len(this.MsgMapping))
3518 for k := range this.MsgMapping {
3519 keysForMsgMapping = append(keysForMsgMapping, k)
3520 }
3521 github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping)
3522 mapStringForMsgMapping := "map[int64]*FloatingPoint{"
3523 for _, k := range keysForMsgMapping {
3524 mapStringForMsgMapping += fmt.Sprintf("%#v: %#v,", k, this.MsgMapping[k])
3525 }
3526 mapStringForMsgMapping += "}"
3527 if this.MsgMapping != nil {
3528 s = append(s, "MsgMapping: "+mapStringForMsgMapping+",\n")
3529 }
3530 keysForByteMapping := make([]bool, 0, len(this.ByteMapping))
3531 for k := range this.ByteMapping {
3532 keysForByteMapping = append(keysForByteMapping, k)
3533 }
3534 github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping)
3535 mapStringForByteMapping := "map[bool][]byte{"
3536 for _, k := range keysForByteMapping {
3537 mapStringForByteMapping += fmt.Sprintf("%#v: %#v,", k, this.ByteMapping[k])
3538 }
3539 mapStringForByteMapping += "}"
3540 if this.ByteMapping != nil {
3541 s = append(s, "ByteMapping: "+mapStringForByteMapping+",\n")
3542 }
3543 if this.XXX_unrecognized != nil {
3544 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3545 }
3546 s = append(s, "}")
3547 return strings.Join(s, "")
3548 }
3549 func (this *FloatingPoint) GoString() string {
3550 if this == nil {
3551 return "nil"
3552 }
3553 s := make([]string, 0, 5)
3554 s = append(s, "&theproto3.FloatingPoint{")
3555 s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n")
3556 if this.XXX_unrecognized != nil {
3557 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3558 }
3559 s = append(s, "}")
3560 return strings.Join(s, "")
3561 }
3562 func (this *Uint128Pair) GoString() string {
3563 if this == nil {
3564 return "nil"
3565 }
3566 s := make([]string, 0, 6)
3567 s = append(s, "&theproto3.Uint128Pair{")
3568 s = append(s, "Left: "+fmt.Sprintf("%#v", this.Left)+",\n")
3569 s = append(s, "Right: "+fmt.Sprintf("%#v", this.Right)+",\n")
3570 if this.XXX_unrecognized != nil {
3571 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3572 }
3573 s = append(s, "}")
3574 return strings.Join(s, "")
3575 }
3576 func (this *ContainsNestedMap) GoString() string {
3577 if this == nil {
3578 return "nil"
3579 }
3580 s := make([]string, 0, 4)
3581 s = append(s, "&theproto3.ContainsNestedMap{")
3582 if this.XXX_unrecognized != nil {
3583 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3584 }
3585 s = append(s, "}")
3586 return strings.Join(s, "")
3587 }
3588 func (this *ContainsNestedMap_NestedMap) GoString() string {
3589 if this == nil {
3590 return "nil"
3591 }
3592 s := make([]string, 0, 5)
3593 s = append(s, "&theproto3.ContainsNestedMap_NestedMap{")
3594 keysForNestedMapField := make([]string, 0, len(this.NestedMapField))
3595 for k := range this.NestedMapField {
3596 keysForNestedMapField = append(keysForNestedMapField, k)
3597 }
3598 github_com_gogo_protobuf_sortkeys.Strings(keysForNestedMapField)
3599 mapStringForNestedMapField := "map[string]float64{"
3600 for _, k := range keysForNestedMapField {
3601 mapStringForNestedMapField += fmt.Sprintf("%#v: %#v,", k, this.NestedMapField[k])
3602 }
3603 mapStringForNestedMapField += "}"
3604 if this.NestedMapField != nil {
3605 s = append(s, "NestedMapField: "+mapStringForNestedMapField+",\n")
3606 }
3607 if this.XXX_unrecognized != nil {
3608 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3609 }
3610 s = append(s, "}")
3611 return strings.Join(s, "")
3612 }
3613 func (this *NotPacked) GoString() string {
3614 if this == nil {
3615 return "nil"
3616 }
3617 s := make([]string, 0, 5)
3618 s = append(s, "&theproto3.NotPacked{")
3619 s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
3620 if this.XXX_unrecognized != nil {
3621 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
3622 }
3623 s = append(s, "}")
3624 return strings.Join(s, "")
3625 }
3626 func valueToGoStringTheproto3(v interface{}, typ string) string {
3627 rv := reflect.ValueOf(v)
3628 if rv.IsNil() {
3629 return "nil"
3630 }
3631 pv := reflect.Indirect(rv).Interface()
3632 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
3633 }
3634 func NewPopulatedMessage(r randyTheproto3, easy bool) *Message {
3635 this := &Message{}
3636 this.Name = string(randStringTheproto3(r))
3637 this.Hilarity = Message_Humour([]int32{0, 1, 2, 3}[r.Intn(4)])
3638 this.HeightInCm = uint32(r.Uint32())
3639 v1 := r.Intn(100)
3640 this.Data = make([]byte, v1)
3641 for i := 0; i < v1; i++ {
3642 this.Data[i] = byte(r.Intn(256))
3643 }
3644 this.ResultCount = int64(r.Int63())
3645 if r.Intn(2) == 0 {
3646 this.ResultCount *= -1
3647 }
3648 this.TrueScotsman = bool(bool(r.Intn(2) == 0))
3649 this.Score = float32(r.Float32())
3650 if r.Intn(2) == 0 {
3651 this.Score *= -1
3652 }
3653 v2 := r.Intn(10)
3654 this.Key = make([]uint64, v2)
3655 for i := 0; i < v2; i++ {
3656 this.Key[i] = uint64(uint64(r.Uint32()))
3657 }
3658 if r.Intn(5) != 0 {
3659 this.Nested = NewPopulatedNested(r, easy)
3660 }
3661 if r.Intn(5) != 0 {
3662 v3 := r.Intn(10)
3663 this.Terrain = make(map[int64]*Nested)
3664 for i := 0; i < v3; i++ {
3665 this.Terrain[int64(r.Int63())] = NewPopulatedNested(r, easy)
3666 }
3667 }
3668 if r.Intn(5) != 0 {
3669 this.Proto2Field = both.NewPopulatedNinOptNative(r, easy)
3670 }
3671 if r.Intn(5) != 0 {
3672 v4 := r.Intn(10)
3673 this.Proto2Value = make(map[int64]*both.NinOptEnum)
3674 for i := 0; i < v4; i++ {
3675 this.Proto2Value[int64(r.Int63())] = both.NewPopulatedNinOptEnum(r, easy)
3676 }
3677 }
3678 if !easy && r.Intn(10) != 0 {
3679 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 14)
3680 }
3681 return this
3682 }
3683
3684 func NewPopulatedNested(r randyTheproto3, easy bool) *Nested {
3685 this := &Nested{}
3686 this.Bunny = string(randStringTheproto3(r))
3687 if !easy && r.Intn(10) != 0 {
3688 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 2)
3689 }
3690 return this
3691 }
3692
3693 func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps {
3694 this := &AllMaps{}
3695 if r.Intn(5) != 0 {
3696 v5 := r.Intn(10)
3697 this.StringToDoubleMap = make(map[string]float64)
3698 for i := 0; i < v5; i++ {
3699 v6 := randStringTheproto3(r)
3700 this.StringToDoubleMap[v6] = float64(r.Float64())
3701 if r.Intn(2) == 0 {
3702 this.StringToDoubleMap[v6] *= -1
3703 }
3704 }
3705 }
3706 if r.Intn(5) != 0 {
3707 v7 := r.Intn(10)
3708 this.StringToFloatMap = make(map[string]float32)
3709 for i := 0; i < v7; i++ {
3710 v8 := randStringTheproto3(r)
3711 this.StringToFloatMap[v8] = float32(r.Float32())
3712 if r.Intn(2) == 0 {
3713 this.StringToFloatMap[v8] *= -1
3714 }
3715 }
3716 }
3717 if r.Intn(5) != 0 {
3718 v9 := r.Intn(10)
3719 this.Int32Map = make(map[int32]int32)
3720 for i := 0; i < v9; i++ {
3721 v10 := int32(r.Int31())
3722 this.Int32Map[v10] = int32(r.Int31())
3723 if r.Intn(2) == 0 {
3724 this.Int32Map[v10] *= -1
3725 }
3726 }
3727 }
3728 if r.Intn(5) != 0 {
3729 v11 := r.Intn(10)
3730 this.Int64Map = make(map[int64]int64)
3731 for i := 0; i < v11; i++ {
3732 v12 := int64(r.Int63())
3733 this.Int64Map[v12] = int64(r.Int63())
3734 if r.Intn(2) == 0 {
3735 this.Int64Map[v12] *= -1
3736 }
3737 }
3738 }
3739 if r.Intn(5) != 0 {
3740 v13 := r.Intn(10)
3741 this.Uint32Map = make(map[uint32]uint32)
3742 for i := 0; i < v13; i++ {
3743 v14 := uint32(r.Uint32())
3744 this.Uint32Map[v14] = uint32(r.Uint32())
3745 }
3746 }
3747 if r.Intn(5) != 0 {
3748 v15 := r.Intn(10)
3749 this.Uint64Map = make(map[uint64]uint64)
3750 for i := 0; i < v15; i++ {
3751 v16 := uint64(uint64(r.Uint32()))
3752 this.Uint64Map[v16] = uint64(uint64(r.Uint32()))
3753 }
3754 }
3755 if r.Intn(5) != 0 {
3756 v17 := r.Intn(10)
3757 this.Sint32Map = make(map[int32]int32)
3758 for i := 0; i < v17; i++ {
3759 v18 := int32(r.Int31())
3760 this.Sint32Map[v18] = int32(r.Int31())
3761 if r.Intn(2) == 0 {
3762 this.Sint32Map[v18] *= -1
3763 }
3764 }
3765 }
3766 if r.Intn(5) != 0 {
3767 v19 := r.Intn(10)
3768 this.Sint64Map = make(map[int64]int64)
3769 for i := 0; i < v19; i++ {
3770 v20 := int64(r.Int63())
3771 this.Sint64Map[v20] = int64(r.Int63())
3772 if r.Intn(2) == 0 {
3773 this.Sint64Map[v20] *= -1
3774 }
3775 }
3776 }
3777 if r.Intn(5) != 0 {
3778 v21 := r.Intn(10)
3779 this.Fixed32Map = make(map[uint32]uint32)
3780 for i := 0; i < v21; i++ {
3781 v22 := uint32(r.Uint32())
3782 this.Fixed32Map[v22] = uint32(r.Uint32())
3783 }
3784 }
3785 if r.Intn(5) != 0 {
3786 v23 := r.Intn(10)
3787 this.Sfixed32Map = make(map[int32]int32)
3788 for i := 0; i < v23; i++ {
3789 v24 := int32(r.Int31())
3790 this.Sfixed32Map[v24] = int32(r.Int31())
3791 if r.Intn(2) == 0 {
3792 this.Sfixed32Map[v24] *= -1
3793 }
3794 }
3795 }
3796 if r.Intn(5) != 0 {
3797 v25 := r.Intn(10)
3798 this.Fixed64Map = make(map[uint64]uint64)
3799 for i := 0; i < v25; i++ {
3800 v26 := uint64(uint64(r.Uint32()))
3801 this.Fixed64Map[v26] = uint64(uint64(r.Uint32()))
3802 }
3803 }
3804 if r.Intn(5) != 0 {
3805 v27 := r.Intn(10)
3806 this.Sfixed64Map = make(map[int64]int64)
3807 for i := 0; i < v27; i++ {
3808 v28 := int64(r.Int63())
3809 this.Sfixed64Map[v28] = int64(r.Int63())
3810 if r.Intn(2) == 0 {
3811 this.Sfixed64Map[v28] *= -1
3812 }
3813 }
3814 }
3815 if r.Intn(5) != 0 {
3816 v29 := r.Intn(10)
3817 this.BoolMap = make(map[bool]bool)
3818 for i := 0; i < v29; i++ {
3819 v30 := bool(bool(r.Intn(2) == 0))
3820 this.BoolMap[v30] = bool(bool(r.Intn(2) == 0))
3821 }
3822 }
3823 if r.Intn(5) != 0 {
3824 v31 := r.Intn(10)
3825 this.StringMap = make(map[string]string)
3826 for i := 0; i < v31; i++ {
3827 this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r)
3828 }
3829 }
3830 if r.Intn(5) != 0 {
3831 v32 := r.Intn(10)
3832 this.StringToBytesMap = make(map[string][]byte)
3833 for i := 0; i < v32; i++ {
3834 v33 := r.Intn(100)
3835 v34 := randStringTheproto3(r)
3836 this.StringToBytesMap[v34] = make([]byte, v33)
3837 for i := 0; i < v33; i++ {
3838 this.StringToBytesMap[v34][i] = byte(r.Intn(256))
3839 }
3840 }
3841 }
3842 if r.Intn(5) != 0 {
3843 v35 := r.Intn(10)
3844 this.StringToEnumMap = make(map[string]MapEnum)
3845 for i := 0; i < v35; i++ {
3846 this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)])
3847 }
3848 }
3849 if r.Intn(5) != 0 {
3850 v36 := r.Intn(10)
3851 this.StringToMsgMap = make(map[string]*FloatingPoint)
3852 for i := 0; i < v36; i++ {
3853 this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy)
3854 }
3855 }
3856 if !easy && r.Intn(10) != 0 {
3857 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 18)
3858 }
3859 return this
3860 }
3861
3862 func NewPopulatedAllMapsOrdered(r randyTheproto3, easy bool) *AllMapsOrdered {
3863 this := &AllMapsOrdered{}
3864 if r.Intn(5) != 0 {
3865 v37 := r.Intn(10)
3866 this.StringToDoubleMap = make(map[string]float64)
3867 for i := 0; i < v37; i++ {
3868 v38 := randStringTheproto3(r)
3869 this.StringToDoubleMap[v38] = float64(r.Float64())
3870 if r.Intn(2) == 0 {
3871 this.StringToDoubleMap[v38] *= -1
3872 }
3873 }
3874 }
3875 if r.Intn(5) != 0 {
3876 v39 := r.Intn(10)
3877 this.StringToFloatMap = make(map[string]float32)
3878 for i := 0; i < v39; i++ {
3879 v40 := randStringTheproto3(r)
3880 this.StringToFloatMap[v40] = float32(r.Float32())
3881 if r.Intn(2) == 0 {
3882 this.StringToFloatMap[v40] *= -1
3883 }
3884 }
3885 }
3886 if r.Intn(5) != 0 {
3887 v41 := r.Intn(10)
3888 this.Int32Map = make(map[int32]int32)
3889 for i := 0; i < v41; i++ {
3890 v42 := int32(r.Int31())
3891 this.Int32Map[v42] = int32(r.Int31())
3892 if r.Intn(2) == 0 {
3893 this.Int32Map[v42] *= -1
3894 }
3895 }
3896 }
3897 if r.Intn(5) != 0 {
3898 v43 := r.Intn(10)
3899 this.Int64Map = make(map[int64]int64)
3900 for i := 0; i < v43; i++ {
3901 v44 := int64(r.Int63())
3902 this.Int64Map[v44] = int64(r.Int63())
3903 if r.Intn(2) == 0 {
3904 this.Int64Map[v44] *= -1
3905 }
3906 }
3907 }
3908 if r.Intn(5) != 0 {
3909 v45 := r.Intn(10)
3910 this.Uint32Map = make(map[uint32]uint32)
3911 for i := 0; i < v45; i++ {
3912 v46 := uint32(r.Uint32())
3913 this.Uint32Map[v46] = uint32(r.Uint32())
3914 }
3915 }
3916 if r.Intn(5) != 0 {
3917 v47 := r.Intn(10)
3918 this.Uint64Map = make(map[uint64]uint64)
3919 for i := 0; i < v47; i++ {
3920 v48 := uint64(uint64(r.Uint32()))
3921 this.Uint64Map[v48] = uint64(uint64(r.Uint32()))
3922 }
3923 }
3924 if r.Intn(5) != 0 {
3925 v49 := r.Intn(10)
3926 this.Sint32Map = make(map[int32]int32)
3927 for i := 0; i < v49; i++ {
3928 v50 := int32(r.Int31())
3929 this.Sint32Map[v50] = int32(r.Int31())
3930 if r.Intn(2) == 0 {
3931 this.Sint32Map[v50] *= -1
3932 }
3933 }
3934 }
3935 if r.Intn(5) != 0 {
3936 v51 := r.Intn(10)
3937 this.Sint64Map = make(map[int64]int64)
3938 for i := 0; i < v51; i++ {
3939 v52 := int64(r.Int63())
3940 this.Sint64Map[v52] = int64(r.Int63())
3941 if r.Intn(2) == 0 {
3942 this.Sint64Map[v52] *= -1
3943 }
3944 }
3945 }
3946 if r.Intn(5) != 0 {
3947 v53 := r.Intn(10)
3948 this.Fixed32Map = make(map[uint32]uint32)
3949 for i := 0; i < v53; i++ {
3950 v54 := uint32(r.Uint32())
3951 this.Fixed32Map[v54] = uint32(r.Uint32())
3952 }
3953 }
3954 if r.Intn(5) != 0 {
3955 v55 := r.Intn(10)
3956 this.Sfixed32Map = make(map[int32]int32)
3957 for i := 0; i < v55; i++ {
3958 v56 := int32(r.Int31())
3959 this.Sfixed32Map[v56] = int32(r.Int31())
3960 if r.Intn(2) == 0 {
3961 this.Sfixed32Map[v56] *= -1
3962 }
3963 }
3964 }
3965 if r.Intn(5) != 0 {
3966 v57 := r.Intn(10)
3967 this.Fixed64Map = make(map[uint64]uint64)
3968 for i := 0; i < v57; i++ {
3969 v58 := uint64(uint64(r.Uint32()))
3970 this.Fixed64Map[v58] = uint64(uint64(r.Uint32()))
3971 }
3972 }
3973 if r.Intn(5) != 0 {
3974 v59 := r.Intn(10)
3975 this.Sfixed64Map = make(map[int64]int64)
3976 for i := 0; i < v59; i++ {
3977 v60 := int64(r.Int63())
3978 this.Sfixed64Map[v60] = int64(r.Int63())
3979 if r.Intn(2) == 0 {
3980 this.Sfixed64Map[v60] *= -1
3981 }
3982 }
3983 }
3984 if r.Intn(5) != 0 {
3985 v61 := r.Intn(10)
3986 this.BoolMap = make(map[bool]bool)
3987 for i := 0; i < v61; i++ {
3988 v62 := bool(bool(r.Intn(2) == 0))
3989 this.BoolMap[v62] = bool(bool(r.Intn(2) == 0))
3990 }
3991 }
3992 if r.Intn(5) != 0 {
3993 v63 := r.Intn(10)
3994 this.StringMap = make(map[string]string)
3995 for i := 0; i < v63; i++ {
3996 this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r)
3997 }
3998 }
3999 if r.Intn(5) != 0 {
4000 v64 := r.Intn(10)
4001 this.StringToBytesMap = make(map[string][]byte)
4002 for i := 0; i < v64; i++ {
4003 v65 := r.Intn(100)
4004 v66 := randStringTheproto3(r)
4005 this.StringToBytesMap[v66] = make([]byte, v65)
4006 for i := 0; i < v65; i++ {
4007 this.StringToBytesMap[v66][i] = byte(r.Intn(256))
4008 }
4009 }
4010 }
4011 if r.Intn(5) != 0 {
4012 v67 := r.Intn(10)
4013 this.StringToEnumMap = make(map[string]MapEnum)
4014 for i := 0; i < v67; i++ {
4015 this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)])
4016 }
4017 }
4018 if r.Intn(5) != 0 {
4019 v68 := r.Intn(10)
4020 this.StringToMsgMap = make(map[string]*FloatingPoint)
4021 for i := 0; i < v68; i++ {
4022 this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy)
4023 }
4024 }
4025 if !easy && r.Intn(10) != 0 {
4026 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 18)
4027 }
4028 return this
4029 }
4030
4031 func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap {
4032 this := &MessageWithMap{}
4033 if r.Intn(5) != 0 {
4034 v69 := r.Intn(10)
4035 this.NameMapping = make(map[int32]string)
4036 for i := 0; i < v69; i++ {
4037 this.NameMapping[int32(r.Int31())] = randStringTheproto3(r)
4038 }
4039 }
4040 if r.Intn(5) != 0 {
4041 v70 := r.Intn(10)
4042 this.MsgMapping = make(map[int64]*FloatingPoint)
4043 for i := 0; i < v70; i++ {
4044 this.MsgMapping[int64(r.Int63())] = NewPopulatedFloatingPoint(r, easy)
4045 }
4046 }
4047 if r.Intn(5) != 0 {
4048 v71 := r.Intn(10)
4049 this.ByteMapping = make(map[bool][]byte)
4050 for i := 0; i < v71; i++ {
4051 v72 := r.Intn(100)
4052 v73 := bool(bool(r.Intn(2) == 0))
4053 this.ByteMapping[v73] = make([]byte, v72)
4054 for i := 0; i < v72; i++ {
4055 this.ByteMapping[v73][i] = byte(r.Intn(256))
4056 }
4057 }
4058 }
4059 if !easy && r.Intn(10) != 0 {
4060 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 4)
4061 }
4062 return this
4063 }
4064
4065 func NewPopulatedFloatingPoint(r randyTheproto3, easy bool) *FloatingPoint {
4066 this := &FloatingPoint{}
4067 this.F = float64(r.Float64())
4068 if r.Intn(2) == 0 {
4069 this.F *= -1
4070 }
4071 if !easy && r.Intn(10) != 0 {
4072 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 2)
4073 }
4074 return this
4075 }
4076
4077 func NewPopulatedUint128Pair(r randyTheproto3, easy bool) *Uint128Pair {
4078 this := &Uint128Pair{}
4079 v74 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
4080 this.Left = *v74
4081 this.Right = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
4082 if !easy && r.Intn(10) != 0 {
4083 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 3)
4084 }
4085 return this
4086 }
4087
4088 func NewPopulatedContainsNestedMap(r randyTheproto3, easy bool) *ContainsNestedMap {
4089 this := &ContainsNestedMap{}
4090 if !easy && r.Intn(10) != 0 {
4091 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 1)
4092 }
4093 return this
4094 }
4095
4096 func NewPopulatedContainsNestedMap_NestedMap(r randyTheproto3, easy bool) *ContainsNestedMap_NestedMap {
4097 this := &ContainsNestedMap_NestedMap{}
4098 if r.Intn(5) != 0 {
4099 v75 := r.Intn(10)
4100 this.NestedMapField = make(map[string]float64)
4101 for i := 0; i < v75; i++ {
4102 v76 := randStringTheproto3(r)
4103 this.NestedMapField[v76] = float64(r.Float64())
4104 if r.Intn(2) == 0 {
4105 this.NestedMapField[v76] *= -1
4106 }
4107 }
4108 }
4109 if !easy && r.Intn(10) != 0 {
4110 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 2)
4111 }
4112 return this
4113 }
4114
4115 func NewPopulatedNotPacked(r randyTheproto3, easy bool) *NotPacked {
4116 this := &NotPacked{}
4117 v77 := r.Intn(10)
4118 this.Key = make([]uint64, v77)
4119 for i := 0; i < v77; i++ {
4120 this.Key[i] = uint64(uint64(r.Uint32()))
4121 }
4122 if !easy && r.Intn(10) != 0 {
4123 this.XXX_unrecognized = randUnrecognizedTheproto3(r, 6)
4124 }
4125 return this
4126 }
4127
4128 type randyTheproto3 interface {
4129 Float32() float32
4130 Float64() float64
4131 Int63() int64
4132 Int31() int32
4133 Uint32() uint32
4134 Intn(n int) int
4135 }
4136
4137 func randUTF8RuneTheproto3(r randyTheproto3) rune {
4138 ru := r.Intn(62)
4139 if ru < 10 {
4140 return rune(ru + 48)
4141 } else if ru < 36 {
4142 return rune(ru + 55)
4143 }
4144 return rune(ru + 61)
4145 }
4146 func randStringTheproto3(r randyTheproto3) string {
4147 v78 := r.Intn(100)
4148 tmps := make([]rune, v78)
4149 for i := 0; i < v78; i++ {
4150 tmps[i] = randUTF8RuneTheproto3(r)
4151 }
4152 return string(tmps)
4153 }
4154 func randUnrecognizedTheproto3(r randyTheproto3, maxFieldNumber int) (dAtA []byte) {
4155 l := r.Intn(5)
4156 for i := 0; i < l; i++ {
4157 wire := r.Intn(4)
4158 if wire == 3 {
4159 wire = 5
4160 }
4161 fieldNumber := maxFieldNumber + r.Intn(100)
4162 dAtA = randFieldTheproto3(dAtA, r, fieldNumber, wire)
4163 }
4164 return dAtA
4165 }
4166 func randFieldTheproto3(dAtA []byte, r randyTheproto3, fieldNumber int, wire int) []byte {
4167 key := uint32(fieldNumber)<<3 | uint32(wire)
4168 switch wire {
4169 case 0:
4170 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
4171 v79 := r.Int63()
4172 if r.Intn(2) == 0 {
4173 v79 *= -1
4174 }
4175 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(v79))
4176 case 1:
4177 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
4178 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)))
4179 case 2:
4180 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
4181 ll := r.Intn(100)
4182 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(ll))
4183 for j := 0; j < ll; j++ {
4184 dAtA = append(dAtA, byte(r.Intn(256)))
4185 }
4186 default:
4187 dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
4188 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
4189 }
4190 return dAtA
4191 }
4192 func encodeVarintPopulateTheproto3(dAtA []byte, v uint64) []byte {
4193 for v >= 1<<7 {
4194 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
4195 v >>= 7
4196 }
4197 dAtA = append(dAtA, uint8(v))
4198 return dAtA
4199 }
4200 func (m *Message) Size() (n int) {
4201 if m == nil {
4202 return 0
4203 }
4204 var l int
4205 _ = l
4206 l = len(m.Name)
4207 if l > 0 {
4208 n += 1 + l + sovTheproto3(uint64(l))
4209 }
4210 if m.Hilarity != 0 {
4211 n += 1 + sovTheproto3(uint64(m.Hilarity))
4212 }
4213 if m.HeightInCm != 0 {
4214 n += 1 + sovTheproto3(uint64(m.HeightInCm))
4215 }
4216 l = len(m.Data)
4217 if l > 0 {
4218 n += 1 + l + sovTheproto3(uint64(l))
4219 }
4220 if m.ResultCount != 0 {
4221 n += 1 + sovTheproto3(uint64(m.ResultCount))
4222 }
4223 if m.TrueScotsman {
4224 n += 2
4225 }
4226 if m.Score != 0 {
4227 n += 5
4228 }
4229 if len(m.Key) > 0 {
4230 l = 0
4231 for _, e := range m.Key {
4232 l += sovTheproto3(uint64(e))
4233 }
4234 n += 1 + sovTheproto3(uint64(l)) + l
4235 }
4236 if m.Nested != nil {
4237 l = m.Nested.Size()
4238 n += 1 + l + sovTheproto3(uint64(l))
4239 }
4240 if len(m.Terrain) > 0 {
4241 for k, v := range m.Terrain {
4242 _ = k
4243 _ = v
4244 l = 0
4245 if v != nil {
4246 l = v.Size()
4247 l += 1 + sovTheproto3(uint64(l))
4248 }
4249 mapEntrySize := 1 + sovTheproto3(uint64(k)) + l
4250 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4251 }
4252 }
4253 if m.Proto2Field != nil {
4254 l = m.Proto2Field.Size()
4255 n += 1 + l + sovTheproto3(uint64(l))
4256 }
4257 if len(m.Proto2Value) > 0 {
4258 for k, v := range m.Proto2Value {
4259 _ = k
4260 _ = v
4261 l = 0
4262 if v != nil {
4263 l = v.Size()
4264 l += 1 + sovTheproto3(uint64(l))
4265 }
4266 mapEntrySize := 1 + sovTheproto3(uint64(k)) + l
4267 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4268 }
4269 }
4270 if m.XXX_unrecognized != nil {
4271 n += len(m.XXX_unrecognized)
4272 }
4273 return n
4274 }
4275
4276 func (m *Nested) Size() (n int) {
4277 if m == nil {
4278 return 0
4279 }
4280 var l int
4281 _ = l
4282 l = len(m.Bunny)
4283 if l > 0 {
4284 n += 1 + l + sovTheproto3(uint64(l))
4285 }
4286 if m.XXX_unrecognized != nil {
4287 n += len(m.XXX_unrecognized)
4288 }
4289 return n
4290 }
4291
4292 func (m *AllMaps) Size() (n int) {
4293 if m == nil {
4294 return 0
4295 }
4296 var l int
4297 _ = l
4298 if len(m.StringToDoubleMap) > 0 {
4299 for k, v := range m.StringToDoubleMap {
4300 _ = k
4301 _ = v
4302 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
4303 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4304 }
4305 }
4306 if len(m.StringToFloatMap) > 0 {
4307 for k, v := range m.StringToFloatMap {
4308 _ = k
4309 _ = v
4310 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4
4311 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4312 }
4313 }
4314 if len(m.Int32Map) > 0 {
4315 for k, v := range m.Int32Map {
4316 _ = k
4317 _ = v
4318 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
4319 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4320 }
4321 }
4322 if len(m.Int64Map) > 0 {
4323 for k, v := range m.Int64Map {
4324 _ = k
4325 _ = v
4326 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
4327 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4328 }
4329 }
4330 if len(m.Uint32Map) > 0 {
4331 for k, v := range m.Uint32Map {
4332 _ = k
4333 _ = v
4334 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
4335 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4336 }
4337 }
4338 if len(m.Uint64Map) > 0 {
4339 for k, v := range m.Uint64Map {
4340 _ = k
4341 _ = v
4342 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
4343 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4344 }
4345 }
4346 if len(m.Sint32Map) > 0 {
4347 for k, v := range m.Sint32Map {
4348 _ = k
4349 _ = v
4350 mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
4351 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4352 }
4353 }
4354 if len(m.Sint64Map) > 0 {
4355 for k, v := range m.Sint64Map {
4356 _ = k
4357 _ = v
4358 mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
4359 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4360 }
4361 }
4362 if len(m.Fixed32Map) > 0 {
4363 for k, v := range m.Fixed32Map {
4364 _ = k
4365 _ = v
4366 mapEntrySize := 1 + 4 + 1 + 4
4367 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4368 }
4369 }
4370 if len(m.Sfixed32Map) > 0 {
4371 for k, v := range m.Sfixed32Map {
4372 _ = k
4373 _ = v
4374 mapEntrySize := 1 + 4 + 1 + 4
4375 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4376 }
4377 }
4378 if len(m.Fixed64Map) > 0 {
4379 for k, v := range m.Fixed64Map {
4380 _ = k
4381 _ = v
4382 mapEntrySize := 1 + 8 + 1 + 8
4383 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4384 }
4385 }
4386 if len(m.Sfixed64Map) > 0 {
4387 for k, v := range m.Sfixed64Map {
4388 _ = k
4389 _ = v
4390 mapEntrySize := 1 + 8 + 1 + 8
4391 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4392 }
4393 }
4394 if len(m.BoolMap) > 0 {
4395 for k, v := range m.BoolMap {
4396 _ = k
4397 _ = v
4398 mapEntrySize := 1 + 1 + 1 + 1
4399 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4400 }
4401 }
4402 if len(m.StringMap) > 0 {
4403 for k, v := range m.StringMap {
4404 _ = k
4405 _ = v
4406 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v)))
4407 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4408 }
4409 }
4410 if len(m.StringToBytesMap) > 0 {
4411 for k, v := range m.StringToBytesMap {
4412 _ = k
4413 _ = v
4414 l = 0
4415 if len(v) > 0 {
4416 l = 1 + len(v) + sovTheproto3(uint64(len(v)))
4417 }
4418 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
4419 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4420 }
4421 }
4422 if len(m.StringToEnumMap) > 0 {
4423 for k, v := range m.StringToEnumMap {
4424 _ = k
4425 _ = v
4426 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v))
4427 n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
4428 }
4429 }
4430 if len(m.StringToMsgMap) > 0 {
4431 for k, v := range m.StringToMsgMap {
4432 _ = k
4433 _ = v
4434 l = 0
4435 if v != nil {
4436 l = v.Size()
4437 l += 1 + sovTheproto3(uint64(l))
4438 }
4439 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
4440 n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
4441 }
4442 }
4443 if m.XXX_unrecognized != nil {
4444 n += len(m.XXX_unrecognized)
4445 }
4446 return n
4447 }
4448
4449 func (m *AllMapsOrdered) Size() (n int) {
4450 if m == nil {
4451 return 0
4452 }
4453 var l int
4454 _ = l
4455 if len(m.StringToDoubleMap) > 0 {
4456 for k, v := range m.StringToDoubleMap {
4457 _ = k
4458 _ = v
4459 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
4460 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4461 }
4462 }
4463 if len(m.StringToFloatMap) > 0 {
4464 for k, v := range m.StringToFloatMap {
4465 _ = k
4466 _ = v
4467 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4
4468 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4469 }
4470 }
4471 if len(m.Int32Map) > 0 {
4472 for k, v := range m.Int32Map {
4473 _ = k
4474 _ = v
4475 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
4476 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4477 }
4478 }
4479 if len(m.Int64Map) > 0 {
4480 for k, v := range m.Int64Map {
4481 _ = k
4482 _ = v
4483 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
4484 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4485 }
4486 }
4487 if len(m.Uint32Map) > 0 {
4488 for k, v := range m.Uint32Map {
4489 _ = k
4490 _ = v
4491 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
4492 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4493 }
4494 }
4495 if len(m.Uint64Map) > 0 {
4496 for k, v := range m.Uint64Map {
4497 _ = k
4498 _ = v
4499 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
4500 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4501 }
4502 }
4503 if len(m.Sint32Map) > 0 {
4504 for k, v := range m.Sint32Map {
4505 _ = k
4506 _ = v
4507 mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
4508 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4509 }
4510 }
4511 if len(m.Sint64Map) > 0 {
4512 for k, v := range m.Sint64Map {
4513 _ = k
4514 _ = v
4515 mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
4516 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4517 }
4518 }
4519 if len(m.Fixed32Map) > 0 {
4520 for k, v := range m.Fixed32Map {
4521 _ = k
4522 _ = v
4523 mapEntrySize := 1 + 4 + 1 + 4
4524 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4525 }
4526 }
4527 if len(m.Sfixed32Map) > 0 {
4528 for k, v := range m.Sfixed32Map {
4529 _ = k
4530 _ = v
4531 mapEntrySize := 1 + 4 + 1 + 4
4532 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4533 }
4534 }
4535 if len(m.Fixed64Map) > 0 {
4536 for k, v := range m.Fixed64Map {
4537 _ = k
4538 _ = v
4539 mapEntrySize := 1 + 8 + 1 + 8
4540 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4541 }
4542 }
4543 if len(m.Sfixed64Map) > 0 {
4544 for k, v := range m.Sfixed64Map {
4545 _ = k
4546 _ = v
4547 mapEntrySize := 1 + 8 + 1 + 8
4548 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4549 }
4550 }
4551 if len(m.BoolMap) > 0 {
4552 for k, v := range m.BoolMap {
4553 _ = k
4554 _ = v
4555 mapEntrySize := 1 + 1 + 1 + 1
4556 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4557 }
4558 }
4559 if len(m.StringMap) > 0 {
4560 for k, v := range m.StringMap {
4561 _ = k
4562 _ = v
4563 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v)))
4564 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4565 }
4566 }
4567 if len(m.StringToBytesMap) > 0 {
4568 for k, v := range m.StringToBytesMap {
4569 _ = k
4570 _ = v
4571 l = 0
4572 if len(v) > 0 {
4573 l = 1 + len(v) + sovTheproto3(uint64(len(v)))
4574 }
4575 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
4576 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4577 }
4578 }
4579 if len(m.StringToEnumMap) > 0 {
4580 for k, v := range m.StringToEnumMap {
4581 _ = k
4582 _ = v
4583 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v))
4584 n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
4585 }
4586 }
4587 if len(m.StringToMsgMap) > 0 {
4588 for k, v := range m.StringToMsgMap {
4589 _ = k
4590 _ = v
4591 l = 0
4592 if v != nil {
4593 l = v.Size()
4594 l += 1 + sovTheproto3(uint64(l))
4595 }
4596 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
4597 n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
4598 }
4599 }
4600 if m.XXX_unrecognized != nil {
4601 n += len(m.XXX_unrecognized)
4602 }
4603 return n
4604 }
4605
4606 func (m *MessageWithMap) Size() (n int) {
4607 if m == nil {
4608 return 0
4609 }
4610 var l int
4611 _ = l
4612 if len(m.NameMapping) > 0 {
4613 for k, v := range m.NameMapping {
4614 _ = k
4615 _ = v
4616 mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v)))
4617 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4618 }
4619 }
4620 if len(m.MsgMapping) > 0 {
4621 for k, v := range m.MsgMapping {
4622 _ = k
4623 _ = v
4624 l = 0
4625 if v != nil {
4626 l = v.Size()
4627 l += 1 + sovTheproto3(uint64(l))
4628 }
4629 mapEntrySize := 1 + sozTheproto3(uint64(k)) + l
4630 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4631 }
4632 }
4633 if len(m.ByteMapping) > 0 {
4634 for k, v := range m.ByteMapping {
4635 _ = k
4636 _ = v
4637 l = 0
4638 if len(v) > 0 {
4639 l = 1 + len(v) + sovTheproto3(uint64(len(v)))
4640 }
4641 mapEntrySize := 1 + 1 + l
4642 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4643 }
4644 }
4645 if m.XXX_unrecognized != nil {
4646 n += len(m.XXX_unrecognized)
4647 }
4648 return n
4649 }
4650
4651 func (m *FloatingPoint) Size() (n int) {
4652 if m == nil {
4653 return 0
4654 }
4655 var l int
4656 _ = l
4657 if m.F != 0 {
4658 n += 9
4659 }
4660 if m.XXX_unrecognized != nil {
4661 n += len(m.XXX_unrecognized)
4662 }
4663 return n
4664 }
4665
4666 func (m *Uint128Pair) Size() (n int) {
4667 if m == nil {
4668 return 0
4669 }
4670 var l int
4671 _ = l
4672 l = m.Left.Size()
4673 n += 1 + l + sovTheproto3(uint64(l))
4674 if m.Right != nil {
4675 l = m.Right.Size()
4676 n += 1 + l + sovTheproto3(uint64(l))
4677 }
4678 if m.XXX_unrecognized != nil {
4679 n += len(m.XXX_unrecognized)
4680 }
4681 return n
4682 }
4683
4684 func (m *ContainsNestedMap) Size() (n int) {
4685 if m == nil {
4686 return 0
4687 }
4688 var l int
4689 _ = l
4690 if m.XXX_unrecognized != nil {
4691 n += len(m.XXX_unrecognized)
4692 }
4693 return n
4694 }
4695
4696 func (m *ContainsNestedMap_NestedMap) Size() (n int) {
4697 if m == nil {
4698 return 0
4699 }
4700 var l int
4701 _ = l
4702 if len(m.NestedMapField) > 0 {
4703 for k, v := range m.NestedMapField {
4704 _ = k
4705 _ = v
4706 mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
4707 n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
4708 }
4709 }
4710 if m.XXX_unrecognized != nil {
4711 n += len(m.XXX_unrecognized)
4712 }
4713 return n
4714 }
4715
4716 func (m *NotPacked) Size() (n int) {
4717 if m == nil {
4718 return 0
4719 }
4720 var l int
4721 _ = l
4722 if len(m.Key) > 0 {
4723 for _, e := range m.Key {
4724 n += 1 + sovTheproto3(uint64(e))
4725 }
4726 }
4727 if m.XXX_unrecognized != nil {
4728 n += len(m.XXX_unrecognized)
4729 }
4730 return n
4731 }
4732
4733 func sovTheproto3(x uint64) (n int) {
4734 return (math_bits.Len64(x|1) + 6) / 7
4735 }
4736 func sozTheproto3(x uint64) (n int) {
4737 return sovTheproto3(uint64((x << 1) ^ uint64((int64(x) >> 63))))
4738 }
4739 func (this *Message) String() string {
4740 if this == nil {
4741 return "nil"
4742 }
4743 keysForTerrain := make([]int64, 0, len(this.Terrain))
4744 for k := range this.Terrain {
4745 keysForTerrain = append(keysForTerrain, k)
4746 }
4747 github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain)
4748 mapStringForTerrain := "map[int64]*Nested{"
4749 for _, k := range keysForTerrain {
4750 mapStringForTerrain += fmt.Sprintf("%v: %v,", k, this.Terrain[k])
4751 }
4752 mapStringForTerrain += "}"
4753 keysForProto2Value := make([]int64, 0, len(this.Proto2Value))
4754 for k := range this.Proto2Value {
4755 keysForProto2Value = append(keysForProto2Value, k)
4756 }
4757 github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value)
4758 mapStringForProto2Value := "map[int64]*both.NinOptEnum{"
4759 for _, k := range keysForProto2Value {
4760 mapStringForProto2Value += fmt.Sprintf("%v: %v,", k, this.Proto2Value[k])
4761 }
4762 mapStringForProto2Value += "}"
4763 s := strings.Join([]string{`&Message{`,
4764 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
4765 `Hilarity:` + fmt.Sprintf("%v", this.Hilarity) + `,`,
4766 `HeightInCm:` + fmt.Sprintf("%v", this.HeightInCm) + `,`,
4767 `Data:` + fmt.Sprintf("%v", this.Data) + `,`,
4768 `ResultCount:` + fmt.Sprintf("%v", this.ResultCount) + `,`,
4769 `TrueScotsman:` + fmt.Sprintf("%v", this.TrueScotsman) + `,`,
4770 `Score:` + fmt.Sprintf("%v", this.Score) + `,`,
4771 `Key:` + fmt.Sprintf("%v", this.Key) + `,`,
4772 `Nested:` + strings.Replace(this.Nested.String(), "Nested", "Nested", 1) + `,`,
4773 `Terrain:` + mapStringForTerrain + `,`,
4774 `Proto2Field:` + strings.Replace(fmt.Sprintf("%v", this.Proto2Field), "NinOptNative", "both.NinOptNative", 1) + `,`,
4775 `Proto2Value:` + mapStringForProto2Value + `,`,
4776 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4777 `}`,
4778 }, "")
4779 return s
4780 }
4781 func (this *Nested) String() string {
4782 if this == nil {
4783 return "nil"
4784 }
4785 s := strings.Join([]string{`&Nested{`,
4786 `Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`,
4787 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4788 `}`,
4789 }, "")
4790 return s
4791 }
4792 func (this *AllMaps) String() string {
4793 if this == nil {
4794 return "nil"
4795 }
4796 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
4797 for k := range this.StringToDoubleMap {
4798 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
4799 }
4800 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
4801 mapStringForStringToDoubleMap := "map[string]float64{"
4802 for _, k := range keysForStringToDoubleMap {
4803 mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k])
4804 }
4805 mapStringForStringToDoubleMap += "}"
4806 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
4807 for k := range this.StringToFloatMap {
4808 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
4809 }
4810 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
4811 mapStringForStringToFloatMap := "map[string]float32{"
4812 for _, k := range keysForStringToFloatMap {
4813 mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k])
4814 }
4815 mapStringForStringToFloatMap += "}"
4816 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
4817 for k := range this.Int32Map {
4818 keysForInt32Map = append(keysForInt32Map, k)
4819 }
4820 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
4821 mapStringForInt32Map := "map[int32]int32{"
4822 for _, k := range keysForInt32Map {
4823 mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k])
4824 }
4825 mapStringForInt32Map += "}"
4826 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
4827 for k := range this.Int64Map {
4828 keysForInt64Map = append(keysForInt64Map, k)
4829 }
4830 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
4831 mapStringForInt64Map := "map[int64]int64{"
4832 for _, k := range keysForInt64Map {
4833 mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k])
4834 }
4835 mapStringForInt64Map += "}"
4836 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
4837 for k := range this.Uint32Map {
4838 keysForUint32Map = append(keysForUint32Map, k)
4839 }
4840 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
4841 mapStringForUint32Map := "map[uint32]uint32{"
4842 for _, k := range keysForUint32Map {
4843 mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k])
4844 }
4845 mapStringForUint32Map += "}"
4846 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
4847 for k := range this.Uint64Map {
4848 keysForUint64Map = append(keysForUint64Map, k)
4849 }
4850 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
4851 mapStringForUint64Map := "map[uint64]uint64{"
4852 for _, k := range keysForUint64Map {
4853 mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k])
4854 }
4855 mapStringForUint64Map += "}"
4856 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
4857 for k := range this.Sint32Map {
4858 keysForSint32Map = append(keysForSint32Map, k)
4859 }
4860 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
4861 mapStringForSint32Map := "map[int32]int32{"
4862 for _, k := range keysForSint32Map {
4863 mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k])
4864 }
4865 mapStringForSint32Map += "}"
4866 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
4867 for k := range this.Sint64Map {
4868 keysForSint64Map = append(keysForSint64Map, k)
4869 }
4870 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
4871 mapStringForSint64Map := "map[int64]int64{"
4872 for _, k := range keysForSint64Map {
4873 mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k])
4874 }
4875 mapStringForSint64Map += "}"
4876 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
4877 for k := range this.Fixed32Map {
4878 keysForFixed32Map = append(keysForFixed32Map, k)
4879 }
4880 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
4881 mapStringForFixed32Map := "map[uint32]uint32{"
4882 for _, k := range keysForFixed32Map {
4883 mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k])
4884 }
4885 mapStringForFixed32Map += "}"
4886 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
4887 for k := range this.Sfixed32Map {
4888 keysForSfixed32Map = append(keysForSfixed32Map, k)
4889 }
4890 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
4891 mapStringForSfixed32Map := "map[int32]int32{"
4892 for _, k := range keysForSfixed32Map {
4893 mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k])
4894 }
4895 mapStringForSfixed32Map += "}"
4896 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
4897 for k := range this.Fixed64Map {
4898 keysForFixed64Map = append(keysForFixed64Map, k)
4899 }
4900 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
4901 mapStringForFixed64Map := "map[uint64]uint64{"
4902 for _, k := range keysForFixed64Map {
4903 mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k])
4904 }
4905 mapStringForFixed64Map += "}"
4906 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
4907 for k := range this.Sfixed64Map {
4908 keysForSfixed64Map = append(keysForSfixed64Map, k)
4909 }
4910 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
4911 mapStringForSfixed64Map := "map[int64]int64{"
4912 for _, k := range keysForSfixed64Map {
4913 mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k])
4914 }
4915 mapStringForSfixed64Map += "}"
4916 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
4917 for k := range this.BoolMap {
4918 keysForBoolMap = append(keysForBoolMap, k)
4919 }
4920 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
4921 mapStringForBoolMap := "map[bool]bool{"
4922 for _, k := range keysForBoolMap {
4923 mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k])
4924 }
4925 mapStringForBoolMap += "}"
4926 keysForStringMap := make([]string, 0, len(this.StringMap))
4927 for k := range this.StringMap {
4928 keysForStringMap = append(keysForStringMap, k)
4929 }
4930 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
4931 mapStringForStringMap := "map[string]string{"
4932 for _, k := range keysForStringMap {
4933 mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k])
4934 }
4935 mapStringForStringMap += "}"
4936 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
4937 for k := range this.StringToBytesMap {
4938 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
4939 }
4940 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
4941 mapStringForStringToBytesMap := "map[string][]byte{"
4942 for _, k := range keysForStringToBytesMap {
4943 mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k])
4944 }
4945 mapStringForStringToBytesMap += "}"
4946 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
4947 for k := range this.StringToEnumMap {
4948 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
4949 }
4950 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
4951 mapStringForStringToEnumMap := "map[string]MapEnum{"
4952 for _, k := range keysForStringToEnumMap {
4953 mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k])
4954 }
4955 mapStringForStringToEnumMap += "}"
4956 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
4957 for k := range this.StringToMsgMap {
4958 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
4959 }
4960 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
4961 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
4962 for _, k := range keysForStringToMsgMap {
4963 mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k])
4964 }
4965 mapStringForStringToMsgMap += "}"
4966 s := strings.Join([]string{`&AllMaps{`,
4967 `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`,
4968 `StringToFloatMap:` + mapStringForStringToFloatMap + `,`,
4969 `Int32Map:` + mapStringForInt32Map + `,`,
4970 `Int64Map:` + mapStringForInt64Map + `,`,
4971 `Uint32Map:` + mapStringForUint32Map + `,`,
4972 `Uint64Map:` + mapStringForUint64Map + `,`,
4973 `Sint32Map:` + mapStringForSint32Map + `,`,
4974 `Sint64Map:` + mapStringForSint64Map + `,`,
4975 `Fixed32Map:` + mapStringForFixed32Map + `,`,
4976 `Sfixed32Map:` + mapStringForSfixed32Map + `,`,
4977 `Fixed64Map:` + mapStringForFixed64Map + `,`,
4978 `Sfixed64Map:` + mapStringForSfixed64Map + `,`,
4979 `BoolMap:` + mapStringForBoolMap + `,`,
4980 `StringMap:` + mapStringForStringMap + `,`,
4981 `StringToBytesMap:` + mapStringForStringToBytesMap + `,`,
4982 `StringToEnumMap:` + mapStringForStringToEnumMap + `,`,
4983 `StringToMsgMap:` + mapStringForStringToMsgMap + `,`,
4984 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
4985 `}`,
4986 }, "")
4987 return s
4988 }
4989 func (this *AllMapsOrdered) String() string {
4990 if this == nil {
4991 return "nil"
4992 }
4993 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
4994 for k := range this.StringToDoubleMap {
4995 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
4996 }
4997 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
4998 mapStringForStringToDoubleMap := "map[string]float64{"
4999 for _, k := range keysForStringToDoubleMap {
5000 mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k])
5001 }
5002 mapStringForStringToDoubleMap += "}"
5003 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
5004 for k := range this.StringToFloatMap {
5005 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
5006 }
5007 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
5008 mapStringForStringToFloatMap := "map[string]float32{"
5009 for _, k := range keysForStringToFloatMap {
5010 mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k])
5011 }
5012 mapStringForStringToFloatMap += "}"
5013 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
5014 for k := range this.Int32Map {
5015 keysForInt32Map = append(keysForInt32Map, k)
5016 }
5017 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
5018 mapStringForInt32Map := "map[int32]int32{"
5019 for _, k := range keysForInt32Map {
5020 mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k])
5021 }
5022 mapStringForInt32Map += "}"
5023 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
5024 for k := range this.Int64Map {
5025 keysForInt64Map = append(keysForInt64Map, k)
5026 }
5027 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
5028 mapStringForInt64Map := "map[int64]int64{"
5029 for _, k := range keysForInt64Map {
5030 mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k])
5031 }
5032 mapStringForInt64Map += "}"
5033 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
5034 for k := range this.Uint32Map {
5035 keysForUint32Map = append(keysForUint32Map, k)
5036 }
5037 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
5038 mapStringForUint32Map := "map[uint32]uint32{"
5039 for _, k := range keysForUint32Map {
5040 mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k])
5041 }
5042 mapStringForUint32Map += "}"
5043 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
5044 for k := range this.Uint64Map {
5045 keysForUint64Map = append(keysForUint64Map, k)
5046 }
5047 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
5048 mapStringForUint64Map := "map[uint64]uint64{"
5049 for _, k := range keysForUint64Map {
5050 mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k])
5051 }
5052 mapStringForUint64Map += "}"
5053 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
5054 for k := range this.Sint32Map {
5055 keysForSint32Map = append(keysForSint32Map, k)
5056 }
5057 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
5058 mapStringForSint32Map := "map[int32]int32{"
5059 for _, k := range keysForSint32Map {
5060 mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k])
5061 }
5062 mapStringForSint32Map += "}"
5063 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
5064 for k := range this.Sint64Map {
5065 keysForSint64Map = append(keysForSint64Map, k)
5066 }
5067 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
5068 mapStringForSint64Map := "map[int64]int64{"
5069 for _, k := range keysForSint64Map {
5070 mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k])
5071 }
5072 mapStringForSint64Map += "}"
5073 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
5074 for k := range this.Fixed32Map {
5075 keysForFixed32Map = append(keysForFixed32Map, k)
5076 }
5077 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
5078 mapStringForFixed32Map := "map[uint32]uint32{"
5079 for _, k := range keysForFixed32Map {
5080 mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k])
5081 }
5082 mapStringForFixed32Map += "}"
5083 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
5084 for k := range this.Sfixed32Map {
5085 keysForSfixed32Map = append(keysForSfixed32Map, k)
5086 }
5087 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
5088 mapStringForSfixed32Map := "map[int32]int32{"
5089 for _, k := range keysForSfixed32Map {
5090 mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k])
5091 }
5092 mapStringForSfixed32Map += "}"
5093 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
5094 for k := range this.Fixed64Map {
5095 keysForFixed64Map = append(keysForFixed64Map, k)
5096 }
5097 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
5098 mapStringForFixed64Map := "map[uint64]uint64{"
5099 for _, k := range keysForFixed64Map {
5100 mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k])
5101 }
5102 mapStringForFixed64Map += "}"
5103 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
5104 for k := range this.Sfixed64Map {
5105 keysForSfixed64Map = append(keysForSfixed64Map, k)
5106 }
5107 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
5108 mapStringForSfixed64Map := "map[int64]int64{"
5109 for _, k := range keysForSfixed64Map {
5110 mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k])
5111 }
5112 mapStringForSfixed64Map += "}"
5113 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
5114 for k := range this.BoolMap {
5115 keysForBoolMap = append(keysForBoolMap, k)
5116 }
5117 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
5118 mapStringForBoolMap := "map[bool]bool{"
5119 for _, k := range keysForBoolMap {
5120 mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k])
5121 }
5122 mapStringForBoolMap += "}"
5123 keysForStringMap := make([]string, 0, len(this.StringMap))
5124 for k := range this.StringMap {
5125 keysForStringMap = append(keysForStringMap, k)
5126 }
5127 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
5128 mapStringForStringMap := "map[string]string{"
5129 for _, k := range keysForStringMap {
5130 mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k])
5131 }
5132 mapStringForStringMap += "}"
5133 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
5134 for k := range this.StringToBytesMap {
5135 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
5136 }
5137 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
5138 mapStringForStringToBytesMap := "map[string][]byte{"
5139 for _, k := range keysForStringToBytesMap {
5140 mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k])
5141 }
5142 mapStringForStringToBytesMap += "}"
5143 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
5144 for k := range this.StringToEnumMap {
5145 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
5146 }
5147 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
5148 mapStringForStringToEnumMap := "map[string]MapEnum{"
5149 for _, k := range keysForStringToEnumMap {
5150 mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k])
5151 }
5152 mapStringForStringToEnumMap += "}"
5153 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
5154 for k := range this.StringToMsgMap {
5155 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
5156 }
5157 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
5158 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
5159 for _, k := range keysForStringToMsgMap {
5160 mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k])
5161 }
5162 mapStringForStringToMsgMap += "}"
5163 s := strings.Join([]string{`&AllMapsOrdered{`,
5164 `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`,
5165 `StringToFloatMap:` + mapStringForStringToFloatMap + `,`,
5166 `Int32Map:` + mapStringForInt32Map + `,`,
5167 `Int64Map:` + mapStringForInt64Map + `,`,
5168 `Uint32Map:` + mapStringForUint32Map + `,`,
5169 `Uint64Map:` + mapStringForUint64Map + `,`,
5170 `Sint32Map:` + mapStringForSint32Map + `,`,
5171 `Sint64Map:` + mapStringForSint64Map + `,`,
5172 `Fixed32Map:` + mapStringForFixed32Map + `,`,
5173 `Sfixed32Map:` + mapStringForSfixed32Map + `,`,
5174 `Fixed64Map:` + mapStringForFixed64Map + `,`,
5175 `Sfixed64Map:` + mapStringForSfixed64Map + `,`,
5176 `BoolMap:` + mapStringForBoolMap + `,`,
5177 `StringMap:` + mapStringForStringMap + `,`,
5178 `StringToBytesMap:` + mapStringForStringToBytesMap + `,`,
5179 `StringToEnumMap:` + mapStringForStringToEnumMap + `,`,
5180 `StringToMsgMap:` + mapStringForStringToMsgMap + `,`,
5181 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5182 `}`,
5183 }, "")
5184 return s
5185 }
5186 func (this *MessageWithMap) String() string {
5187 if this == nil {
5188 return "nil"
5189 }
5190 keysForNameMapping := make([]int32, 0, len(this.NameMapping))
5191 for k := range this.NameMapping {
5192 keysForNameMapping = append(keysForNameMapping, k)
5193 }
5194 github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping)
5195 mapStringForNameMapping := "map[int32]string{"
5196 for _, k := range keysForNameMapping {
5197 mapStringForNameMapping += fmt.Sprintf("%v: %v,", k, this.NameMapping[k])
5198 }
5199 mapStringForNameMapping += "}"
5200 keysForMsgMapping := make([]int64, 0, len(this.MsgMapping))
5201 for k := range this.MsgMapping {
5202 keysForMsgMapping = append(keysForMsgMapping, k)
5203 }
5204 github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping)
5205 mapStringForMsgMapping := "map[int64]*FloatingPoint{"
5206 for _, k := range keysForMsgMapping {
5207 mapStringForMsgMapping += fmt.Sprintf("%v: %v,", k, this.MsgMapping[k])
5208 }
5209 mapStringForMsgMapping += "}"
5210 keysForByteMapping := make([]bool, 0, len(this.ByteMapping))
5211 for k := range this.ByteMapping {
5212 keysForByteMapping = append(keysForByteMapping, k)
5213 }
5214 github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping)
5215 mapStringForByteMapping := "map[bool][]byte{"
5216 for _, k := range keysForByteMapping {
5217 mapStringForByteMapping += fmt.Sprintf("%v: %v,", k, this.ByteMapping[k])
5218 }
5219 mapStringForByteMapping += "}"
5220 s := strings.Join([]string{`&MessageWithMap{`,
5221 `NameMapping:` + mapStringForNameMapping + `,`,
5222 `MsgMapping:` + mapStringForMsgMapping + `,`,
5223 `ByteMapping:` + mapStringForByteMapping + `,`,
5224 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5225 `}`,
5226 }, "")
5227 return s
5228 }
5229 func (this *FloatingPoint) String() string {
5230 if this == nil {
5231 return "nil"
5232 }
5233 s := strings.Join([]string{`&FloatingPoint{`,
5234 `F:` + fmt.Sprintf("%v", this.F) + `,`,
5235 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5236 `}`,
5237 }, "")
5238 return s
5239 }
5240 func (this *Uint128Pair) String() string {
5241 if this == nil {
5242 return "nil"
5243 }
5244 s := strings.Join([]string{`&Uint128Pair{`,
5245 `Left:` + fmt.Sprintf("%v", this.Left) + `,`,
5246 `Right:` + fmt.Sprintf("%v", this.Right) + `,`,
5247 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5248 `}`,
5249 }, "")
5250 return s
5251 }
5252 func (this *ContainsNestedMap) String() string {
5253 if this == nil {
5254 return "nil"
5255 }
5256 s := strings.Join([]string{`&ContainsNestedMap{`,
5257 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5258 `}`,
5259 }, "")
5260 return s
5261 }
5262 func (this *ContainsNestedMap_NestedMap) String() string {
5263 if this == nil {
5264 return "nil"
5265 }
5266 keysForNestedMapField := make([]string, 0, len(this.NestedMapField))
5267 for k := range this.NestedMapField {
5268 keysForNestedMapField = append(keysForNestedMapField, k)
5269 }
5270 github_com_gogo_protobuf_sortkeys.Strings(keysForNestedMapField)
5271 mapStringForNestedMapField := "map[string]float64{"
5272 for _, k := range keysForNestedMapField {
5273 mapStringForNestedMapField += fmt.Sprintf("%v: %v,", k, this.NestedMapField[k])
5274 }
5275 mapStringForNestedMapField += "}"
5276 s := strings.Join([]string{`&ContainsNestedMap_NestedMap{`,
5277 `NestedMapField:` + mapStringForNestedMapField + `,`,
5278 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5279 `}`,
5280 }, "")
5281 return s
5282 }
5283 func (this *NotPacked) String() string {
5284 if this == nil {
5285 return "nil"
5286 }
5287 s := strings.Join([]string{`&NotPacked{`,
5288 `Key:` + fmt.Sprintf("%v", this.Key) + `,`,
5289 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
5290 `}`,
5291 }, "")
5292 return s
5293 }
5294 func valueToStringTheproto3(v interface{}) string {
5295 rv := reflect.ValueOf(v)
5296 if rv.IsNil() {
5297 return "nil"
5298 }
5299 pv := reflect.Indirect(rv).Interface()
5300 return fmt.Sprintf("*%v", pv)
5301 }
5302 func (m *Message) Unmarshal(dAtA []byte) error {
5303 l := len(dAtA)
5304 iNdEx := 0
5305 for iNdEx < l {
5306 preIndex := iNdEx
5307 var wire uint64
5308 for shift := uint(0); ; shift += 7 {
5309 if shift >= 64 {
5310 return ErrIntOverflowTheproto3
5311 }
5312 if iNdEx >= l {
5313 return io.ErrUnexpectedEOF
5314 }
5315 b := dAtA[iNdEx]
5316 iNdEx++
5317 wire |= uint64(b&0x7F) << shift
5318 if b < 0x80 {
5319 break
5320 }
5321 }
5322 fieldNum := int32(wire >> 3)
5323 wireType := int(wire & 0x7)
5324 if wireType == 4 {
5325 return fmt.Errorf("proto: Message: wiretype end group for non-group")
5326 }
5327 if fieldNum <= 0 {
5328 return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire)
5329 }
5330 switch fieldNum {
5331 case 1:
5332 if wireType != 2 {
5333 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5334 }
5335 var stringLen uint64
5336 for shift := uint(0); ; shift += 7 {
5337 if shift >= 64 {
5338 return ErrIntOverflowTheproto3
5339 }
5340 if iNdEx >= l {
5341 return io.ErrUnexpectedEOF
5342 }
5343 b := dAtA[iNdEx]
5344 iNdEx++
5345 stringLen |= uint64(b&0x7F) << shift
5346 if b < 0x80 {
5347 break
5348 }
5349 }
5350 intStringLen := int(stringLen)
5351 if intStringLen < 0 {
5352 return ErrInvalidLengthTheproto3
5353 }
5354 postIndex := iNdEx + intStringLen
5355 if postIndex < 0 {
5356 return ErrInvalidLengthTheproto3
5357 }
5358 if postIndex > l {
5359 return io.ErrUnexpectedEOF
5360 }
5361 m.Name = string(dAtA[iNdEx:postIndex])
5362 iNdEx = postIndex
5363 case 2:
5364 if wireType != 0 {
5365 return fmt.Errorf("proto: wrong wireType = %d for field Hilarity", wireType)
5366 }
5367 m.Hilarity = 0
5368 for shift := uint(0); ; shift += 7 {
5369 if shift >= 64 {
5370 return ErrIntOverflowTheproto3
5371 }
5372 if iNdEx >= l {
5373 return io.ErrUnexpectedEOF
5374 }
5375 b := dAtA[iNdEx]
5376 iNdEx++
5377 m.Hilarity |= Message_Humour(b&0x7F) << shift
5378 if b < 0x80 {
5379 break
5380 }
5381 }
5382 case 3:
5383 if wireType != 0 {
5384 return fmt.Errorf("proto: wrong wireType = %d for field HeightInCm", wireType)
5385 }
5386 m.HeightInCm = 0
5387 for shift := uint(0); ; shift += 7 {
5388 if shift >= 64 {
5389 return ErrIntOverflowTheproto3
5390 }
5391 if iNdEx >= l {
5392 return io.ErrUnexpectedEOF
5393 }
5394 b := dAtA[iNdEx]
5395 iNdEx++
5396 m.HeightInCm |= uint32(b&0x7F) << shift
5397 if b < 0x80 {
5398 break
5399 }
5400 }
5401 case 4:
5402 if wireType != 2 {
5403 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
5404 }
5405 var byteLen int
5406 for shift := uint(0); ; shift += 7 {
5407 if shift >= 64 {
5408 return ErrIntOverflowTheproto3
5409 }
5410 if iNdEx >= l {
5411 return io.ErrUnexpectedEOF
5412 }
5413 b := dAtA[iNdEx]
5414 iNdEx++
5415 byteLen |= int(b&0x7F) << shift
5416 if b < 0x80 {
5417 break
5418 }
5419 }
5420 if byteLen < 0 {
5421 return ErrInvalidLengthTheproto3
5422 }
5423 postIndex := iNdEx + byteLen
5424 if postIndex < 0 {
5425 return ErrInvalidLengthTheproto3
5426 }
5427 if postIndex > l {
5428 return io.ErrUnexpectedEOF
5429 }
5430 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
5431 if m.Data == nil {
5432 m.Data = []byte{}
5433 }
5434 iNdEx = postIndex
5435 case 7:
5436 if wireType != 0 {
5437 return fmt.Errorf("proto: wrong wireType = %d for field ResultCount", wireType)
5438 }
5439 m.ResultCount = 0
5440 for shift := uint(0); ; shift += 7 {
5441 if shift >= 64 {
5442 return ErrIntOverflowTheproto3
5443 }
5444 if iNdEx >= l {
5445 return io.ErrUnexpectedEOF
5446 }
5447 b := dAtA[iNdEx]
5448 iNdEx++
5449 m.ResultCount |= int64(b&0x7F) << shift
5450 if b < 0x80 {
5451 break
5452 }
5453 }
5454 case 8:
5455 if wireType != 0 {
5456 return fmt.Errorf("proto: wrong wireType = %d for field TrueScotsman", wireType)
5457 }
5458 var v int
5459 for shift := uint(0); ; shift += 7 {
5460 if shift >= 64 {
5461 return ErrIntOverflowTheproto3
5462 }
5463 if iNdEx >= l {
5464 return io.ErrUnexpectedEOF
5465 }
5466 b := dAtA[iNdEx]
5467 iNdEx++
5468 v |= int(b&0x7F) << shift
5469 if b < 0x80 {
5470 break
5471 }
5472 }
5473 m.TrueScotsman = bool(v != 0)
5474 case 9:
5475 if wireType != 5 {
5476 return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType)
5477 }
5478 var v uint32
5479 if (iNdEx + 4) > l {
5480 return io.ErrUnexpectedEOF
5481 }
5482 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
5483 iNdEx += 4
5484 m.Score = float32(math.Float32frombits(v))
5485 case 5:
5486 if wireType == 0 {
5487 var v uint64
5488 for shift := uint(0); ; shift += 7 {
5489 if shift >= 64 {
5490 return ErrIntOverflowTheproto3
5491 }
5492 if iNdEx >= l {
5493 return io.ErrUnexpectedEOF
5494 }
5495 b := dAtA[iNdEx]
5496 iNdEx++
5497 v |= uint64(b&0x7F) << shift
5498 if b < 0x80 {
5499 break
5500 }
5501 }
5502 m.Key = append(m.Key, v)
5503 } else if wireType == 2 {
5504 var packedLen int
5505 for shift := uint(0); ; shift += 7 {
5506 if shift >= 64 {
5507 return ErrIntOverflowTheproto3
5508 }
5509 if iNdEx >= l {
5510 return io.ErrUnexpectedEOF
5511 }
5512 b := dAtA[iNdEx]
5513 iNdEx++
5514 packedLen |= int(b&0x7F) << shift
5515 if b < 0x80 {
5516 break
5517 }
5518 }
5519 if packedLen < 0 {
5520 return ErrInvalidLengthTheproto3
5521 }
5522 postIndex := iNdEx + packedLen
5523 if postIndex < 0 {
5524 return ErrInvalidLengthTheproto3
5525 }
5526 if postIndex > l {
5527 return io.ErrUnexpectedEOF
5528 }
5529 var elementCount int
5530 var count int
5531 for _, integer := range dAtA[iNdEx:postIndex] {
5532 if integer < 128 {
5533 count++
5534 }
5535 }
5536 elementCount = count
5537 if elementCount != 0 && len(m.Key) == 0 {
5538 m.Key = make([]uint64, 0, elementCount)
5539 }
5540 for iNdEx < postIndex {
5541 var v uint64
5542 for shift := uint(0); ; shift += 7 {
5543 if shift >= 64 {
5544 return ErrIntOverflowTheproto3
5545 }
5546 if iNdEx >= l {
5547 return io.ErrUnexpectedEOF
5548 }
5549 b := dAtA[iNdEx]
5550 iNdEx++
5551 v |= uint64(b&0x7F) << shift
5552 if b < 0x80 {
5553 break
5554 }
5555 }
5556 m.Key = append(m.Key, v)
5557 }
5558 } else {
5559 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
5560 }
5561 case 6:
5562 if wireType != 2 {
5563 return fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType)
5564 }
5565 var msglen int
5566 for shift := uint(0); ; shift += 7 {
5567 if shift >= 64 {
5568 return ErrIntOverflowTheproto3
5569 }
5570 if iNdEx >= l {
5571 return io.ErrUnexpectedEOF
5572 }
5573 b := dAtA[iNdEx]
5574 iNdEx++
5575 msglen |= int(b&0x7F) << shift
5576 if b < 0x80 {
5577 break
5578 }
5579 }
5580 if msglen < 0 {
5581 return ErrInvalidLengthTheproto3
5582 }
5583 postIndex := iNdEx + msglen
5584 if postIndex < 0 {
5585 return ErrInvalidLengthTheproto3
5586 }
5587 if postIndex > l {
5588 return io.ErrUnexpectedEOF
5589 }
5590 if m.Nested == nil {
5591 m.Nested = &Nested{}
5592 }
5593 if err := m.Nested.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5594 return err
5595 }
5596 iNdEx = postIndex
5597 case 10:
5598 if wireType != 2 {
5599 return fmt.Errorf("proto: wrong wireType = %d for field Terrain", wireType)
5600 }
5601 var msglen int
5602 for shift := uint(0); ; shift += 7 {
5603 if shift >= 64 {
5604 return ErrIntOverflowTheproto3
5605 }
5606 if iNdEx >= l {
5607 return io.ErrUnexpectedEOF
5608 }
5609 b := dAtA[iNdEx]
5610 iNdEx++
5611 msglen |= int(b&0x7F) << shift
5612 if b < 0x80 {
5613 break
5614 }
5615 }
5616 if msglen < 0 {
5617 return ErrInvalidLengthTheproto3
5618 }
5619 postIndex := iNdEx + msglen
5620 if postIndex < 0 {
5621 return ErrInvalidLengthTheproto3
5622 }
5623 if postIndex > l {
5624 return io.ErrUnexpectedEOF
5625 }
5626 if m.Terrain == nil {
5627 m.Terrain = make(map[int64]*Nested)
5628 }
5629 var mapkey int64
5630 var mapvalue *Nested
5631 for iNdEx < postIndex {
5632 entryPreIndex := iNdEx
5633 var wire uint64
5634 for shift := uint(0); ; shift += 7 {
5635 if shift >= 64 {
5636 return ErrIntOverflowTheproto3
5637 }
5638 if iNdEx >= l {
5639 return io.ErrUnexpectedEOF
5640 }
5641 b := dAtA[iNdEx]
5642 iNdEx++
5643 wire |= uint64(b&0x7F) << shift
5644 if b < 0x80 {
5645 break
5646 }
5647 }
5648 fieldNum := int32(wire >> 3)
5649 if fieldNum == 1 {
5650 for shift := uint(0); ; shift += 7 {
5651 if shift >= 64 {
5652 return ErrIntOverflowTheproto3
5653 }
5654 if iNdEx >= l {
5655 return io.ErrUnexpectedEOF
5656 }
5657 b := dAtA[iNdEx]
5658 iNdEx++
5659 mapkey |= int64(b&0x7F) << shift
5660 if b < 0x80 {
5661 break
5662 }
5663 }
5664 } else if fieldNum == 2 {
5665 var mapmsglen int
5666 for shift := uint(0); ; shift += 7 {
5667 if shift >= 64 {
5668 return ErrIntOverflowTheproto3
5669 }
5670 if iNdEx >= l {
5671 return io.ErrUnexpectedEOF
5672 }
5673 b := dAtA[iNdEx]
5674 iNdEx++
5675 mapmsglen |= int(b&0x7F) << shift
5676 if b < 0x80 {
5677 break
5678 }
5679 }
5680 if mapmsglen < 0 {
5681 return ErrInvalidLengthTheproto3
5682 }
5683 postmsgIndex := iNdEx + mapmsglen
5684 if postmsgIndex < 0 {
5685 return ErrInvalidLengthTheproto3
5686 }
5687 if postmsgIndex > l {
5688 return io.ErrUnexpectedEOF
5689 }
5690 mapvalue = &Nested{}
5691 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
5692 return err
5693 }
5694 iNdEx = postmsgIndex
5695 } else {
5696 iNdEx = entryPreIndex
5697 skippy, err := skipTheproto3(dAtA[iNdEx:])
5698 if err != nil {
5699 return err
5700 }
5701 if (skippy < 0) || (iNdEx+skippy) < 0 {
5702 return ErrInvalidLengthTheproto3
5703 }
5704 if (iNdEx + skippy) > postIndex {
5705 return io.ErrUnexpectedEOF
5706 }
5707 iNdEx += skippy
5708 }
5709 }
5710 m.Terrain[mapkey] = mapvalue
5711 iNdEx = postIndex
5712 case 11:
5713 if wireType != 2 {
5714 return fmt.Errorf("proto: wrong wireType = %d for field Proto2Field", wireType)
5715 }
5716 var msglen int
5717 for shift := uint(0); ; shift += 7 {
5718 if shift >= 64 {
5719 return ErrIntOverflowTheproto3
5720 }
5721 if iNdEx >= l {
5722 return io.ErrUnexpectedEOF
5723 }
5724 b := dAtA[iNdEx]
5725 iNdEx++
5726 msglen |= int(b&0x7F) << shift
5727 if b < 0x80 {
5728 break
5729 }
5730 }
5731 if msglen < 0 {
5732 return ErrInvalidLengthTheproto3
5733 }
5734 postIndex := iNdEx + msglen
5735 if postIndex < 0 {
5736 return ErrInvalidLengthTheproto3
5737 }
5738 if postIndex > l {
5739 return io.ErrUnexpectedEOF
5740 }
5741 if m.Proto2Field == nil {
5742 m.Proto2Field = &both.NinOptNative{}
5743 }
5744 if err := m.Proto2Field.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5745 return err
5746 }
5747 iNdEx = postIndex
5748 case 13:
5749 if wireType != 2 {
5750 return fmt.Errorf("proto: wrong wireType = %d for field Proto2Value", wireType)
5751 }
5752 var msglen int
5753 for shift := uint(0); ; shift += 7 {
5754 if shift >= 64 {
5755 return ErrIntOverflowTheproto3
5756 }
5757 if iNdEx >= l {
5758 return io.ErrUnexpectedEOF
5759 }
5760 b := dAtA[iNdEx]
5761 iNdEx++
5762 msglen |= int(b&0x7F) << shift
5763 if b < 0x80 {
5764 break
5765 }
5766 }
5767 if msglen < 0 {
5768 return ErrInvalidLengthTheproto3
5769 }
5770 postIndex := iNdEx + msglen
5771 if postIndex < 0 {
5772 return ErrInvalidLengthTheproto3
5773 }
5774 if postIndex > l {
5775 return io.ErrUnexpectedEOF
5776 }
5777 if m.Proto2Value == nil {
5778 m.Proto2Value = make(map[int64]*both.NinOptEnum)
5779 }
5780 var mapkey int64
5781 var mapvalue *both.NinOptEnum
5782 for iNdEx < postIndex {
5783 entryPreIndex := iNdEx
5784 var wire uint64
5785 for shift := uint(0); ; shift += 7 {
5786 if shift >= 64 {
5787 return ErrIntOverflowTheproto3
5788 }
5789 if iNdEx >= l {
5790 return io.ErrUnexpectedEOF
5791 }
5792 b := dAtA[iNdEx]
5793 iNdEx++
5794 wire |= uint64(b&0x7F) << shift
5795 if b < 0x80 {
5796 break
5797 }
5798 }
5799 fieldNum := int32(wire >> 3)
5800 if fieldNum == 1 {
5801 for shift := uint(0); ; shift += 7 {
5802 if shift >= 64 {
5803 return ErrIntOverflowTheproto3
5804 }
5805 if iNdEx >= l {
5806 return io.ErrUnexpectedEOF
5807 }
5808 b := dAtA[iNdEx]
5809 iNdEx++
5810 mapkey |= int64(b&0x7F) << shift
5811 if b < 0x80 {
5812 break
5813 }
5814 }
5815 } else if fieldNum == 2 {
5816 var mapmsglen int
5817 for shift := uint(0); ; shift += 7 {
5818 if shift >= 64 {
5819 return ErrIntOverflowTheproto3
5820 }
5821 if iNdEx >= l {
5822 return io.ErrUnexpectedEOF
5823 }
5824 b := dAtA[iNdEx]
5825 iNdEx++
5826 mapmsglen |= int(b&0x7F) << shift
5827 if b < 0x80 {
5828 break
5829 }
5830 }
5831 if mapmsglen < 0 {
5832 return ErrInvalidLengthTheproto3
5833 }
5834 postmsgIndex := iNdEx + mapmsglen
5835 if postmsgIndex < 0 {
5836 return ErrInvalidLengthTheproto3
5837 }
5838 if postmsgIndex > l {
5839 return io.ErrUnexpectedEOF
5840 }
5841 mapvalue = &both.NinOptEnum{}
5842 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
5843 return err
5844 }
5845 iNdEx = postmsgIndex
5846 } else {
5847 iNdEx = entryPreIndex
5848 skippy, err := skipTheproto3(dAtA[iNdEx:])
5849 if err != nil {
5850 return err
5851 }
5852 if (skippy < 0) || (iNdEx+skippy) < 0 {
5853 return ErrInvalidLengthTheproto3
5854 }
5855 if (iNdEx + skippy) > postIndex {
5856 return io.ErrUnexpectedEOF
5857 }
5858 iNdEx += skippy
5859 }
5860 }
5861 m.Proto2Value[mapkey] = mapvalue
5862 iNdEx = postIndex
5863 default:
5864 iNdEx = preIndex
5865 skippy, err := skipTheproto3(dAtA[iNdEx:])
5866 if err != nil {
5867 return err
5868 }
5869 if (skippy < 0) || (iNdEx+skippy) < 0 {
5870 return ErrInvalidLengthTheproto3
5871 }
5872 if (iNdEx + skippy) > l {
5873 return io.ErrUnexpectedEOF
5874 }
5875 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5876 iNdEx += skippy
5877 }
5878 }
5879
5880 if iNdEx > l {
5881 return io.ErrUnexpectedEOF
5882 }
5883 return nil
5884 }
5885 func (m *Nested) Unmarshal(dAtA []byte) error {
5886 l := len(dAtA)
5887 iNdEx := 0
5888 for iNdEx < l {
5889 preIndex := iNdEx
5890 var wire uint64
5891 for shift := uint(0); ; shift += 7 {
5892 if shift >= 64 {
5893 return ErrIntOverflowTheproto3
5894 }
5895 if iNdEx >= l {
5896 return io.ErrUnexpectedEOF
5897 }
5898 b := dAtA[iNdEx]
5899 iNdEx++
5900 wire |= uint64(b&0x7F) << shift
5901 if b < 0x80 {
5902 break
5903 }
5904 }
5905 fieldNum := int32(wire >> 3)
5906 wireType := int(wire & 0x7)
5907 if wireType == 4 {
5908 return fmt.Errorf("proto: Nested: wiretype end group for non-group")
5909 }
5910 if fieldNum <= 0 {
5911 return fmt.Errorf("proto: Nested: illegal tag %d (wire type %d)", fieldNum, wire)
5912 }
5913 switch fieldNum {
5914 case 1:
5915 if wireType != 2 {
5916 return fmt.Errorf("proto: wrong wireType = %d for field Bunny", wireType)
5917 }
5918 var stringLen uint64
5919 for shift := uint(0); ; shift += 7 {
5920 if shift >= 64 {
5921 return ErrIntOverflowTheproto3
5922 }
5923 if iNdEx >= l {
5924 return io.ErrUnexpectedEOF
5925 }
5926 b := dAtA[iNdEx]
5927 iNdEx++
5928 stringLen |= uint64(b&0x7F) << shift
5929 if b < 0x80 {
5930 break
5931 }
5932 }
5933 intStringLen := int(stringLen)
5934 if intStringLen < 0 {
5935 return ErrInvalidLengthTheproto3
5936 }
5937 postIndex := iNdEx + intStringLen
5938 if postIndex < 0 {
5939 return ErrInvalidLengthTheproto3
5940 }
5941 if postIndex > l {
5942 return io.ErrUnexpectedEOF
5943 }
5944 m.Bunny = string(dAtA[iNdEx:postIndex])
5945 iNdEx = postIndex
5946 default:
5947 iNdEx = preIndex
5948 skippy, err := skipTheproto3(dAtA[iNdEx:])
5949 if err != nil {
5950 return err
5951 }
5952 if (skippy < 0) || (iNdEx+skippy) < 0 {
5953 return ErrInvalidLengthTheproto3
5954 }
5955 if (iNdEx + skippy) > l {
5956 return io.ErrUnexpectedEOF
5957 }
5958 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
5959 iNdEx += skippy
5960 }
5961 }
5962
5963 if iNdEx > l {
5964 return io.ErrUnexpectedEOF
5965 }
5966 return nil
5967 }
5968 func (m *AllMaps) Unmarshal(dAtA []byte) error {
5969 l := len(dAtA)
5970 iNdEx := 0
5971 for iNdEx < l {
5972 preIndex := iNdEx
5973 var wire uint64
5974 for shift := uint(0); ; shift += 7 {
5975 if shift >= 64 {
5976 return ErrIntOverflowTheproto3
5977 }
5978 if iNdEx >= l {
5979 return io.ErrUnexpectedEOF
5980 }
5981 b := dAtA[iNdEx]
5982 iNdEx++
5983 wire |= uint64(b&0x7F) << shift
5984 if b < 0x80 {
5985 break
5986 }
5987 }
5988 fieldNum := int32(wire >> 3)
5989 wireType := int(wire & 0x7)
5990 if wireType == 4 {
5991 return fmt.Errorf("proto: AllMaps: wiretype end group for non-group")
5992 }
5993 if fieldNum <= 0 {
5994 return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire)
5995 }
5996 switch fieldNum {
5997 case 1:
5998 if wireType != 2 {
5999 return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType)
6000 }
6001 var msglen int
6002 for shift := uint(0); ; shift += 7 {
6003 if shift >= 64 {
6004 return ErrIntOverflowTheproto3
6005 }
6006 if iNdEx >= l {
6007 return io.ErrUnexpectedEOF
6008 }
6009 b := dAtA[iNdEx]
6010 iNdEx++
6011 msglen |= int(b&0x7F) << shift
6012 if b < 0x80 {
6013 break
6014 }
6015 }
6016 if msglen < 0 {
6017 return ErrInvalidLengthTheproto3
6018 }
6019 postIndex := iNdEx + msglen
6020 if postIndex < 0 {
6021 return ErrInvalidLengthTheproto3
6022 }
6023 if postIndex > l {
6024 return io.ErrUnexpectedEOF
6025 }
6026 if m.StringToDoubleMap == nil {
6027 m.StringToDoubleMap = make(map[string]float64)
6028 }
6029 var mapkey string
6030 var mapvalue float64
6031 for iNdEx < postIndex {
6032 entryPreIndex := iNdEx
6033 var wire uint64
6034 for shift := uint(0); ; shift += 7 {
6035 if shift >= 64 {
6036 return ErrIntOverflowTheproto3
6037 }
6038 if iNdEx >= l {
6039 return io.ErrUnexpectedEOF
6040 }
6041 b := dAtA[iNdEx]
6042 iNdEx++
6043 wire |= uint64(b&0x7F) << shift
6044 if b < 0x80 {
6045 break
6046 }
6047 }
6048 fieldNum := int32(wire >> 3)
6049 if fieldNum == 1 {
6050 var stringLenmapkey uint64
6051 for shift := uint(0); ; shift += 7 {
6052 if shift >= 64 {
6053 return ErrIntOverflowTheproto3
6054 }
6055 if iNdEx >= l {
6056 return io.ErrUnexpectedEOF
6057 }
6058 b := dAtA[iNdEx]
6059 iNdEx++
6060 stringLenmapkey |= uint64(b&0x7F) << shift
6061 if b < 0x80 {
6062 break
6063 }
6064 }
6065 intStringLenmapkey := int(stringLenmapkey)
6066 if intStringLenmapkey < 0 {
6067 return ErrInvalidLengthTheproto3
6068 }
6069 postStringIndexmapkey := iNdEx + intStringLenmapkey
6070 if postStringIndexmapkey < 0 {
6071 return ErrInvalidLengthTheproto3
6072 }
6073 if postStringIndexmapkey > l {
6074 return io.ErrUnexpectedEOF
6075 }
6076 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6077 iNdEx = postStringIndexmapkey
6078 } else if fieldNum == 2 {
6079 var mapvaluetemp uint64
6080 if (iNdEx + 8) > l {
6081 return io.ErrUnexpectedEOF
6082 }
6083 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
6084 iNdEx += 8
6085 mapvalue = math.Float64frombits(mapvaluetemp)
6086 } else {
6087 iNdEx = entryPreIndex
6088 skippy, err := skipTheproto3(dAtA[iNdEx:])
6089 if err != nil {
6090 return err
6091 }
6092 if (skippy < 0) || (iNdEx+skippy) < 0 {
6093 return ErrInvalidLengthTheproto3
6094 }
6095 if (iNdEx + skippy) > postIndex {
6096 return io.ErrUnexpectedEOF
6097 }
6098 iNdEx += skippy
6099 }
6100 }
6101 m.StringToDoubleMap[mapkey] = mapvalue
6102 iNdEx = postIndex
6103 case 2:
6104 if wireType != 2 {
6105 return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType)
6106 }
6107 var msglen int
6108 for shift := uint(0); ; shift += 7 {
6109 if shift >= 64 {
6110 return ErrIntOverflowTheproto3
6111 }
6112 if iNdEx >= l {
6113 return io.ErrUnexpectedEOF
6114 }
6115 b := dAtA[iNdEx]
6116 iNdEx++
6117 msglen |= int(b&0x7F) << shift
6118 if b < 0x80 {
6119 break
6120 }
6121 }
6122 if msglen < 0 {
6123 return ErrInvalidLengthTheproto3
6124 }
6125 postIndex := iNdEx + msglen
6126 if postIndex < 0 {
6127 return ErrInvalidLengthTheproto3
6128 }
6129 if postIndex > l {
6130 return io.ErrUnexpectedEOF
6131 }
6132 if m.StringToFloatMap == nil {
6133 m.StringToFloatMap = make(map[string]float32)
6134 }
6135 var mapkey string
6136 var mapvalue float32
6137 for iNdEx < postIndex {
6138 entryPreIndex := iNdEx
6139 var wire uint64
6140 for shift := uint(0); ; shift += 7 {
6141 if shift >= 64 {
6142 return ErrIntOverflowTheproto3
6143 }
6144 if iNdEx >= l {
6145 return io.ErrUnexpectedEOF
6146 }
6147 b := dAtA[iNdEx]
6148 iNdEx++
6149 wire |= uint64(b&0x7F) << shift
6150 if b < 0x80 {
6151 break
6152 }
6153 }
6154 fieldNum := int32(wire >> 3)
6155 if fieldNum == 1 {
6156 var stringLenmapkey uint64
6157 for shift := uint(0); ; shift += 7 {
6158 if shift >= 64 {
6159 return ErrIntOverflowTheproto3
6160 }
6161 if iNdEx >= l {
6162 return io.ErrUnexpectedEOF
6163 }
6164 b := dAtA[iNdEx]
6165 iNdEx++
6166 stringLenmapkey |= uint64(b&0x7F) << shift
6167 if b < 0x80 {
6168 break
6169 }
6170 }
6171 intStringLenmapkey := int(stringLenmapkey)
6172 if intStringLenmapkey < 0 {
6173 return ErrInvalidLengthTheproto3
6174 }
6175 postStringIndexmapkey := iNdEx + intStringLenmapkey
6176 if postStringIndexmapkey < 0 {
6177 return ErrInvalidLengthTheproto3
6178 }
6179 if postStringIndexmapkey > l {
6180 return io.ErrUnexpectedEOF
6181 }
6182 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6183 iNdEx = postStringIndexmapkey
6184 } else if fieldNum == 2 {
6185 var mapvaluetemp uint32
6186 if (iNdEx + 4) > l {
6187 return io.ErrUnexpectedEOF
6188 }
6189 mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6190 iNdEx += 4
6191 mapvalue = math.Float32frombits(mapvaluetemp)
6192 } else {
6193 iNdEx = entryPreIndex
6194 skippy, err := skipTheproto3(dAtA[iNdEx:])
6195 if err != nil {
6196 return err
6197 }
6198 if (skippy < 0) || (iNdEx+skippy) < 0 {
6199 return ErrInvalidLengthTheproto3
6200 }
6201 if (iNdEx + skippy) > postIndex {
6202 return io.ErrUnexpectedEOF
6203 }
6204 iNdEx += skippy
6205 }
6206 }
6207 m.StringToFloatMap[mapkey] = mapvalue
6208 iNdEx = postIndex
6209 case 3:
6210 if wireType != 2 {
6211 return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType)
6212 }
6213 var msglen int
6214 for shift := uint(0); ; shift += 7 {
6215 if shift >= 64 {
6216 return ErrIntOverflowTheproto3
6217 }
6218 if iNdEx >= l {
6219 return io.ErrUnexpectedEOF
6220 }
6221 b := dAtA[iNdEx]
6222 iNdEx++
6223 msglen |= int(b&0x7F) << shift
6224 if b < 0x80 {
6225 break
6226 }
6227 }
6228 if msglen < 0 {
6229 return ErrInvalidLengthTheproto3
6230 }
6231 postIndex := iNdEx + msglen
6232 if postIndex < 0 {
6233 return ErrInvalidLengthTheproto3
6234 }
6235 if postIndex > l {
6236 return io.ErrUnexpectedEOF
6237 }
6238 if m.Int32Map == nil {
6239 m.Int32Map = make(map[int32]int32)
6240 }
6241 var mapkey int32
6242 var mapvalue int32
6243 for iNdEx < postIndex {
6244 entryPreIndex := iNdEx
6245 var wire uint64
6246 for shift := uint(0); ; shift += 7 {
6247 if shift >= 64 {
6248 return ErrIntOverflowTheproto3
6249 }
6250 if iNdEx >= l {
6251 return io.ErrUnexpectedEOF
6252 }
6253 b := dAtA[iNdEx]
6254 iNdEx++
6255 wire |= uint64(b&0x7F) << shift
6256 if b < 0x80 {
6257 break
6258 }
6259 }
6260 fieldNum := int32(wire >> 3)
6261 if fieldNum == 1 {
6262 for shift := uint(0); ; shift += 7 {
6263 if shift >= 64 {
6264 return ErrIntOverflowTheproto3
6265 }
6266 if iNdEx >= l {
6267 return io.ErrUnexpectedEOF
6268 }
6269 b := dAtA[iNdEx]
6270 iNdEx++
6271 mapkey |= int32(b&0x7F) << shift
6272 if b < 0x80 {
6273 break
6274 }
6275 }
6276 } else if fieldNum == 2 {
6277 for shift := uint(0); ; shift += 7 {
6278 if shift >= 64 {
6279 return ErrIntOverflowTheproto3
6280 }
6281 if iNdEx >= l {
6282 return io.ErrUnexpectedEOF
6283 }
6284 b := dAtA[iNdEx]
6285 iNdEx++
6286 mapvalue |= int32(b&0x7F) << shift
6287 if b < 0x80 {
6288 break
6289 }
6290 }
6291 } else {
6292 iNdEx = entryPreIndex
6293 skippy, err := skipTheproto3(dAtA[iNdEx:])
6294 if err != nil {
6295 return err
6296 }
6297 if (skippy < 0) || (iNdEx+skippy) < 0 {
6298 return ErrInvalidLengthTheproto3
6299 }
6300 if (iNdEx + skippy) > postIndex {
6301 return io.ErrUnexpectedEOF
6302 }
6303 iNdEx += skippy
6304 }
6305 }
6306 m.Int32Map[mapkey] = mapvalue
6307 iNdEx = postIndex
6308 case 4:
6309 if wireType != 2 {
6310 return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType)
6311 }
6312 var msglen int
6313 for shift := uint(0); ; shift += 7 {
6314 if shift >= 64 {
6315 return ErrIntOverflowTheproto3
6316 }
6317 if iNdEx >= l {
6318 return io.ErrUnexpectedEOF
6319 }
6320 b := dAtA[iNdEx]
6321 iNdEx++
6322 msglen |= int(b&0x7F) << shift
6323 if b < 0x80 {
6324 break
6325 }
6326 }
6327 if msglen < 0 {
6328 return ErrInvalidLengthTheproto3
6329 }
6330 postIndex := iNdEx + msglen
6331 if postIndex < 0 {
6332 return ErrInvalidLengthTheproto3
6333 }
6334 if postIndex > l {
6335 return io.ErrUnexpectedEOF
6336 }
6337 if m.Int64Map == nil {
6338 m.Int64Map = make(map[int64]int64)
6339 }
6340 var mapkey int64
6341 var mapvalue int64
6342 for iNdEx < postIndex {
6343 entryPreIndex := iNdEx
6344 var wire uint64
6345 for shift := uint(0); ; shift += 7 {
6346 if shift >= 64 {
6347 return ErrIntOverflowTheproto3
6348 }
6349 if iNdEx >= l {
6350 return io.ErrUnexpectedEOF
6351 }
6352 b := dAtA[iNdEx]
6353 iNdEx++
6354 wire |= uint64(b&0x7F) << shift
6355 if b < 0x80 {
6356 break
6357 }
6358 }
6359 fieldNum := int32(wire >> 3)
6360 if fieldNum == 1 {
6361 for shift := uint(0); ; shift += 7 {
6362 if shift >= 64 {
6363 return ErrIntOverflowTheproto3
6364 }
6365 if iNdEx >= l {
6366 return io.ErrUnexpectedEOF
6367 }
6368 b := dAtA[iNdEx]
6369 iNdEx++
6370 mapkey |= int64(b&0x7F) << shift
6371 if b < 0x80 {
6372 break
6373 }
6374 }
6375 } else if fieldNum == 2 {
6376 for shift := uint(0); ; shift += 7 {
6377 if shift >= 64 {
6378 return ErrIntOverflowTheproto3
6379 }
6380 if iNdEx >= l {
6381 return io.ErrUnexpectedEOF
6382 }
6383 b := dAtA[iNdEx]
6384 iNdEx++
6385 mapvalue |= int64(b&0x7F) << shift
6386 if b < 0x80 {
6387 break
6388 }
6389 }
6390 } else {
6391 iNdEx = entryPreIndex
6392 skippy, err := skipTheproto3(dAtA[iNdEx:])
6393 if err != nil {
6394 return err
6395 }
6396 if (skippy < 0) || (iNdEx+skippy) < 0 {
6397 return ErrInvalidLengthTheproto3
6398 }
6399 if (iNdEx + skippy) > postIndex {
6400 return io.ErrUnexpectedEOF
6401 }
6402 iNdEx += skippy
6403 }
6404 }
6405 m.Int64Map[mapkey] = mapvalue
6406 iNdEx = postIndex
6407 case 5:
6408 if wireType != 2 {
6409 return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType)
6410 }
6411 var msglen int
6412 for shift := uint(0); ; shift += 7 {
6413 if shift >= 64 {
6414 return ErrIntOverflowTheproto3
6415 }
6416 if iNdEx >= l {
6417 return io.ErrUnexpectedEOF
6418 }
6419 b := dAtA[iNdEx]
6420 iNdEx++
6421 msglen |= int(b&0x7F) << shift
6422 if b < 0x80 {
6423 break
6424 }
6425 }
6426 if msglen < 0 {
6427 return ErrInvalidLengthTheproto3
6428 }
6429 postIndex := iNdEx + msglen
6430 if postIndex < 0 {
6431 return ErrInvalidLengthTheproto3
6432 }
6433 if postIndex > l {
6434 return io.ErrUnexpectedEOF
6435 }
6436 if m.Uint32Map == nil {
6437 m.Uint32Map = make(map[uint32]uint32)
6438 }
6439 var mapkey uint32
6440 var mapvalue uint32
6441 for iNdEx < postIndex {
6442 entryPreIndex := iNdEx
6443 var wire uint64
6444 for shift := uint(0); ; shift += 7 {
6445 if shift >= 64 {
6446 return ErrIntOverflowTheproto3
6447 }
6448 if iNdEx >= l {
6449 return io.ErrUnexpectedEOF
6450 }
6451 b := dAtA[iNdEx]
6452 iNdEx++
6453 wire |= uint64(b&0x7F) << shift
6454 if b < 0x80 {
6455 break
6456 }
6457 }
6458 fieldNum := int32(wire >> 3)
6459 if fieldNum == 1 {
6460 for shift := uint(0); ; shift += 7 {
6461 if shift >= 64 {
6462 return ErrIntOverflowTheproto3
6463 }
6464 if iNdEx >= l {
6465 return io.ErrUnexpectedEOF
6466 }
6467 b := dAtA[iNdEx]
6468 iNdEx++
6469 mapkey |= uint32(b&0x7F) << shift
6470 if b < 0x80 {
6471 break
6472 }
6473 }
6474 } else if fieldNum == 2 {
6475 for shift := uint(0); ; shift += 7 {
6476 if shift >= 64 {
6477 return ErrIntOverflowTheproto3
6478 }
6479 if iNdEx >= l {
6480 return io.ErrUnexpectedEOF
6481 }
6482 b := dAtA[iNdEx]
6483 iNdEx++
6484 mapvalue |= uint32(b&0x7F) << shift
6485 if b < 0x80 {
6486 break
6487 }
6488 }
6489 } else {
6490 iNdEx = entryPreIndex
6491 skippy, err := skipTheproto3(dAtA[iNdEx:])
6492 if err != nil {
6493 return err
6494 }
6495 if (skippy < 0) || (iNdEx+skippy) < 0 {
6496 return ErrInvalidLengthTheproto3
6497 }
6498 if (iNdEx + skippy) > postIndex {
6499 return io.ErrUnexpectedEOF
6500 }
6501 iNdEx += skippy
6502 }
6503 }
6504 m.Uint32Map[mapkey] = mapvalue
6505 iNdEx = postIndex
6506 case 6:
6507 if wireType != 2 {
6508 return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType)
6509 }
6510 var msglen int
6511 for shift := uint(0); ; shift += 7 {
6512 if shift >= 64 {
6513 return ErrIntOverflowTheproto3
6514 }
6515 if iNdEx >= l {
6516 return io.ErrUnexpectedEOF
6517 }
6518 b := dAtA[iNdEx]
6519 iNdEx++
6520 msglen |= int(b&0x7F) << shift
6521 if b < 0x80 {
6522 break
6523 }
6524 }
6525 if msglen < 0 {
6526 return ErrInvalidLengthTheproto3
6527 }
6528 postIndex := iNdEx + msglen
6529 if postIndex < 0 {
6530 return ErrInvalidLengthTheproto3
6531 }
6532 if postIndex > l {
6533 return io.ErrUnexpectedEOF
6534 }
6535 if m.Uint64Map == nil {
6536 m.Uint64Map = make(map[uint64]uint64)
6537 }
6538 var mapkey uint64
6539 var mapvalue uint64
6540 for iNdEx < postIndex {
6541 entryPreIndex := iNdEx
6542 var wire uint64
6543 for shift := uint(0); ; shift += 7 {
6544 if shift >= 64 {
6545 return ErrIntOverflowTheproto3
6546 }
6547 if iNdEx >= l {
6548 return io.ErrUnexpectedEOF
6549 }
6550 b := dAtA[iNdEx]
6551 iNdEx++
6552 wire |= uint64(b&0x7F) << shift
6553 if b < 0x80 {
6554 break
6555 }
6556 }
6557 fieldNum := int32(wire >> 3)
6558 if fieldNum == 1 {
6559 for shift := uint(0); ; shift += 7 {
6560 if shift >= 64 {
6561 return ErrIntOverflowTheproto3
6562 }
6563 if iNdEx >= l {
6564 return io.ErrUnexpectedEOF
6565 }
6566 b := dAtA[iNdEx]
6567 iNdEx++
6568 mapkey |= uint64(b&0x7F) << shift
6569 if b < 0x80 {
6570 break
6571 }
6572 }
6573 } else if fieldNum == 2 {
6574 for shift := uint(0); ; shift += 7 {
6575 if shift >= 64 {
6576 return ErrIntOverflowTheproto3
6577 }
6578 if iNdEx >= l {
6579 return io.ErrUnexpectedEOF
6580 }
6581 b := dAtA[iNdEx]
6582 iNdEx++
6583 mapvalue |= uint64(b&0x7F) << shift
6584 if b < 0x80 {
6585 break
6586 }
6587 }
6588 } else {
6589 iNdEx = entryPreIndex
6590 skippy, err := skipTheproto3(dAtA[iNdEx:])
6591 if err != nil {
6592 return err
6593 }
6594 if (skippy < 0) || (iNdEx+skippy) < 0 {
6595 return ErrInvalidLengthTheproto3
6596 }
6597 if (iNdEx + skippy) > postIndex {
6598 return io.ErrUnexpectedEOF
6599 }
6600 iNdEx += skippy
6601 }
6602 }
6603 m.Uint64Map[mapkey] = mapvalue
6604 iNdEx = postIndex
6605 case 7:
6606 if wireType != 2 {
6607 return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType)
6608 }
6609 var msglen int
6610 for shift := uint(0); ; shift += 7 {
6611 if shift >= 64 {
6612 return ErrIntOverflowTheproto3
6613 }
6614 if iNdEx >= l {
6615 return io.ErrUnexpectedEOF
6616 }
6617 b := dAtA[iNdEx]
6618 iNdEx++
6619 msglen |= int(b&0x7F) << shift
6620 if b < 0x80 {
6621 break
6622 }
6623 }
6624 if msglen < 0 {
6625 return ErrInvalidLengthTheproto3
6626 }
6627 postIndex := iNdEx + msglen
6628 if postIndex < 0 {
6629 return ErrInvalidLengthTheproto3
6630 }
6631 if postIndex > l {
6632 return io.ErrUnexpectedEOF
6633 }
6634 if m.Sint32Map == nil {
6635 m.Sint32Map = make(map[int32]int32)
6636 }
6637 var mapkey int32
6638 var mapvalue int32
6639 for iNdEx < postIndex {
6640 entryPreIndex := iNdEx
6641 var wire uint64
6642 for shift := uint(0); ; shift += 7 {
6643 if shift >= 64 {
6644 return ErrIntOverflowTheproto3
6645 }
6646 if iNdEx >= l {
6647 return io.ErrUnexpectedEOF
6648 }
6649 b := dAtA[iNdEx]
6650 iNdEx++
6651 wire |= uint64(b&0x7F) << shift
6652 if b < 0x80 {
6653 break
6654 }
6655 }
6656 fieldNum := int32(wire >> 3)
6657 if fieldNum == 1 {
6658 var mapkeytemp int32
6659 for shift := uint(0); ; shift += 7 {
6660 if shift >= 64 {
6661 return ErrIntOverflowTheproto3
6662 }
6663 if iNdEx >= l {
6664 return io.ErrUnexpectedEOF
6665 }
6666 b := dAtA[iNdEx]
6667 iNdEx++
6668 mapkeytemp |= int32(b&0x7F) << shift
6669 if b < 0x80 {
6670 break
6671 }
6672 }
6673 mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
6674 mapkey = int32(mapkeytemp)
6675 } else if fieldNum == 2 {
6676 var mapvaluetemp int32
6677 for shift := uint(0); ; shift += 7 {
6678 if shift >= 64 {
6679 return ErrIntOverflowTheproto3
6680 }
6681 if iNdEx >= l {
6682 return io.ErrUnexpectedEOF
6683 }
6684 b := dAtA[iNdEx]
6685 iNdEx++
6686 mapvaluetemp |= int32(b&0x7F) << shift
6687 if b < 0x80 {
6688 break
6689 }
6690 }
6691 mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
6692 mapvalue = int32(mapvaluetemp)
6693 } else {
6694 iNdEx = entryPreIndex
6695 skippy, err := skipTheproto3(dAtA[iNdEx:])
6696 if err != nil {
6697 return err
6698 }
6699 if (skippy < 0) || (iNdEx+skippy) < 0 {
6700 return ErrInvalidLengthTheproto3
6701 }
6702 if (iNdEx + skippy) > postIndex {
6703 return io.ErrUnexpectedEOF
6704 }
6705 iNdEx += skippy
6706 }
6707 }
6708 m.Sint32Map[mapkey] = mapvalue
6709 iNdEx = postIndex
6710 case 8:
6711 if wireType != 2 {
6712 return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType)
6713 }
6714 var msglen int
6715 for shift := uint(0); ; shift += 7 {
6716 if shift >= 64 {
6717 return ErrIntOverflowTheproto3
6718 }
6719 if iNdEx >= l {
6720 return io.ErrUnexpectedEOF
6721 }
6722 b := dAtA[iNdEx]
6723 iNdEx++
6724 msglen |= int(b&0x7F) << shift
6725 if b < 0x80 {
6726 break
6727 }
6728 }
6729 if msglen < 0 {
6730 return ErrInvalidLengthTheproto3
6731 }
6732 postIndex := iNdEx + msglen
6733 if postIndex < 0 {
6734 return ErrInvalidLengthTheproto3
6735 }
6736 if postIndex > l {
6737 return io.ErrUnexpectedEOF
6738 }
6739 if m.Sint64Map == nil {
6740 m.Sint64Map = make(map[int64]int64)
6741 }
6742 var mapkey int64
6743 var mapvalue int64
6744 for iNdEx < postIndex {
6745 entryPreIndex := iNdEx
6746 var wire uint64
6747 for shift := uint(0); ; shift += 7 {
6748 if shift >= 64 {
6749 return ErrIntOverflowTheproto3
6750 }
6751 if iNdEx >= l {
6752 return io.ErrUnexpectedEOF
6753 }
6754 b := dAtA[iNdEx]
6755 iNdEx++
6756 wire |= uint64(b&0x7F) << shift
6757 if b < 0x80 {
6758 break
6759 }
6760 }
6761 fieldNum := int32(wire >> 3)
6762 if fieldNum == 1 {
6763 var mapkeytemp uint64
6764 for shift := uint(0); ; shift += 7 {
6765 if shift >= 64 {
6766 return ErrIntOverflowTheproto3
6767 }
6768 if iNdEx >= l {
6769 return io.ErrUnexpectedEOF
6770 }
6771 b := dAtA[iNdEx]
6772 iNdEx++
6773 mapkeytemp |= uint64(b&0x7F) << shift
6774 if b < 0x80 {
6775 break
6776 }
6777 }
6778 mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
6779 mapkey = int64(mapkeytemp)
6780 } else if fieldNum == 2 {
6781 var mapvaluetemp uint64
6782 for shift := uint(0); ; shift += 7 {
6783 if shift >= 64 {
6784 return ErrIntOverflowTheproto3
6785 }
6786 if iNdEx >= l {
6787 return io.ErrUnexpectedEOF
6788 }
6789 b := dAtA[iNdEx]
6790 iNdEx++
6791 mapvaluetemp |= uint64(b&0x7F) << shift
6792 if b < 0x80 {
6793 break
6794 }
6795 }
6796 mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
6797 mapvalue = int64(mapvaluetemp)
6798 } else {
6799 iNdEx = entryPreIndex
6800 skippy, err := skipTheproto3(dAtA[iNdEx:])
6801 if err != nil {
6802 return err
6803 }
6804 if (skippy < 0) || (iNdEx+skippy) < 0 {
6805 return ErrInvalidLengthTheproto3
6806 }
6807 if (iNdEx + skippy) > postIndex {
6808 return io.ErrUnexpectedEOF
6809 }
6810 iNdEx += skippy
6811 }
6812 }
6813 m.Sint64Map[mapkey] = mapvalue
6814 iNdEx = postIndex
6815 case 9:
6816 if wireType != 2 {
6817 return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType)
6818 }
6819 var msglen int
6820 for shift := uint(0); ; shift += 7 {
6821 if shift >= 64 {
6822 return ErrIntOverflowTheproto3
6823 }
6824 if iNdEx >= l {
6825 return io.ErrUnexpectedEOF
6826 }
6827 b := dAtA[iNdEx]
6828 iNdEx++
6829 msglen |= int(b&0x7F) << shift
6830 if b < 0x80 {
6831 break
6832 }
6833 }
6834 if msglen < 0 {
6835 return ErrInvalidLengthTheproto3
6836 }
6837 postIndex := iNdEx + msglen
6838 if postIndex < 0 {
6839 return ErrInvalidLengthTheproto3
6840 }
6841 if postIndex > l {
6842 return io.ErrUnexpectedEOF
6843 }
6844 if m.Fixed32Map == nil {
6845 m.Fixed32Map = make(map[uint32]uint32)
6846 }
6847 var mapkey uint32
6848 var mapvalue uint32
6849 for iNdEx < postIndex {
6850 entryPreIndex := iNdEx
6851 var wire uint64
6852 for shift := uint(0); ; shift += 7 {
6853 if shift >= 64 {
6854 return ErrIntOverflowTheproto3
6855 }
6856 if iNdEx >= l {
6857 return io.ErrUnexpectedEOF
6858 }
6859 b := dAtA[iNdEx]
6860 iNdEx++
6861 wire |= uint64(b&0x7F) << shift
6862 if b < 0x80 {
6863 break
6864 }
6865 }
6866 fieldNum := int32(wire >> 3)
6867 if fieldNum == 1 {
6868 if (iNdEx + 4) > l {
6869 return io.ErrUnexpectedEOF
6870 }
6871 mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6872 iNdEx += 4
6873 } else if fieldNum == 2 {
6874 if (iNdEx + 4) > l {
6875 return io.ErrUnexpectedEOF
6876 }
6877 mapvalue = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6878 iNdEx += 4
6879 } else {
6880 iNdEx = entryPreIndex
6881 skippy, err := skipTheproto3(dAtA[iNdEx:])
6882 if err != nil {
6883 return err
6884 }
6885 if (skippy < 0) || (iNdEx+skippy) < 0 {
6886 return ErrInvalidLengthTheproto3
6887 }
6888 if (iNdEx + skippy) > postIndex {
6889 return io.ErrUnexpectedEOF
6890 }
6891 iNdEx += skippy
6892 }
6893 }
6894 m.Fixed32Map[mapkey] = mapvalue
6895 iNdEx = postIndex
6896 case 10:
6897 if wireType != 2 {
6898 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType)
6899 }
6900 var msglen int
6901 for shift := uint(0); ; shift += 7 {
6902 if shift >= 64 {
6903 return ErrIntOverflowTheproto3
6904 }
6905 if iNdEx >= l {
6906 return io.ErrUnexpectedEOF
6907 }
6908 b := dAtA[iNdEx]
6909 iNdEx++
6910 msglen |= int(b&0x7F) << shift
6911 if b < 0x80 {
6912 break
6913 }
6914 }
6915 if msglen < 0 {
6916 return ErrInvalidLengthTheproto3
6917 }
6918 postIndex := iNdEx + msglen
6919 if postIndex < 0 {
6920 return ErrInvalidLengthTheproto3
6921 }
6922 if postIndex > l {
6923 return io.ErrUnexpectedEOF
6924 }
6925 if m.Sfixed32Map == nil {
6926 m.Sfixed32Map = make(map[int32]int32)
6927 }
6928 var mapkey int32
6929 var mapvalue int32
6930 for iNdEx < postIndex {
6931 entryPreIndex := iNdEx
6932 var wire uint64
6933 for shift := uint(0); ; shift += 7 {
6934 if shift >= 64 {
6935 return ErrIntOverflowTheproto3
6936 }
6937 if iNdEx >= l {
6938 return io.ErrUnexpectedEOF
6939 }
6940 b := dAtA[iNdEx]
6941 iNdEx++
6942 wire |= uint64(b&0x7F) << shift
6943 if b < 0x80 {
6944 break
6945 }
6946 }
6947 fieldNum := int32(wire >> 3)
6948 if fieldNum == 1 {
6949 if (iNdEx + 4) > l {
6950 return io.ErrUnexpectedEOF
6951 }
6952 mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6953 iNdEx += 4
6954 } else if fieldNum == 2 {
6955 if (iNdEx + 4) > l {
6956 return io.ErrUnexpectedEOF
6957 }
6958 mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6959 iNdEx += 4
6960 } else {
6961 iNdEx = entryPreIndex
6962 skippy, err := skipTheproto3(dAtA[iNdEx:])
6963 if err != nil {
6964 return err
6965 }
6966 if (skippy < 0) || (iNdEx+skippy) < 0 {
6967 return ErrInvalidLengthTheproto3
6968 }
6969 if (iNdEx + skippy) > postIndex {
6970 return io.ErrUnexpectedEOF
6971 }
6972 iNdEx += skippy
6973 }
6974 }
6975 m.Sfixed32Map[mapkey] = mapvalue
6976 iNdEx = postIndex
6977 case 11:
6978 if wireType != 2 {
6979 return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType)
6980 }
6981 var msglen int
6982 for shift := uint(0); ; shift += 7 {
6983 if shift >= 64 {
6984 return ErrIntOverflowTheproto3
6985 }
6986 if iNdEx >= l {
6987 return io.ErrUnexpectedEOF
6988 }
6989 b := dAtA[iNdEx]
6990 iNdEx++
6991 msglen |= int(b&0x7F) << shift
6992 if b < 0x80 {
6993 break
6994 }
6995 }
6996 if msglen < 0 {
6997 return ErrInvalidLengthTheproto3
6998 }
6999 postIndex := iNdEx + msglen
7000 if postIndex < 0 {
7001 return ErrInvalidLengthTheproto3
7002 }
7003 if postIndex > l {
7004 return io.ErrUnexpectedEOF
7005 }
7006 if m.Fixed64Map == nil {
7007 m.Fixed64Map = make(map[uint64]uint64)
7008 }
7009 var mapkey uint64
7010 var mapvalue uint64
7011 for iNdEx < postIndex {
7012 entryPreIndex := iNdEx
7013 var wire uint64
7014 for shift := uint(0); ; shift += 7 {
7015 if shift >= 64 {
7016 return ErrIntOverflowTheproto3
7017 }
7018 if iNdEx >= l {
7019 return io.ErrUnexpectedEOF
7020 }
7021 b := dAtA[iNdEx]
7022 iNdEx++
7023 wire |= uint64(b&0x7F) << shift
7024 if b < 0x80 {
7025 break
7026 }
7027 }
7028 fieldNum := int32(wire >> 3)
7029 if fieldNum == 1 {
7030 if (iNdEx + 8) > l {
7031 return io.ErrUnexpectedEOF
7032 }
7033 mapkey = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7034 iNdEx += 8
7035 } else if fieldNum == 2 {
7036 if (iNdEx + 8) > l {
7037 return io.ErrUnexpectedEOF
7038 }
7039 mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7040 iNdEx += 8
7041 } else {
7042 iNdEx = entryPreIndex
7043 skippy, err := skipTheproto3(dAtA[iNdEx:])
7044 if err != nil {
7045 return err
7046 }
7047 if (skippy < 0) || (iNdEx+skippy) < 0 {
7048 return ErrInvalidLengthTheproto3
7049 }
7050 if (iNdEx + skippy) > postIndex {
7051 return io.ErrUnexpectedEOF
7052 }
7053 iNdEx += skippy
7054 }
7055 }
7056 m.Fixed64Map[mapkey] = mapvalue
7057 iNdEx = postIndex
7058 case 12:
7059 if wireType != 2 {
7060 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType)
7061 }
7062 var msglen int
7063 for shift := uint(0); ; shift += 7 {
7064 if shift >= 64 {
7065 return ErrIntOverflowTheproto3
7066 }
7067 if iNdEx >= l {
7068 return io.ErrUnexpectedEOF
7069 }
7070 b := dAtA[iNdEx]
7071 iNdEx++
7072 msglen |= int(b&0x7F) << shift
7073 if b < 0x80 {
7074 break
7075 }
7076 }
7077 if msglen < 0 {
7078 return ErrInvalidLengthTheproto3
7079 }
7080 postIndex := iNdEx + msglen
7081 if postIndex < 0 {
7082 return ErrInvalidLengthTheproto3
7083 }
7084 if postIndex > l {
7085 return io.ErrUnexpectedEOF
7086 }
7087 if m.Sfixed64Map == nil {
7088 m.Sfixed64Map = make(map[int64]int64)
7089 }
7090 var mapkey int64
7091 var mapvalue int64
7092 for iNdEx < postIndex {
7093 entryPreIndex := iNdEx
7094 var wire uint64
7095 for shift := uint(0); ; shift += 7 {
7096 if shift >= 64 {
7097 return ErrIntOverflowTheproto3
7098 }
7099 if iNdEx >= l {
7100 return io.ErrUnexpectedEOF
7101 }
7102 b := dAtA[iNdEx]
7103 iNdEx++
7104 wire |= uint64(b&0x7F) << shift
7105 if b < 0x80 {
7106 break
7107 }
7108 }
7109 fieldNum := int32(wire >> 3)
7110 if fieldNum == 1 {
7111 if (iNdEx + 8) > l {
7112 return io.ErrUnexpectedEOF
7113 }
7114 mapkey = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7115 iNdEx += 8
7116 } else if fieldNum == 2 {
7117 if (iNdEx + 8) > l {
7118 return io.ErrUnexpectedEOF
7119 }
7120 mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7121 iNdEx += 8
7122 } else {
7123 iNdEx = entryPreIndex
7124 skippy, err := skipTheproto3(dAtA[iNdEx:])
7125 if err != nil {
7126 return err
7127 }
7128 if (skippy < 0) || (iNdEx+skippy) < 0 {
7129 return ErrInvalidLengthTheproto3
7130 }
7131 if (iNdEx + skippy) > postIndex {
7132 return io.ErrUnexpectedEOF
7133 }
7134 iNdEx += skippy
7135 }
7136 }
7137 m.Sfixed64Map[mapkey] = mapvalue
7138 iNdEx = postIndex
7139 case 13:
7140 if wireType != 2 {
7141 return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType)
7142 }
7143 var msglen int
7144 for shift := uint(0); ; shift += 7 {
7145 if shift >= 64 {
7146 return ErrIntOverflowTheproto3
7147 }
7148 if iNdEx >= l {
7149 return io.ErrUnexpectedEOF
7150 }
7151 b := dAtA[iNdEx]
7152 iNdEx++
7153 msglen |= int(b&0x7F) << shift
7154 if b < 0x80 {
7155 break
7156 }
7157 }
7158 if msglen < 0 {
7159 return ErrInvalidLengthTheproto3
7160 }
7161 postIndex := iNdEx + msglen
7162 if postIndex < 0 {
7163 return ErrInvalidLengthTheproto3
7164 }
7165 if postIndex > l {
7166 return io.ErrUnexpectedEOF
7167 }
7168 if m.BoolMap == nil {
7169 m.BoolMap = make(map[bool]bool)
7170 }
7171 var mapkey bool
7172 var mapvalue bool
7173 for iNdEx < postIndex {
7174 entryPreIndex := iNdEx
7175 var wire uint64
7176 for shift := uint(0); ; shift += 7 {
7177 if shift >= 64 {
7178 return ErrIntOverflowTheproto3
7179 }
7180 if iNdEx >= l {
7181 return io.ErrUnexpectedEOF
7182 }
7183 b := dAtA[iNdEx]
7184 iNdEx++
7185 wire |= uint64(b&0x7F) << shift
7186 if b < 0x80 {
7187 break
7188 }
7189 }
7190 fieldNum := int32(wire >> 3)
7191 if fieldNum == 1 {
7192 var mapkeytemp int
7193 for shift := uint(0); ; shift += 7 {
7194 if shift >= 64 {
7195 return ErrIntOverflowTheproto3
7196 }
7197 if iNdEx >= l {
7198 return io.ErrUnexpectedEOF
7199 }
7200 b := dAtA[iNdEx]
7201 iNdEx++
7202 mapkeytemp |= int(b&0x7F) << shift
7203 if b < 0x80 {
7204 break
7205 }
7206 }
7207 mapkey = bool(mapkeytemp != 0)
7208 } else if fieldNum == 2 {
7209 var mapvaluetemp int
7210 for shift := uint(0); ; shift += 7 {
7211 if shift >= 64 {
7212 return ErrIntOverflowTheproto3
7213 }
7214 if iNdEx >= l {
7215 return io.ErrUnexpectedEOF
7216 }
7217 b := dAtA[iNdEx]
7218 iNdEx++
7219 mapvaluetemp |= int(b&0x7F) << shift
7220 if b < 0x80 {
7221 break
7222 }
7223 }
7224 mapvalue = bool(mapvaluetemp != 0)
7225 } else {
7226 iNdEx = entryPreIndex
7227 skippy, err := skipTheproto3(dAtA[iNdEx:])
7228 if err != nil {
7229 return err
7230 }
7231 if (skippy < 0) || (iNdEx+skippy) < 0 {
7232 return ErrInvalidLengthTheproto3
7233 }
7234 if (iNdEx + skippy) > postIndex {
7235 return io.ErrUnexpectedEOF
7236 }
7237 iNdEx += skippy
7238 }
7239 }
7240 m.BoolMap[mapkey] = mapvalue
7241 iNdEx = postIndex
7242 case 14:
7243 if wireType != 2 {
7244 return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType)
7245 }
7246 var msglen int
7247 for shift := uint(0); ; shift += 7 {
7248 if shift >= 64 {
7249 return ErrIntOverflowTheproto3
7250 }
7251 if iNdEx >= l {
7252 return io.ErrUnexpectedEOF
7253 }
7254 b := dAtA[iNdEx]
7255 iNdEx++
7256 msglen |= int(b&0x7F) << shift
7257 if b < 0x80 {
7258 break
7259 }
7260 }
7261 if msglen < 0 {
7262 return ErrInvalidLengthTheproto3
7263 }
7264 postIndex := iNdEx + msglen
7265 if postIndex < 0 {
7266 return ErrInvalidLengthTheproto3
7267 }
7268 if postIndex > l {
7269 return io.ErrUnexpectedEOF
7270 }
7271 if m.StringMap == nil {
7272 m.StringMap = make(map[string]string)
7273 }
7274 var mapkey string
7275 var mapvalue string
7276 for iNdEx < postIndex {
7277 entryPreIndex := iNdEx
7278 var wire uint64
7279 for shift := uint(0); ; shift += 7 {
7280 if shift >= 64 {
7281 return ErrIntOverflowTheproto3
7282 }
7283 if iNdEx >= l {
7284 return io.ErrUnexpectedEOF
7285 }
7286 b := dAtA[iNdEx]
7287 iNdEx++
7288 wire |= uint64(b&0x7F) << shift
7289 if b < 0x80 {
7290 break
7291 }
7292 }
7293 fieldNum := int32(wire >> 3)
7294 if fieldNum == 1 {
7295 var stringLenmapkey uint64
7296 for shift := uint(0); ; shift += 7 {
7297 if shift >= 64 {
7298 return ErrIntOverflowTheproto3
7299 }
7300 if iNdEx >= l {
7301 return io.ErrUnexpectedEOF
7302 }
7303 b := dAtA[iNdEx]
7304 iNdEx++
7305 stringLenmapkey |= uint64(b&0x7F) << shift
7306 if b < 0x80 {
7307 break
7308 }
7309 }
7310 intStringLenmapkey := int(stringLenmapkey)
7311 if intStringLenmapkey < 0 {
7312 return ErrInvalidLengthTheproto3
7313 }
7314 postStringIndexmapkey := iNdEx + intStringLenmapkey
7315 if postStringIndexmapkey < 0 {
7316 return ErrInvalidLengthTheproto3
7317 }
7318 if postStringIndexmapkey > l {
7319 return io.ErrUnexpectedEOF
7320 }
7321 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7322 iNdEx = postStringIndexmapkey
7323 } else if fieldNum == 2 {
7324 var stringLenmapvalue uint64
7325 for shift := uint(0); ; shift += 7 {
7326 if shift >= 64 {
7327 return ErrIntOverflowTheproto3
7328 }
7329 if iNdEx >= l {
7330 return io.ErrUnexpectedEOF
7331 }
7332 b := dAtA[iNdEx]
7333 iNdEx++
7334 stringLenmapvalue |= uint64(b&0x7F) << shift
7335 if b < 0x80 {
7336 break
7337 }
7338 }
7339 intStringLenmapvalue := int(stringLenmapvalue)
7340 if intStringLenmapvalue < 0 {
7341 return ErrInvalidLengthTheproto3
7342 }
7343 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
7344 if postStringIndexmapvalue < 0 {
7345 return ErrInvalidLengthTheproto3
7346 }
7347 if postStringIndexmapvalue > l {
7348 return io.ErrUnexpectedEOF
7349 }
7350 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
7351 iNdEx = postStringIndexmapvalue
7352 } else {
7353 iNdEx = entryPreIndex
7354 skippy, err := skipTheproto3(dAtA[iNdEx:])
7355 if err != nil {
7356 return err
7357 }
7358 if (skippy < 0) || (iNdEx+skippy) < 0 {
7359 return ErrInvalidLengthTheproto3
7360 }
7361 if (iNdEx + skippy) > postIndex {
7362 return io.ErrUnexpectedEOF
7363 }
7364 iNdEx += skippy
7365 }
7366 }
7367 m.StringMap[mapkey] = mapvalue
7368 iNdEx = postIndex
7369 case 15:
7370 if wireType != 2 {
7371 return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType)
7372 }
7373 var msglen int
7374 for shift := uint(0); ; shift += 7 {
7375 if shift >= 64 {
7376 return ErrIntOverflowTheproto3
7377 }
7378 if iNdEx >= l {
7379 return io.ErrUnexpectedEOF
7380 }
7381 b := dAtA[iNdEx]
7382 iNdEx++
7383 msglen |= int(b&0x7F) << shift
7384 if b < 0x80 {
7385 break
7386 }
7387 }
7388 if msglen < 0 {
7389 return ErrInvalidLengthTheproto3
7390 }
7391 postIndex := iNdEx + msglen
7392 if postIndex < 0 {
7393 return ErrInvalidLengthTheproto3
7394 }
7395 if postIndex > l {
7396 return io.ErrUnexpectedEOF
7397 }
7398 if m.StringToBytesMap == nil {
7399 m.StringToBytesMap = make(map[string][]byte)
7400 }
7401 var mapkey string
7402 mapvalue := []byte{}
7403 for iNdEx < postIndex {
7404 entryPreIndex := iNdEx
7405 var wire uint64
7406 for shift := uint(0); ; shift += 7 {
7407 if shift >= 64 {
7408 return ErrIntOverflowTheproto3
7409 }
7410 if iNdEx >= l {
7411 return io.ErrUnexpectedEOF
7412 }
7413 b := dAtA[iNdEx]
7414 iNdEx++
7415 wire |= uint64(b&0x7F) << shift
7416 if b < 0x80 {
7417 break
7418 }
7419 }
7420 fieldNum := int32(wire >> 3)
7421 if fieldNum == 1 {
7422 var stringLenmapkey uint64
7423 for shift := uint(0); ; shift += 7 {
7424 if shift >= 64 {
7425 return ErrIntOverflowTheproto3
7426 }
7427 if iNdEx >= l {
7428 return io.ErrUnexpectedEOF
7429 }
7430 b := dAtA[iNdEx]
7431 iNdEx++
7432 stringLenmapkey |= uint64(b&0x7F) << shift
7433 if b < 0x80 {
7434 break
7435 }
7436 }
7437 intStringLenmapkey := int(stringLenmapkey)
7438 if intStringLenmapkey < 0 {
7439 return ErrInvalidLengthTheproto3
7440 }
7441 postStringIndexmapkey := iNdEx + intStringLenmapkey
7442 if postStringIndexmapkey < 0 {
7443 return ErrInvalidLengthTheproto3
7444 }
7445 if postStringIndexmapkey > l {
7446 return io.ErrUnexpectedEOF
7447 }
7448 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7449 iNdEx = postStringIndexmapkey
7450 } else if fieldNum == 2 {
7451 var mapbyteLen uint64
7452 for shift := uint(0); ; shift += 7 {
7453 if shift >= 64 {
7454 return ErrIntOverflowTheproto3
7455 }
7456 if iNdEx >= l {
7457 return io.ErrUnexpectedEOF
7458 }
7459 b := dAtA[iNdEx]
7460 iNdEx++
7461 mapbyteLen |= uint64(b&0x7F) << shift
7462 if b < 0x80 {
7463 break
7464 }
7465 }
7466 intMapbyteLen := int(mapbyteLen)
7467 if intMapbyteLen < 0 {
7468 return ErrInvalidLengthTheproto3
7469 }
7470 postbytesIndex := iNdEx + intMapbyteLen
7471 if postbytesIndex < 0 {
7472 return ErrInvalidLengthTheproto3
7473 }
7474 if postbytesIndex > l {
7475 return io.ErrUnexpectedEOF
7476 }
7477 mapvalue = make([]byte, mapbyteLen)
7478 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
7479 iNdEx = postbytesIndex
7480 } else {
7481 iNdEx = entryPreIndex
7482 skippy, err := skipTheproto3(dAtA[iNdEx:])
7483 if err != nil {
7484 return err
7485 }
7486 if (skippy < 0) || (iNdEx+skippy) < 0 {
7487 return ErrInvalidLengthTheproto3
7488 }
7489 if (iNdEx + skippy) > postIndex {
7490 return io.ErrUnexpectedEOF
7491 }
7492 iNdEx += skippy
7493 }
7494 }
7495 m.StringToBytesMap[mapkey] = mapvalue
7496 iNdEx = postIndex
7497 case 16:
7498 if wireType != 2 {
7499 return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType)
7500 }
7501 var msglen int
7502 for shift := uint(0); ; shift += 7 {
7503 if shift >= 64 {
7504 return ErrIntOverflowTheproto3
7505 }
7506 if iNdEx >= l {
7507 return io.ErrUnexpectedEOF
7508 }
7509 b := dAtA[iNdEx]
7510 iNdEx++
7511 msglen |= int(b&0x7F) << shift
7512 if b < 0x80 {
7513 break
7514 }
7515 }
7516 if msglen < 0 {
7517 return ErrInvalidLengthTheproto3
7518 }
7519 postIndex := iNdEx + msglen
7520 if postIndex < 0 {
7521 return ErrInvalidLengthTheproto3
7522 }
7523 if postIndex > l {
7524 return io.ErrUnexpectedEOF
7525 }
7526 if m.StringToEnumMap == nil {
7527 m.StringToEnumMap = make(map[string]MapEnum)
7528 }
7529 var mapkey string
7530 var mapvalue MapEnum
7531 for iNdEx < postIndex {
7532 entryPreIndex := iNdEx
7533 var wire uint64
7534 for shift := uint(0); ; shift += 7 {
7535 if shift >= 64 {
7536 return ErrIntOverflowTheproto3
7537 }
7538 if iNdEx >= l {
7539 return io.ErrUnexpectedEOF
7540 }
7541 b := dAtA[iNdEx]
7542 iNdEx++
7543 wire |= uint64(b&0x7F) << shift
7544 if b < 0x80 {
7545 break
7546 }
7547 }
7548 fieldNum := int32(wire >> 3)
7549 if fieldNum == 1 {
7550 var stringLenmapkey uint64
7551 for shift := uint(0); ; shift += 7 {
7552 if shift >= 64 {
7553 return ErrIntOverflowTheproto3
7554 }
7555 if iNdEx >= l {
7556 return io.ErrUnexpectedEOF
7557 }
7558 b := dAtA[iNdEx]
7559 iNdEx++
7560 stringLenmapkey |= uint64(b&0x7F) << shift
7561 if b < 0x80 {
7562 break
7563 }
7564 }
7565 intStringLenmapkey := int(stringLenmapkey)
7566 if intStringLenmapkey < 0 {
7567 return ErrInvalidLengthTheproto3
7568 }
7569 postStringIndexmapkey := iNdEx + intStringLenmapkey
7570 if postStringIndexmapkey < 0 {
7571 return ErrInvalidLengthTheproto3
7572 }
7573 if postStringIndexmapkey > l {
7574 return io.ErrUnexpectedEOF
7575 }
7576 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7577 iNdEx = postStringIndexmapkey
7578 } else if fieldNum == 2 {
7579 for shift := uint(0); ; shift += 7 {
7580 if shift >= 64 {
7581 return ErrIntOverflowTheproto3
7582 }
7583 if iNdEx >= l {
7584 return io.ErrUnexpectedEOF
7585 }
7586 b := dAtA[iNdEx]
7587 iNdEx++
7588 mapvalue |= MapEnum(b&0x7F) << shift
7589 if b < 0x80 {
7590 break
7591 }
7592 }
7593 } else {
7594 iNdEx = entryPreIndex
7595 skippy, err := skipTheproto3(dAtA[iNdEx:])
7596 if err != nil {
7597 return err
7598 }
7599 if (skippy < 0) || (iNdEx+skippy) < 0 {
7600 return ErrInvalidLengthTheproto3
7601 }
7602 if (iNdEx + skippy) > postIndex {
7603 return io.ErrUnexpectedEOF
7604 }
7605 iNdEx += skippy
7606 }
7607 }
7608 m.StringToEnumMap[mapkey] = mapvalue
7609 iNdEx = postIndex
7610 case 17:
7611 if wireType != 2 {
7612 return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType)
7613 }
7614 var msglen int
7615 for shift := uint(0); ; shift += 7 {
7616 if shift >= 64 {
7617 return ErrIntOverflowTheproto3
7618 }
7619 if iNdEx >= l {
7620 return io.ErrUnexpectedEOF
7621 }
7622 b := dAtA[iNdEx]
7623 iNdEx++
7624 msglen |= int(b&0x7F) << shift
7625 if b < 0x80 {
7626 break
7627 }
7628 }
7629 if msglen < 0 {
7630 return ErrInvalidLengthTheproto3
7631 }
7632 postIndex := iNdEx + msglen
7633 if postIndex < 0 {
7634 return ErrInvalidLengthTheproto3
7635 }
7636 if postIndex > l {
7637 return io.ErrUnexpectedEOF
7638 }
7639 if m.StringToMsgMap == nil {
7640 m.StringToMsgMap = make(map[string]*FloatingPoint)
7641 }
7642 var mapkey string
7643 var mapvalue *FloatingPoint
7644 for iNdEx < postIndex {
7645 entryPreIndex := iNdEx
7646 var wire uint64
7647 for shift := uint(0); ; shift += 7 {
7648 if shift >= 64 {
7649 return ErrIntOverflowTheproto3
7650 }
7651 if iNdEx >= l {
7652 return io.ErrUnexpectedEOF
7653 }
7654 b := dAtA[iNdEx]
7655 iNdEx++
7656 wire |= uint64(b&0x7F) << shift
7657 if b < 0x80 {
7658 break
7659 }
7660 }
7661 fieldNum := int32(wire >> 3)
7662 if fieldNum == 1 {
7663 var stringLenmapkey uint64
7664 for shift := uint(0); ; shift += 7 {
7665 if shift >= 64 {
7666 return ErrIntOverflowTheproto3
7667 }
7668 if iNdEx >= l {
7669 return io.ErrUnexpectedEOF
7670 }
7671 b := dAtA[iNdEx]
7672 iNdEx++
7673 stringLenmapkey |= uint64(b&0x7F) << shift
7674 if b < 0x80 {
7675 break
7676 }
7677 }
7678 intStringLenmapkey := int(stringLenmapkey)
7679 if intStringLenmapkey < 0 {
7680 return ErrInvalidLengthTheproto3
7681 }
7682 postStringIndexmapkey := iNdEx + intStringLenmapkey
7683 if postStringIndexmapkey < 0 {
7684 return ErrInvalidLengthTheproto3
7685 }
7686 if postStringIndexmapkey > l {
7687 return io.ErrUnexpectedEOF
7688 }
7689 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7690 iNdEx = postStringIndexmapkey
7691 } else if fieldNum == 2 {
7692 var mapmsglen int
7693 for shift := uint(0); ; shift += 7 {
7694 if shift >= 64 {
7695 return ErrIntOverflowTheproto3
7696 }
7697 if iNdEx >= l {
7698 return io.ErrUnexpectedEOF
7699 }
7700 b := dAtA[iNdEx]
7701 iNdEx++
7702 mapmsglen |= int(b&0x7F) << shift
7703 if b < 0x80 {
7704 break
7705 }
7706 }
7707 if mapmsglen < 0 {
7708 return ErrInvalidLengthTheproto3
7709 }
7710 postmsgIndex := iNdEx + mapmsglen
7711 if postmsgIndex < 0 {
7712 return ErrInvalidLengthTheproto3
7713 }
7714 if postmsgIndex > l {
7715 return io.ErrUnexpectedEOF
7716 }
7717 mapvalue = &FloatingPoint{}
7718 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
7719 return err
7720 }
7721 iNdEx = postmsgIndex
7722 } else {
7723 iNdEx = entryPreIndex
7724 skippy, err := skipTheproto3(dAtA[iNdEx:])
7725 if err != nil {
7726 return err
7727 }
7728 if (skippy < 0) || (iNdEx+skippy) < 0 {
7729 return ErrInvalidLengthTheproto3
7730 }
7731 if (iNdEx + skippy) > postIndex {
7732 return io.ErrUnexpectedEOF
7733 }
7734 iNdEx += skippy
7735 }
7736 }
7737 m.StringToMsgMap[mapkey] = mapvalue
7738 iNdEx = postIndex
7739 default:
7740 iNdEx = preIndex
7741 skippy, err := skipTheproto3(dAtA[iNdEx:])
7742 if err != nil {
7743 return err
7744 }
7745 if (skippy < 0) || (iNdEx+skippy) < 0 {
7746 return ErrInvalidLengthTheproto3
7747 }
7748 if (iNdEx + skippy) > l {
7749 return io.ErrUnexpectedEOF
7750 }
7751 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7752 iNdEx += skippy
7753 }
7754 }
7755
7756 if iNdEx > l {
7757 return io.ErrUnexpectedEOF
7758 }
7759 return nil
7760 }
7761 func (m *AllMapsOrdered) Unmarshal(dAtA []byte) error {
7762 l := len(dAtA)
7763 iNdEx := 0
7764 for iNdEx < l {
7765 preIndex := iNdEx
7766 var wire uint64
7767 for shift := uint(0); ; shift += 7 {
7768 if shift >= 64 {
7769 return ErrIntOverflowTheproto3
7770 }
7771 if iNdEx >= l {
7772 return io.ErrUnexpectedEOF
7773 }
7774 b := dAtA[iNdEx]
7775 iNdEx++
7776 wire |= uint64(b&0x7F) << shift
7777 if b < 0x80 {
7778 break
7779 }
7780 }
7781 fieldNum := int32(wire >> 3)
7782 wireType := int(wire & 0x7)
7783 if wireType == 4 {
7784 return fmt.Errorf("proto: AllMapsOrdered: wiretype end group for non-group")
7785 }
7786 if fieldNum <= 0 {
7787 return fmt.Errorf("proto: AllMapsOrdered: illegal tag %d (wire type %d)", fieldNum, wire)
7788 }
7789 switch fieldNum {
7790 case 1:
7791 if wireType != 2 {
7792 return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType)
7793 }
7794 var msglen int
7795 for shift := uint(0); ; shift += 7 {
7796 if shift >= 64 {
7797 return ErrIntOverflowTheproto3
7798 }
7799 if iNdEx >= l {
7800 return io.ErrUnexpectedEOF
7801 }
7802 b := dAtA[iNdEx]
7803 iNdEx++
7804 msglen |= int(b&0x7F) << shift
7805 if b < 0x80 {
7806 break
7807 }
7808 }
7809 if msglen < 0 {
7810 return ErrInvalidLengthTheproto3
7811 }
7812 postIndex := iNdEx + msglen
7813 if postIndex < 0 {
7814 return ErrInvalidLengthTheproto3
7815 }
7816 if postIndex > l {
7817 return io.ErrUnexpectedEOF
7818 }
7819 if m.StringToDoubleMap == nil {
7820 m.StringToDoubleMap = make(map[string]float64)
7821 }
7822 var mapkey string
7823 var mapvalue float64
7824 for iNdEx < postIndex {
7825 entryPreIndex := iNdEx
7826 var wire uint64
7827 for shift := uint(0); ; shift += 7 {
7828 if shift >= 64 {
7829 return ErrIntOverflowTheproto3
7830 }
7831 if iNdEx >= l {
7832 return io.ErrUnexpectedEOF
7833 }
7834 b := dAtA[iNdEx]
7835 iNdEx++
7836 wire |= uint64(b&0x7F) << shift
7837 if b < 0x80 {
7838 break
7839 }
7840 }
7841 fieldNum := int32(wire >> 3)
7842 if fieldNum == 1 {
7843 var stringLenmapkey uint64
7844 for shift := uint(0); ; shift += 7 {
7845 if shift >= 64 {
7846 return ErrIntOverflowTheproto3
7847 }
7848 if iNdEx >= l {
7849 return io.ErrUnexpectedEOF
7850 }
7851 b := dAtA[iNdEx]
7852 iNdEx++
7853 stringLenmapkey |= uint64(b&0x7F) << shift
7854 if b < 0x80 {
7855 break
7856 }
7857 }
7858 intStringLenmapkey := int(stringLenmapkey)
7859 if intStringLenmapkey < 0 {
7860 return ErrInvalidLengthTheproto3
7861 }
7862 postStringIndexmapkey := iNdEx + intStringLenmapkey
7863 if postStringIndexmapkey < 0 {
7864 return ErrInvalidLengthTheproto3
7865 }
7866 if postStringIndexmapkey > l {
7867 return io.ErrUnexpectedEOF
7868 }
7869 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7870 iNdEx = postStringIndexmapkey
7871 } else if fieldNum == 2 {
7872 var mapvaluetemp uint64
7873 if (iNdEx + 8) > l {
7874 return io.ErrUnexpectedEOF
7875 }
7876 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7877 iNdEx += 8
7878 mapvalue = math.Float64frombits(mapvaluetemp)
7879 } else {
7880 iNdEx = entryPreIndex
7881 skippy, err := skipTheproto3(dAtA[iNdEx:])
7882 if err != nil {
7883 return err
7884 }
7885 if (skippy < 0) || (iNdEx+skippy) < 0 {
7886 return ErrInvalidLengthTheproto3
7887 }
7888 if (iNdEx + skippy) > postIndex {
7889 return io.ErrUnexpectedEOF
7890 }
7891 iNdEx += skippy
7892 }
7893 }
7894 m.StringToDoubleMap[mapkey] = mapvalue
7895 iNdEx = postIndex
7896 case 2:
7897 if wireType != 2 {
7898 return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType)
7899 }
7900 var msglen int
7901 for shift := uint(0); ; shift += 7 {
7902 if shift >= 64 {
7903 return ErrIntOverflowTheproto3
7904 }
7905 if iNdEx >= l {
7906 return io.ErrUnexpectedEOF
7907 }
7908 b := dAtA[iNdEx]
7909 iNdEx++
7910 msglen |= int(b&0x7F) << shift
7911 if b < 0x80 {
7912 break
7913 }
7914 }
7915 if msglen < 0 {
7916 return ErrInvalidLengthTheproto3
7917 }
7918 postIndex := iNdEx + msglen
7919 if postIndex < 0 {
7920 return ErrInvalidLengthTheproto3
7921 }
7922 if postIndex > l {
7923 return io.ErrUnexpectedEOF
7924 }
7925 if m.StringToFloatMap == nil {
7926 m.StringToFloatMap = make(map[string]float32)
7927 }
7928 var mapkey string
7929 var mapvalue float32
7930 for iNdEx < postIndex {
7931 entryPreIndex := iNdEx
7932 var wire uint64
7933 for shift := uint(0); ; shift += 7 {
7934 if shift >= 64 {
7935 return ErrIntOverflowTheproto3
7936 }
7937 if iNdEx >= l {
7938 return io.ErrUnexpectedEOF
7939 }
7940 b := dAtA[iNdEx]
7941 iNdEx++
7942 wire |= uint64(b&0x7F) << shift
7943 if b < 0x80 {
7944 break
7945 }
7946 }
7947 fieldNum := int32(wire >> 3)
7948 if fieldNum == 1 {
7949 var stringLenmapkey uint64
7950 for shift := uint(0); ; shift += 7 {
7951 if shift >= 64 {
7952 return ErrIntOverflowTheproto3
7953 }
7954 if iNdEx >= l {
7955 return io.ErrUnexpectedEOF
7956 }
7957 b := dAtA[iNdEx]
7958 iNdEx++
7959 stringLenmapkey |= uint64(b&0x7F) << shift
7960 if b < 0x80 {
7961 break
7962 }
7963 }
7964 intStringLenmapkey := int(stringLenmapkey)
7965 if intStringLenmapkey < 0 {
7966 return ErrInvalidLengthTheproto3
7967 }
7968 postStringIndexmapkey := iNdEx + intStringLenmapkey
7969 if postStringIndexmapkey < 0 {
7970 return ErrInvalidLengthTheproto3
7971 }
7972 if postStringIndexmapkey > l {
7973 return io.ErrUnexpectedEOF
7974 }
7975 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7976 iNdEx = postStringIndexmapkey
7977 } else if fieldNum == 2 {
7978 var mapvaluetemp uint32
7979 if (iNdEx + 4) > l {
7980 return io.ErrUnexpectedEOF
7981 }
7982 mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
7983 iNdEx += 4
7984 mapvalue = math.Float32frombits(mapvaluetemp)
7985 } else {
7986 iNdEx = entryPreIndex
7987 skippy, err := skipTheproto3(dAtA[iNdEx:])
7988 if err != nil {
7989 return err
7990 }
7991 if (skippy < 0) || (iNdEx+skippy) < 0 {
7992 return ErrInvalidLengthTheproto3
7993 }
7994 if (iNdEx + skippy) > postIndex {
7995 return io.ErrUnexpectedEOF
7996 }
7997 iNdEx += skippy
7998 }
7999 }
8000 m.StringToFloatMap[mapkey] = mapvalue
8001 iNdEx = postIndex
8002 case 3:
8003 if wireType != 2 {
8004 return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType)
8005 }
8006 var msglen int
8007 for shift := uint(0); ; shift += 7 {
8008 if shift >= 64 {
8009 return ErrIntOverflowTheproto3
8010 }
8011 if iNdEx >= l {
8012 return io.ErrUnexpectedEOF
8013 }
8014 b := dAtA[iNdEx]
8015 iNdEx++
8016 msglen |= int(b&0x7F) << shift
8017 if b < 0x80 {
8018 break
8019 }
8020 }
8021 if msglen < 0 {
8022 return ErrInvalidLengthTheproto3
8023 }
8024 postIndex := iNdEx + msglen
8025 if postIndex < 0 {
8026 return ErrInvalidLengthTheproto3
8027 }
8028 if postIndex > l {
8029 return io.ErrUnexpectedEOF
8030 }
8031 if m.Int32Map == nil {
8032 m.Int32Map = make(map[int32]int32)
8033 }
8034 var mapkey int32
8035 var mapvalue int32
8036 for iNdEx < postIndex {
8037 entryPreIndex := iNdEx
8038 var wire uint64
8039 for shift := uint(0); ; shift += 7 {
8040 if shift >= 64 {
8041 return ErrIntOverflowTheproto3
8042 }
8043 if iNdEx >= l {
8044 return io.ErrUnexpectedEOF
8045 }
8046 b := dAtA[iNdEx]
8047 iNdEx++
8048 wire |= uint64(b&0x7F) << shift
8049 if b < 0x80 {
8050 break
8051 }
8052 }
8053 fieldNum := int32(wire >> 3)
8054 if fieldNum == 1 {
8055 for shift := uint(0); ; shift += 7 {
8056 if shift >= 64 {
8057 return ErrIntOverflowTheproto3
8058 }
8059 if iNdEx >= l {
8060 return io.ErrUnexpectedEOF
8061 }
8062 b := dAtA[iNdEx]
8063 iNdEx++
8064 mapkey |= int32(b&0x7F) << shift
8065 if b < 0x80 {
8066 break
8067 }
8068 }
8069 } else if fieldNum == 2 {
8070 for shift := uint(0); ; shift += 7 {
8071 if shift >= 64 {
8072 return ErrIntOverflowTheproto3
8073 }
8074 if iNdEx >= l {
8075 return io.ErrUnexpectedEOF
8076 }
8077 b := dAtA[iNdEx]
8078 iNdEx++
8079 mapvalue |= int32(b&0x7F) << shift
8080 if b < 0x80 {
8081 break
8082 }
8083 }
8084 } else {
8085 iNdEx = entryPreIndex
8086 skippy, err := skipTheproto3(dAtA[iNdEx:])
8087 if err != nil {
8088 return err
8089 }
8090 if (skippy < 0) || (iNdEx+skippy) < 0 {
8091 return ErrInvalidLengthTheproto3
8092 }
8093 if (iNdEx + skippy) > postIndex {
8094 return io.ErrUnexpectedEOF
8095 }
8096 iNdEx += skippy
8097 }
8098 }
8099 m.Int32Map[mapkey] = mapvalue
8100 iNdEx = postIndex
8101 case 4:
8102 if wireType != 2 {
8103 return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType)
8104 }
8105 var msglen int
8106 for shift := uint(0); ; shift += 7 {
8107 if shift >= 64 {
8108 return ErrIntOverflowTheproto3
8109 }
8110 if iNdEx >= l {
8111 return io.ErrUnexpectedEOF
8112 }
8113 b := dAtA[iNdEx]
8114 iNdEx++
8115 msglen |= int(b&0x7F) << shift
8116 if b < 0x80 {
8117 break
8118 }
8119 }
8120 if msglen < 0 {
8121 return ErrInvalidLengthTheproto3
8122 }
8123 postIndex := iNdEx + msglen
8124 if postIndex < 0 {
8125 return ErrInvalidLengthTheproto3
8126 }
8127 if postIndex > l {
8128 return io.ErrUnexpectedEOF
8129 }
8130 if m.Int64Map == nil {
8131 m.Int64Map = make(map[int64]int64)
8132 }
8133 var mapkey int64
8134 var mapvalue int64
8135 for iNdEx < postIndex {
8136 entryPreIndex := iNdEx
8137 var wire uint64
8138 for shift := uint(0); ; shift += 7 {
8139 if shift >= 64 {
8140 return ErrIntOverflowTheproto3
8141 }
8142 if iNdEx >= l {
8143 return io.ErrUnexpectedEOF
8144 }
8145 b := dAtA[iNdEx]
8146 iNdEx++
8147 wire |= uint64(b&0x7F) << shift
8148 if b < 0x80 {
8149 break
8150 }
8151 }
8152 fieldNum := int32(wire >> 3)
8153 if fieldNum == 1 {
8154 for shift := uint(0); ; shift += 7 {
8155 if shift >= 64 {
8156 return ErrIntOverflowTheproto3
8157 }
8158 if iNdEx >= l {
8159 return io.ErrUnexpectedEOF
8160 }
8161 b := dAtA[iNdEx]
8162 iNdEx++
8163 mapkey |= int64(b&0x7F) << shift
8164 if b < 0x80 {
8165 break
8166 }
8167 }
8168 } else if fieldNum == 2 {
8169 for shift := uint(0); ; shift += 7 {
8170 if shift >= 64 {
8171 return ErrIntOverflowTheproto3
8172 }
8173 if iNdEx >= l {
8174 return io.ErrUnexpectedEOF
8175 }
8176 b := dAtA[iNdEx]
8177 iNdEx++
8178 mapvalue |= int64(b&0x7F) << shift
8179 if b < 0x80 {
8180 break
8181 }
8182 }
8183 } else {
8184 iNdEx = entryPreIndex
8185 skippy, err := skipTheproto3(dAtA[iNdEx:])
8186 if err != nil {
8187 return err
8188 }
8189 if (skippy < 0) || (iNdEx+skippy) < 0 {
8190 return ErrInvalidLengthTheproto3
8191 }
8192 if (iNdEx + skippy) > postIndex {
8193 return io.ErrUnexpectedEOF
8194 }
8195 iNdEx += skippy
8196 }
8197 }
8198 m.Int64Map[mapkey] = mapvalue
8199 iNdEx = postIndex
8200 case 5:
8201 if wireType != 2 {
8202 return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType)
8203 }
8204 var msglen int
8205 for shift := uint(0); ; shift += 7 {
8206 if shift >= 64 {
8207 return ErrIntOverflowTheproto3
8208 }
8209 if iNdEx >= l {
8210 return io.ErrUnexpectedEOF
8211 }
8212 b := dAtA[iNdEx]
8213 iNdEx++
8214 msglen |= int(b&0x7F) << shift
8215 if b < 0x80 {
8216 break
8217 }
8218 }
8219 if msglen < 0 {
8220 return ErrInvalidLengthTheproto3
8221 }
8222 postIndex := iNdEx + msglen
8223 if postIndex < 0 {
8224 return ErrInvalidLengthTheproto3
8225 }
8226 if postIndex > l {
8227 return io.ErrUnexpectedEOF
8228 }
8229 if m.Uint32Map == nil {
8230 m.Uint32Map = make(map[uint32]uint32)
8231 }
8232 var mapkey uint32
8233 var mapvalue uint32
8234 for iNdEx < postIndex {
8235 entryPreIndex := iNdEx
8236 var wire uint64
8237 for shift := uint(0); ; shift += 7 {
8238 if shift >= 64 {
8239 return ErrIntOverflowTheproto3
8240 }
8241 if iNdEx >= l {
8242 return io.ErrUnexpectedEOF
8243 }
8244 b := dAtA[iNdEx]
8245 iNdEx++
8246 wire |= uint64(b&0x7F) << shift
8247 if b < 0x80 {
8248 break
8249 }
8250 }
8251 fieldNum := int32(wire >> 3)
8252 if fieldNum == 1 {
8253 for shift := uint(0); ; shift += 7 {
8254 if shift >= 64 {
8255 return ErrIntOverflowTheproto3
8256 }
8257 if iNdEx >= l {
8258 return io.ErrUnexpectedEOF
8259 }
8260 b := dAtA[iNdEx]
8261 iNdEx++
8262 mapkey |= uint32(b&0x7F) << shift
8263 if b < 0x80 {
8264 break
8265 }
8266 }
8267 } else if fieldNum == 2 {
8268 for shift := uint(0); ; shift += 7 {
8269 if shift >= 64 {
8270 return ErrIntOverflowTheproto3
8271 }
8272 if iNdEx >= l {
8273 return io.ErrUnexpectedEOF
8274 }
8275 b := dAtA[iNdEx]
8276 iNdEx++
8277 mapvalue |= uint32(b&0x7F) << shift
8278 if b < 0x80 {
8279 break
8280 }
8281 }
8282 } else {
8283 iNdEx = entryPreIndex
8284 skippy, err := skipTheproto3(dAtA[iNdEx:])
8285 if err != nil {
8286 return err
8287 }
8288 if (skippy < 0) || (iNdEx+skippy) < 0 {
8289 return ErrInvalidLengthTheproto3
8290 }
8291 if (iNdEx + skippy) > postIndex {
8292 return io.ErrUnexpectedEOF
8293 }
8294 iNdEx += skippy
8295 }
8296 }
8297 m.Uint32Map[mapkey] = mapvalue
8298 iNdEx = postIndex
8299 case 6:
8300 if wireType != 2 {
8301 return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType)
8302 }
8303 var msglen int
8304 for shift := uint(0); ; shift += 7 {
8305 if shift >= 64 {
8306 return ErrIntOverflowTheproto3
8307 }
8308 if iNdEx >= l {
8309 return io.ErrUnexpectedEOF
8310 }
8311 b := dAtA[iNdEx]
8312 iNdEx++
8313 msglen |= int(b&0x7F) << shift
8314 if b < 0x80 {
8315 break
8316 }
8317 }
8318 if msglen < 0 {
8319 return ErrInvalidLengthTheproto3
8320 }
8321 postIndex := iNdEx + msglen
8322 if postIndex < 0 {
8323 return ErrInvalidLengthTheproto3
8324 }
8325 if postIndex > l {
8326 return io.ErrUnexpectedEOF
8327 }
8328 if m.Uint64Map == nil {
8329 m.Uint64Map = make(map[uint64]uint64)
8330 }
8331 var mapkey uint64
8332 var mapvalue uint64
8333 for iNdEx < postIndex {
8334 entryPreIndex := iNdEx
8335 var wire uint64
8336 for shift := uint(0); ; shift += 7 {
8337 if shift >= 64 {
8338 return ErrIntOverflowTheproto3
8339 }
8340 if iNdEx >= l {
8341 return io.ErrUnexpectedEOF
8342 }
8343 b := dAtA[iNdEx]
8344 iNdEx++
8345 wire |= uint64(b&0x7F) << shift
8346 if b < 0x80 {
8347 break
8348 }
8349 }
8350 fieldNum := int32(wire >> 3)
8351 if fieldNum == 1 {
8352 for shift := uint(0); ; shift += 7 {
8353 if shift >= 64 {
8354 return ErrIntOverflowTheproto3
8355 }
8356 if iNdEx >= l {
8357 return io.ErrUnexpectedEOF
8358 }
8359 b := dAtA[iNdEx]
8360 iNdEx++
8361 mapkey |= uint64(b&0x7F) << shift
8362 if b < 0x80 {
8363 break
8364 }
8365 }
8366 } else if fieldNum == 2 {
8367 for shift := uint(0); ; shift += 7 {
8368 if shift >= 64 {
8369 return ErrIntOverflowTheproto3
8370 }
8371 if iNdEx >= l {
8372 return io.ErrUnexpectedEOF
8373 }
8374 b := dAtA[iNdEx]
8375 iNdEx++
8376 mapvalue |= uint64(b&0x7F) << shift
8377 if b < 0x80 {
8378 break
8379 }
8380 }
8381 } else {
8382 iNdEx = entryPreIndex
8383 skippy, err := skipTheproto3(dAtA[iNdEx:])
8384 if err != nil {
8385 return err
8386 }
8387 if (skippy < 0) || (iNdEx+skippy) < 0 {
8388 return ErrInvalidLengthTheproto3
8389 }
8390 if (iNdEx + skippy) > postIndex {
8391 return io.ErrUnexpectedEOF
8392 }
8393 iNdEx += skippy
8394 }
8395 }
8396 m.Uint64Map[mapkey] = mapvalue
8397 iNdEx = postIndex
8398 case 7:
8399 if wireType != 2 {
8400 return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType)
8401 }
8402 var msglen int
8403 for shift := uint(0); ; shift += 7 {
8404 if shift >= 64 {
8405 return ErrIntOverflowTheproto3
8406 }
8407 if iNdEx >= l {
8408 return io.ErrUnexpectedEOF
8409 }
8410 b := dAtA[iNdEx]
8411 iNdEx++
8412 msglen |= int(b&0x7F) << shift
8413 if b < 0x80 {
8414 break
8415 }
8416 }
8417 if msglen < 0 {
8418 return ErrInvalidLengthTheproto3
8419 }
8420 postIndex := iNdEx + msglen
8421 if postIndex < 0 {
8422 return ErrInvalidLengthTheproto3
8423 }
8424 if postIndex > l {
8425 return io.ErrUnexpectedEOF
8426 }
8427 if m.Sint32Map == nil {
8428 m.Sint32Map = make(map[int32]int32)
8429 }
8430 var mapkey int32
8431 var mapvalue int32
8432 for iNdEx < postIndex {
8433 entryPreIndex := iNdEx
8434 var wire uint64
8435 for shift := uint(0); ; shift += 7 {
8436 if shift >= 64 {
8437 return ErrIntOverflowTheproto3
8438 }
8439 if iNdEx >= l {
8440 return io.ErrUnexpectedEOF
8441 }
8442 b := dAtA[iNdEx]
8443 iNdEx++
8444 wire |= uint64(b&0x7F) << shift
8445 if b < 0x80 {
8446 break
8447 }
8448 }
8449 fieldNum := int32(wire >> 3)
8450 if fieldNum == 1 {
8451 var mapkeytemp int32
8452 for shift := uint(0); ; shift += 7 {
8453 if shift >= 64 {
8454 return ErrIntOverflowTheproto3
8455 }
8456 if iNdEx >= l {
8457 return io.ErrUnexpectedEOF
8458 }
8459 b := dAtA[iNdEx]
8460 iNdEx++
8461 mapkeytemp |= int32(b&0x7F) << shift
8462 if b < 0x80 {
8463 break
8464 }
8465 }
8466 mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
8467 mapkey = int32(mapkeytemp)
8468 } else if fieldNum == 2 {
8469 var mapvaluetemp int32
8470 for shift := uint(0); ; shift += 7 {
8471 if shift >= 64 {
8472 return ErrIntOverflowTheproto3
8473 }
8474 if iNdEx >= l {
8475 return io.ErrUnexpectedEOF
8476 }
8477 b := dAtA[iNdEx]
8478 iNdEx++
8479 mapvaluetemp |= int32(b&0x7F) << shift
8480 if b < 0x80 {
8481 break
8482 }
8483 }
8484 mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
8485 mapvalue = int32(mapvaluetemp)
8486 } else {
8487 iNdEx = entryPreIndex
8488 skippy, err := skipTheproto3(dAtA[iNdEx:])
8489 if err != nil {
8490 return err
8491 }
8492 if (skippy < 0) || (iNdEx+skippy) < 0 {
8493 return ErrInvalidLengthTheproto3
8494 }
8495 if (iNdEx + skippy) > postIndex {
8496 return io.ErrUnexpectedEOF
8497 }
8498 iNdEx += skippy
8499 }
8500 }
8501 m.Sint32Map[mapkey] = mapvalue
8502 iNdEx = postIndex
8503 case 8:
8504 if wireType != 2 {
8505 return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType)
8506 }
8507 var msglen int
8508 for shift := uint(0); ; shift += 7 {
8509 if shift >= 64 {
8510 return ErrIntOverflowTheproto3
8511 }
8512 if iNdEx >= l {
8513 return io.ErrUnexpectedEOF
8514 }
8515 b := dAtA[iNdEx]
8516 iNdEx++
8517 msglen |= int(b&0x7F) << shift
8518 if b < 0x80 {
8519 break
8520 }
8521 }
8522 if msglen < 0 {
8523 return ErrInvalidLengthTheproto3
8524 }
8525 postIndex := iNdEx + msglen
8526 if postIndex < 0 {
8527 return ErrInvalidLengthTheproto3
8528 }
8529 if postIndex > l {
8530 return io.ErrUnexpectedEOF
8531 }
8532 if m.Sint64Map == nil {
8533 m.Sint64Map = make(map[int64]int64)
8534 }
8535 var mapkey int64
8536 var mapvalue int64
8537 for iNdEx < postIndex {
8538 entryPreIndex := iNdEx
8539 var wire uint64
8540 for shift := uint(0); ; shift += 7 {
8541 if shift >= 64 {
8542 return ErrIntOverflowTheproto3
8543 }
8544 if iNdEx >= l {
8545 return io.ErrUnexpectedEOF
8546 }
8547 b := dAtA[iNdEx]
8548 iNdEx++
8549 wire |= uint64(b&0x7F) << shift
8550 if b < 0x80 {
8551 break
8552 }
8553 }
8554 fieldNum := int32(wire >> 3)
8555 if fieldNum == 1 {
8556 var mapkeytemp uint64
8557 for shift := uint(0); ; shift += 7 {
8558 if shift >= 64 {
8559 return ErrIntOverflowTheproto3
8560 }
8561 if iNdEx >= l {
8562 return io.ErrUnexpectedEOF
8563 }
8564 b := dAtA[iNdEx]
8565 iNdEx++
8566 mapkeytemp |= uint64(b&0x7F) << shift
8567 if b < 0x80 {
8568 break
8569 }
8570 }
8571 mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
8572 mapkey = int64(mapkeytemp)
8573 } else if fieldNum == 2 {
8574 var mapvaluetemp uint64
8575 for shift := uint(0); ; shift += 7 {
8576 if shift >= 64 {
8577 return ErrIntOverflowTheproto3
8578 }
8579 if iNdEx >= l {
8580 return io.ErrUnexpectedEOF
8581 }
8582 b := dAtA[iNdEx]
8583 iNdEx++
8584 mapvaluetemp |= uint64(b&0x7F) << shift
8585 if b < 0x80 {
8586 break
8587 }
8588 }
8589 mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
8590 mapvalue = int64(mapvaluetemp)
8591 } else {
8592 iNdEx = entryPreIndex
8593 skippy, err := skipTheproto3(dAtA[iNdEx:])
8594 if err != nil {
8595 return err
8596 }
8597 if (skippy < 0) || (iNdEx+skippy) < 0 {
8598 return ErrInvalidLengthTheproto3
8599 }
8600 if (iNdEx + skippy) > postIndex {
8601 return io.ErrUnexpectedEOF
8602 }
8603 iNdEx += skippy
8604 }
8605 }
8606 m.Sint64Map[mapkey] = mapvalue
8607 iNdEx = postIndex
8608 case 9:
8609 if wireType != 2 {
8610 return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType)
8611 }
8612 var msglen int
8613 for shift := uint(0); ; shift += 7 {
8614 if shift >= 64 {
8615 return ErrIntOverflowTheproto3
8616 }
8617 if iNdEx >= l {
8618 return io.ErrUnexpectedEOF
8619 }
8620 b := dAtA[iNdEx]
8621 iNdEx++
8622 msglen |= int(b&0x7F) << shift
8623 if b < 0x80 {
8624 break
8625 }
8626 }
8627 if msglen < 0 {
8628 return ErrInvalidLengthTheproto3
8629 }
8630 postIndex := iNdEx + msglen
8631 if postIndex < 0 {
8632 return ErrInvalidLengthTheproto3
8633 }
8634 if postIndex > l {
8635 return io.ErrUnexpectedEOF
8636 }
8637 if m.Fixed32Map == nil {
8638 m.Fixed32Map = make(map[uint32]uint32)
8639 }
8640 var mapkey uint32
8641 var mapvalue uint32
8642 for iNdEx < postIndex {
8643 entryPreIndex := iNdEx
8644 var wire uint64
8645 for shift := uint(0); ; shift += 7 {
8646 if shift >= 64 {
8647 return ErrIntOverflowTheproto3
8648 }
8649 if iNdEx >= l {
8650 return io.ErrUnexpectedEOF
8651 }
8652 b := dAtA[iNdEx]
8653 iNdEx++
8654 wire |= uint64(b&0x7F) << shift
8655 if b < 0x80 {
8656 break
8657 }
8658 }
8659 fieldNum := int32(wire >> 3)
8660 if fieldNum == 1 {
8661 if (iNdEx + 4) > l {
8662 return io.ErrUnexpectedEOF
8663 }
8664 mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8665 iNdEx += 4
8666 } else if fieldNum == 2 {
8667 if (iNdEx + 4) > l {
8668 return io.ErrUnexpectedEOF
8669 }
8670 mapvalue = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8671 iNdEx += 4
8672 } else {
8673 iNdEx = entryPreIndex
8674 skippy, err := skipTheproto3(dAtA[iNdEx:])
8675 if err != nil {
8676 return err
8677 }
8678 if (skippy < 0) || (iNdEx+skippy) < 0 {
8679 return ErrInvalidLengthTheproto3
8680 }
8681 if (iNdEx + skippy) > postIndex {
8682 return io.ErrUnexpectedEOF
8683 }
8684 iNdEx += skippy
8685 }
8686 }
8687 m.Fixed32Map[mapkey] = mapvalue
8688 iNdEx = postIndex
8689 case 10:
8690 if wireType != 2 {
8691 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType)
8692 }
8693 var msglen int
8694 for shift := uint(0); ; shift += 7 {
8695 if shift >= 64 {
8696 return ErrIntOverflowTheproto3
8697 }
8698 if iNdEx >= l {
8699 return io.ErrUnexpectedEOF
8700 }
8701 b := dAtA[iNdEx]
8702 iNdEx++
8703 msglen |= int(b&0x7F) << shift
8704 if b < 0x80 {
8705 break
8706 }
8707 }
8708 if msglen < 0 {
8709 return ErrInvalidLengthTheproto3
8710 }
8711 postIndex := iNdEx + msglen
8712 if postIndex < 0 {
8713 return ErrInvalidLengthTheproto3
8714 }
8715 if postIndex > l {
8716 return io.ErrUnexpectedEOF
8717 }
8718 if m.Sfixed32Map == nil {
8719 m.Sfixed32Map = make(map[int32]int32)
8720 }
8721 var mapkey int32
8722 var mapvalue int32
8723 for iNdEx < postIndex {
8724 entryPreIndex := iNdEx
8725 var wire uint64
8726 for shift := uint(0); ; shift += 7 {
8727 if shift >= 64 {
8728 return ErrIntOverflowTheproto3
8729 }
8730 if iNdEx >= l {
8731 return io.ErrUnexpectedEOF
8732 }
8733 b := dAtA[iNdEx]
8734 iNdEx++
8735 wire |= uint64(b&0x7F) << shift
8736 if b < 0x80 {
8737 break
8738 }
8739 }
8740 fieldNum := int32(wire >> 3)
8741 if fieldNum == 1 {
8742 if (iNdEx + 4) > l {
8743 return io.ErrUnexpectedEOF
8744 }
8745 mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8746 iNdEx += 4
8747 } else if fieldNum == 2 {
8748 if (iNdEx + 4) > l {
8749 return io.ErrUnexpectedEOF
8750 }
8751 mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
8752 iNdEx += 4
8753 } else {
8754 iNdEx = entryPreIndex
8755 skippy, err := skipTheproto3(dAtA[iNdEx:])
8756 if err != nil {
8757 return err
8758 }
8759 if (skippy < 0) || (iNdEx+skippy) < 0 {
8760 return ErrInvalidLengthTheproto3
8761 }
8762 if (iNdEx + skippy) > postIndex {
8763 return io.ErrUnexpectedEOF
8764 }
8765 iNdEx += skippy
8766 }
8767 }
8768 m.Sfixed32Map[mapkey] = mapvalue
8769 iNdEx = postIndex
8770 case 11:
8771 if wireType != 2 {
8772 return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType)
8773 }
8774 var msglen int
8775 for shift := uint(0); ; shift += 7 {
8776 if shift >= 64 {
8777 return ErrIntOverflowTheproto3
8778 }
8779 if iNdEx >= l {
8780 return io.ErrUnexpectedEOF
8781 }
8782 b := dAtA[iNdEx]
8783 iNdEx++
8784 msglen |= int(b&0x7F) << shift
8785 if b < 0x80 {
8786 break
8787 }
8788 }
8789 if msglen < 0 {
8790 return ErrInvalidLengthTheproto3
8791 }
8792 postIndex := iNdEx + msglen
8793 if postIndex < 0 {
8794 return ErrInvalidLengthTheproto3
8795 }
8796 if postIndex > l {
8797 return io.ErrUnexpectedEOF
8798 }
8799 if m.Fixed64Map == nil {
8800 m.Fixed64Map = make(map[uint64]uint64)
8801 }
8802 var mapkey uint64
8803 var mapvalue uint64
8804 for iNdEx < postIndex {
8805 entryPreIndex := iNdEx
8806 var wire uint64
8807 for shift := uint(0); ; shift += 7 {
8808 if shift >= 64 {
8809 return ErrIntOverflowTheproto3
8810 }
8811 if iNdEx >= l {
8812 return io.ErrUnexpectedEOF
8813 }
8814 b := dAtA[iNdEx]
8815 iNdEx++
8816 wire |= uint64(b&0x7F) << shift
8817 if b < 0x80 {
8818 break
8819 }
8820 }
8821 fieldNum := int32(wire >> 3)
8822 if fieldNum == 1 {
8823 if (iNdEx + 8) > l {
8824 return io.ErrUnexpectedEOF
8825 }
8826 mapkey = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8827 iNdEx += 8
8828 } else if fieldNum == 2 {
8829 if (iNdEx + 8) > l {
8830 return io.ErrUnexpectedEOF
8831 }
8832 mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8833 iNdEx += 8
8834 } else {
8835 iNdEx = entryPreIndex
8836 skippy, err := skipTheproto3(dAtA[iNdEx:])
8837 if err != nil {
8838 return err
8839 }
8840 if (skippy < 0) || (iNdEx+skippy) < 0 {
8841 return ErrInvalidLengthTheproto3
8842 }
8843 if (iNdEx + skippy) > postIndex {
8844 return io.ErrUnexpectedEOF
8845 }
8846 iNdEx += skippy
8847 }
8848 }
8849 m.Fixed64Map[mapkey] = mapvalue
8850 iNdEx = postIndex
8851 case 12:
8852 if wireType != 2 {
8853 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType)
8854 }
8855 var msglen int
8856 for shift := uint(0); ; shift += 7 {
8857 if shift >= 64 {
8858 return ErrIntOverflowTheproto3
8859 }
8860 if iNdEx >= l {
8861 return io.ErrUnexpectedEOF
8862 }
8863 b := dAtA[iNdEx]
8864 iNdEx++
8865 msglen |= int(b&0x7F) << shift
8866 if b < 0x80 {
8867 break
8868 }
8869 }
8870 if msglen < 0 {
8871 return ErrInvalidLengthTheproto3
8872 }
8873 postIndex := iNdEx + msglen
8874 if postIndex < 0 {
8875 return ErrInvalidLengthTheproto3
8876 }
8877 if postIndex > l {
8878 return io.ErrUnexpectedEOF
8879 }
8880 if m.Sfixed64Map == nil {
8881 m.Sfixed64Map = make(map[int64]int64)
8882 }
8883 var mapkey int64
8884 var mapvalue int64
8885 for iNdEx < postIndex {
8886 entryPreIndex := iNdEx
8887 var wire uint64
8888 for shift := uint(0); ; shift += 7 {
8889 if shift >= 64 {
8890 return ErrIntOverflowTheproto3
8891 }
8892 if iNdEx >= l {
8893 return io.ErrUnexpectedEOF
8894 }
8895 b := dAtA[iNdEx]
8896 iNdEx++
8897 wire |= uint64(b&0x7F) << shift
8898 if b < 0x80 {
8899 break
8900 }
8901 }
8902 fieldNum := int32(wire >> 3)
8903 if fieldNum == 1 {
8904 if (iNdEx + 8) > l {
8905 return io.ErrUnexpectedEOF
8906 }
8907 mapkey = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8908 iNdEx += 8
8909 } else if fieldNum == 2 {
8910 if (iNdEx + 8) > l {
8911 return io.ErrUnexpectedEOF
8912 }
8913 mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
8914 iNdEx += 8
8915 } else {
8916 iNdEx = entryPreIndex
8917 skippy, err := skipTheproto3(dAtA[iNdEx:])
8918 if err != nil {
8919 return err
8920 }
8921 if (skippy < 0) || (iNdEx+skippy) < 0 {
8922 return ErrInvalidLengthTheproto3
8923 }
8924 if (iNdEx + skippy) > postIndex {
8925 return io.ErrUnexpectedEOF
8926 }
8927 iNdEx += skippy
8928 }
8929 }
8930 m.Sfixed64Map[mapkey] = mapvalue
8931 iNdEx = postIndex
8932 case 13:
8933 if wireType != 2 {
8934 return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType)
8935 }
8936 var msglen int
8937 for shift := uint(0); ; shift += 7 {
8938 if shift >= 64 {
8939 return ErrIntOverflowTheproto3
8940 }
8941 if iNdEx >= l {
8942 return io.ErrUnexpectedEOF
8943 }
8944 b := dAtA[iNdEx]
8945 iNdEx++
8946 msglen |= int(b&0x7F) << shift
8947 if b < 0x80 {
8948 break
8949 }
8950 }
8951 if msglen < 0 {
8952 return ErrInvalidLengthTheproto3
8953 }
8954 postIndex := iNdEx + msglen
8955 if postIndex < 0 {
8956 return ErrInvalidLengthTheproto3
8957 }
8958 if postIndex > l {
8959 return io.ErrUnexpectedEOF
8960 }
8961 if m.BoolMap == nil {
8962 m.BoolMap = make(map[bool]bool)
8963 }
8964 var mapkey bool
8965 var mapvalue bool
8966 for iNdEx < postIndex {
8967 entryPreIndex := iNdEx
8968 var wire uint64
8969 for shift := uint(0); ; shift += 7 {
8970 if shift >= 64 {
8971 return ErrIntOverflowTheproto3
8972 }
8973 if iNdEx >= l {
8974 return io.ErrUnexpectedEOF
8975 }
8976 b := dAtA[iNdEx]
8977 iNdEx++
8978 wire |= uint64(b&0x7F) << shift
8979 if b < 0x80 {
8980 break
8981 }
8982 }
8983 fieldNum := int32(wire >> 3)
8984 if fieldNum == 1 {
8985 var mapkeytemp int
8986 for shift := uint(0); ; shift += 7 {
8987 if shift >= 64 {
8988 return ErrIntOverflowTheproto3
8989 }
8990 if iNdEx >= l {
8991 return io.ErrUnexpectedEOF
8992 }
8993 b := dAtA[iNdEx]
8994 iNdEx++
8995 mapkeytemp |= int(b&0x7F) << shift
8996 if b < 0x80 {
8997 break
8998 }
8999 }
9000 mapkey = bool(mapkeytemp != 0)
9001 } else if fieldNum == 2 {
9002 var mapvaluetemp int
9003 for shift := uint(0); ; shift += 7 {
9004 if shift >= 64 {
9005 return ErrIntOverflowTheproto3
9006 }
9007 if iNdEx >= l {
9008 return io.ErrUnexpectedEOF
9009 }
9010 b := dAtA[iNdEx]
9011 iNdEx++
9012 mapvaluetemp |= int(b&0x7F) << shift
9013 if b < 0x80 {
9014 break
9015 }
9016 }
9017 mapvalue = bool(mapvaluetemp != 0)
9018 } else {
9019 iNdEx = entryPreIndex
9020 skippy, err := skipTheproto3(dAtA[iNdEx:])
9021 if err != nil {
9022 return err
9023 }
9024 if (skippy < 0) || (iNdEx+skippy) < 0 {
9025 return ErrInvalidLengthTheproto3
9026 }
9027 if (iNdEx + skippy) > postIndex {
9028 return io.ErrUnexpectedEOF
9029 }
9030 iNdEx += skippy
9031 }
9032 }
9033 m.BoolMap[mapkey] = mapvalue
9034 iNdEx = postIndex
9035 case 14:
9036 if wireType != 2 {
9037 return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType)
9038 }
9039 var msglen int
9040 for shift := uint(0); ; shift += 7 {
9041 if shift >= 64 {
9042 return ErrIntOverflowTheproto3
9043 }
9044 if iNdEx >= l {
9045 return io.ErrUnexpectedEOF
9046 }
9047 b := dAtA[iNdEx]
9048 iNdEx++
9049 msglen |= int(b&0x7F) << shift
9050 if b < 0x80 {
9051 break
9052 }
9053 }
9054 if msglen < 0 {
9055 return ErrInvalidLengthTheproto3
9056 }
9057 postIndex := iNdEx + msglen
9058 if postIndex < 0 {
9059 return ErrInvalidLengthTheproto3
9060 }
9061 if postIndex > l {
9062 return io.ErrUnexpectedEOF
9063 }
9064 if m.StringMap == nil {
9065 m.StringMap = make(map[string]string)
9066 }
9067 var mapkey string
9068 var mapvalue string
9069 for iNdEx < postIndex {
9070 entryPreIndex := iNdEx
9071 var wire uint64
9072 for shift := uint(0); ; shift += 7 {
9073 if shift >= 64 {
9074 return ErrIntOverflowTheproto3
9075 }
9076 if iNdEx >= l {
9077 return io.ErrUnexpectedEOF
9078 }
9079 b := dAtA[iNdEx]
9080 iNdEx++
9081 wire |= uint64(b&0x7F) << shift
9082 if b < 0x80 {
9083 break
9084 }
9085 }
9086 fieldNum := int32(wire >> 3)
9087 if fieldNum == 1 {
9088 var stringLenmapkey uint64
9089 for shift := uint(0); ; shift += 7 {
9090 if shift >= 64 {
9091 return ErrIntOverflowTheproto3
9092 }
9093 if iNdEx >= l {
9094 return io.ErrUnexpectedEOF
9095 }
9096 b := dAtA[iNdEx]
9097 iNdEx++
9098 stringLenmapkey |= uint64(b&0x7F) << shift
9099 if b < 0x80 {
9100 break
9101 }
9102 }
9103 intStringLenmapkey := int(stringLenmapkey)
9104 if intStringLenmapkey < 0 {
9105 return ErrInvalidLengthTheproto3
9106 }
9107 postStringIndexmapkey := iNdEx + intStringLenmapkey
9108 if postStringIndexmapkey < 0 {
9109 return ErrInvalidLengthTheproto3
9110 }
9111 if postStringIndexmapkey > l {
9112 return io.ErrUnexpectedEOF
9113 }
9114 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
9115 iNdEx = postStringIndexmapkey
9116 } else if fieldNum == 2 {
9117 var stringLenmapvalue uint64
9118 for shift := uint(0); ; shift += 7 {
9119 if shift >= 64 {
9120 return ErrIntOverflowTheproto3
9121 }
9122 if iNdEx >= l {
9123 return io.ErrUnexpectedEOF
9124 }
9125 b := dAtA[iNdEx]
9126 iNdEx++
9127 stringLenmapvalue |= uint64(b&0x7F) << shift
9128 if b < 0x80 {
9129 break
9130 }
9131 }
9132 intStringLenmapvalue := int(stringLenmapvalue)
9133 if intStringLenmapvalue < 0 {
9134 return ErrInvalidLengthTheproto3
9135 }
9136 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
9137 if postStringIndexmapvalue < 0 {
9138 return ErrInvalidLengthTheproto3
9139 }
9140 if postStringIndexmapvalue > l {
9141 return io.ErrUnexpectedEOF
9142 }
9143 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
9144 iNdEx = postStringIndexmapvalue
9145 } else {
9146 iNdEx = entryPreIndex
9147 skippy, err := skipTheproto3(dAtA[iNdEx:])
9148 if err != nil {
9149 return err
9150 }
9151 if (skippy < 0) || (iNdEx+skippy) < 0 {
9152 return ErrInvalidLengthTheproto3
9153 }
9154 if (iNdEx + skippy) > postIndex {
9155 return io.ErrUnexpectedEOF
9156 }
9157 iNdEx += skippy
9158 }
9159 }
9160 m.StringMap[mapkey] = mapvalue
9161 iNdEx = postIndex
9162 case 15:
9163 if wireType != 2 {
9164 return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType)
9165 }
9166 var msglen int
9167 for shift := uint(0); ; shift += 7 {
9168 if shift >= 64 {
9169 return ErrIntOverflowTheproto3
9170 }
9171 if iNdEx >= l {
9172 return io.ErrUnexpectedEOF
9173 }
9174 b := dAtA[iNdEx]
9175 iNdEx++
9176 msglen |= int(b&0x7F) << shift
9177 if b < 0x80 {
9178 break
9179 }
9180 }
9181 if msglen < 0 {
9182 return ErrInvalidLengthTheproto3
9183 }
9184 postIndex := iNdEx + msglen
9185 if postIndex < 0 {
9186 return ErrInvalidLengthTheproto3
9187 }
9188 if postIndex > l {
9189 return io.ErrUnexpectedEOF
9190 }
9191 if m.StringToBytesMap == nil {
9192 m.StringToBytesMap = make(map[string][]byte)
9193 }
9194 var mapkey string
9195 mapvalue := []byte{}
9196 for iNdEx < postIndex {
9197 entryPreIndex := iNdEx
9198 var wire uint64
9199 for shift := uint(0); ; shift += 7 {
9200 if shift >= 64 {
9201 return ErrIntOverflowTheproto3
9202 }
9203 if iNdEx >= l {
9204 return io.ErrUnexpectedEOF
9205 }
9206 b := dAtA[iNdEx]
9207 iNdEx++
9208 wire |= uint64(b&0x7F) << shift
9209 if b < 0x80 {
9210 break
9211 }
9212 }
9213 fieldNum := int32(wire >> 3)
9214 if fieldNum == 1 {
9215 var stringLenmapkey uint64
9216 for shift := uint(0); ; shift += 7 {
9217 if shift >= 64 {
9218 return ErrIntOverflowTheproto3
9219 }
9220 if iNdEx >= l {
9221 return io.ErrUnexpectedEOF
9222 }
9223 b := dAtA[iNdEx]
9224 iNdEx++
9225 stringLenmapkey |= uint64(b&0x7F) << shift
9226 if b < 0x80 {
9227 break
9228 }
9229 }
9230 intStringLenmapkey := int(stringLenmapkey)
9231 if intStringLenmapkey < 0 {
9232 return ErrInvalidLengthTheproto3
9233 }
9234 postStringIndexmapkey := iNdEx + intStringLenmapkey
9235 if postStringIndexmapkey < 0 {
9236 return ErrInvalidLengthTheproto3
9237 }
9238 if postStringIndexmapkey > l {
9239 return io.ErrUnexpectedEOF
9240 }
9241 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
9242 iNdEx = postStringIndexmapkey
9243 } else if fieldNum == 2 {
9244 var mapbyteLen uint64
9245 for shift := uint(0); ; shift += 7 {
9246 if shift >= 64 {
9247 return ErrIntOverflowTheproto3
9248 }
9249 if iNdEx >= l {
9250 return io.ErrUnexpectedEOF
9251 }
9252 b := dAtA[iNdEx]
9253 iNdEx++
9254 mapbyteLen |= uint64(b&0x7F) << shift
9255 if b < 0x80 {
9256 break
9257 }
9258 }
9259 intMapbyteLen := int(mapbyteLen)
9260 if intMapbyteLen < 0 {
9261 return ErrInvalidLengthTheproto3
9262 }
9263 postbytesIndex := iNdEx + intMapbyteLen
9264 if postbytesIndex < 0 {
9265 return ErrInvalidLengthTheproto3
9266 }
9267 if postbytesIndex > l {
9268 return io.ErrUnexpectedEOF
9269 }
9270 mapvalue = make([]byte, mapbyteLen)
9271 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
9272 iNdEx = postbytesIndex
9273 } else {
9274 iNdEx = entryPreIndex
9275 skippy, err := skipTheproto3(dAtA[iNdEx:])
9276 if err != nil {
9277 return err
9278 }
9279 if (skippy < 0) || (iNdEx+skippy) < 0 {
9280 return ErrInvalidLengthTheproto3
9281 }
9282 if (iNdEx + skippy) > postIndex {
9283 return io.ErrUnexpectedEOF
9284 }
9285 iNdEx += skippy
9286 }
9287 }
9288 m.StringToBytesMap[mapkey] = mapvalue
9289 iNdEx = postIndex
9290 case 16:
9291 if wireType != 2 {
9292 return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType)
9293 }
9294 var msglen int
9295 for shift := uint(0); ; shift += 7 {
9296 if shift >= 64 {
9297 return ErrIntOverflowTheproto3
9298 }
9299 if iNdEx >= l {
9300 return io.ErrUnexpectedEOF
9301 }
9302 b := dAtA[iNdEx]
9303 iNdEx++
9304 msglen |= int(b&0x7F) << shift
9305 if b < 0x80 {
9306 break
9307 }
9308 }
9309 if msglen < 0 {
9310 return ErrInvalidLengthTheproto3
9311 }
9312 postIndex := iNdEx + msglen
9313 if postIndex < 0 {
9314 return ErrInvalidLengthTheproto3
9315 }
9316 if postIndex > l {
9317 return io.ErrUnexpectedEOF
9318 }
9319 if m.StringToEnumMap == nil {
9320 m.StringToEnumMap = make(map[string]MapEnum)
9321 }
9322 var mapkey string
9323 var mapvalue MapEnum
9324 for iNdEx < postIndex {
9325 entryPreIndex := iNdEx
9326 var wire uint64
9327 for shift := uint(0); ; shift += 7 {
9328 if shift >= 64 {
9329 return ErrIntOverflowTheproto3
9330 }
9331 if iNdEx >= l {
9332 return io.ErrUnexpectedEOF
9333 }
9334 b := dAtA[iNdEx]
9335 iNdEx++
9336 wire |= uint64(b&0x7F) << shift
9337 if b < 0x80 {
9338 break
9339 }
9340 }
9341 fieldNum := int32(wire >> 3)
9342 if fieldNum == 1 {
9343 var stringLenmapkey uint64
9344 for shift := uint(0); ; shift += 7 {
9345 if shift >= 64 {
9346 return ErrIntOverflowTheproto3
9347 }
9348 if iNdEx >= l {
9349 return io.ErrUnexpectedEOF
9350 }
9351 b := dAtA[iNdEx]
9352 iNdEx++
9353 stringLenmapkey |= uint64(b&0x7F) << shift
9354 if b < 0x80 {
9355 break
9356 }
9357 }
9358 intStringLenmapkey := int(stringLenmapkey)
9359 if intStringLenmapkey < 0 {
9360 return ErrInvalidLengthTheproto3
9361 }
9362 postStringIndexmapkey := iNdEx + intStringLenmapkey
9363 if postStringIndexmapkey < 0 {
9364 return ErrInvalidLengthTheproto3
9365 }
9366 if postStringIndexmapkey > l {
9367 return io.ErrUnexpectedEOF
9368 }
9369 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
9370 iNdEx = postStringIndexmapkey
9371 } else if fieldNum == 2 {
9372 for shift := uint(0); ; shift += 7 {
9373 if shift >= 64 {
9374 return ErrIntOverflowTheproto3
9375 }
9376 if iNdEx >= l {
9377 return io.ErrUnexpectedEOF
9378 }
9379 b := dAtA[iNdEx]
9380 iNdEx++
9381 mapvalue |= MapEnum(b&0x7F) << shift
9382 if b < 0x80 {
9383 break
9384 }
9385 }
9386 } else {
9387 iNdEx = entryPreIndex
9388 skippy, err := skipTheproto3(dAtA[iNdEx:])
9389 if err != nil {
9390 return err
9391 }
9392 if (skippy < 0) || (iNdEx+skippy) < 0 {
9393 return ErrInvalidLengthTheproto3
9394 }
9395 if (iNdEx + skippy) > postIndex {
9396 return io.ErrUnexpectedEOF
9397 }
9398 iNdEx += skippy
9399 }
9400 }
9401 m.StringToEnumMap[mapkey] = mapvalue
9402 iNdEx = postIndex
9403 case 17:
9404 if wireType != 2 {
9405 return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType)
9406 }
9407 var msglen int
9408 for shift := uint(0); ; shift += 7 {
9409 if shift >= 64 {
9410 return ErrIntOverflowTheproto3
9411 }
9412 if iNdEx >= l {
9413 return io.ErrUnexpectedEOF
9414 }
9415 b := dAtA[iNdEx]
9416 iNdEx++
9417 msglen |= int(b&0x7F) << shift
9418 if b < 0x80 {
9419 break
9420 }
9421 }
9422 if msglen < 0 {
9423 return ErrInvalidLengthTheproto3
9424 }
9425 postIndex := iNdEx + msglen
9426 if postIndex < 0 {
9427 return ErrInvalidLengthTheproto3
9428 }
9429 if postIndex > l {
9430 return io.ErrUnexpectedEOF
9431 }
9432 if m.StringToMsgMap == nil {
9433 m.StringToMsgMap = make(map[string]*FloatingPoint)
9434 }
9435 var mapkey string
9436 var mapvalue *FloatingPoint
9437 for iNdEx < postIndex {
9438 entryPreIndex := iNdEx
9439 var wire uint64
9440 for shift := uint(0); ; shift += 7 {
9441 if shift >= 64 {
9442 return ErrIntOverflowTheproto3
9443 }
9444 if iNdEx >= l {
9445 return io.ErrUnexpectedEOF
9446 }
9447 b := dAtA[iNdEx]
9448 iNdEx++
9449 wire |= uint64(b&0x7F) << shift
9450 if b < 0x80 {
9451 break
9452 }
9453 }
9454 fieldNum := int32(wire >> 3)
9455 if fieldNum == 1 {
9456 var stringLenmapkey uint64
9457 for shift := uint(0); ; shift += 7 {
9458 if shift >= 64 {
9459 return ErrIntOverflowTheproto3
9460 }
9461 if iNdEx >= l {
9462 return io.ErrUnexpectedEOF
9463 }
9464 b := dAtA[iNdEx]
9465 iNdEx++
9466 stringLenmapkey |= uint64(b&0x7F) << shift
9467 if b < 0x80 {
9468 break
9469 }
9470 }
9471 intStringLenmapkey := int(stringLenmapkey)
9472 if intStringLenmapkey < 0 {
9473 return ErrInvalidLengthTheproto3
9474 }
9475 postStringIndexmapkey := iNdEx + intStringLenmapkey
9476 if postStringIndexmapkey < 0 {
9477 return ErrInvalidLengthTheproto3
9478 }
9479 if postStringIndexmapkey > l {
9480 return io.ErrUnexpectedEOF
9481 }
9482 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
9483 iNdEx = postStringIndexmapkey
9484 } else if fieldNum == 2 {
9485 var mapmsglen int
9486 for shift := uint(0); ; shift += 7 {
9487 if shift >= 64 {
9488 return ErrIntOverflowTheproto3
9489 }
9490 if iNdEx >= l {
9491 return io.ErrUnexpectedEOF
9492 }
9493 b := dAtA[iNdEx]
9494 iNdEx++
9495 mapmsglen |= int(b&0x7F) << shift
9496 if b < 0x80 {
9497 break
9498 }
9499 }
9500 if mapmsglen < 0 {
9501 return ErrInvalidLengthTheproto3
9502 }
9503 postmsgIndex := iNdEx + mapmsglen
9504 if postmsgIndex < 0 {
9505 return ErrInvalidLengthTheproto3
9506 }
9507 if postmsgIndex > l {
9508 return io.ErrUnexpectedEOF
9509 }
9510 mapvalue = &FloatingPoint{}
9511 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
9512 return err
9513 }
9514 iNdEx = postmsgIndex
9515 } else {
9516 iNdEx = entryPreIndex
9517 skippy, err := skipTheproto3(dAtA[iNdEx:])
9518 if err != nil {
9519 return err
9520 }
9521 if (skippy < 0) || (iNdEx+skippy) < 0 {
9522 return ErrInvalidLengthTheproto3
9523 }
9524 if (iNdEx + skippy) > postIndex {
9525 return io.ErrUnexpectedEOF
9526 }
9527 iNdEx += skippy
9528 }
9529 }
9530 m.StringToMsgMap[mapkey] = mapvalue
9531 iNdEx = postIndex
9532 default:
9533 iNdEx = preIndex
9534 skippy, err := skipTheproto3(dAtA[iNdEx:])
9535 if err != nil {
9536 return err
9537 }
9538 if (skippy < 0) || (iNdEx+skippy) < 0 {
9539 return ErrInvalidLengthTheproto3
9540 }
9541 if (iNdEx + skippy) > l {
9542 return io.ErrUnexpectedEOF
9543 }
9544 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9545 iNdEx += skippy
9546 }
9547 }
9548
9549 if iNdEx > l {
9550 return io.ErrUnexpectedEOF
9551 }
9552 return nil
9553 }
9554 func (m *MessageWithMap) Unmarshal(dAtA []byte) error {
9555 l := len(dAtA)
9556 iNdEx := 0
9557 for iNdEx < l {
9558 preIndex := iNdEx
9559 var wire uint64
9560 for shift := uint(0); ; shift += 7 {
9561 if shift >= 64 {
9562 return ErrIntOverflowTheproto3
9563 }
9564 if iNdEx >= l {
9565 return io.ErrUnexpectedEOF
9566 }
9567 b := dAtA[iNdEx]
9568 iNdEx++
9569 wire |= uint64(b&0x7F) << shift
9570 if b < 0x80 {
9571 break
9572 }
9573 }
9574 fieldNum := int32(wire >> 3)
9575 wireType := int(wire & 0x7)
9576 if wireType == 4 {
9577 return fmt.Errorf("proto: MessageWithMap: wiretype end group for non-group")
9578 }
9579 if fieldNum <= 0 {
9580 return fmt.Errorf("proto: MessageWithMap: illegal tag %d (wire type %d)", fieldNum, wire)
9581 }
9582 switch fieldNum {
9583 case 1:
9584 if wireType != 2 {
9585 return fmt.Errorf("proto: wrong wireType = %d for field NameMapping", wireType)
9586 }
9587 var msglen int
9588 for shift := uint(0); ; shift += 7 {
9589 if shift >= 64 {
9590 return ErrIntOverflowTheproto3
9591 }
9592 if iNdEx >= l {
9593 return io.ErrUnexpectedEOF
9594 }
9595 b := dAtA[iNdEx]
9596 iNdEx++
9597 msglen |= int(b&0x7F) << shift
9598 if b < 0x80 {
9599 break
9600 }
9601 }
9602 if msglen < 0 {
9603 return ErrInvalidLengthTheproto3
9604 }
9605 postIndex := iNdEx + msglen
9606 if postIndex < 0 {
9607 return ErrInvalidLengthTheproto3
9608 }
9609 if postIndex > l {
9610 return io.ErrUnexpectedEOF
9611 }
9612 if m.NameMapping == nil {
9613 m.NameMapping = make(map[int32]string)
9614 }
9615 var mapkey int32
9616 var mapvalue string
9617 for iNdEx < postIndex {
9618 entryPreIndex := iNdEx
9619 var wire uint64
9620 for shift := uint(0); ; shift += 7 {
9621 if shift >= 64 {
9622 return ErrIntOverflowTheproto3
9623 }
9624 if iNdEx >= l {
9625 return io.ErrUnexpectedEOF
9626 }
9627 b := dAtA[iNdEx]
9628 iNdEx++
9629 wire |= uint64(b&0x7F) << shift
9630 if b < 0x80 {
9631 break
9632 }
9633 }
9634 fieldNum := int32(wire >> 3)
9635 if fieldNum == 1 {
9636 for shift := uint(0); ; shift += 7 {
9637 if shift >= 64 {
9638 return ErrIntOverflowTheproto3
9639 }
9640 if iNdEx >= l {
9641 return io.ErrUnexpectedEOF
9642 }
9643 b := dAtA[iNdEx]
9644 iNdEx++
9645 mapkey |= int32(b&0x7F) << shift
9646 if b < 0x80 {
9647 break
9648 }
9649 }
9650 } else if fieldNum == 2 {
9651 var stringLenmapvalue uint64
9652 for shift := uint(0); ; shift += 7 {
9653 if shift >= 64 {
9654 return ErrIntOverflowTheproto3
9655 }
9656 if iNdEx >= l {
9657 return io.ErrUnexpectedEOF
9658 }
9659 b := dAtA[iNdEx]
9660 iNdEx++
9661 stringLenmapvalue |= uint64(b&0x7F) << shift
9662 if b < 0x80 {
9663 break
9664 }
9665 }
9666 intStringLenmapvalue := int(stringLenmapvalue)
9667 if intStringLenmapvalue < 0 {
9668 return ErrInvalidLengthTheproto3
9669 }
9670 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
9671 if postStringIndexmapvalue < 0 {
9672 return ErrInvalidLengthTheproto3
9673 }
9674 if postStringIndexmapvalue > l {
9675 return io.ErrUnexpectedEOF
9676 }
9677 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
9678 iNdEx = postStringIndexmapvalue
9679 } else {
9680 iNdEx = entryPreIndex
9681 skippy, err := skipTheproto3(dAtA[iNdEx:])
9682 if err != nil {
9683 return err
9684 }
9685 if (skippy < 0) || (iNdEx+skippy) < 0 {
9686 return ErrInvalidLengthTheproto3
9687 }
9688 if (iNdEx + skippy) > postIndex {
9689 return io.ErrUnexpectedEOF
9690 }
9691 iNdEx += skippy
9692 }
9693 }
9694 m.NameMapping[mapkey] = mapvalue
9695 iNdEx = postIndex
9696 case 2:
9697 if wireType != 2 {
9698 return fmt.Errorf("proto: wrong wireType = %d for field MsgMapping", wireType)
9699 }
9700 var msglen int
9701 for shift := uint(0); ; shift += 7 {
9702 if shift >= 64 {
9703 return ErrIntOverflowTheproto3
9704 }
9705 if iNdEx >= l {
9706 return io.ErrUnexpectedEOF
9707 }
9708 b := dAtA[iNdEx]
9709 iNdEx++
9710 msglen |= int(b&0x7F) << shift
9711 if b < 0x80 {
9712 break
9713 }
9714 }
9715 if msglen < 0 {
9716 return ErrInvalidLengthTheproto3
9717 }
9718 postIndex := iNdEx + msglen
9719 if postIndex < 0 {
9720 return ErrInvalidLengthTheproto3
9721 }
9722 if postIndex > l {
9723 return io.ErrUnexpectedEOF
9724 }
9725 if m.MsgMapping == nil {
9726 m.MsgMapping = make(map[int64]*FloatingPoint)
9727 }
9728 var mapkey int64
9729 var mapvalue *FloatingPoint
9730 for iNdEx < postIndex {
9731 entryPreIndex := iNdEx
9732 var wire uint64
9733 for shift := uint(0); ; shift += 7 {
9734 if shift >= 64 {
9735 return ErrIntOverflowTheproto3
9736 }
9737 if iNdEx >= l {
9738 return io.ErrUnexpectedEOF
9739 }
9740 b := dAtA[iNdEx]
9741 iNdEx++
9742 wire |= uint64(b&0x7F) << shift
9743 if b < 0x80 {
9744 break
9745 }
9746 }
9747 fieldNum := int32(wire >> 3)
9748 if fieldNum == 1 {
9749 var mapkeytemp uint64
9750 for shift := uint(0); ; shift += 7 {
9751 if shift >= 64 {
9752 return ErrIntOverflowTheproto3
9753 }
9754 if iNdEx >= l {
9755 return io.ErrUnexpectedEOF
9756 }
9757 b := dAtA[iNdEx]
9758 iNdEx++
9759 mapkeytemp |= uint64(b&0x7F) << shift
9760 if b < 0x80 {
9761 break
9762 }
9763 }
9764 mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
9765 mapkey = int64(mapkeytemp)
9766 } else if fieldNum == 2 {
9767 var mapmsglen int
9768 for shift := uint(0); ; shift += 7 {
9769 if shift >= 64 {
9770 return ErrIntOverflowTheproto3
9771 }
9772 if iNdEx >= l {
9773 return io.ErrUnexpectedEOF
9774 }
9775 b := dAtA[iNdEx]
9776 iNdEx++
9777 mapmsglen |= int(b&0x7F) << shift
9778 if b < 0x80 {
9779 break
9780 }
9781 }
9782 if mapmsglen < 0 {
9783 return ErrInvalidLengthTheproto3
9784 }
9785 postmsgIndex := iNdEx + mapmsglen
9786 if postmsgIndex < 0 {
9787 return ErrInvalidLengthTheproto3
9788 }
9789 if postmsgIndex > l {
9790 return io.ErrUnexpectedEOF
9791 }
9792 mapvalue = &FloatingPoint{}
9793 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
9794 return err
9795 }
9796 iNdEx = postmsgIndex
9797 } else {
9798 iNdEx = entryPreIndex
9799 skippy, err := skipTheproto3(dAtA[iNdEx:])
9800 if err != nil {
9801 return err
9802 }
9803 if (skippy < 0) || (iNdEx+skippy) < 0 {
9804 return ErrInvalidLengthTheproto3
9805 }
9806 if (iNdEx + skippy) > postIndex {
9807 return io.ErrUnexpectedEOF
9808 }
9809 iNdEx += skippy
9810 }
9811 }
9812 m.MsgMapping[mapkey] = mapvalue
9813 iNdEx = postIndex
9814 case 3:
9815 if wireType != 2 {
9816 return fmt.Errorf("proto: wrong wireType = %d for field ByteMapping", wireType)
9817 }
9818 var msglen int
9819 for shift := uint(0); ; shift += 7 {
9820 if shift >= 64 {
9821 return ErrIntOverflowTheproto3
9822 }
9823 if iNdEx >= l {
9824 return io.ErrUnexpectedEOF
9825 }
9826 b := dAtA[iNdEx]
9827 iNdEx++
9828 msglen |= int(b&0x7F) << shift
9829 if b < 0x80 {
9830 break
9831 }
9832 }
9833 if msglen < 0 {
9834 return ErrInvalidLengthTheproto3
9835 }
9836 postIndex := iNdEx + msglen
9837 if postIndex < 0 {
9838 return ErrInvalidLengthTheproto3
9839 }
9840 if postIndex > l {
9841 return io.ErrUnexpectedEOF
9842 }
9843 if m.ByteMapping == nil {
9844 m.ByteMapping = make(map[bool][]byte)
9845 }
9846 var mapkey bool
9847 mapvalue := []byte{}
9848 for iNdEx < postIndex {
9849 entryPreIndex := iNdEx
9850 var wire uint64
9851 for shift := uint(0); ; shift += 7 {
9852 if shift >= 64 {
9853 return ErrIntOverflowTheproto3
9854 }
9855 if iNdEx >= l {
9856 return io.ErrUnexpectedEOF
9857 }
9858 b := dAtA[iNdEx]
9859 iNdEx++
9860 wire |= uint64(b&0x7F) << shift
9861 if b < 0x80 {
9862 break
9863 }
9864 }
9865 fieldNum := int32(wire >> 3)
9866 if fieldNum == 1 {
9867 var mapkeytemp int
9868 for shift := uint(0); ; shift += 7 {
9869 if shift >= 64 {
9870 return ErrIntOverflowTheproto3
9871 }
9872 if iNdEx >= l {
9873 return io.ErrUnexpectedEOF
9874 }
9875 b := dAtA[iNdEx]
9876 iNdEx++
9877 mapkeytemp |= int(b&0x7F) << shift
9878 if b < 0x80 {
9879 break
9880 }
9881 }
9882 mapkey = bool(mapkeytemp != 0)
9883 } else if fieldNum == 2 {
9884 var mapbyteLen uint64
9885 for shift := uint(0); ; shift += 7 {
9886 if shift >= 64 {
9887 return ErrIntOverflowTheproto3
9888 }
9889 if iNdEx >= l {
9890 return io.ErrUnexpectedEOF
9891 }
9892 b := dAtA[iNdEx]
9893 iNdEx++
9894 mapbyteLen |= uint64(b&0x7F) << shift
9895 if b < 0x80 {
9896 break
9897 }
9898 }
9899 intMapbyteLen := int(mapbyteLen)
9900 if intMapbyteLen < 0 {
9901 return ErrInvalidLengthTheproto3
9902 }
9903 postbytesIndex := iNdEx + intMapbyteLen
9904 if postbytesIndex < 0 {
9905 return ErrInvalidLengthTheproto3
9906 }
9907 if postbytesIndex > l {
9908 return io.ErrUnexpectedEOF
9909 }
9910 mapvalue = make([]byte, mapbyteLen)
9911 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
9912 iNdEx = postbytesIndex
9913 } else {
9914 iNdEx = entryPreIndex
9915 skippy, err := skipTheproto3(dAtA[iNdEx:])
9916 if err != nil {
9917 return err
9918 }
9919 if (skippy < 0) || (iNdEx+skippy) < 0 {
9920 return ErrInvalidLengthTheproto3
9921 }
9922 if (iNdEx + skippy) > postIndex {
9923 return io.ErrUnexpectedEOF
9924 }
9925 iNdEx += skippy
9926 }
9927 }
9928 m.ByteMapping[mapkey] = mapvalue
9929 iNdEx = postIndex
9930 default:
9931 iNdEx = preIndex
9932 skippy, err := skipTheproto3(dAtA[iNdEx:])
9933 if err != nil {
9934 return err
9935 }
9936 if (skippy < 0) || (iNdEx+skippy) < 0 {
9937 return ErrInvalidLengthTheproto3
9938 }
9939 if (iNdEx + skippy) > l {
9940 return io.ErrUnexpectedEOF
9941 }
9942 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
9943 iNdEx += skippy
9944 }
9945 }
9946
9947 if iNdEx > l {
9948 return io.ErrUnexpectedEOF
9949 }
9950 return nil
9951 }
9952 func (m *FloatingPoint) Unmarshal(dAtA []byte) error {
9953 l := len(dAtA)
9954 iNdEx := 0
9955 for iNdEx < l {
9956 preIndex := iNdEx
9957 var wire uint64
9958 for shift := uint(0); ; shift += 7 {
9959 if shift >= 64 {
9960 return ErrIntOverflowTheproto3
9961 }
9962 if iNdEx >= l {
9963 return io.ErrUnexpectedEOF
9964 }
9965 b := dAtA[iNdEx]
9966 iNdEx++
9967 wire |= uint64(b&0x7F) << shift
9968 if b < 0x80 {
9969 break
9970 }
9971 }
9972 fieldNum := int32(wire >> 3)
9973 wireType := int(wire & 0x7)
9974 if wireType == 4 {
9975 return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group")
9976 }
9977 if fieldNum <= 0 {
9978 return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire)
9979 }
9980 switch fieldNum {
9981 case 1:
9982 if wireType != 1 {
9983 return fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
9984 }
9985 var v uint64
9986 if (iNdEx + 8) > l {
9987 return io.ErrUnexpectedEOF
9988 }
9989 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
9990 iNdEx += 8
9991 m.F = float64(math.Float64frombits(v))
9992 default:
9993 iNdEx = preIndex
9994 skippy, err := skipTheproto3(dAtA[iNdEx:])
9995 if err != nil {
9996 return err
9997 }
9998 if (skippy < 0) || (iNdEx+skippy) < 0 {
9999 return ErrInvalidLengthTheproto3
10000 }
10001 if (iNdEx + skippy) > l {
10002 return io.ErrUnexpectedEOF
10003 }
10004 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
10005 iNdEx += skippy
10006 }
10007 }
10008
10009 if iNdEx > l {
10010 return io.ErrUnexpectedEOF
10011 }
10012 return nil
10013 }
10014 func (m *Uint128Pair) Unmarshal(dAtA []byte) error {
10015 l := len(dAtA)
10016 iNdEx := 0
10017 for iNdEx < l {
10018 preIndex := iNdEx
10019 var wire uint64
10020 for shift := uint(0); ; shift += 7 {
10021 if shift >= 64 {
10022 return ErrIntOverflowTheproto3
10023 }
10024 if iNdEx >= l {
10025 return io.ErrUnexpectedEOF
10026 }
10027 b := dAtA[iNdEx]
10028 iNdEx++
10029 wire |= uint64(b&0x7F) << shift
10030 if b < 0x80 {
10031 break
10032 }
10033 }
10034 fieldNum := int32(wire >> 3)
10035 wireType := int(wire & 0x7)
10036 if wireType == 4 {
10037 return fmt.Errorf("proto: Uint128Pair: wiretype end group for non-group")
10038 }
10039 if fieldNum <= 0 {
10040 return fmt.Errorf("proto: Uint128Pair: illegal tag %d (wire type %d)", fieldNum, wire)
10041 }
10042 switch fieldNum {
10043 case 1:
10044 if wireType != 2 {
10045 return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
10046 }
10047 var byteLen int
10048 for shift := uint(0); ; shift += 7 {
10049 if shift >= 64 {
10050 return ErrIntOverflowTheproto3
10051 }
10052 if iNdEx >= l {
10053 return io.ErrUnexpectedEOF
10054 }
10055 b := dAtA[iNdEx]
10056 iNdEx++
10057 byteLen |= int(b&0x7F) << shift
10058 if b < 0x80 {
10059 break
10060 }
10061 }
10062 if byteLen < 0 {
10063 return ErrInvalidLengthTheproto3
10064 }
10065 postIndex := iNdEx + byteLen
10066 if postIndex < 0 {
10067 return ErrInvalidLengthTheproto3
10068 }
10069 if postIndex > l {
10070 return io.ErrUnexpectedEOF
10071 }
10072 if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10073 return err
10074 }
10075 iNdEx = postIndex
10076 case 2:
10077 if wireType != 2 {
10078 return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
10079 }
10080 var byteLen int
10081 for shift := uint(0); ; shift += 7 {
10082 if shift >= 64 {
10083 return ErrIntOverflowTheproto3
10084 }
10085 if iNdEx >= l {
10086 return io.ErrUnexpectedEOF
10087 }
10088 b := dAtA[iNdEx]
10089 iNdEx++
10090 byteLen |= int(b&0x7F) << shift
10091 if b < 0x80 {
10092 break
10093 }
10094 }
10095 if byteLen < 0 {
10096 return ErrInvalidLengthTheproto3
10097 }
10098 postIndex := iNdEx + byteLen
10099 if postIndex < 0 {
10100 return ErrInvalidLengthTheproto3
10101 }
10102 if postIndex > l {
10103 return io.ErrUnexpectedEOF
10104 }
10105 var v github_com_gogo_protobuf_test_custom.Uint128
10106 m.Right = &v
10107 if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10108 return err
10109 }
10110 iNdEx = postIndex
10111 default:
10112 iNdEx = preIndex
10113 skippy, err := skipTheproto3(dAtA[iNdEx:])
10114 if err != nil {
10115 return err
10116 }
10117 if (skippy < 0) || (iNdEx+skippy) < 0 {
10118 return ErrInvalidLengthTheproto3
10119 }
10120 if (iNdEx + skippy) > l {
10121 return io.ErrUnexpectedEOF
10122 }
10123 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
10124 iNdEx += skippy
10125 }
10126 }
10127
10128 if iNdEx > l {
10129 return io.ErrUnexpectedEOF
10130 }
10131 return nil
10132 }
10133 func (m *ContainsNestedMap) Unmarshal(dAtA []byte) error {
10134 l := len(dAtA)
10135 iNdEx := 0
10136 for iNdEx < l {
10137 preIndex := iNdEx
10138 var wire uint64
10139 for shift := uint(0); ; shift += 7 {
10140 if shift >= 64 {
10141 return ErrIntOverflowTheproto3
10142 }
10143 if iNdEx >= l {
10144 return io.ErrUnexpectedEOF
10145 }
10146 b := dAtA[iNdEx]
10147 iNdEx++
10148 wire |= uint64(b&0x7F) << shift
10149 if b < 0x80 {
10150 break
10151 }
10152 }
10153 fieldNum := int32(wire >> 3)
10154 wireType := int(wire & 0x7)
10155 if wireType == 4 {
10156 return fmt.Errorf("proto: ContainsNestedMap: wiretype end group for non-group")
10157 }
10158 if fieldNum <= 0 {
10159 return fmt.Errorf("proto: ContainsNestedMap: illegal tag %d (wire type %d)", fieldNum, wire)
10160 }
10161 switch fieldNum {
10162 default:
10163 iNdEx = preIndex
10164 skippy, err := skipTheproto3(dAtA[iNdEx:])
10165 if err != nil {
10166 return err
10167 }
10168 if (skippy < 0) || (iNdEx+skippy) < 0 {
10169 return ErrInvalidLengthTheproto3
10170 }
10171 if (iNdEx + skippy) > l {
10172 return io.ErrUnexpectedEOF
10173 }
10174 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
10175 iNdEx += skippy
10176 }
10177 }
10178
10179 if iNdEx > l {
10180 return io.ErrUnexpectedEOF
10181 }
10182 return nil
10183 }
10184 func (m *ContainsNestedMap_NestedMap) Unmarshal(dAtA []byte) error {
10185 l := len(dAtA)
10186 iNdEx := 0
10187 for iNdEx < l {
10188 preIndex := iNdEx
10189 var wire uint64
10190 for shift := uint(0); ; shift += 7 {
10191 if shift >= 64 {
10192 return ErrIntOverflowTheproto3
10193 }
10194 if iNdEx >= l {
10195 return io.ErrUnexpectedEOF
10196 }
10197 b := dAtA[iNdEx]
10198 iNdEx++
10199 wire |= uint64(b&0x7F) << shift
10200 if b < 0x80 {
10201 break
10202 }
10203 }
10204 fieldNum := int32(wire >> 3)
10205 wireType := int(wire & 0x7)
10206 if wireType == 4 {
10207 return fmt.Errorf("proto: NestedMap: wiretype end group for non-group")
10208 }
10209 if fieldNum <= 0 {
10210 return fmt.Errorf("proto: NestedMap: illegal tag %d (wire type %d)", fieldNum, wire)
10211 }
10212 switch fieldNum {
10213 case 1:
10214 if wireType != 2 {
10215 return fmt.Errorf("proto: wrong wireType = %d for field NestedMapField", wireType)
10216 }
10217 var msglen int
10218 for shift := uint(0); ; shift += 7 {
10219 if shift >= 64 {
10220 return ErrIntOverflowTheproto3
10221 }
10222 if iNdEx >= l {
10223 return io.ErrUnexpectedEOF
10224 }
10225 b := dAtA[iNdEx]
10226 iNdEx++
10227 msglen |= int(b&0x7F) << shift
10228 if b < 0x80 {
10229 break
10230 }
10231 }
10232 if msglen < 0 {
10233 return ErrInvalidLengthTheproto3
10234 }
10235 postIndex := iNdEx + msglen
10236 if postIndex < 0 {
10237 return ErrInvalidLengthTheproto3
10238 }
10239 if postIndex > l {
10240 return io.ErrUnexpectedEOF
10241 }
10242 if m.NestedMapField == nil {
10243 m.NestedMapField = make(map[string]float64)
10244 }
10245 var mapkey string
10246 var mapvalue float64
10247 for iNdEx < postIndex {
10248 entryPreIndex := iNdEx
10249 var wire uint64
10250 for shift := uint(0); ; shift += 7 {
10251 if shift >= 64 {
10252 return ErrIntOverflowTheproto3
10253 }
10254 if iNdEx >= l {
10255 return io.ErrUnexpectedEOF
10256 }
10257 b := dAtA[iNdEx]
10258 iNdEx++
10259 wire |= uint64(b&0x7F) << shift
10260 if b < 0x80 {
10261 break
10262 }
10263 }
10264 fieldNum := int32(wire >> 3)
10265 if fieldNum == 1 {
10266 var stringLenmapkey uint64
10267 for shift := uint(0); ; shift += 7 {
10268 if shift >= 64 {
10269 return ErrIntOverflowTheproto3
10270 }
10271 if iNdEx >= l {
10272 return io.ErrUnexpectedEOF
10273 }
10274 b := dAtA[iNdEx]
10275 iNdEx++
10276 stringLenmapkey |= uint64(b&0x7F) << shift
10277 if b < 0x80 {
10278 break
10279 }
10280 }
10281 intStringLenmapkey := int(stringLenmapkey)
10282 if intStringLenmapkey < 0 {
10283 return ErrInvalidLengthTheproto3
10284 }
10285 postStringIndexmapkey := iNdEx + intStringLenmapkey
10286 if postStringIndexmapkey < 0 {
10287 return ErrInvalidLengthTheproto3
10288 }
10289 if postStringIndexmapkey > l {
10290 return io.ErrUnexpectedEOF
10291 }
10292 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
10293 iNdEx = postStringIndexmapkey
10294 } else if fieldNum == 2 {
10295 var mapvaluetemp uint64
10296 if (iNdEx + 8) > l {
10297 return io.ErrUnexpectedEOF
10298 }
10299 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
10300 iNdEx += 8
10301 mapvalue = math.Float64frombits(mapvaluetemp)
10302 } else {
10303 iNdEx = entryPreIndex
10304 skippy, err := skipTheproto3(dAtA[iNdEx:])
10305 if err != nil {
10306 return err
10307 }
10308 if (skippy < 0) || (iNdEx+skippy) < 0 {
10309 return ErrInvalidLengthTheproto3
10310 }
10311 if (iNdEx + skippy) > postIndex {
10312 return io.ErrUnexpectedEOF
10313 }
10314 iNdEx += skippy
10315 }
10316 }
10317 m.NestedMapField[mapkey] = mapvalue
10318 iNdEx = postIndex
10319 default:
10320 iNdEx = preIndex
10321 skippy, err := skipTheproto3(dAtA[iNdEx:])
10322 if err != nil {
10323 return err
10324 }
10325 if (skippy < 0) || (iNdEx+skippy) < 0 {
10326 return ErrInvalidLengthTheproto3
10327 }
10328 if (iNdEx + skippy) > l {
10329 return io.ErrUnexpectedEOF
10330 }
10331 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
10332 iNdEx += skippy
10333 }
10334 }
10335
10336 if iNdEx > l {
10337 return io.ErrUnexpectedEOF
10338 }
10339 return nil
10340 }
10341 func (m *NotPacked) Unmarshal(dAtA []byte) error {
10342 l := len(dAtA)
10343 iNdEx := 0
10344 for iNdEx < l {
10345 preIndex := iNdEx
10346 var wire uint64
10347 for shift := uint(0); ; shift += 7 {
10348 if shift >= 64 {
10349 return ErrIntOverflowTheproto3
10350 }
10351 if iNdEx >= l {
10352 return io.ErrUnexpectedEOF
10353 }
10354 b := dAtA[iNdEx]
10355 iNdEx++
10356 wire |= uint64(b&0x7F) << shift
10357 if b < 0x80 {
10358 break
10359 }
10360 }
10361 fieldNum := int32(wire >> 3)
10362 wireType := int(wire & 0x7)
10363 if wireType == 4 {
10364 return fmt.Errorf("proto: NotPacked: wiretype end group for non-group")
10365 }
10366 if fieldNum <= 0 {
10367 return fmt.Errorf("proto: NotPacked: illegal tag %d (wire type %d)", fieldNum, wire)
10368 }
10369 switch fieldNum {
10370 case 5:
10371 if wireType == 0 {
10372 var v uint64
10373 for shift := uint(0); ; shift += 7 {
10374 if shift >= 64 {
10375 return ErrIntOverflowTheproto3
10376 }
10377 if iNdEx >= l {
10378 return io.ErrUnexpectedEOF
10379 }
10380 b := dAtA[iNdEx]
10381 iNdEx++
10382 v |= uint64(b&0x7F) << shift
10383 if b < 0x80 {
10384 break
10385 }
10386 }
10387 m.Key = append(m.Key, v)
10388 } else if wireType == 2 {
10389 var packedLen int
10390 for shift := uint(0); ; shift += 7 {
10391 if shift >= 64 {
10392 return ErrIntOverflowTheproto3
10393 }
10394 if iNdEx >= l {
10395 return io.ErrUnexpectedEOF
10396 }
10397 b := dAtA[iNdEx]
10398 iNdEx++
10399 packedLen |= int(b&0x7F) << shift
10400 if b < 0x80 {
10401 break
10402 }
10403 }
10404 if packedLen < 0 {
10405 return ErrInvalidLengthTheproto3
10406 }
10407 postIndex := iNdEx + packedLen
10408 if postIndex < 0 {
10409 return ErrInvalidLengthTheproto3
10410 }
10411 if postIndex > l {
10412 return io.ErrUnexpectedEOF
10413 }
10414 var elementCount int
10415 var count int
10416 for _, integer := range dAtA[iNdEx:postIndex] {
10417 if integer < 128 {
10418 count++
10419 }
10420 }
10421 elementCount = count
10422 if elementCount != 0 && len(m.Key) == 0 {
10423 m.Key = make([]uint64, 0, elementCount)
10424 }
10425 for iNdEx < postIndex {
10426 var v uint64
10427 for shift := uint(0); ; shift += 7 {
10428 if shift >= 64 {
10429 return ErrIntOverflowTheproto3
10430 }
10431 if iNdEx >= l {
10432 return io.ErrUnexpectedEOF
10433 }
10434 b := dAtA[iNdEx]
10435 iNdEx++
10436 v |= uint64(b&0x7F) << shift
10437 if b < 0x80 {
10438 break
10439 }
10440 }
10441 m.Key = append(m.Key, v)
10442 }
10443 } else {
10444 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
10445 }
10446 default:
10447 iNdEx = preIndex
10448 skippy, err := skipTheproto3(dAtA[iNdEx:])
10449 if err != nil {
10450 return err
10451 }
10452 if (skippy < 0) || (iNdEx+skippy) < 0 {
10453 return ErrInvalidLengthTheproto3
10454 }
10455 if (iNdEx + skippy) > l {
10456 return io.ErrUnexpectedEOF
10457 }
10458 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
10459 iNdEx += skippy
10460 }
10461 }
10462
10463 if iNdEx > l {
10464 return io.ErrUnexpectedEOF
10465 }
10466 return nil
10467 }
10468 func skipTheproto3(dAtA []byte) (n int, err error) {
10469 l := len(dAtA)
10470 iNdEx := 0
10471 depth := 0
10472 for iNdEx < l {
10473 var wire uint64
10474 for shift := uint(0); ; shift += 7 {
10475 if shift >= 64 {
10476 return 0, ErrIntOverflowTheproto3
10477 }
10478 if iNdEx >= l {
10479 return 0, io.ErrUnexpectedEOF
10480 }
10481 b := dAtA[iNdEx]
10482 iNdEx++
10483 wire |= (uint64(b) & 0x7F) << shift
10484 if b < 0x80 {
10485 break
10486 }
10487 }
10488 wireType := int(wire & 0x7)
10489 switch wireType {
10490 case 0:
10491 for shift := uint(0); ; shift += 7 {
10492 if shift >= 64 {
10493 return 0, ErrIntOverflowTheproto3
10494 }
10495 if iNdEx >= l {
10496 return 0, io.ErrUnexpectedEOF
10497 }
10498 iNdEx++
10499 if dAtA[iNdEx-1] < 0x80 {
10500 break
10501 }
10502 }
10503 case 1:
10504 iNdEx += 8
10505 case 2:
10506 var length int
10507 for shift := uint(0); ; shift += 7 {
10508 if shift >= 64 {
10509 return 0, ErrIntOverflowTheproto3
10510 }
10511 if iNdEx >= l {
10512 return 0, io.ErrUnexpectedEOF
10513 }
10514 b := dAtA[iNdEx]
10515 iNdEx++
10516 length |= (int(b) & 0x7F) << shift
10517 if b < 0x80 {
10518 break
10519 }
10520 }
10521 if length < 0 {
10522 return 0, ErrInvalidLengthTheproto3
10523 }
10524 iNdEx += length
10525 case 3:
10526 depth++
10527 case 4:
10528 if depth == 0 {
10529 return 0, ErrUnexpectedEndOfGroupTheproto3
10530 }
10531 depth--
10532 case 5:
10533 iNdEx += 4
10534 default:
10535 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
10536 }
10537 if iNdEx < 0 {
10538 return 0, ErrInvalidLengthTheproto3
10539 }
10540 if depth == 0 {
10541 return iNdEx, nil
10542 }
10543 }
10544 return 0, io.ErrUnexpectedEOF
10545 }
10546
10547 var (
10548 ErrInvalidLengthTheproto3 = fmt.Errorf("proto: negative length found during unmarshaling")
10549 ErrIntOverflowTheproto3 = fmt.Errorf("proto: integer overflow")
10550 ErrUnexpectedEndOfGroupTheproto3 = fmt.Errorf("proto: unexpected end of group")
10551 )
10552
View as plain text