1
2
3
4 package unrecognized
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 io "io"
16 io_ioutil "io/ioutil"
17 math "math"
18 math_bits "math/bits"
19 reflect "reflect"
20 strings "strings"
21 )
22
23
24 var _ = proto.Marshal
25 var _ = fmt.Errorf
26 var _ = math.Inf
27
28
29
30
31
32 const _ = proto.GoGoProtoPackageIsVersion3
33
34 type A struct {
35 Field1 *int64 `protobuf:"varint,2,opt,name=Field1" json:"Field1,omitempty"`
36 B []*B `protobuf:"bytes,1,rep,name=B" json:"B,omitempty"`
37 XXX_NoUnkeyedLiteral struct{} `json:"-"`
38 XXX_sizecache int32 `json:"-"`
39 }
40
41 func (m *A) Reset() { *m = A{} }
42 func (*A) ProtoMessage() {}
43 func (*A) Descriptor() ([]byte, []int) {
44 return fileDescriptor_5318ad6f723bf9f6, []int{0}
45 }
46 func (m *A) XXX_Unmarshal(b []byte) error {
47 return m.Unmarshal(b)
48 }
49 func (m *A) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
50 if deterministic {
51 return xxx_messageInfo_A.Marshal(b, m, deterministic)
52 } else {
53 b = b[:cap(b)]
54 n, err := m.MarshalToSizedBuffer(b)
55 if err != nil {
56 return nil, err
57 }
58 return b[:n], nil
59 }
60 }
61 func (m *A) XXX_Merge(src proto.Message) {
62 xxx_messageInfo_A.Merge(m, src)
63 }
64 func (m *A) XXX_Size() int {
65 return m.Size()
66 }
67 func (m *A) XXX_DiscardUnknown() {
68 xxx_messageInfo_A.DiscardUnknown(m)
69 }
70
71 var xxx_messageInfo_A proto.InternalMessageInfo
72
73 type B struct {
74 C *C `protobuf:"bytes,1,opt,name=C" json:"C,omitempty"`
75 D *D `protobuf:"bytes,2,opt,name=D" json:"D,omitempty"`
76 F *OldC `protobuf:"bytes,5,opt,name=F" json:"F,omitempty"`
77 XXX_NoUnkeyedLiteral struct{} `json:"-"`
78 XXX_unrecognized []byte `json:"-"`
79 XXX_sizecache int32 `json:"-"`
80 }
81
82 func (m *B) Reset() { *m = B{} }
83 func (*B) ProtoMessage() {}
84 func (*B) Descriptor() ([]byte, []int) {
85 return fileDescriptor_5318ad6f723bf9f6, []int{1}
86 }
87 func (m *B) XXX_Unmarshal(b []byte) error {
88 return m.Unmarshal(b)
89 }
90 func (m *B) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
91 if deterministic {
92 return xxx_messageInfo_B.Marshal(b, m, deterministic)
93 } else {
94 b = b[:cap(b)]
95 n, err := m.MarshalToSizedBuffer(b)
96 if err != nil {
97 return nil, err
98 }
99 return b[:n], nil
100 }
101 }
102 func (m *B) XXX_Merge(src proto.Message) {
103 xxx_messageInfo_B.Merge(m, src)
104 }
105 func (m *B) XXX_Size() int {
106 return m.Size()
107 }
108 func (m *B) XXX_DiscardUnknown() {
109 xxx_messageInfo_B.DiscardUnknown(m)
110 }
111
112 var xxx_messageInfo_B proto.InternalMessageInfo
113
114 type D struct {
115 Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"`
116 XXX_NoUnkeyedLiteral struct{} `json:"-"`
117 XXX_unrecognized []byte `json:"-"`
118 XXX_sizecache int32 `json:"-"`
119 }
120
121 func (m *D) Reset() { *m = D{} }
122 func (*D) ProtoMessage() {}
123 func (*D) Descriptor() ([]byte, []int) {
124 return fileDescriptor_5318ad6f723bf9f6, []int{2}
125 }
126 func (m *D) XXX_Unmarshal(b []byte) error {
127 return m.Unmarshal(b)
128 }
129 func (m *D) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
130 if deterministic {
131 return xxx_messageInfo_D.Marshal(b, m, deterministic)
132 } else {
133 b = b[:cap(b)]
134 n, err := m.MarshalToSizedBuffer(b)
135 if err != nil {
136 return nil, err
137 }
138 return b[:n], nil
139 }
140 }
141 func (m *D) XXX_Merge(src proto.Message) {
142 xxx_messageInfo_D.Merge(m, src)
143 }
144 func (m *D) XXX_Size() int {
145 return m.Size()
146 }
147 func (m *D) XXX_DiscardUnknown() {
148 xxx_messageInfo_D.DiscardUnknown(m)
149 }
150
151 var xxx_messageInfo_D proto.InternalMessageInfo
152
153 type C struct {
154 Field2 *float64 `protobuf:"fixed64,2,opt,name=Field2" json:"Field2,omitempty"`
155 Field3 *string `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"`
156 Field4 *float64 `protobuf:"fixed64,4,opt,name=Field4" json:"Field4,omitempty"`
157 Field5 [][]byte `protobuf:"bytes,5,rep,name=Field5" json:"Field5,omitempty"`
158 Field6 *int64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"`
159 Field7 []float32 `protobuf:"fixed32,7,rep,name=Field7" json:"Field7,omitempty"`
160 XXX_NoUnkeyedLiteral struct{} `json:"-"`
161 XXX_unrecognized []byte `json:"-"`
162 XXX_sizecache int32 `json:"-"`
163 }
164
165 func (m *C) Reset() { *m = C{} }
166 func (*C) ProtoMessage() {}
167 func (*C) Descriptor() ([]byte, []int) {
168 return fileDescriptor_5318ad6f723bf9f6, []int{3}
169 }
170 func (m *C) XXX_Unmarshal(b []byte) error {
171 return m.Unmarshal(b)
172 }
173 func (m *C) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
174 if deterministic {
175 return xxx_messageInfo_C.Marshal(b, m, deterministic)
176 } else {
177 b = b[:cap(b)]
178 n, err := m.MarshalToSizedBuffer(b)
179 if err != nil {
180 return nil, err
181 }
182 return b[:n], nil
183 }
184 }
185 func (m *C) XXX_Merge(src proto.Message) {
186 xxx_messageInfo_C.Merge(m, src)
187 }
188 func (m *C) XXX_Size() int {
189 return m.Size()
190 }
191 func (m *C) XXX_DiscardUnknown() {
192 xxx_messageInfo_C.DiscardUnknown(m)
193 }
194
195 var xxx_messageInfo_C proto.InternalMessageInfo
196
197 type U struct {
198 Field2 []float64 `protobuf:"fixed64,2,rep,name=Field2" json:"Field2,omitempty"`
199 Field3 *uint32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"`
200 XXX_NoUnkeyedLiteral struct{} `json:"-"`
201 XXX_sizecache int32 `json:"-"`
202 }
203
204 func (m *U) Reset() { *m = U{} }
205 func (*U) ProtoMessage() {}
206 func (*U) Descriptor() ([]byte, []int) {
207 return fileDescriptor_5318ad6f723bf9f6, []int{4}
208 }
209 func (m *U) XXX_Unmarshal(b []byte) error {
210 return m.Unmarshal(b)
211 }
212 func (m *U) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
213 if deterministic {
214 return xxx_messageInfo_U.Marshal(b, m, deterministic)
215 } else {
216 b = b[:cap(b)]
217 n, err := m.MarshalToSizedBuffer(b)
218 if err != nil {
219 return nil, err
220 }
221 return b[:n], nil
222 }
223 }
224 func (m *U) XXX_Merge(src proto.Message) {
225 xxx_messageInfo_U.Merge(m, src)
226 }
227 func (m *U) XXX_Size() int {
228 return m.Size()
229 }
230 func (m *U) XXX_DiscardUnknown() {
231 xxx_messageInfo_U.DiscardUnknown(m)
232 }
233
234 var xxx_messageInfo_U proto.InternalMessageInfo
235
236 type UnoM struct {
237 Field2 []float64 `protobuf:"fixed64,2,rep,name=Field2" json:"Field2,omitempty"`
238 Field3 *uint32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"`
239 XXX_NoUnkeyedLiteral struct{} `json:"-"`
240 XXX_sizecache int32 `json:"-"`
241 }
242
243 func (m *UnoM) Reset() { *m = UnoM{} }
244 func (*UnoM) ProtoMessage() {}
245 func (*UnoM) Descriptor() ([]byte, []int) {
246 return fileDescriptor_5318ad6f723bf9f6, []int{5}
247 }
248 func (m *UnoM) XXX_Unmarshal(b []byte) error {
249 return xxx_messageInfo_UnoM.Unmarshal(m, b)
250 }
251 func (m *UnoM) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
252 return xxx_messageInfo_UnoM.Marshal(b, m, deterministic)
253 }
254 func (m *UnoM) XXX_Merge(src proto.Message) {
255 xxx_messageInfo_UnoM.Merge(m, src)
256 }
257 func (m *UnoM) XXX_Size() int {
258 return xxx_messageInfo_UnoM.Size(m)
259 }
260 func (m *UnoM) XXX_DiscardUnknown() {
261 xxx_messageInfo_UnoM.DiscardUnknown(m)
262 }
263
264 var xxx_messageInfo_UnoM proto.InternalMessageInfo
265
266 type OldA struct {
267 Field1 *int64 `protobuf:"varint,2,opt,name=Field1" json:"Field1,omitempty"`
268 B []*OldB `protobuf:"bytes,1,rep,name=B" json:"B,omitempty"`
269 XXX_NoUnkeyedLiteral struct{} `json:"-"`
270 XXX_sizecache int32 `json:"-"`
271 }
272
273 func (m *OldA) Reset() { *m = OldA{} }
274 func (*OldA) ProtoMessage() {}
275 func (*OldA) Descriptor() ([]byte, []int) {
276 return fileDescriptor_5318ad6f723bf9f6, []int{6}
277 }
278 func (m *OldA) XXX_Unmarshal(b []byte) error {
279 return m.Unmarshal(b)
280 }
281 func (m *OldA) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
282 if deterministic {
283 return xxx_messageInfo_OldA.Marshal(b, m, deterministic)
284 } else {
285 b = b[:cap(b)]
286 n, err := m.MarshalToSizedBuffer(b)
287 if err != nil {
288 return nil, err
289 }
290 return b[:n], nil
291 }
292 }
293 func (m *OldA) XXX_Merge(src proto.Message) {
294 xxx_messageInfo_OldA.Merge(m, src)
295 }
296 func (m *OldA) XXX_Size() int {
297 return m.Size()
298 }
299 func (m *OldA) XXX_DiscardUnknown() {
300 xxx_messageInfo_OldA.DiscardUnknown(m)
301 }
302
303 var xxx_messageInfo_OldA proto.InternalMessageInfo
304
305 type OldB struct {
306 C *OldC `protobuf:"bytes,1,opt,name=C" json:"C,omitempty"`
307 F *OldC `protobuf:"bytes,5,opt,name=F" json:"F,omitempty"`
308 XXX_NoUnkeyedLiteral struct{} `json:"-"`
309 XXX_unrecognized []byte `json:"-"`
310 XXX_sizecache int32 `json:"-"`
311 }
312
313 func (m *OldB) Reset() { *m = OldB{} }
314 func (*OldB) ProtoMessage() {}
315 func (*OldB) Descriptor() ([]byte, []int) {
316 return fileDescriptor_5318ad6f723bf9f6, []int{7}
317 }
318 func (m *OldB) XXX_Unmarshal(b []byte) error {
319 return m.Unmarshal(b)
320 }
321 func (m *OldB) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
322 if deterministic {
323 return xxx_messageInfo_OldB.Marshal(b, m, deterministic)
324 } else {
325 b = b[:cap(b)]
326 n, err := m.MarshalToSizedBuffer(b)
327 if err != nil {
328 return nil, err
329 }
330 return b[:n], nil
331 }
332 }
333 func (m *OldB) XXX_Merge(src proto.Message) {
334 xxx_messageInfo_OldB.Merge(m, src)
335 }
336 func (m *OldB) XXX_Size() int {
337 return m.Size()
338 }
339 func (m *OldB) XXX_DiscardUnknown() {
340 xxx_messageInfo_OldB.DiscardUnknown(m)
341 }
342
343 var xxx_messageInfo_OldB proto.InternalMessageInfo
344
345 type OldC struct {
346 Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"`
347 Field2 *float64 `protobuf:"fixed64,2,opt,name=Field2" json:"Field2,omitempty"`
348 Field3 *string `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"`
349 Field6 *int64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"`
350 Field7 []float32 `protobuf:"fixed32,7,rep,name=Field7" json:"Field7,omitempty"`
351 XXX_NoUnkeyedLiteral struct{} `json:"-"`
352 XXX_unrecognized []byte `json:"-"`
353 XXX_sizecache int32 `json:"-"`
354 }
355
356 func (m *OldC) Reset() { *m = OldC{} }
357 func (*OldC) ProtoMessage() {}
358 func (*OldC) Descriptor() ([]byte, []int) {
359 return fileDescriptor_5318ad6f723bf9f6, []int{8}
360 }
361 func (m *OldC) XXX_Unmarshal(b []byte) error {
362 return m.Unmarshal(b)
363 }
364 func (m *OldC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
365 if deterministic {
366 return xxx_messageInfo_OldC.Marshal(b, m, deterministic)
367 } else {
368 b = b[:cap(b)]
369 n, err := m.MarshalToSizedBuffer(b)
370 if err != nil {
371 return nil, err
372 }
373 return b[:n], nil
374 }
375 }
376 func (m *OldC) XXX_Merge(src proto.Message) {
377 xxx_messageInfo_OldC.Merge(m, src)
378 }
379 func (m *OldC) XXX_Size() int {
380 return m.Size()
381 }
382 func (m *OldC) XXX_DiscardUnknown() {
383 xxx_messageInfo_OldC.DiscardUnknown(m)
384 }
385
386 var xxx_messageInfo_OldC proto.InternalMessageInfo
387
388 type OldU struct {
389 Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"`
390 Field2 []float64 `protobuf:"fixed64,2,rep,name=Field2" json:"Field2,omitempty"`
391 XXX_NoUnkeyedLiteral struct{} `json:"-"`
392 XXX_unrecognized []byte `json:"-"`
393 XXX_sizecache int32 `json:"-"`
394 }
395
396 func (m *OldU) Reset() { *m = OldU{} }
397 func (*OldU) ProtoMessage() {}
398 func (*OldU) Descriptor() ([]byte, []int) {
399 return fileDescriptor_5318ad6f723bf9f6, []int{9}
400 }
401 func (m *OldU) XXX_Unmarshal(b []byte) error {
402 return m.Unmarshal(b)
403 }
404 func (m *OldU) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
405 if deterministic {
406 return xxx_messageInfo_OldU.Marshal(b, m, deterministic)
407 } else {
408 b = b[:cap(b)]
409 n, err := m.MarshalToSizedBuffer(b)
410 if err != nil {
411 return nil, err
412 }
413 return b[:n], nil
414 }
415 }
416 func (m *OldU) XXX_Merge(src proto.Message) {
417 xxx_messageInfo_OldU.Merge(m, src)
418 }
419 func (m *OldU) XXX_Size() int {
420 return m.Size()
421 }
422 func (m *OldU) XXX_DiscardUnknown() {
423 xxx_messageInfo_OldU.DiscardUnknown(m)
424 }
425
426 var xxx_messageInfo_OldU proto.InternalMessageInfo
427
428 type OldUnoM struct {
429 Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"`
430 Field2 []float64 `protobuf:"fixed64,2,rep,name=Field2" json:"Field2,omitempty"`
431 XXX_NoUnkeyedLiteral struct{} `json:"-"`
432 XXX_unrecognized []byte `json:"-"`
433 XXX_sizecache int32 `json:"-"`
434 }
435
436 func (m *OldUnoM) Reset() { *m = OldUnoM{} }
437 func (*OldUnoM) ProtoMessage() {}
438 func (*OldUnoM) Descriptor() ([]byte, []int) {
439 return fileDescriptor_5318ad6f723bf9f6, []int{10}
440 }
441 func (m *OldUnoM) XXX_Unmarshal(b []byte) error {
442 return xxx_messageInfo_OldUnoM.Unmarshal(m, b)
443 }
444 func (m *OldUnoM) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
445 return xxx_messageInfo_OldUnoM.Marshal(b, m, deterministic)
446 }
447 func (m *OldUnoM) XXX_Merge(src proto.Message) {
448 xxx_messageInfo_OldUnoM.Merge(m, src)
449 }
450 func (m *OldUnoM) XXX_Size() int {
451 return xxx_messageInfo_OldUnoM.Size(m)
452 }
453 func (m *OldUnoM) XXX_DiscardUnknown() {
454 xxx_messageInfo_OldUnoM.DiscardUnknown(m)
455 }
456
457 var xxx_messageInfo_OldUnoM proto.InternalMessageInfo
458
459 func init() {
460 proto.RegisterType((*A)(nil), "unrecognized.A")
461 proto.RegisterType((*B)(nil), "unrecognized.B")
462 proto.RegisterType((*D)(nil), "unrecognized.D")
463 proto.RegisterType((*C)(nil), "unrecognized.C")
464 proto.RegisterType((*U)(nil), "unrecognized.U")
465 proto.RegisterType((*UnoM)(nil), "unrecognized.UnoM")
466 proto.RegisterType((*OldA)(nil), "unrecognized.OldA")
467 proto.RegisterType((*OldB)(nil), "unrecognized.OldB")
468 proto.RegisterType((*OldC)(nil), "unrecognized.OldC")
469 proto.RegisterType((*OldU)(nil), "unrecognized.OldU")
470 proto.RegisterType((*OldUnoM)(nil), "unrecognized.OldUnoM")
471 }
472
473 func init() { proto.RegisterFile("unrecognized.proto", fileDescriptor_5318ad6f723bf9f6) }
474
475 var fileDescriptor_5318ad6f723bf9f6 = []byte{
476
477 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x91, 0x3f, 0x4f, 0xf2, 0x50,
478 0x14, 0xc6, 0x7b, 0x68, 0x81, 0x70, 0x5f, 0xde, 0xbc, 0x6f, 0x3a, 0x98, 0x1b, 0x8d, 0xb7, 0x37,
479 0x9d, 0xba, 0x08, 0x91, 0xbf, 0x91, 0x49, 0xdb, 0xa6, 0x1a, 0x13, 0x43, 0xd2, 0x84, 0x2f, 0x00,
480 0xc5, 0x4a, 0x82, 0xd4, 0x10, 0x58, 0x1c, 0x8c, 0xa3, 0xa3, 0x89, 0x5f, 0xc0, 0x6e, 0x8e, 0x8e,
481 0x7e, 0x04, 0x46, 0x46, 0x47, 0xda, 0x4f, 0xe0, 0xe8, 0x68, 0x7a, 0x2d, 0xf5, 0x22, 0x90, 0xa0,
482 0xdb, 0xbd, 0xcf, 0x73, 0xce, 0x79, 0x4e, 0xce, 0x0f, 0xc9, 0xe3, 0xc1, 0xb0, 0xdb, 0xf1, 0xdc,
483 0x41, 0xef, 0xba, 0xeb, 0x14, 0xae, 0x86, 0xde, 0xc8, 0x93, 0xf3, 0xbc, 0xb6, 0xbd, 0xe7, 0xf6,
484 0x46, 0x17, 0xe3, 0x76, 0xa1, 0xe3, 0x5d, 0x16, 0x5d, 0xcf, 0xf5, 0x8a, 0xac, 0xa8, 0x3d, 0x3e,
485 0x67, 0x3f, 0xf6, 0x61, 0xaf, 0xcf, 0x66, 0xf5, 0x10, 0xc1, 0x91, 0xbc, 0x85, 0x32, 0x56, 0xaf,
486 0xdb, 0x77, 0xf6, 0x71, 0x8a, 0x82, 0x26, 0xda, 0xf1, 0x4f, 0xde, 0x45, 0xa0, 0x63, 0xa0, 0xa2,
487 0xf6, 0xa7, 0xf4, 0xaf, 0xb0, 0x90, 0xac, 0xdb, 0xa0, 0x37, 0xa4, 0xa9, 0xaf, 0x08, 0x6a, 0x07,
488 0x81, 0x1e, 0x55, 0x1a, 0x18, 0x28, 0x2c, 0x57, 0x1a, 0x36, 0x18, 0x91, 0x6d, 0xb2, 0xd9, 0x4b,
489 0xb6, 0x69, 0x83, 0x29, 0x53, 0x04, 0x16, 0x4e, 0x33, 0x5b, 0x5e, 0xb4, 0x9b, 0x7d, 0xc7, 0xb0,
490 0xc1, 0x52, 0x77, 0x10, 0x98, 0xdc, 0x9a, 0xc0, 0xaf, 0xa9, 0x3e, 0x00, 0x02, 0x23, 0x71, 0x4b,
491 0x2c, 0x08, 0x62, 0xb7, 0x94, 0xe8, 0x65, 0x2c, 0x52, 0xd0, 0x72, 0xb1, 0x5e, 0x4e, 0xf4, 0x0a,
492 0x96, 0xb8, 0xfa, 0x4a, 0xa2, 0x57, 0x71, 0x9a, 0x8a, 0x5a, 0x3e, 0xd6, 0xab, 0x89, 0x5e, 0xc3,
493 0x19, 0x2e, 0xbd, 0x96, 0xe8, 0x75, 0x9c, 0xa5, 0xa2, 0x96, 0x8a, 0xf5, 0xba, 0x7a, 0x80, 0xa0,
494 0xb5, 0xb0, 0x94, 0xb8, 0x76, 0xa9, 0xbf, 0xf3, 0xa5, 0xe2, 0x93, 0x9e, 0x20, 0xa9, 0x35, 0xf0,
495 0xce, 0x7e, 0xdc, 0xfd, 0xff, 0xce, 0x57, 0x84, 0x7b, 0x5f, 0x11, 0x1e, 0x7d, 0x45, 0x60, 0x93,
496 0x2c, 0x24, 0x35, 0xfb, 0xce, 0x7a, 0xc2, 0xf4, 0x8b, 0xf0, 0xf2, 0xe5, 0x39, 0xc8, 0xa7, 0x6c,
497 0x8e, 0x1e, 0xd5, 0xcf, 0x39, 0xaf, 0x24, 0x65, 0x6c, 0xc0, 0xf2, 0x86, 0xcd, 0x32, 0xd6, 0xe1,
498 0xfc, 0x35, 0xc8, 0x4d, 0xc1, 0xd4, 0x58, 0x7e, 0xeb, 0x5b, 0x7e, 0x6e, 0x65, 0x3e, 0x77, 0x75,
499 0xf5, 0x18, 0x65, 0xa3, 0x3e, 0x1e, 0xcc, 0x86, 0xad, 0x8d, 0x3c, 0x0f, 0x46, 0xaf, 0x4c, 0x02,
500 0x22, 0x4c, 0x03, 0x22, 0xbc, 0x06, 0x44, 0x98, 0x05, 0x04, 0xde, 0x02, 0x02, 0xef, 0x01, 0x81,
501 0xdb, 0x90, 0xc0, 0x53, 0x48, 0xe0, 0x39, 0x24, 0xf0, 0x12, 0x12, 0x98, 0x84, 0x04, 0xa6, 0x21,
502 0x81, 0x59, 0x48, 0xe0, 0x23, 0x00, 0x00, 0xff, 0xff, 0xc5, 0x6d, 0x38, 0x81, 0xfb, 0x03, 0x00,
503 0x00,
504 }
505
506 func (this *A) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
507 return UnrecognizedDescription()
508 }
509 func (this *B) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
510 return UnrecognizedDescription()
511 }
512 func (this *D) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
513 return UnrecognizedDescription()
514 }
515 func (this *C) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
516 return UnrecognizedDescription()
517 }
518 func (this *U) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
519 return UnrecognizedDescription()
520 }
521 func (this *UnoM) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
522 return UnrecognizedDescription()
523 }
524 func (this *OldA) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
525 return UnrecognizedDescription()
526 }
527 func (this *OldB) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
528 return UnrecognizedDescription()
529 }
530 func (this *OldC) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
531 return UnrecognizedDescription()
532 }
533 func (this *OldU) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
534 return UnrecognizedDescription()
535 }
536 func (this *OldUnoM) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
537 return UnrecognizedDescription()
538 }
539 func UnrecognizedDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
540 d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
541 var gzipped = []byte{
542
543 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5b, 0x5b, 0x70, 0xdc, 0xe6,
544 0x75, 0x26, 0xf6, 0x42, 0xee, 0x9e, 0x5d, 0x2e, 0x41, 0x90, 0xa6, 0x56, 0x74, 0x4c, 0x51, 0x6b,
545 0x3b, 0xa6, 0xed, 0x98, 0x4a, 0x65, 0x5d, 0xac, 0x55, 0x13, 0x67, 0xb9, 0x5c, 0xd1, 0x54, 0x49,
546 0x2e, 0x83, 0xe5, 0xc6, 0x97, 0x4c, 0x07, 0x03, 0x62, 0x7f, 0x2e, 0x21, 0x61, 0x01, 0x04, 0xc0,
547 0x4a, 0xa6, 0xa6, 0xd3, 0x51, 0xc7, 0xbd, 0x65, 0x7a, 0x4b, 0x9b, 0xce, 0x34, 0x71, 0x1d, 0x37,
548 0x4a, 0xa7, 0x71, 0x9a, 0xde, 0x92, 0x5e, 0xd2, 0x24, 0x7d, 0xe9, 0x4b, 0x5a, 0x3f, 0x75, 0x9c,
549 0xb7, 0x3e, 0xf4, 0xc1, 0x52, 0x3d, 0xd3, 0x9b, 0xdb, 0xa6, 0xad, 0x1e, 0x32, 0xa3, 0x97, 0xce,
550 0x7f, 0xc3, 0x02, 0xd8, 0xa5, 0x00, 0x7a, 0xc6, 0xf6, 0x93, 0x88, 0xf3, 0x9f, 0xef, 0xc3, 0xf9,
551 0xcf, 0x7f, 0xfe, 0x73, 0xce, 0xff, 0x63, 0x05, 0x6f, 0x56, 0x61, 0xb1, 0x6b, 0x59, 0x5d, 0x03,
552 0x9d, 0xb2, 0x1d, 0xcb, 0xb3, 0x76, 0xfb, 0x7b, 0xa7, 0x3a, 0xc8, 0xd5, 0x1c, 0xdd, 0xf6, 0x2c,
553 0x67, 0x99, 0xc8, 0xa4, 0x29, 0xaa, 0xb1, 0xcc, 0x35, 0x2a, 0x9b, 0x30, 0x7d, 0x49, 0x37, 0xd0,
554 0xaa, 0xaf, 0xd8, 0x42, 0x9e, 0xf4, 0x0c, 0x64, 0xf6, 0x74, 0x03, 0x95, 0x85, 0xc5, 0xf4, 0x52,
555 0xe1, 0xf4, 0x23, 0xcb, 0x11, 0xd0, 0x72, 0x18, 0xb1, 0x8d, 0xc5, 0x32, 0x41, 0x54, 0xde, 0xc9,
556 0xc0, 0xcc, 0x88, 0x51, 0x49, 0x82, 0x8c, 0xa9, 0xf6, 0x30, 0xa3, 0xb0, 0x94, 0x97, 0xc9, 0xdf,
557 0x52, 0x19, 0x26, 0x6c, 0x55, 0xbb, 0xaa, 0x76, 0x51, 0x39, 0x45, 0xc4, 0xfc, 0x51, 0x5a, 0x00,
558 0xe8, 0x20, 0x1b, 0x99, 0x1d, 0x64, 0x6a, 0x07, 0xe5, 0xf4, 0x62, 0x7a, 0x29, 0x2f, 0x07, 0x24,
559 0xd2, 0x93, 0x30, 0x6d, 0xf7, 0x77, 0x0d, 0x5d, 0x53, 0x02, 0x6a, 0xb0, 0x98, 0x5e, 0xca, 0xca,
560 0x22, 0x1d, 0x58, 0x1d, 0x28, 0x3f, 0x06, 0x53, 0xd7, 0x91, 0x7a, 0x35, 0xa8, 0x5a, 0x20, 0xaa,
561 0x25, 0x2c, 0x0e, 0x28, 0xd6, 0xa1, 0xd8, 0x43, 0xae, 0xab, 0x76, 0x91, 0xe2, 0x1d, 0xd8, 0xa8,
562 0x9c, 0x21, 0xb3, 0x5f, 0x1c, 0x9a, 0x7d, 0x74, 0xe6, 0x05, 0x86, 0xda, 0x39, 0xb0, 0x91, 0x54,
563 0x83, 0x3c, 0x32, 0xfb, 0x3d, 0xca, 0x90, 0x3d, 0xc4, 0x7f, 0x0d, 0xb3, 0xdf, 0x8b, 0xb2, 0xe4,
564 0x30, 0x8c, 0x51, 0x4c, 0xb8, 0xc8, 0xb9, 0xa6, 0x6b, 0xa8, 0x3c, 0x4e, 0x08, 0x1e, 0x1b, 0x22,
565 0x68, 0xd1, 0xf1, 0x28, 0x07, 0xc7, 0x49, 0x75, 0xc8, 0xa3, 0x97, 0x3d, 0x64, 0xba, 0xba, 0x65,
566 0x96, 0x27, 0x08, 0xc9, 0xa3, 0x23, 0x56, 0x11, 0x19, 0x9d, 0x28, 0xc5, 0x00, 0x27, 0x9d, 0x83,
567 0x09, 0xcb, 0xf6, 0x74, 0xcb, 0x74, 0xcb, 0xb9, 0x45, 0x61, 0xa9, 0x70, 0xfa, 0x23, 0x23, 0x03,
568 0xa1, 0x49, 0x75, 0x64, 0xae, 0x2c, 0xad, 0x83, 0xe8, 0x5a, 0x7d, 0x47, 0x43, 0x8a, 0x66, 0x75,
569 0x90, 0xa2, 0x9b, 0x7b, 0x56, 0x39, 0x4f, 0x08, 0x4e, 0x0c, 0x4f, 0x84, 0x28, 0xd6, 0xad, 0x0e,
570 0x5a, 0x37, 0xf7, 0x2c, 0xb9, 0xe4, 0x86, 0x9e, 0xa5, 0x39, 0x18, 0x77, 0x0f, 0x4c, 0x4f, 0x7d,
571 0xb9, 0x5c, 0x24, 0x11, 0xc2, 0x9e, 0x2a, 0xdf, 0x1b, 0x87, 0xa9, 0x24, 0x21, 0x76, 0x11, 0xb2,
572 0x7b, 0x78, 0x96, 0xe5, 0xd4, 0x51, 0x7c, 0x40, 0x31, 0x61, 0x27, 0x8e, 0xbf, 0x47, 0x27, 0xd6,
573 0xa0, 0x60, 0x22, 0xd7, 0x43, 0x1d, 0x1a, 0x11, 0xe9, 0x84, 0x31, 0x05, 0x14, 0x34, 0x1c, 0x52,
574 0x99, 0xf7, 0x14, 0x52, 0x2f, 0xc0, 0x94, 0x6f, 0x92, 0xe2, 0xa8, 0x66, 0x97, 0xc7, 0xe6, 0xa9,
575 0x38, 0x4b, 0x96, 0x1b, 0x1c, 0x27, 0x63, 0x98, 0x5c, 0x42, 0xa1, 0x67, 0x69, 0x15, 0xc0, 0x32,
576 0x91, 0xb5, 0xa7, 0x74, 0x90, 0x66, 0x94, 0x73, 0x87, 0x78, 0xa9, 0x89, 0x55, 0x86, 0xbc, 0x64,
577 0x51, 0xa9, 0x66, 0x48, 0x17, 0x06, 0xa1, 0x36, 0x71, 0x48, 0xa4, 0x6c, 0xd2, 0x4d, 0x36, 0x14,
578 0x6d, 0x6d, 0x28, 0x39, 0x08, 0xc7, 0x3d, 0xea, 0xb0, 0x99, 0xe5, 0x89, 0x11, 0xcb, 0xb1, 0x33,
579 0x93, 0x19, 0x8c, 0x4e, 0x6c, 0xd2, 0x09, 0x3e, 0x4a, 0x0f, 0x83, 0x2f, 0x50, 0x48, 0x58, 0x01,
580 0xc9, 0x42, 0x45, 0x2e, 0xdc, 0x52, 0x7b, 0x68, 0xfe, 0x06, 0x94, 0xc2, 0xee, 0x91, 0x66, 0x21,
581 0xeb, 0x7a, 0xaa, 0xe3, 0x91, 0x28, 0xcc, 0xca, 0xf4, 0x41, 0x12, 0x21, 0x8d, 0xcc, 0x0e, 0xc9,
582 0x72, 0x59, 0x19, 0xff, 0x29, 0x7d, 0x6a, 0x30, 0xe1, 0x34, 0x99, 0xf0, 0x47, 0x87, 0x57, 0x34,
583 0xc4, 0x1c, 0x9d, 0xf7, 0xfc, 0x79, 0x98, 0x0c, 0x4d, 0x20, 0xe9, 0xab, 0x2b, 0x3f, 0x03, 0x0f,
584 0x8c, 0xa4, 0x96, 0x5e, 0x80, 0xd9, 0xbe, 0xa9, 0x9b, 0x1e, 0x72, 0x6c, 0x07, 0xe1, 0x88, 0xa5,
585 0xaf, 0x2a, 0xff, 0xcb, 0xc4, 0x21, 0x31, 0xd7, 0x0e, 0x6a, 0x53, 0x16, 0x79, 0xa6, 0x3f, 0x2c,
586 0x7c, 0x22, 0x9f, 0xfb, 0xd7, 0x09, 0xf1, 0xe6, 0xcd, 0x9b, 0x37, 0x53, 0x95, 0x2f, 0x8d, 0xc3,
587 0xec, 0xa8, 0x3d, 0x33, 0x72, 0xfb, 0xce, 0xc1, 0xb8, 0xd9, 0xef, 0xed, 0x22, 0x87, 0x38, 0x29,
588 0x2b, 0xb3, 0x27, 0xa9, 0x06, 0x59, 0x43, 0xdd, 0x45, 0x46, 0x39, 0xb3, 0x28, 0x2c, 0x95, 0x4e,
589 0x3f, 0x99, 0x68, 0x57, 0x2e, 0x6f, 0x60, 0x88, 0x4c, 0x91, 0xd2, 0x27, 0x21, 0xc3, 0x52, 0x34,
590 0x66, 0x78, 0x22, 0x19, 0x03, 0xde, 0x4b, 0x32, 0xc1, 0x49, 0x0f, 0x42, 0x1e, 0xff, 0x4b, 0x63,
591 0x63, 0x9c, 0xd8, 0x9c, 0xc3, 0x02, 0x1c, 0x17, 0xd2, 0x3c, 0xe4, 0xc8, 0x36, 0xe9, 0x20, 0x5e,
592 0xda, 0xfc, 0x67, 0x1c, 0x58, 0x1d, 0xb4, 0xa7, 0xf6, 0x0d, 0x4f, 0xb9, 0xa6, 0x1a, 0x7d, 0x44,
593 0x02, 0x3e, 0x2f, 0x17, 0x99, 0xf0, 0x33, 0x58, 0x26, 0x9d, 0x80, 0x02, 0xdd, 0x55, 0xba, 0xd9,
594 0x41, 0x2f, 0x93, 0xec, 0x99, 0x95, 0xe9, 0x46, 0x5b, 0xc7, 0x12, 0xfc, 0xfa, 0x2b, 0xae, 0x65,
595 0xf2, 0xd0, 0x24, 0xaf, 0xc0, 0x02, 0xf2, 0xfa, 0xf3, 0xd1, 0xc4, 0xfd, 0xd0, 0xe8, 0xe9, 0x45,
596 0x63, 0xaa, 0xf2, 0x9d, 0x14, 0x64, 0x48, 0xbe, 0x98, 0x82, 0xc2, 0xce, 0x8b, 0xdb, 0x0d, 0x65,
597 0xb5, 0xd9, 0x5e, 0xd9, 0x68, 0x88, 0x82, 0x54, 0x02, 0x20, 0x82, 0x4b, 0x1b, 0xcd, 0xda, 0x8e,
598 0x98, 0xf2, 0x9f, 0xd7, 0xb7, 0x76, 0xce, 0x9d, 0x11, 0xd3, 0x3e, 0xa0, 0x4d, 0x05, 0x99, 0xa0,
599 0xc2, 0xd3, 0xa7, 0xc5, 0xac, 0x24, 0x42, 0x91, 0x12, 0xac, 0xbf, 0xd0, 0x58, 0x3d, 0x77, 0x46,
600 0x1c, 0x0f, 0x4b, 0x9e, 0x3e, 0x2d, 0x4e, 0x48, 0x93, 0x90, 0x27, 0x92, 0x95, 0x66, 0x73, 0x43,
601 0xcc, 0xf9, 0x9c, 0xad, 0x1d, 0x79, 0x7d, 0x6b, 0x4d, 0xcc, 0xfb, 0x9c, 0x6b, 0x72, 0xb3, 0xbd,
602 0x2d, 0x82, 0xcf, 0xb0, 0xd9, 0x68, 0xb5, 0x6a, 0x6b, 0x0d, 0xb1, 0xe0, 0x6b, 0xac, 0xbc, 0xb8,
603 0xd3, 0x68, 0x89, 0xc5, 0x90, 0x59, 0x4f, 0x9f, 0x16, 0x27, 0xfd, 0x57, 0x34, 0xb6, 0xda, 0x9b,
604 0x62, 0x49, 0x9a, 0x86, 0x49, 0xfa, 0x0a, 0x6e, 0xc4, 0x54, 0x44, 0x74, 0xee, 0x8c, 0x28, 0x0e,
605 0x0c, 0xa1, 0x2c, 0xd3, 0x21, 0xc1, 0xb9, 0x33, 0xa2, 0x54, 0xa9, 0x43, 0x96, 0x44, 0x97, 0x24,
606 0x41, 0x69, 0xa3, 0xb6, 0xd2, 0xd8, 0x50, 0x9a, 0xdb, 0x3b, 0xeb, 0xcd, 0xad, 0xda, 0x86, 0x28,
607 0x0c, 0x64, 0x72, 0xe3, 0xd3, 0xed, 0x75, 0xb9, 0xb1, 0x2a, 0xa6, 0x82, 0xb2, 0xed, 0x46, 0x6d,
608 0xa7, 0xb1, 0x2a, 0xa6, 0x2b, 0x1a, 0xcc, 0x8e, 0xca, 0x93, 0x23, 0x77, 0x46, 0x60, 0x89, 0x53,
609 0x87, 0x2c, 0x31, 0xe1, 0x1a, 0x5a, 0xe2, 0x7f, 0x4e, 0xc1, 0xcc, 0x88, 0x5a, 0x31, 0xf2, 0x25,
610 0xcf, 0x42, 0x96, 0x86, 0x28, 0xad, 0x9e, 0x8f, 0x8f, 0x2c, 0x3a, 0x24, 0x60, 0x87, 0x2a, 0x28,
611 0xc1, 0x05, 0x3b, 0x88, 0xf4, 0x21, 0x1d, 0x04, 0xa6, 0x18, 0xca, 0xe9, 0x3f, 0x3d, 0x94, 0xd3,
612 0x69, 0xd9, 0x3b, 0x97, 0xa4, 0xec, 0x11, 0xd9, 0xd1, 0x72, 0x7b, 0x76, 0x44, 0x6e, 0xbf, 0x08,
613 0xd3, 0x43, 0x44, 0x89, 0x73, 0xec, 0x2b, 0x02, 0x94, 0x0f, 0x73, 0x4e, 0x4c, 0xa6, 0x4b, 0x85,
614 0x32, 0xdd, 0xc5, 0xa8, 0x07, 0x4f, 0x1e, 0xbe, 0x08, 0x43, 0x6b, 0xfd, 0x86, 0x00, 0x73, 0xa3,
615 0x3b, 0xc5, 0x91, 0x36, 0x7c, 0x12, 0xc6, 0x7b, 0xc8, 0xdb, 0xb7, 0x78, 0xb7, 0xf4, 0xd1, 0x11,
616 0x35, 0x18, 0x0f, 0x47, 0x17, 0x9b, 0xa1, 0x82, 0x45, 0x3c, 0x7d, 0x58, 0xbb, 0x47, 0xad, 0x19,
617 0xb2, 0xf4, 0xf3, 0x29, 0x78, 0x60, 0x24, 0xf9, 0x48, 0x43, 0x1f, 0x02, 0xd0, 0x4d, 0xbb, 0xef,
618 0xd1, 0x8e, 0x88, 0x26, 0xd8, 0x3c, 0x91, 0x90, 0xe4, 0x85, 0x93, 0x67, 0xdf, 0xf3, 0xc7, 0xd3,
619 0x64, 0x1c, 0xa8, 0x88, 0x28, 0x3c, 0x33, 0x30, 0x34, 0x43, 0x0c, 0x5d, 0x38, 0x64, 0xa6, 0x43,
620 0x81, 0xf9, 0x71, 0x10, 0x35, 0x43, 0x47, 0xa6, 0xa7, 0xb8, 0x9e, 0x83, 0xd4, 0x9e, 0x6e, 0x76,
621 0x49, 0x05, 0xc9, 0x55, 0xb3, 0x7b, 0xaa, 0xe1, 0x22, 0x79, 0x8a, 0x0e, 0xb7, 0xf8, 0x28, 0x46,
622 0x90, 0x00, 0x72, 0x02, 0x88, 0xf1, 0x10, 0x82, 0x0e, 0xfb, 0x88, 0xca, 0xaf, 0xe6, 0xa1, 0x10,
623 0xe8, 0xab, 0xa5, 0x93, 0x50, 0xbc, 0xa2, 0x5e, 0x53, 0x15, 0x7e, 0x56, 0xa2, 0x9e, 0x28, 0x60,
624 0xd9, 0x36, 0x3b, 0x2f, 0x7d, 0x1c, 0x66, 0x89, 0x8a, 0xd5, 0xf7, 0x90, 0xa3, 0x68, 0x86, 0xea,
625 0xba, 0xc4, 0x69, 0x39, 0xa2, 0x2a, 0xe1, 0xb1, 0x26, 0x1e, 0xaa, 0xf3, 0x11, 0xe9, 0x2c, 0xcc,
626 0x10, 0x44, 0xaf, 0x6f, 0x78, 0xba, 0x6d, 0x20, 0x05, 0x9f, 0xde, 0x5c, 0x52, 0x49, 0x7c, 0xcb,
627 0xa6, 0xb1, 0xc6, 0x26, 0x53, 0xc0, 0x16, 0xb9, 0xd2, 0x2a, 0x3c, 0x44, 0x60, 0x5d, 0x64, 0x22,
628 0x47, 0xf5, 0x90, 0x82, 0x3e, 0xd7, 0x57, 0x0d, 0x57, 0x51, 0xcd, 0x8e, 0xb2, 0xaf, 0xba, 0xfb,
629 0xe5, 0x59, 0x4c, 0xb0, 0x92, 0x2a, 0x0b, 0xf2, 0x71, 0xac, 0xb8, 0xc6, 0xf4, 0x1a, 0x44, 0xad,
630 0x66, 0x76, 0x9e, 0x53, 0xdd, 0x7d, 0xa9, 0x0a, 0x73, 0x84, 0xc5, 0xf5, 0x1c, 0xdd, 0xec, 0x2a,
631 0xda, 0x3e, 0xd2, 0xae, 0x2a, 0x7d, 0x6f, 0xef, 0x99, 0xf2, 0x83, 0xc1, 0xf7, 0x13, 0x0b, 0x5b,
632 0x44, 0xa7, 0x8e, 0x55, 0xda, 0xde, 0xde, 0x33, 0x52, 0x0b, 0x8a, 0x78, 0x31, 0x7a, 0xfa, 0x0d,
633 0xa4, 0xec, 0x59, 0x0e, 0x29, 0x8d, 0xa5, 0x11, 0xa9, 0x29, 0xe0, 0xc1, 0xe5, 0x26, 0x03, 0x6c,
634 0x5a, 0x1d, 0x54, 0xcd, 0xb6, 0xb6, 0x1b, 0x8d, 0x55, 0xb9, 0xc0, 0x59, 0x2e, 0x59, 0x0e, 0x0e,
635 0xa8, 0xae, 0xe5, 0x3b, 0xb8, 0x40, 0x03, 0xaa, 0x6b, 0x71, 0xf7, 0x9e, 0x85, 0x19, 0x4d, 0xa3,
636 0x73, 0xd6, 0x35, 0x85, 0x9d, 0xb1, 0xdc, 0xb2, 0x18, 0x72, 0x96, 0xa6, 0xad, 0x51, 0x05, 0x16,
637 0xe3, 0xae, 0x74, 0x01, 0x1e, 0x18, 0x38, 0x2b, 0x08, 0x9c, 0x1e, 0x9a, 0x65, 0x14, 0x7a, 0x16,
638 0x66, 0xec, 0x83, 0x61, 0xa0, 0x14, 0x7a, 0xa3, 0x7d, 0x10, 0x85, 0x9d, 0x87, 0x59, 0x7b, 0xdf,
639 0x1e, 0xc6, 0x3d, 0x11, 0xc4, 0x49, 0xf6, 0xbe, 0x1d, 0x05, 0x3e, 0x4a, 0x0e, 0xdc, 0x0e, 0xd2,
640 0x54, 0x0f, 0x75, 0xca, 0xc7, 0x82, 0xea, 0x81, 0x01, 0xe9, 0x14, 0x88, 0x9a, 0xa6, 0x20, 0x53,
641 0xdd, 0x35, 0x90, 0xa2, 0x3a, 0xc8, 0x54, 0xdd, 0xf2, 0x89, 0xa0, 0x72, 0x49, 0xd3, 0x1a, 0x64,
642 0xb4, 0x46, 0x06, 0xa5, 0x27, 0x60, 0xda, 0xda, 0xbd, 0xa2, 0xd1, 0x90, 0x54, 0x6c, 0x07, 0xed,
643 0xe9, 0x2f, 0x97, 0x1f, 0x21, 0xfe, 0x9d, 0xc2, 0x03, 0x24, 0x20, 0xb7, 0x89, 0x58, 0x7a, 0x1c,
644 0x44, 0xcd, 0xdd, 0x57, 0x1d, 0x9b, 0xe4, 0x64, 0xd7, 0x56, 0x35, 0x54, 0x7e, 0x94, 0xaa, 0x52,
645 0xf9, 0x16, 0x17, 0xe3, 0x2d, 0xe1, 0x5e, 0xd7, 0xf7, 0x3c, 0xce, 0xf8, 0x18, 0xdd, 0x12, 0x44,
646 0xc6, 0xd8, 0x96, 0x40, 0xc4, 0xae, 0x08, 0xbd, 0x78, 0x89, 0xa8, 0x95, 0xec, 0x7d, 0x3b, 0xf8,
647 0xde, 0x87, 0x61, 0x12, 0x6b, 0x0e, 0x5e, 0xfa, 0x38, 0x6d, 0xc8, 0xec, 0xfd, 0xc0, 0x1b, 0xcf,
648 0xc0, 0x1c, 0x56, 0xea, 0x21, 0x4f, 0xed, 0xa8, 0x9e, 0x1a, 0xd0, 0xfe, 0x18, 0xd1, 0xc6, 0x7e,
649 0xdf, 0x64, 0x83, 0x21, 0x3b, 0x9d, 0xfe, 0xee, 0x81, 0x1f, 0x59, 0x4f, 0x51, 0x3b, 0xb1, 0x8c,
650 0xc7, 0xd6, 0xfb, 0xd6, 0x74, 0x57, 0xaa, 0x50, 0x0c, 0x06, 0xbe, 0x94, 0x07, 0x1a, 0xfa, 0xa2,
651 0x80, 0xbb, 0xa0, 0x7a, 0x73, 0x15, 0xf7, 0x2f, 0x2f, 0x35, 0xc4, 0x14, 0xee, 0xa3, 0x36, 0xd6,
652 0x77, 0x1a, 0x8a, 0xdc, 0xde, 0xda, 0x59, 0xdf, 0x6c, 0x88, 0xe9, 0x60, 0xc3, 0xfe, 0x83, 0x14,
653 0x94, 0xc2, 0x67, 0x2f, 0xe9, 0x27, 0xe1, 0x18, 0xbf, 0x28, 0x71, 0x91, 0xa7, 0x5c, 0xd7, 0x1d,
654 0xb2, 0x17, 0x7b, 0x2a, 0xad, 0x8b, 0x7e, 0x34, 0xcc, 0x32, 0xad, 0x16, 0xf2, 0x9e, 0xd7, 0x1d,
655 0xbc, 0xd3, 0x7a, 0xaa, 0x27, 0x6d, 0xc0, 0x09, 0xd3, 0x52, 0x5c, 0x4f, 0x35, 0x3b, 0xaa, 0xd3,
656 0x51, 0x06, 0x57, 0x54, 0x8a, 0xaa, 0x69, 0xc8, 0x75, 0x2d, 0x5a, 0x03, 0x7d, 0x96, 0x8f, 0x98,
657 0x56, 0x8b, 0x29, 0x0f, 0x8a, 0x43, 0x8d, 0xa9, 0x46, 0x22, 0x37, 0x7d, 0x58, 0xe4, 0x3e, 0x08,
658 0xf9, 0x9e, 0x6a, 0x2b, 0xc8, 0xf4, 0x9c, 0x03, 0xd2, 0x71, 0xe7, 0xe4, 0x5c, 0x4f, 0xb5, 0x1b,
659 0xf8, 0xf9, 0x83, 0x39, 0xf8, 0xfc, 0x53, 0x1a, 0x8a, 0xc1, 0xae, 0x1b, 0x1f, 0x62, 0x34, 0x52,
660 0xa0, 0x04, 0x92, 0xc2, 0x1e, 0xbe, 0x6f, 0x8f, 0xbe, 0x5c, 0xc7, 0x95, 0xab, 0x3a, 0x4e, 0x7b,
661 0x61, 0x99, 0x22, 0x71, 0xd7, 0x80, 0x43, 0x0b, 0xd1, 0xde, 0x23, 0x27, 0xb3, 0x27, 0x69, 0x0d,
662 0xc6, 0xaf, 0xb8, 0x84, 0x7b, 0x9c, 0x70, 0x3f, 0x72, 0x7f, 0xee, 0xcb, 0x2d, 0x42, 0x9e, 0xbf,
663 0xdc, 0x52, 0xb6, 0x9a, 0xf2, 0x66, 0x6d, 0x43, 0x66, 0x70, 0xe9, 0x38, 0x64, 0x0c, 0xf5, 0xc6,
664 0x41, 0xb8, 0xc6, 0x11, 0x51, 0x52, 0xc7, 0x1f, 0x87, 0xcc, 0x75, 0xa4, 0x5e, 0x0d, 0x57, 0x16,
665 0x22, 0x7a, 0x1f, 0x43, 0xff, 0x14, 0x64, 0x89, 0xbf, 0x24, 0x00, 0xe6, 0x31, 0x71, 0x4c, 0xca,
666 0x41, 0xa6, 0xde, 0x94, 0x71, 0xf8, 0x8b, 0x50, 0xa4, 0x52, 0x65, 0x7b, 0xbd, 0x51, 0x6f, 0x88,
667 0xa9, 0xca, 0x59, 0x18, 0xa7, 0x4e, 0xc0, 0x5b, 0xc3, 0x77, 0x83, 0x38, 0xc6, 0x1e, 0x19, 0x87,
668 0xc0, 0x47, 0xdb, 0x9b, 0x2b, 0x0d, 0x59, 0x4c, 0x05, 0x97, 0xd7, 0x85, 0x62, 0xb0, 0xe1, 0xfe,
669 0x60, 0x62, 0xea, 0xfb, 0x02, 0x14, 0x02, 0x0d, 0x34, 0xee, 0x7c, 0x54, 0xc3, 0xb0, 0xae, 0x2b,
670 0xaa, 0xa1, 0xab, 0x2e, 0x0b, 0x0a, 0x20, 0xa2, 0x1a, 0x96, 0x24, 0x5d, 0xb4, 0x0f, 0xc4, 0xf8,
671 0xd7, 0x05, 0x10, 0xa3, 0xbd, 0x6b, 0xc4, 0x40, 0xe1, 0x43, 0x35, 0xf0, 0x35, 0x01, 0x4a, 0xe1,
672 0x86, 0x35, 0x62, 0xde, 0xc9, 0x0f, 0xd5, 0xbc, 0xb7, 0x53, 0x30, 0x19, 0x6a, 0x53, 0x93, 0x5a,
673 0xf7, 0x39, 0x98, 0xd6, 0x3b, 0xa8, 0x67, 0x5b, 0x1e, 0x32, 0xb5, 0x03, 0xc5, 0x40, 0xd7, 0x90,
674 0x51, 0xae, 0x90, 0x44, 0x71, 0xea, 0xfe, 0x8d, 0xf0, 0xf2, 0xfa, 0x00, 0xb7, 0x81, 0x61, 0xd5,
675 0x99, 0xf5, 0xd5, 0xc6, 0xe6, 0x76, 0x73, 0xa7, 0xb1, 0x55, 0x7f, 0x51, 0x69, 0x6f, 0xfd, 0xd4,
676 0x56, 0xf3, 0xf9, 0x2d, 0x59, 0xd4, 0x23, 0x6a, 0xef, 0xe3, 0x56, 0xdf, 0x06, 0x31, 0x6a, 0x94,
677 0x74, 0x0c, 0x46, 0x99, 0x25, 0x8e, 0x49, 0x33, 0x30, 0xb5, 0xd5, 0x54, 0x5a, 0xeb, 0xab, 0x0d,
678 0xa5, 0x71, 0xe9, 0x52, 0xa3, 0xbe, 0xd3, 0xa2, 0x57, 0x1b, 0xbe, 0xf6, 0x4e, 0x78, 0x53, 0xbf,
679 0x9a, 0x86, 0x99, 0x11, 0x96, 0x48, 0x35, 0x76, 0x28, 0xa1, 0xe7, 0xa4, 0xa7, 0x92, 0x58, 0xbf,
680 0x8c, 0xbb, 0x82, 0x6d, 0xd5, 0xf1, 0xd8, 0x19, 0xe6, 0x71, 0xc0, 0x5e, 0x32, 0x3d, 0x7d, 0x4f,
681 0x47, 0x0e, 0xbb, 0x09, 0xa2, 0x27, 0x95, 0xa9, 0x81, 0x9c, 0x5e, 0x06, 0x7d, 0x0c, 0x24, 0xdb,
682 0x72, 0x75, 0x4f, 0xbf, 0x86, 0x14, 0xdd, 0xe4, 0xd7, 0x46, 0xf8, 0xe4, 0x92, 0x91, 0x45, 0x3e,
683 0xb2, 0x6e, 0x7a, 0xbe, 0xb6, 0x89, 0xba, 0x6a, 0x44, 0x1b, 0x27, 0xf0, 0xb4, 0x2c, 0xf2, 0x11,
684 0x5f, 0xfb, 0x24, 0x14, 0x3b, 0x56, 0x1f, 0xb7, 0x73, 0x54, 0x0f, 0xd7, 0x0b, 0x41, 0x2e, 0x50,
685 0x99, 0xaf, 0xc2, 0x1a, 0xf5, 0xc1, 0x7d, 0x55, 0x51, 0x2e, 0x50, 0x19, 0x55, 0x79, 0x0c, 0xa6,
686 0xd4, 0x6e, 0xd7, 0xc1, 0xe4, 0x9c, 0x88, 0x1e, 0x3d, 0x4a, 0xbe, 0x98, 0x28, 0xce, 0x5f, 0x86,
687 0x1c, 0xf7, 0x03, 0x2e, 0xc9, 0xd8, 0x13, 0x8a, 0x4d, 0xcf, 0xd3, 0xa9, 0xa5, 0xbc, 0x9c, 0x33,
688 0xf9, 0xe0, 0x49, 0x28, 0xea, 0xae, 0x32, 0xb8, 0x7e, 0x4f, 0x2d, 0xa6, 0x96, 0x72, 0x72, 0x41,
689 0x77, 0xfd, 0xab, 0xcb, 0xca, 0x1b, 0x29, 0x28, 0x85, 0x3f, 0x1f, 0x48, 0xab, 0x90, 0x33, 0x2c,
690 0x4d, 0x25, 0xa1, 0x45, 0xbf, 0x5d, 0x2d, 0xc5, 0x7c, 0x71, 0x58, 0xde, 0x60, 0xfa, 0xb2, 0x8f,
691 0x9c, 0xff, 0x07, 0x01, 0x72, 0x5c, 0x2c, 0xcd, 0x41, 0xc6, 0x56, 0xbd, 0x7d, 0x42, 0x97, 0x5d,
692 0x49, 0x89, 0x82, 0x4c, 0x9e, 0xb1, 0xdc, 0xb5, 0x55, 0x93, 0x84, 0x00, 0x93, 0xe3, 0x67, 0xbc,
693 0xae, 0x06, 0x52, 0x3b, 0xe4, 0x5c, 0x63, 0xf5, 0x7a, 0xc8, 0xf4, 0x5c, 0xbe, 0xae, 0x4c, 0x5e,
694 0x67, 0x62, 0xe9, 0x49, 0x98, 0xf6, 0x1c, 0x55, 0x37, 0x42, 0xba, 0x19, 0xa2, 0x2b, 0xf2, 0x01,
695 0x5f, 0xb9, 0x0a, 0xc7, 0x39, 0x6f, 0x07, 0x79, 0xaa, 0xb6, 0x8f, 0x3a, 0x03, 0xd0, 0x38, 0xb9,
696 0xbf, 0x38, 0xc6, 0x14, 0x56, 0xd9, 0x38, 0xc7, 0x56, 0x7e, 0x28, 0xc0, 0x34, 0x3f, 0x89, 0x75,
697 0x7c, 0x67, 0x6d, 0x02, 0xa8, 0xa6, 0x69, 0x79, 0x41, 0x77, 0x0d, 0x87, 0xf2, 0x10, 0x6e, 0xb9,
698 0xe6, 0x83, 0xe4, 0x00, 0xc1, 0x7c, 0x0f, 0x60, 0x30, 0x72, 0xa8, 0xdb, 0x4e, 0x40, 0x81, 0x7d,
699 0x1b, 0x22, 0x1f, 0x18, 0xe9, 0xd9, 0x1d, 0xa8, 0x08, 0x1f, 0xd9, 0xa4, 0x59, 0xc8, 0xee, 0xa2,
700 0xae, 0x6e, 0xb2, 0x1b, 0x5f, 0xfa, 0xc0, 0x6f, 0x58, 0x32, 0xfe, 0x0d, 0xcb, 0xca, 0x67, 0x61,
701 0x46, 0xb3, 0x7a, 0x51, 0x73, 0x57, 0xc4, 0xc8, 0xfd, 0x81, 0xfb, 0x9c, 0xf0, 0x12, 0x0c, 0x5a,
702 0xcc, 0x1f, 0x0b, 0xc2, 0xd7, 0x52, 0xe9, 0xb5, 0xed, 0x95, 0x6f, 0xa6, 0xe6, 0xd7, 0x28, 0x74,
703 0x9b, 0xcf, 0x54, 0x46, 0x7b, 0x06, 0xd2, 0xb0, 0xf5, 0xf0, 0xf5, 0x27, 0xe1, 0xa9, 0xae, 0xee,
704 0xed, 0xf7, 0x77, 0x97, 0x35, 0xab, 0x77, 0xaa, 0x6b, 0x75, 0xad, 0xc1, 0x37, 0x55, 0xfc, 0x44,
705 0x1e, 0xc8, 0x5f, 0xec, 0xbb, 0x6a, 0xde, 0x97, 0xce, 0xc7, 0x7e, 0x84, 0xad, 0x6e, 0xc1, 0x0c,
706 0x53, 0x56, 0xc8, 0x87, 0x1d, 0x7a, 0x3c, 0x91, 0xee, 0x7b, 0x39, 0x56, 0xfe, 0xf6, 0x3b, 0xa4,
707 0x5c, 0xcb, 0xd3, 0x0c, 0x8a, 0xc7, 0xe8, 0x09, 0xa6, 0x2a, 0xc3, 0x03, 0x21, 0x3e, 0xba, 0x35,
708 0x91, 0x13, 0xc3, 0xf8, 0x03, 0xc6, 0x38, 0x13, 0x60, 0x6c, 0x31, 0x68, 0xb5, 0x0e, 0x93, 0x47,
709 0xe1, 0xfa, 0x3b, 0xc6, 0x55, 0x44, 0x41, 0x92, 0x35, 0x98, 0x22, 0x24, 0x5a, 0xdf, 0xf5, 0xac,
710 0x1e, 0xc9, 0x7b, 0xf7, 0xa7, 0xf9, 0xfb, 0x77, 0xe8, 0x5e, 0x29, 0x61, 0x58, 0xdd, 0x47, 0x55,
711 0xab, 0x40, 0xbe, 0x65, 0x75, 0x90, 0x66, 0xc4, 0x30, 0xbc, 0xc9, 0x0c, 0xf1, 0xf5, 0xab, 0x9f,
712 0x81, 0x59, 0xfc, 0x37, 0x49, 0x4b, 0x41, 0x4b, 0xe2, 0x6f, 0xd2, 0xca, 0x3f, 0x7c, 0x85, 0x6e,
713 0xc7, 0x19, 0x9f, 0x20, 0x60, 0x53, 0x60, 0x15, 0xbb, 0xc8, 0xf3, 0x90, 0xe3, 0x2a, 0xaa, 0x31,
714 0xca, 0xbc, 0xc0, 0x55, 0x44, 0xf9, 0xcb, 0xef, 0x86, 0x57, 0x71, 0x8d, 0x22, 0x6b, 0x86, 0x51,
715 0x6d, 0xc3, 0xb1, 0x11, 0x51, 0x91, 0x80, 0xf3, 0x55, 0xc6, 0x39, 0x3b, 0x14, 0x19, 0x98, 0x76,
716 0x1b, 0xb8, 0xdc, 0x5f, 0xcb, 0x04, 0x9c, 0xbf, 0xcb, 0x38, 0x25, 0x86, 0xe5, 0x4b, 0x8a, 0x19,
717 0x2f, 0xc3, 0xf4, 0x35, 0xe4, 0xec, 0x5a, 0x2e, 0xbb, 0xfe, 0x49, 0x40, 0xf7, 0x1a, 0xa3, 0x9b,
718 0x62, 0x40, 0x72, 0x1f, 0x84, 0xb9, 0x2e, 0x40, 0x6e, 0x4f, 0xd5, 0x50, 0x02, 0x8a, 0xaf, 0x30,
719 0x8a, 0x09, 0xac, 0x8f, 0xa1, 0x35, 0x28, 0x76, 0x2d, 0x56, 0x99, 0xe2, 0xe1, 0xaf, 0x33, 0x78,
720 0x81, 0x63, 0x18, 0x85, 0x6d, 0xd9, 0x7d, 0x03, 0x97, 0xad, 0x78, 0x8a, 0xdf, 0xe3, 0x14, 0x1c,
721 0xc3, 0x28, 0x8e, 0xe0, 0xd6, 0xaf, 0x72, 0x0a, 0x37, 0xe0, 0xcf, 0x67, 0xa1, 0x60, 0x99, 0xc6,
722 0x81, 0x65, 0x26, 0x31, 0xe2, 0x16, 0x63, 0x00, 0x06, 0xc1, 0x04, 0x17, 0x21, 0x9f, 0x74, 0x21,
723 0xfe, 0xe0, 0x5d, 0xbe, 0x3d, 0xf8, 0x0a, 0xac, 0xc1, 0x14, 0x4f, 0x50, 0xba, 0x65, 0x26, 0xa0,
724 0xf8, 0x3a, 0xa3, 0x28, 0x05, 0x60, 0x6c, 0x1a, 0x1e, 0x72, 0xbd, 0x2e, 0x4a, 0x42, 0xf2, 0x06,
725 0x9f, 0x06, 0x83, 0x30, 0x57, 0xee, 0x22, 0x53, 0xdb, 0x4f, 0xc6, 0xf0, 0x0d, 0xee, 0x4a, 0x8e,
726 0xc1, 0x14, 0x75, 0x98, 0xec, 0xa9, 0x8e, 0xbb, 0xaf, 0x1a, 0x89, 0x96, 0xe3, 0x0f, 0x19, 0x47,
727 0xd1, 0x07, 0x31, 0x8f, 0xf4, 0xcd, 0xa3, 0xd0, 0x7c, 0x93, 0x7b, 0x24, 0x00, 0x63, 0x5b, 0xcf,
728 0xf5, 0xc8, 0x5d, 0xd9, 0x51, 0xd8, 0xfe, 0x88, 0x6f, 0x3d, 0x8a, 0xdd, 0x0c, 0x32, 0x5e, 0x84,
729 0xbc, 0xab, 0xdf, 0x48, 0x44, 0xf3, 0xc7, 0x7c, 0xa5, 0x09, 0x00, 0x83, 0x5f, 0x84, 0xe3, 0x23,
730 0xcb, 0x44, 0x02, 0xb2, 0x3f, 0x61, 0x64, 0x73, 0x23, 0x4a, 0x05, 0x4b, 0x09, 0x47, 0xa5, 0xfc,
731 0x53, 0x9e, 0x12, 0x50, 0x84, 0x6b, 0x1b, 0x9f, 0x15, 0x5c, 0x75, 0xef, 0x68, 0x5e, 0xfb, 0x33,
732 0xee, 0x35, 0x8a, 0x0d, 0x79, 0x6d, 0x07, 0xe6, 0x18, 0xe3, 0xd1, 0xd6, 0xf5, 0x5b, 0x3c, 0xb1,
733 0x52, 0x74, 0x3b, 0xbc, 0xba, 0x9f, 0x85, 0x79, 0xdf, 0x9d, 0xbc, 0x29, 0x75, 0x95, 0x9e, 0x6a,
734 0x27, 0x60, 0xfe, 0x36, 0x63, 0xe6, 0x19, 0xdf, 0xef, 0x6a, 0xdd, 0x4d, 0xd5, 0xc6, 0xe4, 0x2f,
735 0x40, 0x99, 0x93, 0xf7, 0x4d, 0x07, 0x69, 0x56, 0xd7, 0xd4, 0x6f, 0xa0, 0x4e, 0x02, 0xea, 0x3f,
736 0x8f, 0x2c, 0x55, 0x3b, 0x00, 0xc7, 0xcc, 0xeb, 0x20, 0xfa, 0xbd, 0x8a, 0xa2, 0xf7, 0x6c, 0xcb,
737 0xf1, 0x62, 0x18, 0xff, 0x82, 0xaf, 0x94, 0x8f, 0x5b, 0x27, 0xb0, 0x6a, 0x03, 0x4a, 0xe4, 0x31,
738 0x69, 0x48, 0xfe, 0x25, 0x23, 0x9a, 0x1c, 0xa0, 0x58, 0xe2, 0xd0, 0xac, 0x9e, 0xad, 0x3a, 0x49,
739 0xf2, 0xdf, 0x5f, 0xf1, 0xc4, 0xc1, 0x20, 0x2c, 0x71, 0x78, 0x07, 0x36, 0xc2, 0xd5, 0x3e, 0x01,
740 0xc3, 0x77, 0x78, 0xe2, 0xe0, 0x18, 0x46, 0xc1, 0x1b, 0x86, 0x04, 0x14, 0x7f, 0xcd, 0x29, 0x38,
741 0x06, 0x53, 0x7c, 0x7a, 0x50, 0x68, 0x1d, 0xd4, 0xd5, 0x5d, 0xcf, 0xa1, 0xad, 0xf0, 0xfd, 0xa9,
742 0xbe, 0xfb, 0x6e, 0xb8, 0x09, 0x93, 0x03, 0x50, 0x9c, 0x89, 0xd8, 0x15, 0x2a, 0x39, 0x29, 0xc5,
743 0x1b, 0xf6, 0x3d, 0x9e, 0x89, 0x02, 0x30, 0x6c, 0x5b, 0xa0, 0x43, 0xc4, 0x6e, 0xd7, 0xf0, 0xf9,
744 0x20, 0x01, 0xdd, 0xf7, 0x23, 0xc6, 0xb5, 0x38, 0x16, 0x73, 0x06, 0xfa, 0x9f, 0xbe, 0x79, 0x15,
745 0x1d, 0x24, 0x8a, 0xce, 0xbf, 0x89, 0xf4, 0x3f, 0x6d, 0x8a, 0xa4, 0x39, 0x64, 0x2a, 0xd2, 0x4f,
746 0x49, 0x71, 0xbf, 0x02, 0x2a, 0xff, 0xdc, 0x5d, 0x36, 0xdf, 0x70, 0x3b, 0x55, 0xdd, 0xc0, 0x41,
747 0x1e, 0x6e, 0x7a, 0xe2, 0xc9, 0x5e, 0xb9, 0xeb, 0xc7, 0x79, 0xa8, 0xe7, 0xa9, 0x5e, 0x82, 0xc9,
748 0x50, 0xc3, 0x13, 0x4f, 0xf5, 0xf3, 0x8c, 0xaa, 0x18, 0xec, 0x77, 0xaa, 0x67, 0x21, 0x83, 0x9b,
749 0x97, 0x78, 0xf8, 0x2f, 0x30, 0x38, 0x51, 0xaf, 0x7e, 0x02, 0x72, 0xbc, 0x69, 0x89, 0x87, 0xfe,
750 0x22, 0x83, 0xfa, 0x10, 0x0c, 0xe7, 0x0d, 0x4b, 0x3c, 0xfc, 0x97, 0x38, 0x9c, 0x43, 0x30, 0x3c,
751 0xb9, 0x0b, 0xff, 0xf6, 0x57, 0x32, 0xac, 0xe8, 0x70, 0xdf, 0x5d, 0x84, 0x09, 0xd6, 0xa9, 0xc4,
752 0xa3, 0x3f, 0xcf, 0x5e, 0xce, 0x11, 0xd5, 0xf3, 0x90, 0x4d, 0xe8, 0xf0, 0x5f, 0x63, 0x50, 0xaa,
753 0x5f, 0xad, 0x43, 0x21, 0xd0, 0x9d, 0xc4, 0xc3, 0x7f, 0x9d, 0xc1, 0x83, 0x28, 0x6c, 0x3a, 0xeb,
754 0x4e, 0xe2, 0x09, 0x7e, 0x83, 0x9b, 0xce, 0x10, 0xd8, 0x6d, 0xbc, 0x31, 0x89, 0x47, 0x7f, 0x81,
755 0x7b, 0x9d, 0x43, 0xaa, 0xcf, 0x42, 0xde, 0x2f, 0x36, 0xf1, 0xf8, 0xdf, 0x64, 0xf8, 0x01, 0x06,
756 0x7b, 0x20, 0x50, 0xec, 0xe2, 0x29, 0x7e, 0x8b, 0x7b, 0x20, 0x80, 0xc2, 0xdb, 0x28, 0xda, 0xc0,
757 0xc4, 0x33, 0x7d, 0x91, 0x6f, 0xa3, 0x48, 0xff, 0x82, 0x57, 0x93, 0xe4, 0xfc, 0x78, 0x8a, 0xdf,
758 0xe6, 0xab, 0x49, 0xf4, 0xb1, 0x19, 0xd1, 0x8e, 0x20, 0x9e, 0xe3, 0x77, 0xb8, 0x19, 0x91, 0x86,
759 0xa0, 0xba, 0x0d, 0xd2, 0x70, 0x37, 0x10, 0xcf, 0xf7, 0x25, 0xc6, 0x37, 0x3d, 0xd4, 0x0c, 0x54,
760 0x9f, 0x87, 0xb9, 0xd1, 0x9d, 0x40, 0x3c, 0xeb, 0x97, 0xef, 0x46, 0xce, 0x6e, 0xc1, 0x46, 0xa0,
761 0xba, 0x33, 0x28, 0x29, 0xc1, 0x2e, 0x20, 0x9e, 0xf6, 0xd5, 0xbb, 0xe1, 0xc4, 0x1d, 0x6c, 0x02,
762 0xaa, 0x35, 0x80, 0x41, 0x01, 0x8e, 0xe7, 0x7a, 0x8d, 0x71, 0x05, 0x40, 0x78, 0x6b, 0xb0, 0xfa,
763 0x1b, 0x8f, 0xff, 0x0a, 0xdf, 0x1a, 0x0c, 0x81, 0xb7, 0x06, 0x2f, 0xbd, 0xf1, 0xe8, 0xd7, 0xf9,
764 0xd6, 0xe0, 0x10, 0x1c, 0xd9, 0x81, 0xea, 0x16, 0xcf, 0x70, 0x8b, 0x47, 0x76, 0x00, 0x55, 0xdd,
765 0x82, 0xe9, 0xa1, 0x82, 0x18, 0x4f, 0xf5, 0x35, 0x46, 0x25, 0x46, 0xeb, 0x61, 0xb0, 0x78, 0xb1,
766 0x62, 0x18, 0xcf, 0xf6, 0xfb, 0x91, 0xe2, 0xc5, 0x6a, 0x61, 0xf5, 0x22, 0xe4, 0xcc, 0xbe, 0x61,
767 0xe0, 0xcd, 0x23, 0xdd, 0xff, 0x97, 0x7b, 0xe5, 0x7f, 0xbb, 0xc7, 0xbc, 0xc3, 0x01, 0xd5, 0xb3,
768 0x90, 0x45, 0xbd, 0x5d, 0xd4, 0x89, 0x43, 0xfe, 0xfb, 0x3d, 0x9e, 0x30, 0xb1, 0x76, 0xf5, 0x59,
769 0x00, 0x7a, 0x35, 0x42, 0x3e, 0xfb, 0xc5, 0x60, 0xff, 0xe3, 0x1e, 0xfb, 0x4d, 0xcd, 0x00, 0x32,
770 0x20, 0xa0, 0xbf, 0xd0, 0xb9, 0x3f, 0xc1, 0xbb, 0x61, 0x02, 0xb2, 0x22, 0x17, 0x60, 0xe2, 0x8a,
771 0x6b, 0x99, 0x9e, 0xda, 0x8d, 0x43, 0xff, 0x27, 0x43, 0x73, 0x7d, 0xec, 0xb0, 0x9e, 0xe5, 0x20,
772 0x4f, 0xed, 0xba, 0x71, 0xd8, 0xff, 0x62, 0x58, 0x1f, 0x80, 0xc1, 0x9a, 0xea, 0x7a, 0x49, 0xe6,
773 0xfd, 0xdf, 0x1c, 0xcc, 0x01, 0xd8, 0x68, 0xfc, 0xf7, 0x55, 0x74, 0x10, 0x87, 0xfd, 0x11, 0x37,
774 0x9a, 0xe9, 0x57, 0x3f, 0x01, 0x79, 0xfc, 0x27, 0xfd, 0xa1, 0x5c, 0x0c, 0xf8, 0x7f, 0x18, 0x78,
775 0x80, 0xc0, 0x6f, 0x76, 0xbd, 0x8e, 0xa7, 0xc7, 0x3b, 0xfb, 0x7f, 0xd9, 0x4a, 0x73, 0xfd, 0x6a,
776 0x0d, 0x0a, 0xae, 0xd7, 0xe9, 0xf4, 0x59, 0x7f, 0x1a, 0x03, 0xff, 0xbf, 0x7b, 0xfe, 0x95, 0x85,
777 0x8f, 0xc1, 0xab, 0x7d, 0xfd, 0xaa, 0x67, 0x5b, 0xe4, 0x33, 0x47, 0x1c, 0xc3, 0x5d, 0xc6, 0x10,
778 0x80, 0xac, 0x34, 0x46, 0x5f, 0xdf, 0xc2, 0x9a, 0xb5, 0x66, 0xd1, 0x8b, 0xdb, 0x97, 0x2a, 0xf1,
779 0x37, 0xb0, 0x70, 0x6f, 0x02, 0x27, 0xf3, 0x41, 0x6e, 0x63, 0xb7, 0xb1, 0xc5, 0xa0, 0x6c, 0xfe,
780 0x68, 0x57, 0xb9, 0x95, 0x4f, 0x81, 0x50, 0x93, 0xe6, 0x60, 0x9c, 0xcc, 0xe1, 0x27, 0xc8, 0x15,
781 0x75, 0x5a, 0x66, 0x4f, 0xd2, 0x43, 0x20, 0xac, 0xb0, 0xbb, 0xf2, 0xa9, 0xe5, 0xd0, 0x9b, 0x57,
782 0x64, 0x61, 0xa5, 0x9a, 0x79, 0xeb, 0xd6, 0x89, 0xb1, 0x8a, 0x06, 0xc2, 0x0a, 0xd6, 0xac, 0x93,
783 0x0f, 0x98, 0x43, 0x9a, 0x75, 0x59, 0xa8, 0xe3, 0xe1, 0x55, 0xf6, 0xd3, 0xcd, 0xc8, 0xf0, 0xaa,
784 0x2c, 0xac, 0x4a, 0x8b, 0x20, 0x5c, 0x22, 0x1f, 0x6d, 0x0a, 0xa7, 0xa5, 0xf0, 0x70, 0xd3, 0xe8,
785 0xd4, 0x65, 0xe1, 0x52, 0xe5, 0x41, 0x10, 0x56, 0x03, 0x66, 0x0a, 0x41, 0x33, 0x2b, 0x5f, 0x14,
786 0x40, 0xa8, 0xfb, 0xa3, 0xa7, 0xc9, 0x8b, 0x04, 0x36, 0x7a, 0xda, 0x97, 0x3f, 0xcd, 0xbe, 0x4c,
787 0xb0, 0x27, 0x5f, 0x7e, 0x86, 0x5c, 0xb4, 0x73, 0xfd, 0x33, 0xbe, 0xfc, 0x2c, 0xf9, 0xa1, 0x64,
788 0x91, 0xc9, 0xcf, 0xfa, 0xf2, 0x73, 0xe4, 0xb3, 0x11, 0x7f, 0xfb, 0x39, 0x5f, 0x7e, 0x9e, 0xfc,
789 0xd7, 0x93, 0x14, 0x93, 0x9f, 0xaf, 0x5c, 0x00, 0xa1, 0x1d, 0x32, 0x2a, 0x7d, 0xa8, 0x51, 0x93,
790 0xdc, 0x28, 0xe6, 0xd2, 0xe7, 0x20, 0xd3, 0x36, 0xad, 0xcd, 0x23, 0xa3, 0xc5, 0x5f, 0xbe, 0x75,
791 0x62, 0xec, 0x0b, 0xb7, 0x4e, 0x8c, 0x7d, 0xf5, 0xd6, 0x89, 0x31, 0xc2, 0x74, 0x09, 0x32, 0x4d,
792 0xa3, 0x73, 0xf8, 0x0a, 0x2f, 0x0e, 0x56, 0x78, 0xd8, 0xf3, 0x81, 0x45, 0xbe, 0x4c, 0x78, 0x56,
793 0xb0, 0x3e, 0x5f, 0xe7, 0x91, 0x2b, 0x55, 0x4f, 0xb0, 0x96, 0x3f, 0x4b, 0xb8, 0xea, 0x87, 0x2d,
794 0xe7, 0x7b, 0x5e, 0xc8, 0xa4, 0x0b, 0x73, 0x8e, 0xbc, 0xbf, 0x1d, 0x79, 0x7f, 0x7e, 0xe4, 0xfb,
795 0x03, 0x5e, 0xaf, 0xac, 0xc1, 0x04, 0xc6, 0x05, 0x17, 0x26, 0x21, 0xb4, 0x5a, 0x0c, 0x2e, 0xcc,
796 0xca, 0x99, 0x37, 0x6f, 0x2f, 0x8c, 0xbd, 0x75, 0x7b, 0x61, 0xec, 0x1f, 0x6f, 0x2f, 0x8c, 0xbd,
797 0x7d, 0x7b, 0x41, 0xf8, 0xd1, 0xed, 0x05, 0xe1, 0xc7, 0xb7, 0x17, 0x84, 0x9b, 0x77, 0x16, 0x84,
798 0x6f, 0xdc, 0x59, 0x10, 0xbe, 0x75, 0x67, 0x41, 0xf8, 0xee, 0x9d, 0x05, 0xe1, 0xcd, 0x3b, 0x0b,
799 0xc2, 0x5b, 0x77, 0x16, 0x84, 0xb7, 0xef, 0x2c, 0x08, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x4b,
800 0x91, 0xe1, 0x56, 0xf2, 0x36, 0x00, 0x00,
801 }
802 r := bytes.NewReader(gzipped)
803 gzipr, err := compress_gzip.NewReader(r)
804 if err != nil {
805 panic(err)
806 }
807 ungzipped, err := io_ioutil.ReadAll(gzipr)
808 if err != nil {
809 panic(err)
810 }
811 if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
812 panic(err)
813 }
814 return d
815 }
816 func (this *A) VerboseEqual(that interface{}) error {
817 if that == nil {
818 if this == nil {
819 return nil
820 }
821 return fmt.Errorf("that == nil && this != nil")
822 }
823
824 that1, ok := that.(*A)
825 if !ok {
826 that2, ok := that.(A)
827 if ok {
828 that1 = &that2
829 } else {
830 return fmt.Errorf("that is not of type *A")
831 }
832 }
833 if that1 == nil {
834 if this == nil {
835 return nil
836 }
837 return fmt.Errorf("that is type *A but is nil && this != nil")
838 } else if this == nil {
839 return fmt.Errorf("that is type *A but is not nil && this == nil")
840 }
841 if this.Field1 != nil && that1.Field1 != nil {
842 if *this.Field1 != *that1.Field1 {
843 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
844 }
845 } else if this.Field1 != nil {
846 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
847 } else if that1.Field1 != nil {
848 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
849 }
850 if len(this.B) != len(that1.B) {
851 return fmt.Errorf("B this(%v) Not Equal that(%v)", len(this.B), len(that1.B))
852 }
853 for i := range this.B {
854 if !this.B[i].Equal(that1.B[i]) {
855 return fmt.Errorf("B this[%v](%v) Not Equal that[%v](%v)", i, this.B[i], i, that1.B[i])
856 }
857 }
858 return nil
859 }
860 func (this *A) Equal(that interface{}) bool {
861 if that == nil {
862 return this == nil
863 }
864
865 that1, ok := that.(*A)
866 if !ok {
867 that2, ok := that.(A)
868 if ok {
869 that1 = &that2
870 } else {
871 return false
872 }
873 }
874 if that1 == nil {
875 return this == nil
876 } else if this == nil {
877 return false
878 }
879 if this.Field1 != nil && that1.Field1 != nil {
880 if *this.Field1 != *that1.Field1 {
881 return false
882 }
883 } else if this.Field1 != nil {
884 return false
885 } else if that1.Field1 != nil {
886 return false
887 }
888 if len(this.B) != len(that1.B) {
889 return false
890 }
891 for i := range this.B {
892 if !this.B[i].Equal(that1.B[i]) {
893 return false
894 }
895 }
896 return true
897 }
898 func (this *B) VerboseEqual(that interface{}) error {
899 if that == nil {
900 if this == nil {
901 return nil
902 }
903 return fmt.Errorf("that == nil && this != nil")
904 }
905
906 that1, ok := that.(*B)
907 if !ok {
908 that2, ok := that.(B)
909 if ok {
910 that1 = &that2
911 } else {
912 return fmt.Errorf("that is not of type *B")
913 }
914 }
915 if that1 == nil {
916 if this == nil {
917 return nil
918 }
919 return fmt.Errorf("that is type *B but is nil && this != nil")
920 } else if this == nil {
921 return fmt.Errorf("that is type *B but is not nil && this == nil")
922 }
923 if !this.C.Equal(that1.C) {
924 return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C)
925 }
926 if !this.D.Equal(that1.D) {
927 return fmt.Errorf("D this(%v) Not Equal that(%v)", this.D, that1.D)
928 }
929 if !this.F.Equal(that1.F) {
930 return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F)
931 }
932 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
933 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
934 }
935 return nil
936 }
937 func (this *B) Equal(that interface{}) bool {
938 if that == nil {
939 return this == nil
940 }
941
942 that1, ok := that.(*B)
943 if !ok {
944 that2, ok := that.(B)
945 if ok {
946 that1 = &that2
947 } else {
948 return false
949 }
950 }
951 if that1 == nil {
952 return this == nil
953 } else if this == nil {
954 return false
955 }
956 if !this.C.Equal(that1.C) {
957 return false
958 }
959 if !this.D.Equal(that1.D) {
960 return false
961 }
962 if !this.F.Equal(that1.F) {
963 return false
964 }
965 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
966 return false
967 }
968 return true
969 }
970 func (this *D) VerboseEqual(that interface{}) error {
971 if that == nil {
972 if this == nil {
973 return nil
974 }
975 return fmt.Errorf("that == nil && this != nil")
976 }
977
978 that1, ok := that.(*D)
979 if !ok {
980 that2, ok := that.(D)
981 if ok {
982 that1 = &that2
983 } else {
984 return fmt.Errorf("that is not of type *D")
985 }
986 }
987 if that1 == nil {
988 if this == nil {
989 return nil
990 }
991 return fmt.Errorf("that is type *D but is nil && this != nil")
992 } else if this == nil {
993 return fmt.Errorf("that is type *D but is not nil && this == nil")
994 }
995 if this.Field1 != nil && that1.Field1 != nil {
996 if *this.Field1 != *that1.Field1 {
997 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
998 }
999 } else if this.Field1 != nil {
1000 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
1001 } else if that1.Field1 != nil {
1002 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
1003 }
1004 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1005 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1006 }
1007 return nil
1008 }
1009 func (this *D) Equal(that interface{}) bool {
1010 if that == nil {
1011 return this == nil
1012 }
1013
1014 that1, ok := that.(*D)
1015 if !ok {
1016 that2, ok := that.(D)
1017 if ok {
1018 that1 = &that2
1019 } else {
1020 return false
1021 }
1022 }
1023 if that1 == nil {
1024 return this == nil
1025 } else if this == nil {
1026 return false
1027 }
1028 if this.Field1 != nil && that1.Field1 != nil {
1029 if *this.Field1 != *that1.Field1 {
1030 return false
1031 }
1032 } else if this.Field1 != nil {
1033 return false
1034 } else if that1.Field1 != nil {
1035 return false
1036 }
1037 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1038 return false
1039 }
1040 return true
1041 }
1042 func (this *C) VerboseEqual(that interface{}) error {
1043 if that == nil {
1044 if this == nil {
1045 return nil
1046 }
1047 return fmt.Errorf("that == nil && this != nil")
1048 }
1049
1050 that1, ok := that.(*C)
1051 if !ok {
1052 that2, ok := that.(C)
1053 if ok {
1054 that1 = &that2
1055 } else {
1056 return fmt.Errorf("that is not of type *C")
1057 }
1058 }
1059 if that1 == nil {
1060 if this == nil {
1061 return nil
1062 }
1063 return fmt.Errorf("that is type *C but is nil && this != nil")
1064 } else if this == nil {
1065 return fmt.Errorf("that is type *C but is not nil && this == nil")
1066 }
1067 if this.Field2 != nil && that1.Field2 != nil {
1068 if *this.Field2 != *that1.Field2 {
1069 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
1070 }
1071 } else if this.Field2 != nil {
1072 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
1073 } else if that1.Field2 != nil {
1074 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
1075 }
1076 if this.Field3 != nil && that1.Field3 != nil {
1077 if *this.Field3 != *that1.Field3 {
1078 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
1079 }
1080 } else if this.Field3 != nil {
1081 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
1082 } else if that1.Field3 != nil {
1083 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
1084 }
1085 if this.Field4 != nil && that1.Field4 != nil {
1086 if *this.Field4 != *that1.Field4 {
1087 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4)
1088 }
1089 } else if this.Field4 != nil {
1090 return fmt.Errorf("this.Field4 == nil && that.Field4 != nil")
1091 } else if that1.Field4 != nil {
1092 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4)
1093 }
1094 if len(this.Field5) != len(that1.Field5) {
1095 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5))
1096 }
1097 for i := range this.Field5 {
1098 if !bytes.Equal(this.Field5[i], that1.Field5[i]) {
1099 return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i])
1100 }
1101 }
1102 if this.Field6 != nil && that1.Field6 != nil {
1103 if *this.Field6 != *that1.Field6 {
1104 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6)
1105 }
1106 } else if this.Field6 != nil {
1107 return fmt.Errorf("this.Field6 == nil && that.Field6 != nil")
1108 } else if that1.Field6 != nil {
1109 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6)
1110 }
1111 if len(this.Field7) != len(that1.Field7) {
1112 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7))
1113 }
1114 for i := range this.Field7 {
1115 if this.Field7[i] != that1.Field7[i] {
1116 return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i])
1117 }
1118 }
1119 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1120 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1121 }
1122 return nil
1123 }
1124 func (this *C) Equal(that interface{}) bool {
1125 if that == nil {
1126 return this == nil
1127 }
1128
1129 that1, ok := that.(*C)
1130 if !ok {
1131 that2, ok := that.(C)
1132 if ok {
1133 that1 = &that2
1134 } else {
1135 return false
1136 }
1137 }
1138 if that1 == nil {
1139 return this == nil
1140 } else if this == nil {
1141 return false
1142 }
1143 if this.Field2 != nil && that1.Field2 != nil {
1144 if *this.Field2 != *that1.Field2 {
1145 return false
1146 }
1147 } else if this.Field2 != nil {
1148 return false
1149 } else if that1.Field2 != nil {
1150 return false
1151 }
1152 if this.Field3 != nil && that1.Field3 != nil {
1153 if *this.Field3 != *that1.Field3 {
1154 return false
1155 }
1156 } else if this.Field3 != nil {
1157 return false
1158 } else if that1.Field3 != nil {
1159 return false
1160 }
1161 if this.Field4 != nil && that1.Field4 != nil {
1162 if *this.Field4 != *that1.Field4 {
1163 return false
1164 }
1165 } else if this.Field4 != nil {
1166 return false
1167 } else if that1.Field4 != nil {
1168 return false
1169 }
1170 if len(this.Field5) != len(that1.Field5) {
1171 return false
1172 }
1173 for i := range this.Field5 {
1174 if !bytes.Equal(this.Field5[i], that1.Field5[i]) {
1175 return false
1176 }
1177 }
1178 if this.Field6 != nil && that1.Field6 != nil {
1179 if *this.Field6 != *that1.Field6 {
1180 return false
1181 }
1182 } else if this.Field6 != nil {
1183 return false
1184 } else if that1.Field6 != nil {
1185 return false
1186 }
1187 if len(this.Field7) != len(that1.Field7) {
1188 return false
1189 }
1190 for i := range this.Field7 {
1191 if this.Field7[i] != that1.Field7[i] {
1192 return false
1193 }
1194 }
1195 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1196 return false
1197 }
1198 return true
1199 }
1200 func (this *U) VerboseEqual(that interface{}) error {
1201 if that == nil {
1202 if this == nil {
1203 return nil
1204 }
1205 return fmt.Errorf("that == nil && this != nil")
1206 }
1207
1208 that1, ok := that.(*U)
1209 if !ok {
1210 that2, ok := that.(U)
1211 if ok {
1212 that1 = &that2
1213 } else {
1214 return fmt.Errorf("that is not of type *U")
1215 }
1216 }
1217 if that1 == nil {
1218 if this == nil {
1219 return nil
1220 }
1221 return fmt.Errorf("that is type *U but is nil && this != nil")
1222 } else if this == nil {
1223 return fmt.Errorf("that is type *U but is not nil && this == nil")
1224 }
1225 if len(this.Field2) != len(that1.Field2) {
1226 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
1227 }
1228 for i := range this.Field2 {
1229 if this.Field2[i] != that1.Field2[i] {
1230 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
1231 }
1232 }
1233 if this.Field3 != nil && that1.Field3 != nil {
1234 if *this.Field3 != *that1.Field3 {
1235 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
1236 }
1237 } else if this.Field3 != nil {
1238 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
1239 } else if that1.Field3 != nil {
1240 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
1241 }
1242 return nil
1243 }
1244 func (this *U) Equal(that interface{}) bool {
1245 if that == nil {
1246 return this == nil
1247 }
1248
1249 that1, ok := that.(*U)
1250 if !ok {
1251 that2, ok := that.(U)
1252 if ok {
1253 that1 = &that2
1254 } else {
1255 return false
1256 }
1257 }
1258 if that1 == nil {
1259 return this == nil
1260 } else if this == nil {
1261 return false
1262 }
1263 if len(this.Field2) != len(that1.Field2) {
1264 return false
1265 }
1266 for i := range this.Field2 {
1267 if this.Field2[i] != that1.Field2[i] {
1268 return false
1269 }
1270 }
1271 if this.Field3 != nil && that1.Field3 != nil {
1272 if *this.Field3 != *that1.Field3 {
1273 return false
1274 }
1275 } else if this.Field3 != nil {
1276 return false
1277 } else if that1.Field3 != nil {
1278 return false
1279 }
1280 return true
1281 }
1282 func (this *UnoM) VerboseEqual(that interface{}) error {
1283 if that == nil {
1284 if this == nil {
1285 return nil
1286 }
1287 return fmt.Errorf("that == nil && this != nil")
1288 }
1289
1290 that1, ok := that.(*UnoM)
1291 if !ok {
1292 that2, ok := that.(UnoM)
1293 if ok {
1294 that1 = &that2
1295 } else {
1296 return fmt.Errorf("that is not of type *UnoM")
1297 }
1298 }
1299 if that1 == nil {
1300 if this == nil {
1301 return nil
1302 }
1303 return fmt.Errorf("that is type *UnoM but is nil && this != nil")
1304 } else if this == nil {
1305 return fmt.Errorf("that is type *UnoM but is not nil && this == nil")
1306 }
1307 if len(this.Field2) != len(that1.Field2) {
1308 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
1309 }
1310 for i := range this.Field2 {
1311 if this.Field2[i] != that1.Field2[i] {
1312 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
1313 }
1314 }
1315 if this.Field3 != nil && that1.Field3 != nil {
1316 if *this.Field3 != *that1.Field3 {
1317 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
1318 }
1319 } else if this.Field3 != nil {
1320 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
1321 } else if that1.Field3 != nil {
1322 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
1323 }
1324 return nil
1325 }
1326 func (this *UnoM) Equal(that interface{}) bool {
1327 if that == nil {
1328 return this == nil
1329 }
1330
1331 that1, ok := that.(*UnoM)
1332 if !ok {
1333 that2, ok := that.(UnoM)
1334 if ok {
1335 that1 = &that2
1336 } else {
1337 return false
1338 }
1339 }
1340 if that1 == nil {
1341 return this == nil
1342 } else if this == nil {
1343 return false
1344 }
1345 if len(this.Field2) != len(that1.Field2) {
1346 return false
1347 }
1348 for i := range this.Field2 {
1349 if this.Field2[i] != that1.Field2[i] {
1350 return false
1351 }
1352 }
1353 if this.Field3 != nil && that1.Field3 != nil {
1354 if *this.Field3 != *that1.Field3 {
1355 return false
1356 }
1357 } else if this.Field3 != nil {
1358 return false
1359 } else if that1.Field3 != nil {
1360 return false
1361 }
1362 return true
1363 }
1364 func (this *OldA) VerboseEqual(that interface{}) error {
1365 if that == nil {
1366 if this == nil {
1367 return nil
1368 }
1369 return fmt.Errorf("that == nil && this != nil")
1370 }
1371
1372 that1, ok := that.(*OldA)
1373 if !ok {
1374 that2, ok := that.(OldA)
1375 if ok {
1376 that1 = &that2
1377 } else {
1378 return fmt.Errorf("that is not of type *OldA")
1379 }
1380 }
1381 if that1 == nil {
1382 if this == nil {
1383 return nil
1384 }
1385 return fmt.Errorf("that is type *OldA but is nil && this != nil")
1386 } else if this == nil {
1387 return fmt.Errorf("that is type *OldA but is not nil && this == nil")
1388 }
1389 if this.Field1 != nil && that1.Field1 != nil {
1390 if *this.Field1 != *that1.Field1 {
1391 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
1392 }
1393 } else if this.Field1 != nil {
1394 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
1395 } else if that1.Field1 != nil {
1396 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
1397 }
1398 if len(this.B) != len(that1.B) {
1399 return fmt.Errorf("B this(%v) Not Equal that(%v)", len(this.B), len(that1.B))
1400 }
1401 for i := range this.B {
1402 if !this.B[i].Equal(that1.B[i]) {
1403 return fmt.Errorf("B this[%v](%v) Not Equal that[%v](%v)", i, this.B[i], i, that1.B[i])
1404 }
1405 }
1406 return nil
1407 }
1408 func (this *OldA) Equal(that interface{}) bool {
1409 if that == nil {
1410 return this == nil
1411 }
1412
1413 that1, ok := that.(*OldA)
1414 if !ok {
1415 that2, ok := that.(OldA)
1416 if ok {
1417 that1 = &that2
1418 } else {
1419 return false
1420 }
1421 }
1422 if that1 == nil {
1423 return this == nil
1424 } else if this == nil {
1425 return false
1426 }
1427 if this.Field1 != nil && that1.Field1 != nil {
1428 if *this.Field1 != *that1.Field1 {
1429 return false
1430 }
1431 } else if this.Field1 != nil {
1432 return false
1433 } else if that1.Field1 != nil {
1434 return false
1435 }
1436 if len(this.B) != len(that1.B) {
1437 return false
1438 }
1439 for i := range this.B {
1440 if !this.B[i].Equal(that1.B[i]) {
1441 return false
1442 }
1443 }
1444 return true
1445 }
1446 func (this *OldB) VerboseEqual(that interface{}) error {
1447 if that == nil {
1448 if this == nil {
1449 return nil
1450 }
1451 return fmt.Errorf("that == nil && this != nil")
1452 }
1453
1454 that1, ok := that.(*OldB)
1455 if !ok {
1456 that2, ok := that.(OldB)
1457 if ok {
1458 that1 = &that2
1459 } else {
1460 return fmt.Errorf("that is not of type *OldB")
1461 }
1462 }
1463 if that1 == nil {
1464 if this == nil {
1465 return nil
1466 }
1467 return fmt.Errorf("that is type *OldB but is nil && this != nil")
1468 } else if this == nil {
1469 return fmt.Errorf("that is type *OldB but is not nil && this == nil")
1470 }
1471 if !this.C.Equal(that1.C) {
1472 return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C)
1473 }
1474 if !this.F.Equal(that1.F) {
1475 return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F)
1476 }
1477 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1478 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1479 }
1480 return nil
1481 }
1482 func (this *OldB) Equal(that interface{}) bool {
1483 if that == nil {
1484 return this == nil
1485 }
1486
1487 that1, ok := that.(*OldB)
1488 if !ok {
1489 that2, ok := that.(OldB)
1490 if ok {
1491 that1 = &that2
1492 } else {
1493 return false
1494 }
1495 }
1496 if that1 == nil {
1497 return this == nil
1498 } else if this == nil {
1499 return false
1500 }
1501 if !this.C.Equal(that1.C) {
1502 return false
1503 }
1504 if !this.F.Equal(that1.F) {
1505 return false
1506 }
1507 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1508 return false
1509 }
1510 return true
1511 }
1512 func (this *OldC) VerboseEqual(that interface{}) error {
1513 if that == nil {
1514 if this == nil {
1515 return nil
1516 }
1517 return fmt.Errorf("that == nil && this != nil")
1518 }
1519
1520 that1, ok := that.(*OldC)
1521 if !ok {
1522 that2, ok := that.(OldC)
1523 if ok {
1524 that1 = &that2
1525 } else {
1526 return fmt.Errorf("that is not of type *OldC")
1527 }
1528 }
1529 if that1 == nil {
1530 if this == nil {
1531 return nil
1532 }
1533 return fmt.Errorf("that is type *OldC but is nil && this != nil")
1534 } else if this == nil {
1535 return fmt.Errorf("that is type *OldC but is not nil && this == nil")
1536 }
1537 if this.Field1 != nil && that1.Field1 != nil {
1538 if *this.Field1 != *that1.Field1 {
1539 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
1540 }
1541 } else if this.Field1 != nil {
1542 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
1543 } else if that1.Field1 != nil {
1544 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
1545 }
1546 if this.Field2 != nil && that1.Field2 != nil {
1547 if *this.Field2 != *that1.Field2 {
1548 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
1549 }
1550 } else if this.Field2 != nil {
1551 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
1552 } else if that1.Field2 != nil {
1553 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
1554 }
1555 if this.Field3 != nil && that1.Field3 != nil {
1556 if *this.Field3 != *that1.Field3 {
1557 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
1558 }
1559 } else if this.Field3 != nil {
1560 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
1561 } else if that1.Field3 != nil {
1562 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
1563 }
1564 if this.Field6 != nil && that1.Field6 != nil {
1565 if *this.Field6 != *that1.Field6 {
1566 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6)
1567 }
1568 } else if this.Field6 != nil {
1569 return fmt.Errorf("this.Field6 == nil && that.Field6 != nil")
1570 } else if that1.Field6 != nil {
1571 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6)
1572 }
1573 if len(this.Field7) != len(that1.Field7) {
1574 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7))
1575 }
1576 for i := range this.Field7 {
1577 if this.Field7[i] != that1.Field7[i] {
1578 return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i])
1579 }
1580 }
1581 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1582 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1583 }
1584 return nil
1585 }
1586 func (this *OldC) Equal(that interface{}) bool {
1587 if that == nil {
1588 return this == nil
1589 }
1590
1591 that1, ok := that.(*OldC)
1592 if !ok {
1593 that2, ok := that.(OldC)
1594 if ok {
1595 that1 = &that2
1596 } else {
1597 return false
1598 }
1599 }
1600 if that1 == nil {
1601 return this == nil
1602 } else if this == nil {
1603 return false
1604 }
1605 if this.Field1 != nil && that1.Field1 != nil {
1606 if *this.Field1 != *that1.Field1 {
1607 return false
1608 }
1609 } else if this.Field1 != nil {
1610 return false
1611 } else if that1.Field1 != nil {
1612 return false
1613 }
1614 if this.Field2 != nil && that1.Field2 != nil {
1615 if *this.Field2 != *that1.Field2 {
1616 return false
1617 }
1618 } else if this.Field2 != nil {
1619 return false
1620 } else if that1.Field2 != nil {
1621 return false
1622 }
1623 if this.Field3 != nil && that1.Field3 != nil {
1624 if *this.Field3 != *that1.Field3 {
1625 return false
1626 }
1627 } else if this.Field3 != nil {
1628 return false
1629 } else if that1.Field3 != nil {
1630 return false
1631 }
1632 if this.Field6 != nil && that1.Field6 != nil {
1633 if *this.Field6 != *that1.Field6 {
1634 return false
1635 }
1636 } else if this.Field6 != nil {
1637 return false
1638 } else if that1.Field6 != nil {
1639 return false
1640 }
1641 if len(this.Field7) != len(that1.Field7) {
1642 return false
1643 }
1644 for i := range this.Field7 {
1645 if this.Field7[i] != that1.Field7[i] {
1646 return false
1647 }
1648 }
1649 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1650 return false
1651 }
1652 return true
1653 }
1654 func (this *OldU) VerboseEqual(that interface{}) error {
1655 if that == nil {
1656 if this == nil {
1657 return nil
1658 }
1659 return fmt.Errorf("that == nil && this != nil")
1660 }
1661
1662 that1, ok := that.(*OldU)
1663 if !ok {
1664 that2, ok := that.(OldU)
1665 if ok {
1666 that1 = &that2
1667 } else {
1668 return fmt.Errorf("that is not of type *OldU")
1669 }
1670 }
1671 if that1 == nil {
1672 if this == nil {
1673 return nil
1674 }
1675 return fmt.Errorf("that is type *OldU but is nil && this != nil")
1676 } else if this == nil {
1677 return fmt.Errorf("that is type *OldU but is not nil && this == nil")
1678 }
1679 if this.Field1 != nil && that1.Field1 != nil {
1680 if *this.Field1 != *that1.Field1 {
1681 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
1682 }
1683 } else if this.Field1 != nil {
1684 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
1685 } else if that1.Field1 != nil {
1686 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
1687 }
1688 if len(this.Field2) != len(that1.Field2) {
1689 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
1690 }
1691 for i := range this.Field2 {
1692 if this.Field2[i] != that1.Field2[i] {
1693 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
1694 }
1695 }
1696 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1697 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1698 }
1699 return nil
1700 }
1701 func (this *OldU) Equal(that interface{}) bool {
1702 if that == nil {
1703 return this == nil
1704 }
1705
1706 that1, ok := that.(*OldU)
1707 if !ok {
1708 that2, ok := that.(OldU)
1709 if ok {
1710 that1 = &that2
1711 } else {
1712 return false
1713 }
1714 }
1715 if that1 == nil {
1716 return this == nil
1717 } else if this == nil {
1718 return false
1719 }
1720 if this.Field1 != nil && that1.Field1 != nil {
1721 if *this.Field1 != *that1.Field1 {
1722 return false
1723 }
1724 } else if this.Field1 != nil {
1725 return false
1726 } else if that1.Field1 != nil {
1727 return false
1728 }
1729 if len(this.Field2) != len(that1.Field2) {
1730 return false
1731 }
1732 for i := range this.Field2 {
1733 if this.Field2[i] != that1.Field2[i] {
1734 return false
1735 }
1736 }
1737 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1738 return false
1739 }
1740 return true
1741 }
1742 func (this *OldUnoM) VerboseEqual(that interface{}) error {
1743 if that == nil {
1744 if this == nil {
1745 return nil
1746 }
1747 return fmt.Errorf("that == nil && this != nil")
1748 }
1749
1750 that1, ok := that.(*OldUnoM)
1751 if !ok {
1752 that2, ok := that.(OldUnoM)
1753 if ok {
1754 that1 = &that2
1755 } else {
1756 return fmt.Errorf("that is not of type *OldUnoM")
1757 }
1758 }
1759 if that1 == nil {
1760 if this == nil {
1761 return nil
1762 }
1763 return fmt.Errorf("that is type *OldUnoM but is nil && this != nil")
1764 } else if this == nil {
1765 return fmt.Errorf("that is type *OldUnoM but is not nil && this == nil")
1766 }
1767 if this.Field1 != nil && that1.Field1 != nil {
1768 if *this.Field1 != *that1.Field1 {
1769 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
1770 }
1771 } else if this.Field1 != nil {
1772 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
1773 } else if that1.Field1 != nil {
1774 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
1775 }
1776 if len(this.Field2) != len(that1.Field2) {
1777 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
1778 }
1779 for i := range this.Field2 {
1780 if this.Field2[i] != that1.Field2[i] {
1781 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
1782 }
1783 }
1784 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1785 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1786 }
1787 return nil
1788 }
1789 func (this *OldUnoM) Equal(that interface{}) bool {
1790 if that == nil {
1791 return this == nil
1792 }
1793
1794 that1, ok := that.(*OldUnoM)
1795 if !ok {
1796 that2, ok := that.(OldUnoM)
1797 if ok {
1798 that1 = &that2
1799 } else {
1800 return false
1801 }
1802 }
1803 if that1 == nil {
1804 return this == nil
1805 } else if this == nil {
1806 return false
1807 }
1808 if this.Field1 != nil && that1.Field1 != nil {
1809 if *this.Field1 != *that1.Field1 {
1810 return false
1811 }
1812 } else if this.Field1 != nil {
1813 return false
1814 } else if that1.Field1 != nil {
1815 return false
1816 }
1817 if len(this.Field2) != len(that1.Field2) {
1818 return false
1819 }
1820 for i := range this.Field2 {
1821 if this.Field2[i] != that1.Field2[i] {
1822 return false
1823 }
1824 }
1825 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1826 return false
1827 }
1828 return true
1829 }
1830 func (this *A) GoString() string {
1831 if this == nil {
1832 return "nil"
1833 }
1834 s := make([]string, 0, 6)
1835 s = append(s, "&unrecognized.A{")
1836 if this.Field1 != nil {
1837 s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "int64")+",\n")
1838 }
1839 if this.B != nil {
1840 s = append(s, "B: "+fmt.Sprintf("%#v", this.B)+",\n")
1841 }
1842 s = append(s, "}")
1843 return strings.Join(s, "")
1844 }
1845 func (this *B) GoString() string {
1846 if this == nil {
1847 return "nil"
1848 }
1849 s := make([]string, 0, 7)
1850 s = append(s, "&unrecognized.B{")
1851 if this.C != nil {
1852 s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n")
1853 }
1854 if this.D != nil {
1855 s = append(s, "D: "+fmt.Sprintf("%#v", this.D)+",\n")
1856 }
1857 if this.F != nil {
1858 s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n")
1859 }
1860 if this.XXX_unrecognized != nil {
1861 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1862 }
1863 s = append(s, "}")
1864 return strings.Join(s, "")
1865 }
1866 func (this *D) GoString() string {
1867 if this == nil {
1868 return "nil"
1869 }
1870 s := make([]string, 0, 5)
1871 s = append(s, "&unrecognized.D{")
1872 if this.Field1 != nil {
1873 s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "int64")+",\n")
1874 }
1875 if this.XXX_unrecognized != nil {
1876 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1877 }
1878 s = append(s, "}")
1879 return strings.Join(s, "")
1880 }
1881 func (this *C) GoString() string {
1882 if this == nil {
1883 return "nil"
1884 }
1885 s := make([]string, 0, 10)
1886 s = append(s, "&unrecognized.C{")
1887 if this.Field2 != nil {
1888 s = append(s, "Field2: "+valueToGoStringUnrecognized(this.Field2, "float64")+",\n")
1889 }
1890 if this.Field3 != nil {
1891 s = append(s, "Field3: "+valueToGoStringUnrecognized(this.Field3, "string")+",\n")
1892 }
1893 if this.Field4 != nil {
1894 s = append(s, "Field4: "+valueToGoStringUnrecognized(this.Field4, "float64")+",\n")
1895 }
1896 if this.Field5 != nil {
1897 s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n")
1898 }
1899 if this.Field6 != nil {
1900 s = append(s, "Field6: "+valueToGoStringUnrecognized(this.Field6, "int64")+",\n")
1901 }
1902 if this.Field7 != nil {
1903 s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
1904 }
1905 if this.XXX_unrecognized != nil {
1906 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1907 }
1908 s = append(s, "}")
1909 return strings.Join(s, "")
1910 }
1911 func (this *U) GoString() string {
1912 if this == nil {
1913 return "nil"
1914 }
1915 s := make([]string, 0, 6)
1916 s = append(s, "&unrecognized.U{")
1917 if this.Field2 != nil {
1918 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
1919 }
1920 if this.Field3 != nil {
1921 s = append(s, "Field3: "+valueToGoStringUnrecognized(this.Field3, "uint32")+",\n")
1922 }
1923 s = append(s, "}")
1924 return strings.Join(s, "")
1925 }
1926 func (this *UnoM) GoString() string {
1927 if this == nil {
1928 return "nil"
1929 }
1930 s := make([]string, 0, 6)
1931 s = append(s, "&unrecognized.UnoM{")
1932 if this.Field2 != nil {
1933 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
1934 }
1935 if this.Field3 != nil {
1936 s = append(s, "Field3: "+valueToGoStringUnrecognized(this.Field3, "uint32")+",\n")
1937 }
1938 s = append(s, "}")
1939 return strings.Join(s, "")
1940 }
1941 func (this *OldA) GoString() string {
1942 if this == nil {
1943 return "nil"
1944 }
1945 s := make([]string, 0, 6)
1946 s = append(s, "&unrecognized.OldA{")
1947 if this.Field1 != nil {
1948 s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "int64")+",\n")
1949 }
1950 if this.B != nil {
1951 s = append(s, "B: "+fmt.Sprintf("%#v", this.B)+",\n")
1952 }
1953 s = append(s, "}")
1954 return strings.Join(s, "")
1955 }
1956 func (this *OldB) GoString() string {
1957 if this == nil {
1958 return "nil"
1959 }
1960 s := make([]string, 0, 6)
1961 s = append(s, "&unrecognized.OldB{")
1962 if this.C != nil {
1963 s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n")
1964 }
1965 if this.F != nil {
1966 s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n")
1967 }
1968 if this.XXX_unrecognized != nil {
1969 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1970 }
1971 s = append(s, "}")
1972 return strings.Join(s, "")
1973 }
1974 func (this *OldC) GoString() string {
1975 if this == nil {
1976 return "nil"
1977 }
1978 s := make([]string, 0, 9)
1979 s = append(s, "&unrecognized.OldC{")
1980 if this.Field1 != nil {
1981 s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "int64")+",\n")
1982 }
1983 if this.Field2 != nil {
1984 s = append(s, "Field2: "+valueToGoStringUnrecognized(this.Field2, "float64")+",\n")
1985 }
1986 if this.Field3 != nil {
1987 s = append(s, "Field3: "+valueToGoStringUnrecognized(this.Field3, "string")+",\n")
1988 }
1989 if this.Field6 != nil {
1990 s = append(s, "Field6: "+valueToGoStringUnrecognized(this.Field6, "int64")+",\n")
1991 }
1992 if this.Field7 != nil {
1993 s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
1994 }
1995 if this.XXX_unrecognized != nil {
1996 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1997 }
1998 s = append(s, "}")
1999 return strings.Join(s, "")
2000 }
2001 func (this *OldU) GoString() string {
2002 if this == nil {
2003 return "nil"
2004 }
2005 s := make([]string, 0, 6)
2006 s = append(s, "&unrecognized.OldU{")
2007 if this.Field1 != nil {
2008 s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "string")+",\n")
2009 }
2010 if this.Field2 != nil {
2011 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
2012 }
2013 if this.XXX_unrecognized != nil {
2014 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
2015 }
2016 s = append(s, "}")
2017 return strings.Join(s, "")
2018 }
2019 func (this *OldUnoM) GoString() string {
2020 if this == nil {
2021 return "nil"
2022 }
2023 s := make([]string, 0, 6)
2024 s = append(s, "&unrecognized.OldUnoM{")
2025 if this.Field1 != nil {
2026 s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "string")+",\n")
2027 }
2028 if this.Field2 != nil {
2029 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
2030 }
2031 if this.XXX_unrecognized != nil {
2032 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
2033 }
2034 s = append(s, "}")
2035 return strings.Join(s, "")
2036 }
2037 func valueToGoStringUnrecognized(v interface{}, typ string) string {
2038 rv := reflect.ValueOf(v)
2039 if rv.IsNil() {
2040 return "nil"
2041 }
2042 pv := reflect.Indirect(rv).Interface()
2043 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
2044 }
2045 func (m *A) Marshal() (dAtA []byte, err error) {
2046 size := m.Size()
2047 dAtA = make([]byte, size)
2048 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2049 if err != nil {
2050 return nil, err
2051 }
2052 return dAtA[:n], nil
2053 }
2054
2055 func (m *A) MarshalTo(dAtA []byte) (int, error) {
2056 size := m.Size()
2057 return m.MarshalToSizedBuffer(dAtA[:size])
2058 }
2059
2060 func (m *A) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2061 i := len(dAtA)
2062 _ = i
2063 var l int
2064 _ = l
2065 if m.Field1 != nil {
2066 i = encodeVarintUnrecognized(dAtA, i, uint64(*m.Field1))
2067 i--
2068 dAtA[i] = 0x10
2069 }
2070 if len(m.B) > 0 {
2071 for iNdEx := len(m.B) - 1; iNdEx >= 0; iNdEx-- {
2072 {
2073 size, err := m.B[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2074 if err != nil {
2075 return 0, err
2076 }
2077 i -= size
2078 i = encodeVarintUnrecognized(dAtA, i, uint64(size))
2079 }
2080 i--
2081 dAtA[i] = 0xa
2082 }
2083 }
2084 return len(dAtA) - i, nil
2085 }
2086
2087 func (m *B) Marshal() (dAtA []byte, err error) {
2088 size := m.Size()
2089 dAtA = make([]byte, size)
2090 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2091 if err != nil {
2092 return nil, err
2093 }
2094 return dAtA[:n], nil
2095 }
2096
2097 func (m *B) MarshalTo(dAtA []byte) (int, error) {
2098 size := m.Size()
2099 return m.MarshalToSizedBuffer(dAtA[:size])
2100 }
2101
2102 func (m *B) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2103 i := len(dAtA)
2104 _ = i
2105 var l int
2106 _ = l
2107 if m.XXX_unrecognized != nil {
2108 i -= len(m.XXX_unrecognized)
2109 copy(dAtA[i:], m.XXX_unrecognized)
2110 }
2111 if m.F != nil {
2112 {
2113 size, err := m.F.MarshalToSizedBuffer(dAtA[:i])
2114 if err != nil {
2115 return 0, err
2116 }
2117 i -= size
2118 i = encodeVarintUnrecognized(dAtA, i, uint64(size))
2119 }
2120 i--
2121 dAtA[i] = 0x2a
2122 }
2123 if m.D != nil {
2124 {
2125 size, err := m.D.MarshalToSizedBuffer(dAtA[:i])
2126 if err != nil {
2127 return 0, err
2128 }
2129 i -= size
2130 i = encodeVarintUnrecognized(dAtA, i, uint64(size))
2131 }
2132 i--
2133 dAtA[i] = 0x12
2134 }
2135 if m.C != nil {
2136 {
2137 size, err := m.C.MarshalToSizedBuffer(dAtA[:i])
2138 if err != nil {
2139 return 0, err
2140 }
2141 i -= size
2142 i = encodeVarintUnrecognized(dAtA, i, uint64(size))
2143 }
2144 i--
2145 dAtA[i] = 0xa
2146 }
2147 return len(dAtA) - i, nil
2148 }
2149
2150 func (m *D) Marshal() (dAtA []byte, err error) {
2151 size := m.Size()
2152 dAtA = make([]byte, size)
2153 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2154 if err != nil {
2155 return nil, err
2156 }
2157 return dAtA[:n], nil
2158 }
2159
2160 func (m *D) MarshalTo(dAtA []byte) (int, error) {
2161 size := m.Size()
2162 return m.MarshalToSizedBuffer(dAtA[:size])
2163 }
2164
2165 func (m *D) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2166 i := len(dAtA)
2167 _ = i
2168 var l int
2169 _ = l
2170 if m.XXX_unrecognized != nil {
2171 i -= len(m.XXX_unrecognized)
2172 copy(dAtA[i:], m.XXX_unrecognized)
2173 }
2174 if m.Field1 != nil {
2175 i = encodeVarintUnrecognized(dAtA, i, uint64(*m.Field1))
2176 i--
2177 dAtA[i] = 0x8
2178 }
2179 return len(dAtA) - i, nil
2180 }
2181
2182 func (m *C) Marshal() (dAtA []byte, err error) {
2183 size := m.Size()
2184 dAtA = make([]byte, size)
2185 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2186 if err != nil {
2187 return nil, err
2188 }
2189 return dAtA[:n], nil
2190 }
2191
2192 func (m *C) MarshalTo(dAtA []byte) (int, error) {
2193 size := m.Size()
2194 return m.MarshalToSizedBuffer(dAtA[:size])
2195 }
2196
2197 func (m *C) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2198 i := len(dAtA)
2199 _ = i
2200 var l int
2201 _ = l
2202 if m.XXX_unrecognized != nil {
2203 i -= len(m.XXX_unrecognized)
2204 copy(dAtA[i:], m.XXX_unrecognized)
2205 }
2206 if len(m.Field7) > 0 {
2207 for iNdEx := len(m.Field7) - 1; iNdEx >= 0; iNdEx-- {
2208 f4 := math.Float32bits(float32(m.Field7[iNdEx]))
2209 i -= 4
2210 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f4))
2211 i--
2212 dAtA[i] = 0x3d
2213 }
2214 }
2215 if m.Field6 != nil {
2216 i = encodeVarintUnrecognized(dAtA, i, uint64(*m.Field6))
2217 i--
2218 dAtA[i] = 0x30
2219 }
2220 if len(m.Field5) > 0 {
2221 for iNdEx := len(m.Field5) - 1; iNdEx >= 0; iNdEx-- {
2222 i -= len(m.Field5[iNdEx])
2223 copy(dAtA[i:], m.Field5[iNdEx])
2224 i = encodeVarintUnrecognized(dAtA, i, uint64(len(m.Field5[iNdEx])))
2225 i--
2226 dAtA[i] = 0x2a
2227 }
2228 }
2229 if m.Field4 != nil {
2230 i -= 8
2231 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Field4))))
2232 i--
2233 dAtA[i] = 0x21
2234 }
2235 if m.Field3 != nil {
2236 i -= len(*m.Field3)
2237 copy(dAtA[i:], *m.Field3)
2238 i = encodeVarintUnrecognized(dAtA, i, uint64(len(*m.Field3)))
2239 i--
2240 dAtA[i] = 0x1a
2241 }
2242 if m.Field2 != nil {
2243 i -= 8
2244 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Field2))))
2245 i--
2246 dAtA[i] = 0x11
2247 }
2248 return len(dAtA) - i, nil
2249 }
2250
2251 func (m *U) Marshal() (dAtA []byte, err error) {
2252 size := m.Size()
2253 dAtA = make([]byte, size)
2254 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2255 if err != nil {
2256 return nil, err
2257 }
2258 return dAtA[:n], nil
2259 }
2260
2261 func (m *U) MarshalTo(dAtA []byte) (int, error) {
2262 size := m.Size()
2263 return m.MarshalToSizedBuffer(dAtA[:size])
2264 }
2265
2266 func (m *U) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2267 i := len(dAtA)
2268 _ = i
2269 var l int
2270 _ = l
2271 if m.Field3 != nil {
2272 i = encodeVarintUnrecognized(dAtA, i, uint64(*m.Field3))
2273 i--
2274 dAtA[i] = 0x18
2275 }
2276 if len(m.Field2) > 0 {
2277 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
2278 f5 := math.Float64bits(float64(m.Field2[iNdEx]))
2279 i -= 8
2280 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f5))
2281 i--
2282 dAtA[i] = 0x11
2283 }
2284 }
2285 return len(dAtA) - i, nil
2286 }
2287
2288 func (m *OldA) Marshal() (dAtA []byte, err error) {
2289 size := m.Size()
2290 dAtA = make([]byte, size)
2291 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2292 if err != nil {
2293 return nil, err
2294 }
2295 return dAtA[:n], nil
2296 }
2297
2298 func (m *OldA) MarshalTo(dAtA []byte) (int, error) {
2299 size := m.Size()
2300 return m.MarshalToSizedBuffer(dAtA[:size])
2301 }
2302
2303 func (m *OldA) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2304 i := len(dAtA)
2305 _ = i
2306 var l int
2307 _ = l
2308 if m.Field1 != nil {
2309 i = encodeVarintUnrecognized(dAtA, i, uint64(*m.Field1))
2310 i--
2311 dAtA[i] = 0x10
2312 }
2313 if len(m.B) > 0 {
2314 for iNdEx := len(m.B) - 1; iNdEx >= 0; iNdEx-- {
2315 {
2316 size, err := m.B[iNdEx].MarshalToSizedBuffer(dAtA[:i])
2317 if err != nil {
2318 return 0, err
2319 }
2320 i -= size
2321 i = encodeVarintUnrecognized(dAtA, i, uint64(size))
2322 }
2323 i--
2324 dAtA[i] = 0xa
2325 }
2326 }
2327 return len(dAtA) - i, nil
2328 }
2329
2330 func (m *OldB) Marshal() (dAtA []byte, err error) {
2331 size := m.Size()
2332 dAtA = make([]byte, size)
2333 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2334 if err != nil {
2335 return nil, err
2336 }
2337 return dAtA[:n], nil
2338 }
2339
2340 func (m *OldB) MarshalTo(dAtA []byte) (int, error) {
2341 size := m.Size()
2342 return m.MarshalToSizedBuffer(dAtA[:size])
2343 }
2344
2345 func (m *OldB) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2346 i := len(dAtA)
2347 _ = i
2348 var l int
2349 _ = l
2350 if m.XXX_unrecognized != nil {
2351 i -= len(m.XXX_unrecognized)
2352 copy(dAtA[i:], m.XXX_unrecognized)
2353 }
2354 if m.F != nil {
2355 {
2356 size, err := m.F.MarshalToSizedBuffer(dAtA[:i])
2357 if err != nil {
2358 return 0, err
2359 }
2360 i -= size
2361 i = encodeVarintUnrecognized(dAtA, i, uint64(size))
2362 }
2363 i--
2364 dAtA[i] = 0x2a
2365 }
2366 if m.C != nil {
2367 {
2368 size, err := m.C.MarshalToSizedBuffer(dAtA[:i])
2369 if err != nil {
2370 return 0, err
2371 }
2372 i -= size
2373 i = encodeVarintUnrecognized(dAtA, i, uint64(size))
2374 }
2375 i--
2376 dAtA[i] = 0xa
2377 }
2378 return len(dAtA) - i, nil
2379 }
2380
2381 func (m *OldC) Marshal() (dAtA []byte, err error) {
2382 size := m.Size()
2383 dAtA = make([]byte, size)
2384 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2385 if err != nil {
2386 return nil, err
2387 }
2388 return dAtA[:n], nil
2389 }
2390
2391 func (m *OldC) MarshalTo(dAtA []byte) (int, error) {
2392 size := m.Size()
2393 return m.MarshalToSizedBuffer(dAtA[:size])
2394 }
2395
2396 func (m *OldC) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2397 i := len(dAtA)
2398 _ = i
2399 var l int
2400 _ = l
2401 if m.XXX_unrecognized != nil {
2402 i -= len(m.XXX_unrecognized)
2403 copy(dAtA[i:], m.XXX_unrecognized)
2404 }
2405 if len(m.Field7) > 0 {
2406 for iNdEx := len(m.Field7) - 1; iNdEx >= 0; iNdEx-- {
2407 f8 := math.Float32bits(float32(m.Field7[iNdEx]))
2408 i -= 4
2409 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f8))
2410 i--
2411 dAtA[i] = 0x3d
2412 }
2413 }
2414 if m.Field6 != nil {
2415 i = encodeVarintUnrecognized(dAtA, i, uint64(*m.Field6))
2416 i--
2417 dAtA[i] = 0x30
2418 }
2419 if m.Field3 != nil {
2420 i -= len(*m.Field3)
2421 copy(dAtA[i:], *m.Field3)
2422 i = encodeVarintUnrecognized(dAtA, i, uint64(len(*m.Field3)))
2423 i--
2424 dAtA[i] = 0x1a
2425 }
2426 if m.Field2 != nil {
2427 i -= 8
2428 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Field2))))
2429 i--
2430 dAtA[i] = 0x11
2431 }
2432 if m.Field1 != nil {
2433 i = encodeVarintUnrecognized(dAtA, i, uint64(*m.Field1))
2434 i--
2435 dAtA[i] = 0x8
2436 }
2437 return len(dAtA) - i, nil
2438 }
2439
2440 func (m *OldU) Marshal() (dAtA []byte, err error) {
2441 size := m.Size()
2442 dAtA = make([]byte, size)
2443 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2444 if err != nil {
2445 return nil, err
2446 }
2447 return dAtA[:n], nil
2448 }
2449
2450 func (m *OldU) MarshalTo(dAtA []byte) (int, error) {
2451 size := m.Size()
2452 return m.MarshalToSizedBuffer(dAtA[:size])
2453 }
2454
2455 func (m *OldU) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2456 i := len(dAtA)
2457 _ = i
2458 var l int
2459 _ = l
2460 if m.XXX_unrecognized != nil {
2461 i -= len(m.XXX_unrecognized)
2462 copy(dAtA[i:], m.XXX_unrecognized)
2463 }
2464 if len(m.Field2) > 0 {
2465 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
2466 f9 := math.Float64bits(float64(m.Field2[iNdEx]))
2467 i -= 8
2468 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f9))
2469 i--
2470 dAtA[i] = 0x11
2471 }
2472 }
2473 if m.Field1 != nil {
2474 i -= len(*m.Field1)
2475 copy(dAtA[i:], *m.Field1)
2476 i = encodeVarintUnrecognized(dAtA, i, uint64(len(*m.Field1)))
2477 i--
2478 dAtA[i] = 0xa
2479 }
2480 return len(dAtA) - i, nil
2481 }
2482
2483 func encodeVarintUnrecognized(dAtA []byte, offset int, v uint64) int {
2484 offset -= sovUnrecognized(v)
2485 base := offset
2486 for v >= 1<<7 {
2487 dAtA[offset] = uint8(v&0x7f | 0x80)
2488 v >>= 7
2489 offset++
2490 }
2491 dAtA[offset] = uint8(v)
2492 return base
2493 }
2494 func NewPopulatedA(r randyUnrecognized, easy bool) *A {
2495 this := &A{}
2496 if r.Intn(5) != 0 {
2497 v1 := r.Intn(5)
2498 this.B = make([]*B, v1)
2499 for i := 0; i < v1; i++ {
2500 this.B[i] = NewPopulatedB(r, easy)
2501 }
2502 }
2503 if r.Intn(5) != 0 {
2504 v2 := int64(r.Int63())
2505 if r.Intn(2) == 0 {
2506 v2 *= -1
2507 }
2508 this.Field1 = &v2
2509 }
2510 if !easy && r.Intn(10) != 0 {
2511 }
2512 return this
2513 }
2514
2515 func NewPopulatedB(r randyUnrecognized, easy bool) *B {
2516 this := &B{}
2517 if r.Intn(5) != 0 {
2518 this.C = NewPopulatedC(r, easy)
2519 }
2520 if r.Intn(5) != 0 {
2521 this.D = NewPopulatedD(r, easy)
2522 }
2523 if r.Intn(5) != 0 {
2524 this.F = NewPopulatedOldC(r, easy)
2525 }
2526 if !easy && r.Intn(10) != 0 {
2527 this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 6)
2528 }
2529 return this
2530 }
2531
2532 func NewPopulatedD(r randyUnrecognized, easy bool) *D {
2533 this := &D{}
2534 if r.Intn(5) != 0 {
2535 v3 := int64(r.Int63())
2536 if r.Intn(2) == 0 {
2537 v3 *= -1
2538 }
2539 this.Field1 = &v3
2540 }
2541 if !easy && r.Intn(10) != 0 {
2542 this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 2)
2543 }
2544 return this
2545 }
2546
2547 func NewPopulatedC(r randyUnrecognized, easy bool) *C {
2548 this := &C{}
2549 if r.Intn(5) != 0 {
2550 v4 := float64(r.Float64())
2551 if r.Intn(2) == 0 {
2552 v4 *= -1
2553 }
2554 this.Field2 = &v4
2555 }
2556 if r.Intn(5) != 0 {
2557 v5 := string(randStringUnrecognized(r))
2558 this.Field3 = &v5
2559 }
2560 if r.Intn(5) != 0 {
2561 v6 := float64(r.Float64())
2562 if r.Intn(2) == 0 {
2563 v6 *= -1
2564 }
2565 this.Field4 = &v6
2566 }
2567 if r.Intn(5) != 0 {
2568 v7 := r.Intn(10)
2569 this.Field5 = make([][]byte, v7)
2570 for i := 0; i < v7; i++ {
2571 v8 := r.Intn(100)
2572 this.Field5[i] = make([]byte, v8)
2573 for j := 0; j < v8; j++ {
2574 this.Field5[i][j] = byte(r.Intn(256))
2575 }
2576 }
2577 }
2578 if r.Intn(5) != 0 {
2579 v9 := int64(r.Int63())
2580 if r.Intn(2) == 0 {
2581 v9 *= -1
2582 }
2583 this.Field6 = &v9
2584 }
2585 if r.Intn(5) != 0 {
2586 v10 := r.Intn(10)
2587 this.Field7 = make([]float32, v10)
2588 for i := 0; i < v10; i++ {
2589 this.Field7[i] = float32(r.Float32())
2590 if r.Intn(2) == 0 {
2591 this.Field7[i] *= -1
2592 }
2593 }
2594 }
2595 if !easy && r.Intn(10) != 0 {
2596 this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 8)
2597 }
2598 return this
2599 }
2600
2601 func NewPopulatedU(r randyUnrecognized, easy bool) *U {
2602 this := &U{}
2603 if r.Intn(5) != 0 {
2604 v11 := r.Intn(10)
2605 this.Field2 = make([]float64, v11)
2606 for i := 0; i < v11; i++ {
2607 this.Field2[i] = float64(r.Float64())
2608 if r.Intn(2) == 0 {
2609 this.Field2[i] *= -1
2610 }
2611 }
2612 }
2613 if r.Intn(5) != 0 {
2614 v12 := uint32(r.Uint32())
2615 this.Field3 = &v12
2616 }
2617 if !easy && r.Intn(10) != 0 {
2618 }
2619 return this
2620 }
2621
2622 func NewPopulatedUnoM(r randyUnrecognized, easy bool) *UnoM {
2623 this := &UnoM{}
2624 if r.Intn(5) != 0 {
2625 v13 := r.Intn(10)
2626 this.Field2 = make([]float64, v13)
2627 for i := 0; i < v13; i++ {
2628 this.Field2[i] = float64(r.Float64())
2629 if r.Intn(2) == 0 {
2630 this.Field2[i] *= -1
2631 }
2632 }
2633 }
2634 if r.Intn(5) != 0 {
2635 v14 := uint32(r.Uint32())
2636 this.Field3 = &v14
2637 }
2638 if !easy && r.Intn(10) != 0 {
2639 }
2640 return this
2641 }
2642
2643 func NewPopulatedOldA(r randyUnrecognized, easy bool) *OldA {
2644 this := &OldA{}
2645 if r.Intn(5) != 0 {
2646 v15 := r.Intn(5)
2647 this.B = make([]*OldB, v15)
2648 for i := 0; i < v15; i++ {
2649 this.B[i] = NewPopulatedOldB(r, easy)
2650 }
2651 }
2652 if r.Intn(5) != 0 {
2653 v16 := int64(r.Int63())
2654 if r.Intn(2) == 0 {
2655 v16 *= -1
2656 }
2657 this.Field1 = &v16
2658 }
2659 if !easy && r.Intn(10) != 0 {
2660 }
2661 return this
2662 }
2663
2664 func NewPopulatedOldB(r randyUnrecognized, easy bool) *OldB {
2665 this := &OldB{}
2666 if r.Intn(5) != 0 {
2667 this.C = NewPopulatedOldC(r, easy)
2668 }
2669 if r.Intn(5) != 0 {
2670 this.F = NewPopulatedOldC(r, easy)
2671 }
2672 if !easy && r.Intn(10) != 0 {
2673 this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 6)
2674 }
2675 return this
2676 }
2677
2678 func NewPopulatedOldC(r randyUnrecognized, easy bool) *OldC {
2679 this := &OldC{}
2680 if r.Intn(5) != 0 {
2681 v17 := int64(r.Int63())
2682 if r.Intn(2) == 0 {
2683 v17 *= -1
2684 }
2685 this.Field1 = &v17
2686 }
2687 if r.Intn(5) != 0 {
2688 v18 := float64(r.Float64())
2689 if r.Intn(2) == 0 {
2690 v18 *= -1
2691 }
2692 this.Field2 = &v18
2693 }
2694 if r.Intn(5) != 0 {
2695 v19 := string(randStringUnrecognized(r))
2696 this.Field3 = &v19
2697 }
2698 if r.Intn(5) != 0 {
2699 v20 := int64(r.Int63())
2700 if r.Intn(2) == 0 {
2701 v20 *= -1
2702 }
2703 this.Field6 = &v20
2704 }
2705 if r.Intn(5) != 0 {
2706 v21 := r.Intn(10)
2707 this.Field7 = make([]float32, v21)
2708 for i := 0; i < v21; i++ {
2709 this.Field7[i] = float32(r.Float32())
2710 if r.Intn(2) == 0 {
2711 this.Field7[i] *= -1
2712 }
2713 }
2714 }
2715 if !easy && r.Intn(10) != 0 {
2716 this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 8)
2717 }
2718 return this
2719 }
2720
2721 func NewPopulatedOldU(r randyUnrecognized, easy bool) *OldU {
2722 this := &OldU{}
2723 if r.Intn(5) != 0 {
2724 v22 := string(randStringUnrecognized(r))
2725 this.Field1 = &v22
2726 }
2727 if r.Intn(5) != 0 {
2728 v23 := r.Intn(10)
2729 this.Field2 = make([]float64, v23)
2730 for i := 0; i < v23; i++ {
2731 this.Field2[i] = float64(r.Float64())
2732 if r.Intn(2) == 0 {
2733 this.Field2[i] *= -1
2734 }
2735 }
2736 }
2737 if !easy && r.Intn(10) != 0 {
2738 this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 3)
2739 }
2740 return this
2741 }
2742
2743 func NewPopulatedOldUnoM(r randyUnrecognized, easy bool) *OldUnoM {
2744 this := &OldUnoM{}
2745 if r.Intn(5) != 0 {
2746 v24 := string(randStringUnrecognized(r))
2747 this.Field1 = &v24
2748 }
2749 if r.Intn(5) != 0 {
2750 v25 := r.Intn(10)
2751 this.Field2 = make([]float64, v25)
2752 for i := 0; i < v25; i++ {
2753 this.Field2[i] = float64(r.Float64())
2754 if r.Intn(2) == 0 {
2755 this.Field2[i] *= -1
2756 }
2757 }
2758 }
2759 if !easy && r.Intn(10) != 0 {
2760 this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 3)
2761 }
2762 return this
2763 }
2764
2765 type randyUnrecognized interface {
2766 Float32() float32
2767 Float64() float64
2768 Int63() int64
2769 Int31() int32
2770 Uint32() uint32
2771 Intn(n int) int
2772 }
2773
2774 func randUTF8RuneUnrecognized(r randyUnrecognized) rune {
2775 ru := r.Intn(62)
2776 if ru < 10 {
2777 return rune(ru + 48)
2778 } else if ru < 36 {
2779 return rune(ru + 55)
2780 }
2781 return rune(ru + 61)
2782 }
2783 func randStringUnrecognized(r randyUnrecognized) string {
2784 v26 := r.Intn(100)
2785 tmps := make([]rune, v26)
2786 for i := 0; i < v26; i++ {
2787 tmps[i] = randUTF8RuneUnrecognized(r)
2788 }
2789 return string(tmps)
2790 }
2791 func randUnrecognizedUnrecognized(r randyUnrecognized, maxFieldNumber int) (dAtA []byte) {
2792 l := r.Intn(5)
2793 for i := 0; i < l; i++ {
2794 wire := r.Intn(4)
2795 if wire == 3 {
2796 wire = 5
2797 }
2798 fieldNumber := maxFieldNumber + r.Intn(100)
2799 dAtA = randFieldUnrecognized(dAtA, r, fieldNumber, wire)
2800 }
2801 return dAtA
2802 }
2803 func randFieldUnrecognized(dAtA []byte, r randyUnrecognized, fieldNumber int, wire int) []byte {
2804 key := uint32(fieldNumber)<<3 | uint32(wire)
2805 switch wire {
2806 case 0:
2807 dAtA = encodeVarintPopulateUnrecognized(dAtA, uint64(key))
2808 v27 := r.Int63()
2809 if r.Intn(2) == 0 {
2810 v27 *= -1
2811 }
2812 dAtA = encodeVarintPopulateUnrecognized(dAtA, uint64(v27))
2813 case 1:
2814 dAtA = encodeVarintPopulateUnrecognized(dAtA, uint64(key))
2815 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)))
2816 case 2:
2817 dAtA = encodeVarintPopulateUnrecognized(dAtA, uint64(key))
2818 ll := r.Intn(100)
2819 dAtA = encodeVarintPopulateUnrecognized(dAtA, uint64(ll))
2820 for j := 0; j < ll; j++ {
2821 dAtA = append(dAtA, byte(r.Intn(256)))
2822 }
2823 default:
2824 dAtA = encodeVarintPopulateUnrecognized(dAtA, uint64(key))
2825 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
2826 }
2827 return dAtA
2828 }
2829 func encodeVarintPopulateUnrecognized(dAtA []byte, v uint64) []byte {
2830 for v >= 1<<7 {
2831 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
2832 v >>= 7
2833 }
2834 dAtA = append(dAtA, uint8(v))
2835 return dAtA
2836 }
2837 func (m *A) Size() (n int) {
2838 if m == nil {
2839 return 0
2840 }
2841 var l int
2842 _ = l
2843 if len(m.B) > 0 {
2844 for _, e := range m.B {
2845 l = e.Size()
2846 n += 1 + l + sovUnrecognized(uint64(l))
2847 }
2848 }
2849 if m.Field1 != nil {
2850 n += 1 + sovUnrecognized(uint64(*m.Field1))
2851 }
2852 return n
2853 }
2854
2855 func (m *B) Size() (n int) {
2856 if m == nil {
2857 return 0
2858 }
2859 var l int
2860 _ = l
2861 if m.C != nil {
2862 l = m.C.Size()
2863 n += 1 + l + sovUnrecognized(uint64(l))
2864 }
2865 if m.D != nil {
2866 l = m.D.Size()
2867 n += 1 + l + sovUnrecognized(uint64(l))
2868 }
2869 if m.F != nil {
2870 l = m.F.Size()
2871 n += 1 + l + sovUnrecognized(uint64(l))
2872 }
2873 if m.XXX_unrecognized != nil {
2874 n += len(m.XXX_unrecognized)
2875 }
2876 return n
2877 }
2878
2879 func (m *D) Size() (n int) {
2880 if m == nil {
2881 return 0
2882 }
2883 var l int
2884 _ = l
2885 if m.Field1 != nil {
2886 n += 1 + sovUnrecognized(uint64(*m.Field1))
2887 }
2888 if m.XXX_unrecognized != nil {
2889 n += len(m.XXX_unrecognized)
2890 }
2891 return n
2892 }
2893
2894 func (m *C) Size() (n int) {
2895 if m == nil {
2896 return 0
2897 }
2898 var l int
2899 _ = l
2900 if m.Field2 != nil {
2901 n += 9
2902 }
2903 if m.Field3 != nil {
2904 l = len(*m.Field3)
2905 n += 1 + l + sovUnrecognized(uint64(l))
2906 }
2907 if m.Field4 != nil {
2908 n += 9
2909 }
2910 if len(m.Field5) > 0 {
2911 for _, b := range m.Field5 {
2912 l = len(b)
2913 n += 1 + l + sovUnrecognized(uint64(l))
2914 }
2915 }
2916 if m.Field6 != nil {
2917 n += 1 + sovUnrecognized(uint64(*m.Field6))
2918 }
2919 if len(m.Field7) > 0 {
2920 n += 5 * len(m.Field7)
2921 }
2922 if m.XXX_unrecognized != nil {
2923 n += len(m.XXX_unrecognized)
2924 }
2925 return n
2926 }
2927
2928 func (m *U) Size() (n int) {
2929 if m == nil {
2930 return 0
2931 }
2932 var l int
2933 _ = l
2934 if len(m.Field2) > 0 {
2935 n += 9 * len(m.Field2)
2936 }
2937 if m.Field3 != nil {
2938 n += 1 + sovUnrecognized(uint64(*m.Field3))
2939 }
2940 return n
2941 }
2942
2943 func (m *OldA) Size() (n int) {
2944 if m == nil {
2945 return 0
2946 }
2947 var l int
2948 _ = l
2949 if len(m.B) > 0 {
2950 for _, e := range m.B {
2951 l = e.Size()
2952 n += 1 + l + sovUnrecognized(uint64(l))
2953 }
2954 }
2955 if m.Field1 != nil {
2956 n += 1 + sovUnrecognized(uint64(*m.Field1))
2957 }
2958 return n
2959 }
2960
2961 func (m *OldB) Size() (n int) {
2962 if m == nil {
2963 return 0
2964 }
2965 var l int
2966 _ = l
2967 if m.C != nil {
2968 l = m.C.Size()
2969 n += 1 + l + sovUnrecognized(uint64(l))
2970 }
2971 if m.F != nil {
2972 l = m.F.Size()
2973 n += 1 + l + sovUnrecognized(uint64(l))
2974 }
2975 if m.XXX_unrecognized != nil {
2976 n += len(m.XXX_unrecognized)
2977 }
2978 return n
2979 }
2980
2981 func (m *OldC) Size() (n int) {
2982 if m == nil {
2983 return 0
2984 }
2985 var l int
2986 _ = l
2987 if m.Field1 != nil {
2988 n += 1 + sovUnrecognized(uint64(*m.Field1))
2989 }
2990 if m.Field2 != nil {
2991 n += 9
2992 }
2993 if m.Field3 != nil {
2994 l = len(*m.Field3)
2995 n += 1 + l + sovUnrecognized(uint64(l))
2996 }
2997 if m.Field6 != nil {
2998 n += 1 + sovUnrecognized(uint64(*m.Field6))
2999 }
3000 if len(m.Field7) > 0 {
3001 n += 5 * len(m.Field7)
3002 }
3003 if m.XXX_unrecognized != nil {
3004 n += len(m.XXX_unrecognized)
3005 }
3006 return n
3007 }
3008
3009 func (m *OldU) Size() (n int) {
3010 if m == nil {
3011 return 0
3012 }
3013 var l int
3014 _ = l
3015 if m.Field1 != nil {
3016 l = len(*m.Field1)
3017 n += 1 + l + sovUnrecognized(uint64(l))
3018 }
3019 if len(m.Field2) > 0 {
3020 n += 9 * len(m.Field2)
3021 }
3022 if m.XXX_unrecognized != nil {
3023 n += len(m.XXX_unrecognized)
3024 }
3025 return n
3026 }
3027
3028 func sovUnrecognized(x uint64) (n int) {
3029 return (math_bits.Len64(x|1) + 6) / 7
3030 }
3031 func sozUnrecognized(x uint64) (n int) {
3032 return sovUnrecognized(uint64((x << 1) ^ uint64((int64(x) >> 63))))
3033 }
3034 func (this *A) String() string {
3035 if this == nil {
3036 return "nil"
3037 }
3038 repeatedStringForB := "[]*B{"
3039 for _, f := range this.B {
3040 repeatedStringForB += strings.Replace(f.String(), "B", "B", 1) + ","
3041 }
3042 repeatedStringForB += "}"
3043 s := strings.Join([]string{`&A{`,
3044 `B:` + repeatedStringForB + `,`,
3045 `Field1:` + valueToStringUnrecognized(this.Field1) + `,`,
3046 `}`,
3047 }, "")
3048 return s
3049 }
3050 func (this *B) String() string {
3051 if this == nil {
3052 return "nil"
3053 }
3054 s := strings.Join([]string{`&B{`,
3055 `C:` + strings.Replace(this.C.String(), "C", "C", 1) + `,`,
3056 `D:` + strings.Replace(this.D.String(), "D", "D", 1) + `,`,
3057 `F:` + strings.Replace(this.F.String(), "OldC", "OldC", 1) + `,`,
3058 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3059 `}`,
3060 }, "")
3061 return s
3062 }
3063 func (this *D) String() string {
3064 if this == nil {
3065 return "nil"
3066 }
3067 s := strings.Join([]string{`&D{`,
3068 `Field1:` + valueToStringUnrecognized(this.Field1) + `,`,
3069 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3070 `}`,
3071 }, "")
3072 return s
3073 }
3074 func (this *C) String() string {
3075 if this == nil {
3076 return "nil"
3077 }
3078 s := strings.Join([]string{`&C{`,
3079 `Field2:` + valueToStringUnrecognized(this.Field2) + `,`,
3080 `Field3:` + valueToStringUnrecognized(this.Field3) + `,`,
3081 `Field4:` + valueToStringUnrecognized(this.Field4) + `,`,
3082 `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`,
3083 `Field6:` + valueToStringUnrecognized(this.Field6) + `,`,
3084 `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
3085 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3086 `}`,
3087 }, "")
3088 return s
3089 }
3090 func (this *U) String() string {
3091 if this == nil {
3092 return "nil"
3093 }
3094 s := strings.Join([]string{`&U{`,
3095 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
3096 `Field3:` + valueToStringUnrecognized(this.Field3) + `,`,
3097 `}`,
3098 }, "")
3099 return s
3100 }
3101 func (this *UnoM) String() string {
3102 if this == nil {
3103 return "nil"
3104 }
3105 s := strings.Join([]string{`&UnoM{`,
3106 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
3107 `Field3:` + valueToStringUnrecognized(this.Field3) + `,`,
3108 `}`,
3109 }, "")
3110 return s
3111 }
3112 func (this *OldA) String() string {
3113 if this == nil {
3114 return "nil"
3115 }
3116 repeatedStringForB := "[]*OldB{"
3117 for _, f := range this.B {
3118 repeatedStringForB += strings.Replace(f.String(), "OldB", "OldB", 1) + ","
3119 }
3120 repeatedStringForB += "}"
3121 s := strings.Join([]string{`&OldA{`,
3122 `B:` + repeatedStringForB + `,`,
3123 `Field1:` + valueToStringUnrecognized(this.Field1) + `,`,
3124 `}`,
3125 }, "")
3126 return s
3127 }
3128 func (this *OldB) String() string {
3129 if this == nil {
3130 return "nil"
3131 }
3132 s := strings.Join([]string{`&OldB{`,
3133 `C:` + strings.Replace(this.C.String(), "OldC", "OldC", 1) + `,`,
3134 `F:` + strings.Replace(this.F.String(), "OldC", "OldC", 1) + `,`,
3135 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3136 `}`,
3137 }, "")
3138 return s
3139 }
3140 func (this *OldC) String() string {
3141 if this == nil {
3142 return "nil"
3143 }
3144 s := strings.Join([]string{`&OldC{`,
3145 `Field1:` + valueToStringUnrecognized(this.Field1) + `,`,
3146 `Field2:` + valueToStringUnrecognized(this.Field2) + `,`,
3147 `Field3:` + valueToStringUnrecognized(this.Field3) + `,`,
3148 `Field6:` + valueToStringUnrecognized(this.Field6) + `,`,
3149 `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
3150 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3151 `}`,
3152 }, "")
3153 return s
3154 }
3155 func (this *OldU) String() string {
3156 if this == nil {
3157 return "nil"
3158 }
3159 s := strings.Join([]string{`&OldU{`,
3160 `Field1:` + valueToStringUnrecognized(this.Field1) + `,`,
3161 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
3162 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3163 `}`,
3164 }, "")
3165 return s
3166 }
3167 func (this *OldUnoM) String() string {
3168 if this == nil {
3169 return "nil"
3170 }
3171 s := strings.Join([]string{`&OldUnoM{`,
3172 `Field1:` + valueToStringUnrecognized(this.Field1) + `,`,
3173 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
3174 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3175 `}`,
3176 }, "")
3177 return s
3178 }
3179 func valueToStringUnrecognized(v interface{}) string {
3180 rv := reflect.ValueOf(v)
3181 if rv.IsNil() {
3182 return "nil"
3183 }
3184 pv := reflect.Indirect(rv).Interface()
3185 return fmt.Sprintf("*%v", pv)
3186 }
3187 func (m *A) Unmarshal(dAtA []byte) error {
3188 l := len(dAtA)
3189 iNdEx := 0
3190 for iNdEx < l {
3191 preIndex := iNdEx
3192 var wire uint64
3193 for shift := uint(0); ; shift += 7 {
3194 if shift >= 64 {
3195 return ErrIntOverflowUnrecognized
3196 }
3197 if iNdEx >= l {
3198 return io.ErrUnexpectedEOF
3199 }
3200 b := dAtA[iNdEx]
3201 iNdEx++
3202 wire |= uint64(b&0x7F) << shift
3203 if b < 0x80 {
3204 break
3205 }
3206 }
3207 fieldNum := int32(wire >> 3)
3208 wireType := int(wire & 0x7)
3209 if wireType == 4 {
3210 return fmt.Errorf("proto: A: wiretype end group for non-group")
3211 }
3212 if fieldNum <= 0 {
3213 return fmt.Errorf("proto: A: illegal tag %d (wire type %d)", fieldNum, wire)
3214 }
3215 switch fieldNum {
3216 case 1:
3217 if wireType != 2 {
3218 return fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
3219 }
3220 var msglen int
3221 for shift := uint(0); ; shift += 7 {
3222 if shift >= 64 {
3223 return ErrIntOverflowUnrecognized
3224 }
3225 if iNdEx >= l {
3226 return io.ErrUnexpectedEOF
3227 }
3228 b := dAtA[iNdEx]
3229 iNdEx++
3230 msglen |= int(b&0x7F) << shift
3231 if b < 0x80 {
3232 break
3233 }
3234 }
3235 if msglen < 0 {
3236 return ErrInvalidLengthUnrecognized
3237 }
3238 postIndex := iNdEx + msglen
3239 if postIndex < 0 {
3240 return ErrInvalidLengthUnrecognized
3241 }
3242 if postIndex > l {
3243 return io.ErrUnexpectedEOF
3244 }
3245 m.B = append(m.B, &B{})
3246 if err := m.B[len(m.B)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3247 return err
3248 }
3249 iNdEx = postIndex
3250 case 2:
3251 if wireType != 0 {
3252 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
3253 }
3254 var v int64
3255 for shift := uint(0); ; shift += 7 {
3256 if shift >= 64 {
3257 return ErrIntOverflowUnrecognized
3258 }
3259 if iNdEx >= l {
3260 return io.ErrUnexpectedEOF
3261 }
3262 b := dAtA[iNdEx]
3263 iNdEx++
3264 v |= int64(b&0x7F) << shift
3265 if b < 0x80 {
3266 break
3267 }
3268 }
3269 m.Field1 = &v
3270 default:
3271 iNdEx = preIndex
3272 skippy, err := skipUnrecognized(dAtA[iNdEx:])
3273 if err != nil {
3274 return err
3275 }
3276 if (skippy < 0) || (iNdEx+skippy) < 0 {
3277 return ErrInvalidLengthUnrecognized
3278 }
3279 if (iNdEx + skippy) > l {
3280 return io.ErrUnexpectedEOF
3281 }
3282 iNdEx += skippy
3283 }
3284 }
3285
3286 if iNdEx > l {
3287 return io.ErrUnexpectedEOF
3288 }
3289 return nil
3290 }
3291 func (m *B) Unmarshal(dAtA []byte) error {
3292 l := len(dAtA)
3293 iNdEx := 0
3294 for iNdEx < l {
3295 preIndex := iNdEx
3296 var wire uint64
3297 for shift := uint(0); ; shift += 7 {
3298 if shift >= 64 {
3299 return ErrIntOverflowUnrecognized
3300 }
3301 if iNdEx >= l {
3302 return io.ErrUnexpectedEOF
3303 }
3304 b := dAtA[iNdEx]
3305 iNdEx++
3306 wire |= uint64(b&0x7F) << shift
3307 if b < 0x80 {
3308 break
3309 }
3310 }
3311 fieldNum := int32(wire >> 3)
3312 wireType := int(wire & 0x7)
3313 if wireType == 4 {
3314 return fmt.Errorf("proto: B: wiretype end group for non-group")
3315 }
3316 if fieldNum <= 0 {
3317 return fmt.Errorf("proto: B: illegal tag %d (wire type %d)", fieldNum, wire)
3318 }
3319 switch fieldNum {
3320 case 1:
3321 if wireType != 2 {
3322 return fmt.Errorf("proto: wrong wireType = %d for field C", wireType)
3323 }
3324 var msglen int
3325 for shift := uint(0); ; shift += 7 {
3326 if shift >= 64 {
3327 return ErrIntOverflowUnrecognized
3328 }
3329 if iNdEx >= l {
3330 return io.ErrUnexpectedEOF
3331 }
3332 b := dAtA[iNdEx]
3333 iNdEx++
3334 msglen |= int(b&0x7F) << shift
3335 if b < 0x80 {
3336 break
3337 }
3338 }
3339 if msglen < 0 {
3340 return ErrInvalidLengthUnrecognized
3341 }
3342 postIndex := iNdEx + msglen
3343 if postIndex < 0 {
3344 return ErrInvalidLengthUnrecognized
3345 }
3346 if postIndex > l {
3347 return io.ErrUnexpectedEOF
3348 }
3349 if m.C == nil {
3350 m.C = &C{}
3351 }
3352 if err := m.C.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3353 return err
3354 }
3355 iNdEx = postIndex
3356 case 2:
3357 if wireType != 2 {
3358 return fmt.Errorf("proto: wrong wireType = %d for field D", wireType)
3359 }
3360 var msglen int
3361 for shift := uint(0); ; shift += 7 {
3362 if shift >= 64 {
3363 return ErrIntOverflowUnrecognized
3364 }
3365 if iNdEx >= l {
3366 return io.ErrUnexpectedEOF
3367 }
3368 b := dAtA[iNdEx]
3369 iNdEx++
3370 msglen |= int(b&0x7F) << shift
3371 if b < 0x80 {
3372 break
3373 }
3374 }
3375 if msglen < 0 {
3376 return ErrInvalidLengthUnrecognized
3377 }
3378 postIndex := iNdEx + msglen
3379 if postIndex < 0 {
3380 return ErrInvalidLengthUnrecognized
3381 }
3382 if postIndex > l {
3383 return io.ErrUnexpectedEOF
3384 }
3385 if m.D == nil {
3386 m.D = &D{}
3387 }
3388 if err := m.D.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3389 return err
3390 }
3391 iNdEx = postIndex
3392 case 5:
3393 if wireType != 2 {
3394 return fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
3395 }
3396 var msglen int
3397 for shift := uint(0); ; shift += 7 {
3398 if shift >= 64 {
3399 return ErrIntOverflowUnrecognized
3400 }
3401 if iNdEx >= l {
3402 return io.ErrUnexpectedEOF
3403 }
3404 b := dAtA[iNdEx]
3405 iNdEx++
3406 msglen |= int(b&0x7F) << shift
3407 if b < 0x80 {
3408 break
3409 }
3410 }
3411 if msglen < 0 {
3412 return ErrInvalidLengthUnrecognized
3413 }
3414 postIndex := iNdEx + msglen
3415 if postIndex < 0 {
3416 return ErrInvalidLengthUnrecognized
3417 }
3418 if postIndex > l {
3419 return io.ErrUnexpectedEOF
3420 }
3421 if m.F == nil {
3422 m.F = &OldC{}
3423 }
3424 if err := m.F.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3425 return err
3426 }
3427 iNdEx = postIndex
3428 default:
3429 iNdEx = preIndex
3430 skippy, err := skipUnrecognized(dAtA[iNdEx:])
3431 if err != nil {
3432 return err
3433 }
3434 if (skippy < 0) || (iNdEx+skippy) < 0 {
3435 return ErrInvalidLengthUnrecognized
3436 }
3437 if (iNdEx + skippy) > l {
3438 return io.ErrUnexpectedEOF
3439 }
3440 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3441 iNdEx += skippy
3442 }
3443 }
3444
3445 if iNdEx > l {
3446 return io.ErrUnexpectedEOF
3447 }
3448 return nil
3449 }
3450 func (m *D) Unmarshal(dAtA []byte) error {
3451 l := len(dAtA)
3452 iNdEx := 0
3453 for iNdEx < l {
3454 preIndex := iNdEx
3455 var wire uint64
3456 for shift := uint(0); ; shift += 7 {
3457 if shift >= 64 {
3458 return ErrIntOverflowUnrecognized
3459 }
3460 if iNdEx >= l {
3461 return io.ErrUnexpectedEOF
3462 }
3463 b := dAtA[iNdEx]
3464 iNdEx++
3465 wire |= uint64(b&0x7F) << shift
3466 if b < 0x80 {
3467 break
3468 }
3469 }
3470 fieldNum := int32(wire >> 3)
3471 wireType := int(wire & 0x7)
3472 if wireType == 4 {
3473 return fmt.Errorf("proto: D: wiretype end group for non-group")
3474 }
3475 if fieldNum <= 0 {
3476 return fmt.Errorf("proto: D: illegal tag %d (wire type %d)", fieldNum, wire)
3477 }
3478 switch fieldNum {
3479 case 1:
3480 if wireType != 0 {
3481 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
3482 }
3483 var v int64
3484 for shift := uint(0); ; shift += 7 {
3485 if shift >= 64 {
3486 return ErrIntOverflowUnrecognized
3487 }
3488 if iNdEx >= l {
3489 return io.ErrUnexpectedEOF
3490 }
3491 b := dAtA[iNdEx]
3492 iNdEx++
3493 v |= int64(b&0x7F) << shift
3494 if b < 0x80 {
3495 break
3496 }
3497 }
3498 m.Field1 = &v
3499 default:
3500 iNdEx = preIndex
3501 skippy, err := skipUnrecognized(dAtA[iNdEx:])
3502 if err != nil {
3503 return err
3504 }
3505 if (skippy < 0) || (iNdEx+skippy) < 0 {
3506 return ErrInvalidLengthUnrecognized
3507 }
3508 if (iNdEx + skippy) > l {
3509 return io.ErrUnexpectedEOF
3510 }
3511 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3512 iNdEx += skippy
3513 }
3514 }
3515
3516 if iNdEx > l {
3517 return io.ErrUnexpectedEOF
3518 }
3519 return nil
3520 }
3521 func (m *C) Unmarshal(dAtA []byte) error {
3522 l := len(dAtA)
3523 iNdEx := 0
3524 for iNdEx < l {
3525 preIndex := iNdEx
3526 var wire uint64
3527 for shift := uint(0); ; shift += 7 {
3528 if shift >= 64 {
3529 return ErrIntOverflowUnrecognized
3530 }
3531 if iNdEx >= l {
3532 return io.ErrUnexpectedEOF
3533 }
3534 b := dAtA[iNdEx]
3535 iNdEx++
3536 wire |= uint64(b&0x7F) << shift
3537 if b < 0x80 {
3538 break
3539 }
3540 }
3541 fieldNum := int32(wire >> 3)
3542 wireType := int(wire & 0x7)
3543 if wireType == 4 {
3544 return fmt.Errorf("proto: C: wiretype end group for non-group")
3545 }
3546 if fieldNum <= 0 {
3547 return fmt.Errorf("proto: C: illegal tag %d (wire type %d)", fieldNum, wire)
3548 }
3549 switch fieldNum {
3550 case 2:
3551 if wireType != 1 {
3552 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
3553 }
3554 var v uint64
3555 if (iNdEx + 8) > l {
3556 return io.ErrUnexpectedEOF
3557 }
3558 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
3559 iNdEx += 8
3560 v2 := float64(math.Float64frombits(v))
3561 m.Field2 = &v2
3562 case 3:
3563 if wireType != 2 {
3564 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
3565 }
3566 var stringLen uint64
3567 for shift := uint(0); ; shift += 7 {
3568 if shift >= 64 {
3569 return ErrIntOverflowUnrecognized
3570 }
3571 if iNdEx >= l {
3572 return io.ErrUnexpectedEOF
3573 }
3574 b := dAtA[iNdEx]
3575 iNdEx++
3576 stringLen |= uint64(b&0x7F) << shift
3577 if b < 0x80 {
3578 break
3579 }
3580 }
3581 intStringLen := int(stringLen)
3582 if intStringLen < 0 {
3583 return ErrInvalidLengthUnrecognized
3584 }
3585 postIndex := iNdEx + intStringLen
3586 if postIndex < 0 {
3587 return ErrInvalidLengthUnrecognized
3588 }
3589 if postIndex > l {
3590 return io.ErrUnexpectedEOF
3591 }
3592 s := string(dAtA[iNdEx:postIndex])
3593 m.Field3 = &s
3594 iNdEx = postIndex
3595 case 4:
3596 if wireType != 1 {
3597 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
3598 }
3599 var v uint64
3600 if (iNdEx + 8) > l {
3601 return io.ErrUnexpectedEOF
3602 }
3603 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
3604 iNdEx += 8
3605 v2 := float64(math.Float64frombits(v))
3606 m.Field4 = &v2
3607 case 5:
3608 if wireType != 2 {
3609 return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
3610 }
3611 var byteLen int
3612 for shift := uint(0); ; shift += 7 {
3613 if shift >= 64 {
3614 return ErrIntOverflowUnrecognized
3615 }
3616 if iNdEx >= l {
3617 return io.ErrUnexpectedEOF
3618 }
3619 b := dAtA[iNdEx]
3620 iNdEx++
3621 byteLen |= int(b&0x7F) << shift
3622 if b < 0x80 {
3623 break
3624 }
3625 }
3626 if byteLen < 0 {
3627 return ErrInvalidLengthUnrecognized
3628 }
3629 postIndex := iNdEx + byteLen
3630 if postIndex < 0 {
3631 return ErrInvalidLengthUnrecognized
3632 }
3633 if postIndex > l {
3634 return io.ErrUnexpectedEOF
3635 }
3636 m.Field5 = append(m.Field5, make([]byte, postIndex-iNdEx))
3637 copy(m.Field5[len(m.Field5)-1], dAtA[iNdEx:postIndex])
3638 iNdEx = postIndex
3639 case 6:
3640 if wireType != 0 {
3641 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
3642 }
3643 var v int64
3644 for shift := uint(0); ; shift += 7 {
3645 if shift >= 64 {
3646 return ErrIntOverflowUnrecognized
3647 }
3648 if iNdEx >= l {
3649 return io.ErrUnexpectedEOF
3650 }
3651 b := dAtA[iNdEx]
3652 iNdEx++
3653 v |= int64(b&0x7F) << shift
3654 if b < 0x80 {
3655 break
3656 }
3657 }
3658 m.Field6 = &v
3659 case 7:
3660 if wireType == 5 {
3661 var v uint32
3662 if (iNdEx + 4) > l {
3663 return io.ErrUnexpectedEOF
3664 }
3665 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
3666 iNdEx += 4
3667 v2 := float32(math.Float32frombits(v))
3668 m.Field7 = append(m.Field7, v2)
3669 } else if wireType == 2 {
3670 var packedLen int
3671 for shift := uint(0); ; shift += 7 {
3672 if shift >= 64 {
3673 return ErrIntOverflowUnrecognized
3674 }
3675 if iNdEx >= l {
3676 return io.ErrUnexpectedEOF
3677 }
3678 b := dAtA[iNdEx]
3679 iNdEx++
3680 packedLen |= int(b&0x7F) << shift
3681 if b < 0x80 {
3682 break
3683 }
3684 }
3685 if packedLen < 0 {
3686 return ErrInvalidLengthUnrecognized
3687 }
3688 postIndex := iNdEx + packedLen
3689 if postIndex < 0 {
3690 return ErrInvalidLengthUnrecognized
3691 }
3692 if postIndex > l {
3693 return io.ErrUnexpectedEOF
3694 }
3695 var elementCount int
3696 elementCount = packedLen / 4
3697 if elementCount != 0 && len(m.Field7) == 0 {
3698 m.Field7 = make([]float32, 0, elementCount)
3699 }
3700 for iNdEx < postIndex {
3701 var v uint32
3702 if (iNdEx + 4) > l {
3703 return io.ErrUnexpectedEOF
3704 }
3705 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
3706 iNdEx += 4
3707 v2 := float32(math.Float32frombits(v))
3708 m.Field7 = append(m.Field7, v2)
3709 }
3710 } else {
3711 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
3712 }
3713 default:
3714 iNdEx = preIndex
3715 skippy, err := skipUnrecognized(dAtA[iNdEx:])
3716 if err != nil {
3717 return err
3718 }
3719 if (skippy < 0) || (iNdEx+skippy) < 0 {
3720 return ErrInvalidLengthUnrecognized
3721 }
3722 if (iNdEx + skippy) > l {
3723 return io.ErrUnexpectedEOF
3724 }
3725 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3726 iNdEx += skippy
3727 }
3728 }
3729
3730 if iNdEx > l {
3731 return io.ErrUnexpectedEOF
3732 }
3733 return nil
3734 }
3735 func (m *U) Unmarshal(dAtA []byte) error {
3736 l := len(dAtA)
3737 iNdEx := 0
3738 for iNdEx < l {
3739 preIndex := iNdEx
3740 var wire uint64
3741 for shift := uint(0); ; shift += 7 {
3742 if shift >= 64 {
3743 return ErrIntOverflowUnrecognized
3744 }
3745 if iNdEx >= l {
3746 return io.ErrUnexpectedEOF
3747 }
3748 b := dAtA[iNdEx]
3749 iNdEx++
3750 wire |= uint64(b&0x7F) << shift
3751 if b < 0x80 {
3752 break
3753 }
3754 }
3755 fieldNum := int32(wire >> 3)
3756 wireType := int(wire & 0x7)
3757 if wireType == 4 {
3758 return fmt.Errorf("proto: U: wiretype end group for non-group")
3759 }
3760 if fieldNum <= 0 {
3761 return fmt.Errorf("proto: U: illegal tag %d (wire type %d)", fieldNum, wire)
3762 }
3763 switch fieldNum {
3764 case 2:
3765 if wireType == 1 {
3766 var v uint64
3767 if (iNdEx + 8) > l {
3768 return io.ErrUnexpectedEOF
3769 }
3770 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
3771 iNdEx += 8
3772 v2 := float64(math.Float64frombits(v))
3773 m.Field2 = append(m.Field2, v2)
3774 } else if wireType == 2 {
3775 var packedLen int
3776 for shift := uint(0); ; shift += 7 {
3777 if shift >= 64 {
3778 return ErrIntOverflowUnrecognized
3779 }
3780 if iNdEx >= l {
3781 return io.ErrUnexpectedEOF
3782 }
3783 b := dAtA[iNdEx]
3784 iNdEx++
3785 packedLen |= int(b&0x7F) << shift
3786 if b < 0x80 {
3787 break
3788 }
3789 }
3790 if packedLen < 0 {
3791 return ErrInvalidLengthUnrecognized
3792 }
3793 postIndex := iNdEx + packedLen
3794 if postIndex < 0 {
3795 return ErrInvalidLengthUnrecognized
3796 }
3797 if postIndex > l {
3798 return io.ErrUnexpectedEOF
3799 }
3800 var elementCount int
3801 elementCount = packedLen / 8
3802 if elementCount != 0 && len(m.Field2) == 0 {
3803 m.Field2 = make([]float64, 0, elementCount)
3804 }
3805 for iNdEx < postIndex {
3806 var v uint64
3807 if (iNdEx + 8) > l {
3808 return io.ErrUnexpectedEOF
3809 }
3810 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
3811 iNdEx += 8
3812 v2 := float64(math.Float64frombits(v))
3813 m.Field2 = append(m.Field2, v2)
3814 }
3815 } else {
3816 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
3817 }
3818 case 3:
3819 if wireType != 0 {
3820 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
3821 }
3822 var v uint32
3823 for shift := uint(0); ; shift += 7 {
3824 if shift >= 64 {
3825 return ErrIntOverflowUnrecognized
3826 }
3827 if iNdEx >= l {
3828 return io.ErrUnexpectedEOF
3829 }
3830 b := dAtA[iNdEx]
3831 iNdEx++
3832 v |= uint32(b&0x7F) << shift
3833 if b < 0x80 {
3834 break
3835 }
3836 }
3837 m.Field3 = &v
3838 default:
3839 iNdEx = preIndex
3840 skippy, err := skipUnrecognized(dAtA[iNdEx:])
3841 if err != nil {
3842 return err
3843 }
3844 if (skippy < 0) || (iNdEx+skippy) < 0 {
3845 return ErrInvalidLengthUnrecognized
3846 }
3847 if (iNdEx + skippy) > l {
3848 return io.ErrUnexpectedEOF
3849 }
3850 iNdEx += skippy
3851 }
3852 }
3853
3854 if iNdEx > l {
3855 return io.ErrUnexpectedEOF
3856 }
3857 return nil
3858 }
3859 func (m *OldA) Unmarshal(dAtA []byte) error {
3860 l := len(dAtA)
3861 iNdEx := 0
3862 for iNdEx < l {
3863 preIndex := iNdEx
3864 var wire uint64
3865 for shift := uint(0); ; shift += 7 {
3866 if shift >= 64 {
3867 return ErrIntOverflowUnrecognized
3868 }
3869 if iNdEx >= l {
3870 return io.ErrUnexpectedEOF
3871 }
3872 b := dAtA[iNdEx]
3873 iNdEx++
3874 wire |= uint64(b&0x7F) << shift
3875 if b < 0x80 {
3876 break
3877 }
3878 }
3879 fieldNum := int32(wire >> 3)
3880 wireType := int(wire & 0x7)
3881 if wireType == 4 {
3882 return fmt.Errorf("proto: OldA: wiretype end group for non-group")
3883 }
3884 if fieldNum <= 0 {
3885 return fmt.Errorf("proto: OldA: illegal tag %d (wire type %d)", fieldNum, wire)
3886 }
3887 switch fieldNum {
3888 case 1:
3889 if wireType != 2 {
3890 return fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
3891 }
3892 var msglen int
3893 for shift := uint(0); ; shift += 7 {
3894 if shift >= 64 {
3895 return ErrIntOverflowUnrecognized
3896 }
3897 if iNdEx >= l {
3898 return io.ErrUnexpectedEOF
3899 }
3900 b := dAtA[iNdEx]
3901 iNdEx++
3902 msglen |= int(b&0x7F) << shift
3903 if b < 0x80 {
3904 break
3905 }
3906 }
3907 if msglen < 0 {
3908 return ErrInvalidLengthUnrecognized
3909 }
3910 postIndex := iNdEx + msglen
3911 if postIndex < 0 {
3912 return ErrInvalidLengthUnrecognized
3913 }
3914 if postIndex > l {
3915 return io.ErrUnexpectedEOF
3916 }
3917 m.B = append(m.B, &OldB{})
3918 if err := m.B[len(m.B)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3919 return err
3920 }
3921 iNdEx = postIndex
3922 case 2:
3923 if wireType != 0 {
3924 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
3925 }
3926 var v int64
3927 for shift := uint(0); ; shift += 7 {
3928 if shift >= 64 {
3929 return ErrIntOverflowUnrecognized
3930 }
3931 if iNdEx >= l {
3932 return io.ErrUnexpectedEOF
3933 }
3934 b := dAtA[iNdEx]
3935 iNdEx++
3936 v |= int64(b&0x7F) << shift
3937 if b < 0x80 {
3938 break
3939 }
3940 }
3941 m.Field1 = &v
3942 default:
3943 iNdEx = preIndex
3944 skippy, err := skipUnrecognized(dAtA[iNdEx:])
3945 if err != nil {
3946 return err
3947 }
3948 if (skippy < 0) || (iNdEx+skippy) < 0 {
3949 return ErrInvalidLengthUnrecognized
3950 }
3951 if (iNdEx + skippy) > l {
3952 return io.ErrUnexpectedEOF
3953 }
3954 iNdEx += skippy
3955 }
3956 }
3957
3958 if iNdEx > l {
3959 return io.ErrUnexpectedEOF
3960 }
3961 return nil
3962 }
3963 func (m *OldB) Unmarshal(dAtA []byte) error {
3964 l := len(dAtA)
3965 iNdEx := 0
3966 for iNdEx < l {
3967 preIndex := iNdEx
3968 var wire uint64
3969 for shift := uint(0); ; shift += 7 {
3970 if shift >= 64 {
3971 return ErrIntOverflowUnrecognized
3972 }
3973 if iNdEx >= l {
3974 return io.ErrUnexpectedEOF
3975 }
3976 b := dAtA[iNdEx]
3977 iNdEx++
3978 wire |= uint64(b&0x7F) << shift
3979 if b < 0x80 {
3980 break
3981 }
3982 }
3983 fieldNum := int32(wire >> 3)
3984 wireType := int(wire & 0x7)
3985 if wireType == 4 {
3986 return fmt.Errorf("proto: OldB: wiretype end group for non-group")
3987 }
3988 if fieldNum <= 0 {
3989 return fmt.Errorf("proto: OldB: illegal tag %d (wire type %d)", fieldNum, wire)
3990 }
3991 switch fieldNum {
3992 case 1:
3993 if wireType != 2 {
3994 return fmt.Errorf("proto: wrong wireType = %d for field C", wireType)
3995 }
3996 var msglen int
3997 for shift := uint(0); ; shift += 7 {
3998 if shift >= 64 {
3999 return ErrIntOverflowUnrecognized
4000 }
4001 if iNdEx >= l {
4002 return io.ErrUnexpectedEOF
4003 }
4004 b := dAtA[iNdEx]
4005 iNdEx++
4006 msglen |= int(b&0x7F) << shift
4007 if b < 0x80 {
4008 break
4009 }
4010 }
4011 if msglen < 0 {
4012 return ErrInvalidLengthUnrecognized
4013 }
4014 postIndex := iNdEx + msglen
4015 if postIndex < 0 {
4016 return ErrInvalidLengthUnrecognized
4017 }
4018 if postIndex > l {
4019 return io.ErrUnexpectedEOF
4020 }
4021 if m.C == nil {
4022 m.C = &OldC{}
4023 }
4024 if err := m.C.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4025 return err
4026 }
4027 iNdEx = postIndex
4028 case 5:
4029 if wireType != 2 {
4030 return fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
4031 }
4032 var msglen int
4033 for shift := uint(0); ; shift += 7 {
4034 if shift >= 64 {
4035 return ErrIntOverflowUnrecognized
4036 }
4037 if iNdEx >= l {
4038 return io.ErrUnexpectedEOF
4039 }
4040 b := dAtA[iNdEx]
4041 iNdEx++
4042 msglen |= int(b&0x7F) << shift
4043 if b < 0x80 {
4044 break
4045 }
4046 }
4047 if msglen < 0 {
4048 return ErrInvalidLengthUnrecognized
4049 }
4050 postIndex := iNdEx + msglen
4051 if postIndex < 0 {
4052 return ErrInvalidLengthUnrecognized
4053 }
4054 if postIndex > l {
4055 return io.ErrUnexpectedEOF
4056 }
4057 if m.F == nil {
4058 m.F = &OldC{}
4059 }
4060 if err := m.F.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4061 return err
4062 }
4063 iNdEx = postIndex
4064 default:
4065 iNdEx = preIndex
4066 skippy, err := skipUnrecognized(dAtA[iNdEx:])
4067 if err != nil {
4068 return err
4069 }
4070 if (skippy < 0) || (iNdEx+skippy) < 0 {
4071 return ErrInvalidLengthUnrecognized
4072 }
4073 if (iNdEx + skippy) > l {
4074 return io.ErrUnexpectedEOF
4075 }
4076 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4077 iNdEx += skippy
4078 }
4079 }
4080
4081 if iNdEx > l {
4082 return io.ErrUnexpectedEOF
4083 }
4084 return nil
4085 }
4086 func (m *OldC) Unmarshal(dAtA []byte) error {
4087 l := len(dAtA)
4088 iNdEx := 0
4089 for iNdEx < l {
4090 preIndex := iNdEx
4091 var wire uint64
4092 for shift := uint(0); ; shift += 7 {
4093 if shift >= 64 {
4094 return ErrIntOverflowUnrecognized
4095 }
4096 if iNdEx >= l {
4097 return io.ErrUnexpectedEOF
4098 }
4099 b := dAtA[iNdEx]
4100 iNdEx++
4101 wire |= uint64(b&0x7F) << shift
4102 if b < 0x80 {
4103 break
4104 }
4105 }
4106 fieldNum := int32(wire >> 3)
4107 wireType := int(wire & 0x7)
4108 if wireType == 4 {
4109 return fmt.Errorf("proto: OldC: wiretype end group for non-group")
4110 }
4111 if fieldNum <= 0 {
4112 return fmt.Errorf("proto: OldC: illegal tag %d (wire type %d)", fieldNum, wire)
4113 }
4114 switch fieldNum {
4115 case 1:
4116 if wireType != 0 {
4117 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
4118 }
4119 var v int64
4120 for shift := uint(0); ; shift += 7 {
4121 if shift >= 64 {
4122 return ErrIntOverflowUnrecognized
4123 }
4124 if iNdEx >= l {
4125 return io.ErrUnexpectedEOF
4126 }
4127 b := dAtA[iNdEx]
4128 iNdEx++
4129 v |= int64(b&0x7F) << shift
4130 if b < 0x80 {
4131 break
4132 }
4133 }
4134 m.Field1 = &v
4135 case 2:
4136 if wireType != 1 {
4137 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
4138 }
4139 var v uint64
4140 if (iNdEx + 8) > l {
4141 return io.ErrUnexpectedEOF
4142 }
4143 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
4144 iNdEx += 8
4145 v2 := float64(math.Float64frombits(v))
4146 m.Field2 = &v2
4147 case 3:
4148 if wireType != 2 {
4149 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
4150 }
4151 var stringLen uint64
4152 for shift := uint(0); ; shift += 7 {
4153 if shift >= 64 {
4154 return ErrIntOverflowUnrecognized
4155 }
4156 if iNdEx >= l {
4157 return io.ErrUnexpectedEOF
4158 }
4159 b := dAtA[iNdEx]
4160 iNdEx++
4161 stringLen |= uint64(b&0x7F) << shift
4162 if b < 0x80 {
4163 break
4164 }
4165 }
4166 intStringLen := int(stringLen)
4167 if intStringLen < 0 {
4168 return ErrInvalidLengthUnrecognized
4169 }
4170 postIndex := iNdEx + intStringLen
4171 if postIndex < 0 {
4172 return ErrInvalidLengthUnrecognized
4173 }
4174 if postIndex > l {
4175 return io.ErrUnexpectedEOF
4176 }
4177 s := string(dAtA[iNdEx:postIndex])
4178 m.Field3 = &s
4179 iNdEx = postIndex
4180 case 6:
4181 if wireType != 0 {
4182 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
4183 }
4184 var v int64
4185 for shift := uint(0); ; shift += 7 {
4186 if shift >= 64 {
4187 return ErrIntOverflowUnrecognized
4188 }
4189 if iNdEx >= l {
4190 return io.ErrUnexpectedEOF
4191 }
4192 b := dAtA[iNdEx]
4193 iNdEx++
4194 v |= int64(b&0x7F) << shift
4195 if b < 0x80 {
4196 break
4197 }
4198 }
4199 m.Field6 = &v
4200 case 7:
4201 if wireType == 5 {
4202 var v uint32
4203 if (iNdEx + 4) > l {
4204 return io.ErrUnexpectedEOF
4205 }
4206 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
4207 iNdEx += 4
4208 v2 := float32(math.Float32frombits(v))
4209 m.Field7 = append(m.Field7, v2)
4210 } else if wireType == 2 {
4211 var packedLen int
4212 for shift := uint(0); ; shift += 7 {
4213 if shift >= 64 {
4214 return ErrIntOverflowUnrecognized
4215 }
4216 if iNdEx >= l {
4217 return io.ErrUnexpectedEOF
4218 }
4219 b := dAtA[iNdEx]
4220 iNdEx++
4221 packedLen |= int(b&0x7F) << shift
4222 if b < 0x80 {
4223 break
4224 }
4225 }
4226 if packedLen < 0 {
4227 return ErrInvalidLengthUnrecognized
4228 }
4229 postIndex := iNdEx + packedLen
4230 if postIndex < 0 {
4231 return ErrInvalidLengthUnrecognized
4232 }
4233 if postIndex > l {
4234 return io.ErrUnexpectedEOF
4235 }
4236 var elementCount int
4237 elementCount = packedLen / 4
4238 if elementCount != 0 && len(m.Field7) == 0 {
4239 m.Field7 = make([]float32, 0, elementCount)
4240 }
4241 for iNdEx < postIndex {
4242 var v uint32
4243 if (iNdEx + 4) > l {
4244 return io.ErrUnexpectedEOF
4245 }
4246 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
4247 iNdEx += 4
4248 v2 := float32(math.Float32frombits(v))
4249 m.Field7 = append(m.Field7, v2)
4250 }
4251 } else {
4252 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
4253 }
4254 default:
4255 iNdEx = preIndex
4256 skippy, err := skipUnrecognized(dAtA[iNdEx:])
4257 if err != nil {
4258 return err
4259 }
4260 if (skippy < 0) || (iNdEx+skippy) < 0 {
4261 return ErrInvalidLengthUnrecognized
4262 }
4263 if (iNdEx + skippy) > l {
4264 return io.ErrUnexpectedEOF
4265 }
4266 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4267 iNdEx += skippy
4268 }
4269 }
4270
4271 if iNdEx > l {
4272 return io.ErrUnexpectedEOF
4273 }
4274 return nil
4275 }
4276 func (m *OldU) Unmarshal(dAtA []byte) error {
4277 l := len(dAtA)
4278 iNdEx := 0
4279 for iNdEx < l {
4280 preIndex := iNdEx
4281 var wire uint64
4282 for shift := uint(0); ; shift += 7 {
4283 if shift >= 64 {
4284 return ErrIntOverflowUnrecognized
4285 }
4286 if iNdEx >= l {
4287 return io.ErrUnexpectedEOF
4288 }
4289 b := dAtA[iNdEx]
4290 iNdEx++
4291 wire |= uint64(b&0x7F) << shift
4292 if b < 0x80 {
4293 break
4294 }
4295 }
4296 fieldNum := int32(wire >> 3)
4297 wireType := int(wire & 0x7)
4298 if wireType == 4 {
4299 return fmt.Errorf("proto: OldU: wiretype end group for non-group")
4300 }
4301 if fieldNum <= 0 {
4302 return fmt.Errorf("proto: OldU: illegal tag %d (wire type %d)", fieldNum, wire)
4303 }
4304 switch fieldNum {
4305 case 1:
4306 if wireType != 2 {
4307 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
4308 }
4309 var stringLen uint64
4310 for shift := uint(0); ; shift += 7 {
4311 if shift >= 64 {
4312 return ErrIntOverflowUnrecognized
4313 }
4314 if iNdEx >= l {
4315 return io.ErrUnexpectedEOF
4316 }
4317 b := dAtA[iNdEx]
4318 iNdEx++
4319 stringLen |= uint64(b&0x7F) << shift
4320 if b < 0x80 {
4321 break
4322 }
4323 }
4324 intStringLen := int(stringLen)
4325 if intStringLen < 0 {
4326 return ErrInvalidLengthUnrecognized
4327 }
4328 postIndex := iNdEx + intStringLen
4329 if postIndex < 0 {
4330 return ErrInvalidLengthUnrecognized
4331 }
4332 if postIndex > l {
4333 return io.ErrUnexpectedEOF
4334 }
4335 s := string(dAtA[iNdEx:postIndex])
4336 m.Field1 = &s
4337 iNdEx = postIndex
4338 case 2:
4339 if wireType == 1 {
4340 var v uint64
4341 if (iNdEx + 8) > l {
4342 return io.ErrUnexpectedEOF
4343 }
4344 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
4345 iNdEx += 8
4346 v2 := float64(math.Float64frombits(v))
4347 m.Field2 = append(m.Field2, v2)
4348 } else if wireType == 2 {
4349 var packedLen int
4350 for shift := uint(0); ; shift += 7 {
4351 if shift >= 64 {
4352 return ErrIntOverflowUnrecognized
4353 }
4354 if iNdEx >= l {
4355 return io.ErrUnexpectedEOF
4356 }
4357 b := dAtA[iNdEx]
4358 iNdEx++
4359 packedLen |= int(b&0x7F) << shift
4360 if b < 0x80 {
4361 break
4362 }
4363 }
4364 if packedLen < 0 {
4365 return ErrInvalidLengthUnrecognized
4366 }
4367 postIndex := iNdEx + packedLen
4368 if postIndex < 0 {
4369 return ErrInvalidLengthUnrecognized
4370 }
4371 if postIndex > l {
4372 return io.ErrUnexpectedEOF
4373 }
4374 var elementCount int
4375 elementCount = packedLen / 8
4376 if elementCount != 0 && len(m.Field2) == 0 {
4377 m.Field2 = make([]float64, 0, elementCount)
4378 }
4379 for iNdEx < postIndex {
4380 var v uint64
4381 if (iNdEx + 8) > l {
4382 return io.ErrUnexpectedEOF
4383 }
4384 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
4385 iNdEx += 8
4386 v2 := float64(math.Float64frombits(v))
4387 m.Field2 = append(m.Field2, v2)
4388 }
4389 } else {
4390 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
4391 }
4392 default:
4393 iNdEx = preIndex
4394 skippy, err := skipUnrecognized(dAtA[iNdEx:])
4395 if err != nil {
4396 return err
4397 }
4398 if (skippy < 0) || (iNdEx+skippy) < 0 {
4399 return ErrInvalidLengthUnrecognized
4400 }
4401 if (iNdEx + skippy) > l {
4402 return io.ErrUnexpectedEOF
4403 }
4404 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4405 iNdEx += skippy
4406 }
4407 }
4408
4409 if iNdEx > l {
4410 return io.ErrUnexpectedEOF
4411 }
4412 return nil
4413 }
4414 func skipUnrecognized(dAtA []byte) (n int, err error) {
4415 l := len(dAtA)
4416 iNdEx := 0
4417 depth := 0
4418 for iNdEx < l {
4419 var wire uint64
4420 for shift := uint(0); ; shift += 7 {
4421 if shift >= 64 {
4422 return 0, ErrIntOverflowUnrecognized
4423 }
4424 if iNdEx >= l {
4425 return 0, io.ErrUnexpectedEOF
4426 }
4427 b := dAtA[iNdEx]
4428 iNdEx++
4429 wire |= (uint64(b) & 0x7F) << shift
4430 if b < 0x80 {
4431 break
4432 }
4433 }
4434 wireType := int(wire & 0x7)
4435 switch wireType {
4436 case 0:
4437 for shift := uint(0); ; shift += 7 {
4438 if shift >= 64 {
4439 return 0, ErrIntOverflowUnrecognized
4440 }
4441 if iNdEx >= l {
4442 return 0, io.ErrUnexpectedEOF
4443 }
4444 iNdEx++
4445 if dAtA[iNdEx-1] < 0x80 {
4446 break
4447 }
4448 }
4449 case 1:
4450 iNdEx += 8
4451 case 2:
4452 var length int
4453 for shift := uint(0); ; shift += 7 {
4454 if shift >= 64 {
4455 return 0, ErrIntOverflowUnrecognized
4456 }
4457 if iNdEx >= l {
4458 return 0, io.ErrUnexpectedEOF
4459 }
4460 b := dAtA[iNdEx]
4461 iNdEx++
4462 length |= (int(b) & 0x7F) << shift
4463 if b < 0x80 {
4464 break
4465 }
4466 }
4467 if length < 0 {
4468 return 0, ErrInvalidLengthUnrecognized
4469 }
4470 iNdEx += length
4471 case 3:
4472 depth++
4473 case 4:
4474 if depth == 0 {
4475 return 0, ErrUnexpectedEndOfGroupUnrecognized
4476 }
4477 depth--
4478 case 5:
4479 iNdEx += 4
4480 default:
4481 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
4482 }
4483 if iNdEx < 0 {
4484 return 0, ErrInvalidLengthUnrecognized
4485 }
4486 if depth == 0 {
4487 return iNdEx, nil
4488 }
4489 }
4490 return 0, io.ErrUnexpectedEOF
4491 }
4492
4493 var (
4494 ErrInvalidLengthUnrecognized = fmt.Errorf("proto: negative length found during unmarshaling")
4495 ErrIntOverflowUnrecognized = fmt.Errorf("proto: integer overflow")
4496 ErrUnexpectedEndOfGroupUnrecognized = fmt.Errorf("proto: unexpected end of group")
4497 )
4498
View as plain text