1
2
3
4 package test
5
6 import (
7 bytes "bytes"
8 compress_gzip "compress/gzip"
9 encoding_binary "encoding/binary"
10 fmt "fmt"
11 _ "github.com/gogo/protobuf/gogoproto"
12 github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
13 proto "github.com/gogo/protobuf/proto"
14 github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
15 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
16 github_com_gogo_protobuf_test_custom "github.com/gogo/protobuf/test/custom"
17 github_com_gogo_protobuf_test_custom_dash_type "github.com/gogo/protobuf/test/custom-dash-type"
18 io "io"
19 io_ioutil "io/ioutil"
20 math "math"
21 math_bits "math/bits"
22 reflect "reflect"
23 sort "sort"
24 strconv "strconv"
25 strings "strings"
26 )
27
28
29 var _ = proto.Marshal
30 var _ = fmt.Errorf
31 var _ = math.Inf
32
33
34
35
36
37 const _ = proto.GoGoProtoPackageIsVersion3
38
39 type TheTestEnum int32
40
41 const (
42 A TheTestEnum = 0
43 B TheTestEnum = 1
44 C TheTestEnum = 2
45 )
46
47 var TheTestEnum_name = map[int32]string{
48 0: "A",
49 1: "B",
50 2: "C",
51 }
52
53 var TheTestEnum_value = map[string]int32{
54 "A": 0,
55 "B": 1,
56 "C": 2,
57 }
58
59 func (x TheTestEnum) Enum() *TheTestEnum {
60 p := new(TheTestEnum)
61 *p = x
62 return p
63 }
64
65 func (x TheTestEnum) MarshalJSON() ([]byte, error) {
66 return proto.MarshalJSONEnum(TheTestEnum_name, int32(x))
67 }
68
69 func (x *TheTestEnum) UnmarshalJSON(data []byte) error {
70 value, err := proto.UnmarshalJSONEnum(TheTestEnum_value, data, "TheTestEnum")
71 if err != nil {
72 return err
73 }
74 *x = TheTestEnum(value)
75 return nil
76 }
77
78 func (TheTestEnum) EnumDescriptor() ([]byte, []int) {
79 return fileDescriptor_519c3115fa9830d1, []int{0}
80 }
81
82 type AnotherTestEnum int32
83
84 const (
85 D AnotherTestEnum = 10
86 E AnotherTestEnum = 11
87 )
88
89 var AnotherTestEnum_name = map[int32]string{
90 10: "D",
91 11: "E",
92 }
93
94 var AnotherTestEnum_value = map[string]int32{
95 "D": 10,
96 "E": 11,
97 }
98
99 func (x AnotherTestEnum) Enum() *AnotherTestEnum {
100 p := new(AnotherTestEnum)
101 *p = x
102 return p
103 }
104
105 func (x AnotherTestEnum) MarshalJSON() ([]byte, error) {
106 return proto.MarshalJSONEnum(AnotherTestEnum_name, int32(x))
107 }
108
109 func (x *AnotherTestEnum) UnmarshalJSON(data []byte) error {
110 value, err := proto.UnmarshalJSONEnum(AnotherTestEnum_value, data, "AnotherTestEnum")
111 if err != nil {
112 return err
113 }
114 *x = AnotherTestEnum(value)
115 return nil
116 }
117
118 func (AnotherTestEnum) EnumDescriptor() ([]byte, []int) {
119 return fileDescriptor_519c3115fa9830d1, []int{1}
120 }
121
122
123
124 type YetAnotherTestEnum int32
125
126 const (
127 AA YetAnotherTestEnum = 0
128 BetterYetBB YetAnotherTestEnum = 1
129 )
130
131 var YetAnotherTestEnum_name = map[int32]string{
132 0: "AA",
133 1: "BB",
134 }
135
136 var YetAnotherTestEnum_value = map[string]int32{
137 "AA": 0,
138 "BB": 1,
139 }
140
141 func (x YetAnotherTestEnum) Enum() *YetAnotherTestEnum {
142 p := new(YetAnotherTestEnum)
143 *p = x
144 return p
145 }
146
147 func (x YetAnotherTestEnum) MarshalJSON() ([]byte, error) {
148 return proto.MarshalJSONEnum(YetAnotherTestEnum_name, int32(x))
149 }
150
151 func (x *YetAnotherTestEnum) UnmarshalJSON(data []byte) error {
152 value, err := proto.UnmarshalJSONEnum(YetAnotherTestEnum_value, data, "YetAnotherTestEnum")
153 if err != nil {
154 return err
155 }
156 *x = YetAnotherTestEnum(value)
157 return nil
158 }
159
160 func (YetAnotherTestEnum) EnumDescriptor() ([]byte, []int) {
161 return fileDescriptor_519c3115fa9830d1, []int{2}
162 }
163
164
165
166 type YetYetAnotherTestEnum int32
167
168 const (
169 YetYetAnotherTestEnum_CC YetYetAnotherTestEnum = 0
170 YetYetAnotherTestEnum_BetterYetDD YetYetAnotherTestEnum = 1
171 )
172
173 var YetYetAnotherTestEnum_name = map[int32]string{
174 0: "CC",
175 1: "DD",
176 }
177
178 var YetYetAnotherTestEnum_value = map[string]int32{
179 "CC": 0,
180 "DD": 1,
181 }
182
183 func (x YetYetAnotherTestEnum) Enum() *YetYetAnotherTestEnum {
184 p := new(YetYetAnotherTestEnum)
185 *p = x
186 return p
187 }
188
189 func (x YetYetAnotherTestEnum) MarshalJSON() ([]byte, error) {
190 return proto.MarshalJSONEnum(YetYetAnotherTestEnum_name, int32(x))
191 }
192
193 func (x *YetYetAnotherTestEnum) UnmarshalJSON(data []byte) error {
194 value, err := proto.UnmarshalJSONEnum(YetYetAnotherTestEnum_value, data, "YetYetAnotherTestEnum")
195 if err != nil {
196 return err
197 }
198 *x = YetYetAnotherTestEnum(value)
199 return nil
200 }
201
202 func (YetYetAnotherTestEnum) EnumDescriptor() ([]byte, []int) {
203 return fileDescriptor_519c3115fa9830d1, []int{3}
204 }
205
206 type NestedDefinition_NestedEnum int32
207
208 const (
209 TYPE_NESTED NestedDefinition_NestedEnum = 1
210 )
211
212 var NestedDefinition_NestedEnum_name = map[int32]string{
213 1: "TYPE_NESTED",
214 }
215
216 var NestedDefinition_NestedEnum_value = map[string]int32{
217 "TYPE_NESTED": 1,
218 }
219
220 func (x NestedDefinition_NestedEnum) Enum() *NestedDefinition_NestedEnum {
221 p := new(NestedDefinition_NestedEnum)
222 *p = x
223 return p
224 }
225
226 func (x NestedDefinition_NestedEnum) MarshalJSON() ([]byte, error) {
227 return proto.MarshalJSONEnum(NestedDefinition_NestedEnum_name, int32(x))
228 }
229
230 func (x *NestedDefinition_NestedEnum) UnmarshalJSON(data []byte) error {
231 value, err := proto.UnmarshalJSONEnum(NestedDefinition_NestedEnum_value, data, "NestedDefinition_NestedEnum")
232 if err != nil {
233 return err
234 }
235 *x = NestedDefinition_NestedEnum(value)
236 return nil
237 }
238
239 func (NestedDefinition_NestedEnum) EnumDescriptor() ([]byte, []int) {
240 return fileDescriptor_519c3115fa9830d1, []int{42, 0}
241 }
242
243 type NidOptNative struct {
244 Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"`
245 Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"`
246 Field3 int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"`
247 Field4 int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"`
248 Field5 uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"`
249 Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"`
250 Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"`
251 Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"`
252 Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"`
253 Field10 int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"`
254 Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"`
255 Field12 int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"`
256 Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"`
257 Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"`
258 Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"`
259 XXX_NoUnkeyedLiteral struct{} `json:"-"`
260 XXX_unrecognized []byte `json:"-"`
261 XXX_sizecache int32 `json:"-"`
262 }
263
264 func (m *NidOptNative) Reset() { *m = NidOptNative{} }
265 func (*NidOptNative) ProtoMessage() {}
266 func (*NidOptNative) Descriptor() ([]byte, []int) {
267 return fileDescriptor_519c3115fa9830d1, []int{0}
268 }
269 func (m *NidOptNative) XXX_Unmarshal(b []byte) error {
270 return m.Unmarshal(b)
271 }
272 func (m *NidOptNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
273 if deterministic {
274 return xxx_messageInfo_NidOptNative.Marshal(b, m, deterministic)
275 } else {
276 b = b[:cap(b)]
277 n, err := m.MarshalToSizedBuffer(b)
278 if err != nil {
279 return nil, err
280 }
281 return b[:n], nil
282 }
283 }
284 func (m *NidOptNative) XXX_Merge(src proto.Message) {
285 xxx_messageInfo_NidOptNative.Merge(m, src)
286 }
287 func (m *NidOptNative) XXX_Size() int {
288 return m.Size()
289 }
290 func (m *NidOptNative) XXX_DiscardUnknown() {
291 xxx_messageInfo_NidOptNative.DiscardUnknown(m)
292 }
293
294 var xxx_messageInfo_NidOptNative proto.InternalMessageInfo
295
296 type NinOptNative struct {
297 Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"`
298 Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"`
299 Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"`
300 Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"`
301 Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"`
302 Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"`
303 Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"`
304 Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"`
305 Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"`
306 Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"`
307 Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"`
308 Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"`
309 Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"`
310 Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"`
311 Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"`
312 XXX_NoUnkeyedLiteral struct{} `json:"-"`
313 XXX_unrecognized []byte `json:"-"`
314 XXX_sizecache int32 `json:"-"`
315 }
316
317 func (m *NinOptNative) Reset() { *m = NinOptNative{} }
318 func (*NinOptNative) ProtoMessage() {}
319 func (*NinOptNative) Descriptor() ([]byte, []int) {
320 return fileDescriptor_519c3115fa9830d1, []int{1}
321 }
322 func (m *NinOptNative) XXX_Unmarshal(b []byte) error {
323 return m.Unmarshal(b)
324 }
325 func (m *NinOptNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
326 if deterministic {
327 return xxx_messageInfo_NinOptNative.Marshal(b, m, deterministic)
328 } else {
329 b = b[:cap(b)]
330 n, err := m.MarshalToSizedBuffer(b)
331 if err != nil {
332 return nil, err
333 }
334 return b[:n], nil
335 }
336 }
337 func (m *NinOptNative) XXX_Merge(src proto.Message) {
338 xxx_messageInfo_NinOptNative.Merge(m, src)
339 }
340 func (m *NinOptNative) XXX_Size() int {
341 return m.Size()
342 }
343 func (m *NinOptNative) XXX_DiscardUnknown() {
344 xxx_messageInfo_NinOptNative.DiscardUnknown(m)
345 }
346
347 var xxx_messageInfo_NinOptNative proto.InternalMessageInfo
348
349 type NidRepNative struct {
350 Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"`
351 Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"`
352 Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"`
353 Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"`
354 Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"`
355 Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"`
356 Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"`
357 Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"`
358 Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"`
359 Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"`
360 Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"`
361 Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"`
362 Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"`
363 Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"`
364 Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"`
365 XXX_NoUnkeyedLiteral struct{} `json:"-"`
366 XXX_unrecognized []byte `json:"-"`
367 XXX_sizecache int32 `json:"-"`
368 }
369
370 func (m *NidRepNative) Reset() { *m = NidRepNative{} }
371 func (*NidRepNative) ProtoMessage() {}
372 func (*NidRepNative) Descriptor() ([]byte, []int) {
373 return fileDescriptor_519c3115fa9830d1, []int{2}
374 }
375 func (m *NidRepNative) XXX_Unmarshal(b []byte) error {
376 return m.Unmarshal(b)
377 }
378 func (m *NidRepNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
379 if deterministic {
380 return xxx_messageInfo_NidRepNative.Marshal(b, m, deterministic)
381 } else {
382 b = b[:cap(b)]
383 n, err := m.MarshalToSizedBuffer(b)
384 if err != nil {
385 return nil, err
386 }
387 return b[:n], nil
388 }
389 }
390 func (m *NidRepNative) XXX_Merge(src proto.Message) {
391 xxx_messageInfo_NidRepNative.Merge(m, src)
392 }
393 func (m *NidRepNative) XXX_Size() int {
394 return m.Size()
395 }
396 func (m *NidRepNative) XXX_DiscardUnknown() {
397 xxx_messageInfo_NidRepNative.DiscardUnknown(m)
398 }
399
400 var xxx_messageInfo_NidRepNative proto.InternalMessageInfo
401
402 type NinRepNative struct {
403 Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"`
404 Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"`
405 Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"`
406 Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"`
407 Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"`
408 Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"`
409 Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"`
410 Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"`
411 Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"`
412 Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"`
413 Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"`
414 Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"`
415 Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"`
416 Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"`
417 Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"`
418 XXX_NoUnkeyedLiteral struct{} `json:"-"`
419 XXX_unrecognized []byte `json:"-"`
420 XXX_sizecache int32 `json:"-"`
421 }
422
423 func (m *NinRepNative) Reset() { *m = NinRepNative{} }
424 func (*NinRepNative) ProtoMessage() {}
425 func (*NinRepNative) Descriptor() ([]byte, []int) {
426 return fileDescriptor_519c3115fa9830d1, []int{3}
427 }
428 func (m *NinRepNative) XXX_Unmarshal(b []byte) error {
429 return m.Unmarshal(b)
430 }
431 func (m *NinRepNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
432 if deterministic {
433 return xxx_messageInfo_NinRepNative.Marshal(b, m, deterministic)
434 } else {
435 b = b[:cap(b)]
436 n, err := m.MarshalToSizedBuffer(b)
437 if err != nil {
438 return nil, err
439 }
440 return b[:n], nil
441 }
442 }
443 func (m *NinRepNative) XXX_Merge(src proto.Message) {
444 xxx_messageInfo_NinRepNative.Merge(m, src)
445 }
446 func (m *NinRepNative) XXX_Size() int {
447 return m.Size()
448 }
449 func (m *NinRepNative) XXX_DiscardUnknown() {
450 xxx_messageInfo_NinRepNative.DiscardUnknown(m)
451 }
452
453 var xxx_messageInfo_NinRepNative proto.InternalMessageInfo
454
455 type NidRepPackedNative struct {
456 Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"`
457 Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"`
458 Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"`
459 Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"`
460 Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"`
461 Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"`
462 Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"`
463 Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"`
464 Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"`
465 Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"`
466 Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"`
467 Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"`
468 Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"`
469 XXX_NoUnkeyedLiteral struct{} `json:"-"`
470 XXX_unrecognized []byte `json:"-"`
471 XXX_sizecache int32 `json:"-"`
472 }
473
474 func (m *NidRepPackedNative) Reset() { *m = NidRepPackedNative{} }
475 func (*NidRepPackedNative) ProtoMessage() {}
476 func (*NidRepPackedNative) Descriptor() ([]byte, []int) {
477 return fileDescriptor_519c3115fa9830d1, []int{4}
478 }
479 func (m *NidRepPackedNative) XXX_Unmarshal(b []byte) error {
480 return m.Unmarshal(b)
481 }
482 func (m *NidRepPackedNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
483 if deterministic {
484 return xxx_messageInfo_NidRepPackedNative.Marshal(b, m, deterministic)
485 } else {
486 b = b[:cap(b)]
487 n, err := m.MarshalToSizedBuffer(b)
488 if err != nil {
489 return nil, err
490 }
491 return b[:n], nil
492 }
493 }
494 func (m *NidRepPackedNative) XXX_Merge(src proto.Message) {
495 xxx_messageInfo_NidRepPackedNative.Merge(m, src)
496 }
497 func (m *NidRepPackedNative) XXX_Size() int {
498 return m.Size()
499 }
500 func (m *NidRepPackedNative) XXX_DiscardUnknown() {
501 xxx_messageInfo_NidRepPackedNative.DiscardUnknown(m)
502 }
503
504 var xxx_messageInfo_NidRepPackedNative proto.InternalMessageInfo
505
506 type NinRepPackedNative struct {
507 Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"`
508 Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"`
509 Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"`
510 Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"`
511 Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"`
512 Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"`
513 Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"`
514 Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"`
515 Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"`
516 Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"`
517 Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"`
518 Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"`
519 Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"`
520 XXX_NoUnkeyedLiteral struct{} `json:"-"`
521 XXX_unrecognized []byte `json:"-"`
522 XXX_sizecache int32 `json:"-"`
523 }
524
525 func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} }
526 func (*NinRepPackedNative) ProtoMessage() {}
527 func (*NinRepPackedNative) Descriptor() ([]byte, []int) {
528 return fileDescriptor_519c3115fa9830d1, []int{5}
529 }
530 func (m *NinRepPackedNative) XXX_Unmarshal(b []byte) error {
531 return m.Unmarshal(b)
532 }
533 func (m *NinRepPackedNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
534 if deterministic {
535 return xxx_messageInfo_NinRepPackedNative.Marshal(b, m, deterministic)
536 } else {
537 b = b[:cap(b)]
538 n, err := m.MarshalToSizedBuffer(b)
539 if err != nil {
540 return nil, err
541 }
542 return b[:n], nil
543 }
544 }
545 func (m *NinRepPackedNative) XXX_Merge(src proto.Message) {
546 xxx_messageInfo_NinRepPackedNative.Merge(m, src)
547 }
548 func (m *NinRepPackedNative) XXX_Size() int {
549 return m.Size()
550 }
551 func (m *NinRepPackedNative) XXX_DiscardUnknown() {
552 xxx_messageInfo_NinRepPackedNative.DiscardUnknown(m)
553 }
554
555 var xxx_messageInfo_NinRepPackedNative proto.InternalMessageInfo
556
557 type NidOptStruct struct {
558 Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"`
559 Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"`
560 Field3 NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3"`
561 Field4 NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4"`
562 Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"`
563 Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"`
564 Field8 NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8"`
565 Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"`
566 Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"`
567 Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"`
568 XXX_NoUnkeyedLiteral struct{} `json:"-"`
569 XXX_unrecognized []byte `json:"-"`
570 XXX_sizecache int32 `json:"-"`
571 }
572
573 func (m *NidOptStruct) Reset() { *m = NidOptStruct{} }
574 func (*NidOptStruct) ProtoMessage() {}
575 func (*NidOptStruct) Descriptor() ([]byte, []int) {
576 return fileDescriptor_519c3115fa9830d1, []int{6}
577 }
578 func (m *NidOptStruct) XXX_Unmarshal(b []byte) error {
579 return m.Unmarshal(b)
580 }
581 func (m *NidOptStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
582 if deterministic {
583 return xxx_messageInfo_NidOptStruct.Marshal(b, m, deterministic)
584 } else {
585 b = b[:cap(b)]
586 n, err := m.MarshalToSizedBuffer(b)
587 if err != nil {
588 return nil, err
589 }
590 return b[:n], nil
591 }
592 }
593 func (m *NidOptStruct) XXX_Merge(src proto.Message) {
594 xxx_messageInfo_NidOptStruct.Merge(m, src)
595 }
596 func (m *NidOptStruct) XXX_Size() int {
597 return m.Size()
598 }
599 func (m *NidOptStruct) XXX_DiscardUnknown() {
600 xxx_messageInfo_NidOptStruct.DiscardUnknown(m)
601 }
602
603 var xxx_messageInfo_NidOptStruct proto.InternalMessageInfo
604
605 type NinOptStruct struct {
606 Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"`
607 Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"`
608 Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"`
609 Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"`
610 Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"`
611 Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"`
612 Field8 *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"`
613 Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"`
614 Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"`
615 Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"`
616 XXX_NoUnkeyedLiteral struct{} `json:"-"`
617 XXX_unrecognized []byte `json:"-"`
618 XXX_sizecache int32 `json:"-"`
619 }
620
621 func (m *NinOptStruct) Reset() { *m = NinOptStruct{} }
622 func (*NinOptStruct) ProtoMessage() {}
623 func (*NinOptStruct) Descriptor() ([]byte, []int) {
624 return fileDescriptor_519c3115fa9830d1, []int{7}
625 }
626 func (m *NinOptStruct) XXX_Unmarshal(b []byte) error {
627 return m.Unmarshal(b)
628 }
629 func (m *NinOptStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
630 if deterministic {
631 return xxx_messageInfo_NinOptStruct.Marshal(b, m, deterministic)
632 } else {
633 b = b[:cap(b)]
634 n, err := m.MarshalToSizedBuffer(b)
635 if err != nil {
636 return nil, err
637 }
638 return b[:n], nil
639 }
640 }
641 func (m *NinOptStruct) XXX_Merge(src proto.Message) {
642 xxx_messageInfo_NinOptStruct.Merge(m, src)
643 }
644 func (m *NinOptStruct) XXX_Size() int {
645 return m.Size()
646 }
647 func (m *NinOptStruct) XXX_DiscardUnknown() {
648 xxx_messageInfo_NinOptStruct.DiscardUnknown(m)
649 }
650
651 var xxx_messageInfo_NinOptStruct proto.InternalMessageInfo
652
653 type NidRepStruct struct {
654 Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"`
655 Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"`
656 Field3 []NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3"`
657 Field4 []NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4"`
658 Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"`
659 Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"`
660 Field8 []NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8"`
661 Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"`
662 Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"`
663 Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"`
664 XXX_NoUnkeyedLiteral struct{} `json:"-"`
665 XXX_unrecognized []byte `json:"-"`
666 XXX_sizecache int32 `json:"-"`
667 }
668
669 func (m *NidRepStruct) Reset() { *m = NidRepStruct{} }
670 func (*NidRepStruct) ProtoMessage() {}
671 func (*NidRepStruct) Descriptor() ([]byte, []int) {
672 return fileDescriptor_519c3115fa9830d1, []int{8}
673 }
674 func (m *NidRepStruct) XXX_Unmarshal(b []byte) error {
675 return m.Unmarshal(b)
676 }
677 func (m *NidRepStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
678 if deterministic {
679 return xxx_messageInfo_NidRepStruct.Marshal(b, m, deterministic)
680 } else {
681 b = b[:cap(b)]
682 n, err := m.MarshalToSizedBuffer(b)
683 if err != nil {
684 return nil, err
685 }
686 return b[:n], nil
687 }
688 }
689 func (m *NidRepStruct) XXX_Merge(src proto.Message) {
690 xxx_messageInfo_NidRepStruct.Merge(m, src)
691 }
692 func (m *NidRepStruct) XXX_Size() int {
693 return m.Size()
694 }
695 func (m *NidRepStruct) XXX_DiscardUnknown() {
696 xxx_messageInfo_NidRepStruct.DiscardUnknown(m)
697 }
698
699 var xxx_messageInfo_NidRepStruct proto.InternalMessageInfo
700
701 type NinRepStruct struct {
702 Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"`
703 Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"`
704 Field3 []*NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3,omitempty"`
705 Field4 []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"`
706 Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"`
707 Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"`
708 Field8 []*NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8,omitempty"`
709 Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"`
710 Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"`
711 Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"`
712 XXX_NoUnkeyedLiteral struct{} `json:"-"`
713 XXX_unrecognized []byte `json:"-"`
714 XXX_sizecache int32 `json:"-"`
715 }
716
717 func (m *NinRepStruct) Reset() { *m = NinRepStruct{} }
718 func (*NinRepStruct) ProtoMessage() {}
719 func (*NinRepStruct) Descriptor() ([]byte, []int) {
720 return fileDescriptor_519c3115fa9830d1, []int{9}
721 }
722 func (m *NinRepStruct) XXX_Unmarshal(b []byte) error {
723 return m.Unmarshal(b)
724 }
725 func (m *NinRepStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
726 if deterministic {
727 return xxx_messageInfo_NinRepStruct.Marshal(b, m, deterministic)
728 } else {
729 b = b[:cap(b)]
730 n, err := m.MarshalToSizedBuffer(b)
731 if err != nil {
732 return nil, err
733 }
734 return b[:n], nil
735 }
736 }
737 func (m *NinRepStruct) XXX_Merge(src proto.Message) {
738 xxx_messageInfo_NinRepStruct.Merge(m, src)
739 }
740 func (m *NinRepStruct) XXX_Size() int {
741 return m.Size()
742 }
743 func (m *NinRepStruct) XXX_DiscardUnknown() {
744 xxx_messageInfo_NinRepStruct.DiscardUnknown(m)
745 }
746
747 var xxx_messageInfo_NinRepStruct proto.InternalMessageInfo
748
749 type NidEmbeddedStruct struct {
750 *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"`
751 Field200 NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200"`
752 Field210 bool `protobuf:"varint,210,opt,name=Field210" json:"Field210"`
753 XXX_NoUnkeyedLiteral struct{} `json:"-"`
754 XXX_unrecognized []byte `json:"-"`
755 XXX_sizecache int32 `json:"-"`
756 }
757
758 func (m *NidEmbeddedStruct) Reset() { *m = NidEmbeddedStruct{} }
759 func (*NidEmbeddedStruct) ProtoMessage() {}
760 func (*NidEmbeddedStruct) Descriptor() ([]byte, []int) {
761 return fileDescriptor_519c3115fa9830d1, []int{10}
762 }
763 func (m *NidEmbeddedStruct) XXX_Unmarshal(b []byte) error {
764 return m.Unmarshal(b)
765 }
766 func (m *NidEmbeddedStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
767 if deterministic {
768 return xxx_messageInfo_NidEmbeddedStruct.Marshal(b, m, deterministic)
769 } else {
770 b = b[:cap(b)]
771 n, err := m.MarshalToSizedBuffer(b)
772 if err != nil {
773 return nil, err
774 }
775 return b[:n], nil
776 }
777 }
778 func (m *NidEmbeddedStruct) XXX_Merge(src proto.Message) {
779 xxx_messageInfo_NidEmbeddedStruct.Merge(m, src)
780 }
781 func (m *NidEmbeddedStruct) XXX_Size() int {
782 return m.Size()
783 }
784 func (m *NidEmbeddedStruct) XXX_DiscardUnknown() {
785 xxx_messageInfo_NidEmbeddedStruct.DiscardUnknown(m)
786 }
787
788 var xxx_messageInfo_NidEmbeddedStruct proto.InternalMessageInfo
789
790 type NinEmbeddedStruct struct {
791 *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"`
792 Field200 *NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"`
793 Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"`
794 XXX_NoUnkeyedLiteral struct{} `json:"-"`
795 XXX_unrecognized []byte `json:"-"`
796 XXX_sizecache int32 `json:"-"`
797 }
798
799 func (m *NinEmbeddedStruct) Reset() { *m = NinEmbeddedStruct{} }
800 func (*NinEmbeddedStruct) ProtoMessage() {}
801 func (*NinEmbeddedStruct) Descriptor() ([]byte, []int) {
802 return fileDescriptor_519c3115fa9830d1, []int{11}
803 }
804 func (m *NinEmbeddedStruct) XXX_Unmarshal(b []byte) error {
805 return m.Unmarshal(b)
806 }
807 func (m *NinEmbeddedStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
808 if deterministic {
809 return xxx_messageInfo_NinEmbeddedStruct.Marshal(b, m, deterministic)
810 } else {
811 b = b[:cap(b)]
812 n, err := m.MarshalToSizedBuffer(b)
813 if err != nil {
814 return nil, err
815 }
816 return b[:n], nil
817 }
818 }
819 func (m *NinEmbeddedStruct) XXX_Merge(src proto.Message) {
820 xxx_messageInfo_NinEmbeddedStruct.Merge(m, src)
821 }
822 func (m *NinEmbeddedStruct) XXX_Size() int {
823 return m.Size()
824 }
825 func (m *NinEmbeddedStruct) XXX_DiscardUnknown() {
826 xxx_messageInfo_NinEmbeddedStruct.DiscardUnknown(m)
827 }
828
829 var xxx_messageInfo_NinEmbeddedStruct proto.InternalMessageInfo
830
831 type NidNestedStruct struct {
832 Field1 NidOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1"`
833 Field2 []NidRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2"`
834 XXX_NoUnkeyedLiteral struct{} `json:"-"`
835 XXX_unrecognized []byte `json:"-"`
836 XXX_sizecache int32 `json:"-"`
837 }
838
839 func (m *NidNestedStruct) Reset() { *m = NidNestedStruct{} }
840 func (*NidNestedStruct) ProtoMessage() {}
841 func (*NidNestedStruct) Descriptor() ([]byte, []int) {
842 return fileDescriptor_519c3115fa9830d1, []int{12}
843 }
844 func (m *NidNestedStruct) XXX_Unmarshal(b []byte) error {
845 return m.Unmarshal(b)
846 }
847 func (m *NidNestedStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
848 if deterministic {
849 return xxx_messageInfo_NidNestedStruct.Marshal(b, m, deterministic)
850 } else {
851 b = b[:cap(b)]
852 n, err := m.MarshalToSizedBuffer(b)
853 if err != nil {
854 return nil, err
855 }
856 return b[:n], nil
857 }
858 }
859 func (m *NidNestedStruct) XXX_Merge(src proto.Message) {
860 xxx_messageInfo_NidNestedStruct.Merge(m, src)
861 }
862 func (m *NidNestedStruct) XXX_Size() int {
863 return m.Size()
864 }
865 func (m *NidNestedStruct) XXX_DiscardUnknown() {
866 xxx_messageInfo_NidNestedStruct.DiscardUnknown(m)
867 }
868
869 var xxx_messageInfo_NidNestedStruct proto.InternalMessageInfo
870
871 type NinNestedStruct struct {
872 Field1 *NinOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"`
873 Field2 []*NinRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2,omitempty"`
874 XXX_NoUnkeyedLiteral struct{} `json:"-"`
875 XXX_unrecognized []byte `json:"-"`
876 XXX_sizecache int32 `json:"-"`
877 }
878
879 func (m *NinNestedStruct) Reset() { *m = NinNestedStruct{} }
880 func (*NinNestedStruct) ProtoMessage() {}
881 func (*NinNestedStruct) Descriptor() ([]byte, []int) {
882 return fileDescriptor_519c3115fa9830d1, []int{13}
883 }
884 func (m *NinNestedStruct) XXX_Unmarshal(b []byte) error {
885 return m.Unmarshal(b)
886 }
887 func (m *NinNestedStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
888 if deterministic {
889 return xxx_messageInfo_NinNestedStruct.Marshal(b, m, deterministic)
890 } else {
891 b = b[:cap(b)]
892 n, err := m.MarshalToSizedBuffer(b)
893 if err != nil {
894 return nil, err
895 }
896 return b[:n], nil
897 }
898 }
899 func (m *NinNestedStruct) XXX_Merge(src proto.Message) {
900 xxx_messageInfo_NinNestedStruct.Merge(m, src)
901 }
902 func (m *NinNestedStruct) XXX_Size() int {
903 return m.Size()
904 }
905 func (m *NinNestedStruct) XXX_DiscardUnknown() {
906 xxx_messageInfo_NinNestedStruct.DiscardUnknown(m)
907 }
908
909 var xxx_messageInfo_NinNestedStruct proto.InternalMessageInfo
910
911 type NidOptCustom struct {
912 Id Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id"`
913 Value github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"`
914 XXX_NoUnkeyedLiteral struct{} `json:"-"`
915 XXX_unrecognized []byte `json:"-"`
916 XXX_sizecache int32 `json:"-"`
917 }
918
919 func (m *NidOptCustom) Reset() { *m = NidOptCustom{} }
920 func (*NidOptCustom) ProtoMessage() {}
921 func (*NidOptCustom) Descriptor() ([]byte, []int) {
922 return fileDescriptor_519c3115fa9830d1, []int{14}
923 }
924 func (m *NidOptCustom) XXX_Unmarshal(b []byte) error {
925 return m.Unmarshal(b)
926 }
927 func (m *NidOptCustom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
928 if deterministic {
929 return xxx_messageInfo_NidOptCustom.Marshal(b, m, deterministic)
930 } else {
931 b = b[:cap(b)]
932 n, err := m.MarshalToSizedBuffer(b)
933 if err != nil {
934 return nil, err
935 }
936 return b[:n], nil
937 }
938 }
939 func (m *NidOptCustom) XXX_Merge(src proto.Message) {
940 xxx_messageInfo_NidOptCustom.Merge(m, src)
941 }
942 func (m *NidOptCustom) XXX_Size() int {
943 return m.Size()
944 }
945 func (m *NidOptCustom) XXX_DiscardUnknown() {
946 xxx_messageInfo_NidOptCustom.DiscardUnknown(m)
947 }
948
949 var xxx_messageInfo_NidOptCustom proto.InternalMessageInfo
950
951 type CustomDash struct {
952 Value *github_com_gogo_protobuf_test_custom_dash_type.Bytes `protobuf:"bytes,1,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom-dash-type.Bytes" json:"Value,omitempty"`
953 XXX_NoUnkeyedLiteral struct{} `json:"-"`
954 XXX_unrecognized []byte `json:"-"`
955 XXX_sizecache int32 `json:"-"`
956 }
957
958 func (m *CustomDash) Reset() { *m = CustomDash{} }
959 func (*CustomDash) ProtoMessage() {}
960 func (*CustomDash) Descriptor() ([]byte, []int) {
961 return fileDescriptor_519c3115fa9830d1, []int{15}
962 }
963 func (m *CustomDash) XXX_Unmarshal(b []byte) error {
964 return m.Unmarshal(b)
965 }
966 func (m *CustomDash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
967 if deterministic {
968 return xxx_messageInfo_CustomDash.Marshal(b, m, deterministic)
969 } else {
970 b = b[:cap(b)]
971 n, err := m.MarshalToSizedBuffer(b)
972 if err != nil {
973 return nil, err
974 }
975 return b[:n], nil
976 }
977 }
978 func (m *CustomDash) XXX_Merge(src proto.Message) {
979 xxx_messageInfo_CustomDash.Merge(m, src)
980 }
981 func (m *CustomDash) XXX_Size() int {
982 return m.Size()
983 }
984 func (m *CustomDash) XXX_DiscardUnknown() {
985 xxx_messageInfo_CustomDash.DiscardUnknown(m)
986 }
987
988 var xxx_messageInfo_CustomDash proto.InternalMessageInfo
989
990 type NinOptCustom struct {
991 Id *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"`
992 Value *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"`
993 XXX_NoUnkeyedLiteral struct{} `json:"-"`
994 XXX_unrecognized []byte `json:"-"`
995 XXX_sizecache int32 `json:"-"`
996 }
997
998 func (m *NinOptCustom) Reset() { *m = NinOptCustom{} }
999 func (*NinOptCustom) ProtoMessage() {}
1000 func (*NinOptCustom) Descriptor() ([]byte, []int) {
1001 return fileDescriptor_519c3115fa9830d1, []int{16}
1002 }
1003 func (m *NinOptCustom) XXX_Unmarshal(b []byte) error {
1004 return m.Unmarshal(b)
1005 }
1006 func (m *NinOptCustom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1007 if deterministic {
1008 return xxx_messageInfo_NinOptCustom.Marshal(b, m, deterministic)
1009 } else {
1010 b = b[:cap(b)]
1011 n, err := m.MarshalToSizedBuffer(b)
1012 if err != nil {
1013 return nil, err
1014 }
1015 return b[:n], nil
1016 }
1017 }
1018 func (m *NinOptCustom) XXX_Merge(src proto.Message) {
1019 xxx_messageInfo_NinOptCustom.Merge(m, src)
1020 }
1021 func (m *NinOptCustom) XXX_Size() int {
1022 return m.Size()
1023 }
1024 func (m *NinOptCustom) XXX_DiscardUnknown() {
1025 xxx_messageInfo_NinOptCustom.DiscardUnknown(m)
1026 }
1027
1028 var xxx_messageInfo_NinOptCustom proto.InternalMessageInfo
1029
1030 type NidRepCustom struct {
1031 Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id"`
1032 Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"`
1033 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1034 XXX_unrecognized []byte `json:"-"`
1035 XXX_sizecache int32 `json:"-"`
1036 }
1037
1038 func (m *NidRepCustom) Reset() { *m = NidRepCustom{} }
1039 func (*NidRepCustom) ProtoMessage() {}
1040 func (*NidRepCustom) Descriptor() ([]byte, []int) {
1041 return fileDescriptor_519c3115fa9830d1, []int{17}
1042 }
1043 func (m *NidRepCustom) XXX_Unmarshal(b []byte) error {
1044 return m.Unmarshal(b)
1045 }
1046 func (m *NidRepCustom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1047 if deterministic {
1048 return xxx_messageInfo_NidRepCustom.Marshal(b, m, deterministic)
1049 } else {
1050 b = b[:cap(b)]
1051 n, err := m.MarshalToSizedBuffer(b)
1052 if err != nil {
1053 return nil, err
1054 }
1055 return b[:n], nil
1056 }
1057 }
1058 func (m *NidRepCustom) XXX_Merge(src proto.Message) {
1059 xxx_messageInfo_NidRepCustom.Merge(m, src)
1060 }
1061 func (m *NidRepCustom) XXX_Size() int {
1062 return m.Size()
1063 }
1064 func (m *NidRepCustom) XXX_DiscardUnknown() {
1065 xxx_messageInfo_NidRepCustom.DiscardUnknown(m)
1066 }
1067
1068 var xxx_messageInfo_NidRepCustom proto.InternalMessageInfo
1069
1070 type NinRepCustom struct {
1071 Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id,omitempty"`
1072 Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"`
1073 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1074 XXX_unrecognized []byte `json:"-"`
1075 XXX_sizecache int32 `json:"-"`
1076 }
1077
1078 func (m *NinRepCustom) Reset() { *m = NinRepCustom{} }
1079 func (*NinRepCustom) ProtoMessage() {}
1080 func (*NinRepCustom) Descriptor() ([]byte, []int) {
1081 return fileDescriptor_519c3115fa9830d1, []int{18}
1082 }
1083 func (m *NinRepCustom) XXX_Unmarshal(b []byte) error {
1084 return m.Unmarshal(b)
1085 }
1086 func (m *NinRepCustom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1087 if deterministic {
1088 return xxx_messageInfo_NinRepCustom.Marshal(b, m, deterministic)
1089 } else {
1090 b = b[:cap(b)]
1091 n, err := m.MarshalToSizedBuffer(b)
1092 if err != nil {
1093 return nil, err
1094 }
1095 return b[:n], nil
1096 }
1097 }
1098 func (m *NinRepCustom) XXX_Merge(src proto.Message) {
1099 xxx_messageInfo_NinRepCustom.Merge(m, src)
1100 }
1101 func (m *NinRepCustom) XXX_Size() int {
1102 return m.Size()
1103 }
1104 func (m *NinRepCustom) XXX_DiscardUnknown() {
1105 xxx_messageInfo_NinRepCustom.DiscardUnknown(m)
1106 }
1107
1108 var xxx_messageInfo_NinRepCustom proto.InternalMessageInfo
1109
1110 type NinOptNativeUnion struct {
1111 Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"`
1112 Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"`
1113 Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"`
1114 Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"`
1115 Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"`
1116 Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"`
1117 Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"`
1118 Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"`
1119 Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"`
1120 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1121 XXX_unrecognized []byte `json:"-"`
1122 XXX_sizecache int32 `json:"-"`
1123 }
1124
1125 func (m *NinOptNativeUnion) Reset() { *m = NinOptNativeUnion{} }
1126 func (*NinOptNativeUnion) ProtoMessage() {}
1127 func (*NinOptNativeUnion) Descriptor() ([]byte, []int) {
1128 return fileDescriptor_519c3115fa9830d1, []int{19}
1129 }
1130 func (m *NinOptNativeUnion) XXX_Unmarshal(b []byte) error {
1131 return m.Unmarshal(b)
1132 }
1133 func (m *NinOptNativeUnion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1134 if deterministic {
1135 return xxx_messageInfo_NinOptNativeUnion.Marshal(b, m, deterministic)
1136 } else {
1137 b = b[:cap(b)]
1138 n, err := m.MarshalToSizedBuffer(b)
1139 if err != nil {
1140 return nil, err
1141 }
1142 return b[:n], nil
1143 }
1144 }
1145 func (m *NinOptNativeUnion) XXX_Merge(src proto.Message) {
1146 xxx_messageInfo_NinOptNativeUnion.Merge(m, src)
1147 }
1148 func (m *NinOptNativeUnion) XXX_Size() int {
1149 return m.Size()
1150 }
1151 func (m *NinOptNativeUnion) XXX_DiscardUnknown() {
1152 xxx_messageInfo_NinOptNativeUnion.DiscardUnknown(m)
1153 }
1154
1155 var xxx_messageInfo_NinOptNativeUnion proto.InternalMessageInfo
1156
1157 type NinOptStructUnion struct {
1158 Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"`
1159 Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"`
1160 Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"`
1161 Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"`
1162 Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"`
1163 Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"`
1164 Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"`
1165 Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"`
1166 Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"`
1167 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1168 XXX_unrecognized []byte `json:"-"`
1169 XXX_sizecache int32 `json:"-"`
1170 }
1171
1172 func (m *NinOptStructUnion) Reset() { *m = NinOptStructUnion{} }
1173 func (*NinOptStructUnion) ProtoMessage() {}
1174 func (*NinOptStructUnion) Descriptor() ([]byte, []int) {
1175 return fileDescriptor_519c3115fa9830d1, []int{20}
1176 }
1177 func (m *NinOptStructUnion) XXX_Unmarshal(b []byte) error {
1178 return m.Unmarshal(b)
1179 }
1180 func (m *NinOptStructUnion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1181 if deterministic {
1182 return xxx_messageInfo_NinOptStructUnion.Marshal(b, m, deterministic)
1183 } else {
1184 b = b[:cap(b)]
1185 n, err := m.MarshalToSizedBuffer(b)
1186 if err != nil {
1187 return nil, err
1188 }
1189 return b[:n], nil
1190 }
1191 }
1192 func (m *NinOptStructUnion) XXX_Merge(src proto.Message) {
1193 xxx_messageInfo_NinOptStructUnion.Merge(m, src)
1194 }
1195 func (m *NinOptStructUnion) XXX_Size() int {
1196 return m.Size()
1197 }
1198 func (m *NinOptStructUnion) XXX_DiscardUnknown() {
1199 xxx_messageInfo_NinOptStructUnion.DiscardUnknown(m)
1200 }
1201
1202 var xxx_messageInfo_NinOptStructUnion proto.InternalMessageInfo
1203
1204 type NinEmbeddedStructUnion struct {
1205 *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"`
1206 Field200 *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"`
1207 Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"`
1208 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1209 XXX_unrecognized []byte `json:"-"`
1210 XXX_sizecache int32 `json:"-"`
1211 }
1212
1213 func (m *NinEmbeddedStructUnion) Reset() { *m = NinEmbeddedStructUnion{} }
1214 func (*NinEmbeddedStructUnion) ProtoMessage() {}
1215 func (*NinEmbeddedStructUnion) Descriptor() ([]byte, []int) {
1216 return fileDescriptor_519c3115fa9830d1, []int{21}
1217 }
1218 func (m *NinEmbeddedStructUnion) XXX_Unmarshal(b []byte) error {
1219 return m.Unmarshal(b)
1220 }
1221 func (m *NinEmbeddedStructUnion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1222 if deterministic {
1223 return xxx_messageInfo_NinEmbeddedStructUnion.Marshal(b, m, deterministic)
1224 } else {
1225 b = b[:cap(b)]
1226 n, err := m.MarshalToSizedBuffer(b)
1227 if err != nil {
1228 return nil, err
1229 }
1230 return b[:n], nil
1231 }
1232 }
1233 func (m *NinEmbeddedStructUnion) XXX_Merge(src proto.Message) {
1234 xxx_messageInfo_NinEmbeddedStructUnion.Merge(m, src)
1235 }
1236 func (m *NinEmbeddedStructUnion) XXX_Size() int {
1237 return m.Size()
1238 }
1239 func (m *NinEmbeddedStructUnion) XXX_DiscardUnknown() {
1240 xxx_messageInfo_NinEmbeddedStructUnion.DiscardUnknown(m)
1241 }
1242
1243 var xxx_messageInfo_NinEmbeddedStructUnion proto.InternalMessageInfo
1244
1245 type NinNestedStructUnion struct {
1246 Field1 *NinOptNativeUnion `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"`
1247 Field2 *NinOptStructUnion `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"`
1248 Field3 *NinEmbeddedStructUnion `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"`
1249 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1250 XXX_unrecognized []byte `json:"-"`
1251 XXX_sizecache int32 `json:"-"`
1252 }
1253
1254 func (m *NinNestedStructUnion) Reset() { *m = NinNestedStructUnion{} }
1255 func (*NinNestedStructUnion) ProtoMessage() {}
1256 func (*NinNestedStructUnion) Descriptor() ([]byte, []int) {
1257 return fileDescriptor_519c3115fa9830d1, []int{22}
1258 }
1259 func (m *NinNestedStructUnion) XXX_Unmarshal(b []byte) error {
1260 return m.Unmarshal(b)
1261 }
1262 func (m *NinNestedStructUnion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1263 if deterministic {
1264 return xxx_messageInfo_NinNestedStructUnion.Marshal(b, m, deterministic)
1265 } else {
1266 b = b[:cap(b)]
1267 n, err := m.MarshalToSizedBuffer(b)
1268 if err != nil {
1269 return nil, err
1270 }
1271 return b[:n], nil
1272 }
1273 }
1274 func (m *NinNestedStructUnion) XXX_Merge(src proto.Message) {
1275 xxx_messageInfo_NinNestedStructUnion.Merge(m, src)
1276 }
1277 func (m *NinNestedStructUnion) XXX_Size() int {
1278 return m.Size()
1279 }
1280 func (m *NinNestedStructUnion) XXX_DiscardUnknown() {
1281 xxx_messageInfo_NinNestedStructUnion.DiscardUnknown(m)
1282 }
1283
1284 var xxx_messageInfo_NinNestedStructUnion proto.InternalMessageInfo
1285
1286 type Tree struct {
1287 Or *OrBranch `protobuf:"bytes,1,opt,name=Or" json:"Or,omitempty"`
1288 And *AndBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"`
1289 Leaf *Leaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"`
1290 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1291 XXX_unrecognized []byte `json:"-"`
1292 XXX_sizecache int32 `json:"-"`
1293 }
1294
1295 func (m *Tree) Reset() { *m = Tree{} }
1296 func (*Tree) ProtoMessage() {}
1297 func (*Tree) Descriptor() ([]byte, []int) {
1298 return fileDescriptor_519c3115fa9830d1, []int{23}
1299 }
1300 func (m *Tree) XXX_Unmarshal(b []byte) error {
1301 return m.Unmarshal(b)
1302 }
1303 func (m *Tree) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1304 if deterministic {
1305 return xxx_messageInfo_Tree.Marshal(b, m, deterministic)
1306 } else {
1307 b = b[:cap(b)]
1308 n, err := m.MarshalToSizedBuffer(b)
1309 if err != nil {
1310 return nil, err
1311 }
1312 return b[:n], nil
1313 }
1314 }
1315 func (m *Tree) XXX_Merge(src proto.Message) {
1316 xxx_messageInfo_Tree.Merge(m, src)
1317 }
1318 func (m *Tree) XXX_Size() int {
1319 return m.Size()
1320 }
1321 func (m *Tree) XXX_DiscardUnknown() {
1322 xxx_messageInfo_Tree.DiscardUnknown(m)
1323 }
1324
1325 var xxx_messageInfo_Tree proto.InternalMessageInfo
1326
1327 type OrBranch struct {
1328 Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"`
1329 Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"`
1330 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1331 XXX_unrecognized []byte `json:"-"`
1332 XXX_sizecache int32 `json:"-"`
1333 }
1334
1335 func (m *OrBranch) Reset() { *m = OrBranch{} }
1336 func (*OrBranch) ProtoMessage() {}
1337 func (*OrBranch) Descriptor() ([]byte, []int) {
1338 return fileDescriptor_519c3115fa9830d1, []int{24}
1339 }
1340 func (m *OrBranch) XXX_Unmarshal(b []byte) error {
1341 return m.Unmarshal(b)
1342 }
1343 func (m *OrBranch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1344 if deterministic {
1345 return xxx_messageInfo_OrBranch.Marshal(b, m, deterministic)
1346 } else {
1347 b = b[:cap(b)]
1348 n, err := m.MarshalToSizedBuffer(b)
1349 if err != nil {
1350 return nil, err
1351 }
1352 return b[:n], nil
1353 }
1354 }
1355 func (m *OrBranch) XXX_Merge(src proto.Message) {
1356 xxx_messageInfo_OrBranch.Merge(m, src)
1357 }
1358 func (m *OrBranch) XXX_Size() int {
1359 return m.Size()
1360 }
1361 func (m *OrBranch) XXX_DiscardUnknown() {
1362 xxx_messageInfo_OrBranch.DiscardUnknown(m)
1363 }
1364
1365 var xxx_messageInfo_OrBranch proto.InternalMessageInfo
1366
1367 type AndBranch struct {
1368 Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"`
1369 Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"`
1370 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1371 XXX_unrecognized []byte `json:"-"`
1372 XXX_sizecache int32 `json:"-"`
1373 }
1374
1375 func (m *AndBranch) Reset() { *m = AndBranch{} }
1376 func (*AndBranch) ProtoMessage() {}
1377 func (*AndBranch) Descriptor() ([]byte, []int) {
1378 return fileDescriptor_519c3115fa9830d1, []int{25}
1379 }
1380 func (m *AndBranch) XXX_Unmarshal(b []byte) error {
1381 return m.Unmarshal(b)
1382 }
1383 func (m *AndBranch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1384 if deterministic {
1385 return xxx_messageInfo_AndBranch.Marshal(b, m, deterministic)
1386 } else {
1387 b = b[:cap(b)]
1388 n, err := m.MarshalToSizedBuffer(b)
1389 if err != nil {
1390 return nil, err
1391 }
1392 return b[:n], nil
1393 }
1394 }
1395 func (m *AndBranch) XXX_Merge(src proto.Message) {
1396 xxx_messageInfo_AndBranch.Merge(m, src)
1397 }
1398 func (m *AndBranch) XXX_Size() int {
1399 return m.Size()
1400 }
1401 func (m *AndBranch) XXX_DiscardUnknown() {
1402 xxx_messageInfo_AndBranch.DiscardUnknown(m)
1403 }
1404
1405 var xxx_messageInfo_AndBranch proto.InternalMessageInfo
1406
1407 type Leaf struct {
1408 Value int64 `protobuf:"varint,1,opt,name=Value" json:"Value"`
1409 StrValue string `protobuf:"bytes,2,opt,name=StrValue" json:"StrValue"`
1410 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1411 XXX_unrecognized []byte `json:"-"`
1412 XXX_sizecache int32 `json:"-"`
1413 }
1414
1415 func (m *Leaf) Reset() { *m = Leaf{} }
1416 func (*Leaf) ProtoMessage() {}
1417 func (*Leaf) Descriptor() ([]byte, []int) {
1418 return fileDescriptor_519c3115fa9830d1, []int{26}
1419 }
1420 func (m *Leaf) XXX_Unmarshal(b []byte) error {
1421 return m.Unmarshal(b)
1422 }
1423 func (m *Leaf) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1424 if deterministic {
1425 return xxx_messageInfo_Leaf.Marshal(b, m, deterministic)
1426 } else {
1427 b = b[:cap(b)]
1428 n, err := m.MarshalToSizedBuffer(b)
1429 if err != nil {
1430 return nil, err
1431 }
1432 return b[:n], nil
1433 }
1434 }
1435 func (m *Leaf) XXX_Merge(src proto.Message) {
1436 xxx_messageInfo_Leaf.Merge(m, src)
1437 }
1438 func (m *Leaf) XXX_Size() int {
1439 return m.Size()
1440 }
1441 func (m *Leaf) XXX_DiscardUnknown() {
1442 xxx_messageInfo_Leaf.DiscardUnknown(m)
1443 }
1444
1445 var xxx_messageInfo_Leaf proto.InternalMessageInfo
1446
1447 type DeepTree struct {
1448 Down *ADeepBranch `protobuf:"bytes,1,opt,name=Down" json:"Down,omitempty"`
1449 And *AndDeepBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"`
1450 Leaf *DeepLeaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"`
1451 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1452 XXX_unrecognized []byte `json:"-"`
1453 XXX_sizecache int32 `json:"-"`
1454 }
1455
1456 func (m *DeepTree) Reset() { *m = DeepTree{} }
1457 func (*DeepTree) ProtoMessage() {}
1458 func (*DeepTree) Descriptor() ([]byte, []int) {
1459 return fileDescriptor_519c3115fa9830d1, []int{27}
1460 }
1461 func (m *DeepTree) XXX_Unmarshal(b []byte) error {
1462 return m.Unmarshal(b)
1463 }
1464 func (m *DeepTree) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1465 if deterministic {
1466 return xxx_messageInfo_DeepTree.Marshal(b, m, deterministic)
1467 } else {
1468 b = b[:cap(b)]
1469 n, err := m.MarshalToSizedBuffer(b)
1470 if err != nil {
1471 return nil, err
1472 }
1473 return b[:n], nil
1474 }
1475 }
1476 func (m *DeepTree) XXX_Merge(src proto.Message) {
1477 xxx_messageInfo_DeepTree.Merge(m, src)
1478 }
1479 func (m *DeepTree) XXX_Size() int {
1480 return m.Size()
1481 }
1482 func (m *DeepTree) XXX_DiscardUnknown() {
1483 xxx_messageInfo_DeepTree.DiscardUnknown(m)
1484 }
1485
1486 var xxx_messageInfo_DeepTree proto.InternalMessageInfo
1487
1488 type ADeepBranch struct {
1489 Down DeepTree `protobuf:"bytes,2,opt,name=Down" json:"Down"`
1490 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1491 XXX_unrecognized []byte `json:"-"`
1492 XXX_sizecache int32 `json:"-"`
1493 }
1494
1495 func (m *ADeepBranch) Reset() { *m = ADeepBranch{} }
1496 func (*ADeepBranch) ProtoMessage() {}
1497 func (*ADeepBranch) Descriptor() ([]byte, []int) {
1498 return fileDescriptor_519c3115fa9830d1, []int{28}
1499 }
1500 func (m *ADeepBranch) XXX_Unmarshal(b []byte) error {
1501 return m.Unmarshal(b)
1502 }
1503 func (m *ADeepBranch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1504 if deterministic {
1505 return xxx_messageInfo_ADeepBranch.Marshal(b, m, deterministic)
1506 } else {
1507 b = b[:cap(b)]
1508 n, err := m.MarshalToSizedBuffer(b)
1509 if err != nil {
1510 return nil, err
1511 }
1512 return b[:n], nil
1513 }
1514 }
1515 func (m *ADeepBranch) XXX_Merge(src proto.Message) {
1516 xxx_messageInfo_ADeepBranch.Merge(m, src)
1517 }
1518 func (m *ADeepBranch) XXX_Size() int {
1519 return m.Size()
1520 }
1521 func (m *ADeepBranch) XXX_DiscardUnknown() {
1522 xxx_messageInfo_ADeepBranch.DiscardUnknown(m)
1523 }
1524
1525 var xxx_messageInfo_ADeepBranch proto.InternalMessageInfo
1526
1527 type AndDeepBranch struct {
1528 Left DeepTree `protobuf:"bytes,1,opt,name=Left" json:"Left"`
1529 Right DeepTree `protobuf:"bytes,2,opt,name=Right" json:"Right"`
1530 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1531 XXX_unrecognized []byte `json:"-"`
1532 XXX_sizecache int32 `json:"-"`
1533 }
1534
1535 func (m *AndDeepBranch) Reset() { *m = AndDeepBranch{} }
1536 func (*AndDeepBranch) ProtoMessage() {}
1537 func (*AndDeepBranch) Descriptor() ([]byte, []int) {
1538 return fileDescriptor_519c3115fa9830d1, []int{29}
1539 }
1540 func (m *AndDeepBranch) XXX_Unmarshal(b []byte) error {
1541 return m.Unmarshal(b)
1542 }
1543 func (m *AndDeepBranch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1544 if deterministic {
1545 return xxx_messageInfo_AndDeepBranch.Marshal(b, m, deterministic)
1546 } else {
1547 b = b[:cap(b)]
1548 n, err := m.MarshalToSizedBuffer(b)
1549 if err != nil {
1550 return nil, err
1551 }
1552 return b[:n], nil
1553 }
1554 }
1555 func (m *AndDeepBranch) XXX_Merge(src proto.Message) {
1556 xxx_messageInfo_AndDeepBranch.Merge(m, src)
1557 }
1558 func (m *AndDeepBranch) XXX_Size() int {
1559 return m.Size()
1560 }
1561 func (m *AndDeepBranch) XXX_DiscardUnknown() {
1562 xxx_messageInfo_AndDeepBranch.DiscardUnknown(m)
1563 }
1564
1565 var xxx_messageInfo_AndDeepBranch proto.InternalMessageInfo
1566
1567 type DeepLeaf struct {
1568 Tree Tree `protobuf:"bytes,1,opt,name=Tree" json:"Tree"`
1569 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1570 XXX_unrecognized []byte `json:"-"`
1571 XXX_sizecache int32 `json:"-"`
1572 }
1573
1574 func (m *DeepLeaf) Reset() { *m = DeepLeaf{} }
1575 func (*DeepLeaf) ProtoMessage() {}
1576 func (*DeepLeaf) Descriptor() ([]byte, []int) {
1577 return fileDescriptor_519c3115fa9830d1, []int{30}
1578 }
1579 func (m *DeepLeaf) XXX_Unmarshal(b []byte) error {
1580 return m.Unmarshal(b)
1581 }
1582 func (m *DeepLeaf) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1583 if deterministic {
1584 return xxx_messageInfo_DeepLeaf.Marshal(b, m, deterministic)
1585 } else {
1586 b = b[:cap(b)]
1587 n, err := m.MarshalToSizedBuffer(b)
1588 if err != nil {
1589 return nil, err
1590 }
1591 return b[:n], nil
1592 }
1593 }
1594 func (m *DeepLeaf) XXX_Merge(src proto.Message) {
1595 xxx_messageInfo_DeepLeaf.Merge(m, src)
1596 }
1597 func (m *DeepLeaf) XXX_Size() int {
1598 return m.Size()
1599 }
1600 func (m *DeepLeaf) XXX_DiscardUnknown() {
1601 xxx_messageInfo_DeepLeaf.DiscardUnknown(m)
1602 }
1603
1604 var xxx_messageInfo_DeepLeaf proto.InternalMessageInfo
1605
1606 type Nil struct {
1607 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1608 XXX_unrecognized []byte `json:"-"`
1609 XXX_sizecache int32 `json:"-"`
1610 }
1611
1612 func (m *Nil) Reset() { *m = Nil{} }
1613 func (*Nil) ProtoMessage() {}
1614 func (*Nil) Descriptor() ([]byte, []int) {
1615 return fileDescriptor_519c3115fa9830d1, []int{31}
1616 }
1617 func (m *Nil) XXX_Unmarshal(b []byte) error {
1618 return m.Unmarshal(b)
1619 }
1620 func (m *Nil) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1621 if deterministic {
1622 return xxx_messageInfo_Nil.Marshal(b, m, deterministic)
1623 } else {
1624 b = b[:cap(b)]
1625 n, err := m.MarshalToSizedBuffer(b)
1626 if err != nil {
1627 return nil, err
1628 }
1629 return b[:n], nil
1630 }
1631 }
1632 func (m *Nil) XXX_Merge(src proto.Message) {
1633 xxx_messageInfo_Nil.Merge(m, src)
1634 }
1635 func (m *Nil) XXX_Size() int {
1636 return m.Size()
1637 }
1638 func (m *Nil) XXX_DiscardUnknown() {
1639 xxx_messageInfo_Nil.DiscardUnknown(m)
1640 }
1641
1642 var xxx_messageInfo_Nil proto.InternalMessageInfo
1643
1644 type NidOptEnum struct {
1645 Field1 TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1"`
1646 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1647 XXX_unrecognized []byte `json:"-"`
1648 XXX_sizecache int32 `json:"-"`
1649 }
1650
1651 func (m *NidOptEnum) Reset() { *m = NidOptEnum{} }
1652 func (*NidOptEnum) ProtoMessage() {}
1653 func (*NidOptEnum) Descriptor() ([]byte, []int) {
1654 return fileDescriptor_519c3115fa9830d1, []int{32}
1655 }
1656 func (m *NidOptEnum) XXX_Unmarshal(b []byte) error {
1657 return m.Unmarshal(b)
1658 }
1659 func (m *NidOptEnum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1660 if deterministic {
1661 return xxx_messageInfo_NidOptEnum.Marshal(b, m, deterministic)
1662 } else {
1663 b = b[:cap(b)]
1664 n, err := m.MarshalToSizedBuffer(b)
1665 if err != nil {
1666 return nil, err
1667 }
1668 return b[:n], nil
1669 }
1670 }
1671 func (m *NidOptEnum) XXX_Merge(src proto.Message) {
1672 xxx_messageInfo_NidOptEnum.Merge(m, src)
1673 }
1674 func (m *NidOptEnum) XXX_Size() int {
1675 return m.Size()
1676 }
1677 func (m *NidOptEnum) XXX_DiscardUnknown() {
1678 xxx_messageInfo_NidOptEnum.DiscardUnknown(m)
1679 }
1680
1681 var xxx_messageInfo_NidOptEnum proto.InternalMessageInfo
1682
1683 type NinOptEnum struct {
1684 Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"`
1685 Field2 *YetAnotherTestEnum `protobuf:"varint,2,opt,name=Field2,enum=test.YetAnotherTestEnum" json:"Field2,omitempty"`
1686 Field3 *YetYetAnotherTestEnum `protobuf:"varint,3,opt,name=Field3,enum=test.YetYetAnotherTestEnum" json:"Field3,omitempty"`
1687 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1688 XXX_unrecognized []byte `json:"-"`
1689 XXX_sizecache int32 `json:"-"`
1690 }
1691
1692 func (m *NinOptEnum) Reset() { *m = NinOptEnum{} }
1693 func (*NinOptEnum) ProtoMessage() {}
1694 func (*NinOptEnum) Descriptor() ([]byte, []int) {
1695 return fileDescriptor_519c3115fa9830d1, []int{33}
1696 }
1697 func (m *NinOptEnum) XXX_Unmarshal(b []byte) error {
1698 return m.Unmarshal(b)
1699 }
1700 func (m *NinOptEnum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1701 if deterministic {
1702 return xxx_messageInfo_NinOptEnum.Marshal(b, m, deterministic)
1703 } else {
1704 b = b[:cap(b)]
1705 n, err := m.MarshalToSizedBuffer(b)
1706 if err != nil {
1707 return nil, err
1708 }
1709 return b[:n], nil
1710 }
1711 }
1712 func (m *NinOptEnum) XXX_Merge(src proto.Message) {
1713 xxx_messageInfo_NinOptEnum.Merge(m, src)
1714 }
1715 func (m *NinOptEnum) XXX_Size() int {
1716 return m.Size()
1717 }
1718 func (m *NinOptEnum) XXX_DiscardUnknown() {
1719 xxx_messageInfo_NinOptEnum.DiscardUnknown(m)
1720 }
1721
1722 var xxx_messageInfo_NinOptEnum proto.InternalMessageInfo
1723
1724 type NidRepEnum struct {
1725 Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"`
1726 Field2 []YetAnotherTestEnum `protobuf:"varint,2,rep,name=Field2,enum=test.YetAnotherTestEnum" json:"Field2,omitempty"`
1727 Field3 []YetYetAnotherTestEnum `protobuf:"varint,3,rep,name=Field3,enum=test.YetYetAnotherTestEnum" json:"Field3,omitempty"`
1728 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1729 XXX_unrecognized []byte `json:"-"`
1730 XXX_sizecache int32 `json:"-"`
1731 }
1732
1733 func (m *NidRepEnum) Reset() { *m = NidRepEnum{} }
1734 func (*NidRepEnum) ProtoMessage() {}
1735 func (*NidRepEnum) Descriptor() ([]byte, []int) {
1736 return fileDescriptor_519c3115fa9830d1, []int{34}
1737 }
1738 func (m *NidRepEnum) XXX_Unmarshal(b []byte) error {
1739 return m.Unmarshal(b)
1740 }
1741 func (m *NidRepEnum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1742 if deterministic {
1743 return xxx_messageInfo_NidRepEnum.Marshal(b, m, deterministic)
1744 } else {
1745 b = b[:cap(b)]
1746 n, err := m.MarshalToSizedBuffer(b)
1747 if err != nil {
1748 return nil, err
1749 }
1750 return b[:n], nil
1751 }
1752 }
1753 func (m *NidRepEnum) XXX_Merge(src proto.Message) {
1754 xxx_messageInfo_NidRepEnum.Merge(m, src)
1755 }
1756 func (m *NidRepEnum) XXX_Size() int {
1757 return m.Size()
1758 }
1759 func (m *NidRepEnum) XXX_DiscardUnknown() {
1760 xxx_messageInfo_NidRepEnum.DiscardUnknown(m)
1761 }
1762
1763 var xxx_messageInfo_NidRepEnum proto.InternalMessageInfo
1764
1765 type NinRepEnum struct {
1766 Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"`
1767 Field2 []YetAnotherTestEnum `protobuf:"varint,2,rep,name=Field2,enum=test.YetAnotherTestEnum" json:"Field2,omitempty"`
1768 Field3 []YetYetAnotherTestEnum `protobuf:"varint,3,rep,name=Field3,enum=test.YetYetAnotherTestEnum" json:"Field3,omitempty"`
1769 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1770 XXX_unrecognized []byte `json:"-"`
1771 XXX_sizecache int32 `json:"-"`
1772 }
1773
1774 func (m *NinRepEnum) Reset() { *m = NinRepEnum{} }
1775 func (*NinRepEnum) ProtoMessage() {}
1776 func (*NinRepEnum) Descriptor() ([]byte, []int) {
1777 return fileDescriptor_519c3115fa9830d1, []int{35}
1778 }
1779 func (m *NinRepEnum) XXX_Unmarshal(b []byte) error {
1780 return m.Unmarshal(b)
1781 }
1782 func (m *NinRepEnum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1783 if deterministic {
1784 return xxx_messageInfo_NinRepEnum.Marshal(b, m, deterministic)
1785 } else {
1786 b = b[:cap(b)]
1787 n, err := m.MarshalToSizedBuffer(b)
1788 if err != nil {
1789 return nil, err
1790 }
1791 return b[:n], nil
1792 }
1793 }
1794 func (m *NinRepEnum) XXX_Merge(src proto.Message) {
1795 xxx_messageInfo_NinRepEnum.Merge(m, src)
1796 }
1797 func (m *NinRepEnum) XXX_Size() int {
1798 return m.Size()
1799 }
1800 func (m *NinRepEnum) XXX_DiscardUnknown() {
1801 xxx_messageInfo_NinRepEnum.DiscardUnknown(m)
1802 }
1803
1804 var xxx_messageInfo_NinRepEnum proto.InternalMessageInfo
1805
1806 type NinOptEnumDefault struct {
1807 Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum,def=2" json:"Field1,omitempty"`
1808 Field2 *YetAnotherTestEnum `protobuf:"varint,2,opt,name=Field2,enum=test.YetAnotherTestEnum,def=1" json:"Field2,omitempty"`
1809 Field3 *YetYetAnotherTestEnum `protobuf:"varint,3,opt,name=Field3,enum=test.YetYetAnotherTestEnum,def=0" json:"Field3,omitempty"`
1810 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1811 XXX_unrecognized []byte `json:"-"`
1812 XXX_sizecache int32 `json:"-"`
1813 }
1814
1815 func (m *NinOptEnumDefault) Reset() { *m = NinOptEnumDefault{} }
1816 func (*NinOptEnumDefault) ProtoMessage() {}
1817 func (*NinOptEnumDefault) Descriptor() ([]byte, []int) {
1818 return fileDescriptor_519c3115fa9830d1, []int{36}
1819 }
1820 func (m *NinOptEnumDefault) XXX_Unmarshal(b []byte) error {
1821 return m.Unmarshal(b)
1822 }
1823 func (m *NinOptEnumDefault) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1824 if deterministic {
1825 return xxx_messageInfo_NinOptEnumDefault.Marshal(b, m, deterministic)
1826 } else {
1827 b = b[:cap(b)]
1828 n, err := m.MarshalToSizedBuffer(b)
1829 if err != nil {
1830 return nil, err
1831 }
1832 return b[:n], nil
1833 }
1834 }
1835 func (m *NinOptEnumDefault) XXX_Merge(src proto.Message) {
1836 xxx_messageInfo_NinOptEnumDefault.Merge(m, src)
1837 }
1838 func (m *NinOptEnumDefault) XXX_Size() int {
1839 return m.Size()
1840 }
1841 func (m *NinOptEnumDefault) XXX_DiscardUnknown() {
1842 xxx_messageInfo_NinOptEnumDefault.DiscardUnknown(m)
1843 }
1844
1845 var xxx_messageInfo_NinOptEnumDefault proto.InternalMessageInfo
1846
1847 const Default_NinOptEnumDefault_Field1 TheTestEnum = C
1848 const Default_NinOptEnumDefault_Field2 YetAnotherTestEnum = BetterYetBB
1849 const Default_NinOptEnumDefault_Field3 YetYetAnotherTestEnum = YetYetAnotherTestEnum_CC
1850
1851 func (m *NinOptEnumDefault) GetField1() TheTestEnum {
1852 if m != nil && m.Field1 != nil {
1853 return *m.Field1
1854 }
1855 return Default_NinOptEnumDefault_Field1
1856 }
1857
1858 func (m *NinOptEnumDefault) GetField2() YetAnotherTestEnum {
1859 if m != nil && m.Field2 != nil {
1860 return *m.Field2
1861 }
1862 return Default_NinOptEnumDefault_Field2
1863 }
1864
1865 func (m *NinOptEnumDefault) GetField3() YetYetAnotherTestEnum {
1866 if m != nil && m.Field3 != nil {
1867 return *m.Field3
1868 }
1869 return Default_NinOptEnumDefault_Field3
1870 }
1871
1872 type AnotherNinOptEnum struct {
1873 Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum" json:"Field1,omitempty"`
1874 Field2 *YetAnotherTestEnum `protobuf:"varint,2,opt,name=Field2,enum=test.YetAnotherTestEnum" json:"Field2,omitempty"`
1875 Field3 *YetYetAnotherTestEnum `protobuf:"varint,3,opt,name=Field3,enum=test.YetYetAnotherTestEnum" json:"Field3,omitempty"`
1876 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1877 XXX_unrecognized []byte `json:"-"`
1878 XXX_sizecache int32 `json:"-"`
1879 }
1880
1881 func (m *AnotherNinOptEnum) Reset() { *m = AnotherNinOptEnum{} }
1882 func (*AnotherNinOptEnum) ProtoMessage() {}
1883 func (*AnotherNinOptEnum) Descriptor() ([]byte, []int) {
1884 return fileDescriptor_519c3115fa9830d1, []int{37}
1885 }
1886 func (m *AnotherNinOptEnum) XXX_Unmarshal(b []byte) error {
1887 return m.Unmarshal(b)
1888 }
1889 func (m *AnotherNinOptEnum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1890 if deterministic {
1891 return xxx_messageInfo_AnotherNinOptEnum.Marshal(b, m, deterministic)
1892 } else {
1893 b = b[:cap(b)]
1894 n, err := m.MarshalToSizedBuffer(b)
1895 if err != nil {
1896 return nil, err
1897 }
1898 return b[:n], nil
1899 }
1900 }
1901 func (m *AnotherNinOptEnum) XXX_Merge(src proto.Message) {
1902 xxx_messageInfo_AnotherNinOptEnum.Merge(m, src)
1903 }
1904 func (m *AnotherNinOptEnum) XXX_Size() int {
1905 return m.Size()
1906 }
1907 func (m *AnotherNinOptEnum) XXX_DiscardUnknown() {
1908 xxx_messageInfo_AnotherNinOptEnum.DiscardUnknown(m)
1909 }
1910
1911 var xxx_messageInfo_AnotherNinOptEnum proto.InternalMessageInfo
1912
1913 type AnotherNinOptEnumDefault struct {
1914 Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum,def=11" json:"Field1,omitempty"`
1915 Field2 *YetAnotherTestEnum `protobuf:"varint,2,opt,name=Field2,enum=test.YetAnotherTestEnum,def=1" json:"Field2,omitempty"`
1916 Field3 *YetYetAnotherTestEnum `protobuf:"varint,3,opt,name=Field3,enum=test.YetYetAnotherTestEnum,def=0" json:"Field3,omitempty"`
1917 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1918 XXX_unrecognized []byte `json:"-"`
1919 XXX_sizecache int32 `json:"-"`
1920 }
1921
1922 func (m *AnotherNinOptEnumDefault) Reset() { *m = AnotherNinOptEnumDefault{} }
1923 func (*AnotherNinOptEnumDefault) ProtoMessage() {}
1924 func (*AnotherNinOptEnumDefault) Descriptor() ([]byte, []int) {
1925 return fileDescriptor_519c3115fa9830d1, []int{38}
1926 }
1927 func (m *AnotherNinOptEnumDefault) XXX_Unmarshal(b []byte) error {
1928 return m.Unmarshal(b)
1929 }
1930 func (m *AnotherNinOptEnumDefault) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1931 if deterministic {
1932 return xxx_messageInfo_AnotherNinOptEnumDefault.Marshal(b, m, deterministic)
1933 } else {
1934 b = b[:cap(b)]
1935 n, err := m.MarshalToSizedBuffer(b)
1936 if err != nil {
1937 return nil, err
1938 }
1939 return b[:n], nil
1940 }
1941 }
1942 func (m *AnotherNinOptEnumDefault) XXX_Merge(src proto.Message) {
1943 xxx_messageInfo_AnotherNinOptEnumDefault.Merge(m, src)
1944 }
1945 func (m *AnotherNinOptEnumDefault) XXX_Size() int {
1946 return m.Size()
1947 }
1948 func (m *AnotherNinOptEnumDefault) XXX_DiscardUnknown() {
1949 xxx_messageInfo_AnotherNinOptEnumDefault.DiscardUnknown(m)
1950 }
1951
1952 var xxx_messageInfo_AnotherNinOptEnumDefault proto.InternalMessageInfo
1953
1954 const Default_AnotherNinOptEnumDefault_Field1 AnotherTestEnum = E
1955 const Default_AnotherNinOptEnumDefault_Field2 YetAnotherTestEnum = BetterYetBB
1956 const Default_AnotherNinOptEnumDefault_Field3 YetYetAnotherTestEnum = YetYetAnotherTestEnum_CC
1957
1958 func (m *AnotherNinOptEnumDefault) GetField1() AnotherTestEnum {
1959 if m != nil && m.Field1 != nil {
1960 return *m.Field1
1961 }
1962 return Default_AnotherNinOptEnumDefault_Field1
1963 }
1964
1965 func (m *AnotherNinOptEnumDefault) GetField2() YetAnotherTestEnum {
1966 if m != nil && m.Field2 != nil {
1967 return *m.Field2
1968 }
1969 return Default_AnotherNinOptEnumDefault_Field2
1970 }
1971
1972 func (m *AnotherNinOptEnumDefault) GetField3() YetYetAnotherTestEnum {
1973 if m != nil && m.Field3 != nil {
1974 return *m.Field3
1975 }
1976 return Default_AnotherNinOptEnumDefault_Field3
1977 }
1978
1979 type Timer struct {
1980 Time1 int64 `protobuf:"fixed64,1,opt,name=Time1" json:"Time1"`
1981 Time2 int64 `protobuf:"fixed64,2,opt,name=Time2" json:"Time2"`
1982 Data []byte `protobuf:"bytes,3,opt,name=Data" json:"Data"`
1983 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1984 XXX_unrecognized []byte `json:"-"`
1985 XXX_sizecache int32 `json:"-"`
1986 }
1987
1988 func (m *Timer) Reset() { *m = Timer{} }
1989 func (*Timer) ProtoMessage() {}
1990 func (*Timer) Descriptor() ([]byte, []int) {
1991 return fileDescriptor_519c3115fa9830d1, []int{39}
1992 }
1993 func (m *Timer) XXX_Unmarshal(b []byte) error {
1994 return m.Unmarshal(b)
1995 }
1996 func (m *Timer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1997 if deterministic {
1998 return xxx_messageInfo_Timer.Marshal(b, m, deterministic)
1999 } else {
2000 b = b[:cap(b)]
2001 n, err := m.MarshalToSizedBuffer(b)
2002 if err != nil {
2003 return nil, err
2004 }
2005 return b[:n], nil
2006 }
2007 }
2008 func (m *Timer) XXX_Merge(src proto.Message) {
2009 xxx_messageInfo_Timer.Merge(m, src)
2010 }
2011 func (m *Timer) XXX_Size() int {
2012 return m.Size()
2013 }
2014 func (m *Timer) XXX_DiscardUnknown() {
2015 xxx_messageInfo_Timer.DiscardUnknown(m)
2016 }
2017
2018 var xxx_messageInfo_Timer proto.InternalMessageInfo
2019
2020 type MyExtendable struct {
2021 Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"`
2022 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2023 proto.XXX_InternalExtensions `json:"-"`
2024 XXX_unrecognized []byte `json:"-"`
2025 XXX_sizecache int32 `json:"-"`
2026 }
2027
2028 func (m *MyExtendable) Reset() { *m = MyExtendable{} }
2029 func (*MyExtendable) ProtoMessage() {}
2030 func (*MyExtendable) Descriptor() ([]byte, []int) {
2031 return fileDescriptor_519c3115fa9830d1, []int{40}
2032 }
2033
2034 var extRange_MyExtendable = []proto.ExtensionRange{
2035 {Start: 100, End: 199},
2036 }
2037
2038 func (*MyExtendable) ExtensionRangeArray() []proto.ExtensionRange {
2039 return extRange_MyExtendable
2040 }
2041
2042 func (m *MyExtendable) XXX_Unmarshal(b []byte) error {
2043 return m.Unmarshal(b)
2044 }
2045 func (m *MyExtendable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2046 if deterministic {
2047 return xxx_messageInfo_MyExtendable.Marshal(b, m, deterministic)
2048 } else {
2049 b = b[:cap(b)]
2050 n, err := m.MarshalToSizedBuffer(b)
2051 if err != nil {
2052 return nil, err
2053 }
2054 return b[:n], nil
2055 }
2056 }
2057 func (m *MyExtendable) XXX_Merge(src proto.Message) {
2058 xxx_messageInfo_MyExtendable.Merge(m, src)
2059 }
2060 func (m *MyExtendable) XXX_Size() int {
2061 return m.Size()
2062 }
2063 func (m *MyExtendable) XXX_DiscardUnknown() {
2064 xxx_messageInfo_MyExtendable.DiscardUnknown(m)
2065 }
2066
2067 var xxx_messageInfo_MyExtendable proto.InternalMessageInfo
2068
2069 type OtherExtenable struct {
2070 Field2 *int64 `protobuf:"varint,2,opt,name=Field2" json:"Field2,omitempty"`
2071 Field13 *int64 `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"`
2072 M *MyExtendable `protobuf:"bytes,1,opt,name=M" json:"M,omitempty"`
2073 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2074 proto.XXX_InternalExtensions `json:"-"`
2075 XXX_unrecognized []byte `json:"-"`
2076 XXX_sizecache int32 `json:"-"`
2077 }
2078
2079 func (m *OtherExtenable) Reset() { *m = OtherExtenable{} }
2080 func (*OtherExtenable) ProtoMessage() {}
2081 func (*OtherExtenable) Descriptor() ([]byte, []int) {
2082 return fileDescriptor_519c3115fa9830d1, []int{41}
2083 }
2084
2085 var extRange_OtherExtenable = []proto.ExtensionRange{
2086 {Start: 14, End: 16},
2087 {Start: 10, End: 12},
2088 }
2089
2090 func (*OtherExtenable) ExtensionRangeArray() []proto.ExtensionRange {
2091 return extRange_OtherExtenable
2092 }
2093
2094 func (m *OtherExtenable) XXX_Unmarshal(b []byte) error {
2095 return m.Unmarshal(b)
2096 }
2097 func (m *OtherExtenable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2098 if deterministic {
2099 return xxx_messageInfo_OtherExtenable.Marshal(b, m, deterministic)
2100 } else {
2101 b = b[:cap(b)]
2102 n, err := m.MarshalToSizedBuffer(b)
2103 if err != nil {
2104 return nil, err
2105 }
2106 return b[:n], nil
2107 }
2108 }
2109 func (m *OtherExtenable) XXX_Merge(src proto.Message) {
2110 xxx_messageInfo_OtherExtenable.Merge(m, src)
2111 }
2112 func (m *OtherExtenable) XXX_Size() int {
2113 return m.Size()
2114 }
2115 func (m *OtherExtenable) XXX_DiscardUnknown() {
2116 xxx_messageInfo_OtherExtenable.DiscardUnknown(m)
2117 }
2118
2119 var xxx_messageInfo_OtherExtenable proto.InternalMessageInfo
2120
2121 type NestedDefinition struct {
2122 Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"`
2123 EnumField *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=EnumField,enum=test.NestedDefinition_NestedEnum" json:"EnumField,omitempty"`
2124 NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,3,opt,name=NNM" json:"NNM,omitempty"`
2125 NM *NestedDefinition_NestedMessage `protobuf:"bytes,4,opt,name=NM" json:"NM,omitempty"`
2126 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2127 XXX_unrecognized []byte `json:"-"`
2128 XXX_sizecache int32 `json:"-"`
2129 }
2130
2131 func (m *NestedDefinition) Reset() { *m = NestedDefinition{} }
2132 func (*NestedDefinition) ProtoMessage() {}
2133 func (*NestedDefinition) Descriptor() ([]byte, []int) {
2134 return fileDescriptor_519c3115fa9830d1, []int{42}
2135 }
2136 func (m *NestedDefinition) XXX_Unmarshal(b []byte) error {
2137 return m.Unmarshal(b)
2138 }
2139 func (m *NestedDefinition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2140 if deterministic {
2141 return xxx_messageInfo_NestedDefinition.Marshal(b, m, deterministic)
2142 } else {
2143 b = b[:cap(b)]
2144 n, err := m.MarshalToSizedBuffer(b)
2145 if err != nil {
2146 return nil, err
2147 }
2148 return b[:n], nil
2149 }
2150 }
2151 func (m *NestedDefinition) XXX_Merge(src proto.Message) {
2152 xxx_messageInfo_NestedDefinition.Merge(m, src)
2153 }
2154 func (m *NestedDefinition) XXX_Size() int {
2155 return m.Size()
2156 }
2157 func (m *NestedDefinition) XXX_DiscardUnknown() {
2158 xxx_messageInfo_NestedDefinition.DiscardUnknown(m)
2159 }
2160
2161 var xxx_messageInfo_NestedDefinition proto.InternalMessageInfo
2162
2163 type NestedDefinition_NestedMessage struct {
2164 NestedField1 *uint64 `protobuf:"fixed64,1,opt,name=NestedField1" json:"NestedField1,omitempty"`
2165 NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,2,opt,name=NNM" json:"NNM,omitempty"`
2166 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2167 XXX_unrecognized []byte `json:"-"`
2168 XXX_sizecache int32 `json:"-"`
2169 }
2170
2171 func (m *NestedDefinition_NestedMessage) Reset() { *m = NestedDefinition_NestedMessage{} }
2172 func (*NestedDefinition_NestedMessage) ProtoMessage() {}
2173 func (*NestedDefinition_NestedMessage) Descriptor() ([]byte, []int) {
2174 return fileDescriptor_519c3115fa9830d1, []int{42, 0}
2175 }
2176 func (m *NestedDefinition_NestedMessage) XXX_Unmarshal(b []byte) error {
2177 return m.Unmarshal(b)
2178 }
2179 func (m *NestedDefinition_NestedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2180 if deterministic {
2181 return xxx_messageInfo_NestedDefinition_NestedMessage.Marshal(b, m, deterministic)
2182 } else {
2183 b = b[:cap(b)]
2184 n, err := m.MarshalToSizedBuffer(b)
2185 if err != nil {
2186 return nil, err
2187 }
2188 return b[:n], nil
2189 }
2190 }
2191 func (m *NestedDefinition_NestedMessage) XXX_Merge(src proto.Message) {
2192 xxx_messageInfo_NestedDefinition_NestedMessage.Merge(m, src)
2193 }
2194 func (m *NestedDefinition_NestedMessage) XXX_Size() int {
2195 return m.Size()
2196 }
2197 func (m *NestedDefinition_NestedMessage) XXX_DiscardUnknown() {
2198 xxx_messageInfo_NestedDefinition_NestedMessage.DiscardUnknown(m)
2199 }
2200
2201 var xxx_messageInfo_NestedDefinition_NestedMessage proto.InternalMessageInfo
2202
2203 type NestedDefinition_NestedMessage_NestedNestedMsg struct {
2204 NestedNestedField1 *string `protobuf:"bytes,10,opt,name=NestedNestedField1" json:"NestedNestedField1,omitempty"`
2205 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2206 XXX_unrecognized []byte `json:"-"`
2207 XXX_sizecache int32 `json:"-"`
2208 }
2209
2210 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Reset() {
2211 *m = NestedDefinition_NestedMessage_NestedNestedMsg{}
2212 }
2213 func (*NestedDefinition_NestedMessage_NestedNestedMsg) ProtoMessage() {}
2214 func (*NestedDefinition_NestedMessage_NestedNestedMsg) Descriptor() ([]byte, []int) {
2215 return fileDescriptor_519c3115fa9830d1, []int{42, 0, 0}
2216 }
2217 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) XXX_Unmarshal(b []byte) error {
2218 return m.Unmarshal(b)
2219 }
2220 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2221 if deterministic {
2222 return xxx_messageInfo_NestedDefinition_NestedMessage_NestedNestedMsg.Marshal(b, m, deterministic)
2223 } else {
2224 b = b[:cap(b)]
2225 n, err := m.MarshalToSizedBuffer(b)
2226 if err != nil {
2227 return nil, err
2228 }
2229 return b[:n], nil
2230 }
2231 }
2232 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) XXX_Merge(src proto.Message) {
2233 xxx_messageInfo_NestedDefinition_NestedMessage_NestedNestedMsg.Merge(m, src)
2234 }
2235 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) XXX_Size() int {
2236 return m.Size()
2237 }
2238 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) XXX_DiscardUnknown() {
2239 xxx_messageInfo_NestedDefinition_NestedMessage_NestedNestedMsg.DiscardUnknown(m)
2240 }
2241
2242 var xxx_messageInfo_NestedDefinition_NestedMessage_NestedNestedMsg proto.InternalMessageInfo
2243
2244 type NestedScope struct {
2245 A *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,1,opt,name=A" json:"A,omitempty"`
2246 B *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=B,enum=test.NestedDefinition_NestedEnum" json:"B,omitempty"`
2247 C *NestedDefinition_NestedMessage `protobuf:"bytes,3,opt,name=C" json:"C,omitempty"`
2248 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2249 XXX_unrecognized []byte `json:"-"`
2250 XXX_sizecache int32 `json:"-"`
2251 }
2252
2253 func (m *NestedScope) Reset() { *m = NestedScope{} }
2254 func (*NestedScope) ProtoMessage() {}
2255 func (*NestedScope) Descriptor() ([]byte, []int) {
2256 return fileDescriptor_519c3115fa9830d1, []int{43}
2257 }
2258 func (m *NestedScope) XXX_Unmarshal(b []byte) error {
2259 return m.Unmarshal(b)
2260 }
2261 func (m *NestedScope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2262 if deterministic {
2263 return xxx_messageInfo_NestedScope.Marshal(b, m, deterministic)
2264 } else {
2265 b = b[:cap(b)]
2266 n, err := m.MarshalToSizedBuffer(b)
2267 if err != nil {
2268 return nil, err
2269 }
2270 return b[:n], nil
2271 }
2272 }
2273 func (m *NestedScope) XXX_Merge(src proto.Message) {
2274 xxx_messageInfo_NestedScope.Merge(m, src)
2275 }
2276 func (m *NestedScope) XXX_Size() int {
2277 return m.Size()
2278 }
2279 func (m *NestedScope) XXX_DiscardUnknown() {
2280 xxx_messageInfo_NestedScope.DiscardUnknown(m)
2281 }
2282
2283 var xxx_messageInfo_NestedScope proto.InternalMessageInfo
2284
2285 type NinOptNativeDefault struct {
2286 Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1,def=1234.1234" json:"Field1,omitempty"`
2287 Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2,def=1234.1234" json:"Field2,omitempty"`
2288 Field3 *int32 `protobuf:"varint,3,opt,name=Field3,def=1234" json:"Field3,omitempty"`
2289 Field4 *int64 `protobuf:"varint,4,opt,name=Field4,def=1234" json:"Field4,omitempty"`
2290 Field5 *uint32 `protobuf:"varint,5,opt,name=Field5,def=1234" json:"Field5,omitempty"`
2291 Field6 *uint64 `protobuf:"varint,6,opt,name=Field6,def=1234" json:"Field6,omitempty"`
2292 Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7,def=1234" json:"Field7,omitempty"`
2293 Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8,def=1234" json:"Field8,omitempty"`
2294 Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9,def=1234" json:"Field9,omitempty"`
2295 Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10,def=1234" json:"Field10,omitempty"`
2296 Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11,def=1234" json:"Field11,omitempty"`
2297 Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12,def=1234" json:"Field12,omitempty"`
2298 Field13 *bool `protobuf:"varint,13,opt,name=Field13,def=1" json:"Field13,omitempty"`
2299 Field14 *string `protobuf:"bytes,14,opt,name=Field14,def=1234" json:"Field14,omitempty"`
2300 Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"`
2301 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2302 XXX_unrecognized []byte `json:"-"`
2303 XXX_sizecache int32 `json:"-"`
2304 }
2305
2306 func (m *NinOptNativeDefault) Reset() { *m = NinOptNativeDefault{} }
2307 func (*NinOptNativeDefault) ProtoMessage() {}
2308 func (*NinOptNativeDefault) Descriptor() ([]byte, []int) {
2309 return fileDescriptor_519c3115fa9830d1, []int{44}
2310 }
2311 func (m *NinOptNativeDefault) XXX_Unmarshal(b []byte) error {
2312 return m.Unmarshal(b)
2313 }
2314 func (m *NinOptNativeDefault) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2315 if deterministic {
2316 return xxx_messageInfo_NinOptNativeDefault.Marshal(b, m, deterministic)
2317 } else {
2318 b = b[:cap(b)]
2319 n, err := m.MarshalToSizedBuffer(b)
2320 if err != nil {
2321 return nil, err
2322 }
2323 return b[:n], nil
2324 }
2325 }
2326 func (m *NinOptNativeDefault) XXX_Merge(src proto.Message) {
2327 xxx_messageInfo_NinOptNativeDefault.Merge(m, src)
2328 }
2329 func (m *NinOptNativeDefault) XXX_Size() int {
2330 return m.Size()
2331 }
2332 func (m *NinOptNativeDefault) XXX_DiscardUnknown() {
2333 xxx_messageInfo_NinOptNativeDefault.DiscardUnknown(m)
2334 }
2335
2336 var xxx_messageInfo_NinOptNativeDefault proto.InternalMessageInfo
2337
2338 const Default_NinOptNativeDefault_Field1 float64 = 1234.1234
2339 const Default_NinOptNativeDefault_Field2 float32 = 1234.1234
2340 const Default_NinOptNativeDefault_Field3 int32 = 1234
2341 const Default_NinOptNativeDefault_Field4 int64 = 1234
2342 const Default_NinOptNativeDefault_Field5 uint32 = 1234
2343 const Default_NinOptNativeDefault_Field6 uint64 = 1234
2344 const Default_NinOptNativeDefault_Field7 int32 = 1234
2345 const Default_NinOptNativeDefault_Field8 int64 = 1234
2346 const Default_NinOptNativeDefault_Field9 uint32 = 1234
2347 const Default_NinOptNativeDefault_Field10 int32 = 1234
2348 const Default_NinOptNativeDefault_Field11 uint64 = 1234
2349 const Default_NinOptNativeDefault_Field12 int64 = 1234
2350 const Default_NinOptNativeDefault_Field13 bool = true
2351 const Default_NinOptNativeDefault_Field14 string = "1234"
2352
2353 func (m *NinOptNativeDefault) GetField1() float64 {
2354 if m != nil && m.Field1 != nil {
2355 return *m.Field1
2356 }
2357 return Default_NinOptNativeDefault_Field1
2358 }
2359
2360 func (m *NinOptNativeDefault) GetField2() float32 {
2361 if m != nil && m.Field2 != nil {
2362 return *m.Field2
2363 }
2364 return Default_NinOptNativeDefault_Field2
2365 }
2366
2367 func (m *NinOptNativeDefault) GetField3() int32 {
2368 if m != nil && m.Field3 != nil {
2369 return *m.Field3
2370 }
2371 return Default_NinOptNativeDefault_Field3
2372 }
2373
2374 func (m *NinOptNativeDefault) GetField4() int64 {
2375 if m != nil && m.Field4 != nil {
2376 return *m.Field4
2377 }
2378 return Default_NinOptNativeDefault_Field4
2379 }
2380
2381 func (m *NinOptNativeDefault) GetField5() uint32 {
2382 if m != nil && m.Field5 != nil {
2383 return *m.Field5
2384 }
2385 return Default_NinOptNativeDefault_Field5
2386 }
2387
2388 func (m *NinOptNativeDefault) GetField6() uint64 {
2389 if m != nil && m.Field6 != nil {
2390 return *m.Field6
2391 }
2392 return Default_NinOptNativeDefault_Field6
2393 }
2394
2395 func (m *NinOptNativeDefault) GetField7() int32 {
2396 if m != nil && m.Field7 != nil {
2397 return *m.Field7
2398 }
2399 return Default_NinOptNativeDefault_Field7
2400 }
2401
2402 func (m *NinOptNativeDefault) GetField8() int64 {
2403 if m != nil && m.Field8 != nil {
2404 return *m.Field8
2405 }
2406 return Default_NinOptNativeDefault_Field8
2407 }
2408
2409 func (m *NinOptNativeDefault) GetField9() uint32 {
2410 if m != nil && m.Field9 != nil {
2411 return *m.Field9
2412 }
2413 return Default_NinOptNativeDefault_Field9
2414 }
2415
2416 func (m *NinOptNativeDefault) GetField10() int32 {
2417 if m != nil && m.Field10 != nil {
2418 return *m.Field10
2419 }
2420 return Default_NinOptNativeDefault_Field10
2421 }
2422
2423 func (m *NinOptNativeDefault) GetField11() uint64 {
2424 if m != nil && m.Field11 != nil {
2425 return *m.Field11
2426 }
2427 return Default_NinOptNativeDefault_Field11
2428 }
2429
2430 func (m *NinOptNativeDefault) GetField12() int64 {
2431 if m != nil && m.Field12 != nil {
2432 return *m.Field12
2433 }
2434 return Default_NinOptNativeDefault_Field12
2435 }
2436
2437 func (m *NinOptNativeDefault) GetField13() bool {
2438 if m != nil && m.Field13 != nil {
2439 return *m.Field13
2440 }
2441 return Default_NinOptNativeDefault_Field13
2442 }
2443
2444 func (m *NinOptNativeDefault) GetField14() string {
2445 if m != nil && m.Field14 != nil {
2446 return *m.Field14
2447 }
2448 return Default_NinOptNativeDefault_Field14
2449 }
2450
2451 func (m *NinOptNativeDefault) GetField15() []byte {
2452 if m != nil {
2453 return m.Field15
2454 }
2455 return nil
2456 }
2457
2458 type CustomContainer struct {
2459 CustomStruct NidOptCustom `protobuf:"bytes,1,opt,name=CustomStruct" json:"CustomStruct"`
2460 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2461 XXX_unrecognized []byte `json:"-"`
2462 XXX_sizecache int32 `json:"-"`
2463 }
2464
2465 func (m *CustomContainer) Reset() { *m = CustomContainer{} }
2466 func (*CustomContainer) ProtoMessage() {}
2467 func (*CustomContainer) Descriptor() ([]byte, []int) {
2468 return fileDescriptor_519c3115fa9830d1, []int{45}
2469 }
2470 func (m *CustomContainer) XXX_Unmarshal(b []byte) error {
2471 return m.Unmarshal(b)
2472 }
2473 func (m *CustomContainer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2474 if deterministic {
2475 return xxx_messageInfo_CustomContainer.Marshal(b, m, deterministic)
2476 } else {
2477 b = b[:cap(b)]
2478 n, err := m.MarshalToSizedBuffer(b)
2479 if err != nil {
2480 return nil, err
2481 }
2482 return b[:n], nil
2483 }
2484 }
2485 func (m *CustomContainer) XXX_Merge(src proto.Message) {
2486 xxx_messageInfo_CustomContainer.Merge(m, src)
2487 }
2488 func (m *CustomContainer) XXX_Size() int {
2489 return m.Size()
2490 }
2491 func (m *CustomContainer) XXX_DiscardUnknown() {
2492 xxx_messageInfo_CustomContainer.DiscardUnknown(m)
2493 }
2494
2495 var xxx_messageInfo_CustomContainer proto.InternalMessageInfo
2496
2497 type CustomNameNidOptNative struct {
2498 FieldA float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"`
2499 FieldB float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"`
2500 FieldC int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"`
2501 FieldD int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"`
2502 FieldE uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"`
2503 FieldF uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"`
2504 FieldG int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"`
2505 FieldH int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"`
2506 FieldI uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"`
2507 FieldJ int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"`
2508 FieldK uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"`
2509 FieldL int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"`
2510 FieldM bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"`
2511 FieldN string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"`
2512 FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"`
2513 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2514 XXX_unrecognized []byte `json:"-"`
2515 XXX_sizecache int32 `json:"-"`
2516 }
2517
2518 func (m *CustomNameNidOptNative) Reset() { *m = CustomNameNidOptNative{} }
2519 func (*CustomNameNidOptNative) ProtoMessage() {}
2520 func (*CustomNameNidOptNative) Descriptor() ([]byte, []int) {
2521 return fileDescriptor_519c3115fa9830d1, []int{46}
2522 }
2523 func (m *CustomNameNidOptNative) XXX_Unmarshal(b []byte) error {
2524 return m.Unmarshal(b)
2525 }
2526 func (m *CustomNameNidOptNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2527 if deterministic {
2528 return xxx_messageInfo_CustomNameNidOptNative.Marshal(b, m, deterministic)
2529 } else {
2530 b = b[:cap(b)]
2531 n, err := m.MarshalToSizedBuffer(b)
2532 if err != nil {
2533 return nil, err
2534 }
2535 return b[:n], nil
2536 }
2537 }
2538 func (m *CustomNameNidOptNative) XXX_Merge(src proto.Message) {
2539 xxx_messageInfo_CustomNameNidOptNative.Merge(m, src)
2540 }
2541 func (m *CustomNameNidOptNative) XXX_Size() int {
2542 return m.Size()
2543 }
2544 func (m *CustomNameNidOptNative) XXX_DiscardUnknown() {
2545 xxx_messageInfo_CustomNameNidOptNative.DiscardUnknown(m)
2546 }
2547
2548 var xxx_messageInfo_CustomNameNidOptNative proto.InternalMessageInfo
2549
2550 type CustomNameNinOptNative struct {
2551 FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"`
2552 FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"`
2553 FieldC *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"`
2554 FieldD *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"`
2555 FieldE *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"`
2556 FieldF *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"`
2557 FieldG *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"`
2558 FieldH *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"`
2559 FieldI *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"`
2560 FieldJ *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"`
2561 FieldK *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"`
2562 FielL *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"`
2563 FieldM *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"`
2564 FieldN *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"`
2565 FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"`
2566 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2567 XXX_unrecognized []byte `json:"-"`
2568 XXX_sizecache int32 `json:"-"`
2569 }
2570
2571 func (m *CustomNameNinOptNative) Reset() { *m = CustomNameNinOptNative{} }
2572 func (*CustomNameNinOptNative) ProtoMessage() {}
2573 func (*CustomNameNinOptNative) Descriptor() ([]byte, []int) {
2574 return fileDescriptor_519c3115fa9830d1, []int{47}
2575 }
2576 func (m *CustomNameNinOptNative) XXX_Unmarshal(b []byte) error {
2577 return m.Unmarshal(b)
2578 }
2579 func (m *CustomNameNinOptNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2580 if deterministic {
2581 return xxx_messageInfo_CustomNameNinOptNative.Marshal(b, m, deterministic)
2582 } else {
2583 b = b[:cap(b)]
2584 n, err := m.MarshalToSizedBuffer(b)
2585 if err != nil {
2586 return nil, err
2587 }
2588 return b[:n], nil
2589 }
2590 }
2591 func (m *CustomNameNinOptNative) XXX_Merge(src proto.Message) {
2592 xxx_messageInfo_CustomNameNinOptNative.Merge(m, src)
2593 }
2594 func (m *CustomNameNinOptNative) XXX_Size() int {
2595 return m.Size()
2596 }
2597 func (m *CustomNameNinOptNative) XXX_DiscardUnknown() {
2598 xxx_messageInfo_CustomNameNinOptNative.DiscardUnknown(m)
2599 }
2600
2601 var xxx_messageInfo_CustomNameNinOptNative proto.InternalMessageInfo
2602
2603 type CustomNameNinRepNative struct {
2604 FieldA []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"`
2605 FieldB []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"`
2606 FieldC []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"`
2607 FieldD []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"`
2608 FieldE []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"`
2609 FieldF []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"`
2610 FieldG []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"`
2611 FieldH []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"`
2612 FieldI []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"`
2613 FieldJ []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"`
2614 FieldK []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"`
2615 FieldL []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"`
2616 FieldM []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"`
2617 FieldN []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"`
2618 FieldO [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"`
2619 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2620 XXX_unrecognized []byte `json:"-"`
2621 XXX_sizecache int32 `json:"-"`
2622 }
2623
2624 func (m *CustomNameNinRepNative) Reset() { *m = CustomNameNinRepNative{} }
2625 func (*CustomNameNinRepNative) ProtoMessage() {}
2626 func (*CustomNameNinRepNative) Descriptor() ([]byte, []int) {
2627 return fileDescriptor_519c3115fa9830d1, []int{48}
2628 }
2629 func (m *CustomNameNinRepNative) XXX_Unmarshal(b []byte) error {
2630 return m.Unmarshal(b)
2631 }
2632 func (m *CustomNameNinRepNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2633 if deterministic {
2634 return xxx_messageInfo_CustomNameNinRepNative.Marshal(b, m, deterministic)
2635 } else {
2636 b = b[:cap(b)]
2637 n, err := m.MarshalToSizedBuffer(b)
2638 if err != nil {
2639 return nil, err
2640 }
2641 return b[:n], nil
2642 }
2643 }
2644 func (m *CustomNameNinRepNative) XXX_Merge(src proto.Message) {
2645 xxx_messageInfo_CustomNameNinRepNative.Merge(m, src)
2646 }
2647 func (m *CustomNameNinRepNative) XXX_Size() int {
2648 return m.Size()
2649 }
2650 func (m *CustomNameNinRepNative) XXX_DiscardUnknown() {
2651 xxx_messageInfo_CustomNameNinRepNative.DiscardUnknown(m)
2652 }
2653
2654 var xxx_messageInfo_CustomNameNinRepNative proto.InternalMessageInfo
2655
2656 type CustomNameNinStruct struct {
2657 FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"`
2658 FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"`
2659 FieldC *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"`
2660 FieldD []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"`
2661 FieldE *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"`
2662 FieldF *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"`
2663 FieldG *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"`
2664 FieldH *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"`
2665 FieldI *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"`
2666 FieldJ []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"`
2667 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2668 XXX_unrecognized []byte `json:"-"`
2669 XXX_sizecache int32 `json:"-"`
2670 }
2671
2672 func (m *CustomNameNinStruct) Reset() { *m = CustomNameNinStruct{} }
2673 func (*CustomNameNinStruct) ProtoMessage() {}
2674 func (*CustomNameNinStruct) Descriptor() ([]byte, []int) {
2675 return fileDescriptor_519c3115fa9830d1, []int{49}
2676 }
2677 func (m *CustomNameNinStruct) XXX_Unmarshal(b []byte) error {
2678 return m.Unmarshal(b)
2679 }
2680 func (m *CustomNameNinStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2681 if deterministic {
2682 return xxx_messageInfo_CustomNameNinStruct.Marshal(b, m, deterministic)
2683 } else {
2684 b = b[:cap(b)]
2685 n, err := m.MarshalToSizedBuffer(b)
2686 if err != nil {
2687 return nil, err
2688 }
2689 return b[:n], nil
2690 }
2691 }
2692 func (m *CustomNameNinStruct) XXX_Merge(src proto.Message) {
2693 xxx_messageInfo_CustomNameNinStruct.Merge(m, src)
2694 }
2695 func (m *CustomNameNinStruct) XXX_Size() int {
2696 return m.Size()
2697 }
2698 func (m *CustomNameNinStruct) XXX_DiscardUnknown() {
2699 xxx_messageInfo_CustomNameNinStruct.DiscardUnknown(m)
2700 }
2701
2702 var xxx_messageInfo_CustomNameNinStruct proto.InternalMessageInfo
2703
2704 type CustomNameCustomType struct {
2705 FieldA *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"`
2706 FieldB *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"`
2707 FieldC []Uuid `protobuf:"bytes,3,rep,name=Ids,customtype=Uuid" json:"Ids,omitempty"`
2708 FieldD []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,4,rep,name=Values,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Values,omitempty"`
2709 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2710 XXX_unrecognized []byte `json:"-"`
2711 XXX_sizecache int32 `json:"-"`
2712 }
2713
2714 func (m *CustomNameCustomType) Reset() { *m = CustomNameCustomType{} }
2715 func (*CustomNameCustomType) ProtoMessage() {}
2716 func (*CustomNameCustomType) Descriptor() ([]byte, []int) {
2717 return fileDescriptor_519c3115fa9830d1, []int{50}
2718 }
2719 func (m *CustomNameCustomType) XXX_Unmarshal(b []byte) error {
2720 return m.Unmarshal(b)
2721 }
2722 func (m *CustomNameCustomType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2723 if deterministic {
2724 return xxx_messageInfo_CustomNameCustomType.Marshal(b, m, deterministic)
2725 } else {
2726 b = b[:cap(b)]
2727 n, err := m.MarshalToSizedBuffer(b)
2728 if err != nil {
2729 return nil, err
2730 }
2731 return b[:n], nil
2732 }
2733 }
2734 func (m *CustomNameCustomType) XXX_Merge(src proto.Message) {
2735 xxx_messageInfo_CustomNameCustomType.Merge(m, src)
2736 }
2737 func (m *CustomNameCustomType) XXX_Size() int {
2738 return m.Size()
2739 }
2740 func (m *CustomNameCustomType) XXX_DiscardUnknown() {
2741 xxx_messageInfo_CustomNameCustomType.DiscardUnknown(m)
2742 }
2743
2744 var xxx_messageInfo_CustomNameCustomType proto.InternalMessageInfo
2745
2746 type CustomNameNinEmbeddedStructUnion struct {
2747 *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"`
2748 FieldA *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"`
2749 FieldB *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"`
2750 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2751 XXX_unrecognized []byte `json:"-"`
2752 XXX_sizecache int32 `json:"-"`
2753 }
2754
2755 func (m *CustomNameNinEmbeddedStructUnion) Reset() { *m = CustomNameNinEmbeddedStructUnion{} }
2756 func (*CustomNameNinEmbeddedStructUnion) ProtoMessage() {}
2757 func (*CustomNameNinEmbeddedStructUnion) Descriptor() ([]byte, []int) {
2758 return fileDescriptor_519c3115fa9830d1, []int{51}
2759 }
2760 func (m *CustomNameNinEmbeddedStructUnion) XXX_Unmarshal(b []byte) error {
2761 return m.Unmarshal(b)
2762 }
2763 func (m *CustomNameNinEmbeddedStructUnion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2764 if deterministic {
2765 return xxx_messageInfo_CustomNameNinEmbeddedStructUnion.Marshal(b, m, deterministic)
2766 } else {
2767 b = b[:cap(b)]
2768 n, err := m.MarshalToSizedBuffer(b)
2769 if err != nil {
2770 return nil, err
2771 }
2772 return b[:n], nil
2773 }
2774 }
2775 func (m *CustomNameNinEmbeddedStructUnion) XXX_Merge(src proto.Message) {
2776 xxx_messageInfo_CustomNameNinEmbeddedStructUnion.Merge(m, src)
2777 }
2778 func (m *CustomNameNinEmbeddedStructUnion) XXX_Size() int {
2779 return m.Size()
2780 }
2781 func (m *CustomNameNinEmbeddedStructUnion) XXX_DiscardUnknown() {
2782 xxx_messageInfo_CustomNameNinEmbeddedStructUnion.DiscardUnknown(m)
2783 }
2784
2785 var xxx_messageInfo_CustomNameNinEmbeddedStructUnion proto.InternalMessageInfo
2786
2787 type CustomNameEnum struct {
2788 FieldA *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"`
2789 FieldB []TheTestEnum `protobuf:"varint,2,rep,name=Field2,enum=test.TheTestEnum" json:"Field2,omitempty"`
2790 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2791 XXX_unrecognized []byte `json:"-"`
2792 XXX_sizecache int32 `json:"-"`
2793 }
2794
2795 func (m *CustomNameEnum) Reset() { *m = CustomNameEnum{} }
2796 func (*CustomNameEnum) ProtoMessage() {}
2797 func (*CustomNameEnum) Descriptor() ([]byte, []int) {
2798 return fileDescriptor_519c3115fa9830d1, []int{52}
2799 }
2800 func (m *CustomNameEnum) XXX_Unmarshal(b []byte) error {
2801 return m.Unmarshal(b)
2802 }
2803 func (m *CustomNameEnum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2804 if deterministic {
2805 return xxx_messageInfo_CustomNameEnum.Marshal(b, m, deterministic)
2806 } else {
2807 b = b[:cap(b)]
2808 n, err := m.MarshalToSizedBuffer(b)
2809 if err != nil {
2810 return nil, err
2811 }
2812 return b[:n], nil
2813 }
2814 }
2815 func (m *CustomNameEnum) XXX_Merge(src proto.Message) {
2816 xxx_messageInfo_CustomNameEnum.Merge(m, src)
2817 }
2818 func (m *CustomNameEnum) XXX_Size() int {
2819 return m.Size()
2820 }
2821 func (m *CustomNameEnum) XXX_DiscardUnknown() {
2822 xxx_messageInfo_CustomNameEnum.DiscardUnknown(m)
2823 }
2824
2825 var xxx_messageInfo_CustomNameEnum proto.InternalMessageInfo
2826
2827 type NoExtensionsMap struct {
2828 Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"`
2829 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2830 XXX_extensions []byte `protobuf:"bytes,0,opt" json:"-"`
2831 XXX_unrecognized []byte `json:"-"`
2832 XXX_sizecache int32 `json:"-"`
2833 }
2834
2835 func (m *NoExtensionsMap) Reset() { *m = NoExtensionsMap{} }
2836 func (*NoExtensionsMap) ProtoMessage() {}
2837 func (*NoExtensionsMap) Descriptor() ([]byte, []int) {
2838 return fileDescriptor_519c3115fa9830d1, []int{53}
2839 }
2840
2841 var extRange_NoExtensionsMap = []proto.ExtensionRange{
2842 {Start: 100, End: 199},
2843 }
2844
2845 func (*NoExtensionsMap) ExtensionRangeArray() []proto.ExtensionRange {
2846 return extRange_NoExtensionsMap
2847 }
2848
2849 func (m *NoExtensionsMap) GetExtensions() *[]byte {
2850 if m.XXX_extensions == nil {
2851 m.XXX_extensions = make([]byte, 0)
2852 }
2853 return &m.XXX_extensions
2854 }
2855 func (m *NoExtensionsMap) XXX_Unmarshal(b []byte) error {
2856 return m.Unmarshal(b)
2857 }
2858 func (m *NoExtensionsMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2859 if deterministic {
2860 return xxx_messageInfo_NoExtensionsMap.Marshal(b, m, deterministic)
2861 } else {
2862 b = b[:cap(b)]
2863 n, err := m.MarshalToSizedBuffer(b)
2864 if err != nil {
2865 return nil, err
2866 }
2867 return b[:n], nil
2868 }
2869 }
2870 func (m *NoExtensionsMap) XXX_Merge(src proto.Message) {
2871 xxx_messageInfo_NoExtensionsMap.Merge(m, src)
2872 }
2873 func (m *NoExtensionsMap) XXX_Size() int {
2874 return m.Size()
2875 }
2876 func (m *NoExtensionsMap) XXX_DiscardUnknown() {
2877 xxx_messageInfo_NoExtensionsMap.DiscardUnknown(m)
2878 }
2879
2880 var xxx_messageInfo_NoExtensionsMap proto.InternalMessageInfo
2881
2882 type Unrecognized struct {
2883 Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"`
2884 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2885 XXX_sizecache int32 `json:"-"`
2886 }
2887
2888 func (m *Unrecognized) Reset() { *m = Unrecognized{} }
2889 func (*Unrecognized) ProtoMessage() {}
2890 func (*Unrecognized) Descriptor() ([]byte, []int) {
2891 return fileDescriptor_519c3115fa9830d1, []int{54}
2892 }
2893 func (m *Unrecognized) XXX_Unmarshal(b []byte) error {
2894 return m.Unmarshal(b)
2895 }
2896 func (m *Unrecognized) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2897 if deterministic {
2898 return xxx_messageInfo_Unrecognized.Marshal(b, m, deterministic)
2899 } else {
2900 b = b[:cap(b)]
2901 n, err := m.MarshalToSizedBuffer(b)
2902 if err != nil {
2903 return nil, err
2904 }
2905 return b[:n], nil
2906 }
2907 }
2908 func (m *Unrecognized) XXX_Merge(src proto.Message) {
2909 xxx_messageInfo_Unrecognized.Merge(m, src)
2910 }
2911 func (m *Unrecognized) XXX_Size() int {
2912 return m.Size()
2913 }
2914 func (m *Unrecognized) XXX_DiscardUnknown() {
2915 xxx_messageInfo_Unrecognized.DiscardUnknown(m)
2916 }
2917
2918 var xxx_messageInfo_Unrecognized proto.InternalMessageInfo
2919
2920 type UnrecognizedWithInner struct {
2921 Embedded []*UnrecognizedWithInner_Inner `protobuf:"bytes,1,rep,name=embedded" json:"embedded,omitempty"`
2922 Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"`
2923 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2924 XXX_unrecognized []byte `json:"-"`
2925 XXX_sizecache int32 `json:"-"`
2926 }
2927
2928 func (m *UnrecognizedWithInner) Reset() { *m = UnrecognizedWithInner{} }
2929 func (*UnrecognizedWithInner) ProtoMessage() {}
2930 func (*UnrecognizedWithInner) Descriptor() ([]byte, []int) {
2931 return fileDescriptor_519c3115fa9830d1, []int{55}
2932 }
2933 func (m *UnrecognizedWithInner) XXX_Unmarshal(b []byte) error {
2934 return m.Unmarshal(b)
2935 }
2936 func (m *UnrecognizedWithInner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2937 if deterministic {
2938 return xxx_messageInfo_UnrecognizedWithInner.Marshal(b, m, deterministic)
2939 } else {
2940 b = b[:cap(b)]
2941 n, err := m.MarshalToSizedBuffer(b)
2942 if err != nil {
2943 return nil, err
2944 }
2945 return b[:n], nil
2946 }
2947 }
2948 func (m *UnrecognizedWithInner) XXX_Merge(src proto.Message) {
2949 xxx_messageInfo_UnrecognizedWithInner.Merge(m, src)
2950 }
2951 func (m *UnrecognizedWithInner) XXX_Size() int {
2952 return m.Size()
2953 }
2954 func (m *UnrecognizedWithInner) XXX_DiscardUnknown() {
2955 xxx_messageInfo_UnrecognizedWithInner.DiscardUnknown(m)
2956 }
2957
2958 var xxx_messageInfo_UnrecognizedWithInner proto.InternalMessageInfo
2959
2960 type UnrecognizedWithInner_Inner struct {
2961 Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"`
2962 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2963 XXX_sizecache int32 `json:"-"`
2964 }
2965
2966 func (m *UnrecognizedWithInner_Inner) Reset() { *m = UnrecognizedWithInner_Inner{} }
2967 func (*UnrecognizedWithInner_Inner) ProtoMessage() {}
2968 func (*UnrecognizedWithInner_Inner) Descriptor() ([]byte, []int) {
2969 return fileDescriptor_519c3115fa9830d1, []int{55, 0}
2970 }
2971 func (m *UnrecognizedWithInner_Inner) XXX_Unmarshal(b []byte) error {
2972 return m.Unmarshal(b)
2973 }
2974 func (m *UnrecognizedWithInner_Inner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2975 if deterministic {
2976 return xxx_messageInfo_UnrecognizedWithInner_Inner.Marshal(b, m, deterministic)
2977 } else {
2978 b = b[:cap(b)]
2979 n, err := m.MarshalToSizedBuffer(b)
2980 if err != nil {
2981 return nil, err
2982 }
2983 return b[:n], nil
2984 }
2985 }
2986 func (m *UnrecognizedWithInner_Inner) XXX_Merge(src proto.Message) {
2987 xxx_messageInfo_UnrecognizedWithInner_Inner.Merge(m, src)
2988 }
2989 func (m *UnrecognizedWithInner_Inner) XXX_Size() int {
2990 return m.Size()
2991 }
2992 func (m *UnrecognizedWithInner_Inner) XXX_DiscardUnknown() {
2993 xxx_messageInfo_UnrecognizedWithInner_Inner.DiscardUnknown(m)
2994 }
2995
2996 var xxx_messageInfo_UnrecognizedWithInner_Inner proto.InternalMessageInfo
2997
2998 type UnrecognizedWithEmbed struct {
2999 UnrecognizedWithEmbed_Embedded `protobuf:"bytes,1,opt,name=embedded,embedded=embedded" json:"embedded"`
3000 Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"`
3001 XXX_NoUnkeyedLiteral struct{} `json:"-"`
3002 XXX_unrecognized []byte `json:"-"`
3003 XXX_sizecache int32 `json:"-"`
3004 }
3005
3006 func (m *UnrecognizedWithEmbed) Reset() { *m = UnrecognizedWithEmbed{} }
3007 func (*UnrecognizedWithEmbed) ProtoMessage() {}
3008 func (*UnrecognizedWithEmbed) Descriptor() ([]byte, []int) {
3009 return fileDescriptor_519c3115fa9830d1, []int{56}
3010 }
3011 func (m *UnrecognizedWithEmbed) XXX_Unmarshal(b []byte) error {
3012 return m.Unmarshal(b)
3013 }
3014 func (m *UnrecognizedWithEmbed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3015 if deterministic {
3016 return xxx_messageInfo_UnrecognizedWithEmbed.Marshal(b, m, deterministic)
3017 } else {
3018 b = b[:cap(b)]
3019 n, err := m.MarshalToSizedBuffer(b)
3020 if err != nil {
3021 return nil, err
3022 }
3023 return b[:n], nil
3024 }
3025 }
3026 func (m *UnrecognizedWithEmbed) XXX_Merge(src proto.Message) {
3027 xxx_messageInfo_UnrecognizedWithEmbed.Merge(m, src)
3028 }
3029 func (m *UnrecognizedWithEmbed) XXX_Size() int {
3030 return m.Size()
3031 }
3032 func (m *UnrecognizedWithEmbed) XXX_DiscardUnknown() {
3033 xxx_messageInfo_UnrecognizedWithEmbed.DiscardUnknown(m)
3034 }
3035
3036 var xxx_messageInfo_UnrecognizedWithEmbed proto.InternalMessageInfo
3037
3038 type UnrecognizedWithEmbed_Embedded struct {
3039 Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"`
3040 XXX_NoUnkeyedLiteral struct{} `json:"-"`
3041 XXX_sizecache int32 `json:"-"`
3042 }
3043
3044 func (m *UnrecognizedWithEmbed_Embedded) Reset() { *m = UnrecognizedWithEmbed_Embedded{} }
3045 func (*UnrecognizedWithEmbed_Embedded) ProtoMessage() {}
3046 func (*UnrecognizedWithEmbed_Embedded) Descriptor() ([]byte, []int) {
3047 return fileDescriptor_519c3115fa9830d1, []int{56, 0}
3048 }
3049 func (m *UnrecognizedWithEmbed_Embedded) XXX_Unmarshal(b []byte) error {
3050 return m.Unmarshal(b)
3051 }
3052 func (m *UnrecognizedWithEmbed_Embedded) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3053 if deterministic {
3054 return xxx_messageInfo_UnrecognizedWithEmbed_Embedded.Marshal(b, m, deterministic)
3055 } else {
3056 b = b[:cap(b)]
3057 n, err := m.MarshalToSizedBuffer(b)
3058 if err != nil {
3059 return nil, err
3060 }
3061 return b[:n], nil
3062 }
3063 }
3064 func (m *UnrecognizedWithEmbed_Embedded) XXX_Merge(src proto.Message) {
3065 xxx_messageInfo_UnrecognizedWithEmbed_Embedded.Merge(m, src)
3066 }
3067 func (m *UnrecognizedWithEmbed_Embedded) XXX_Size() int {
3068 return m.Size()
3069 }
3070 func (m *UnrecognizedWithEmbed_Embedded) XXX_DiscardUnknown() {
3071 xxx_messageInfo_UnrecognizedWithEmbed_Embedded.DiscardUnknown(m)
3072 }
3073
3074 var xxx_messageInfo_UnrecognizedWithEmbed_Embedded proto.InternalMessageInfo
3075
3076 type Node struct {
3077 Label *string `protobuf:"bytes,1,opt,name=Label" json:"Label,omitempty"`
3078 Children []*Node `protobuf:"bytes,2,rep,name=Children" json:"Children,omitempty"`
3079 XXX_NoUnkeyedLiteral struct{} `json:"-"`
3080 XXX_unrecognized []byte `json:"-"`
3081 XXX_sizecache int32 `json:"-"`
3082 }
3083
3084 func (m *Node) Reset() { *m = Node{} }
3085 func (*Node) ProtoMessage() {}
3086 func (*Node) Descriptor() ([]byte, []int) {
3087 return fileDescriptor_519c3115fa9830d1, []int{57}
3088 }
3089 func (m *Node) XXX_Unmarshal(b []byte) error {
3090 return m.Unmarshal(b)
3091 }
3092 func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3093 if deterministic {
3094 return xxx_messageInfo_Node.Marshal(b, m, deterministic)
3095 } else {
3096 b = b[:cap(b)]
3097 n, err := m.MarshalToSizedBuffer(b)
3098 if err != nil {
3099 return nil, err
3100 }
3101 return b[:n], nil
3102 }
3103 }
3104 func (m *Node) XXX_Merge(src proto.Message) {
3105 xxx_messageInfo_Node.Merge(m, src)
3106 }
3107 func (m *Node) XXX_Size() int {
3108 return m.Size()
3109 }
3110 func (m *Node) XXX_DiscardUnknown() {
3111 xxx_messageInfo_Node.DiscardUnknown(m)
3112 }
3113
3114 var xxx_messageInfo_Node proto.InternalMessageInfo
3115
3116 type NonByteCustomType struct {
3117 Field1 *T `protobuf:"bytes,1,opt,name=Field1,customtype=T" json:"Field1,omitempty"`
3118 XXX_NoUnkeyedLiteral struct{} `json:"-"`
3119 XXX_unrecognized []byte `json:"-"`
3120 XXX_sizecache int32 `json:"-"`
3121 }
3122
3123 func (m *NonByteCustomType) Reset() { *m = NonByteCustomType{} }
3124 func (*NonByteCustomType) ProtoMessage() {}
3125 func (*NonByteCustomType) Descriptor() ([]byte, []int) {
3126 return fileDescriptor_519c3115fa9830d1, []int{58}
3127 }
3128 func (m *NonByteCustomType) XXX_Unmarshal(b []byte) error {
3129 return m.Unmarshal(b)
3130 }
3131 func (m *NonByteCustomType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3132 if deterministic {
3133 return xxx_messageInfo_NonByteCustomType.Marshal(b, m, deterministic)
3134 } else {
3135 b = b[:cap(b)]
3136 n, err := m.MarshalToSizedBuffer(b)
3137 if err != nil {
3138 return nil, err
3139 }
3140 return b[:n], nil
3141 }
3142 }
3143 func (m *NonByteCustomType) XXX_Merge(src proto.Message) {
3144 xxx_messageInfo_NonByteCustomType.Merge(m, src)
3145 }
3146 func (m *NonByteCustomType) XXX_Size() int {
3147 return m.Size()
3148 }
3149 func (m *NonByteCustomType) XXX_DiscardUnknown() {
3150 xxx_messageInfo_NonByteCustomType.DiscardUnknown(m)
3151 }
3152
3153 var xxx_messageInfo_NonByteCustomType proto.InternalMessageInfo
3154
3155 type NidOptNonByteCustomType struct {
3156 Field1 T `protobuf:"bytes,1,opt,name=Field1,customtype=T" json:"Field1"`
3157 XXX_NoUnkeyedLiteral struct{} `json:"-"`
3158 XXX_unrecognized []byte `json:"-"`
3159 XXX_sizecache int32 `json:"-"`
3160 }
3161
3162 func (m *NidOptNonByteCustomType) Reset() { *m = NidOptNonByteCustomType{} }
3163 func (*NidOptNonByteCustomType) ProtoMessage() {}
3164 func (*NidOptNonByteCustomType) Descriptor() ([]byte, []int) {
3165 return fileDescriptor_519c3115fa9830d1, []int{59}
3166 }
3167 func (m *NidOptNonByteCustomType) XXX_Unmarshal(b []byte) error {
3168 return m.Unmarshal(b)
3169 }
3170 func (m *NidOptNonByteCustomType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3171 if deterministic {
3172 return xxx_messageInfo_NidOptNonByteCustomType.Marshal(b, m, deterministic)
3173 } else {
3174 b = b[:cap(b)]
3175 n, err := m.MarshalToSizedBuffer(b)
3176 if err != nil {
3177 return nil, err
3178 }
3179 return b[:n], nil
3180 }
3181 }
3182 func (m *NidOptNonByteCustomType) XXX_Merge(src proto.Message) {
3183 xxx_messageInfo_NidOptNonByteCustomType.Merge(m, src)
3184 }
3185 func (m *NidOptNonByteCustomType) XXX_Size() int {
3186 return m.Size()
3187 }
3188 func (m *NidOptNonByteCustomType) XXX_DiscardUnknown() {
3189 xxx_messageInfo_NidOptNonByteCustomType.DiscardUnknown(m)
3190 }
3191
3192 var xxx_messageInfo_NidOptNonByteCustomType proto.InternalMessageInfo
3193
3194 type NinOptNonByteCustomType struct {
3195 Field1 *T `protobuf:"bytes,1,opt,name=Field1,customtype=T" json:"Field1,omitempty"`
3196 XXX_NoUnkeyedLiteral struct{} `json:"-"`
3197 XXX_unrecognized []byte `json:"-"`
3198 XXX_sizecache int32 `json:"-"`
3199 }
3200
3201 func (m *NinOptNonByteCustomType) Reset() { *m = NinOptNonByteCustomType{} }
3202 func (*NinOptNonByteCustomType) ProtoMessage() {}
3203 func (*NinOptNonByteCustomType) Descriptor() ([]byte, []int) {
3204 return fileDescriptor_519c3115fa9830d1, []int{60}
3205 }
3206 func (m *NinOptNonByteCustomType) XXX_Unmarshal(b []byte) error {
3207 return m.Unmarshal(b)
3208 }
3209 func (m *NinOptNonByteCustomType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3210 if deterministic {
3211 return xxx_messageInfo_NinOptNonByteCustomType.Marshal(b, m, deterministic)
3212 } else {
3213 b = b[:cap(b)]
3214 n, err := m.MarshalToSizedBuffer(b)
3215 if err != nil {
3216 return nil, err
3217 }
3218 return b[:n], nil
3219 }
3220 }
3221 func (m *NinOptNonByteCustomType) XXX_Merge(src proto.Message) {
3222 xxx_messageInfo_NinOptNonByteCustomType.Merge(m, src)
3223 }
3224 func (m *NinOptNonByteCustomType) XXX_Size() int {
3225 return m.Size()
3226 }
3227 func (m *NinOptNonByteCustomType) XXX_DiscardUnknown() {
3228 xxx_messageInfo_NinOptNonByteCustomType.DiscardUnknown(m)
3229 }
3230
3231 var xxx_messageInfo_NinOptNonByteCustomType proto.InternalMessageInfo
3232
3233 type NidRepNonByteCustomType struct {
3234 Field1 []T `protobuf:"bytes,1,rep,name=Field1,customtype=T" json:"Field1"`
3235 XXX_NoUnkeyedLiteral struct{} `json:"-"`
3236 XXX_unrecognized []byte `json:"-"`
3237 XXX_sizecache int32 `json:"-"`
3238 }
3239
3240 func (m *NidRepNonByteCustomType) Reset() { *m = NidRepNonByteCustomType{} }
3241 func (*NidRepNonByteCustomType) ProtoMessage() {}
3242 func (*NidRepNonByteCustomType) Descriptor() ([]byte, []int) {
3243 return fileDescriptor_519c3115fa9830d1, []int{61}
3244 }
3245 func (m *NidRepNonByteCustomType) XXX_Unmarshal(b []byte) error {
3246 return m.Unmarshal(b)
3247 }
3248 func (m *NidRepNonByteCustomType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3249 if deterministic {
3250 return xxx_messageInfo_NidRepNonByteCustomType.Marshal(b, m, deterministic)
3251 } else {
3252 b = b[:cap(b)]
3253 n, err := m.MarshalToSizedBuffer(b)
3254 if err != nil {
3255 return nil, err
3256 }
3257 return b[:n], nil
3258 }
3259 }
3260 func (m *NidRepNonByteCustomType) XXX_Merge(src proto.Message) {
3261 xxx_messageInfo_NidRepNonByteCustomType.Merge(m, src)
3262 }
3263 func (m *NidRepNonByteCustomType) XXX_Size() int {
3264 return m.Size()
3265 }
3266 func (m *NidRepNonByteCustomType) XXX_DiscardUnknown() {
3267 xxx_messageInfo_NidRepNonByteCustomType.DiscardUnknown(m)
3268 }
3269
3270 var xxx_messageInfo_NidRepNonByteCustomType proto.InternalMessageInfo
3271
3272 type NinRepNonByteCustomType struct {
3273 Field1 []T `protobuf:"bytes,1,rep,name=Field1,customtype=T" json:"Field1,omitempty"`
3274 XXX_NoUnkeyedLiteral struct{} `json:"-"`
3275 XXX_unrecognized []byte `json:"-"`
3276 XXX_sizecache int32 `json:"-"`
3277 }
3278
3279 func (m *NinRepNonByteCustomType) Reset() { *m = NinRepNonByteCustomType{} }
3280 func (*NinRepNonByteCustomType) ProtoMessage() {}
3281 func (*NinRepNonByteCustomType) Descriptor() ([]byte, []int) {
3282 return fileDescriptor_519c3115fa9830d1, []int{62}
3283 }
3284 func (m *NinRepNonByteCustomType) XXX_Unmarshal(b []byte) error {
3285 return m.Unmarshal(b)
3286 }
3287 func (m *NinRepNonByteCustomType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3288 if deterministic {
3289 return xxx_messageInfo_NinRepNonByteCustomType.Marshal(b, m, deterministic)
3290 } else {
3291 b = b[:cap(b)]
3292 n, err := m.MarshalToSizedBuffer(b)
3293 if err != nil {
3294 return nil, err
3295 }
3296 return b[:n], nil
3297 }
3298 }
3299 func (m *NinRepNonByteCustomType) XXX_Merge(src proto.Message) {
3300 xxx_messageInfo_NinRepNonByteCustomType.Merge(m, src)
3301 }
3302 func (m *NinRepNonByteCustomType) XXX_Size() int {
3303 return m.Size()
3304 }
3305 func (m *NinRepNonByteCustomType) XXX_DiscardUnknown() {
3306 xxx_messageInfo_NinRepNonByteCustomType.DiscardUnknown(m)
3307 }
3308
3309 var xxx_messageInfo_NinRepNonByteCustomType proto.InternalMessageInfo
3310
3311 type ProtoType struct {
3312 Field2 *string `protobuf:"bytes,1,opt,name=Field2" json:"Field2,omitempty"`
3313 XXX_NoUnkeyedLiteral struct{} `json:"-"`
3314 XXX_unrecognized []byte `json:"-"`
3315 XXX_sizecache int32 `json:"-"`
3316 }
3317
3318 func (m *ProtoType) Reset() { *m = ProtoType{} }
3319 func (*ProtoType) ProtoMessage() {}
3320 func (*ProtoType) Descriptor() ([]byte, []int) {
3321 return fileDescriptor_519c3115fa9830d1, []int{63}
3322 }
3323 func (m *ProtoType) XXX_Unmarshal(b []byte) error {
3324 return m.Unmarshal(b)
3325 }
3326 func (m *ProtoType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
3327 if deterministic {
3328 return xxx_messageInfo_ProtoType.Marshal(b, m, deterministic)
3329 } else {
3330 b = b[:cap(b)]
3331 n, err := m.MarshalToSizedBuffer(b)
3332 if err != nil {
3333 return nil, err
3334 }
3335 return b[:n], nil
3336 }
3337 }
3338 func (m *ProtoType) XXX_Merge(src proto.Message) {
3339 xxx_messageInfo_ProtoType.Merge(m, src)
3340 }
3341 func (m *ProtoType) XXX_Size() int {
3342 return m.Size()
3343 }
3344 func (m *ProtoType) XXX_DiscardUnknown() {
3345 xxx_messageInfo_ProtoType.DiscardUnknown(m)
3346 }
3347
3348 var xxx_messageInfo_ProtoType proto.InternalMessageInfo
3349
3350 var E_FieldA = &proto.ExtensionDesc{
3351 ExtendedType: (*MyExtendable)(nil),
3352 ExtensionType: (*float64)(nil),
3353 Field: 100,
3354 Name: "test.FieldA",
3355 Tag: "fixed64,100,opt,name=FieldA",
3356 Filename: "combos/both/thetest.proto",
3357 }
3358
3359 var E_FieldB = &proto.ExtensionDesc{
3360 ExtendedType: (*MyExtendable)(nil),
3361 ExtensionType: (*NinOptNative)(nil),
3362 Field: 101,
3363 Name: "test.FieldB",
3364 Tag: "bytes,101,opt,name=FieldB",
3365 Filename: "combos/both/thetest.proto",
3366 }
3367
3368 var E_FieldC = &proto.ExtensionDesc{
3369 ExtendedType: (*MyExtendable)(nil),
3370 ExtensionType: (*NinEmbeddedStruct)(nil),
3371 Field: 102,
3372 Name: "test.FieldC",
3373 Tag: "bytes,102,opt,name=FieldC",
3374 Filename: "combos/both/thetest.proto",
3375 }
3376
3377 var E_FieldD = &proto.ExtensionDesc{
3378 ExtendedType: (*MyExtendable)(nil),
3379 ExtensionType: ([]int64)(nil),
3380 Field: 104,
3381 Name: "test.FieldD",
3382 Tag: "varint,104,rep,name=FieldD",
3383 Filename: "combos/both/thetest.proto",
3384 }
3385
3386 var E_FieldE = &proto.ExtensionDesc{
3387 ExtendedType: (*MyExtendable)(nil),
3388 ExtensionType: ([]*NinOptNative)(nil),
3389 Field: 105,
3390 Name: "test.FieldE",
3391 Tag: "bytes,105,rep,name=FieldE",
3392 Filename: "combos/both/thetest.proto",
3393 }
3394
3395 var E_FieldA1 = &proto.ExtensionDesc{
3396 ExtendedType: (*NoExtensionsMap)(nil),
3397 ExtensionType: (*float64)(nil),
3398 Field: 100,
3399 Name: "test.FieldA1",
3400 Tag: "fixed64,100,opt,name=FieldA1",
3401 Filename: "combos/both/thetest.proto",
3402 }
3403
3404 var E_FieldB1 = &proto.ExtensionDesc{
3405 ExtendedType: (*NoExtensionsMap)(nil),
3406 ExtensionType: (*NinOptNative)(nil),
3407 Field: 101,
3408 Name: "test.FieldB1",
3409 Tag: "bytes,101,opt,name=FieldB1",
3410 Filename: "combos/both/thetest.proto",
3411 }
3412
3413 var E_FieldC1 = &proto.ExtensionDesc{
3414 ExtendedType: (*NoExtensionsMap)(nil),
3415 ExtensionType: (*NinEmbeddedStruct)(nil),
3416 Field: 102,
3417 Name: "test.FieldC1",
3418 Tag: "bytes,102,opt,name=FieldC1",
3419 Filename: "combos/both/thetest.proto",
3420 }
3421
3422 func init() {
3423 proto.RegisterEnum("test.TheTestEnum", TheTestEnum_name, TheTestEnum_value)
3424 proto.RegisterEnum("test.AnotherTestEnum", AnotherTestEnum_name, AnotherTestEnum_value)
3425 proto.RegisterEnum("test.YetAnotherTestEnum", YetAnotherTestEnum_name, YetAnotherTestEnum_value)
3426 proto.RegisterEnum("test.YetYetAnotherTestEnum", YetYetAnotherTestEnum_name, YetYetAnotherTestEnum_value)
3427 proto.RegisterEnum("test.NestedDefinition_NestedEnum", NestedDefinition_NestedEnum_name, NestedDefinition_NestedEnum_value)
3428 proto.RegisterType((*NidOptNative)(nil), "test.NidOptNative")
3429 proto.RegisterType((*NinOptNative)(nil), "test.NinOptNative")
3430 proto.RegisterType((*NidRepNative)(nil), "test.NidRepNative")
3431 proto.RegisterType((*NinRepNative)(nil), "test.NinRepNative")
3432 proto.RegisterType((*NidRepPackedNative)(nil), "test.NidRepPackedNative")
3433 proto.RegisterType((*NinRepPackedNative)(nil), "test.NinRepPackedNative")
3434 proto.RegisterType((*NidOptStruct)(nil), "test.NidOptStruct")
3435 proto.RegisterType((*NinOptStruct)(nil), "test.NinOptStruct")
3436 proto.RegisterType((*NidRepStruct)(nil), "test.NidRepStruct")
3437 proto.RegisterType((*NinRepStruct)(nil), "test.NinRepStruct")
3438 proto.RegisterType((*NidEmbeddedStruct)(nil), "test.NidEmbeddedStruct")
3439 proto.RegisterType((*NinEmbeddedStruct)(nil), "test.NinEmbeddedStruct")
3440 proto.RegisterType((*NidNestedStruct)(nil), "test.NidNestedStruct")
3441 proto.RegisterType((*NinNestedStruct)(nil), "test.NinNestedStruct")
3442 proto.RegisterType((*NidOptCustom)(nil), "test.NidOptCustom")
3443 proto.RegisterType((*CustomDash)(nil), "test.CustomDash")
3444 proto.RegisterType((*NinOptCustom)(nil), "test.NinOptCustom")
3445 proto.RegisterType((*NidRepCustom)(nil), "test.NidRepCustom")
3446 proto.RegisterType((*NinRepCustom)(nil), "test.NinRepCustom")
3447 proto.RegisterType((*NinOptNativeUnion)(nil), "test.NinOptNativeUnion")
3448 proto.RegisterType((*NinOptStructUnion)(nil), "test.NinOptStructUnion")
3449 proto.RegisterType((*NinEmbeddedStructUnion)(nil), "test.NinEmbeddedStructUnion")
3450 proto.RegisterType((*NinNestedStructUnion)(nil), "test.NinNestedStructUnion")
3451 proto.RegisterType((*Tree)(nil), "test.Tree")
3452 proto.RegisterType((*OrBranch)(nil), "test.OrBranch")
3453 proto.RegisterType((*AndBranch)(nil), "test.AndBranch")
3454 proto.RegisterType((*Leaf)(nil), "test.Leaf")
3455 proto.RegisterType((*DeepTree)(nil), "test.DeepTree")
3456 proto.RegisterType((*ADeepBranch)(nil), "test.ADeepBranch")
3457 proto.RegisterType((*AndDeepBranch)(nil), "test.AndDeepBranch")
3458 proto.RegisterType((*DeepLeaf)(nil), "test.DeepLeaf")
3459 proto.RegisterType((*Nil)(nil), "test.Nil")
3460 proto.RegisterType((*NidOptEnum)(nil), "test.NidOptEnum")
3461 proto.RegisterType((*NinOptEnum)(nil), "test.NinOptEnum")
3462 proto.RegisterType((*NidRepEnum)(nil), "test.NidRepEnum")
3463 proto.RegisterType((*NinRepEnum)(nil), "test.NinRepEnum")
3464 proto.RegisterType((*NinOptEnumDefault)(nil), "test.NinOptEnumDefault")
3465 proto.RegisterType((*AnotherNinOptEnum)(nil), "test.AnotherNinOptEnum")
3466 proto.RegisterType((*AnotherNinOptEnumDefault)(nil), "test.AnotherNinOptEnumDefault")
3467 proto.RegisterType((*Timer)(nil), "test.Timer")
3468 proto.RegisterType((*MyExtendable)(nil), "test.MyExtendable")
3469 proto.RegisterType((*OtherExtenable)(nil), "test.OtherExtenable")
3470 proto.RegisterType((*NestedDefinition)(nil), "test.NestedDefinition")
3471 proto.RegisterType((*NestedDefinition_NestedMessage)(nil), "test.NestedDefinition.NestedMessage")
3472 proto.RegisterType((*NestedDefinition_NestedMessage_NestedNestedMsg)(nil), "test.NestedDefinition.NestedMessage.NestedNestedMsg")
3473 proto.RegisterType((*NestedScope)(nil), "test.NestedScope")
3474 proto.RegisterType((*NinOptNativeDefault)(nil), "test.NinOptNativeDefault")
3475 proto.RegisterType((*CustomContainer)(nil), "test.CustomContainer")
3476 proto.RegisterType((*CustomNameNidOptNative)(nil), "test.CustomNameNidOptNative")
3477 proto.RegisterType((*CustomNameNinOptNative)(nil), "test.CustomNameNinOptNative")
3478 proto.RegisterType((*CustomNameNinRepNative)(nil), "test.CustomNameNinRepNative")
3479 proto.RegisterType((*CustomNameNinStruct)(nil), "test.CustomNameNinStruct")
3480 proto.RegisterType((*CustomNameCustomType)(nil), "test.CustomNameCustomType")
3481 proto.RegisterType((*CustomNameNinEmbeddedStructUnion)(nil), "test.CustomNameNinEmbeddedStructUnion")
3482 proto.RegisterType((*CustomNameEnum)(nil), "test.CustomNameEnum")
3483 proto.RegisterType((*NoExtensionsMap)(nil), "test.NoExtensionsMap")
3484 proto.RegisterType((*Unrecognized)(nil), "test.Unrecognized")
3485 proto.RegisterType((*UnrecognizedWithInner)(nil), "test.UnrecognizedWithInner")
3486 proto.RegisterType((*UnrecognizedWithInner_Inner)(nil), "test.UnrecognizedWithInner.Inner")
3487 proto.RegisterType((*UnrecognizedWithEmbed)(nil), "test.UnrecognizedWithEmbed")
3488 proto.RegisterType((*UnrecognizedWithEmbed_Embedded)(nil), "test.UnrecognizedWithEmbed.Embedded")
3489 proto.RegisterType((*Node)(nil), "test.Node")
3490 proto.RegisterType((*NonByteCustomType)(nil), "test.NonByteCustomType")
3491 proto.RegisterType((*NidOptNonByteCustomType)(nil), "test.NidOptNonByteCustomType")
3492 proto.RegisterType((*NinOptNonByteCustomType)(nil), "test.NinOptNonByteCustomType")
3493 proto.RegisterType((*NidRepNonByteCustomType)(nil), "test.NidRepNonByteCustomType")
3494 proto.RegisterType((*NinRepNonByteCustomType)(nil), "test.NinRepNonByteCustomType")
3495 proto.RegisterType((*ProtoType)(nil), "test.ProtoType")
3496 proto.RegisterExtension(E_FieldA)
3497 proto.RegisterExtension(E_FieldB)
3498 proto.RegisterExtension(E_FieldC)
3499 proto.RegisterExtension(E_FieldD)
3500 proto.RegisterExtension(E_FieldE)
3501 proto.RegisterExtension(E_FieldA1)
3502 proto.RegisterExtension(E_FieldB1)
3503 proto.RegisterExtension(E_FieldC1)
3504 }
3505
3506 func init() { proto.RegisterFile("combos/both/thetest.proto", fileDescriptor_519c3115fa9830d1) }
3507
3508 var fileDescriptor_519c3115fa9830d1 = []byte{
3509
3510 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0x4d, 0x6c, 0x1b, 0xc7,
3511 0x15, 0xd6, 0xec, 0x50, 0x0a, 0xf5, 0x24, 0x4b, 0xf4, 0x26, 0x56, 0xb6, 0x8c, 0xba, 0xa2, 0x37,
3512 0xb2, 0xca, 0x10, 0xb1, 0x44, 0x51, 0x94, 0x2c, 0x33, 0x4d, 0x0a, 0xf1, 0xc7, 0x8d, 0xdc, 0x88,
3513 0x32, 0x18, 0xb9, 0xad, 0x81, 0x02, 0x05, 0x25, 0xae, 0x45, 0xa2, 0xd2, 0x52, 0x20, 0x57, 0x69,
3514 0xdc, 0x43, 0x11, 0xe4, 0x50, 0x04, 0xbd, 0x16, 0x3d, 0xb6, 0x71, 0x51, 0x14, 0x48, 0x6f, 0x39,
3515 0x14, 0x45, 0x51, 0x14, 0x8d, 0x2f, 0x05, 0xd4, 0x9b, 0xd1, 0x53, 0x11, 0x14, 0x42, 0xc4, 0x5c,
3516 0x72, 0x0c, 0x7a, 0x69, 0x0e, 0x39, 0x14, 0xbb, 0x3b, 0x3b, 0x3b, 0x33, 0xdc, 0xe5, 0x2e, 0x2d,
3517 0xb9, 0xcd, 0xc5, 0x16, 0xe7, 0xbd, 0x37, 0xf3, 0xf6, 0x7d, 0xdf, 0x7b, 0xfb, 0x76, 0x66, 0xe0,
3518 0x6b, 0x7b, 0xed, 0xc3, 0xdd, 0x76, 0x77, 0x69, 0xb7, 0x6d, 0x36, 0x97, 0xcc, 0xa6, 0x6e, 0xea,
3519 0x5d, 0x73, 0xf1, 0xa8, 0xd3, 0x36, 0xdb, 0x72, 0xcc, 0xfa, 0x3b, 0x79, 0x7d, 0xbf, 0x65, 0x36,
3520 0x8f, 0x77, 0x17, 0xf7, 0xda, 0x87, 0x4b, 0xfb, 0xed, 0xfd, 0xf6, 0x92, 0x2d, 0xdc, 0x3d, 0xbe,
3521 0x6f, 0xff, 0xb2, 0x7f, 0xd8, 0x7f, 0x39, 0x46, 0xda, 0xbf, 0x30, 0x4c, 0x56, 0x5b, 0x8d, 0xed,
3522 0x23, 0xb3, 0x5a, 0x37, 0x5b, 0x6f, 0xe9, 0xf2, 0x2c, 0x8c, 0xdd, 0x6a, 0xe9, 0x07, 0x8d, 0x65,
3523 0x05, 0xa5, 0x50, 0x1a, 0x15, 0x63, 0x27, 0xa7, 0x73, 0x23, 0x35, 0x32, 0x46, 0xa5, 0x39, 0x45,
3524 0x4a, 0xa1, 0xb4, 0xc4, 0x49, 0x73, 0x54, 0xba, 0xa2, 0xe0, 0x14, 0x4a, 0x8f, 0x72, 0xd2, 0x15,
3525 0x2a, 0xcd, 0x2b, 0xb1, 0x14, 0x4a, 0x63, 0x4e, 0x9a, 0xa7, 0xd2, 0x55, 0x65, 0x34, 0x85, 0xd2,
3526 0x97, 0x38, 0xe9, 0x2a, 0x95, 0xae, 0x29, 0x63, 0x29, 0x94, 0x8e, 0x71, 0xd2, 0x35, 0x2a, 0xbd,
3527 0xa1, 0x3c, 0x93, 0x42, 0xe9, 0xcb, 0x9c, 0xf4, 0x06, 0x95, 0xae, 0x2b, 0xf1, 0x14, 0x4a, 0xcb,
3528 0x9c, 0x74, 0x9d, 0x4a, 0x6f, 0x2a, 0xe3, 0x29, 0x94, 0x7e, 0x86, 0x93, 0xde, 0x94, 0x55, 0x78,
3529 0xc6, 0x79, 0xf2, 0xac, 0x02, 0x29, 0x94, 0x9e, 0x26, 0x62, 0x77, 0xd0, 0x93, 0x2f, 0x2b, 0x13,
3530 0x29, 0x94, 0x1e, 0xe3, 0xe5, 0xcb, 0x9e, 0x3c, 0xa7, 0x4c, 0xa6, 0x50, 0x3a, 0xc1, 0xcb, 0x73,
3531 0x9e, 0x7c, 0x45, 0xb9, 0x94, 0x42, 0xe9, 0x38, 0x2f, 0x5f, 0xf1, 0xe4, 0x79, 0x65, 0x2a, 0x85,
3532 0xd2, 0xe3, 0xbc, 0x3c, 0xef, 0xc9, 0x57, 0x95, 0xe9, 0x14, 0x4a, 0x4f, 0xf2, 0xf2, 0x55, 0xed,
3533 0x5d, 0x1b, 0x5e, 0xc3, 0x83, 0x77, 0x86, 0x87, 0x97, 0x02, 0x3b, 0xc3, 0x03, 0x4b, 0x21, 0x9d,
3534 0xe1, 0x21, 0xa5, 0x60, 0xce, 0xf0, 0x60, 0x52, 0x18, 0x67, 0x78, 0x18, 0x29, 0x80, 0x33, 0x3c,
3535 0x80, 0x14, 0xba, 0x19, 0x1e, 0x3a, 0x0a, 0xda, 0x0c, 0x0f, 0x1a, 0x85, 0x6b, 0x86, 0x87, 0x8b,
3536 0x02, 0xa5, 0x08, 0x40, 0x79, 0x10, 0x29, 0x02, 0x44, 0x1e, 0x38, 0x8a, 0x00, 0x8e, 0x07, 0x8b,
3537 0x22, 0xc0, 0xe2, 0x01, 0xa2, 0x08, 0x80, 0x78, 0x50, 0x28, 0x02, 0x14, 0x1e, 0x08, 0x24, 0xc7,
3538 0x6a, 0xfa, 0x91, 0x4f, 0x8e, 0xe1, 0x81, 0x39, 0x86, 0x07, 0xe6, 0x18, 0x1e, 0x98, 0x63, 0x78,
3539 0x60, 0x8e, 0xe1, 0x81, 0x39, 0x86, 0x07, 0xe6, 0x18, 0x1e, 0x98, 0x63, 0x78, 0x60, 0x8e, 0xe1,
3540 0xc1, 0x39, 0x86, 0x43, 0x72, 0x0c, 0x87, 0xe4, 0x18, 0x0e, 0xc9, 0x31, 0x1c, 0x92, 0x63, 0x38,
3541 0x24, 0xc7, 0x70, 0x60, 0x8e, 0x79, 0xf0, 0xce, 0xf0, 0xf0, 0xfa, 0xe6, 0x18, 0x0e, 0xc8, 0x31,
3542 0x1c, 0x90, 0x63, 0x38, 0x20, 0xc7, 0x70, 0x40, 0x8e, 0xe1, 0x80, 0x1c, 0xc3, 0x01, 0x39, 0x86,
3543 0x03, 0x72, 0x0c, 0x07, 0xe5, 0x18, 0x0e, 0xcc, 0x31, 0x1c, 0x98, 0x63, 0x38, 0x30, 0xc7, 0x70,
3544 0x60, 0x8e, 0xe1, 0xc0, 0x1c, 0xc3, 0x6c, 0x8e, 0xfd, 0x05, 0x83, 0xec, 0xe4, 0xd8, 0x9d, 0xfa,
3545 0xde, 0x8f, 0xf4, 0x06, 0x81, 0x42, 0x15, 0x32, 0x6d, 0xcc, 0x82, 0x2e, 0xe1, 0x41, 0xa2, 0x0a,
3546 0xb9, 0xc6, 0xcb, 0x73, 0x54, 0xee, 0x66, 0x1b, 0x2f, 0x5f, 0xa1, 0x72, 0x37, 0xdf, 0x78, 0x79,
3547 0x9e, 0xca, 0xdd, 0x8c, 0xe3, 0xe5, 0xab, 0x54, 0xee, 0xe6, 0x1c, 0x2f, 0x5f, 0xa3, 0x72, 0x37,
3548 0xeb, 0x78, 0xf9, 0x0d, 0x2a, 0x77, 0xf3, 0x8e, 0x97, 0xaf, 0x53, 0xb9, 0x9b, 0x79, 0xbc, 0xfc,
3549 0xa6, 0x9c, 0x12, 0x73, 0xcf, 0x55, 0xa0, 0xd0, 0xa6, 0xc4, 0xec, 0x13, 0x34, 0x96, 0x3d, 0x0d,
3550 0x37, 0xff, 0x04, 0x8d, 0x9c, 0xa7, 0xe1, 0x66, 0xa0, 0xa0, 0xb1, 0xa2, 0xbd, 0x67, 0xc3, 0x67,
3551 0x88, 0xf0, 0x25, 0x05, 0xf8, 0x24, 0x06, 0xba, 0xa4, 0x00, 0x9d, 0xc4, 0xc0, 0x96, 0x14, 0x60,
3552 0x93, 0x18, 0xc8, 0x92, 0x02, 0x64, 0x12, 0x03, 0x57, 0x52, 0x80, 0x4b, 0x62, 0xa0, 0x4a, 0x0a,
3553 0x50, 0x49, 0x0c, 0x4c, 0x49, 0x01, 0x26, 0x89, 0x81, 0x28, 0x29, 0x40, 0x24, 0x31, 0xf0, 0x24,
3554 0x05, 0x78, 0x24, 0x06, 0x9a, 0x59, 0x11, 0x1a, 0x89, 0x85, 0x65, 0x56, 0x84, 0x45, 0x62, 0x21,
3555 0x99, 0x15, 0x21, 0x91, 0x58, 0x38, 0x66, 0x45, 0x38, 0x24, 0x16, 0x8a, 0x2f, 0x25, 0xb7, 0x23,
3556 0x7c, 0xd3, 0xec, 0x1c, 0xef, 0x99, 0xe7, 0xea, 0x08, 0xb3, 0x5c, 0xfb, 0x30, 0x91, 0x93, 0x17,
3557 0xed, 0x86, 0x95, 0xed, 0x38, 0x85, 0x37, 0x58, 0x96, 0x6b, 0x2c, 0x18, 0x0b, 0xc3, 0xdf, 0x22,
3558 0x7f, 0xae, 0xde, 0x30, 0xcb, 0xb5, 0x19, 0xe1, 0xfe, 0xad, 0x3f, 0xf5, 0x8e, 0xed, 0x91, 0xe4,
3559 0x76, 0x6c, 0x24, 0xfc, 0xc3, 0x76, 0x6c, 0x99, 0xf0, 0x90, 0xd3, 0x60, 0x67, 0xc2, 0x83, 0xdd,
3560 0xf7, 0xd6, 0x89, 0xda, 0xc1, 0x65, 0xc2, 0x43, 0x4b, 0x83, 0x7a, 0xb1, 0xfd, 0x16, 0x61, 0x70,
3561 0x4d, 0x3f, 0xf2, 0x61, 0xf0, 0xb0, 0xfd, 0x56, 0x96, 0x2b, 0x25, 0xc3, 0x32, 0x18, 0x0f, 0xcd,
3562 0xe0, 0x61, 0x3b, 0xaf, 0x2c, 0x57, 0x5e, 0x86, 0x66, 0xf0, 0x53, 0xe8, 0x87, 0x08, 0x83, 0xbd,
3563 0xf0, 0x0f, 0xdb, 0x0f, 0x65, 0xc2, 0x43, 0xee, 0xcb, 0x60, 0x3c, 0x04, 0x83, 0xa3, 0xf4, 0x47,
3564 0x99, 0xf0, 0xd0, 0xfa, 0x33, 0xf8, 0xdc, 0xdd, 0xcc, 0xfb, 0x08, 0x2e, 0x57, 0x5b, 0x8d, 0xca,
3565 0xe1, 0xae, 0xde, 0x68, 0xe8, 0x0d, 0x12, 0xc7, 0x2c, 0x57, 0x09, 0x02, 0xa0, 0x7e, 0x7c, 0x3a,
3566 0xe7, 0x45, 0x78, 0x15, 0xe2, 0x4e, 0x4c, 0xb3, 0x59, 0xe5, 0x04, 0x85, 0x54, 0x38, 0xaa, 0x2a,
3567 0x5f, 0x75, 0xcd, 0x96, 0xb3, 0xca, 0x3f, 0x10, 0x53, 0xe5, 0xe8, 0xb0, 0xf6, 0x0b, 0xdb, 0x43,
3568 0xe3, 0xdc, 0x1e, 0x2e, 0x45, 0xf2, 0x90, 0xf1, 0xed, 0x85, 0x3e, 0xdf, 0x18, 0xaf, 0x8e, 0x61,
3569 0xba, 0xda, 0x6a, 0x54, 0xf5, 0xae, 0x19, 0xcd, 0x25, 0x47, 0x47, 0xa8, 0x07, 0x59, 0x8e, 0x96,
3570 0xac, 0x05, 0xa5, 0x34, 0x5f, 0x23, 0xb4, 0x96, 0xb5, 0xac, 0xc1, 0x2d, 0x9b, 0x09, 0x5a, 0xd6,
3571 0xab, 0xec, 0x74, 0xc1, 0x4c, 0xd0, 0x82, 0x5e, 0x0e, 0xd1, 0xa5, 0xde, 0x76, 0x5f, 0xce, 0xa5,
3572 0xe3, 0xae, 0xd9, 0x3e, 0x94, 0x67, 0x41, 0xda, 0x6c, 0xd8, 0x6b, 0x4c, 0x16, 0x27, 0x2d, 0xa7,
3573 0x3e, 0x3e, 0x9d, 0x8b, 0xdd, 0x3d, 0x6e, 0x35, 0x6a, 0xd2, 0x66, 0x43, 0xbe, 0x0d, 0xa3, 0xdf,
3574 0xad, 0x1f, 0x1c, 0xeb, 0xf6, 0x2b, 0x62, 0xb2, 0x98, 0x27, 0x0a, 0x2f, 0x07, 0xee, 0x11, 0x59,
3575 0x0b, 0x2f, 0xed, 0xd9, 0x53, 0x2f, 0xde, 0x6d, 0x19, 0xe6, 0x72, 0x6e, 0xbd, 0xe6, 0x4c, 0xa1,
3576 0xfd, 0x00, 0xc0, 0x59, 0xb3, 0x5c, 0xef, 0x36, 0xe5, 0xaa, 0x3b, 0xb3, 0xb3, 0xf4, 0xfa, 0xc7,
3577 0xa7, 0x73, 0xf9, 0x28, 0xb3, 0x5e, 0x6f, 0xd4, 0xbb, 0xcd, 0xeb, 0xe6, 0x83, 0x23, 0x7d, 0xb1,
3578 0xf8, 0xc0, 0xd4, 0xbb, 0xee, 0xec, 0x47, 0xee, 0x5b, 0x8f, 0x3c, 0x97, 0xc2, 0x3c, 0x57, 0x9c,
3579 0x7b, 0xa6, 0x5b, 0xfc, 0x33, 0x65, 0x9f, 0xf4, 0x79, 0xde, 0x76, 0x5f, 0x12, 0x42, 0x24, 0x71,
3580 0x58, 0x24, 0xf1, 0x79, 0x23, 0x79, 0xe4, 0xd6, 0x47, 0xe1, 0x59, 0xf1, 0xa0, 0x67, 0xc5, 0xe7,
3581 0x79, 0xd6, 0xff, 0x38, 0xd9, 0x4a, 0xf3, 0xe9, 0xae, 0xd1, 0x6a, 0x1b, 0x5f, 0xb9, 0xbd, 0xa0,
3582 0x0b, 0xed, 0x02, 0x0a, 0xb1, 0x93, 0x87, 0x73, 0x48, 0x7b, 0x5f, 0x72, 0x9f, 0xdc, 0x49, 0xa4,
3583 0x27, 0x7b, 0xf2, 0xaf, 0x4a, 0x4f, 0xf5, 0x34, 0x22, 0xf4, 0x6b, 0x04, 0x33, 0x7d, 0x95, 0xdc,
3584 0x09, 0xd3, 0xc5, 0x96, 0x73, 0x63, 0xd8, 0x72, 0x4e, 0x1c, 0xfc, 0x03, 0x82, 0xe7, 0x84, 0xf2,
3585 0xea, 0xb8, 0xb7, 0x24, 0xb8, 0xf7, 0x7c, 0xff, 0x4a, 0xb6, 0x22, 0xe3, 0x1d, 0x0b, 0xaf, 0x60,
3586 0xc0, 0xcc, 0x4c, 0x71, 0xcf, 0x0b, 0xb8, 0xcf, 0x52, 0x03, 0x9f, 0x70, 0xb9, 0x0c, 0x20, 0x6e,
3587 0xb7, 0x21, 0xb6, 0xd3, 0xd1, 0x75, 0x59, 0x05, 0x69, 0xbb, 0x43, 0x3c, 0x9c, 0x72, 0xec, 0xb7,
3588 0x3b, 0xc5, 0x4e, 0xdd, 0xd8, 0x6b, 0xd6, 0xa4, 0xed, 0x8e, 0x7c, 0x15, 0xf0, 0x86, 0xd1, 0x20,
3589 0x1e, 0x4d, 0x3b, 0x0a, 0x1b, 0x46, 0x83, 0x68, 0x58, 0x32, 0x59, 0x85, 0xd8, 0x1b, 0x7a, 0xfd,
3590 0x3e, 0x71, 0x02, 0x1c, 0x1d, 0x6b, 0xa4, 0x66, 0x8f, 0x93, 0x05, 0xbf, 0x0f, 0x71, 0x77, 0x62,
3591 0x79, 0xde, 0xb2, 0xb8, 0x6f, 0x92, 0x65, 0x89, 0x85, 0xe5, 0x0e, 0x79, 0x73, 0xd9, 0x52, 0x79,
3592 0x01, 0x46, 0x6b, 0xad, 0xfd, 0xa6, 0x49, 0x16, 0xef, 0x57, 0x73, 0xc4, 0xda, 0x3d, 0x18, 0xa7,
3593 0x1e, 0x5d, 0xf0, 0xd4, 0x65, 0xe7, 0xd1, 0xe4, 0x24, 0xfb, 0x3e, 0x71, 0xf7, 0x2d, 0x9d, 0x21,
3594 0x39, 0x05, 0xf1, 0x37, 0xcd, 0x8e, 0x57, 0xf4, 0xdd, 0x8e, 0x94, 0x8e, 0x6a, 0xef, 0x22, 0x88,
3595 0x97, 0x75, 0xfd, 0xc8, 0x0e, 0xf8, 0x35, 0x88, 0x95, 0xdb, 0x3f, 0x36, 0x88, 0x83, 0x97, 0x49,
3596 0x44, 0x2d, 0x31, 0x89, 0xa9, 0x2d, 0x96, 0xaf, 0xb1, 0x71, 0x7f, 0x96, 0xc6, 0x9d, 0xd1, 0xb3,
3597 0x63, 0xaf, 0x71, 0xb1, 0x27, 0x00, 0x5a, 0x4a, 0x7d, 0xf1, 0xbf, 0x01, 0x13, 0xcc, 0x2a, 0x72,
3598 0x9a, 0xb8, 0x21, 0x89, 0x86, 0x6c, 0xac, 0x2c, 0x0d, 0x4d, 0x87, 0x4b, 0xdc, 0xc2, 0x96, 0x29,
3599 0x13, 0xe2, 0x00, 0x53, 0x3b, 0xcc, 0x19, 0x3e, 0xcc, 0xfe, 0xaa, 0x24, 0xd4, 0x59, 0x27, 0x46,
3600 0x76, 0xb8, 0xe7, 0x1d, 0x72, 0x06, 0x83, 0x68, 0xfd, 0xad, 0x8d, 0x02, 0xae, 0xb6, 0x0e, 0xb4,
3601 0x57, 0x01, 0x9c, 0x94, 0xaf, 0x18, 0xc7, 0x87, 0x42, 0xd6, 0x4d, 0xb9, 0x01, 0xde, 0x69, 0xea,
3602 0x3b, 0x7a, 0xd7, 0x56, 0xe1, 0xfb, 0x29, 0xab, 0xc0, 0x80, 0x93, 0x62, 0xb6, 0xfd, 0x4b, 0xa1,
3603 0xf6, 0xbe, 0x9d, 0x98, 0xa5, 0xaa, 0x38, 0xaa, 0xf7, 0x74, 0x73, 0xc3, 0x68, 0x9b, 0x4d, 0xbd,
3604 0x23, 0x58, 0xe4, 0xe4, 0x15, 0x2e, 0x61, 0xa7, 0x72, 0x2f, 0x50, 0x8b, 0x40, 0xa3, 0x15, 0xed,
3605 0x43, 0xdb, 0x41, 0xab, 0x15, 0xe8, 0x7b, 0x40, 0x1c, 0xe1, 0x01, 0xe5, 0x35, 0xae, 0x7f, 0x1b,
3606 0xe0, 0xa6, 0xf0, 0x69, 0x79, 0x93, 0xfb, 0xce, 0x19, 0xec, 0x2c, 0xff, 0x8d, 0xe9, 0xc6, 0xd4,
3607 0x75, 0xf9, 0xa5, 0x50, 0x97, 0x03, 0xba, 0xdb, 0x61, 0x63, 0x8a, 0xa3, 0xc6, 0xf4, 0xcf, 0xb4,
3608 0xe3, 0xb0, 0x86, 0xcb, 0xfa, 0xfd, 0xfa, 0xf1, 0x81, 0x29, 0xbf, 0x1c, 0x8a, 0x7d, 0x01, 0x95,
3609 0xa8, 0xab, 0xf9, 0xa8, 0xf0, 0x17, 0xa4, 0x62, 0x91, 0xba, 0x7b, 0x63, 0x08, 0x0a, 0x14, 0xa4,
3610 0x52, 0x89, 0x96, 0xed, 0xf8, 0x7b, 0x0f, 0xe7, 0xd0, 0x07, 0x0f, 0xe7, 0x46, 0xb4, 0xdf, 0x23,
3611 0xb8, 0x4c, 0x34, 0x19, 0xe2, 0x5e, 0x17, 0x9c, 0xbf, 0xe2, 0xd6, 0x0c, 0xbf, 0x08, 0xfc, 0xcf,
3612 0xc8, 0xfb, 0x37, 0x04, 0x4a, 0x9f, 0xaf, 0x6e, 0xbc, 0xb3, 0x91, 0x5c, 0x2e, 0xa0, 0xca, 0xff,
3613 0x3f, 0xe6, 0xf7, 0x60, 0x74, 0xa7, 0x75, 0xa8, 0x77, 0xac, 0x37, 0x81, 0xf5, 0x87, 0xe3, 0xb2,
3614 0x7b, 0x98, 0xe3, 0x0c, 0xb9, 0x32, 0xc7, 0x39, 0x4e, 0x96, 0x93, 0x15, 0x88, 0x95, 0xeb, 0x66,
3615 0xdd, 0xf6, 0x60, 0x92, 0xd6, 0xd7, 0xba, 0x59, 0xd7, 0x56, 0x60, 0x72, 0xeb, 0x41, 0xe5, 0x6d,
3616 0x53, 0x37, 0x1a, 0xf5, 0xdd, 0x03, 0xf1, 0x0c, 0xd4, 0xed, 0x57, 0x97, 0x33, 0xa3, 0xf1, 0x46,
3617 0xe2, 0x04, 0x15, 0x62, 0xb6, 0x3f, 0x6f, 0xc1, 0xd4, 0xb6, 0xe5, 0xb6, 0x6d, 0xc7, 0x99, 0x39,
3618 0xab, 0x63, 0xfa, 0xf0, 0x42, 0x53, 0x86, 0xbd, 0xa6, 0x2c, 0x05, 0x68, 0x8b, 0x6f, 0x9d, 0x58,
3619 0x3f, 0x6a, 0x68, 0x2b, 0x13, 0x8b, 0x4f, 0x25, 0x2e, 0x67, 0x62, 0x71, 0x48, 0x5c, 0x22, 0xeb,
3620 0xfe, 0x1d, 0x43, 0xc2, 0x69, 0x75, 0xca, 0xfa, 0xfd, 0x96, 0xd1, 0x32, 0xfb, 0xfb, 0x55, 0xea,
3621 0xb1, 0xfc, 0x2d, 0x18, 0xb7, 0x42, 0x6a, 0xff, 0x22, 0x80, 0x5d, 0x25, 0x2d, 0x8a, 0x30, 0x05,
3622 0x19, 0xb0, 0xa9, 0xe3, 0xd9, 0xc8, 0xb7, 0x00, 0x57, 0xab, 0x5b, 0xe4, 0xe5, 0x96, 0x1f, 0x68,
3623 0xba, 0xa5, 0x77, 0xbb, 0xf5, 0x7d, 0x9d, 0xfc, 0x22, 0x63, 0xdd, 0xfd, 0x9a, 0x35, 0x81, 0x9c,
3624 0x07, 0xa9, 0xba, 0x45, 0x1a, 0xde, 0xf9, 0x28, 0xd3, 0xd4, 0xa4, 0xea, 0x56, 0xf2, 0xaf, 0x08,
3625 0x2e, 0x71, 0xa3, 0xb2, 0x06, 0x93, 0xce, 0x00, 0xf3, 0xb8, 0x63, 0x35, 0x6e, 0xcc, 0xf5, 0x59,
3626 0x3a, 0xa7, 0xcf, 0xc9, 0x0d, 0x98, 0x16, 0xc6, 0xe5, 0x45, 0x90, 0xd9, 0x21, 0xe2, 0x04, 0xd8,
3627 0x0d, 0xb5, 0x8f, 0x44, 0xfb, 0x3a, 0x80, 0x17, 0x57, 0x79, 0x1a, 0x26, 0x76, 0xee, 0xdd, 0xa9,
3628 0xfc, 0xb0, 0x5a, 0x79, 0x73, 0xa7, 0x52, 0x4e, 0x20, 0xed, 0x8f, 0x08, 0x26, 0x48, 0xdb, 0xba,
3629 0xd7, 0x3e, 0xd2, 0xe5, 0x22, 0xa0, 0x0d, 0xc2, 0x87, 0x27, 0xf3, 0x1b, 0x6d, 0xc8, 0x4b, 0x80,
3630 0x8a, 0xd1, 0xa1, 0x46, 0x45, 0x39, 0x07, 0xa8, 0x44, 0x00, 0x8e, 0x86, 0x0c, 0x2a, 0x69, 0xff,
3631 0xc6, 0xf0, 0x2c, 0xdb, 0x46, 0xbb, 0xf5, 0xe4, 0x2a, 0xff, 0xdd, 0x54, 0x18, 0x5f, 0xce, 0xad,
3632 0xe4, 0x17, 0xad, 0x7f, 0x28, 0x25, 0x35, 0xfe, 0x13, 0xaa, 0x00, 0x54, 0x65, 0x39, 0xe8, 0x9e,
3633 0x48, 0x21, 0xc6, 0xcc, 0xd0, 0x77, 0x4f, 0x84, 0x93, 0xf6, 0xdd, 0x13, 0xe1, 0xa4, 0x7d, 0xf7,
3634 0x44, 0x38, 0x69, 0xdf, 0x59, 0x00, 0x27, 0xed, 0xbb, 0x27, 0xc2, 0x49, 0xfb, 0xee, 0x89, 0x70,
3635 0xd2, 0xfe, 0x7b, 0x22, 0x44, 0x1c, 0x78, 0x4f, 0x84, 0x97, 0xf7, 0xdf, 0x13, 0xe1, 0xe5, 0xfd,
3636 0xf7, 0x44, 0x0a, 0x31, 0xb3, 0x73, 0xac, 0x07, 0x9f, 0x3a, 0xf0, 0xf6, 0x83, 0x3e, 0x02, 0xbd,
3637 0x0a, 0xbc, 0x0d, 0xd3, 0xce, 0x86, 0x44, 0xa9, 0x6d, 0x98, 0xf5, 0x96, 0xa1, 0x77, 0xe4, 0x6f,
3638 0xc2, 0xa4, 0x33, 0xe4, 0x7c, 0xe6, 0xf8, 0x7d, 0x06, 0x3a, 0x72, 0x52, 0x6f, 0x39, 0x6d, 0xed,
3639 0xcb, 0x18, 0xcc, 0x38, 0x03, 0xd5, 0xfa, 0xa1, 0xce, 0xdd, 0x32, 0x5a, 0x10, 0xce, 0x94, 0xa6,
3640 0x2c, 0xf3, 0xde, 0xe9, 0x9c, 0x33, 0xba, 0x41, 0xd9, 0xb4, 0x20, 0x9c, 0x2e, 0xf1, 0x7a, 0xde,
3641 0x0b, 0x68, 0x41, 0xb8, 0x79, 0xc4, 0xeb, 0xd1, 0xf7, 0x0d, 0xd5, 0x73, 0xef, 0x20, 0xf1, 0x7a,
3642 0x65, 0xca, 0xb2, 0x05, 0xe1, 0x36, 0x12, 0xaf, 0x57, 0xa1, 0x7c, 0x5b, 0x10, 0xce, 0x9e, 0x78,
3643 0xbd, 0x5b, 0x94, 0x79, 0x0b, 0xc2, 0x29, 0x14, 0xaf, 0xf7, 0x6d, 0xca, 0xc1, 0x05, 0xe1, 0xae,
3644 0x12, 0xaf, 0xf7, 0x3a, 0x65, 0xe3, 0x82, 0x70, 0x6b, 0x89, 0xd7, 0xdb, 0xa4, 0xbc, 0x4c, 0x8b,
3645 0xf7, 0x97, 0x78, 0xc5, 0xdb, 0x1e, 0x43, 0xd3, 0xe2, 0x4d, 0x26, 0x5e, 0xf3, 0x3b, 0x1e, 0x57,
3646 0xd3, 0xe2, 0x9d, 0x26, 0x5e, 0xf3, 0x0d, 0x8f, 0xb5, 0x69, 0xf1, 0xac, 0x8c, 0xd7, 0xdc, 0xf2,
3647 0xf8, 0x9b, 0x16, 0x4f, 0xcd, 0x78, 0xcd, 0xaa, 0xc7, 0xe4, 0xb4, 0x78, 0x7e, 0xc6, 0x6b, 0x6e,
3648 0x7b, 0x9b, 0xe8, 0x1f, 0x09, 0xf4, 0x63, 0x6e, 0x41, 0x69, 0x02, 0xfd, 0xc0, 0x87, 0x7a, 0x42,
3649 0x21, 0x63, 0x74, 0x3c, 0xda, 0x69, 0x02, 0xed, 0xc0, 0x87, 0x72, 0x9a, 0x40, 0x39, 0xf0, 0xa1,
3650 0x9b, 0x26, 0xd0, 0x0d, 0x7c, 0xa8, 0xa6, 0x09, 0x54, 0x03, 0x1f, 0x9a, 0x69, 0x02, 0xcd, 0xc0,
3651 0x87, 0x62, 0x9a, 0x40, 0x31, 0xf0, 0xa1, 0x97, 0x26, 0xd0, 0x0b, 0x7c, 0xa8, 0x35, 0x2f, 0x52,
3652 0x0b, 0xfc, 0x68, 0x35, 0x2f, 0xd2, 0x0a, 0xfc, 0x28, 0xf5, 0xa2, 0x48, 0xa9, 0xf1, 0xde, 0xe9,
3653 0xdc, 0xa8, 0x35, 0xc4, 0xb0, 0x69, 0x5e, 0x64, 0x13, 0xf8, 0x31, 0x69, 0x5e, 0x64, 0x12, 0xf8,
3654 0xb1, 0x68, 0x5e, 0x64, 0x11, 0xf8, 0x31, 0xe8, 0x91, 0xc8, 0x20, 0xef, 0x8e, 0x8f, 0x26, 0x1c,
3655 0x29, 0x86, 0x31, 0x08, 0x47, 0x60, 0x10, 0x8e, 0xc0, 0x20, 0x1c, 0x81, 0x41, 0x38, 0x02, 0x83,
3656 0x70, 0x04, 0x06, 0xe1, 0x08, 0x0c, 0xc2, 0x11, 0x18, 0x84, 0xa3, 0x30, 0x08, 0x47, 0x62, 0x10,
3657 0x0e, 0x62, 0xd0, 0xbc, 0x78, 0xe3, 0x01, 0xfc, 0x0a, 0xd2, 0xbc, 0x78, 0xf4, 0x19, 0x4e, 0x21,
3658 0x1c, 0x89, 0x42, 0x38, 0x88, 0x42, 0x1f, 0x61, 0x78, 0x96, 0xa3, 0x10, 0x39, 0x1f, 0xba, 0xa8,
3659 0x0a, 0xb4, 0x16, 0xe1, 0x82, 0x85, 0x1f, 0xa7, 0xd6, 0x22, 0x1c, 0x52, 0x0f, 0xe2, 0x59, 0x7f,
3660 0x15, 0xaa, 0x44, 0xa8, 0x42, 0xb7, 0x28, 0x87, 0xd6, 0x22, 0x5c, 0xbc, 0xe8, 0xe7, 0xde, 0xfa,
3661 0xa0, 0x22, 0xf0, 0x7a, 0xa4, 0x22, 0xb0, 0x19, 0xa9, 0x08, 0xdc, 0xf6, 0x10, 0xfc, 0x99, 0x04,
3662 0xcf, 0x79, 0x08, 0x3a, 0x7f, 0xed, 0x3c, 0x38, 0xb2, 0x4a, 0x80, 0x77, 0x44, 0x25, 0xbb, 0xc7,
3663 0x36, 0x0c, 0x8c, 0xd2, 0x66, 0x43, 0xbe, 0xc3, 0x1f, 0x56, 0x15, 0x86, 0x3d, 0xc0, 0x61, 0x10,
3664 0x27, 0x9b, 0xa1, 0xf3, 0x80, 0x37, 0x1b, 0x5d, 0xbb, 0x5a, 0xf8, 0x2d, 0x5b, 0xaa, 0x59, 0x62,
3665 0xb9, 0x06, 0x63, 0xb6, 0x7a, 0xd7, 0x86, 0xf7, 0x3c, 0x0b, 0x97, 0x6b, 0x64, 0x26, 0xed, 0x11,
3666 0x82, 0x14, 0x47, 0xe5, 0x8b, 0x39, 0x32, 0x78, 0x25, 0xd2, 0x91, 0x01, 0x97, 0x20, 0xde, 0xf1,
3667 0xc1, 0x37, 0xfa, 0x4f, 0xaa, 0xd9, 0x2c, 0x11, 0x8f, 0x12, 0x7e, 0x0a, 0x53, 0xde, 0x13, 0xd8,
3668 0xdf, 0x6c, 0xab, 0xe1, 0xbb, 0x99, 0x7e, 0xa9, 0xb9, 0x2a, 0xec, 0xa2, 0x0d, 0x34, 0xa3, 0xd9,
3669 0xaa, 0x15, 0x60, 0xba, 0xda, 0xb6, 0x77, 0x00, 0xba, 0xad, 0xb6, 0xd1, 0xdd, 0xaa, 0x1f, 0x85,
3670 0x6d, 0x46, 0xc4, 0xad, 0xd6, 0xfc, 0xe4, 0x37, 0x73, 0x23, 0xda, 0xcb, 0x30, 0x79, 0xd7, 0xe8,
3671 0xe8, 0x7b, 0xed, 0x7d, 0xa3, 0xf5, 0x13, 0xbd, 0x21, 0x18, 0x8e, 0xbb, 0x86, 0x85, 0xd8, 0x63,
3672 0x4b, 0xfb, 0x97, 0x08, 0xae, 0xb0, 0xea, 0xdf, 0x6b, 0x99, 0xcd, 0x4d, 0xc3, 0xea, 0xe9, 0x5f,
3673 0x85, 0xb8, 0x4e, 0x80, 0xb3, 0xdf, 0x5d, 0x13, 0xee, 0x77, 0xa4, 0xaf, 0xfa, 0xa2, 0xfd, 0x6f,
3674 0x8d, 0x9a, 0x08, 0xbb, 0x20, 0xee, 0xb2, 0xb9, 0xe4, 0x35, 0x18, 0x75, 0xe6, 0xe7, 0xfd, 0xba,
3675 0x24, 0xf8, 0xf5, 0x3b, 0x1f, 0xbf, 0x6c, 0x1e, 0xc9, 0xb7, 0x39, 0xbf, 0x98, 0xcf, 0x55, 0x5f,
3676 0xf5, 0x45, 0x97, 0x7c, 0xc5, 0xb8, 0xd5, 0xff, 0xd9, 0x8c, 0x0a, 0x77, 0x32, 0x0d, 0xf1, 0x8a,
3677 0xa8, 0xe3, 0xef, 0x67, 0x19, 0x62, 0xd5, 0x76, 0x43, 0x97, 0x9f, 0x83, 0xd1, 0x37, 0xea, 0xbb,
3678 0xfa, 0x01, 0x09, 0xb2, 0xf3, 0x43, 0x5e, 0x80, 0x78, 0xa9, 0xd9, 0x3a, 0x68, 0x74, 0x74, 0x83,
3679 0x9c, 0xd9, 0x93, 0x2d, 0x74, 0xcb, 0xa6, 0x46, 0x65, 0x5a, 0x09, 0x2e, 0x57, 0xdb, 0x46, 0xf1,
3680 0x81, 0xc9, 0xd6, 0x8d, 0x45, 0x21, 0x45, 0xc8, 0x99, 0xcf, 0x1d, 0x2b, 0x1b, 0x2d, 0x85, 0xe2,
3681 0xe8, 0xc7, 0xa7, 0x73, 0x68, 0x87, 0xee, 0x9f, 0x6f, 0xc1, 0xf3, 0x24, 0x7d, 0xfa, 0xa6, 0xca,
3682 0x85, 0x4d, 0x35, 0x4e, 0xce, 0xa9, 0x99, 0xe9, 0x36, 0xad, 0xe9, 0x0c, 0xdf, 0xe9, 0x9e, 0xcc,
3683 0x33, 0xab, 0x29, 0x1a, 0xe8, 0x19, 0x1e, 0xca, 0x33, 0xdf, 0xe9, 0x16, 0xc3, 0xa6, 0x13, 0x3c,
3684 0x7b, 0x11, 0xc6, 0xa9, 0x8c, 0x61, 0x03, 0x9b, 0x29, 0xb9, 0x8c, 0x06, 0x13, 0x4c, 0xc2, 0xca,
3685 0xa3, 0x80, 0x36, 0x12, 0x23, 0xd6, 0x7f, 0xc5, 0x04, 0xb2, 0xfe, 0x2b, 0x25, 0xa4, 0xcc, 0x35,
3686 0x98, 0x16, 0xf6, 0x2f, 0x2d, 0x49, 0x39, 0x01, 0xd6, 0x7f, 0x95, 0xc4, 0x44, 0x32, 0xf6, 0xde,
3687 0x6f, 0xd5, 0x91, 0xcc, 0x2b, 0x20, 0xf7, 0xef, 0x74, 0xca, 0x63, 0x20, 0x6d, 0x58, 0x53, 0x3e,
3688 0x0f, 0x52, 0xb1, 0x98, 0x40, 0xc9, 0xe9, 0x9f, 0xff, 0x2a, 0x35, 0x51, 0xd4, 0x4d, 0x53, 0xef,
3689 0xdc, 0xd3, 0xcd, 0x62, 0x91, 0x18, 0xbf, 0x06, 0x57, 0x7c, 0x77, 0x4a, 0x2d, 0xfb, 0x52, 0xc9,
3690 0xb1, 0x2f, 0x97, 0xfb, 0xec, 0xcb, 0x65, 0xdb, 0x1e, 0x15, 0xdc, 0x13, 0xe7, 0x0d, 0xd9, 0x67,
3691 0x97, 0x51, 0x69, 0x30, 0x27, 0xdc, 0x1b, 0x85, 0xd7, 0x88, 0x6e, 0xd1, 0x57, 0x57, 0x0f, 0x39,
3692 0xb1, 0x2e, 0x16, 0x4a, 0xc4, 0xbe, 0xe4, 0x6b, 0x7f, 0x5f, 0x38, 0x56, 0xe5, 0xdf, 0x10, 0x64,
3693 0x92, 0x12, 0x75, 0xb8, 0xec, 0x3b, 0x49, 0x93, 0xb9, 0xec, 0x5e, 0xa6, 0x0e, 0x57, 0x7c, 0x75,
3694 0x5b, 0x21, 0x97, 0xbe, 0x2a, 0x85, 0x25, 0xf2, 0x92, 0xdf, 0x58, 0x96, 0xaf, 0xb8, 0x39, 0xca,
3695 0x55, 0x60, 0x12, 0x20, 0x57, 0xab, 0x50, 0x22, 0x06, 0xc5, 0x40, 0x83, 0xe0, 0x28, 0xb9, 0x96,
3696 0x85, 0xd7, 0xc9, 0x24, 0xa5, 0xc0, 0x49, 0x42, 0x42, 0xe5, 0x9a, 0x17, 0x77, 0x4e, 0xce, 0xd4,
3697 0x91, 0xc7, 0x67, 0xea, 0xc8, 0x3f, 0xcf, 0xd4, 0x91, 0x4f, 0xce, 0x54, 0xf4, 0xd9, 0x99, 0x8a,
3698 0x3e, 0x3f, 0x53, 0xd1, 0x17, 0x67, 0x2a, 0x7a, 0xa7, 0xa7, 0xa2, 0x0f, 0x7a, 0x2a, 0xfa, 0xb0,
3699 0xa7, 0xa2, 0x3f, 0xf5, 0x54, 0xf4, 0xa8, 0xa7, 0xa2, 0x93, 0x9e, 0x8a, 0x1e, 0xf7, 0x54, 0xf4,
3700 0x49, 0x4f, 0x45, 0x9f, 0xf5, 0xd4, 0x91, 0xcf, 0x7b, 0x2a, 0xfa, 0xa2, 0xa7, 0x8e, 0xbc, 0xf3,
3701 0xa9, 0x3a, 0xf2, 0xf0, 0x53, 0x75, 0xe4, 0x83, 0x4f, 0x55, 0xf4, 0xdf, 0x00, 0x00, 0x00, 0xff,
3702 0xff, 0x6f, 0x5f, 0xc5, 0x7d, 0x47, 0x36, 0x00, 0x00,
3703 }
3704
3705 func (this *NidOptNative) Compare(that interface{}) int {
3706 if that == nil {
3707 if this == nil {
3708 return 0
3709 }
3710 return 1
3711 }
3712
3713 that1, ok := that.(*NidOptNative)
3714 if !ok {
3715 that2, ok := that.(NidOptNative)
3716 if ok {
3717 that1 = &that2
3718 } else {
3719 return 1
3720 }
3721 }
3722 if that1 == nil {
3723 if this == nil {
3724 return 0
3725 }
3726 return 1
3727 } else if this == nil {
3728 return -1
3729 }
3730 if this.Field1 != that1.Field1 {
3731 if this.Field1 < that1.Field1 {
3732 return -1
3733 }
3734 return 1
3735 }
3736 if this.Field2 != that1.Field2 {
3737 if this.Field2 < that1.Field2 {
3738 return -1
3739 }
3740 return 1
3741 }
3742 if this.Field3 != that1.Field3 {
3743 if this.Field3 < that1.Field3 {
3744 return -1
3745 }
3746 return 1
3747 }
3748 if this.Field4 != that1.Field4 {
3749 if this.Field4 < that1.Field4 {
3750 return -1
3751 }
3752 return 1
3753 }
3754 if this.Field5 != that1.Field5 {
3755 if this.Field5 < that1.Field5 {
3756 return -1
3757 }
3758 return 1
3759 }
3760 if this.Field6 != that1.Field6 {
3761 if this.Field6 < that1.Field6 {
3762 return -1
3763 }
3764 return 1
3765 }
3766 if this.Field7 != that1.Field7 {
3767 if this.Field7 < that1.Field7 {
3768 return -1
3769 }
3770 return 1
3771 }
3772 if this.Field8 != that1.Field8 {
3773 if this.Field8 < that1.Field8 {
3774 return -1
3775 }
3776 return 1
3777 }
3778 if this.Field9 != that1.Field9 {
3779 if this.Field9 < that1.Field9 {
3780 return -1
3781 }
3782 return 1
3783 }
3784 if this.Field10 != that1.Field10 {
3785 if this.Field10 < that1.Field10 {
3786 return -1
3787 }
3788 return 1
3789 }
3790 if this.Field11 != that1.Field11 {
3791 if this.Field11 < that1.Field11 {
3792 return -1
3793 }
3794 return 1
3795 }
3796 if this.Field12 != that1.Field12 {
3797 if this.Field12 < that1.Field12 {
3798 return -1
3799 }
3800 return 1
3801 }
3802 if this.Field13 != that1.Field13 {
3803 if !this.Field13 {
3804 return -1
3805 }
3806 return 1
3807 }
3808 if this.Field14 != that1.Field14 {
3809 if this.Field14 < that1.Field14 {
3810 return -1
3811 }
3812 return 1
3813 }
3814 if c := bytes.Compare(this.Field15, that1.Field15); c != 0 {
3815 return c
3816 }
3817 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
3818 return c
3819 }
3820 return 0
3821 }
3822 func (this *NinOptNative) Compare(that interface{}) int {
3823 if that == nil {
3824 if this == nil {
3825 return 0
3826 }
3827 return 1
3828 }
3829
3830 that1, ok := that.(*NinOptNative)
3831 if !ok {
3832 that2, ok := that.(NinOptNative)
3833 if ok {
3834 that1 = &that2
3835 } else {
3836 return 1
3837 }
3838 }
3839 if that1 == nil {
3840 if this == nil {
3841 return 0
3842 }
3843 return 1
3844 } else if this == nil {
3845 return -1
3846 }
3847 if this.Field1 != nil && that1.Field1 != nil {
3848 if *this.Field1 != *that1.Field1 {
3849 if *this.Field1 < *that1.Field1 {
3850 return -1
3851 }
3852 return 1
3853 }
3854 } else if this.Field1 != nil {
3855 return 1
3856 } else if that1.Field1 != nil {
3857 return -1
3858 }
3859 if this.Field2 != nil && that1.Field2 != nil {
3860 if *this.Field2 != *that1.Field2 {
3861 if *this.Field2 < *that1.Field2 {
3862 return -1
3863 }
3864 return 1
3865 }
3866 } else if this.Field2 != nil {
3867 return 1
3868 } else if that1.Field2 != nil {
3869 return -1
3870 }
3871 if this.Field3 != nil && that1.Field3 != nil {
3872 if *this.Field3 != *that1.Field3 {
3873 if *this.Field3 < *that1.Field3 {
3874 return -1
3875 }
3876 return 1
3877 }
3878 } else if this.Field3 != nil {
3879 return 1
3880 } else if that1.Field3 != nil {
3881 return -1
3882 }
3883 if this.Field4 != nil && that1.Field4 != nil {
3884 if *this.Field4 != *that1.Field4 {
3885 if *this.Field4 < *that1.Field4 {
3886 return -1
3887 }
3888 return 1
3889 }
3890 } else if this.Field4 != nil {
3891 return 1
3892 } else if that1.Field4 != nil {
3893 return -1
3894 }
3895 if this.Field5 != nil && that1.Field5 != nil {
3896 if *this.Field5 != *that1.Field5 {
3897 if *this.Field5 < *that1.Field5 {
3898 return -1
3899 }
3900 return 1
3901 }
3902 } else if this.Field5 != nil {
3903 return 1
3904 } else if that1.Field5 != nil {
3905 return -1
3906 }
3907 if this.Field6 != nil && that1.Field6 != nil {
3908 if *this.Field6 != *that1.Field6 {
3909 if *this.Field6 < *that1.Field6 {
3910 return -1
3911 }
3912 return 1
3913 }
3914 } else if this.Field6 != nil {
3915 return 1
3916 } else if that1.Field6 != nil {
3917 return -1
3918 }
3919 if this.Field7 != nil && that1.Field7 != nil {
3920 if *this.Field7 != *that1.Field7 {
3921 if *this.Field7 < *that1.Field7 {
3922 return -1
3923 }
3924 return 1
3925 }
3926 } else if this.Field7 != nil {
3927 return 1
3928 } else if that1.Field7 != nil {
3929 return -1
3930 }
3931 if this.Field8 != nil && that1.Field8 != nil {
3932 if *this.Field8 != *that1.Field8 {
3933 if *this.Field8 < *that1.Field8 {
3934 return -1
3935 }
3936 return 1
3937 }
3938 } else if this.Field8 != nil {
3939 return 1
3940 } else if that1.Field8 != nil {
3941 return -1
3942 }
3943 if this.Field9 != nil && that1.Field9 != nil {
3944 if *this.Field9 != *that1.Field9 {
3945 if *this.Field9 < *that1.Field9 {
3946 return -1
3947 }
3948 return 1
3949 }
3950 } else if this.Field9 != nil {
3951 return 1
3952 } else if that1.Field9 != nil {
3953 return -1
3954 }
3955 if this.Field10 != nil && that1.Field10 != nil {
3956 if *this.Field10 != *that1.Field10 {
3957 if *this.Field10 < *that1.Field10 {
3958 return -1
3959 }
3960 return 1
3961 }
3962 } else if this.Field10 != nil {
3963 return 1
3964 } else if that1.Field10 != nil {
3965 return -1
3966 }
3967 if this.Field11 != nil && that1.Field11 != nil {
3968 if *this.Field11 != *that1.Field11 {
3969 if *this.Field11 < *that1.Field11 {
3970 return -1
3971 }
3972 return 1
3973 }
3974 } else if this.Field11 != nil {
3975 return 1
3976 } else if that1.Field11 != nil {
3977 return -1
3978 }
3979 if this.Field12 != nil && that1.Field12 != nil {
3980 if *this.Field12 != *that1.Field12 {
3981 if *this.Field12 < *that1.Field12 {
3982 return -1
3983 }
3984 return 1
3985 }
3986 } else if this.Field12 != nil {
3987 return 1
3988 } else if that1.Field12 != nil {
3989 return -1
3990 }
3991 if this.Field13 != nil && that1.Field13 != nil {
3992 if *this.Field13 != *that1.Field13 {
3993 if !*this.Field13 {
3994 return -1
3995 }
3996 return 1
3997 }
3998 } else if this.Field13 != nil {
3999 return 1
4000 } else if that1.Field13 != nil {
4001 return -1
4002 }
4003 if this.Field14 != nil && that1.Field14 != nil {
4004 if *this.Field14 != *that1.Field14 {
4005 if *this.Field14 < *that1.Field14 {
4006 return -1
4007 }
4008 return 1
4009 }
4010 } else if this.Field14 != nil {
4011 return 1
4012 } else if that1.Field14 != nil {
4013 return -1
4014 }
4015 if c := bytes.Compare(this.Field15, that1.Field15); c != 0 {
4016 return c
4017 }
4018 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
4019 return c
4020 }
4021 return 0
4022 }
4023 func (this *NidRepNative) Compare(that interface{}) int {
4024 if that == nil {
4025 if this == nil {
4026 return 0
4027 }
4028 return 1
4029 }
4030
4031 that1, ok := that.(*NidRepNative)
4032 if !ok {
4033 that2, ok := that.(NidRepNative)
4034 if ok {
4035 that1 = &that2
4036 } else {
4037 return 1
4038 }
4039 }
4040 if that1 == nil {
4041 if this == nil {
4042 return 0
4043 }
4044 return 1
4045 } else if this == nil {
4046 return -1
4047 }
4048 if len(this.Field1) != len(that1.Field1) {
4049 if len(this.Field1) < len(that1.Field1) {
4050 return -1
4051 }
4052 return 1
4053 }
4054 for i := range this.Field1 {
4055 if this.Field1[i] != that1.Field1[i] {
4056 if this.Field1[i] < that1.Field1[i] {
4057 return -1
4058 }
4059 return 1
4060 }
4061 }
4062 if len(this.Field2) != len(that1.Field2) {
4063 if len(this.Field2) < len(that1.Field2) {
4064 return -1
4065 }
4066 return 1
4067 }
4068 for i := range this.Field2 {
4069 if this.Field2[i] != that1.Field2[i] {
4070 if this.Field2[i] < that1.Field2[i] {
4071 return -1
4072 }
4073 return 1
4074 }
4075 }
4076 if len(this.Field3) != len(that1.Field3) {
4077 if len(this.Field3) < len(that1.Field3) {
4078 return -1
4079 }
4080 return 1
4081 }
4082 for i := range this.Field3 {
4083 if this.Field3[i] != that1.Field3[i] {
4084 if this.Field3[i] < that1.Field3[i] {
4085 return -1
4086 }
4087 return 1
4088 }
4089 }
4090 if len(this.Field4) != len(that1.Field4) {
4091 if len(this.Field4) < len(that1.Field4) {
4092 return -1
4093 }
4094 return 1
4095 }
4096 for i := range this.Field4 {
4097 if this.Field4[i] != that1.Field4[i] {
4098 if this.Field4[i] < that1.Field4[i] {
4099 return -1
4100 }
4101 return 1
4102 }
4103 }
4104 if len(this.Field5) != len(that1.Field5) {
4105 if len(this.Field5) < len(that1.Field5) {
4106 return -1
4107 }
4108 return 1
4109 }
4110 for i := range this.Field5 {
4111 if this.Field5[i] != that1.Field5[i] {
4112 if this.Field5[i] < that1.Field5[i] {
4113 return -1
4114 }
4115 return 1
4116 }
4117 }
4118 if len(this.Field6) != len(that1.Field6) {
4119 if len(this.Field6) < len(that1.Field6) {
4120 return -1
4121 }
4122 return 1
4123 }
4124 for i := range this.Field6 {
4125 if this.Field6[i] != that1.Field6[i] {
4126 if this.Field6[i] < that1.Field6[i] {
4127 return -1
4128 }
4129 return 1
4130 }
4131 }
4132 if len(this.Field7) != len(that1.Field7) {
4133 if len(this.Field7) < len(that1.Field7) {
4134 return -1
4135 }
4136 return 1
4137 }
4138 for i := range this.Field7 {
4139 if this.Field7[i] != that1.Field7[i] {
4140 if this.Field7[i] < that1.Field7[i] {
4141 return -1
4142 }
4143 return 1
4144 }
4145 }
4146 if len(this.Field8) != len(that1.Field8) {
4147 if len(this.Field8) < len(that1.Field8) {
4148 return -1
4149 }
4150 return 1
4151 }
4152 for i := range this.Field8 {
4153 if this.Field8[i] != that1.Field8[i] {
4154 if this.Field8[i] < that1.Field8[i] {
4155 return -1
4156 }
4157 return 1
4158 }
4159 }
4160 if len(this.Field9) != len(that1.Field9) {
4161 if len(this.Field9) < len(that1.Field9) {
4162 return -1
4163 }
4164 return 1
4165 }
4166 for i := range this.Field9 {
4167 if this.Field9[i] != that1.Field9[i] {
4168 if this.Field9[i] < that1.Field9[i] {
4169 return -1
4170 }
4171 return 1
4172 }
4173 }
4174 if len(this.Field10) != len(that1.Field10) {
4175 if len(this.Field10) < len(that1.Field10) {
4176 return -1
4177 }
4178 return 1
4179 }
4180 for i := range this.Field10 {
4181 if this.Field10[i] != that1.Field10[i] {
4182 if this.Field10[i] < that1.Field10[i] {
4183 return -1
4184 }
4185 return 1
4186 }
4187 }
4188 if len(this.Field11) != len(that1.Field11) {
4189 if len(this.Field11) < len(that1.Field11) {
4190 return -1
4191 }
4192 return 1
4193 }
4194 for i := range this.Field11 {
4195 if this.Field11[i] != that1.Field11[i] {
4196 if this.Field11[i] < that1.Field11[i] {
4197 return -1
4198 }
4199 return 1
4200 }
4201 }
4202 if len(this.Field12) != len(that1.Field12) {
4203 if len(this.Field12) < len(that1.Field12) {
4204 return -1
4205 }
4206 return 1
4207 }
4208 for i := range this.Field12 {
4209 if this.Field12[i] != that1.Field12[i] {
4210 if this.Field12[i] < that1.Field12[i] {
4211 return -1
4212 }
4213 return 1
4214 }
4215 }
4216 if len(this.Field13) != len(that1.Field13) {
4217 if len(this.Field13) < len(that1.Field13) {
4218 return -1
4219 }
4220 return 1
4221 }
4222 for i := range this.Field13 {
4223 if this.Field13[i] != that1.Field13[i] {
4224 if !this.Field13[i] {
4225 return -1
4226 }
4227 return 1
4228 }
4229 }
4230 if len(this.Field14) != len(that1.Field14) {
4231 if len(this.Field14) < len(that1.Field14) {
4232 return -1
4233 }
4234 return 1
4235 }
4236 for i := range this.Field14 {
4237 if this.Field14[i] != that1.Field14[i] {
4238 if this.Field14[i] < that1.Field14[i] {
4239 return -1
4240 }
4241 return 1
4242 }
4243 }
4244 if len(this.Field15) != len(that1.Field15) {
4245 if len(this.Field15) < len(that1.Field15) {
4246 return -1
4247 }
4248 return 1
4249 }
4250 for i := range this.Field15 {
4251 if c := bytes.Compare(this.Field15[i], that1.Field15[i]); c != 0 {
4252 return c
4253 }
4254 }
4255 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
4256 return c
4257 }
4258 return 0
4259 }
4260 func (this *NinRepNative) Compare(that interface{}) int {
4261 if that == nil {
4262 if this == nil {
4263 return 0
4264 }
4265 return 1
4266 }
4267
4268 that1, ok := that.(*NinRepNative)
4269 if !ok {
4270 that2, ok := that.(NinRepNative)
4271 if ok {
4272 that1 = &that2
4273 } else {
4274 return 1
4275 }
4276 }
4277 if that1 == nil {
4278 if this == nil {
4279 return 0
4280 }
4281 return 1
4282 } else if this == nil {
4283 return -1
4284 }
4285 if len(this.Field1) != len(that1.Field1) {
4286 if len(this.Field1) < len(that1.Field1) {
4287 return -1
4288 }
4289 return 1
4290 }
4291 for i := range this.Field1 {
4292 if this.Field1[i] != that1.Field1[i] {
4293 if this.Field1[i] < that1.Field1[i] {
4294 return -1
4295 }
4296 return 1
4297 }
4298 }
4299 if len(this.Field2) != len(that1.Field2) {
4300 if len(this.Field2) < len(that1.Field2) {
4301 return -1
4302 }
4303 return 1
4304 }
4305 for i := range this.Field2 {
4306 if this.Field2[i] != that1.Field2[i] {
4307 if this.Field2[i] < that1.Field2[i] {
4308 return -1
4309 }
4310 return 1
4311 }
4312 }
4313 if len(this.Field3) != len(that1.Field3) {
4314 if len(this.Field3) < len(that1.Field3) {
4315 return -1
4316 }
4317 return 1
4318 }
4319 for i := range this.Field3 {
4320 if this.Field3[i] != that1.Field3[i] {
4321 if this.Field3[i] < that1.Field3[i] {
4322 return -1
4323 }
4324 return 1
4325 }
4326 }
4327 if len(this.Field4) != len(that1.Field4) {
4328 if len(this.Field4) < len(that1.Field4) {
4329 return -1
4330 }
4331 return 1
4332 }
4333 for i := range this.Field4 {
4334 if this.Field4[i] != that1.Field4[i] {
4335 if this.Field4[i] < that1.Field4[i] {
4336 return -1
4337 }
4338 return 1
4339 }
4340 }
4341 if len(this.Field5) != len(that1.Field5) {
4342 if len(this.Field5) < len(that1.Field5) {
4343 return -1
4344 }
4345 return 1
4346 }
4347 for i := range this.Field5 {
4348 if this.Field5[i] != that1.Field5[i] {
4349 if this.Field5[i] < that1.Field5[i] {
4350 return -1
4351 }
4352 return 1
4353 }
4354 }
4355 if len(this.Field6) != len(that1.Field6) {
4356 if len(this.Field6) < len(that1.Field6) {
4357 return -1
4358 }
4359 return 1
4360 }
4361 for i := range this.Field6 {
4362 if this.Field6[i] != that1.Field6[i] {
4363 if this.Field6[i] < that1.Field6[i] {
4364 return -1
4365 }
4366 return 1
4367 }
4368 }
4369 if len(this.Field7) != len(that1.Field7) {
4370 if len(this.Field7) < len(that1.Field7) {
4371 return -1
4372 }
4373 return 1
4374 }
4375 for i := range this.Field7 {
4376 if this.Field7[i] != that1.Field7[i] {
4377 if this.Field7[i] < that1.Field7[i] {
4378 return -1
4379 }
4380 return 1
4381 }
4382 }
4383 if len(this.Field8) != len(that1.Field8) {
4384 if len(this.Field8) < len(that1.Field8) {
4385 return -1
4386 }
4387 return 1
4388 }
4389 for i := range this.Field8 {
4390 if this.Field8[i] != that1.Field8[i] {
4391 if this.Field8[i] < that1.Field8[i] {
4392 return -1
4393 }
4394 return 1
4395 }
4396 }
4397 if len(this.Field9) != len(that1.Field9) {
4398 if len(this.Field9) < len(that1.Field9) {
4399 return -1
4400 }
4401 return 1
4402 }
4403 for i := range this.Field9 {
4404 if this.Field9[i] != that1.Field9[i] {
4405 if this.Field9[i] < that1.Field9[i] {
4406 return -1
4407 }
4408 return 1
4409 }
4410 }
4411 if len(this.Field10) != len(that1.Field10) {
4412 if len(this.Field10) < len(that1.Field10) {
4413 return -1
4414 }
4415 return 1
4416 }
4417 for i := range this.Field10 {
4418 if this.Field10[i] != that1.Field10[i] {
4419 if this.Field10[i] < that1.Field10[i] {
4420 return -1
4421 }
4422 return 1
4423 }
4424 }
4425 if len(this.Field11) != len(that1.Field11) {
4426 if len(this.Field11) < len(that1.Field11) {
4427 return -1
4428 }
4429 return 1
4430 }
4431 for i := range this.Field11 {
4432 if this.Field11[i] != that1.Field11[i] {
4433 if this.Field11[i] < that1.Field11[i] {
4434 return -1
4435 }
4436 return 1
4437 }
4438 }
4439 if len(this.Field12) != len(that1.Field12) {
4440 if len(this.Field12) < len(that1.Field12) {
4441 return -1
4442 }
4443 return 1
4444 }
4445 for i := range this.Field12 {
4446 if this.Field12[i] != that1.Field12[i] {
4447 if this.Field12[i] < that1.Field12[i] {
4448 return -1
4449 }
4450 return 1
4451 }
4452 }
4453 if len(this.Field13) != len(that1.Field13) {
4454 if len(this.Field13) < len(that1.Field13) {
4455 return -1
4456 }
4457 return 1
4458 }
4459 for i := range this.Field13 {
4460 if this.Field13[i] != that1.Field13[i] {
4461 if !this.Field13[i] {
4462 return -1
4463 }
4464 return 1
4465 }
4466 }
4467 if len(this.Field14) != len(that1.Field14) {
4468 if len(this.Field14) < len(that1.Field14) {
4469 return -1
4470 }
4471 return 1
4472 }
4473 for i := range this.Field14 {
4474 if this.Field14[i] != that1.Field14[i] {
4475 if this.Field14[i] < that1.Field14[i] {
4476 return -1
4477 }
4478 return 1
4479 }
4480 }
4481 if len(this.Field15) != len(that1.Field15) {
4482 if len(this.Field15) < len(that1.Field15) {
4483 return -1
4484 }
4485 return 1
4486 }
4487 for i := range this.Field15 {
4488 if c := bytes.Compare(this.Field15[i], that1.Field15[i]); c != 0 {
4489 return c
4490 }
4491 }
4492 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
4493 return c
4494 }
4495 return 0
4496 }
4497 func (this *NidRepPackedNative) Compare(that interface{}) int {
4498 if that == nil {
4499 if this == nil {
4500 return 0
4501 }
4502 return 1
4503 }
4504
4505 that1, ok := that.(*NidRepPackedNative)
4506 if !ok {
4507 that2, ok := that.(NidRepPackedNative)
4508 if ok {
4509 that1 = &that2
4510 } else {
4511 return 1
4512 }
4513 }
4514 if that1 == nil {
4515 if this == nil {
4516 return 0
4517 }
4518 return 1
4519 } else if this == nil {
4520 return -1
4521 }
4522 if len(this.Field1) != len(that1.Field1) {
4523 if len(this.Field1) < len(that1.Field1) {
4524 return -1
4525 }
4526 return 1
4527 }
4528 for i := range this.Field1 {
4529 if this.Field1[i] != that1.Field1[i] {
4530 if this.Field1[i] < that1.Field1[i] {
4531 return -1
4532 }
4533 return 1
4534 }
4535 }
4536 if len(this.Field2) != len(that1.Field2) {
4537 if len(this.Field2) < len(that1.Field2) {
4538 return -1
4539 }
4540 return 1
4541 }
4542 for i := range this.Field2 {
4543 if this.Field2[i] != that1.Field2[i] {
4544 if this.Field2[i] < that1.Field2[i] {
4545 return -1
4546 }
4547 return 1
4548 }
4549 }
4550 if len(this.Field3) != len(that1.Field3) {
4551 if len(this.Field3) < len(that1.Field3) {
4552 return -1
4553 }
4554 return 1
4555 }
4556 for i := range this.Field3 {
4557 if this.Field3[i] != that1.Field3[i] {
4558 if this.Field3[i] < that1.Field3[i] {
4559 return -1
4560 }
4561 return 1
4562 }
4563 }
4564 if len(this.Field4) != len(that1.Field4) {
4565 if len(this.Field4) < len(that1.Field4) {
4566 return -1
4567 }
4568 return 1
4569 }
4570 for i := range this.Field4 {
4571 if this.Field4[i] != that1.Field4[i] {
4572 if this.Field4[i] < that1.Field4[i] {
4573 return -1
4574 }
4575 return 1
4576 }
4577 }
4578 if len(this.Field5) != len(that1.Field5) {
4579 if len(this.Field5) < len(that1.Field5) {
4580 return -1
4581 }
4582 return 1
4583 }
4584 for i := range this.Field5 {
4585 if this.Field5[i] != that1.Field5[i] {
4586 if this.Field5[i] < that1.Field5[i] {
4587 return -1
4588 }
4589 return 1
4590 }
4591 }
4592 if len(this.Field6) != len(that1.Field6) {
4593 if len(this.Field6) < len(that1.Field6) {
4594 return -1
4595 }
4596 return 1
4597 }
4598 for i := range this.Field6 {
4599 if this.Field6[i] != that1.Field6[i] {
4600 if this.Field6[i] < that1.Field6[i] {
4601 return -1
4602 }
4603 return 1
4604 }
4605 }
4606 if len(this.Field7) != len(that1.Field7) {
4607 if len(this.Field7) < len(that1.Field7) {
4608 return -1
4609 }
4610 return 1
4611 }
4612 for i := range this.Field7 {
4613 if this.Field7[i] != that1.Field7[i] {
4614 if this.Field7[i] < that1.Field7[i] {
4615 return -1
4616 }
4617 return 1
4618 }
4619 }
4620 if len(this.Field8) != len(that1.Field8) {
4621 if len(this.Field8) < len(that1.Field8) {
4622 return -1
4623 }
4624 return 1
4625 }
4626 for i := range this.Field8 {
4627 if this.Field8[i] != that1.Field8[i] {
4628 if this.Field8[i] < that1.Field8[i] {
4629 return -1
4630 }
4631 return 1
4632 }
4633 }
4634 if len(this.Field9) != len(that1.Field9) {
4635 if len(this.Field9) < len(that1.Field9) {
4636 return -1
4637 }
4638 return 1
4639 }
4640 for i := range this.Field9 {
4641 if this.Field9[i] != that1.Field9[i] {
4642 if this.Field9[i] < that1.Field9[i] {
4643 return -1
4644 }
4645 return 1
4646 }
4647 }
4648 if len(this.Field10) != len(that1.Field10) {
4649 if len(this.Field10) < len(that1.Field10) {
4650 return -1
4651 }
4652 return 1
4653 }
4654 for i := range this.Field10 {
4655 if this.Field10[i] != that1.Field10[i] {
4656 if this.Field10[i] < that1.Field10[i] {
4657 return -1
4658 }
4659 return 1
4660 }
4661 }
4662 if len(this.Field11) != len(that1.Field11) {
4663 if len(this.Field11) < len(that1.Field11) {
4664 return -1
4665 }
4666 return 1
4667 }
4668 for i := range this.Field11 {
4669 if this.Field11[i] != that1.Field11[i] {
4670 if this.Field11[i] < that1.Field11[i] {
4671 return -1
4672 }
4673 return 1
4674 }
4675 }
4676 if len(this.Field12) != len(that1.Field12) {
4677 if len(this.Field12) < len(that1.Field12) {
4678 return -1
4679 }
4680 return 1
4681 }
4682 for i := range this.Field12 {
4683 if this.Field12[i] != that1.Field12[i] {
4684 if this.Field12[i] < that1.Field12[i] {
4685 return -1
4686 }
4687 return 1
4688 }
4689 }
4690 if len(this.Field13) != len(that1.Field13) {
4691 if len(this.Field13) < len(that1.Field13) {
4692 return -1
4693 }
4694 return 1
4695 }
4696 for i := range this.Field13 {
4697 if this.Field13[i] != that1.Field13[i] {
4698 if !this.Field13[i] {
4699 return -1
4700 }
4701 return 1
4702 }
4703 }
4704 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
4705 return c
4706 }
4707 return 0
4708 }
4709 func (this *NinRepPackedNative) Compare(that interface{}) int {
4710 if that == nil {
4711 if this == nil {
4712 return 0
4713 }
4714 return 1
4715 }
4716
4717 that1, ok := that.(*NinRepPackedNative)
4718 if !ok {
4719 that2, ok := that.(NinRepPackedNative)
4720 if ok {
4721 that1 = &that2
4722 } else {
4723 return 1
4724 }
4725 }
4726 if that1 == nil {
4727 if this == nil {
4728 return 0
4729 }
4730 return 1
4731 } else if this == nil {
4732 return -1
4733 }
4734 if len(this.Field1) != len(that1.Field1) {
4735 if len(this.Field1) < len(that1.Field1) {
4736 return -1
4737 }
4738 return 1
4739 }
4740 for i := range this.Field1 {
4741 if this.Field1[i] != that1.Field1[i] {
4742 if this.Field1[i] < that1.Field1[i] {
4743 return -1
4744 }
4745 return 1
4746 }
4747 }
4748 if len(this.Field2) != len(that1.Field2) {
4749 if len(this.Field2) < len(that1.Field2) {
4750 return -1
4751 }
4752 return 1
4753 }
4754 for i := range this.Field2 {
4755 if this.Field2[i] != that1.Field2[i] {
4756 if this.Field2[i] < that1.Field2[i] {
4757 return -1
4758 }
4759 return 1
4760 }
4761 }
4762 if len(this.Field3) != len(that1.Field3) {
4763 if len(this.Field3) < len(that1.Field3) {
4764 return -1
4765 }
4766 return 1
4767 }
4768 for i := range this.Field3 {
4769 if this.Field3[i] != that1.Field3[i] {
4770 if this.Field3[i] < that1.Field3[i] {
4771 return -1
4772 }
4773 return 1
4774 }
4775 }
4776 if len(this.Field4) != len(that1.Field4) {
4777 if len(this.Field4) < len(that1.Field4) {
4778 return -1
4779 }
4780 return 1
4781 }
4782 for i := range this.Field4 {
4783 if this.Field4[i] != that1.Field4[i] {
4784 if this.Field4[i] < that1.Field4[i] {
4785 return -1
4786 }
4787 return 1
4788 }
4789 }
4790 if len(this.Field5) != len(that1.Field5) {
4791 if len(this.Field5) < len(that1.Field5) {
4792 return -1
4793 }
4794 return 1
4795 }
4796 for i := range this.Field5 {
4797 if this.Field5[i] != that1.Field5[i] {
4798 if this.Field5[i] < that1.Field5[i] {
4799 return -1
4800 }
4801 return 1
4802 }
4803 }
4804 if len(this.Field6) != len(that1.Field6) {
4805 if len(this.Field6) < len(that1.Field6) {
4806 return -1
4807 }
4808 return 1
4809 }
4810 for i := range this.Field6 {
4811 if this.Field6[i] != that1.Field6[i] {
4812 if this.Field6[i] < that1.Field6[i] {
4813 return -1
4814 }
4815 return 1
4816 }
4817 }
4818 if len(this.Field7) != len(that1.Field7) {
4819 if len(this.Field7) < len(that1.Field7) {
4820 return -1
4821 }
4822 return 1
4823 }
4824 for i := range this.Field7 {
4825 if this.Field7[i] != that1.Field7[i] {
4826 if this.Field7[i] < that1.Field7[i] {
4827 return -1
4828 }
4829 return 1
4830 }
4831 }
4832 if len(this.Field8) != len(that1.Field8) {
4833 if len(this.Field8) < len(that1.Field8) {
4834 return -1
4835 }
4836 return 1
4837 }
4838 for i := range this.Field8 {
4839 if this.Field8[i] != that1.Field8[i] {
4840 if this.Field8[i] < that1.Field8[i] {
4841 return -1
4842 }
4843 return 1
4844 }
4845 }
4846 if len(this.Field9) != len(that1.Field9) {
4847 if len(this.Field9) < len(that1.Field9) {
4848 return -1
4849 }
4850 return 1
4851 }
4852 for i := range this.Field9 {
4853 if this.Field9[i] != that1.Field9[i] {
4854 if this.Field9[i] < that1.Field9[i] {
4855 return -1
4856 }
4857 return 1
4858 }
4859 }
4860 if len(this.Field10) != len(that1.Field10) {
4861 if len(this.Field10) < len(that1.Field10) {
4862 return -1
4863 }
4864 return 1
4865 }
4866 for i := range this.Field10 {
4867 if this.Field10[i] != that1.Field10[i] {
4868 if this.Field10[i] < that1.Field10[i] {
4869 return -1
4870 }
4871 return 1
4872 }
4873 }
4874 if len(this.Field11) != len(that1.Field11) {
4875 if len(this.Field11) < len(that1.Field11) {
4876 return -1
4877 }
4878 return 1
4879 }
4880 for i := range this.Field11 {
4881 if this.Field11[i] != that1.Field11[i] {
4882 if this.Field11[i] < that1.Field11[i] {
4883 return -1
4884 }
4885 return 1
4886 }
4887 }
4888 if len(this.Field12) != len(that1.Field12) {
4889 if len(this.Field12) < len(that1.Field12) {
4890 return -1
4891 }
4892 return 1
4893 }
4894 for i := range this.Field12 {
4895 if this.Field12[i] != that1.Field12[i] {
4896 if this.Field12[i] < that1.Field12[i] {
4897 return -1
4898 }
4899 return 1
4900 }
4901 }
4902 if len(this.Field13) != len(that1.Field13) {
4903 if len(this.Field13) < len(that1.Field13) {
4904 return -1
4905 }
4906 return 1
4907 }
4908 for i := range this.Field13 {
4909 if this.Field13[i] != that1.Field13[i] {
4910 if !this.Field13[i] {
4911 return -1
4912 }
4913 return 1
4914 }
4915 }
4916 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
4917 return c
4918 }
4919 return 0
4920 }
4921 func (this *NidOptStruct) Compare(that interface{}) int {
4922 if that == nil {
4923 if this == nil {
4924 return 0
4925 }
4926 return 1
4927 }
4928
4929 that1, ok := that.(*NidOptStruct)
4930 if !ok {
4931 that2, ok := that.(NidOptStruct)
4932 if ok {
4933 that1 = &that2
4934 } else {
4935 return 1
4936 }
4937 }
4938 if that1 == nil {
4939 if this == nil {
4940 return 0
4941 }
4942 return 1
4943 } else if this == nil {
4944 return -1
4945 }
4946 if this.Field1 != that1.Field1 {
4947 if this.Field1 < that1.Field1 {
4948 return -1
4949 }
4950 return 1
4951 }
4952 if this.Field2 != that1.Field2 {
4953 if this.Field2 < that1.Field2 {
4954 return -1
4955 }
4956 return 1
4957 }
4958 if c := this.Field3.Compare(&that1.Field3); c != 0 {
4959 return c
4960 }
4961 if c := this.Field4.Compare(&that1.Field4); c != 0 {
4962 return c
4963 }
4964 if this.Field6 != that1.Field6 {
4965 if this.Field6 < that1.Field6 {
4966 return -1
4967 }
4968 return 1
4969 }
4970 if this.Field7 != that1.Field7 {
4971 if this.Field7 < that1.Field7 {
4972 return -1
4973 }
4974 return 1
4975 }
4976 if c := this.Field8.Compare(&that1.Field8); c != 0 {
4977 return c
4978 }
4979 if this.Field13 != that1.Field13 {
4980 if !this.Field13 {
4981 return -1
4982 }
4983 return 1
4984 }
4985 if this.Field14 != that1.Field14 {
4986 if this.Field14 < that1.Field14 {
4987 return -1
4988 }
4989 return 1
4990 }
4991 if c := bytes.Compare(this.Field15, that1.Field15); c != 0 {
4992 return c
4993 }
4994 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
4995 return c
4996 }
4997 return 0
4998 }
4999 func (this *NinOptStruct) Compare(that interface{}) int {
5000 if that == nil {
5001 if this == nil {
5002 return 0
5003 }
5004 return 1
5005 }
5006
5007 that1, ok := that.(*NinOptStruct)
5008 if !ok {
5009 that2, ok := that.(NinOptStruct)
5010 if ok {
5011 that1 = &that2
5012 } else {
5013 return 1
5014 }
5015 }
5016 if that1 == nil {
5017 if this == nil {
5018 return 0
5019 }
5020 return 1
5021 } else if this == nil {
5022 return -1
5023 }
5024 if this.Field1 != nil && that1.Field1 != nil {
5025 if *this.Field1 != *that1.Field1 {
5026 if *this.Field1 < *that1.Field1 {
5027 return -1
5028 }
5029 return 1
5030 }
5031 } else if this.Field1 != nil {
5032 return 1
5033 } else if that1.Field1 != nil {
5034 return -1
5035 }
5036 if this.Field2 != nil && that1.Field2 != nil {
5037 if *this.Field2 != *that1.Field2 {
5038 if *this.Field2 < *that1.Field2 {
5039 return -1
5040 }
5041 return 1
5042 }
5043 } else if this.Field2 != nil {
5044 return 1
5045 } else if that1.Field2 != nil {
5046 return -1
5047 }
5048 if c := this.Field3.Compare(that1.Field3); c != 0 {
5049 return c
5050 }
5051 if c := this.Field4.Compare(that1.Field4); c != 0 {
5052 return c
5053 }
5054 if this.Field6 != nil && that1.Field6 != nil {
5055 if *this.Field6 != *that1.Field6 {
5056 if *this.Field6 < *that1.Field6 {
5057 return -1
5058 }
5059 return 1
5060 }
5061 } else if this.Field6 != nil {
5062 return 1
5063 } else if that1.Field6 != nil {
5064 return -1
5065 }
5066 if this.Field7 != nil && that1.Field7 != nil {
5067 if *this.Field7 != *that1.Field7 {
5068 if *this.Field7 < *that1.Field7 {
5069 return -1
5070 }
5071 return 1
5072 }
5073 } else if this.Field7 != nil {
5074 return 1
5075 } else if that1.Field7 != nil {
5076 return -1
5077 }
5078 if c := this.Field8.Compare(that1.Field8); c != 0 {
5079 return c
5080 }
5081 if this.Field13 != nil && that1.Field13 != nil {
5082 if *this.Field13 != *that1.Field13 {
5083 if !*this.Field13 {
5084 return -1
5085 }
5086 return 1
5087 }
5088 } else if this.Field13 != nil {
5089 return 1
5090 } else if that1.Field13 != nil {
5091 return -1
5092 }
5093 if this.Field14 != nil && that1.Field14 != nil {
5094 if *this.Field14 != *that1.Field14 {
5095 if *this.Field14 < *that1.Field14 {
5096 return -1
5097 }
5098 return 1
5099 }
5100 } else if this.Field14 != nil {
5101 return 1
5102 } else if that1.Field14 != nil {
5103 return -1
5104 }
5105 if c := bytes.Compare(this.Field15, that1.Field15); c != 0 {
5106 return c
5107 }
5108 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5109 return c
5110 }
5111 return 0
5112 }
5113 func (this *NidRepStruct) Compare(that interface{}) int {
5114 if that == nil {
5115 if this == nil {
5116 return 0
5117 }
5118 return 1
5119 }
5120
5121 that1, ok := that.(*NidRepStruct)
5122 if !ok {
5123 that2, ok := that.(NidRepStruct)
5124 if ok {
5125 that1 = &that2
5126 } else {
5127 return 1
5128 }
5129 }
5130 if that1 == nil {
5131 if this == nil {
5132 return 0
5133 }
5134 return 1
5135 } else if this == nil {
5136 return -1
5137 }
5138 if len(this.Field1) != len(that1.Field1) {
5139 if len(this.Field1) < len(that1.Field1) {
5140 return -1
5141 }
5142 return 1
5143 }
5144 for i := range this.Field1 {
5145 if this.Field1[i] != that1.Field1[i] {
5146 if this.Field1[i] < that1.Field1[i] {
5147 return -1
5148 }
5149 return 1
5150 }
5151 }
5152 if len(this.Field2) != len(that1.Field2) {
5153 if len(this.Field2) < len(that1.Field2) {
5154 return -1
5155 }
5156 return 1
5157 }
5158 for i := range this.Field2 {
5159 if this.Field2[i] != that1.Field2[i] {
5160 if this.Field2[i] < that1.Field2[i] {
5161 return -1
5162 }
5163 return 1
5164 }
5165 }
5166 if len(this.Field3) != len(that1.Field3) {
5167 if len(this.Field3) < len(that1.Field3) {
5168 return -1
5169 }
5170 return 1
5171 }
5172 for i := range this.Field3 {
5173 if c := this.Field3[i].Compare(&that1.Field3[i]); c != 0 {
5174 return c
5175 }
5176 }
5177 if len(this.Field4) != len(that1.Field4) {
5178 if len(this.Field4) < len(that1.Field4) {
5179 return -1
5180 }
5181 return 1
5182 }
5183 for i := range this.Field4 {
5184 if c := this.Field4[i].Compare(&that1.Field4[i]); c != 0 {
5185 return c
5186 }
5187 }
5188 if len(this.Field6) != len(that1.Field6) {
5189 if len(this.Field6) < len(that1.Field6) {
5190 return -1
5191 }
5192 return 1
5193 }
5194 for i := range this.Field6 {
5195 if this.Field6[i] != that1.Field6[i] {
5196 if this.Field6[i] < that1.Field6[i] {
5197 return -1
5198 }
5199 return 1
5200 }
5201 }
5202 if len(this.Field7) != len(that1.Field7) {
5203 if len(this.Field7) < len(that1.Field7) {
5204 return -1
5205 }
5206 return 1
5207 }
5208 for i := range this.Field7 {
5209 if this.Field7[i] != that1.Field7[i] {
5210 if this.Field7[i] < that1.Field7[i] {
5211 return -1
5212 }
5213 return 1
5214 }
5215 }
5216 if len(this.Field8) != len(that1.Field8) {
5217 if len(this.Field8) < len(that1.Field8) {
5218 return -1
5219 }
5220 return 1
5221 }
5222 for i := range this.Field8 {
5223 if c := this.Field8[i].Compare(&that1.Field8[i]); c != 0 {
5224 return c
5225 }
5226 }
5227 if len(this.Field13) != len(that1.Field13) {
5228 if len(this.Field13) < len(that1.Field13) {
5229 return -1
5230 }
5231 return 1
5232 }
5233 for i := range this.Field13 {
5234 if this.Field13[i] != that1.Field13[i] {
5235 if !this.Field13[i] {
5236 return -1
5237 }
5238 return 1
5239 }
5240 }
5241 if len(this.Field14) != len(that1.Field14) {
5242 if len(this.Field14) < len(that1.Field14) {
5243 return -1
5244 }
5245 return 1
5246 }
5247 for i := range this.Field14 {
5248 if this.Field14[i] != that1.Field14[i] {
5249 if this.Field14[i] < that1.Field14[i] {
5250 return -1
5251 }
5252 return 1
5253 }
5254 }
5255 if len(this.Field15) != len(that1.Field15) {
5256 if len(this.Field15) < len(that1.Field15) {
5257 return -1
5258 }
5259 return 1
5260 }
5261 for i := range this.Field15 {
5262 if c := bytes.Compare(this.Field15[i], that1.Field15[i]); c != 0 {
5263 return c
5264 }
5265 }
5266 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5267 return c
5268 }
5269 return 0
5270 }
5271 func (this *NinRepStruct) Compare(that interface{}) int {
5272 if that == nil {
5273 if this == nil {
5274 return 0
5275 }
5276 return 1
5277 }
5278
5279 that1, ok := that.(*NinRepStruct)
5280 if !ok {
5281 that2, ok := that.(NinRepStruct)
5282 if ok {
5283 that1 = &that2
5284 } else {
5285 return 1
5286 }
5287 }
5288 if that1 == nil {
5289 if this == nil {
5290 return 0
5291 }
5292 return 1
5293 } else if this == nil {
5294 return -1
5295 }
5296 if len(this.Field1) != len(that1.Field1) {
5297 if len(this.Field1) < len(that1.Field1) {
5298 return -1
5299 }
5300 return 1
5301 }
5302 for i := range this.Field1 {
5303 if this.Field1[i] != that1.Field1[i] {
5304 if this.Field1[i] < that1.Field1[i] {
5305 return -1
5306 }
5307 return 1
5308 }
5309 }
5310 if len(this.Field2) != len(that1.Field2) {
5311 if len(this.Field2) < len(that1.Field2) {
5312 return -1
5313 }
5314 return 1
5315 }
5316 for i := range this.Field2 {
5317 if this.Field2[i] != that1.Field2[i] {
5318 if this.Field2[i] < that1.Field2[i] {
5319 return -1
5320 }
5321 return 1
5322 }
5323 }
5324 if len(this.Field3) != len(that1.Field3) {
5325 if len(this.Field3) < len(that1.Field3) {
5326 return -1
5327 }
5328 return 1
5329 }
5330 for i := range this.Field3 {
5331 if c := this.Field3[i].Compare(that1.Field3[i]); c != 0 {
5332 return c
5333 }
5334 }
5335 if len(this.Field4) != len(that1.Field4) {
5336 if len(this.Field4) < len(that1.Field4) {
5337 return -1
5338 }
5339 return 1
5340 }
5341 for i := range this.Field4 {
5342 if c := this.Field4[i].Compare(that1.Field4[i]); c != 0 {
5343 return c
5344 }
5345 }
5346 if len(this.Field6) != len(that1.Field6) {
5347 if len(this.Field6) < len(that1.Field6) {
5348 return -1
5349 }
5350 return 1
5351 }
5352 for i := range this.Field6 {
5353 if this.Field6[i] != that1.Field6[i] {
5354 if this.Field6[i] < that1.Field6[i] {
5355 return -1
5356 }
5357 return 1
5358 }
5359 }
5360 if len(this.Field7) != len(that1.Field7) {
5361 if len(this.Field7) < len(that1.Field7) {
5362 return -1
5363 }
5364 return 1
5365 }
5366 for i := range this.Field7 {
5367 if this.Field7[i] != that1.Field7[i] {
5368 if this.Field7[i] < that1.Field7[i] {
5369 return -1
5370 }
5371 return 1
5372 }
5373 }
5374 if len(this.Field8) != len(that1.Field8) {
5375 if len(this.Field8) < len(that1.Field8) {
5376 return -1
5377 }
5378 return 1
5379 }
5380 for i := range this.Field8 {
5381 if c := this.Field8[i].Compare(that1.Field8[i]); c != 0 {
5382 return c
5383 }
5384 }
5385 if len(this.Field13) != len(that1.Field13) {
5386 if len(this.Field13) < len(that1.Field13) {
5387 return -1
5388 }
5389 return 1
5390 }
5391 for i := range this.Field13 {
5392 if this.Field13[i] != that1.Field13[i] {
5393 if !this.Field13[i] {
5394 return -1
5395 }
5396 return 1
5397 }
5398 }
5399 if len(this.Field14) != len(that1.Field14) {
5400 if len(this.Field14) < len(that1.Field14) {
5401 return -1
5402 }
5403 return 1
5404 }
5405 for i := range this.Field14 {
5406 if this.Field14[i] != that1.Field14[i] {
5407 if this.Field14[i] < that1.Field14[i] {
5408 return -1
5409 }
5410 return 1
5411 }
5412 }
5413 if len(this.Field15) != len(that1.Field15) {
5414 if len(this.Field15) < len(that1.Field15) {
5415 return -1
5416 }
5417 return 1
5418 }
5419 for i := range this.Field15 {
5420 if c := bytes.Compare(this.Field15[i], that1.Field15[i]); c != 0 {
5421 return c
5422 }
5423 }
5424 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5425 return c
5426 }
5427 return 0
5428 }
5429 func (this *NidEmbeddedStruct) Compare(that interface{}) int {
5430 if that == nil {
5431 if this == nil {
5432 return 0
5433 }
5434 return 1
5435 }
5436
5437 that1, ok := that.(*NidEmbeddedStruct)
5438 if !ok {
5439 that2, ok := that.(NidEmbeddedStruct)
5440 if ok {
5441 that1 = &that2
5442 } else {
5443 return 1
5444 }
5445 }
5446 if that1 == nil {
5447 if this == nil {
5448 return 0
5449 }
5450 return 1
5451 } else if this == nil {
5452 return -1
5453 }
5454 if c := this.NidOptNative.Compare(that1.NidOptNative); c != 0 {
5455 return c
5456 }
5457 if c := this.Field200.Compare(&that1.Field200); c != 0 {
5458 return c
5459 }
5460 if this.Field210 != that1.Field210 {
5461 if !this.Field210 {
5462 return -1
5463 }
5464 return 1
5465 }
5466 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5467 return c
5468 }
5469 return 0
5470 }
5471 func (this *NinEmbeddedStruct) Compare(that interface{}) int {
5472 if that == nil {
5473 if this == nil {
5474 return 0
5475 }
5476 return 1
5477 }
5478
5479 that1, ok := that.(*NinEmbeddedStruct)
5480 if !ok {
5481 that2, ok := that.(NinEmbeddedStruct)
5482 if ok {
5483 that1 = &that2
5484 } else {
5485 return 1
5486 }
5487 }
5488 if that1 == nil {
5489 if this == nil {
5490 return 0
5491 }
5492 return 1
5493 } else if this == nil {
5494 return -1
5495 }
5496 if c := this.NidOptNative.Compare(that1.NidOptNative); c != 0 {
5497 return c
5498 }
5499 if c := this.Field200.Compare(that1.Field200); c != 0 {
5500 return c
5501 }
5502 if this.Field210 != nil && that1.Field210 != nil {
5503 if *this.Field210 != *that1.Field210 {
5504 if !*this.Field210 {
5505 return -1
5506 }
5507 return 1
5508 }
5509 } else if this.Field210 != nil {
5510 return 1
5511 } else if that1.Field210 != nil {
5512 return -1
5513 }
5514 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5515 return c
5516 }
5517 return 0
5518 }
5519 func (this *NidNestedStruct) Compare(that interface{}) int {
5520 if that == nil {
5521 if this == nil {
5522 return 0
5523 }
5524 return 1
5525 }
5526
5527 that1, ok := that.(*NidNestedStruct)
5528 if !ok {
5529 that2, ok := that.(NidNestedStruct)
5530 if ok {
5531 that1 = &that2
5532 } else {
5533 return 1
5534 }
5535 }
5536 if that1 == nil {
5537 if this == nil {
5538 return 0
5539 }
5540 return 1
5541 } else if this == nil {
5542 return -1
5543 }
5544 if c := this.Field1.Compare(&that1.Field1); c != 0 {
5545 return c
5546 }
5547 if len(this.Field2) != len(that1.Field2) {
5548 if len(this.Field2) < len(that1.Field2) {
5549 return -1
5550 }
5551 return 1
5552 }
5553 for i := range this.Field2 {
5554 if c := this.Field2[i].Compare(&that1.Field2[i]); c != 0 {
5555 return c
5556 }
5557 }
5558 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5559 return c
5560 }
5561 return 0
5562 }
5563 func (this *NinNestedStruct) Compare(that interface{}) int {
5564 if that == nil {
5565 if this == nil {
5566 return 0
5567 }
5568 return 1
5569 }
5570
5571 that1, ok := that.(*NinNestedStruct)
5572 if !ok {
5573 that2, ok := that.(NinNestedStruct)
5574 if ok {
5575 that1 = &that2
5576 } else {
5577 return 1
5578 }
5579 }
5580 if that1 == nil {
5581 if this == nil {
5582 return 0
5583 }
5584 return 1
5585 } else if this == nil {
5586 return -1
5587 }
5588 if c := this.Field1.Compare(that1.Field1); c != 0 {
5589 return c
5590 }
5591 if len(this.Field2) != len(that1.Field2) {
5592 if len(this.Field2) < len(that1.Field2) {
5593 return -1
5594 }
5595 return 1
5596 }
5597 for i := range this.Field2 {
5598 if c := this.Field2[i].Compare(that1.Field2[i]); c != 0 {
5599 return c
5600 }
5601 }
5602 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5603 return c
5604 }
5605 return 0
5606 }
5607 func (this *NidOptCustom) Compare(that interface{}) int {
5608 if that == nil {
5609 if this == nil {
5610 return 0
5611 }
5612 return 1
5613 }
5614
5615 that1, ok := that.(*NidOptCustom)
5616 if !ok {
5617 that2, ok := that.(NidOptCustom)
5618 if ok {
5619 that1 = &that2
5620 } else {
5621 return 1
5622 }
5623 }
5624 if that1 == nil {
5625 if this == nil {
5626 return 0
5627 }
5628 return 1
5629 } else if this == nil {
5630 return -1
5631 }
5632 if c := this.Id.Compare(that1.Id); c != 0 {
5633 return c
5634 }
5635 if c := this.Value.Compare(that1.Value); c != 0 {
5636 return c
5637 }
5638 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5639 return c
5640 }
5641 return 0
5642 }
5643 func (this *CustomDash) Compare(that interface{}) int {
5644 if that == nil {
5645 if this == nil {
5646 return 0
5647 }
5648 return 1
5649 }
5650
5651 that1, ok := that.(*CustomDash)
5652 if !ok {
5653 that2, ok := that.(CustomDash)
5654 if ok {
5655 that1 = &that2
5656 } else {
5657 return 1
5658 }
5659 }
5660 if that1 == nil {
5661 if this == nil {
5662 return 0
5663 }
5664 return 1
5665 } else if this == nil {
5666 return -1
5667 }
5668 if that1.Value == nil {
5669 if this.Value != nil {
5670 return 1
5671 }
5672 } else if this.Value == nil {
5673 return -1
5674 } else if c := this.Value.Compare(*that1.Value); c != 0 {
5675 return c
5676 }
5677 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5678 return c
5679 }
5680 return 0
5681 }
5682 func (this *NinOptCustom) Compare(that interface{}) int {
5683 if that == nil {
5684 if this == nil {
5685 return 0
5686 }
5687 return 1
5688 }
5689
5690 that1, ok := that.(*NinOptCustom)
5691 if !ok {
5692 that2, ok := that.(NinOptCustom)
5693 if ok {
5694 that1 = &that2
5695 } else {
5696 return 1
5697 }
5698 }
5699 if that1 == nil {
5700 if this == nil {
5701 return 0
5702 }
5703 return 1
5704 } else if this == nil {
5705 return -1
5706 }
5707 if that1.Id == nil {
5708 if this.Id != nil {
5709 return 1
5710 }
5711 } else if this.Id == nil {
5712 return -1
5713 } else if c := this.Id.Compare(*that1.Id); c != 0 {
5714 return c
5715 }
5716 if that1.Value == nil {
5717 if this.Value != nil {
5718 return 1
5719 }
5720 } else if this.Value == nil {
5721 return -1
5722 } else if c := this.Value.Compare(*that1.Value); c != 0 {
5723 return c
5724 }
5725 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5726 return c
5727 }
5728 return 0
5729 }
5730 func (this *NidRepCustom) Compare(that interface{}) int {
5731 if that == nil {
5732 if this == nil {
5733 return 0
5734 }
5735 return 1
5736 }
5737
5738 that1, ok := that.(*NidRepCustom)
5739 if !ok {
5740 that2, ok := that.(NidRepCustom)
5741 if ok {
5742 that1 = &that2
5743 } else {
5744 return 1
5745 }
5746 }
5747 if that1 == nil {
5748 if this == nil {
5749 return 0
5750 }
5751 return 1
5752 } else if this == nil {
5753 return -1
5754 }
5755 if len(this.Id) != len(that1.Id) {
5756 if len(this.Id) < len(that1.Id) {
5757 return -1
5758 }
5759 return 1
5760 }
5761 for i := range this.Id {
5762 if c := this.Id[i].Compare(that1.Id[i]); c != 0 {
5763 return c
5764 }
5765 }
5766 if len(this.Value) != len(that1.Value) {
5767 if len(this.Value) < len(that1.Value) {
5768 return -1
5769 }
5770 return 1
5771 }
5772 for i := range this.Value {
5773 if c := this.Value[i].Compare(that1.Value[i]); c != 0 {
5774 return c
5775 }
5776 }
5777 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5778 return c
5779 }
5780 return 0
5781 }
5782 func (this *NinRepCustom) Compare(that interface{}) int {
5783 if that == nil {
5784 if this == nil {
5785 return 0
5786 }
5787 return 1
5788 }
5789
5790 that1, ok := that.(*NinRepCustom)
5791 if !ok {
5792 that2, ok := that.(NinRepCustom)
5793 if ok {
5794 that1 = &that2
5795 } else {
5796 return 1
5797 }
5798 }
5799 if that1 == nil {
5800 if this == nil {
5801 return 0
5802 }
5803 return 1
5804 } else if this == nil {
5805 return -1
5806 }
5807 if len(this.Id) != len(that1.Id) {
5808 if len(this.Id) < len(that1.Id) {
5809 return -1
5810 }
5811 return 1
5812 }
5813 for i := range this.Id {
5814 if c := this.Id[i].Compare(that1.Id[i]); c != 0 {
5815 return c
5816 }
5817 }
5818 if len(this.Value) != len(that1.Value) {
5819 if len(this.Value) < len(that1.Value) {
5820 return -1
5821 }
5822 return 1
5823 }
5824 for i := range this.Value {
5825 if c := this.Value[i].Compare(that1.Value[i]); c != 0 {
5826 return c
5827 }
5828 }
5829 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5830 return c
5831 }
5832 return 0
5833 }
5834 func (this *NinOptNativeUnion) Compare(that interface{}) int {
5835 if that == nil {
5836 if this == nil {
5837 return 0
5838 }
5839 return 1
5840 }
5841
5842 that1, ok := that.(*NinOptNativeUnion)
5843 if !ok {
5844 that2, ok := that.(NinOptNativeUnion)
5845 if ok {
5846 that1 = &that2
5847 } else {
5848 return 1
5849 }
5850 }
5851 if that1 == nil {
5852 if this == nil {
5853 return 0
5854 }
5855 return 1
5856 } else if this == nil {
5857 return -1
5858 }
5859 if this.Field1 != nil && that1.Field1 != nil {
5860 if *this.Field1 != *that1.Field1 {
5861 if *this.Field1 < *that1.Field1 {
5862 return -1
5863 }
5864 return 1
5865 }
5866 } else if this.Field1 != nil {
5867 return 1
5868 } else if that1.Field1 != nil {
5869 return -1
5870 }
5871 if this.Field2 != nil && that1.Field2 != nil {
5872 if *this.Field2 != *that1.Field2 {
5873 if *this.Field2 < *that1.Field2 {
5874 return -1
5875 }
5876 return 1
5877 }
5878 } else if this.Field2 != nil {
5879 return 1
5880 } else if that1.Field2 != nil {
5881 return -1
5882 }
5883 if this.Field3 != nil && that1.Field3 != nil {
5884 if *this.Field3 != *that1.Field3 {
5885 if *this.Field3 < *that1.Field3 {
5886 return -1
5887 }
5888 return 1
5889 }
5890 } else if this.Field3 != nil {
5891 return 1
5892 } else if that1.Field3 != nil {
5893 return -1
5894 }
5895 if this.Field4 != nil && that1.Field4 != nil {
5896 if *this.Field4 != *that1.Field4 {
5897 if *this.Field4 < *that1.Field4 {
5898 return -1
5899 }
5900 return 1
5901 }
5902 } else if this.Field4 != nil {
5903 return 1
5904 } else if that1.Field4 != nil {
5905 return -1
5906 }
5907 if this.Field5 != nil && that1.Field5 != nil {
5908 if *this.Field5 != *that1.Field5 {
5909 if *this.Field5 < *that1.Field5 {
5910 return -1
5911 }
5912 return 1
5913 }
5914 } else if this.Field5 != nil {
5915 return 1
5916 } else if that1.Field5 != nil {
5917 return -1
5918 }
5919 if this.Field6 != nil && that1.Field6 != nil {
5920 if *this.Field6 != *that1.Field6 {
5921 if *this.Field6 < *that1.Field6 {
5922 return -1
5923 }
5924 return 1
5925 }
5926 } else if this.Field6 != nil {
5927 return 1
5928 } else if that1.Field6 != nil {
5929 return -1
5930 }
5931 if this.Field13 != nil && that1.Field13 != nil {
5932 if *this.Field13 != *that1.Field13 {
5933 if !*this.Field13 {
5934 return -1
5935 }
5936 return 1
5937 }
5938 } else if this.Field13 != nil {
5939 return 1
5940 } else if that1.Field13 != nil {
5941 return -1
5942 }
5943 if this.Field14 != nil && that1.Field14 != nil {
5944 if *this.Field14 != *that1.Field14 {
5945 if *this.Field14 < *that1.Field14 {
5946 return -1
5947 }
5948 return 1
5949 }
5950 } else if this.Field14 != nil {
5951 return 1
5952 } else if that1.Field14 != nil {
5953 return -1
5954 }
5955 if c := bytes.Compare(this.Field15, that1.Field15); c != 0 {
5956 return c
5957 }
5958 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
5959 return c
5960 }
5961 return 0
5962 }
5963 func (this *NinOptStructUnion) Compare(that interface{}) int {
5964 if that == nil {
5965 if this == nil {
5966 return 0
5967 }
5968 return 1
5969 }
5970
5971 that1, ok := that.(*NinOptStructUnion)
5972 if !ok {
5973 that2, ok := that.(NinOptStructUnion)
5974 if ok {
5975 that1 = &that2
5976 } else {
5977 return 1
5978 }
5979 }
5980 if that1 == nil {
5981 if this == nil {
5982 return 0
5983 }
5984 return 1
5985 } else if this == nil {
5986 return -1
5987 }
5988 if this.Field1 != nil && that1.Field1 != nil {
5989 if *this.Field1 != *that1.Field1 {
5990 if *this.Field1 < *that1.Field1 {
5991 return -1
5992 }
5993 return 1
5994 }
5995 } else if this.Field1 != nil {
5996 return 1
5997 } else if that1.Field1 != nil {
5998 return -1
5999 }
6000 if this.Field2 != nil && that1.Field2 != nil {
6001 if *this.Field2 != *that1.Field2 {
6002 if *this.Field2 < *that1.Field2 {
6003 return -1
6004 }
6005 return 1
6006 }
6007 } else if this.Field2 != nil {
6008 return 1
6009 } else if that1.Field2 != nil {
6010 return -1
6011 }
6012 if c := this.Field3.Compare(that1.Field3); c != 0 {
6013 return c
6014 }
6015 if c := this.Field4.Compare(that1.Field4); c != 0 {
6016 return c
6017 }
6018 if this.Field6 != nil && that1.Field6 != nil {
6019 if *this.Field6 != *that1.Field6 {
6020 if *this.Field6 < *that1.Field6 {
6021 return -1
6022 }
6023 return 1
6024 }
6025 } else if this.Field6 != nil {
6026 return 1
6027 } else if that1.Field6 != nil {
6028 return -1
6029 }
6030 if this.Field7 != nil && that1.Field7 != nil {
6031 if *this.Field7 != *that1.Field7 {
6032 if *this.Field7 < *that1.Field7 {
6033 return -1
6034 }
6035 return 1
6036 }
6037 } else if this.Field7 != nil {
6038 return 1
6039 } else if that1.Field7 != nil {
6040 return -1
6041 }
6042 if this.Field13 != nil && that1.Field13 != nil {
6043 if *this.Field13 != *that1.Field13 {
6044 if !*this.Field13 {
6045 return -1
6046 }
6047 return 1
6048 }
6049 } else if this.Field13 != nil {
6050 return 1
6051 } else if that1.Field13 != nil {
6052 return -1
6053 }
6054 if this.Field14 != nil && that1.Field14 != nil {
6055 if *this.Field14 != *that1.Field14 {
6056 if *this.Field14 < *that1.Field14 {
6057 return -1
6058 }
6059 return 1
6060 }
6061 } else if this.Field14 != nil {
6062 return 1
6063 } else if that1.Field14 != nil {
6064 return -1
6065 }
6066 if c := bytes.Compare(this.Field15, that1.Field15); c != 0 {
6067 return c
6068 }
6069 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6070 return c
6071 }
6072 return 0
6073 }
6074 func (this *NinEmbeddedStructUnion) Compare(that interface{}) int {
6075 if that == nil {
6076 if this == nil {
6077 return 0
6078 }
6079 return 1
6080 }
6081
6082 that1, ok := that.(*NinEmbeddedStructUnion)
6083 if !ok {
6084 that2, ok := that.(NinEmbeddedStructUnion)
6085 if ok {
6086 that1 = &that2
6087 } else {
6088 return 1
6089 }
6090 }
6091 if that1 == nil {
6092 if this == nil {
6093 return 0
6094 }
6095 return 1
6096 } else if this == nil {
6097 return -1
6098 }
6099 if c := this.NidOptNative.Compare(that1.NidOptNative); c != 0 {
6100 return c
6101 }
6102 if c := this.Field200.Compare(that1.Field200); c != 0 {
6103 return c
6104 }
6105 if this.Field210 != nil && that1.Field210 != nil {
6106 if *this.Field210 != *that1.Field210 {
6107 if !*this.Field210 {
6108 return -1
6109 }
6110 return 1
6111 }
6112 } else if this.Field210 != nil {
6113 return 1
6114 } else if that1.Field210 != nil {
6115 return -1
6116 }
6117 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6118 return c
6119 }
6120 return 0
6121 }
6122 func (this *NinNestedStructUnion) Compare(that interface{}) int {
6123 if that == nil {
6124 if this == nil {
6125 return 0
6126 }
6127 return 1
6128 }
6129
6130 that1, ok := that.(*NinNestedStructUnion)
6131 if !ok {
6132 that2, ok := that.(NinNestedStructUnion)
6133 if ok {
6134 that1 = &that2
6135 } else {
6136 return 1
6137 }
6138 }
6139 if that1 == nil {
6140 if this == nil {
6141 return 0
6142 }
6143 return 1
6144 } else if this == nil {
6145 return -1
6146 }
6147 if c := this.Field1.Compare(that1.Field1); c != 0 {
6148 return c
6149 }
6150 if c := this.Field2.Compare(that1.Field2); c != 0 {
6151 return c
6152 }
6153 if c := this.Field3.Compare(that1.Field3); c != 0 {
6154 return c
6155 }
6156 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6157 return c
6158 }
6159 return 0
6160 }
6161 func (this *Tree) Compare(that interface{}) int {
6162 if that == nil {
6163 if this == nil {
6164 return 0
6165 }
6166 return 1
6167 }
6168
6169 that1, ok := that.(*Tree)
6170 if !ok {
6171 that2, ok := that.(Tree)
6172 if ok {
6173 that1 = &that2
6174 } else {
6175 return 1
6176 }
6177 }
6178 if that1 == nil {
6179 if this == nil {
6180 return 0
6181 }
6182 return 1
6183 } else if this == nil {
6184 return -1
6185 }
6186 if c := this.Or.Compare(that1.Or); c != 0 {
6187 return c
6188 }
6189 if c := this.And.Compare(that1.And); c != 0 {
6190 return c
6191 }
6192 if c := this.Leaf.Compare(that1.Leaf); c != 0 {
6193 return c
6194 }
6195 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6196 return c
6197 }
6198 return 0
6199 }
6200 func (this *OrBranch) Compare(that interface{}) int {
6201 if that == nil {
6202 if this == nil {
6203 return 0
6204 }
6205 return 1
6206 }
6207
6208 that1, ok := that.(*OrBranch)
6209 if !ok {
6210 that2, ok := that.(OrBranch)
6211 if ok {
6212 that1 = &that2
6213 } else {
6214 return 1
6215 }
6216 }
6217 if that1 == nil {
6218 if this == nil {
6219 return 0
6220 }
6221 return 1
6222 } else if this == nil {
6223 return -1
6224 }
6225 if c := this.Left.Compare(&that1.Left); c != 0 {
6226 return c
6227 }
6228 if c := this.Right.Compare(&that1.Right); c != 0 {
6229 return c
6230 }
6231 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6232 return c
6233 }
6234 return 0
6235 }
6236 func (this *AndBranch) Compare(that interface{}) int {
6237 if that == nil {
6238 if this == nil {
6239 return 0
6240 }
6241 return 1
6242 }
6243
6244 that1, ok := that.(*AndBranch)
6245 if !ok {
6246 that2, ok := that.(AndBranch)
6247 if ok {
6248 that1 = &that2
6249 } else {
6250 return 1
6251 }
6252 }
6253 if that1 == nil {
6254 if this == nil {
6255 return 0
6256 }
6257 return 1
6258 } else if this == nil {
6259 return -1
6260 }
6261 if c := this.Left.Compare(&that1.Left); c != 0 {
6262 return c
6263 }
6264 if c := this.Right.Compare(&that1.Right); c != 0 {
6265 return c
6266 }
6267 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6268 return c
6269 }
6270 return 0
6271 }
6272 func (this *Leaf) Compare(that interface{}) int {
6273 if that == nil {
6274 if this == nil {
6275 return 0
6276 }
6277 return 1
6278 }
6279
6280 that1, ok := that.(*Leaf)
6281 if !ok {
6282 that2, ok := that.(Leaf)
6283 if ok {
6284 that1 = &that2
6285 } else {
6286 return 1
6287 }
6288 }
6289 if that1 == nil {
6290 if this == nil {
6291 return 0
6292 }
6293 return 1
6294 } else if this == nil {
6295 return -1
6296 }
6297 if this.Value != that1.Value {
6298 if this.Value < that1.Value {
6299 return -1
6300 }
6301 return 1
6302 }
6303 if this.StrValue != that1.StrValue {
6304 if this.StrValue < that1.StrValue {
6305 return -1
6306 }
6307 return 1
6308 }
6309 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6310 return c
6311 }
6312 return 0
6313 }
6314 func (this *DeepTree) Compare(that interface{}) int {
6315 if that == nil {
6316 if this == nil {
6317 return 0
6318 }
6319 return 1
6320 }
6321
6322 that1, ok := that.(*DeepTree)
6323 if !ok {
6324 that2, ok := that.(DeepTree)
6325 if ok {
6326 that1 = &that2
6327 } else {
6328 return 1
6329 }
6330 }
6331 if that1 == nil {
6332 if this == nil {
6333 return 0
6334 }
6335 return 1
6336 } else if this == nil {
6337 return -1
6338 }
6339 if c := this.Down.Compare(that1.Down); c != 0 {
6340 return c
6341 }
6342 if c := this.And.Compare(that1.And); c != 0 {
6343 return c
6344 }
6345 if c := this.Leaf.Compare(that1.Leaf); c != 0 {
6346 return c
6347 }
6348 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6349 return c
6350 }
6351 return 0
6352 }
6353 func (this *ADeepBranch) Compare(that interface{}) int {
6354 if that == nil {
6355 if this == nil {
6356 return 0
6357 }
6358 return 1
6359 }
6360
6361 that1, ok := that.(*ADeepBranch)
6362 if !ok {
6363 that2, ok := that.(ADeepBranch)
6364 if ok {
6365 that1 = &that2
6366 } else {
6367 return 1
6368 }
6369 }
6370 if that1 == nil {
6371 if this == nil {
6372 return 0
6373 }
6374 return 1
6375 } else if this == nil {
6376 return -1
6377 }
6378 if c := this.Down.Compare(&that1.Down); c != 0 {
6379 return c
6380 }
6381 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6382 return c
6383 }
6384 return 0
6385 }
6386 func (this *AndDeepBranch) Compare(that interface{}) int {
6387 if that == nil {
6388 if this == nil {
6389 return 0
6390 }
6391 return 1
6392 }
6393
6394 that1, ok := that.(*AndDeepBranch)
6395 if !ok {
6396 that2, ok := that.(AndDeepBranch)
6397 if ok {
6398 that1 = &that2
6399 } else {
6400 return 1
6401 }
6402 }
6403 if that1 == nil {
6404 if this == nil {
6405 return 0
6406 }
6407 return 1
6408 } else if this == nil {
6409 return -1
6410 }
6411 if c := this.Left.Compare(&that1.Left); c != 0 {
6412 return c
6413 }
6414 if c := this.Right.Compare(&that1.Right); c != 0 {
6415 return c
6416 }
6417 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6418 return c
6419 }
6420 return 0
6421 }
6422 func (this *DeepLeaf) Compare(that interface{}) int {
6423 if that == nil {
6424 if this == nil {
6425 return 0
6426 }
6427 return 1
6428 }
6429
6430 that1, ok := that.(*DeepLeaf)
6431 if !ok {
6432 that2, ok := that.(DeepLeaf)
6433 if ok {
6434 that1 = &that2
6435 } else {
6436 return 1
6437 }
6438 }
6439 if that1 == nil {
6440 if this == nil {
6441 return 0
6442 }
6443 return 1
6444 } else if this == nil {
6445 return -1
6446 }
6447 if c := this.Tree.Compare(&that1.Tree); c != 0 {
6448 return c
6449 }
6450 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6451 return c
6452 }
6453 return 0
6454 }
6455 func (this *Nil) Compare(that interface{}) int {
6456 if that == nil {
6457 if this == nil {
6458 return 0
6459 }
6460 return 1
6461 }
6462
6463 that1, ok := that.(*Nil)
6464 if !ok {
6465 that2, ok := that.(Nil)
6466 if ok {
6467 that1 = &that2
6468 } else {
6469 return 1
6470 }
6471 }
6472 if that1 == nil {
6473 if this == nil {
6474 return 0
6475 }
6476 return 1
6477 } else if this == nil {
6478 return -1
6479 }
6480 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6481 return c
6482 }
6483 return 0
6484 }
6485 func (this *NidOptEnum) Compare(that interface{}) int {
6486 if that == nil {
6487 if this == nil {
6488 return 0
6489 }
6490 return 1
6491 }
6492
6493 that1, ok := that.(*NidOptEnum)
6494 if !ok {
6495 that2, ok := that.(NidOptEnum)
6496 if ok {
6497 that1 = &that2
6498 } else {
6499 return 1
6500 }
6501 }
6502 if that1 == nil {
6503 if this == nil {
6504 return 0
6505 }
6506 return 1
6507 } else if this == nil {
6508 return -1
6509 }
6510 if this.Field1 != that1.Field1 {
6511 if this.Field1 < that1.Field1 {
6512 return -1
6513 }
6514 return 1
6515 }
6516 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6517 return c
6518 }
6519 return 0
6520 }
6521 func (this *NinOptEnum) Compare(that interface{}) int {
6522 if that == nil {
6523 if this == nil {
6524 return 0
6525 }
6526 return 1
6527 }
6528
6529 that1, ok := that.(*NinOptEnum)
6530 if !ok {
6531 that2, ok := that.(NinOptEnum)
6532 if ok {
6533 that1 = &that2
6534 } else {
6535 return 1
6536 }
6537 }
6538 if that1 == nil {
6539 if this == nil {
6540 return 0
6541 }
6542 return 1
6543 } else if this == nil {
6544 return -1
6545 }
6546 if this.Field1 != nil && that1.Field1 != nil {
6547 if *this.Field1 != *that1.Field1 {
6548 if *this.Field1 < *that1.Field1 {
6549 return -1
6550 }
6551 return 1
6552 }
6553 } else if this.Field1 != nil {
6554 return 1
6555 } else if that1.Field1 != nil {
6556 return -1
6557 }
6558 if this.Field2 != nil && that1.Field2 != nil {
6559 if *this.Field2 != *that1.Field2 {
6560 if *this.Field2 < *that1.Field2 {
6561 return -1
6562 }
6563 return 1
6564 }
6565 } else if this.Field2 != nil {
6566 return 1
6567 } else if that1.Field2 != nil {
6568 return -1
6569 }
6570 if this.Field3 != nil && that1.Field3 != nil {
6571 if *this.Field3 != *that1.Field3 {
6572 if *this.Field3 < *that1.Field3 {
6573 return -1
6574 }
6575 return 1
6576 }
6577 } else if this.Field3 != nil {
6578 return 1
6579 } else if that1.Field3 != nil {
6580 return -1
6581 }
6582 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6583 return c
6584 }
6585 return 0
6586 }
6587 func (this *NidRepEnum) Compare(that interface{}) int {
6588 if that == nil {
6589 if this == nil {
6590 return 0
6591 }
6592 return 1
6593 }
6594
6595 that1, ok := that.(*NidRepEnum)
6596 if !ok {
6597 that2, ok := that.(NidRepEnum)
6598 if ok {
6599 that1 = &that2
6600 } else {
6601 return 1
6602 }
6603 }
6604 if that1 == nil {
6605 if this == nil {
6606 return 0
6607 }
6608 return 1
6609 } else if this == nil {
6610 return -1
6611 }
6612 if len(this.Field1) != len(that1.Field1) {
6613 if len(this.Field1) < len(that1.Field1) {
6614 return -1
6615 }
6616 return 1
6617 }
6618 for i := range this.Field1 {
6619 if this.Field1[i] != that1.Field1[i] {
6620 if this.Field1[i] < that1.Field1[i] {
6621 return -1
6622 }
6623 return 1
6624 }
6625 }
6626 if len(this.Field2) != len(that1.Field2) {
6627 if len(this.Field2) < len(that1.Field2) {
6628 return -1
6629 }
6630 return 1
6631 }
6632 for i := range this.Field2 {
6633 if this.Field2[i] != that1.Field2[i] {
6634 if this.Field2[i] < that1.Field2[i] {
6635 return -1
6636 }
6637 return 1
6638 }
6639 }
6640 if len(this.Field3) != len(that1.Field3) {
6641 if len(this.Field3) < len(that1.Field3) {
6642 return -1
6643 }
6644 return 1
6645 }
6646 for i := range this.Field3 {
6647 if this.Field3[i] != that1.Field3[i] {
6648 if this.Field3[i] < that1.Field3[i] {
6649 return -1
6650 }
6651 return 1
6652 }
6653 }
6654 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6655 return c
6656 }
6657 return 0
6658 }
6659 func (this *NinRepEnum) Compare(that interface{}) int {
6660 if that == nil {
6661 if this == nil {
6662 return 0
6663 }
6664 return 1
6665 }
6666
6667 that1, ok := that.(*NinRepEnum)
6668 if !ok {
6669 that2, ok := that.(NinRepEnum)
6670 if ok {
6671 that1 = &that2
6672 } else {
6673 return 1
6674 }
6675 }
6676 if that1 == nil {
6677 if this == nil {
6678 return 0
6679 }
6680 return 1
6681 } else if this == nil {
6682 return -1
6683 }
6684 if len(this.Field1) != len(that1.Field1) {
6685 if len(this.Field1) < len(that1.Field1) {
6686 return -1
6687 }
6688 return 1
6689 }
6690 for i := range this.Field1 {
6691 if this.Field1[i] != that1.Field1[i] {
6692 if this.Field1[i] < that1.Field1[i] {
6693 return -1
6694 }
6695 return 1
6696 }
6697 }
6698 if len(this.Field2) != len(that1.Field2) {
6699 if len(this.Field2) < len(that1.Field2) {
6700 return -1
6701 }
6702 return 1
6703 }
6704 for i := range this.Field2 {
6705 if this.Field2[i] != that1.Field2[i] {
6706 if this.Field2[i] < that1.Field2[i] {
6707 return -1
6708 }
6709 return 1
6710 }
6711 }
6712 if len(this.Field3) != len(that1.Field3) {
6713 if len(this.Field3) < len(that1.Field3) {
6714 return -1
6715 }
6716 return 1
6717 }
6718 for i := range this.Field3 {
6719 if this.Field3[i] != that1.Field3[i] {
6720 if this.Field3[i] < that1.Field3[i] {
6721 return -1
6722 }
6723 return 1
6724 }
6725 }
6726 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6727 return c
6728 }
6729 return 0
6730 }
6731 func (this *NinOptEnumDefault) Compare(that interface{}) int {
6732 if that == nil {
6733 if this == nil {
6734 return 0
6735 }
6736 return 1
6737 }
6738
6739 that1, ok := that.(*NinOptEnumDefault)
6740 if !ok {
6741 that2, ok := that.(NinOptEnumDefault)
6742 if ok {
6743 that1 = &that2
6744 } else {
6745 return 1
6746 }
6747 }
6748 if that1 == nil {
6749 if this == nil {
6750 return 0
6751 }
6752 return 1
6753 } else if this == nil {
6754 return -1
6755 }
6756 if this.Field1 != nil && that1.Field1 != nil {
6757 if *this.Field1 != *that1.Field1 {
6758 if *this.Field1 < *that1.Field1 {
6759 return -1
6760 }
6761 return 1
6762 }
6763 } else if this.Field1 != nil {
6764 return 1
6765 } else if that1.Field1 != nil {
6766 return -1
6767 }
6768 if this.Field2 != nil && that1.Field2 != nil {
6769 if *this.Field2 != *that1.Field2 {
6770 if *this.Field2 < *that1.Field2 {
6771 return -1
6772 }
6773 return 1
6774 }
6775 } else if this.Field2 != nil {
6776 return 1
6777 } else if that1.Field2 != nil {
6778 return -1
6779 }
6780 if this.Field3 != nil && that1.Field3 != nil {
6781 if *this.Field3 != *that1.Field3 {
6782 if *this.Field3 < *that1.Field3 {
6783 return -1
6784 }
6785 return 1
6786 }
6787 } else if this.Field3 != nil {
6788 return 1
6789 } else if that1.Field3 != nil {
6790 return -1
6791 }
6792 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6793 return c
6794 }
6795 return 0
6796 }
6797 func (this *AnotherNinOptEnum) Compare(that interface{}) int {
6798 if that == nil {
6799 if this == nil {
6800 return 0
6801 }
6802 return 1
6803 }
6804
6805 that1, ok := that.(*AnotherNinOptEnum)
6806 if !ok {
6807 that2, ok := that.(AnotherNinOptEnum)
6808 if ok {
6809 that1 = &that2
6810 } else {
6811 return 1
6812 }
6813 }
6814 if that1 == nil {
6815 if this == nil {
6816 return 0
6817 }
6818 return 1
6819 } else if this == nil {
6820 return -1
6821 }
6822 if this.Field1 != nil && that1.Field1 != nil {
6823 if *this.Field1 != *that1.Field1 {
6824 if *this.Field1 < *that1.Field1 {
6825 return -1
6826 }
6827 return 1
6828 }
6829 } else if this.Field1 != nil {
6830 return 1
6831 } else if that1.Field1 != nil {
6832 return -1
6833 }
6834 if this.Field2 != nil && that1.Field2 != nil {
6835 if *this.Field2 != *that1.Field2 {
6836 if *this.Field2 < *that1.Field2 {
6837 return -1
6838 }
6839 return 1
6840 }
6841 } else if this.Field2 != nil {
6842 return 1
6843 } else if that1.Field2 != nil {
6844 return -1
6845 }
6846 if this.Field3 != nil && that1.Field3 != nil {
6847 if *this.Field3 != *that1.Field3 {
6848 if *this.Field3 < *that1.Field3 {
6849 return -1
6850 }
6851 return 1
6852 }
6853 } else if this.Field3 != nil {
6854 return 1
6855 } else if that1.Field3 != nil {
6856 return -1
6857 }
6858 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6859 return c
6860 }
6861 return 0
6862 }
6863 func (this *AnotherNinOptEnumDefault) Compare(that interface{}) int {
6864 if that == nil {
6865 if this == nil {
6866 return 0
6867 }
6868 return 1
6869 }
6870
6871 that1, ok := that.(*AnotherNinOptEnumDefault)
6872 if !ok {
6873 that2, ok := that.(AnotherNinOptEnumDefault)
6874 if ok {
6875 that1 = &that2
6876 } else {
6877 return 1
6878 }
6879 }
6880 if that1 == nil {
6881 if this == nil {
6882 return 0
6883 }
6884 return 1
6885 } else if this == nil {
6886 return -1
6887 }
6888 if this.Field1 != nil && that1.Field1 != nil {
6889 if *this.Field1 != *that1.Field1 {
6890 if *this.Field1 < *that1.Field1 {
6891 return -1
6892 }
6893 return 1
6894 }
6895 } else if this.Field1 != nil {
6896 return 1
6897 } else if that1.Field1 != nil {
6898 return -1
6899 }
6900 if this.Field2 != nil && that1.Field2 != nil {
6901 if *this.Field2 != *that1.Field2 {
6902 if *this.Field2 < *that1.Field2 {
6903 return -1
6904 }
6905 return 1
6906 }
6907 } else if this.Field2 != nil {
6908 return 1
6909 } else if that1.Field2 != nil {
6910 return -1
6911 }
6912 if this.Field3 != nil && that1.Field3 != nil {
6913 if *this.Field3 != *that1.Field3 {
6914 if *this.Field3 < *that1.Field3 {
6915 return -1
6916 }
6917 return 1
6918 }
6919 } else if this.Field3 != nil {
6920 return 1
6921 } else if that1.Field3 != nil {
6922 return -1
6923 }
6924 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6925 return c
6926 }
6927 return 0
6928 }
6929 func (this *Timer) Compare(that interface{}) int {
6930 if that == nil {
6931 if this == nil {
6932 return 0
6933 }
6934 return 1
6935 }
6936
6937 that1, ok := that.(*Timer)
6938 if !ok {
6939 that2, ok := that.(Timer)
6940 if ok {
6941 that1 = &that2
6942 } else {
6943 return 1
6944 }
6945 }
6946 if that1 == nil {
6947 if this == nil {
6948 return 0
6949 }
6950 return 1
6951 } else if this == nil {
6952 return -1
6953 }
6954 if this.Time1 != that1.Time1 {
6955 if this.Time1 < that1.Time1 {
6956 return -1
6957 }
6958 return 1
6959 }
6960 if this.Time2 != that1.Time2 {
6961 if this.Time2 < that1.Time2 {
6962 return -1
6963 }
6964 return 1
6965 }
6966 if c := bytes.Compare(this.Data, that1.Data); c != 0 {
6967 return c
6968 }
6969 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
6970 return c
6971 }
6972 return 0
6973 }
6974 func (this *MyExtendable) Compare(that interface{}) int {
6975 if that == nil {
6976 if this == nil {
6977 return 0
6978 }
6979 return 1
6980 }
6981
6982 that1, ok := that.(*MyExtendable)
6983 if !ok {
6984 that2, ok := that.(MyExtendable)
6985 if ok {
6986 that1 = &that2
6987 } else {
6988 return 1
6989 }
6990 }
6991 if that1 == nil {
6992 if this == nil {
6993 return 0
6994 }
6995 return 1
6996 } else if this == nil {
6997 return -1
6998 }
6999 if this.Field1 != nil && that1.Field1 != nil {
7000 if *this.Field1 != *that1.Field1 {
7001 if *this.Field1 < *that1.Field1 {
7002 return -1
7003 }
7004 return 1
7005 }
7006 } else if this.Field1 != nil {
7007 return 1
7008 } else if that1.Field1 != nil {
7009 return -1
7010 }
7011 thismap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(this)
7012 thatmap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(that1)
7013 extkeys := make([]int32, 0, len(thismap)+len(thatmap))
7014 for k := range thismap {
7015 extkeys = append(extkeys, k)
7016 }
7017 for k := range thatmap {
7018 if _, ok := thismap[k]; !ok {
7019 extkeys = append(extkeys, k)
7020 }
7021 }
7022 github_com_gogo_protobuf_sortkeys.Int32s(extkeys)
7023 for _, k := range extkeys {
7024 if v, ok := thismap[k]; ok {
7025 if v2, ok := thatmap[k]; ok {
7026 if c := v.Compare(&v2); c != 0 {
7027 return c
7028 }
7029 } else {
7030 return 1
7031 }
7032 } else {
7033 return -1
7034 }
7035 }
7036 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
7037 return c
7038 }
7039 return 0
7040 }
7041 func (this *OtherExtenable) Compare(that interface{}) int {
7042 if that == nil {
7043 if this == nil {
7044 return 0
7045 }
7046 return 1
7047 }
7048
7049 that1, ok := that.(*OtherExtenable)
7050 if !ok {
7051 that2, ok := that.(OtherExtenable)
7052 if ok {
7053 that1 = &that2
7054 } else {
7055 return 1
7056 }
7057 }
7058 if that1 == nil {
7059 if this == nil {
7060 return 0
7061 }
7062 return 1
7063 } else if this == nil {
7064 return -1
7065 }
7066 if this.Field2 != nil && that1.Field2 != nil {
7067 if *this.Field2 != *that1.Field2 {
7068 if *this.Field2 < *that1.Field2 {
7069 return -1
7070 }
7071 return 1
7072 }
7073 } else if this.Field2 != nil {
7074 return 1
7075 } else if that1.Field2 != nil {
7076 return -1
7077 }
7078 if this.Field13 != nil && that1.Field13 != nil {
7079 if *this.Field13 != *that1.Field13 {
7080 if *this.Field13 < *that1.Field13 {
7081 return -1
7082 }
7083 return 1
7084 }
7085 } else if this.Field13 != nil {
7086 return 1
7087 } else if that1.Field13 != nil {
7088 return -1
7089 }
7090 if c := this.M.Compare(that1.M); c != 0 {
7091 return c
7092 }
7093 thismap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(this)
7094 thatmap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(that1)
7095 extkeys := make([]int32, 0, len(thismap)+len(thatmap))
7096 for k := range thismap {
7097 extkeys = append(extkeys, k)
7098 }
7099 for k := range thatmap {
7100 if _, ok := thismap[k]; !ok {
7101 extkeys = append(extkeys, k)
7102 }
7103 }
7104 github_com_gogo_protobuf_sortkeys.Int32s(extkeys)
7105 for _, k := range extkeys {
7106 if v, ok := thismap[k]; ok {
7107 if v2, ok := thatmap[k]; ok {
7108 if c := v.Compare(&v2); c != 0 {
7109 return c
7110 }
7111 } else {
7112 return 1
7113 }
7114 } else {
7115 return -1
7116 }
7117 }
7118 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
7119 return c
7120 }
7121 return 0
7122 }
7123 func (this *NestedDefinition) Compare(that interface{}) int {
7124 if that == nil {
7125 if this == nil {
7126 return 0
7127 }
7128 return 1
7129 }
7130
7131 that1, ok := that.(*NestedDefinition)
7132 if !ok {
7133 that2, ok := that.(NestedDefinition)
7134 if ok {
7135 that1 = &that2
7136 } else {
7137 return 1
7138 }
7139 }
7140 if that1 == nil {
7141 if this == nil {
7142 return 0
7143 }
7144 return 1
7145 } else if this == nil {
7146 return -1
7147 }
7148 if this.Field1 != nil && that1.Field1 != nil {
7149 if *this.Field1 != *that1.Field1 {
7150 if *this.Field1 < *that1.Field1 {
7151 return -1
7152 }
7153 return 1
7154 }
7155 } else if this.Field1 != nil {
7156 return 1
7157 } else if that1.Field1 != nil {
7158 return -1
7159 }
7160 if this.EnumField != nil && that1.EnumField != nil {
7161 if *this.EnumField != *that1.EnumField {
7162 if *this.EnumField < *that1.EnumField {
7163 return -1
7164 }
7165 return 1
7166 }
7167 } else if this.EnumField != nil {
7168 return 1
7169 } else if that1.EnumField != nil {
7170 return -1
7171 }
7172 if c := this.NNM.Compare(that1.NNM); c != 0 {
7173 return c
7174 }
7175 if c := this.NM.Compare(that1.NM); c != 0 {
7176 return c
7177 }
7178 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
7179 return c
7180 }
7181 return 0
7182 }
7183 func (this *NestedDefinition_NestedMessage) Compare(that interface{}) int {
7184 if that == nil {
7185 if this == nil {
7186 return 0
7187 }
7188 return 1
7189 }
7190
7191 that1, ok := that.(*NestedDefinition_NestedMessage)
7192 if !ok {
7193 that2, ok := that.(NestedDefinition_NestedMessage)
7194 if ok {
7195 that1 = &that2
7196 } else {
7197 return 1
7198 }
7199 }
7200 if that1 == nil {
7201 if this == nil {
7202 return 0
7203 }
7204 return 1
7205 } else if this == nil {
7206 return -1
7207 }
7208 if this.NestedField1 != nil && that1.NestedField1 != nil {
7209 if *this.NestedField1 != *that1.NestedField1 {
7210 if *this.NestedField1 < *that1.NestedField1 {
7211 return -1
7212 }
7213 return 1
7214 }
7215 } else if this.NestedField1 != nil {
7216 return 1
7217 } else if that1.NestedField1 != nil {
7218 return -1
7219 }
7220 if c := this.NNM.Compare(that1.NNM); c != 0 {
7221 return c
7222 }
7223 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
7224 return c
7225 }
7226 return 0
7227 }
7228 func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Compare(that interface{}) int {
7229 if that == nil {
7230 if this == nil {
7231 return 0
7232 }
7233 return 1
7234 }
7235
7236 that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg)
7237 if !ok {
7238 that2, ok := that.(NestedDefinition_NestedMessage_NestedNestedMsg)
7239 if ok {
7240 that1 = &that2
7241 } else {
7242 return 1
7243 }
7244 }
7245 if that1 == nil {
7246 if this == nil {
7247 return 0
7248 }
7249 return 1
7250 } else if this == nil {
7251 return -1
7252 }
7253 if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil {
7254 if *this.NestedNestedField1 != *that1.NestedNestedField1 {
7255 if *this.NestedNestedField1 < *that1.NestedNestedField1 {
7256 return -1
7257 }
7258 return 1
7259 }
7260 } else if this.NestedNestedField1 != nil {
7261 return 1
7262 } else if that1.NestedNestedField1 != nil {
7263 return -1
7264 }
7265 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
7266 return c
7267 }
7268 return 0
7269 }
7270 func (this *NestedScope) Compare(that interface{}) int {
7271 if that == nil {
7272 if this == nil {
7273 return 0
7274 }
7275 return 1
7276 }
7277
7278 that1, ok := that.(*NestedScope)
7279 if !ok {
7280 that2, ok := that.(NestedScope)
7281 if ok {
7282 that1 = &that2
7283 } else {
7284 return 1
7285 }
7286 }
7287 if that1 == nil {
7288 if this == nil {
7289 return 0
7290 }
7291 return 1
7292 } else if this == nil {
7293 return -1
7294 }
7295 if c := this.A.Compare(that1.A); c != 0 {
7296 return c
7297 }
7298 if this.B != nil && that1.B != nil {
7299 if *this.B != *that1.B {
7300 if *this.B < *that1.B {
7301 return -1
7302 }
7303 return 1
7304 }
7305 } else if this.B != nil {
7306 return 1
7307 } else if that1.B != nil {
7308 return -1
7309 }
7310 if c := this.C.Compare(that1.C); c != 0 {
7311 return c
7312 }
7313 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
7314 return c
7315 }
7316 return 0
7317 }
7318 func (this *NinOptNativeDefault) Compare(that interface{}) int {
7319 if that == nil {
7320 if this == nil {
7321 return 0
7322 }
7323 return 1
7324 }
7325
7326 that1, ok := that.(*NinOptNativeDefault)
7327 if !ok {
7328 that2, ok := that.(NinOptNativeDefault)
7329 if ok {
7330 that1 = &that2
7331 } else {
7332 return 1
7333 }
7334 }
7335 if that1 == nil {
7336 if this == nil {
7337 return 0
7338 }
7339 return 1
7340 } else if this == nil {
7341 return -1
7342 }
7343 if this.Field1 != nil && that1.Field1 != nil {
7344 if *this.Field1 != *that1.Field1 {
7345 if *this.Field1 < *that1.Field1 {
7346 return -1
7347 }
7348 return 1
7349 }
7350 } else if this.Field1 != nil {
7351 return 1
7352 } else if that1.Field1 != nil {
7353 return -1
7354 }
7355 if this.Field2 != nil && that1.Field2 != nil {
7356 if *this.Field2 != *that1.Field2 {
7357 if *this.Field2 < *that1.Field2 {
7358 return -1
7359 }
7360 return 1
7361 }
7362 } else if this.Field2 != nil {
7363 return 1
7364 } else if that1.Field2 != nil {
7365 return -1
7366 }
7367 if this.Field3 != nil && that1.Field3 != nil {
7368 if *this.Field3 != *that1.Field3 {
7369 if *this.Field3 < *that1.Field3 {
7370 return -1
7371 }
7372 return 1
7373 }
7374 } else if this.Field3 != nil {
7375 return 1
7376 } else if that1.Field3 != nil {
7377 return -1
7378 }
7379 if this.Field4 != nil && that1.Field4 != nil {
7380 if *this.Field4 != *that1.Field4 {
7381 if *this.Field4 < *that1.Field4 {
7382 return -1
7383 }
7384 return 1
7385 }
7386 } else if this.Field4 != nil {
7387 return 1
7388 } else if that1.Field4 != nil {
7389 return -1
7390 }
7391 if this.Field5 != nil && that1.Field5 != nil {
7392 if *this.Field5 != *that1.Field5 {
7393 if *this.Field5 < *that1.Field5 {
7394 return -1
7395 }
7396 return 1
7397 }
7398 } else if this.Field5 != nil {
7399 return 1
7400 } else if that1.Field5 != nil {
7401 return -1
7402 }
7403 if this.Field6 != nil && that1.Field6 != nil {
7404 if *this.Field6 != *that1.Field6 {
7405 if *this.Field6 < *that1.Field6 {
7406 return -1
7407 }
7408 return 1
7409 }
7410 } else if this.Field6 != nil {
7411 return 1
7412 } else if that1.Field6 != nil {
7413 return -1
7414 }
7415 if this.Field7 != nil && that1.Field7 != nil {
7416 if *this.Field7 != *that1.Field7 {
7417 if *this.Field7 < *that1.Field7 {
7418 return -1
7419 }
7420 return 1
7421 }
7422 } else if this.Field7 != nil {
7423 return 1
7424 } else if that1.Field7 != nil {
7425 return -1
7426 }
7427 if this.Field8 != nil && that1.Field8 != nil {
7428 if *this.Field8 != *that1.Field8 {
7429 if *this.Field8 < *that1.Field8 {
7430 return -1
7431 }
7432 return 1
7433 }
7434 } else if this.Field8 != nil {
7435 return 1
7436 } else if that1.Field8 != nil {
7437 return -1
7438 }
7439 if this.Field9 != nil && that1.Field9 != nil {
7440 if *this.Field9 != *that1.Field9 {
7441 if *this.Field9 < *that1.Field9 {
7442 return -1
7443 }
7444 return 1
7445 }
7446 } else if this.Field9 != nil {
7447 return 1
7448 } else if that1.Field9 != nil {
7449 return -1
7450 }
7451 if this.Field10 != nil && that1.Field10 != nil {
7452 if *this.Field10 != *that1.Field10 {
7453 if *this.Field10 < *that1.Field10 {
7454 return -1
7455 }
7456 return 1
7457 }
7458 } else if this.Field10 != nil {
7459 return 1
7460 } else if that1.Field10 != nil {
7461 return -1
7462 }
7463 if this.Field11 != nil && that1.Field11 != nil {
7464 if *this.Field11 != *that1.Field11 {
7465 if *this.Field11 < *that1.Field11 {
7466 return -1
7467 }
7468 return 1
7469 }
7470 } else if this.Field11 != nil {
7471 return 1
7472 } else if that1.Field11 != nil {
7473 return -1
7474 }
7475 if this.Field12 != nil && that1.Field12 != nil {
7476 if *this.Field12 != *that1.Field12 {
7477 if *this.Field12 < *that1.Field12 {
7478 return -1
7479 }
7480 return 1
7481 }
7482 } else if this.Field12 != nil {
7483 return 1
7484 } else if that1.Field12 != nil {
7485 return -1
7486 }
7487 if this.Field13 != nil && that1.Field13 != nil {
7488 if *this.Field13 != *that1.Field13 {
7489 if !*this.Field13 {
7490 return -1
7491 }
7492 return 1
7493 }
7494 } else if this.Field13 != nil {
7495 return 1
7496 } else if that1.Field13 != nil {
7497 return -1
7498 }
7499 if this.Field14 != nil && that1.Field14 != nil {
7500 if *this.Field14 != *that1.Field14 {
7501 if *this.Field14 < *that1.Field14 {
7502 return -1
7503 }
7504 return 1
7505 }
7506 } else if this.Field14 != nil {
7507 return 1
7508 } else if that1.Field14 != nil {
7509 return -1
7510 }
7511 if c := bytes.Compare(this.Field15, that1.Field15); c != 0 {
7512 return c
7513 }
7514 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
7515 return c
7516 }
7517 return 0
7518 }
7519 func (this *CustomContainer) Compare(that interface{}) int {
7520 if that == nil {
7521 if this == nil {
7522 return 0
7523 }
7524 return 1
7525 }
7526
7527 that1, ok := that.(*CustomContainer)
7528 if !ok {
7529 that2, ok := that.(CustomContainer)
7530 if ok {
7531 that1 = &that2
7532 } else {
7533 return 1
7534 }
7535 }
7536 if that1 == nil {
7537 if this == nil {
7538 return 0
7539 }
7540 return 1
7541 } else if this == nil {
7542 return -1
7543 }
7544 if c := this.CustomStruct.Compare(&that1.CustomStruct); c != 0 {
7545 return c
7546 }
7547 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
7548 return c
7549 }
7550 return 0
7551 }
7552 func (this *CustomNameNidOptNative) Compare(that interface{}) int {
7553 if that == nil {
7554 if this == nil {
7555 return 0
7556 }
7557 return 1
7558 }
7559
7560 that1, ok := that.(*CustomNameNidOptNative)
7561 if !ok {
7562 that2, ok := that.(CustomNameNidOptNative)
7563 if ok {
7564 that1 = &that2
7565 } else {
7566 return 1
7567 }
7568 }
7569 if that1 == nil {
7570 if this == nil {
7571 return 0
7572 }
7573 return 1
7574 } else if this == nil {
7575 return -1
7576 }
7577 if this.FieldA != that1.FieldA {
7578 if this.FieldA < that1.FieldA {
7579 return -1
7580 }
7581 return 1
7582 }
7583 if this.FieldB != that1.FieldB {
7584 if this.FieldB < that1.FieldB {
7585 return -1
7586 }
7587 return 1
7588 }
7589 if this.FieldC != that1.FieldC {
7590 if this.FieldC < that1.FieldC {
7591 return -1
7592 }
7593 return 1
7594 }
7595 if this.FieldD != that1.FieldD {
7596 if this.FieldD < that1.FieldD {
7597 return -1
7598 }
7599 return 1
7600 }
7601 if this.FieldE != that1.FieldE {
7602 if this.FieldE < that1.FieldE {
7603 return -1
7604 }
7605 return 1
7606 }
7607 if this.FieldF != that1.FieldF {
7608 if this.FieldF < that1.FieldF {
7609 return -1
7610 }
7611 return 1
7612 }
7613 if this.FieldG != that1.FieldG {
7614 if this.FieldG < that1.FieldG {
7615 return -1
7616 }
7617 return 1
7618 }
7619 if this.FieldH != that1.FieldH {
7620 if this.FieldH < that1.FieldH {
7621 return -1
7622 }
7623 return 1
7624 }
7625 if this.FieldI != that1.FieldI {
7626 if this.FieldI < that1.FieldI {
7627 return -1
7628 }
7629 return 1
7630 }
7631 if this.FieldJ != that1.FieldJ {
7632 if this.FieldJ < that1.FieldJ {
7633 return -1
7634 }
7635 return 1
7636 }
7637 if this.FieldK != that1.FieldK {
7638 if this.FieldK < that1.FieldK {
7639 return -1
7640 }
7641 return 1
7642 }
7643 if this.FieldL != that1.FieldL {
7644 if this.FieldL < that1.FieldL {
7645 return -1
7646 }
7647 return 1
7648 }
7649 if this.FieldM != that1.FieldM {
7650 if !this.FieldM {
7651 return -1
7652 }
7653 return 1
7654 }
7655 if this.FieldN != that1.FieldN {
7656 if this.FieldN < that1.FieldN {
7657 return -1
7658 }
7659 return 1
7660 }
7661 if c := bytes.Compare(this.FieldO, that1.FieldO); c != 0 {
7662 return c
7663 }
7664 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
7665 return c
7666 }
7667 return 0
7668 }
7669 func (this *CustomNameNinOptNative) Compare(that interface{}) int {
7670 if that == nil {
7671 if this == nil {
7672 return 0
7673 }
7674 return 1
7675 }
7676
7677 that1, ok := that.(*CustomNameNinOptNative)
7678 if !ok {
7679 that2, ok := that.(CustomNameNinOptNative)
7680 if ok {
7681 that1 = &that2
7682 } else {
7683 return 1
7684 }
7685 }
7686 if that1 == nil {
7687 if this == nil {
7688 return 0
7689 }
7690 return 1
7691 } else if this == nil {
7692 return -1
7693 }
7694 if this.FieldA != nil && that1.FieldA != nil {
7695 if *this.FieldA != *that1.FieldA {
7696 if *this.FieldA < *that1.FieldA {
7697 return -1
7698 }
7699 return 1
7700 }
7701 } else if this.FieldA != nil {
7702 return 1
7703 } else if that1.FieldA != nil {
7704 return -1
7705 }
7706 if this.FieldB != nil && that1.FieldB != nil {
7707 if *this.FieldB != *that1.FieldB {
7708 if *this.FieldB < *that1.FieldB {
7709 return -1
7710 }
7711 return 1
7712 }
7713 } else if this.FieldB != nil {
7714 return 1
7715 } else if that1.FieldB != nil {
7716 return -1
7717 }
7718 if this.FieldC != nil && that1.FieldC != nil {
7719 if *this.FieldC != *that1.FieldC {
7720 if *this.FieldC < *that1.FieldC {
7721 return -1
7722 }
7723 return 1
7724 }
7725 } else if this.FieldC != nil {
7726 return 1
7727 } else if that1.FieldC != nil {
7728 return -1
7729 }
7730 if this.FieldD != nil && that1.FieldD != nil {
7731 if *this.FieldD != *that1.FieldD {
7732 if *this.FieldD < *that1.FieldD {
7733 return -1
7734 }
7735 return 1
7736 }
7737 } else if this.FieldD != nil {
7738 return 1
7739 } else if that1.FieldD != nil {
7740 return -1
7741 }
7742 if this.FieldE != nil && that1.FieldE != nil {
7743 if *this.FieldE != *that1.FieldE {
7744 if *this.FieldE < *that1.FieldE {
7745 return -1
7746 }
7747 return 1
7748 }
7749 } else if this.FieldE != nil {
7750 return 1
7751 } else if that1.FieldE != nil {
7752 return -1
7753 }
7754 if this.FieldF != nil && that1.FieldF != nil {
7755 if *this.FieldF != *that1.FieldF {
7756 if *this.FieldF < *that1.FieldF {
7757 return -1
7758 }
7759 return 1
7760 }
7761 } else if this.FieldF != nil {
7762 return 1
7763 } else if that1.FieldF != nil {
7764 return -1
7765 }
7766 if this.FieldG != nil && that1.FieldG != nil {
7767 if *this.FieldG != *that1.FieldG {
7768 if *this.FieldG < *that1.FieldG {
7769 return -1
7770 }
7771 return 1
7772 }
7773 } else if this.FieldG != nil {
7774 return 1
7775 } else if that1.FieldG != nil {
7776 return -1
7777 }
7778 if this.FieldH != nil && that1.FieldH != nil {
7779 if *this.FieldH != *that1.FieldH {
7780 if *this.FieldH < *that1.FieldH {
7781 return -1
7782 }
7783 return 1
7784 }
7785 } else if this.FieldH != nil {
7786 return 1
7787 } else if that1.FieldH != nil {
7788 return -1
7789 }
7790 if this.FieldI != nil && that1.FieldI != nil {
7791 if *this.FieldI != *that1.FieldI {
7792 if *this.FieldI < *that1.FieldI {
7793 return -1
7794 }
7795 return 1
7796 }
7797 } else if this.FieldI != nil {
7798 return 1
7799 } else if that1.FieldI != nil {
7800 return -1
7801 }
7802 if this.FieldJ != nil && that1.FieldJ != nil {
7803 if *this.FieldJ != *that1.FieldJ {
7804 if *this.FieldJ < *that1.FieldJ {
7805 return -1
7806 }
7807 return 1
7808 }
7809 } else if this.FieldJ != nil {
7810 return 1
7811 } else if that1.FieldJ != nil {
7812 return -1
7813 }
7814 if this.FieldK != nil && that1.FieldK != nil {
7815 if *this.FieldK != *that1.FieldK {
7816 if *this.FieldK < *that1.FieldK {
7817 return -1
7818 }
7819 return 1
7820 }
7821 } else if this.FieldK != nil {
7822 return 1
7823 } else if that1.FieldK != nil {
7824 return -1
7825 }
7826 if this.FielL != nil && that1.FielL != nil {
7827 if *this.FielL != *that1.FielL {
7828 if *this.FielL < *that1.FielL {
7829 return -1
7830 }
7831 return 1
7832 }
7833 } else if this.FielL != nil {
7834 return 1
7835 } else if that1.FielL != nil {
7836 return -1
7837 }
7838 if this.FieldM != nil && that1.FieldM != nil {
7839 if *this.FieldM != *that1.FieldM {
7840 if !*this.FieldM {
7841 return -1
7842 }
7843 return 1
7844 }
7845 } else if this.FieldM != nil {
7846 return 1
7847 } else if that1.FieldM != nil {
7848 return -1
7849 }
7850 if this.FieldN != nil && that1.FieldN != nil {
7851 if *this.FieldN != *that1.FieldN {
7852 if *this.FieldN < *that1.FieldN {
7853 return -1
7854 }
7855 return 1
7856 }
7857 } else if this.FieldN != nil {
7858 return 1
7859 } else if that1.FieldN != nil {
7860 return -1
7861 }
7862 if c := bytes.Compare(this.FieldO, that1.FieldO); c != 0 {
7863 return c
7864 }
7865 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
7866 return c
7867 }
7868 return 0
7869 }
7870 func (this *CustomNameNinRepNative) Compare(that interface{}) int {
7871 if that == nil {
7872 if this == nil {
7873 return 0
7874 }
7875 return 1
7876 }
7877
7878 that1, ok := that.(*CustomNameNinRepNative)
7879 if !ok {
7880 that2, ok := that.(CustomNameNinRepNative)
7881 if ok {
7882 that1 = &that2
7883 } else {
7884 return 1
7885 }
7886 }
7887 if that1 == nil {
7888 if this == nil {
7889 return 0
7890 }
7891 return 1
7892 } else if this == nil {
7893 return -1
7894 }
7895 if len(this.FieldA) != len(that1.FieldA) {
7896 if len(this.FieldA) < len(that1.FieldA) {
7897 return -1
7898 }
7899 return 1
7900 }
7901 for i := range this.FieldA {
7902 if this.FieldA[i] != that1.FieldA[i] {
7903 if this.FieldA[i] < that1.FieldA[i] {
7904 return -1
7905 }
7906 return 1
7907 }
7908 }
7909 if len(this.FieldB) != len(that1.FieldB) {
7910 if len(this.FieldB) < len(that1.FieldB) {
7911 return -1
7912 }
7913 return 1
7914 }
7915 for i := range this.FieldB {
7916 if this.FieldB[i] != that1.FieldB[i] {
7917 if this.FieldB[i] < that1.FieldB[i] {
7918 return -1
7919 }
7920 return 1
7921 }
7922 }
7923 if len(this.FieldC) != len(that1.FieldC) {
7924 if len(this.FieldC) < len(that1.FieldC) {
7925 return -1
7926 }
7927 return 1
7928 }
7929 for i := range this.FieldC {
7930 if this.FieldC[i] != that1.FieldC[i] {
7931 if this.FieldC[i] < that1.FieldC[i] {
7932 return -1
7933 }
7934 return 1
7935 }
7936 }
7937 if len(this.FieldD) != len(that1.FieldD) {
7938 if len(this.FieldD) < len(that1.FieldD) {
7939 return -1
7940 }
7941 return 1
7942 }
7943 for i := range this.FieldD {
7944 if this.FieldD[i] != that1.FieldD[i] {
7945 if this.FieldD[i] < that1.FieldD[i] {
7946 return -1
7947 }
7948 return 1
7949 }
7950 }
7951 if len(this.FieldE) != len(that1.FieldE) {
7952 if len(this.FieldE) < len(that1.FieldE) {
7953 return -1
7954 }
7955 return 1
7956 }
7957 for i := range this.FieldE {
7958 if this.FieldE[i] != that1.FieldE[i] {
7959 if this.FieldE[i] < that1.FieldE[i] {
7960 return -1
7961 }
7962 return 1
7963 }
7964 }
7965 if len(this.FieldF) != len(that1.FieldF) {
7966 if len(this.FieldF) < len(that1.FieldF) {
7967 return -1
7968 }
7969 return 1
7970 }
7971 for i := range this.FieldF {
7972 if this.FieldF[i] != that1.FieldF[i] {
7973 if this.FieldF[i] < that1.FieldF[i] {
7974 return -1
7975 }
7976 return 1
7977 }
7978 }
7979 if len(this.FieldG) != len(that1.FieldG) {
7980 if len(this.FieldG) < len(that1.FieldG) {
7981 return -1
7982 }
7983 return 1
7984 }
7985 for i := range this.FieldG {
7986 if this.FieldG[i] != that1.FieldG[i] {
7987 if this.FieldG[i] < that1.FieldG[i] {
7988 return -1
7989 }
7990 return 1
7991 }
7992 }
7993 if len(this.FieldH) != len(that1.FieldH) {
7994 if len(this.FieldH) < len(that1.FieldH) {
7995 return -1
7996 }
7997 return 1
7998 }
7999 for i := range this.FieldH {
8000 if this.FieldH[i] != that1.FieldH[i] {
8001 if this.FieldH[i] < that1.FieldH[i] {
8002 return -1
8003 }
8004 return 1
8005 }
8006 }
8007 if len(this.FieldI) != len(that1.FieldI) {
8008 if len(this.FieldI) < len(that1.FieldI) {
8009 return -1
8010 }
8011 return 1
8012 }
8013 for i := range this.FieldI {
8014 if this.FieldI[i] != that1.FieldI[i] {
8015 if this.FieldI[i] < that1.FieldI[i] {
8016 return -1
8017 }
8018 return 1
8019 }
8020 }
8021 if len(this.FieldJ) != len(that1.FieldJ) {
8022 if len(this.FieldJ) < len(that1.FieldJ) {
8023 return -1
8024 }
8025 return 1
8026 }
8027 for i := range this.FieldJ {
8028 if this.FieldJ[i] != that1.FieldJ[i] {
8029 if this.FieldJ[i] < that1.FieldJ[i] {
8030 return -1
8031 }
8032 return 1
8033 }
8034 }
8035 if len(this.FieldK) != len(that1.FieldK) {
8036 if len(this.FieldK) < len(that1.FieldK) {
8037 return -1
8038 }
8039 return 1
8040 }
8041 for i := range this.FieldK {
8042 if this.FieldK[i] != that1.FieldK[i] {
8043 if this.FieldK[i] < that1.FieldK[i] {
8044 return -1
8045 }
8046 return 1
8047 }
8048 }
8049 if len(this.FieldL) != len(that1.FieldL) {
8050 if len(this.FieldL) < len(that1.FieldL) {
8051 return -1
8052 }
8053 return 1
8054 }
8055 for i := range this.FieldL {
8056 if this.FieldL[i] != that1.FieldL[i] {
8057 if this.FieldL[i] < that1.FieldL[i] {
8058 return -1
8059 }
8060 return 1
8061 }
8062 }
8063 if len(this.FieldM) != len(that1.FieldM) {
8064 if len(this.FieldM) < len(that1.FieldM) {
8065 return -1
8066 }
8067 return 1
8068 }
8069 for i := range this.FieldM {
8070 if this.FieldM[i] != that1.FieldM[i] {
8071 if !this.FieldM[i] {
8072 return -1
8073 }
8074 return 1
8075 }
8076 }
8077 if len(this.FieldN) != len(that1.FieldN) {
8078 if len(this.FieldN) < len(that1.FieldN) {
8079 return -1
8080 }
8081 return 1
8082 }
8083 for i := range this.FieldN {
8084 if this.FieldN[i] != that1.FieldN[i] {
8085 if this.FieldN[i] < that1.FieldN[i] {
8086 return -1
8087 }
8088 return 1
8089 }
8090 }
8091 if len(this.FieldO) != len(that1.FieldO) {
8092 if len(this.FieldO) < len(that1.FieldO) {
8093 return -1
8094 }
8095 return 1
8096 }
8097 for i := range this.FieldO {
8098 if c := bytes.Compare(this.FieldO[i], that1.FieldO[i]); c != 0 {
8099 return c
8100 }
8101 }
8102 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8103 return c
8104 }
8105 return 0
8106 }
8107 func (this *CustomNameNinStruct) Compare(that interface{}) int {
8108 if that == nil {
8109 if this == nil {
8110 return 0
8111 }
8112 return 1
8113 }
8114
8115 that1, ok := that.(*CustomNameNinStruct)
8116 if !ok {
8117 that2, ok := that.(CustomNameNinStruct)
8118 if ok {
8119 that1 = &that2
8120 } else {
8121 return 1
8122 }
8123 }
8124 if that1 == nil {
8125 if this == nil {
8126 return 0
8127 }
8128 return 1
8129 } else if this == nil {
8130 return -1
8131 }
8132 if this.FieldA != nil && that1.FieldA != nil {
8133 if *this.FieldA != *that1.FieldA {
8134 if *this.FieldA < *that1.FieldA {
8135 return -1
8136 }
8137 return 1
8138 }
8139 } else if this.FieldA != nil {
8140 return 1
8141 } else if that1.FieldA != nil {
8142 return -1
8143 }
8144 if this.FieldB != nil && that1.FieldB != nil {
8145 if *this.FieldB != *that1.FieldB {
8146 if *this.FieldB < *that1.FieldB {
8147 return -1
8148 }
8149 return 1
8150 }
8151 } else if this.FieldB != nil {
8152 return 1
8153 } else if that1.FieldB != nil {
8154 return -1
8155 }
8156 if c := this.FieldC.Compare(that1.FieldC); c != 0 {
8157 return c
8158 }
8159 if len(this.FieldD) != len(that1.FieldD) {
8160 if len(this.FieldD) < len(that1.FieldD) {
8161 return -1
8162 }
8163 return 1
8164 }
8165 for i := range this.FieldD {
8166 if c := this.FieldD[i].Compare(that1.FieldD[i]); c != 0 {
8167 return c
8168 }
8169 }
8170 if this.FieldE != nil && that1.FieldE != nil {
8171 if *this.FieldE != *that1.FieldE {
8172 if *this.FieldE < *that1.FieldE {
8173 return -1
8174 }
8175 return 1
8176 }
8177 } else if this.FieldE != nil {
8178 return 1
8179 } else if that1.FieldE != nil {
8180 return -1
8181 }
8182 if this.FieldF != nil && that1.FieldF != nil {
8183 if *this.FieldF != *that1.FieldF {
8184 if *this.FieldF < *that1.FieldF {
8185 return -1
8186 }
8187 return 1
8188 }
8189 } else if this.FieldF != nil {
8190 return 1
8191 } else if that1.FieldF != nil {
8192 return -1
8193 }
8194 if c := this.FieldG.Compare(that1.FieldG); c != 0 {
8195 return c
8196 }
8197 if this.FieldH != nil && that1.FieldH != nil {
8198 if *this.FieldH != *that1.FieldH {
8199 if !*this.FieldH {
8200 return -1
8201 }
8202 return 1
8203 }
8204 } else if this.FieldH != nil {
8205 return 1
8206 } else if that1.FieldH != nil {
8207 return -1
8208 }
8209 if this.FieldI != nil && that1.FieldI != nil {
8210 if *this.FieldI != *that1.FieldI {
8211 if *this.FieldI < *that1.FieldI {
8212 return -1
8213 }
8214 return 1
8215 }
8216 } else if this.FieldI != nil {
8217 return 1
8218 } else if that1.FieldI != nil {
8219 return -1
8220 }
8221 if c := bytes.Compare(this.FieldJ, that1.FieldJ); c != 0 {
8222 return c
8223 }
8224 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8225 return c
8226 }
8227 return 0
8228 }
8229 func (this *CustomNameCustomType) Compare(that interface{}) int {
8230 if that == nil {
8231 if this == nil {
8232 return 0
8233 }
8234 return 1
8235 }
8236
8237 that1, ok := that.(*CustomNameCustomType)
8238 if !ok {
8239 that2, ok := that.(CustomNameCustomType)
8240 if ok {
8241 that1 = &that2
8242 } else {
8243 return 1
8244 }
8245 }
8246 if that1 == nil {
8247 if this == nil {
8248 return 0
8249 }
8250 return 1
8251 } else if this == nil {
8252 return -1
8253 }
8254 if that1.FieldA == nil {
8255 if this.FieldA != nil {
8256 return 1
8257 }
8258 } else if this.FieldA == nil {
8259 return -1
8260 } else if c := this.FieldA.Compare(*that1.FieldA); c != 0 {
8261 return c
8262 }
8263 if that1.FieldB == nil {
8264 if this.FieldB != nil {
8265 return 1
8266 }
8267 } else if this.FieldB == nil {
8268 return -1
8269 } else if c := this.FieldB.Compare(*that1.FieldB); c != 0 {
8270 return c
8271 }
8272 if len(this.FieldC) != len(that1.FieldC) {
8273 if len(this.FieldC) < len(that1.FieldC) {
8274 return -1
8275 }
8276 return 1
8277 }
8278 for i := range this.FieldC {
8279 if c := this.FieldC[i].Compare(that1.FieldC[i]); c != 0 {
8280 return c
8281 }
8282 }
8283 if len(this.FieldD) != len(that1.FieldD) {
8284 if len(this.FieldD) < len(that1.FieldD) {
8285 return -1
8286 }
8287 return 1
8288 }
8289 for i := range this.FieldD {
8290 if c := this.FieldD[i].Compare(that1.FieldD[i]); c != 0 {
8291 return c
8292 }
8293 }
8294 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8295 return c
8296 }
8297 return 0
8298 }
8299 func (this *CustomNameNinEmbeddedStructUnion) Compare(that interface{}) int {
8300 if that == nil {
8301 if this == nil {
8302 return 0
8303 }
8304 return 1
8305 }
8306
8307 that1, ok := that.(*CustomNameNinEmbeddedStructUnion)
8308 if !ok {
8309 that2, ok := that.(CustomNameNinEmbeddedStructUnion)
8310 if ok {
8311 that1 = &that2
8312 } else {
8313 return 1
8314 }
8315 }
8316 if that1 == nil {
8317 if this == nil {
8318 return 0
8319 }
8320 return 1
8321 } else if this == nil {
8322 return -1
8323 }
8324 if c := this.NidOptNative.Compare(that1.NidOptNative); c != 0 {
8325 return c
8326 }
8327 if c := this.FieldA.Compare(that1.FieldA); c != 0 {
8328 return c
8329 }
8330 if this.FieldB != nil && that1.FieldB != nil {
8331 if *this.FieldB != *that1.FieldB {
8332 if !*this.FieldB {
8333 return -1
8334 }
8335 return 1
8336 }
8337 } else if this.FieldB != nil {
8338 return 1
8339 } else if that1.FieldB != nil {
8340 return -1
8341 }
8342 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8343 return c
8344 }
8345 return 0
8346 }
8347 func (this *CustomNameEnum) Compare(that interface{}) int {
8348 if that == nil {
8349 if this == nil {
8350 return 0
8351 }
8352 return 1
8353 }
8354
8355 that1, ok := that.(*CustomNameEnum)
8356 if !ok {
8357 that2, ok := that.(CustomNameEnum)
8358 if ok {
8359 that1 = &that2
8360 } else {
8361 return 1
8362 }
8363 }
8364 if that1 == nil {
8365 if this == nil {
8366 return 0
8367 }
8368 return 1
8369 } else if this == nil {
8370 return -1
8371 }
8372 if this.FieldA != nil && that1.FieldA != nil {
8373 if *this.FieldA != *that1.FieldA {
8374 if *this.FieldA < *that1.FieldA {
8375 return -1
8376 }
8377 return 1
8378 }
8379 } else if this.FieldA != nil {
8380 return 1
8381 } else if that1.FieldA != nil {
8382 return -1
8383 }
8384 if len(this.FieldB) != len(that1.FieldB) {
8385 if len(this.FieldB) < len(that1.FieldB) {
8386 return -1
8387 }
8388 return 1
8389 }
8390 for i := range this.FieldB {
8391 if this.FieldB[i] != that1.FieldB[i] {
8392 if this.FieldB[i] < that1.FieldB[i] {
8393 return -1
8394 }
8395 return 1
8396 }
8397 }
8398 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8399 return c
8400 }
8401 return 0
8402 }
8403 func (this *NoExtensionsMap) Compare(that interface{}) int {
8404 if that == nil {
8405 if this == nil {
8406 return 0
8407 }
8408 return 1
8409 }
8410
8411 that1, ok := that.(*NoExtensionsMap)
8412 if !ok {
8413 that2, ok := that.(NoExtensionsMap)
8414 if ok {
8415 that1 = &that2
8416 } else {
8417 return 1
8418 }
8419 }
8420 if that1 == nil {
8421 if this == nil {
8422 return 0
8423 }
8424 return 1
8425 } else if this == nil {
8426 return -1
8427 }
8428 if this.Field1 != nil && that1.Field1 != nil {
8429 if *this.Field1 != *that1.Field1 {
8430 if *this.Field1 < *that1.Field1 {
8431 return -1
8432 }
8433 return 1
8434 }
8435 } else if this.Field1 != nil {
8436 return 1
8437 } else if that1.Field1 != nil {
8438 return -1
8439 }
8440 if c := bytes.Compare(this.XXX_extensions, that1.XXX_extensions); c != 0 {
8441 return c
8442 }
8443 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8444 return c
8445 }
8446 return 0
8447 }
8448 func (this *Unrecognized) Compare(that interface{}) int {
8449 if that == nil {
8450 if this == nil {
8451 return 0
8452 }
8453 return 1
8454 }
8455
8456 that1, ok := that.(*Unrecognized)
8457 if !ok {
8458 that2, ok := that.(Unrecognized)
8459 if ok {
8460 that1 = &that2
8461 } else {
8462 return 1
8463 }
8464 }
8465 if that1 == nil {
8466 if this == nil {
8467 return 0
8468 }
8469 return 1
8470 } else if this == nil {
8471 return -1
8472 }
8473 if this.Field1 != nil && that1.Field1 != nil {
8474 if *this.Field1 != *that1.Field1 {
8475 if *this.Field1 < *that1.Field1 {
8476 return -1
8477 }
8478 return 1
8479 }
8480 } else if this.Field1 != nil {
8481 return 1
8482 } else if that1.Field1 != nil {
8483 return -1
8484 }
8485 return 0
8486 }
8487 func (this *UnrecognizedWithInner) Compare(that interface{}) int {
8488 if that == nil {
8489 if this == nil {
8490 return 0
8491 }
8492 return 1
8493 }
8494
8495 that1, ok := that.(*UnrecognizedWithInner)
8496 if !ok {
8497 that2, ok := that.(UnrecognizedWithInner)
8498 if ok {
8499 that1 = &that2
8500 } else {
8501 return 1
8502 }
8503 }
8504 if that1 == nil {
8505 if this == nil {
8506 return 0
8507 }
8508 return 1
8509 } else if this == nil {
8510 return -1
8511 }
8512 if len(this.Embedded) != len(that1.Embedded) {
8513 if len(this.Embedded) < len(that1.Embedded) {
8514 return -1
8515 }
8516 return 1
8517 }
8518 for i := range this.Embedded {
8519 if c := this.Embedded[i].Compare(that1.Embedded[i]); c != 0 {
8520 return c
8521 }
8522 }
8523 if this.Field2 != nil && that1.Field2 != nil {
8524 if *this.Field2 != *that1.Field2 {
8525 if *this.Field2 < *that1.Field2 {
8526 return -1
8527 }
8528 return 1
8529 }
8530 } else if this.Field2 != nil {
8531 return 1
8532 } else if that1.Field2 != nil {
8533 return -1
8534 }
8535 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8536 return c
8537 }
8538 return 0
8539 }
8540 func (this *UnrecognizedWithInner_Inner) Compare(that interface{}) int {
8541 if that == nil {
8542 if this == nil {
8543 return 0
8544 }
8545 return 1
8546 }
8547
8548 that1, ok := that.(*UnrecognizedWithInner_Inner)
8549 if !ok {
8550 that2, ok := that.(UnrecognizedWithInner_Inner)
8551 if ok {
8552 that1 = &that2
8553 } else {
8554 return 1
8555 }
8556 }
8557 if that1 == nil {
8558 if this == nil {
8559 return 0
8560 }
8561 return 1
8562 } else if this == nil {
8563 return -1
8564 }
8565 if this.Field1 != nil && that1.Field1 != nil {
8566 if *this.Field1 != *that1.Field1 {
8567 if *this.Field1 < *that1.Field1 {
8568 return -1
8569 }
8570 return 1
8571 }
8572 } else if this.Field1 != nil {
8573 return 1
8574 } else if that1.Field1 != nil {
8575 return -1
8576 }
8577 return 0
8578 }
8579 func (this *UnrecognizedWithEmbed) Compare(that interface{}) int {
8580 if that == nil {
8581 if this == nil {
8582 return 0
8583 }
8584 return 1
8585 }
8586
8587 that1, ok := that.(*UnrecognizedWithEmbed)
8588 if !ok {
8589 that2, ok := that.(UnrecognizedWithEmbed)
8590 if ok {
8591 that1 = &that2
8592 } else {
8593 return 1
8594 }
8595 }
8596 if that1 == nil {
8597 if this == nil {
8598 return 0
8599 }
8600 return 1
8601 } else if this == nil {
8602 return -1
8603 }
8604 if c := this.UnrecognizedWithEmbed_Embedded.Compare(&that1.UnrecognizedWithEmbed_Embedded); c != 0 {
8605 return c
8606 }
8607 if this.Field2 != nil && that1.Field2 != nil {
8608 if *this.Field2 != *that1.Field2 {
8609 if *this.Field2 < *that1.Field2 {
8610 return -1
8611 }
8612 return 1
8613 }
8614 } else if this.Field2 != nil {
8615 return 1
8616 } else if that1.Field2 != nil {
8617 return -1
8618 }
8619 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8620 return c
8621 }
8622 return 0
8623 }
8624 func (this *UnrecognizedWithEmbed_Embedded) Compare(that interface{}) int {
8625 if that == nil {
8626 if this == nil {
8627 return 0
8628 }
8629 return 1
8630 }
8631
8632 that1, ok := that.(*UnrecognizedWithEmbed_Embedded)
8633 if !ok {
8634 that2, ok := that.(UnrecognizedWithEmbed_Embedded)
8635 if ok {
8636 that1 = &that2
8637 } else {
8638 return 1
8639 }
8640 }
8641 if that1 == nil {
8642 if this == nil {
8643 return 0
8644 }
8645 return 1
8646 } else if this == nil {
8647 return -1
8648 }
8649 if this.Field1 != nil && that1.Field1 != nil {
8650 if *this.Field1 != *that1.Field1 {
8651 if *this.Field1 < *that1.Field1 {
8652 return -1
8653 }
8654 return 1
8655 }
8656 } else if this.Field1 != nil {
8657 return 1
8658 } else if that1.Field1 != nil {
8659 return -1
8660 }
8661 return 0
8662 }
8663 func (this *Node) Compare(that interface{}) int {
8664 if that == nil {
8665 if this == nil {
8666 return 0
8667 }
8668 return 1
8669 }
8670
8671 that1, ok := that.(*Node)
8672 if !ok {
8673 that2, ok := that.(Node)
8674 if ok {
8675 that1 = &that2
8676 } else {
8677 return 1
8678 }
8679 }
8680 if that1 == nil {
8681 if this == nil {
8682 return 0
8683 }
8684 return 1
8685 } else if this == nil {
8686 return -1
8687 }
8688 if this.Label != nil && that1.Label != nil {
8689 if *this.Label != *that1.Label {
8690 if *this.Label < *that1.Label {
8691 return -1
8692 }
8693 return 1
8694 }
8695 } else if this.Label != nil {
8696 return 1
8697 } else if that1.Label != nil {
8698 return -1
8699 }
8700 if len(this.Children) != len(that1.Children) {
8701 if len(this.Children) < len(that1.Children) {
8702 return -1
8703 }
8704 return 1
8705 }
8706 for i := range this.Children {
8707 if c := this.Children[i].Compare(that1.Children[i]); c != 0 {
8708 return c
8709 }
8710 }
8711 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8712 return c
8713 }
8714 return 0
8715 }
8716 func (this *NonByteCustomType) Compare(that interface{}) int {
8717 if that == nil {
8718 if this == nil {
8719 return 0
8720 }
8721 return 1
8722 }
8723
8724 that1, ok := that.(*NonByteCustomType)
8725 if !ok {
8726 that2, ok := that.(NonByteCustomType)
8727 if ok {
8728 that1 = &that2
8729 } else {
8730 return 1
8731 }
8732 }
8733 if that1 == nil {
8734 if this == nil {
8735 return 0
8736 }
8737 return 1
8738 } else if this == nil {
8739 return -1
8740 }
8741 if that1.Field1 == nil {
8742 if this.Field1 != nil {
8743 return 1
8744 }
8745 } else if this.Field1 == nil {
8746 return -1
8747 } else if c := this.Field1.Compare(*that1.Field1); c != 0 {
8748 return c
8749 }
8750 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8751 return c
8752 }
8753 return 0
8754 }
8755 func (this *NidOptNonByteCustomType) Compare(that interface{}) int {
8756 if that == nil {
8757 if this == nil {
8758 return 0
8759 }
8760 return 1
8761 }
8762
8763 that1, ok := that.(*NidOptNonByteCustomType)
8764 if !ok {
8765 that2, ok := that.(NidOptNonByteCustomType)
8766 if ok {
8767 that1 = &that2
8768 } else {
8769 return 1
8770 }
8771 }
8772 if that1 == nil {
8773 if this == nil {
8774 return 0
8775 }
8776 return 1
8777 } else if this == nil {
8778 return -1
8779 }
8780 if c := this.Field1.Compare(that1.Field1); c != 0 {
8781 return c
8782 }
8783 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8784 return c
8785 }
8786 return 0
8787 }
8788 func (this *NinOptNonByteCustomType) Compare(that interface{}) int {
8789 if that == nil {
8790 if this == nil {
8791 return 0
8792 }
8793 return 1
8794 }
8795
8796 that1, ok := that.(*NinOptNonByteCustomType)
8797 if !ok {
8798 that2, ok := that.(NinOptNonByteCustomType)
8799 if ok {
8800 that1 = &that2
8801 } else {
8802 return 1
8803 }
8804 }
8805 if that1 == nil {
8806 if this == nil {
8807 return 0
8808 }
8809 return 1
8810 } else if this == nil {
8811 return -1
8812 }
8813 if that1.Field1 == nil {
8814 if this.Field1 != nil {
8815 return 1
8816 }
8817 } else if this.Field1 == nil {
8818 return -1
8819 } else if c := this.Field1.Compare(*that1.Field1); c != 0 {
8820 return c
8821 }
8822 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8823 return c
8824 }
8825 return 0
8826 }
8827 func (this *NidRepNonByteCustomType) Compare(that interface{}) int {
8828 if that == nil {
8829 if this == nil {
8830 return 0
8831 }
8832 return 1
8833 }
8834
8835 that1, ok := that.(*NidRepNonByteCustomType)
8836 if !ok {
8837 that2, ok := that.(NidRepNonByteCustomType)
8838 if ok {
8839 that1 = &that2
8840 } else {
8841 return 1
8842 }
8843 }
8844 if that1 == nil {
8845 if this == nil {
8846 return 0
8847 }
8848 return 1
8849 } else if this == nil {
8850 return -1
8851 }
8852 if len(this.Field1) != len(that1.Field1) {
8853 if len(this.Field1) < len(that1.Field1) {
8854 return -1
8855 }
8856 return 1
8857 }
8858 for i := range this.Field1 {
8859 if c := this.Field1[i].Compare(that1.Field1[i]); c != 0 {
8860 return c
8861 }
8862 }
8863 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8864 return c
8865 }
8866 return 0
8867 }
8868 func (this *NinRepNonByteCustomType) Compare(that interface{}) int {
8869 if that == nil {
8870 if this == nil {
8871 return 0
8872 }
8873 return 1
8874 }
8875
8876 that1, ok := that.(*NinRepNonByteCustomType)
8877 if !ok {
8878 that2, ok := that.(NinRepNonByteCustomType)
8879 if ok {
8880 that1 = &that2
8881 } else {
8882 return 1
8883 }
8884 }
8885 if that1 == nil {
8886 if this == nil {
8887 return 0
8888 }
8889 return 1
8890 } else if this == nil {
8891 return -1
8892 }
8893 if len(this.Field1) != len(that1.Field1) {
8894 if len(this.Field1) < len(that1.Field1) {
8895 return -1
8896 }
8897 return 1
8898 }
8899 for i := range this.Field1 {
8900 if c := this.Field1[i].Compare(that1.Field1[i]); c != 0 {
8901 return c
8902 }
8903 }
8904 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8905 return c
8906 }
8907 return 0
8908 }
8909 func (this *ProtoType) Compare(that interface{}) int {
8910 if that == nil {
8911 if this == nil {
8912 return 0
8913 }
8914 return 1
8915 }
8916
8917 that1, ok := that.(*ProtoType)
8918 if !ok {
8919 that2, ok := that.(ProtoType)
8920 if ok {
8921 that1 = &that2
8922 } else {
8923 return 1
8924 }
8925 }
8926 if that1 == nil {
8927 if this == nil {
8928 return 0
8929 }
8930 return 1
8931 } else if this == nil {
8932 return -1
8933 }
8934 if this.Field2 != nil && that1.Field2 != nil {
8935 if *this.Field2 != *that1.Field2 {
8936 if *this.Field2 < *that1.Field2 {
8937 return -1
8938 }
8939 return 1
8940 }
8941 } else if this.Field2 != nil {
8942 return 1
8943 } else if that1.Field2 != nil {
8944 return -1
8945 }
8946 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
8947 return c
8948 }
8949 return 0
8950 }
8951 func (this *NidOptNative) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8952 return ThetestDescription()
8953 }
8954 func (this *NinOptNative) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8955 return ThetestDescription()
8956 }
8957 func (this *NidRepNative) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8958 return ThetestDescription()
8959 }
8960 func (this *NinRepNative) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8961 return ThetestDescription()
8962 }
8963 func (this *NidRepPackedNative) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8964 return ThetestDescription()
8965 }
8966 func (this *NinRepPackedNative) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8967 return ThetestDescription()
8968 }
8969 func (this *NidOptStruct) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8970 return ThetestDescription()
8971 }
8972 func (this *NinOptStruct) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8973 return ThetestDescription()
8974 }
8975 func (this *NidRepStruct) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8976 return ThetestDescription()
8977 }
8978 func (this *NinRepStruct) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8979 return ThetestDescription()
8980 }
8981 func (this *NidEmbeddedStruct) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8982 return ThetestDescription()
8983 }
8984 func (this *NinEmbeddedStruct) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8985 return ThetestDescription()
8986 }
8987 func (this *NidNestedStruct) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8988 return ThetestDescription()
8989 }
8990 func (this *NinNestedStruct) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8991 return ThetestDescription()
8992 }
8993 func (this *NidOptCustom) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8994 return ThetestDescription()
8995 }
8996 func (this *CustomDash) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
8997 return ThetestDescription()
8998 }
8999 func (this *NinOptCustom) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9000 return ThetestDescription()
9001 }
9002 func (this *NidRepCustom) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9003 return ThetestDescription()
9004 }
9005 func (this *NinRepCustom) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9006 return ThetestDescription()
9007 }
9008 func (this *NinOptNativeUnion) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9009 return ThetestDescription()
9010 }
9011 func (this *NinOptStructUnion) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9012 return ThetestDescription()
9013 }
9014 func (this *NinEmbeddedStructUnion) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9015 return ThetestDescription()
9016 }
9017 func (this *NinNestedStructUnion) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9018 return ThetestDescription()
9019 }
9020 func (this *Tree) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9021 return ThetestDescription()
9022 }
9023 func (this *OrBranch) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9024 return ThetestDescription()
9025 }
9026 func (this *AndBranch) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9027 return ThetestDescription()
9028 }
9029 func (this *Leaf) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9030 return ThetestDescription()
9031 }
9032 func (this *DeepTree) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9033 return ThetestDescription()
9034 }
9035 func (this *ADeepBranch) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9036 return ThetestDescription()
9037 }
9038 func (this *AndDeepBranch) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9039 return ThetestDescription()
9040 }
9041 func (this *DeepLeaf) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9042 return ThetestDescription()
9043 }
9044 func (this *Nil) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9045 return ThetestDescription()
9046 }
9047 func (this *NidOptEnum) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9048 return ThetestDescription()
9049 }
9050 func (this *NinOptEnum) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9051 return ThetestDescription()
9052 }
9053 func (this *NidRepEnum) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9054 return ThetestDescription()
9055 }
9056 func (this *NinRepEnum) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9057 return ThetestDescription()
9058 }
9059 func (this *NinOptEnumDefault) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9060 return ThetestDescription()
9061 }
9062 func (this *AnotherNinOptEnum) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9063 return ThetestDescription()
9064 }
9065 func (this *AnotherNinOptEnumDefault) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9066 return ThetestDescription()
9067 }
9068 func (this *Timer) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9069 return ThetestDescription()
9070 }
9071 func (this *MyExtendable) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9072 return ThetestDescription()
9073 }
9074 func (this *OtherExtenable) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9075 return ThetestDescription()
9076 }
9077 func (this *NestedDefinition) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9078 return ThetestDescription()
9079 }
9080 func (this *NestedDefinition_NestedMessage) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9081 return ThetestDescription()
9082 }
9083 func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9084 return ThetestDescription()
9085 }
9086 func (this *NestedScope) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9087 return ThetestDescription()
9088 }
9089 func (this *NinOptNativeDefault) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9090 return ThetestDescription()
9091 }
9092 func (this *CustomContainer) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9093 return ThetestDescription()
9094 }
9095 func (this *CustomNameNidOptNative) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9096 return ThetestDescription()
9097 }
9098 func (this *CustomNameNinOptNative) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9099 return ThetestDescription()
9100 }
9101 func (this *CustomNameNinRepNative) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9102 return ThetestDescription()
9103 }
9104 func (this *CustomNameNinStruct) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9105 return ThetestDescription()
9106 }
9107 func (this *CustomNameCustomType) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9108 return ThetestDescription()
9109 }
9110 func (this *CustomNameNinEmbeddedStructUnion) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9111 return ThetestDescription()
9112 }
9113 func (this *CustomNameEnum) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9114 return ThetestDescription()
9115 }
9116 func (this *NoExtensionsMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9117 return ThetestDescription()
9118 }
9119 func (this *Unrecognized) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9120 return ThetestDescription()
9121 }
9122 func (this *UnrecognizedWithInner) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9123 return ThetestDescription()
9124 }
9125 func (this *UnrecognizedWithInner_Inner) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9126 return ThetestDescription()
9127 }
9128 func (this *UnrecognizedWithEmbed) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9129 return ThetestDescription()
9130 }
9131 func (this *UnrecognizedWithEmbed_Embedded) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9132 return ThetestDescription()
9133 }
9134 func (this *Node) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9135 return ThetestDescription()
9136 }
9137 func (this *NonByteCustomType) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9138 return ThetestDescription()
9139 }
9140 func (this *NidOptNonByteCustomType) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9141 return ThetestDescription()
9142 }
9143 func (this *NinOptNonByteCustomType) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9144 return ThetestDescription()
9145 }
9146 func (this *NidRepNonByteCustomType) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9147 return ThetestDescription()
9148 }
9149 func (this *NinRepNonByteCustomType) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9150 return ThetestDescription()
9151 }
9152 func (this *ProtoType) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9153 return ThetestDescription()
9154 }
9155 func ThetestDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
9156 d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
9157 var gzipped = []byte{
9158
9159 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x7c, 0x7b, 0x70, 0x24, 0x57,
9160 0x75, 0xf7, 0xf6, 0xf4, 0x48, 0x3b, 0x3a, 0x7a, 0xb5, 0x5a, 0xbb, 0xda, 0xb1, 0xbc, 0x96, 0x76,
9161 0xc7, 0xeb, 0xb5, 0x2c, 0xdb, 0x5a, 0xad, 0x56, 0xfb, 0x9a, 0xc5, 0xf6, 0x37, 0xaf, 0x5d, 0x6b,
9162 0x59, 0x8d, 0x44, 0x4b, 0xc2, 0x5e, 0xf8, 0xbe, 0x9a, 0x6a, 0xcd, 0x5c, 0x49, 0x63, 0xcf, 0x74,
9163 0x0f, 0xd3, 0x3d, 0xb6, 0xe5, 0xfa, 0xea, 0x2b, 0x7f, 0x90, 0x10, 0xc8, 0x3b, 0x21, 0xa9, 0x00,
9164 0x01, 0x63, 0xa0, 0x00, 0x43, 0x5e, 0x90, 0x10, 0x02, 0x24, 0x15, 0xfc, 0x0f, 0x61, 0xf3, 0x4f,
9165 0xca, 0xe4, 0xaf, 0x14, 0x95, 0x72, 0xe1, 0x35, 0x55, 0x21, 0x89, 0x93, 0x10, 0xe2, 0xaa, 0x50,
9166 0x65, 0xfe, 0x48, 0xdd, 0x57, 0x77, 0xdf, 0x3b, 0x3d, 0xea, 0x96, 0xd7, 0x36, 0xfc, 0xb3, 0x3b,
9167 0x73, 0xcf, 0xf9, 0x9d, 0x3e, 0xf7, 0xbc, 0xee, 0xe9, 0x7b, 0xaf, 0x06, 0x6e, 0x64, 0xe1, 0xd8,
9168 0xb6, 0x6d, 0x6f, 0x37, 0xd0, 0xa9, 0x56, 0xdb, 0x76, 0xed, 0xcd, 0xce, 0xd6, 0xa9, 0x1a, 0x72,
9169 0xaa, 0xed, 0x7a, 0xcb, 0xb5, 0xdb, 0x73, 0x64, 0x4c, 0x1f, 0xa5, 0x1c, 0x73, 0x9c, 0x23, 0xb3,
9170 0x0c, 0x63, 0x97, 0xeb, 0x0d, 0x54, 0xf4, 0x18, 0xd7, 0x90, 0xab, 0x5f, 0x80, 0xe4, 0x56, 0xbd,
9171 0x81, 0xd2, 0xca, 0x31, 0x75, 0x66, 0x70, 0xe1, 0xc4, 0x9c, 0x04, 0x9a, 0x13, 0x11, 0xab, 0x78,
9172 0xd8, 0x20, 0x88, 0xcc, 0x0f, 0x92, 0x30, 0x1e, 0x42, 0xd5, 0x75, 0x48, 0x5a, 0x66, 0x13, 0x4b,
9173 0x54, 0x66, 0x06, 0x0c, 0xf2, 0x59, 0x4f, 0xc3, 0xc1, 0x96, 0x59, 0x7d, 0xdc, 0xdc, 0x46, 0xe9,
9174 0x04, 0x19, 0xe6, 0x5f, 0xf5, 0x29, 0x80, 0x1a, 0x6a, 0x21, 0xab, 0x86, 0xac, 0xea, 0x6e, 0x5a,
9175 0x3d, 0xa6, 0xce, 0x0c, 0x18, 0x81, 0x11, 0xfd, 0x5e, 0x18, 0x6b, 0x75, 0x36, 0x1b, 0xf5, 0x6a,
9176 0x25, 0xc0, 0x06, 0xc7, 0xd4, 0x99, 0x3e, 0x43, 0xa3, 0x84, 0xa2, 0xcf, 0x7c, 0x37, 0x8c, 0x3e,
9177 0x89, 0xcc, 0xc7, 0x83, 0xac, 0x83, 0x84, 0x75, 0x04, 0x0f, 0x07, 0x18, 0x0b, 0x30, 0xd4, 0x44,
9178 0x8e, 0x63, 0x6e, 0xa3, 0x8a, 0xbb, 0xdb, 0x42, 0xe9, 0x24, 0x99, 0xfd, 0xb1, 0xae, 0xd9, 0xcb,
9179 0x33, 0x1f, 0x64, 0xa8, 0xf5, 0xdd, 0x16, 0xd2, 0x73, 0x30, 0x80, 0xac, 0x4e, 0x93, 0x4a, 0xe8,
9180 0xeb, 0x61, 0xbf, 0x92, 0xd5, 0x69, 0xca, 0x52, 0x52, 0x18, 0xc6, 0x44, 0x1c, 0x74, 0x50, 0xfb,
9181 0x89, 0x7a, 0x15, 0xa5, 0xfb, 0x89, 0x80, 0xbb, 0xbb, 0x04, 0xac, 0x51, 0xba, 0x2c, 0x83, 0xe3,
9182 0xf4, 0x02, 0x0c, 0xa0, 0xa7, 0x5c, 0x64, 0x39, 0x75, 0xdb, 0x4a, 0x1f, 0x24, 0x42, 0xee, 0x0a,
9183 0xf1, 0x22, 0x6a, 0xd4, 0x64, 0x11, 0x3e, 0x4e, 0x3f, 0x07, 0x07, 0xed, 0x96, 0x5b, 0xb7, 0x2d,
9184 0x27, 0x9d, 0x3a, 0xa6, 0xcc, 0x0c, 0x2e, 0x1c, 0x0d, 0x0d, 0x84, 0x15, 0xca, 0x63, 0x70, 0x66,
9185 0x7d, 0x09, 0x34, 0xc7, 0xee, 0xb4, 0xab, 0xa8, 0x52, 0xb5, 0x6b, 0xa8, 0x52, 0xb7, 0xb6, 0xec,
9186 0xf4, 0x00, 0x11, 0x30, 0xdd, 0x3d, 0x11, 0xc2, 0x58, 0xb0, 0x6b, 0x68, 0xc9, 0xda, 0xb2, 0x8d,
9187 0x11, 0x47, 0xf8, 0xae, 0x4f, 0x40, 0xbf, 0xb3, 0x6b, 0xb9, 0xe6, 0x53, 0xe9, 0x21, 0x12, 0x21,
9188 0xec, 0x5b, 0xe6, 0x1b, 0xfd, 0x30, 0x1a, 0x27, 0xc4, 0x2e, 0x41, 0xdf, 0x16, 0x9e, 0x65, 0x3a,
9189 0xb1, 0x1f, 0x1b, 0x50, 0x8c, 0x68, 0xc4, 0xfe, 0x37, 0x68, 0xc4, 0x1c, 0x0c, 0x5a, 0xc8, 0x71,
9190 0x51, 0x8d, 0x46, 0x84, 0x1a, 0x33, 0xa6, 0x80, 0x82, 0xba, 0x43, 0x2a, 0xf9, 0x86, 0x42, 0xea,
9191 0x51, 0x18, 0xf5, 0x54, 0xaa, 0xb4, 0x4d, 0x6b, 0x9b, 0xc7, 0xe6, 0xa9, 0x28, 0x4d, 0xe6, 0x4a,
9192 0x1c, 0x67, 0x60, 0x98, 0x31, 0x82, 0x84, 0xef, 0x7a, 0x11, 0xc0, 0xb6, 0x90, 0xbd, 0x55, 0xa9,
9193 0xa1, 0x6a, 0x23, 0x9d, 0xea, 0x61, 0xa5, 0x15, 0xcc, 0xd2, 0x65, 0x25, 0x9b, 0x8e, 0x56, 0x1b,
9194 0xfa, 0x45, 0x3f, 0xd4, 0x0e, 0xf6, 0x88, 0x94, 0x65, 0x9a, 0x64, 0x5d, 0xd1, 0xb6, 0x01, 0x23,
9195 0x6d, 0x84, 0xe3, 0x1e, 0xd5, 0xd8, 0xcc, 0x06, 0x88, 0x12, 0x73, 0x91, 0x33, 0x33, 0x18, 0x8c,
9196 0x4e, 0x6c, 0xb8, 0x1d, 0xfc, 0xaa, 0xdf, 0x09, 0xde, 0x40, 0x85, 0x84, 0x15, 0x90, 0x2a, 0x34,
9197 0xc4, 0x07, 0xcb, 0x66, 0x13, 0x4d, 0x3e, 0x0d, 0x23, 0xa2, 0x79, 0xf4, 0x43, 0xd0, 0xe7, 0xb8,
9198 0x66, 0xdb, 0x25, 0x51, 0xd8, 0x67, 0xd0, 0x2f, 0xba, 0x06, 0x2a, 0xb2, 0x6a, 0xa4, 0xca, 0xf5,
9199 0x19, 0xf8, 0xa3, 0xfe, 0xbf, 0xfc, 0x09, 0xab, 0x64, 0xc2, 0x27, 0xbb, 0x3d, 0x2a, 0x48, 0x96,
9200 0xe7, 0x3d, 0x79, 0x1e, 0x86, 0x85, 0x09, 0xc4, 0x7d, 0x74, 0xe6, 0xff, 0xc2, 0xe1, 0x50, 0xd1,
9201 0xfa, 0xa3, 0x70, 0xa8, 0x63, 0xd5, 0x2d, 0x17, 0xb5, 0x5b, 0x6d, 0x84, 0x23, 0x96, 0x3e, 0x2a,
9202 0xfd, 0x4f, 0x07, 0x7b, 0xc4, 0xdc, 0x46, 0x90, 0x9b, 0x4a, 0x31, 0xc6, 0x3b, 0xdd, 0x83, 0xb3,
9203 0x03, 0xa9, 0x1f, 0x1e, 0xd4, 0x9e, 0x79, 0xe6, 0x99, 0x67, 0x12, 0x99, 0x8f, 0xf6, 0xc3, 0xa1,
9204 0xb0, 0x9c, 0x09, 0x4d, 0xdf, 0x09, 0xe8, 0xb7, 0x3a, 0xcd, 0x4d, 0xd4, 0x26, 0x46, 0xea, 0x33,
9205 0xd8, 0x37, 0x3d, 0x07, 0x7d, 0x0d, 0x73, 0x13, 0x35, 0xd2, 0xc9, 0x63, 0xca, 0xcc, 0xc8, 0xc2,
9206 0xbd, 0xb1, 0xb2, 0x72, 0xee, 0x1a, 0x86, 0x18, 0x14, 0xa9, 0x3f, 0x08, 0x49, 0x56, 0xa2, 0xb1,
9207 0x84, 0xd9, 0x78, 0x12, 0x70, 0x2e, 0x19, 0x04, 0xa7, 0xdf, 0x0e, 0x03, 0xf8, 0x7f, 0x1a, 0x1b,
9208 0xfd, 0x44, 0xe7, 0x14, 0x1e, 0xc0, 0x71, 0xa1, 0x4f, 0x42, 0x8a, 0xa4, 0x49, 0x0d, 0xf1, 0xa5,
9209 0xcd, 0xfb, 0x8e, 0x03, 0xab, 0x86, 0xb6, 0xcc, 0x4e, 0xc3, 0xad, 0x3c, 0x61, 0x36, 0x3a, 0x88,
9210 0x04, 0xfc, 0x80, 0x31, 0xc4, 0x06, 0xdf, 0x8d, 0xc7, 0xf4, 0x69, 0x18, 0xa4, 0x59, 0x55, 0xb7,
9211 0x6a, 0xe8, 0x29, 0x52, 0x3d, 0xfb, 0x0c, 0x9a, 0x68, 0x4b, 0x78, 0x04, 0x3f, 0xfe, 0x31, 0xc7,
9212 0xb6, 0x78, 0x68, 0x92, 0x47, 0xe0, 0x01, 0xf2, 0xf8, 0xf3, 0x72, 0xe1, 0xbe, 0x23, 0x7c, 0x7a,
9213 0x72, 0x4c, 0x65, 0xbe, 0x96, 0x80, 0x24, 0xa9, 0x17, 0xa3, 0x30, 0xb8, 0x7e, 0x7d, 0xb5, 0x54,
9214 0x29, 0xae, 0x6c, 0xe4, 0xaf, 0x95, 0x34, 0x45, 0x1f, 0x01, 0x20, 0x03, 0x97, 0xaf, 0xad, 0xe4,
9215 0xd6, 0xb5, 0x84, 0xf7, 0x7d, 0xa9, 0xbc, 0x7e, 0x6e, 0x51, 0x53, 0x3d, 0xc0, 0x06, 0x1d, 0x48,
9216 0x06, 0x19, 0xce, 0x2c, 0x68, 0x7d, 0xba, 0x06, 0x43, 0x54, 0xc0, 0xd2, 0xa3, 0xa5, 0xe2, 0xb9,
9217 0x45, 0xad, 0x5f, 0x1c, 0x39, 0xb3, 0xa0, 0x1d, 0xd4, 0x87, 0x61, 0x80, 0x8c, 0xe4, 0x57, 0x56,
9218 0xae, 0x69, 0x29, 0x4f, 0xe6, 0xda, 0xba, 0xb1, 0x54, 0xbe, 0xa2, 0x0d, 0x78, 0x32, 0xaf, 0x18,
9219 0x2b, 0x1b, 0xab, 0x1a, 0x78, 0x12, 0x96, 0x4b, 0x6b, 0x6b, 0xb9, 0x2b, 0x25, 0x6d, 0xd0, 0xe3,
9220 0xc8, 0x5f, 0x5f, 0x2f, 0xad, 0x69, 0x43, 0x82, 0x5a, 0x67, 0x16, 0xb4, 0x61, 0xef, 0x11, 0xa5,
9221 0xf2, 0xc6, 0xb2, 0x36, 0xa2, 0x8f, 0xc1, 0x30, 0x7d, 0x04, 0x57, 0x62, 0x54, 0x1a, 0x3a, 0xb7,
9222 0xa8, 0x69, 0xbe, 0x22, 0x54, 0xca, 0x98, 0x30, 0x70, 0x6e, 0x51, 0xd3, 0x33, 0x05, 0xe8, 0x23,
9223 0xd1, 0xa5, 0xeb, 0x30, 0x72, 0x2d, 0x97, 0x2f, 0x5d, 0xab, 0xac, 0xac, 0xae, 0x2f, 0xad, 0x94,
9224 0x73, 0xd7, 0x34, 0xc5, 0x1f, 0x33, 0x4a, 0xef, 0xda, 0x58, 0x32, 0x4a, 0x45, 0x2d, 0x11, 0x1c,
9225 0x5b, 0x2d, 0xe5, 0xd6, 0x4b, 0x45, 0x4d, 0xcd, 0x54, 0xe1, 0x50, 0x58, 0x9d, 0x0c, 0xcd, 0x8c,
9226 0x80, 0x8b, 0x13, 0x3d, 0x5c, 0x4c, 0x64, 0x75, 0xb9, 0xf8, 0x95, 0x04, 0x8c, 0x87, 0xac, 0x15,
9227 0xa1, 0x0f, 0x79, 0x08, 0xfa, 0x68, 0x88, 0xd2, 0xd5, 0xf3, 0x9e, 0xd0, 0x45, 0x87, 0x04, 0x6c,
9228 0xd7, 0x0a, 0x4a, 0x70, 0xc1, 0x0e, 0x42, 0xed, 0xd1, 0x41, 0x60, 0x11, 0x5d, 0x35, 0xfd, 0xff,
9229 0x74, 0xd5, 0x74, 0xba, 0xec, 0x9d, 0x8b, 0xb3, 0xec, 0x91, 0xb1, 0xfd, 0xd5, 0xf6, 0xbe, 0x90,
9230 0xda, 0x7e, 0x09, 0xc6, 0xba, 0x04, 0xc5, 0xae, 0xb1, 0x1f, 0x50, 0x20, 0xdd, 0xcb, 0x38, 0x11,
9231 0x95, 0x2e, 0x21, 0x54, 0xba, 0x4b, 0xb2, 0x05, 0x8f, 0xf7, 0x76, 0x42, 0x97, 0xaf, 0xbf, 0xa0,
9232 0xc0, 0x44, 0x78, 0xa7, 0x18, 0xaa, 0xc3, 0x83, 0xd0, 0xdf, 0x44, 0xee, 0x8e, 0xcd, 0xbb, 0xa5,
9233 0x93, 0x21, 0x6b, 0x30, 0x26, 0xcb, 0xce, 0x66, 0xa8, 0xe0, 0x22, 0xae, 0xf6, 0x6a, 0xf7, 0xa8,
9234 0x36, 0x5d, 0x9a, 0x7e, 0x38, 0x01, 0x87, 0x43, 0x85, 0x87, 0x2a, 0x7a, 0x07, 0x40, 0xdd, 0x6a,
9235 0x75, 0x5c, 0xda, 0x11, 0xd1, 0x02, 0x3b, 0x40, 0x46, 0x48, 0xf1, 0xc2, 0xc5, 0xb3, 0xe3, 0x7a,
9236 0x74, 0x95, 0xd0, 0x81, 0x0e, 0x11, 0x86, 0x0b, 0xbe, 0xa2, 0x49, 0xa2, 0xe8, 0x54, 0x8f, 0x99,
9237 0x76, 0x05, 0xe6, 0x3c, 0x68, 0xd5, 0x46, 0x1d, 0x59, 0x6e, 0xc5, 0x71, 0xdb, 0xc8, 0x6c, 0xd6,
9238 0xad, 0x6d, 0xb2, 0x82, 0xa4, 0xb2, 0x7d, 0x5b, 0x66, 0xc3, 0x41, 0xc6, 0x28, 0x25, 0xaf, 0x71,
9239 0x2a, 0x46, 0x90, 0x00, 0x6a, 0x07, 0x10, 0xfd, 0x02, 0x82, 0x92, 0x3d, 0x44, 0xe6, 0x57, 0x07,
9240 0x60, 0x30, 0xd0, 0x57, 0xeb, 0xc7, 0x61, 0xe8, 0x31, 0xf3, 0x09, 0xb3, 0xc2, 0xdf, 0x95, 0xa8,
9241 0x25, 0x06, 0xf1, 0xd8, 0x2a, 0x7b, 0x5f, 0x9a, 0x87, 0x43, 0x84, 0xc5, 0xee, 0xb8, 0xa8, 0x5d,
9242 0xa9, 0x36, 0x4c, 0xc7, 0x21, 0x46, 0x4b, 0x11, 0x56, 0x1d, 0xd3, 0x56, 0x30, 0xa9, 0xc0, 0x29,
9243 0xfa, 0x59, 0x18, 0x27, 0x88, 0x66, 0xa7, 0xe1, 0xd6, 0x5b, 0x0d, 0x54, 0xc1, 0x6f, 0x6f, 0x0e,
9244 0x59, 0x49, 0x3c, 0xcd, 0xc6, 0x30, 0xc7, 0x32, 0x63, 0xc0, 0x1a, 0x39, 0x7a, 0x11, 0xee, 0x20,
9245 0xb0, 0x6d, 0x64, 0xa1, 0xb6, 0xe9, 0xa2, 0x0a, 0x7a, 0x5f, 0xc7, 0x6c, 0x38, 0x15, 0xd3, 0xaa,
9246 0x55, 0x76, 0x4c, 0x67, 0x27, 0x7d, 0x08, 0x0b, 0xc8, 0x27, 0xd2, 0x8a, 0x71, 0x1b, 0x66, 0xbc,
9247 0xc2, 0xf8, 0x4a, 0x84, 0x2d, 0x67, 0xd5, 0x1e, 0x36, 0x9d, 0x1d, 0x3d, 0x0b, 0x13, 0x44, 0x8a,
9248 0xe3, 0xb6, 0xeb, 0xd6, 0x76, 0xa5, 0xba, 0x83, 0xaa, 0x8f, 0x57, 0x3a, 0xee, 0xd6, 0x85, 0xf4,
9249 0xed, 0xc1, 0xe7, 0x13, 0x0d, 0xd7, 0x08, 0x4f, 0x01, 0xb3, 0x6c, 0xb8, 0x5b, 0x17, 0xf4, 0x35,
9250 0x18, 0xc2, 0xce, 0x68, 0xd6, 0x9f, 0x46, 0x95, 0x2d, 0xbb, 0x4d, 0x96, 0xc6, 0x91, 0x90, 0xd2,
9251 0x14, 0xb0, 0xe0, 0xdc, 0x0a, 0x03, 0x2c, 0xdb, 0x35, 0x94, 0xed, 0x5b, 0x5b, 0x2d, 0x95, 0x8a,
9252 0xc6, 0x20, 0x97, 0x72, 0xd9, 0x6e, 0xe3, 0x80, 0xda, 0xb6, 0x3d, 0x03, 0x0f, 0xd2, 0x80, 0xda,
9253 0xb6, 0xb9, 0x79, 0xcf, 0xc2, 0x78, 0xb5, 0x4a, 0xe7, 0x5c, 0xaf, 0x56, 0xd8, 0x3b, 0x96, 0x93,
9254 0xd6, 0x04, 0x63, 0x55, 0xab, 0x57, 0x28, 0x03, 0x8b, 0x71, 0x47, 0xbf, 0x08, 0x87, 0x7d, 0x63,
9255 0x05, 0x81, 0x63, 0x5d, 0xb3, 0x94, 0xa1, 0x67, 0x61, 0xbc, 0xb5, 0xdb, 0x0d, 0xd4, 0x85, 0x27,
9256 0xb6, 0x76, 0x65, 0xd8, 0x79, 0x38, 0xd4, 0xda, 0x69, 0x75, 0xe3, 0x66, 0x83, 0x38, 0xbd, 0xb5,
9257 0xd3, 0x92, 0x81, 0x77, 0x91, 0x17, 0xee, 0x36, 0xaa, 0x9a, 0x2e, 0xaa, 0xa5, 0x8f, 0x04, 0xd9,
9258 0x03, 0x04, 0xfd, 0x14, 0x68, 0xd5, 0x6a, 0x05, 0x59, 0xe6, 0x66, 0x03, 0x55, 0xcc, 0x36, 0xb2,
9259 0x4c, 0x27, 0x3d, 0x1d, 0x64, 0x1e, 0xa9, 0x56, 0x4b, 0x84, 0x9a, 0x23, 0x44, 0x7d, 0x16, 0xc6,
9260 0xec, 0xcd, 0xc7, 0xaa, 0x34, 0x24, 0x2b, 0xad, 0x36, 0xda, 0xaa, 0x3f, 0x95, 0x3e, 0x41, 0xec,
9261 0x3b, 0x8a, 0x09, 0x24, 0x20, 0x57, 0xc9, 0xb0, 0x7e, 0x0f, 0x68, 0x55, 0x67, 0xc7, 0x6c, 0xb7,
9262 0x48, 0x4d, 0x76, 0x5a, 0x66, 0x15, 0xa5, 0xef, 0xa2, 0xac, 0x74, 0xbc, 0xcc, 0x87, 0x71, 0x4a,
9263 0x38, 0x4f, 0xd6, 0xb7, 0x5c, 0x2e, 0xf1, 0x6e, 0x9a, 0x12, 0x64, 0x8c, 0x49, 0x9b, 0x01, 0x0d,
9264 0x9b, 0x42, 0x78, 0xf0, 0x0c, 0x61, 0x1b, 0x69, 0xed, 0xb4, 0x82, 0xcf, 0xbd, 0x13, 0x86, 0x31,
9265 0xa7, 0xff, 0xd0, 0x7b, 0x68, 0x43, 0xd6, 0xda, 0x09, 0x3c, 0x71, 0x11, 0x26, 0x30, 0x53, 0x13,
9266 0xb9, 0x66, 0xcd, 0x74, 0xcd, 0x00, 0xf7, 0x7d, 0x84, 0x1b, 0xdb, 0x7d, 0x99, 0x11, 0x05, 0x3d,
9267 0xdb, 0x9d, 0xcd, 0x5d, 0x2f, 0xb2, 0xee, 0xa7, 0x7a, 0xe2, 0x31, 0x1e, 0x5b, 0x6f, 0x59, 0xd3,
9268 0x9d, 0xc9, 0xc2, 0x50, 0x30, 0xf0, 0xf5, 0x01, 0xa0, 0xa1, 0xaf, 0x29, 0xb8, 0x0b, 0x2a, 0xac,
9269 0x14, 0x71, 0xff, 0xf2, 0x9e, 0x92, 0x96, 0xc0, 0x7d, 0xd4, 0xb5, 0xa5, 0xf5, 0x52, 0xc5, 0xd8,
9270 0x28, 0xaf, 0x2f, 0x2d, 0x97, 0x34, 0x35, 0xd8, 0xb0, 0x7f, 0x3b, 0x01, 0x23, 0xe2, 0xbb, 0x97,
9271 0xfe, 0x0e, 0x38, 0xc2, 0x37, 0x4a, 0x1c, 0xe4, 0x56, 0x9e, 0xac, 0xb7, 0x49, 0x2e, 0x36, 0x4d,
9272 0xba, 0x2e, 0x7a, 0xd1, 0x70, 0x88, 0x71, 0xad, 0x21, 0xf7, 0x91, 0x7a, 0x1b, 0x67, 0x5a, 0xd3,
9273 0x74, 0xf5, 0x6b, 0x30, 0x6d, 0xd9, 0x15, 0xc7, 0x35, 0xad, 0x9a, 0xd9, 0xae, 0x55, 0xfc, 0x2d,
9274 0xaa, 0x8a, 0x59, 0xad, 0x22, 0xc7, 0xb1, 0xe9, 0x1a, 0xe8, 0x49, 0x39, 0x6a, 0xd9, 0x6b, 0x8c,
9275 0xd9, 0x5f, 0x1c, 0x72, 0x8c, 0x55, 0x8a, 0x5c, 0xb5, 0x57, 0xe4, 0xde, 0x0e, 0x03, 0x4d, 0xb3,
9276 0x55, 0x41, 0x96, 0xdb, 0xde, 0x25, 0x1d, 0x77, 0xca, 0x48, 0x35, 0xcd, 0x56, 0x09, 0x7f, 0x7f,
9277 0x7b, 0x5e, 0x7c, 0xfe, 0x51, 0x85, 0xa1, 0x60, 0xd7, 0x8d, 0x5f, 0x62, 0xaa, 0x64, 0x81, 0x52,
9278 0x48, 0x09, 0xbb, 0x73, 0xcf, 0x1e, 0x7d, 0xae, 0x80, 0x57, 0xae, 0x6c, 0x3f, 0xed, 0x85, 0x0d,
9279 0x8a, 0xc4, 0x5d, 0x03, 0x0e, 0x2d, 0x44, 0x7b, 0x8f, 0x94, 0xc1, 0xbe, 0xe9, 0x57, 0xa0, 0xff,
9280 0x31, 0x87, 0xc8, 0xee, 0x27, 0xb2, 0x4f, 0xec, 0x2d, 0xfb, 0xea, 0x1a, 0x11, 0x3e, 0x70, 0x75,
9281 0xad, 0x52, 0x5e, 0x31, 0x96, 0x73, 0xd7, 0x0c, 0x06, 0xd7, 0x6f, 0x83, 0x64, 0xc3, 0x7c, 0x7a,
9282 0x57, 0x5c, 0xe3, 0xc8, 0x50, 0x5c, 0xc3, 0xdf, 0x06, 0xc9, 0x27, 0x91, 0xf9, 0xb8, 0xb8, 0xb2,
9283 0x90, 0xa1, 0xb7, 0x30, 0xf4, 0x4f, 0x41, 0x1f, 0xb1, 0x97, 0x0e, 0xc0, 0x2c, 0xa6, 0x1d, 0xd0,
9284 0x53, 0x90, 0x2c, 0xac, 0x18, 0x38, 0xfc, 0x35, 0x18, 0xa2, 0xa3, 0x95, 0xd5, 0xa5, 0x52, 0xa1,
9285 0xa4, 0x25, 0x32, 0x67, 0xa1, 0x9f, 0x1a, 0x01, 0xa7, 0x86, 0x67, 0x06, 0xed, 0x00, 0xfb, 0xca,
9286 0x64, 0x28, 0x9c, 0xba, 0xb1, 0x9c, 0x2f, 0x19, 0x5a, 0x22, 0xe8, 0x5e, 0x07, 0x86, 0x82, 0x0d,
9287 0xf7, 0xdb, 0x13, 0x53, 0xdf, 0x54, 0x60, 0x30, 0xd0, 0x40, 0xe3, 0xce, 0xc7, 0x6c, 0x34, 0xec,
9288 0x27, 0x2b, 0x66, 0xa3, 0x6e, 0x3a, 0x2c, 0x28, 0x80, 0x0c, 0xe5, 0xf0, 0x48, 0x5c, 0xa7, 0xbd,
9289 0x2d, 0xca, 0x3f, 0xab, 0x80, 0x26, 0xf7, 0xae, 0x92, 0x82, 0xca, 0xcf, 0x54, 0xc1, 0x4f, 0x28,
9290 0x30, 0x22, 0x36, 0xac, 0x92, 0x7a, 0xc7, 0x7f, 0xa6, 0xea, 0x7d, 0x3f, 0x01, 0xc3, 0x42, 0x9b,
9291 0x1a, 0x57, 0xbb, 0xf7, 0xc1, 0x58, 0xbd, 0x86, 0x9a, 0x2d, 0xdb, 0x45, 0x56, 0x75, 0xb7, 0xd2,
9292 0x40, 0x4f, 0xa0, 0x46, 0x3a, 0x43, 0x0a, 0xc5, 0xa9, 0xbd, 0x1b, 0xe1, 0xb9, 0x25, 0x1f, 0x77,
9293 0x0d, 0xc3, 0xb2, 0xe3, 0x4b, 0xc5, 0xd2, 0xf2, 0xea, 0xca, 0x7a, 0xa9, 0x5c, 0xb8, 0x5e, 0xd9,
9294 0x28, 0xbf, 0xb3, 0xbc, 0xf2, 0x48, 0xd9, 0xd0, 0xea, 0x12, 0xdb, 0x5b, 0x98, 0xea, 0xab, 0xa0,
9295 0xc9, 0x4a, 0xe9, 0x47, 0x20, 0x4c, 0x2d, 0xed, 0x80, 0x3e, 0x0e, 0xa3, 0xe5, 0x95, 0xca, 0xda,
9296 0x52, 0xb1, 0x54, 0x29, 0x5d, 0xbe, 0x5c, 0x2a, 0xac, 0xaf, 0xd1, 0xad, 0x0d, 0x8f, 0x7b, 0x5d,
9297 0x4c, 0xea, 0x8f, 0xab, 0x30, 0x1e, 0xa2, 0x89, 0x9e, 0x63, 0x2f, 0x25, 0xf4, 0x3d, 0xe9, 0xfe,
9298 0x38, 0xda, 0xcf, 0xe1, 0xae, 0x60, 0xd5, 0x6c, 0xbb, 0xec, 0x1d, 0xe6, 0x1e, 0xc0, 0x56, 0xb2,
9299 0xdc, 0xfa, 0x56, 0x1d, 0xb5, 0xd9, 0x4e, 0x10, 0x7d, 0x53, 0x19, 0xf5, 0xc7, 0xe9, 0x66, 0xd0,
9300 0x7d, 0xa0, 0xb7, 0x6c, 0xa7, 0xee, 0xd6, 0x9f, 0x40, 0x95, 0xba, 0xc5, 0xb7, 0x8d, 0xf0, 0x9b,
9301 0x4b, 0xd2, 0xd0, 0x38, 0x65, 0xc9, 0x72, 0x3d, 0x6e, 0x0b, 0x6d, 0x9b, 0x12, 0x37, 0x2e, 0xe0,
9302 0xaa, 0xa1, 0x71, 0x8a, 0xc7, 0x7d, 0x1c, 0x86, 0x6a, 0x76, 0x07, 0xb7, 0x73, 0x94, 0x0f, 0xaf,
9303 0x17, 0x8a, 0x31, 0x48, 0xc7, 0x3c, 0x16, 0xd6, 0xa8, 0xfb, 0xfb, 0x55, 0x43, 0xc6, 0x20, 0x1d,
9304 0xa3, 0x2c, 0x77, 0xc3, 0xa8, 0xb9, 0xbd, 0xdd, 0xc6, 0xc2, 0xb9, 0x20, 0xfa, 0xea, 0x31, 0xe2,
9305 0x0d, 0x13, 0xc6, 0xc9, 0xab, 0x90, 0xe2, 0x76, 0xc0, 0x4b, 0x32, 0xb6, 0x44, 0xa5, 0x45, 0xdf,
9306 0xa7, 0x13, 0x33, 0x03, 0x46, 0xca, 0xe2, 0xc4, 0xe3, 0x30, 0x54, 0x77, 0x2a, 0xfe, 0xf6, 0x7b,
9307 0xe2, 0x58, 0x62, 0x26, 0x65, 0x0c, 0xd6, 0x1d, 0x6f, 0xeb, 0x32, 0xf3, 0x85, 0x04, 0x8c, 0x88,
9308 0xc7, 0x07, 0x7a, 0x11, 0x52, 0x0d, 0xbb, 0x6a, 0x92, 0xd0, 0xa2, 0x67, 0x57, 0x33, 0x11, 0x27,
9309 0x0e, 0x73, 0xd7, 0x18, 0xbf, 0xe1, 0x21, 0x27, 0xff, 0x4e, 0x81, 0x14, 0x1f, 0xd6, 0x27, 0x20,
9310 0xd9, 0x32, 0xdd, 0x1d, 0x22, 0xae, 0x2f, 0x9f, 0xd0, 0x14, 0x83, 0x7c, 0xc7, 0xe3, 0x4e, 0xcb,
9311 0xb4, 0x48, 0x08, 0xb0, 0x71, 0xfc, 0x1d, 0xfb, 0xb5, 0x81, 0xcc, 0x1a, 0x79, 0xaf, 0xb1, 0x9b,
9312 0x4d, 0x64, 0xb9, 0x0e, 0xf7, 0x2b, 0x1b, 0x2f, 0xb0, 0x61, 0xfd, 0x5e, 0x18, 0x73, 0xdb, 0x66,
9313 0xbd, 0x21, 0xf0, 0x26, 0x09, 0xaf, 0xc6, 0x09, 0x1e, 0x73, 0x16, 0x6e, 0xe3, 0x72, 0x6b, 0xc8,
9314 0x35, 0xab, 0x3b, 0xa8, 0xe6, 0x83, 0xfa, 0xc9, 0xfe, 0xc5, 0x11, 0xc6, 0x50, 0x64, 0x74, 0x8e,
9315 0xcd, 0x7c, 0x57, 0x81, 0x31, 0xfe, 0x26, 0x56, 0xf3, 0x8c, 0xb5, 0x0c, 0x60, 0x5a, 0x96, 0xed,
9316 0x06, 0xcd, 0xd5, 0x1d, 0xca, 0x5d, 0xb8, 0xb9, 0x9c, 0x07, 0x32, 0x02, 0x02, 0x26, 0x9b, 0x00,
9317 0x3e, 0xa5, 0xa7, 0xd9, 0xa6, 0x61, 0x90, 0x9d, 0x0d, 0x91, 0x03, 0x46, 0xfa, 0xee, 0x0e, 0x74,
9318 0x08, 0xbf, 0xb2, 0xe9, 0x87, 0xa0, 0x6f, 0x13, 0x6d, 0xd7, 0x2d, 0xb6, 0xe3, 0x4b, 0xbf, 0xf0,
9319 0x1d, 0x96, 0xa4, 0xb7, 0xc3, 0x92, 0x7f, 0x2f, 0x8c, 0x57, 0xed, 0xa6, 0xac, 0x6e, 0x5e, 0x93,
9320 0xf6, 0x0f, 0x9c, 0x87, 0x95, 0xf7, 0x80, 0xdf, 0x62, 0xfe, 0x44, 0x51, 0x3e, 0x93, 0x50, 0xaf,
9321 0xac, 0xe6, 0xbf, 0x94, 0x98, 0xbc, 0x42, 0xa1, 0xab, 0x7c, 0xa6, 0x06, 0xda, 0x6a, 0xa0, 0x2a,
9322 0xd6, 0x1e, 0x3e, 0x7f, 0x2f, 0xdc, 0xbf, 0x5d, 0x77, 0x77, 0x3a, 0x9b, 0x73, 0x55, 0xbb, 0x79,
9323 0x6a, 0xdb, 0xde, 0xb6, 0xfd, 0x33, 0x55, 0xfc, 0x8d, 0x7c, 0x21, 0x9f, 0xd8, 0xb9, 0xea, 0x80,
9324 0x37, 0x3a, 0x19, 0x79, 0x08, 0x9b, 0x2d, 0xc3, 0x38, 0x63, 0xae, 0x90, 0x83, 0x1d, 0xfa, 0x7a,
9325 0xa2, 0xef, 0xb9, 0x39, 0x96, 0xfe, 0xca, 0x0f, 0xc8, 0x72, 0x6d, 0x8c, 0x31, 0x28, 0xa6, 0xd1,
9326 0x37, 0x98, 0xac, 0x01, 0x87, 0x05, 0x79, 0x34, 0x35, 0x51, 0x3b, 0x42, 0xe2, 0xb7, 0x99, 0xc4,
9327 0xf1, 0x80, 0xc4, 0x35, 0x06, 0xcd, 0x16, 0x60, 0x78, 0x3f, 0xb2, 0xfe, 0x86, 0xc9, 0x1a, 0x42,
9328 0x41, 0x21, 0x57, 0x60, 0x94, 0x08, 0xa9, 0x76, 0x1c, 0xd7, 0x6e, 0x92, 0xba, 0xb7, 0xb7, 0x98,
9329 0xef, 0xfc, 0x80, 0xe6, 0xca, 0x08, 0x86, 0x15, 0x3c, 0x54, 0x36, 0x0b, 0xe4, 0x2c, 0xab, 0x86,
9330 0xaa, 0x8d, 0x08, 0x09, 0x37, 0x98, 0x22, 0x1e, 0x7f, 0xf6, 0xdd, 0x70, 0x08, 0x7f, 0x26, 0x65,
9331 0x29, 0xa8, 0x49, 0xf4, 0x4e, 0x5a, 0xfa, 0xbb, 0x1f, 0xa0, 0xe9, 0x38, 0xee, 0x09, 0x08, 0xe8,
9332 0x14, 0xf0, 0xe2, 0x36, 0x72, 0x5d, 0xd4, 0x76, 0x2a, 0x66, 0x23, 0x4c, 0xbd, 0xc0, 0x56, 0x44,
9333 0xfa, 0x63, 0xaf, 0x8a, 0x5e, 0xbc, 0x42, 0x91, 0xb9, 0x46, 0x23, 0xbb, 0x01, 0x47, 0x42, 0xa2,
9334 0x22, 0x86, 0xcc, 0x8f, 0x33, 0x99, 0x87, 0xba, 0x22, 0x03, 0x8b, 0x5d, 0x05, 0x3e, 0xee, 0xf9,
9335 0x32, 0x86, 0xcc, 0xdf, 0x67, 0x32, 0x75, 0x86, 0xe5, 0x2e, 0xc5, 0x12, 0xaf, 0xc2, 0xd8, 0x13,
9336 0xa8, 0xbd, 0x69, 0x3b, 0x6c, 0xfb, 0x27, 0x86, 0xb8, 0x4f, 0x30, 0x71, 0xa3, 0x0c, 0x48, 0xf6,
9337 0x83, 0xb0, 0xac, 0x8b, 0x90, 0xda, 0x32, 0xab, 0x28, 0x86, 0x88, 0x4f, 0x32, 0x11, 0x07, 0x31,
9338 0x3f, 0x86, 0xe6, 0x60, 0x68, 0xdb, 0x66, 0x2b, 0x53, 0x34, 0xfc, 0x59, 0x06, 0x1f, 0xe4, 0x18,
9339 0x26, 0xa2, 0x65, 0xb7, 0x3a, 0x0d, 0xbc, 0x6c, 0x45, 0x8b, 0xf8, 0x14, 0x17, 0xc1, 0x31, 0x4c,
9340 0xc4, 0x3e, 0xcc, 0xfa, 0x1c, 0x17, 0xe1, 0x04, 0xec, 0xf9, 0x10, 0x0c, 0xda, 0x56, 0x63, 0xd7,
9341 0xb6, 0xe2, 0x28, 0xf1, 0x69, 0x26, 0x01, 0x18, 0x04, 0x0b, 0xb8, 0x04, 0x03, 0x71, 0x1d, 0xf1,
9342 0xb9, 0x57, 0x79, 0x7a, 0x70, 0x0f, 0x5c, 0x81, 0x51, 0x5e, 0xa0, 0xea, 0xb6, 0x15, 0x43, 0xc4,
9343 0xe7, 0x99, 0x88, 0x91, 0x00, 0x8c, 0x4d, 0xc3, 0x45, 0x8e, 0xbb, 0x8d, 0xe2, 0x08, 0xf9, 0x02,
9344 0x9f, 0x06, 0x83, 0x30, 0x53, 0x6e, 0x22, 0xab, 0xba, 0x13, 0x4f, 0xc2, 0xf3, 0xdc, 0x94, 0x1c,
9345 0x83, 0x45, 0x14, 0x60, 0xb8, 0x69, 0xb6, 0x9d, 0x1d, 0xb3, 0x11, 0xcb, 0x1d, 0x5f, 0x64, 0x32,
9346 0x86, 0x3c, 0x10, 0xb3, 0x48, 0xc7, 0xda, 0x8f, 0x98, 0x2f, 0x71, 0x8b, 0x04, 0x60, 0x2c, 0xf5,
9347 0x1c, 0x97, 0xec, 0x95, 0xed, 0x47, 0xda, 0x1f, 0xf0, 0xd4, 0xa3, 0xd8, 0xe5, 0xa0, 0xc4, 0x4b,
9348 0x30, 0xe0, 0xd4, 0x9f, 0x8e, 0x25, 0xe6, 0x0f, 0xb9, 0xa7, 0x09, 0x00, 0x83, 0xaf, 0xc3, 0x6d,
9349 0xa1, 0xcb, 0x44, 0x0c, 0x61, 0x7f, 0xc4, 0x84, 0x4d, 0x84, 0x2c, 0x15, 0xac, 0x24, 0xec, 0x57,
9350 0xe4, 0x1f, 0xf3, 0x92, 0x80, 0x24, 0x59, 0xab, 0xf8, 0x5d, 0xc1, 0x31, 0xb7, 0xf6, 0x67, 0xb5,
9351 0x3f, 0xe1, 0x56, 0xa3, 0x58, 0xc1, 0x6a, 0xeb, 0x30, 0xc1, 0x24, 0xee, 0xcf, 0xaf, 0x5f, 0xe6,
9352 0x85, 0x95, 0xa2, 0x37, 0x44, 0xef, 0xbe, 0x17, 0x26, 0x3d, 0x73, 0xf2, 0xa6, 0xd4, 0xa9, 0x34,
9353 0xcd, 0x56, 0x0c, 0xc9, 0x5f, 0x61, 0x92, 0x79, 0xc5, 0xf7, 0xba, 0x5a, 0x67, 0xd9, 0x6c, 0x61,
9354 0xe1, 0x8f, 0x42, 0x9a, 0x0b, 0xef, 0x58, 0x6d, 0x54, 0xb5, 0xb7, 0xad, 0xfa, 0xd3, 0xa8, 0x16,
9355 0x43, 0xf4, 0x9f, 0x4a, 0xae, 0xda, 0x08, 0xc0, 0xb1, 0xe4, 0x25, 0xd0, 0xbc, 0x5e, 0xa5, 0x52,
9356 0x6f, 0xb6, 0xec, 0xb6, 0x1b, 0x21, 0xf1, 0xcf, 0xb8, 0xa7, 0x3c, 0xdc, 0x12, 0x81, 0x65, 0x4b,
9357 0x30, 0x42, 0xbe, 0xc6, 0x0d, 0xc9, 0xaf, 0x32, 0x41, 0xc3, 0x3e, 0x8a, 0x15, 0x8e, 0xaa, 0xdd,
9358 0x6c, 0x99, 0xed, 0x38, 0xf5, 0xef, 0xcf, 0x79, 0xe1, 0x60, 0x10, 0x56, 0x38, 0xdc, 0xdd, 0x16,
9359 0xc2, 0xab, 0x7d, 0x0c, 0x09, 0x5f, 0xe3, 0x85, 0x83, 0x63, 0x98, 0x08, 0xde, 0x30, 0xc4, 0x10,
9360 0xf1, 0x17, 0x5c, 0x04, 0xc7, 0x60, 0x11, 0xef, 0xf2, 0x17, 0xda, 0x36, 0xda, 0xae, 0x3b, 0x6e,
9361 0x9b, 0xb6, 0xc2, 0x7b, 0x8b, 0xfa, 0xfa, 0xab, 0x62, 0x13, 0x66, 0x04, 0xa0, 0xb8, 0x12, 0xb1,
9362 0x2d, 0x54, 0xf2, 0xa6, 0x14, 0xad, 0xd8, 0x37, 0x78, 0x25, 0x0a, 0xc0, 0xb0, 0x6e, 0x81, 0x0e,
9363 0x11, 0x9b, 0xbd, 0x8a, 0xdf, 0x0f, 0x62, 0x88, 0xfb, 0xa6, 0xa4, 0xdc, 0x1a, 0xc7, 0x62, 0x99,
9364 0x81, 0xfe, 0xa7, 0x63, 0x3d, 0x8e, 0x76, 0x63, 0x45, 0xe7, 0x5f, 0x4a, 0xfd, 0xcf, 0x06, 0x45,
9365 0xd2, 0x1a, 0x32, 0x2a, 0xf5, 0x53, 0x7a, 0xd4, 0x2d, 0xa0, 0xf4, 0xff, 0x7f, 0x8d, 0xcd, 0x57,
9366 0x6c, 0xa7, 0xb2, 0xd7, 0x70, 0x90, 0x8b, 0x4d, 0x4f, 0xb4, 0xb0, 0x0f, 0xbc, 0xe6, 0xc5, 0xb9,
9367 0xd0, 0xf3, 0x64, 0x2f, 0xc3, 0xb0, 0xd0, 0xf0, 0x44, 0x8b, 0xfa, 0x05, 0x26, 0x6a, 0x28, 0xd8,
9368 0xef, 0x64, 0xcf, 0x42, 0x12, 0x37, 0x2f, 0xd1, 0xf0, 0x5f, 0x64, 0x70, 0xc2, 0x9e, 0x7d, 0x00,
9369 0x52, 0xbc, 0x69, 0x89, 0x86, 0x7e, 0x90, 0x41, 0x3d, 0x08, 0x86, 0xf3, 0x86, 0x25, 0x1a, 0xfe,
9370 0x4b, 0x1c, 0xce, 0x21, 0x18, 0x1e, 0xdf, 0x84, 0x2f, 0xfc, 0x4a, 0x92, 0x2d, 0x3a, 0xdc, 0x76,
9371 0x97, 0xe0, 0x20, 0xeb, 0x54, 0xa2, 0xd1, 0x1f, 0x66, 0x0f, 0xe7, 0x88, 0xec, 0x79, 0xe8, 0x8b,
9372 0x69, 0xf0, 0x5f, 0x63, 0x50, 0xca, 0x9f, 0x2d, 0xc0, 0x60, 0xa0, 0x3b, 0x89, 0x86, 0xff, 0x3a,
9373 0x83, 0x07, 0x51, 0x58, 0x75, 0xd6, 0x9d, 0x44, 0x0b, 0xf8, 0x0d, 0xae, 0x3a, 0x43, 0x60, 0xb3,
9374 0xf1, 0xc6, 0x24, 0x1a, 0xfd, 0x9b, 0xdc, 0xea, 0x1c, 0x92, 0x7d, 0x08, 0x06, 0xbc, 0xc5, 0x26,
9375 0x1a, 0xff, 0x5b, 0x0c, 0xef, 0x63, 0xb0, 0x05, 0x02, 0x8b, 0x5d, 0xb4, 0x88, 0xdf, 0xe6, 0x16,
9376 0x08, 0xa0, 0x70, 0x1a, 0xc9, 0x0d, 0x4c, 0xb4, 0xa4, 0x8f, 0xf0, 0x34, 0x92, 0xfa, 0x17, 0xec,
9377 0x4d, 0x52, 0xf3, 0xa3, 0x45, 0xfc, 0x0e, 0xf7, 0x26, 0xe1, 0xc7, 0x6a, 0xc8, 0x1d, 0x41, 0xb4,
9378 0x8c, 0xdf, 0xe3, 0x6a, 0x48, 0x0d, 0x41, 0x76, 0x15, 0xf4, 0xee, 0x6e, 0x20, 0x5a, 0xde, 0x47,
9379 0x99, 0xbc, 0xb1, 0xae, 0x66, 0x20, 0xfb, 0x08, 0x4c, 0x84, 0x77, 0x02, 0xd1, 0x52, 0x3f, 0xf6,
9380 0x9a, 0xf4, 0xee, 0x16, 0x6c, 0x04, 0xb2, 0xeb, 0xfe, 0x92, 0x12, 0xec, 0x02, 0xa2, 0xc5, 0x7e,
9381 0xfc, 0x35, 0xb1, 0x70, 0x07, 0x9b, 0x80, 0x6c, 0x0e, 0xc0, 0x5f, 0x80, 0xa3, 0x65, 0x7d, 0x82,
9382 0xc9, 0x0a, 0x80, 0x70, 0x6a, 0xb0, 0xf5, 0x37, 0x1a, 0xff, 0x49, 0x9e, 0x1a, 0x0c, 0x81, 0x53,
9383 0x83, 0x2f, 0xbd, 0xd1, 0xe8, 0x67, 0x79, 0x6a, 0x70, 0x08, 0x8e, 0xec, 0xc0, 0xea, 0x16, 0x2d,
9384 0xe1, 0xd3, 0x3c, 0xb2, 0x03, 0xa8, 0x6c, 0x19, 0xc6, 0xba, 0x16, 0xc4, 0x68, 0x51, 0x9f, 0x61,
9385 0xa2, 0x34, 0x79, 0x3d, 0x0c, 0x2e, 0x5e, 0x6c, 0x31, 0x8c, 0x96, 0xf6, 0x59, 0x69, 0xf1, 0x62,
9386 0x6b, 0x61, 0xf6, 0x12, 0xa4, 0xac, 0x4e, 0xa3, 0x81, 0x93, 0x47, 0xdf, 0xfb, 0xe6, 0x5e, 0xfa,
9387 0x9f, 0x5f, 0x67, 0xd6, 0xe1, 0x80, 0xec, 0x59, 0xe8, 0x43, 0xcd, 0x4d, 0x54, 0x8b, 0x42, 0xfe,
9388 0xcb, 0xeb, 0xbc, 0x60, 0x62, 0xee, 0xec, 0x43, 0x00, 0x74, 0x6b, 0x84, 0x1c, 0xfb, 0x45, 0x60,
9389 0xff, 0xf5, 0x75, 0x76, 0xa7, 0xc6, 0x87, 0xf8, 0x02, 0xe8, 0x0d, 0x9d, 0xbd, 0x05, 0xbc, 0x2a,
9390 0x0a, 0x20, 0x1e, 0xb9, 0x08, 0x07, 0x1f, 0x73, 0x6c, 0xcb, 0x35, 0xb7, 0xa3, 0xd0, 0xff, 0xc6,
9391 0xd0, 0x9c, 0x1f, 0x1b, 0xac, 0x69, 0xb7, 0x91, 0x6b, 0x6e, 0x3b, 0x51, 0xd8, 0x7f, 0x67, 0x58,
9392 0x0f, 0x80, 0xc1, 0x55, 0xd3, 0x71, 0xe3, 0xcc, 0xfb, 0x3f, 0x38, 0x98, 0x03, 0xb0, 0xd2, 0xf8,
9393 0xf3, 0xe3, 0x68, 0x37, 0x0a, 0xfb, 0x23, 0xae, 0x34, 0xe3, 0xcf, 0x3e, 0x00, 0x03, 0xf8, 0x23,
9394 0xbd, 0x28, 0x17, 0x01, 0xfe, 0x4f, 0x06, 0xf6, 0x11, 0xf8, 0xc9, 0x8e, 0x5b, 0x73, 0xeb, 0xd1,
9395 0xc6, 0xfe, 0x31, 0xf3, 0x34, 0xe7, 0xcf, 0xe6, 0x60, 0xd0, 0x71, 0x6b, 0xb5, 0x0e, 0xeb, 0x4f,
9396 0x23, 0xe0, 0xff, 0xf5, 0xba, 0xb7, 0x65, 0xe1, 0x61, 0xb0, 0xb7, 0x9f, 0x7c, 0xdc, 0x6d, 0xd9,
9397 0xe4, 0x98, 0x23, 0x4a, 0xc2, 0x6b, 0x4c, 0x42, 0x00, 0x92, 0x2f, 0x85, 0x6f, 0xdf, 0xc2, 0x15,
9398 0xfb, 0x8a, 0x4d, 0x37, 0x6e, 0xdf, 0x93, 0x89, 0xde, 0x81, 0x85, 0xef, 0x34, 0xe0, 0xb6, 0xaa,
9399 0xdd, 0xdc, 0xb4, 0x9d, 0x53, 0x9b, 0xb6, 0xbb, 0x73, 0xca, 0xdd, 0x41, 0x78, 0x01, 0x66, 0x9b,
9400 0xb2, 0x49, 0xfc, 0x79, 0x72, 0x7f, 0x3b, 0xb9, 0xe4, 0x9c, 0xbe, 0x5c, 0xc7, 0xca, 0x97, 0xc9,
9401 0x51, 0x89, 0x7e, 0x14, 0xfa, 0xc9, 0x74, 0x4e, 0x93, 0xe3, 0x48, 0x25, 0x9f, 0xbc, 0xf1, 0xd2,
9402 0xf4, 0x01, 0x83, 0x8d, 0x79, 0xd4, 0x05, 0xb2, 0x97, 0x9d, 0x10, 0xa8, 0x0b, 0x1e, 0xf5, 0x0c,
9403 0xdd, 0xce, 0x16, 0xa8, 0x67, 0x3c, 0xea, 0x22, 0xd9, 0xd8, 0x56, 0x05, 0xea, 0xa2, 0x47, 0x3d,
9404 0x4b, 0x0e, 0x6f, 0x86, 0x05, 0xea, 0x59, 0x8f, 0x7a, 0x8e, 0x1c, 0xd9, 0x24, 0x05, 0xea, 0x39,
9405 0x8f, 0x7a, 0x9e, 0x9c, 0xd6, 0x8c, 0x09, 0xd4, 0xf3, 0x1e, 0xf5, 0x02, 0x39, 0xa5, 0xd1, 0x05,
9406 0xea, 0x05, 0x8f, 0x7a, 0x91, 0xdc, 0xad, 0x3a, 0x28, 0x50, 0x2f, 0xea, 0x53, 0x70, 0x90, 0xce,
9407 0x7c, 0x9e, 0x1c, 0xe9, 0x8f, 0x32, 0x32, 0x1f, 0xf4, 0xe9, 0xa7, 0xc9, 0x3d, 0xaa, 0x7e, 0x91,
9408 0x7e, 0xda, 0xa7, 0x2f, 0x90, 0x3f, 0xe9, 0xd0, 0x44, 0xfa, 0x82, 0x4f, 0x3f, 0x93, 0x1e, 0x26,
9409 0x77, 0xc9, 0x04, 0xfa, 0x19, 0x9f, 0xbe, 0x98, 0x1e, 0xc1, 0x39, 0x21, 0xd2, 0x17, 0x7d, 0xfa,
9410 0xd9, 0xf4, 0xe8, 0x31, 0x65, 0x66, 0x48, 0xa4, 0x9f, 0xcd, 0xbc, 0x9f, 0xb8, 0xd7, 0xf2, 0xdd,
9411 0x3b, 0x21, 0xba, 0xd7, 0x73, 0xec, 0x84, 0xe8, 0x58, 0xcf, 0xa5, 0x13, 0xa2, 0x4b, 0x3d, 0x67,
9412 0x4e, 0x88, 0xce, 0xf4, 0xdc, 0x38, 0x21, 0xba, 0xd1, 0x73, 0xe0, 0x84, 0xe8, 0x40, 0xcf, 0x75,
9413 0x13, 0xa2, 0xeb, 0x3c, 0xa7, 0x4d, 0x88, 0x4e, 0xf3, 0xdc, 0x35, 0x21, 0xba, 0xcb, 0x73, 0x54,
9414 0x5a, 0x72, 0x94, 0xef, 0xa2, 0xb4, 0xe4, 0x22, 0xdf, 0x39, 0x69, 0xc9, 0x39, 0xbe, 0x5b, 0xd2,
9415 0x92, 0x5b, 0x7c, 0x87, 0xa4, 0x25, 0x87, 0xf8, 0xae, 0x48, 0x4b, 0xae, 0xf0, 0x9d, 0xc0, 0x72,
9416 0xcc, 0x40, 0xad, 0x90, 0x1c, 0x53, 0xf7, 0xcc, 0x31, 0x75, 0xcf, 0x1c, 0x53, 0xf7, 0xcc, 0x31,
9417 0x75, 0xcf, 0x1c, 0x53, 0xf7, 0xcc, 0x31, 0x75, 0xcf, 0x1c, 0x53, 0xf7, 0xcc, 0x31, 0x75, 0xcf,
9418 0x1c, 0x53, 0xf7, 0xce, 0x31, 0x35, 0x22, 0xc7, 0xd4, 0x88, 0x1c, 0x53, 0x23, 0x72, 0x4c, 0x8d,
9419 0xc8, 0x31, 0x35, 0x22, 0xc7, 0xd4, 0x9e, 0x39, 0xe6, 0xbb, 0x77, 0x42, 0x74, 0x6f, 0x68, 0x8e,
9420 0xa9, 0x3d, 0x72, 0x4c, 0xed, 0x91, 0x63, 0x6a, 0x8f, 0x1c, 0x53, 0x7b, 0xe4, 0x98, 0xda, 0x23,
9421 0xc7, 0xd4, 0x1e, 0x39, 0xa6, 0xf6, 0xc8, 0x31, 0xb5, 0x57, 0x8e, 0xa9, 0x3d, 0x73, 0x4c, 0xed,
9422 0x99, 0x63, 0x6a, 0xcf, 0x1c, 0x53, 0x7b, 0xe6, 0x98, 0xda, 0x33, 0xc7, 0xd4, 0x60, 0x8e, 0xfd,
9423 0x95, 0x0a, 0x3a, 0xcd, 0xb1, 0x55, 0x72, 0x29, 0x8c, 0xb9, 0x62, 0x4a, 0xca, 0xb4, 0x7e, 0xec,
9424 0x3a, 0xcd, 0x77, 0xc9, 0x94, 0x94, 0x6b, 0x22, 0x7d, 0xc1, 0xa3, 0xf3, 0x6c, 0x13, 0xe9, 0x67,
9425 0x3c, 0x3a, 0xcf, 0x37, 0x91, 0xbe, 0xe8, 0xd1, 0x79, 0xc6, 0x89, 0xf4, 0xb3, 0x1e, 0x9d, 0xe7,
9426 0x9c, 0x48, 0x3f, 0xe7, 0xd1, 0x79, 0xd6, 0x89, 0xf4, 0xf3, 0x1e, 0x9d, 0xe7, 0x9d, 0x48, 0xbf,
9427 0xe0, 0xd1, 0x79, 0xe6, 0x89, 0xf4, 0x8b, 0xfa, 0x31, 0x39, 0xf7, 0x38, 0x83, 0xe7, 0xda, 0x63,
9428 0x72, 0xf6, 0x49, 0x1c, 0xa7, 0x7d, 0x0e, 0x9e, 0x7f, 0x12, 0xc7, 0x82, 0xcf, 0xc1, 0x33, 0x50,
9429 0xe2, 0x38, 0x93, 0xf9, 0x10, 0x71, 0x9f, 0x25, 0xbb, 0x6f, 0x52, 0x72, 0x5f, 0x22, 0xe0, 0xba,
9430 0x49, 0xc9, 0x75, 0x89, 0x80, 0xdb, 0x26, 0x25, 0xb7, 0x25, 0x02, 0x2e, 0x9b, 0x94, 0x5c, 0x96,
9431 0x08, 0xb8, 0x6b, 0x52, 0x72, 0x57, 0x22, 0xe0, 0xaa, 0x49, 0xc9, 0x55, 0x89, 0x80, 0x9b, 0x26,
9432 0x25, 0x37, 0x25, 0x02, 0x2e, 0x9a, 0x94, 0x5c, 0x94, 0x08, 0xb8, 0x67, 0x52, 0x72, 0x4f, 0x22,
9433 0xe0, 0x9a, 0xa3, 0xb2, 0x6b, 0x12, 0x41, 0xb7, 0x1c, 0x95, 0xdd, 0x92, 0x08, 0xba, 0xe4, 0xa8,
9434 0xec, 0x92, 0x44, 0xd0, 0x1d, 0x47, 0x65, 0x77, 0x24, 0x82, 0xae, 0xf8, 0x69, 0x82, 0x77, 0x84,
9435 0x6b, 0x6e, 0xbb, 0x53, 0x75, 0x6f, 0xa9, 0x23, 0x9c, 0x17, 0xda, 0x87, 0xc1, 0x05, 0x7d, 0x8e,
9436 0x34, 0xac, 0xc1, 0x8e, 0x53, 0x5a, 0xc1, 0xe6, 0x85, 0xc6, 0x22, 0x80, 0xb0, 0xc2, 0x11, 0x8b,
9437 0xb7, 0xd4, 0x1b, 0xce, 0x0b, 0x6d, 0x46, 0xb4, 0x7e, 0x17, 0xde, 0xf2, 0x8e, 0xed, 0x85, 0x04,
9438 0xef, 0xd8, 0x98, 0xf9, 0xf7, 0xdb, 0xb1, 0xcd, 0x46, 0x9b, 0xdc, 0x33, 0xf6, 0x6c, 0xb4, 0xb1,
9439 0xbb, 0x56, 0x9d, 0xb8, 0x1d, 0xdc, 0x6c, 0xb4, 0x69, 0x3d, 0xa3, 0xbe, 0xb9, 0xfd, 0x16, 0x8b,
9440 0x60, 0x03, 0xb5, 0x42, 0x22, 0x78, 0xbf, 0xfd, 0xd6, 0xbc, 0x50, 0x4a, 0xf6, 0x1b, 0xc1, 0xea,
9441 0xbe, 0x23, 0x78, 0xbf, 0x9d, 0xd7, 0xbc, 0x50, 0x5e, 0xf6, 0x1d, 0xc1, 0x6f, 0x41, 0x3f, 0xc4,
9442 0x22, 0xd8, 0x37, 0xff, 0x7e, 0xfb, 0xa1, 0xd9, 0x68, 0x93, 0x87, 0x46, 0xb0, 0xba, 0x8f, 0x08,
9443 0x8e, 0xd3, 0x1f, 0xcd, 0x46, 0x9b, 0x36, 0x3c, 0x82, 0x6f, 0xb9, 0x9b, 0xf9, 0x94, 0x02, 0x63,
9444 0xe5, 0x7a, 0xad, 0xd4, 0xdc, 0x44, 0xb5, 0x1a, 0xaa, 0x31, 0x3b, 0xce, 0x0b, 0x95, 0xa0, 0x87,
9445 0xab, 0x5f, 0x7c, 0x69, 0xda, 0xb7, 0xf0, 0x59, 0x48, 0x51, 0x9b, 0xce, 0xcf, 0xa7, 0x6f, 0x28,
9446 0x11, 0x15, 0xce, 0x63, 0xd5, 0x8f, 0x73, 0xd8, 0xe9, 0xf9, 0xf4, 0xdf, 0x2b, 0x81, 0x2a, 0xe7,
9447 0x0d, 0x67, 0x3e, 0x42, 0x34, 0xb4, 0x6e, 0x59, 0xc3, 0x53, 0xb1, 0x34, 0x0c, 0xe8, 0x76, 0x7b,
9448 0x97, 0x6e, 0x01, 0xad, 0x3a, 0x30, 0x5a, 0xae, 0xd7, 0xca, 0xe4, 0xc7, 0x04, 0xe2, 0xa8, 0x44,
9449 0x79, 0xa4, 0x7a, 0x30, 0x2f, 0x84, 0x65, 0x10, 0xe1, 0x85, 0xb4, 0x58, 0x23, 0x32, 0x75, 0xfc,
9450 0x58, 0x4b, 0x78, 0xec, 0x6c, 0xaf, 0xc7, 0xfa, 0x95, 0xdd, 0x7b, 0xe0, 0x6c, 0xaf, 0x07, 0xfa,
9451 0x39, 0xe4, 0x3d, 0xea, 0x29, 0xbe, 0x38, 0xd3, 0xab, 0x59, 0xfa, 0x51, 0x48, 0x2c, 0xd1, 0x9b,
9452 0xe3, 0x43, 0xf9, 0x21, 0xac, 0xd4, 0xf7, 0x5e, 0x9a, 0x4e, 0x6e, 0x74, 0xea, 0x35, 0x23, 0xb1,
9453 0x54, 0xd3, 0xaf, 0x42, 0xdf, 0xbb, 0xd9, 0x9f, 0xb4, 0x62, 0x86, 0x45, 0xc6, 0x70, 0x5f, 0xcf,
9454 0x3d, 0x22, 0xfc, 0xe0, 0x53, 0x74, 0x9b, 0x72, 0x6e, 0xa3, 0x6e, 0xb9, 0xa7, 0x17, 0x2e, 0x18,
9455 0x54, 0x44, 0xe6, 0x7f, 0x03, 0xd0, 0x67, 0x16, 0x4d, 0x67, 0x47, 0x2f, 0x73, 0xc9, 0xf4, 0xd1,
9456 0x17, 0xbe, 0xf7, 0xd2, 0xf4, 0x62, 0x1c, 0xa9, 0xf7, 0xd7, 0x4c, 0x67, 0xe7, 0x7e, 0x77, 0xb7,
9457 0x85, 0xe6, 0xf2, 0xbb, 0x2e, 0x72, 0xb8, 0xf4, 0x16, 0x5f, 0xf5, 0xd8, 0xbc, 0xd2, 0x81, 0x79,
9458 0xa5, 0x84, 0x39, 0x5d, 0x16, 0xe7, 0x34, 0xff, 0x46, 0xe7, 0xf3, 0x14, 0x5f, 0x24, 0x24, 0x4b,
9459 0xaa, 0x51, 0x96, 0x54, 0x6f, 0xd5, 0x92, 0x2d, 0x5e, 0x1f, 0xa5, 0xb9, 0xaa, 0x7b, 0xcd, 0x55,
9460 0xbd, 0x95, 0xb9, 0xfe, 0x37, 0xcd, 0x56, 0x2f, 0x9f, 0x36, 0x2c, 0x7a, 0x6b, 0xf5, 0xe7, 0x6b,
9461 0x2f, 0xe8, 0x4d, 0xed, 0x02, 0xb2, 0xc9, 0x1b, 0xcf, 0x4d, 0x2b, 0x99, 0x4f, 0x25, 0xf8, 0xcc,
9462 0x69, 0x22, 0xbd, 0xb1, 0x99, 0xff, 0xbc, 0xf4, 0x54, 0x6f, 0x85, 0x85, 0x9e, 0x55, 0x60, 0xa2,
9463 0xab, 0x92, 0x53, 0x33, 0xbd, 0xb9, 0xe5, 0xdc, 0xda, 0x6f, 0x39, 0x67, 0x0a, 0x7e, 0x55, 0x81,
9464 0x43, 0x52, 0x79, 0xa5, 0xea, 0x9d, 0x92, 0xd4, 0x3b, 0xd2, 0xfd, 0x24, 0xc2, 0x18, 0xd0, 0x2e,
9465 0xe8, 0x5e, 0x09, 0x10, 0x90, 0xec, 0xf9, 0x7d, 0x51, 0xf2, 0xfb, 0x51, 0x0f, 0x10, 0x62, 0x2e,
9466 0x1e, 0x01, 0x4c, 0x6d, 0x1b, 0x92, 0xeb, 0x6d, 0x84, 0xf4, 0x29, 0x48, 0xac, 0xb4, 0x99, 0x86,
9467 0x23, 0x14, 0xbf, 0xd2, 0xce, 0xb7, 0x4d, 0xab, 0xba, 0x63, 0x24, 0x56, 0xda, 0xfa, 0x71, 0x50,
9468 0x73, 0xec, 0xcf, 0xe9, 0x07, 0x17, 0x46, 0x29, 0x43, 0xce, 0xaa, 0x31, 0x0e, 0x4c, 0xd3, 0xa7,
9469 0x20, 0x79, 0x0d, 0x99, 0x5b, 0x4c, 0x09, 0xa0, 0x3c, 0x78, 0xc4, 0x20, 0xe3, 0xec, 0x81, 0x8f,
9470 0x42, 0x8a, 0x0b, 0xd6, 0x4f, 0x60, 0xc4, 0x96, 0xcb, 0x1e, 0xcb, 0x10, 0x58, 0x1d, 0xb6, 0x72,
9471 0x11, 0xaa, 0x7e, 0x12, 0xfa, 0x8c, 0xfa, 0xf6, 0x8e, 0xcb, 0x1e, 0xde, 0xcd, 0x46, 0xc9, 0x99,
9472 0xeb, 0x30, 0xe0, 0x69, 0xf4, 0x26, 0x8b, 0x2e, 0xd2, 0xa9, 0xe9, 0x93, 0xc1, 0xf5, 0x84, 0xef,
9473 0x5b, 0xd2, 0x21, 0xfd, 0x18, 0xa4, 0xd6, 0xdc, 0xb6, 0x5f, 0xf4, 0x79, 0x47, 0xea, 0x8d, 0x66,
9474 0xde, 0xaf, 0x40, 0xaa, 0x88, 0x50, 0x8b, 0x18, 0xfc, 0x2e, 0x48, 0x16, 0xed, 0x27, 0x2d, 0xa6,
9475 0xe0, 0x18, 0xb3, 0x28, 0x26, 0x33, 0x9b, 0x12, 0xb2, 0x7e, 0x57, 0xd0, 0xee, 0xe3, 0x9e, 0xdd,
9476 0x03, 0x7c, 0xc4, 0xf6, 0x19, 0xc1, 0xf6, 0xcc, 0x81, 0x98, 0xa9, 0xcb, 0xfe, 0xe7, 0x61, 0x30,
9477 0xf0, 0x14, 0x7d, 0x86, 0xa9, 0x91, 0x90, 0x81, 0x41, 0x5b, 0x61, 0x8e, 0x0c, 0x82, 0x61, 0xe1,
9478 0xc1, 0x18, 0x1a, 0x30, 0x71, 0x0f, 0x28, 0x31, 0xf3, 0xac, 0x68, 0xe6, 0x70, 0x56, 0x66, 0xea,
9479 0x79, 0x6a, 0x23, 0x62, 0xee, 0x13, 0x34, 0x38, 0x7b, 0x3b, 0x11, 0x7f, 0xce, 0xf4, 0x81, 0x5a,
9480 0xae, 0x37, 0x32, 0x0f, 0x00, 0xd0, 0x94, 0x2f, 0x59, 0x9d, 0xa6, 0x94, 0x75, 0x23, 0xdc, 0xc0,
9481 0xeb, 0x3b, 0x68, 0x1d, 0x39, 0x84, 0x45, 0xec, 0xa7, 0x70, 0x81, 0x01, 0x9a, 0x62, 0x04, 0x7f,
9482 0x4f, 0x24, 0x3e, 0xb4, 0x13, 0xc3, 0xac, 0x69, 0xca, 0x7a, 0x1d, 0xb9, 0x39, 0xcb, 0x76, 0x77,
9483 0x50, 0x5b, 0x42, 0x2c, 0xe8, 0x67, 0x84, 0x84, 0x1d, 0x59, 0xb8, 0xdd, 0x43, 0xf4, 0x04, 0x9d,
9484 0xc9, 0x7c, 0x99, 0x28, 0x88, 0x5b, 0x81, 0xae, 0x09, 0xaa, 0x31, 0x26, 0xa8, 0x9f, 0x13, 0xfa,
9485 0xb7, 0x3d, 0xd4, 0x94, 0x5e, 0x2d, 0x2f, 0x0a, 0xef, 0x39, 0x7b, 0x2b, 0x2b, 0xbe, 0x63, 0x72,
9486 0x9b, 0x72, 0x95, 0xef, 0x89, 0x54, 0xb9, 0x47, 0x77, 0xbb, 0x5f, 0x9b, 0xaa, 0x71, 0x6d, 0xfa,
9487 0x4d, 0xaf, 0xe3, 0xa0, 0xbf, 0x59, 0x42, 0x7e, 0xed, 0x47, 0xbf, 0x2f, 0xd2, 0xf7, 0x59, 0xa5,
9488 0xe0, 0xa9, 0xba, 0x18, 0xd7, 0xfd, 0xd9, 0x44, 0x3e, 0xef, 0xa9, 0x7b, 0x7e, 0x1f, 0x21, 0x90,
9489 0x4d, 0x14, 0x0a, 0x5e, 0xd9, 0x4e, 0x7d, 0xe8, 0xb9, 0x69, 0xe5, 0xf9, 0xe7, 0xa6, 0x0f, 0x64,
9490 0xbe, 0xa8, 0xc0, 0x18, 0xe3, 0x0c, 0x04, 0xee, 0xfd, 0x92, 0xf2, 0x87, 0x79, 0xcd, 0x08, 0xb3,
9491 0xc0, 0xdb, 0x16, 0xbc, 0xdf, 0x56, 0x20, 0xdd, 0xa5, 0x2b, 0xb7, 0xf7, 0x7c, 0x2c, 0x95, 0xb3,
9492 0x4a, 0xe9, 0x67, 0x6f, 0xf3, 0xeb, 0xd0, 0xb7, 0x5e, 0x6f, 0xa2, 0x36, 0x5e, 0x09, 0xf0, 0x07,
9493 0xaa, 0x32, 0x3f, 0xcc, 0xa1, 0x43, 0x9c, 0x46, 0x95, 0x13, 0x68, 0x0b, 0x7a, 0x1a, 0x92, 0x45,
9494 0xd3, 0x35, 0x89, 0x06, 0x43, 0x5e, 0x7d, 0x35, 0x5d, 0x33, 0x73, 0x06, 0x86, 0x96, 0x77, 0xc9,
9495 0x55, 0xa3, 0x1a, 0xb9, 0x65, 0x22, 0x76, 0x7f, 0xbc, 0x5f, 0x3d, 0x3d, 0xdb, 0x97, 0xaa, 0x69,
9496 0x37, 0x94, 0x6c, 0x92, 0xe8, 0xf3, 0x04, 0x8c, 0xac, 0x60, 0xb5, 0x09, 0x4e, 0x80, 0xd1, 0xa7,
9497 0xab, 0xde, 0xe4, 0xa5, 0xa6, 0x4c, 0xf5, 0x9b, 0xb2, 0x63, 0xa0, 0x2c, 0x8b, 0xad, 0x53, 0x50,
9498 0x0f, 0x43, 0x59, 0x9e, 0x4d, 0xa6, 0x46, 0xb4, 0xb1, 0xd9, 0x64, 0x0a, 0xb4, 0x61, 0xf6, 0xdc,
9499 0xbf, 0x55, 0x41, 0xa3, 0xad, 0x4e, 0x11, 0x6d, 0xd5, 0xad, 0xba, 0xdb, 0xdd, 0xaf, 0x7a, 0x1a,
9500 0xeb, 0x0f, 0xc1, 0x00, 0x36, 0xe9, 0x65, 0xf6, 0xa3, 0x7f, 0xd8, 0xf4, 0xc7, 0x59, 0x8b, 0x22,
9501 0x89, 0x60, 0x03, 0x24, 0x74, 0x7c, 0x8c, 0x7e, 0x19, 0xd4, 0x72, 0x79, 0x99, 0x2d, 0x6e, 0x8b,
9502 0x7b, 0x42, 0xd9, 0x75, 0x1e, 0xf6, 0x8d, 0x8d, 0x39, 0xdb, 0x06, 0x16, 0xa0, 0x2f, 0x42, 0xa2,
9503 0xbc, 0xcc, 0x1a, 0xde, 0x13, 0x71, 0xc4, 0x18, 0x89, 0xf2, 0xf2, 0xe4, 0x5f, 0x2b, 0x30, 0x2c,
9504 0x8c, 0xea, 0x19, 0x18, 0xa2, 0x03, 0x81, 0xe9, 0xf6, 0x1b, 0xc2, 0x18, 0xd7, 0x39, 0x71, 0x8b,
9505 0x3a, 0x4f, 0xe6, 0x60, 0x54, 0x1a, 0xd7, 0xe7, 0x40, 0x0f, 0x0e, 0x31, 0x25, 0xe8, 0x0f, 0x8e,
9506 0x85, 0x50, 0x32, 0x77, 0x00, 0xf8, 0x76, 0xf5, 0x7e, 0x27, 0xab, 0x5c, 0x5a, 0x5b, 0x2f, 0x15,
9507 0x35, 0x25, 0xf3, 0x35, 0x05, 0x06, 0x59, 0xdb, 0x5a, 0xb5, 0x5b, 0x48, 0xcf, 0x83, 0x92, 0x63,
9508 0xf1, 0xf0, 0xc6, 0xf4, 0x56, 0x72, 0xfa, 0x29, 0x50, 0xf2, 0xf1, 0x5d, 0xad, 0xe4, 0xf5, 0x05,
9509 0x50, 0x0a, 0xcc, 0xc1, 0xf1, 0x3c, 0xa3, 0x14, 0x32, 0x3f, 0x56, 0x61, 0x3c, 0xd8, 0x46, 0xf3,
9510 0x7a, 0x72, 0x5c, 0x7c, 0x6f, 0xca, 0x0e, 0x9c, 0x5e, 0x38, 0xb3, 0x38, 0x87, 0xff, 0xf1, 0x42,
9511 0x32, 0x23, 0xbe, 0x42, 0x65, 0xc1, 0x63, 0x39, 0xdd, 0xeb, 0x9e, 0x48, 0x36, 0x19, 0x90, 0xd0,
9512 0x75, 0x4f, 0x44, 0xa0, 0x76, 0xdd, 0x13, 0x11, 0xa8, 0x5d, 0xf7, 0x44, 0x04, 0x6a, 0xd7, 0x59,
9513 0x80, 0x40, 0xed, 0xba, 0x27, 0x22, 0x50, 0xbb, 0xee, 0x89, 0x08, 0xd4, 0xee, 0x7b, 0x22, 0x8c,
9514 0xdc, 0xf3, 0x9e, 0x88, 0x48, 0xef, 0xbe, 0x27, 0x22, 0xd2, 0xbb, 0xef, 0x89, 0x64, 0x93, 0x6e,
9515 0xbb, 0x83, 0x7a, 0x9f, 0x3a, 0x88, 0xf8, 0xbd, 0x5e, 0x02, 0xfd, 0x0a, 0xbc, 0x02, 0xa3, 0x74,
9516 0x43, 0xa2, 0x60, 0x5b, 0xae, 0x59, 0xb7, 0x50, 0x5b, 0x7f, 0x07, 0x0c, 0xd1, 0x21, 0xfa, 0x9a,
9517 0x13, 0xf6, 0x1a, 0x48, 0xe9, 0xac, 0xde, 0x0a, 0xdc, 0x99, 0x9f, 0x26, 0x61, 0x82, 0x0e, 0x94,
9518 0xcd, 0x26, 0x12, 0x6e, 0x19, 0x9d, 0x94, 0xce, 0x94, 0x46, 0x30, 0xfc, 0xe6, 0x4b, 0xd3, 0x74,
9519 0x34, 0xe7, 0x45, 0xd3, 0x49, 0xe9, 0x74, 0x49, 0xe4, 0xf3, 0x17, 0xa0, 0x93, 0xd2, 0xcd, 0x23,
9520 0x91, 0xcf, 0x5b, 0x6f, 0x3c, 0x3e, 0x7e, 0x07, 0x49, 0xe4, 0x2b, 0x7a, 0x51, 0x76, 0x52, 0xba,
9521 0x8d, 0x24, 0xf2, 0x95, 0xbc, 0x78, 0x3b, 0x29, 0x9d, 0x3d, 0x89, 0x7c, 0x97, 0xbd, 0xc8, 0x3b,
9522 0x29, 0x9d, 0x42, 0x89, 0x7c, 0x57, 0xbc, 0x18, 0x3c, 0x29, 0xdd, 0x55, 0x12, 0xf9, 0x1e, 0xf6,
9523 0xa2, 0xf1, 0xa4, 0x74, 0x6b, 0x49, 0xe4, 0x5b, 0xf2, 0xe2, 0x72, 0x46, 0xbe, 0xbf, 0x24, 0x32,
9524 0x5e, 0xf5, 0x23, 0x74, 0x46, 0xbe, 0xc9, 0x24, 0x72, 0xbe, 0xd3, 0x8f, 0xd5, 0x19, 0xf9, 0x4e,
9525 0x93, 0xc8, 0x79, 0xcd, 0x8f, 0xda, 0x19, 0xf9, 0xac, 0x4c, 0xe4, 0x5c, 0xf6, 0xe3, 0x77, 0x46,
9526 0x3e, 0x35, 0x13, 0x39, 0xcb, 0x7e, 0x24, 0xcf, 0xc8, 0xe7, 0x67, 0x22, 0xe7, 0x8a, 0xbf, 0x89,
9527 0xfe, 0x2d, 0x29, 0xfc, 0x02, 0xb7, 0xa0, 0x32, 0x52, 0xf8, 0x41, 0x48, 0xe8, 0x49, 0x85, 0x2c,
9528 0xc0, 0xe3, 0x87, 0x5d, 0x46, 0x0a, 0x3b, 0x08, 0x09, 0xb9, 0x8c, 0x14, 0x72, 0x10, 0x12, 0x6e,
9529 0x19, 0x29, 0xdc, 0x20, 0x24, 0xd4, 0x32, 0x52, 0xa8, 0x41, 0x48, 0x98, 0x65, 0xa4, 0x30, 0x83,
9530 0x90, 0x10, 0xcb, 0x48, 0x21, 0x06, 0x21, 0xe1, 0x95, 0x91, 0xc2, 0x0b, 0x42, 0x42, 0xeb, 0x84,
9531 0x1c, 0x5a, 0x10, 0x16, 0x56, 0x27, 0xe4, 0xb0, 0x82, 0xb0, 0x90, 0xba, 0x53, 0x0e, 0xa9, 0x81,
9532 0x9b, 0x2f, 0x4d, 0xf7, 0xe1, 0xa1, 0x40, 0x34, 0x9d, 0x90, 0xa3, 0x09, 0xc2, 0x22, 0xe9, 0x84,
9533 0x1c, 0x49, 0x10, 0x16, 0x45, 0x27, 0xe4, 0x28, 0x82, 0xb0, 0x08, 0x7a, 0x41, 0x8e, 0x20, 0xff,
9534 0x8e, 0x4f, 0x46, 0x3a, 0x52, 0x8c, 0x8a, 0x20, 0x35, 0x46, 0x04, 0xa9, 0x31, 0x22, 0x48, 0x8d,
9535 0x11, 0x41, 0x6a, 0x8c, 0x08, 0x52, 0x63, 0x44, 0x90, 0x1a, 0x23, 0x82, 0xd4, 0x18, 0x11, 0xa4,
9536 0xc6, 0x89, 0x20, 0x35, 0x56, 0x04, 0xa9, 0xbd, 0x22, 0xe8, 0x84, 0x7c, 0xe3, 0x01, 0xc2, 0x0a,
9537 0xd2, 0x09, 0xf9, 0xe8, 0x33, 0x3a, 0x84, 0xd4, 0x58, 0x21, 0xa4, 0xf6, 0x0a, 0xa1, 0x6f, 0xa9,
9538 0x30, 0x2e, 0x84, 0x10, 0x3b, 0x1f, 0x7a, 0xb3, 0x2a, 0xd0, 0xb9, 0x18, 0x17, 0x2c, 0xc2, 0x62,
9539 0xea, 0x5c, 0x8c, 0x43, 0xea, 0xbd, 0xe2, 0xac, 0xbb, 0x0a, 0x95, 0x62, 0x54, 0xa1, 0xcb, 0x5e,
9540 0x0c, 0x9d, 0x8b, 0x71, 0xf1, 0xa2, 0x3b, 0xf6, 0x2e, 0xec, 0x55, 0x04, 0x1e, 0x8e, 0x55, 0x04,
9541 0x96, 0x62, 0x15, 0x81, 0xab, 0xbe, 0x07, 0x3f, 0x98, 0x80, 0x43, 0xbe, 0x07, 0xe9, 0x27, 0xf2,
9542 0xdb, 0x59, 0x99, 0xc0, 0x11, 0x95, 0xce, 0x8f, 0x6d, 0x02, 0x6e, 0x4c, 0x2c, 0xd5, 0xf4, 0x55,
9543 0xf1, 0xb0, 0x2a, 0xbb, 0xdf, 0x03, 0x9c, 0x80, 0xc7, 0xd9, 0x66, 0xe8, 0x09, 0x50, 0x97, 0x6a,
9544 0x0e, 0xa9, 0x16, 0x61, 0x8f, 0x2d, 0x18, 0x98, 0xac, 0x1b, 0xd0, 0x4f, 0xd8, 0x1d, 0xe2, 0xde,
9545 0x5b, 0x79, 0x70, 0xd1, 0x60, 0x92, 0x32, 0x2f, 0x28, 0x70, 0x4c, 0x08, 0xe5, 0x37, 0xe7, 0xc8,
9546 0xe0, 0x52, 0xac, 0x23, 0x03, 0x21, 0x41, 0xfc, 0xe3, 0x83, 0xbb, 0xbb, 0x4f, 0xaa, 0x83, 0x59,
9547 0x22, 0x1f, 0x25, 0xfc, 0x3f, 0x18, 0xf1, 0x67, 0x40, 0xde, 0xd9, 0xce, 0x46, 0xef, 0x66, 0x86,
9548 0xa5, 0xe6, 0x59, 0x69, 0x17, 0x6d, 0x4f, 0x98, 0x97, 0xad, 0x99, 0x2c, 0x8c, 0x96, 0xc5, 0x3f,
9549 0x7a, 0x8a, 0xda, 0x8c, 0x48, 0xe1, 0xd6, 0xfc, 0xc6, 0xa7, 0xa7, 0x0f, 0x64, 0xee, 0x83, 0xa1,
9550 0xe0, 0xdf, 0x35, 0x49, 0xc0, 0x01, 0x0e, 0xcc, 0x26, 0x5f, 0xc4, 0xdc, 0xbf, 0xab, 0xc0, 0xe1,
9551 0x20, 0xfb, 0x23, 0x75, 0x77, 0x67, 0xc9, 0xc2, 0x3d, 0xfd, 0x03, 0x90, 0x42, 0xcc, 0x71, 0xec,
9552 0x67, 0x70, 0xd8, 0x7b, 0x64, 0x28, 0xfb, 0x1c, 0xf9, 0xd7, 0xf0, 0x20, 0xd2, 0x2e, 0x08, 0x7f,
9553 0xec, 0xc2, 0xe4, 0x5d, 0xd0, 0x47, 0xe5, 0x8b, 0x7a, 0x0d, 0x4b, 0x7a, 0x7d, 0x2e, 0x44, 0x2f,
9554 0x12, 0x47, 0xfa, 0x55, 0x41, 0xaf, 0xc0, 0xeb, 0x6a, 0x28, 0xfb, 0x1c, 0x0f, 0xbe, 0x7c, 0x0a,
9555 0xf7, 0x7f, 0x24, 0xa2, 0xa2, 0x95, 0x9c, 0x81, 0x54, 0x49, 0xe6, 0x09, 0xd7, 0xb3, 0x08, 0xc9,
9556 0xb2, 0x5d, 0x23, 0x3f, 0xd0, 0x43, 0x7e, 0xea, 0x9a, 0x19, 0x99, 0xfd, 0xee, 0xf5, 0x49, 0x48,
9557 0x15, 0x76, 0xea, 0x8d, 0x5a, 0x1b, 0x59, 0xec, 0xcc, 0x9e, 0x6d, 0xa1, 0x63, 0x8c, 0xe1, 0xd1,
9558 0x32, 0x05, 0x18, 0x2b, 0xdb, 0x56, 0x7e, 0xd7, 0x0d, 0xd6, 0x8d, 0x39, 0x29, 0x45, 0xd8, 0x99,
9559 0x0f, 0xf9, 0x3b, 0x10, 0xcc, 0x90, 0xef, 0xfb, 0xde, 0x4b, 0xd3, 0xca, 0xba, 0xb7, 0x7f, 0xbe,
9560 0x0c, 0x47, 0x58, 0xfa, 0x74, 0x89, 0x5a, 0x88, 0x12, 0x35, 0xc0, 0xce, 0xa9, 0x03, 0xe2, 0x96,
9561 0xb0, 0x38, 0x2b, 0x54, 0xdc, 0x1b, 0xd3, 0x0c, 0x37, 0x45, 0x7b, 0x6a, 0xa6, 0xee, 0x4b, 0xb3,
9562 0x50, 0x71, 0x73, 0x51, 0xe2, 0x24, 0xcd, 0xee, 0x84, 0x01, 0x8f, 0x16, 0x88, 0x86, 0x60, 0xa6,
9563 0x2c, 0xcc, 0x66, 0x60, 0x30, 0x90, 0xb0, 0x7a, 0x1f, 0x28, 0x39, 0xed, 0x00, 0xfe, 0x2f, 0xaf,
9564 0x29, 0xf8, 0xbf, 0x82, 0x96, 0x98, 0xbd, 0x0b, 0x46, 0xa5, 0xfd, 0x4b, 0x4c, 0x29, 0x6a, 0x80,
9565 0xff, 0x2b, 0x69, 0x83, 0x93, 0xc9, 0x0f, 0x7d, 0x76, 0xea, 0xc0, 0xec, 0x25, 0xd0, 0xbb, 0x77,
9566 0x3a, 0xf5, 0x7e, 0x48, 0xe4, 0xb0, 0xc8, 0x23, 0x90, 0xc8, 0xe7, 0x35, 0x65, 0x72, 0xf4, 0x97,
9567 0x3f, 0x79, 0x6c, 0x30, 0x4f, 0xfe, 0x68, 0xfb, 0x3a, 0x72, 0xf3, 0x79, 0x06, 0x7e, 0x10, 0x0e,
9568 0x87, 0xee, 0x94, 0x62, 0x7c, 0xa1, 0x40, 0xf1, 0xc5, 0x62, 0x17, 0xbe, 0x58, 0x24, 0x78, 0x25,
9569 0xcb, 0x4f, 0x9c, 0x73, 0x7a, 0xc8, 0x2e, 0x63, 0xba, 0x16, 0x38, 0xe1, 0xce, 0x65, 0x1f, 0x64,
9570 0xbc, 0xf9, 0x50, 0x5e, 0x14, 0x71, 0x62, 0x9d, 0xcf, 0x16, 0x18, 0xbe, 0x10, 0x8a, 0xdf, 0x92,
9571 0x8e, 0x55, 0xc5, 0x15, 0x82, 0x09, 0x29, 0x78, 0x0a, 0x17, 0x43, 0x85, 0xec, 0x04, 0x2e, 0xbb,
9572 0x17, 0x3d, 0x85, 0x4b, 0xa1, 0xbc, 0xf5, 0x88, 0x4b, 0x5f, 0xa5, 0xec, 0x29, 0xb6, 0xc8, 0xe7,
9573 0x4e, 0xeb, 0x87, 0x79, 0x8e, 0x0a, 0x15, 0x98, 0x19, 0x88, 0x73, 0x65, 0x0b, 0x0c, 0x90, 0xef,
9574 0x09, 0xe8, 0x6d, 0x25, 0x8e, 0xcc, 0x3e, 0xcc, 0x84, 0x14, 0x7a, 0x0a, 0x89, 0x30, 0x15, 0x87,
9575 0xe7, 0xd7, 0x6f, 0xbc, 0x3c, 0x75, 0xe0, 0xc5, 0x97, 0xa7, 0x0e, 0xfc, 0xc3, 0xcb, 0x53, 0x07,
9576 0xbe, 0xff, 0xf2, 0x94, 0xf2, 0xc3, 0x97, 0xa7, 0x94, 0x1f, 0xbd, 0x3c, 0xa5, 0xfc, 0xe4, 0xe5,
9577 0x29, 0xe5, 0x99, 0x9b, 0x53, 0xca, 0xf3, 0x37, 0xa7, 0x94, 0x2f, 0xdf, 0x9c, 0x52, 0xbe, 0x7e,
9578 0x73, 0x4a, 0x79, 0xe1, 0xe6, 0x94, 0x72, 0xe3, 0xe6, 0x94, 0xf2, 0xe2, 0xcd, 0x29, 0xe5, 0xfb,
9579 0x37, 0xa7, 0x94, 0x1f, 0xde, 0x9c, 0x3a, 0xf0, 0xa3, 0x9b, 0x53, 0xca, 0x4f, 0x6e, 0x4e, 0x1d,
9580 0x78, 0xe6, 0x95, 0xa9, 0x03, 0xcf, 0xbd, 0x32, 0x75, 0xe0, 0xf9, 0x57, 0xa6, 0x94, 0xff, 0x09,
9581 0x00, 0x00, 0xff, 0xff, 0xb3, 0x44, 0x1b, 0x6f, 0x3e, 0x69, 0x00, 0x00,
9582 }
9583 r := bytes.NewReader(gzipped)
9584 gzipr, err := compress_gzip.NewReader(r)
9585 if err != nil {
9586 panic(err)
9587 }
9588 ungzipped, err := io_ioutil.ReadAll(gzipr)
9589 if err != nil {
9590 panic(err)
9591 }
9592 if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
9593 panic(err)
9594 }
9595 return d
9596 }
9597 func (x TheTestEnum) String() string {
9598 s, ok := TheTestEnum_name[int32(x)]
9599 if ok {
9600 return s
9601 }
9602 return strconv.Itoa(int(x))
9603 }
9604 func (x AnotherTestEnum) String() string {
9605 s, ok := AnotherTestEnum_name[int32(x)]
9606 if ok {
9607 return s
9608 }
9609 return strconv.Itoa(int(x))
9610 }
9611 func (x YetAnotherTestEnum) String() string {
9612 s, ok := YetAnotherTestEnum_name[int32(x)]
9613 if ok {
9614 return s
9615 }
9616 return strconv.Itoa(int(x))
9617 }
9618 func (x YetYetAnotherTestEnum) String() string {
9619 s, ok := YetYetAnotherTestEnum_name[int32(x)]
9620 if ok {
9621 return s
9622 }
9623 return strconv.Itoa(int(x))
9624 }
9625 func (x NestedDefinition_NestedEnum) String() string {
9626 s, ok := NestedDefinition_NestedEnum_name[int32(x)]
9627 if ok {
9628 return s
9629 }
9630 return strconv.Itoa(int(x))
9631 }
9632 func (this *NidOptNative) VerboseEqual(that interface{}) error {
9633 if that == nil {
9634 if this == nil {
9635 return nil
9636 }
9637 return fmt.Errorf("that == nil && this != nil")
9638 }
9639
9640 that1, ok := that.(*NidOptNative)
9641 if !ok {
9642 that2, ok := that.(NidOptNative)
9643 if ok {
9644 that1 = &that2
9645 } else {
9646 return fmt.Errorf("that is not of type *NidOptNative")
9647 }
9648 }
9649 if that1 == nil {
9650 if this == nil {
9651 return nil
9652 }
9653 return fmt.Errorf("that is type *NidOptNative but is nil && this != nil")
9654 } else if this == nil {
9655 return fmt.Errorf("that is type *NidOptNative but is not nil && this == nil")
9656 }
9657 if this.Field1 != that1.Field1 {
9658 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
9659 }
9660 if this.Field2 != that1.Field2 {
9661 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
9662 }
9663 if this.Field3 != that1.Field3 {
9664 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
9665 }
9666 if this.Field4 != that1.Field4 {
9667 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4)
9668 }
9669 if this.Field5 != that1.Field5 {
9670 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5)
9671 }
9672 if this.Field6 != that1.Field6 {
9673 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6)
9674 }
9675 if this.Field7 != that1.Field7 {
9676 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7)
9677 }
9678 if this.Field8 != that1.Field8 {
9679 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8)
9680 }
9681 if this.Field9 != that1.Field9 {
9682 return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9)
9683 }
9684 if this.Field10 != that1.Field10 {
9685 return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10)
9686 }
9687 if this.Field11 != that1.Field11 {
9688 return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11)
9689 }
9690 if this.Field12 != that1.Field12 {
9691 return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12)
9692 }
9693 if this.Field13 != that1.Field13 {
9694 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13)
9695 }
9696 if this.Field14 != that1.Field14 {
9697 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14)
9698 }
9699 if !bytes.Equal(this.Field15, that1.Field15) {
9700 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15)
9701 }
9702 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
9703 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
9704 }
9705 return nil
9706 }
9707 func (this *NidOptNative) Equal(that interface{}) bool {
9708 if that == nil {
9709 return this == nil
9710 }
9711
9712 that1, ok := that.(*NidOptNative)
9713 if !ok {
9714 that2, ok := that.(NidOptNative)
9715 if ok {
9716 that1 = &that2
9717 } else {
9718 return false
9719 }
9720 }
9721 if that1 == nil {
9722 return this == nil
9723 } else if this == nil {
9724 return false
9725 }
9726 if this.Field1 != that1.Field1 {
9727 return false
9728 }
9729 if this.Field2 != that1.Field2 {
9730 return false
9731 }
9732 if this.Field3 != that1.Field3 {
9733 return false
9734 }
9735 if this.Field4 != that1.Field4 {
9736 return false
9737 }
9738 if this.Field5 != that1.Field5 {
9739 return false
9740 }
9741 if this.Field6 != that1.Field6 {
9742 return false
9743 }
9744 if this.Field7 != that1.Field7 {
9745 return false
9746 }
9747 if this.Field8 != that1.Field8 {
9748 return false
9749 }
9750 if this.Field9 != that1.Field9 {
9751 return false
9752 }
9753 if this.Field10 != that1.Field10 {
9754 return false
9755 }
9756 if this.Field11 != that1.Field11 {
9757 return false
9758 }
9759 if this.Field12 != that1.Field12 {
9760 return false
9761 }
9762 if this.Field13 != that1.Field13 {
9763 return false
9764 }
9765 if this.Field14 != that1.Field14 {
9766 return false
9767 }
9768 if !bytes.Equal(this.Field15, that1.Field15) {
9769 return false
9770 }
9771 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
9772 return false
9773 }
9774 return true
9775 }
9776 func (this *NinOptNative) VerboseEqual(that interface{}) error {
9777 if that == nil {
9778 if this == nil {
9779 return nil
9780 }
9781 return fmt.Errorf("that == nil && this != nil")
9782 }
9783
9784 that1, ok := that.(*NinOptNative)
9785 if !ok {
9786 that2, ok := that.(NinOptNative)
9787 if ok {
9788 that1 = &that2
9789 } else {
9790 return fmt.Errorf("that is not of type *NinOptNative")
9791 }
9792 }
9793 if that1 == nil {
9794 if this == nil {
9795 return nil
9796 }
9797 return fmt.Errorf("that is type *NinOptNative but is nil && this != nil")
9798 } else if this == nil {
9799 return fmt.Errorf("that is type *NinOptNative but is not nil && this == nil")
9800 }
9801 if this.Field1 != nil && that1.Field1 != nil {
9802 if *this.Field1 != *that1.Field1 {
9803 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
9804 }
9805 } else if this.Field1 != nil {
9806 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
9807 } else if that1.Field1 != nil {
9808 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
9809 }
9810 if this.Field2 != nil && that1.Field2 != nil {
9811 if *this.Field2 != *that1.Field2 {
9812 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
9813 }
9814 } else if this.Field2 != nil {
9815 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
9816 } else if that1.Field2 != nil {
9817 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
9818 }
9819 if this.Field3 != nil && that1.Field3 != nil {
9820 if *this.Field3 != *that1.Field3 {
9821 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
9822 }
9823 } else if this.Field3 != nil {
9824 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
9825 } else if that1.Field3 != nil {
9826 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
9827 }
9828 if this.Field4 != nil && that1.Field4 != nil {
9829 if *this.Field4 != *that1.Field4 {
9830 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4)
9831 }
9832 } else if this.Field4 != nil {
9833 return fmt.Errorf("this.Field4 == nil && that.Field4 != nil")
9834 } else if that1.Field4 != nil {
9835 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4)
9836 }
9837 if this.Field5 != nil && that1.Field5 != nil {
9838 if *this.Field5 != *that1.Field5 {
9839 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5)
9840 }
9841 } else if this.Field5 != nil {
9842 return fmt.Errorf("this.Field5 == nil && that.Field5 != nil")
9843 } else if that1.Field5 != nil {
9844 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5)
9845 }
9846 if this.Field6 != nil && that1.Field6 != nil {
9847 if *this.Field6 != *that1.Field6 {
9848 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6)
9849 }
9850 } else if this.Field6 != nil {
9851 return fmt.Errorf("this.Field6 == nil && that.Field6 != nil")
9852 } else if that1.Field6 != nil {
9853 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6)
9854 }
9855 if this.Field7 != nil && that1.Field7 != nil {
9856 if *this.Field7 != *that1.Field7 {
9857 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7)
9858 }
9859 } else if this.Field7 != nil {
9860 return fmt.Errorf("this.Field7 == nil && that.Field7 != nil")
9861 } else if that1.Field7 != nil {
9862 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7)
9863 }
9864 if this.Field8 != nil && that1.Field8 != nil {
9865 if *this.Field8 != *that1.Field8 {
9866 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8)
9867 }
9868 } else if this.Field8 != nil {
9869 return fmt.Errorf("this.Field8 == nil && that.Field8 != nil")
9870 } else if that1.Field8 != nil {
9871 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8)
9872 }
9873 if this.Field9 != nil && that1.Field9 != nil {
9874 if *this.Field9 != *that1.Field9 {
9875 return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9)
9876 }
9877 } else if this.Field9 != nil {
9878 return fmt.Errorf("this.Field9 == nil && that.Field9 != nil")
9879 } else if that1.Field9 != nil {
9880 return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9)
9881 }
9882 if this.Field10 != nil && that1.Field10 != nil {
9883 if *this.Field10 != *that1.Field10 {
9884 return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10)
9885 }
9886 } else if this.Field10 != nil {
9887 return fmt.Errorf("this.Field10 == nil && that.Field10 != nil")
9888 } else if that1.Field10 != nil {
9889 return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10)
9890 }
9891 if this.Field11 != nil && that1.Field11 != nil {
9892 if *this.Field11 != *that1.Field11 {
9893 return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11)
9894 }
9895 } else if this.Field11 != nil {
9896 return fmt.Errorf("this.Field11 == nil && that.Field11 != nil")
9897 } else if that1.Field11 != nil {
9898 return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11)
9899 }
9900 if this.Field12 != nil && that1.Field12 != nil {
9901 if *this.Field12 != *that1.Field12 {
9902 return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12)
9903 }
9904 } else if this.Field12 != nil {
9905 return fmt.Errorf("this.Field12 == nil && that.Field12 != nil")
9906 } else if that1.Field12 != nil {
9907 return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12)
9908 }
9909 if this.Field13 != nil && that1.Field13 != nil {
9910 if *this.Field13 != *that1.Field13 {
9911 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13)
9912 }
9913 } else if this.Field13 != nil {
9914 return fmt.Errorf("this.Field13 == nil && that.Field13 != nil")
9915 } else if that1.Field13 != nil {
9916 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13)
9917 }
9918 if this.Field14 != nil && that1.Field14 != nil {
9919 if *this.Field14 != *that1.Field14 {
9920 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14)
9921 }
9922 } else if this.Field14 != nil {
9923 return fmt.Errorf("this.Field14 == nil && that.Field14 != nil")
9924 } else if that1.Field14 != nil {
9925 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14)
9926 }
9927 if !bytes.Equal(this.Field15, that1.Field15) {
9928 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15)
9929 }
9930 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
9931 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
9932 }
9933 return nil
9934 }
9935 func (this *NinOptNative) Equal(that interface{}) bool {
9936 if that == nil {
9937 return this == nil
9938 }
9939
9940 that1, ok := that.(*NinOptNative)
9941 if !ok {
9942 that2, ok := that.(NinOptNative)
9943 if ok {
9944 that1 = &that2
9945 } else {
9946 return false
9947 }
9948 }
9949 if that1 == nil {
9950 return this == nil
9951 } else if this == nil {
9952 return false
9953 }
9954 if this.Field1 != nil && that1.Field1 != nil {
9955 if *this.Field1 != *that1.Field1 {
9956 return false
9957 }
9958 } else if this.Field1 != nil {
9959 return false
9960 } else if that1.Field1 != nil {
9961 return false
9962 }
9963 if this.Field2 != nil && that1.Field2 != nil {
9964 if *this.Field2 != *that1.Field2 {
9965 return false
9966 }
9967 } else if this.Field2 != nil {
9968 return false
9969 } else if that1.Field2 != nil {
9970 return false
9971 }
9972 if this.Field3 != nil && that1.Field3 != nil {
9973 if *this.Field3 != *that1.Field3 {
9974 return false
9975 }
9976 } else if this.Field3 != nil {
9977 return false
9978 } else if that1.Field3 != nil {
9979 return false
9980 }
9981 if this.Field4 != nil && that1.Field4 != nil {
9982 if *this.Field4 != *that1.Field4 {
9983 return false
9984 }
9985 } else if this.Field4 != nil {
9986 return false
9987 } else if that1.Field4 != nil {
9988 return false
9989 }
9990 if this.Field5 != nil && that1.Field5 != nil {
9991 if *this.Field5 != *that1.Field5 {
9992 return false
9993 }
9994 } else if this.Field5 != nil {
9995 return false
9996 } else if that1.Field5 != nil {
9997 return false
9998 }
9999 if this.Field6 != nil && that1.Field6 != nil {
10000 if *this.Field6 != *that1.Field6 {
10001 return false
10002 }
10003 } else if this.Field6 != nil {
10004 return false
10005 } else if that1.Field6 != nil {
10006 return false
10007 }
10008 if this.Field7 != nil && that1.Field7 != nil {
10009 if *this.Field7 != *that1.Field7 {
10010 return false
10011 }
10012 } else if this.Field7 != nil {
10013 return false
10014 } else if that1.Field7 != nil {
10015 return false
10016 }
10017 if this.Field8 != nil && that1.Field8 != nil {
10018 if *this.Field8 != *that1.Field8 {
10019 return false
10020 }
10021 } else if this.Field8 != nil {
10022 return false
10023 } else if that1.Field8 != nil {
10024 return false
10025 }
10026 if this.Field9 != nil && that1.Field9 != nil {
10027 if *this.Field9 != *that1.Field9 {
10028 return false
10029 }
10030 } else if this.Field9 != nil {
10031 return false
10032 } else if that1.Field9 != nil {
10033 return false
10034 }
10035 if this.Field10 != nil && that1.Field10 != nil {
10036 if *this.Field10 != *that1.Field10 {
10037 return false
10038 }
10039 } else if this.Field10 != nil {
10040 return false
10041 } else if that1.Field10 != nil {
10042 return false
10043 }
10044 if this.Field11 != nil && that1.Field11 != nil {
10045 if *this.Field11 != *that1.Field11 {
10046 return false
10047 }
10048 } else if this.Field11 != nil {
10049 return false
10050 } else if that1.Field11 != nil {
10051 return false
10052 }
10053 if this.Field12 != nil && that1.Field12 != nil {
10054 if *this.Field12 != *that1.Field12 {
10055 return false
10056 }
10057 } else if this.Field12 != nil {
10058 return false
10059 } else if that1.Field12 != nil {
10060 return false
10061 }
10062 if this.Field13 != nil && that1.Field13 != nil {
10063 if *this.Field13 != *that1.Field13 {
10064 return false
10065 }
10066 } else if this.Field13 != nil {
10067 return false
10068 } else if that1.Field13 != nil {
10069 return false
10070 }
10071 if this.Field14 != nil && that1.Field14 != nil {
10072 if *this.Field14 != *that1.Field14 {
10073 return false
10074 }
10075 } else if this.Field14 != nil {
10076 return false
10077 } else if that1.Field14 != nil {
10078 return false
10079 }
10080 if !bytes.Equal(this.Field15, that1.Field15) {
10081 return false
10082 }
10083 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
10084 return false
10085 }
10086 return true
10087 }
10088 func (this *NidRepNative) VerboseEqual(that interface{}) error {
10089 if that == nil {
10090 if this == nil {
10091 return nil
10092 }
10093 return fmt.Errorf("that == nil && this != nil")
10094 }
10095
10096 that1, ok := that.(*NidRepNative)
10097 if !ok {
10098 that2, ok := that.(NidRepNative)
10099 if ok {
10100 that1 = &that2
10101 } else {
10102 return fmt.Errorf("that is not of type *NidRepNative")
10103 }
10104 }
10105 if that1 == nil {
10106 if this == nil {
10107 return nil
10108 }
10109 return fmt.Errorf("that is type *NidRepNative but is nil && this != nil")
10110 } else if this == nil {
10111 return fmt.Errorf("that is type *NidRepNative but is not nil && this == nil")
10112 }
10113 if len(this.Field1) != len(that1.Field1) {
10114 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1))
10115 }
10116 for i := range this.Field1 {
10117 if this.Field1[i] != that1.Field1[i] {
10118 return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i])
10119 }
10120 }
10121 if len(this.Field2) != len(that1.Field2) {
10122 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
10123 }
10124 for i := range this.Field2 {
10125 if this.Field2[i] != that1.Field2[i] {
10126 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
10127 }
10128 }
10129 if len(this.Field3) != len(that1.Field3) {
10130 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3))
10131 }
10132 for i := range this.Field3 {
10133 if this.Field3[i] != that1.Field3[i] {
10134 return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i])
10135 }
10136 }
10137 if len(this.Field4) != len(that1.Field4) {
10138 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4))
10139 }
10140 for i := range this.Field4 {
10141 if this.Field4[i] != that1.Field4[i] {
10142 return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i])
10143 }
10144 }
10145 if len(this.Field5) != len(that1.Field5) {
10146 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5))
10147 }
10148 for i := range this.Field5 {
10149 if this.Field5[i] != that1.Field5[i] {
10150 return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i])
10151 }
10152 }
10153 if len(this.Field6) != len(that1.Field6) {
10154 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6))
10155 }
10156 for i := range this.Field6 {
10157 if this.Field6[i] != that1.Field6[i] {
10158 return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i])
10159 }
10160 }
10161 if len(this.Field7) != len(that1.Field7) {
10162 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7))
10163 }
10164 for i := range this.Field7 {
10165 if this.Field7[i] != that1.Field7[i] {
10166 return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i])
10167 }
10168 }
10169 if len(this.Field8) != len(that1.Field8) {
10170 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8))
10171 }
10172 for i := range this.Field8 {
10173 if this.Field8[i] != that1.Field8[i] {
10174 return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i])
10175 }
10176 }
10177 if len(this.Field9) != len(that1.Field9) {
10178 return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9))
10179 }
10180 for i := range this.Field9 {
10181 if this.Field9[i] != that1.Field9[i] {
10182 return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i])
10183 }
10184 }
10185 if len(this.Field10) != len(that1.Field10) {
10186 return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10))
10187 }
10188 for i := range this.Field10 {
10189 if this.Field10[i] != that1.Field10[i] {
10190 return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i])
10191 }
10192 }
10193 if len(this.Field11) != len(that1.Field11) {
10194 return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11))
10195 }
10196 for i := range this.Field11 {
10197 if this.Field11[i] != that1.Field11[i] {
10198 return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i])
10199 }
10200 }
10201 if len(this.Field12) != len(that1.Field12) {
10202 return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12))
10203 }
10204 for i := range this.Field12 {
10205 if this.Field12[i] != that1.Field12[i] {
10206 return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i])
10207 }
10208 }
10209 if len(this.Field13) != len(that1.Field13) {
10210 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13))
10211 }
10212 for i := range this.Field13 {
10213 if this.Field13[i] != that1.Field13[i] {
10214 return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i])
10215 }
10216 }
10217 if len(this.Field14) != len(that1.Field14) {
10218 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14))
10219 }
10220 for i := range this.Field14 {
10221 if this.Field14[i] != that1.Field14[i] {
10222 return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i])
10223 }
10224 }
10225 if len(this.Field15) != len(that1.Field15) {
10226 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15))
10227 }
10228 for i := range this.Field15 {
10229 if !bytes.Equal(this.Field15[i], that1.Field15[i]) {
10230 return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i])
10231 }
10232 }
10233 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
10234 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
10235 }
10236 return nil
10237 }
10238 func (this *NidRepNative) Equal(that interface{}) bool {
10239 if that == nil {
10240 return this == nil
10241 }
10242
10243 that1, ok := that.(*NidRepNative)
10244 if !ok {
10245 that2, ok := that.(NidRepNative)
10246 if ok {
10247 that1 = &that2
10248 } else {
10249 return false
10250 }
10251 }
10252 if that1 == nil {
10253 return this == nil
10254 } else if this == nil {
10255 return false
10256 }
10257 if len(this.Field1) != len(that1.Field1) {
10258 return false
10259 }
10260 for i := range this.Field1 {
10261 if this.Field1[i] != that1.Field1[i] {
10262 return false
10263 }
10264 }
10265 if len(this.Field2) != len(that1.Field2) {
10266 return false
10267 }
10268 for i := range this.Field2 {
10269 if this.Field2[i] != that1.Field2[i] {
10270 return false
10271 }
10272 }
10273 if len(this.Field3) != len(that1.Field3) {
10274 return false
10275 }
10276 for i := range this.Field3 {
10277 if this.Field3[i] != that1.Field3[i] {
10278 return false
10279 }
10280 }
10281 if len(this.Field4) != len(that1.Field4) {
10282 return false
10283 }
10284 for i := range this.Field4 {
10285 if this.Field4[i] != that1.Field4[i] {
10286 return false
10287 }
10288 }
10289 if len(this.Field5) != len(that1.Field5) {
10290 return false
10291 }
10292 for i := range this.Field5 {
10293 if this.Field5[i] != that1.Field5[i] {
10294 return false
10295 }
10296 }
10297 if len(this.Field6) != len(that1.Field6) {
10298 return false
10299 }
10300 for i := range this.Field6 {
10301 if this.Field6[i] != that1.Field6[i] {
10302 return false
10303 }
10304 }
10305 if len(this.Field7) != len(that1.Field7) {
10306 return false
10307 }
10308 for i := range this.Field7 {
10309 if this.Field7[i] != that1.Field7[i] {
10310 return false
10311 }
10312 }
10313 if len(this.Field8) != len(that1.Field8) {
10314 return false
10315 }
10316 for i := range this.Field8 {
10317 if this.Field8[i] != that1.Field8[i] {
10318 return false
10319 }
10320 }
10321 if len(this.Field9) != len(that1.Field9) {
10322 return false
10323 }
10324 for i := range this.Field9 {
10325 if this.Field9[i] != that1.Field9[i] {
10326 return false
10327 }
10328 }
10329 if len(this.Field10) != len(that1.Field10) {
10330 return false
10331 }
10332 for i := range this.Field10 {
10333 if this.Field10[i] != that1.Field10[i] {
10334 return false
10335 }
10336 }
10337 if len(this.Field11) != len(that1.Field11) {
10338 return false
10339 }
10340 for i := range this.Field11 {
10341 if this.Field11[i] != that1.Field11[i] {
10342 return false
10343 }
10344 }
10345 if len(this.Field12) != len(that1.Field12) {
10346 return false
10347 }
10348 for i := range this.Field12 {
10349 if this.Field12[i] != that1.Field12[i] {
10350 return false
10351 }
10352 }
10353 if len(this.Field13) != len(that1.Field13) {
10354 return false
10355 }
10356 for i := range this.Field13 {
10357 if this.Field13[i] != that1.Field13[i] {
10358 return false
10359 }
10360 }
10361 if len(this.Field14) != len(that1.Field14) {
10362 return false
10363 }
10364 for i := range this.Field14 {
10365 if this.Field14[i] != that1.Field14[i] {
10366 return false
10367 }
10368 }
10369 if len(this.Field15) != len(that1.Field15) {
10370 return false
10371 }
10372 for i := range this.Field15 {
10373 if !bytes.Equal(this.Field15[i], that1.Field15[i]) {
10374 return false
10375 }
10376 }
10377 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
10378 return false
10379 }
10380 return true
10381 }
10382 func (this *NinRepNative) VerboseEqual(that interface{}) error {
10383 if that == nil {
10384 if this == nil {
10385 return nil
10386 }
10387 return fmt.Errorf("that == nil && this != nil")
10388 }
10389
10390 that1, ok := that.(*NinRepNative)
10391 if !ok {
10392 that2, ok := that.(NinRepNative)
10393 if ok {
10394 that1 = &that2
10395 } else {
10396 return fmt.Errorf("that is not of type *NinRepNative")
10397 }
10398 }
10399 if that1 == nil {
10400 if this == nil {
10401 return nil
10402 }
10403 return fmt.Errorf("that is type *NinRepNative but is nil && this != nil")
10404 } else if this == nil {
10405 return fmt.Errorf("that is type *NinRepNative but is not nil && this == nil")
10406 }
10407 if len(this.Field1) != len(that1.Field1) {
10408 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1))
10409 }
10410 for i := range this.Field1 {
10411 if this.Field1[i] != that1.Field1[i] {
10412 return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i])
10413 }
10414 }
10415 if len(this.Field2) != len(that1.Field2) {
10416 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
10417 }
10418 for i := range this.Field2 {
10419 if this.Field2[i] != that1.Field2[i] {
10420 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
10421 }
10422 }
10423 if len(this.Field3) != len(that1.Field3) {
10424 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3))
10425 }
10426 for i := range this.Field3 {
10427 if this.Field3[i] != that1.Field3[i] {
10428 return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i])
10429 }
10430 }
10431 if len(this.Field4) != len(that1.Field4) {
10432 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4))
10433 }
10434 for i := range this.Field4 {
10435 if this.Field4[i] != that1.Field4[i] {
10436 return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i])
10437 }
10438 }
10439 if len(this.Field5) != len(that1.Field5) {
10440 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5))
10441 }
10442 for i := range this.Field5 {
10443 if this.Field5[i] != that1.Field5[i] {
10444 return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i])
10445 }
10446 }
10447 if len(this.Field6) != len(that1.Field6) {
10448 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6))
10449 }
10450 for i := range this.Field6 {
10451 if this.Field6[i] != that1.Field6[i] {
10452 return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i])
10453 }
10454 }
10455 if len(this.Field7) != len(that1.Field7) {
10456 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7))
10457 }
10458 for i := range this.Field7 {
10459 if this.Field7[i] != that1.Field7[i] {
10460 return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i])
10461 }
10462 }
10463 if len(this.Field8) != len(that1.Field8) {
10464 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8))
10465 }
10466 for i := range this.Field8 {
10467 if this.Field8[i] != that1.Field8[i] {
10468 return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i])
10469 }
10470 }
10471 if len(this.Field9) != len(that1.Field9) {
10472 return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9))
10473 }
10474 for i := range this.Field9 {
10475 if this.Field9[i] != that1.Field9[i] {
10476 return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i])
10477 }
10478 }
10479 if len(this.Field10) != len(that1.Field10) {
10480 return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10))
10481 }
10482 for i := range this.Field10 {
10483 if this.Field10[i] != that1.Field10[i] {
10484 return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i])
10485 }
10486 }
10487 if len(this.Field11) != len(that1.Field11) {
10488 return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11))
10489 }
10490 for i := range this.Field11 {
10491 if this.Field11[i] != that1.Field11[i] {
10492 return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i])
10493 }
10494 }
10495 if len(this.Field12) != len(that1.Field12) {
10496 return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12))
10497 }
10498 for i := range this.Field12 {
10499 if this.Field12[i] != that1.Field12[i] {
10500 return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i])
10501 }
10502 }
10503 if len(this.Field13) != len(that1.Field13) {
10504 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13))
10505 }
10506 for i := range this.Field13 {
10507 if this.Field13[i] != that1.Field13[i] {
10508 return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i])
10509 }
10510 }
10511 if len(this.Field14) != len(that1.Field14) {
10512 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14))
10513 }
10514 for i := range this.Field14 {
10515 if this.Field14[i] != that1.Field14[i] {
10516 return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i])
10517 }
10518 }
10519 if len(this.Field15) != len(that1.Field15) {
10520 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15))
10521 }
10522 for i := range this.Field15 {
10523 if !bytes.Equal(this.Field15[i], that1.Field15[i]) {
10524 return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i])
10525 }
10526 }
10527 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
10528 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
10529 }
10530 return nil
10531 }
10532 func (this *NinRepNative) Equal(that interface{}) bool {
10533 if that == nil {
10534 return this == nil
10535 }
10536
10537 that1, ok := that.(*NinRepNative)
10538 if !ok {
10539 that2, ok := that.(NinRepNative)
10540 if ok {
10541 that1 = &that2
10542 } else {
10543 return false
10544 }
10545 }
10546 if that1 == nil {
10547 return this == nil
10548 } else if this == nil {
10549 return false
10550 }
10551 if len(this.Field1) != len(that1.Field1) {
10552 return false
10553 }
10554 for i := range this.Field1 {
10555 if this.Field1[i] != that1.Field1[i] {
10556 return false
10557 }
10558 }
10559 if len(this.Field2) != len(that1.Field2) {
10560 return false
10561 }
10562 for i := range this.Field2 {
10563 if this.Field2[i] != that1.Field2[i] {
10564 return false
10565 }
10566 }
10567 if len(this.Field3) != len(that1.Field3) {
10568 return false
10569 }
10570 for i := range this.Field3 {
10571 if this.Field3[i] != that1.Field3[i] {
10572 return false
10573 }
10574 }
10575 if len(this.Field4) != len(that1.Field4) {
10576 return false
10577 }
10578 for i := range this.Field4 {
10579 if this.Field4[i] != that1.Field4[i] {
10580 return false
10581 }
10582 }
10583 if len(this.Field5) != len(that1.Field5) {
10584 return false
10585 }
10586 for i := range this.Field5 {
10587 if this.Field5[i] != that1.Field5[i] {
10588 return false
10589 }
10590 }
10591 if len(this.Field6) != len(that1.Field6) {
10592 return false
10593 }
10594 for i := range this.Field6 {
10595 if this.Field6[i] != that1.Field6[i] {
10596 return false
10597 }
10598 }
10599 if len(this.Field7) != len(that1.Field7) {
10600 return false
10601 }
10602 for i := range this.Field7 {
10603 if this.Field7[i] != that1.Field7[i] {
10604 return false
10605 }
10606 }
10607 if len(this.Field8) != len(that1.Field8) {
10608 return false
10609 }
10610 for i := range this.Field8 {
10611 if this.Field8[i] != that1.Field8[i] {
10612 return false
10613 }
10614 }
10615 if len(this.Field9) != len(that1.Field9) {
10616 return false
10617 }
10618 for i := range this.Field9 {
10619 if this.Field9[i] != that1.Field9[i] {
10620 return false
10621 }
10622 }
10623 if len(this.Field10) != len(that1.Field10) {
10624 return false
10625 }
10626 for i := range this.Field10 {
10627 if this.Field10[i] != that1.Field10[i] {
10628 return false
10629 }
10630 }
10631 if len(this.Field11) != len(that1.Field11) {
10632 return false
10633 }
10634 for i := range this.Field11 {
10635 if this.Field11[i] != that1.Field11[i] {
10636 return false
10637 }
10638 }
10639 if len(this.Field12) != len(that1.Field12) {
10640 return false
10641 }
10642 for i := range this.Field12 {
10643 if this.Field12[i] != that1.Field12[i] {
10644 return false
10645 }
10646 }
10647 if len(this.Field13) != len(that1.Field13) {
10648 return false
10649 }
10650 for i := range this.Field13 {
10651 if this.Field13[i] != that1.Field13[i] {
10652 return false
10653 }
10654 }
10655 if len(this.Field14) != len(that1.Field14) {
10656 return false
10657 }
10658 for i := range this.Field14 {
10659 if this.Field14[i] != that1.Field14[i] {
10660 return false
10661 }
10662 }
10663 if len(this.Field15) != len(that1.Field15) {
10664 return false
10665 }
10666 for i := range this.Field15 {
10667 if !bytes.Equal(this.Field15[i], that1.Field15[i]) {
10668 return false
10669 }
10670 }
10671 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
10672 return false
10673 }
10674 return true
10675 }
10676 func (this *NidRepPackedNative) VerboseEqual(that interface{}) error {
10677 if that == nil {
10678 if this == nil {
10679 return nil
10680 }
10681 return fmt.Errorf("that == nil && this != nil")
10682 }
10683
10684 that1, ok := that.(*NidRepPackedNative)
10685 if !ok {
10686 that2, ok := that.(NidRepPackedNative)
10687 if ok {
10688 that1 = &that2
10689 } else {
10690 return fmt.Errorf("that is not of type *NidRepPackedNative")
10691 }
10692 }
10693 if that1 == nil {
10694 if this == nil {
10695 return nil
10696 }
10697 return fmt.Errorf("that is type *NidRepPackedNative but is nil && this != nil")
10698 } else if this == nil {
10699 return fmt.Errorf("that is type *NidRepPackedNative but is not nil && this == nil")
10700 }
10701 if len(this.Field1) != len(that1.Field1) {
10702 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1))
10703 }
10704 for i := range this.Field1 {
10705 if this.Field1[i] != that1.Field1[i] {
10706 return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i])
10707 }
10708 }
10709 if len(this.Field2) != len(that1.Field2) {
10710 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
10711 }
10712 for i := range this.Field2 {
10713 if this.Field2[i] != that1.Field2[i] {
10714 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
10715 }
10716 }
10717 if len(this.Field3) != len(that1.Field3) {
10718 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3))
10719 }
10720 for i := range this.Field3 {
10721 if this.Field3[i] != that1.Field3[i] {
10722 return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i])
10723 }
10724 }
10725 if len(this.Field4) != len(that1.Field4) {
10726 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4))
10727 }
10728 for i := range this.Field4 {
10729 if this.Field4[i] != that1.Field4[i] {
10730 return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i])
10731 }
10732 }
10733 if len(this.Field5) != len(that1.Field5) {
10734 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5))
10735 }
10736 for i := range this.Field5 {
10737 if this.Field5[i] != that1.Field5[i] {
10738 return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i])
10739 }
10740 }
10741 if len(this.Field6) != len(that1.Field6) {
10742 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6))
10743 }
10744 for i := range this.Field6 {
10745 if this.Field6[i] != that1.Field6[i] {
10746 return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i])
10747 }
10748 }
10749 if len(this.Field7) != len(that1.Field7) {
10750 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7))
10751 }
10752 for i := range this.Field7 {
10753 if this.Field7[i] != that1.Field7[i] {
10754 return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i])
10755 }
10756 }
10757 if len(this.Field8) != len(that1.Field8) {
10758 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8))
10759 }
10760 for i := range this.Field8 {
10761 if this.Field8[i] != that1.Field8[i] {
10762 return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i])
10763 }
10764 }
10765 if len(this.Field9) != len(that1.Field9) {
10766 return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9))
10767 }
10768 for i := range this.Field9 {
10769 if this.Field9[i] != that1.Field9[i] {
10770 return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i])
10771 }
10772 }
10773 if len(this.Field10) != len(that1.Field10) {
10774 return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10))
10775 }
10776 for i := range this.Field10 {
10777 if this.Field10[i] != that1.Field10[i] {
10778 return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i])
10779 }
10780 }
10781 if len(this.Field11) != len(that1.Field11) {
10782 return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11))
10783 }
10784 for i := range this.Field11 {
10785 if this.Field11[i] != that1.Field11[i] {
10786 return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i])
10787 }
10788 }
10789 if len(this.Field12) != len(that1.Field12) {
10790 return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12))
10791 }
10792 for i := range this.Field12 {
10793 if this.Field12[i] != that1.Field12[i] {
10794 return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i])
10795 }
10796 }
10797 if len(this.Field13) != len(that1.Field13) {
10798 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13))
10799 }
10800 for i := range this.Field13 {
10801 if this.Field13[i] != that1.Field13[i] {
10802 return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i])
10803 }
10804 }
10805 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
10806 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
10807 }
10808 return nil
10809 }
10810 func (this *NidRepPackedNative) Equal(that interface{}) bool {
10811 if that == nil {
10812 return this == nil
10813 }
10814
10815 that1, ok := that.(*NidRepPackedNative)
10816 if !ok {
10817 that2, ok := that.(NidRepPackedNative)
10818 if ok {
10819 that1 = &that2
10820 } else {
10821 return false
10822 }
10823 }
10824 if that1 == nil {
10825 return this == nil
10826 } else if this == nil {
10827 return false
10828 }
10829 if len(this.Field1) != len(that1.Field1) {
10830 return false
10831 }
10832 for i := range this.Field1 {
10833 if this.Field1[i] != that1.Field1[i] {
10834 return false
10835 }
10836 }
10837 if len(this.Field2) != len(that1.Field2) {
10838 return false
10839 }
10840 for i := range this.Field2 {
10841 if this.Field2[i] != that1.Field2[i] {
10842 return false
10843 }
10844 }
10845 if len(this.Field3) != len(that1.Field3) {
10846 return false
10847 }
10848 for i := range this.Field3 {
10849 if this.Field3[i] != that1.Field3[i] {
10850 return false
10851 }
10852 }
10853 if len(this.Field4) != len(that1.Field4) {
10854 return false
10855 }
10856 for i := range this.Field4 {
10857 if this.Field4[i] != that1.Field4[i] {
10858 return false
10859 }
10860 }
10861 if len(this.Field5) != len(that1.Field5) {
10862 return false
10863 }
10864 for i := range this.Field5 {
10865 if this.Field5[i] != that1.Field5[i] {
10866 return false
10867 }
10868 }
10869 if len(this.Field6) != len(that1.Field6) {
10870 return false
10871 }
10872 for i := range this.Field6 {
10873 if this.Field6[i] != that1.Field6[i] {
10874 return false
10875 }
10876 }
10877 if len(this.Field7) != len(that1.Field7) {
10878 return false
10879 }
10880 for i := range this.Field7 {
10881 if this.Field7[i] != that1.Field7[i] {
10882 return false
10883 }
10884 }
10885 if len(this.Field8) != len(that1.Field8) {
10886 return false
10887 }
10888 for i := range this.Field8 {
10889 if this.Field8[i] != that1.Field8[i] {
10890 return false
10891 }
10892 }
10893 if len(this.Field9) != len(that1.Field9) {
10894 return false
10895 }
10896 for i := range this.Field9 {
10897 if this.Field9[i] != that1.Field9[i] {
10898 return false
10899 }
10900 }
10901 if len(this.Field10) != len(that1.Field10) {
10902 return false
10903 }
10904 for i := range this.Field10 {
10905 if this.Field10[i] != that1.Field10[i] {
10906 return false
10907 }
10908 }
10909 if len(this.Field11) != len(that1.Field11) {
10910 return false
10911 }
10912 for i := range this.Field11 {
10913 if this.Field11[i] != that1.Field11[i] {
10914 return false
10915 }
10916 }
10917 if len(this.Field12) != len(that1.Field12) {
10918 return false
10919 }
10920 for i := range this.Field12 {
10921 if this.Field12[i] != that1.Field12[i] {
10922 return false
10923 }
10924 }
10925 if len(this.Field13) != len(that1.Field13) {
10926 return false
10927 }
10928 for i := range this.Field13 {
10929 if this.Field13[i] != that1.Field13[i] {
10930 return false
10931 }
10932 }
10933 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
10934 return false
10935 }
10936 return true
10937 }
10938 func (this *NinRepPackedNative) VerboseEqual(that interface{}) error {
10939 if that == nil {
10940 if this == nil {
10941 return nil
10942 }
10943 return fmt.Errorf("that == nil && this != nil")
10944 }
10945
10946 that1, ok := that.(*NinRepPackedNative)
10947 if !ok {
10948 that2, ok := that.(NinRepPackedNative)
10949 if ok {
10950 that1 = &that2
10951 } else {
10952 return fmt.Errorf("that is not of type *NinRepPackedNative")
10953 }
10954 }
10955 if that1 == nil {
10956 if this == nil {
10957 return nil
10958 }
10959 return fmt.Errorf("that is type *NinRepPackedNative but is nil && this != nil")
10960 } else if this == nil {
10961 return fmt.Errorf("that is type *NinRepPackedNative but is not nil && this == nil")
10962 }
10963 if len(this.Field1) != len(that1.Field1) {
10964 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1))
10965 }
10966 for i := range this.Field1 {
10967 if this.Field1[i] != that1.Field1[i] {
10968 return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i])
10969 }
10970 }
10971 if len(this.Field2) != len(that1.Field2) {
10972 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
10973 }
10974 for i := range this.Field2 {
10975 if this.Field2[i] != that1.Field2[i] {
10976 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
10977 }
10978 }
10979 if len(this.Field3) != len(that1.Field3) {
10980 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3))
10981 }
10982 for i := range this.Field3 {
10983 if this.Field3[i] != that1.Field3[i] {
10984 return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i])
10985 }
10986 }
10987 if len(this.Field4) != len(that1.Field4) {
10988 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4))
10989 }
10990 for i := range this.Field4 {
10991 if this.Field4[i] != that1.Field4[i] {
10992 return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i])
10993 }
10994 }
10995 if len(this.Field5) != len(that1.Field5) {
10996 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5))
10997 }
10998 for i := range this.Field5 {
10999 if this.Field5[i] != that1.Field5[i] {
11000 return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i])
11001 }
11002 }
11003 if len(this.Field6) != len(that1.Field6) {
11004 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6))
11005 }
11006 for i := range this.Field6 {
11007 if this.Field6[i] != that1.Field6[i] {
11008 return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i])
11009 }
11010 }
11011 if len(this.Field7) != len(that1.Field7) {
11012 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7))
11013 }
11014 for i := range this.Field7 {
11015 if this.Field7[i] != that1.Field7[i] {
11016 return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i])
11017 }
11018 }
11019 if len(this.Field8) != len(that1.Field8) {
11020 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8))
11021 }
11022 for i := range this.Field8 {
11023 if this.Field8[i] != that1.Field8[i] {
11024 return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i])
11025 }
11026 }
11027 if len(this.Field9) != len(that1.Field9) {
11028 return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9))
11029 }
11030 for i := range this.Field9 {
11031 if this.Field9[i] != that1.Field9[i] {
11032 return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i])
11033 }
11034 }
11035 if len(this.Field10) != len(that1.Field10) {
11036 return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10))
11037 }
11038 for i := range this.Field10 {
11039 if this.Field10[i] != that1.Field10[i] {
11040 return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i])
11041 }
11042 }
11043 if len(this.Field11) != len(that1.Field11) {
11044 return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11))
11045 }
11046 for i := range this.Field11 {
11047 if this.Field11[i] != that1.Field11[i] {
11048 return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i])
11049 }
11050 }
11051 if len(this.Field12) != len(that1.Field12) {
11052 return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12))
11053 }
11054 for i := range this.Field12 {
11055 if this.Field12[i] != that1.Field12[i] {
11056 return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i])
11057 }
11058 }
11059 if len(this.Field13) != len(that1.Field13) {
11060 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13))
11061 }
11062 for i := range this.Field13 {
11063 if this.Field13[i] != that1.Field13[i] {
11064 return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i])
11065 }
11066 }
11067 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11068 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
11069 }
11070 return nil
11071 }
11072 func (this *NinRepPackedNative) Equal(that interface{}) bool {
11073 if that == nil {
11074 return this == nil
11075 }
11076
11077 that1, ok := that.(*NinRepPackedNative)
11078 if !ok {
11079 that2, ok := that.(NinRepPackedNative)
11080 if ok {
11081 that1 = &that2
11082 } else {
11083 return false
11084 }
11085 }
11086 if that1 == nil {
11087 return this == nil
11088 } else if this == nil {
11089 return false
11090 }
11091 if len(this.Field1) != len(that1.Field1) {
11092 return false
11093 }
11094 for i := range this.Field1 {
11095 if this.Field1[i] != that1.Field1[i] {
11096 return false
11097 }
11098 }
11099 if len(this.Field2) != len(that1.Field2) {
11100 return false
11101 }
11102 for i := range this.Field2 {
11103 if this.Field2[i] != that1.Field2[i] {
11104 return false
11105 }
11106 }
11107 if len(this.Field3) != len(that1.Field3) {
11108 return false
11109 }
11110 for i := range this.Field3 {
11111 if this.Field3[i] != that1.Field3[i] {
11112 return false
11113 }
11114 }
11115 if len(this.Field4) != len(that1.Field4) {
11116 return false
11117 }
11118 for i := range this.Field4 {
11119 if this.Field4[i] != that1.Field4[i] {
11120 return false
11121 }
11122 }
11123 if len(this.Field5) != len(that1.Field5) {
11124 return false
11125 }
11126 for i := range this.Field5 {
11127 if this.Field5[i] != that1.Field5[i] {
11128 return false
11129 }
11130 }
11131 if len(this.Field6) != len(that1.Field6) {
11132 return false
11133 }
11134 for i := range this.Field6 {
11135 if this.Field6[i] != that1.Field6[i] {
11136 return false
11137 }
11138 }
11139 if len(this.Field7) != len(that1.Field7) {
11140 return false
11141 }
11142 for i := range this.Field7 {
11143 if this.Field7[i] != that1.Field7[i] {
11144 return false
11145 }
11146 }
11147 if len(this.Field8) != len(that1.Field8) {
11148 return false
11149 }
11150 for i := range this.Field8 {
11151 if this.Field8[i] != that1.Field8[i] {
11152 return false
11153 }
11154 }
11155 if len(this.Field9) != len(that1.Field9) {
11156 return false
11157 }
11158 for i := range this.Field9 {
11159 if this.Field9[i] != that1.Field9[i] {
11160 return false
11161 }
11162 }
11163 if len(this.Field10) != len(that1.Field10) {
11164 return false
11165 }
11166 for i := range this.Field10 {
11167 if this.Field10[i] != that1.Field10[i] {
11168 return false
11169 }
11170 }
11171 if len(this.Field11) != len(that1.Field11) {
11172 return false
11173 }
11174 for i := range this.Field11 {
11175 if this.Field11[i] != that1.Field11[i] {
11176 return false
11177 }
11178 }
11179 if len(this.Field12) != len(that1.Field12) {
11180 return false
11181 }
11182 for i := range this.Field12 {
11183 if this.Field12[i] != that1.Field12[i] {
11184 return false
11185 }
11186 }
11187 if len(this.Field13) != len(that1.Field13) {
11188 return false
11189 }
11190 for i := range this.Field13 {
11191 if this.Field13[i] != that1.Field13[i] {
11192 return false
11193 }
11194 }
11195 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11196 return false
11197 }
11198 return true
11199 }
11200 func (this *NidOptStruct) VerboseEqual(that interface{}) error {
11201 if that == nil {
11202 if this == nil {
11203 return nil
11204 }
11205 return fmt.Errorf("that == nil && this != nil")
11206 }
11207
11208 that1, ok := that.(*NidOptStruct)
11209 if !ok {
11210 that2, ok := that.(NidOptStruct)
11211 if ok {
11212 that1 = &that2
11213 } else {
11214 return fmt.Errorf("that is not of type *NidOptStruct")
11215 }
11216 }
11217 if that1 == nil {
11218 if this == nil {
11219 return nil
11220 }
11221 return fmt.Errorf("that is type *NidOptStruct but is nil && this != nil")
11222 } else if this == nil {
11223 return fmt.Errorf("that is type *NidOptStruct but is not nil && this == nil")
11224 }
11225 if this.Field1 != that1.Field1 {
11226 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
11227 }
11228 if this.Field2 != that1.Field2 {
11229 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
11230 }
11231 if !this.Field3.Equal(&that1.Field3) {
11232 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
11233 }
11234 if !this.Field4.Equal(&that1.Field4) {
11235 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4)
11236 }
11237 if this.Field6 != that1.Field6 {
11238 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6)
11239 }
11240 if this.Field7 != that1.Field7 {
11241 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7)
11242 }
11243 if !this.Field8.Equal(&that1.Field8) {
11244 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8)
11245 }
11246 if this.Field13 != that1.Field13 {
11247 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13)
11248 }
11249 if this.Field14 != that1.Field14 {
11250 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14)
11251 }
11252 if !bytes.Equal(this.Field15, that1.Field15) {
11253 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15)
11254 }
11255 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11256 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
11257 }
11258 return nil
11259 }
11260 func (this *NidOptStruct) Equal(that interface{}) bool {
11261 if that == nil {
11262 return this == nil
11263 }
11264
11265 that1, ok := that.(*NidOptStruct)
11266 if !ok {
11267 that2, ok := that.(NidOptStruct)
11268 if ok {
11269 that1 = &that2
11270 } else {
11271 return false
11272 }
11273 }
11274 if that1 == nil {
11275 return this == nil
11276 } else if this == nil {
11277 return false
11278 }
11279 if this.Field1 != that1.Field1 {
11280 return false
11281 }
11282 if this.Field2 != that1.Field2 {
11283 return false
11284 }
11285 if !this.Field3.Equal(&that1.Field3) {
11286 return false
11287 }
11288 if !this.Field4.Equal(&that1.Field4) {
11289 return false
11290 }
11291 if this.Field6 != that1.Field6 {
11292 return false
11293 }
11294 if this.Field7 != that1.Field7 {
11295 return false
11296 }
11297 if !this.Field8.Equal(&that1.Field8) {
11298 return false
11299 }
11300 if this.Field13 != that1.Field13 {
11301 return false
11302 }
11303 if this.Field14 != that1.Field14 {
11304 return false
11305 }
11306 if !bytes.Equal(this.Field15, that1.Field15) {
11307 return false
11308 }
11309 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11310 return false
11311 }
11312 return true
11313 }
11314 func (this *NinOptStruct) VerboseEqual(that interface{}) error {
11315 if that == nil {
11316 if this == nil {
11317 return nil
11318 }
11319 return fmt.Errorf("that == nil && this != nil")
11320 }
11321
11322 that1, ok := that.(*NinOptStruct)
11323 if !ok {
11324 that2, ok := that.(NinOptStruct)
11325 if ok {
11326 that1 = &that2
11327 } else {
11328 return fmt.Errorf("that is not of type *NinOptStruct")
11329 }
11330 }
11331 if that1 == nil {
11332 if this == nil {
11333 return nil
11334 }
11335 return fmt.Errorf("that is type *NinOptStruct but is nil && this != nil")
11336 } else if this == nil {
11337 return fmt.Errorf("that is type *NinOptStruct but is not nil && this == nil")
11338 }
11339 if this.Field1 != nil && that1.Field1 != nil {
11340 if *this.Field1 != *that1.Field1 {
11341 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
11342 }
11343 } else if this.Field1 != nil {
11344 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
11345 } else if that1.Field1 != nil {
11346 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
11347 }
11348 if this.Field2 != nil && that1.Field2 != nil {
11349 if *this.Field2 != *that1.Field2 {
11350 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
11351 }
11352 } else if this.Field2 != nil {
11353 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
11354 } else if that1.Field2 != nil {
11355 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
11356 }
11357 if !this.Field3.Equal(that1.Field3) {
11358 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
11359 }
11360 if !this.Field4.Equal(that1.Field4) {
11361 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4)
11362 }
11363 if this.Field6 != nil && that1.Field6 != nil {
11364 if *this.Field6 != *that1.Field6 {
11365 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6)
11366 }
11367 } else if this.Field6 != nil {
11368 return fmt.Errorf("this.Field6 == nil && that.Field6 != nil")
11369 } else if that1.Field6 != nil {
11370 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6)
11371 }
11372 if this.Field7 != nil && that1.Field7 != nil {
11373 if *this.Field7 != *that1.Field7 {
11374 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7)
11375 }
11376 } else if this.Field7 != nil {
11377 return fmt.Errorf("this.Field7 == nil && that.Field7 != nil")
11378 } else if that1.Field7 != nil {
11379 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7)
11380 }
11381 if !this.Field8.Equal(that1.Field8) {
11382 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8)
11383 }
11384 if this.Field13 != nil && that1.Field13 != nil {
11385 if *this.Field13 != *that1.Field13 {
11386 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13)
11387 }
11388 } else if this.Field13 != nil {
11389 return fmt.Errorf("this.Field13 == nil && that.Field13 != nil")
11390 } else if that1.Field13 != nil {
11391 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13)
11392 }
11393 if this.Field14 != nil && that1.Field14 != nil {
11394 if *this.Field14 != *that1.Field14 {
11395 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14)
11396 }
11397 } else if this.Field14 != nil {
11398 return fmt.Errorf("this.Field14 == nil && that.Field14 != nil")
11399 } else if that1.Field14 != nil {
11400 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14)
11401 }
11402 if !bytes.Equal(this.Field15, that1.Field15) {
11403 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15)
11404 }
11405 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11406 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
11407 }
11408 return nil
11409 }
11410 func (this *NinOptStruct) Equal(that interface{}) bool {
11411 if that == nil {
11412 return this == nil
11413 }
11414
11415 that1, ok := that.(*NinOptStruct)
11416 if !ok {
11417 that2, ok := that.(NinOptStruct)
11418 if ok {
11419 that1 = &that2
11420 } else {
11421 return false
11422 }
11423 }
11424 if that1 == nil {
11425 return this == nil
11426 } else if this == nil {
11427 return false
11428 }
11429 if this.Field1 != nil && that1.Field1 != nil {
11430 if *this.Field1 != *that1.Field1 {
11431 return false
11432 }
11433 } else if this.Field1 != nil {
11434 return false
11435 } else if that1.Field1 != nil {
11436 return false
11437 }
11438 if this.Field2 != nil && that1.Field2 != nil {
11439 if *this.Field2 != *that1.Field2 {
11440 return false
11441 }
11442 } else if this.Field2 != nil {
11443 return false
11444 } else if that1.Field2 != nil {
11445 return false
11446 }
11447 if !this.Field3.Equal(that1.Field3) {
11448 return false
11449 }
11450 if !this.Field4.Equal(that1.Field4) {
11451 return false
11452 }
11453 if this.Field6 != nil && that1.Field6 != nil {
11454 if *this.Field6 != *that1.Field6 {
11455 return false
11456 }
11457 } else if this.Field6 != nil {
11458 return false
11459 } else if that1.Field6 != nil {
11460 return false
11461 }
11462 if this.Field7 != nil && that1.Field7 != nil {
11463 if *this.Field7 != *that1.Field7 {
11464 return false
11465 }
11466 } else if this.Field7 != nil {
11467 return false
11468 } else if that1.Field7 != nil {
11469 return false
11470 }
11471 if !this.Field8.Equal(that1.Field8) {
11472 return false
11473 }
11474 if this.Field13 != nil && that1.Field13 != nil {
11475 if *this.Field13 != *that1.Field13 {
11476 return false
11477 }
11478 } else if this.Field13 != nil {
11479 return false
11480 } else if that1.Field13 != nil {
11481 return false
11482 }
11483 if this.Field14 != nil && that1.Field14 != nil {
11484 if *this.Field14 != *that1.Field14 {
11485 return false
11486 }
11487 } else if this.Field14 != nil {
11488 return false
11489 } else if that1.Field14 != nil {
11490 return false
11491 }
11492 if !bytes.Equal(this.Field15, that1.Field15) {
11493 return false
11494 }
11495 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11496 return false
11497 }
11498 return true
11499 }
11500 func (this *NidRepStruct) VerboseEqual(that interface{}) error {
11501 if that == nil {
11502 if this == nil {
11503 return nil
11504 }
11505 return fmt.Errorf("that == nil && this != nil")
11506 }
11507
11508 that1, ok := that.(*NidRepStruct)
11509 if !ok {
11510 that2, ok := that.(NidRepStruct)
11511 if ok {
11512 that1 = &that2
11513 } else {
11514 return fmt.Errorf("that is not of type *NidRepStruct")
11515 }
11516 }
11517 if that1 == nil {
11518 if this == nil {
11519 return nil
11520 }
11521 return fmt.Errorf("that is type *NidRepStruct but is nil && this != nil")
11522 } else if this == nil {
11523 return fmt.Errorf("that is type *NidRepStruct but is not nil && this == nil")
11524 }
11525 if len(this.Field1) != len(that1.Field1) {
11526 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1))
11527 }
11528 for i := range this.Field1 {
11529 if this.Field1[i] != that1.Field1[i] {
11530 return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i])
11531 }
11532 }
11533 if len(this.Field2) != len(that1.Field2) {
11534 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
11535 }
11536 for i := range this.Field2 {
11537 if this.Field2[i] != that1.Field2[i] {
11538 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
11539 }
11540 }
11541 if len(this.Field3) != len(that1.Field3) {
11542 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3))
11543 }
11544 for i := range this.Field3 {
11545 if !this.Field3[i].Equal(&that1.Field3[i]) {
11546 return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i])
11547 }
11548 }
11549 if len(this.Field4) != len(that1.Field4) {
11550 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4))
11551 }
11552 for i := range this.Field4 {
11553 if !this.Field4[i].Equal(&that1.Field4[i]) {
11554 return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i])
11555 }
11556 }
11557 if len(this.Field6) != len(that1.Field6) {
11558 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6))
11559 }
11560 for i := range this.Field6 {
11561 if this.Field6[i] != that1.Field6[i] {
11562 return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i])
11563 }
11564 }
11565 if len(this.Field7) != len(that1.Field7) {
11566 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7))
11567 }
11568 for i := range this.Field7 {
11569 if this.Field7[i] != that1.Field7[i] {
11570 return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i])
11571 }
11572 }
11573 if len(this.Field8) != len(that1.Field8) {
11574 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8))
11575 }
11576 for i := range this.Field8 {
11577 if !this.Field8[i].Equal(&that1.Field8[i]) {
11578 return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i])
11579 }
11580 }
11581 if len(this.Field13) != len(that1.Field13) {
11582 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13))
11583 }
11584 for i := range this.Field13 {
11585 if this.Field13[i] != that1.Field13[i] {
11586 return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i])
11587 }
11588 }
11589 if len(this.Field14) != len(that1.Field14) {
11590 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14))
11591 }
11592 for i := range this.Field14 {
11593 if this.Field14[i] != that1.Field14[i] {
11594 return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i])
11595 }
11596 }
11597 if len(this.Field15) != len(that1.Field15) {
11598 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15))
11599 }
11600 for i := range this.Field15 {
11601 if !bytes.Equal(this.Field15[i], that1.Field15[i]) {
11602 return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i])
11603 }
11604 }
11605 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11606 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
11607 }
11608 return nil
11609 }
11610 func (this *NidRepStruct) Equal(that interface{}) bool {
11611 if that == nil {
11612 return this == nil
11613 }
11614
11615 that1, ok := that.(*NidRepStruct)
11616 if !ok {
11617 that2, ok := that.(NidRepStruct)
11618 if ok {
11619 that1 = &that2
11620 } else {
11621 return false
11622 }
11623 }
11624 if that1 == nil {
11625 return this == nil
11626 } else if this == nil {
11627 return false
11628 }
11629 if len(this.Field1) != len(that1.Field1) {
11630 return false
11631 }
11632 for i := range this.Field1 {
11633 if this.Field1[i] != that1.Field1[i] {
11634 return false
11635 }
11636 }
11637 if len(this.Field2) != len(that1.Field2) {
11638 return false
11639 }
11640 for i := range this.Field2 {
11641 if this.Field2[i] != that1.Field2[i] {
11642 return false
11643 }
11644 }
11645 if len(this.Field3) != len(that1.Field3) {
11646 return false
11647 }
11648 for i := range this.Field3 {
11649 if !this.Field3[i].Equal(&that1.Field3[i]) {
11650 return false
11651 }
11652 }
11653 if len(this.Field4) != len(that1.Field4) {
11654 return false
11655 }
11656 for i := range this.Field4 {
11657 if !this.Field4[i].Equal(&that1.Field4[i]) {
11658 return false
11659 }
11660 }
11661 if len(this.Field6) != len(that1.Field6) {
11662 return false
11663 }
11664 for i := range this.Field6 {
11665 if this.Field6[i] != that1.Field6[i] {
11666 return false
11667 }
11668 }
11669 if len(this.Field7) != len(that1.Field7) {
11670 return false
11671 }
11672 for i := range this.Field7 {
11673 if this.Field7[i] != that1.Field7[i] {
11674 return false
11675 }
11676 }
11677 if len(this.Field8) != len(that1.Field8) {
11678 return false
11679 }
11680 for i := range this.Field8 {
11681 if !this.Field8[i].Equal(&that1.Field8[i]) {
11682 return false
11683 }
11684 }
11685 if len(this.Field13) != len(that1.Field13) {
11686 return false
11687 }
11688 for i := range this.Field13 {
11689 if this.Field13[i] != that1.Field13[i] {
11690 return false
11691 }
11692 }
11693 if len(this.Field14) != len(that1.Field14) {
11694 return false
11695 }
11696 for i := range this.Field14 {
11697 if this.Field14[i] != that1.Field14[i] {
11698 return false
11699 }
11700 }
11701 if len(this.Field15) != len(that1.Field15) {
11702 return false
11703 }
11704 for i := range this.Field15 {
11705 if !bytes.Equal(this.Field15[i], that1.Field15[i]) {
11706 return false
11707 }
11708 }
11709 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11710 return false
11711 }
11712 return true
11713 }
11714 func (this *NinRepStruct) VerboseEqual(that interface{}) error {
11715 if that == nil {
11716 if this == nil {
11717 return nil
11718 }
11719 return fmt.Errorf("that == nil && this != nil")
11720 }
11721
11722 that1, ok := that.(*NinRepStruct)
11723 if !ok {
11724 that2, ok := that.(NinRepStruct)
11725 if ok {
11726 that1 = &that2
11727 } else {
11728 return fmt.Errorf("that is not of type *NinRepStruct")
11729 }
11730 }
11731 if that1 == nil {
11732 if this == nil {
11733 return nil
11734 }
11735 return fmt.Errorf("that is type *NinRepStruct but is nil && this != nil")
11736 } else if this == nil {
11737 return fmt.Errorf("that is type *NinRepStruct but is not nil && this == nil")
11738 }
11739 if len(this.Field1) != len(that1.Field1) {
11740 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1))
11741 }
11742 for i := range this.Field1 {
11743 if this.Field1[i] != that1.Field1[i] {
11744 return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i])
11745 }
11746 }
11747 if len(this.Field2) != len(that1.Field2) {
11748 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
11749 }
11750 for i := range this.Field2 {
11751 if this.Field2[i] != that1.Field2[i] {
11752 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
11753 }
11754 }
11755 if len(this.Field3) != len(that1.Field3) {
11756 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3))
11757 }
11758 for i := range this.Field3 {
11759 if !this.Field3[i].Equal(that1.Field3[i]) {
11760 return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i])
11761 }
11762 }
11763 if len(this.Field4) != len(that1.Field4) {
11764 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4))
11765 }
11766 for i := range this.Field4 {
11767 if !this.Field4[i].Equal(that1.Field4[i]) {
11768 return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i])
11769 }
11770 }
11771 if len(this.Field6) != len(that1.Field6) {
11772 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6))
11773 }
11774 for i := range this.Field6 {
11775 if this.Field6[i] != that1.Field6[i] {
11776 return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i])
11777 }
11778 }
11779 if len(this.Field7) != len(that1.Field7) {
11780 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7))
11781 }
11782 for i := range this.Field7 {
11783 if this.Field7[i] != that1.Field7[i] {
11784 return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i])
11785 }
11786 }
11787 if len(this.Field8) != len(that1.Field8) {
11788 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8))
11789 }
11790 for i := range this.Field8 {
11791 if !this.Field8[i].Equal(that1.Field8[i]) {
11792 return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i])
11793 }
11794 }
11795 if len(this.Field13) != len(that1.Field13) {
11796 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13))
11797 }
11798 for i := range this.Field13 {
11799 if this.Field13[i] != that1.Field13[i] {
11800 return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i])
11801 }
11802 }
11803 if len(this.Field14) != len(that1.Field14) {
11804 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14))
11805 }
11806 for i := range this.Field14 {
11807 if this.Field14[i] != that1.Field14[i] {
11808 return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i])
11809 }
11810 }
11811 if len(this.Field15) != len(that1.Field15) {
11812 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15))
11813 }
11814 for i := range this.Field15 {
11815 if !bytes.Equal(this.Field15[i], that1.Field15[i]) {
11816 return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i])
11817 }
11818 }
11819 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11820 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
11821 }
11822 return nil
11823 }
11824 func (this *NinRepStruct) Equal(that interface{}) bool {
11825 if that == nil {
11826 return this == nil
11827 }
11828
11829 that1, ok := that.(*NinRepStruct)
11830 if !ok {
11831 that2, ok := that.(NinRepStruct)
11832 if ok {
11833 that1 = &that2
11834 } else {
11835 return false
11836 }
11837 }
11838 if that1 == nil {
11839 return this == nil
11840 } else if this == nil {
11841 return false
11842 }
11843 if len(this.Field1) != len(that1.Field1) {
11844 return false
11845 }
11846 for i := range this.Field1 {
11847 if this.Field1[i] != that1.Field1[i] {
11848 return false
11849 }
11850 }
11851 if len(this.Field2) != len(that1.Field2) {
11852 return false
11853 }
11854 for i := range this.Field2 {
11855 if this.Field2[i] != that1.Field2[i] {
11856 return false
11857 }
11858 }
11859 if len(this.Field3) != len(that1.Field3) {
11860 return false
11861 }
11862 for i := range this.Field3 {
11863 if !this.Field3[i].Equal(that1.Field3[i]) {
11864 return false
11865 }
11866 }
11867 if len(this.Field4) != len(that1.Field4) {
11868 return false
11869 }
11870 for i := range this.Field4 {
11871 if !this.Field4[i].Equal(that1.Field4[i]) {
11872 return false
11873 }
11874 }
11875 if len(this.Field6) != len(that1.Field6) {
11876 return false
11877 }
11878 for i := range this.Field6 {
11879 if this.Field6[i] != that1.Field6[i] {
11880 return false
11881 }
11882 }
11883 if len(this.Field7) != len(that1.Field7) {
11884 return false
11885 }
11886 for i := range this.Field7 {
11887 if this.Field7[i] != that1.Field7[i] {
11888 return false
11889 }
11890 }
11891 if len(this.Field8) != len(that1.Field8) {
11892 return false
11893 }
11894 for i := range this.Field8 {
11895 if !this.Field8[i].Equal(that1.Field8[i]) {
11896 return false
11897 }
11898 }
11899 if len(this.Field13) != len(that1.Field13) {
11900 return false
11901 }
11902 for i := range this.Field13 {
11903 if this.Field13[i] != that1.Field13[i] {
11904 return false
11905 }
11906 }
11907 if len(this.Field14) != len(that1.Field14) {
11908 return false
11909 }
11910 for i := range this.Field14 {
11911 if this.Field14[i] != that1.Field14[i] {
11912 return false
11913 }
11914 }
11915 if len(this.Field15) != len(that1.Field15) {
11916 return false
11917 }
11918 for i := range this.Field15 {
11919 if !bytes.Equal(this.Field15[i], that1.Field15[i]) {
11920 return false
11921 }
11922 }
11923 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11924 return false
11925 }
11926 return true
11927 }
11928 func (this *NidEmbeddedStruct) VerboseEqual(that interface{}) error {
11929 if that == nil {
11930 if this == nil {
11931 return nil
11932 }
11933 return fmt.Errorf("that == nil && this != nil")
11934 }
11935
11936 that1, ok := that.(*NidEmbeddedStruct)
11937 if !ok {
11938 that2, ok := that.(NidEmbeddedStruct)
11939 if ok {
11940 that1 = &that2
11941 } else {
11942 return fmt.Errorf("that is not of type *NidEmbeddedStruct")
11943 }
11944 }
11945 if that1 == nil {
11946 if this == nil {
11947 return nil
11948 }
11949 return fmt.Errorf("that is type *NidEmbeddedStruct but is nil && this != nil")
11950 } else if this == nil {
11951 return fmt.Errorf("that is type *NidEmbeddedStruct but is not nil && this == nil")
11952 }
11953 if !this.NidOptNative.Equal(that1.NidOptNative) {
11954 return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative)
11955 }
11956 if !this.Field200.Equal(&that1.Field200) {
11957 return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200)
11958 }
11959 if this.Field210 != that1.Field210 {
11960 return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210)
11961 }
11962 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11963 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
11964 }
11965 return nil
11966 }
11967 func (this *NidEmbeddedStruct) Equal(that interface{}) bool {
11968 if that == nil {
11969 return this == nil
11970 }
11971
11972 that1, ok := that.(*NidEmbeddedStruct)
11973 if !ok {
11974 that2, ok := that.(NidEmbeddedStruct)
11975 if ok {
11976 that1 = &that2
11977 } else {
11978 return false
11979 }
11980 }
11981 if that1 == nil {
11982 return this == nil
11983 } else if this == nil {
11984 return false
11985 }
11986 if !this.NidOptNative.Equal(that1.NidOptNative) {
11987 return false
11988 }
11989 if !this.Field200.Equal(&that1.Field200) {
11990 return false
11991 }
11992 if this.Field210 != that1.Field210 {
11993 return false
11994 }
11995 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
11996 return false
11997 }
11998 return true
11999 }
12000 func (this *NinEmbeddedStruct) VerboseEqual(that interface{}) error {
12001 if that == nil {
12002 if this == nil {
12003 return nil
12004 }
12005 return fmt.Errorf("that == nil && this != nil")
12006 }
12007
12008 that1, ok := that.(*NinEmbeddedStruct)
12009 if !ok {
12010 that2, ok := that.(NinEmbeddedStruct)
12011 if ok {
12012 that1 = &that2
12013 } else {
12014 return fmt.Errorf("that is not of type *NinEmbeddedStruct")
12015 }
12016 }
12017 if that1 == nil {
12018 if this == nil {
12019 return nil
12020 }
12021 return fmt.Errorf("that is type *NinEmbeddedStruct but is nil && this != nil")
12022 } else if this == nil {
12023 return fmt.Errorf("that is type *NinEmbeddedStruct but is not nil && this == nil")
12024 }
12025 if !this.NidOptNative.Equal(that1.NidOptNative) {
12026 return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative)
12027 }
12028 if !this.Field200.Equal(that1.Field200) {
12029 return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200)
12030 }
12031 if this.Field210 != nil && that1.Field210 != nil {
12032 if *this.Field210 != *that1.Field210 {
12033 return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210)
12034 }
12035 } else if this.Field210 != nil {
12036 return fmt.Errorf("this.Field210 == nil && that.Field210 != nil")
12037 } else if that1.Field210 != nil {
12038 return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210)
12039 }
12040 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12041 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
12042 }
12043 return nil
12044 }
12045 func (this *NinEmbeddedStruct) Equal(that interface{}) bool {
12046 if that == nil {
12047 return this == nil
12048 }
12049
12050 that1, ok := that.(*NinEmbeddedStruct)
12051 if !ok {
12052 that2, ok := that.(NinEmbeddedStruct)
12053 if ok {
12054 that1 = &that2
12055 } else {
12056 return false
12057 }
12058 }
12059 if that1 == nil {
12060 return this == nil
12061 } else if this == nil {
12062 return false
12063 }
12064 if !this.NidOptNative.Equal(that1.NidOptNative) {
12065 return false
12066 }
12067 if !this.Field200.Equal(that1.Field200) {
12068 return false
12069 }
12070 if this.Field210 != nil && that1.Field210 != nil {
12071 if *this.Field210 != *that1.Field210 {
12072 return false
12073 }
12074 } else if this.Field210 != nil {
12075 return false
12076 } else if that1.Field210 != nil {
12077 return false
12078 }
12079 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12080 return false
12081 }
12082 return true
12083 }
12084 func (this *NidNestedStruct) VerboseEqual(that interface{}) error {
12085 if that == nil {
12086 if this == nil {
12087 return nil
12088 }
12089 return fmt.Errorf("that == nil && this != nil")
12090 }
12091
12092 that1, ok := that.(*NidNestedStruct)
12093 if !ok {
12094 that2, ok := that.(NidNestedStruct)
12095 if ok {
12096 that1 = &that2
12097 } else {
12098 return fmt.Errorf("that is not of type *NidNestedStruct")
12099 }
12100 }
12101 if that1 == nil {
12102 if this == nil {
12103 return nil
12104 }
12105 return fmt.Errorf("that is type *NidNestedStruct but is nil && this != nil")
12106 } else if this == nil {
12107 return fmt.Errorf("that is type *NidNestedStruct but is not nil && this == nil")
12108 }
12109 if !this.Field1.Equal(&that1.Field1) {
12110 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
12111 }
12112 if len(this.Field2) != len(that1.Field2) {
12113 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
12114 }
12115 for i := range this.Field2 {
12116 if !this.Field2[i].Equal(&that1.Field2[i]) {
12117 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
12118 }
12119 }
12120 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12121 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
12122 }
12123 return nil
12124 }
12125 func (this *NidNestedStruct) Equal(that interface{}) bool {
12126 if that == nil {
12127 return this == nil
12128 }
12129
12130 that1, ok := that.(*NidNestedStruct)
12131 if !ok {
12132 that2, ok := that.(NidNestedStruct)
12133 if ok {
12134 that1 = &that2
12135 } else {
12136 return false
12137 }
12138 }
12139 if that1 == nil {
12140 return this == nil
12141 } else if this == nil {
12142 return false
12143 }
12144 if !this.Field1.Equal(&that1.Field1) {
12145 return false
12146 }
12147 if len(this.Field2) != len(that1.Field2) {
12148 return false
12149 }
12150 for i := range this.Field2 {
12151 if !this.Field2[i].Equal(&that1.Field2[i]) {
12152 return false
12153 }
12154 }
12155 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12156 return false
12157 }
12158 return true
12159 }
12160 func (this *NinNestedStruct) VerboseEqual(that interface{}) error {
12161 if that == nil {
12162 if this == nil {
12163 return nil
12164 }
12165 return fmt.Errorf("that == nil && this != nil")
12166 }
12167
12168 that1, ok := that.(*NinNestedStruct)
12169 if !ok {
12170 that2, ok := that.(NinNestedStruct)
12171 if ok {
12172 that1 = &that2
12173 } else {
12174 return fmt.Errorf("that is not of type *NinNestedStruct")
12175 }
12176 }
12177 if that1 == nil {
12178 if this == nil {
12179 return nil
12180 }
12181 return fmt.Errorf("that is type *NinNestedStruct but is nil && this != nil")
12182 } else if this == nil {
12183 return fmt.Errorf("that is type *NinNestedStruct but is not nil && this == nil")
12184 }
12185 if !this.Field1.Equal(that1.Field1) {
12186 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
12187 }
12188 if len(this.Field2) != len(that1.Field2) {
12189 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
12190 }
12191 for i := range this.Field2 {
12192 if !this.Field2[i].Equal(that1.Field2[i]) {
12193 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
12194 }
12195 }
12196 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12197 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
12198 }
12199 return nil
12200 }
12201 func (this *NinNestedStruct) Equal(that interface{}) bool {
12202 if that == nil {
12203 return this == nil
12204 }
12205
12206 that1, ok := that.(*NinNestedStruct)
12207 if !ok {
12208 that2, ok := that.(NinNestedStruct)
12209 if ok {
12210 that1 = &that2
12211 } else {
12212 return false
12213 }
12214 }
12215 if that1 == nil {
12216 return this == nil
12217 } else if this == nil {
12218 return false
12219 }
12220 if !this.Field1.Equal(that1.Field1) {
12221 return false
12222 }
12223 if len(this.Field2) != len(that1.Field2) {
12224 return false
12225 }
12226 for i := range this.Field2 {
12227 if !this.Field2[i].Equal(that1.Field2[i]) {
12228 return false
12229 }
12230 }
12231 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12232 return false
12233 }
12234 return true
12235 }
12236 func (this *NidOptCustom) VerboseEqual(that interface{}) error {
12237 if that == nil {
12238 if this == nil {
12239 return nil
12240 }
12241 return fmt.Errorf("that == nil && this != nil")
12242 }
12243
12244 that1, ok := that.(*NidOptCustom)
12245 if !ok {
12246 that2, ok := that.(NidOptCustom)
12247 if ok {
12248 that1 = &that2
12249 } else {
12250 return fmt.Errorf("that is not of type *NidOptCustom")
12251 }
12252 }
12253 if that1 == nil {
12254 if this == nil {
12255 return nil
12256 }
12257 return fmt.Errorf("that is type *NidOptCustom but is nil && this != nil")
12258 } else if this == nil {
12259 return fmt.Errorf("that is type *NidOptCustom but is not nil && this == nil")
12260 }
12261 if !this.Id.Equal(that1.Id) {
12262 return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id)
12263 }
12264 if !this.Value.Equal(that1.Value) {
12265 return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value)
12266 }
12267 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12268 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
12269 }
12270 return nil
12271 }
12272 func (this *NidOptCustom) Equal(that interface{}) bool {
12273 if that == nil {
12274 return this == nil
12275 }
12276
12277 that1, ok := that.(*NidOptCustom)
12278 if !ok {
12279 that2, ok := that.(NidOptCustom)
12280 if ok {
12281 that1 = &that2
12282 } else {
12283 return false
12284 }
12285 }
12286 if that1 == nil {
12287 return this == nil
12288 } else if this == nil {
12289 return false
12290 }
12291 if !this.Id.Equal(that1.Id) {
12292 return false
12293 }
12294 if !this.Value.Equal(that1.Value) {
12295 return false
12296 }
12297 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12298 return false
12299 }
12300 return true
12301 }
12302 func (this *CustomDash) VerboseEqual(that interface{}) error {
12303 if that == nil {
12304 if this == nil {
12305 return nil
12306 }
12307 return fmt.Errorf("that == nil && this != nil")
12308 }
12309
12310 that1, ok := that.(*CustomDash)
12311 if !ok {
12312 that2, ok := that.(CustomDash)
12313 if ok {
12314 that1 = &that2
12315 } else {
12316 return fmt.Errorf("that is not of type *CustomDash")
12317 }
12318 }
12319 if that1 == nil {
12320 if this == nil {
12321 return nil
12322 }
12323 return fmt.Errorf("that is type *CustomDash but is nil && this != nil")
12324 } else if this == nil {
12325 return fmt.Errorf("that is type *CustomDash but is not nil && this == nil")
12326 }
12327 if that1.Value == nil {
12328 if this.Value != nil {
12329 return fmt.Errorf("this.Value != nil && that1.Value == nil")
12330 }
12331 } else if !this.Value.Equal(*that1.Value) {
12332 return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value)
12333 }
12334 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12335 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
12336 }
12337 return nil
12338 }
12339 func (this *CustomDash) Equal(that interface{}) bool {
12340 if that == nil {
12341 return this == nil
12342 }
12343
12344 that1, ok := that.(*CustomDash)
12345 if !ok {
12346 that2, ok := that.(CustomDash)
12347 if ok {
12348 that1 = &that2
12349 } else {
12350 return false
12351 }
12352 }
12353 if that1 == nil {
12354 return this == nil
12355 } else if this == nil {
12356 return false
12357 }
12358 if that1.Value == nil {
12359 if this.Value != nil {
12360 return false
12361 }
12362 } else if !this.Value.Equal(*that1.Value) {
12363 return false
12364 }
12365 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12366 return false
12367 }
12368 return true
12369 }
12370 func (this *NinOptCustom) VerboseEqual(that interface{}) error {
12371 if that == nil {
12372 if this == nil {
12373 return nil
12374 }
12375 return fmt.Errorf("that == nil && this != nil")
12376 }
12377
12378 that1, ok := that.(*NinOptCustom)
12379 if !ok {
12380 that2, ok := that.(NinOptCustom)
12381 if ok {
12382 that1 = &that2
12383 } else {
12384 return fmt.Errorf("that is not of type *NinOptCustom")
12385 }
12386 }
12387 if that1 == nil {
12388 if this == nil {
12389 return nil
12390 }
12391 return fmt.Errorf("that is type *NinOptCustom but is nil && this != nil")
12392 } else if this == nil {
12393 return fmt.Errorf("that is type *NinOptCustom but is not nil && this == nil")
12394 }
12395 if that1.Id == nil {
12396 if this.Id != nil {
12397 return fmt.Errorf("this.Id != nil && that1.Id == nil")
12398 }
12399 } else if !this.Id.Equal(*that1.Id) {
12400 return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id)
12401 }
12402 if that1.Value == nil {
12403 if this.Value != nil {
12404 return fmt.Errorf("this.Value != nil && that1.Value == nil")
12405 }
12406 } else if !this.Value.Equal(*that1.Value) {
12407 return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value)
12408 }
12409 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12410 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
12411 }
12412 return nil
12413 }
12414 func (this *NinOptCustom) Equal(that interface{}) bool {
12415 if that == nil {
12416 return this == nil
12417 }
12418
12419 that1, ok := that.(*NinOptCustom)
12420 if !ok {
12421 that2, ok := that.(NinOptCustom)
12422 if ok {
12423 that1 = &that2
12424 } else {
12425 return false
12426 }
12427 }
12428 if that1 == nil {
12429 return this == nil
12430 } else if this == nil {
12431 return false
12432 }
12433 if that1.Id == nil {
12434 if this.Id != nil {
12435 return false
12436 }
12437 } else if !this.Id.Equal(*that1.Id) {
12438 return false
12439 }
12440 if that1.Value == nil {
12441 if this.Value != nil {
12442 return false
12443 }
12444 } else if !this.Value.Equal(*that1.Value) {
12445 return false
12446 }
12447 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12448 return false
12449 }
12450 return true
12451 }
12452 func (this *NidRepCustom) VerboseEqual(that interface{}) error {
12453 if that == nil {
12454 if this == nil {
12455 return nil
12456 }
12457 return fmt.Errorf("that == nil && this != nil")
12458 }
12459
12460 that1, ok := that.(*NidRepCustom)
12461 if !ok {
12462 that2, ok := that.(NidRepCustom)
12463 if ok {
12464 that1 = &that2
12465 } else {
12466 return fmt.Errorf("that is not of type *NidRepCustom")
12467 }
12468 }
12469 if that1 == nil {
12470 if this == nil {
12471 return nil
12472 }
12473 return fmt.Errorf("that is type *NidRepCustom but is nil && this != nil")
12474 } else if this == nil {
12475 return fmt.Errorf("that is type *NidRepCustom but is not nil && this == nil")
12476 }
12477 if len(this.Id) != len(that1.Id) {
12478 return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id))
12479 }
12480 for i := range this.Id {
12481 if !this.Id[i].Equal(that1.Id[i]) {
12482 return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i])
12483 }
12484 }
12485 if len(this.Value) != len(that1.Value) {
12486 return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value))
12487 }
12488 for i := range this.Value {
12489 if !this.Value[i].Equal(that1.Value[i]) {
12490 return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i])
12491 }
12492 }
12493 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12494 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
12495 }
12496 return nil
12497 }
12498 func (this *NidRepCustom) Equal(that interface{}) bool {
12499 if that == nil {
12500 return this == nil
12501 }
12502
12503 that1, ok := that.(*NidRepCustom)
12504 if !ok {
12505 that2, ok := that.(NidRepCustom)
12506 if ok {
12507 that1 = &that2
12508 } else {
12509 return false
12510 }
12511 }
12512 if that1 == nil {
12513 return this == nil
12514 } else if this == nil {
12515 return false
12516 }
12517 if len(this.Id) != len(that1.Id) {
12518 return false
12519 }
12520 for i := range this.Id {
12521 if !this.Id[i].Equal(that1.Id[i]) {
12522 return false
12523 }
12524 }
12525 if len(this.Value) != len(that1.Value) {
12526 return false
12527 }
12528 for i := range this.Value {
12529 if !this.Value[i].Equal(that1.Value[i]) {
12530 return false
12531 }
12532 }
12533 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12534 return false
12535 }
12536 return true
12537 }
12538 func (this *NinRepCustom) VerboseEqual(that interface{}) error {
12539 if that == nil {
12540 if this == nil {
12541 return nil
12542 }
12543 return fmt.Errorf("that == nil && this != nil")
12544 }
12545
12546 that1, ok := that.(*NinRepCustom)
12547 if !ok {
12548 that2, ok := that.(NinRepCustom)
12549 if ok {
12550 that1 = &that2
12551 } else {
12552 return fmt.Errorf("that is not of type *NinRepCustom")
12553 }
12554 }
12555 if that1 == nil {
12556 if this == nil {
12557 return nil
12558 }
12559 return fmt.Errorf("that is type *NinRepCustom but is nil && this != nil")
12560 } else if this == nil {
12561 return fmt.Errorf("that is type *NinRepCustom but is not nil && this == nil")
12562 }
12563 if len(this.Id) != len(that1.Id) {
12564 return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id))
12565 }
12566 for i := range this.Id {
12567 if !this.Id[i].Equal(that1.Id[i]) {
12568 return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i])
12569 }
12570 }
12571 if len(this.Value) != len(that1.Value) {
12572 return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value))
12573 }
12574 for i := range this.Value {
12575 if !this.Value[i].Equal(that1.Value[i]) {
12576 return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i])
12577 }
12578 }
12579 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12580 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
12581 }
12582 return nil
12583 }
12584 func (this *NinRepCustom) Equal(that interface{}) bool {
12585 if that == nil {
12586 return this == nil
12587 }
12588
12589 that1, ok := that.(*NinRepCustom)
12590 if !ok {
12591 that2, ok := that.(NinRepCustom)
12592 if ok {
12593 that1 = &that2
12594 } else {
12595 return false
12596 }
12597 }
12598 if that1 == nil {
12599 return this == nil
12600 } else if this == nil {
12601 return false
12602 }
12603 if len(this.Id) != len(that1.Id) {
12604 return false
12605 }
12606 for i := range this.Id {
12607 if !this.Id[i].Equal(that1.Id[i]) {
12608 return false
12609 }
12610 }
12611 if len(this.Value) != len(that1.Value) {
12612 return false
12613 }
12614 for i := range this.Value {
12615 if !this.Value[i].Equal(that1.Value[i]) {
12616 return false
12617 }
12618 }
12619 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12620 return false
12621 }
12622 return true
12623 }
12624 func (this *NinOptNativeUnion) VerboseEqual(that interface{}) error {
12625 if that == nil {
12626 if this == nil {
12627 return nil
12628 }
12629 return fmt.Errorf("that == nil && this != nil")
12630 }
12631
12632 that1, ok := that.(*NinOptNativeUnion)
12633 if !ok {
12634 that2, ok := that.(NinOptNativeUnion)
12635 if ok {
12636 that1 = &that2
12637 } else {
12638 return fmt.Errorf("that is not of type *NinOptNativeUnion")
12639 }
12640 }
12641 if that1 == nil {
12642 if this == nil {
12643 return nil
12644 }
12645 return fmt.Errorf("that is type *NinOptNativeUnion but is nil && this != nil")
12646 } else if this == nil {
12647 return fmt.Errorf("that is type *NinOptNativeUnion but is not nil && this == nil")
12648 }
12649 if this.Field1 != nil && that1.Field1 != nil {
12650 if *this.Field1 != *that1.Field1 {
12651 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
12652 }
12653 } else if this.Field1 != nil {
12654 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
12655 } else if that1.Field1 != nil {
12656 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
12657 }
12658 if this.Field2 != nil && that1.Field2 != nil {
12659 if *this.Field2 != *that1.Field2 {
12660 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
12661 }
12662 } else if this.Field2 != nil {
12663 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
12664 } else if that1.Field2 != nil {
12665 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
12666 }
12667 if this.Field3 != nil && that1.Field3 != nil {
12668 if *this.Field3 != *that1.Field3 {
12669 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
12670 }
12671 } else if this.Field3 != nil {
12672 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
12673 } else if that1.Field3 != nil {
12674 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
12675 }
12676 if this.Field4 != nil && that1.Field4 != nil {
12677 if *this.Field4 != *that1.Field4 {
12678 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4)
12679 }
12680 } else if this.Field4 != nil {
12681 return fmt.Errorf("this.Field4 == nil && that.Field4 != nil")
12682 } else if that1.Field4 != nil {
12683 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4)
12684 }
12685 if this.Field5 != nil && that1.Field5 != nil {
12686 if *this.Field5 != *that1.Field5 {
12687 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5)
12688 }
12689 } else if this.Field5 != nil {
12690 return fmt.Errorf("this.Field5 == nil && that.Field5 != nil")
12691 } else if that1.Field5 != nil {
12692 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5)
12693 }
12694 if this.Field6 != nil && that1.Field6 != nil {
12695 if *this.Field6 != *that1.Field6 {
12696 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6)
12697 }
12698 } else if this.Field6 != nil {
12699 return fmt.Errorf("this.Field6 == nil && that.Field6 != nil")
12700 } else if that1.Field6 != nil {
12701 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6)
12702 }
12703 if this.Field13 != nil && that1.Field13 != nil {
12704 if *this.Field13 != *that1.Field13 {
12705 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13)
12706 }
12707 } else if this.Field13 != nil {
12708 return fmt.Errorf("this.Field13 == nil && that.Field13 != nil")
12709 } else if that1.Field13 != nil {
12710 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13)
12711 }
12712 if this.Field14 != nil && that1.Field14 != nil {
12713 if *this.Field14 != *that1.Field14 {
12714 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14)
12715 }
12716 } else if this.Field14 != nil {
12717 return fmt.Errorf("this.Field14 == nil && that.Field14 != nil")
12718 } else if that1.Field14 != nil {
12719 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14)
12720 }
12721 if !bytes.Equal(this.Field15, that1.Field15) {
12722 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15)
12723 }
12724 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12725 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
12726 }
12727 return nil
12728 }
12729 func (this *NinOptNativeUnion) Equal(that interface{}) bool {
12730 if that == nil {
12731 return this == nil
12732 }
12733
12734 that1, ok := that.(*NinOptNativeUnion)
12735 if !ok {
12736 that2, ok := that.(NinOptNativeUnion)
12737 if ok {
12738 that1 = &that2
12739 } else {
12740 return false
12741 }
12742 }
12743 if that1 == nil {
12744 return this == nil
12745 } else if this == nil {
12746 return false
12747 }
12748 if this.Field1 != nil && that1.Field1 != nil {
12749 if *this.Field1 != *that1.Field1 {
12750 return false
12751 }
12752 } else if this.Field1 != nil {
12753 return false
12754 } else if that1.Field1 != nil {
12755 return false
12756 }
12757 if this.Field2 != nil && that1.Field2 != nil {
12758 if *this.Field2 != *that1.Field2 {
12759 return false
12760 }
12761 } else if this.Field2 != nil {
12762 return false
12763 } else if that1.Field2 != nil {
12764 return false
12765 }
12766 if this.Field3 != nil && that1.Field3 != nil {
12767 if *this.Field3 != *that1.Field3 {
12768 return false
12769 }
12770 } else if this.Field3 != nil {
12771 return false
12772 } else if that1.Field3 != nil {
12773 return false
12774 }
12775 if this.Field4 != nil && that1.Field4 != nil {
12776 if *this.Field4 != *that1.Field4 {
12777 return false
12778 }
12779 } else if this.Field4 != nil {
12780 return false
12781 } else if that1.Field4 != nil {
12782 return false
12783 }
12784 if this.Field5 != nil && that1.Field5 != nil {
12785 if *this.Field5 != *that1.Field5 {
12786 return false
12787 }
12788 } else if this.Field5 != nil {
12789 return false
12790 } else if that1.Field5 != nil {
12791 return false
12792 }
12793 if this.Field6 != nil && that1.Field6 != nil {
12794 if *this.Field6 != *that1.Field6 {
12795 return false
12796 }
12797 } else if this.Field6 != nil {
12798 return false
12799 } else if that1.Field6 != nil {
12800 return false
12801 }
12802 if this.Field13 != nil && that1.Field13 != nil {
12803 if *this.Field13 != *that1.Field13 {
12804 return false
12805 }
12806 } else if this.Field13 != nil {
12807 return false
12808 } else if that1.Field13 != nil {
12809 return false
12810 }
12811 if this.Field14 != nil && that1.Field14 != nil {
12812 if *this.Field14 != *that1.Field14 {
12813 return false
12814 }
12815 } else if this.Field14 != nil {
12816 return false
12817 } else if that1.Field14 != nil {
12818 return false
12819 }
12820 if !bytes.Equal(this.Field15, that1.Field15) {
12821 return false
12822 }
12823 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12824 return false
12825 }
12826 return true
12827 }
12828 func (this *NinOptStructUnion) VerboseEqual(that interface{}) error {
12829 if that == nil {
12830 if this == nil {
12831 return nil
12832 }
12833 return fmt.Errorf("that == nil && this != nil")
12834 }
12835
12836 that1, ok := that.(*NinOptStructUnion)
12837 if !ok {
12838 that2, ok := that.(NinOptStructUnion)
12839 if ok {
12840 that1 = &that2
12841 } else {
12842 return fmt.Errorf("that is not of type *NinOptStructUnion")
12843 }
12844 }
12845 if that1 == nil {
12846 if this == nil {
12847 return nil
12848 }
12849 return fmt.Errorf("that is type *NinOptStructUnion but is nil && this != nil")
12850 } else if this == nil {
12851 return fmt.Errorf("that is type *NinOptStructUnion but is not nil && this == nil")
12852 }
12853 if this.Field1 != nil && that1.Field1 != nil {
12854 if *this.Field1 != *that1.Field1 {
12855 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
12856 }
12857 } else if this.Field1 != nil {
12858 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
12859 } else if that1.Field1 != nil {
12860 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
12861 }
12862 if this.Field2 != nil && that1.Field2 != nil {
12863 if *this.Field2 != *that1.Field2 {
12864 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
12865 }
12866 } else if this.Field2 != nil {
12867 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
12868 } else if that1.Field2 != nil {
12869 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
12870 }
12871 if !this.Field3.Equal(that1.Field3) {
12872 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
12873 }
12874 if !this.Field4.Equal(that1.Field4) {
12875 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4)
12876 }
12877 if this.Field6 != nil && that1.Field6 != nil {
12878 if *this.Field6 != *that1.Field6 {
12879 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6)
12880 }
12881 } else if this.Field6 != nil {
12882 return fmt.Errorf("this.Field6 == nil && that.Field6 != nil")
12883 } else if that1.Field6 != nil {
12884 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6)
12885 }
12886 if this.Field7 != nil && that1.Field7 != nil {
12887 if *this.Field7 != *that1.Field7 {
12888 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7)
12889 }
12890 } else if this.Field7 != nil {
12891 return fmt.Errorf("this.Field7 == nil && that.Field7 != nil")
12892 } else if that1.Field7 != nil {
12893 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7)
12894 }
12895 if this.Field13 != nil && that1.Field13 != nil {
12896 if *this.Field13 != *that1.Field13 {
12897 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13)
12898 }
12899 } else if this.Field13 != nil {
12900 return fmt.Errorf("this.Field13 == nil && that.Field13 != nil")
12901 } else if that1.Field13 != nil {
12902 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13)
12903 }
12904 if this.Field14 != nil && that1.Field14 != nil {
12905 if *this.Field14 != *that1.Field14 {
12906 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14)
12907 }
12908 } else if this.Field14 != nil {
12909 return fmt.Errorf("this.Field14 == nil && that.Field14 != nil")
12910 } else if that1.Field14 != nil {
12911 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14)
12912 }
12913 if !bytes.Equal(this.Field15, that1.Field15) {
12914 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15)
12915 }
12916 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
12917 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
12918 }
12919 return nil
12920 }
12921 func (this *NinOptStructUnion) Equal(that interface{}) bool {
12922 if that == nil {
12923 return this == nil
12924 }
12925
12926 that1, ok := that.(*NinOptStructUnion)
12927 if !ok {
12928 that2, ok := that.(NinOptStructUnion)
12929 if ok {
12930 that1 = &that2
12931 } else {
12932 return false
12933 }
12934 }
12935 if that1 == nil {
12936 return this == nil
12937 } else if this == nil {
12938 return false
12939 }
12940 if this.Field1 != nil && that1.Field1 != nil {
12941 if *this.Field1 != *that1.Field1 {
12942 return false
12943 }
12944 } else if this.Field1 != nil {
12945 return false
12946 } else if that1.Field1 != nil {
12947 return false
12948 }
12949 if this.Field2 != nil && that1.Field2 != nil {
12950 if *this.Field2 != *that1.Field2 {
12951 return false
12952 }
12953 } else if this.Field2 != nil {
12954 return false
12955 } else if that1.Field2 != nil {
12956 return false
12957 }
12958 if !this.Field3.Equal(that1.Field3) {
12959 return false
12960 }
12961 if !this.Field4.Equal(that1.Field4) {
12962 return false
12963 }
12964 if this.Field6 != nil && that1.Field6 != nil {
12965 if *this.Field6 != *that1.Field6 {
12966 return false
12967 }
12968 } else if this.Field6 != nil {
12969 return false
12970 } else if that1.Field6 != nil {
12971 return false
12972 }
12973 if this.Field7 != nil && that1.Field7 != nil {
12974 if *this.Field7 != *that1.Field7 {
12975 return false
12976 }
12977 } else if this.Field7 != nil {
12978 return false
12979 } else if that1.Field7 != nil {
12980 return false
12981 }
12982 if this.Field13 != nil && that1.Field13 != nil {
12983 if *this.Field13 != *that1.Field13 {
12984 return false
12985 }
12986 } else if this.Field13 != nil {
12987 return false
12988 } else if that1.Field13 != nil {
12989 return false
12990 }
12991 if this.Field14 != nil && that1.Field14 != nil {
12992 if *this.Field14 != *that1.Field14 {
12993 return false
12994 }
12995 } else if this.Field14 != nil {
12996 return false
12997 } else if that1.Field14 != nil {
12998 return false
12999 }
13000 if !bytes.Equal(this.Field15, that1.Field15) {
13001 return false
13002 }
13003 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13004 return false
13005 }
13006 return true
13007 }
13008 func (this *NinEmbeddedStructUnion) VerboseEqual(that interface{}) error {
13009 if that == nil {
13010 if this == nil {
13011 return nil
13012 }
13013 return fmt.Errorf("that == nil && this != nil")
13014 }
13015
13016 that1, ok := that.(*NinEmbeddedStructUnion)
13017 if !ok {
13018 that2, ok := that.(NinEmbeddedStructUnion)
13019 if ok {
13020 that1 = &that2
13021 } else {
13022 return fmt.Errorf("that is not of type *NinEmbeddedStructUnion")
13023 }
13024 }
13025 if that1 == nil {
13026 if this == nil {
13027 return nil
13028 }
13029 return fmt.Errorf("that is type *NinEmbeddedStructUnion but is nil && this != nil")
13030 } else if this == nil {
13031 return fmt.Errorf("that is type *NinEmbeddedStructUnion but is not nil && this == nil")
13032 }
13033 if !this.NidOptNative.Equal(that1.NidOptNative) {
13034 return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative)
13035 }
13036 if !this.Field200.Equal(that1.Field200) {
13037 return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200)
13038 }
13039 if this.Field210 != nil && that1.Field210 != nil {
13040 if *this.Field210 != *that1.Field210 {
13041 return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210)
13042 }
13043 } else if this.Field210 != nil {
13044 return fmt.Errorf("this.Field210 == nil && that.Field210 != nil")
13045 } else if that1.Field210 != nil {
13046 return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210)
13047 }
13048 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13049 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13050 }
13051 return nil
13052 }
13053 func (this *NinEmbeddedStructUnion) Equal(that interface{}) bool {
13054 if that == nil {
13055 return this == nil
13056 }
13057
13058 that1, ok := that.(*NinEmbeddedStructUnion)
13059 if !ok {
13060 that2, ok := that.(NinEmbeddedStructUnion)
13061 if ok {
13062 that1 = &that2
13063 } else {
13064 return false
13065 }
13066 }
13067 if that1 == nil {
13068 return this == nil
13069 } else if this == nil {
13070 return false
13071 }
13072 if !this.NidOptNative.Equal(that1.NidOptNative) {
13073 return false
13074 }
13075 if !this.Field200.Equal(that1.Field200) {
13076 return false
13077 }
13078 if this.Field210 != nil && that1.Field210 != nil {
13079 if *this.Field210 != *that1.Field210 {
13080 return false
13081 }
13082 } else if this.Field210 != nil {
13083 return false
13084 } else if that1.Field210 != nil {
13085 return false
13086 }
13087 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13088 return false
13089 }
13090 return true
13091 }
13092 func (this *NinNestedStructUnion) VerboseEqual(that interface{}) error {
13093 if that == nil {
13094 if this == nil {
13095 return nil
13096 }
13097 return fmt.Errorf("that == nil && this != nil")
13098 }
13099
13100 that1, ok := that.(*NinNestedStructUnion)
13101 if !ok {
13102 that2, ok := that.(NinNestedStructUnion)
13103 if ok {
13104 that1 = &that2
13105 } else {
13106 return fmt.Errorf("that is not of type *NinNestedStructUnion")
13107 }
13108 }
13109 if that1 == nil {
13110 if this == nil {
13111 return nil
13112 }
13113 return fmt.Errorf("that is type *NinNestedStructUnion but is nil && this != nil")
13114 } else if this == nil {
13115 return fmt.Errorf("that is type *NinNestedStructUnion but is not nil && this == nil")
13116 }
13117 if !this.Field1.Equal(that1.Field1) {
13118 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
13119 }
13120 if !this.Field2.Equal(that1.Field2) {
13121 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
13122 }
13123 if !this.Field3.Equal(that1.Field3) {
13124 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
13125 }
13126 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13127 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13128 }
13129 return nil
13130 }
13131 func (this *NinNestedStructUnion) Equal(that interface{}) bool {
13132 if that == nil {
13133 return this == nil
13134 }
13135
13136 that1, ok := that.(*NinNestedStructUnion)
13137 if !ok {
13138 that2, ok := that.(NinNestedStructUnion)
13139 if ok {
13140 that1 = &that2
13141 } else {
13142 return false
13143 }
13144 }
13145 if that1 == nil {
13146 return this == nil
13147 } else if this == nil {
13148 return false
13149 }
13150 if !this.Field1.Equal(that1.Field1) {
13151 return false
13152 }
13153 if !this.Field2.Equal(that1.Field2) {
13154 return false
13155 }
13156 if !this.Field3.Equal(that1.Field3) {
13157 return false
13158 }
13159 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13160 return false
13161 }
13162 return true
13163 }
13164 func (this *Tree) VerboseEqual(that interface{}) error {
13165 if that == nil {
13166 if this == nil {
13167 return nil
13168 }
13169 return fmt.Errorf("that == nil && this != nil")
13170 }
13171
13172 that1, ok := that.(*Tree)
13173 if !ok {
13174 that2, ok := that.(Tree)
13175 if ok {
13176 that1 = &that2
13177 } else {
13178 return fmt.Errorf("that is not of type *Tree")
13179 }
13180 }
13181 if that1 == nil {
13182 if this == nil {
13183 return nil
13184 }
13185 return fmt.Errorf("that is type *Tree but is nil && this != nil")
13186 } else if this == nil {
13187 return fmt.Errorf("that is type *Tree but is not nil && this == nil")
13188 }
13189 if !this.Or.Equal(that1.Or) {
13190 return fmt.Errorf("Or this(%v) Not Equal that(%v)", this.Or, that1.Or)
13191 }
13192 if !this.And.Equal(that1.And) {
13193 return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And)
13194 }
13195 if !this.Leaf.Equal(that1.Leaf) {
13196 return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf)
13197 }
13198 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13199 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13200 }
13201 return nil
13202 }
13203 func (this *Tree) Equal(that interface{}) bool {
13204 if that == nil {
13205 return this == nil
13206 }
13207
13208 that1, ok := that.(*Tree)
13209 if !ok {
13210 that2, ok := that.(Tree)
13211 if ok {
13212 that1 = &that2
13213 } else {
13214 return false
13215 }
13216 }
13217 if that1 == nil {
13218 return this == nil
13219 } else if this == nil {
13220 return false
13221 }
13222 if !this.Or.Equal(that1.Or) {
13223 return false
13224 }
13225 if !this.And.Equal(that1.And) {
13226 return false
13227 }
13228 if !this.Leaf.Equal(that1.Leaf) {
13229 return false
13230 }
13231 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13232 return false
13233 }
13234 return true
13235 }
13236 func (this *OrBranch) VerboseEqual(that interface{}) error {
13237 if that == nil {
13238 if this == nil {
13239 return nil
13240 }
13241 return fmt.Errorf("that == nil && this != nil")
13242 }
13243
13244 that1, ok := that.(*OrBranch)
13245 if !ok {
13246 that2, ok := that.(OrBranch)
13247 if ok {
13248 that1 = &that2
13249 } else {
13250 return fmt.Errorf("that is not of type *OrBranch")
13251 }
13252 }
13253 if that1 == nil {
13254 if this == nil {
13255 return nil
13256 }
13257 return fmt.Errorf("that is type *OrBranch but is nil && this != nil")
13258 } else if this == nil {
13259 return fmt.Errorf("that is type *OrBranch but is not nil && this == nil")
13260 }
13261 if !this.Left.Equal(&that1.Left) {
13262 return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left)
13263 }
13264 if !this.Right.Equal(&that1.Right) {
13265 return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right)
13266 }
13267 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13268 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13269 }
13270 return nil
13271 }
13272 func (this *OrBranch) Equal(that interface{}) bool {
13273 if that == nil {
13274 return this == nil
13275 }
13276
13277 that1, ok := that.(*OrBranch)
13278 if !ok {
13279 that2, ok := that.(OrBranch)
13280 if ok {
13281 that1 = &that2
13282 } else {
13283 return false
13284 }
13285 }
13286 if that1 == nil {
13287 return this == nil
13288 } else if this == nil {
13289 return false
13290 }
13291 if !this.Left.Equal(&that1.Left) {
13292 return false
13293 }
13294 if !this.Right.Equal(&that1.Right) {
13295 return false
13296 }
13297 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13298 return false
13299 }
13300 return true
13301 }
13302 func (this *AndBranch) VerboseEqual(that interface{}) error {
13303 if that == nil {
13304 if this == nil {
13305 return nil
13306 }
13307 return fmt.Errorf("that == nil && this != nil")
13308 }
13309
13310 that1, ok := that.(*AndBranch)
13311 if !ok {
13312 that2, ok := that.(AndBranch)
13313 if ok {
13314 that1 = &that2
13315 } else {
13316 return fmt.Errorf("that is not of type *AndBranch")
13317 }
13318 }
13319 if that1 == nil {
13320 if this == nil {
13321 return nil
13322 }
13323 return fmt.Errorf("that is type *AndBranch but is nil && this != nil")
13324 } else if this == nil {
13325 return fmt.Errorf("that is type *AndBranch but is not nil && this == nil")
13326 }
13327 if !this.Left.Equal(&that1.Left) {
13328 return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left)
13329 }
13330 if !this.Right.Equal(&that1.Right) {
13331 return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right)
13332 }
13333 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13334 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13335 }
13336 return nil
13337 }
13338 func (this *AndBranch) Equal(that interface{}) bool {
13339 if that == nil {
13340 return this == nil
13341 }
13342
13343 that1, ok := that.(*AndBranch)
13344 if !ok {
13345 that2, ok := that.(AndBranch)
13346 if ok {
13347 that1 = &that2
13348 } else {
13349 return false
13350 }
13351 }
13352 if that1 == nil {
13353 return this == nil
13354 } else if this == nil {
13355 return false
13356 }
13357 if !this.Left.Equal(&that1.Left) {
13358 return false
13359 }
13360 if !this.Right.Equal(&that1.Right) {
13361 return false
13362 }
13363 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13364 return false
13365 }
13366 return true
13367 }
13368 func (this *Leaf) VerboseEqual(that interface{}) error {
13369 if that == nil {
13370 if this == nil {
13371 return nil
13372 }
13373 return fmt.Errorf("that == nil && this != nil")
13374 }
13375
13376 that1, ok := that.(*Leaf)
13377 if !ok {
13378 that2, ok := that.(Leaf)
13379 if ok {
13380 that1 = &that2
13381 } else {
13382 return fmt.Errorf("that is not of type *Leaf")
13383 }
13384 }
13385 if that1 == nil {
13386 if this == nil {
13387 return nil
13388 }
13389 return fmt.Errorf("that is type *Leaf but is nil && this != nil")
13390 } else if this == nil {
13391 return fmt.Errorf("that is type *Leaf but is not nil && this == nil")
13392 }
13393 if this.Value != that1.Value {
13394 return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value)
13395 }
13396 if this.StrValue != that1.StrValue {
13397 return fmt.Errorf("StrValue this(%v) Not Equal that(%v)", this.StrValue, that1.StrValue)
13398 }
13399 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13400 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13401 }
13402 return nil
13403 }
13404 func (this *Leaf) Equal(that interface{}) bool {
13405 if that == nil {
13406 return this == nil
13407 }
13408
13409 that1, ok := that.(*Leaf)
13410 if !ok {
13411 that2, ok := that.(Leaf)
13412 if ok {
13413 that1 = &that2
13414 } else {
13415 return false
13416 }
13417 }
13418 if that1 == nil {
13419 return this == nil
13420 } else if this == nil {
13421 return false
13422 }
13423 if this.Value != that1.Value {
13424 return false
13425 }
13426 if this.StrValue != that1.StrValue {
13427 return false
13428 }
13429 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13430 return false
13431 }
13432 return true
13433 }
13434 func (this *DeepTree) VerboseEqual(that interface{}) error {
13435 if that == nil {
13436 if this == nil {
13437 return nil
13438 }
13439 return fmt.Errorf("that == nil && this != nil")
13440 }
13441
13442 that1, ok := that.(*DeepTree)
13443 if !ok {
13444 that2, ok := that.(DeepTree)
13445 if ok {
13446 that1 = &that2
13447 } else {
13448 return fmt.Errorf("that is not of type *DeepTree")
13449 }
13450 }
13451 if that1 == nil {
13452 if this == nil {
13453 return nil
13454 }
13455 return fmt.Errorf("that is type *DeepTree but is nil && this != nil")
13456 } else if this == nil {
13457 return fmt.Errorf("that is type *DeepTree but is not nil && this == nil")
13458 }
13459 if !this.Down.Equal(that1.Down) {
13460 return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down)
13461 }
13462 if !this.And.Equal(that1.And) {
13463 return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And)
13464 }
13465 if !this.Leaf.Equal(that1.Leaf) {
13466 return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf)
13467 }
13468 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13469 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13470 }
13471 return nil
13472 }
13473 func (this *DeepTree) Equal(that interface{}) bool {
13474 if that == nil {
13475 return this == nil
13476 }
13477
13478 that1, ok := that.(*DeepTree)
13479 if !ok {
13480 that2, ok := that.(DeepTree)
13481 if ok {
13482 that1 = &that2
13483 } else {
13484 return false
13485 }
13486 }
13487 if that1 == nil {
13488 return this == nil
13489 } else if this == nil {
13490 return false
13491 }
13492 if !this.Down.Equal(that1.Down) {
13493 return false
13494 }
13495 if !this.And.Equal(that1.And) {
13496 return false
13497 }
13498 if !this.Leaf.Equal(that1.Leaf) {
13499 return false
13500 }
13501 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13502 return false
13503 }
13504 return true
13505 }
13506 func (this *ADeepBranch) VerboseEqual(that interface{}) error {
13507 if that == nil {
13508 if this == nil {
13509 return nil
13510 }
13511 return fmt.Errorf("that == nil && this != nil")
13512 }
13513
13514 that1, ok := that.(*ADeepBranch)
13515 if !ok {
13516 that2, ok := that.(ADeepBranch)
13517 if ok {
13518 that1 = &that2
13519 } else {
13520 return fmt.Errorf("that is not of type *ADeepBranch")
13521 }
13522 }
13523 if that1 == nil {
13524 if this == nil {
13525 return nil
13526 }
13527 return fmt.Errorf("that is type *ADeepBranch but is nil && this != nil")
13528 } else if this == nil {
13529 return fmt.Errorf("that is type *ADeepBranch but is not nil && this == nil")
13530 }
13531 if !this.Down.Equal(&that1.Down) {
13532 return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down)
13533 }
13534 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13535 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13536 }
13537 return nil
13538 }
13539 func (this *ADeepBranch) Equal(that interface{}) bool {
13540 if that == nil {
13541 return this == nil
13542 }
13543
13544 that1, ok := that.(*ADeepBranch)
13545 if !ok {
13546 that2, ok := that.(ADeepBranch)
13547 if ok {
13548 that1 = &that2
13549 } else {
13550 return false
13551 }
13552 }
13553 if that1 == nil {
13554 return this == nil
13555 } else if this == nil {
13556 return false
13557 }
13558 if !this.Down.Equal(&that1.Down) {
13559 return false
13560 }
13561 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13562 return false
13563 }
13564 return true
13565 }
13566 func (this *AndDeepBranch) VerboseEqual(that interface{}) error {
13567 if that == nil {
13568 if this == nil {
13569 return nil
13570 }
13571 return fmt.Errorf("that == nil && this != nil")
13572 }
13573
13574 that1, ok := that.(*AndDeepBranch)
13575 if !ok {
13576 that2, ok := that.(AndDeepBranch)
13577 if ok {
13578 that1 = &that2
13579 } else {
13580 return fmt.Errorf("that is not of type *AndDeepBranch")
13581 }
13582 }
13583 if that1 == nil {
13584 if this == nil {
13585 return nil
13586 }
13587 return fmt.Errorf("that is type *AndDeepBranch but is nil && this != nil")
13588 } else if this == nil {
13589 return fmt.Errorf("that is type *AndDeepBranch but is not nil && this == nil")
13590 }
13591 if !this.Left.Equal(&that1.Left) {
13592 return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left)
13593 }
13594 if !this.Right.Equal(&that1.Right) {
13595 return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right)
13596 }
13597 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13598 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13599 }
13600 return nil
13601 }
13602 func (this *AndDeepBranch) Equal(that interface{}) bool {
13603 if that == nil {
13604 return this == nil
13605 }
13606
13607 that1, ok := that.(*AndDeepBranch)
13608 if !ok {
13609 that2, ok := that.(AndDeepBranch)
13610 if ok {
13611 that1 = &that2
13612 } else {
13613 return false
13614 }
13615 }
13616 if that1 == nil {
13617 return this == nil
13618 } else if this == nil {
13619 return false
13620 }
13621 if !this.Left.Equal(&that1.Left) {
13622 return false
13623 }
13624 if !this.Right.Equal(&that1.Right) {
13625 return false
13626 }
13627 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13628 return false
13629 }
13630 return true
13631 }
13632 func (this *DeepLeaf) VerboseEqual(that interface{}) error {
13633 if that == nil {
13634 if this == nil {
13635 return nil
13636 }
13637 return fmt.Errorf("that == nil && this != nil")
13638 }
13639
13640 that1, ok := that.(*DeepLeaf)
13641 if !ok {
13642 that2, ok := that.(DeepLeaf)
13643 if ok {
13644 that1 = &that2
13645 } else {
13646 return fmt.Errorf("that is not of type *DeepLeaf")
13647 }
13648 }
13649 if that1 == nil {
13650 if this == nil {
13651 return nil
13652 }
13653 return fmt.Errorf("that is type *DeepLeaf but is nil && this != nil")
13654 } else if this == nil {
13655 return fmt.Errorf("that is type *DeepLeaf but is not nil && this == nil")
13656 }
13657 if !this.Tree.Equal(&that1.Tree) {
13658 return fmt.Errorf("Tree this(%v) Not Equal that(%v)", this.Tree, that1.Tree)
13659 }
13660 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13661 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13662 }
13663 return nil
13664 }
13665 func (this *DeepLeaf) Equal(that interface{}) bool {
13666 if that == nil {
13667 return this == nil
13668 }
13669
13670 that1, ok := that.(*DeepLeaf)
13671 if !ok {
13672 that2, ok := that.(DeepLeaf)
13673 if ok {
13674 that1 = &that2
13675 } else {
13676 return false
13677 }
13678 }
13679 if that1 == nil {
13680 return this == nil
13681 } else if this == nil {
13682 return false
13683 }
13684 if !this.Tree.Equal(&that1.Tree) {
13685 return false
13686 }
13687 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13688 return false
13689 }
13690 return true
13691 }
13692 func (this *Nil) VerboseEqual(that interface{}) error {
13693 if that == nil {
13694 if this == nil {
13695 return nil
13696 }
13697 return fmt.Errorf("that == nil && this != nil")
13698 }
13699
13700 that1, ok := that.(*Nil)
13701 if !ok {
13702 that2, ok := that.(Nil)
13703 if ok {
13704 that1 = &that2
13705 } else {
13706 return fmt.Errorf("that is not of type *Nil")
13707 }
13708 }
13709 if that1 == nil {
13710 if this == nil {
13711 return nil
13712 }
13713 return fmt.Errorf("that is type *Nil but is nil && this != nil")
13714 } else if this == nil {
13715 return fmt.Errorf("that is type *Nil but is not nil && this == nil")
13716 }
13717 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13718 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13719 }
13720 return nil
13721 }
13722 func (this *Nil) Equal(that interface{}) bool {
13723 if that == nil {
13724 return this == nil
13725 }
13726
13727 that1, ok := that.(*Nil)
13728 if !ok {
13729 that2, ok := that.(Nil)
13730 if ok {
13731 that1 = &that2
13732 } else {
13733 return false
13734 }
13735 }
13736 if that1 == nil {
13737 return this == nil
13738 } else if this == nil {
13739 return false
13740 }
13741 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13742 return false
13743 }
13744 return true
13745 }
13746 func (this *NidOptEnum) VerboseEqual(that interface{}) error {
13747 if that == nil {
13748 if this == nil {
13749 return nil
13750 }
13751 return fmt.Errorf("that == nil && this != nil")
13752 }
13753
13754 that1, ok := that.(*NidOptEnum)
13755 if !ok {
13756 that2, ok := that.(NidOptEnum)
13757 if ok {
13758 that1 = &that2
13759 } else {
13760 return fmt.Errorf("that is not of type *NidOptEnum")
13761 }
13762 }
13763 if that1 == nil {
13764 if this == nil {
13765 return nil
13766 }
13767 return fmt.Errorf("that is type *NidOptEnum but is nil && this != nil")
13768 } else if this == nil {
13769 return fmt.Errorf("that is type *NidOptEnum but is not nil && this == nil")
13770 }
13771 if this.Field1 != that1.Field1 {
13772 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
13773 }
13774 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13775 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13776 }
13777 return nil
13778 }
13779 func (this *NidOptEnum) Equal(that interface{}) bool {
13780 if that == nil {
13781 return this == nil
13782 }
13783
13784 that1, ok := that.(*NidOptEnum)
13785 if !ok {
13786 that2, ok := that.(NidOptEnum)
13787 if ok {
13788 that1 = &that2
13789 } else {
13790 return false
13791 }
13792 }
13793 if that1 == nil {
13794 return this == nil
13795 } else if this == nil {
13796 return false
13797 }
13798 if this.Field1 != that1.Field1 {
13799 return false
13800 }
13801 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13802 return false
13803 }
13804 return true
13805 }
13806 func (this *NinOptEnum) VerboseEqual(that interface{}) error {
13807 if that == nil {
13808 if this == nil {
13809 return nil
13810 }
13811 return fmt.Errorf("that == nil && this != nil")
13812 }
13813
13814 that1, ok := that.(*NinOptEnum)
13815 if !ok {
13816 that2, ok := that.(NinOptEnum)
13817 if ok {
13818 that1 = &that2
13819 } else {
13820 return fmt.Errorf("that is not of type *NinOptEnum")
13821 }
13822 }
13823 if that1 == nil {
13824 if this == nil {
13825 return nil
13826 }
13827 return fmt.Errorf("that is type *NinOptEnum but is nil && this != nil")
13828 } else if this == nil {
13829 return fmt.Errorf("that is type *NinOptEnum but is not nil && this == nil")
13830 }
13831 if this.Field1 != nil && that1.Field1 != nil {
13832 if *this.Field1 != *that1.Field1 {
13833 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
13834 }
13835 } else if this.Field1 != nil {
13836 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
13837 } else if that1.Field1 != nil {
13838 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
13839 }
13840 if this.Field2 != nil && that1.Field2 != nil {
13841 if *this.Field2 != *that1.Field2 {
13842 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
13843 }
13844 } else if this.Field2 != nil {
13845 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
13846 } else if that1.Field2 != nil {
13847 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
13848 }
13849 if this.Field3 != nil && that1.Field3 != nil {
13850 if *this.Field3 != *that1.Field3 {
13851 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
13852 }
13853 } else if this.Field3 != nil {
13854 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
13855 } else if that1.Field3 != nil {
13856 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
13857 }
13858 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13859 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13860 }
13861 return nil
13862 }
13863 func (this *NinOptEnum) Equal(that interface{}) bool {
13864 if that == nil {
13865 return this == nil
13866 }
13867
13868 that1, ok := that.(*NinOptEnum)
13869 if !ok {
13870 that2, ok := that.(NinOptEnum)
13871 if ok {
13872 that1 = &that2
13873 } else {
13874 return false
13875 }
13876 }
13877 if that1 == nil {
13878 return this == nil
13879 } else if this == nil {
13880 return false
13881 }
13882 if this.Field1 != nil && that1.Field1 != nil {
13883 if *this.Field1 != *that1.Field1 {
13884 return false
13885 }
13886 } else if this.Field1 != nil {
13887 return false
13888 } else if that1.Field1 != nil {
13889 return false
13890 }
13891 if this.Field2 != nil && that1.Field2 != nil {
13892 if *this.Field2 != *that1.Field2 {
13893 return false
13894 }
13895 } else if this.Field2 != nil {
13896 return false
13897 } else if that1.Field2 != nil {
13898 return false
13899 }
13900 if this.Field3 != nil && that1.Field3 != nil {
13901 if *this.Field3 != *that1.Field3 {
13902 return false
13903 }
13904 } else if this.Field3 != nil {
13905 return false
13906 } else if that1.Field3 != nil {
13907 return false
13908 }
13909 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13910 return false
13911 }
13912 return true
13913 }
13914 func (this *NidRepEnum) VerboseEqual(that interface{}) error {
13915 if that == nil {
13916 if this == nil {
13917 return nil
13918 }
13919 return fmt.Errorf("that == nil && this != nil")
13920 }
13921
13922 that1, ok := that.(*NidRepEnum)
13923 if !ok {
13924 that2, ok := that.(NidRepEnum)
13925 if ok {
13926 that1 = &that2
13927 } else {
13928 return fmt.Errorf("that is not of type *NidRepEnum")
13929 }
13930 }
13931 if that1 == nil {
13932 if this == nil {
13933 return nil
13934 }
13935 return fmt.Errorf("that is type *NidRepEnum but is nil && this != nil")
13936 } else if this == nil {
13937 return fmt.Errorf("that is type *NidRepEnum but is not nil && this == nil")
13938 }
13939 if len(this.Field1) != len(that1.Field1) {
13940 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1))
13941 }
13942 for i := range this.Field1 {
13943 if this.Field1[i] != that1.Field1[i] {
13944 return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i])
13945 }
13946 }
13947 if len(this.Field2) != len(that1.Field2) {
13948 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
13949 }
13950 for i := range this.Field2 {
13951 if this.Field2[i] != that1.Field2[i] {
13952 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
13953 }
13954 }
13955 if len(this.Field3) != len(that1.Field3) {
13956 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3))
13957 }
13958 for i := range this.Field3 {
13959 if this.Field3[i] != that1.Field3[i] {
13960 return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i])
13961 }
13962 }
13963 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
13964 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
13965 }
13966 return nil
13967 }
13968 func (this *NidRepEnum) Equal(that interface{}) bool {
13969 if that == nil {
13970 return this == nil
13971 }
13972
13973 that1, ok := that.(*NidRepEnum)
13974 if !ok {
13975 that2, ok := that.(NidRepEnum)
13976 if ok {
13977 that1 = &that2
13978 } else {
13979 return false
13980 }
13981 }
13982 if that1 == nil {
13983 return this == nil
13984 } else if this == nil {
13985 return false
13986 }
13987 if len(this.Field1) != len(that1.Field1) {
13988 return false
13989 }
13990 for i := range this.Field1 {
13991 if this.Field1[i] != that1.Field1[i] {
13992 return false
13993 }
13994 }
13995 if len(this.Field2) != len(that1.Field2) {
13996 return false
13997 }
13998 for i := range this.Field2 {
13999 if this.Field2[i] != that1.Field2[i] {
14000 return false
14001 }
14002 }
14003 if len(this.Field3) != len(that1.Field3) {
14004 return false
14005 }
14006 for i := range this.Field3 {
14007 if this.Field3[i] != that1.Field3[i] {
14008 return false
14009 }
14010 }
14011 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14012 return false
14013 }
14014 return true
14015 }
14016 func (this *NinRepEnum) VerboseEqual(that interface{}) error {
14017 if that == nil {
14018 if this == nil {
14019 return nil
14020 }
14021 return fmt.Errorf("that == nil && this != nil")
14022 }
14023
14024 that1, ok := that.(*NinRepEnum)
14025 if !ok {
14026 that2, ok := that.(NinRepEnum)
14027 if ok {
14028 that1 = &that2
14029 } else {
14030 return fmt.Errorf("that is not of type *NinRepEnum")
14031 }
14032 }
14033 if that1 == nil {
14034 if this == nil {
14035 return nil
14036 }
14037 return fmt.Errorf("that is type *NinRepEnum but is nil && this != nil")
14038 } else if this == nil {
14039 return fmt.Errorf("that is type *NinRepEnum but is not nil && this == nil")
14040 }
14041 if len(this.Field1) != len(that1.Field1) {
14042 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1))
14043 }
14044 for i := range this.Field1 {
14045 if this.Field1[i] != that1.Field1[i] {
14046 return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i])
14047 }
14048 }
14049 if len(this.Field2) != len(that1.Field2) {
14050 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2))
14051 }
14052 for i := range this.Field2 {
14053 if this.Field2[i] != that1.Field2[i] {
14054 return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i])
14055 }
14056 }
14057 if len(this.Field3) != len(that1.Field3) {
14058 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3))
14059 }
14060 for i := range this.Field3 {
14061 if this.Field3[i] != that1.Field3[i] {
14062 return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i])
14063 }
14064 }
14065 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14066 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
14067 }
14068 return nil
14069 }
14070 func (this *NinRepEnum) Equal(that interface{}) bool {
14071 if that == nil {
14072 return this == nil
14073 }
14074
14075 that1, ok := that.(*NinRepEnum)
14076 if !ok {
14077 that2, ok := that.(NinRepEnum)
14078 if ok {
14079 that1 = &that2
14080 } else {
14081 return false
14082 }
14083 }
14084 if that1 == nil {
14085 return this == nil
14086 } else if this == nil {
14087 return false
14088 }
14089 if len(this.Field1) != len(that1.Field1) {
14090 return false
14091 }
14092 for i := range this.Field1 {
14093 if this.Field1[i] != that1.Field1[i] {
14094 return false
14095 }
14096 }
14097 if len(this.Field2) != len(that1.Field2) {
14098 return false
14099 }
14100 for i := range this.Field2 {
14101 if this.Field2[i] != that1.Field2[i] {
14102 return false
14103 }
14104 }
14105 if len(this.Field3) != len(that1.Field3) {
14106 return false
14107 }
14108 for i := range this.Field3 {
14109 if this.Field3[i] != that1.Field3[i] {
14110 return false
14111 }
14112 }
14113 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14114 return false
14115 }
14116 return true
14117 }
14118 func (this *NinOptEnumDefault) VerboseEqual(that interface{}) error {
14119 if that == nil {
14120 if this == nil {
14121 return nil
14122 }
14123 return fmt.Errorf("that == nil && this != nil")
14124 }
14125
14126 that1, ok := that.(*NinOptEnumDefault)
14127 if !ok {
14128 that2, ok := that.(NinOptEnumDefault)
14129 if ok {
14130 that1 = &that2
14131 } else {
14132 return fmt.Errorf("that is not of type *NinOptEnumDefault")
14133 }
14134 }
14135 if that1 == nil {
14136 if this == nil {
14137 return nil
14138 }
14139 return fmt.Errorf("that is type *NinOptEnumDefault but is nil && this != nil")
14140 } else if this == nil {
14141 return fmt.Errorf("that is type *NinOptEnumDefault but is not nil && this == nil")
14142 }
14143 if this.Field1 != nil && that1.Field1 != nil {
14144 if *this.Field1 != *that1.Field1 {
14145 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
14146 }
14147 } else if this.Field1 != nil {
14148 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
14149 } else if that1.Field1 != nil {
14150 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
14151 }
14152 if this.Field2 != nil && that1.Field2 != nil {
14153 if *this.Field2 != *that1.Field2 {
14154 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
14155 }
14156 } else if this.Field2 != nil {
14157 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
14158 } else if that1.Field2 != nil {
14159 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
14160 }
14161 if this.Field3 != nil && that1.Field3 != nil {
14162 if *this.Field3 != *that1.Field3 {
14163 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
14164 }
14165 } else if this.Field3 != nil {
14166 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
14167 } else if that1.Field3 != nil {
14168 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
14169 }
14170 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14171 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
14172 }
14173 return nil
14174 }
14175 func (this *NinOptEnumDefault) Equal(that interface{}) bool {
14176 if that == nil {
14177 return this == nil
14178 }
14179
14180 that1, ok := that.(*NinOptEnumDefault)
14181 if !ok {
14182 that2, ok := that.(NinOptEnumDefault)
14183 if ok {
14184 that1 = &that2
14185 } else {
14186 return false
14187 }
14188 }
14189 if that1 == nil {
14190 return this == nil
14191 } else if this == nil {
14192 return false
14193 }
14194 if this.Field1 != nil && that1.Field1 != nil {
14195 if *this.Field1 != *that1.Field1 {
14196 return false
14197 }
14198 } else if this.Field1 != nil {
14199 return false
14200 } else if that1.Field1 != nil {
14201 return false
14202 }
14203 if this.Field2 != nil && that1.Field2 != nil {
14204 if *this.Field2 != *that1.Field2 {
14205 return false
14206 }
14207 } else if this.Field2 != nil {
14208 return false
14209 } else if that1.Field2 != nil {
14210 return false
14211 }
14212 if this.Field3 != nil && that1.Field3 != nil {
14213 if *this.Field3 != *that1.Field3 {
14214 return false
14215 }
14216 } else if this.Field3 != nil {
14217 return false
14218 } else if that1.Field3 != nil {
14219 return false
14220 }
14221 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14222 return false
14223 }
14224 return true
14225 }
14226 func (this *AnotherNinOptEnum) VerboseEqual(that interface{}) error {
14227 if that == nil {
14228 if this == nil {
14229 return nil
14230 }
14231 return fmt.Errorf("that == nil && this != nil")
14232 }
14233
14234 that1, ok := that.(*AnotherNinOptEnum)
14235 if !ok {
14236 that2, ok := that.(AnotherNinOptEnum)
14237 if ok {
14238 that1 = &that2
14239 } else {
14240 return fmt.Errorf("that is not of type *AnotherNinOptEnum")
14241 }
14242 }
14243 if that1 == nil {
14244 if this == nil {
14245 return nil
14246 }
14247 return fmt.Errorf("that is type *AnotherNinOptEnum but is nil && this != nil")
14248 } else if this == nil {
14249 return fmt.Errorf("that is type *AnotherNinOptEnum but is not nil && this == nil")
14250 }
14251 if this.Field1 != nil && that1.Field1 != nil {
14252 if *this.Field1 != *that1.Field1 {
14253 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
14254 }
14255 } else if this.Field1 != nil {
14256 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
14257 } else if that1.Field1 != nil {
14258 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
14259 }
14260 if this.Field2 != nil && that1.Field2 != nil {
14261 if *this.Field2 != *that1.Field2 {
14262 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
14263 }
14264 } else if this.Field2 != nil {
14265 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
14266 } else if that1.Field2 != nil {
14267 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
14268 }
14269 if this.Field3 != nil && that1.Field3 != nil {
14270 if *this.Field3 != *that1.Field3 {
14271 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
14272 }
14273 } else if this.Field3 != nil {
14274 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
14275 } else if that1.Field3 != nil {
14276 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
14277 }
14278 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14279 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
14280 }
14281 return nil
14282 }
14283 func (this *AnotherNinOptEnum) Equal(that interface{}) bool {
14284 if that == nil {
14285 return this == nil
14286 }
14287
14288 that1, ok := that.(*AnotherNinOptEnum)
14289 if !ok {
14290 that2, ok := that.(AnotherNinOptEnum)
14291 if ok {
14292 that1 = &that2
14293 } else {
14294 return false
14295 }
14296 }
14297 if that1 == nil {
14298 return this == nil
14299 } else if this == nil {
14300 return false
14301 }
14302 if this.Field1 != nil && that1.Field1 != nil {
14303 if *this.Field1 != *that1.Field1 {
14304 return false
14305 }
14306 } else if this.Field1 != nil {
14307 return false
14308 } else if that1.Field1 != nil {
14309 return false
14310 }
14311 if this.Field2 != nil && that1.Field2 != nil {
14312 if *this.Field2 != *that1.Field2 {
14313 return false
14314 }
14315 } else if this.Field2 != nil {
14316 return false
14317 } else if that1.Field2 != nil {
14318 return false
14319 }
14320 if this.Field3 != nil && that1.Field3 != nil {
14321 if *this.Field3 != *that1.Field3 {
14322 return false
14323 }
14324 } else if this.Field3 != nil {
14325 return false
14326 } else if that1.Field3 != nil {
14327 return false
14328 }
14329 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14330 return false
14331 }
14332 return true
14333 }
14334 func (this *AnotherNinOptEnumDefault) VerboseEqual(that interface{}) error {
14335 if that == nil {
14336 if this == nil {
14337 return nil
14338 }
14339 return fmt.Errorf("that == nil && this != nil")
14340 }
14341
14342 that1, ok := that.(*AnotherNinOptEnumDefault)
14343 if !ok {
14344 that2, ok := that.(AnotherNinOptEnumDefault)
14345 if ok {
14346 that1 = &that2
14347 } else {
14348 return fmt.Errorf("that is not of type *AnotherNinOptEnumDefault")
14349 }
14350 }
14351 if that1 == nil {
14352 if this == nil {
14353 return nil
14354 }
14355 return fmt.Errorf("that is type *AnotherNinOptEnumDefault but is nil && this != nil")
14356 } else if this == nil {
14357 return fmt.Errorf("that is type *AnotherNinOptEnumDefault but is not nil && this == nil")
14358 }
14359 if this.Field1 != nil && that1.Field1 != nil {
14360 if *this.Field1 != *that1.Field1 {
14361 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
14362 }
14363 } else if this.Field1 != nil {
14364 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
14365 } else if that1.Field1 != nil {
14366 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
14367 }
14368 if this.Field2 != nil && that1.Field2 != nil {
14369 if *this.Field2 != *that1.Field2 {
14370 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
14371 }
14372 } else if this.Field2 != nil {
14373 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
14374 } else if that1.Field2 != nil {
14375 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
14376 }
14377 if this.Field3 != nil && that1.Field3 != nil {
14378 if *this.Field3 != *that1.Field3 {
14379 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
14380 }
14381 } else if this.Field3 != nil {
14382 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
14383 } else if that1.Field3 != nil {
14384 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
14385 }
14386 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14387 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
14388 }
14389 return nil
14390 }
14391 func (this *AnotherNinOptEnumDefault) Equal(that interface{}) bool {
14392 if that == nil {
14393 return this == nil
14394 }
14395
14396 that1, ok := that.(*AnotherNinOptEnumDefault)
14397 if !ok {
14398 that2, ok := that.(AnotherNinOptEnumDefault)
14399 if ok {
14400 that1 = &that2
14401 } else {
14402 return false
14403 }
14404 }
14405 if that1 == nil {
14406 return this == nil
14407 } else if this == nil {
14408 return false
14409 }
14410 if this.Field1 != nil && that1.Field1 != nil {
14411 if *this.Field1 != *that1.Field1 {
14412 return false
14413 }
14414 } else if this.Field1 != nil {
14415 return false
14416 } else if that1.Field1 != nil {
14417 return false
14418 }
14419 if this.Field2 != nil && that1.Field2 != nil {
14420 if *this.Field2 != *that1.Field2 {
14421 return false
14422 }
14423 } else if this.Field2 != nil {
14424 return false
14425 } else if that1.Field2 != nil {
14426 return false
14427 }
14428 if this.Field3 != nil && that1.Field3 != nil {
14429 if *this.Field3 != *that1.Field3 {
14430 return false
14431 }
14432 } else if this.Field3 != nil {
14433 return false
14434 } else if that1.Field3 != nil {
14435 return false
14436 }
14437 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14438 return false
14439 }
14440 return true
14441 }
14442 func (this *Timer) VerboseEqual(that interface{}) error {
14443 if that == nil {
14444 if this == nil {
14445 return nil
14446 }
14447 return fmt.Errorf("that == nil && this != nil")
14448 }
14449
14450 that1, ok := that.(*Timer)
14451 if !ok {
14452 that2, ok := that.(Timer)
14453 if ok {
14454 that1 = &that2
14455 } else {
14456 return fmt.Errorf("that is not of type *Timer")
14457 }
14458 }
14459 if that1 == nil {
14460 if this == nil {
14461 return nil
14462 }
14463 return fmt.Errorf("that is type *Timer but is nil && this != nil")
14464 } else if this == nil {
14465 return fmt.Errorf("that is type *Timer but is not nil && this == nil")
14466 }
14467 if this.Time1 != that1.Time1 {
14468 return fmt.Errorf("Time1 this(%v) Not Equal that(%v)", this.Time1, that1.Time1)
14469 }
14470 if this.Time2 != that1.Time2 {
14471 return fmt.Errorf("Time2 this(%v) Not Equal that(%v)", this.Time2, that1.Time2)
14472 }
14473 if !bytes.Equal(this.Data, that1.Data) {
14474 return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
14475 }
14476 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14477 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
14478 }
14479 return nil
14480 }
14481 func (this *Timer) Equal(that interface{}) bool {
14482 if that == nil {
14483 return this == nil
14484 }
14485
14486 that1, ok := that.(*Timer)
14487 if !ok {
14488 that2, ok := that.(Timer)
14489 if ok {
14490 that1 = &that2
14491 } else {
14492 return false
14493 }
14494 }
14495 if that1 == nil {
14496 return this == nil
14497 } else if this == nil {
14498 return false
14499 }
14500 if this.Time1 != that1.Time1 {
14501 return false
14502 }
14503 if this.Time2 != that1.Time2 {
14504 return false
14505 }
14506 if !bytes.Equal(this.Data, that1.Data) {
14507 return false
14508 }
14509 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14510 return false
14511 }
14512 return true
14513 }
14514 func (this *MyExtendable) VerboseEqual(that interface{}) error {
14515 if that == nil {
14516 if this == nil {
14517 return nil
14518 }
14519 return fmt.Errorf("that == nil && this != nil")
14520 }
14521
14522 that1, ok := that.(*MyExtendable)
14523 if !ok {
14524 that2, ok := that.(MyExtendable)
14525 if ok {
14526 that1 = &that2
14527 } else {
14528 return fmt.Errorf("that is not of type *MyExtendable")
14529 }
14530 }
14531 if that1 == nil {
14532 if this == nil {
14533 return nil
14534 }
14535 return fmt.Errorf("that is type *MyExtendable but is nil && this != nil")
14536 } else if this == nil {
14537 return fmt.Errorf("that is type *MyExtendable but is not nil && this == nil")
14538 }
14539 if this.Field1 != nil && that1.Field1 != nil {
14540 if *this.Field1 != *that1.Field1 {
14541 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
14542 }
14543 } else if this.Field1 != nil {
14544 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
14545 } else if that1.Field1 != nil {
14546 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
14547 }
14548 thismap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(this)
14549 thatmap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(that1)
14550 for k, v := range thismap {
14551 if v2, ok := thatmap[k]; ok {
14552 if !v.Equal(&v2) {
14553 return fmt.Errorf("XXX_InternalExtensions this[%v](%v) Not Equal that[%v](%v)", k, thismap[k], k, thatmap[k])
14554 }
14555 } else {
14556 return fmt.Errorf("XXX_InternalExtensions[%v] Not In that", k)
14557 }
14558 }
14559 for k := range thatmap {
14560 if _, ok := thismap[k]; !ok {
14561 return fmt.Errorf("XXX_InternalExtensions[%v] Not In this", k)
14562 }
14563 }
14564 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14565 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
14566 }
14567 return nil
14568 }
14569 func (this *MyExtendable) Equal(that interface{}) bool {
14570 if that == nil {
14571 return this == nil
14572 }
14573
14574 that1, ok := that.(*MyExtendable)
14575 if !ok {
14576 that2, ok := that.(MyExtendable)
14577 if ok {
14578 that1 = &that2
14579 } else {
14580 return false
14581 }
14582 }
14583 if that1 == nil {
14584 return this == nil
14585 } else if this == nil {
14586 return false
14587 }
14588 if this.Field1 != nil && that1.Field1 != nil {
14589 if *this.Field1 != *that1.Field1 {
14590 return false
14591 }
14592 } else if this.Field1 != nil {
14593 return false
14594 } else if that1.Field1 != nil {
14595 return false
14596 }
14597 thismap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(this)
14598 thatmap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(that1)
14599 for k, v := range thismap {
14600 if v2, ok := thatmap[k]; ok {
14601 if !v.Equal(&v2) {
14602 return false
14603 }
14604 } else {
14605 return false
14606 }
14607 }
14608 for k := range thatmap {
14609 if _, ok := thismap[k]; !ok {
14610 return false
14611 }
14612 }
14613 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14614 return false
14615 }
14616 return true
14617 }
14618 func (this *OtherExtenable) VerboseEqual(that interface{}) error {
14619 if that == nil {
14620 if this == nil {
14621 return nil
14622 }
14623 return fmt.Errorf("that == nil && this != nil")
14624 }
14625
14626 that1, ok := that.(*OtherExtenable)
14627 if !ok {
14628 that2, ok := that.(OtherExtenable)
14629 if ok {
14630 that1 = &that2
14631 } else {
14632 return fmt.Errorf("that is not of type *OtherExtenable")
14633 }
14634 }
14635 if that1 == nil {
14636 if this == nil {
14637 return nil
14638 }
14639 return fmt.Errorf("that is type *OtherExtenable but is nil && this != nil")
14640 } else if this == nil {
14641 return fmt.Errorf("that is type *OtherExtenable but is not nil && this == nil")
14642 }
14643 if this.Field2 != nil && that1.Field2 != nil {
14644 if *this.Field2 != *that1.Field2 {
14645 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
14646 }
14647 } else if this.Field2 != nil {
14648 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
14649 } else if that1.Field2 != nil {
14650 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
14651 }
14652 if this.Field13 != nil && that1.Field13 != nil {
14653 if *this.Field13 != *that1.Field13 {
14654 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13)
14655 }
14656 } else if this.Field13 != nil {
14657 return fmt.Errorf("this.Field13 == nil && that.Field13 != nil")
14658 } else if that1.Field13 != nil {
14659 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13)
14660 }
14661 if !this.M.Equal(that1.M) {
14662 return fmt.Errorf("M this(%v) Not Equal that(%v)", this.M, that1.M)
14663 }
14664 thismap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(this)
14665 thatmap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(that1)
14666 for k, v := range thismap {
14667 if v2, ok := thatmap[k]; ok {
14668 if !v.Equal(&v2) {
14669 return fmt.Errorf("XXX_InternalExtensions this[%v](%v) Not Equal that[%v](%v)", k, thismap[k], k, thatmap[k])
14670 }
14671 } else {
14672 return fmt.Errorf("XXX_InternalExtensions[%v] Not In that", k)
14673 }
14674 }
14675 for k := range thatmap {
14676 if _, ok := thismap[k]; !ok {
14677 return fmt.Errorf("XXX_InternalExtensions[%v] Not In this", k)
14678 }
14679 }
14680 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14681 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
14682 }
14683 return nil
14684 }
14685 func (this *OtherExtenable) Equal(that interface{}) bool {
14686 if that == nil {
14687 return this == nil
14688 }
14689
14690 that1, ok := that.(*OtherExtenable)
14691 if !ok {
14692 that2, ok := that.(OtherExtenable)
14693 if ok {
14694 that1 = &that2
14695 } else {
14696 return false
14697 }
14698 }
14699 if that1 == nil {
14700 return this == nil
14701 } else if this == nil {
14702 return false
14703 }
14704 if this.Field2 != nil && that1.Field2 != nil {
14705 if *this.Field2 != *that1.Field2 {
14706 return false
14707 }
14708 } else if this.Field2 != nil {
14709 return false
14710 } else if that1.Field2 != nil {
14711 return false
14712 }
14713 if this.Field13 != nil && that1.Field13 != nil {
14714 if *this.Field13 != *that1.Field13 {
14715 return false
14716 }
14717 } else if this.Field13 != nil {
14718 return false
14719 } else if that1.Field13 != nil {
14720 return false
14721 }
14722 if !this.M.Equal(that1.M) {
14723 return false
14724 }
14725 thismap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(this)
14726 thatmap := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(that1)
14727 for k, v := range thismap {
14728 if v2, ok := thatmap[k]; ok {
14729 if !v.Equal(&v2) {
14730 return false
14731 }
14732 } else {
14733 return false
14734 }
14735 }
14736 for k := range thatmap {
14737 if _, ok := thismap[k]; !ok {
14738 return false
14739 }
14740 }
14741 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14742 return false
14743 }
14744 return true
14745 }
14746 func (this *NestedDefinition) VerboseEqual(that interface{}) error {
14747 if that == nil {
14748 if this == nil {
14749 return nil
14750 }
14751 return fmt.Errorf("that == nil && this != nil")
14752 }
14753
14754 that1, ok := that.(*NestedDefinition)
14755 if !ok {
14756 that2, ok := that.(NestedDefinition)
14757 if ok {
14758 that1 = &that2
14759 } else {
14760 return fmt.Errorf("that is not of type *NestedDefinition")
14761 }
14762 }
14763 if that1 == nil {
14764 if this == nil {
14765 return nil
14766 }
14767 return fmt.Errorf("that is type *NestedDefinition but is nil && this != nil")
14768 } else if this == nil {
14769 return fmt.Errorf("that is type *NestedDefinition but is not nil && this == nil")
14770 }
14771 if this.Field1 != nil && that1.Field1 != nil {
14772 if *this.Field1 != *that1.Field1 {
14773 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
14774 }
14775 } else if this.Field1 != nil {
14776 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
14777 } else if that1.Field1 != nil {
14778 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
14779 }
14780 if this.EnumField != nil && that1.EnumField != nil {
14781 if *this.EnumField != *that1.EnumField {
14782 return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", *this.EnumField, *that1.EnumField)
14783 }
14784 } else if this.EnumField != nil {
14785 return fmt.Errorf("this.EnumField == nil && that.EnumField != nil")
14786 } else if that1.EnumField != nil {
14787 return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", this.EnumField, that1.EnumField)
14788 }
14789 if !this.NNM.Equal(that1.NNM) {
14790 return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM)
14791 }
14792 if !this.NM.Equal(that1.NM) {
14793 return fmt.Errorf("NM this(%v) Not Equal that(%v)", this.NM, that1.NM)
14794 }
14795 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14796 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
14797 }
14798 return nil
14799 }
14800 func (this *NestedDefinition) Equal(that interface{}) bool {
14801 if that == nil {
14802 return this == nil
14803 }
14804
14805 that1, ok := that.(*NestedDefinition)
14806 if !ok {
14807 that2, ok := that.(NestedDefinition)
14808 if ok {
14809 that1 = &that2
14810 } else {
14811 return false
14812 }
14813 }
14814 if that1 == nil {
14815 return this == nil
14816 } else if this == nil {
14817 return false
14818 }
14819 if this.Field1 != nil && that1.Field1 != nil {
14820 if *this.Field1 != *that1.Field1 {
14821 return false
14822 }
14823 } else if this.Field1 != nil {
14824 return false
14825 } else if that1.Field1 != nil {
14826 return false
14827 }
14828 if this.EnumField != nil && that1.EnumField != nil {
14829 if *this.EnumField != *that1.EnumField {
14830 return false
14831 }
14832 } else if this.EnumField != nil {
14833 return false
14834 } else if that1.EnumField != nil {
14835 return false
14836 }
14837 if !this.NNM.Equal(that1.NNM) {
14838 return false
14839 }
14840 if !this.NM.Equal(that1.NM) {
14841 return false
14842 }
14843 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14844 return false
14845 }
14846 return true
14847 }
14848 func (this *NestedDefinition_NestedMessage) VerboseEqual(that interface{}) error {
14849 if that == nil {
14850 if this == nil {
14851 return nil
14852 }
14853 return fmt.Errorf("that == nil && this != nil")
14854 }
14855
14856 that1, ok := that.(*NestedDefinition_NestedMessage)
14857 if !ok {
14858 that2, ok := that.(NestedDefinition_NestedMessage)
14859 if ok {
14860 that1 = &that2
14861 } else {
14862 return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage")
14863 }
14864 }
14865 if that1 == nil {
14866 if this == nil {
14867 return nil
14868 }
14869 return fmt.Errorf("that is type *NestedDefinition_NestedMessage but is nil && this != nil")
14870 } else if this == nil {
14871 return fmt.Errorf("that is type *NestedDefinition_NestedMessage but is not nil && this == nil")
14872 }
14873 if this.NestedField1 != nil && that1.NestedField1 != nil {
14874 if *this.NestedField1 != *that1.NestedField1 {
14875 return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", *this.NestedField1, *that1.NestedField1)
14876 }
14877 } else if this.NestedField1 != nil {
14878 return fmt.Errorf("this.NestedField1 == nil && that.NestedField1 != nil")
14879 } else if that1.NestedField1 != nil {
14880 return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", this.NestedField1, that1.NestedField1)
14881 }
14882 if !this.NNM.Equal(that1.NNM) {
14883 return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM)
14884 }
14885 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14886 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
14887 }
14888 return nil
14889 }
14890 func (this *NestedDefinition_NestedMessage) Equal(that interface{}) bool {
14891 if that == nil {
14892 return this == nil
14893 }
14894
14895 that1, ok := that.(*NestedDefinition_NestedMessage)
14896 if !ok {
14897 that2, ok := that.(NestedDefinition_NestedMessage)
14898 if ok {
14899 that1 = &that2
14900 } else {
14901 return false
14902 }
14903 }
14904 if that1 == nil {
14905 return this == nil
14906 } else if this == nil {
14907 return false
14908 }
14909 if this.NestedField1 != nil && that1.NestedField1 != nil {
14910 if *this.NestedField1 != *that1.NestedField1 {
14911 return false
14912 }
14913 } else if this.NestedField1 != nil {
14914 return false
14915 } else if that1.NestedField1 != nil {
14916 return false
14917 }
14918 if !this.NNM.Equal(that1.NNM) {
14919 return false
14920 }
14921 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14922 return false
14923 }
14924 return true
14925 }
14926 func (this *NestedDefinition_NestedMessage_NestedNestedMsg) VerboseEqual(that interface{}) error {
14927 if that == nil {
14928 if this == nil {
14929 return nil
14930 }
14931 return fmt.Errorf("that == nil && this != nil")
14932 }
14933
14934 that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg)
14935 if !ok {
14936 that2, ok := that.(NestedDefinition_NestedMessage_NestedNestedMsg)
14937 if ok {
14938 that1 = &that2
14939 } else {
14940 return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage_NestedNestedMsg")
14941 }
14942 }
14943 if that1 == nil {
14944 if this == nil {
14945 return nil
14946 }
14947 return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsg but is nil && this != nil")
14948 } else if this == nil {
14949 return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsg but is not nil && this == nil")
14950 }
14951 if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil {
14952 if *this.NestedNestedField1 != *that1.NestedNestedField1 {
14953 return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", *this.NestedNestedField1, *that1.NestedNestedField1)
14954 }
14955 } else if this.NestedNestedField1 != nil {
14956 return fmt.Errorf("this.NestedNestedField1 == nil && that.NestedNestedField1 != nil")
14957 } else if that1.NestedNestedField1 != nil {
14958 return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", this.NestedNestedField1, that1.NestedNestedField1)
14959 }
14960 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14961 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
14962 }
14963 return nil
14964 }
14965 func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Equal(that interface{}) bool {
14966 if that == nil {
14967 return this == nil
14968 }
14969
14970 that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg)
14971 if !ok {
14972 that2, ok := that.(NestedDefinition_NestedMessage_NestedNestedMsg)
14973 if ok {
14974 that1 = &that2
14975 } else {
14976 return false
14977 }
14978 }
14979 if that1 == nil {
14980 return this == nil
14981 } else if this == nil {
14982 return false
14983 }
14984 if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil {
14985 if *this.NestedNestedField1 != *that1.NestedNestedField1 {
14986 return false
14987 }
14988 } else if this.NestedNestedField1 != nil {
14989 return false
14990 } else if that1.NestedNestedField1 != nil {
14991 return false
14992 }
14993 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
14994 return false
14995 }
14996 return true
14997 }
14998 func (this *NestedScope) VerboseEqual(that interface{}) error {
14999 if that == nil {
15000 if this == nil {
15001 return nil
15002 }
15003 return fmt.Errorf("that == nil && this != nil")
15004 }
15005
15006 that1, ok := that.(*NestedScope)
15007 if !ok {
15008 that2, ok := that.(NestedScope)
15009 if ok {
15010 that1 = &that2
15011 } else {
15012 return fmt.Errorf("that is not of type *NestedScope")
15013 }
15014 }
15015 if that1 == nil {
15016 if this == nil {
15017 return nil
15018 }
15019 return fmt.Errorf("that is type *NestedScope but is nil && this != nil")
15020 } else if this == nil {
15021 return fmt.Errorf("that is type *NestedScope but is not nil && this == nil")
15022 }
15023 if !this.A.Equal(that1.A) {
15024 return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A)
15025 }
15026 if this.B != nil && that1.B != nil {
15027 if *this.B != *that1.B {
15028 return fmt.Errorf("B this(%v) Not Equal that(%v)", *this.B, *that1.B)
15029 }
15030 } else if this.B != nil {
15031 return fmt.Errorf("this.B == nil && that.B != nil")
15032 } else if that1.B != nil {
15033 return fmt.Errorf("B this(%v) Not Equal that(%v)", this.B, that1.B)
15034 }
15035 if !this.C.Equal(that1.C) {
15036 return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C)
15037 }
15038 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
15039 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
15040 }
15041 return nil
15042 }
15043 func (this *NestedScope) Equal(that interface{}) bool {
15044 if that == nil {
15045 return this == nil
15046 }
15047
15048 that1, ok := that.(*NestedScope)
15049 if !ok {
15050 that2, ok := that.(NestedScope)
15051 if ok {
15052 that1 = &that2
15053 } else {
15054 return false
15055 }
15056 }
15057 if that1 == nil {
15058 return this == nil
15059 } else if this == nil {
15060 return false
15061 }
15062 if !this.A.Equal(that1.A) {
15063 return false
15064 }
15065 if this.B != nil && that1.B != nil {
15066 if *this.B != *that1.B {
15067 return false
15068 }
15069 } else if this.B != nil {
15070 return false
15071 } else if that1.B != nil {
15072 return false
15073 }
15074 if !this.C.Equal(that1.C) {
15075 return false
15076 }
15077 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
15078 return false
15079 }
15080 return true
15081 }
15082 func (this *NinOptNativeDefault) VerboseEqual(that interface{}) error {
15083 if that == nil {
15084 if this == nil {
15085 return nil
15086 }
15087 return fmt.Errorf("that == nil && this != nil")
15088 }
15089
15090 that1, ok := that.(*NinOptNativeDefault)
15091 if !ok {
15092 that2, ok := that.(NinOptNativeDefault)
15093 if ok {
15094 that1 = &that2
15095 } else {
15096 return fmt.Errorf("that is not of type *NinOptNativeDefault")
15097 }
15098 }
15099 if that1 == nil {
15100 if this == nil {
15101 return nil
15102 }
15103 return fmt.Errorf("that is type *NinOptNativeDefault but is nil && this != nil")
15104 } else if this == nil {
15105 return fmt.Errorf("that is type *NinOptNativeDefault but is not nil && this == nil")
15106 }
15107 if this.Field1 != nil && that1.Field1 != nil {
15108 if *this.Field1 != *that1.Field1 {
15109 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
15110 }
15111 } else if this.Field1 != nil {
15112 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
15113 } else if that1.Field1 != nil {
15114 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
15115 }
15116 if this.Field2 != nil && that1.Field2 != nil {
15117 if *this.Field2 != *that1.Field2 {
15118 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
15119 }
15120 } else if this.Field2 != nil {
15121 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
15122 } else if that1.Field2 != nil {
15123 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
15124 }
15125 if this.Field3 != nil && that1.Field3 != nil {
15126 if *this.Field3 != *that1.Field3 {
15127 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3)
15128 }
15129 } else if this.Field3 != nil {
15130 return fmt.Errorf("this.Field3 == nil && that.Field3 != nil")
15131 } else if that1.Field3 != nil {
15132 return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3)
15133 }
15134 if this.Field4 != nil && that1.Field4 != nil {
15135 if *this.Field4 != *that1.Field4 {
15136 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4)
15137 }
15138 } else if this.Field4 != nil {
15139 return fmt.Errorf("this.Field4 == nil && that.Field4 != nil")
15140 } else if that1.Field4 != nil {
15141 return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4)
15142 }
15143 if this.Field5 != nil && that1.Field5 != nil {
15144 if *this.Field5 != *that1.Field5 {
15145 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5)
15146 }
15147 } else if this.Field5 != nil {
15148 return fmt.Errorf("this.Field5 == nil && that.Field5 != nil")
15149 } else if that1.Field5 != nil {
15150 return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5)
15151 }
15152 if this.Field6 != nil && that1.Field6 != nil {
15153 if *this.Field6 != *that1.Field6 {
15154 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6)
15155 }
15156 } else if this.Field6 != nil {
15157 return fmt.Errorf("this.Field6 == nil && that.Field6 != nil")
15158 } else if that1.Field6 != nil {
15159 return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6)
15160 }
15161 if this.Field7 != nil && that1.Field7 != nil {
15162 if *this.Field7 != *that1.Field7 {
15163 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7)
15164 }
15165 } else if this.Field7 != nil {
15166 return fmt.Errorf("this.Field7 == nil && that.Field7 != nil")
15167 } else if that1.Field7 != nil {
15168 return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7)
15169 }
15170 if this.Field8 != nil && that1.Field8 != nil {
15171 if *this.Field8 != *that1.Field8 {
15172 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8)
15173 }
15174 } else if this.Field8 != nil {
15175 return fmt.Errorf("this.Field8 == nil && that.Field8 != nil")
15176 } else if that1.Field8 != nil {
15177 return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8)
15178 }
15179 if this.Field9 != nil && that1.Field9 != nil {
15180 if *this.Field9 != *that1.Field9 {
15181 return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9)
15182 }
15183 } else if this.Field9 != nil {
15184 return fmt.Errorf("this.Field9 == nil && that.Field9 != nil")
15185 } else if that1.Field9 != nil {
15186 return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9)
15187 }
15188 if this.Field10 != nil && that1.Field10 != nil {
15189 if *this.Field10 != *that1.Field10 {
15190 return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10)
15191 }
15192 } else if this.Field10 != nil {
15193 return fmt.Errorf("this.Field10 == nil && that.Field10 != nil")
15194 } else if that1.Field10 != nil {
15195 return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10)
15196 }
15197 if this.Field11 != nil && that1.Field11 != nil {
15198 if *this.Field11 != *that1.Field11 {
15199 return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11)
15200 }
15201 } else if this.Field11 != nil {
15202 return fmt.Errorf("this.Field11 == nil && that.Field11 != nil")
15203 } else if that1.Field11 != nil {
15204 return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11)
15205 }
15206 if this.Field12 != nil && that1.Field12 != nil {
15207 if *this.Field12 != *that1.Field12 {
15208 return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12)
15209 }
15210 } else if this.Field12 != nil {
15211 return fmt.Errorf("this.Field12 == nil && that.Field12 != nil")
15212 } else if that1.Field12 != nil {
15213 return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12)
15214 }
15215 if this.Field13 != nil && that1.Field13 != nil {
15216 if *this.Field13 != *that1.Field13 {
15217 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13)
15218 }
15219 } else if this.Field13 != nil {
15220 return fmt.Errorf("this.Field13 == nil && that.Field13 != nil")
15221 } else if that1.Field13 != nil {
15222 return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13)
15223 }
15224 if this.Field14 != nil && that1.Field14 != nil {
15225 if *this.Field14 != *that1.Field14 {
15226 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14)
15227 }
15228 } else if this.Field14 != nil {
15229 return fmt.Errorf("this.Field14 == nil && that.Field14 != nil")
15230 } else if that1.Field14 != nil {
15231 return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14)
15232 }
15233 if !bytes.Equal(this.Field15, that1.Field15) {
15234 return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15)
15235 }
15236 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
15237 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
15238 }
15239 return nil
15240 }
15241 func (this *NinOptNativeDefault) Equal(that interface{}) bool {
15242 if that == nil {
15243 return this == nil
15244 }
15245
15246 that1, ok := that.(*NinOptNativeDefault)
15247 if !ok {
15248 that2, ok := that.(NinOptNativeDefault)
15249 if ok {
15250 that1 = &that2
15251 } else {
15252 return false
15253 }
15254 }
15255 if that1 == nil {
15256 return this == nil
15257 } else if this == nil {
15258 return false
15259 }
15260 if this.Field1 != nil && that1.Field1 != nil {
15261 if *this.Field1 != *that1.Field1 {
15262 return false
15263 }
15264 } else if this.Field1 != nil {
15265 return false
15266 } else if that1.Field1 != nil {
15267 return false
15268 }
15269 if this.Field2 != nil && that1.Field2 != nil {
15270 if *this.Field2 != *that1.Field2 {
15271 return false
15272 }
15273 } else if this.Field2 != nil {
15274 return false
15275 } else if that1.Field2 != nil {
15276 return false
15277 }
15278 if this.Field3 != nil && that1.Field3 != nil {
15279 if *this.Field3 != *that1.Field3 {
15280 return false
15281 }
15282 } else if this.Field3 != nil {
15283 return false
15284 } else if that1.Field3 != nil {
15285 return false
15286 }
15287 if this.Field4 != nil && that1.Field4 != nil {
15288 if *this.Field4 != *that1.Field4 {
15289 return false
15290 }
15291 } else if this.Field4 != nil {
15292 return false
15293 } else if that1.Field4 != nil {
15294 return false
15295 }
15296 if this.Field5 != nil && that1.Field5 != nil {
15297 if *this.Field5 != *that1.Field5 {
15298 return false
15299 }
15300 } else if this.Field5 != nil {
15301 return false
15302 } else if that1.Field5 != nil {
15303 return false
15304 }
15305 if this.Field6 != nil && that1.Field6 != nil {
15306 if *this.Field6 != *that1.Field6 {
15307 return false
15308 }
15309 } else if this.Field6 != nil {
15310 return false
15311 } else if that1.Field6 != nil {
15312 return false
15313 }
15314 if this.Field7 != nil && that1.Field7 != nil {
15315 if *this.Field7 != *that1.Field7 {
15316 return false
15317 }
15318 } else if this.Field7 != nil {
15319 return false
15320 } else if that1.Field7 != nil {
15321 return false
15322 }
15323 if this.Field8 != nil && that1.Field8 != nil {
15324 if *this.Field8 != *that1.Field8 {
15325 return false
15326 }
15327 } else if this.Field8 != nil {
15328 return false
15329 } else if that1.Field8 != nil {
15330 return false
15331 }
15332 if this.Field9 != nil && that1.Field9 != nil {
15333 if *this.Field9 != *that1.Field9 {
15334 return false
15335 }
15336 } else if this.Field9 != nil {
15337 return false
15338 } else if that1.Field9 != nil {
15339 return false
15340 }
15341 if this.Field10 != nil && that1.Field10 != nil {
15342 if *this.Field10 != *that1.Field10 {
15343 return false
15344 }
15345 } else if this.Field10 != nil {
15346 return false
15347 } else if that1.Field10 != nil {
15348 return false
15349 }
15350 if this.Field11 != nil && that1.Field11 != nil {
15351 if *this.Field11 != *that1.Field11 {
15352 return false
15353 }
15354 } else if this.Field11 != nil {
15355 return false
15356 } else if that1.Field11 != nil {
15357 return false
15358 }
15359 if this.Field12 != nil && that1.Field12 != nil {
15360 if *this.Field12 != *that1.Field12 {
15361 return false
15362 }
15363 } else if this.Field12 != nil {
15364 return false
15365 } else if that1.Field12 != nil {
15366 return false
15367 }
15368 if this.Field13 != nil && that1.Field13 != nil {
15369 if *this.Field13 != *that1.Field13 {
15370 return false
15371 }
15372 } else if this.Field13 != nil {
15373 return false
15374 } else if that1.Field13 != nil {
15375 return false
15376 }
15377 if this.Field14 != nil && that1.Field14 != nil {
15378 if *this.Field14 != *that1.Field14 {
15379 return false
15380 }
15381 } else if this.Field14 != nil {
15382 return false
15383 } else if that1.Field14 != nil {
15384 return false
15385 }
15386 if !bytes.Equal(this.Field15, that1.Field15) {
15387 return false
15388 }
15389 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
15390 return false
15391 }
15392 return true
15393 }
15394 func (this *CustomContainer) VerboseEqual(that interface{}) error {
15395 if that == nil {
15396 if this == nil {
15397 return nil
15398 }
15399 return fmt.Errorf("that == nil && this != nil")
15400 }
15401
15402 that1, ok := that.(*CustomContainer)
15403 if !ok {
15404 that2, ok := that.(CustomContainer)
15405 if ok {
15406 that1 = &that2
15407 } else {
15408 return fmt.Errorf("that is not of type *CustomContainer")
15409 }
15410 }
15411 if that1 == nil {
15412 if this == nil {
15413 return nil
15414 }
15415 return fmt.Errorf("that is type *CustomContainer but is nil && this != nil")
15416 } else if this == nil {
15417 return fmt.Errorf("that is type *CustomContainer but is not nil && this == nil")
15418 }
15419 if !this.CustomStruct.Equal(&that1.CustomStruct) {
15420 return fmt.Errorf("CustomStruct this(%v) Not Equal that(%v)", this.CustomStruct, that1.CustomStruct)
15421 }
15422 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
15423 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
15424 }
15425 return nil
15426 }
15427 func (this *CustomContainer) Equal(that interface{}) bool {
15428 if that == nil {
15429 return this == nil
15430 }
15431
15432 that1, ok := that.(*CustomContainer)
15433 if !ok {
15434 that2, ok := that.(CustomContainer)
15435 if ok {
15436 that1 = &that2
15437 } else {
15438 return false
15439 }
15440 }
15441 if that1 == nil {
15442 return this == nil
15443 } else if this == nil {
15444 return false
15445 }
15446 if !this.CustomStruct.Equal(&that1.CustomStruct) {
15447 return false
15448 }
15449 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
15450 return false
15451 }
15452 return true
15453 }
15454 func (this *CustomNameNidOptNative) VerboseEqual(that interface{}) error {
15455 if that == nil {
15456 if this == nil {
15457 return nil
15458 }
15459 return fmt.Errorf("that == nil && this != nil")
15460 }
15461
15462 that1, ok := that.(*CustomNameNidOptNative)
15463 if !ok {
15464 that2, ok := that.(CustomNameNidOptNative)
15465 if ok {
15466 that1 = &that2
15467 } else {
15468 return fmt.Errorf("that is not of type *CustomNameNidOptNative")
15469 }
15470 }
15471 if that1 == nil {
15472 if this == nil {
15473 return nil
15474 }
15475 return fmt.Errorf("that is type *CustomNameNidOptNative but is nil && this != nil")
15476 } else if this == nil {
15477 return fmt.Errorf("that is type *CustomNameNidOptNative but is not nil && this == nil")
15478 }
15479 if this.FieldA != that1.FieldA {
15480 return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA)
15481 }
15482 if this.FieldB != that1.FieldB {
15483 return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB)
15484 }
15485 if this.FieldC != that1.FieldC {
15486 return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC)
15487 }
15488 if this.FieldD != that1.FieldD {
15489 return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD)
15490 }
15491 if this.FieldE != that1.FieldE {
15492 return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE)
15493 }
15494 if this.FieldF != that1.FieldF {
15495 return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF)
15496 }
15497 if this.FieldG != that1.FieldG {
15498 return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG)
15499 }
15500 if this.FieldH != that1.FieldH {
15501 return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH)
15502 }
15503 if this.FieldI != that1.FieldI {
15504 return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI)
15505 }
15506 if this.FieldJ != that1.FieldJ {
15507 return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ)
15508 }
15509 if this.FieldK != that1.FieldK {
15510 return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK)
15511 }
15512 if this.FieldL != that1.FieldL {
15513 return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", this.FieldL, that1.FieldL)
15514 }
15515 if this.FieldM != that1.FieldM {
15516 return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM)
15517 }
15518 if this.FieldN != that1.FieldN {
15519 return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN)
15520 }
15521 if !bytes.Equal(this.FieldO, that1.FieldO) {
15522 return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO)
15523 }
15524 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
15525 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
15526 }
15527 return nil
15528 }
15529 func (this *CustomNameNidOptNative) Equal(that interface{}) bool {
15530 if that == nil {
15531 return this == nil
15532 }
15533
15534 that1, ok := that.(*CustomNameNidOptNative)
15535 if !ok {
15536 that2, ok := that.(CustomNameNidOptNative)
15537 if ok {
15538 that1 = &that2
15539 } else {
15540 return false
15541 }
15542 }
15543 if that1 == nil {
15544 return this == nil
15545 } else if this == nil {
15546 return false
15547 }
15548 if this.FieldA != that1.FieldA {
15549 return false
15550 }
15551 if this.FieldB != that1.FieldB {
15552 return false
15553 }
15554 if this.FieldC != that1.FieldC {
15555 return false
15556 }
15557 if this.FieldD != that1.FieldD {
15558 return false
15559 }
15560 if this.FieldE != that1.FieldE {
15561 return false
15562 }
15563 if this.FieldF != that1.FieldF {
15564 return false
15565 }
15566 if this.FieldG != that1.FieldG {
15567 return false
15568 }
15569 if this.FieldH != that1.FieldH {
15570 return false
15571 }
15572 if this.FieldI != that1.FieldI {
15573 return false
15574 }
15575 if this.FieldJ != that1.FieldJ {
15576 return false
15577 }
15578 if this.FieldK != that1.FieldK {
15579 return false
15580 }
15581 if this.FieldL != that1.FieldL {
15582 return false
15583 }
15584 if this.FieldM != that1.FieldM {
15585 return false
15586 }
15587 if this.FieldN != that1.FieldN {
15588 return false
15589 }
15590 if !bytes.Equal(this.FieldO, that1.FieldO) {
15591 return false
15592 }
15593 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
15594 return false
15595 }
15596 return true
15597 }
15598 func (this *CustomNameNinOptNative) VerboseEqual(that interface{}) error {
15599 if that == nil {
15600 if this == nil {
15601 return nil
15602 }
15603 return fmt.Errorf("that == nil && this != nil")
15604 }
15605
15606 that1, ok := that.(*CustomNameNinOptNative)
15607 if !ok {
15608 that2, ok := that.(CustomNameNinOptNative)
15609 if ok {
15610 that1 = &that2
15611 } else {
15612 return fmt.Errorf("that is not of type *CustomNameNinOptNative")
15613 }
15614 }
15615 if that1 == nil {
15616 if this == nil {
15617 return nil
15618 }
15619 return fmt.Errorf("that is type *CustomNameNinOptNative but is nil && this != nil")
15620 } else if this == nil {
15621 return fmt.Errorf("that is type *CustomNameNinOptNative but is not nil && this == nil")
15622 }
15623 if this.FieldA != nil && that1.FieldA != nil {
15624 if *this.FieldA != *that1.FieldA {
15625 return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA)
15626 }
15627 } else if this.FieldA != nil {
15628 return fmt.Errorf("this.FieldA == nil && that.FieldA != nil")
15629 } else if that1.FieldA != nil {
15630 return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA)
15631 }
15632 if this.FieldB != nil && that1.FieldB != nil {
15633 if *this.FieldB != *that1.FieldB {
15634 return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB)
15635 }
15636 } else if this.FieldB != nil {
15637 return fmt.Errorf("this.FieldB == nil && that.FieldB != nil")
15638 } else if that1.FieldB != nil {
15639 return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB)
15640 }
15641 if this.FieldC != nil && that1.FieldC != nil {
15642 if *this.FieldC != *that1.FieldC {
15643 return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", *this.FieldC, *that1.FieldC)
15644 }
15645 } else if this.FieldC != nil {
15646 return fmt.Errorf("this.FieldC == nil && that.FieldC != nil")
15647 } else if that1.FieldC != nil {
15648 return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC)
15649 }
15650 if this.FieldD != nil && that1.FieldD != nil {
15651 if *this.FieldD != *that1.FieldD {
15652 return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", *this.FieldD, *that1.FieldD)
15653 }
15654 } else if this.FieldD != nil {
15655 return fmt.Errorf("this.FieldD == nil && that.FieldD != nil")
15656 } else if that1.FieldD != nil {
15657 return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD)
15658 }
15659 if this.FieldE != nil && that1.FieldE != nil {
15660 if *this.FieldE != *that1.FieldE {
15661 return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE)
15662 }
15663 } else if this.FieldE != nil {
15664 return fmt.Errorf("this.FieldE == nil && that.FieldE != nil")
15665 } else if that1.FieldE != nil {
15666 return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE)
15667 }
15668 if this.FieldF != nil && that1.FieldF != nil {
15669 if *this.FieldF != *that1.FieldF {
15670 return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF)
15671 }
15672 } else if this.FieldF != nil {
15673 return fmt.Errorf("this.FieldF == nil && that.FieldF != nil")
15674 } else if that1.FieldF != nil {
15675 return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF)
15676 }
15677 if this.FieldG != nil && that1.FieldG != nil {
15678 if *this.FieldG != *that1.FieldG {
15679 return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", *this.FieldG, *that1.FieldG)
15680 }
15681 } else if this.FieldG != nil {
15682 return fmt.Errorf("this.FieldG == nil && that.FieldG != nil")
15683 } else if that1.FieldG != nil {
15684 return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG)
15685 }
15686 if this.FieldH != nil && that1.FieldH != nil {
15687 if *this.FieldH != *that1.FieldH {
15688 return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH)
15689 }
15690 } else if this.FieldH != nil {
15691 return fmt.Errorf("this.FieldH == nil && that.FieldH != nil")
15692 } else if that1.FieldH != nil {
15693 return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH)
15694 }
15695 if this.FieldI != nil && that1.FieldI != nil {
15696 if *this.FieldI != *that1.FieldI {
15697 return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI)
15698 }
15699 } else if this.FieldI != nil {
15700 return fmt.Errorf("this.FieldI == nil && that.FieldI != nil")
15701 } else if that1.FieldI != nil {
15702 return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI)
15703 }
15704 if this.FieldJ != nil && that1.FieldJ != nil {
15705 if *this.FieldJ != *that1.FieldJ {
15706 return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", *this.FieldJ, *that1.FieldJ)
15707 }
15708 } else if this.FieldJ != nil {
15709 return fmt.Errorf("this.FieldJ == nil && that.FieldJ != nil")
15710 } else if that1.FieldJ != nil {
15711 return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ)
15712 }
15713 if this.FieldK != nil && that1.FieldK != nil {
15714 if *this.FieldK != *that1.FieldK {
15715 return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", *this.FieldK, *that1.FieldK)
15716 }
15717 } else if this.FieldK != nil {
15718 return fmt.Errorf("this.FieldK == nil && that.FieldK != nil")
15719 } else if that1.FieldK != nil {
15720 return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK)
15721 }
15722 if this.FielL != nil && that1.FielL != nil {
15723 if *this.FielL != *that1.FielL {
15724 return fmt.Errorf("FielL this(%v) Not Equal that(%v)", *this.FielL, *that1.FielL)
15725 }
15726 } else if this.FielL != nil {
15727 return fmt.Errorf("this.FielL == nil && that.FielL != nil")
15728 } else if that1.FielL != nil {
15729 return fmt.Errorf("FielL this(%v) Not Equal that(%v)", this.FielL, that1.FielL)
15730 }
15731 if this.FieldM != nil && that1.FieldM != nil {
15732 if *this.FieldM != *that1.FieldM {
15733 return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", *this.FieldM, *that1.FieldM)
15734 }
15735 } else if this.FieldM != nil {
15736 return fmt.Errorf("this.FieldM == nil && that.FieldM != nil")
15737 } else if that1.FieldM != nil {
15738 return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM)
15739 }
15740 if this.FieldN != nil && that1.FieldN != nil {
15741 if *this.FieldN != *that1.FieldN {
15742 return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", *this.FieldN, *that1.FieldN)
15743 }
15744 } else if this.FieldN != nil {
15745 return fmt.Errorf("this.FieldN == nil && that.FieldN != nil")
15746 } else if that1.FieldN != nil {
15747 return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN)
15748 }
15749 if !bytes.Equal(this.FieldO, that1.FieldO) {
15750 return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO)
15751 }
15752 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
15753 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
15754 }
15755 return nil
15756 }
15757 func (this *CustomNameNinOptNative) Equal(that interface{}) bool {
15758 if that == nil {
15759 return this == nil
15760 }
15761
15762 that1, ok := that.(*CustomNameNinOptNative)
15763 if !ok {
15764 that2, ok := that.(CustomNameNinOptNative)
15765 if ok {
15766 that1 = &that2
15767 } else {
15768 return false
15769 }
15770 }
15771 if that1 == nil {
15772 return this == nil
15773 } else if this == nil {
15774 return false
15775 }
15776 if this.FieldA != nil && that1.FieldA != nil {
15777 if *this.FieldA != *that1.FieldA {
15778 return false
15779 }
15780 } else if this.FieldA != nil {
15781 return false
15782 } else if that1.FieldA != nil {
15783 return false
15784 }
15785 if this.FieldB != nil && that1.FieldB != nil {
15786 if *this.FieldB != *that1.FieldB {
15787 return false
15788 }
15789 } else if this.FieldB != nil {
15790 return false
15791 } else if that1.FieldB != nil {
15792 return false
15793 }
15794 if this.FieldC != nil && that1.FieldC != nil {
15795 if *this.FieldC != *that1.FieldC {
15796 return false
15797 }
15798 } else if this.FieldC != nil {
15799 return false
15800 } else if that1.FieldC != nil {
15801 return false
15802 }
15803 if this.FieldD != nil && that1.FieldD != nil {
15804 if *this.FieldD != *that1.FieldD {
15805 return false
15806 }
15807 } else if this.FieldD != nil {
15808 return false
15809 } else if that1.FieldD != nil {
15810 return false
15811 }
15812 if this.FieldE != nil && that1.FieldE != nil {
15813 if *this.FieldE != *that1.FieldE {
15814 return false
15815 }
15816 } else if this.FieldE != nil {
15817 return false
15818 } else if that1.FieldE != nil {
15819 return false
15820 }
15821 if this.FieldF != nil && that1.FieldF != nil {
15822 if *this.FieldF != *that1.FieldF {
15823 return false
15824 }
15825 } else if this.FieldF != nil {
15826 return false
15827 } else if that1.FieldF != nil {
15828 return false
15829 }
15830 if this.FieldG != nil && that1.FieldG != nil {
15831 if *this.FieldG != *that1.FieldG {
15832 return false
15833 }
15834 } else if this.FieldG != nil {
15835 return false
15836 } else if that1.FieldG != nil {
15837 return false
15838 }
15839 if this.FieldH != nil && that1.FieldH != nil {
15840 if *this.FieldH != *that1.FieldH {
15841 return false
15842 }
15843 } else if this.FieldH != nil {
15844 return false
15845 } else if that1.FieldH != nil {
15846 return false
15847 }
15848 if this.FieldI != nil && that1.FieldI != nil {
15849 if *this.FieldI != *that1.FieldI {
15850 return false
15851 }
15852 } else if this.FieldI != nil {
15853 return false
15854 } else if that1.FieldI != nil {
15855 return false
15856 }
15857 if this.FieldJ != nil && that1.FieldJ != nil {
15858 if *this.FieldJ != *that1.FieldJ {
15859 return false
15860 }
15861 } else if this.FieldJ != nil {
15862 return false
15863 } else if that1.FieldJ != nil {
15864 return false
15865 }
15866 if this.FieldK != nil && that1.FieldK != nil {
15867 if *this.FieldK != *that1.FieldK {
15868 return false
15869 }
15870 } else if this.FieldK != nil {
15871 return false
15872 } else if that1.FieldK != nil {
15873 return false
15874 }
15875 if this.FielL != nil && that1.FielL != nil {
15876 if *this.FielL != *that1.FielL {
15877 return false
15878 }
15879 } else if this.FielL != nil {
15880 return false
15881 } else if that1.FielL != nil {
15882 return false
15883 }
15884 if this.FieldM != nil && that1.FieldM != nil {
15885 if *this.FieldM != *that1.FieldM {
15886 return false
15887 }
15888 } else if this.FieldM != nil {
15889 return false
15890 } else if that1.FieldM != nil {
15891 return false
15892 }
15893 if this.FieldN != nil && that1.FieldN != nil {
15894 if *this.FieldN != *that1.FieldN {
15895 return false
15896 }
15897 } else if this.FieldN != nil {
15898 return false
15899 } else if that1.FieldN != nil {
15900 return false
15901 }
15902 if !bytes.Equal(this.FieldO, that1.FieldO) {
15903 return false
15904 }
15905 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
15906 return false
15907 }
15908 return true
15909 }
15910 func (this *CustomNameNinRepNative) VerboseEqual(that interface{}) error {
15911 if that == nil {
15912 if this == nil {
15913 return nil
15914 }
15915 return fmt.Errorf("that == nil && this != nil")
15916 }
15917
15918 that1, ok := that.(*CustomNameNinRepNative)
15919 if !ok {
15920 that2, ok := that.(CustomNameNinRepNative)
15921 if ok {
15922 that1 = &that2
15923 } else {
15924 return fmt.Errorf("that is not of type *CustomNameNinRepNative")
15925 }
15926 }
15927 if that1 == nil {
15928 if this == nil {
15929 return nil
15930 }
15931 return fmt.Errorf("that is type *CustomNameNinRepNative but is nil && this != nil")
15932 } else if this == nil {
15933 return fmt.Errorf("that is type *CustomNameNinRepNative but is not nil && this == nil")
15934 }
15935 if len(this.FieldA) != len(that1.FieldA) {
15936 return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", len(this.FieldA), len(that1.FieldA))
15937 }
15938 for i := range this.FieldA {
15939 if this.FieldA[i] != that1.FieldA[i] {
15940 return fmt.Errorf("FieldA this[%v](%v) Not Equal that[%v](%v)", i, this.FieldA[i], i, that1.FieldA[i])
15941 }
15942 }
15943 if len(this.FieldB) != len(that1.FieldB) {
15944 return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB))
15945 }
15946 for i := range this.FieldB {
15947 if this.FieldB[i] != that1.FieldB[i] {
15948 return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i])
15949 }
15950 }
15951 if len(this.FieldC) != len(that1.FieldC) {
15952 return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC))
15953 }
15954 for i := range this.FieldC {
15955 if this.FieldC[i] != that1.FieldC[i] {
15956 return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i])
15957 }
15958 }
15959 if len(this.FieldD) != len(that1.FieldD) {
15960 return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD))
15961 }
15962 for i := range this.FieldD {
15963 if this.FieldD[i] != that1.FieldD[i] {
15964 return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i])
15965 }
15966 }
15967 if len(this.FieldE) != len(that1.FieldE) {
15968 return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", len(this.FieldE), len(that1.FieldE))
15969 }
15970 for i := range this.FieldE {
15971 if this.FieldE[i] != that1.FieldE[i] {
15972 return fmt.Errorf("FieldE this[%v](%v) Not Equal that[%v](%v)", i, this.FieldE[i], i, that1.FieldE[i])
15973 }
15974 }
15975 if len(this.FieldF) != len(that1.FieldF) {
15976 return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", len(this.FieldF), len(that1.FieldF))
15977 }
15978 for i := range this.FieldF {
15979 if this.FieldF[i] != that1.FieldF[i] {
15980 return fmt.Errorf("FieldF this[%v](%v) Not Equal that[%v](%v)", i, this.FieldF[i], i, that1.FieldF[i])
15981 }
15982 }
15983 if len(this.FieldG) != len(that1.FieldG) {
15984 return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", len(this.FieldG), len(that1.FieldG))
15985 }
15986 for i := range this.FieldG {
15987 if this.FieldG[i] != that1.FieldG[i] {
15988 return fmt.Errorf("FieldG this[%v](%v) Not Equal that[%v](%v)", i, this.FieldG[i], i, that1.FieldG[i])
15989 }
15990 }
15991 if len(this.FieldH) != len(that1.FieldH) {
15992 return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", len(this.FieldH), len(that1.FieldH))
15993 }
15994 for i := range this.FieldH {
15995 if this.FieldH[i] != that1.FieldH[i] {
15996 return fmt.Errorf("FieldH this[%v](%v) Not Equal that[%v](%v)", i, this.FieldH[i], i, that1.FieldH[i])
15997 }
15998 }
15999 if len(this.FieldI) != len(that1.FieldI) {
16000 return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", len(this.FieldI), len(that1.FieldI))
16001 }
16002 for i := range this.FieldI {
16003 if this.FieldI[i] != that1.FieldI[i] {
16004 return fmt.Errorf("FieldI this[%v](%v) Not Equal that[%v](%v)", i, this.FieldI[i], i, that1.FieldI[i])
16005 }
16006 }
16007 if len(this.FieldJ) != len(that1.FieldJ) {
16008 return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", len(this.FieldJ), len(that1.FieldJ))
16009 }
16010 for i := range this.FieldJ {
16011 if this.FieldJ[i] != that1.FieldJ[i] {
16012 return fmt.Errorf("FieldJ this[%v](%v) Not Equal that[%v](%v)", i, this.FieldJ[i], i, that1.FieldJ[i])
16013 }
16014 }
16015 if len(this.FieldK) != len(that1.FieldK) {
16016 return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", len(this.FieldK), len(that1.FieldK))
16017 }
16018 for i := range this.FieldK {
16019 if this.FieldK[i] != that1.FieldK[i] {
16020 return fmt.Errorf("FieldK this[%v](%v) Not Equal that[%v](%v)", i, this.FieldK[i], i, that1.FieldK[i])
16021 }
16022 }
16023 if len(this.FieldL) != len(that1.FieldL) {
16024 return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", len(this.FieldL), len(that1.FieldL))
16025 }
16026 for i := range this.FieldL {
16027 if this.FieldL[i] != that1.FieldL[i] {
16028 return fmt.Errorf("FieldL this[%v](%v) Not Equal that[%v](%v)", i, this.FieldL[i], i, that1.FieldL[i])
16029 }
16030 }
16031 if len(this.FieldM) != len(that1.FieldM) {
16032 return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", len(this.FieldM), len(that1.FieldM))
16033 }
16034 for i := range this.FieldM {
16035 if this.FieldM[i] != that1.FieldM[i] {
16036 return fmt.Errorf("FieldM this[%v](%v) Not Equal that[%v](%v)", i, this.FieldM[i], i, that1.FieldM[i])
16037 }
16038 }
16039 if len(this.FieldN) != len(that1.FieldN) {
16040 return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", len(this.FieldN), len(that1.FieldN))
16041 }
16042 for i := range this.FieldN {
16043 if this.FieldN[i] != that1.FieldN[i] {
16044 return fmt.Errorf("FieldN this[%v](%v) Not Equal that[%v](%v)", i, this.FieldN[i], i, that1.FieldN[i])
16045 }
16046 }
16047 if len(this.FieldO) != len(that1.FieldO) {
16048 return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", len(this.FieldO), len(that1.FieldO))
16049 }
16050 for i := range this.FieldO {
16051 if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) {
16052 return fmt.Errorf("FieldO this[%v](%v) Not Equal that[%v](%v)", i, this.FieldO[i], i, that1.FieldO[i])
16053 }
16054 }
16055 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16056 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
16057 }
16058 return nil
16059 }
16060 func (this *CustomNameNinRepNative) Equal(that interface{}) bool {
16061 if that == nil {
16062 return this == nil
16063 }
16064
16065 that1, ok := that.(*CustomNameNinRepNative)
16066 if !ok {
16067 that2, ok := that.(CustomNameNinRepNative)
16068 if ok {
16069 that1 = &that2
16070 } else {
16071 return false
16072 }
16073 }
16074 if that1 == nil {
16075 return this == nil
16076 } else if this == nil {
16077 return false
16078 }
16079 if len(this.FieldA) != len(that1.FieldA) {
16080 return false
16081 }
16082 for i := range this.FieldA {
16083 if this.FieldA[i] != that1.FieldA[i] {
16084 return false
16085 }
16086 }
16087 if len(this.FieldB) != len(that1.FieldB) {
16088 return false
16089 }
16090 for i := range this.FieldB {
16091 if this.FieldB[i] != that1.FieldB[i] {
16092 return false
16093 }
16094 }
16095 if len(this.FieldC) != len(that1.FieldC) {
16096 return false
16097 }
16098 for i := range this.FieldC {
16099 if this.FieldC[i] != that1.FieldC[i] {
16100 return false
16101 }
16102 }
16103 if len(this.FieldD) != len(that1.FieldD) {
16104 return false
16105 }
16106 for i := range this.FieldD {
16107 if this.FieldD[i] != that1.FieldD[i] {
16108 return false
16109 }
16110 }
16111 if len(this.FieldE) != len(that1.FieldE) {
16112 return false
16113 }
16114 for i := range this.FieldE {
16115 if this.FieldE[i] != that1.FieldE[i] {
16116 return false
16117 }
16118 }
16119 if len(this.FieldF) != len(that1.FieldF) {
16120 return false
16121 }
16122 for i := range this.FieldF {
16123 if this.FieldF[i] != that1.FieldF[i] {
16124 return false
16125 }
16126 }
16127 if len(this.FieldG) != len(that1.FieldG) {
16128 return false
16129 }
16130 for i := range this.FieldG {
16131 if this.FieldG[i] != that1.FieldG[i] {
16132 return false
16133 }
16134 }
16135 if len(this.FieldH) != len(that1.FieldH) {
16136 return false
16137 }
16138 for i := range this.FieldH {
16139 if this.FieldH[i] != that1.FieldH[i] {
16140 return false
16141 }
16142 }
16143 if len(this.FieldI) != len(that1.FieldI) {
16144 return false
16145 }
16146 for i := range this.FieldI {
16147 if this.FieldI[i] != that1.FieldI[i] {
16148 return false
16149 }
16150 }
16151 if len(this.FieldJ) != len(that1.FieldJ) {
16152 return false
16153 }
16154 for i := range this.FieldJ {
16155 if this.FieldJ[i] != that1.FieldJ[i] {
16156 return false
16157 }
16158 }
16159 if len(this.FieldK) != len(that1.FieldK) {
16160 return false
16161 }
16162 for i := range this.FieldK {
16163 if this.FieldK[i] != that1.FieldK[i] {
16164 return false
16165 }
16166 }
16167 if len(this.FieldL) != len(that1.FieldL) {
16168 return false
16169 }
16170 for i := range this.FieldL {
16171 if this.FieldL[i] != that1.FieldL[i] {
16172 return false
16173 }
16174 }
16175 if len(this.FieldM) != len(that1.FieldM) {
16176 return false
16177 }
16178 for i := range this.FieldM {
16179 if this.FieldM[i] != that1.FieldM[i] {
16180 return false
16181 }
16182 }
16183 if len(this.FieldN) != len(that1.FieldN) {
16184 return false
16185 }
16186 for i := range this.FieldN {
16187 if this.FieldN[i] != that1.FieldN[i] {
16188 return false
16189 }
16190 }
16191 if len(this.FieldO) != len(that1.FieldO) {
16192 return false
16193 }
16194 for i := range this.FieldO {
16195 if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) {
16196 return false
16197 }
16198 }
16199 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16200 return false
16201 }
16202 return true
16203 }
16204 func (this *CustomNameNinStruct) VerboseEqual(that interface{}) error {
16205 if that == nil {
16206 if this == nil {
16207 return nil
16208 }
16209 return fmt.Errorf("that == nil && this != nil")
16210 }
16211
16212 that1, ok := that.(*CustomNameNinStruct)
16213 if !ok {
16214 that2, ok := that.(CustomNameNinStruct)
16215 if ok {
16216 that1 = &that2
16217 } else {
16218 return fmt.Errorf("that is not of type *CustomNameNinStruct")
16219 }
16220 }
16221 if that1 == nil {
16222 if this == nil {
16223 return nil
16224 }
16225 return fmt.Errorf("that is type *CustomNameNinStruct but is nil && this != nil")
16226 } else if this == nil {
16227 return fmt.Errorf("that is type *CustomNameNinStruct but is not nil && this == nil")
16228 }
16229 if this.FieldA != nil && that1.FieldA != nil {
16230 if *this.FieldA != *that1.FieldA {
16231 return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA)
16232 }
16233 } else if this.FieldA != nil {
16234 return fmt.Errorf("this.FieldA == nil && that.FieldA != nil")
16235 } else if that1.FieldA != nil {
16236 return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA)
16237 }
16238 if this.FieldB != nil && that1.FieldB != nil {
16239 if *this.FieldB != *that1.FieldB {
16240 return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB)
16241 }
16242 } else if this.FieldB != nil {
16243 return fmt.Errorf("this.FieldB == nil && that.FieldB != nil")
16244 } else if that1.FieldB != nil {
16245 return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB)
16246 }
16247 if !this.FieldC.Equal(that1.FieldC) {
16248 return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC)
16249 }
16250 if len(this.FieldD) != len(that1.FieldD) {
16251 return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD))
16252 }
16253 for i := range this.FieldD {
16254 if !this.FieldD[i].Equal(that1.FieldD[i]) {
16255 return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i])
16256 }
16257 }
16258 if this.FieldE != nil && that1.FieldE != nil {
16259 if *this.FieldE != *that1.FieldE {
16260 return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE)
16261 }
16262 } else if this.FieldE != nil {
16263 return fmt.Errorf("this.FieldE == nil && that.FieldE != nil")
16264 } else if that1.FieldE != nil {
16265 return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE)
16266 }
16267 if this.FieldF != nil && that1.FieldF != nil {
16268 if *this.FieldF != *that1.FieldF {
16269 return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF)
16270 }
16271 } else if this.FieldF != nil {
16272 return fmt.Errorf("this.FieldF == nil && that.FieldF != nil")
16273 } else if that1.FieldF != nil {
16274 return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF)
16275 }
16276 if !this.FieldG.Equal(that1.FieldG) {
16277 return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG)
16278 }
16279 if this.FieldH != nil && that1.FieldH != nil {
16280 if *this.FieldH != *that1.FieldH {
16281 return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH)
16282 }
16283 } else if this.FieldH != nil {
16284 return fmt.Errorf("this.FieldH == nil && that.FieldH != nil")
16285 } else if that1.FieldH != nil {
16286 return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH)
16287 }
16288 if this.FieldI != nil && that1.FieldI != nil {
16289 if *this.FieldI != *that1.FieldI {
16290 return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI)
16291 }
16292 } else if this.FieldI != nil {
16293 return fmt.Errorf("this.FieldI == nil && that.FieldI != nil")
16294 } else if that1.FieldI != nil {
16295 return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI)
16296 }
16297 if !bytes.Equal(this.FieldJ, that1.FieldJ) {
16298 return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ)
16299 }
16300 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16301 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
16302 }
16303 return nil
16304 }
16305 func (this *CustomNameNinStruct) Equal(that interface{}) bool {
16306 if that == nil {
16307 return this == nil
16308 }
16309
16310 that1, ok := that.(*CustomNameNinStruct)
16311 if !ok {
16312 that2, ok := that.(CustomNameNinStruct)
16313 if ok {
16314 that1 = &that2
16315 } else {
16316 return false
16317 }
16318 }
16319 if that1 == nil {
16320 return this == nil
16321 } else if this == nil {
16322 return false
16323 }
16324 if this.FieldA != nil && that1.FieldA != nil {
16325 if *this.FieldA != *that1.FieldA {
16326 return false
16327 }
16328 } else if this.FieldA != nil {
16329 return false
16330 } else if that1.FieldA != nil {
16331 return false
16332 }
16333 if this.FieldB != nil && that1.FieldB != nil {
16334 if *this.FieldB != *that1.FieldB {
16335 return false
16336 }
16337 } else if this.FieldB != nil {
16338 return false
16339 } else if that1.FieldB != nil {
16340 return false
16341 }
16342 if !this.FieldC.Equal(that1.FieldC) {
16343 return false
16344 }
16345 if len(this.FieldD) != len(that1.FieldD) {
16346 return false
16347 }
16348 for i := range this.FieldD {
16349 if !this.FieldD[i].Equal(that1.FieldD[i]) {
16350 return false
16351 }
16352 }
16353 if this.FieldE != nil && that1.FieldE != nil {
16354 if *this.FieldE != *that1.FieldE {
16355 return false
16356 }
16357 } else if this.FieldE != nil {
16358 return false
16359 } else if that1.FieldE != nil {
16360 return false
16361 }
16362 if this.FieldF != nil && that1.FieldF != nil {
16363 if *this.FieldF != *that1.FieldF {
16364 return false
16365 }
16366 } else if this.FieldF != nil {
16367 return false
16368 } else if that1.FieldF != nil {
16369 return false
16370 }
16371 if !this.FieldG.Equal(that1.FieldG) {
16372 return false
16373 }
16374 if this.FieldH != nil && that1.FieldH != nil {
16375 if *this.FieldH != *that1.FieldH {
16376 return false
16377 }
16378 } else if this.FieldH != nil {
16379 return false
16380 } else if that1.FieldH != nil {
16381 return false
16382 }
16383 if this.FieldI != nil && that1.FieldI != nil {
16384 if *this.FieldI != *that1.FieldI {
16385 return false
16386 }
16387 } else if this.FieldI != nil {
16388 return false
16389 } else if that1.FieldI != nil {
16390 return false
16391 }
16392 if !bytes.Equal(this.FieldJ, that1.FieldJ) {
16393 return false
16394 }
16395 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16396 return false
16397 }
16398 return true
16399 }
16400 func (this *CustomNameCustomType) VerboseEqual(that interface{}) error {
16401 if that == nil {
16402 if this == nil {
16403 return nil
16404 }
16405 return fmt.Errorf("that == nil && this != nil")
16406 }
16407
16408 that1, ok := that.(*CustomNameCustomType)
16409 if !ok {
16410 that2, ok := that.(CustomNameCustomType)
16411 if ok {
16412 that1 = &that2
16413 } else {
16414 return fmt.Errorf("that is not of type *CustomNameCustomType")
16415 }
16416 }
16417 if that1 == nil {
16418 if this == nil {
16419 return nil
16420 }
16421 return fmt.Errorf("that is type *CustomNameCustomType but is nil && this != nil")
16422 } else if this == nil {
16423 return fmt.Errorf("that is type *CustomNameCustomType but is not nil && this == nil")
16424 }
16425 if that1.FieldA == nil {
16426 if this.FieldA != nil {
16427 return fmt.Errorf("this.FieldA != nil && that1.FieldA == nil")
16428 }
16429 } else if !this.FieldA.Equal(*that1.FieldA) {
16430 return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA)
16431 }
16432 if that1.FieldB == nil {
16433 if this.FieldB != nil {
16434 return fmt.Errorf("this.FieldB != nil && that1.FieldB == nil")
16435 }
16436 } else if !this.FieldB.Equal(*that1.FieldB) {
16437 return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB)
16438 }
16439 if len(this.FieldC) != len(that1.FieldC) {
16440 return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC))
16441 }
16442 for i := range this.FieldC {
16443 if !this.FieldC[i].Equal(that1.FieldC[i]) {
16444 return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i])
16445 }
16446 }
16447 if len(this.FieldD) != len(that1.FieldD) {
16448 return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD))
16449 }
16450 for i := range this.FieldD {
16451 if !this.FieldD[i].Equal(that1.FieldD[i]) {
16452 return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i])
16453 }
16454 }
16455 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16456 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
16457 }
16458 return nil
16459 }
16460 func (this *CustomNameCustomType) Equal(that interface{}) bool {
16461 if that == nil {
16462 return this == nil
16463 }
16464
16465 that1, ok := that.(*CustomNameCustomType)
16466 if !ok {
16467 that2, ok := that.(CustomNameCustomType)
16468 if ok {
16469 that1 = &that2
16470 } else {
16471 return false
16472 }
16473 }
16474 if that1 == nil {
16475 return this == nil
16476 } else if this == nil {
16477 return false
16478 }
16479 if that1.FieldA == nil {
16480 if this.FieldA != nil {
16481 return false
16482 }
16483 } else if !this.FieldA.Equal(*that1.FieldA) {
16484 return false
16485 }
16486 if that1.FieldB == nil {
16487 if this.FieldB != nil {
16488 return false
16489 }
16490 } else if !this.FieldB.Equal(*that1.FieldB) {
16491 return false
16492 }
16493 if len(this.FieldC) != len(that1.FieldC) {
16494 return false
16495 }
16496 for i := range this.FieldC {
16497 if !this.FieldC[i].Equal(that1.FieldC[i]) {
16498 return false
16499 }
16500 }
16501 if len(this.FieldD) != len(that1.FieldD) {
16502 return false
16503 }
16504 for i := range this.FieldD {
16505 if !this.FieldD[i].Equal(that1.FieldD[i]) {
16506 return false
16507 }
16508 }
16509 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16510 return false
16511 }
16512 return true
16513 }
16514 func (this *CustomNameNinEmbeddedStructUnion) VerboseEqual(that interface{}) error {
16515 if that == nil {
16516 if this == nil {
16517 return nil
16518 }
16519 return fmt.Errorf("that == nil && this != nil")
16520 }
16521
16522 that1, ok := that.(*CustomNameNinEmbeddedStructUnion)
16523 if !ok {
16524 that2, ok := that.(CustomNameNinEmbeddedStructUnion)
16525 if ok {
16526 that1 = &that2
16527 } else {
16528 return fmt.Errorf("that is not of type *CustomNameNinEmbeddedStructUnion")
16529 }
16530 }
16531 if that1 == nil {
16532 if this == nil {
16533 return nil
16534 }
16535 return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnion but is nil && this != nil")
16536 } else if this == nil {
16537 return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnion but is not nil && this == nil")
16538 }
16539 if !this.NidOptNative.Equal(that1.NidOptNative) {
16540 return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative)
16541 }
16542 if !this.FieldA.Equal(that1.FieldA) {
16543 return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA)
16544 }
16545 if this.FieldB != nil && that1.FieldB != nil {
16546 if *this.FieldB != *that1.FieldB {
16547 return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB)
16548 }
16549 } else if this.FieldB != nil {
16550 return fmt.Errorf("this.FieldB == nil && that.FieldB != nil")
16551 } else if that1.FieldB != nil {
16552 return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB)
16553 }
16554 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16555 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
16556 }
16557 return nil
16558 }
16559 func (this *CustomNameNinEmbeddedStructUnion) Equal(that interface{}) bool {
16560 if that == nil {
16561 return this == nil
16562 }
16563
16564 that1, ok := that.(*CustomNameNinEmbeddedStructUnion)
16565 if !ok {
16566 that2, ok := that.(CustomNameNinEmbeddedStructUnion)
16567 if ok {
16568 that1 = &that2
16569 } else {
16570 return false
16571 }
16572 }
16573 if that1 == nil {
16574 return this == nil
16575 } else if this == nil {
16576 return false
16577 }
16578 if !this.NidOptNative.Equal(that1.NidOptNative) {
16579 return false
16580 }
16581 if !this.FieldA.Equal(that1.FieldA) {
16582 return false
16583 }
16584 if this.FieldB != nil && that1.FieldB != nil {
16585 if *this.FieldB != *that1.FieldB {
16586 return false
16587 }
16588 } else if this.FieldB != nil {
16589 return false
16590 } else if that1.FieldB != nil {
16591 return false
16592 }
16593 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16594 return false
16595 }
16596 return true
16597 }
16598 func (this *CustomNameEnum) VerboseEqual(that interface{}) error {
16599 if that == nil {
16600 if this == nil {
16601 return nil
16602 }
16603 return fmt.Errorf("that == nil && this != nil")
16604 }
16605
16606 that1, ok := that.(*CustomNameEnum)
16607 if !ok {
16608 that2, ok := that.(CustomNameEnum)
16609 if ok {
16610 that1 = &that2
16611 } else {
16612 return fmt.Errorf("that is not of type *CustomNameEnum")
16613 }
16614 }
16615 if that1 == nil {
16616 if this == nil {
16617 return nil
16618 }
16619 return fmt.Errorf("that is type *CustomNameEnum but is nil && this != nil")
16620 } else if this == nil {
16621 return fmt.Errorf("that is type *CustomNameEnum but is not nil && this == nil")
16622 }
16623 if this.FieldA != nil && that1.FieldA != nil {
16624 if *this.FieldA != *that1.FieldA {
16625 return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA)
16626 }
16627 } else if this.FieldA != nil {
16628 return fmt.Errorf("this.FieldA == nil && that.FieldA != nil")
16629 } else if that1.FieldA != nil {
16630 return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA)
16631 }
16632 if len(this.FieldB) != len(that1.FieldB) {
16633 return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB))
16634 }
16635 for i := range this.FieldB {
16636 if this.FieldB[i] != that1.FieldB[i] {
16637 return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i])
16638 }
16639 }
16640 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16641 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
16642 }
16643 return nil
16644 }
16645 func (this *CustomNameEnum) Equal(that interface{}) bool {
16646 if that == nil {
16647 return this == nil
16648 }
16649
16650 that1, ok := that.(*CustomNameEnum)
16651 if !ok {
16652 that2, ok := that.(CustomNameEnum)
16653 if ok {
16654 that1 = &that2
16655 } else {
16656 return false
16657 }
16658 }
16659 if that1 == nil {
16660 return this == nil
16661 } else if this == nil {
16662 return false
16663 }
16664 if this.FieldA != nil && that1.FieldA != nil {
16665 if *this.FieldA != *that1.FieldA {
16666 return false
16667 }
16668 } else if this.FieldA != nil {
16669 return false
16670 } else if that1.FieldA != nil {
16671 return false
16672 }
16673 if len(this.FieldB) != len(that1.FieldB) {
16674 return false
16675 }
16676 for i := range this.FieldB {
16677 if this.FieldB[i] != that1.FieldB[i] {
16678 return false
16679 }
16680 }
16681 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16682 return false
16683 }
16684 return true
16685 }
16686 func (this *NoExtensionsMap) VerboseEqual(that interface{}) error {
16687 if that == nil {
16688 if this == nil {
16689 return nil
16690 }
16691 return fmt.Errorf("that == nil && this != nil")
16692 }
16693
16694 that1, ok := that.(*NoExtensionsMap)
16695 if !ok {
16696 that2, ok := that.(NoExtensionsMap)
16697 if ok {
16698 that1 = &that2
16699 } else {
16700 return fmt.Errorf("that is not of type *NoExtensionsMap")
16701 }
16702 }
16703 if that1 == nil {
16704 if this == nil {
16705 return nil
16706 }
16707 return fmt.Errorf("that is type *NoExtensionsMap but is nil && this != nil")
16708 } else if this == nil {
16709 return fmt.Errorf("that is type *NoExtensionsMap but is not nil && this == nil")
16710 }
16711 if this.Field1 != nil && that1.Field1 != nil {
16712 if *this.Field1 != *that1.Field1 {
16713 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
16714 }
16715 } else if this.Field1 != nil {
16716 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
16717 } else if that1.Field1 != nil {
16718 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
16719 }
16720 if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) {
16721 return fmt.Errorf("XXX_extensions this(%v) Not Equal that(%v)", this.XXX_extensions, that1.XXX_extensions)
16722 }
16723 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16724 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
16725 }
16726 return nil
16727 }
16728 func (this *NoExtensionsMap) Equal(that interface{}) bool {
16729 if that == nil {
16730 return this == nil
16731 }
16732
16733 that1, ok := that.(*NoExtensionsMap)
16734 if !ok {
16735 that2, ok := that.(NoExtensionsMap)
16736 if ok {
16737 that1 = &that2
16738 } else {
16739 return false
16740 }
16741 }
16742 if that1 == nil {
16743 return this == nil
16744 } else if this == nil {
16745 return false
16746 }
16747 if this.Field1 != nil && that1.Field1 != nil {
16748 if *this.Field1 != *that1.Field1 {
16749 return false
16750 }
16751 } else if this.Field1 != nil {
16752 return false
16753 } else if that1.Field1 != nil {
16754 return false
16755 }
16756 if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) {
16757 return false
16758 }
16759 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16760 return false
16761 }
16762 return true
16763 }
16764 func (this *Unrecognized) VerboseEqual(that interface{}) error {
16765 if that == nil {
16766 if this == nil {
16767 return nil
16768 }
16769 return fmt.Errorf("that == nil && this != nil")
16770 }
16771
16772 that1, ok := that.(*Unrecognized)
16773 if !ok {
16774 that2, ok := that.(Unrecognized)
16775 if ok {
16776 that1 = &that2
16777 } else {
16778 return fmt.Errorf("that is not of type *Unrecognized")
16779 }
16780 }
16781 if that1 == nil {
16782 if this == nil {
16783 return nil
16784 }
16785 return fmt.Errorf("that is type *Unrecognized but is nil && this != nil")
16786 } else if this == nil {
16787 return fmt.Errorf("that is type *Unrecognized but is not nil && this == nil")
16788 }
16789 if this.Field1 != nil && that1.Field1 != nil {
16790 if *this.Field1 != *that1.Field1 {
16791 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
16792 }
16793 } else if this.Field1 != nil {
16794 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
16795 } else if that1.Field1 != nil {
16796 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
16797 }
16798 return nil
16799 }
16800 func (this *Unrecognized) Equal(that interface{}) bool {
16801 if that == nil {
16802 return this == nil
16803 }
16804
16805 that1, ok := that.(*Unrecognized)
16806 if !ok {
16807 that2, ok := that.(Unrecognized)
16808 if ok {
16809 that1 = &that2
16810 } else {
16811 return false
16812 }
16813 }
16814 if that1 == nil {
16815 return this == nil
16816 } else if this == nil {
16817 return false
16818 }
16819 if this.Field1 != nil && that1.Field1 != nil {
16820 if *this.Field1 != *that1.Field1 {
16821 return false
16822 }
16823 } else if this.Field1 != nil {
16824 return false
16825 } else if that1.Field1 != nil {
16826 return false
16827 }
16828 return true
16829 }
16830 func (this *UnrecognizedWithInner) VerboseEqual(that interface{}) error {
16831 if that == nil {
16832 if this == nil {
16833 return nil
16834 }
16835 return fmt.Errorf("that == nil && this != nil")
16836 }
16837
16838 that1, ok := that.(*UnrecognizedWithInner)
16839 if !ok {
16840 that2, ok := that.(UnrecognizedWithInner)
16841 if ok {
16842 that1 = &that2
16843 } else {
16844 return fmt.Errorf("that is not of type *UnrecognizedWithInner")
16845 }
16846 }
16847 if that1 == nil {
16848 if this == nil {
16849 return nil
16850 }
16851 return fmt.Errorf("that is type *UnrecognizedWithInner but is nil && this != nil")
16852 } else if this == nil {
16853 return fmt.Errorf("that is type *UnrecognizedWithInner but is not nil && this == nil")
16854 }
16855 if len(this.Embedded) != len(that1.Embedded) {
16856 return fmt.Errorf("Embedded this(%v) Not Equal that(%v)", len(this.Embedded), len(that1.Embedded))
16857 }
16858 for i := range this.Embedded {
16859 if !this.Embedded[i].Equal(that1.Embedded[i]) {
16860 return fmt.Errorf("Embedded this[%v](%v) Not Equal that[%v](%v)", i, this.Embedded[i], i, that1.Embedded[i])
16861 }
16862 }
16863 if this.Field2 != nil && that1.Field2 != nil {
16864 if *this.Field2 != *that1.Field2 {
16865 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
16866 }
16867 } else if this.Field2 != nil {
16868 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
16869 } else if that1.Field2 != nil {
16870 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
16871 }
16872 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16873 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
16874 }
16875 return nil
16876 }
16877 func (this *UnrecognizedWithInner) Equal(that interface{}) bool {
16878 if that == nil {
16879 return this == nil
16880 }
16881
16882 that1, ok := that.(*UnrecognizedWithInner)
16883 if !ok {
16884 that2, ok := that.(UnrecognizedWithInner)
16885 if ok {
16886 that1 = &that2
16887 } else {
16888 return false
16889 }
16890 }
16891 if that1 == nil {
16892 return this == nil
16893 } else if this == nil {
16894 return false
16895 }
16896 if len(this.Embedded) != len(that1.Embedded) {
16897 return false
16898 }
16899 for i := range this.Embedded {
16900 if !this.Embedded[i].Equal(that1.Embedded[i]) {
16901 return false
16902 }
16903 }
16904 if this.Field2 != nil && that1.Field2 != nil {
16905 if *this.Field2 != *that1.Field2 {
16906 return false
16907 }
16908 } else if this.Field2 != nil {
16909 return false
16910 } else if that1.Field2 != nil {
16911 return false
16912 }
16913 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
16914 return false
16915 }
16916 return true
16917 }
16918 func (this *UnrecognizedWithInner_Inner) VerboseEqual(that interface{}) error {
16919 if that == nil {
16920 if this == nil {
16921 return nil
16922 }
16923 return fmt.Errorf("that == nil && this != nil")
16924 }
16925
16926 that1, ok := that.(*UnrecognizedWithInner_Inner)
16927 if !ok {
16928 that2, ok := that.(UnrecognizedWithInner_Inner)
16929 if ok {
16930 that1 = &that2
16931 } else {
16932 return fmt.Errorf("that is not of type *UnrecognizedWithInner_Inner")
16933 }
16934 }
16935 if that1 == nil {
16936 if this == nil {
16937 return nil
16938 }
16939 return fmt.Errorf("that is type *UnrecognizedWithInner_Inner but is nil && this != nil")
16940 } else if this == nil {
16941 return fmt.Errorf("that is type *UnrecognizedWithInner_Inner but is not nil && this == nil")
16942 }
16943 if this.Field1 != nil && that1.Field1 != nil {
16944 if *this.Field1 != *that1.Field1 {
16945 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
16946 }
16947 } else if this.Field1 != nil {
16948 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
16949 } else if that1.Field1 != nil {
16950 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
16951 }
16952 return nil
16953 }
16954 func (this *UnrecognizedWithInner_Inner) Equal(that interface{}) bool {
16955 if that == nil {
16956 return this == nil
16957 }
16958
16959 that1, ok := that.(*UnrecognizedWithInner_Inner)
16960 if !ok {
16961 that2, ok := that.(UnrecognizedWithInner_Inner)
16962 if ok {
16963 that1 = &that2
16964 } else {
16965 return false
16966 }
16967 }
16968 if that1 == nil {
16969 return this == nil
16970 } else if this == nil {
16971 return false
16972 }
16973 if this.Field1 != nil && that1.Field1 != nil {
16974 if *this.Field1 != *that1.Field1 {
16975 return false
16976 }
16977 } else if this.Field1 != nil {
16978 return false
16979 } else if that1.Field1 != nil {
16980 return false
16981 }
16982 return true
16983 }
16984 func (this *UnrecognizedWithEmbed) VerboseEqual(that interface{}) error {
16985 if that == nil {
16986 if this == nil {
16987 return nil
16988 }
16989 return fmt.Errorf("that == nil && this != nil")
16990 }
16991
16992 that1, ok := that.(*UnrecognizedWithEmbed)
16993 if !ok {
16994 that2, ok := that.(UnrecognizedWithEmbed)
16995 if ok {
16996 that1 = &that2
16997 } else {
16998 return fmt.Errorf("that is not of type *UnrecognizedWithEmbed")
16999 }
17000 }
17001 if that1 == nil {
17002 if this == nil {
17003 return nil
17004 }
17005 return fmt.Errorf("that is type *UnrecognizedWithEmbed but is nil && this != nil")
17006 } else if this == nil {
17007 return fmt.Errorf("that is type *UnrecognizedWithEmbed but is not nil && this == nil")
17008 }
17009 if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) {
17010 return fmt.Errorf("UnrecognizedWithEmbed_Embedded this(%v) Not Equal that(%v)", this.UnrecognizedWithEmbed_Embedded, that1.UnrecognizedWithEmbed_Embedded)
17011 }
17012 if this.Field2 != nil && that1.Field2 != nil {
17013 if *this.Field2 != *that1.Field2 {
17014 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
17015 }
17016 } else if this.Field2 != nil {
17017 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
17018 } else if that1.Field2 != nil {
17019 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
17020 }
17021 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17022 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
17023 }
17024 return nil
17025 }
17026 func (this *UnrecognizedWithEmbed) Equal(that interface{}) bool {
17027 if that == nil {
17028 return this == nil
17029 }
17030
17031 that1, ok := that.(*UnrecognizedWithEmbed)
17032 if !ok {
17033 that2, ok := that.(UnrecognizedWithEmbed)
17034 if ok {
17035 that1 = &that2
17036 } else {
17037 return false
17038 }
17039 }
17040 if that1 == nil {
17041 return this == nil
17042 } else if this == nil {
17043 return false
17044 }
17045 if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) {
17046 return false
17047 }
17048 if this.Field2 != nil && that1.Field2 != nil {
17049 if *this.Field2 != *that1.Field2 {
17050 return false
17051 }
17052 } else if this.Field2 != nil {
17053 return false
17054 } else if that1.Field2 != nil {
17055 return false
17056 }
17057 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17058 return false
17059 }
17060 return true
17061 }
17062 func (this *UnrecognizedWithEmbed_Embedded) VerboseEqual(that interface{}) error {
17063 if that == nil {
17064 if this == nil {
17065 return nil
17066 }
17067 return fmt.Errorf("that == nil && this != nil")
17068 }
17069
17070 that1, ok := that.(*UnrecognizedWithEmbed_Embedded)
17071 if !ok {
17072 that2, ok := that.(UnrecognizedWithEmbed_Embedded)
17073 if ok {
17074 that1 = &that2
17075 } else {
17076 return fmt.Errorf("that is not of type *UnrecognizedWithEmbed_Embedded")
17077 }
17078 }
17079 if that1 == nil {
17080 if this == nil {
17081 return nil
17082 }
17083 return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embedded but is nil && this != nil")
17084 } else if this == nil {
17085 return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embedded but is not nil && this == nil")
17086 }
17087 if this.Field1 != nil && that1.Field1 != nil {
17088 if *this.Field1 != *that1.Field1 {
17089 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1)
17090 }
17091 } else if this.Field1 != nil {
17092 return fmt.Errorf("this.Field1 == nil && that.Field1 != nil")
17093 } else if that1.Field1 != nil {
17094 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
17095 }
17096 return nil
17097 }
17098 func (this *UnrecognizedWithEmbed_Embedded) Equal(that interface{}) bool {
17099 if that == nil {
17100 return this == nil
17101 }
17102
17103 that1, ok := that.(*UnrecognizedWithEmbed_Embedded)
17104 if !ok {
17105 that2, ok := that.(UnrecognizedWithEmbed_Embedded)
17106 if ok {
17107 that1 = &that2
17108 } else {
17109 return false
17110 }
17111 }
17112 if that1 == nil {
17113 return this == nil
17114 } else if this == nil {
17115 return false
17116 }
17117 if this.Field1 != nil && that1.Field1 != nil {
17118 if *this.Field1 != *that1.Field1 {
17119 return false
17120 }
17121 } else if this.Field1 != nil {
17122 return false
17123 } else if that1.Field1 != nil {
17124 return false
17125 }
17126 return true
17127 }
17128 func (this *Node) VerboseEqual(that interface{}) error {
17129 if that == nil {
17130 if this == nil {
17131 return nil
17132 }
17133 return fmt.Errorf("that == nil && this != nil")
17134 }
17135
17136 that1, ok := that.(*Node)
17137 if !ok {
17138 that2, ok := that.(Node)
17139 if ok {
17140 that1 = &that2
17141 } else {
17142 return fmt.Errorf("that is not of type *Node")
17143 }
17144 }
17145 if that1 == nil {
17146 if this == nil {
17147 return nil
17148 }
17149 return fmt.Errorf("that is type *Node but is nil && this != nil")
17150 } else if this == nil {
17151 return fmt.Errorf("that is type *Node but is not nil && this == nil")
17152 }
17153 if this.Label != nil && that1.Label != nil {
17154 if *this.Label != *that1.Label {
17155 return fmt.Errorf("Label this(%v) Not Equal that(%v)", *this.Label, *that1.Label)
17156 }
17157 } else if this.Label != nil {
17158 return fmt.Errorf("this.Label == nil && that.Label != nil")
17159 } else if that1.Label != nil {
17160 return fmt.Errorf("Label this(%v) Not Equal that(%v)", this.Label, that1.Label)
17161 }
17162 if len(this.Children) != len(that1.Children) {
17163 return fmt.Errorf("Children this(%v) Not Equal that(%v)", len(this.Children), len(that1.Children))
17164 }
17165 for i := range this.Children {
17166 if !this.Children[i].Equal(that1.Children[i]) {
17167 return fmt.Errorf("Children this[%v](%v) Not Equal that[%v](%v)", i, this.Children[i], i, that1.Children[i])
17168 }
17169 }
17170 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17171 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
17172 }
17173 return nil
17174 }
17175 func (this *Node) Equal(that interface{}) bool {
17176 if that == nil {
17177 return this == nil
17178 }
17179
17180 that1, ok := that.(*Node)
17181 if !ok {
17182 that2, ok := that.(Node)
17183 if ok {
17184 that1 = &that2
17185 } else {
17186 return false
17187 }
17188 }
17189 if that1 == nil {
17190 return this == nil
17191 } else if this == nil {
17192 return false
17193 }
17194 if this.Label != nil && that1.Label != nil {
17195 if *this.Label != *that1.Label {
17196 return false
17197 }
17198 } else if this.Label != nil {
17199 return false
17200 } else if that1.Label != nil {
17201 return false
17202 }
17203 if len(this.Children) != len(that1.Children) {
17204 return false
17205 }
17206 for i := range this.Children {
17207 if !this.Children[i].Equal(that1.Children[i]) {
17208 return false
17209 }
17210 }
17211 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17212 return false
17213 }
17214 return true
17215 }
17216 func (this *NonByteCustomType) VerboseEqual(that interface{}) error {
17217 if that == nil {
17218 if this == nil {
17219 return nil
17220 }
17221 return fmt.Errorf("that == nil && this != nil")
17222 }
17223
17224 that1, ok := that.(*NonByteCustomType)
17225 if !ok {
17226 that2, ok := that.(NonByteCustomType)
17227 if ok {
17228 that1 = &that2
17229 } else {
17230 return fmt.Errorf("that is not of type *NonByteCustomType")
17231 }
17232 }
17233 if that1 == nil {
17234 if this == nil {
17235 return nil
17236 }
17237 return fmt.Errorf("that is type *NonByteCustomType but is nil && this != nil")
17238 } else if this == nil {
17239 return fmt.Errorf("that is type *NonByteCustomType but is not nil && this == nil")
17240 }
17241 if that1.Field1 == nil {
17242 if this.Field1 != nil {
17243 return fmt.Errorf("this.Field1 != nil && that1.Field1 == nil")
17244 }
17245 } else if !this.Field1.Equal(*that1.Field1) {
17246 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
17247 }
17248 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17249 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
17250 }
17251 return nil
17252 }
17253 func (this *NonByteCustomType) Equal(that interface{}) bool {
17254 if that == nil {
17255 return this == nil
17256 }
17257
17258 that1, ok := that.(*NonByteCustomType)
17259 if !ok {
17260 that2, ok := that.(NonByteCustomType)
17261 if ok {
17262 that1 = &that2
17263 } else {
17264 return false
17265 }
17266 }
17267 if that1 == nil {
17268 return this == nil
17269 } else if this == nil {
17270 return false
17271 }
17272 if that1.Field1 == nil {
17273 if this.Field1 != nil {
17274 return false
17275 }
17276 } else if !this.Field1.Equal(*that1.Field1) {
17277 return false
17278 }
17279 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17280 return false
17281 }
17282 return true
17283 }
17284 func (this *NidOptNonByteCustomType) VerboseEqual(that interface{}) error {
17285 if that == nil {
17286 if this == nil {
17287 return nil
17288 }
17289 return fmt.Errorf("that == nil && this != nil")
17290 }
17291
17292 that1, ok := that.(*NidOptNonByteCustomType)
17293 if !ok {
17294 that2, ok := that.(NidOptNonByteCustomType)
17295 if ok {
17296 that1 = &that2
17297 } else {
17298 return fmt.Errorf("that is not of type *NidOptNonByteCustomType")
17299 }
17300 }
17301 if that1 == nil {
17302 if this == nil {
17303 return nil
17304 }
17305 return fmt.Errorf("that is type *NidOptNonByteCustomType but is nil && this != nil")
17306 } else if this == nil {
17307 return fmt.Errorf("that is type *NidOptNonByteCustomType but is not nil && this == nil")
17308 }
17309 if !this.Field1.Equal(that1.Field1) {
17310 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
17311 }
17312 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17313 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
17314 }
17315 return nil
17316 }
17317 func (this *NidOptNonByteCustomType) Equal(that interface{}) bool {
17318 if that == nil {
17319 return this == nil
17320 }
17321
17322 that1, ok := that.(*NidOptNonByteCustomType)
17323 if !ok {
17324 that2, ok := that.(NidOptNonByteCustomType)
17325 if ok {
17326 that1 = &that2
17327 } else {
17328 return false
17329 }
17330 }
17331 if that1 == nil {
17332 return this == nil
17333 } else if this == nil {
17334 return false
17335 }
17336 if !this.Field1.Equal(that1.Field1) {
17337 return false
17338 }
17339 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17340 return false
17341 }
17342 return true
17343 }
17344 func (this *NinOptNonByteCustomType) VerboseEqual(that interface{}) error {
17345 if that == nil {
17346 if this == nil {
17347 return nil
17348 }
17349 return fmt.Errorf("that == nil && this != nil")
17350 }
17351
17352 that1, ok := that.(*NinOptNonByteCustomType)
17353 if !ok {
17354 that2, ok := that.(NinOptNonByteCustomType)
17355 if ok {
17356 that1 = &that2
17357 } else {
17358 return fmt.Errorf("that is not of type *NinOptNonByteCustomType")
17359 }
17360 }
17361 if that1 == nil {
17362 if this == nil {
17363 return nil
17364 }
17365 return fmt.Errorf("that is type *NinOptNonByteCustomType but is nil && this != nil")
17366 } else if this == nil {
17367 return fmt.Errorf("that is type *NinOptNonByteCustomType but is not nil && this == nil")
17368 }
17369 if that1.Field1 == nil {
17370 if this.Field1 != nil {
17371 return fmt.Errorf("this.Field1 != nil && that1.Field1 == nil")
17372 }
17373 } else if !this.Field1.Equal(*that1.Field1) {
17374 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1)
17375 }
17376 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17377 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
17378 }
17379 return nil
17380 }
17381 func (this *NinOptNonByteCustomType) Equal(that interface{}) bool {
17382 if that == nil {
17383 return this == nil
17384 }
17385
17386 that1, ok := that.(*NinOptNonByteCustomType)
17387 if !ok {
17388 that2, ok := that.(NinOptNonByteCustomType)
17389 if ok {
17390 that1 = &that2
17391 } else {
17392 return false
17393 }
17394 }
17395 if that1 == nil {
17396 return this == nil
17397 } else if this == nil {
17398 return false
17399 }
17400 if that1.Field1 == nil {
17401 if this.Field1 != nil {
17402 return false
17403 }
17404 } else if !this.Field1.Equal(*that1.Field1) {
17405 return false
17406 }
17407 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17408 return false
17409 }
17410 return true
17411 }
17412 func (this *NidRepNonByteCustomType) VerboseEqual(that interface{}) error {
17413 if that == nil {
17414 if this == nil {
17415 return nil
17416 }
17417 return fmt.Errorf("that == nil && this != nil")
17418 }
17419
17420 that1, ok := that.(*NidRepNonByteCustomType)
17421 if !ok {
17422 that2, ok := that.(NidRepNonByteCustomType)
17423 if ok {
17424 that1 = &that2
17425 } else {
17426 return fmt.Errorf("that is not of type *NidRepNonByteCustomType")
17427 }
17428 }
17429 if that1 == nil {
17430 if this == nil {
17431 return nil
17432 }
17433 return fmt.Errorf("that is type *NidRepNonByteCustomType but is nil && this != nil")
17434 } else if this == nil {
17435 return fmt.Errorf("that is type *NidRepNonByteCustomType but is not nil && this == nil")
17436 }
17437 if len(this.Field1) != len(that1.Field1) {
17438 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1))
17439 }
17440 for i := range this.Field1 {
17441 if !this.Field1[i].Equal(that1.Field1[i]) {
17442 return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i])
17443 }
17444 }
17445 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17446 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
17447 }
17448 return nil
17449 }
17450 func (this *NidRepNonByteCustomType) Equal(that interface{}) bool {
17451 if that == nil {
17452 return this == nil
17453 }
17454
17455 that1, ok := that.(*NidRepNonByteCustomType)
17456 if !ok {
17457 that2, ok := that.(NidRepNonByteCustomType)
17458 if ok {
17459 that1 = &that2
17460 } else {
17461 return false
17462 }
17463 }
17464 if that1 == nil {
17465 return this == nil
17466 } else if this == nil {
17467 return false
17468 }
17469 if len(this.Field1) != len(that1.Field1) {
17470 return false
17471 }
17472 for i := range this.Field1 {
17473 if !this.Field1[i].Equal(that1.Field1[i]) {
17474 return false
17475 }
17476 }
17477 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17478 return false
17479 }
17480 return true
17481 }
17482 func (this *NinRepNonByteCustomType) VerboseEqual(that interface{}) error {
17483 if that == nil {
17484 if this == nil {
17485 return nil
17486 }
17487 return fmt.Errorf("that == nil && this != nil")
17488 }
17489
17490 that1, ok := that.(*NinRepNonByteCustomType)
17491 if !ok {
17492 that2, ok := that.(NinRepNonByteCustomType)
17493 if ok {
17494 that1 = &that2
17495 } else {
17496 return fmt.Errorf("that is not of type *NinRepNonByteCustomType")
17497 }
17498 }
17499 if that1 == nil {
17500 if this == nil {
17501 return nil
17502 }
17503 return fmt.Errorf("that is type *NinRepNonByteCustomType but is nil && this != nil")
17504 } else if this == nil {
17505 return fmt.Errorf("that is type *NinRepNonByteCustomType but is not nil && this == nil")
17506 }
17507 if len(this.Field1) != len(that1.Field1) {
17508 return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1))
17509 }
17510 for i := range this.Field1 {
17511 if !this.Field1[i].Equal(that1.Field1[i]) {
17512 return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i])
17513 }
17514 }
17515 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17516 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
17517 }
17518 return nil
17519 }
17520 func (this *NinRepNonByteCustomType) Equal(that interface{}) bool {
17521 if that == nil {
17522 return this == nil
17523 }
17524
17525 that1, ok := that.(*NinRepNonByteCustomType)
17526 if !ok {
17527 that2, ok := that.(NinRepNonByteCustomType)
17528 if ok {
17529 that1 = &that2
17530 } else {
17531 return false
17532 }
17533 }
17534 if that1 == nil {
17535 return this == nil
17536 } else if this == nil {
17537 return false
17538 }
17539 if len(this.Field1) != len(that1.Field1) {
17540 return false
17541 }
17542 for i := range this.Field1 {
17543 if !this.Field1[i].Equal(that1.Field1[i]) {
17544 return false
17545 }
17546 }
17547 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17548 return false
17549 }
17550 return true
17551 }
17552 func (this *ProtoType) VerboseEqual(that interface{}) error {
17553 if that == nil {
17554 if this == nil {
17555 return nil
17556 }
17557 return fmt.Errorf("that == nil && this != nil")
17558 }
17559
17560 that1, ok := that.(*ProtoType)
17561 if !ok {
17562 that2, ok := that.(ProtoType)
17563 if ok {
17564 that1 = &that2
17565 } else {
17566 return fmt.Errorf("that is not of type *ProtoType")
17567 }
17568 }
17569 if that1 == nil {
17570 if this == nil {
17571 return nil
17572 }
17573 return fmt.Errorf("that is type *ProtoType but is nil && this != nil")
17574 } else if this == nil {
17575 return fmt.Errorf("that is type *ProtoType but is not nil && this == nil")
17576 }
17577 if this.Field2 != nil && that1.Field2 != nil {
17578 if *this.Field2 != *that1.Field2 {
17579 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2)
17580 }
17581 } else if this.Field2 != nil {
17582 return fmt.Errorf("this.Field2 == nil && that.Field2 != nil")
17583 } else if that1.Field2 != nil {
17584 return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2)
17585 }
17586 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17587 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
17588 }
17589 return nil
17590 }
17591 func (this *ProtoType) Equal(that interface{}) bool {
17592 if that == nil {
17593 return this == nil
17594 }
17595
17596 that1, ok := that.(*ProtoType)
17597 if !ok {
17598 that2, ok := that.(ProtoType)
17599 if ok {
17600 that1 = &that2
17601 } else {
17602 return false
17603 }
17604 }
17605 if that1 == nil {
17606 return this == nil
17607 } else if this == nil {
17608 return false
17609 }
17610 if this.Field2 != nil && that1.Field2 != nil {
17611 if *this.Field2 != *that1.Field2 {
17612 return false
17613 }
17614 } else if this.Field2 != nil {
17615 return false
17616 } else if that1.Field2 != nil {
17617 return false
17618 }
17619 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
17620 return false
17621 }
17622 return true
17623 }
17624
17625 type NidOptNativeFace interface {
17626 Proto() github_com_gogo_protobuf_proto.Message
17627 GetField1() float64
17628 GetField2() float32
17629 GetField3() int32
17630 GetField4() int64
17631 GetField5() uint32
17632 GetField6() uint64
17633 GetField7() int32
17634 GetField8() int64
17635 GetField9() uint32
17636 GetField10() int32
17637 GetField11() uint64
17638 GetField12() int64
17639 GetField13() bool
17640 GetField14() string
17641 GetField15() []byte
17642 }
17643
17644 func (this *NidOptNative) Proto() github_com_gogo_protobuf_proto.Message {
17645 return this
17646 }
17647
17648 func (this *NidOptNative) TestProto() github_com_gogo_protobuf_proto.Message {
17649 return NewNidOptNativeFromFace(this)
17650 }
17651
17652 func (this *NidOptNative) GetField1() float64 {
17653 return this.Field1
17654 }
17655
17656 func (this *NidOptNative) GetField2() float32 {
17657 return this.Field2
17658 }
17659
17660 func (this *NidOptNative) GetField3() int32 {
17661 return this.Field3
17662 }
17663
17664 func (this *NidOptNative) GetField4() int64 {
17665 return this.Field4
17666 }
17667
17668 func (this *NidOptNative) GetField5() uint32 {
17669 return this.Field5
17670 }
17671
17672 func (this *NidOptNative) GetField6() uint64 {
17673 return this.Field6
17674 }
17675
17676 func (this *NidOptNative) GetField7() int32 {
17677 return this.Field7
17678 }
17679
17680 func (this *NidOptNative) GetField8() int64 {
17681 return this.Field8
17682 }
17683
17684 func (this *NidOptNative) GetField9() uint32 {
17685 return this.Field9
17686 }
17687
17688 func (this *NidOptNative) GetField10() int32 {
17689 return this.Field10
17690 }
17691
17692 func (this *NidOptNative) GetField11() uint64 {
17693 return this.Field11
17694 }
17695
17696 func (this *NidOptNative) GetField12() int64 {
17697 return this.Field12
17698 }
17699
17700 func (this *NidOptNative) GetField13() bool {
17701 return this.Field13
17702 }
17703
17704 func (this *NidOptNative) GetField14() string {
17705 return this.Field14
17706 }
17707
17708 func (this *NidOptNative) GetField15() []byte {
17709 return this.Field15
17710 }
17711
17712 func NewNidOptNativeFromFace(that NidOptNativeFace) *NidOptNative {
17713 this := &NidOptNative{}
17714 this.Field1 = that.GetField1()
17715 this.Field2 = that.GetField2()
17716 this.Field3 = that.GetField3()
17717 this.Field4 = that.GetField4()
17718 this.Field5 = that.GetField5()
17719 this.Field6 = that.GetField6()
17720 this.Field7 = that.GetField7()
17721 this.Field8 = that.GetField8()
17722 this.Field9 = that.GetField9()
17723 this.Field10 = that.GetField10()
17724 this.Field11 = that.GetField11()
17725 this.Field12 = that.GetField12()
17726 this.Field13 = that.GetField13()
17727 this.Field14 = that.GetField14()
17728 this.Field15 = that.GetField15()
17729 return this
17730 }
17731
17732 type NinOptNativeFace interface {
17733 Proto() github_com_gogo_protobuf_proto.Message
17734 GetField1() *float64
17735 GetField2() *float32
17736 GetField3() *int32
17737 GetField4() *int64
17738 GetField5() *uint32
17739 GetField6() *uint64
17740 GetField7() *int32
17741 GetField8() *int64
17742 GetField9() *uint32
17743 GetField10() *int32
17744 GetField11() *uint64
17745 GetField12() *int64
17746 GetField13() *bool
17747 GetField14() *string
17748 GetField15() []byte
17749 }
17750
17751 func (this *NinOptNative) Proto() github_com_gogo_protobuf_proto.Message {
17752 return this
17753 }
17754
17755 func (this *NinOptNative) TestProto() github_com_gogo_protobuf_proto.Message {
17756 return NewNinOptNativeFromFace(this)
17757 }
17758
17759 func (this *NinOptNative) GetField1() *float64 {
17760 return this.Field1
17761 }
17762
17763 func (this *NinOptNative) GetField2() *float32 {
17764 return this.Field2
17765 }
17766
17767 func (this *NinOptNative) GetField3() *int32 {
17768 return this.Field3
17769 }
17770
17771 func (this *NinOptNative) GetField4() *int64 {
17772 return this.Field4
17773 }
17774
17775 func (this *NinOptNative) GetField5() *uint32 {
17776 return this.Field5
17777 }
17778
17779 func (this *NinOptNative) GetField6() *uint64 {
17780 return this.Field6
17781 }
17782
17783 func (this *NinOptNative) GetField7() *int32 {
17784 return this.Field7
17785 }
17786
17787 func (this *NinOptNative) GetField8() *int64 {
17788 return this.Field8
17789 }
17790
17791 func (this *NinOptNative) GetField9() *uint32 {
17792 return this.Field9
17793 }
17794
17795 func (this *NinOptNative) GetField10() *int32 {
17796 return this.Field10
17797 }
17798
17799 func (this *NinOptNative) GetField11() *uint64 {
17800 return this.Field11
17801 }
17802
17803 func (this *NinOptNative) GetField12() *int64 {
17804 return this.Field12
17805 }
17806
17807 func (this *NinOptNative) GetField13() *bool {
17808 return this.Field13
17809 }
17810
17811 func (this *NinOptNative) GetField14() *string {
17812 return this.Field14
17813 }
17814
17815 func (this *NinOptNative) GetField15() []byte {
17816 return this.Field15
17817 }
17818
17819 func NewNinOptNativeFromFace(that NinOptNativeFace) *NinOptNative {
17820 this := &NinOptNative{}
17821 this.Field1 = that.GetField1()
17822 this.Field2 = that.GetField2()
17823 this.Field3 = that.GetField3()
17824 this.Field4 = that.GetField4()
17825 this.Field5 = that.GetField5()
17826 this.Field6 = that.GetField6()
17827 this.Field7 = that.GetField7()
17828 this.Field8 = that.GetField8()
17829 this.Field9 = that.GetField9()
17830 this.Field10 = that.GetField10()
17831 this.Field11 = that.GetField11()
17832 this.Field12 = that.GetField12()
17833 this.Field13 = that.GetField13()
17834 this.Field14 = that.GetField14()
17835 this.Field15 = that.GetField15()
17836 return this
17837 }
17838
17839 type NidRepNativeFace interface {
17840 Proto() github_com_gogo_protobuf_proto.Message
17841 GetField1() []float64
17842 GetField2() []float32
17843 GetField3() []int32
17844 GetField4() []int64
17845 GetField5() []uint32
17846 GetField6() []uint64
17847 GetField7() []int32
17848 GetField8() []int64
17849 GetField9() []uint32
17850 GetField10() []int32
17851 GetField11() []uint64
17852 GetField12() []int64
17853 GetField13() []bool
17854 GetField14() []string
17855 GetField15() [][]byte
17856 }
17857
17858 func (this *NidRepNative) Proto() github_com_gogo_protobuf_proto.Message {
17859 return this
17860 }
17861
17862 func (this *NidRepNative) TestProto() github_com_gogo_protobuf_proto.Message {
17863 return NewNidRepNativeFromFace(this)
17864 }
17865
17866 func (this *NidRepNative) GetField1() []float64 {
17867 return this.Field1
17868 }
17869
17870 func (this *NidRepNative) GetField2() []float32 {
17871 return this.Field2
17872 }
17873
17874 func (this *NidRepNative) GetField3() []int32 {
17875 return this.Field3
17876 }
17877
17878 func (this *NidRepNative) GetField4() []int64 {
17879 return this.Field4
17880 }
17881
17882 func (this *NidRepNative) GetField5() []uint32 {
17883 return this.Field5
17884 }
17885
17886 func (this *NidRepNative) GetField6() []uint64 {
17887 return this.Field6
17888 }
17889
17890 func (this *NidRepNative) GetField7() []int32 {
17891 return this.Field7
17892 }
17893
17894 func (this *NidRepNative) GetField8() []int64 {
17895 return this.Field8
17896 }
17897
17898 func (this *NidRepNative) GetField9() []uint32 {
17899 return this.Field9
17900 }
17901
17902 func (this *NidRepNative) GetField10() []int32 {
17903 return this.Field10
17904 }
17905
17906 func (this *NidRepNative) GetField11() []uint64 {
17907 return this.Field11
17908 }
17909
17910 func (this *NidRepNative) GetField12() []int64 {
17911 return this.Field12
17912 }
17913
17914 func (this *NidRepNative) GetField13() []bool {
17915 return this.Field13
17916 }
17917
17918 func (this *NidRepNative) GetField14() []string {
17919 return this.Field14
17920 }
17921
17922 func (this *NidRepNative) GetField15() [][]byte {
17923 return this.Field15
17924 }
17925
17926 func NewNidRepNativeFromFace(that NidRepNativeFace) *NidRepNative {
17927 this := &NidRepNative{}
17928 this.Field1 = that.GetField1()
17929 this.Field2 = that.GetField2()
17930 this.Field3 = that.GetField3()
17931 this.Field4 = that.GetField4()
17932 this.Field5 = that.GetField5()
17933 this.Field6 = that.GetField6()
17934 this.Field7 = that.GetField7()
17935 this.Field8 = that.GetField8()
17936 this.Field9 = that.GetField9()
17937 this.Field10 = that.GetField10()
17938 this.Field11 = that.GetField11()
17939 this.Field12 = that.GetField12()
17940 this.Field13 = that.GetField13()
17941 this.Field14 = that.GetField14()
17942 this.Field15 = that.GetField15()
17943 return this
17944 }
17945
17946 type NinRepNativeFace interface {
17947 Proto() github_com_gogo_protobuf_proto.Message
17948 GetField1() []float64
17949 GetField2() []float32
17950 GetField3() []int32
17951 GetField4() []int64
17952 GetField5() []uint32
17953 GetField6() []uint64
17954 GetField7() []int32
17955 GetField8() []int64
17956 GetField9() []uint32
17957 GetField10() []int32
17958 GetField11() []uint64
17959 GetField12() []int64
17960 GetField13() []bool
17961 GetField14() []string
17962 GetField15() [][]byte
17963 }
17964
17965 func (this *NinRepNative) Proto() github_com_gogo_protobuf_proto.Message {
17966 return this
17967 }
17968
17969 func (this *NinRepNative) TestProto() github_com_gogo_protobuf_proto.Message {
17970 return NewNinRepNativeFromFace(this)
17971 }
17972
17973 func (this *NinRepNative) GetField1() []float64 {
17974 return this.Field1
17975 }
17976
17977 func (this *NinRepNative) GetField2() []float32 {
17978 return this.Field2
17979 }
17980
17981 func (this *NinRepNative) GetField3() []int32 {
17982 return this.Field3
17983 }
17984
17985 func (this *NinRepNative) GetField4() []int64 {
17986 return this.Field4
17987 }
17988
17989 func (this *NinRepNative) GetField5() []uint32 {
17990 return this.Field5
17991 }
17992
17993 func (this *NinRepNative) GetField6() []uint64 {
17994 return this.Field6
17995 }
17996
17997 func (this *NinRepNative) GetField7() []int32 {
17998 return this.Field7
17999 }
18000
18001 func (this *NinRepNative) GetField8() []int64 {
18002 return this.Field8
18003 }
18004
18005 func (this *NinRepNative) GetField9() []uint32 {
18006 return this.Field9
18007 }
18008
18009 func (this *NinRepNative) GetField10() []int32 {
18010 return this.Field10
18011 }
18012
18013 func (this *NinRepNative) GetField11() []uint64 {
18014 return this.Field11
18015 }
18016
18017 func (this *NinRepNative) GetField12() []int64 {
18018 return this.Field12
18019 }
18020
18021 func (this *NinRepNative) GetField13() []bool {
18022 return this.Field13
18023 }
18024
18025 func (this *NinRepNative) GetField14() []string {
18026 return this.Field14
18027 }
18028
18029 func (this *NinRepNative) GetField15() [][]byte {
18030 return this.Field15
18031 }
18032
18033 func NewNinRepNativeFromFace(that NinRepNativeFace) *NinRepNative {
18034 this := &NinRepNative{}
18035 this.Field1 = that.GetField1()
18036 this.Field2 = that.GetField2()
18037 this.Field3 = that.GetField3()
18038 this.Field4 = that.GetField4()
18039 this.Field5 = that.GetField5()
18040 this.Field6 = that.GetField6()
18041 this.Field7 = that.GetField7()
18042 this.Field8 = that.GetField8()
18043 this.Field9 = that.GetField9()
18044 this.Field10 = that.GetField10()
18045 this.Field11 = that.GetField11()
18046 this.Field12 = that.GetField12()
18047 this.Field13 = that.GetField13()
18048 this.Field14 = that.GetField14()
18049 this.Field15 = that.GetField15()
18050 return this
18051 }
18052
18053 type NidRepPackedNativeFace interface {
18054 Proto() github_com_gogo_protobuf_proto.Message
18055 GetField1() []float64
18056 GetField2() []float32
18057 GetField3() []int32
18058 GetField4() []int64
18059 GetField5() []uint32
18060 GetField6() []uint64
18061 GetField7() []int32
18062 GetField8() []int64
18063 GetField9() []uint32
18064 GetField10() []int32
18065 GetField11() []uint64
18066 GetField12() []int64
18067 GetField13() []bool
18068 }
18069
18070 func (this *NidRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message {
18071 return this
18072 }
18073
18074 func (this *NidRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message {
18075 return NewNidRepPackedNativeFromFace(this)
18076 }
18077
18078 func (this *NidRepPackedNative) GetField1() []float64 {
18079 return this.Field1
18080 }
18081
18082 func (this *NidRepPackedNative) GetField2() []float32 {
18083 return this.Field2
18084 }
18085
18086 func (this *NidRepPackedNative) GetField3() []int32 {
18087 return this.Field3
18088 }
18089
18090 func (this *NidRepPackedNative) GetField4() []int64 {
18091 return this.Field4
18092 }
18093
18094 func (this *NidRepPackedNative) GetField5() []uint32 {
18095 return this.Field5
18096 }
18097
18098 func (this *NidRepPackedNative) GetField6() []uint64 {
18099 return this.Field6
18100 }
18101
18102 func (this *NidRepPackedNative) GetField7() []int32 {
18103 return this.Field7
18104 }
18105
18106 func (this *NidRepPackedNative) GetField8() []int64 {
18107 return this.Field8
18108 }
18109
18110 func (this *NidRepPackedNative) GetField9() []uint32 {
18111 return this.Field9
18112 }
18113
18114 func (this *NidRepPackedNative) GetField10() []int32 {
18115 return this.Field10
18116 }
18117
18118 func (this *NidRepPackedNative) GetField11() []uint64 {
18119 return this.Field11
18120 }
18121
18122 func (this *NidRepPackedNative) GetField12() []int64 {
18123 return this.Field12
18124 }
18125
18126 func (this *NidRepPackedNative) GetField13() []bool {
18127 return this.Field13
18128 }
18129
18130 func NewNidRepPackedNativeFromFace(that NidRepPackedNativeFace) *NidRepPackedNative {
18131 this := &NidRepPackedNative{}
18132 this.Field1 = that.GetField1()
18133 this.Field2 = that.GetField2()
18134 this.Field3 = that.GetField3()
18135 this.Field4 = that.GetField4()
18136 this.Field5 = that.GetField5()
18137 this.Field6 = that.GetField6()
18138 this.Field7 = that.GetField7()
18139 this.Field8 = that.GetField8()
18140 this.Field9 = that.GetField9()
18141 this.Field10 = that.GetField10()
18142 this.Field11 = that.GetField11()
18143 this.Field12 = that.GetField12()
18144 this.Field13 = that.GetField13()
18145 return this
18146 }
18147
18148 type NinRepPackedNativeFace interface {
18149 Proto() github_com_gogo_protobuf_proto.Message
18150 GetField1() []float64
18151 GetField2() []float32
18152 GetField3() []int32
18153 GetField4() []int64
18154 GetField5() []uint32
18155 GetField6() []uint64
18156 GetField7() []int32
18157 GetField8() []int64
18158 GetField9() []uint32
18159 GetField10() []int32
18160 GetField11() []uint64
18161 GetField12() []int64
18162 GetField13() []bool
18163 }
18164
18165 func (this *NinRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message {
18166 return this
18167 }
18168
18169 func (this *NinRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message {
18170 return NewNinRepPackedNativeFromFace(this)
18171 }
18172
18173 func (this *NinRepPackedNative) GetField1() []float64 {
18174 return this.Field1
18175 }
18176
18177 func (this *NinRepPackedNative) GetField2() []float32 {
18178 return this.Field2
18179 }
18180
18181 func (this *NinRepPackedNative) GetField3() []int32 {
18182 return this.Field3
18183 }
18184
18185 func (this *NinRepPackedNative) GetField4() []int64 {
18186 return this.Field4
18187 }
18188
18189 func (this *NinRepPackedNative) GetField5() []uint32 {
18190 return this.Field5
18191 }
18192
18193 func (this *NinRepPackedNative) GetField6() []uint64 {
18194 return this.Field6
18195 }
18196
18197 func (this *NinRepPackedNative) GetField7() []int32 {
18198 return this.Field7
18199 }
18200
18201 func (this *NinRepPackedNative) GetField8() []int64 {
18202 return this.Field8
18203 }
18204
18205 func (this *NinRepPackedNative) GetField9() []uint32 {
18206 return this.Field9
18207 }
18208
18209 func (this *NinRepPackedNative) GetField10() []int32 {
18210 return this.Field10
18211 }
18212
18213 func (this *NinRepPackedNative) GetField11() []uint64 {
18214 return this.Field11
18215 }
18216
18217 func (this *NinRepPackedNative) GetField12() []int64 {
18218 return this.Field12
18219 }
18220
18221 func (this *NinRepPackedNative) GetField13() []bool {
18222 return this.Field13
18223 }
18224
18225 func NewNinRepPackedNativeFromFace(that NinRepPackedNativeFace) *NinRepPackedNative {
18226 this := &NinRepPackedNative{}
18227 this.Field1 = that.GetField1()
18228 this.Field2 = that.GetField2()
18229 this.Field3 = that.GetField3()
18230 this.Field4 = that.GetField4()
18231 this.Field5 = that.GetField5()
18232 this.Field6 = that.GetField6()
18233 this.Field7 = that.GetField7()
18234 this.Field8 = that.GetField8()
18235 this.Field9 = that.GetField9()
18236 this.Field10 = that.GetField10()
18237 this.Field11 = that.GetField11()
18238 this.Field12 = that.GetField12()
18239 this.Field13 = that.GetField13()
18240 return this
18241 }
18242
18243 type NidOptStructFace interface {
18244 Proto() github_com_gogo_protobuf_proto.Message
18245 GetField1() float64
18246 GetField2() float32
18247 GetField3() NidOptNative
18248 GetField4() NinOptNative
18249 GetField6() uint64
18250 GetField7() int32
18251 GetField8() NidOptNative
18252 GetField13() bool
18253 GetField14() string
18254 GetField15() []byte
18255 }
18256
18257 func (this *NidOptStruct) Proto() github_com_gogo_protobuf_proto.Message {
18258 return this
18259 }
18260
18261 func (this *NidOptStruct) TestProto() github_com_gogo_protobuf_proto.Message {
18262 return NewNidOptStructFromFace(this)
18263 }
18264
18265 func (this *NidOptStruct) GetField1() float64 {
18266 return this.Field1
18267 }
18268
18269 func (this *NidOptStruct) GetField2() float32 {
18270 return this.Field2
18271 }
18272
18273 func (this *NidOptStruct) GetField3() NidOptNative {
18274 return this.Field3
18275 }
18276
18277 func (this *NidOptStruct) GetField4() NinOptNative {
18278 return this.Field4
18279 }
18280
18281 func (this *NidOptStruct) GetField6() uint64 {
18282 return this.Field6
18283 }
18284
18285 func (this *NidOptStruct) GetField7() int32 {
18286 return this.Field7
18287 }
18288
18289 func (this *NidOptStruct) GetField8() NidOptNative {
18290 return this.Field8
18291 }
18292
18293 func (this *NidOptStruct) GetField13() bool {
18294 return this.Field13
18295 }
18296
18297 func (this *NidOptStruct) GetField14() string {
18298 return this.Field14
18299 }
18300
18301 func (this *NidOptStruct) GetField15() []byte {
18302 return this.Field15
18303 }
18304
18305 func NewNidOptStructFromFace(that NidOptStructFace) *NidOptStruct {
18306 this := &NidOptStruct{}
18307 this.Field1 = that.GetField1()
18308 this.Field2 = that.GetField2()
18309 this.Field3 = that.GetField3()
18310 this.Field4 = that.GetField4()
18311 this.Field6 = that.GetField6()
18312 this.Field7 = that.GetField7()
18313 this.Field8 = that.GetField8()
18314 this.Field13 = that.GetField13()
18315 this.Field14 = that.GetField14()
18316 this.Field15 = that.GetField15()
18317 return this
18318 }
18319
18320 type NinOptStructFace interface {
18321 Proto() github_com_gogo_protobuf_proto.Message
18322 GetField1() *float64
18323 GetField2() *float32
18324 GetField3() *NidOptNative
18325 GetField4() *NinOptNative
18326 GetField6() *uint64
18327 GetField7() *int32
18328 GetField8() *NidOptNative
18329 GetField13() *bool
18330 GetField14() *string
18331 GetField15() []byte
18332 }
18333
18334 func (this *NinOptStruct) Proto() github_com_gogo_protobuf_proto.Message {
18335 return this
18336 }
18337
18338 func (this *NinOptStruct) TestProto() github_com_gogo_protobuf_proto.Message {
18339 return NewNinOptStructFromFace(this)
18340 }
18341
18342 func (this *NinOptStruct) GetField1() *float64 {
18343 return this.Field1
18344 }
18345
18346 func (this *NinOptStruct) GetField2() *float32 {
18347 return this.Field2
18348 }
18349
18350 func (this *NinOptStruct) GetField3() *NidOptNative {
18351 return this.Field3
18352 }
18353
18354 func (this *NinOptStruct) GetField4() *NinOptNative {
18355 return this.Field4
18356 }
18357
18358 func (this *NinOptStruct) GetField6() *uint64 {
18359 return this.Field6
18360 }
18361
18362 func (this *NinOptStruct) GetField7() *int32 {
18363 return this.Field7
18364 }
18365
18366 func (this *NinOptStruct) GetField8() *NidOptNative {
18367 return this.Field8
18368 }
18369
18370 func (this *NinOptStruct) GetField13() *bool {
18371 return this.Field13
18372 }
18373
18374 func (this *NinOptStruct) GetField14() *string {
18375 return this.Field14
18376 }
18377
18378 func (this *NinOptStruct) GetField15() []byte {
18379 return this.Field15
18380 }
18381
18382 func NewNinOptStructFromFace(that NinOptStructFace) *NinOptStruct {
18383 this := &NinOptStruct{}
18384 this.Field1 = that.GetField1()
18385 this.Field2 = that.GetField2()
18386 this.Field3 = that.GetField3()
18387 this.Field4 = that.GetField4()
18388 this.Field6 = that.GetField6()
18389 this.Field7 = that.GetField7()
18390 this.Field8 = that.GetField8()
18391 this.Field13 = that.GetField13()
18392 this.Field14 = that.GetField14()
18393 this.Field15 = that.GetField15()
18394 return this
18395 }
18396
18397 type NidRepStructFace interface {
18398 Proto() github_com_gogo_protobuf_proto.Message
18399 GetField1() []float64
18400 GetField2() []float32
18401 GetField3() []NidOptNative
18402 GetField4() []NinOptNative
18403 GetField6() []uint64
18404 GetField7() []int32
18405 GetField8() []NidOptNative
18406 GetField13() []bool
18407 GetField14() []string
18408 GetField15() [][]byte
18409 }
18410
18411 func (this *NidRepStruct) Proto() github_com_gogo_protobuf_proto.Message {
18412 return this
18413 }
18414
18415 func (this *NidRepStruct) TestProto() github_com_gogo_protobuf_proto.Message {
18416 return NewNidRepStructFromFace(this)
18417 }
18418
18419 func (this *NidRepStruct) GetField1() []float64 {
18420 return this.Field1
18421 }
18422
18423 func (this *NidRepStruct) GetField2() []float32 {
18424 return this.Field2
18425 }
18426
18427 func (this *NidRepStruct) GetField3() []NidOptNative {
18428 return this.Field3
18429 }
18430
18431 func (this *NidRepStruct) GetField4() []NinOptNative {
18432 return this.Field4
18433 }
18434
18435 func (this *NidRepStruct) GetField6() []uint64 {
18436 return this.Field6
18437 }
18438
18439 func (this *NidRepStruct) GetField7() []int32 {
18440 return this.Field7
18441 }
18442
18443 func (this *NidRepStruct) GetField8() []NidOptNative {
18444 return this.Field8
18445 }
18446
18447 func (this *NidRepStruct) GetField13() []bool {
18448 return this.Field13
18449 }
18450
18451 func (this *NidRepStruct) GetField14() []string {
18452 return this.Field14
18453 }
18454
18455 func (this *NidRepStruct) GetField15() [][]byte {
18456 return this.Field15
18457 }
18458
18459 func NewNidRepStructFromFace(that NidRepStructFace) *NidRepStruct {
18460 this := &NidRepStruct{}
18461 this.Field1 = that.GetField1()
18462 this.Field2 = that.GetField2()
18463 this.Field3 = that.GetField3()
18464 this.Field4 = that.GetField4()
18465 this.Field6 = that.GetField6()
18466 this.Field7 = that.GetField7()
18467 this.Field8 = that.GetField8()
18468 this.Field13 = that.GetField13()
18469 this.Field14 = that.GetField14()
18470 this.Field15 = that.GetField15()
18471 return this
18472 }
18473
18474 type NinRepStructFace interface {
18475 Proto() github_com_gogo_protobuf_proto.Message
18476 GetField1() []float64
18477 GetField2() []float32
18478 GetField3() []*NidOptNative
18479 GetField4() []*NinOptNative
18480 GetField6() []uint64
18481 GetField7() []int32
18482 GetField8() []*NidOptNative
18483 GetField13() []bool
18484 GetField14() []string
18485 GetField15() [][]byte
18486 }
18487
18488 func (this *NinRepStruct) Proto() github_com_gogo_protobuf_proto.Message {
18489 return this
18490 }
18491
18492 func (this *NinRepStruct) TestProto() github_com_gogo_protobuf_proto.Message {
18493 return NewNinRepStructFromFace(this)
18494 }
18495
18496 func (this *NinRepStruct) GetField1() []float64 {
18497 return this.Field1
18498 }
18499
18500 func (this *NinRepStruct) GetField2() []float32 {
18501 return this.Field2
18502 }
18503
18504 func (this *NinRepStruct) GetField3() []*NidOptNative {
18505 return this.Field3
18506 }
18507
18508 func (this *NinRepStruct) GetField4() []*NinOptNative {
18509 return this.Field4
18510 }
18511
18512 func (this *NinRepStruct) GetField6() []uint64 {
18513 return this.Field6
18514 }
18515
18516 func (this *NinRepStruct) GetField7() []int32 {
18517 return this.Field7
18518 }
18519
18520 func (this *NinRepStruct) GetField8() []*NidOptNative {
18521 return this.Field8
18522 }
18523
18524 func (this *NinRepStruct) GetField13() []bool {
18525 return this.Field13
18526 }
18527
18528 func (this *NinRepStruct) GetField14() []string {
18529 return this.Field14
18530 }
18531
18532 func (this *NinRepStruct) GetField15() [][]byte {
18533 return this.Field15
18534 }
18535
18536 func NewNinRepStructFromFace(that NinRepStructFace) *NinRepStruct {
18537 this := &NinRepStruct{}
18538 this.Field1 = that.GetField1()
18539 this.Field2 = that.GetField2()
18540 this.Field3 = that.GetField3()
18541 this.Field4 = that.GetField4()
18542 this.Field6 = that.GetField6()
18543 this.Field7 = that.GetField7()
18544 this.Field8 = that.GetField8()
18545 this.Field13 = that.GetField13()
18546 this.Field14 = that.GetField14()
18547 this.Field15 = that.GetField15()
18548 return this
18549 }
18550
18551 type NidEmbeddedStructFace interface {
18552 Proto() github_com_gogo_protobuf_proto.Message
18553 GetNidOptNative() *NidOptNative
18554 GetField200() NidOptNative
18555 GetField210() bool
18556 }
18557
18558 func (this *NidEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message {
18559 return this
18560 }
18561
18562 func (this *NidEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message {
18563 return NewNidEmbeddedStructFromFace(this)
18564 }
18565
18566 func (this *NidEmbeddedStruct) GetNidOptNative() *NidOptNative {
18567 return this.NidOptNative
18568 }
18569
18570 func (this *NidEmbeddedStruct) GetField200() NidOptNative {
18571 return this.Field200
18572 }
18573
18574 func (this *NidEmbeddedStruct) GetField210() bool {
18575 return this.Field210
18576 }
18577
18578 func NewNidEmbeddedStructFromFace(that NidEmbeddedStructFace) *NidEmbeddedStruct {
18579 this := &NidEmbeddedStruct{}
18580 this.NidOptNative = that.GetNidOptNative()
18581 this.Field200 = that.GetField200()
18582 this.Field210 = that.GetField210()
18583 return this
18584 }
18585
18586 type NinEmbeddedStructFace interface {
18587 Proto() github_com_gogo_protobuf_proto.Message
18588 GetNidOptNative() *NidOptNative
18589 GetField200() *NidOptNative
18590 GetField210() *bool
18591 }
18592
18593 func (this *NinEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message {
18594 return this
18595 }
18596
18597 func (this *NinEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message {
18598 return NewNinEmbeddedStructFromFace(this)
18599 }
18600
18601 func (this *NinEmbeddedStruct) GetNidOptNative() *NidOptNative {
18602 return this.NidOptNative
18603 }
18604
18605 func (this *NinEmbeddedStruct) GetField200() *NidOptNative {
18606 return this.Field200
18607 }
18608
18609 func (this *NinEmbeddedStruct) GetField210() *bool {
18610 return this.Field210
18611 }
18612
18613 func NewNinEmbeddedStructFromFace(that NinEmbeddedStructFace) *NinEmbeddedStruct {
18614 this := &NinEmbeddedStruct{}
18615 this.NidOptNative = that.GetNidOptNative()
18616 this.Field200 = that.GetField200()
18617 this.Field210 = that.GetField210()
18618 return this
18619 }
18620
18621 type NidNestedStructFace interface {
18622 Proto() github_com_gogo_protobuf_proto.Message
18623 GetField1() NidOptStruct
18624 GetField2() []NidRepStruct
18625 }
18626
18627 func (this *NidNestedStruct) Proto() github_com_gogo_protobuf_proto.Message {
18628 return this
18629 }
18630
18631 func (this *NidNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message {
18632 return NewNidNestedStructFromFace(this)
18633 }
18634
18635 func (this *NidNestedStruct) GetField1() NidOptStruct {
18636 return this.Field1
18637 }
18638
18639 func (this *NidNestedStruct) GetField2() []NidRepStruct {
18640 return this.Field2
18641 }
18642
18643 func NewNidNestedStructFromFace(that NidNestedStructFace) *NidNestedStruct {
18644 this := &NidNestedStruct{}
18645 this.Field1 = that.GetField1()
18646 this.Field2 = that.GetField2()
18647 return this
18648 }
18649
18650 type NinNestedStructFace interface {
18651 Proto() github_com_gogo_protobuf_proto.Message
18652 GetField1() *NinOptStruct
18653 GetField2() []*NinRepStruct
18654 }
18655
18656 func (this *NinNestedStruct) Proto() github_com_gogo_protobuf_proto.Message {
18657 return this
18658 }
18659
18660 func (this *NinNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message {
18661 return NewNinNestedStructFromFace(this)
18662 }
18663
18664 func (this *NinNestedStruct) GetField1() *NinOptStruct {
18665 return this.Field1
18666 }
18667
18668 func (this *NinNestedStruct) GetField2() []*NinRepStruct {
18669 return this.Field2
18670 }
18671
18672 func NewNinNestedStructFromFace(that NinNestedStructFace) *NinNestedStruct {
18673 this := &NinNestedStruct{}
18674 this.Field1 = that.GetField1()
18675 this.Field2 = that.GetField2()
18676 return this
18677 }
18678
18679 type NidOptCustomFace interface {
18680 Proto() github_com_gogo_protobuf_proto.Message
18681 GetId() Uuid
18682 GetValue() github_com_gogo_protobuf_test_custom.Uint128
18683 }
18684
18685 func (this *NidOptCustom) Proto() github_com_gogo_protobuf_proto.Message {
18686 return this
18687 }
18688
18689 func (this *NidOptCustom) TestProto() github_com_gogo_protobuf_proto.Message {
18690 return NewNidOptCustomFromFace(this)
18691 }
18692
18693 func (this *NidOptCustom) GetId() Uuid {
18694 return this.Id
18695 }
18696
18697 func (this *NidOptCustom) GetValue() github_com_gogo_protobuf_test_custom.Uint128 {
18698 return this.Value
18699 }
18700
18701 func NewNidOptCustomFromFace(that NidOptCustomFace) *NidOptCustom {
18702 this := &NidOptCustom{}
18703 this.Id = that.GetId()
18704 this.Value = that.GetValue()
18705 return this
18706 }
18707
18708 type CustomDashFace interface {
18709 Proto() github_com_gogo_protobuf_proto.Message
18710 GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes
18711 }
18712
18713 func (this *CustomDash) Proto() github_com_gogo_protobuf_proto.Message {
18714 return this
18715 }
18716
18717 func (this *CustomDash) TestProto() github_com_gogo_protobuf_proto.Message {
18718 return NewCustomDashFromFace(this)
18719 }
18720
18721 func (this *CustomDash) GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes {
18722 return this.Value
18723 }
18724
18725 func NewCustomDashFromFace(that CustomDashFace) *CustomDash {
18726 this := &CustomDash{}
18727 this.Value = that.GetValue()
18728 return this
18729 }
18730
18731 type NinOptCustomFace interface {
18732 Proto() github_com_gogo_protobuf_proto.Message
18733 GetId() *Uuid
18734 GetValue() *github_com_gogo_protobuf_test_custom.Uint128
18735 }
18736
18737 func (this *NinOptCustom) Proto() github_com_gogo_protobuf_proto.Message {
18738 return this
18739 }
18740
18741 func (this *NinOptCustom) TestProto() github_com_gogo_protobuf_proto.Message {
18742 return NewNinOptCustomFromFace(this)
18743 }
18744
18745 func (this *NinOptCustom) GetId() *Uuid {
18746 return this.Id
18747 }
18748
18749 func (this *NinOptCustom) GetValue() *github_com_gogo_protobuf_test_custom.Uint128 {
18750 return this.Value
18751 }
18752
18753 func NewNinOptCustomFromFace(that NinOptCustomFace) *NinOptCustom {
18754 this := &NinOptCustom{}
18755 this.Id = that.GetId()
18756 this.Value = that.GetValue()
18757 return this
18758 }
18759
18760 type NidRepCustomFace interface {
18761 Proto() github_com_gogo_protobuf_proto.Message
18762 GetId() []Uuid
18763 GetValue() []github_com_gogo_protobuf_test_custom.Uint128
18764 }
18765
18766 func (this *NidRepCustom) Proto() github_com_gogo_protobuf_proto.Message {
18767 return this
18768 }
18769
18770 func (this *NidRepCustom) TestProto() github_com_gogo_protobuf_proto.Message {
18771 return NewNidRepCustomFromFace(this)
18772 }
18773
18774 func (this *NidRepCustom) GetId() []Uuid {
18775 return this.Id
18776 }
18777
18778 func (this *NidRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 {
18779 return this.Value
18780 }
18781
18782 func NewNidRepCustomFromFace(that NidRepCustomFace) *NidRepCustom {
18783 this := &NidRepCustom{}
18784 this.Id = that.GetId()
18785 this.Value = that.GetValue()
18786 return this
18787 }
18788
18789 type NinRepCustomFace interface {
18790 Proto() github_com_gogo_protobuf_proto.Message
18791 GetId() []Uuid
18792 GetValue() []github_com_gogo_protobuf_test_custom.Uint128
18793 }
18794
18795 func (this *NinRepCustom) Proto() github_com_gogo_protobuf_proto.Message {
18796 return this
18797 }
18798
18799 func (this *NinRepCustom) TestProto() github_com_gogo_protobuf_proto.Message {
18800 return NewNinRepCustomFromFace(this)
18801 }
18802
18803 func (this *NinRepCustom) GetId() []Uuid {
18804 return this.Id
18805 }
18806
18807 func (this *NinRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 {
18808 return this.Value
18809 }
18810
18811 func NewNinRepCustomFromFace(that NinRepCustomFace) *NinRepCustom {
18812 this := &NinRepCustom{}
18813 this.Id = that.GetId()
18814 this.Value = that.GetValue()
18815 return this
18816 }
18817
18818 type NinOptNativeUnionFace interface {
18819 Proto() github_com_gogo_protobuf_proto.Message
18820 GetField1() *float64
18821 GetField2() *float32
18822 GetField3() *int32
18823 GetField4() *int64
18824 GetField5() *uint32
18825 GetField6() *uint64
18826 GetField13() *bool
18827 GetField14() *string
18828 GetField15() []byte
18829 }
18830
18831 func (this *NinOptNativeUnion) Proto() github_com_gogo_protobuf_proto.Message {
18832 return this
18833 }
18834
18835 func (this *NinOptNativeUnion) TestProto() github_com_gogo_protobuf_proto.Message {
18836 return NewNinOptNativeUnionFromFace(this)
18837 }
18838
18839 func (this *NinOptNativeUnion) GetField1() *float64 {
18840 return this.Field1
18841 }
18842
18843 func (this *NinOptNativeUnion) GetField2() *float32 {
18844 return this.Field2
18845 }
18846
18847 func (this *NinOptNativeUnion) GetField3() *int32 {
18848 return this.Field3
18849 }
18850
18851 func (this *NinOptNativeUnion) GetField4() *int64 {
18852 return this.Field4
18853 }
18854
18855 func (this *NinOptNativeUnion) GetField5() *uint32 {
18856 return this.Field5
18857 }
18858
18859 func (this *NinOptNativeUnion) GetField6() *uint64 {
18860 return this.Field6
18861 }
18862
18863 func (this *NinOptNativeUnion) GetField13() *bool {
18864 return this.Field13
18865 }
18866
18867 func (this *NinOptNativeUnion) GetField14() *string {
18868 return this.Field14
18869 }
18870
18871 func (this *NinOptNativeUnion) GetField15() []byte {
18872 return this.Field15
18873 }
18874
18875 func NewNinOptNativeUnionFromFace(that NinOptNativeUnionFace) *NinOptNativeUnion {
18876 this := &NinOptNativeUnion{}
18877 this.Field1 = that.GetField1()
18878 this.Field2 = that.GetField2()
18879 this.Field3 = that.GetField3()
18880 this.Field4 = that.GetField4()
18881 this.Field5 = that.GetField5()
18882 this.Field6 = that.GetField6()
18883 this.Field13 = that.GetField13()
18884 this.Field14 = that.GetField14()
18885 this.Field15 = that.GetField15()
18886 return this
18887 }
18888
18889 type NinOptStructUnionFace interface {
18890 Proto() github_com_gogo_protobuf_proto.Message
18891 GetField1() *float64
18892 GetField2() *float32
18893 GetField3() *NidOptNative
18894 GetField4() *NinOptNative
18895 GetField6() *uint64
18896 GetField7() *int32
18897 GetField13() *bool
18898 GetField14() *string
18899 GetField15() []byte
18900 }
18901
18902 func (this *NinOptStructUnion) Proto() github_com_gogo_protobuf_proto.Message {
18903 return this
18904 }
18905
18906 func (this *NinOptStructUnion) TestProto() github_com_gogo_protobuf_proto.Message {
18907 return NewNinOptStructUnionFromFace(this)
18908 }
18909
18910 func (this *NinOptStructUnion) GetField1() *float64 {
18911 return this.Field1
18912 }
18913
18914 func (this *NinOptStructUnion) GetField2() *float32 {
18915 return this.Field2
18916 }
18917
18918 func (this *NinOptStructUnion) GetField3() *NidOptNative {
18919 return this.Field3
18920 }
18921
18922 func (this *NinOptStructUnion) GetField4() *NinOptNative {
18923 return this.Field4
18924 }
18925
18926 func (this *NinOptStructUnion) GetField6() *uint64 {
18927 return this.Field6
18928 }
18929
18930 func (this *NinOptStructUnion) GetField7() *int32 {
18931 return this.Field7
18932 }
18933
18934 func (this *NinOptStructUnion) GetField13() *bool {
18935 return this.Field13
18936 }
18937
18938 func (this *NinOptStructUnion) GetField14() *string {
18939 return this.Field14
18940 }
18941
18942 func (this *NinOptStructUnion) GetField15() []byte {
18943 return this.Field15
18944 }
18945
18946 func NewNinOptStructUnionFromFace(that NinOptStructUnionFace) *NinOptStructUnion {
18947 this := &NinOptStructUnion{}
18948 this.Field1 = that.GetField1()
18949 this.Field2 = that.GetField2()
18950 this.Field3 = that.GetField3()
18951 this.Field4 = that.GetField4()
18952 this.Field6 = that.GetField6()
18953 this.Field7 = that.GetField7()
18954 this.Field13 = that.GetField13()
18955 this.Field14 = that.GetField14()
18956 this.Field15 = that.GetField15()
18957 return this
18958 }
18959
18960 type NinEmbeddedStructUnionFace interface {
18961 Proto() github_com_gogo_protobuf_proto.Message
18962 GetNidOptNative() *NidOptNative
18963 GetField200() *NinOptNative
18964 GetField210() *bool
18965 }
18966
18967 func (this *NinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message {
18968 return this
18969 }
18970
18971 func (this *NinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message {
18972 return NewNinEmbeddedStructUnionFromFace(this)
18973 }
18974
18975 func (this *NinEmbeddedStructUnion) GetNidOptNative() *NidOptNative {
18976 return this.NidOptNative
18977 }
18978
18979 func (this *NinEmbeddedStructUnion) GetField200() *NinOptNative {
18980 return this.Field200
18981 }
18982
18983 func (this *NinEmbeddedStructUnion) GetField210() *bool {
18984 return this.Field210
18985 }
18986
18987 func NewNinEmbeddedStructUnionFromFace(that NinEmbeddedStructUnionFace) *NinEmbeddedStructUnion {
18988 this := &NinEmbeddedStructUnion{}
18989 this.NidOptNative = that.GetNidOptNative()
18990 this.Field200 = that.GetField200()
18991 this.Field210 = that.GetField210()
18992 return this
18993 }
18994
18995 type NinNestedStructUnionFace interface {
18996 Proto() github_com_gogo_protobuf_proto.Message
18997 GetField1() *NinOptNativeUnion
18998 GetField2() *NinOptStructUnion
18999 GetField3() *NinEmbeddedStructUnion
19000 }
19001
19002 func (this *NinNestedStructUnion) Proto() github_com_gogo_protobuf_proto.Message {
19003 return this
19004 }
19005
19006 func (this *NinNestedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message {
19007 return NewNinNestedStructUnionFromFace(this)
19008 }
19009
19010 func (this *NinNestedStructUnion) GetField1() *NinOptNativeUnion {
19011 return this.Field1
19012 }
19013
19014 func (this *NinNestedStructUnion) GetField2() *NinOptStructUnion {
19015 return this.Field2
19016 }
19017
19018 func (this *NinNestedStructUnion) GetField3() *NinEmbeddedStructUnion {
19019 return this.Field3
19020 }
19021
19022 func NewNinNestedStructUnionFromFace(that NinNestedStructUnionFace) *NinNestedStructUnion {
19023 this := &NinNestedStructUnion{}
19024 this.Field1 = that.GetField1()
19025 this.Field2 = that.GetField2()
19026 this.Field3 = that.GetField3()
19027 return this
19028 }
19029
19030 type TreeFace interface {
19031 Proto() github_com_gogo_protobuf_proto.Message
19032 GetOr() *OrBranch
19033 GetAnd() *AndBranch
19034 GetLeaf() *Leaf
19035 }
19036
19037 func (this *Tree) Proto() github_com_gogo_protobuf_proto.Message {
19038 return this
19039 }
19040
19041 func (this *Tree) TestProto() github_com_gogo_protobuf_proto.Message {
19042 return NewTreeFromFace(this)
19043 }
19044
19045 func (this *Tree) GetOr() *OrBranch {
19046 return this.Or
19047 }
19048
19049 func (this *Tree) GetAnd() *AndBranch {
19050 return this.And
19051 }
19052
19053 func (this *Tree) GetLeaf() *Leaf {
19054 return this.Leaf
19055 }
19056
19057 func NewTreeFromFace(that TreeFace) *Tree {
19058 this := &Tree{}
19059 this.Or = that.GetOr()
19060 this.And = that.GetAnd()
19061 this.Leaf = that.GetLeaf()
19062 return this
19063 }
19064
19065 type OrBranchFace interface {
19066 Proto() github_com_gogo_protobuf_proto.Message
19067 GetLeft() Tree
19068 GetRight() Tree
19069 }
19070
19071 func (this *OrBranch) Proto() github_com_gogo_protobuf_proto.Message {
19072 return this
19073 }
19074
19075 func (this *OrBranch) TestProto() github_com_gogo_protobuf_proto.Message {
19076 return NewOrBranchFromFace(this)
19077 }
19078
19079 func (this *OrBranch) GetLeft() Tree {
19080 return this.Left
19081 }
19082
19083 func (this *OrBranch) GetRight() Tree {
19084 return this.Right
19085 }
19086
19087 func NewOrBranchFromFace(that OrBranchFace) *OrBranch {
19088 this := &OrBranch{}
19089 this.Left = that.GetLeft()
19090 this.Right = that.GetRight()
19091 return this
19092 }
19093
19094 type AndBranchFace interface {
19095 Proto() github_com_gogo_protobuf_proto.Message
19096 GetLeft() Tree
19097 GetRight() Tree
19098 }
19099
19100 func (this *AndBranch) Proto() github_com_gogo_protobuf_proto.Message {
19101 return this
19102 }
19103
19104 func (this *AndBranch) TestProto() github_com_gogo_protobuf_proto.Message {
19105 return NewAndBranchFromFace(this)
19106 }
19107
19108 func (this *AndBranch) GetLeft() Tree {
19109 return this.Left
19110 }
19111
19112 func (this *AndBranch) GetRight() Tree {
19113 return this.Right
19114 }
19115
19116 func NewAndBranchFromFace(that AndBranchFace) *AndBranch {
19117 this := &AndBranch{}
19118 this.Left = that.GetLeft()
19119 this.Right = that.GetRight()
19120 return this
19121 }
19122
19123 type LeafFace interface {
19124 Proto() github_com_gogo_protobuf_proto.Message
19125 GetValue() int64
19126 GetStrValue() string
19127 }
19128
19129 func (this *Leaf) Proto() github_com_gogo_protobuf_proto.Message {
19130 return this
19131 }
19132
19133 func (this *Leaf) TestProto() github_com_gogo_protobuf_proto.Message {
19134 return NewLeafFromFace(this)
19135 }
19136
19137 func (this *Leaf) GetValue() int64 {
19138 return this.Value
19139 }
19140
19141 func (this *Leaf) GetStrValue() string {
19142 return this.StrValue
19143 }
19144
19145 func NewLeafFromFace(that LeafFace) *Leaf {
19146 this := &Leaf{}
19147 this.Value = that.GetValue()
19148 this.StrValue = that.GetStrValue()
19149 return this
19150 }
19151
19152 type DeepTreeFace interface {
19153 Proto() github_com_gogo_protobuf_proto.Message
19154 GetDown() *ADeepBranch
19155 GetAnd() *AndDeepBranch
19156 GetLeaf() *DeepLeaf
19157 }
19158
19159 func (this *DeepTree) Proto() github_com_gogo_protobuf_proto.Message {
19160 return this
19161 }
19162
19163 func (this *DeepTree) TestProto() github_com_gogo_protobuf_proto.Message {
19164 return NewDeepTreeFromFace(this)
19165 }
19166
19167 func (this *DeepTree) GetDown() *ADeepBranch {
19168 return this.Down
19169 }
19170
19171 func (this *DeepTree) GetAnd() *AndDeepBranch {
19172 return this.And
19173 }
19174
19175 func (this *DeepTree) GetLeaf() *DeepLeaf {
19176 return this.Leaf
19177 }
19178
19179 func NewDeepTreeFromFace(that DeepTreeFace) *DeepTree {
19180 this := &DeepTree{}
19181 this.Down = that.GetDown()
19182 this.And = that.GetAnd()
19183 this.Leaf = that.GetLeaf()
19184 return this
19185 }
19186
19187 type ADeepBranchFace interface {
19188 Proto() github_com_gogo_protobuf_proto.Message
19189 GetDown() DeepTree
19190 }
19191
19192 func (this *ADeepBranch) Proto() github_com_gogo_protobuf_proto.Message {
19193 return this
19194 }
19195
19196 func (this *ADeepBranch) TestProto() github_com_gogo_protobuf_proto.Message {
19197 return NewADeepBranchFromFace(this)
19198 }
19199
19200 func (this *ADeepBranch) GetDown() DeepTree {
19201 return this.Down
19202 }
19203
19204 func NewADeepBranchFromFace(that ADeepBranchFace) *ADeepBranch {
19205 this := &ADeepBranch{}
19206 this.Down = that.GetDown()
19207 return this
19208 }
19209
19210 type AndDeepBranchFace interface {
19211 Proto() github_com_gogo_protobuf_proto.Message
19212 GetLeft() DeepTree
19213 GetRight() DeepTree
19214 }
19215
19216 func (this *AndDeepBranch) Proto() github_com_gogo_protobuf_proto.Message {
19217 return this
19218 }
19219
19220 func (this *AndDeepBranch) TestProto() github_com_gogo_protobuf_proto.Message {
19221 return NewAndDeepBranchFromFace(this)
19222 }
19223
19224 func (this *AndDeepBranch) GetLeft() DeepTree {
19225 return this.Left
19226 }
19227
19228 func (this *AndDeepBranch) GetRight() DeepTree {
19229 return this.Right
19230 }
19231
19232 func NewAndDeepBranchFromFace(that AndDeepBranchFace) *AndDeepBranch {
19233 this := &AndDeepBranch{}
19234 this.Left = that.GetLeft()
19235 this.Right = that.GetRight()
19236 return this
19237 }
19238
19239 type DeepLeafFace interface {
19240 Proto() github_com_gogo_protobuf_proto.Message
19241 GetTree() Tree
19242 }
19243
19244 func (this *DeepLeaf) Proto() github_com_gogo_protobuf_proto.Message {
19245 return this
19246 }
19247
19248 func (this *DeepLeaf) TestProto() github_com_gogo_protobuf_proto.Message {
19249 return NewDeepLeafFromFace(this)
19250 }
19251
19252 func (this *DeepLeaf) GetTree() Tree {
19253 return this.Tree
19254 }
19255
19256 func NewDeepLeafFromFace(that DeepLeafFace) *DeepLeaf {
19257 this := &DeepLeaf{}
19258 this.Tree = that.GetTree()
19259 return this
19260 }
19261
19262 type NilFace interface {
19263 Proto() github_com_gogo_protobuf_proto.Message
19264 }
19265
19266 func (this *Nil) Proto() github_com_gogo_protobuf_proto.Message {
19267 return this
19268 }
19269
19270 func (this *Nil) TestProto() github_com_gogo_protobuf_proto.Message {
19271 return NewNilFromFace(this)
19272 }
19273
19274 func NewNilFromFace(that NilFace) *Nil {
19275 this := &Nil{}
19276 return this
19277 }
19278
19279 type NidOptEnumFace interface {
19280 Proto() github_com_gogo_protobuf_proto.Message
19281 GetField1() TheTestEnum
19282 }
19283
19284 func (this *NidOptEnum) Proto() github_com_gogo_protobuf_proto.Message {
19285 return this
19286 }
19287
19288 func (this *NidOptEnum) TestProto() github_com_gogo_protobuf_proto.Message {
19289 return NewNidOptEnumFromFace(this)
19290 }
19291
19292 func (this *NidOptEnum) GetField1() TheTestEnum {
19293 return this.Field1
19294 }
19295
19296 func NewNidOptEnumFromFace(that NidOptEnumFace) *NidOptEnum {
19297 this := &NidOptEnum{}
19298 this.Field1 = that.GetField1()
19299 return this
19300 }
19301
19302 type NinOptEnumFace interface {
19303 Proto() github_com_gogo_protobuf_proto.Message
19304 GetField1() *TheTestEnum
19305 GetField2() *YetAnotherTestEnum
19306 GetField3() *YetYetAnotherTestEnum
19307 }
19308
19309 func (this *NinOptEnum) Proto() github_com_gogo_protobuf_proto.Message {
19310 return this
19311 }
19312
19313 func (this *NinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message {
19314 return NewNinOptEnumFromFace(this)
19315 }
19316
19317 func (this *NinOptEnum) GetField1() *TheTestEnum {
19318 return this.Field1
19319 }
19320
19321 func (this *NinOptEnum) GetField2() *YetAnotherTestEnum {
19322 return this.Field2
19323 }
19324
19325 func (this *NinOptEnum) GetField3() *YetYetAnotherTestEnum {
19326 return this.Field3
19327 }
19328
19329 func NewNinOptEnumFromFace(that NinOptEnumFace) *NinOptEnum {
19330 this := &NinOptEnum{}
19331 this.Field1 = that.GetField1()
19332 this.Field2 = that.GetField2()
19333 this.Field3 = that.GetField3()
19334 return this
19335 }
19336
19337 type NidRepEnumFace interface {
19338 Proto() github_com_gogo_protobuf_proto.Message
19339 GetField1() []TheTestEnum
19340 GetField2() []YetAnotherTestEnum
19341 GetField3() []YetYetAnotherTestEnum
19342 }
19343
19344 func (this *NidRepEnum) Proto() github_com_gogo_protobuf_proto.Message {
19345 return this
19346 }
19347
19348 func (this *NidRepEnum) TestProto() github_com_gogo_protobuf_proto.Message {
19349 return NewNidRepEnumFromFace(this)
19350 }
19351
19352 func (this *NidRepEnum) GetField1() []TheTestEnum {
19353 return this.Field1
19354 }
19355
19356 func (this *NidRepEnum) GetField2() []YetAnotherTestEnum {
19357 return this.Field2
19358 }
19359
19360 func (this *NidRepEnum) GetField3() []YetYetAnotherTestEnum {
19361 return this.Field3
19362 }
19363
19364 func NewNidRepEnumFromFace(that NidRepEnumFace) *NidRepEnum {
19365 this := &NidRepEnum{}
19366 this.Field1 = that.GetField1()
19367 this.Field2 = that.GetField2()
19368 this.Field3 = that.GetField3()
19369 return this
19370 }
19371
19372 type NinRepEnumFace interface {
19373 Proto() github_com_gogo_protobuf_proto.Message
19374 GetField1() []TheTestEnum
19375 GetField2() []YetAnotherTestEnum
19376 GetField3() []YetYetAnotherTestEnum
19377 }
19378
19379 func (this *NinRepEnum) Proto() github_com_gogo_protobuf_proto.Message {
19380 return this
19381 }
19382
19383 func (this *NinRepEnum) TestProto() github_com_gogo_protobuf_proto.Message {
19384 return NewNinRepEnumFromFace(this)
19385 }
19386
19387 func (this *NinRepEnum) GetField1() []TheTestEnum {
19388 return this.Field1
19389 }
19390
19391 func (this *NinRepEnum) GetField2() []YetAnotherTestEnum {
19392 return this.Field2
19393 }
19394
19395 func (this *NinRepEnum) GetField3() []YetYetAnotherTestEnum {
19396 return this.Field3
19397 }
19398
19399 func NewNinRepEnumFromFace(that NinRepEnumFace) *NinRepEnum {
19400 this := &NinRepEnum{}
19401 this.Field1 = that.GetField1()
19402 this.Field2 = that.GetField2()
19403 this.Field3 = that.GetField3()
19404 return this
19405 }
19406
19407 type AnotherNinOptEnumFace interface {
19408 Proto() github_com_gogo_protobuf_proto.Message
19409 GetField1() *AnotherTestEnum
19410 GetField2() *YetAnotherTestEnum
19411 GetField3() *YetYetAnotherTestEnum
19412 }
19413
19414 func (this *AnotherNinOptEnum) Proto() github_com_gogo_protobuf_proto.Message {
19415 return this
19416 }
19417
19418 func (this *AnotherNinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message {
19419 return NewAnotherNinOptEnumFromFace(this)
19420 }
19421
19422 func (this *AnotherNinOptEnum) GetField1() *AnotherTestEnum {
19423 return this.Field1
19424 }
19425
19426 func (this *AnotherNinOptEnum) GetField2() *YetAnotherTestEnum {
19427 return this.Field2
19428 }
19429
19430 func (this *AnotherNinOptEnum) GetField3() *YetYetAnotherTestEnum {
19431 return this.Field3
19432 }
19433
19434 func NewAnotherNinOptEnumFromFace(that AnotherNinOptEnumFace) *AnotherNinOptEnum {
19435 this := &AnotherNinOptEnum{}
19436 this.Field1 = that.GetField1()
19437 this.Field2 = that.GetField2()
19438 this.Field3 = that.GetField3()
19439 return this
19440 }
19441
19442 type TimerFace interface {
19443 Proto() github_com_gogo_protobuf_proto.Message
19444 GetTime1() int64
19445 GetTime2() int64
19446 GetData() []byte
19447 }
19448
19449 func (this *Timer) Proto() github_com_gogo_protobuf_proto.Message {
19450 return this
19451 }
19452
19453 func (this *Timer) TestProto() github_com_gogo_protobuf_proto.Message {
19454 return NewTimerFromFace(this)
19455 }
19456
19457 func (this *Timer) GetTime1() int64 {
19458 return this.Time1
19459 }
19460
19461 func (this *Timer) GetTime2() int64 {
19462 return this.Time2
19463 }
19464
19465 func (this *Timer) GetData() []byte {
19466 return this.Data
19467 }
19468
19469 func NewTimerFromFace(that TimerFace) *Timer {
19470 this := &Timer{}
19471 this.Time1 = that.GetTime1()
19472 this.Time2 = that.GetTime2()
19473 this.Data = that.GetData()
19474 return this
19475 }
19476
19477 type NestedDefinitionFace interface {
19478 Proto() github_com_gogo_protobuf_proto.Message
19479 GetField1() *int64
19480 GetEnumField() *NestedDefinition_NestedEnum
19481 GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg
19482 GetNM() *NestedDefinition_NestedMessage
19483 }
19484
19485 func (this *NestedDefinition) Proto() github_com_gogo_protobuf_proto.Message {
19486 return this
19487 }
19488
19489 func (this *NestedDefinition) TestProto() github_com_gogo_protobuf_proto.Message {
19490 return NewNestedDefinitionFromFace(this)
19491 }
19492
19493 func (this *NestedDefinition) GetField1() *int64 {
19494 return this.Field1
19495 }
19496
19497 func (this *NestedDefinition) GetEnumField() *NestedDefinition_NestedEnum {
19498 return this.EnumField
19499 }
19500
19501 func (this *NestedDefinition) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg {
19502 return this.NNM
19503 }
19504
19505 func (this *NestedDefinition) GetNM() *NestedDefinition_NestedMessage {
19506 return this.NM
19507 }
19508
19509 func NewNestedDefinitionFromFace(that NestedDefinitionFace) *NestedDefinition {
19510 this := &NestedDefinition{}
19511 this.Field1 = that.GetField1()
19512 this.EnumField = that.GetEnumField()
19513 this.NNM = that.GetNNM()
19514 this.NM = that.GetNM()
19515 return this
19516 }
19517
19518 type NestedDefinition_NestedMessageFace interface {
19519 Proto() github_com_gogo_protobuf_proto.Message
19520 GetNestedField1() *uint64
19521 GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg
19522 }
19523
19524 func (this *NestedDefinition_NestedMessage) Proto() github_com_gogo_protobuf_proto.Message {
19525 return this
19526 }
19527
19528 func (this *NestedDefinition_NestedMessage) TestProto() github_com_gogo_protobuf_proto.Message {
19529 return NewNestedDefinition_NestedMessageFromFace(this)
19530 }
19531
19532 func (this *NestedDefinition_NestedMessage) GetNestedField1() *uint64 {
19533 return this.NestedField1
19534 }
19535
19536 func (this *NestedDefinition_NestedMessage) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg {
19537 return this.NNM
19538 }
19539
19540 func NewNestedDefinition_NestedMessageFromFace(that NestedDefinition_NestedMessageFace) *NestedDefinition_NestedMessage {
19541 this := &NestedDefinition_NestedMessage{}
19542 this.NestedField1 = that.GetNestedField1()
19543 this.NNM = that.GetNNM()
19544 return this
19545 }
19546
19547 type NestedDefinition_NestedMessage_NestedNestedMsgFace interface {
19548 Proto() github_com_gogo_protobuf_proto.Message
19549 GetNestedNestedField1() *string
19550 }
19551
19552 func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Proto() github_com_gogo_protobuf_proto.Message {
19553 return this
19554 }
19555
19556 func (this *NestedDefinition_NestedMessage_NestedNestedMsg) TestProto() github_com_gogo_protobuf_proto.Message {
19557 return NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(this)
19558 }
19559
19560 func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GetNestedNestedField1() *string {
19561 return this.NestedNestedField1
19562 }
19563
19564 func NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(that NestedDefinition_NestedMessage_NestedNestedMsgFace) *NestedDefinition_NestedMessage_NestedNestedMsg {
19565 this := &NestedDefinition_NestedMessage_NestedNestedMsg{}
19566 this.NestedNestedField1 = that.GetNestedNestedField1()
19567 return this
19568 }
19569
19570 type NestedScopeFace interface {
19571 Proto() github_com_gogo_protobuf_proto.Message
19572 GetA() *NestedDefinition_NestedMessage_NestedNestedMsg
19573 GetB() *NestedDefinition_NestedEnum
19574 GetC() *NestedDefinition_NestedMessage
19575 }
19576
19577 func (this *NestedScope) Proto() github_com_gogo_protobuf_proto.Message {
19578 return this
19579 }
19580
19581 func (this *NestedScope) TestProto() github_com_gogo_protobuf_proto.Message {
19582 return NewNestedScopeFromFace(this)
19583 }
19584
19585 func (this *NestedScope) GetA() *NestedDefinition_NestedMessage_NestedNestedMsg {
19586 return this.A
19587 }
19588
19589 func (this *NestedScope) GetB() *NestedDefinition_NestedEnum {
19590 return this.B
19591 }
19592
19593 func (this *NestedScope) GetC() *NestedDefinition_NestedMessage {
19594 return this.C
19595 }
19596
19597 func NewNestedScopeFromFace(that NestedScopeFace) *NestedScope {
19598 this := &NestedScope{}
19599 this.A = that.GetA()
19600 this.B = that.GetB()
19601 this.C = that.GetC()
19602 return this
19603 }
19604
19605 type CustomContainerFace interface {
19606 Proto() github_com_gogo_protobuf_proto.Message
19607 GetCustomStruct() NidOptCustom
19608 }
19609
19610 func (this *CustomContainer) Proto() github_com_gogo_protobuf_proto.Message {
19611 return this
19612 }
19613
19614 func (this *CustomContainer) TestProto() github_com_gogo_protobuf_proto.Message {
19615 return NewCustomContainerFromFace(this)
19616 }
19617
19618 func (this *CustomContainer) GetCustomStruct() NidOptCustom {
19619 return this.CustomStruct
19620 }
19621
19622 func NewCustomContainerFromFace(that CustomContainerFace) *CustomContainer {
19623 this := &CustomContainer{}
19624 this.CustomStruct = that.GetCustomStruct()
19625 return this
19626 }
19627
19628 type CustomNameNidOptNativeFace interface {
19629 Proto() github_com_gogo_protobuf_proto.Message
19630 GetFieldA() float64
19631 GetFieldB() float32
19632 GetFieldC() int32
19633 GetFieldD() int64
19634 GetFieldE() uint32
19635 GetFieldF() uint64
19636 GetFieldG() int32
19637 GetFieldH() int64
19638 GetFieldI() uint32
19639 GetFieldJ() int32
19640 GetFieldK() uint64
19641 GetFieldL() int64
19642 GetFieldM() bool
19643 GetFieldN() string
19644 GetFieldO() []byte
19645 }
19646
19647 func (this *CustomNameNidOptNative) Proto() github_com_gogo_protobuf_proto.Message {
19648 return this
19649 }
19650
19651 func (this *CustomNameNidOptNative) TestProto() github_com_gogo_protobuf_proto.Message {
19652 return NewCustomNameNidOptNativeFromFace(this)
19653 }
19654
19655 func (this *CustomNameNidOptNative) GetFieldA() float64 {
19656 return this.FieldA
19657 }
19658
19659 func (this *CustomNameNidOptNative) GetFieldB() float32 {
19660 return this.FieldB
19661 }
19662
19663 func (this *CustomNameNidOptNative) GetFieldC() int32 {
19664 return this.FieldC
19665 }
19666
19667 func (this *CustomNameNidOptNative) GetFieldD() int64 {
19668 return this.FieldD
19669 }
19670
19671 func (this *CustomNameNidOptNative) GetFieldE() uint32 {
19672 return this.FieldE
19673 }
19674
19675 func (this *CustomNameNidOptNative) GetFieldF() uint64 {
19676 return this.FieldF
19677 }
19678
19679 func (this *CustomNameNidOptNative) GetFieldG() int32 {
19680 return this.FieldG
19681 }
19682
19683 func (this *CustomNameNidOptNative) GetFieldH() int64 {
19684 return this.FieldH
19685 }
19686
19687 func (this *CustomNameNidOptNative) GetFieldI() uint32 {
19688 return this.FieldI
19689 }
19690
19691 func (this *CustomNameNidOptNative) GetFieldJ() int32 {
19692 return this.FieldJ
19693 }
19694
19695 func (this *CustomNameNidOptNative) GetFieldK() uint64 {
19696 return this.FieldK
19697 }
19698
19699 func (this *CustomNameNidOptNative) GetFieldL() int64 {
19700 return this.FieldL
19701 }
19702
19703 func (this *CustomNameNidOptNative) GetFieldM() bool {
19704 return this.FieldM
19705 }
19706
19707 func (this *CustomNameNidOptNative) GetFieldN() string {
19708 return this.FieldN
19709 }
19710
19711 func (this *CustomNameNidOptNative) GetFieldO() []byte {
19712 return this.FieldO
19713 }
19714
19715 func NewCustomNameNidOptNativeFromFace(that CustomNameNidOptNativeFace) *CustomNameNidOptNative {
19716 this := &CustomNameNidOptNative{}
19717 this.FieldA = that.GetFieldA()
19718 this.FieldB = that.GetFieldB()
19719 this.FieldC = that.GetFieldC()
19720 this.FieldD = that.GetFieldD()
19721 this.FieldE = that.GetFieldE()
19722 this.FieldF = that.GetFieldF()
19723 this.FieldG = that.GetFieldG()
19724 this.FieldH = that.GetFieldH()
19725 this.FieldI = that.GetFieldI()
19726 this.FieldJ = that.GetFieldJ()
19727 this.FieldK = that.GetFieldK()
19728 this.FieldL = that.GetFieldL()
19729 this.FieldM = that.GetFieldM()
19730 this.FieldN = that.GetFieldN()
19731 this.FieldO = that.GetFieldO()
19732 return this
19733 }
19734
19735 type CustomNameNinOptNativeFace interface {
19736 Proto() github_com_gogo_protobuf_proto.Message
19737 GetFieldA() *float64
19738 GetFieldB() *float32
19739 GetFieldC() *int32
19740 GetFieldD() *int64
19741 GetFieldE() *uint32
19742 GetFieldF() *uint64
19743 GetFieldG() *int32
19744 GetFieldH() *int64
19745 GetFieldI() *uint32
19746 GetFieldJ() *int32
19747 GetFieldK() *uint64
19748 GetFielL() *int64
19749 GetFieldM() *bool
19750 GetFieldN() *string
19751 GetFieldO() []byte
19752 }
19753
19754 func (this *CustomNameNinOptNative) Proto() github_com_gogo_protobuf_proto.Message {
19755 return this
19756 }
19757
19758 func (this *CustomNameNinOptNative) TestProto() github_com_gogo_protobuf_proto.Message {
19759 return NewCustomNameNinOptNativeFromFace(this)
19760 }
19761
19762 func (this *CustomNameNinOptNative) GetFieldA() *float64 {
19763 return this.FieldA
19764 }
19765
19766 func (this *CustomNameNinOptNative) GetFieldB() *float32 {
19767 return this.FieldB
19768 }
19769
19770 func (this *CustomNameNinOptNative) GetFieldC() *int32 {
19771 return this.FieldC
19772 }
19773
19774 func (this *CustomNameNinOptNative) GetFieldD() *int64 {
19775 return this.FieldD
19776 }
19777
19778 func (this *CustomNameNinOptNative) GetFieldE() *uint32 {
19779 return this.FieldE
19780 }
19781
19782 func (this *CustomNameNinOptNative) GetFieldF() *uint64 {
19783 return this.FieldF
19784 }
19785
19786 func (this *CustomNameNinOptNative) GetFieldG() *int32 {
19787 return this.FieldG
19788 }
19789
19790 func (this *CustomNameNinOptNative) GetFieldH() *int64 {
19791 return this.FieldH
19792 }
19793
19794 func (this *CustomNameNinOptNative) GetFieldI() *uint32 {
19795 return this.FieldI
19796 }
19797
19798 func (this *CustomNameNinOptNative) GetFieldJ() *int32 {
19799 return this.FieldJ
19800 }
19801
19802 func (this *CustomNameNinOptNative) GetFieldK() *uint64 {
19803 return this.FieldK
19804 }
19805
19806 func (this *CustomNameNinOptNative) GetFielL() *int64 {
19807 return this.FielL
19808 }
19809
19810 func (this *CustomNameNinOptNative) GetFieldM() *bool {
19811 return this.FieldM
19812 }
19813
19814 func (this *CustomNameNinOptNative) GetFieldN() *string {
19815 return this.FieldN
19816 }
19817
19818 func (this *CustomNameNinOptNative) GetFieldO() []byte {
19819 return this.FieldO
19820 }
19821
19822 func NewCustomNameNinOptNativeFromFace(that CustomNameNinOptNativeFace) *CustomNameNinOptNative {
19823 this := &CustomNameNinOptNative{}
19824 this.FieldA = that.GetFieldA()
19825 this.FieldB = that.GetFieldB()
19826 this.FieldC = that.GetFieldC()
19827 this.FieldD = that.GetFieldD()
19828 this.FieldE = that.GetFieldE()
19829 this.FieldF = that.GetFieldF()
19830 this.FieldG = that.GetFieldG()
19831 this.FieldH = that.GetFieldH()
19832 this.FieldI = that.GetFieldI()
19833 this.FieldJ = that.GetFieldJ()
19834 this.FieldK = that.GetFieldK()
19835 this.FielL = that.GetFielL()
19836 this.FieldM = that.GetFieldM()
19837 this.FieldN = that.GetFieldN()
19838 this.FieldO = that.GetFieldO()
19839 return this
19840 }
19841
19842 type CustomNameNinRepNativeFace interface {
19843 Proto() github_com_gogo_protobuf_proto.Message
19844 GetFieldA() []float64
19845 GetFieldB() []float32
19846 GetFieldC() []int32
19847 GetFieldD() []int64
19848 GetFieldE() []uint32
19849 GetFieldF() []uint64
19850 GetFieldG() []int32
19851 GetFieldH() []int64
19852 GetFieldI() []uint32
19853 GetFieldJ() []int32
19854 GetFieldK() []uint64
19855 GetFieldL() []int64
19856 GetFieldM() []bool
19857 GetFieldN() []string
19858 GetFieldO() [][]byte
19859 }
19860
19861 func (this *CustomNameNinRepNative) Proto() github_com_gogo_protobuf_proto.Message {
19862 return this
19863 }
19864
19865 func (this *CustomNameNinRepNative) TestProto() github_com_gogo_protobuf_proto.Message {
19866 return NewCustomNameNinRepNativeFromFace(this)
19867 }
19868
19869 func (this *CustomNameNinRepNative) GetFieldA() []float64 {
19870 return this.FieldA
19871 }
19872
19873 func (this *CustomNameNinRepNative) GetFieldB() []float32 {
19874 return this.FieldB
19875 }
19876
19877 func (this *CustomNameNinRepNative) GetFieldC() []int32 {
19878 return this.FieldC
19879 }
19880
19881 func (this *CustomNameNinRepNative) GetFieldD() []int64 {
19882 return this.FieldD
19883 }
19884
19885 func (this *CustomNameNinRepNative) GetFieldE() []uint32 {
19886 return this.FieldE
19887 }
19888
19889 func (this *CustomNameNinRepNative) GetFieldF() []uint64 {
19890 return this.FieldF
19891 }
19892
19893 func (this *CustomNameNinRepNative) GetFieldG() []int32 {
19894 return this.FieldG
19895 }
19896
19897 func (this *CustomNameNinRepNative) GetFieldH() []int64 {
19898 return this.FieldH
19899 }
19900
19901 func (this *CustomNameNinRepNative) GetFieldI() []uint32 {
19902 return this.FieldI
19903 }
19904
19905 func (this *CustomNameNinRepNative) GetFieldJ() []int32 {
19906 return this.FieldJ
19907 }
19908
19909 func (this *CustomNameNinRepNative) GetFieldK() []uint64 {
19910 return this.FieldK
19911 }
19912
19913 func (this *CustomNameNinRepNative) GetFieldL() []int64 {
19914 return this.FieldL
19915 }
19916
19917 func (this *CustomNameNinRepNative) GetFieldM() []bool {
19918 return this.FieldM
19919 }
19920
19921 func (this *CustomNameNinRepNative) GetFieldN() []string {
19922 return this.FieldN
19923 }
19924
19925 func (this *CustomNameNinRepNative) GetFieldO() [][]byte {
19926 return this.FieldO
19927 }
19928
19929 func NewCustomNameNinRepNativeFromFace(that CustomNameNinRepNativeFace) *CustomNameNinRepNative {
19930 this := &CustomNameNinRepNative{}
19931 this.FieldA = that.GetFieldA()
19932 this.FieldB = that.GetFieldB()
19933 this.FieldC = that.GetFieldC()
19934 this.FieldD = that.GetFieldD()
19935 this.FieldE = that.GetFieldE()
19936 this.FieldF = that.GetFieldF()
19937 this.FieldG = that.GetFieldG()
19938 this.FieldH = that.GetFieldH()
19939 this.FieldI = that.GetFieldI()
19940 this.FieldJ = that.GetFieldJ()
19941 this.FieldK = that.GetFieldK()
19942 this.FieldL = that.GetFieldL()
19943 this.FieldM = that.GetFieldM()
19944 this.FieldN = that.GetFieldN()
19945 this.FieldO = that.GetFieldO()
19946 return this
19947 }
19948
19949 type CustomNameNinStructFace interface {
19950 Proto() github_com_gogo_protobuf_proto.Message
19951 GetFieldA() *float64
19952 GetFieldB() *float32
19953 GetFieldC() *NidOptNative
19954 GetFieldD() []*NinOptNative
19955 GetFieldE() *uint64
19956 GetFieldF() *int32
19957 GetFieldG() *NidOptNative
19958 GetFieldH() *bool
19959 GetFieldI() *string
19960 GetFieldJ() []byte
19961 }
19962
19963 func (this *CustomNameNinStruct) Proto() github_com_gogo_protobuf_proto.Message {
19964 return this
19965 }
19966
19967 func (this *CustomNameNinStruct) TestProto() github_com_gogo_protobuf_proto.Message {
19968 return NewCustomNameNinStructFromFace(this)
19969 }
19970
19971 func (this *CustomNameNinStruct) GetFieldA() *float64 {
19972 return this.FieldA
19973 }
19974
19975 func (this *CustomNameNinStruct) GetFieldB() *float32 {
19976 return this.FieldB
19977 }
19978
19979 func (this *CustomNameNinStruct) GetFieldC() *NidOptNative {
19980 return this.FieldC
19981 }
19982
19983 func (this *CustomNameNinStruct) GetFieldD() []*NinOptNative {
19984 return this.FieldD
19985 }
19986
19987 func (this *CustomNameNinStruct) GetFieldE() *uint64 {
19988 return this.FieldE
19989 }
19990
19991 func (this *CustomNameNinStruct) GetFieldF() *int32 {
19992 return this.FieldF
19993 }
19994
19995 func (this *CustomNameNinStruct) GetFieldG() *NidOptNative {
19996 return this.FieldG
19997 }
19998
19999 func (this *CustomNameNinStruct) GetFieldH() *bool {
20000 return this.FieldH
20001 }
20002
20003 func (this *CustomNameNinStruct) GetFieldI() *string {
20004 return this.FieldI
20005 }
20006
20007 func (this *CustomNameNinStruct) GetFieldJ() []byte {
20008 return this.FieldJ
20009 }
20010
20011 func NewCustomNameNinStructFromFace(that CustomNameNinStructFace) *CustomNameNinStruct {
20012 this := &CustomNameNinStruct{}
20013 this.FieldA = that.GetFieldA()
20014 this.FieldB = that.GetFieldB()
20015 this.FieldC = that.GetFieldC()
20016 this.FieldD = that.GetFieldD()
20017 this.FieldE = that.GetFieldE()
20018 this.FieldF = that.GetFieldF()
20019 this.FieldG = that.GetFieldG()
20020 this.FieldH = that.GetFieldH()
20021 this.FieldI = that.GetFieldI()
20022 this.FieldJ = that.GetFieldJ()
20023 return this
20024 }
20025
20026 type CustomNameCustomTypeFace interface {
20027 Proto() github_com_gogo_protobuf_proto.Message
20028 GetFieldA() *Uuid
20029 GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128
20030 GetFieldC() []Uuid
20031 GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128
20032 }
20033
20034 func (this *CustomNameCustomType) Proto() github_com_gogo_protobuf_proto.Message {
20035 return this
20036 }
20037
20038 func (this *CustomNameCustomType) TestProto() github_com_gogo_protobuf_proto.Message {
20039 return NewCustomNameCustomTypeFromFace(this)
20040 }
20041
20042 func (this *CustomNameCustomType) GetFieldA() *Uuid {
20043 return this.FieldA
20044 }
20045
20046 func (this *CustomNameCustomType) GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 {
20047 return this.FieldB
20048 }
20049
20050 func (this *CustomNameCustomType) GetFieldC() []Uuid {
20051 return this.FieldC
20052 }
20053
20054 func (this *CustomNameCustomType) GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 {
20055 return this.FieldD
20056 }
20057
20058 func NewCustomNameCustomTypeFromFace(that CustomNameCustomTypeFace) *CustomNameCustomType {
20059 this := &CustomNameCustomType{}
20060 this.FieldA = that.GetFieldA()
20061 this.FieldB = that.GetFieldB()
20062 this.FieldC = that.GetFieldC()
20063 this.FieldD = that.GetFieldD()
20064 return this
20065 }
20066
20067 type CustomNameNinEmbeddedStructUnionFace interface {
20068 Proto() github_com_gogo_protobuf_proto.Message
20069 GetNidOptNative() *NidOptNative
20070 GetFieldA() *NinOptNative
20071 GetFieldB() *bool
20072 }
20073
20074 func (this *CustomNameNinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message {
20075 return this
20076 }
20077
20078 func (this *CustomNameNinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message {
20079 return NewCustomNameNinEmbeddedStructUnionFromFace(this)
20080 }
20081
20082 func (this *CustomNameNinEmbeddedStructUnion) GetNidOptNative() *NidOptNative {
20083 return this.NidOptNative
20084 }
20085
20086 func (this *CustomNameNinEmbeddedStructUnion) GetFieldA() *NinOptNative {
20087 return this.FieldA
20088 }
20089
20090 func (this *CustomNameNinEmbeddedStructUnion) GetFieldB() *bool {
20091 return this.FieldB
20092 }
20093
20094 func NewCustomNameNinEmbeddedStructUnionFromFace(that CustomNameNinEmbeddedStructUnionFace) *CustomNameNinEmbeddedStructUnion {
20095 this := &CustomNameNinEmbeddedStructUnion{}
20096 this.NidOptNative = that.GetNidOptNative()
20097 this.FieldA = that.GetFieldA()
20098 this.FieldB = that.GetFieldB()
20099 return this
20100 }
20101
20102 type CustomNameEnumFace interface {
20103 Proto() github_com_gogo_protobuf_proto.Message
20104 GetFieldA() *TheTestEnum
20105 GetFieldB() []TheTestEnum
20106 }
20107
20108 func (this *CustomNameEnum) Proto() github_com_gogo_protobuf_proto.Message {
20109 return this
20110 }
20111
20112 func (this *CustomNameEnum) TestProto() github_com_gogo_protobuf_proto.Message {
20113 return NewCustomNameEnumFromFace(this)
20114 }
20115
20116 func (this *CustomNameEnum) GetFieldA() *TheTestEnum {
20117 return this.FieldA
20118 }
20119
20120 func (this *CustomNameEnum) GetFieldB() []TheTestEnum {
20121 return this.FieldB
20122 }
20123
20124 func NewCustomNameEnumFromFace(that CustomNameEnumFace) *CustomNameEnum {
20125 this := &CustomNameEnum{}
20126 this.FieldA = that.GetFieldA()
20127 this.FieldB = that.GetFieldB()
20128 return this
20129 }
20130
20131 type UnrecognizedFace interface {
20132 Proto() github_com_gogo_protobuf_proto.Message
20133 GetField1() *string
20134 }
20135
20136 func (this *Unrecognized) Proto() github_com_gogo_protobuf_proto.Message {
20137 return this
20138 }
20139
20140 func (this *Unrecognized) TestProto() github_com_gogo_protobuf_proto.Message {
20141 return NewUnrecognizedFromFace(this)
20142 }
20143
20144 func (this *Unrecognized) GetField1() *string {
20145 return this.Field1
20146 }
20147
20148 func NewUnrecognizedFromFace(that UnrecognizedFace) *Unrecognized {
20149 this := &Unrecognized{}
20150 this.Field1 = that.GetField1()
20151 return this
20152 }
20153
20154 type UnrecognizedWithInnerFace interface {
20155 Proto() github_com_gogo_protobuf_proto.Message
20156 GetEmbedded() []*UnrecognizedWithInner_Inner
20157 GetField2() *string
20158 }
20159
20160 func (this *UnrecognizedWithInner) Proto() github_com_gogo_protobuf_proto.Message {
20161 return this
20162 }
20163
20164 func (this *UnrecognizedWithInner) TestProto() github_com_gogo_protobuf_proto.Message {
20165 return NewUnrecognizedWithInnerFromFace(this)
20166 }
20167
20168 func (this *UnrecognizedWithInner) GetEmbedded() []*UnrecognizedWithInner_Inner {
20169 return this.Embedded
20170 }
20171
20172 func (this *UnrecognizedWithInner) GetField2() *string {
20173 return this.Field2
20174 }
20175
20176 func NewUnrecognizedWithInnerFromFace(that UnrecognizedWithInnerFace) *UnrecognizedWithInner {
20177 this := &UnrecognizedWithInner{}
20178 this.Embedded = that.GetEmbedded()
20179 this.Field2 = that.GetField2()
20180 return this
20181 }
20182
20183 type UnrecognizedWithInner_InnerFace interface {
20184 Proto() github_com_gogo_protobuf_proto.Message
20185 GetField1() *uint32
20186 }
20187
20188 func (this *UnrecognizedWithInner_Inner) Proto() github_com_gogo_protobuf_proto.Message {
20189 return this
20190 }
20191
20192 func (this *UnrecognizedWithInner_Inner) TestProto() github_com_gogo_protobuf_proto.Message {
20193 return NewUnrecognizedWithInner_InnerFromFace(this)
20194 }
20195
20196 func (this *UnrecognizedWithInner_Inner) GetField1() *uint32 {
20197 return this.Field1
20198 }
20199
20200 func NewUnrecognizedWithInner_InnerFromFace(that UnrecognizedWithInner_InnerFace) *UnrecognizedWithInner_Inner {
20201 this := &UnrecognizedWithInner_Inner{}
20202 this.Field1 = that.GetField1()
20203 return this
20204 }
20205
20206 type UnrecognizedWithEmbedFace interface {
20207 Proto() github_com_gogo_protobuf_proto.Message
20208 GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded
20209 GetField2() *string
20210 }
20211
20212 func (this *UnrecognizedWithEmbed) Proto() github_com_gogo_protobuf_proto.Message {
20213 return this
20214 }
20215
20216 func (this *UnrecognizedWithEmbed) TestProto() github_com_gogo_protobuf_proto.Message {
20217 return NewUnrecognizedWithEmbedFromFace(this)
20218 }
20219
20220 func (this *UnrecognizedWithEmbed) GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded {
20221 return this.UnrecognizedWithEmbed_Embedded
20222 }
20223
20224 func (this *UnrecognizedWithEmbed) GetField2() *string {
20225 return this.Field2
20226 }
20227
20228 func NewUnrecognizedWithEmbedFromFace(that UnrecognizedWithEmbedFace) *UnrecognizedWithEmbed {
20229 this := &UnrecognizedWithEmbed{}
20230 this.UnrecognizedWithEmbed_Embedded = that.GetUnrecognizedWithEmbed_Embedded()
20231 this.Field2 = that.GetField2()
20232 return this
20233 }
20234
20235 type UnrecognizedWithEmbed_EmbeddedFace interface {
20236 Proto() github_com_gogo_protobuf_proto.Message
20237 GetField1() *uint32
20238 }
20239
20240 func (this *UnrecognizedWithEmbed_Embedded) Proto() github_com_gogo_protobuf_proto.Message {
20241 return this
20242 }
20243
20244 func (this *UnrecognizedWithEmbed_Embedded) TestProto() github_com_gogo_protobuf_proto.Message {
20245 return NewUnrecognizedWithEmbed_EmbeddedFromFace(this)
20246 }
20247
20248 func (this *UnrecognizedWithEmbed_Embedded) GetField1() *uint32 {
20249 return this.Field1
20250 }
20251
20252 func NewUnrecognizedWithEmbed_EmbeddedFromFace(that UnrecognizedWithEmbed_EmbeddedFace) *UnrecognizedWithEmbed_Embedded {
20253 this := &UnrecognizedWithEmbed_Embedded{}
20254 this.Field1 = that.GetField1()
20255 return this
20256 }
20257
20258 type NodeFace interface {
20259 Proto() github_com_gogo_protobuf_proto.Message
20260 GetLabel() *string
20261 GetChildren() []*Node
20262 }
20263
20264 func (this *Node) Proto() github_com_gogo_protobuf_proto.Message {
20265 return this
20266 }
20267
20268 func (this *Node) TestProto() github_com_gogo_protobuf_proto.Message {
20269 return NewNodeFromFace(this)
20270 }
20271
20272 func (this *Node) GetLabel() *string {
20273 return this.Label
20274 }
20275
20276 func (this *Node) GetChildren() []*Node {
20277 return this.Children
20278 }
20279
20280 func NewNodeFromFace(that NodeFace) *Node {
20281 this := &Node{}
20282 this.Label = that.GetLabel()
20283 this.Children = that.GetChildren()
20284 return this
20285 }
20286
20287 type NonByteCustomTypeFace interface {
20288 Proto() github_com_gogo_protobuf_proto.Message
20289 GetField1() *T
20290 }
20291
20292 func (this *NonByteCustomType) Proto() github_com_gogo_protobuf_proto.Message {
20293 return this
20294 }
20295
20296 func (this *NonByteCustomType) TestProto() github_com_gogo_protobuf_proto.Message {
20297 return NewNonByteCustomTypeFromFace(this)
20298 }
20299
20300 func (this *NonByteCustomType) GetField1() *T {
20301 return this.Field1
20302 }
20303
20304 func NewNonByteCustomTypeFromFace(that NonByteCustomTypeFace) *NonByteCustomType {
20305 this := &NonByteCustomType{}
20306 this.Field1 = that.GetField1()
20307 return this
20308 }
20309
20310 type NidOptNonByteCustomTypeFace interface {
20311 Proto() github_com_gogo_protobuf_proto.Message
20312 GetField1() T
20313 }
20314
20315 func (this *NidOptNonByteCustomType) Proto() github_com_gogo_protobuf_proto.Message {
20316 return this
20317 }
20318
20319 func (this *NidOptNonByteCustomType) TestProto() github_com_gogo_protobuf_proto.Message {
20320 return NewNidOptNonByteCustomTypeFromFace(this)
20321 }
20322
20323 func (this *NidOptNonByteCustomType) GetField1() T {
20324 return this.Field1
20325 }
20326
20327 func NewNidOptNonByteCustomTypeFromFace(that NidOptNonByteCustomTypeFace) *NidOptNonByteCustomType {
20328 this := &NidOptNonByteCustomType{}
20329 this.Field1 = that.GetField1()
20330 return this
20331 }
20332
20333 type NinOptNonByteCustomTypeFace interface {
20334 Proto() github_com_gogo_protobuf_proto.Message
20335 GetField1() *T
20336 }
20337
20338 func (this *NinOptNonByteCustomType) Proto() github_com_gogo_protobuf_proto.Message {
20339 return this
20340 }
20341
20342 func (this *NinOptNonByteCustomType) TestProto() github_com_gogo_protobuf_proto.Message {
20343 return NewNinOptNonByteCustomTypeFromFace(this)
20344 }
20345
20346 func (this *NinOptNonByteCustomType) GetField1() *T {
20347 return this.Field1
20348 }
20349
20350 func NewNinOptNonByteCustomTypeFromFace(that NinOptNonByteCustomTypeFace) *NinOptNonByteCustomType {
20351 this := &NinOptNonByteCustomType{}
20352 this.Field1 = that.GetField1()
20353 return this
20354 }
20355
20356 type NidRepNonByteCustomTypeFace interface {
20357 Proto() github_com_gogo_protobuf_proto.Message
20358 GetField1() []T
20359 }
20360
20361 func (this *NidRepNonByteCustomType) Proto() github_com_gogo_protobuf_proto.Message {
20362 return this
20363 }
20364
20365 func (this *NidRepNonByteCustomType) TestProto() github_com_gogo_protobuf_proto.Message {
20366 return NewNidRepNonByteCustomTypeFromFace(this)
20367 }
20368
20369 func (this *NidRepNonByteCustomType) GetField1() []T {
20370 return this.Field1
20371 }
20372
20373 func NewNidRepNonByteCustomTypeFromFace(that NidRepNonByteCustomTypeFace) *NidRepNonByteCustomType {
20374 this := &NidRepNonByteCustomType{}
20375 this.Field1 = that.GetField1()
20376 return this
20377 }
20378
20379 type NinRepNonByteCustomTypeFace interface {
20380 Proto() github_com_gogo_protobuf_proto.Message
20381 GetField1() []T
20382 }
20383
20384 func (this *NinRepNonByteCustomType) Proto() github_com_gogo_protobuf_proto.Message {
20385 return this
20386 }
20387
20388 func (this *NinRepNonByteCustomType) TestProto() github_com_gogo_protobuf_proto.Message {
20389 return NewNinRepNonByteCustomTypeFromFace(this)
20390 }
20391
20392 func (this *NinRepNonByteCustomType) GetField1() []T {
20393 return this.Field1
20394 }
20395
20396 func NewNinRepNonByteCustomTypeFromFace(that NinRepNonByteCustomTypeFace) *NinRepNonByteCustomType {
20397 this := &NinRepNonByteCustomType{}
20398 this.Field1 = that.GetField1()
20399 return this
20400 }
20401
20402 type ProtoTypeFace interface {
20403 Proto() github_com_gogo_protobuf_proto.Message
20404 GetField2() *string
20405 }
20406
20407 func (this *ProtoType) Proto() github_com_gogo_protobuf_proto.Message {
20408 return this
20409 }
20410
20411 func (this *ProtoType) TestProto() github_com_gogo_protobuf_proto.Message {
20412 return NewProtoTypeFromFace(this)
20413 }
20414
20415 func (this *ProtoType) GetField2() *string {
20416 return this.Field2
20417 }
20418
20419 func NewProtoTypeFromFace(that ProtoTypeFace) *ProtoType {
20420 this := &ProtoType{}
20421 this.Field2 = that.GetField2()
20422 return this
20423 }
20424
20425 func (this *NidOptNative) GoString() string {
20426 if this == nil {
20427 return "nil"
20428 }
20429 s := make([]string, 0, 19)
20430 s = append(s, "&test.NidOptNative{")
20431 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
20432 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
20433 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
20434 s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
20435 s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n")
20436 s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n")
20437 s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
20438 s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
20439 s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n")
20440 s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n")
20441 s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n")
20442 s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n")
20443 s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n")
20444 s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n")
20445 s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n")
20446 if this.XXX_unrecognized != nil {
20447 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20448 }
20449 s = append(s, "}")
20450 return strings.Join(s, "")
20451 }
20452 func (this *NinOptNative) GoString() string {
20453 if this == nil {
20454 return "nil"
20455 }
20456 s := make([]string, 0, 19)
20457 s = append(s, "&test.NinOptNative{")
20458 if this.Field1 != nil {
20459 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n")
20460 }
20461 if this.Field2 != nil {
20462 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n")
20463 }
20464 if this.Field3 != nil {
20465 s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n")
20466 }
20467 if this.Field4 != nil {
20468 s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n")
20469 }
20470 if this.Field5 != nil {
20471 s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n")
20472 }
20473 if this.Field6 != nil {
20474 s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n")
20475 }
20476 if this.Field7 != nil {
20477 s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n")
20478 }
20479 if this.Field8 != nil {
20480 s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n")
20481 }
20482 if this.Field9 != nil {
20483 s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n")
20484 }
20485 if this.Field10 != nil {
20486 s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n")
20487 }
20488 if this.Field11 != nil {
20489 s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n")
20490 }
20491 if this.Field12 != nil {
20492 s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n")
20493 }
20494 if this.Field13 != nil {
20495 s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n")
20496 }
20497 if this.Field14 != nil {
20498 s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n")
20499 }
20500 if this.Field15 != nil {
20501 s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n")
20502 }
20503 if this.XXX_unrecognized != nil {
20504 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20505 }
20506 s = append(s, "}")
20507 return strings.Join(s, "")
20508 }
20509 func (this *NidRepNative) GoString() string {
20510 if this == nil {
20511 return "nil"
20512 }
20513 s := make([]string, 0, 19)
20514 s = append(s, "&test.NidRepNative{")
20515 if this.Field1 != nil {
20516 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
20517 }
20518 if this.Field2 != nil {
20519 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
20520 }
20521 if this.Field3 != nil {
20522 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
20523 }
20524 if this.Field4 != nil {
20525 s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
20526 }
20527 if this.Field5 != nil {
20528 s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n")
20529 }
20530 if this.Field6 != nil {
20531 s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n")
20532 }
20533 if this.Field7 != nil {
20534 s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
20535 }
20536 if this.Field8 != nil {
20537 s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
20538 }
20539 if this.Field9 != nil {
20540 s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n")
20541 }
20542 if this.Field10 != nil {
20543 s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n")
20544 }
20545 if this.Field11 != nil {
20546 s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n")
20547 }
20548 if this.Field12 != nil {
20549 s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n")
20550 }
20551 if this.Field13 != nil {
20552 s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n")
20553 }
20554 if this.Field14 != nil {
20555 s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n")
20556 }
20557 if this.Field15 != nil {
20558 s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n")
20559 }
20560 if this.XXX_unrecognized != nil {
20561 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20562 }
20563 s = append(s, "}")
20564 return strings.Join(s, "")
20565 }
20566 func (this *NinRepNative) GoString() string {
20567 if this == nil {
20568 return "nil"
20569 }
20570 s := make([]string, 0, 19)
20571 s = append(s, "&test.NinRepNative{")
20572 if this.Field1 != nil {
20573 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
20574 }
20575 if this.Field2 != nil {
20576 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
20577 }
20578 if this.Field3 != nil {
20579 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
20580 }
20581 if this.Field4 != nil {
20582 s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
20583 }
20584 if this.Field5 != nil {
20585 s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n")
20586 }
20587 if this.Field6 != nil {
20588 s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n")
20589 }
20590 if this.Field7 != nil {
20591 s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
20592 }
20593 if this.Field8 != nil {
20594 s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
20595 }
20596 if this.Field9 != nil {
20597 s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n")
20598 }
20599 if this.Field10 != nil {
20600 s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n")
20601 }
20602 if this.Field11 != nil {
20603 s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n")
20604 }
20605 if this.Field12 != nil {
20606 s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n")
20607 }
20608 if this.Field13 != nil {
20609 s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n")
20610 }
20611 if this.Field14 != nil {
20612 s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n")
20613 }
20614 if this.Field15 != nil {
20615 s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n")
20616 }
20617 if this.XXX_unrecognized != nil {
20618 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20619 }
20620 s = append(s, "}")
20621 return strings.Join(s, "")
20622 }
20623 func (this *NidRepPackedNative) GoString() string {
20624 if this == nil {
20625 return "nil"
20626 }
20627 s := make([]string, 0, 17)
20628 s = append(s, "&test.NidRepPackedNative{")
20629 if this.Field1 != nil {
20630 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
20631 }
20632 if this.Field2 != nil {
20633 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
20634 }
20635 if this.Field3 != nil {
20636 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
20637 }
20638 if this.Field4 != nil {
20639 s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
20640 }
20641 if this.Field5 != nil {
20642 s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n")
20643 }
20644 if this.Field6 != nil {
20645 s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n")
20646 }
20647 if this.Field7 != nil {
20648 s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
20649 }
20650 if this.Field8 != nil {
20651 s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
20652 }
20653 if this.Field9 != nil {
20654 s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n")
20655 }
20656 if this.Field10 != nil {
20657 s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n")
20658 }
20659 if this.Field11 != nil {
20660 s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n")
20661 }
20662 if this.Field12 != nil {
20663 s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n")
20664 }
20665 if this.Field13 != nil {
20666 s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n")
20667 }
20668 if this.XXX_unrecognized != nil {
20669 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20670 }
20671 s = append(s, "}")
20672 return strings.Join(s, "")
20673 }
20674 func (this *NinRepPackedNative) GoString() string {
20675 if this == nil {
20676 return "nil"
20677 }
20678 s := make([]string, 0, 17)
20679 s = append(s, "&test.NinRepPackedNative{")
20680 if this.Field1 != nil {
20681 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
20682 }
20683 if this.Field2 != nil {
20684 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
20685 }
20686 if this.Field3 != nil {
20687 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
20688 }
20689 if this.Field4 != nil {
20690 s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
20691 }
20692 if this.Field5 != nil {
20693 s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n")
20694 }
20695 if this.Field6 != nil {
20696 s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n")
20697 }
20698 if this.Field7 != nil {
20699 s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
20700 }
20701 if this.Field8 != nil {
20702 s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
20703 }
20704 if this.Field9 != nil {
20705 s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n")
20706 }
20707 if this.Field10 != nil {
20708 s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n")
20709 }
20710 if this.Field11 != nil {
20711 s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n")
20712 }
20713 if this.Field12 != nil {
20714 s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n")
20715 }
20716 if this.Field13 != nil {
20717 s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n")
20718 }
20719 if this.XXX_unrecognized != nil {
20720 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20721 }
20722 s = append(s, "}")
20723 return strings.Join(s, "")
20724 }
20725 func (this *NidOptStruct) GoString() string {
20726 if this == nil {
20727 return "nil"
20728 }
20729 s := make([]string, 0, 14)
20730 s = append(s, "&test.NidOptStruct{")
20731 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
20732 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
20733 s = append(s, "Field3: "+strings.Replace(this.Field3.GoString(), `&`, ``, 1)+",\n")
20734 s = append(s, "Field4: "+strings.Replace(this.Field4.GoString(), `&`, ``, 1)+",\n")
20735 s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n")
20736 s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
20737 s = append(s, "Field8: "+strings.Replace(this.Field8.GoString(), `&`, ``, 1)+",\n")
20738 s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n")
20739 s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n")
20740 s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n")
20741 if this.XXX_unrecognized != nil {
20742 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20743 }
20744 s = append(s, "}")
20745 return strings.Join(s, "")
20746 }
20747 func (this *NinOptStruct) GoString() string {
20748 if this == nil {
20749 return "nil"
20750 }
20751 s := make([]string, 0, 14)
20752 s = append(s, "&test.NinOptStruct{")
20753 if this.Field1 != nil {
20754 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n")
20755 }
20756 if this.Field2 != nil {
20757 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n")
20758 }
20759 if this.Field3 != nil {
20760 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
20761 }
20762 if this.Field4 != nil {
20763 s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
20764 }
20765 if this.Field6 != nil {
20766 s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n")
20767 }
20768 if this.Field7 != nil {
20769 s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n")
20770 }
20771 if this.Field8 != nil {
20772 s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
20773 }
20774 if this.Field13 != nil {
20775 s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n")
20776 }
20777 if this.Field14 != nil {
20778 s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n")
20779 }
20780 if this.Field15 != nil {
20781 s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n")
20782 }
20783 if this.XXX_unrecognized != nil {
20784 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20785 }
20786 s = append(s, "}")
20787 return strings.Join(s, "")
20788 }
20789 func (this *NidRepStruct) GoString() string {
20790 if this == nil {
20791 return "nil"
20792 }
20793 s := make([]string, 0, 14)
20794 s = append(s, "&test.NidRepStruct{")
20795 if this.Field1 != nil {
20796 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
20797 }
20798 if this.Field2 != nil {
20799 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
20800 }
20801 if this.Field3 != nil {
20802 vs := make([]NidOptNative, len(this.Field3))
20803 for i := range vs {
20804 vs[i] = this.Field3[i]
20805 }
20806 s = append(s, "Field3: "+fmt.Sprintf("%#v", vs)+",\n")
20807 }
20808 if this.Field4 != nil {
20809 vs := make([]NinOptNative, len(this.Field4))
20810 for i := range vs {
20811 vs[i] = this.Field4[i]
20812 }
20813 s = append(s, "Field4: "+fmt.Sprintf("%#v", vs)+",\n")
20814 }
20815 if this.Field6 != nil {
20816 s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n")
20817 }
20818 if this.Field7 != nil {
20819 s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
20820 }
20821 if this.Field8 != nil {
20822 vs := make([]NidOptNative, len(this.Field8))
20823 for i := range vs {
20824 vs[i] = this.Field8[i]
20825 }
20826 s = append(s, "Field8: "+fmt.Sprintf("%#v", vs)+",\n")
20827 }
20828 if this.Field13 != nil {
20829 s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n")
20830 }
20831 if this.Field14 != nil {
20832 s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n")
20833 }
20834 if this.Field15 != nil {
20835 s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n")
20836 }
20837 if this.XXX_unrecognized != nil {
20838 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20839 }
20840 s = append(s, "}")
20841 return strings.Join(s, "")
20842 }
20843 func (this *NinRepStruct) GoString() string {
20844 if this == nil {
20845 return "nil"
20846 }
20847 s := make([]string, 0, 14)
20848 s = append(s, "&test.NinRepStruct{")
20849 if this.Field1 != nil {
20850 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
20851 }
20852 if this.Field2 != nil {
20853 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
20854 }
20855 if this.Field3 != nil {
20856 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
20857 }
20858 if this.Field4 != nil {
20859 s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
20860 }
20861 if this.Field6 != nil {
20862 s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n")
20863 }
20864 if this.Field7 != nil {
20865 s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
20866 }
20867 if this.Field8 != nil {
20868 s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
20869 }
20870 if this.Field13 != nil {
20871 s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n")
20872 }
20873 if this.Field14 != nil {
20874 s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n")
20875 }
20876 if this.Field15 != nil {
20877 s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n")
20878 }
20879 if this.XXX_unrecognized != nil {
20880 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20881 }
20882 s = append(s, "}")
20883 return strings.Join(s, "")
20884 }
20885 func (this *NidEmbeddedStruct) GoString() string {
20886 if this == nil {
20887 return "nil"
20888 }
20889 s := make([]string, 0, 7)
20890 s = append(s, "&test.NidEmbeddedStruct{")
20891 if this.NidOptNative != nil {
20892 s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n")
20893 }
20894 s = append(s, "Field200: "+strings.Replace(this.Field200.GoString(), `&`, ``, 1)+",\n")
20895 s = append(s, "Field210: "+fmt.Sprintf("%#v", this.Field210)+",\n")
20896 if this.XXX_unrecognized != nil {
20897 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20898 }
20899 s = append(s, "}")
20900 return strings.Join(s, "")
20901 }
20902 func (this *NinEmbeddedStruct) GoString() string {
20903 if this == nil {
20904 return "nil"
20905 }
20906 s := make([]string, 0, 7)
20907 s = append(s, "&test.NinEmbeddedStruct{")
20908 if this.NidOptNative != nil {
20909 s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n")
20910 }
20911 if this.Field200 != nil {
20912 s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n")
20913 }
20914 if this.Field210 != nil {
20915 s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n")
20916 }
20917 if this.XXX_unrecognized != nil {
20918 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20919 }
20920 s = append(s, "}")
20921 return strings.Join(s, "")
20922 }
20923 func (this *NidNestedStruct) GoString() string {
20924 if this == nil {
20925 return "nil"
20926 }
20927 s := make([]string, 0, 6)
20928 s = append(s, "&test.NidNestedStruct{")
20929 s = append(s, "Field1: "+strings.Replace(this.Field1.GoString(), `&`, ``, 1)+",\n")
20930 if this.Field2 != nil {
20931 vs := make([]NidRepStruct, len(this.Field2))
20932 for i := range vs {
20933 vs[i] = this.Field2[i]
20934 }
20935 s = append(s, "Field2: "+fmt.Sprintf("%#v", vs)+",\n")
20936 }
20937 if this.XXX_unrecognized != nil {
20938 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20939 }
20940 s = append(s, "}")
20941 return strings.Join(s, "")
20942 }
20943 func (this *NinNestedStruct) GoString() string {
20944 if this == nil {
20945 return "nil"
20946 }
20947 s := make([]string, 0, 6)
20948 s = append(s, "&test.NinNestedStruct{")
20949 if this.Field1 != nil {
20950 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
20951 }
20952 if this.Field2 != nil {
20953 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
20954 }
20955 if this.XXX_unrecognized != nil {
20956 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20957 }
20958 s = append(s, "}")
20959 return strings.Join(s, "")
20960 }
20961 func (this *NidOptCustom) GoString() string {
20962 if this == nil {
20963 return "nil"
20964 }
20965 s := make([]string, 0, 6)
20966 s = append(s, "&test.NidOptCustom{")
20967 s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
20968 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
20969 if this.XXX_unrecognized != nil {
20970 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20971 }
20972 s = append(s, "}")
20973 return strings.Join(s, "")
20974 }
20975 func (this *CustomDash) GoString() string {
20976 if this == nil {
20977 return "nil"
20978 }
20979 s := make([]string, 0, 5)
20980 s = append(s, "&test.CustomDash{")
20981 if this.Value != nil {
20982 s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom_dash_type.Bytes")+",\n")
20983 }
20984 if this.XXX_unrecognized != nil {
20985 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
20986 }
20987 s = append(s, "}")
20988 return strings.Join(s, "")
20989 }
20990 func (this *NinOptCustom) GoString() string {
20991 if this == nil {
20992 return "nil"
20993 }
20994 s := make([]string, 0, 6)
20995 s = append(s, "&test.NinOptCustom{")
20996 if this.Id != nil {
20997 s = append(s, "Id: "+valueToGoStringThetest(this.Id, "Uuid")+",\n")
20998 }
20999 if this.Value != nil {
21000 s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom.Uint128")+",\n")
21001 }
21002 if this.XXX_unrecognized != nil {
21003 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21004 }
21005 s = append(s, "}")
21006 return strings.Join(s, "")
21007 }
21008 func (this *NidRepCustom) GoString() string {
21009 if this == nil {
21010 return "nil"
21011 }
21012 s := make([]string, 0, 6)
21013 s = append(s, "&test.NidRepCustom{")
21014 if this.Id != nil {
21015 s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
21016 }
21017 if this.Value != nil {
21018 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
21019 }
21020 if this.XXX_unrecognized != nil {
21021 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21022 }
21023 s = append(s, "}")
21024 return strings.Join(s, "")
21025 }
21026 func (this *NinRepCustom) GoString() string {
21027 if this == nil {
21028 return "nil"
21029 }
21030 s := make([]string, 0, 6)
21031 s = append(s, "&test.NinRepCustom{")
21032 if this.Id != nil {
21033 s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
21034 }
21035 if this.Value != nil {
21036 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
21037 }
21038 if this.XXX_unrecognized != nil {
21039 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21040 }
21041 s = append(s, "}")
21042 return strings.Join(s, "")
21043 }
21044 func (this *NinOptNativeUnion) GoString() string {
21045 if this == nil {
21046 return "nil"
21047 }
21048 s := make([]string, 0, 13)
21049 s = append(s, "&test.NinOptNativeUnion{")
21050 if this.Field1 != nil {
21051 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n")
21052 }
21053 if this.Field2 != nil {
21054 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n")
21055 }
21056 if this.Field3 != nil {
21057 s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n")
21058 }
21059 if this.Field4 != nil {
21060 s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n")
21061 }
21062 if this.Field5 != nil {
21063 s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n")
21064 }
21065 if this.Field6 != nil {
21066 s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n")
21067 }
21068 if this.Field13 != nil {
21069 s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n")
21070 }
21071 if this.Field14 != nil {
21072 s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n")
21073 }
21074 if this.Field15 != nil {
21075 s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n")
21076 }
21077 if this.XXX_unrecognized != nil {
21078 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21079 }
21080 s = append(s, "}")
21081 return strings.Join(s, "")
21082 }
21083 func (this *NinOptStructUnion) GoString() string {
21084 if this == nil {
21085 return "nil"
21086 }
21087 s := make([]string, 0, 13)
21088 s = append(s, "&test.NinOptStructUnion{")
21089 if this.Field1 != nil {
21090 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n")
21091 }
21092 if this.Field2 != nil {
21093 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n")
21094 }
21095 if this.Field3 != nil {
21096 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
21097 }
21098 if this.Field4 != nil {
21099 s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
21100 }
21101 if this.Field6 != nil {
21102 s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n")
21103 }
21104 if this.Field7 != nil {
21105 s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n")
21106 }
21107 if this.Field13 != nil {
21108 s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n")
21109 }
21110 if this.Field14 != nil {
21111 s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n")
21112 }
21113 if this.Field15 != nil {
21114 s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n")
21115 }
21116 if this.XXX_unrecognized != nil {
21117 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21118 }
21119 s = append(s, "}")
21120 return strings.Join(s, "")
21121 }
21122 func (this *NinEmbeddedStructUnion) GoString() string {
21123 if this == nil {
21124 return "nil"
21125 }
21126 s := make([]string, 0, 7)
21127 s = append(s, "&test.NinEmbeddedStructUnion{")
21128 if this.NidOptNative != nil {
21129 s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n")
21130 }
21131 if this.Field200 != nil {
21132 s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n")
21133 }
21134 if this.Field210 != nil {
21135 s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n")
21136 }
21137 if this.XXX_unrecognized != nil {
21138 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21139 }
21140 s = append(s, "}")
21141 return strings.Join(s, "")
21142 }
21143 func (this *NinNestedStructUnion) GoString() string {
21144 if this == nil {
21145 return "nil"
21146 }
21147 s := make([]string, 0, 7)
21148 s = append(s, "&test.NinNestedStructUnion{")
21149 if this.Field1 != nil {
21150 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
21151 }
21152 if this.Field2 != nil {
21153 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
21154 }
21155 if this.Field3 != nil {
21156 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
21157 }
21158 if this.XXX_unrecognized != nil {
21159 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21160 }
21161 s = append(s, "}")
21162 return strings.Join(s, "")
21163 }
21164 func (this *Tree) GoString() string {
21165 if this == nil {
21166 return "nil"
21167 }
21168 s := make([]string, 0, 7)
21169 s = append(s, "&test.Tree{")
21170 if this.Or != nil {
21171 s = append(s, "Or: "+fmt.Sprintf("%#v", this.Or)+",\n")
21172 }
21173 if this.And != nil {
21174 s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n")
21175 }
21176 if this.Leaf != nil {
21177 s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n")
21178 }
21179 if this.XXX_unrecognized != nil {
21180 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21181 }
21182 s = append(s, "}")
21183 return strings.Join(s, "")
21184 }
21185 func (this *OrBranch) GoString() string {
21186 if this == nil {
21187 return "nil"
21188 }
21189 s := make([]string, 0, 6)
21190 s = append(s, "&test.OrBranch{")
21191 s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n")
21192 s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n")
21193 if this.XXX_unrecognized != nil {
21194 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21195 }
21196 s = append(s, "}")
21197 return strings.Join(s, "")
21198 }
21199 func (this *AndBranch) GoString() string {
21200 if this == nil {
21201 return "nil"
21202 }
21203 s := make([]string, 0, 6)
21204 s = append(s, "&test.AndBranch{")
21205 s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n")
21206 s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n")
21207 if this.XXX_unrecognized != nil {
21208 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21209 }
21210 s = append(s, "}")
21211 return strings.Join(s, "")
21212 }
21213 func (this *Leaf) GoString() string {
21214 if this == nil {
21215 return "nil"
21216 }
21217 s := make([]string, 0, 6)
21218 s = append(s, "&test.Leaf{")
21219 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
21220 s = append(s, "StrValue: "+fmt.Sprintf("%#v", this.StrValue)+",\n")
21221 if this.XXX_unrecognized != nil {
21222 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21223 }
21224 s = append(s, "}")
21225 return strings.Join(s, "")
21226 }
21227 func (this *DeepTree) GoString() string {
21228 if this == nil {
21229 return "nil"
21230 }
21231 s := make([]string, 0, 7)
21232 s = append(s, "&test.DeepTree{")
21233 if this.Down != nil {
21234 s = append(s, "Down: "+fmt.Sprintf("%#v", this.Down)+",\n")
21235 }
21236 if this.And != nil {
21237 s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n")
21238 }
21239 if this.Leaf != nil {
21240 s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n")
21241 }
21242 if this.XXX_unrecognized != nil {
21243 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21244 }
21245 s = append(s, "}")
21246 return strings.Join(s, "")
21247 }
21248 func (this *ADeepBranch) GoString() string {
21249 if this == nil {
21250 return "nil"
21251 }
21252 s := make([]string, 0, 5)
21253 s = append(s, "&test.ADeepBranch{")
21254 s = append(s, "Down: "+strings.Replace(this.Down.GoString(), `&`, ``, 1)+",\n")
21255 if this.XXX_unrecognized != nil {
21256 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21257 }
21258 s = append(s, "}")
21259 return strings.Join(s, "")
21260 }
21261 func (this *AndDeepBranch) GoString() string {
21262 if this == nil {
21263 return "nil"
21264 }
21265 s := make([]string, 0, 6)
21266 s = append(s, "&test.AndDeepBranch{")
21267 s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n")
21268 s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n")
21269 if this.XXX_unrecognized != nil {
21270 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21271 }
21272 s = append(s, "}")
21273 return strings.Join(s, "")
21274 }
21275 func (this *DeepLeaf) GoString() string {
21276 if this == nil {
21277 return "nil"
21278 }
21279 s := make([]string, 0, 5)
21280 s = append(s, "&test.DeepLeaf{")
21281 s = append(s, "Tree: "+strings.Replace(this.Tree.GoString(), `&`, ``, 1)+",\n")
21282 if this.XXX_unrecognized != nil {
21283 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21284 }
21285 s = append(s, "}")
21286 return strings.Join(s, "")
21287 }
21288 func (this *Nil) GoString() string {
21289 if this == nil {
21290 return "nil"
21291 }
21292 s := make([]string, 0, 4)
21293 s = append(s, "&test.Nil{")
21294 if this.XXX_unrecognized != nil {
21295 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21296 }
21297 s = append(s, "}")
21298 return strings.Join(s, "")
21299 }
21300 func (this *NidOptEnum) GoString() string {
21301 if this == nil {
21302 return "nil"
21303 }
21304 s := make([]string, 0, 5)
21305 s = append(s, "&test.NidOptEnum{")
21306 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
21307 if this.XXX_unrecognized != nil {
21308 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21309 }
21310 s = append(s, "}")
21311 return strings.Join(s, "")
21312 }
21313 func (this *NinOptEnum) GoString() string {
21314 if this == nil {
21315 return "nil"
21316 }
21317 s := make([]string, 0, 7)
21318 s = append(s, "&test.NinOptEnum{")
21319 if this.Field1 != nil {
21320 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "TheTestEnum")+",\n")
21321 }
21322 if this.Field2 != nil {
21323 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "YetAnotherTestEnum")+",\n")
21324 }
21325 if this.Field3 != nil {
21326 s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "YetYetAnotherTestEnum")+",\n")
21327 }
21328 if this.XXX_unrecognized != nil {
21329 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21330 }
21331 s = append(s, "}")
21332 return strings.Join(s, "")
21333 }
21334 func (this *NidRepEnum) GoString() string {
21335 if this == nil {
21336 return "nil"
21337 }
21338 s := make([]string, 0, 7)
21339 s = append(s, "&test.NidRepEnum{")
21340 if this.Field1 != nil {
21341 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
21342 }
21343 if this.Field2 != nil {
21344 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
21345 }
21346 if this.Field3 != nil {
21347 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
21348 }
21349 if this.XXX_unrecognized != nil {
21350 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21351 }
21352 s = append(s, "}")
21353 return strings.Join(s, "")
21354 }
21355 func (this *NinRepEnum) GoString() string {
21356 if this == nil {
21357 return "nil"
21358 }
21359 s := make([]string, 0, 7)
21360 s = append(s, "&test.NinRepEnum{")
21361 if this.Field1 != nil {
21362 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
21363 }
21364 if this.Field2 != nil {
21365 s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
21366 }
21367 if this.Field3 != nil {
21368 s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
21369 }
21370 if this.XXX_unrecognized != nil {
21371 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21372 }
21373 s = append(s, "}")
21374 return strings.Join(s, "")
21375 }
21376 func (this *NinOptEnumDefault) GoString() string {
21377 if this == nil {
21378 return "nil"
21379 }
21380 s := make([]string, 0, 7)
21381 s = append(s, "&test.NinOptEnumDefault{")
21382 if this.Field1 != nil {
21383 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "TheTestEnum")+",\n")
21384 }
21385 if this.Field2 != nil {
21386 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "YetAnotherTestEnum")+",\n")
21387 }
21388 if this.Field3 != nil {
21389 s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "YetYetAnotherTestEnum")+",\n")
21390 }
21391 if this.XXX_unrecognized != nil {
21392 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21393 }
21394 s = append(s, "}")
21395 return strings.Join(s, "")
21396 }
21397 func (this *AnotherNinOptEnum) GoString() string {
21398 if this == nil {
21399 return "nil"
21400 }
21401 s := make([]string, 0, 7)
21402 s = append(s, "&test.AnotherNinOptEnum{")
21403 if this.Field1 != nil {
21404 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "AnotherTestEnum")+",\n")
21405 }
21406 if this.Field2 != nil {
21407 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "YetAnotherTestEnum")+",\n")
21408 }
21409 if this.Field3 != nil {
21410 s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "YetYetAnotherTestEnum")+",\n")
21411 }
21412 if this.XXX_unrecognized != nil {
21413 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21414 }
21415 s = append(s, "}")
21416 return strings.Join(s, "")
21417 }
21418 func (this *AnotherNinOptEnumDefault) GoString() string {
21419 if this == nil {
21420 return "nil"
21421 }
21422 s := make([]string, 0, 7)
21423 s = append(s, "&test.AnotherNinOptEnumDefault{")
21424 if this.Field1 != nil {
21425 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "AnotherTestEnum")+",\n")
21426 }
21427 if this.Field2 != nil {
21428 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "YetAnotherTestEnum")+",\n")
21429 }
21430 if this.Field3 != nil {
21431 s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "YetYetAnotherTestEnum")+",\n")
21432 }
21433 if this.XXX_unrecognized != nil {
21434 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21435 }
21436 s = append(s, "}")
21437 return strings.Join(s, "")
21438 }
21439 func (this *Timer) GoString() string {
21440 if this == nil {
21441 return "nil"
21442 }
21443 s := make([]string, 0, 7)
21444 s = append(s, "&test.Timer{")
21445 s = append(s, "Time1: "+fmt.Sprintf("%#v", this.Time1)+",\n")
21446 s = append(s, "Time2: "+fmt.Sprintf("%#v", this.Time2)+",\n")
21447 s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
21448 if this.XXX_unrecognized != nil {
21449 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21450 }
21451 s = append(s, "}")
21452 return strings.Join(s, "")
21453 }
21454 func (this *MyExtendable) GoString() string {
21455 if this == nil {
21456 return "nil"
21457 }
21458 s := make([]string, 0, 5)
21459 s = append(s, "&test.MyExtendable{")
21460 if this.Field1 != nil {
21461 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n")
21462 }
21463 s = append(s, "XXX_InternalExtensions: "+extensionToGoStringThetest(this)+",\n")
21464 if this.XXX_unrecognized != nil {
21465 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21466 }
21467 s = append(s, "}")
21468 return strings.Join(s, "")
21469 }
21470 func (this *OtherExtenable) GoString() string {
21471 if this == nil {
21472 return "nil"
21473 }
21474 s := make([]string, 0, 7)
21475 s = append(s, "&test.OtherExtenable{")
21476 if this.Field2 != nil {
21477 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "int64")+",\n")
21478 }
21479 if this.Field13 != nil {
21480 s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "int64")+",\n")
21481 }
21482 if this.M != nil {
21483 s = append(s, "M: "+fmt.Sprintf("%#v", this.M)+",\n")
21484 }
21485 s = append(s, "XXX_InternalExtensions: "+extensionToGoStringThetest(this)+",\n")
21486 if this.XXX_unrecognized != nil {
21487 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21488 }
21489 s = append(s, "}")
21490 return strings.Join(s, "")
21491 }
21492 func (this *NestedDefinition) GoString() string {
21493 if this == nil {
21494 return "nil"
21495 }
21496 s := make([]string, 0, 8)
21497 s = append(s, "&test.NestedDefinition{")
21498 if this.Field1 != nil {
21499 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n")
21500 }
21501 if this.EnumField != nil {
21502 s = append(s, "EnumField: "+valueToGoStringThetest(this.EnumField, "NestedDefinition_NestedEnum")+",\n")
21503 }
21504 if this.NNM != nil {
21505 s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n")
21506 }
21507 if this.NM != nil {
21508 s = append(s, "NM: "+fmt.Sprintf("%#v", this.NM)+",\n")
21509 }
21510 if this.XXX_unrecognized != nil {
21511 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21512 }
21513 s = append(s, "}")
21514 return strings.Join(s, "")
21515 }
21516 func (this *NestedDefinition_NestedMessage) GoString() string {
21517 if this == nil {
21518 return "nil"
21519 }
21520 s := make([]string, 0, 6)
21521 s = append(s, "&test.NestedDefinition_NestedMessage{")
21522 if this.NestedField1 != nil {
21523 s = append(s, "NestedField1: "+valueToGoStringThetest(this.NestedField1, "uint64")+",\n")
21524 }
21525 if this.NNM != nil {
21526 s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n")
21527 }
21528 if this.XXX_unrecognized != nil {
21529 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21530 }
21531 s = append(s, "}")
21532 return strings.Join(s, "")
21533 }
21534 func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GoString() string {
21535 if this == nil {
21536 return "nil"
21537 }
21538 s := make([]string, 0, 5)
21539 s = append(s, "&test.NestedDefinition_NestedMessage_NestedNestedMsg{")
21540 if this.NestedNestedField1 != nil {
21541 s = append(s, "NestedNestedField1: "+valueToGoStringThetest(this.NestedNestedField1, "string")+",\n")
21542 }
21543 if this.XXX_unrecognized != nil {
21544 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21545 }
21546 s = append(s, "}")
21547 return strings.Join(s, "")
21548 }
21549 func (this *NestedScope) GoString() string {
21550 if this == nil {
21551 return "nil"
21552 }
21553 s := make([]string, 0, 7)
21554 s = append(s, "&test.NestedScope{")
21555 if this.A != nil {
21556 s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n")
21557 }
21558 if this.B != nil {
21559 s = append(s, "B: "+valueToGoStringThetest(this.B, "NestedDefinition_NestedEnum")+",\n")
21560 }
21561 if this.C != nil {
21562 s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n")
21563 }
21564 if this.XXX_unrecognized != nil {
21565 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21566 }
21567 s = append(s, "}")
21568 return strings.Join(s, "")
21569 }
21570 func (this *NinOptNativeDefault) GoString() string {
21571 if this == nil {
21572 return "nil"
21573 }
21574 s := make([]string, 0, 19)
21575 s = append(s, "&test.NinOptNativeDefault{")
21576 if this.Field1 != nil {
21577 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n")
21578 }
21579 if this.Field2 != nil {
21580 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n")
21581 }
21582 if this.Field3 != nil {
21583 s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n")
21584 }
21585 if this.Field4 != nil {
21586 s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n")
21587 }
21588 if this.Field5 != nil {
21589 s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n")
21590 }
21591 if this.Field6 != nil {
21592 s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n")
21593 }
21594 if this.Field7 != nil {
21595 s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n")
21596 }
21597 if this.Field8 != nil {
21598 s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n")
21599 }
21600 if this.Field9 != nil {
21601 s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n")
21602 }
21603 if this.Field10 != nil {
21604 s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n")
21605 }
21606 if this.Field11 != nil {
21607 s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n")
21608 }
21609 if this.Field12 != nil {
21610 s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n")
21611 }
21612 if this.Field13 != nil {
21613 s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n")
21614 }
21615 if this.Field14 != nil {
21616 s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n")
21617 }
21618 if this.Field15 != nil {
21619 s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n")
21620 }
21621 if this.XXX_unrecognized != nil {
21622 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21623 }
21624 s = append(s, "}")
21625 return strings.Join(s, "")
21626 }
21627 func (this *CustomContainer) GoString() string {
21628 if this == nil {
21629 return "nil"
21630 }
21631 s := make([]string, 0, 5)
21632 s = append(s, "&test.CustomContainer{")
21633 s = append(s, "CustomStruct: "+strings.Replace(this.CustomStruct.GoString(), `&`, ``, 1)+",\n")
21634 if this.XXX_unrecognized != nil {
21635 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21636 }
21637 s = append(s, "}")
21638 return strings.Join(s, "")
21639 }
21640 func (this *CustomNameNidOptNative) GoString() string {
21641 if this == nil {
21642 return "nil"
21643 }
21644 s := make([]string, 0, 19)
21645 s = append(s, "&test.CustomNameNidOptNative{")
21646 s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n")
21647 s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n")
21648 s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n")
21649 s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n")
21650 s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n")
21651 s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n")
21652 s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n")
21653 s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n")
21654 s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n")
21655 s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n")
21656 s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n")
21657 s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n")
21658 s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n")
21659 s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n")
21660 s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n")
21661 if this.XXX_unrecognized != nil {
21662 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21663 }
21664 s = append(s, "}")
21665 return strings.Join(s, "")
21666 }
21667 func (this *CustomNameNinOptNative) GoString() string {
21668 if this == nil {
21669 return "nil"
21670 }
21671 s := make([]string, 0, 19)
21672 s = append(s, "&test.CustomNameNinOptNative{")
21673 if this.FieldA != nil {
21674 s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n")
21675 }
21676 if this.FieldB != nil {
21677 s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n")
21678 }
21679 if this.FieldC != nil {
21680 s = append(s, "FieldC: "+valueToGoStringThetest(this.FieldC, "int32")+",\n")
21681 }
21682 if this.FieldD != nil {
21683 s = append(s, "FieldD: "+valueToGoStringThetest(this.FieldD, "int64")+",\n")
21684 }
21685 if this.FieldE != nil {
21686 s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint32")+",\n")
21687 }
21688 if this.FieldF != nil {
21689 s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "uint64")+",\n")
21690 }
21691 if this.FieldG != nil {
21692 s = append(s, "FieldG: "+valueToGoStringThetest(this.FieldG, "int32")+",\n")
21693 }
21694 if this.FieldH != nil {
21695 s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "int64")+",\n")
21696 }
21697 if this.FieldI != nil {
21698 s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "uint32")+",\n")
21699 }
21700 if this.FieldJ != nil {
21701 s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "int32")+",\n")
21702 }
21703 if this.FieldK != nil {
21704 s = append(s, "FieldK: "+valueToGoStringThetest(this.FieldK, "uint64")+",\n")
21705 }
21706 if this.FielL != nil {
21707 s = append(s, "FielL: "+valueToGoStringThetest(this.FielL, "int64")+",\n")
21708 }
21709 if this.FieldM != nil {
21710 s = append(s, "FieldM: "+valueToGoStringThetest(this.FieldM, "bool")+",\n")
21711 }
21712 if this.FieldN != nil {
21713 s = append(s, "FieldN: "+valueToGoStringThetest(this.FieldN, "string")+",\n")
21714 }
21715 if this.FieldO != nil {
21716 s = append(s, "FieldO: "+valueToGoStringThetest(this.FieldO, "byte")+",\n")
21717 }
21718 if this.XXX_unrecognized != nil {
21719 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21720 }
21721 s = append(s, "}")
21722 return strings.Join(s, "")
21723 }
21724 func (this *CustomNameNinRepNative) GoString() string {
21725 if this == nil {
21726 return "nil"
21727 }
21728 s := make([]string, 0, 19)
21729 s = append(s, "&test.CustomNameNinRepNative{")
21730 if this.FieldA != nil {
21731 s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n")
21732 }
21733 if this.FieldB != nil {
21734 s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n")
21735 }
21736 if this.FieldC != nil {
21737 s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n")
21738 }
21739 if this.FieldD != nil {
21740 s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n")
21741 }
21742 if this.FieldE != nil {
21743 s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n")
21744 }
21745 if this.FieldF != nil {
21746 s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n")
21747 }
21748 if this.FieldG != nil {
21749 s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n")
21750 }
21751 if this.FieldH != nil {
21752 s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n")
21753 }
21754 if this.FieldI != nil {
21755 s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n")
21756 }
21757 if this.FieldJ != nil {
21758 s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n")
21759 }
21760 if this.FieldK != nil {
21761 s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n")
21762 }
21763 if this.FieldL != nil {
21764 s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n")
21765 }
21766 if this.FieldM != nil {
21767 s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n")
21768 }
21769 if this.FieldN != nil {
21770 s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n")
21771 }
21772 if this.FieldO != nil {
21773 s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n")
21774 }
21775 if this.XXX_unrecognized != nil {
21776 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21777 }
21778 s = append(s, "}")
21779 return strings.Join(s, "")
21780 }
21781 func (this *CustomNameNinStruct) GoString() string {
21782 if this == nil {
21783 return "nil"
21784 }
21785 s := make([]string, 0, 14)
21786 s = append(s, "&test.CustomNameNinStruct{")
21787 if this.FieldA != nil {
21788 s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n")
21789 }
21790 if this.FieldB != nil {
21791 s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n")
21792 }
21793 if this.FieldC != nil {
21794 s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n")
21795 }
21796 if this.FieldD != nil {
21797 s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n")
21798 }
21799 if this.FieldE != nil {
21800 s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint64")+",\n")
21801 }
21802 if this.FieldF != nil {
21803 s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "int32")+",\n")
21804 }
21805 if this.FieldG != nil {
21806 s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n")
21807 }
21808 if this.FieldH != nil {
21809 s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "bool")+",\n")
21810 }
21811 if this.FieldI != nil {
21812 s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "string")+",\n")
21813 }
21814 if this.FieldJ != nil {
21815 s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "byte")+",\n")
21816 }
21817 if this.XXX_unrecognized != nil {
21818 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21819 }
21820 s = append(s, "}")
21821 return strings.Join(s, "")
21822 }
21823 func (this *CustomNameCustomType) GoString() string {
21824 if this == nil {
21825 return "nil"
21826 }
21827 s := make([]string, 0, 8)
21828 s = append(s, "&test.CustomNameCustomType{")
21829 if this.FieldA != nil {
21830 s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "Uuid")+",\n")
21831 }
21832 if this.FieldB != nil {
21833 s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "github_com_gogo_protobuf_test_custom.Uint128")+",\n")
21834 }
21835 if this.FieldC != nil {
21836 s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n")
21837 }
21838 if this.FieldD != nil {
21839 s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n")
21840 }
21841 if this.XXX_unrecognized != nil {
21842 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21843 }
21844 s = append(s, "}")
21845 return strings.Join(s, "")
21846 }
21847 func (this *CustomNameNinEmbeddedStructUnion) GoString() string {
21848 if this == nil {
21849 return "nil"
21850 }
21851 s := make([]string, 0, 7)
21852 s = append(s, "&test.CustomNameNinEmbeddedStructUnion{")
21853 if this.NidOptNative != nil {
21854 s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n")
21855 }
21856 if this.FieldA != nil {
21857 s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n")
21858 }
21859 if this.FieldB != nil {
21860 s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "bool")+",\n")
21861 }
21862 if this.XXX_unrecognized != nil {
21863 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21864 }
21865 s = append(s, "}")
21866 return strings.Join(s, "")
21867 }
21868 func (this *CustomNameEnum) GoString() string {
21869 if this == nil {
21870 return "nil"
21871 }
21872 s := make([]string, 0, 6)
21873 s = append(s, "&test.CustomNameEnum{")
21874 if this.FieldA != nil {
21875 s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "TheTestEnum")+",\n")
21876 }
21877 if this.FieldB != nil {
21878 s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n")
21879 }
21880 if this.XXX_unrecognized != nil {
21881 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21882 }
21883 s = append(s, "}")
21884 return strings.Join(s, "")
21885 }
21886 func (this *NoExtensionsMap) GoString() string {
21887 if this == nil {
21888 return "nil"
21889 }
21890 s := make([]string, 0, 5)
21891 s = append(s, "&test.NoExtensionsMap{")
21892 if this.Field1 != nil {
21893 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n")
21894 }
21895 if this.XXX_extensions != nil {
21896 s = append(s, "XXX_extensions: "+fmt.Sprintf("%#v", this.XXX_extensions)+",\n")
21897 }
21898 if this.XXX_unrecognized != nil {
21899 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21900 }
21901 s = append(s, "}")
21902 return strings.Join(s, "")
21903 }
21904 func (this *Unrecognized) GoString() string {
21905 if this == nil {
21906 return "nil"
21907 }
21908 s := make([]string, 0, 5)
21909 s = append(s, "&test.Unrecognized{")
21910 if this.Field1 != nil {
21911 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "string")+",\n")
21912 }
21913 s = append(s, "}")
21914 return strings.Join(s, "")
21915 }
21916 func (this *UnrecognizedWithInner) GoString() string {
21917 if this == nil {
21918 return "nil"
21919 }
21920 s := make([]string, 0, 6)
21921 s = append(s, "&test.UnrecognizedWithInner{")
21922 if this.Embedded != nil {
21923 s = append(s, "Embedded: "+fmt.Sprintf("%#v", this.Embedded)+",\n")
21924 }
21925 if this.Field2 != nil {
21926 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n")
21927 }
21928 if this.XXX_unrecognized != nil {
21929 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21930 }
21931 s = append(s, "}")
21932 return strings.Join(s, "")
21933 }
21934 func (this *UnrecognizedWithInner_Inner) GoString() string {
21935 if this == nil {
21936 return "nil"
21937 }
21938 s := make([]string, 0, 5)
21939 s = append(s, "&test.UnrecognizedWithInner_Inner{")
21940 if this.Field1 != nil {
21941 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n")
21942 }
21943 s = append(s, "}")
21944 return strings.Join(s, "")
21945 }
21946 func (this *UnrecognizedWithEmbed) GoString() string {
21947 if this == nil {
21948 return "nil"
21949 }
21950 s := make([]string, 0, 6)
21951 s = append(s, "&test.UnrecognizedWithEmbed{")
21952 s = append(s, "UnrecognizedWithEmbed_Embedded: "+strings.Replace(this.UnrecognizedWithEmbed_Embedded.GoString(), `&`, ``, 1)+",\n")
21953 if this.Field2 != nil {
21954 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n")
21955 }
21956 if this.XXX_unrecognized != nil {
21957 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21958 }
21959 s = append(s, "}")
21960 return strings.Join(s, "")
21961 }
21962 func (this *UnrecognizedWithEmbed_Embedded) GoString() string {
21963 if this == nil {
21964 return "nil"
21965 }
21966 s := make([]string, 0, 5)
21967 s = append(s, "&test.UnrecognizedWithEmbed_Embedded{")
21968 if this.Field1 != nil {
21969 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n")
21970 }
21971 s = append(s, "}")
21972 return strings.Join(s, "")
21973 }
21974 func (this *Node) GoString() string {
21975 if this == nil {
21976 return "nil"
21977 }
21978 s := make([]string, 0, 6)
21979 s = append(s, "&test.Node{")
21980 if this.Label != nil {
21981 s = append(s, "Label: "+valueToGoStringThetest(this.Label, "string")+",\n")
21982 }
21983 if this.Children != nil {
21984 s = append(s, "Children: "+fmt.Sprintf("%#v", this.Children)+",\n")
21985 }
21986 if this.XXX_unrecognized != nil {
21987 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
21988 }
21989 s = append(s, "}")
21990 return strings.Join(s, "")
21991 }
21992 func (this *NonByteCustomType) GoString() string {
21993 if this == nil {
21994 return "nil"
21995 }
21996 s := make([]string, 0, 5)
21997 s = append(s, "&test.NonByteCustomType{")
21998 if this.Field1 != nil {
21999 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "T")+",\n")
22000 }
22001 if this.XXX_unrecognized != nil {
22002 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
22003 }
22004 s = append(s, "}")
22005 return strings.Join(s, "")
22006 }
22007 func (this *NidOptNonByteCustomType) GoString() string {
22008 if this == nil {
22009 return "nil"
22010 }
22011 s := make([]string, 0, 5)
22012 s = append(s, "&test.NidOptNonByteCustomType{")
22013 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
22014 if this.XXX_unrecognized != nil {
22015 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
22016 }
22017 s = append(s, "}")
22018 return strings.Join(s, "")
22019 }
22020 func (this *NinOptNonByteCustomType) GoString() string {
22021 if this == nil {
22022 return "nil"
22023 }
22024 s := make([]string, 0, 5)
22025 s = append(s, "&test.NinOptNonByteCustomType{")
22026 if this.Field1 != nil {
22027 s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "T")+",\n")
22028 }
22029 if this.XXX_unrecognized != nil {
22030 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
22031 }
22032 s = append(s, "}")
22033 return strings.Join(s, "")
22034 }
22035 func (this *NidRepNonByteCustomType) GoString() string {
22036 if this == nil {
22037 return "nil"
22038 }
22039 s := make([]string, 0, 5)
22040 s = append(s, "&test.NidRepNonByteCustomType{")
22041 if this.Field1 != nil {
22042 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
22043 }
22044 if this.XXX_unrecognized != nil {
22045 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
22046 }
22047 s = append(s, "}")
22048 return strings.Join(s, "")
22049 }
22050 func (this *NinRepNonByteCustomType) GoString() string {
22051 if this == nil {
22052 return "nil"
22053 }
22054 s := make([]string, 0, 5)
22055 s = append(s, "&test.NinRepNonByteCustomType{")
22056 if this.Field1 != nil {
22057 s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
22058 }
22059 if this.XXX_unrecognized != nil {
22060 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
22061 }
22062 s = append(s, "}")
22063 return strings.Join(s, "")
22064 }
22065 func (this *ProtoType) GoString() string {
22066 if this == nil {
22067 return "nil"
22068 }
22069 s := make([]string, 0, 5)
22070 s = append(s, "&test.ProtoType{")
22071 if this.Field2 != nil {
22072 s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n")
22073 }
22074 if this.XXX_unrecognized != nil {
22075 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
22076 }
22077 s = append(s, "}")
22078 return strings.Join(s, "")
22079 }
22080 func valueToGoStringThetest(v interface{}, typ string) string {
22081 rv := reflect.ValueOf(v)
22082 if rv.IsNil() {
22083 return "nil"
22084 }
22085 pv := reflect.Indirect(rv).Interface()
22086 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
22087 }
22088 func extensionToGoStringThetest(m github_com_gogo_protobuf_proto.Message) string {
22089 e := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(m)
22090 if e == nil {
22091 return "nil"
22092 }
22093 s := "proto.NewUnsafeXXX_InternalExtensions(map[int32]proto.Extension{"
22094 keys := make([]int, 0, len(e))
22095 for k := range e {
22096 keys = append(keys, int(k))
22097 }
22098 sort.Ints(keys)
22099 ss := []string{}
22100 for _, k := range keys {
22101 ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
22102 }
22103 s += strings.Join(ss, ",") + "})"
22104 return s
22105 }
22106 func (m *NidOptNative) Marshal() (dAtA []byte, err error) {
22107 size := m.Size()
22108 dAtA = make([]byte, size)
22109 n, err := m.MarshalToSizedBuffer(dAtA[:size])
22110 if err != nil {
22111 return nil, err
22112 }
22113 return dAtA[:n], nil
22114 }
22115
22116 func (m *NidOptNative) MarshalTo(dAtA []byte) (int, error) {
22117 size := m.Size()
22118 return m.MarshalToSizedBuffer(dAtA[:size])
22119 }
22120
22121 func (m *NidOptNative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
22122 i := len(dAtA)
22123 _ = i
22124 var l int
22125 _ = l
22126 if m.XXX_unrecognized != nil {
22127 i -= len(m.XXX_unrecognized)
22128 copy(dAtA[i:], m.XXX_unrecognized)
22129 }
22130 if m.Field15 != nil {
22131 i -= len(m.Field15)
22132 copy(dAtA[i:], m.Field15)
22133 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15)))
22134 i--
22135 dAtA[i] = 0x7a
22136 }
22137 i -= len(m.Field14)
22138 copy(dAtA[i:], m.Field14)
22139 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field14)))
22140 i--
22141 dAtA[i] = 0x72
22142 i--
22143 if m.Field13 {
22144 dAtA[i] = 1
22145 } else {
22146 dAtA[i] = 0
22147 }
22148 i--
22149 dAtA[i] = 0x68
22150 i -= 8
22151 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field12))
22152 i--
22153 dAtA[i] = 0x61
22154 i -= 8
22155 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field11))
22156 i--
22157 dAtA[i] = 0x59
22158 i -= 4
22159 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field10))
22160 i--
22161 dAtA[i] = 0x55
22162 i -= 4
22163 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field9))
22164 i--
22165 dAtA[i] = 0x4d
22166 i = encodeVarintThetest(dAtA, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63))))
22167 i--
22168 dAtA[i] = 0x40
22169 i = encodeVarintThetest(dAtA, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31))))
22170 i--
22171 dAtA[i] = 0x38
22172 i = encodeVarintThetest(dAtA, i, uint64(m.Field6))
22173 i--
22174 dAtA[i] = 0x30
22175 i = encodeVarintThetest(dAtA, i, uint64(m.Field5))
22176 i--
22177 dAtA[i] = 0x28
22178 i = encodeVarintThetest(dAtA, i, uint64(m.Field4))
22179 i--
22180 dAtA[i] = 0x20
22181 i = encodeVarintThetest(dAtA, i, uint64(m.Field3))
22182 i--
22183 dAtA[i] = 0x18
22184 i -= 4
22185 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Field2))))
22186 i--
22187 dAtA[i] = 0x15
22188 i -= 8
22189 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Field1))))
22190 i--
22191 dAtA[i] = 0x9
22192 return len(dAtA) - i, nil
22193 }
22194
22195 func (m *NinOptNative) Marshal() (dAtA []byte, err error) {
22196 size := m.Size()
22197 dAtA = make([]byte, size)
22198 n, err := m.MarshalToSizedBuffer(dAtA[:size])
22199 if err != nil {
22200 return nil, err
22201 }
22202 return dAtA[:n], nil
22203 }
22204
22205 func (m *NinOptNative) MarshalTo(dAtA []byte) (int, error) {
22206 size := m.Size()
22207 return m.MarshalToSizedBuffer(dAtA[:size])
22208 }
22209
22210 func (m *NinOptNative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
22211 i := len(dAtA)
22212 _ = i
22213 var l int
22214 _ = l
22215 if m.XXX_unrecognized != nil {
22216 i -= len(m.XXX_unrecognized)
22217 copy(dAtA[i:], m.XXX_unrecognized)
22218 }
22219 if m.Field15 != nil {
22220 i -= len(m.Field15)
22221 copy(dAtA[i:], m.Field15)
22222 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15)))
22223 i--
22224 dAtA[i] = 0x7a
22225 }
22226 if m.Field14 != nil {
22227 i -= len(*m.Field14)
22228 copy(dAtA[i:], *m.Field14)
22229 i = encodeVarintThetest(dAtA, i, uint64(len(*m.Field14)))
22230 i--
22231 dAtA[i] = 0x72
22232 }
22233 if m.Field13 != nil {
22234 i--
22235 if *m.Field13 {
22236 dAtA[i] = 1
22237 } else {
22238 dAtA[i] = 0
22239 }
22240 i--
22241 dAtA[i] = 0x68
22242 }
22243 if m.Field12 != nil {
22244 i -= 8
22245 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.Field12))
22246 i--
22247 dAtA[i] = 0x61
22248 }
22249 if m.Field11 != nil {
22250 i -= 8
22251 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.Field11))
22252 i--
22253 dAtA[i] = 0x59
22254 }
22255 if m.Field10 != nil {
22256 i -= 4
22257 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.Field10))
22258 i--
22259 dAtA[i] = 0x55
22260 }
22261 if m.Field9 != nil {
22262 i -= 4
22263 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.Field9))
22264 i--
22265 dAtA[i] = 0x4d
22266 }
22267 if m.Field8 != nil {
22268 i = encodeVarintThetest(dAtA, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63))))
22269 i--
22270 dAtA[i] = 0x40
22271 }
22272 if m.Field7 != nil {
22273 i = encodeVarintThetest(dAtA, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31))))
22274 i--
22275 dAtA[i] = 0x38
22276 }
22277 if m.Field6 != nil {
22278 i = encodeVarintThetest(dAtA, i, uint64(*m.Field6))
22279 i--
22280 dAtA[i] = 0x30
22281 }
22282 if m.Field5 != nil {
22283 i = encodeVarintThetest(dAtA, i, uint64(*m.Field5))
22284 i--
22285 dAtA[i] = 0x28
22286 }
22287 if m.Field4 != nil {
22288 i = encodeVarintThetest(dAtA, i, uint64(*m.Field4))
22289 i--
22290 dAtA[i] = 0x20
22291 }
22292 if m.Field3 != nil {
22293 i = encodeVarintThetest(dAtA, i, uint64(*m.Field3))
22294 i--
22295 dAtA[i] = 0x18
22296 }
22297 if m.Field2 != nil {
22298 i -= 4
22299 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.Field2))))
22300 i--
22301 dAtA[i] = 0x15
22302 }
22303 if m.Field1 != nil {
22304 i -= 8
22305 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Field1))))
22306 i--
22307 dAtA[i] = 0x9
22308 }
22309 return len(dAtA) - i, nil
22310 }
22311
22312 func (m *NidRepNative) Marshal() (dAtA []byte, err error) {
22313 size := m.Size()
22314 dAtA = make([]byte, size)
22315 n, err := m.MarshalToSizedBuffer(dAtA[:size])
22316 if err != nil {
22317 return nil, err
22318 }
22319 return dAtA[:n], nil
22320 }
22321
22322 func (m *NidRepNative) MarshalTo(dAtA []byte) (int, error) {
22323 size := m.Size()
22324 return m.MarshalToSizedBuffer(dAtA[:size])
22325 }
22326
22327 func (m *NidRepNative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
22328 i := len(dAtA)
22329 _ = i
22330 var l int
22331 _ = l
22332 if m.XXX_unrecognized != nil {
22333 i -= len(m.XXX_unrecognized)
22334 copy(dAtA[i:], m.XXX_unrecognized)
22335 }
22336 if len(m.Field15) > 0 {
22337 for iNdEx := len(m.Field15) - 1; iNdEx >= 0; iNdEx-- {
22338 i -= len(m.Field15[iNdEx])
22339 copy(dAtA[i:], m.Field15[iNdEx])
22340 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15[iNdEx])))
22341 i--
22342 dAtA[i] = 0x7a
22343 }
22344 }
22345 if len(m.Field14) > 0 {
22346 for iNdEx := len(m.Field14) - 1; iNdEx >= 0; iNdEx-- {
22347 i -= len(m.Field14[iNdEx])
22348 copy(dAtA[i:], m.Field14[iNdEx])
22349 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field14[iNdEx])))
22350 i--
22351 dAtA[i] = 0x72
22352 }
22353 }
22354 if len(m.Field13) > 0 {
22355 for iNdEx := len(m.Field13) - 1; iNdEx >= 0; iNdEx-- {
22356 i--
22357 if m.Field13[iNdEx] {
22358 dAtA[i] = 1
22359 } else {
22360 dAtA[i] = 0
22361 }
22362 i--
22363 dAtA[i] = 0x68
22364 }
22365 }
22366 if len(m.Field12) > 0 {
22367 for iNdEx := len(m.Field12) - 1; iNdEx >= 0; iNdEx-- {
22368 i -= 8
22369 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field12[iNdEx]))
22370 i--
22371 dAtA[i] = 0x61
22372 }
22373 }
22374 if len(m.Field11) > 0 {
22375 for iNdEx := len(m.Field11) - 1; iNdEx >= 0; iNdEx-- {
22376 i -= 8
22377 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field11[iNdEx]))
22378 i--
22379 dAtA[i] = 0x59
22380 }
22381 }
22382 if len(m.Field10) > 0 {
22383 for iNdEx := len(m.Field10) - 1; iNdEx >= 0; iNdEx-- {
22384 i -= 4
22385 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field10[iNdEx]))
22386 i--
22387 dAtA[i] = 0x55
22388 }
22389 }
22390 if len(m.Field9) > 0 {
22391 for iNdEx := len(m.Field9) - 1; iNdEx >= 0; iNdEx-- {
22392 i -= 4
22393 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field9[iNdEx]))
22394 i--
22395 dAtA[i] = 0x4d
22396 }
22397 }
22398 if len(m.Field8) > 0 {
22399 for iNdEx := len(m.Field8) - 1; iNdEx >= 0; iNdEx-- {
22400 x1 := (uint64(m.Field8[iNdEx]) << 1) ^ uint64((m.Field8[iNdEx] >> 63))
22401 i = encodeVarintThetest(dAtA, i, uint64(x1))
22402 i--
22403 dAtA[i] = 0x40
22404 }
22405 }
22406 if len(m.Field7) > 0 {
22407 for iNdEx := len(m.Field7) - 1; iNdEx >= 0; iNdEx-- {
22408 x2 := (uint32(m.Field7[iNdEx]) << 1) ^ uint32((m.Field7[iNdEx] >> 31))
22409 i = encodeVarintThetest(dAtA, i, uint64(x2))
22410 i--
22411 dAtA[i] = 0x38
22412 }
22413 }
22414 if len(m.Field6) > 0 {
22415 for iNdEx := len(m.Field6) - 1; iNdEx >= 0; iNdEx-- {
22416 i = encodeVarintThetest(dAtA, i, uint64(m.Field6[iNdEx]))
22417 i--
22418 dAtA[i] = 0x30
22419 }
22420 }
22421 if len(m.Field5) > 0 {
22422 for iNdEx := len(m.Field5) - 1; iNdEx >= 0; iNdEx-- {
22423 i = encodeVarintThetest(dAtA, i, uint64(m.Field5[iNdEx]))
22424 i--
22425 dAtA[i] = 0x28
22426 }
22427 }
22428 if len(m.Field4) > 0 {
22429 for iNdEx := len(m.Field4) - 1; iNdEx >= 0; iNdEx-- {
22430 i = encodeVarintThetest(dAtA, i, uint64(m.Field4[iNdEx]))
22431 i--
22432 dAtA[i] = 0x20
22433 }
22434 }
22435 if len(m.Field3) > 0 {
22436 for iNdEx := len(m.Field3) - 1; iNdEx >= 0; iNdEx-- {
22437 i = encodeVarintThetest(dAtA, i, uint64(m.Field3[iNdEx]))
22438 i--
22439 dAtA[i] = 0x18
22440 }
22441 }
22442 if len(m.Field2) > 0 {
22443 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
22444 f3 := math.Float32bits(float32(m.Field2[iNdEx]))
22445 i -= 4
22446 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f3))
22447 i--
22448 dAtA[i] = 0x15
22449 }
22450 }
22451 if len(m.Field1) > 0 {
22452 for iNdEx := len(m.Field1) - 1; iNdEx >= 0; iNdEx-- {
22453 f4 := math.Float64bits(float64(m.Field1[iNdEx]))
22454 i -= 8
22455 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f4))
22456 i--
22457 dAtA[i] = 0x9
22458 }
22459 }
22460 return len(dAtA) - i, nil
22461 }
22462
22463 func (m *NinRepNative) Marshal() (dAtA []byte, err error) {
22464 size := m.Size()
22465 dAtA = make([]byte, size)
22466 n, err := m.MarshalToSizedBuffer(dAtA[:size])
22467 if err != nil {
22468 return nil, err
22469 }
22470 return dAtA[:n], nil
22471 }
22472
22473 func (m *NinRepNative) MarshalTo(dAtA []byte) (int, error) {
22474 size := m.Size()
22475 return m.MarshalToSizedBuffer(dAtA[:size])
22476 }
22477
22478 func (m *NinRepNative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
22479 i := len(dAtA)
22480 _ = i
22481 var l int
22482 _ = l
22483 if m.XXX_unrecognized != nil {
22484 i -= len(m.XXX_unrecognized)
22485 copy(dAtA[i:], m.XXX_unrecognized)
22486 }
22487 if len(m.Field15) > 0 {
22488 for iNdEx := len(m.Field15) - 1; iNdEx >= 0; iNdEx-- {
22489 i -= len(m.Field15[iNdEx])
22490 copy(dAtA[i:], m.Field15[iNdEx])
22491 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15[iNdEx])))
22492 i--
22493 dAtA[i] = 0x7a
22494 }
22495 }
22496 if len(m.Field14) > 0 {
22497 for iNdEx := len(m.Field14) - 1; iNdEx >= 0; iNdEx-- {
22498 i -= len(m.Field14[iNdEx])
22499 copy(dAtA[i:], m.Field14[iNdEx])
22500 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field14[iNdEx])))
22501 i--
22502 dAtA[i] = 0x72
22503 }
22504 }
22505 if len(m.Field13) > 0 {
22506 for iNdEx := len(m.Field13) - 1; iNdEx >= 0; iNdEx-- {
22507 i--
22508 if m.Field13[iNdEx] {
22509 dAtA[i] = 1
22510 } else {
22511 dAtA[i] = 0
22512 }
22513 i--
22514 dAtA[i] = 0x68
22515 }
22516 }
22517 if len(m.Field12) > 0 {
22518 for iNdEx := len(m.Field12) - 1; iNdEx >= 0; iNdEx-- {
22519 i -= 8
22520 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field12[iNdEx]))
22521 i--
22522 dAtA[i] = 0x61
22523 }
22524 }
22525 if len(m.Field11) > 0 {
22526 for iNdEx := len(m.Field11) - 1; iNdEx >= 0; iNdEx-- {
22527 i -= 8
22528 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field11[iNdEx]))
22529 i--
22530 dAtA[i] = 0x59
22531 }
22532 }
22533 if len(m.Field10) > 0 {
22534 for iNdEx := len(m.Field10) - 1; iNdEx >= 0; iNdEx-- {
22535 i -= 4
22536 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field10[iNdEx]))
22537 i--
22538 dAtA[i] = 0x55
22539 }
22540 }
22541 if len(m.Field9) > 0 {
22542 for iNdEx := len(m.Field9) - 1; iNdEx >= 0; iNdEx-- {
22543 i -= 4
22544 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field9[iNdEx]))
22545 i--
22546 dAtA[i] = 0x4d
22547 }
22548 }
22549 if len(m.Field8) > 0 {
22550 for iNdEx := len(m.Field8) - 1; iNdEx >= 0; iNdEx-- {
22551 x5 := (uint64(m.Field8[iNdEx]) << 1) ^ uint64((m.Field8[iNdEx] >> 63))
22552 i = encodeVarintThetest(dAtA, i, uint64(x5))
22553 i--
22554 dAtA[i] = 0x40
22555 }
22556 }
22557 if len(m.Field7) > 0 {
22558 for iNdEx := len(m.Field7) - 1; iNdEx >= 0; iNdEx-- {
22559 x6 := (uint32(m.Field7[iNdEx]) << 1) ^ uint32((m.Field7[iNdEx] >> 31))
22560 i = encodeVarintThetest(dAtA, i, uint64(x6))
22561 i--
22562 dAtA[i] = 0x38
22563 }
22564 }
22565 if len(m.Field6) > 0 {
22566 for iNdEx := len(m.Field6) - 1; iNdEx >= 0; iNdEx-- {
22567 i = encodeVarintThetest(dAtA, i, uint64(m.Field6[iNdEx]))
22568 i--
22569 dAtA[i] = 0x30
22570 }
22571 }
22572 if len(m.Field5) > 0 {
22573 for iNdEx := len(m.Field5) - 1; iNdEx >= 0; iNdEx-- {
22574 i = encodeVarintThetest(dAtA, i, uint64(m.Field5[iNdEx]))
22575 i--
22576 dAtA[i] = 0x28
22577 }
22578 }
22579 if len(m.Field4) > 0 {
22580 for iNdEx := len(m.Field4) - 1; iNdEx >= 0; iNdEx-- {
22581 i = encodeVarintThetest(dAtA, i, uint64(m.Field4[iNdEx]))
22582 i--
22583 dAtA[i] = 0x20
22584 }
22585 }
22586 if len(m.Field3) > 0 {
22587 for iNdEx := len(m.Field3) - 1; iNdEx >= 0; iNdEx-- {
22588 i = encodeVarintThetest(dAtA, i, uint64(m.Field3[iNdEx]))
22589 i--
22590 dAtA[i] = 0x18
22591 }
22592 }
22593 if len(m.Field2) > 0 {
22594 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
22595 f7 := math.Float32bits(float32(m.Field2[iNdEx]))
22596 i -= 4
22597 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f7))
22598 i--
22599 dAtA[i] = 0x15
22600 }
22601 }
22602 if len(m.Field1) > 0 {
22603 for iNdEx := len(m.Field1) - 1; iNdEx >= 0; iNdEx-- {
22604 f8 := math.Float64bits(float64(m.Field1[iNdEx]))
22605 i -= 8
22606 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f8))
22607 i--
22608 dAtA[i] = 0x9
22609 }
22610 }
22611 return len(dAtA) - i, nil
22612 }
22613
22614 func (m *NidRepPackedNative) Marshal() (dAtA []byte, err error) {
22615 size := m.Size()
22616 dAtA = make([]byte, size)
22617 n, err := m.MarshalToSizedBuffer(dAtA[:size])
22618 if err != nil {
22619 return nil, err
22620 }
22621 return dAtA[:n], nil
22622 }
22623
22624 func (m *NidRepPackedNative) MarshalTo(dAtA []byte) (int, error) {
22625 size := m.Size()
22626 return m.MarshalToSizedBuffer(dAtA[:size])
22627 }
22628
22629 func (m *NidRepPackedNative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
22630 i := len(dAtA)
22631 _ = i
22632 var l int
22633 _ = l
22634 if m.XXX_unrecognized != nil {
22635 i -= len(m.XXX_unrecognized)
22636 copy(dAtA[i:], m.XXX_unrecognized)
22637 }
22638 if len(m.Field13) > 0 {
22639 for iNdEx := len(m.Field13) - 1; iNdEx >= 0; iNdEx-- {
22640 i--
22641 if m.Field13[iNdEx] {
22642 dAtA[i] = 1
22643 } else {
22644 dAtA[i] = 0
22645 }
22646 }
22647 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field13)))
22648 i--
22649 dAtA[i] = 0x6a
22650 }
22651 if len(m.Field12) > 0 {
22652 for iNdEx := len(m.Field12) - 1; iNdEx >= 0; iNdEx-- {
22653 i -= 8
22654 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field12[iNdEx]))
22655 }
22656 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field12)*8))
22657 i--
22658 dAtA[i] = 0x62
22659 }
22660 if len(m.Field11) > 0 {
22661 for iNdEx := len(m.Field11) - 1; iNdEx >= 0; iNdEx-- {
22662 i -= 8
22663 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field11[iNdEx]))
22664 }
22665 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field11)*8))
22666 i--
22667 dAtA[i] = 0x5a
22668 }
22669 if len(m.Field10) > 0 {
22670 for iNdEx := len(m.Field10) - 1; iNdEx >= 0; iNdEx-- {
22671 i -= 4
22672 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field10[iNdEx]))
22673 }
22674 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field10)*4))
22675 i--
22676 dAtA[i] = 0x52
22677 }
22678 if len(m.Field9) > 0 {
22679 for iNdEx := len(m.Field9) - 1; iNdEx >= 0; iNdEx-- {
22680 i -= 4
22681 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field9[iNdEx]))
22682 }
22683 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field9)*4))
22684 i--
22685 dAtA[i] = 0x4a
22686 }
22687 if len(m.Field8) > 0 {
22688 var j9 int
22689 dAtA11 := make([]byte, len(m.Field8)*10)
22690 for _, num := range m.Field8 {
22691 x10 := (uint64(num) << 1) ^ uint64((num >> 63))
22692 for x10 >= 1<<7 {
22693 dAtA11[j9] = uint8(uint64(x10)&0x7f | 0x80)
22694 j9++
22695 x10 >>= 7
22696 }
22697 dAtA11[j9] = uint8(x10)
22698 j9++
22699 }
22700 i -= j9
22701 copy(dAtA[i:], dAtA11[:j9])
22702 i = encodeVarintThetest(dAtA, i, uint64(j9))
22703 i--
22704 dAtA[i] = 0x42
22705 }
22706 if len(m.Field7) > 0 {
22707 dAtA12 := make([]byte, len(m.Field7)*5)
22708 var j13 int
22709 for _, num := range m.Field7 {
22710 x14 := (uint32(num) << 1) ^ uint32((num >> 31))
22711 for x14 >= 1<<7 {
22712 dAtA12[j13] = uint8(uint64(x14)&0x7f | 0x80)
22713 j13++
22714 x14 >>= 7
22715 }
22716 dAtA12[j13] = uint8(x14)
22717 j13++
22718 }
22719 i -= j13
22720 copy(dAtA[i:], dAtA12[:j13])
22721 i = encodeVarintThetest(dAtA, i, uint64(j13))
22722 i--
22723 dAtA[i] = 0x3a
22724 }
22725 if len(m.Field6) > 0 {
22726 dAtA16 := make([]byte, len(m.Field6)*10)
22727 var j15 int
22728 for _, num := range m.Field6 {
22729 for num >= 1<<7 {
22730 dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
22731 num >>= 7
22732 j15++
22733 }
22734 dAtA16[j15] = uint8(num)
22735 j15++
22736 }
22737 i -= j15
22738 copy(dAtA[i:], dAtA16[:j15])
22739 i = encodeVarintThetest(dAtA, i, uint64(j15))
22740 i--
22741 dAtA[i] = 0x32
22742 }
22743 if len(m.Field5) > 0 {
22744 dAtA18 := make([]byte, len(m.Field5)*10)
22745 var j17 int
22746 for _, num := range m.Field5 {
22747 for num >= 1<<7 {
22748 dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80)
22749 num >>= 7
22750 j17++
22751 }
22752 dAtA18[j17] = uint8(num)
22753 j17++
22754 }
22755 i -= j17
22756 copy(dAtA[i:], dAtA18[:j17])
22757 i = encodeVarintThetest(dAtA, i, uint64(j17))
22758 i--
22759 dAtA[i] = 0x2a
22760 }
22761 if len(m.Field4) > 0 {
22762 dAtA20 := make([]byte, len(m.Field4)*10)
22763 var j19 int
22764 for _, num1 := range m.Field4 {
22765 num := uint64(num1)
22766 for num >= 1<<7 {
22767 dAtA20[j19] = uint8(uint64(num)&0x7f | 0x80)
22768 num >>= 7
22769 j19++
22770 }
22771 dAtA20[j19] = uint8(num)
22772 j19++
22773 }
22774 i -= j19
22775 copy(dAtA[i:], dAtA20[:j19])
22776 i = encodeVarintThetest(dAtA, i, uint64(j19))
22777 i--
22778 dAtA[i] = 0x22
22779 }
22780 if len(m.Field3) > 0 {
22781 dAtA22 := make([]byte, len(m.Field3)*10)
22782 var j21 int
22783 for _, num1 := range m.Field3 {
22784 num := uint64(num1)
22785 for num >= 1<<7 {
22786 dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
22787 num >>= 7
22788 j21++
22789 }
22790 dAtA22[j21] = uint8(num)
22791 j21++
22792 }
22793 i -= j21
22794 copy(dAtA[i:], dAtA22[:j21])
22795 i = encodeVarintThetest(dAtA, i, uint64(j21))
22796 i--
22797 dAtA[i] = 0x1a
22798 }
22799 if len(m.Field2) > 0 {
22800 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
22801 f23 := math.Float32bits(float32(m.Field2[iNdEx]))
22802 i -= 4
22803 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f23))
22804 }
22805 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field2)*4))
22806 i--
22807 dAtA[i] = 0x12
22808 }
22809 if len(m.Field1) > 0 {
22810 for iNdEx := len(m.Field1) - 1; iNdEx >= 0; iNdEx-- {
22811 f24 := math.Float64bits(float64(m.Field1[iNdEx]))
22812 i -= 8
22813 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f24))
22814 }
22815 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field1)*8))
22816 i--
22817 dAtA[i] = 0xa
22818 }
22819 return len(dAtA) - i, nil
22820 }
22821
22822 func (m *NinRepPackedNative) Marshal() (dAtA []byte, err error) {
22823 size := m.Size()
22824 dAtA = make([]byte, size)
22825 n, err := m.MarshalToSizedBuffer(dAtA[:size])
22826 if err != nil {
22827 return nil, err
22828 }
22829 return dAtA[:n], nil
22830 }
22831
22832 func (m *NinRepPackedNative) MarshalTo(dAtA []byte) (int, error) {
22833 size := m.Size()
22834 return m.MarshalToSizedBuffer(dAtA[:size])
22835 }
22836
22837 func (m *NinRepPackedNative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
22838 i := len(dAtA)
22839 _ = i
22840 var l int
22841 _ = l
22842 if m.XXX_unrecognized != nil {
22843 i -= len(m.XXX_unrecognized)
22844 copy(dAtA[i:], m.XXX_unrecognized)
22845 }
22846 if len(m.Field13) > 0 {
22847 for iNdEx := len(m.Field13) - 1; iNdEx >= 0; iNdEx-- {
22848 i--
22849 if m.Field13[iNdEx] {
22850 dAtA[i] = 1
22851 } else {
22852 dAtA[i] = 0
22853 }
22854 }
22855 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field13)))
22856 i--
22857 dAtA[i] = 0x6a
22858 }
22859 if len(m.Field12) > 0 {
22860 for iNdEx := len(m.Field12) - 1; iNdEx >= 0; iNdEx-- {
22861 i -= 8
22862 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field12[iNdEx]))
22863 }
22864 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field12)*8))
22865 i--
22866 dAtA[i] = 0x62
22867 }
22868 if len(m.Field11) > 0 {
22869 for iNdEx := len(m.Field11) - 1; iNdEx >= 0; iNdEx-- {
22870 i -= 8
22871 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field11[iNdEx]))
22872 }
22873 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field11)*8))
22874 i--
22875 dAtA[i] = 0x5a
22876 }
22877 if len(m.Field10) > 0 {
22878 for iNdEx := len(m.Field10) - 1; iNdEx >= 0; iNdEx-- {
22879 i -= 4
22880 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field10[iNdEx]))
22881 }
22882 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field10)*4))
22883 i--
22884 dAtA[i] = 0x52
22885 }
22886 if len(m.Field9) > 0 {
22887 for iNdEx := len(m.Field9) - 1; iNdEx >= 0; iNdEx-- {
22888 i -= 4
22889 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field9[iNdEx]))
22890 }
22891 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field9)*4))
22892 i--
22893 dAtA[i] = 0x4a
22894 }
22895 if len(m.Field8) > 0 {
22896 var j25 int
22897 dAtA27 := make([]byte, len(m.Field8)*10)
22898 for _, num := range m.Field8 {
22899 x26 := (uint64(num) << 1) ^ uint64((num >> 63))
22900 for x26 >= 1<<7 {
22901 dAtA27[j25] = uint8(uint64(x26)&0x7f | 0x80)
22902 j25++
22903 x26 >>= 7
22904 }
22905 dAtA27[j25] = uint8(x26)
22906 j25++
22907 }
22908 i -= j25
22909 copy(dAtA[i:], dAtA27[:j25])
22910 i = encodeVarintThetest(dAtA, i, uint64(j25))
22911 i--
22912 dAtA[i] = 0x42
22913 }
22914 if len(m.Field7) > 0 {
22915 dAtA28 := make([]byte, len(m.Field7)*5)
22916 var j29 int
22917 for _, num := range m.Field7 {
22918 x30 := (uint32(num) << 1) ^ uint32((num >> 31))
22919 for x30 >= 1<<7 {
22920 dAtA28[j29] = uint8(uint64(x30)&0x7f | 0x80)
22921 j29++
22922 x30 >>= 7
22923 }
22924 dAtA28[j29] = uint8(x30)
22925 j29++
22926 }
22927 i -= j29
22928 copy(dAtA[i:], dAtA28[:j29])
22929 i = encodeVarintThetest(dAtA, i, uint64(j29))
22930 i--
22931 dAtA[i] = 0x3a
22932 }
22933 if len(m.Field6) > 0 {
22934 dAtA32 := make([]byte, len(m.Field6)*10)
22935 var j31 int
22936 for _, num := range m.Field6 {
22937 for num >= 1<<7 {
22938 dAtA32[j31] = uint8(uint64(num)&0x7f | 0x80)
22939 num >>= 7
22940 j31++
22941 }
22942 dAtA32[j31] = uint8(num)
22943 j31++
22944 }
22945 i -= j31
22946 copy(dAtA[i:], dAtA32[:j31])
22947 i = encodeVarintThetest(dAtA, i, uint64(j31))
22948 i--
22949 dAtA[i] = 0x32
22950 }
22951 if len(m.Field5) > 0 {
22952 dAtA34 := make([]byte, len(m.Field5)*10)
22953 var j33 int
22954 for _, num := range m.Field5 {
22955 for num >= 1<<7 {
22956 dAtA34[j33] = uint8(uint64(num)&0x7f | 0x80)
22957 num >>= 7
22958 j33++
22959 }
22960 dAtA34[j33] = uint8(num)
22961 j33++
22962 }
22963 i -= j33
22964 copy(dAtA[i:], dAtA34[:j33])
22965 i = encodeVarintThetest(dAtA, i, uint64(j33))
22966 i--
22967 dAtA[i] = 0x2a
22968 }
22969 if len(m.Field4) > 0 {
22970 dAtA36 := make([]byte, len(m.Field4)*10)
22971 var j35 int
22972 for _, num1 := range m.Field4 {
22973 num := uint64(num1)
22974 for num >= 1<<7 {
22975 dAtA36[j35] = uint8(uint64(num)&0x7f | 0x80)
22976 num >>= 7
22977 j35++
22978 }
22979 dAtA36[j35] = uint8(num)
22980 j35++
22981 }
22982 i -= j35
22983 copy(dAtA[i:], dAtA36[:j35])
22984 i = encodeVarintThetest(dAtA, i, uint64(j35))
22985 i--
22986 dAtA[i] = 0x22
22987 }
22988 if len(m.Field3) > 0 {
22989 dAtA38 := make([]byte, len(m.Field3)*10)
22990 var j37 int
22991 for _, num1 := range m.Field3 {
22992 num := uint64(num1)
22993 for num >= 1<<7 {
22994 dAtA38[j37] = uint8(uint64(num)&0x7f | 0x80)
22995 num >>= 7
22996 j37++
22997 }
22998 dAtA38[j37] = uint8(num)
22999 j37++
23000 }
23001 i -= j37
23002 copy(dAtA[i:], dAtA38[:j37])
23003 i = encodeVarintThetest(dAtA, i, uint64(j37))
23004 i--
23005 dAtA[i] = 0x1a
23006 }
23007 if len(m.Field2) > 0 {
23008 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
23009 f39 := math.Float32bits(float32(m.Field2[iNdEx]))
23010 i -= 4
23011 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f39))
23012 }
23013 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field2)*4))
23014 i--
23015 dAtA[i] = 0x12
23016 }
23017 if len(m.Field1) > 0 {
23018 for iNdEx := len(m.Field1) - 1; iNdEx >= 0; iNdEx-- {
23019 f40 := math.Float64bits(float64(m.Field1[iNdEx]))
23020 i -= 8
23021 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f40))
23022 }
23023 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field1)*8))
23024 i--
23025 dAtA[i] = 0xa
23026 }
23027 return len(dAtA) - i, nil
23028 }
23029
23030 func (m *NidOptStruct) Marshal() (dAtA []byte, err error) {
23031 size := m.Size()
23032 dAtA = make([]byte, size)
23033 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23034 if err != nil {
23035 return nil, err
23036 }
23037 return dAtA[:n], nil
23038 }
23039
23040 func (m *NidOptStruct) MarshalTo(dAtA []byte) (int, error) {
23041 size := m.Size()
23042 return m.MarshalToSizedBuffer(dAtA[:size])
23043 }
23044
23045 func (m *NidOptStruct) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23046 i := len(dAtA)
23047 _ = i
23048 var l int
23049 _ = l
23050 if m.XXX_unrecognized != nil {
23051 i -= len(m.XXX_unrecognized)
23052 copy(dAtA[i:], m.XXX_unrecognized)
23053 }
23054 if m.Field15 != nil {
23055 i -= len(m.Field15)
23056 copy(dAtA[i:], m.Field15)
23057 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15)))
23058 i--
23059 dAtA[i] = 0x7a
23060 }
23061 i -= len(m.Field14)
23062 copy(dAtA[i:], m.Field14)
23063 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field14)))
23064 i--
23065 dAtA[i] = 0x72
23066 i--
23067 if m.Field13 {
23068 dAtA[i] = 1
23069 } else {
23070 dAtA[i] = 0
23071 }
23072 i--
23073 dAtA[i] = 0x68
23074 {
23075 size, err := m.Field8.MarshalToSizedBuffer(dAtA[:i])
23076 if err != nil {
23077 return 0, err
23078 }
23079 i -= size
23080 i = encodeVarintThetest(dAtA, i, uint64(size))
23081 }
23082 i--
23083 dAtA[i] = 0x42
23084 i = encodeVarintThetest(dAtA, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31))))
23085 i--
23086 dAtA[i] = 0x38
23087 i = encodeVarintThetest(dAtA, i, uint64(m.Field6))
23088 i--
23089 dAtA[i] = 0x30
23090 {
23091 size, err := m.Field4.MarshalToSizedBuffer(dAtA[:i])
23092 if err != nil {
23093 return 0, err
23094 }
23095 i -= size
23096 i = encodeVarintThetest(dAtA, i, uint64(size))
23097 }
23098 i--
23099 dAtA[i] = 0x22
23100 {
23101 size, err := m.Field3.MarshalToSizedBuffer(dAtA[:i])
23102 if err != nil {
23103 return 0, err
23104 }
23105 i -= size
23106 i = encodeVarintThetest(dAtA, i, uint64(size))
23107 }
23108 i--
23109 dAtA[i] = 0x1a
23110 i -= 4
23111 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Field2))))
23112 i--
23113 dAtA[i] = 0x15
23114 i -= 8
23115 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Field1))))
23116 i--
23117 dAtA[i] = 0x9
23118 return len(dAtA) - i, nil
23119 }
23120
23121 func (m *NinOptStruct) Marshal() (dAtA []byte, err error) {
23122 size := m.Size()
23123 dAtA = make([]byte, size)
23124 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23125 if err != nil {
23126 return nil, err
23127 }
23128 return dAtA[:n], nil
23129 }
23130
23131 func (m *NinOptStruct) MarshalTo(dAtA []byte) (int, error) {
23132 size := m.Size()
23133 return m.MarshalToSizedBuffer(dAtA[:size])
23134 }
23135
23136 func (m *NinOptStruct) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23137 i := len(dAtA)
23138 _ = i
23139 var l int
23140 _ = l
23141 if m.XXX_unrecognized != nil {
23142 i -= len(m.XXX_unrecognized)
23143 copy(dAtA[i:], m.XXX_unrecognized)
23144 }
23145 if m.Field15 != nil {
23146 i -= len(m.Field15)
23147 copy(dAtA[i:], m.Field15)
23148 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15)))
23149 i--
23150 dAtA[i] = 0x7a
23151 }
23152 if m.Field14 != nil {
23153 i -= len(*m.Field14)
23154 copy(dAtA[i:], *m.Field14)
23155 i = encodeVarintThetest(dAtA, i, uint64(len(*m.Field14)))
23156 i--
23157 dAtA[i] = 0x72
23158 }
23159 if m.Field13 != nil {
23160 i--
23161 if *m.Field13 {
23162 dAtA[i] = 1
23163 } else {
23164 dAtA[i] = 0
23165 }
23166 i--
23167 dAtA[i] = 0x68
23168 }
23169 if m.Field8 != nil {
23170 {
23171 size, err := m.Field8.MarshalToSizedBuffer(dAtA[:i])
23172 if err != nil {
23173 return 0, err
23174 }
23175 i -= size
23176 i = encodeVarintThetest(dAtA, i, uint64(size))
23177 }
23178 i--
23179 dAtA[i] = 0x42
23180 }
23181 if m.Field7 != nil {
23182 i = encodeVarintThetest(dAtA, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31))))
23183 i--
23184 dAtA[i] = 0x38
23185 }
23186 if m.Field6 != nil {
23187 i = encodeVarintThetest(dAtA, i, uint64(*m.Field6))
23188 i--
23189 dAtA[i] = 0x30
23190 }
23191 if m.Field4 != nil {
23192 {
23193 size, err := m.Field4.MarshalToSizedBuffer(dAtA[:i])
23194 if err != nil {
23195 return 0, err
23196 }
23197 i -= size
23198 i = encodeVarintThetest(dAtA, i, uint64(size))
23199 }
23200 i--
23201 dAtA[i] = 0x22
23202 }
23203 if m.Field3 != nil {
23204 {
23205 size, err := m.Field3.MarshalToSizedBuffer(dAtA[:i])
23206 if err != nil {
23207 return 0, err
23208 }
23209 i -= size
23210 i = encodeVarintThetest(dAtA, i, uint64(size))
23211 }
23212 i--
23213 dAtA[i] = 0x1a
23214 }
23215 if m.Field2 != nil {
23216 i -= 4
23217 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.Field2))))
23218 i--
23219 dAtA[i] = 0x15
23220 }
23221 if m.Field1 != nil {
23222 i -= 8
23223 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Field1))))
23224 i--
23225 dAtA[i] = 0x9
23226 }
23227 return len(dAtA) - i, nil
23228 }
23229
23230 func (m *NidRepStruct) Marshal() (dAtA []byte, err error) {
23231 size := m.Size()
23232 dAtA = make([]byte, size)
23233 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23234 if err != nil {
23235 return nil, err
23236 }
23237 return dAtA[:n], nil
23238 }
23239
23240 func (m *NidRepStruct) MarshalTo(dAtA []byte) (int, error) {
23241 size := m.Size()
23242 return m.MarshalToSizedBuffer(dAtA[:size])
23243 }
23244
23245 func (m *NidRepStruct) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23246 i := len(dAtA)
23247 _ = i
23248 var l int
23249 _ = l
23250 if m.XXX_unrecognized != nil {
23251 i -= len(m.XXX_unrecognized)
23252 copy(dAtA[i:], m.XXX_unrecognized)
23253 }
23254 if len(m.Field15) > 0 {
23255 for iNdEx := len(m.Field15) - 1; iNdEx >= 0; iNdEx-- {
23256 i -= len(m.Field15[iNdEx])
23257 copy(dAtA[i:], m.Field15[iNdEx])
23258 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15[iNdEx])))
23259 i--
23260 dAtA[i] = 0x7a
23261 }
23262 }
23263 if len(m.Field14) > 0 {
23264 for iNdEx := len(m.Field14) - 1; iNdEx >= 0; iNdEx-- {
23265 i -= len(m.Field14[iNdEx])
23266 copy(dAtA[i:], m.Field14[iNdEx])
23267 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field14[iNdEx])))
23268 i--
23269 dAtA[i] = 0x72
23270 }
23271 }
23272 if len(m.Field13) > 0 {
23273 for iNdEx := len(m.Field13) - 1; iNdEx >= 0; iNdEx-- {
23274 i--
23275 if m.Field13[iNdEx] {
23276 dAtA[i] = 1
23277 } else {
23278 dAtA[i] = 0
23279 }
23280 i--
23281 dAtA[i] = 0x68
23282 }
23283 }
23284 if len(m.Field8) > 0 {
23285 for iNdEx := len(m.Field8) - 1; iNdEx >= 0; iNdEx-- {
23286 {
23287 size, err := m.Field8[iNdEx].MarshalToSizedBuffer(dAtA[:i])
23288 if err != nil {
23289 return 0, err
23290 }
23291 i -= size
23292 i = encodeVarintThetest(dAtA, i, uint64(size))
23293 }
23294 i--
23295 dAtA[i] = 0x42
23296 }
23297 }
23298 if len(m.Field7) > 0 {
23299 for iNdEx := len(m.Field7) - 1; iNdEx >= 0; iNdEx-- {
23300 x47 := (uint32(m.Field7[iNdEx]) << 1) ^ uint32((m.Field7[iNdEx] >> 31))
23301 i = encodeVarintThetest(dAtA, i, uint64(x47))
23302 i--
23303 dAtA[i] = 0x38
23304 }
23305 }
23306 if len(m.Field6) > 0 {
23307 for iNdEx := len(m.Field6) - 1; iNdEx >= 0; iNdEx-- {
23308 i = encodeVarintThetest(dAtA, i, uint64(m.Field6[iNdEx]))
23309 i--
23310 dAtA[i] = 0x30
23311 }
23312 }
23313 if len(m.Field4) > 0 {
23314 for iNdEx := len(m.Field4) - 1; iNdEx >= 0; iNdEx-- {
23315 {
23316 size, err := m.Field4[iNdEx].MarshalToSizedBuffer(dAtA[:i])
23317 if err != nil {
23318 return 0, err
23319 }
23320 i -= size
23321 i = encodeVarintThetest(dAtA, i, uint64(size))
23322 }
23323 i--
23324 dAtA[i] = 0x22
23325 }
23326 }
23327 if len(m.Field3) > 0 {
23328 for iNdEx := len(m.Field3) - 1; iNdEx >= 0; iNdEx-- {
23329 {
23330 size, err := m.Field3[iNdEx].MarshalToSizedBuffer(dAtA[:i])
23331 if err != nil {
23332 return 0, err
23333 }
23334 i -= size
23335 i = encodeVarintThetest(dAtA, i, uint64(size))
23336 }
23337 i--
23338 dAtA[i] = 0x1a
23339 }
23340 }
23341 if len(m.Field2) > 0 {
23342 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
23343 f48 := math.Float32bits(float32(m.Field2[iNdEx]))
23344 i -= 4
23345 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f48))
23346 i--
23347 dAtA[i] = 0x15
23348 }
23349 }
23350 if len(m.Field1) > 0 {
23351 for iNdEx := len(m.Field1) - 1; iNdEx >= 0; iNdEx-- {
23352 f49 := math.Float64bits(float64(m.Field1[iNdEx]))
23353 i -= 8
23354 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f49))
23355 i--
23356 dAtA[i] = 0x9
23357 }
23358 }
23359 return len(dAtA) - i, nil
23360 }
23361
23362 func (m *NinRepStruct) Marshal() (dAtA []byte, err error) {
23363 size := m.Size()
23364 dAtA = make([]byte, size)
23365 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23366 if err != nil {
23367 return nil, err
23368 }
23369 return dAtA[:n], nil
23370 }
23371
23372 func (m *NinRepStruct) MarshalTo(dAtA []byte) (int, error) {
23373 size := m.Size()
23374 return m.MarshalToSizedBuffer(dAtA[:size])
23375 }
23376
23377 func (m *NinRepStruct) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23378 i := len(dAtA)
23379 _ = i
23380 var l int
23381 _ = l
23382 if m.XXX_unrecognized != nil {
23383 i -= len(m.XXX_unrecognized)
23384 copy(dAtA[i:], m.XXX_unrecognized)
23385 }
23386 if len(m.Field15) > 0 {
23387 for iNdEx := len(m.Field15) - 1; iNdEx >= 0; iNdEx-- {
23388 i -= len(m.Field15[iNdEx])
23389 copy(dAtA[i:], m.Field15[iNdEx])
23390 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15[iNdEx])))
23391 i--
23392 dAtA[i] = 0x7a
23393 }
23394 }
23395 if len(m.Field14) > 0 {
23396 for iNdEx := len(m.Field14) - 1; iNdEx >= 0; iNdEx-- {
23397 i -= len(m.Field14[iNdEx])
23398 copy(dAtA[i:], m.Field14[iNdEx])
23399 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field14[iNdEx])))
23400 i--
23401 dAtA[i] = 0x72
23402 }
23403 }
23404 if len(m.Field13) > 0 {
23405 for iNdEx := len(m.Field13) - 1; iNdEx >= 0; iNdEx-- {
23406 i--
23407 if m.Field13[iNdEx] {
23408 dAtA[i] = 1
23409 } else {
23410 dAtA[i] = 0
23411 }
23412 i--
23413 dAtA[i] = 0x68
23414 }
23415 }
23416 if len(m.Field8) > 0 {
23417 for iNdEx := len(m.Field8) - 1; iNdEx >= 0; iNdEx-- {
23418 {
23419 size, err := m.Field8[iNdEx].MarshalToSizedBuffer(dAtA[:i])
23420 if err != nil {
23421 return 0, err
23422 }
23423 i -= size
23424 i = encodeVarintThetest(dAtA, i, uint64(size))
23425 }
23426 i--
23427 dAtA[i] = 0x42
23428 }
23429 }
23430 if len(m.Field7) > 0 {
23431 for iNdEx := len(m.Field7) - 1; iNdEx >= 0; iNdEx-- {
23432 x50 := (uint32(m.Field7[iNdEx]) << 1) ^ uint32((m.Field7[iNdEx] >> 31))
23433 i = encodeVarintThetest(dAtA, i, uint64(x50))
23434 i--
23435 dAtA[i] = 0x38
23436 }
23437 }
23438 if len(m.Field6) > 0 {
23439 for iNdEx := len(m.Field6) - 1; iNdEx >= 0; iNdEx-- {
23440 i = encodeVarintThetest(dAtA, i, uint64(m.Field6[iNdEx]))
23441 i--
23442 dAtA[i] = 0x30
23443 }
23444 }
23445 if len(m.Field4) > 0 {
23446 for iNdEx := len(m.Field4) - 1; iNdEx >= 0; iNdEx-- {
23447 {
23448 size, err := m.Field4[iNdEx].MarshalToSizedBuffer(dAtA[:i])
23449 if err != nil {
23450 return 0, err
23451 }
23452 i -= size
23453 i = encodeVarintThetest(dAtA, i, uint64(size))
23454 }
23455 i--
23456 dAtA[i] = 0x22
23457 }
23458 }
23459 if len(m.Field3) > 0 {
23460 for iNdEx := len(m.Field3) - 1; iNdEx >= 0; iNdEx-- {
23461 {
23462 size, err := m.Field3[iNdEx].MarshalToSizedBuffer(dAtA[:i])
23463 if err != nil {
23464 return 0, err
23465 }
23466 i -= size
23467 i = encodeVarintThetest(dAtA, i, uint64(size))
23468 }
23469 i--
23470 dAtA[i] = 0x1a
23471 }
23472 }
23473 if len(m.Field2) > 0 {
23474 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
23475 f51 := math.Float32bits(float32(m.Field2[iNdEx]))
23476 i -= 4
23477 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f51))
23478 i--
23479 dAtA[i] = 0x15
23480 }
23481 }
23482 if len(m.Field1) > 0 {
23483 for iNdEx := len(m.Field1) - 1; iNdEx >= 0; iNdEx-- {
23484 f52 := math.Float64bits(float64(m.Field1[iNdEx]))
23485 i -= 8
23486 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f52))
23487 i--
23488 dAtA[i] = 0x9
23489 }
23490 }
23491 return len(dAtA) - i, nil
23492 }
23493
23494 func (m *NidEmbeddedStruct) Marshal() (dAtA []byte, err error) {
23495 size := m.Size()
23496 dAtA = make([]byte, size)
23497 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23498 if err != nil {
23499 return nil, err
23500 }
23501 return dAtA[:n], nil
23502 }
23503
23504 func (m *NidEmbeddedStruct) MarshalTo(dAtA []byte) (int, error) {
23505 size := m.Size()
23506 return m.MarshalToSizedBuffer(dAtA[:size])
23507 }
23508
23509 func (m *NidEmbeddedStruct) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23510 i := len(dAtA)
23511 _ = i
23512 var l int
23513 _ = l
23514 if m.XXX_unrecognized != nil {
23515 i -= len(m.XXX_unrecognized)
23516 copy(dAtA[i:], m.XXX_unrecognized)
23517 }
23518 i--
23519 if m.Field210 {
23520 dAtA[i] = 1
23521 } else {
23522 dAtA[i] = 0
23523 }
23524 i--
23525 dAtA[i] = 0xd
23526 i--
23527 dAtA[i] = 0x90
23528 {
23529 size, err := m.Field200.MarshalToSizedBuffer(dAtA[:i])
23530 if err != nil {
23531 return 0, err
23532 }
23533 i -= size
23534 i = encodeVarintThetest(dAtA, i, uint64(size))
23535 }
23536 i--
23537 dAtA[i] = 0xc
23538 i--
23539 dAtA[i] = 0xc2
23540 if m.NidOptNative != nil {
23541 {
23542 size, err := m.NidOptNative.MarshalToSizedBuffer(dAtA[:i])
23543 if err != nil {
23544 return 0, err
23545 }
23546 i -= size
23547 i = encodeVarintThetest(dAtA, i, uint64(size))
23548 }
23549 i--
23550 dAtA[i] = 0xa
23551 }
23552 return len(dAtA) - i, nil
23553 }
23554
23555 func (m *NinEmbeddedStruct) Marshal() (dAtA []byte, err error) {
23556 size := m.Size()
23557 dAtA = make([]byte, size)
23558 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23559 if err != nil {
23560 return nil, err
23561 }
23562 return dAtA[:n], nil
23563 }
23564
23565 func (m *NinEmbeddedStruct) MarshalTo(dAtA []byte) (int, error) {
23566 size := m.Size()
23567 return m.MarshalToSizedBuffer(dAtA[:size])
23568 }
23569
23570 func (m *NinEmbeddedStruct) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23571 i := len(dAtA)
23572 _ = i
23573 var l int
23574 _ = l
23575 if m.XXX_unrecognized != nil {
23576 i -= len(m.XXX_unrecognized)
23577 copy(dAtA[i:], m.XXX_unrecognized)
23578 }
23579 if m.Field210 != nil {
23580 i--
23581 if *m.Field210 {
23582 dAtA[i] = 1
23583 } else {
23584 dAtA[i] = 0
23585 }
23586 i--
23587 dAtA[i] = 0xd
23588 i--
23589 dAtA[i] = 0x90
23590 }
23591 if m.Field200 != nil {
23592 {
23593 size, err := m.Field200.MarshalToSizedBuffer(dAtA[:i])
23594 if err != nil {
23595 return 0, err
23596 }
23597 i -= size
23598 i = encodeVarintThetest(dAtA, i, uint64(size))
23599 }
23600 i--
23601 dAtA[i] = 0xc
23602 i--
23603 dAtA[i] = 0xc2
23604 }
23605 if m.NidOptNative != nil {
23606 {
23607 size, err := m.NidOptNative.MarshalToSizedBuffer(dAtA[:i])
23608 if err != nil {
23609 return 0, err
23610 }
23611 i -= size
23612 i = encodeVarintThetest(dAtA, i, uint64(size))
23613 }
23614 i--
23615 dAtA[i] = 0xa
23616 }
23617 return len(dAtA) - i, nil
23618 }
23619
23620 func (m *NidNestedStruct) Marshal() (dAtA []byte, err error) {
23621 size := m.Size()
23622 dAtA = make([]byte, size)
23623 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23624 if err != nil {
23625 return nil, err
23626 }
23627 return dAtA[:n], nil
23628 }
23629
23630 func (m *NidNestedStruct) MarshalTo(dAtA []byte) (int, error) {
23631 size := m.Size()
23632 return m.MarshalToSizedBuffer(dAtA[:size])
23633 }
23634
23635 func (m *NidNestedStruct) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23636 i := len(dAtA)
23637 _ = i
23638 var l int
23639 _ = l
23640 if m.XXX_unrecognized != nil {
23641 i -= len(m.XXX_unrecognized)
23642 copy(dAtA[i:], m.XXX_unrecognized)
23643 }
23644 if len(m.Field2) > 0 {
23645 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
23646 {
23647 size, err := m.Field2[iNdEx].MarshalToSizedBuffer(dAtA[:i])
23648 if err != nil {
23649 return 0, err
23650 }
23651 i -= size
23652 i = encodeVarintThetest(dAtA, i, uint64(size))
23653 }
23654 i--
23655 dAtA[i] = 0x12
23656 }
23657 }
23658 {
23659 size, err := m.Field1.MarshalToSizedBuffer(dAtA[:i])
23660 if err != nil {
23661 return 0, err
23662 }
23663 i -= size
23664 i = encodeVarintThetest(dAtA, i, uint64(size))
23665 }
23666 i--
23667 dAtA[i] = 0xa
23668 return len(dAtA) - i, nil
23669 }
23670
23671 func (m *NinNestedStruct) Marshal() (dAtA []byte, err error) {
23672 size := m.Size()
23673 dAtA = make([]byte, size)
23674 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23675 if err != nil {
23676 return nil, err
23677 }
23678 return dAtA[:n], nil
23679 }
23680
23681 func (m *NinNestedStruct) MarshalTo(dAtA []byte) (int, error) {
23682 size := m.Size()
23683 return m.MarshalToSizedBuffer(dAtA[:size])
23684 }
23685
23686 func (m *NinNestedStruct) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23687 i := len(dAtA)
23688 _ = i
23689 var l int
23690 _ = l
23691 if m.XXX_unrecognized != nil {
23692 i -= len(m.XXX_unrecognized)
23693 copy(dAtA[i:], m.XXX_unrecognized)
23694 }
23695 if len(m.Field2) > 0 {
23696 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
23697 {
23698 size, err := m.Field2[iNdEx].MarshalToSizedBuffer(dAtA[:i])
23699 if err != nil {
23700 return 0, err
23701 }
23702 i -= size
23703 i = encodeVarintThetest(dAtA, i, uint64(size))
23704 }
23705 i--
23706 dAtA[i] = 0x12
23707 }
23708 }
23709 if m.Field1 != nil {
23710 {
23711 size, err := m.Field1.MarshalToSizedBuffer(dAtA[:i])
23712 if err != nil {
23713 return 0, err
23714 }
23715 i -= size
23716 i = encodeVarintThetest(dAtA, i, uint64(size))
23717 }
23718 i--
23719 dAtA[i] = 0xa
23720 }
23721 return len(dAtA) - i, nil
23722 }
23723
23724 func (m *NidOptCustom) Marshal() (dAtA []byte, err error) {
23725 size := m.Size()
23726 dAtA = make([]byte, size)
23727 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23728 if err != nil {
23729 return nil, err
23730 }
23731 return dAtA[:n], nil
23732 }
23733
23734 func (m *NidOptCustom) MarshalTo(dAtA []byte) (int, error) {
23735 size := m.Size()
23736 return m.MarshalToSizedBuffer(dAtA[:size])
23737 }
23738
23739 func (m *NidOptCustom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23740 i := len(dAtA)
23741 _ = i
23742 var l int
23743 _ = l
23744 if m.XXX_unrecognized != nil {
23745 i -= len(m.XXX_unrecognized)
23746 copy(dAtA[i:], m.XXX_unrecognized)
23747 }
23748 {
23749 size := m.Value.Size()
23750 i -= size
23751 if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
23752 return 0, err
23753 }
23754 i = encodeVarintThetest(dAtA, i, uint64(size))
23755 }
23756 i--
23757 dAtA[i] = 0x12
23758 {
23759 size := m.Id.Size()
23760 i -= size
23761 if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil {
23762 return 0, err
23763 }
23764 i = encodeVarintThetest(dAtA, i, uint64(size))
23765 }
23766 i--
23767 dAtA[i] = 0xa
23768 return len(dAtA) - i, nil
23769 }
23770
23771 func (m *CustomDash) Marshal() (dAtA []byte, err error) {
23772 size := m.Size()
23773 dAtA = make([]byte, size)
23774 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23775 if err != nil {
23776 return nil, err
23777 }
23778 return dAtA[:n], nil
23779 }
23780
23781 func (m *CustomDash) MarshalTo(dAtA []byte) (int, error) {
23782 size := m.Size()
23783 return m.MarshalToSizedBuffer(dAtA[:size])
23784 }
23785
23786 func (m *CustomDash) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23787 i := len(dAtA)
23788 _ = i
23789 var l int
23790 _ = l
23791 if m.XXX_unrecognized != nil {
23792 i -= len(m.XXX_unrecognized)
23793 copy(dAtA[i:], m.XXX_unrecognized)
23794 }
23795 if m.Value != nil {
23796 {
23797 size := m.Value.Size()
23798 i -= size
23799 if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
23800 return 0, err
23801 }
23802 i = encodeVarintThetest(dAtA, i, uint64(size))
23803 }
23804 i--
23805 dAtA[i] = 0xa
23806 }
23807 return len(dAtA) - i, nil
23808 }
23809
23810 func (m *NinOptCustom) Marshal() (dAtA []byte, err error) {
23811 size := m.Size()
23812 dAtA = make([]byte, size)
23813 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23814 if err != nil {
23815 return nil, err
23816 }
23817 return dAtA[:n], nil
23818 }
23819
23820 func (m *NinOptCustom) MarshalTo(dAtA []byte) (int, error) {
23821 size := m.Size()
23822 return m.MarshalToSizedBuffer(dAtA[:size])
23823 }
23824
23825 func (m *NinOptCustom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23826 i := len(dAtA)
23827 _ = i
23828 var l int
23829 _ = l
23830 if m.XXX_unrecognized != nil {
23831 i -= len(m.XXX_unrecognized)
23832 copy(dAtA[i:], m.XXX_unrecognized)
23833 }
23834 if m.Value != nil {
23835 {
23836 size := m.Value.Size()
23837 i -= size
23838 if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
23839 return 0, err
23840 }
23841 i = encodeVarintThetest(dAtA, i, uint64(size))
23842 }
23843 i--
23844 dAtA[i] = 0x12
23845 }
23846 if m.Id != nil {
23847 {
23848 size := m.Id.Size()
23849 i -= size
23850 if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil {
23851 return 0, err
23852 }
23853 i = encodeVarintThetest(dAtA, i, uint64(size))
23854 }
23855 i--
23856 dAtA[i] = 0xa
23857 }
23858 return len(dAtA) - i, nil
23859 }
23860
23861 func (m *NidRepCustom) Marshal() (dAtA []byte, err error) {
23862 size := m.Size()
23863 dAtA = make([]byte, size)
23864 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23865 if err != nil {
23866 return nil, err
23867 }
23868 return dAtA[:n], nil
23869 }
23870
23871 func (m *NidRepCustom) MarshalTo(dAtA []byte) (int, error) {
23872 size := m.Size()
23873 return m.MarshalToSizedBuffer(dAtA[:size])
23874 }
23875
23876 func (m *NidRepCustom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23877 i := len(dAtA)
23878 _ = i
23879 var l int
23880 _ = l
23881 if m.XXX_unrecognized != nil {
23882 i -= len(m.XXX_unrecognized)
23883 copy(dAtA[i:], m.XXX_unrecognized)
23884 }
23885 if len(m.Value) > 0 {
23886 for iNdEx := len(m.Value) - 1; iNdEx >= 0; iNdEx-- {
23887 {
23888 size := m.Value[iNdEx].Size()
23889 i -= size
23890 if _, err := m.Value[iNdEx].MarshalTo(dAtA[i:]); err != nil {
23891 return 0, err
23892 }
23893 i = encodeVarintThetest(dAtA, i, uint64(size))
23894 }
23895 i--
23896 dAtA[i] = 0x12
23897 }
23898 }
23899 if len(m.Id) > 0 {
23900 for iNdEx := len(m.Id) - 1; iNdEx >= 0; iNdEx-- {
23901 {
23902 size := m.Id[iNdEx].Size()
23903 i -= size
23904 if _, err := m.Id[iNdEx].MarshalTo(dAtA[i:]); err != nil {
23905 return 0, err
23906 }
23907 i = encodeVarintThetest(dAtA, i, uint64(size))
23908 }
23909 i--
23910 dAtA[i] = 0xa
23911 }
23912 }
23913 return len(dAtA) - i, nil
23914 }
23915
23916 func (m *NinRepCustom) Marshal() (dAtA []byte, err error) {
23917 size := m.Size()
23918 dAtA = make([]byte, size)
23919 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23920 if err != nil {
23921 return nil, err
23922 }
23923 return dAtA[:n], nil
23924 }
23925
23926 func (m *NinRepCustom) MarshalTo(dAtA []byte) (int, error) {
23927 size := m.Size()
23928 return m.MarshalToSizedBuffer(dAtA[:size])
23929 }
23930
23931 func (m *NinRepCustom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23932 i := len(dAtA)
23933 _ = i
23934 var l int
23935 _ = l
23936 if m.XXX_unrecognized != nil {
23937 i -= len(m.XXX_unrecognized)
23938 copy(dAtA[i:], m.XXX_unrecognized)
23939 }
23940 if len(m.Value) > 0 {
23941 for iNdEx := len(m.Value) - 1; iNdEx >= 0; iNdEx-- {
23942 {
23943 size := m.Value[iNdEx].Size()
23944 i -= size
23945 if _, err := m.Value[iNdEx].MarshalTo(dAtA[i:]); err != nil {
23946 return 0, err
23947 }
23948 i = encodeVarintThetest(dAtA, i, uint64(size))
23949 }
23950 i--
23951 dAtA[i] = 0x12
23952 }
23953 }
23954 if len(m.Id) > 0 {
23955 for iNdEx := len(m.Id) - 1; iNdEx >= 0; iNdEx-- {
23956 {
23957 size := m.Id[iNdEx].Size()
23958 i -= size
23959 if _, err := m.Id[iNdEx].MarshalTo(dAtA[i:]); err != nil {
23960 return 0, err
23961 }
23962 i = encodeVarintThetest(dAtA, i, uint64(size))
23963 }
23964 i--
23965 dAtA[i] = 0xa
23966 }
23967 }
23968 return len(dAtA) - i, nil
23969 }
23970
23971 func (m *NinOptNativeUnion) Marshal() (dAtA []byte, err error) {
23972 size := m.Size()
23973 dAtA = make([]byte, size)
23974 n, err := m.MarshalToSizedBuffer(dAtA[:size])
23975 if err != nil {
23976 return nil, err
23977 }
23978 return dAtA[:n], nil
23979 }
23980
23981 func (m *NinOptNativeUnion) MarshalTo(dAtA []byte) (int, error) {
23982 size := m.Size()
23983 return m.MarshalToSizedBuffer(dAtA[:size])
23984 }
23985
23986 func (m *NinOptNativeUnion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
23987 i := len(dAtA)
23988 _ = i
23989 var l int
23990 _ = l
23991 if m.XXX_unrecognized != nil {
23992 i -= len(m.XXX_unrecognized)
23993 copy(dAtA[i:], m.XXX_unrecognized)
23994 }
23995 if m.Field15 != nil {
23996 i -= len(m.Field15)
23997 copy(dAtA[i:], m.Field15)
23998 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15)))
23999 i--
24000 dAtA[i] = 0x7a
24001 }
24002 if m.Field14 != nil {
24003 i -= len(*m.Field14)
24004 copy(dAtA[i:], *m.Field14)
24005 i = encodeVarintThetest(dAtA, i, uint64(len(*m.Field14)))
24006 i--
24007 dAtA[i] = 0x72
24008 }
24009 if m.Field13 != nil {
24010 i--
24011 if *m.Field13 {
24012 dAtA[i] = 1
24013 } else {
24014 dAtA[i] = 0
24015 }
24016 i--
24017 dAtA[i] = 0x68
24018 }
24019 if m.Field6 != nil {
24020 i = encodeVarintThetest(dAtA, i, uint64(*m.Field6))
24021 i--
24022 dAtA[i] = 0x30
24023 }
24024 if m.Field5 != nil {
24025 i = encodeVarintThetest(dAtA, i, uint64(*m.Field5))
24026 i--
24027 dAtA[i] = 0x28
24028 }
24029 if m.Field4 != nil {
24030 i = encodeVarintThetest(dAtA, i, uint64(*m.Field4))
24031 i--
24032 dAtA[i] = 0x20
24033 }
24034 if m.Field3 != nil {
24035 i = encodeVarintThetest(dAtA, i, uint64(*m.Field3))
24036 i--
24037 dAtA[i] = 0x18
24038 }
24039 if m.Field2 != nil {
24040 i -= 4
24041 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.Field2))))
24042 i--
24043 dAtA[i] = 0x15
24044 }
24045 if m.Field1 != nil {
24046 i -= 8
24047 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Field1))))
24048 i--
24049 dAtA[i] = 0x9
24050 }
24051 return len(dAtA) - i, nil
24052 }
24053
24054 func (m *NinOptStructUnion) Marshal() (dAtA []byte, err error) {
24055 size := m.Size()
24056 dAtA = make([]byte, size)
24057 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24058 if err != nil {
24059 return nil, err
24060 }
24061 return dAtA[:n], nil
24062 }
24063
24064 func (m *NinOptStructUnion) MarshalTo(dAtA []byte) (int, error) {
24065 size := m.Size()
24066 return m.MarshalToSizedBuffer(dAtA[:size])
24067 }
24068
24069 func (m *NinOptStructUnion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24070 i := len(dAtA)
24071 _ = i
24072 var l int
24073 _ = l
24074 if m.XXX_unrecognized != nil {
24075 i -= len(m.XXX_unrecognized)
24076 copy(dAtA[i:], m.XXX_unrecognized)
24077 }
24078 if m.Field15 != nil {
24079 i -= len(m.Field15)
24080 copy(dAtA[i:], m.Field15)
24081 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15)))
24082 i--
24083 dAtA[i] = 0x7a
24084 }
24085 if m.Field14 != nil {
24086 i -= len(*m.Field14)
24087 copy(dAtA[i:], *m.Field14)
24088 i = encodeVarintThetest(dAtA, i, uint64(len(*m.Field14)))
24089 i--
24090 dAtA[i] = 0x72
24091 }
24092 if m.Field13 != nil {
24093 i--
24094 if *m.Field13 {
24095 dAtA[i] = 1
24096 } else {
24097 dAtA[i] = 0
24098 }
24099 i--
24100 dAtA[i] = 0x68
24101 }
24102 if m.Field7 != nil {
24103 i = encodeVarintThetest(dAtA, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31))))
24104 i--
24105 dAtA[i] = 0x38
24106 }
24107 if m.Field6 != nil {
24108 i = encodeVarintThetest(dAtA, i, uint64(*m.Field6))
24109 i--
24110 dAtA[i] = 0x30
24111 }
24112 if m.Field4 != nil {
24113 {
24114 size, err := m.Field4.MarshalToSizedBuffer(dAtA[:i])
24115 if err != nil {
24116 return 0, err
24117 }
24118 i -= size
24119 i = encodeVarintThetest(dAtA, i, uint64(size))
24120 }
24121 i--
24122 dAtA[i] = 0x22
24123 }
24124 if m.Field3 != nil {
24125 {
24126 size, err := m.Field3.MarshalToSizedBuffer(dAtA[:i])
24127 if err != nil {
24128 return 0, err
24129 }
24130 i -= size
24131 i = encodeVarintThetest(dAtA, i, uint64(size))
24132 }
24133 i--
24134 dAtA[i] = 0x1a
24135 }
24136 if m.Field2 != nil {
24137 i -= 4
24138 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.Field2))))
24139 i--
24140 dAtA[i] = 0x15
24141 }
24142 if m.Field1 != nil {
24143 i -= 8
24144 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Field1))))
24145 i--
24146 dAtA[i] = 0x9
24147 }
24148 return len(dAtA) - i, nil
24149 }
24150
24151 func (m *NinEmbeddedStructUnion) Marshal() (dAtA []byte, err error) {
24152 size := m.Size()
24153 dAtA = make([]byte, size)
24154 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24155 if err != nil {
24156 return nil, err
24157 }
24158 return dAtA[:n], nil
24159 }
24160
24161 func (m *NinEmbeddedStructUnion) MarshalTo(dAtA []byte) (int, error) {
24162 size := m.Size()
24163 return m.MarshalToSizedBuffer(dAtA[:size])
24164 }
24165
24166 func (m *NinEmbeddedStructUnion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24167 i := len(dAtA)
24168 _ = i
24169 var l int
24170 _ = l
24171 if m.XXX_unrecognized != nil {
24172 i -= len(m.XXX_unrecognized)
24173 copy(dAtA[i:], m.XXX_unrecognized)
24174 }
24175 if m.Field210 != nil {
24176 i--
24177 if *m.Field210 {
24178 dAtA[i] = 1
24179 } else {
24180 dAtA[i] = 0
24181 }
24182 i--
24183 dAtA[i] = 0xd
24184 i--
24185 dAtA[i] = 0x90
24186 }
24187 if m.Field200 != nil {
24188 {
24189 size, err := m.Field200.MarshalToSizedBuffer(dAtA[:i])
24190 if err != nil {
24191 return 0, err
24192 }
24193 i -= size
24194 i = encodeVarintThetest(dAtA, i, uint64(size))
24195 }
24196 i--
24197 dAtA[i] = 0xc
24198 i--
24199 dAtA[i] = 0xc2
24200 }
24201 if m.NidOptNative != nil {
24202 {
24203 size, err := m.NidOptNative.MarshalToSizedBuffer(dAtA[:i])
24204 if err != nil {
24205 return 0, err
24206 }
24207 i -= size
24208 i = encodeVarintThetest(dAtA, i, uint64(size))
24209 }
24210 i--
24211 dAtA[i] = 0xa
24212 }
24213 return len(dAtA) - i, nil
24214 }
24215
24216 func (m *NinNestedStructUnion) Marshal() (dAtA []byte, err error) {
24217 size := m.Size()
24218 dAtA = make([]byte, size)
24219 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24220 if err != nil {
24221 return nil, err
24222 }
24223 return dAtA[:n], nil
24224 }
24225
24226 func (m *NinNestedStructUnion) MarshalTo(dAtA []byte) (int, error) {
24227 size := m.Size()
24228 return m.MarshalToSizedBuffer(dAtA[:size])
24229 }
24230
24231 func (m *NinNestedStructUnion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24232 i := len(dAtA)
24233 _ = i
24234 var l int
24235 _ = l
24236 if m.XXX_unrecognized != nil {
24237 i -= len(m.XXX_unrecognized)
24238 copy(dAtA[i:], m.XXX_unrecognized)
24239 }
24240 if m.Field3 != nil {
24241 {
24242 size, err := m.Field3.MarshalToSizedBuffer(dAtA[:i])
24243 if err != nil {
24244 return 0, err
24245 }
24246 i -= size
24247 i = encodeVarintThetest(dAtA, i, uint64(size))
24248 }
24249 i--
24250 dAtA[i] = 0x1a
24251 }
24252 if m.Field2 != nil {
24253 {
24254 size, err := m.Field2.MarshalToSizedBuffer(dAtA[:i])
24255 if err != nil {
24256 return 0, err
24257 }
24258 i -= size
24259 i = encodeVarintThetest(dAtA, i, uint64(size))
24260 }
24261 i--
24262 dAtA[i] = 0x12
24263 }
24264 if m.Field1 != nil {
24265 {
24266 size, err := m.Field1.MarshalToSizedBuffer(dAtA[:i])
24267 if err != nil {
24268 return 0, err
24269 }
24270 i -= size
24271 i = encodeVarintThetest(dAtA, i, uint64(size))
24272 }
24273 i--
24274 dAtA[i] = 0xa
24275 }
24276 return len(dAtA) - i, nil
24277 }
24278
24279 func (m *Tree) Marshal() (dAtA []byte, err error) {
24280 size := m.Size()
24281 dAtA = make([]byte, size)
24282 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24283 if err != nil {
24284 return nil, err
24285 }
24286 return dAtA[:n], nil
24287 }
24288
24289 func (m *Tree) MarshalTo(dAtA []byte) (int, error) {
24290 size := m.Size()
24291 return m.MarshalToSizedBuffer(dAtA[:size])
24292 }
24293
24294 func (m *Tree) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24295 i := len(dAtA)
24296 _ = i
24297 var l int
24298 _ = l
24299 if m.XXX_unrecognized != nil {
24300 i -= len(m.XXX_unrecognized)
24301 copy(dAtA[i:], m.XXX_unrecognized)
24302 }
24303 if m.Leaf != nil {
24304 {
24305 size, err := m.Leaf.MarshalToSizedBuffer(dAtA[:i])
24306 if err != nil {
24307 return 0, err
24308 }
24309 i -= size
24310 i = encodeVarintThetest(dAtA, i, uint64(size))
24311 }
24312 i--
24313 dAtA[i] = 0x1a
24314 }
24315 if m.And != nil {
24316 {
24317 size, err := m.And.MarshalToSizedBuffer(dAtA[:i])
24318 if err != nil {
24319 return 0, err
24320 }
24321 i -= size
24322 i = encodeVarintThetest(dAtA, i, uint64(size))
24323 }
24324 i--
24325 dAtA[i] = 0x12
24326 }
24327 if m.Or != nil {
24328 {
24329 size, err := m.Or.MarshalToSizedBuffer(dAtA[:i])
24330 if err != nil {
24331 return 0, err
24332 }
24333 i -= size
24334 i = encodeVarintThetest(dAtA, i, uint64(size))
24335 }
24336 i--
24337 dAtA[i] = 0xa
24338 }
24339 return len(dAtA) - i, nil
24340 }
24341
24342 func (m *OrBranch) Marshal() (dAtA []byte, err error) {
24343 size := m.Size()
24344 dAtA = make([]byte, size)
24345 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24346 if err != nil {
24347 return nil, err
24348 }
24349 return dAtA[:n], nil
24350 }
24351
24352 func (m *OrBranch) MarshalTo(dAtA []byte) (int, error) {
24353 size := m.Size()
24354 return m.MarshalToSizedBuffer(dAtA[:size])
24355 }
24356
24357 func (m *OrBranch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24358 i := len(dAtA)
24359 _ = i
24360 var l int
24361 _ = l
24362 if m.XXX_unrecognized != nil {
24363 i -= len(m.XXX_unrecognized)
24364 copy(dAtA[i:], m.XXX_unrecognized)
24365 }
24366 {
24367 size, err := m.Right.MarshalToSizedBuffer(dAtA[:i])
24368 if err != nil {
24369 return 0, err
24370 }
24371 i -= size
24372 i = encodeVarintThetest(dAtA, i, uint64(size))
24373 }
24374 i--
24375 dAtA[i] = 0x12
24376 {
24377 size, err := m.Left.MarshalToSizedBuffer(dAtA[:i])
24378 if err != nil {
24379 return 0, err
24380 }
24381 i -= size
24382 i = encodeVarintThetest(dAtA, i, uint64(size))
24383 }
24384 i--
24385 dAtA[i] = 0xa
24386 return len(dAtA) - i, nil
24387 }
24388
24389 func (m *AndBranch) Marshal() (dAtA []byte, err error) {
24390 size := m.Size()
24391 dAtA = make([]byte, size)
24392 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24393 if err != nil {
24394 return nil, err
24395 }
24396 return dAtA[:n], nil
24397 }
24398
24399 func (m *AndBranch) MarshalTo(dAtA []byte) (int, error) {
24400 size := m.Size()
24401 return m.MarshalToSizedBuffer(dAtA[:size])
24402 }
24403
24404 func (m *AndBranch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24405 i := len(dAtA)
24406 _ = i
24407 var l int
24408 _ = l
24409 if m.XXX_unrecognized != nil {
24410 i -= len(m.XXX_unrecognized)
24411 copy(dAtA[i:], m.XXX_unrecognized)
24412 }
24413 {
24414 size, err := m.Right.MarshalToSizedBuffer(dAtA[:i])
24415 if err != nil {
24416 return 0, err
24417 }
24418 i -= size
24419 i = encodeVarintThetest(dAtA, i, uint64(size))
24420 }
24421 i--
24422 dAtA[i] = 0x12
24423 {
24424 size, err := m.Left.MarshalToSizedBuffer(dAtA[:i])
24425 if err != nil {
24426 return 0, err
24427 }
24428 i -= size
24429 i = encodeVarintThetest(dAtA, i, uint64(size))
24430 }
24431 i--
24432 dAtA[i] = 0xa
24433 return len(dAtA) - i, nil
24434 }
24435
24436 func (m *Leaf) Marshal() (dAtA []byte, err error) {
24437 size := m.Size()
24438 dAtA = make([]byte, size)
24439 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24440 if err != nil {
24441 return nil, err
24442 }
24443 return dAtA[:n], nil
24444 }
24445
24446 func (m *Leaf) MarshalTo(dAtA []byte) (int, error) {
24447 size := m.Size()
24448 return m.MarshalToSizedBuffer(dAtA[:size])
24449 }
24450
24451 func (m *Leaf) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24452 i := len(dAtA)
24453 _ = i
24454 var l int
24455 _ = l
24456 if m.XXX_unrecognized != nil {
24457 i -= len(m.XXX_unrecognized)
24458 copy(dAtA[i:], m.XXX_unrecognized)
24459 }
24460 i -= len(m.StrValue)
24461 copy(dAtA[i:], m.StrValue)
24462 i = encodeVarintThetest(dAtA, i, uint64(len(m.StrValue)))
24463 i--
24464 dAtA[i] = 0x12
24465 i = encodeVarintThetest(dAtA, i, uint64(m.Value))
24466 i--
24467 dAtA[i] = 0x8
24468 return len(dAtA) - i, nil
24469 }
24470
24471 func (m *DeepTree) Marshal() (dAtA []byte, err error) {
24472 size := m.Size()
24473 dAtA = make([]byte, size)
24474 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24475 if err != nil {
24476 return nil, err
24477 }
24478 return dAtA[:n], nil
24479 }
24480
24481 func (m *DeepTree) MarshalTo(dAtA []byte) (int, error) {
24482 size := m.Size()
24483 return m.MarshalToSizedBuffer(dAtA[:size])
24484 }
24485
24486 func (m *DeepTree) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24487 i := len(dAtA)
24488 _ = i
24489 var l int
24490 _ = l
24491 if m.XXX_unrecognized != nil {
24492 i -= len(m.XXX_unrecognized)
24493 copy(dAtA[i:], m.XXX_unrecognized)
24494 }
24495 if m.Leaf != nil {
24496 {
24497 size, err := m.Leaf.MarshalToSizedBuffer(dAtA[:i])
24498 if err != nil {
24499 return 0, err
24500 }
24501 i -= size
24502 i = encodeVarintThetest(dAtA, i, uint64(size))
24503 }
24504 i--
24505 dAtA[i] = 0x1a
24506 }
24507 if m.And != nil {
24508 {
24509 size, err := m.And.MarshalToSizedBuffer(dAtA[:i])
24510 if err != nil {
24511 return 0, err
24512 }
24513 i -= size
24514 i = encodeVarintThetest(dAtA, i, uint64(size))
24515 }
24516 i--
24517 dAtA[i] = 0x12
24518 }
24519 if m.Down != nil {
24520 {
24521 size, err := m.Down.MarshalToSizedBuffer(dAtA[:i])
24522 if err != nil {
24523 return 0, err
24524 }
24525 i -= size
24526 i = encodeVarintThetest(dAtA, i, uint64(size))
24527 }
24528 i--
24529 dAtA[i] = 0xa
24530 }
24531 return len(dAtA) - i, nil
24532 }
24533
24534 func (m *ADeepBranch) Marshal() (dAtA []byte, err error) {
24535 size := m.Size()
24536 dAtA = make([]byte, size)
24537 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24538 if err != nil {
24539 return nil, err
24540 }
24541 return dAtA[:n], nil
24542 }
24543
24544 func (m *ADeepBranch) MarshalTo(dAtA []byte) (int, error) {
24545 size := m.Size()
24546 return m.MarshalToSizedBuffer(dAtA[:size])
24547 }
24548
24549 func (m *ADeepBranch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24550 i := len(dAtA)
24551 _ = i
24552 var l int
24553 _ = l
24554 if m.XXX_unrecognized != nil {
24555 i -= len(m.XXX_unrecognized)
24556 copy(dAtA[i:], m.XXX_unrecognized)
24557 }
24558 {
24559 size, err := m.Down.MarshalToSizedBuffer(dAtA[:i])
24560 if err != nil {
24561 return 0, err
24562 }
24563 i -= size
24564 i = encodeVarintThetest(dAtA, i, uint64(size))
24565 }
24566 i--
24567 dAtA[i] = 0x12
24568 return len(dAtA) - i, nil
24569 }
24570
24571 func (m *AndDeepBranch) Marshal() (dAtA []byte, err error) {
24572 size := m.Size()
24573 dAtA = make([]byte, size)
24574 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24575 if err != nil {
24576 return nil, err
24577 }
24578 return dAtA[:n], nil
24579 }
24580
24581 func (m *AndDeepBranch) MarshalTo(dAtA []byte) (int, error) {
24582 size := m.Size()
24583 return m.MarshalToSizedBuffer(dAtA[:size])
24584 }
24585
24586 func (m *AndDeepBranch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24587 i := len(dAtA)
24588 _ = i
24589 var l int
24590 _ = l
24591 if m.XXX_unrecognized != nil {
24592 i -= len(m.XXX_unrecognized)
24593 copy(dAtA[i:], m.XXX_unrecognized)
24594 }
24595 {
24596 size, err := m.Right.MarshalToSizedBuffer(dAtA[:i])
24597 if err != nil {
24598 return 0, err
24599 }
24600 i -= size
24601 i = encodeVarintThetest(dAtA, i, uint64(size))
24602 }
24603 i--
24604 dAtA[i] = 0x12
24605 {
24606 size, err := m.Left.MarshalToSizedBuffer(dAtA[:i])
24607 if err != nil {
24608 return 0, err
24609 }
24610 i -= size
24611 i = encodeVarintThetest(dAtA, i, uint64(size))
24612 }
24613 i--
24614 dAtA[i] = 0xa
24615 return len(dAtA) - i, nil
24616 }
24617
24618 func (m *DeepLeaf) Marshal() (dAtA []byte, err error) {
24619 size := m.Size()
24620 dAtA = make([]byte, size)
24621 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24622 if err != nil {
24623 return nil, err
24624 }
24625 return dAtA[:n], nil
24626 }
24627
24628 func (m *DeepLeaf) MarshalTo(dAtA []byte) (int, error) {
24629 size := m.Size()
24630 return m.MarshalToSizedBuffer(dAtA[:size])
24631 }
24632
24633 func (m *DeepLeaf) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24634 i := len(dAtA)
24635 _ = i
24636 var l int
24637 _ = l
24638 if m.XXX_unrecognized != nil {
24639 i -= len(m.XXX_unrecognized)
24640 copy(dAtA[i:], m.XXX_unrecognized)
24641 }
24642 {
24643 size, err := m.Tree.MarshalToSizedBuffer(dAtA[:i])
24644 if err != nil {
24645 return 0, err
24646 }
24647 i -= size
24648 i = encodeVarintThetest(dAtA, i, uint64(size))
24649 }
24650 i--
24651 dAtA[i] = 0xa
24652 return len(dAtA) - i, nil
24653 }
24654
24655 func (m *Nil) Marshal() (dAtA []byte, err error) {
24656 size := m.Size()
24657 dAtA = make([]byte, size)
24658 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24659 if err != nil {
24660 return nil, err
24661 }
24662 return dAtA[:n], nil
24663 }
24664
24665 func (m *Nil) MarshalTo(dAtA []byte) (int, error) {
24666 size := m.Size()
24667 return m.MarshalToSizedBuffer(dAtA[:size])
24668 }
24669
24670 func (m *Nil) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24671 i := len(dAtA)
24672 _ = i
24673 var l int
24674 _ = l
24675 if m.XXX_unrecognized != nil {
24676 i -= len(m.XXX_unrecognized)
24677 copy(dAtA[i:], m.XXX_unrecognized)
24678 }
24679 return len(dAtA) - i, nil
24680 }
24681
24682 func (m *NidOptEnum) Marshal() (dAtA []byte, err error) {
24683 size := m.Size()
24684 dAtA = make([]byte, size)
24685 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24686 if err != nil {
24687 return nil, err
24688 }
24689 return dAtA[:n], nil
24690 }
24691
24692 func (m *NidOptEnum) MarshalTo(dAtA []byte) (int, error) {
24693 size := m.Size()
24694 return m.MarshalToSizedBuffer(dAtA[:size])
24695 }
24696
24697 func (m *NidOptEnum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24698 i := len(dAtA)
24699 _ = i
24700 var l int
24701 _ = l
24702 if m.XXX_unrecognized != nil {
24703 i -= len(m.XXX_unrecognized)
24704 copy(dAtA[i:], m.XXX_unrecognized)
24705 }
24706 i = encodeVarintThetest(dAtA, i, uint64(m.Field1))
24707 i--
24708 dAtA[i] = 0x8
24709 return len(dAtA) - i, nil
24710 }
24711
24712 func (m *NinOptEnum) Marshal() (dAtA []byte, err error) {
24713 size := m.Size()
24714 dAtA = make([]byte, size)
24715 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24716 if err != nil {
24717 return nil, err
24718 }
24719 return dAtA[:n], nil
24720 }
24721
24722 func (m *NinOptEnum) MarshalTo(dAtA []byte) (int, error) {
24723 size := m.Size()
24724 return m.MarshalToSizedBuffer(dAtA[:size])
24725 }
24726
24727 func (m *NinOptEnum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24728 i := len(dAtA)
24729 _ = i
24730 var l int
24731 _ = l
24732 if m.XXX_unrecognized != nil {
24733 i -= len(m.XXX_unrecognized)
24734 copy(dAtA[i:], m.XXX_unrecognized)
24735 }
24736 if m.Field3 != nil {
24737 i = encodeVarintThetest(dAtA, i, uint64(*m.Field3))
24738 i--
24739 dAtA[i] = 0x18
24740 }
24741 if m.Field2 != nil {
24742 i = encodeVarintThetest(dAtA, i, uint64(*m.Field2))
24743 i--
24744 dAtA[i] = 0x10
24745 }
24746 if m.Field1 != nil {
24747 i = encodeVarintThetest(dAtA, i, uint64(*m.Field1))
24748 i--
24749 dAtA[i] = 0x8
24750 }
24751 return len(dAtA) - i, nil
24752 }
24753
24754 func (m *NidRepEnum) Marshal() (dAtA []byte, err error) {
24755 size := m.Size()
24756 dAtA = make([]byte, size)
24757 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24758 if err != nil {
24759 return nil, err
24760 }
24761 return dAtA[:n], nil
24762 }
24763
24764 func (m *NidRepEnum) MarshalTo(dAtA []byte) (int, error) {
24765 size := m.Size()
24766 return m.MarshalToSizedBuffer(dAtA[:size])
24767 }
24768
24769 func (m *NidRepEnum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24770 i := len(dAtA)
24771 _ = i
24772 var l int
24773 _ = l
24774 if m.XXX_unrecognized != nil {
24775 i -= len(m.XXX_unrecognized)
24776 copy(dAtA[i:], m.XXX_unrecognized)
24777 }
24778 if len(m.Field3) > 0 {
24779 for iNdEx := len(m.Field3) - 1; iNdEx >= 0; iNdEx-- {
24780 i = encodeVarintThetest(dAtA, i, uint64(m.Field3[iNdEx]))
24781 i--
24782 dAtA[i] = 0x18
24783 }
24784 }
24785 if len(m.Field2) > 0 {
24786 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
24787 i = encodeVarintThetest(dAtA, i, uint64(m.Field2[iNdEx]))
24788 i--
24789 dAtA[i] = 0x10
24790 }
24791 }
24792 if len(m.Field1) > 0 {
24793 for iNdEx := len(m.Field1) - 1; iNdEx >= 0; iNdEx-- {
24794 i = encodeVarintThetest(dAtA, i, uint64(m.Field1[iNdEx]))
24795 i--
24796 dAtA[i] = 0x8
24797 }
24798 }
24799 return len(dAtA) - i, nil
24800 }
24801
24802 func (m *NinRepEnum) Marshal() (dAtA []byte, err error) {
24803 size := m.Size()
24804 dAtA = make([]byte, size)
24805 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24806 if err != nil {
24807 return nil, err
24808 }
24809 return dAtA[:n], nil
24810 }
24811
24812 func (m *NinRepEnum) MarshalTo(dAtA []byte) (int, error) {
24813 size := m.Size()
24814 return m.MarshalToSizedBuffer(dAtA[:size])
24815 }
24816
24817 func (m *NinRepEnum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24818 i := len(dAtA)
24819 _ = i
24820 var l int
24821 _ = l
24822 if m.XXX_unrecognized != nil {
24823 i -= len(m.XXX_unrecognized)
24824 copy(dAtA[i:], m.XXX_unrecognized)
24825 }
24826 if len(m.Field3) > 0 {
24827 for iNdEx := len(m.Field3) - 1; iNdEx >= 0; iNdEx-- {
24828 i = encodeVarintThetest(dAtA, i, uint64(m.Field3[iNdEx]))
24829 i--
24830 dAtA[i] = 0x18
24831 }
24832 }
24833 if len(m.Field2) > 0 {
24834 for iNdEx := len(m.Field2) - 1; iNdEx >= 0; iNdEx-- {
24835 i = encodeVarintThetest(dAtA, i, uint64(m.Field2[iNdEx]))
24836 i--
24837 dAtA[i] = 0x10
24838 }
24839 }
24840 if len(m.Field1) > 0 {
24841 for iNdEx := len(m.Field1) - 1; iNdEx >= 0; iNdEx-- {
24842 i = encodeVarintThetest(dAtA, i, uint64(m.Field1[iNdEx]))
24843 i--
24844 dAtA[i] = 0x8
24845 }
24846 }
24847 return len(dAtA) - i, nil
24848 }
24849
24850 func (m *NinOptEnumDefault) Marshal() (dAtA []byte, err error) {
24851 size := m.Size()
24852 dAtA = make([]byte, size)
24853 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24854 if err != nil {
24855 return nil, err
24856 }
24857 return dAtA[:n], nil
24858 }
24859
24860 func (m *NinOptEnumDefault) MarshalTo(dAtA []byte) (int, error) {
24861 size := m.Size()
24862 return m.MarshalToSizedBuffer(dAtA[:size])
24863 }
24864
24865 func (m *NinOptEnumDefault) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24866 i := len(dAtA)
24867 _ = i
24868 var l int
24869 _ = l
24870 if m.XXX_unrecognized != nil {
24871 i -= len(m.XXX_unrecognized)
24872 copy(dAtA[i:], m.XXX_unrecognized)
24873 }
24874 if m.Field3 != nil {
24875 i = encodeVarintThetest(dAtA, i, uint64(*m.Field3))
24876 i--
24877 dAtA[i] = 0x18
24878 }
24879 if m.Field2 != nil {
24880 i = encodeVarintThetest(dAtA, i, uint64(*m.Field2))
24881 i--
24882 dAtA[i] = 0x10
24883 }
24884 if m.Field1 != nil {
24885 i = encodeVarintThetest(dAtA, i, uint64(*m.Field1))
24886 i--
24887 dAtA[i] = 0x8
24888 }
24889 return len(dAtA) - i, nil
24890 }
24891
24892 func (m *AnotherNinOptEnum) Marshal() (dAtA []byte, err error) {
24893 size := m.Size()
24894 dAtA = make([]byte, size)
24895 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24896 if err != nil {
24897 return nil, err
24898 }
24899 return dAtA[:n], nil
24900 }
24901
24902 func (m *AnotherNinOptEnum) MarshalTo(dAtA []byte) (int, error) {
24903 size := m.Size()
24904 return m.MarshalToSizedBuffer(dAtA[:size])
24905 }
24906
24907 func (m *AnotherNinOptEnum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24908 i := len(dAtA)
24909 _ = i
24910 var l int
24911 _ = l
24912 if m.XXX_unrecognized != nil {
24913 i -= len(m.XXX_unrecognized)
24914 copy(dAtA[i:], m.XXX_unrecognized)
24915 }
24916 if m.Field3 != nil {
24917 i = encodeVarintThetest(dAtA, i, uint64(*m.Field3))
24918 i--
24919 dAtA[i] = 0x18
24920 }
24921 if m.Field2 != nil {
24922 i = encodeVarintThetest(dAtA, i, uint64(*m.Field2))
24923 i--
24924 dAtA[i] = 0x10
24925 }
24926 if m.Field1 != nil {
24927 i = encodeVarintThetest(dAtA, i, uint64(*m.Field1))
24928 i--
24929 dAtA[i] = 0x8
24930 }
24931 return len(dAtA) - i, nil
24932 }
24933
24934 func (m *AnotherNinOptEnumDefault) Marshal() (dAtA []byte, err error) {
24935 size := m.Size()
24936 dAtA = make([]byte, size)
24937 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24938 if err != nil {
24939 return nil, err
24940 }
24941 return dAtA[:n], nil
24942 }
24943
24944 func (m *AnotherNinOptEnumDefault) MarshalTo(dAtA []byte) (int, error) {
24945 size := m.Size()
24946 return m.MarshalToSizedBuffer(dAtA[:size])
24947 }
24948
24949 func (m *AnotherNinOptEnumDefault) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24950 i := len(dAtA)
24951 _ = i
24952 var l int
24953 _ = l
24954 if m.XXX_unrecognized != nil {
24955 i -= len(m.XXX_unrecognized)
24956 copy(dAtA[i:], m.XXX_unrecognized)
24957 }
24958 if m.Field3 != nil {
24959 i = encodeVarintThetest(dAtA, i, uint64(*m.Field3))
24960 i--
24961 dAtA[i] = 0x18
24962 }
24963 if m.Field2 != nil {
24964 i = encodeVarintThetest(dAtA, i, uint64(*m.Field2))
24965 i--
24966 dAtA[i] = 0x10
24967 }
24968 if m.Field1 != nil {
24969 i = encodeVarintThetest(dAtA, i, uint64(*m.Field1))
24970 i--
24971 dAtA[i] = 0x8
24972 }
24973 return len(dAtA) - i, nil
24974 }
24975
24976 func (m *Timer) Marshal() (dAtA []byte, err error) {
24977 size := m.Size()
24978 dAtA = make([]byte, size)
24979 n, err := m.MarshalToSizedBuffer(dAtA[:size])
24980 if err != nil {
24981 return nil, err
24982 }
24983 return dAtA[:n], nil
24984 }
24985
24986 func (m *Timer) MarshalTo(dAtA []byte) (int, error) {
24987 size := m.Size()
24988 return m.MarshalToSizedBuffer(dAtA[:size])
24989 }
24990
24991 func (m *Timer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
24992 i := len(dAtA)
24993 _ = i
24994 var l int
24995 _ = l
24996 if m.XXX_unrecognized != nil {
24997 i -= len(m.XXX_unrecognized)
24998 copy(dAtA[i:], m.XXX_unrecognized)
24999 }
25000 if m.Data != nil {
25001 i -= len(m.Data)
25002 copy(dAtA[i:], m.Data)
25003 i = encodeVarintThetest(dAtA, i, uint64(len(m.Data)))
25004 i--
25005 dAtA[i] = 0x1a
25006 }
25007 i -= 8
25008 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Time2))
25009 i--
25010 dAtA[i] = 0x11
25011 i -= 8
25012 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Time1))
25013 i--
25014 dAtA[i] = 0x9
25015 return len(dAtA) - i, nil
25016 }
25017
25018 func (m *MyExtendable) Marshal() (dAtA []byte, err error) {
25019 size := m.Size()
25020 dAtA = make([]byte, size)
25021 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25022 if err != nil {
25023 return nil, err
25024 }
25025 return dAtA[:n], nil
25026 }
25027
25028 func (m *MyExtendable) MarshalTo(dAtA []byte) (int, error) {
25029 size := m.Size()
25030 return m.MarshalToSizedBuffer(dAtA[:size])
25031 }
25032
25033 func (m *MyExtendable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25034 i := len(dAtA)
25035 _ = i
25036 var l int
25037 _ = l
25038 if m.XXX_unrecognized != nil {
25039 i -= len(m.XXX_unrecognized)
25040 copy(dAtA[i:], m.XXX_unrecognized)
25041 }
25042 if n, err := github_com_gogo_protobuf_proto.EncodeInternalExtensionBackwards(m, dAtA[:i]); err != nil {
25043 return 0, err
25044 } else {
25045 i -= n
25046 }
25047 if m.Field1 != nil {
25048 i = encodeVarintThetest(dAtA, i, uint64(*m.Field1))
25049 i--
25050 dAtA[i] = 0x8
25051 }
25052 return len(dAtA) - i, nil
25053 }
25054
25055 func (m *OtherExtenable) Marshal() (dAtA []byte, err error) {
25056 size := m.Size()
25057 dAtA = make([]byte, size)
25058 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25059 if err != nil {
25060 return nil, err
25061 }
25062 return dAtA[:n], nil
25063 }
25064
25065 func (m *OtherExtenable) MarshalTo(dAtA []byte) (int, error) {
25066 size := m.Size()
25067 return m.MarshalToSizedBuffer(dAtA[:size])
25068 }
25069
25070 func (m *OtherExtenable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25071 i := len(dAtA)
25072 _ = i
25073 var l int
25074 _ = l
25075 if m.XXX_unrecognized != nil {
25076 i -= len(m.XXX_unrecognized)
25077 copy(dAtA[i:], m.XXX_unrecognized)
25078 }
25079 if n, err := github_com_gogo_protobuf_proto.EncodeInternalExtensionBackwards(m, dAtA[:i]); err != nil {
25080 return 0, err
25081 } else {
25082 i -= n
25083 }
25084 if m.Field13 != nil {
25085 i = encodeVarintThetest(dAtA, i, uint64(*m.Field13))
25086 i--
25087 dAtA[i] = 0x68
25088 }
25089 if m.Field2 != nil {
25090 i = encodeVarintThetest(dAtA, i, uint64(*m.Field2))
25091 i--
25092 dAtA[i] = 0x10
25093 }
25094 if m.M != nil {
25095 {
25096 size, err := m.M.MarshalToSizedBuffer(dAtA[:i])
25097 if err != nil {
25098 return 0, err
25099 }
25100 i -= size
25101 i = encodeVarintThetest(dAtA, i, uint64(size))
25102 }
25103 i--
25104 dAtA[i] = 0xa
25105 }
25106 return len(dAtA) - i, nil
25107 }
25108
25109 func (m *NestedDefinition) Marshal() (dAtA []byte, err error) {
25110 size := m.Size()
25111 dAtA = make([]byte, size)
25112 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25113 if err != nil {
25114 return nil, err
25115 }
25116 return dAtA[:n], nil
25117 }
25118
25119 func (m *NestedDefinition) MarshalTo(dAtA []byte) (int, error) {
25120 size := m.Size()
25121 return m.MarshalToSizedBuffer(dAtA[:size])
25122 }
25123
25124 func (m *NestedDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25125 i := len(dAtA)
25126 _ = i
25127 var l int
25128 _ = l
25129 if m.XXX_unrecognized != nil {
25130 i -= len(m.XXX_unrecognized)
25131 copy(dAtA[i:], m.XXX_unrecognized)
25132 }
25133 if m.NM != nil {
25134 {
25135 size, err := m.NM.MarshalToSizedBuffer(dAtA[:i])
25136 if err != nil {
25137 return 0, err
25138 }
25139 i -= size
25140 i = encodeVarintThetest(dAtA, i, uint64(size))
25141 }
25142 i--
25143 dAtA[i] = 0x22
25144 }
25145 if m.NNM != nil {
25146 {
25147 size, err := m.NNM.MarshalToSizedBuffer(dAtA[:i])
25148 if err != nil {
25149 return 0, err
25150 }
25151 i -= size
25152 i = encodeVarintThetest(dAtA, i, uint64(size))
25153 }
25154 i--
25155 dAtA[i] = 0x1a
25156 }
25157 if m.EnumField != nil {
25158 i = encodeVarintThetest(dAtA, i, uint64(*m.EnumField))
25159 i--
25160 dAtA[i] = 0x10
25161 }
25162 if m.Field1 != nil {
25163 i = encodeVarintThetest(dAtA, i, uint64(*m.Field1))
25164 i--
25165 dAtA[i] = 0x8
25166 }
25167 return len(dAtA) - i, nil
25168 }
25169
25170 func (m *NestedDefinition_NestedMessage) Marshal() (dAtA []byte, err error) {
25171 size := m.Size()
25172 dAtA = make([]byte, size)
25173 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25174 if err != nil {
25175 return nil, err
25176 }
25177 return dAtA[:n], nil
25178 }
25179
25180 func (m *NestedDefinition_NestedMessage) MarshalTo(dAtA []byte) (int, error) {
25181 size := m.Size()
25182 return m.MarshalToSizedBuffer(dAtA[:size])
25183 }
25184
25185 func (m *NestedDefinition_NestedMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25186 i := len(dAtA)
25187 _ = i
25188 var l int
25189 _ = l
25190 if m.XXX_unrecognized != nil {
25191 i -= len(m.XXX_unrecognized)
25192 copy(dAtA[i:], m.XXX_unrecognized)
25193 }
25194 if m.NNM != nil {
25195 {
25196 size, err := m.NNM.MarshalToSizedBuffer(dAtA[:i])
25197 if err != nil {
25198 return 0, err
25199 }
25200 i -= size
25201 i = encodeVarintThetest(dAtA, i, uint64(size))
25202 }
25203 i--
25204 dAtA[i] = 0x12
25205 }
25206 if m.NestedField1 != nil {
25207 i -= 8
25208 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.NestedField1))
25209 i--
25210 dAtA[i] = 0x9
25211 }
25212 return len(dAtA) - i, nil
25213 }
25214
25215 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Marshal() (dAtA []byte, err error) {
25216 size := m.Size()
25217 dAtA = make([]byte, size)
25218 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25219 if err != nil {
25220 return nil, err
25221 }
25222 return dAtA[:n], nil
25223 }
25224
25225 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) MarshalTo(dAtA []byte) (int, error) {
25226 size := m.Size()
25227 return m.MarshalToSizedBuffer(dAtA[:size])
25228 }
25229
25230 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25231 i := len(dAtA)
25232 _ = i
25233 var l int
25234 _ = l
25235 if m.XXX_unrecognized != nil {
25236 i -= len(m.XXX_unrecognized)
25237 copy(dAtA[i:], m.XXX_unrecognized)
25238 }
25239 if m.NestedNestedField1 != nil {
25240 i -= len(*m.NestedNestedField1)
25241 copy(dAtA[i:], *m.NestedNestedField1)
25242 i = encodeVarintThetest(dAtA, i, uint64(len(*m.NestedNestedField1)))
25243 i--
25244 dAtA[i] = 0x52
25245 }
25246 return len(dAtA) - i, nil
25247 }
25248
25249 func (m *NestedScope) Marshal() (dAtA []byte, err error) {
25250 size := m.Size()
25251 dAtA = make([]byte, size)
25252 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25253 if err != nil {
25254 return nil, err
25255 }
25256 return dAtA[:n], nil
25257 }
25258
25259 func (m *NestedScope) MarshalTo(dAtA []byte) (int, error) {
25260 size := m.Size()
25261 return m.MarshalToSizedBuffer(dAtA[:size])
25262 }
25263
25264 func (m *NestedScope) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25265 i := len(dAtA)
25266 _ = i
25267 var l int
25268 _ = l
25269 if m.XXX_unrecognized != nil {
25270 i -= len(m.XXX_unrecognized)
25271 copy(dAtA[i:], m.XXX_unrecognized)
25272 }
25273 if m.C != nil {
25274 {
25275 size, err := m.C.MarshalToSizedBuffer(dAtA[:i])
25276 if err != nil {
25277 return 0, err
25278 }
25279 i -= size
25280 i = encodeVarintThetest(dAtA, i, uint64(size))
25281 }
25282 i--
25283 dAtA[i] = 0x1a
25284 }
25285 if m.B != nil {
25286 i = encodeVarintThetest(dAtA, i, uint64(*m.B))
25287 i--
25288 dAtA[i] = 0x10
25289 }
25290 if m.A != nil {
25291 {
25292 size, err := m.A.MarshalToSizedBuffer(dAtA[:i])
25293 if err != nil {
25294 return 0, err
25295 }
25296 i -= size
25297 i = encodeVarintThetest(dAtA, i, uint64(size))
25298 }
25299 i--
25300 dAtA[i] = 0xa
25301 }
25302 return len(dAtA) - i, nil
25303 }
25304
25305 func (m *NinOptNativeDefault) Marshal() (dAtA []byte, err error) {
25306 size := m.Size()
25307 dAtA = make([]byte, size)
25308 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25309 if err != nil {
25310 return nil, err
25311 }
25312 return dAtA[:n], nil
25313 }
25314
25315 func (m *NinOptNativeDefault) MarshalTo(dAtA []byte) (int, error) {
25316 size := m.Size()
25317 return m.MarshalToSizedBuffer(dAtA[:size])
25318 }
25319
25320 func (m *NinOptNativeDefault) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25321 i := len(dAtA)
25322 _ = i
25323 var l int
25324 _ = l
25325 if m.XXX_unrecognized != nil {
25326 i -= len(m.XXX_unrecognized)
25327 copy(dAtA[i:], m.XXX_unrecognized)
25328 }
25329 if m.Field15 != nil {
25330 i -= len(m.Field15)
25331 copy(dAtA[i:], m.Field15)
25332 i = encodeVarintThetest(dAtA, i, uint64(len(m.Field15)))
25333 i--
25334 dAtA[i] = 0x7a
25335 }
25336 if m.Field14 != nil {
25337 i -= len(*m.Field14)
25338 copy(dAtA[i:], *m.Field14)
25339 i = encodeVarintThetest(dAtA, i, uint64(len(*m.Field14)))
25340 i--
25341 dAtA[i] = 0x72
25342 }
25343 if m.Field13 != nil {
25344 i--
25345 if *m.Field13 {
25346 dAtA[i] = 1
25347 } else {
25348 dAtA[i] = 0
25349 }
25350 i--
25351 dAtA[i] = 0x68
25352 }
25353 if m.Field12 != nil {
25354 i -= 8
25355 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.Field12))
25356 i--
25357 dAtA[i] = 0x61
25358 }
25359 if m.Field11 != nil {
25360 i -= 8
25361 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.Field11))
25362 i--
25363 dAtA[i] = 0x59
25364 }
25365 if m.Field10 != nil {
25366 i -= 4
25367 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.Field10))
25368 i--
25369 dAtA[i] = 0x55
25370 }
25371 if m.Field9 != nil {
25372 i -= 4
25373 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.Field9))
25374 i--
25375 dAtA[i] = 0x4d
25376 }
25377 if m.Field8 != nil {
25378 i = encodeVarintThetest(dAtA, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63))))
25379 i--
25380 dAtA[i] = 0x40
25381 }
25382 if m.Field7 != nil {
25383 i = encodeVarintThetest(dAtA, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31))))
25384 i--
25385 dAtA[i] = 0x38
25386 }
25387 if m.Field6 != nil {
25388 i = encodeVarintThetest(dAtA, i, uint64(*m.Field6))
25389 i--
25390 dAtA[i] = 0x30
25391 }
25392 if m.Field5 != nil {
25393 i = encodeVarintThetest(dAtA, i, uint64(*m.Field5))
25394 i--
25395 dAtA[i] = 0x28
25396 }
25397 if m.Field4 != nil {
25398 i = encodeVarintThetest(dAtA, i, uint64(*m.Field4))
25399 i--
25400 dAtA[i] = 0x20
25401 }
25402 if m.Field3 != nil {
25403 i = encodeVarintThetest(dAtA, i, uint64(*m.Field3))
25404 i--
25405 dAtA[i] = 0x18
25406 }
25407 if m.Field2 != nil {
25408 i -= 4
25409 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.Field2))))
25410 i--
25411 dAtA[i] = 0x15
25412 }
25413 if m.Field1 != nil {
25414 i -= 8
25415 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Field1))))
25416 i--
25417 dAtA[i] = 0x9
25418 }
25419 return len(dAtA) - i, nil
25420 }
25421
25422 func (m *CustomContainer) Marshal() (dAtA []byte, err error) {
25423 size := m.Size()
25424 dAtA = make([]byte, size)
25425 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25426 if err != nil {
25427 return nil, err
25428 }
25429 return dAtA[:n], nil
25430 }
25431
25432 func (m *CustomContainer) MarshalTo(dAtA []byte) (int, error) {
25433 size := m.Size()
25434 return m.MarshalToSizedBuffer(dAtA[:size])
25435 }
25436
25437 func (m *CustomContainer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25438 i := len(dAtA)
25439 _ = i
25440 var l int
25441 _ = l
25442 if m.XXX_unrecognized != nil {
25443 i -= len(m.XXX_unrecognized)
25444 copy(dAtA[i:], m.XXX_unrecognized)
25445 }
25446 {
25447 size, err := m.CustomStruct.MarshalToSizedBuffer(dAtA[:i])
25448 if err != nil {
25449 return 0, err
25450 }
25451 i -= size
25452 i = encodeVarintThetest(dAtA, i, uint64(size))
25453 }
25454 i--
25455 dAtA[i] = 0xa
25456 return len(dAtA) - i, nil
25457 }
25458
25459 func (m *CustomNameNidOptNative) Marshal() (dAtA []byte, err error) {
25460 size := m.Size()
25461 dAtA = make([]byte, size)
25462 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25463 if err != nil {
25464 return nil, err
25465 }
25466 return dAtA[:n], nil
25467 }
25468
25469 func (m *CustomNameNidOptNative) MarshalTo(dAtA []byte) (int, error) {
25470 size := m.Size()
25471 return m.MarshalToSizedBuffer(dAtA[:size])
25472 }
25473
25474 func (m *CustomNameNidOptNative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25475 i := len(dAtA)
25476 _ = i
25477 var l int
25478 _ = l
25479 if m.XXX_unrecognized != nil {
25480 i -= len(m.XXX_unrecognized)
25481 copy(dAtA[i:], m.XXX_unrecognized)
25482 }
25483 if m.FieldO != nil {
25484 i -= len(m.FieldO)
25485 copy(dAtA[i:], m.FieldO)
25486 i = encodeVarintThetest(dAtA, i, uint64(len(m.FieldO)))
25487 i--
25488 dAtA[i] = 0x7a
25489 }
25490 i -= len(m.FieldN)
25491 copy(dAtA[i:], m.FieldN)
25492 i = encodeVarintThetest(dAtA, i, uint64(len(m.FieldN)))
25493 i--
25494 dAtA[i] = 0x72
25495 i--
25496 if m.FieldM {
25497 dAtA[i] = 1
25498 } else {
25499 dAtA[i] = 0
25500 }
25501 i--
25502 dAtA[i] = 0x68
25503 i -= 8
25504 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.FieldL))
25505 i--
25506 dAtA[i] = 0x61
25507 i -= 8
25508 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.FieldK))
25509 i--
25510 dAtA[i] = 0x59
25511 i -= 4
25512 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.FieldJ))
25513 i--
25514 dAtA[i] = 0x55
25515 i -= 4
25516 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.FieldI))
25517 i--
25518 dAtA[i] = 0x4d
25519 i = encodeVarintThetest(dAtA, i, uint64((uint64(m.FieldH)<<1)^uint64((m.FieldH>>63))))
25520 i--
25521 dAtA[i] = 0x40
25522 i = encodeVarintThetest(dAtA, i, uint64((uint32(m.FieldG)<<1)^uint32((m.FieldG>>31))))
25523 i--
25524 dAtA[i] = 0x38
25525 i = encodeVarintThetest(dAtA, i, uint64(m.FieldF))
25526 i--
25527 dAtA[i] = 0x30
25528 i = encodeVarintThetest(dAtA, i, uint64(m.FieldE))
25529 i--
25530 dAtA[i] = 0x28
25531 i = encodeVarintThetest(dAtA, i, uint64(m.FieldD))
25532 i--
25533 dAtA[i] = 0x20
25534 i = encodeVarintThetest(dAtA, i, uint64(m.FieldC))
25535 i--
25536 dAtA[i] = 0x18
25537 i -= 4
25538 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FieldB))))
25539 i--
25540 dAtA[i] = 0x15
25541 i -= 8
25542 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FieldA))))
25543 i--
25544 dAtA[i] = 0x9
25545 return len(dAtA) - i, nil
25546 }
25547
25548 func (m *CustomNameNinOptNative) Marshal() (dAtA []byte, err error) {
25549 size := m.Size()
25550 dAtA = make([]byte, size)
25551 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25552 if err != nil {
25553 return nil, err
25554 }
25555 return dAtA[:n], nil
25556 }
25557
25558 func (m *CustomNameNinOptNative) MarshalTo(dAtA []byte) (int, error) {
25559 size := m.Size()
25560 return m.MarshalToSizedBuffer(dAtA[:size])
25561 }
25562
25563 func (m *CustomNameNinOptNative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25564 i := len(dAtA)
25565 _ = i
25566 var l int
25567 _ = l
25568 if m.XXX_unrecognized != nil {
25569 i -= len(m.XXX_unrecognized)
25570 copy(dAtA[i:], m.XXX_unrecognized)
25571 }
25572 if m.FieldO != nil {
25573 i -= len(m.FieldO)
25574 copy(dAtA[i:], m.FieldO)
25575 i = encodeVarintThetest(dAtA, i, uint64(len(m.FieldO)))
25576 i--
25577 dAtA[i] = 0x7a
25578 }
25579 if m.FieldN != nil {
25580 i -= len(*m.FieldN)
25581 copy(dAtA[i:], *m.FieldN)
25582 i = encodeVarintThetest(dAtA, i, uint64(len(*m.FieldN)))
25583 i--
25584 dAtA[i] = 0x72
25585 }
25586 if m.FieldM != nil {
25587 i--
25588 if *m.FieldM {
25589 dAtA[i] = 1
25590 } else {
25591 dAtA[i] = 0
25592 }
25593 i--
25594 dAtA[i] = 0x68
25595 }
25596 if m.FielL != nil {
25597 i -= 8
25598 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.FielL))
25599 i--
25600 dAtA[i] = 0x61
25601 }
25602 if m.FieldK != nil {
25603 i -= 8
25604 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.FieldK))
25605 i--
25606 dAtA[i] = 0x59
25607 }
25608 if m.FieldJ != nil {
25609 i -= 4
25610 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.FieldJ))
25611 i--
25612 dAtA[i] = 0x55
25613 }
25614 if m.FieldI != nil {
25615 i -= 4
25616 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.FieldI))
25617 i--
25618 dAtA[i] = 0x4d
25619 }
25620 if m.FieldH != nil {
25621 i = encodeVarintThetest(dAtA, i, uint64((uint64(*m.FieldH)<<1)^uint64((*m.FieldH>>63))))
25622 i--
25623 dAtA[i] = 0x40
25624 }
25625 if m.FieldG != nil {
25626 i = encodeVarintThetest(dAtA, i, uint64((uint32(*m.FieldG)<<1)^uint32((*m.FieldG>>31))))
25627 i--
25628 dAtA[i] = 0x38
25629 }
25630 if m.FieldF != nil {
25631 i = encodeVarintThetest(dAtA, i, uint64(*m.FieldF))
25632 i--
25633 dAtA[i] = 0x30
25634 }
25635 if m.FieldE != nil {
25636 i = encodeVarintThetest(dAtA, i, uint64(*m.FieldE))
25637 i--
25638 dAtA[i] = 0x28
25639 }
25640 if m.FieldD != nil {
25641 i = encodeVarintThetest(dAtA, i, uint64(*m.FieldD))
25642 i--
25643 dAtA[i] = 0x20
25644 }
25645 if m.FieldC != nil {
25646 i = encodeVarintThetest(dAtA, i, uint64(*m.FieldC))
25647 i--
25648 dAtA[i] = 0x18
25649 }
25650 if m.FieldB != nil {
25651 i -= 4
25652 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.FieldB))))
25653 i--
25654 dAtA[i] = 0x15
25655 }
25656 if m.FieldA != nil {
25657 i -= 8
25658 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.FieldA))))
25659 i--
25660 dAtA[i] = 0x9
25661 }
25662 return len(dAtA) - i, nil
25663 }
25664
25665 func (m *CustomNameNinRepNative) Marshal() (dAtA []byte, err error) {
25666 size := m.Size()
25667 dAtA = make([]byte, size)
25668 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25669 if err != nil {
25670 return nil, err
25671 }
25672 return dAtA[:n], nil
25673 }
25674
25675 func (m *CustomNameNinRepNative) MarshalTo(dAtA []byte) (int, error) {
25676 size := m.Size()
25677 return m.MarshalToSizedBuffer(dAtA[:size])
25678 }
25679
25680 func (m *CustomNameNinRepNative) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25681 i := len(dAtA)
25682 _ = i
25683 var l int
25684 _ = l
25685 if m.XXX_unrecognized != nil {
25686 i -= len(m.XXX_unrecognized)
25687 copy(dAtA[i:], m.XXX_unrecognized)
25688 }
25689 if len(m.FieldO) > 0 {
25690 for iNdEx := len(m.FieldO) - 1; iNdEx >= 0; iNdEx-- {
25691 i -= len(m.FieldO[iNdEx])
25692 copy(dAtA[i:], m.FieldO[iNdEx])
25693 i = encodeVarintThetest(dAtA, i, uint64(len(m.FieldO[iNdEx])))
25694 i--
25695 dAtA[i] = 0x7a
25696 }
25697 }
25698 if len(m.FieldN) > 0 {
25699 for iNdEx := len(m.FieldN) - 1; iNdEx >= 0; iNdEx-- {
25700 i -= len(m.FieldN[iNdEx])
25701 copy(dAtA[i:], m.FieldN[iNdEx])
25702 i = encodeVarintThetest(dAtA, i, uint64(len(m.FieldN[iNdEx])))
25703 i--
25704 dAtA[i] = 0x72
25705 }
25706 }
25707 if len(m.FieldM) > 0 {
25708 for iNdEx := len(m.FieldM) - 1; iNdEx >= 0; iNdEx-- {
25709 i--
25710 if m.FieldM[iNdEx] {
25711 dAtA[i] = 1
25712 } else {
25713 dAtA[i] = 0
25714 }
25715 i--
25716 dAtA[i] = 0x68
25717 }
25718 }
25719 if len(m.FieldL) > 0 {
25720 for iNdEx := len(m.FieldL) - 1; iNdEx >= 0; iNdEx-- {
25721 i -= 8
25722 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.FieldL[iNdEx]))
25723 i--
25724 dAtA[i] = 0x61
25725 }
25726 }
25727 if len(m.FieldK) > 0 {
25728 for iNdEx := len(m.FieldK) - 1; iNdEx >= 0; iNdEx-- {
25729 i -= 8
25730 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.FieldK[iNdEx]))
25731 i--
25732 dAtA[i] = 0x59
25733 }
25734 }
25735 if len(m.FieldJ) > 0 {
25736 for iNdEx := len(m.FieldJ) - 1; iNdEx >= 0; iNdEx-- {
25737 i -= 4
25738 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.FieldJ[iNdEx]))
25739 i--
25740 dAtA[i] = 0x55
25741 }
25742 }
25743 if len(m.FieldI) > 0 {
25744 for iNdEx := len(m.FieldI) - 1; iNdEx >= 0; iNdEx-- {
25745 i -= 4
25746 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.FieldI[iNdEx]))
25747 i--
25748 dAtA[i] = 0x4d
25749 }
25750 }
25751 if len(m.FieldH) > 0 {
25752 for iNdEx := len(m.FieldH) - 1; iNdEx >= 0; iNdEx-- {
25753 x87 := (uint64(m.FieldH[iNdEx]) << 1) ^ uint64((m.FieldH[iNdEx] >> 63))
25754 i = encodeVarintThetest(dAtA, i, uint64(x87))
25755 i--
25756 dAtA[i] = 0x40
25757 }
25758 }
25759 if len(m.FieldG) > 0 {
25760 for iNdEx := len(m.FieldG) - 1; iNdEx >= 0; iNdEx-- {
25761 x88 := (uint32(m.FieldG[iNdEx]) << 1) ^ uint32((m.FieldG[iNdEx] >> 31))
25762 i = encodeVarintThetest(dAtA, i, uint64(x88))
25763 i--
25764 dAtA[i] = 0x38
25765 }
25766 }
25767 if len(m.FieldF) > 0 {
25768 for iNdEx := len(m.FieldF) - 1; iNdEx >= 0; iNdEx-- {
25769 i = encodeVarintThetest(dAtA, i, uint64(m.FieldF[iNdEx]))
25770 i--
25771 dAtA[i] = 0x30
25772 }
25773 }
25774 if len(m.FieldE) > 0 {
25775 for iNdEx := len(m.FieldE) - 1; iNdEx >= 0; iNdEx-- {
25776 i = encodeVarintThetest(dAtA, i, uint64(m.FieldE[iNdEx]))
25777 i--
25778 dAtA[i] = 0x28
25779 }
25780 }
25781 if len(m.FieldD) > 0 {
25782 for iNdEx := len(m.FieldD) - 1; iNdEx >= 0; iNdEx-- {
25783 i = encodeVarintThetest(dAtA, i, uint64(m.FieldD[iNdEx]))
25784 i--
25785 dAtA[i] = 0x20
25786 }
25787 }
25788 if len(m.FieldC) > 0 {
25789 for iNdEx := len(m.FieldC) - 1; iNdEx >= 0; iNdEx-- {
25790 i = encodeVarintThetest(dAtA, i, uint64(m.FieldC[iNdEx]))
25791 i--
25792 dAtA[i] = 0x18
25793 }
25794 }
25795 if len(m.FieldB) > 0 {
25796 for iNdEx := len(m.FieldB) - 1; iNdEx >= 0; iNdEx-- {
25797 f89 := math.Float32bits(float32(m.FieldB[iNdEx]))
25798 i -= 4
25799 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f89))
25800 i--
25801 dAtA[i] = 0x15
25802 }
25803 }
25804 if len(m.FieldA) > 0 {
25805 for iNdEx := len(m.FieldA) - 1; iNdEx >= 0; iNdEx-- {
25806 f90 := math.Float64bits(float64(m.FieldA[iNdEx]))
25807 i -= 8
25808 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f90))
25809 i--
25810 dAtA[i] = 0x9
25811 }
25812 }
25813 return len(dAtA) - i, nil
25814 }
25815
25816 func (m *CustomNameNinStruct) Marshal() (dAtA []byte, err error) {
25817 size := m.Size()
25818 dAtA = make([]byte, size)
25819 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25820 if err != nil {
25821 return nil, err
25822 }
25823 return dAtA[:n], nil
25824 }
25825
25826 func (m *CustomNameNinStruct) MarshalTo(dAtA []byte) (int, error) {
25827 size := m.Size()
25828 return m.MarshalToSizedBuffer(dAtA[:size])
25829 }
25830
25831 func (m *CustomNameNinStruct) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25832 i := len(dAtA)
25833 _ = i
25834 var l int
25835 _ = l
25836 if m.XXX_unrecognized != nil {
25837 i -= len(m.XXX_unrecognized)
25838 copy(dAtA[i:], m.XXX_unrecognized)
25839 }
25840 if m.FieldJ != nil {
25841 i -= len(m.FieldJ)
25842 copy(dAtA[i:], m.FieldJ)
25843 i = encodeVarintThetest(dAtA, i, uint64(len(m.FieldJ)))
25844 i--
25845 dAtA[i] = 0x7a
25846 }
25847 if m.FieldI != nil {
25848 i -= len(*m.FieldI)
25849 copy(dAtA[i:], *m.FieldI)
25850 i = encodeVarintThetest(dAtA, i, uint64(len(*m.FieldI)))
25851 i--
25852 dAtA[i] = 0x72
25853 }
25854 if m.FieldH != nil {
25855 i--
25856 if *m.FieldH {
25857 dAtA[i] = 1
25858 } else {
25859 dAtA[i] = 0
25860 }
25861 i--
25862 dAtA[i] = 0x68
25863 }
25864 if m.FieldG != nil {
25865 {
25866 size, err := m.FieldG.MarshalToSizedBuffer(dAtA[:i])
25867 if err != nil {
25868 return 0, err
25869 }
25870 i -= size
25871 i = encodeVarintThetest(dAtA, i, uint64(size))
25872 }
25873 i--
25874 dAtA[i] = 0x42
25875 }
25876 if m.FieldF != nil {
25877 i = encodeVarintThetest(dAtA, i, uint64((uint32(*m.FieldF)<<1)^uint32((*m.FieldF>>31))))
25878 i--
25879 dAtA[i] = 0x38
25880 }
25881 if m.FieldE != nil {
25882 i = encodeVarintThetest(dAtA, i, uint64(*m.FieldE))
25883 i--
25884 dAtA[i] = 0x30
25885 }
25886 if len(m.FieldD) > 0 {
25887 for iNdEx := len(m.FieldD) - 1; iNdEx >= 0; iNdEx-- {
25888 {
25889 size, err := m.FieldD[iNdEx].MarshalToSizedBuffer(dAtA[:i])
25890 if err != nil {
25891 return 0, err
25892 }
25893 i -= size
25894 i = encodeVarintThetest(dAtA, i, uint64(size))
25895 }
25896 i--
25897 dAtA[i] = 0x22
25898 }
25899 }
25900 if m.FieldC != nil {
25901 {
25902 size, err := m.FieldC.MarshalToSizedBuffer(dAtA[:i])
25903 if err != nil {
25904 return 0, err
25905 }
25906 i -= size
25907 i = encodeVarintThetest(dAtA, i, uint64(size))
25908 }
25909 i--
25910 dAtA[i] = 0x1a
25911 }
25912 if m.FieldB != nil {
25913 i -= 4
25914 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.FieldB))))
25915 i--
25916 dAtA[i] = 0x15
25917 }
25918 if m.FieldA != nil {
25919 i -= 8
25920 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.FieldA))))
25921 i--
25922 dAtA[i] = 0x9
25923 }
25924 return len(dAtA) - i, nil
25925 }
25926
25927 func (m *CustomNameCustomType) Marshal() (dAtA []byte, err error) {
25928 size := m.Size()
25929 dAtA = make([]byte, size)
25930 n, err := m.MarshalToSizedBuffer(dAtA[:size])
25931 if err != nil {
25932 return nil, err
25933 }
25934 return dAtA[:n], nil
25935 }
25936
25937 func (m *CustomNameCustomType) MarshalTo(dAtA []byte) (int, error) {
25938 size := m.Size()
25939 return m.MarshalToSizedBuffer(dAtA[:size])
25940 }
25941
25942 func (m *CustomNameCustomType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
25943 i := len(dAtA)
25944 _ = i
25945 var l int
25946 _ = l
25947 if m.XXX_unrecognized != nil {
25948 i -= len(m.XXX_unrecognized)
25949 copy(dAtA[i:], m.XXX_unrecognized)
25950 }
25951 if len(m.FieldD) > 0 {
25952 for iNdEx := len(m.FieldD) - 1; iNdEx >= 0; iNdEx-- {
25953 {
25954 size := m.FieldD[iNdEx].Size()
25955 i -= size
25956 if _, err := m.FieldD[iNdEx].MarshalTo(dAtA[i:]); err != nil {
25957 return 0, err
25958 }
25959 i = encodeVarintThetest(dAtA, i, uint64(size))
25960 }
25961 i--
25962 dAtA[i] = 0x22
25963 }
25964 }
25965 if len(m.FieldC) > 0 {
25966 for iNdEx := len(m.FieldC) - 1; iNdEx >= 0; iNdEx-- {
25967 {
25968 size := m.FieldC[iNdEx].Size()
25969 i -= size
25970 if _, err := m.FieldC[iNdEx].MarshalTo(dAtA[i:]); err != nil {
25971 return 0, err
25972 }
25973 i = encodeVarintThetest(dAtA, i, uint64(size))
25974 }
25975 i--
25976 dAtA[i] = 0x1a
25977 }
25978 }
25979 if m.FieldB != nil {
25980 {
25981 size := m.FieldB.Size()
25982 i -= size
25983 if _, err := m.FieldB.MarshalTo(dAtA[i:]); err != nil {
25984 return 0, err
25985 }
25986 i = encodeVarintThetest(dAtA, i, uint64(size))
25987 }
25988 i--
25989 dAtA[i] = 0x12
25990 }
25991 if m.FieldA != nil {
25992 {
25993 size := m.FieldA.Size()
25994 i -= size
25995 if _, err := m.FieldA.MarshalTo(dAtA[i:]); err != nil {
25996 return 0, err
25997 }
25998 i = encodeVarintThetest(dAtA, i, uint64(size))
25999 }
26000 i--
26001 dAtA[i] = 0xa
26002 }
26003 return len(dAtA) - i, nil
26004 }
26005
26006 func (m *CustomNameNinEmbeddedStructUnion) Marshal() (dAtA []byte, err error) {
26007 size := m.Size()
26008 dAtA = make([]byte, size)
26009 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26010 if err != nil {
26011 return nil, err
26012 }
26013 return dAtA[:n], nil
26014 }
26015
26016 func (m *CustomNameNinEmbeddedStructUnion) MarshalTo(dAtA []byte) (int, error) {
26017 size := m.Size()
26018 return m.MarshalToSizedBuffer(dAtA[:size])
26019 }
26020
26021 func (m *CustomNameNinEmbeddedStructUnion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26022 i := len(dAtA)
26023 _ = i
26024 var l int
26025 _ = l
26026 if m.XXX_unrecognized != nil {
26027 i -= len(m.XXX_unrecognized)
26028 copy(dAtA[i:], m.XXX_unrecognized)
26029 }
26030 if m.FieldB != nil {
26031 i--
26032 if *m.FieldB {
26033 dAtA[i] = 1
26034 } else {
26035 dAtA[i] = 0
26036 }
26037 i--
26038 dAtA[i] = 0xd
26039 i--
26040 dAtA[i] = 0x90
26041 }
26042 if m.FieldA != nil {
26043 {
26044 size, err := m.FieldA.MarshalToSizedBuffer(dAtA[:i])
26045 if err != nil {
26046 return 0, err
26047 }
26048 i -= size
26049 i = encodeVarintThetest(dAtA, i, uint64(size))
26050 }
26051 i--
26052 dAtA[i] = 0xc
26053 i--
26054 dAtA[i] = 0xc2
26055 }
26056 if m.NidOptNative != nil {
26057 {
26058 size, err := m.NidOptNative.MarshalToSizedBuffer(dAtA[:i])
26059 if err != nil {
26060 return 0, err
26061 }
26062 i -= size
26063 i = encodeVarintThetest(dAtA, i, uint64(size))
26064 }
26065 i--
26066 dAtA[i] = 0xa
26067 }
26068 return len(dAtA) - i, nil
26069 }
26070
26071 func (m *CustomNameEnum) Marshal() (dAtA []byte, err error) {
26072 size := m.Size()
26073 dAtA = make([]byte, size)
26074 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26075 if err != nil {
26076 return nil, err
26077 }
26078 return dAtA[:n], nil
26079 }
26080
26081 func (m *CustomNameEnum) MarshalTo(dAtA []byte) (int, error) {
26082 size := m.Size()
26083 return m.MarshalToSizedBuffer(dAtA[:size])
26084 }
26085
26086 func (m *CustomNameEnum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26087 i := len(dAtA)
26088 _ = i
26089 var l int
26090 _ = l
26091 if m.XXX_unrecognized != nil {
26092 i -= len(m.XXX_unrecognized)
26093 copy(dAtA[i:], m.XXX_unrecognized)
26094 }
26095 if len(m.FieldB) > 0 {
26096 for iNdEx := len(m.FieldB) - 1; iNdEx >= 0; iNdEx-- {
26097 i = encodeVarintThetest(dAtA, i, uint64(m.FieldB[iNdEx]))
26098 i--
26099 dAtA[i] = 0x10
26100 }
26101 }
26102 if m.FieldA != nil {
26103 i = encodeVarintThetest(dAtA, i, uint64(*m.FieldA))
26104 i--
26105 dAtA[i] = 0x8
26106 }
26107 return len(dAtA) - i, nil
26108 }
26109
26110 func (m *NoExtensionsMap) Marshal() (dAtA []byte, err error) {
26111 size := m.Size()
26112 dAtA = make([]byte, size)
26113 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26114 if err != nil {
26115 return nil, err
26116 }
26117 return dAtA[:n], nil
26118 }
26119
26120 func (m *NoExtensionsMap) MarshalTo(dAtA []byte) (int, error) {
26121 size := m.Size()
26122 return m.MarshalToSizedBuffer(dAtA[:size])
26123 }
26124
26125 func (m *NoExtensionsMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26126 i := len(dAtA)
26127 _ = i
26128 var l int
26129 _ = l
26130 if m.XXX_unrecognized != nil {
26131 i -= len(m.XXX_unrecognized)
26132 copy(dAtA[i:], m.XXX_unrecognized)
26133 }
26134 if m.XXX_extensions != nil {
26135 i -= len(m.XXX_extensions)
26136 copy(dAtA[i:], m.XXX_extensions)
26137 }
26138 if m.Field1 != nil {
26139 i = encodeVarintThetest(dAtA, i, uint64(*m.Field1))
26140 i--
26141 dAtA[i] = 0x8
26142 }
26143 return len(dAtA) - i, nil
26144 }
26145
26146 func (m *Unrecognized) Marshal() (dAtA []byte, err error) {
26147 size := m.Size()
26148 dAtA = make([]byte, size)
26149 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26150 if err != nil {
26151 return nil, err
26152 }
26153 return dAtA[:n], nil
26154 }
26155
26156 func (m *Unrecognized) MarshalTo(dAtA []byte) (int, error) {
26157 size := m.Size()
26158 return m.MarshalToSizedBuffer(dAtA[:size])
26159 }
26160
26161 func (m *Unrecognized) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26162 i := len(dAtA)
26163 _ = i
26164 var l int
26165 _ = l
26166 if m.Field1 != nil {
26167 i -= len(*m.Field1)
26168 copy(dAtA[i:], *m.Field1)
26169 i = encodeVarintThetest(dAtA, i, uint64(len(*m.Field1)))
26170 i--
26171 dAtA[i] = 0xa
26172 }
26173 return len(dAtA) - i, nil
26174 }
26175
26176 func (m *UnrecognizedWithInner) Marshal() (dAtA []byte, err error) {
26177 size := m.Size()
26178 dAtA = make([]byte, size)
26179 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26180 if err != nil {
26181 return nil, err
26182 }
26183 return dAtA[:n], nil
26184 }
26185
26186 func (m *UnrecognizedWithInner) MarshalTo(dAtA []byte) (int, error) {
26187 size := m.Size()
26188 return m.MarshalToSizedBuffer(dAtA[:size])
26189 }
26190
26191 func (m *UnrecognizedWithInner) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26192 i := len(dAtA)
26193 _ = i
26194 var l int
26195 _ = l
26196 if m.XXX_unrecognized != nil {
26197 i -= len(m.XXX_unrecognized)
26198 copy(dAtA[i:], m.XXX_unrecognized)
26199 }
26200 if m.Field2 != nil {
26201 i -= len(*m.Field2)
26202 copy(dAtA[i:], *m.Field2)
26203 i = encodeVarintThetest(dAtA, i, uint64(len(*m.Field2)))
26204 i--
26205 dAtA[i] = 0x12
26206 }
26207 if len(m.Embedded) > 0 {
26208 for iNdEx := len(m.Embedded) - 1; iNdEx >= 0; iNdEx-- {
26209 {
26210 size, err := m.Embedded[iNdEx].MarshalToSizedBuffer(dAtA[:i])
26211 if err != nil {
26212 return 0, err
26213 }
26214 i -= size
26215 i = encodeVarintThetest(dAtA, i, uint64(size))
26216 }
26217 i--
26218 dAtA[i] = 0xa
26219 }
26220 }
26221 return len(dAtA) - i, nil
26222 }
26223
26224 func (m *UnrecognizedWithInner_Inner) Marshal() (dAtA []byte, err error) {
26225 size := m.Size()
26226 dAtA = make([]byte, size)
26227 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26228 if err != nil {
26229 return nil, err
26230 }
26231 return dAtA[:n], nil
26232 }
26233
26234 func (m *UnrecognizedWithInner_Inner) MarshalTo(dAtA []byte) (int, error) {
26235 size := m.Size()
26236 return m.MarshalToSizedBuffer(dAtA[:size])
26237 }
26238
26239 func (m *UnrecognizedWithInner_Inner) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26240 i := len(dAtA)
26241 _ = i
26242 var l int
26243 _ = l
26244 if m.Field1 != nil {
26245 i = encodeVarintThetest(dAtA, i, uint64(*m.Field1))
26246 i--
26247 dAtA[i] = 0x8
26248 }
26249 return len(dAtA) - i, nil
26250 }
26251
26252 func (m *UnrecognizedWithEmbed) Marshal() (dAtA []byte, err error) {
26253 size := m.Size()
26254 dAtA = make([]byte, size)
26255 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26256 if err != nil {
26257 return nil, err
26258 }
26259 return dAtA[:n], nil
26260 }
26261
26262 func (m *UnrecognizedWithEmbed) MarshalTo(dAtA []byte) (int, error) {
26263 size := m.Size()
26264 return m.MarshalToSizedBuffer(dAtA[:size])
26265 }
26266
26267 func (m *UnrecognizedWithEmbed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26268 i := len(dAtA)
26269 _ = i
26270 var l int
26271 _ = l
26272 if m.XXX_unrecognized != nil {
26273 i -= len(m.XXX_unrecognized)
26274 copy(dAtA[i:], m.XXX_unrecognized)
26275 }
26276 if m.Field2 != nil {
26277 i -= len(*m.Field2)
26278 copy(dAtA[i:], *m.Field2)
26279 i = encodeVarintThetest(dAtA, i, uint64(len(*m.Field2)))
26280 i--
26281 dAtA[i] = 0x12
26282 }
26283 {
26284 size, err := m.UnrecognizedWithEmbed_Embedded.MarshalToSizedBuffer(dAtA[:i])
26285 if err != nil {
26286 return 0, err
26287 }
26288 i -= size
26289 i = encodeVarintThetest(dAtA, i, uint64(size))
26290 }
26291 i--
26292 dAtA[i] = 0xa
26293 return len(dAtA) - i, nil
26294 }
26295
26296 func (m *UnrecognizedWithEmbed_Embedded) Marshal() (dAtA []byte, err error) {
26297 size := m.Size()
26298 dAtA = make([]byte, size)
26299 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26300 if err != nil {
26301 return nil, err
26302 }
26303 return dAtA[:n], nil
26304 }
26305
26306 func (m *UnrecognizedWithEmbed_Embedded) MarshalTo(dAtA []byte) (int, error) {
26307 size := m.Size()
26308 return m.MarshalToSizedBuffer(dAtA[:size])
26309 }
26310
26311 func (m *UnrecognizedWithEmbed_Embedded) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26312 i := len(dAtA)
26313 _ = i
26314 var l int
26315 _ = l
26316 if m.Field1 != nil {
26317 i = encodeVarintThetest(dAtA, i, uint64(*m.Field1))
26318 i--
26319 dAtA[i] = 0x8
26320 }
26321 return len(dAtA) - i, nil
26322 }
26323
26324 func (m *Node) Marshal() (dAtA []byte, err error) {
26325 size := m.Size()
26326 dAtA = make([]byte, size)
26327 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26328 if err != nil {
26329 return nil, err
26330 }
26331 return dAtA[:n], nil
26332 }
26333
26334 func (m *Node) MarshalTo(dAtA []byte) (int, error) {
26335 size := m.Size()
26336 return m.MarshalToSizedBuffer(dAtA[:size])
26337 }
26338
26339 func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26340 i := len(dAtA)
26341 _ = i
26342 var l int
26343 _ = l
26344 if m.XXX_unrecognized != nil {
26345 i -= len(m.XXX_unrecognized)
26346 copy(dAtA[i:], m.XXX_unrecognized)
26347 }
26348 if len(m.Children) > 0 {
26349 for iNdEx := len(m.Children) - 1; iNdEx >= 0; iNdEx-- {
26350 {
26351 size, err := m.Children[iNdEx].MarshalToSizedBuffer(dAtA[:i])
26352 if err != nil {
26353 return 0, err
26354 }
26355 i -= size
26356 i = encodeVarintThetest(dAtA, i, uint64(size))
26357 }
26358 i--
26359 dAtA[i] = 0x12
26360 }
26361 }
26362 if m.Label != nil {
26363 i -= len(*m.Label)
26364 copy(dAtA[i:], *m.Label)
26365 i = encodeVarintThetest(dAtA, i, uint64(len(*m.Label)))
26366 i--
26367 dAtA[i] = 0xa
26368 }
26369 return len(dAtA) - i, nil
26370 }
26371
26372 func (m *NonByteCustomType) Marshal() (dAtA []byte, err error) {
26373 size := m.Size()
26374 dAtA = make([]byte, size)
26375 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26376 if err != nil {
26377 return nil, err
26378 }
26379 return dAtA[:n], nil
26380 }
26381
26382 func (m *NonByteCustomType) MarshalTo(dAtA []byte) (int, error) {
26383 size := m.Size()
26384 return m.MarshalToSizedBuffer(dAtA[:size])
26385 }
26386
26387 func (m *NonByteCustomType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26388 i := len(dAtA)
26389 _ = i
26390 var l int
26391 _ = l
26392 if m.XXX_unrecognized != nil {
26393 i -= len(m.XXX_unrecognized)
26394 copy(dAtA[i:], m.XXX_unrecognized)
26395 }
26396 if m.Field1 != nil {
26397 {
26398 size := m.Field1.Size()
26399 i -= size
26400 if _, err := m.Field1.MarshalTo(dAtA[i:]); err != nil {
26401 return 0, err
26402 }
26403 i = encodeVarintThetest(dAtA, i, uint64(size))
26404 }
26405 i--
26406 dAtA[i] = 0xa
26407 }
26408 return len(dAtA) - i, nil
26409 }
26410
26411 func (m *NidOptNonByteCustomType) Marshal() (dAtA []byte, err error) {
26412 size := m.Size()
26413 dAtA = make([]byte, size)
26414 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26415 if err != nil {
26416 return nil, err
26417 }
26418 return dAtA[:n], nil
26419 }
26420
26421 func (m *NidOptNonByteCustomType) MarshalTo(dAtA []byte) (int, error) {
26422 size := m.Size()
26423 return m.MarshalToSizedBuffer(dAtA[:size])
26424 }
26425
26426 func (m *NidOptNonByteCustomType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26427 i := len(dAtA)
26428 _ = i
26429 var l int
26430 _ = l
26431 if m.XXX_unrecognized != nil {
26432 i -= len(m.XXX_unrecognized)
26433 copy(dAtA[i:], m.XXX_unrecognized)
26434 }
26435 {
26436 size := m.Field1.Size()
26437 i -= size
26438 if _, err := m.Field1.MarshalTo(dAtA[i:]); err != nil {
26439 return 0, err
26440 }
26441 i = encodeVarintThetest(dAtA, i, uint64(size))
26442 }
26443 i--
26444 dAtA[i] = 0xa
26445 return len(dAtA) - i, nil
26446 }
26447
26448 func (m *NinOptNonByteCustomType) Marshal() (dAtA []byte, err error) {
26449 size := m.Size()
26450 dAtA = make([]byte, size)
26451 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26452 if err != nil {
26453 return nil, err
26454 }
26455 return dAtA[:n], nil
26456 }
26457
26458 func (m *NinOptNonByteCustomType) MarshalTo(dAtA []byte) (int, error) {
26459 size := m.Size()
26460 return m.MarshalToSizedBuffer(dAtA[:size])
26461 }
26462
26463 func (m *NinOptNonByteCustomType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26464 i := len(dAtA)
26465 _ = i
26466 var l int
26467 _ = l
26468 if m.XXX_unrecognized != nil {
26469 i -= len(m.XXX_unrecognized)
26470 copy(dAtA[i:], m.XXX_unrecognized)
26471 }
26472 if m.Field1 != nil {
26473 {
26474 size := m.Field1.Size()
26475 i -= size
26476 if _, err := m.Field1.MarshalTo(dAtA[i:]); err != nil {
26477 return 0, err
26478 }
26479 i = encodeVarintThetest(dAtA, i, uint64(size))
26480 }
26481 i--
26482 dAtA[i] = 0xa
26483 }
26484 return len(dAtA) - i, nil
26485 }
26486
26487 func (m *NidRepNonByteCustomType) Marshal() (dAtA []byte, err error) {
26488 size := m.Size()
26489 dAtA = make([]byte, size)
26490 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26491 if err != nil {
26492 return nil, err
26493 }
26494 return dAtA[:n], nil
26495 }
26496
26497 func (m *NidRepNonByteCustomType) MarshalTo(dAtA []byte) (int, error) {
26498 size := m.Size()
26499 return m.MarshalToSizedBuffer(dAtA[:size])
26500 }
26501
26502 func (m *NidRepNonByteCustomType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26503 i := len(dAtA)
26504 _ = i
26505 var l int
26506 _ = l
26507 if m.XXX_unrecognized != nil {
26508 i -= len(m.XXX_unrecognized)
26509 copy(dAtA[i:], m.XXX_unrecognized)
26510 }
26511 if len(m.Field1) > 0 {
26512 for iNdEx := len(m.Field1) - 1; iNdEx >= 0; iNdEx-- {
26513 {
26514 size := m.Field1[iNdEx].Size()
26515 i -= size
26516 if _, err := m.Field1[iNdEx].MarshalTo(dAtA[i:]); err != nil {
26517 return 0, err
26518 }
26519 i = encodeVarintThetest(dAtA, i, uint64(size))
26520 }
26521 i--
26522 dAtA[i] = 0xa
26523 }
26524 }
26525 return len(dAtA) - i, nil
26526 }
26527
26528 func (m *NinRepNonByteCustomType) Marshal() (dAtA []byte, err error) {
26529 size := m.Size()
26530 dAtA = make([]byte, size)
26531 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26532 if err != nil {
26533 return nil, err
26534 }
26535 return dAtA[:n], nil
26536 }
26537
26538 func (m *NinRepNonByteCustomType) MarshalTo(dAtA []byte) (int, error) {
26539 size := m.Size()
26540 return m.MarshalToSizedBuffer(dAtA[:size])
26541 }
26542
26543 func (m *NinRepNonByteCustomType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26544 i := len(dAtA)
26545 _ = i
26546 var l int
26547 _ = l
26548 if m.XXX_unrecognized != nil {
26549 i -= len(m.XXX_unrecognized)
26550 copy(dAtA[i:], m.XXX_unrecognized)
26551 }
26552 if len(m.Field1) > 0 {
26553 for iNdEx := len(m.Field1) - 1; iNdEx >= 0; iNdEx-- {
26554 {
26555 size := m.Field1[iNdEx].Size()
26556 i -= size
26557 if _, err := m.Field1[iNdEx].MarshalTo(dAtA[i:]); err != nil {
26558 return 0, err
26559 }
26560 i = encodeVarintThetest(dAtA, i, uint64(size))
26561 }
26562 i--
26563 dAtA[i] = 0xa
26564 }
26565 }
26566 return len(dAtA) - i, nil
26567 }
26568
26569 func (m *ProtoType) Marshal() (dAtA []byte, err error) {
26570 size := m.Size()
26571 dAtA = make([]byte, size)
26572 n, err := m.MarshalToSizedBuffer(dAtA[:size])
26573 if err != nil {
26574 return nil, err
26575 }
26576 return dAtA[:n], nil
26577 }
26578
26579 func (m *ProtoType) MarshalTo(dAtA []byte) (int, error) {
26580 size := m.Size()
26581 return m.MarshalToSizedBuffer(dAtA[:size])
26582 }
26583
26584 func (m *ProtoType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
26585 i := len(dAtA)
26586 _ = i
26587 var l int
26588 _ = l
26589 if m.XXX_unrecognized != nil {
26590 i -= len(m.XXX_unrecognized)
26591 copy(dAtA[i:], m.XXX_unrecognized)
26592 }
26593 if m.Field2 != nil {
26594 i -= len(*m.Field2)
26595 copy(dAtA[i:], *m.Field2)
26596 i = encodeVarintThetest(dAtA, i, uint64(len(*m.Field2)))
26597 i--
26598 dAtA[i] = 0xa
26599 }
26600 return len(dAtA) - i, nil
26601 }
26602
26603 func encodeVarintThetest(dAtA []byte, offset int, v uint64) int {
26604 offset -= sovThetest(v)
26605 base := offset
26606 for v >= 1<<7 {
26607 dAtA[offset] = uint8(v&0x7f | 0x80)
26608 v >>= 7
26609 offset++
26610 }
26611 dAtA[offset] = uint8(v)
26612 return base
26613 }
26614 func NewPopulatedNidOptNative(r randyThetest, easy bool) *NidOptNative {
26615 this := &NidOptNative{}
26616 this.Field1 = float64(r.Float64())
26617 if r.Intn(2) == 0 {
26618 this.Field1 *= -1
26619 }
26620 this.Field2 = float32(r.Float32())
26621 if r.Intn(2) == 0 {
26622 this.Field2 *= -1
26623 }
26624 this.Field3 = int32(r.Int31())
26625 if r.Intn(2) == 0 {
26626 this.Field3 *= -1
26627 }
26628 this.Field4 = int64(r.Int63())
26629 if r.Intn(2) == 0 {
26630 this.Field4 *= -1
26631 }
26632 this.Field5 = uint32(r.Uint32())
26633 this.Field6 = uint64(uint64(r.Uint32()))
26634 this.Field7 = int32(r.Int31())
26635 if r.Intn(2) == 0 {
26636 this.Field7 *= -1
26637 }
26638 this.Field8 = int64(r.Int63())
26639 if r.Intn(2) == 0 {
26640 this.Field8 *= -1
26641 }
26642 this.Field9 = uint32(r.Uint32())
26643 this.Field10 = int32(r.Int31())
26644 if r.Intn(2) == 0 {
26645 this.Field10 *= -1
26646 }
26647 this.Field11 = uint64(uint64(r.Uint32()))
26648 this.Field12 = int64(r.Int63())
26649 if r.Intn(2) == 0 {
26650 this.Field12 *= -1
26651 }
26652 this.Field13 = bool(bool(r.Intn(2) == 0))
26653 this.Field14 = string(randStringThetest(r))
26654 v1 := r.Intn(100)
26655 this.Field15 = make([]byte, v1)
26656 for i := 0; i < v1; i++ {
26657 this.Field15[i] = byte(r.Intn(256))
26658 }
26659 if !easy && r.Intn(10) != 0 {
26660 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
26661 }
26662 return this
26663 }
26664
26665 func NewPopulatedNinOptNative(r randyThetest, easy bool) *NinOptNative {
26666 this := &NinOptNative{}
26667 if r.Intn(5) != 0 {
26668 v2 := float64(r.Float64())
26669 if r.Intn(2) == 0 {
26670 v2 *= -1
26671 }
26672 this.Field1 = &v2
26673 }
26674 if r.Intn(5) != 0 {
26675 v3 := float32(r.Float32())
26676 if r.Intn(2) == 0 {
26677 v3 *= -1
26678 }
26679 this.Field2 = &v3
26680 }
26681 if r.Intn(5) != 0 {
26682 v4 := int32(r.Int31())
26683 if r.Intn(2) == 0 {
26684 v4 *= -1
26685 }
26686 this.Field3 = &v4
26687 }
26688 if r.Intn(5) != 0 {
26689 v5 := int64(r.Int63())
26690 if r.Intn(2) == 0 {
26691 v5 *= -1
26692 }
26693 this.Field4 = &v5
26694 }
26695 if r.Intn(5) != 0 {
26696 v6 := uint32(r.Uint32())
26697 this.Field5 = &v6
26698 }
26699 if r.Intn(5) != 0 {
26700 v7 := uint64(uint64(r.Uint32()))
26701 this.Field6 = &v7
26702 }
26703 if r.Intn(5) != 0 {
26704 v8 := int32(r.Int31())
26705 if r.Intn(2) == 0 {
26706 v8 *= -1
26707 }
26708 this.Field7 = &v8
26709 }
26710 if r.Intn(5) != 0 {
26711 v9 := int64(r.Int63())
26712 if r.Intn(2) == 0 {
26713 v9 *= -1
26714 }
26715 this.Field8 = &v9
26716 }
26717 if r.Intn(5) != 0 {
26718 v10 := uint32(r.Uint32())
26719 this.Field9 = &v10
26720 }
26721 if r.Intn(5) != 0 {
26722 v11 := int32(r.Int31())
26723 if r.Intn(2) == 0 {
26724 v11 *= -1
26725 }
26726 this.Field10 = &v11
26727 }
26728 if r.Intn(5) != 0 {
26729 v12 := uint64(uint64(r.Uint32()))
26730 this.Field11 = &v12
26731 }
26732 if r.Intn(5) != 0 {
26733 v13 := int64(r.Int63())
26734 if r.Intn(2) == 0 {
26735 v13 *= -1
26736 }
26737 this.Field12 = &v13
26738 }
26739 if r.Intn(5) != 0 {
26740 v14 := bool(bool(r.Intn(2) == 0))
26741 this.Field13 = &v14
26742 }
26743 if r.Intn(5) != 0 {
26744 v15 := string(randStringThetest(r))
26745 this.Field14 = &v15
26746 }
26747 if r.Intn(5) != 0 {
26748 v16 := r.Intn(100)
26749 this.Field15 = make([]byte, v16)
26750 for i := 0; i < v16; i++ {
26751 this.Field15[i] = byte(r.Intn(256))
26752 }
26753 }
26754 if !easy && r.Intn(10) != 0 {
26755 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
26756 }
26757 return this
26758 }
26759
26760 func NewPopulatedNidRepNative(r randyThetest, easy bool) *NidRepNative {
26761 this := &NidRepNative{}
26762 if r.Intn(5) != 0 {
26763 v17 := r.Intn(10)
26764 this.Field1 = make([]float64, v17)
26765 for i := 0; i < v17; i++ {
26766 this.Field1[i] = float64(r.Float64())
26767 if r.Intn(2) == 0 {
26768 this.Field1[i] *= -1
26769 }
26770 }
26771 }
26772 if r.Intn(5) != 0 {
26773 v18 := r.Intn(10)
26774 this.Field2 = make([]float32, v18)
26775 for i := 0; i < v18; i++ {
26776 this.Field2[i] = float32(r.Float32())
26777 if r.Intn(2) == 0 {
26778 this.Field2[i] *= -1
26779 }
26780 }
26781 }
26782 if r.Intn(5) != 0 {
26783 v19 := r.Intn(10)
26784 this.Field3 = make([]int32, v19)
26785 for i := 0; i < v19; i++ {
26786 this.Field3[i] = int32(r.Int31())
26787 if r.Intn(2) == 0 {
26788 this.Field3[i] *= -1
26789 }
26790 }
26791 }
26792 if r.Intn(5) != 0 {
26793 v20 := r.Intn(10)
26794 this.Field4 = make([]int64, v20)
26795 for i := 0; i < v20; i++ {
26796 this.Field4[i] = int64(r.Int63())
26797 if r.Intn(2) == 0 {
26798 this.Field4[i] *= -1
26799 }
26800 }
26801 }
26802 if r.Intn(5) != 0 {
26803 v21 := r.Intn(10)
26804 this.Field5 = make([]uint32, v21)
26805 for i := 0; i < v21; i++ {
26806 this.Field5[i] = uint32(r.Uint32())
26807 }
26808 }
26809 if r.Intn(5) != 0 {
26810 v22 := r.Intn(10)
26811 this.Field6 = make([]uint64, v22)
26812 for i := 0; i < v22; i++ {
26813 this.Field6[i] = uint64(uint64(r.Uint32()))
26814 }
26815 }
26816 if r.Intn(5) != 0 {
26817 v23 := r.Intn(10)
26818 this.Field7 = make([]int32, v23)
26819 for i := 0; i < v23; i++ {
26820 this.Field7[i] = int32(r.Int31())
26821 if r.Intn(2) == 0 {
26822 this.Field7[i] *= -1
26823 }
26824 }
26825 }
26826 if r.Intn(5) != 0 {
26827 v24 := r.Intn(10)
26828 this.Field8 = make([]int64, v24)
26829 for i := 0; i < v24; i++ {
26830 this.Field8[i] = int64(r.Int63())
26831 if r.Intn(2) == 0 {
26832 this.Field8[i] *= -1
26833 }
26834 }
26835 }
26836 if r.Intn(5) != 0 {
26837 v25 := r.Intn(10)
26838 this.Field9 = make([]uint32, v25)
26839 for i := 0; i < v25; i++ {
26840 this.Field9[i] = uint32(r.Uint32())
26841 }
26842 }
26843 if r.Intn(5) != 0 {
26844 v26 := r.Intn(10)
26845 this.Field10 = make([]int32, v26)
26846 for i := 0; i < v26; i++ {
26847 this.Field10[i] = int32(r.Int31())
26848 if r.Intn(2) == 0 {
26849 this.Field10[i] *= -1
26850 }
26851 }
26852 }
26853 if r.Intn(5) != 0 {
26854 v27 := r.Intn(10)
26855 this.Field11 = make([]uint64, v27)
26856 for i := 0; i < v27; i++ {
26857 this.Field11[i] = uint64(uint64(r.Uint32()))
26858 }
26859 }
26860 if r.Intn(5) != 0 {
26861 v28 := r.Intn(10)
26862 this.Field12 = make([]int64, v28)
26863 for i := 0; i < v28; i++ {
26864 this.Field12[i] = int64(r.Int63())
26865 if r.Intn(2) == 0 {
26866 this.Field12[i] *= -1
26867 }
26868 }
26869 }
26870 if r.Intn(5) != 0 {
26871 v29 := r.Intn(10)
26872 this.Field13 = make([]bool, v29)
26873 for i := 0; i < v29; i++ {
26874 this.Field13[i] = bool(bool(r.Intn(2) == 0))
26875 }
26876 }
26877 if r.Intn(5) != 0 {
26878 v30 := r.Intn(10)
26879 this.Field14 = make([]string, v30)
26880 for i := 0; i < v30; i++ {
26881 this.Field14[i] = string(randStringThetest(r))
26882 }
26883 }
26884 if r.Intn(5) != 0 {
26885 v31 := r.Intn(10)
26886 this.Field15 = make([][]byte, v31)
26887 for i := 0; i < v31; i++ {
26888 v32 := r.Intn(100)
26889 this.Field15[i] = make([]byte, v32)
26890 for j := 0; j < v32; j++ {
26891 this.Field15[i][j] = byte(r.Intn(256))
26892 }
26893 }
26894 }
26895 if !easy && r.Intn(10) != 0 {
26896 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
26897 }
26898 return this
26899 }
26900
26901 func NewPopulatedNinRepNative(r randyThetest, easy bool) *NinRepNative {
26902 this := &NinRepNative{}
26903 if r.Intn(5) != 0 {
26904 v33 := r.Intn(10)
26905 this.Field1 = make([]float64, v33)
26906 for i := 0; i < v33; i++ {
26907 this.Field1[i] = float64(r.Float64())
26908 if r.Intn(2) == 0 {
26909 this.Field1[i] *= -1
26910 }
26911 }
26912 }
26913 if r.Intn(5) != 0 {
26914 v34 := r.Intn(10)
26915 this.Field2 = make([]float32, v34)
26916 for i := 0; i < v34; i++ {
26917 this.Field2[i] = float32(r.Float32())
26918 if r.Intn(2) == 0 {
26919 this.Field2[i] *= -1
26920 }
26921 }
26922 }
26923 if r.Intn(5) != 0 {
26924 v35 := r.Intn(10)
26925 this.Field3 = make([]int32, v35)
26926 for i := 0; i < v35; i++ {
26927 this.Field3[i] = int32(r.Int31())
26928 if r.Intn(2) == 0 {
26929 this.Field3[i] *= -1
26930 }
26931 }
26932 }
26933 if r.Intn(5) != 0 {
26934 v36 := r.Intn(10)
26935 this.Field4 = make([]int64, v36)
26936 for i := 0; i < v36; i++ {
26937 this.Field4[i] = int64(r.Int63())
26938 if r.Intn(2) == 0 {
26939 this.Field4[i] *= -1
26940 }
26941 }
26942 }
26943 if r.Intn(5) != 0 {
26944 v37 := r.Intn(10)
26945 this.Field5 = make([]uint32, v37)
26946 for i := 0; i < v37; i++ {
26947 this.Field5[i] = uint32(r.Uint32())
26948 }
26949 }
26950 if r.Intn(5) != 0 {
26951 v38 := r.Intn(10)
26952 this.Field6 = make([]uint64, v38)
26953 for i := 0; i < v38; i++ {
26954 this.Field6[i] = uint64(uint64(r.Uint32()))
26955 }
26956 }
26957 if r.Intn(5) != 0 {
26958 v39 := r.Intn(10)
26959 this.Field7 = make([]int32, v39)
26960 for i := 0; i < v39; i++ {
26961 this.Field7[i] = int32(r.Int31())
26962 if r.Intn(2) == 0 {
26963 this.Field7[i] *= -1
26964 }
26965 }
26966 }
26967 if r.Intn(5) != 0 {
26968 v40 := r.Intn(10)
26969 this.Field8 = make([]int64, v40)
26970 for i := 0; i < v40; i++ {
26971 this.Field8[i] = int64(r.Int63())
26972 if r.Intn(2) == 0 {
26973 this.Field8[i] *= -1
26974 }
26975 }
26976 }
26977 if r.Intn(5) != 0 {
26978 v41 := r.Intn(10)
26979 this.Field9 = make([]uint32, v41)
26980 for i := 0; i < v41; i++ {
26981 this.Field9[i] = uint32(r.Uint32())
26982 }
26983 }
26984 if r.Intn(5) != 0 {
26985 v42 := r.Intn(10)
26986 this.Field10 = make([]int32, v42)
26987 for i := 0; i < v42; i++ {
26988 this.Field10[i] = int32(r.Int31())
26989 if r.Intn(2) == 0 {
26990 this.Field10[i] *= -1
26991 }
26992 }
26993 }
26994 if r.Intn(5) != 0 {
26995 v43 := r.Intn(10)
26996 this.Field11 = make([]uint64, v43)
26997 for i := 0; i < v43; i++ {
26998 this.Field11[i] = uint64(uint64(r.Uint32()))
26999 }
27000 }
27001 if r.Intn(5) != 0 {
27002 v44 := r.Intn(10)
27003 this.Field12 = make([]int64, v44)
27004 for i := 0; i < v44; i++ {
27005 this.Field12[i] = int64(r.Int63())
27006 if r.Intn(2) == 0 {
27007 this.Field12[i] *= -1
27008 }
27009 }
27010 }
27011 if r.Intn(5) != 0 {
27012 v45 := r.Intn(10)
27013 this.Field13 = make([]bool, v45)
27014 for i := 0; i < v45; i++ {
27015 this.Field13[i] = bool(bool(r.Intn(2) == 0))
27016 }
27017 }
27018 if r.Intn(5) != 0 {
27019 v46 := r.Intn(10)
27020 this.Field14 = make([]string, v46)
27021 for i := 0; i < v46; i++ {
27022 this.Field14[i] = string(randStringThetest(r))
27023 }
27024 }
27025 if r.Intn(5) != 0 {
27026 v47 := r.Intn(10)
27027 this.Field15 = make([][]byte, v47)
27028 for i := 0; i < v47; i++ {
27029 v48 := r.Intn(100)
27030 this.Field15[i] = make([]byte, v48)
27031 for j := 0; j < v48; j++ {
27032 this.Field15[i][j] = byte(r.Intn(256))
27033 }
27034 }
27035 }
27036 if !easy && r.Intn(10) != 0 {
27037 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
27038 }
27039 return this
27040 }
27041
27042 func NewPopulatedNidRepPackedNative(r randyThetest, easy bool) *NidRepPackedNative {
27043 this := &NidRepPackedNative{}
27044 if r.Intn(5) != 0 {
27045 v49 := r.Intn(10)
27046 this.Field1 = make([]float64, v49)
27047 for i := 0; i < v49; i++ {
27048 this.Field1[i] = float64(r.Float64())
27049 if r.Intn(2) == 0 {
27050 this.Field1[i] *= -1
27051 }
27052 }
27053 }
27054 if r.Intn(5) != 0 {
27055 v50 := r.Intn(10)
27056 this.Field2 = make([]float32, v50)
27057 for i := 0; i < v50; i++ {
27058 this.Field2[i] = float32(r.Float32())
27059 if r.Intn(2) == 0 {
27060 this.Field2[i] *= -1
27061 }
27062 }
27063 }
27064 if r.Intn(5) != 0 {
27065 v51 := r.Intn(10)
27066 this.Field3 = make([]int32, v51)
27067 for i := 0; i < v51; i++ {
27068 this.Field3[i] = int32(r.Int31())
27069 if r.Intn(2) == 0 {
27070 this.Field3[i] *= -1
27071 }
27072 }
27073 }
27074 if r.Intn(5) != 0 {
27075 v52 := r.Intn(10)
27076 this.Field4 = make([]int64, v52)
27077 for i := 0; i < v52; i++ {
27078 this.Field4[i] = int64(r.Int63())
27079 if r.Intn(2) == 0 {
27080 this.Field4[i] *= -1
27081 }
27082 }
27083 }
27084 if r.Intn(5) != 0 {
27085 v53 := r.Intn(10)
27086 this.Field5 = make([]uint32, v53)
27087 for i := 0; i < v53; i++ {
27088 this.Field5[i] = uint32(r.Uint32())
27089 }
27090 }
27091 if r.Intn(5) != 0 {
27092 v54 := r.Intn(10)
27093 this.Field6 = make([]uint64, v54)
27094 for i := 0; i < v54; i++ {
27095 this.Field6[i] = uint64(uint64(r.Uint32()))
27096 }
27097 }
27098 if r.Intn(5) != 0 {
27099 v55 := r.Intn(10)
27100 this.Field7 = make([]int32, v55)
27101 for i := 0; i < v55; i++ {
27102 this.Field7[i] = int32(r.Int31())
27103 if r.Intn(2) == 0 {
27104 this.Field7[i] *= -1
27105 }
27106 }
27107 }
27108 if r.Intn(5) != 0 {
27109 v56 := r.Intn(10)
27110 this.Field8 = make([]int64, v56)
27111 for i := 0; i < v56; i++ {
27112 this.Field8[i] = int64(r.Int63())
27113 if r.Intn(2) == 0 {
27114 this.Field8[i] *= -1
27115 }
27116 }
27117 }
27118 if r.Intn(5) != 0 {
27119 v57 := r.Intn(10)
27120 this.Field9 = make([]uint32, v57)
27121 for i := 0; i < v57; i++ {
27122 this.Field9[i] = uint32(r.Uint32())
27123 }
27124 }
27125 if r.Intn(5) != 0 {
27126 v58 := r.Intn(10)
27127 this.Field10 = make([]int32, v58)
27128 for i := 0; i < v58; i++ {
27129 this.Field10[i] = int32(r.Int31())
27130 if r.Intn(2) == 0 {
27131 this.Field10[i] *= -1
27132 }
27133 }
27134 }
27135 if r.Intn(5) != 0 {
27136 v59 := r.Intn(10)
27137 this.Field11 = make([]uint64, v59)
27138 for i := 0; i < v59; i++ {
27139 this.Field11[i] = uint64(uint64(r.Uint32()))
27140 }
27141 }
27142 if r.Intn(5) != 0 {
27143 v60 := r.Intn(10)
27144 this.Field12 = make([]int64, v60)
27145 for i := 0; i < v60; i++ {
27146 this.Field12[i] = int64(r.Int63())
27147 if r.Intn(2) == 0 {
27148 this.Field12[i] *= -1
27149 }
27150 }
27151 }
27152 if r.Intn(5) != 0 {
27153 v61 := r.Intn(10)
27154 this.Field13 = make([]bool, v61)
27155 for i := 0; i < v61; i++ {
27156 this.Field13[i] = bool(bool(r.Intn(2) == 0))
27157 }
27158 }
27159 if !easy && r.Intn(10) != 0 {
27160 this.XXX_unrecognized = randUnrecognizedThetest(r, 14)
27161 }
27162 return this
27163 }
27164
27165 func NewPopulatedNinRepPackedNative(r randyThetest, easy bool) *NinRepPackedNative {
27166 this := &NinRepPackedNative{}
27167 if r.Intn(5) != 0 {
27168 v62 := r.Intn(10)
27169 this.Field1 = make([]float64, v62)
27170 for i := 0; i < v62; i++ {
27171 this.Field1[i] = float64(r.Float64())
27172 if r.Intn(2) == 0 {
27173 this.Field1[i] *= -1
27174 }
27175 }
27176 }
27177 if r.Intn(5) != 0 {
27178 v63 := r.Intn(10)
27179 this.Field2 = make([]float32, v63)
27180 for i := 0; i < v63; i++ {
27181 this.Field2[i] = float32(r.Float32())
27182 if r.Intn(2) == 0 {
27183 this.Field2[i] *= -1
27184 }
27185 }
27186 }
27187 if r.Intn(5) != 0 {
27188 v64 := r.Intn(10)
27189 this.Field3 = make([]int32, v64)
27190 for i := 0; i < v64; i++ {
27191 this.Field3[i] = int32(r.Int31())
27192 if r.Intn(2) == 0 {
27193 this.Field3[i] *= -1
27194 }
27195 }
27196 }
27197 if r.Intn(5) != 0 {
27198 v65 := r.Intn(10)
27199 this.Field4 = make([]int64, v65)
27200 for i := 0; i < v65; i++ {
27201 this.Field4[i] = int64(r.Int63())
27202 if r.Intn(2) == 0 {
27203 this.Field4[i] *= -1
27204 }
27205 }
27206 }
27207 if r.Intn(5) != 0 {
27208 v66 := r.Intn(10)
27209 this.Field5 = make([]uint32, v66)
27210 for i := 0; i < v66; i++ {
27211 this.Field5[i] = uint32(r.Uint32())
27212 }
27213 }
27214 if r.Intn(5) != 0 {
27215 v67 := r.Intn(10)
27216 this.Field6 = make([]uint64, v67)
27217 for i := 0; i < v67; i++ {
27218 this.Field6[i] = uint64(uint64(r.Uint32()))
27219 }
27220 }
27221 if r.Intn(5) != 0 {
27222 v68 := r.Intn(10)
27223 this.Field7 = make([]int32, v68)
27224 for i := 0; i < v68; i++ {
27225 this.Field7[i] = int32(r.Int31())
27226 if r.Intn(2) == 0 {
27227 this.Field7[i] *= -1
27228 }
27229 }
27230 }
27231 if r.Intn(5) != 0 {
27232 v69 := r.Intn(10)
27233 this.Field8 = make([]int64, v69)
27234 for i := 0; i < v69; i++ {
27235 this.Field8[i] = int64(r.Int63())
27236 if r.Intn(2) == 0 {
27237 this.Field8[i] *= -1
27238 }
27239 }
27240 }
27241 if r.Intn(5) != 0 {
27242 v70 := r.Intn(10)
27243 this.Field9 = make([]uint32, v70)
27244 for i := 0; i < v70; i++ {
27245 this.Field9[i] = uint32(r.Uint32())
27246 }
27247 }
27248 if r.Intn(5) != 0 {
27249 v71 := r.Intn(10)
27250 this.Field10 = make([]int32, v71)
27251 for i := 0; i < v71; i++ {
27252 this.Field10[i] = int32(r.Int31())
27253 if r.Intn(2) == 0 {
27254 this.Field10[i] *= -1
27255 }
27256 }
27257 }
27258 if r.Intn(5) != 0 {
27259 v72 := r.Intn(10)
27260 this.Field11 = make([]uint64, v72)
27261 for i := 0; i < v72; i++ {
27262 this.Field11[i] = uint64(uint64(r.Uint32()))
27263 }
27264 }
27265 if r.Intn(5) != 0 {
27266 v73 := r.Intn(10)
27267 this.Field12 = make([]int64, v73)
27268 for i := 0; i < v73; i++ {
27269 this.Field12[i] = int64(r.Int63())
27270 if r.Intn(2) == 0 {
27271 this.Field12[i] *= -1
27272 }
27273 }
27274 }
27275 if r.Intn(5) != 0 {
27276 v74 := r.Intn(10)
27277 this.Field13 = make([]bool, v74)
27278 for i := 0; i < v74; i++ {
27279 this.Field13[i] = bool(bool(r.Intn(2) == 0))
27280 }
27281 }
27282 if !easy && r.Intn(10) != 0 {
27283 this.XXX_unrecognized = randUnrecognizedThetest(r, 14)
27284 }
27285 return this
27286 }
27287
27288 func NewPopulatedNidOptStruct(r randyThetest, easy bool) *NidOptStruct {
27289 this := &NidOptStruct{}
27290 this.Field1 = float64(r.Float64())
27291 if r.Intn(2) == 0 {
27292 this.Field1 *= -1
27293 }
27294 this.Field2 = float32(r.Float32())
27295 if r.Intn(2) == 0 {
27296 this.Field2 *= -1
27297 }
27298 v75 := NewPopulatedNidOptNative(r, easy)
27299 this.Field3 = *v75
27300 v76 := NewPopulatedNinOptNative(r, easy)
27301 this.Field4 = *v76
27302 this.Field6 = uint64(uint64(r.Uint32()))
27303 this.Field7 = int32(r.Int31())
27304 if r.Intn(2) == 0 {
27305 this.Field7 *= -1
27306 }
27307 v77 := NewPopulatedNidOptNative(r, easy)
27308 this.Field8 = *v77
27309 this.Field13 = bool(bool(r.Intn(2) == 0))
27310 this.Field14 = string(randStringThetest(r))
27311 v78 := r.Intn(100)
27312 this.Field15 = make([]byte, v78)
27313 for i := 0; i < v78; i++ {
27314 this.Field15[i] = byte(r.Intn(256))
27315 }
27316 if !easy && r.Intn(10) != 0 {
27317 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
27318 }
27319 return this
27320 }
27321
27322 func NewPopulatedNinOptStruct(r randyThetest, easy bool) *NinOptStruct {
27323 this := &NinOptStruct{}
27324 if r.Intn(5) != 0 {
27325 v79 := float64(r.Float64())
27326 if r.Intn(2) == 0 {
27327 v79 *= -1
27328 }
27329 this.Field1 = &v79
27330 }
27331 if r.Intn(5) != 0 {
27332 v80 := float32(r.Float32())
27333 if r.Intn(2) == 0 {
27334 v80 *= -1
27335 }
27336 this.Field2 = &v80
27337 }
27338 if r.Intn(5) != 0 {
27339 this.Field3 = NewPopulatedNidOptNative(r, easy)
27340 }
27341 if r.Intn(5) != 0 {
27342 this.Field4 = NewPopulatedNinOptNative(r, easy)
27343 }
27344 if r.Intn(5) != 0 {
27345 v81 := uint64(uint64(r.Uint32()))
27346 this.Field6 = &v81
27347 }
27348 if r.Intn(5) != 0 {
27349 v82 := int32(r.Int31())
27350 if r.Intn(2) == 0 {
27351 v82 *= -1
27352 }
27353 this.Field7 = &v82
27354 }
27355 if r.Intn(5) != 0 {
27356 this.Field8 = NewPopulatedNidOptNative(r, easy)
27357 }
27358 if r.Intn(5) != 0 {
27359 v83 := bool(bool(r.Intn(2) == 0))
27360 this.Field13 = &v83
27361 }
27362 if r.Intn(5) != 0 {
27363 v84 := string(randStringThetest(r))
27364 this.Field14 = &v84
27365 }
27366 if r.Intn(5) != 0 {
27367 v85 := r.Intn(100)
27368 this.Field15 = make([]byte, v85)
27369 for i := 0; i < v85; i++ {
27370 this.Field15[i] = byte(r.Intn(256))
27371 }
27372 }
27373 if !easy && r.Intn(10) != 0 {
27374 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
27375 }
27376 return this
27377 }
27378
27379 func NewPopulatedNidRepStruct(r randyThetest, easy bool) *NidRepStruct {
27380 this := &NidRepStruct{}
27381 if r.Intn(5) != 0 {
27382 v86 := r.Intn(10)
27383 this.Field1 = make([]float64, v86)
27384 for i := 0; i < v86; i++ {
27385 this.Field1[i] = float64(r.Float64())
27386 if r.Intn(2) == 0 {
27387 this.Field1[i] *= -1
27388 }
27389 }
27390 }
27391 if r.Intn(5) != 0 {
27392 v87 := r.Intn(10)
27393 this.Field2 = make([]float32, v87)
27394 for i := 0; i < v87; i++ {
27395 this.Field2[i] = float32(r.Float32())
27396 if r.Intn(2) == 0 {
27397 this.Field2[i] *= -1
27398 }
27399 }
27400 }
27401 if r.Intn(5) != 0 {
27402 v88 := r.Intn(5)
27403 this.Field3 = make([]NidOptNative, v88)
27404 for i := 0; i < v88; i++ {
27405 v89 := NewPopulatedNidOptNative(r, easy)
27406 this.Field3[i] = *v89
27407 }
27408 }
27409 if r.Intn(5) != 0 {
27410 v90 := r.Intn(5)
27411 this.Field4 = make([]NinOptNative, v90)
27412 for i := 0; i < v90; i++ {
27413 v91 := NewPopulatedNinOptNative(r, easy)
27414 this.Field4[i] = *v91
27415 }
27416 }
27417 if r.Intn(5) != 0 {
27418 v92 := r.Intn(10)
27419 this.Field6 = make([]uint64, v92)
27420 for i := 0; i < v92; i++ {
27421 this.Field6[i] = uint64(uint64(r.Uint32()))
27422 }
27423 }
27424 if r.Intn(5) != 0 {
27425 v93 := r.Intn(10)
27426 this.Field7 = make([]int32, v93)
27427 for i := 0; i < v93; i++ {
27428 this.Field7[i] = int32(r.Int31())
27429 if r.Intn(2) == 0 {
27430 this.Field7[i] *= -1
27431 }
27432 }
27433 }
27434 if r.Intn(5) != 0 {
27435 v94 := r.Intn(5)
27436 this.Field8 = make([]NidOptNative, v94)
27437 for i := 0; i < v94; i++ {
27438 v95 := NewPopulatedNidOptNative(r, easy)
27439 this.Field8[i] = *v95
27440 }
27441 }
27442 if r.Intn(5) != 0 {
27443 v96 := r.Intn(10)
27444 this.Field13 = make([]bool, v96)
27445 for i := 0; i < v96; i++ {
27446 this.Field13[i] = bool(bool(r.Intn(2) == 0))
27447 }
27448 }
27449 if r.Intn(5) != 0 {
27450 v97 := r.Intn(10)
27451 this.Field14 = make([]string, v97)
27452 for i := 0; i < v97; i++ {
27453 this.Field14[i] = string(randStringThetest(r))
27454 }
27455 }
27456 if r.Intn(5) != 0 {
27457 v98 := r.Intn(10)
27458 this.Field15 = make([][]byte, v98)
27459 for i := 0; i < v98; i++ {
27460 v99 := r.Intn(100)
27461 this.Field15[i] = make([]byte, v99)
27462 for j := 0; j < v99; j++ {
27463 this.Field15[i][j] = byte(r.Intn(256))
27464 }
27465 }
27466 }
27467 if !easy && r.Intn(10) != 0 {
27468 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
27469 }
27470 return this
27471 }
27472
27473 func NewPopulatedNinRepStruct(r randyThetest, easy bool) *NinRepStruct {
27474 this := &NinRepStruct{}
27475 if r.Intn(5) != 0 {
27476 v100 := r.Intn(10)
27477 this.Field1 = make([]float64, v100)
27478 for i := 0; i < v100; i++ {
27479 this.Field1[i] = float64(r.Float64())
27480 if r.Intn(2) == 0 {
27481 this.Field1[i] *= -1
27482 }
27483 }
27484 }
27485 if r.Intn(5) != 0 {
27486 v101 := r.Intn(10)
27487 this.Field2 = make([]float32, v101)
27488 for i := 0; i < v101; i++ {
27489 this.Field2[i] = float32(r.Float32())
27490 if r.Intn(2) == 0 {
27491 this.Field2[i] *= -1
27492 }
27493 }
27494 }
27495 if r.Intn(5) != 0 {
27496 v102 := r.Intn(5)
27497 this.Field3 = make([]*NidOptNative, v102)
27498 for i := 0; i < v102; i++ {
27499 this.Field3[i] = NewPopulatedNidOptNative(r, easy)
27500 }
27501 }
27502 if r.Intn(5) != 0 {
27503 v103 := r.Intn(5)
27504 this.Field4 = make([]*NinOptNative, v103)
27505 for i := 0; i < v103; i++ {
27506 this.Field4[i] = NewPopulatedNinOptNative(r, easy)
27507 }
27508 }
27509 if r.Intn(5) != 0 {
27510 v104 := r.Intn(10)
27511 this.Field6 = make([]uint64, v104)
27512 for i := 0; i < v104; i++ {
27513 this.Field6[i] = uint64(uint64(r.Uint32()))
27514 }
27515 }
27516 if r.Intn(5) != 0 {
27517 v105 := r.Intn(10)
27518 this.Field7 = make([]int32, v105)
27519 for i := 0; i < v105; i++ {
27520 this.Field7[i] = int32(r.Int31())
27521 if r.Intn(2) == 0 {
27522 this.Field7[i] *= -1
27523 }
27524 }
27525 }
27526 if r.Intn(5) != 0 {
27527 v106 := r.Intn(5)
27528 this.Field8 = make([]*NidOptNative, v106)
27529 for i := 0; i < v106; i++ {
27530 this.Field8[i] = NewPopulatedNidOptNative(r, easy)
27531 }
27532 }
27533 if r.Intn(5) != 0 {
27534 v107 := r.Intn(10)
27535 this.Field13 = make([]bool, v107)
27536 for i := 0; i < v107; i++ {
27537 this.Field13[i] = bool(bool(r.Intn(2) == 0))
27538 }
27539 }
27540 if r.Intn(5) != 0 {
27541 v108 := r.Intn(10)
27542 this.Field14 = make([]string, v108)
27543 for i := 0; i < v108; i++ {
27544 this.Field14[i] = string(randStringThetest(r))
27545 }
27546 }
27547 if r.Intn(5) != 0 {
27548 v109 := r.Intn(10)
27549 this.Field15 = make([][]byte, v109)
27550 for i := 0; i < v109; i++ {
27551 v110 := r.Intn(100)
27552 this.Field15[i] = make([]byte, v110)
27553 for j := 0; j < v110; j++ {
27554 this.Field15[i][j] = byte(r.Intn(256))
27555 }
27556 }
27557 }
27558 if !easy && r.Intn(10) != 0 {
27559 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
27560 }
27561 return this
27562 }
27563
27564 func NewPopulatedNidEmbeddedStruct(r randyThetest, easy bool) *NidEmbeddedStruct {
27565 this := &NidEmbeddedStruct{}
27566 if r.Intn(5) != 0 {
27567 this.NidOptNative = NewPopulatedNidOptNative(r, easy)
27568 }
27569 v111 := NewPopulatedNidOptNative(r, easy)
27570 this.Field200 = *v111
27571 this.Field210 = bool(bool(r.Intn(2) == 0))
27572 if !easy && r.Intn(10) != 0 {
27573 this.XXX_unrecognized = randUnrecognizedThetest(r, 211)
27574 }
27575 return this
27576 }
27577
27578 func NewPopulatedNinEmbeddedStruct(r randyThetest, easy bool) *NinEmbeddedStruct {
27579 this := &NinEmbeddedStruct{}
27580 if r.Intn(5) != 0 {
27581 this.NidOptNative = NewPopulatedNidOptNative(r, easy)
27582 }
27583 if r.Intn(5) != 0 {
27584 this.Field200 = NewPopulatedNidOptNative(r, easy)
27585 }
27586 if r.Intn(5) != 0 {
27587 v112 := bool(bool(r.Intn(2) == 0))
27588 this.Field210 = &v112
27589 }
27590 if !easy && r.Intn(10) != 0 {
27591 this.XXX_unrecognized = randUnrecognizedThetest(r, 211)
27592 }
27593 return this
27594 }
27595
27596 func NewPopulatedNidNestedStruct(r randyThetest, easy bool) *NidNestedStruct {
27597 this := &NidNestedStruct{}
27598 v113 := NewPopulatedNidOptStruct(r, easy)
27599 this.Field1 = *v113
27600 if r.Intn(5) != 0 {
27601 v114 := r.Intn(5)
27602 this.Field2 = make([]NidRepStruct, v114)
27603 for i := 0; i < v114; i++ {
27604 v115 := NewPopulatedNidRepStruct(r, easy)
27605 this.Field2[i] = *v115
27606 }
27607 }
27608 if !easy && r.Intn(10) != 0 {
27609 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27610 }
27611 return this
27612 }
27613
27614 func NewPopulatedNinNestedStruct(r randyThetest, easy bool) *NinNestedStruct {
27615 this := &NinNestedStruct{}
27616 if r.Intn(5) != 0 {
27617 this.Field1 = NewPopulatedNinOptStruct(r, easy)
27618 }
27619 if r.Intn(5) != 0 {
27620 v116 := r.Intn(5)
27621 this.Field2 = make([]*NinRepStruct, v116)
27622 for i := 0; i < v116; i++ {
27623 this.Field2[i] = NewPopulatedNinRepStruct(r, easy)
27624 }
27625 }
27626 if !easy && r.Intn(10) != 0 {
27627 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27628 }
27629 return this
27630 }
27631
27632 func NewPopulatedNidOptCustom(r randyThetest, easy bool) *NidOptCustom {
27633 this := &NidOptCustom{}
27634 v117 := NewPopulatedUuid(r)
27635 this.Id = *v117
27636 v118 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
27637 this.Value = *v118
27638 if !easy && r.Intn(10) != 0 {
27639 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27640 }
27641 return this
27642 }
27643
27644 func NewPopulatedCustomDash(r randyThetest, easy bool) *CustomDash {
27645 this := &CustomDash{}
27646 if r.Intn(5) != 0 {
27647 this.Value = github_com_gogo_protobuf_test_custom_dash_type.NewPopulatedBytes(r)
27648 }
27649 if !easy && r.Intn(10) != 0 {
27650 this.XXX_unrecognized = randUnrecognizedThetest(r, 2)
27651 }
27652 return this
27653 }
27654
27655 func NewPopulatedNinOptCustom(r randyThetest, easy bool) *NinOptCustom {
27656 this := &NinOptCustom{}
27657 if r.Intn(5) != 0 {
27658 this.Id = NewPopulatedUuid(r)
27659 }
27660 if r.Intn(5) != 0 {
27661 this.Value = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
27662 }
27663 if !easy && r.Intn(10) != 0 {
27664 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27665 }
27666 return this
27667 }
27668
27669 func NewPopulatedNidRepCustom(r randyThetest, easy bool) *NidRepCustom {
27670 this := &NidRepCustom{}
27671 if r.Intn(5) != 0 {
27672 v119 := r.Intn(10)
27673 this.Id = make([]Uuid, v119)
27674 for i := 0; i < v119; i++ {
27675 v120 := NewPopulatedUuid(r)
27676 this.Id[i] = *v120
27677 }
27678 }
27679 if r.Intn(5) != 0 {
27680 v121 := r.Intn(10)
27681 this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v121)
27682 for i := 0; i < v121; i++ {
27683 v122 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
27684 this.Value[i] = *v122
27685 }
27686 }
27687 if !easy && r.Intn(10) != 0 {
27688 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27689 }
27690 return this
27691 }
27692
27693 func NewPopulatedNinRepCustom(r randyThetest, easy bool) *NinRepCustom {
27694 this := &NinRepCustom{}
27695 if r.Intn(5) != 0 {
27696 v123 := r.Intn(10)
27697 this.Id = make([]Uuid, v123)
27698 for i := 0; i < v123; i++ {
27699 v124 := NewPopulatedUuid(r)
27700 this.Id[i] = *v124
27701 }
27702 }
27703 if r.Intn(5) != 0 {
27704 v125 := r.Intn(10)
27705 this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v125)
27706 for i := 0; i < v125; i++ {
27707 v126 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
27708 this.Value[i] = *v126
27709 }
27710 }
27711 if !easy && r.Intn(10) != 0 {
27712 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27713 }
27714 return this
27715 }
27716
27717 func NewPopulatedNinOptNativeUnion(r randyThetest, easy bool) *NinOptNativeUnion {
27718 this := &NinOptNativeUnion{}
27719 fieldNum := r.Intn(9)
27720 switch fieldNum {
27721 case 0:
27722 v127 := float64(r.Float64())
27723 if r.Intn(2) == 0 {
27724 v127 *= -1
27725 }
27726 this.Field1 = &v127
27727 case 1:
27728 v128 := float32(r.Float32())
27729 if r.Intn(2) == 0 {
27730 v128 *= -1
27731 }
27732 this.Field2 = &v128
27733 case 2:
27734 v129 := int32(r.Int31())
27735 if r.Intn(2) == 0 {
27736 v129 *= -1
27737 }
27738 this.Field3 = &v129
27739 case 3:
27740 v130 := int64(r.Int63())
27741 if r.Intn(2) == 0 {
27742 v130 *= -1
27743 }
27744 this.Field4 = &v130
27745 case 4:
27746 v131 := uint32(r.Uint32())
27747 this.Field5 = &v131
27748 case 5:
27749 v132 := uint64(uint64(r.Uint32()))
27750 this.Field6 = &v132
27751 case 6:
27752 v133 := bool(bool(r.Intn(2) == 0))
27753 this.Field13 = &v133
27754 case 7:
27755 v134 := string(randStringThetest(r))
27756 this.Field14 = &v134
27757 case 8:
27758 v135 := r.Intn(100)
27759 this.Field15 = make([]byte, v135)
27760 for i := 0; i < v135; i++ {
27761 this.Field15[i] = byte(r.Intn(256))
27762 }
27763 }
27764 return this
27765 }
27766
27767 func NewPopulatedNinOptStructUnion(r randyThetest, easy bool) *NinOptStructUnion {
27768 this := &NinOptStructUnion{}
27769 fieldNum := r.Intn(9)
27770 switch fieldNum {
27771 case 0:
27772 v136 := float64(r.Float64())
27773 if r.Intn(2) == 0 {
27774 v136 *= -1
27775 }
27776 this.Field1 = &v136
27777 case 1:
27778 v137 := float32(r.Float32())
27779 if r.Intn(2) == 0 {
27780 v137 *= -1
27781 }
27782 this.Field2 = &v137
27783 case 2:
27784 this.Field3 = NewPopulatedNidOptNative(r, easy)
27785 case 3:
27786 this.Field4 = NewPopulatedNinOptNative(r, easy)
27787 case 4:
27788 v138 := uint64(uint64(r.Uint32()))
27789 this.Field6 = &v138
27790 case 5:
27791 v139 := int32(r.Int31())
27792 if r.Intn(2) == 0 {
27793 v139 *= -1
27794 }
27795 this.Field7 = &v139
27796 case 6:
27797 v140 := bool(bool(r.Intn(2) == 0))
27798 this.Field13 = &v140
27799 case 7:
27800 v141 := string(randStringThetest(r))
27801 this.Field14 = &v141
27802 case 8:
27803 v142 := r.Intn(100)
27804 this.Field15 = make([]byte, v142)
27805 for i := 0; i < v142; i++ {
27806 this.Field15[i] = byte(r.Intn(256))
27807 }
27808 }
27809 return this
27810 }
27811
27812 func NewPopulatedNinEmbeddedStructUnion(r randyThetest, easy bool) *NinEmbeddedStructUnion {
27813 this := &NinEmbeddedStructUnion{}
27814 fieldNum := r.Intn(3)
27815 switch fieldNum {
27816 case 0:
27817 this.NidOptNative = NewPopulatedNidOptNative(r, easy)
27818 case 1:
27819 this.Field200 = NewPopulatedNinOptNative(r, easy)
27820 case 2:
27821 v143 := bool(bool(r.Intn(2) == 0))
27822 this.Field210 = &v143
27823 }
27824 return this
27825 }
27826
27827 func NewPopulatedNinNestedStructUnion(r randyThetest, easy bool) *NinNestedStructUnion {
27828 this := &NinNestedStructUnion{}
27829 fieldNum := r.Intn(3)
27830 switch fieldNum {
27831 case 0:
27832 this.Field1 = NewPopulatedNinOptNativeUnion(r, easy)
27833 case 1:
27834 this.Field2 = NewPopulatedNinOptStructUnion(r, easy)
27835 case 2:
27836 this.Field3 = NewPopulatedNinEmbeddedStructUnion(r, easy)
27837 }
27838 return this
27839 }
27840
27841 func NewPopulatedTree(r randyThetest, easy bool) *Tree {
27842 this := &Tree{}
27843 fieldNum := r.Intn(102)
27844 switch fieldNum {
27845 case 0:
27846 this.Or = NewPopulatedOrBranch(r, easy)
27847 case 1:
27848 this.And = NewPopulatedAndBranch(r, easy)
27849 case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101:
27850 this.Leaf = NewPopulatedLeaf(r, easy)
27851 }
27852 return this
27853 }
27854
27855 func NewPopulatedOrBranch(r randyThetest, easy bool) *OrBranch {
27856 this := &OrBranch{}
27857 v144 := NewPopulatedTree(r, easy)
27858 this.Left = *v144
27859 v145 := NewPopulatedTree(r, easy)
27860 this.Right = *v145
27861 if !easy && r.Intn(10) != 0 {
27862 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27863 }
27864 return this
27865 }
27866
27867 func NewPopulatedAndBranch(r randyThetest, easy bool) *AndBranch {
27868 this := &AndBranch{}
27869 v146 := NewPopulatedTree(r, easy)
27870 this.Left = *v146
27871 v147 := NewPopulatedTree(r, easy)
27872 this.Right = *v147
27873 if !easy && r.Intn(10) != 0 {
27874 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27875 }
27876 return this
27877 }
27878
27879 func NewPopulatedLeaf(r randyThetest, easy bool) *Leaf {
27880 this := &Leaf{}
27881 this.Value = int64(r.Int63())
27882 if r.Intn(2) == 0 {
27883 this.Value *= -1
27884 }
27885 this.StrValue = string(randStringThetest(r))
27886 if !easy && r.Intn(10) != 0 {
27887 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27888 }
27889 return this
27890 }
27891
27892 func NewPopulatedDeepTree(r randyThetest, easy bool) *DeepTree {
27893 this := &DeepTree{}
27894 fieldNum := r.Intn(102)
27895 switch fieldNum {
27896 case 0:
27897 this.Down = NewPopulatedADeepBranch(r, easy)
27898 case 1:
27899 this.And = NewPopulatedAndDeepBranch(r, easy)
27900 case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101:
27901 this.Leaf = NewPopulatedDeepLeaf(r, easy)
27902 }
27903 return this
27904 }
27905
27906 func NewPopulatedADeepBranch(r randyThetest, easy bool) *ADeepBranch {
27907 this := &ADeepBranch{}
27908 v148 := NewPopulatedDeepTree(r, easy)
27909 this.Down = *v148
27910 if !easy && r.Intn(10) != 0 {
27911 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27912 }
27913 return this
27914 }
27915
27916 func NewPopulatedAndDeepBranch(r randyThetest, easy bool) *AndDeepBranch {
27917 this := &AndDeepBranch{}
27918 v149 := NewPopulatedDeepTree(r, easy)
27919 this.Left = *v149
27920 v150 := NewPopulatedDeepTree(r, easy)
27921 this.Right = *v150
27922 if !easy && r.Intn(10) != 0 {
27923 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
27924 }
27925 return this
27926 }
27927
27928 func NewPopulatedDeepLeaf(r randyThetest, easy bool) *DeepLeaf {
27929 this := &DeepLeaf{}
27930 v151 := NewPopulatedTree(r, easy)
27931 this.Tree = *v151
27932 if !easy && r.Intn(10) != 0 {
27933 this.XXX_unrecognized = randUnrecognizedThetest(r, 2)
27934 }
27935 return this
27936 }
27937
27938 func NewPopulatedNil(r randyThetest, easy bool) *Nil {
27939 this := &Nil{}
27940 if !easy && r.Intn(10) != 0 {
27941 this.XXX_unrecognized = randUnrecognizedThetest(r, 1)
27942 }
27943 return this
27944 }
27945
27946 func NewPopulatedNidOptEnum(r randyThetest, easy bool) *NidOptEnum {
27947 this := &NidOptEnum{}
27948 this.Field1 = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)])
27949 if !easy && r.Intn(10) != 0 {
27950 this.XXX_unrecognized = randUnrecognizedThetest(r, 2)
27951 }
27952 return this
27953 }
27954
27955 func NewPopulatedNinOptEnum(r randyThetest, easy bool) *NinOptEnum {
27956 this := &NinOptEnum{}
27957 if r.Intn(5) != 0 {
27958 v152 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)])
27959 this.Field1 = &v152
27960 }
27961 if r.Intn(5) != 0 {
27962 v153 := YetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
27963 this.Field2 = &v153
27964 }
27965 if r.Intn(5) != 0 {
27966 v154 := YetYetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
27967 this.Field3 = &v154
27968 }
27969 if !easy && r.Intn(10) != 0 {
27970 this.XXX_unrecognized = randUnrecognizedThetest(r, 4)
27971 }
27972 return this
27973 }
27974
27975 func NewPopulatedNidRepEnum(r randyThetest, easy bool) *NidRepEnum {
27976 this := &NidRepEnum{}
27977 if r.Intn(5) != 0 {
27978 v155 := r.Intn(10)
27979 this.Field1 = make([]TheTestEnum, v155)
27980 for i := 0; i < v155; i++ {
27981 this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)])
27982 }
27983 }
27984 if r.Intn(5) != 0 {
27985 v156 := r.Intn(10)
27986 this.Field2 = make([]YetAnotherTestEnum, v156)
27987 for i := 0; i < v156; i++ {
27988 this.Field2[i] = YetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
27989 }
27990 }
27991 if r.Intn(5) != 0 {
27992 v157 := r.Intn(10)
27993 this.Field3 = make([]YetYetAnotherTestEnum, v157)
27994 for i := 0; i < v157; i++ {
27995 this.Field3[i] = YetYetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
27996 }
27997 }
27998 if !easy && r.Intn(10) != 0 {
27999 this.XXX_unrecognized = randUnrecognizedThetest(r, 4)
28000 }
28001 return this
28002 }
28003
28004 func NewPopulatedNinRepEnum(r randyThetest, easy bool) *NinRepEnum {
28005 this := &NinRepEnum{}
28006 if r.Intn(5) != 0 {
28007 v158 := r.Intn(10)
28008 this.Field1 = make([]TheTestEnum, v158)
28009 for i := 0; i < v158; i++ {
28010 this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)])
28011 }
28012 }
28013 if r.Intn(5) != 0 {
28014 v159 := r.Intn(10)
28015 this.Field2 = make([]YetAnotherTestEnum, v159)
28016 for i := 0; i < v159; i++ {
28017 this.Field2[i] = YetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
28018 }
28019 }
28020 if r.Intn(5) != 0 {
28021 v160 := r.Intn(10)
28022 this.Field3 = make([]YetYetAnotherTestEnum, v160)
28023 for i := 0; i < v160; i++ {
28024 this.Field3[i] = YetYetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
28025 }
28026 }
28027 if !easy && r.Intn(10) != 0 {
28028 this.XXX_unrecognized = randUnrecognizedThetest(r, 4)
28029 }
28030 return this
28031 }
28032
28033 func NewPopulatedNinOptEnumDefault(r randyThetest, easy bool) *NinOptEnumDefault {
28034 this := &NinOptEnumDefault{}
28035 if r.Intn(5) != 0 {
28036 v161 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)])
28037 this.Field1 = &v161
28038 }
28039 if r.Intn(5) != 0 {
28040 v162 := YetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
28041 this.Field2 = &v162
28042 }
28043 if r.Intn(5) != 0 {
28044 v163 := YetYetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
28045 this.Field3 = &v163
28046 }
28047 if !easy && r.Intn(10) != 0 {
28048 this.XXX_unrecognized = randUnrecognizedThetest(r, 4)
28049 }
28050 return this
28051 }
28052
28053 func NewPopulatedAnotherNinOptEnum(r randyThetest, easy bool) *AnotherNinOptEnum {
28054 this := &AnotherNinOptEnum{}
28055 if r.Intn(5) != 0 {
28056 v164 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)])
28057 this.Field1 = &v164
28058 }
28059 if r.Intn(5) != 0 {
28060 v165 := YetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
28061 this.Field2 = &v165
28062 }
28063 if r.Intn(5) != 0 {
28064 v166 := YetYetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
28065 this.Field3 = &v166
28066 }
28067 if !easy && r.Intn(10) != 0 {
28068 this.XXX_unrecognized = randUnrecognizedThetest(r, 4)
28069 }
28070 return this
28071 }
28072
28073 func NewPopulatedAnotherNinOptEnumDefault(r randyThetest, easy bool) *AnotherNinOptEnumDefault {
28074 this := &AnotherNinOptEnumDefault{}
28075 if r.Intn(5) != 0 {
28076 v167 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)])
28077 this.Field1 = &v167
28078 }
28079 if r.Intn(5) != 0 {
28080 v168 := YetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
28081 this.Field2 = &v168
28082 }
28083 if r.Intn(5) != 0 {
28084 v169 := YetYetAnotherTestEnum([]int32{0, 1}[r.Intn(2)])
28085 this.Field3 = &v169
28086 }
28087 if !easy && r.Intn(10) != 0 {
28088 this.XXX_unrecognized = randUnrecognizedThetest(r, 4)
28089 }
28090 return this
28091 }
28092
28093 func NewPopulatedTimer(r randyThetest, easy bool) *Timer {
28094 this := &Timer{}
28095 this.Time1 = int64(r.Int63())
28096 if r.Intn(2) == 0 {
28097 this.Time1 *= -1
28098 }
28099 this.Time2 = int64(r.Int63())
28100 if r.Intn(2) == 0 {
28101 this.Time2 *= -1
28102 }
28103 v170 := r.Intn(100)
28104 this.Data = make([]byte, v170)
28105 for i := 0; i < v170; i++ {
28106 this.Data[i] = byte(r.Intn(256))
28107 }
28108 if !easy && r.Intn(10) != 0 {
28109 this.XXX_unrecognized = randUnrecognizedThetest(r, 4)
28110 }
28111 return this
28112 }
28113
28114 func NewPopulatedMyExtendable(r randyThetest, easy bool) *MyExtendable {
28115 this := &MyExtendable{}
28116 if r.Intn(5) != 0 {
28117 v171 := int64(r.Int63())
28118 if r.Intn(2) == 0 {
28119 v171 *= -1
28120 }
28121 this.Field1 = &v171
28122 }
28123 if !easy && r.Intn(10) != 0 {
28124 l := r.Intn(5)
28125 for i := 0; i < l; i++ {
28126 fieldNumber := r.Intn(100) + 100
28127 wire := r.Intn(4)
28128 if wire == 3 {
28129 wire = 5
28130 }
28131 dAtA := randFieldThetest(nil, r, fieldNumber, wire)
28132 github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), dAtA)
28133 }
28134 }
28135 if !easy && r.Intn(10) != 0 {
28136 this.XXX_unrecognized = randUnrecognizedThetest(r, 201)
28137 }
28138 return this
28139 }
28140
28141 func NewPopulatedOtherExtenable(r randyThetest, easy bool) *OtherExtenable {
28142 this := &OtherExtenable{}
28143 if r.Intn(5) != 0 {
28144 this.M = NewPopulatedMyExtendable(r, easy)
28145 }
28146 if r.Intn(5) != 0 {
28147 v172 := int64(r.Int63())
28148 if r.Intn(2) == 0 {
28149 v172 *= -1
28150 }
28151 this.Field2 = &v172
28152 }
28153 if r.Intn(5) != 0 {
28154 v173 := int64(r.Int63())
28155 if r.Intn(2) == 0 {
28156 v173 *= -1
28157 }
28158 this.Field13 = &v173
28159 }
28160 if !easy && r.Intn(10) != 0 {
28161 l := r.Intn(5)
28162 for i := 0; i < l; i++ {
28163 eIndex := r.Intn(2)
28164 fieldNumber := 0
28165 switch eIndex {
28166 case 0:
28167 fieldNumber = r.Intn(3) + 14
28168 case 1:
28169 fieldNumber = r.Intn(3) + 10
28170 }
28171 wire := r.Intn(4)
28172 if wire == 3 {
28173 wire = 5
28174 }
28175 dAtA := randFieldThetest(nil, r, fieldNumber, wire)
28176 github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), dAtA)
28177 }
28178 }
28179 if !easy && r.Intn(10) != 0 {
28180 this.XXX_unrecognized = randUnrecognizedThetest(r, 18)
28181 }
28182 return this
28183 }
28184
28185 func NewPopulatedNestedDefinition(r randyThetest, easy bool) *NestedDefinition {
28186 this := &NestedDefinition{}
28187 if r.Intn(5) != 0 {
28188 v174 := int64(r.Int63())
28189 if r.Intn(2) == 0 {
28190 v174 *= -1
28191 }
28192 this.Field1 = &v174
28193 }
28194 if r.Intn(5) != 0 {
28195 v175 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)])
28196 this.EnumField = &v175
28197 }
28198 if r.Intn(5) != 0 {
28199 this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy)
28200 }
28201 if r.Intn(5) != 0 {
28202 this.NM = NewPopulatedNestedDefinition_NestedMessage(r, easy)
28203 }
28204 if !easy && r.Intn(10) != 0 {
28205 this.XXX_unrecognized = randUnrecognizedThetest(r, 5)
28206 }
28207 return this
28208 }
28209
28210 func NewPopulatedNestedDefinition_NestedMessage(r randyThetest, easy bool) *NestedDefinition_NestedMessage {
28211 this := &NestedDefinition_NestedMessage{}
28212 if r.Intn(5) != 0 {
28213 v176 := uint64(uint64(r.Uint32()))
28214 this.NestedField1 = &v176
28215 }
28216 if r.Intn(5) != 0 {
28217 this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy)
28218 }
28219 if !easy && r.Intn(10) != 0 {
28220 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
28221 }
28222 return this
28223 }
28224
28225 func NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r randyThetest, easy bool) *NestedDefinition_NestedMessage_NestedNestedMsg {
28226 this := &NestedDefinition_NestedMessage_NestedNestedMsg{}
28227 if r.Intn(5) != 0 {
28228 v177 := string(randStringThetest(r))
28229 this.NestedNestedField1 = &v177
28230 }
28231 if !easy && r.Intn(10) != 0 {
28232 this.XXX_unrecognized = randUnrecognizedThetest(r, 11)
28233 }
28234 return this
28235 }
28236
28237 func NewPopulatedNestedScope(r randyThetest, easy bool) *NestedScope {
28238 this := &NestedScope{}
28239 if r.Intn(5) != 0 {
28240 this.A = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy)
28241 }
28242 if r.Intn(5) != 0 {
28243 v178 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)])
28244 this.B = &v178
28245 }
28246 if r.Intn(5) != 0 {
28247 this.C = NewPopulatedNestedDefinition_NestedMessage(r, easy)
28248 }
28249 if !easy && r.Intn(10) != 0 {
28250 this.XXX_unrecognized = randUnrecognizedThetest(r, 4)
28251 }
28252 return this
28253 }
28254
28255 func NewPopulatedNinOptNativeDefault(r randyThetest, easy bool) *NinOptNativeDefault {
28256 this := &NinOptNativeDefault{}
28257 if r.Intn(5) != 0 {
28258 v179 := float64(r.Float64())
28259 if r.Intn(2) == 0 {
28260 v179 *= -1
28261 }
28262 this.Field1 = &v179
28263 }
28264 if r.Intn(5) != 0 {
28265 v180 := float32(r.Float32())
28266 if r.Intn(2) == 0 {
28267 v180 *= -1
28268 }
28269 this.Field2 = &v180
28270 }
28271 if r.Intn(5) != 0 {
28272 v181 := int32(r.Int31())
28273 if r.Intn(2) == 0 {
28274 v181 *= -1
28275 }
28276 this.Field3 = &v181
28277 }
28278 if r.Intn(5) != 0 {
28279 v182 := int64(r.Int63())
28280 if r.Intn(2) == 0 {
28281 v182 *= -1
28282 }
28283 this.Field4 = &v182
28284 }
28285 if r.Intn(5) != 0 {
28286 v183 := uint32(r.Uint32())
28287 this.Field5 = &v183
28288 }
28289 if r.Intn(5) != 0 {
28290 v184 := uint64(uint64(r.Uint32()))
28291 this.Field6 = &v184
28292 }
28293 if r.Intn(5) != 0 {
28294 v185 := int32(r.Int31())
28295 if r.Intn(2) == 0 {
28296 v185 *= -1
28297 }
28298 this.Field7 = &v185
28299 }
28300 if r.Intn(5) != 0 {
28301 v186 := int64(r.Int63())
28302 if r.Intn(2) == 0 {
28303 v186 *= -1
28304 }
28305 this.Field8 = &v186
28306 }
28307 if r.Intn(5) != 0 {
28308 v187 := uint32(r.Uint32())
28309 this.Field9 = &v187
28310 }
28311 if r.Intn(5) != 0 {
28312 v188 := int32(r.Int31())
28313 if r.Intn(2) == 0 {
28314 v188 *= -1
28315 }
28316 this.Field10 = &v188
28317 }
28318 if r.Intn(5) != 0 {
28319 v189 := uint64(uint64(r.Uint32()))
28320 this.Field11 = &v189
28321 }
28322 if r.Intn(5) != 0 {
28323 v190 := int64(r.Int63())
28324 if r.Intn(2) == 0 {
28325 v190 *= -1
28326 }
28327 this.Field12 = &v190
28328 }
28329 if r.Intn(5) != 0 {
28330 v191 := bool(bool(r.Intn(2) == 0))
28331 this.Field13 = &v191
28332 }
28333 if r.Intn(5) != 0 {
28334 v192 := string(randStringThetest(r))
28335 this.Field14 = &v192
28336 }
28337 if r.Intn(5) != 0 {
28338 v193 := r.Intn(100)
28339 this.Field15 = make([]byte, v193)
28340 for i := 0; i < v193; i++ {
28341 this.Field15[i] = byte(r.Intn(256))
28342 }
28343 }
28344 if !easy && r.Intn(10) != 0 {
28345 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
28346 }
28347 return this
28348 }
28349
28350 func NewPopulatedCustomContainer(r randyThetest, easy bool) *CustomContainer {
28351 this := &CustomContainer{}
28352 v194 := NewPopulatedNidOptCustom(r, easy)
28353 this.CustomStruct = *v194
28354 if !easy && r.Intn(10) != 0 {
28355 this.XXX_unrecognized = randUnrecognizedThetest(r, 2)
28356 }
28357 return this
28358 }
28359
28360 func NewPopulatedCustomNameNidOptNative(r randyThetest, easy bool) *CustomNameNidOptNative {
28361 this := &CustomNameNidOptNative{}
28362 this.FieldA = float64(r.Float64())
28363 if r.Intn(2) == 0 {
28364 this.FieldA *= -1
28365 }
28366 this.FieldB = float32(r.Float32())
28367 if r.Intn(2) == 0 {
28368 this.FieldB *= -1
28369 }
28370 this.FieldC = int32(r.Int31())
28371 if r.Intn(2) == 0 {
28372 this.FieldC *= -1
28373 }
28374 this.FieldD = int64(r.Int63())
28375 if r.Intn(2) == 0 {
28376 this.FieldD *= -1
28377 }
28378 this.FieldE = uint32(r.Uint32())
28379 this.FieldF = uint64(uint64(r.Uint32()))
28380 this.FieldG = int32(r.Int31())
28381 if r.Intn(2) == 0 {
28382 this.FieldG *= -1
28383 }
28384 this.FieldH = int64(r.Int63())
28385 if r.Intn(2) == 0 {
28386 this.FieldH *= -1
28387 }
28388 this.FieldI = uint32(r.Uint32())
28389 this.FieldJ = int32(r.Int31())
28390 if r.Intn(2) == 0 {
28391 this.FieldJ *= -1
28392 }
28393 this.FieldK = uint64(uint64(r.Uint32()))
28394 this.FieldL = int64(r.Int63())
28395 if r.Intn(2) == 0 {
28396 this.FieldL *= -1
28397 }
28398 this.FieldM = bool(bool(r.Intn(2) == 0))
28399 this.FieldN = string(randStringThetest(r))
28400 v195 := r.Intn(100)
28401 this.FieldO = make([]byte, v195)
28402 for i := 0; i < v195; i++ {
28403 this.FieldO[i] = byte(r.Intn(256))
28404 }
28405 if !easy && r.Intn(10) != 0 {
28406 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
28407 }
28408 return this
28409 }
28410
28411 func NewPopulatedCustomNameNinOptNative(r randyThetest, easy bool) *CustomNameNinOptNative {
28412 this := &CustomNameNinOptNative{}
28413 if r.Intn(5) != 0 {
28414 v196 := float64(r.Float64())
28415 if r.Intn(2) == 0 {
28416 v196 *= -1
28417 }
28418 this.FieldA = &v196
28419 }
28420 if r.Intn(5) != 0 {
28421 v197 := float32(r.Float32())
28422 if r.Intn(2) == 0 {
28423 v197 *= -1
28424 }
28425 this.FieldB = &v197
28426 }
28427 if r.Intn(5) != 0 {
28428 v198 := int32(r.Int31())
28429 if r.Intn(2) == 0 {
28430 v198 *= -1
28431 }
28432 this.FieldC = &v198
28433 }
28434 if r.Intn(5) != 0 {
28435 v199 := int64(r.Int63())
28436 if r.Intn(2) == 0 {
28437 v199 *= -1
28438 }
28439 this.FieldD = &v199
28440 }
28441 if r.Intn(5) != 0 {
28442 v200 := uint32(r.Uint32())
28443 this.FieldE = &v200
28444 }
28445 if r.Intn(5) != 0 {
28446 v201 := uint64(uint64(r.Uint32()))
28447 this.FieldF = &v201
28448 }
28449 if r.Intn(5) != 0 {
28450 v202 := int32(r.Int31())
28451 if r.Intn(2) == 0 {
28452 v202 *= -1
28453 }
28454 this.FieldG = &v202
28455 }
28456 if r.Intn(5) != 0 {
28457 v203 := int64(r.Int63())
28458 if r.Intn(2) == 0 {
28459 v203 *= -1
28460 }
28461 this.FieldH = &v203
28462 }
28463 if r.Intn(5) != 0 {
28464 v204 := uint32(r.Uint32())
28465 this.FieldI = &v204
28466 }
28467 if r.Intn(5) != 0 {
28468 v205 := int32(r.Int31())
28469 if r.Intn(2) == 0 {
28470 v205 *= -1
28471 }
28472 this.FieldJ = &v205
28473 }
28474 if r.Intn(5) != 0 {
28475 v206 := uint64(uint64(r.Uint32()))
28476 this.FieldK = &v206
28477 }
28478 if r.Intn(5) != 0 {
28479 v207 := int64(r.Int63())
28480 if r.Intn(2) == 0 {
28481 v207 *= -1
28482 }
28483 this.FielL = &v207
28484 }
28485 if r.Intn(5) != 0 {
28486 v208 := bool(bool(r.Intn(2) == 0))
28487 this.FieldM = &v208
28488 }
28489 if r.Intn(5) != 0 {
28490 v209 := string(randStringThetest(r))
28491 this.FieldN = &v209
28492 }
28493 if r.Intn(5) != 0 {
28494 v210 := r.Intn(100)
28495 this.FieldO = make([]byte, v210)
28496 for i := 0; i < v210; i++ {
28497 this.FieldO[i] = byte(r.Intn(256))
28498 }
28499 }
28500 if !easy && r.Intn(10) != 0 {
28501 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
28502 }
28503 return this
28504 }
28505
28506 func NewPopulatedCustomNameNinRepNative(r randyThetest, easy bool) *CustomNameNinRepNative {
28507 this := &CustomNameNinRepNative{}
28508 if r.Intn(5) != 0 {
28509 v211 := r.Intn(10)
28510 this.FieldA = make([]float64, v211)
28511 for i := 0; i < v211; i++ {
28512 this.FieldA[i] = float64(r.Float64())
28513 if r.Intn(2) == 0 {
28514 this.FieldA[i] *= -1
28515 }
28516 }
28517 }
28518 if r.Intn(5) != 0 {
28519 v212 := r.Intn(10)
28520 this.FieldB = make([]float32, v212)
28521 for i := 0; i < v212; i++ {
28522 this.FieldB[i] = float32(r.Float32())
28523 if r.Intn(2) == 0 {
28524 this.FieldB[i] *= -1
28525 }
28526 }
28527 }
28528 if r.Intn(5) != 0 {
28529 v213 := r.Intn(10)
28530 this.FieldC = make([]int32, v213)
28531 for i := 0; i < v213; i++ {
28532 this.FieldC[i] = int32(r.Int31())
28533 if r.Intn(2) == 0 {
28534 this.FieldC[i] *= -1
28535 }
28536 }
28537 }
28538 if r.Intn(5) != 0 {
28539 v214 := r.Intn(10)
28540 this.FieldD = make([]int64, v214)
28541 for i := 0; i < v214; i++ {
28542 this.FieldD[i] = int64(r.Int63())
28543 if r.Intn(2) == 0 {
28544 this.FieldD[i] *= -1
28545 }
28546 }
28547 }
28548 if r.Intn(5) != 0 {
28549 v215 := r.Intn(10)
28550 this.FieldE = make([]uint32, v215)
28551 for i := 0; i < v215; i++ {
28552 this.FieldE[i] = uint32(r.Uint32())
28553 }
28554 }
28555 if r.Intn(5) != 0 {
28556 v216 := r.Intn(10)
28557 this.FieldF = make([]uint64, v216)
28558 for i := 0; i < v216; i++ {
28559 this.FieldF[i] = uint64(uint64(r.Uint32()))
28560 }
28561 }
28562 if r.Intn(5) != 0 {
28563 v217 := r.Intn(10)
28564 this.FieldG = make([]int32, v217)
28565 for i := 0; i < v217; i++ {
28566 this.FieldG[i] = int32(r.Int31())
28567 if r.Intn(2) == 0 {
28568 this.FieldG[i] *= -1
28569 }
28570 }
28571 }
28572 if r.Intn(5) != 0 {
28573 v218 := r.Intn(10)
28574 this.FieldH = make([]int64, v218)
28575 for i := 0; i < v218; i++ {
28576 this.FieldH[i] = int64(r.Int63())
28577 if r.Intn(2) == 0 {
28578 this.FieldH[i] *= -1
28579 }
28580 }
28581 }
28582 if r.Intn(5) != 0 {
28583 v219 := r.Intn(10)
28584 this.FieldI = make([]uint32, v219)
28585 for i := 0; i < v219; i++ {
28586 this.FieldI[i] = uint32(r.Uint32())
28587 }
28588 }
28589 if r.Intn(5) != 0 {
28590 v220 := r.Intn(10)
28591 this.FieldJ = make([]int32, v220)
28592 for i := 0; i < v220; i++ {
28593 this.FieldJ[i] = int32(r.Int31())
28594 if r.Intn(2) == 0 {
28595 this.FieldJ[i] *= -1
28596 }
28597 }
28598 }
28599 if r.Intn(5) != 0 {
28600 v221 := r.Intn(10)
28601 this.FieldK = make([]uint64, v221)
28602 for i := 0; i < v221; i++ {
28603 this.FieldK[i] = uint64(uint64(r.Uint32()))
28604 }
28605 }
28606 if r.Intn(5) != 0 {
28607 v222 := r.Intn(10)
28608 this.FieldL = make([]int64, v222)
28609 for i := 0; i < v222; i++ {
28610 this.FieldL[i] = int64(r.Int63())
28611 if r.Intn(2) == 0 {
28612 this.FieldL[i] *= -1
28613 }
28614 }
28615 }
28616 if r.Intn(5) != 0 {
28617 v223 := r.Intn(10)
28618 this.FieldM = make([]bool, v223)
28619 for i := 0; i < v223; i++ {
28620 this.FieldM[i] = bool(bool(r.Intn(2) == 0))
28621 }
28622 }
28623 if r.Intn(5) != 0 {
28624 v224 := r.Intn(10)
28625 this.FieldN = make([]string, v224)
28626 for i := 0; i < v224; i++ {
28627 this.FieldN[i] = string(randStringThetest(r))
28628 }
28629 }
28630 if r.Intn(5) != 0 {
28631 v225 := r.Intn(10)
28632 this.FieldO = make([][]byte, v225)
28633 for i := 0; i < v225; i++ {
28634 v226 := r.Intn(100)
28635 this.FieldO[i] = make([]byte, v226)
28636 for j := 0; j < v226; j++ {
28637 this.FieldO[i][j] = byte(r.Intn(256))
28638 }
28639 }
28640 }
28641 if !easy && r.Intn(10) != 0 {
28642 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
28643 }
28644 return this
28645 }
28646
28647 func NewPopulatedCustomNameNinStruct(r randyThetest, easy bool) *CustomNameNinStruct {
28648 this := &CustomNameNinStruct{}
28649 if r.Intn(5) != 0 {
28650 v227 := float64(r.Float64())
28651 if r.Intn(2) == 0 {
28652 v227 *= -1
28653 }
28654 this.FieldA = &v227
28655 }
28656 if r.Intn(5) != 0 {
28657 v228 := float32(r.Float32())
28658 if r.Intn(2) == 0 {
28659 v228 *= -1
28660 }
28661 this.FieldB = &v228
28662 }
28663 if r.Intn(5) != 0 {
28664 this.FieldC = NewPopulatedNidOptNative(r, easy)
28665 }
28666 if r.Intn(5) != 0 {
28667 v229 := r.Intn(5)
28668 this.FieldD = make([]*NinOptNative, v229)
28669 for i := 0; i < v229; i++ {
28670 this.FieldD[i] = NewPopulatedNinOptNative(r, easy)
28671 }
28672 }
28673 if r.Intn(5) != 0 {
28674 v230 := uint64(uint64(r.Uint32()))
28675 this.FieldE = &v230
28676 }
28677 if r.Intn(5) != 0 {
28678 v231 := int32(r.Int31())
28679 if r.Intn(2) == 0 {
28680 v231 *= -1
28681 }
28682 this.FieldF = &v231
28683 }
28684 if r.Intn(5) != 0 {
28685 this.FieldG = NewPopulatedNidOptNative(r, easy)
28686 }
28687 if r.Intn(5) != 0 {
28688 v232 := bool(bool(r.Intn(2) == 0))
28689 this.FieldH = &v232
28690 }
28691 if r.Intn(5) != 0 {
28692 v233 := string(randStringThetest(r))
28693 this.FieldI = &v233
28694 }
28695 if r.Intn(5) != 0 {
28696 v234 := r.Intn(100)
28697 this.FieldJ = make([]byte, v234)
28698 for i := 0; i < v234; i++ {
28699 this.FieldJ[i] = byte(r.Intn(256))
28700 }
28701 }
28702 if !easy && r.Intn(10) != 0 {
28703 this.XXX_unrecognized = randUnrecognizedThetest(r, 16)
28704 }
28705 return this
28706 }
28707
28708 func NewPopulatedCustomNameCustomType(r randyThetest, easy bool) *CustomNameCustomType {
28709 this := &CustomNameCustomType{}
28710 if r.Intn(5) != 0 {
28711 this.FieldA = NewPopulatedUuid(r)
28712 }
28713 if r.Intn(5) != 0 {
28714 this.FieldB = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
28715 }
28716 if r.Intn(5) != 0 {
28717 v235 := r.Intn(10)
28718 this.FieldC = make([]Uuid, v235)
28719 for i := 0; i < v235; i++ {
28720 v236 := NewPopulatedUuid(r)
28721 this.FieldC[i] = *v236
28722 }
28723 }
28724 if r.Intn(5) != 0 {
28725 v237 := r.Intn(10)
28726 this.FieldD = make([]github_com_gogo_protobuf_test_custom.Uint128, v237)
28727 for i := 0; i < v237; i++ {
28728 v238 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
28729 this.FieldD[i] = *v238
28730 }
28731 }
28732 if !easy && r.Intn(10) != 0 {
28733 this.XXX_unrecognized = randUnrecognizedThetest(r, 5)
28734 }
28735 return this
28736 }
28737
28738 func NewPopulatedCustomNameNinEmbeddedStructUnion(r randyThetest, easy bool) *CustomNameNinEmbeddedStructUnion {
28739 this := &CustomNameNinEmbeddedStructUnion{}
28740 fieldNum := r.Intn(3)
28741 switch fieldNum {
28742 case 0:
28743 this.NidOptNative = NewPopulatedNidOptNative(r, easy)
28744 case 1:
28745 this.FieldA = NewPopulatedNinOptNative(r, easy)
28746 case 2:
28747 v239 := bool(bool(r.Intn(2) == 0))
28748 this.FieldB = &v239
28749 }
28750 return this
28751 }
28752
28753 func NewPopulatedCustomNameEnum(r randyThetest, easy bool) *CustomNameEnum {
28754 this := &CustomNameEnum{}
28755 if r.Intn(5) != 0 {
28756 v240 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)])
28757 this.FieldA = &v240
28758 }
28759 if r.Intn(5) != 0 {
28760 v241 := r.Intn(10)
28761 this.FieldB = make([]TheTestEnum, v241)
28762 for i := 0; i < v241; i++ {
28763 this.FieldB[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)])
28764 }
28765 }
28766 if !easy && r.Intn(10) != 0 {
28767 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
28768 }
28769 return this
28770 }
28771
28772 func NewPopulatedNoExtensionsMap(r randyThetest, easy bool) *NoExtensionsMap {
28773 this := &NoExtensionsMap{}
28774 if r.Intn(5) != 0 {
28775 v242 := int64(r.Int63())
28776 if r.Intn(2) == 0 {
28777 v242 *= -1
28778 }
28779 this.Field1 = &v242
28780 }
28781 if !easy && r.Intn(10) != 0 {
28782 l := r.Intn(5)
28783 for i := 0; i < l; i++ {
28784 fieldNumber := r.Intn(100) + 100
28785 wire := r.Intn(4)
28786 if wire == 3 {
28787 wire = 5
28788 }
28789 dAtA := randFieldThetest(nil, r, fieldNumber, wire)
28790 github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), dAtA)
28791 }
28792 }
28793 if !easy && r.Intn(10) != 0 {
28794 this.XXX_unrecognized = randUnrecognizedThetest(r, 201)
28795 }
28796 return this
28797 }
28798
28799 func NewPopulatedUnrecognized(r randyThetest, easy bool) *Unrecognized {
28800 this := &Unrecognized{}
28801 if r.Intn(5) != 0 {
28802 v243 := string(randStringThetest(r))
28803 this.Field1 = &v243
28804 }
28805 if !easy && r.Intn(10) != 0 {
28806 }
28807 return this
28808 }
28809
28810 func NewPopulatedUnrecognizedWithInner(r randyThetest, easy bool) *UnrecognizedWithInner {
28811 this := &UnrecognizedWithInner{}
28812 if r.Intn(5) != 0 {
28813 v244 := r.Intn(5)
28814 this.Embedded = make([]*UnrecognizedWithInner_Inner, v244)
28815 for i := 0; i < v244; i++ {
28816 this.Embedded[i] = NewPopulatedUnrecognizedWithInner_Inner(r, easy)
28817 }
28818 }
28819 if r.Intn(5) != 0 {
28820 v245 := string(randStringThetest(r))
28821 this.Field2 = &v245
28822 }
28823 if !easy && r.Intn(10) != 0 {
28824 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
28825 }
28826 return this
28827 }
28828
28829 func NewPopulatedUnrecognizedWithInner_Inner(r randyThetest, easy bool) *UnrecognizedWithInner_Inner {
28830 this := &UnrecognizedWithInner_Inner{}
28831 if r.Intn(5) != 0 {
28832 v246 := uint32(r.Uint32())
28833 this.Field1 = &v246
28834 }
28835 if !easy && r.Intn(10) != 0 {
28836 }
28837 return this
28838 }
28839
28840 func NewPopulatedUnrecognizedWithEmbed(r randyThetest, easy bool) *UnrecognizedWithEmbed {
28841 this := &UnrecognizedWithEmbed{}
28842 v247 := NewPopulatedUnrecognizedWithEmbed_Embedded(r, easy)
28843 this.UnrecognizedWithEmbed_Embedded = *v247
28844 if r.Intn(5) != 0 {
28845 v248 := string(randStringThetest(r))
28846 this.Field2 = &v248
28847 }
28848 if !easy && r.Intn(10) != 0 {
28849 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
28850 }
28851 return this
28852 }
28853
28854 func NewPopulatedUnrecognizedWithEmbed_Embedded(r randyThetest, easy bool) *UnrecognizedWithEmbed_Embedded {
28855 this := &UnrecognizedWithEmbed_Embedded{}
28856 if r.Intn(5) != 0 {
28857 v249 := uint32(r.Uint32())
28858 this.Field1 = &v249
28859 }
28860 if !easy && r.Intn(10) != 0 {
28861 }
28862 return this
28863 }
28864
28865 func NewPopulatedNode(r randyThetest, easy bool) *Node {
28866 this := &Node{}
28867 if r.Intn(5) != 0 {
28868 v250 := string(randStringThetest(r))
28869 this.Label = &v250
28870 }
28871 if r.Intn(5) == 0 {
28872 v251 := r.Intn(5)
28873 this.Children = make([]*Node, v251)
28874 for i := 0; i < v251; i++ {
28875 this.Children[i] = NewPopulatedNode(r, easy)
28876 }
28877 }
28878 if !easy && r.Intn(10) != 0 {
28879 this.XXX_unrecognized = randUnrecognizedThetest(r, 3)
28880 }
28881 return this
28882 }
28883
28884 func NewPopulatedNonByteCustomType(r randyThetest, easy bool) *NonByteCustomType {
28885 this := &NonByteCustomType{}
28886 if r.Intn(5) != 0 {
28887 this.Field1 = NewPopulatedT(r)
28888 }
28889 if !easy && r.Intn(10) != 0 {
28890 this.XXX_unrecognized = randUnrecognizedThetest(r, 2)
28891 }
28892 return this
28893 }
28894
28895 func NewPopulatedNidOptNonByteCustomType(r randyThetest, easy bool) *NidOptNonByteCustomType {
28896 this := &NidOptNonByteCustomType{}
28897 v252 := NewPopulatedT(r)
28898 this.Field1 = *v252
28899 if !easy && r.Intn(10) != 0 {
28900 this.XXX_unrecognized = randUnrecognizedThetest(r, 2)
28901 }
28902 return this
28903 }
28904
28905 func NewPopulatedNinOptNonByteCustomType(r randyThetest, easy bool) *NinOptNonByteCustomType {
28906 this := &NinOptNonByteCustomType{}
28907 if r.Intn(5) != 0 {
28908 this.Field1 = NewPopulatedT(r)
28909 }
28910 if !easy && r.Intn(10) != 0 {
28911 this.XXX_unrecognized = randUnrecognizedThetest(r, 2)
28912 }
28913 return this
28914 }
28915
28916 func NewPopulatedNidRepNonByteCustomType(r randyThetest, easy bool) *NidRepNonByteCustomType {
28917 this := &NidRepNonByteCustomType{}
28918 if r.Intn(5) != 0 {
28919 v253 := r.Intn(10)
28920 this.Field1 = make([]T, v253)
28921 for i := 0; i < v253; i++ {
28922 v254 := NewPopulatedT(r)
28923 this.Field1[i] = *v254
28924 }
28925 }
28926 if !easy && r.Intn(10) != 0 {
28927 this.XXX_unrecognized = randUnrecognizedThetest(r, 2)
28928 }
28929 return this
28930 }
28931
28932 func NewPopulatedNinRepNonByteCustomType(r randyThetest, easy bool) *NinRepNonByteCustomType {
28933 this := &NinRepNonByteCustomType{}
28934 if r.Intn(5) != 0 {
28935 v255 := r.Intn(10)
28936 this.Field1 = make([]T, v255)
28937 for i := 0; i < v255; i++ {
28938 v256 := NewPopulatedT(r)
28939 this.Field1[i] = *v256
28940 }
28941 }
28942 if !easy && r.Intn(10) != 0 {
28943 this.XXX_unrecognized = randUnrecognizedThetest(r, 2)
28944 }
28945 return this
28946 }
28947
28948 func NewPopulatedProtoType(r randyThetest, easy bool) *ProtoType {
28949 this := &ProtoType{}
28950 if r.Intn(5) != 0 {
28951 v257 := string(randStringThetest(r))
28952 this.Field2 = &v257
28953 }
28954 if !easy && r.Intn(10) != 0 {
28955 this.XXX_unrecognized = randUnrecognizedThetest(r, 2)
28956 }
28957 return this
28958 }
28959
28960 type randyThetest interface {
28961 Float32() float32
28962 Float64() float64
28963 Int63() int64
28964 Int31() int32
28965 Uint32() uint32
28966 Intn(n int) int
28967 }
28968
28969 func randUTF8RuneThetest(r randyThetest) rune {
28970 ru := r.Intn(62)
28971 if ru < 10 {
28972 return rune(ru + 48)
28973 } else if ru < 36 {
28974 return rune(ru + 55)
28975 }
28976 return rune(ru + 61)
28977 }
28978 func randStringThetest(r randyThetest) string {
28979 v258 := r.Intn(100)
28980 tmps := make([]rune, v258)
28981 for i := 0; i < v258; i++ {
28982 tmps[i] = randUTF8RuneThetest(r)
28983 }
28984 return string(tmps)
28985 }
28986 func randUnrecognizedThetest(r randyThetest, maxFieldNumber int) (dAtA []byte) {
28987 l := r.Intn(5)
28988 for i := 0; i < l; i++ {
28989 wire := r.Intn(4)
28990 if wire == 3 {
28991 wire = 5
28992 }
28993 fieldNumber := maxFieldNumber + r.Intn(100)
28994 dAtA = randFieldThetest(dAtA, r, fieldNumber, wire)
28995 }
28996 return dAtA
28997 }
28998 func randFieldThetest(dAtA []byte, r randyThetest, fieldNumber int, wire int) []byte {
28999 key := uint32(fieldNumber)<<3 | uint32(wire)
29000 switch wire {
29001 case 0:
29002 dAtA = encodeVarintPopulateThetest(dAtA, uint64(key))
29003 v259 := r.Int63()
29004 if r.Intn(2) == 0 {
29005 v259 *= -1
29006 }
29007 dAtA = encodeVarintPopulateThetest(dAtA, uint64(v259))
29008 case 1:
29009 dAtA = encodeVarintPopulateThetest(dAtA, uint64(key))
29010 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)))
29011 case 2:
29012 dAtA = encodeVarintPopulateThetest(dAtA, uint64(key))
29013 ll := r.Intn(100)
29014 dAtA = encodeVarintPopulateThetest(dAtA, uint64(ll))
29015 for j := 0; j < ll; j++ {
29016 dAtA = append(dAtA, byte(r.Intn(256)))
29017 }
29018 default:
29019 dAtA = encodeVarintPopulateThetest(dAtA, uint64(key))
29020 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
29021 }
29022 return dAtA
29023 }
29024 func encodeVarintPopulateThetest(dAtA []byte, v uint64) []byte {
29025 for v >= 1<<7 {
29026 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
29027 v >>= 7
29028 }
29029 dAtA = append(dAtA, uint8(v))
29030 return dAtA
29031 }
29032 func (m *NidOptNative) Size() (n int) {
29033 if m == nil {
29034 return 0
29035 }
29036 var l int
29037 _ = l
29038 n += 9
29039 n += 5
29040 n += 1 + sovThetest(uint64(m.Field3))
29041 n += 1 + sovThetest(uint64(m.Field4))
29042 n += 1 + sovThetest(uint64(m.Field5))
29043 n += 1 + sovThetest(uint64(m.Field6))
29044 n += 1 + sozThetest(uint64(m.Field7))
29045 n += 1 + sozThetest(uint64(m.Field8))
29046 n += 5
29047 n += 5
29048 n += 9
29049 n += 9
29050 n += 2
29051 l = len(m.Field14)
29052 n += 1 + l + sovThetest(uint64(l))
29053 if m.Field15 != nil {
29054 l = len(m.Field15)
29055 n += 1 + l + sovThetest(uint64(l))
29056 }
29057 if m.XXX_unrecognized != nil {
29058 n += len(m.XXX_unrecognized)
29059 }
29060 return n
29061 }
29062
29063 func (m *NinOptNative) Size() (n int) {
29064 if m == nil {
29065 return 0
29066 }
29067 var l int
29068 _ = l
29069 if m.Field1 != nil {
29070 n += 9
29071 }
29072 if m.Field2 != nil {
29073 n += 5
29074 }
29075 if m.Field3 != nil {
29076 n += 1 + sovThetest(uint64(*m.Field3))
29077 }
29078 if m.Field4 != nil {
29079 n += 1 + sovThetest(uint64(*m.Field4))
29080 }
29081 if m.Field5 != nil {
29082 n += 1 + sovThetest(uint64(*m.Field5))
29083 }
29084 if m.Field6 != nil {
29085 n += 1 + sovThetest(uint64(*m.Field6))
29086 }
29087 if m.Field7 != nil {
29088 n += 1 + sozThetest(uint64(*m.Field7))
29089 }
29090 if m.Field8 != nil {
29091 n += 1 + sozThetest(uint64(*m.Field8))
29092 }
29093 if m.Field9 != nil {
29094 n += 5
29095 }
29096 if m.Field10 != nil {
29097 n += 5
29098 }
29099 if m.Field11 != nil {
29100 n += 9
29101 }
29102 if m.Field12 != nil {
29103 n += 9
29104 }
29105 if m.Field13 != nil {
29106 n += 2
29107 }
29108 if m.Field14 != nil {
29109 l = len(*m.Field14)
29110 n += 1 + l + sovThetest(uint64(l))
29111 }
29112 if m.Field15 != nil {
29113 l = len(m.Field15)
29114 n += 1 + l + sovThetest(uint64(l))
29115 }
29116 if m.XXX_unrecognized != nil {
29117 n += len(m.XXX_unrecognized)
29118 }
29119 return n
29120 }
29121
29122 func (m *NidRepNative) Size() (n int) {
29123 if m == nil {
29124 return 0
29125 }
29126 var l int
29127 _ = l
29128 if len(m.Field1) > 0 {
29129 n += 9 * len(m.Field1)
29130 }
29131 if len(m.Field2) > 0 {
29132 n += 5 * len(m.Field2)
29133 }
29134 if len(m.Field3) > 0 {
29135 for _, e := range m.Field3 {
29136 n += 1 + sovThetest(uint64(e))
29137 }
29138 }
29139 if len(m.Field4) > 0 {
29140 for _, e := range m.Field4 {
29141 n += 1 + sovThetest(uint64(e))
29142 }
29143 }
29144 if len(m.Field5) > 0 {
29145 for _, e := range m.Field5 {
29146 n += 1 + sovThetest(uint64(e))
29147 }
29148 }
29149 if len(m.Field6) > 0 {
29150 for _, e := range m.Field6 {
29151 n += 1 + sovThetest(uint64(e))
29152 }
29153 }
29154 if len(m.Field7) > 0 {
29155 for _, e := range m.Field7 {
29156 n += 1 + sozThetest(uint64(e))
29157 }
29158 }
29159 if len(m.Field8) > 0 {
29160 for _, e := range m.Field8 {
29161 n += 1 + sozThetest(uint64(e))
29162 }
29163 }
29164 if len(m.Field9) > 0 {
29165 n += 5 * len(m.Field9)
29166 }
29167 if len(m.Field10) > 0 {
29168 n += 5 * len(m.Field10)
29169 }
29170 if len(m.Field11) > 0 {
29171 n += 9 * len(m.Field11)
29172 }
29173 if len(m.Field12) > 0 {
29174 n += 9 * len(m.Field12)
29175 }
29176 if len(m.Field13) > 0 {
29177 n += 2 * len(m.Field13)
29178 }
29179 if len(m.Field14) > 0 {
29180 for _, s := range m.Field14 {
29181 l = len(s)
29182 n += 1 + l + sovThetest(uint64(l))
29183 }
29184 }
29185 if len(m.Field15) > 0 {
29186 for _, b := range m.Field15 {
29187 l = len(b)
29188 n += 1 + l + sovThetest(uint64(l))
29189 }
29190 }
29191 if m.XXX_unrecognized != nil {
29192 n += len(m.XXX_unrecognized)
29193 }
29194 return n
29195 }
29196
29197 func (m *NinRepNative) Size() (n int) {
29198 if m == nil {
29199 return 0
29200 }
29201 var l int
29202 _ = l
29203 if len(m.Field1) > 0 {
29204 n += 9 * len(m.Field1)
29205 }
29206 if len(m.Field2) > 0 {
29207 n += 5 * len(m.Field2)
29208 }
29209 if len(m.Field3) > 0 {
29210 for _, e := range m.Field3 {
29211 n += 1 + sovThetest(uint64(e))
29212 }
29213 }
29214 if len(m.Field4) > 0 {
29215 for _, e := range m.Field4 {
29216 n += 1 + sovThetest(uint64(e))
29217 }
29218 }
29219 if len(m.Field5) > 0 {
29220 for _, e := range m.Field5 {
29221 n += 1 + sovThetest(uint64(e))
29222 }
29223 }
29224 if len(m.Field6) > 0 {
29225 for _, e := range m.Field6 {
29226 n += 1 + sovThetest(uint64(e))
29227 }
29228 }
29229 if len(m.Field7) > 0 {
29230 for _, e := range m.Field7 {
29231 n += 1 + sozThetest(uint64(e))
29232 }
29233 }
29234 if len(m.Field8) > 0 {
29235 for _, e := range m.Field8 {
29236 n += 1 + sozThetest(uint64(e))
29237 }
29238 }
29239 if len(m.Field9) > 0 {
29240 n += 5 * len(m.Field9)
29241 }
29242 if len(m.Field10) > 0 {
29243 n += 5 * len(m.Field10)
29244 }
29245 if len(m.Field11) > 0 {
29246 n += 9 * len(m.Field11)
29247 }
29248 if len(m.Field12) > 0 {
29249 n += 9 * len(m.Field12)
29250 }
29251 if len(m.Field13) > 0 {
29252 n += 2 * len(m.Field13)
29253 }
29254 if len(m.Field14) > 0 {
29255 for _, s := range m.Field14 {
29256 l = len(s)
29257 n += 1 + l + sovThetest(uint64(l))
29258 }
29259 }
29260 if len(m.Field15) > 0 {
29261 for _, b := range m.Field15 {
29262 l = len(b)
29263 n += 1 + l + sovThetest(uint64(l))
29264 }
29265 }
29266 if m.XXX_unrecognized != nil {
29267 n += len(m.XXX_unrecognized)
29268 }
29269 return n
29270 }
29271
29272 func (m *NidRepPackedNative) Size() (n int) {
29273 if m == nil {
29274 return 0
29275 }
29276 var l int
29277 _ = l
29278 if len(m.Field1) > 0 {
29279 n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8
29280 }
29281 if len(m.Field2) > 0 {
29282 n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4
29283 }
29284 if len(m.Field3) > 0 {
29285 l = 0
29286 for _, e := range m.Field3 {
29287 l += sovThetest(uint64(e))
29288 }
29289 n += 1 + sovThetest(uint64(l)) + l
29290 }
29291 if len(m.Field4) > 0 {
29292 l = 0
29293 for _, e := range m.Field4 {
29294 l += sovThetest(uint64(e))
29295 }
29296 n += 1 + sovThetest(uint64(l)) + l
29297 }
29298 if len(m.Field5) > 0 {
29299 l = 0
29300 for _, e := range m.Field5 {
29301 l += sovThetest(uint64(e))
29302 }
29303 n += 1 + sovThetest(uint64(l)) + l
29304 }
29305 if len(m.Field6) > 0 {
29306 l = 0
29307 for _, e := range m.Field6 {
29308 l += sovThetest(uint64(e))
29309 }
29310 n += 1 + sovThetest(uint64(l)) + l
29311 }
29312 if len(m.Field7) > 0 {
29313 l = 0
29314 for _, e := range m.Field7 {
29315 l += sozThetest(uint64(e))
29316 }
29317 n += 1 + sovThetest(uint64(l)) + l
29318 }
29319 if len(m.Field8) > 0 {
29320 l = 0
29321 for _, e := range m.Field8 {
29322 l += sozThetest(uint64(e))
29323 }
29324 n += 1 + sovThetest(uint64(l)) + l
29325 }
29326 if len(m.Field9) > 0 {
29327 n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4
29328 }
29329 if len(m.Field10) > 0 {
29330 n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4
29331 }
29332 if len(m.Field11) > 0 {
29333 n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8
29334 }
29335 if len(m.Field12) > 0 {
29336 n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8
29337 }
29338 if len(m.Field13) > 0 {
29339 n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1
29340 }
29341 if m.XXX_unrecognized != nil {
29342 n += len(m.XXX_unrecognized)
29343 }
29344 return n
29345 }
29346
29347 func (m *NinRepPackedNative) Size() (n int) {
29348 if m == nil {
29349 return 0
29350 }
29351 var l int
29352 _ = l
29353 if len(m.Field1) > 0 {
29354 n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8
29355 }
29356 if len(m.Field2) > 0 {
29357 n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4
29358 }
29359 if len(m.Field3) > 0 {
29360 l = 0
29361 for _, e := range m.Field3 {
29362 l += sovThetest(uint64(e))
29363 }
29364 n += 1 + sovThetest(uint64(l)) + l
29365 }
29366 if len(m.Field4) > 0 {
29367 l = 0
29368 for _, e := range m.Field4 {
29369 l += sovThetest(uint64(e))
29370 }
29371 n += 1 + sovThetest(uint64(l)) + l
29372 }
29373 if len(m.Field5) > 0 {
29374 l = 0
29375 for _, e := range m.Field5 {
29376 l += sovThetest(uint64(e))
29377 }
29378 n += 1 + sovThetest(uint64(l)) + l
29379 }
29380 if len(m.Field6) > 0 {
29381 l = 0
29382 for _, e := range m.Field6 {
29383 l += sovThetest(uint64(e))
29384 }
29385 n += 1 + sovThetest(uint64(l)) + l
29386 }
29387 if len(m.Field7) > 0 {
29388 l = 0
29389 for _, e := range m.Field7 {
29390 l += sozThetest(uint64(e))
29391 }
29392 n += 1 + sovThetest(uint64(l)) + l
29393 }
29394 if len(m.Field8) > 0 {
29395 l = 0
29396 for _, e := range m.Field8 {
29397 l += sozThetest(uint64(e))
29398 }
29399 n += 1 + sovThetest(uint64(l)) + l
29400 }
29401 if len(m.Field9) > 0 {
29402 n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4
29403 }
29404 if len(m.Field10) > 0 {
29405 n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4
29406 }
29407 if len(m.Field11) > 0 {
29408 n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8
29409 }
29410 if len(m.Field12) > 0 {
29411 n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8
29412 }
29413 if len(m.Field13) > 0 {
29414 n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1
29415 }
29416 if m.XXX_unrecognized != nil {
29417 n += len(m.XXX_unrecognized)
29418 }
29419 return n
29420 }
29421
29422 func (m *NidOptStruct) Size() (n int) {
29423 if m == nil {
29424 return 0
29425 }
29426 var l int
29427 _ = l
29428 n += 9
29429 n += 5
29430 l = m.Field3.Size()
29431 n += 1 + l + sovThetest(uint64(l))
29432 l = m.Field4.Size()
29433 n += 1 + l + sovThetest(uint64(l))
29434 n += 1 + sovThetest(uint64(m.Field6))
29435 n += 1 + sozThetest(uint64(m.Field7))
29436 l = m.Field8.Size()
29437 n += 1 + l + sovThetest(uint64(l))
29438 n += 2
29439 l = len(m.Field14)
29440 n += 1 + l + sovThetest(uint64(l))
29441 if m.Field15 != nil {
29442 l = len(m.Field15)
29443 n += 1 + l + sovThetest(uint64(l))
29444 }
29445 if m.XXX_unrecognized != nil {
29446 n += len(m.XXX_unrecognized)
29447 }
29448 return n
29449 }
29450
29451 func (m *NinOptStruct) Size() (n int) {
29452 if m == nil {
29453 return 0
29454 }
29455 var l int
29456 _ = l
29457 if m.Field1 != nil {
29458 n += 9
29459 }
29460 if m.Field2 != nil {
29461 n += 5
29462 }
29463 if m.Field3 != nil {
29464 l = m.Field3.Size()
29465 n += 1 + l + sovThetest(uint64(l))
29466 }
29467 if m.Field4 != nil {
29468 l = m.Field4.Size()
29469 n += 1 + l + sovThetest(uint64(l))
29470 }
29471 if m.Field6 != nil {
29472 n += 1 + sovThetest(uint64(*m.Field6))
29473 }
29474 if m.Field7 != nil {
29475 n += 1 + sozThetest(uint64(*m.Field7))
29476 }
29477 if m.Field8 != nil {
29478 l = m.Field8.Size()
29479 n += 1 + l + sovThetest(uint64(l))
29480 }
29481 if m.Field13 != nil {
29482 n += 2
29483 }
29484 if m.Field14 != nil {
29485 l = len(*m.Field14)
29486 n += 1 + l + sovThetest(uint64(l))
29487 }
29488 if m.Field15 != nil {
29489 l = len(m.Field15)
29490 n += 1 + l + sovThetest(uint64(l))
29491 }
29492 if m.XXX_unrecognized != nil {
29493 n += len(m.XXX_unrecognized)
29494 }
29495 return n
29496 }
29497
29498 func (m *NidRepStruct) Size() (n int) {
29499 if m == nil {
29500 return 0
29501 }
29502 var l int
29503 _ = l
29504 if len(m.Field1) > 0 {
29505 n += 9 * len(m.Field1)
29506 }
29507 if len(m.Field2) > 0 {
29508 n += 5 * len(m.Field2)
29509 }
29510 if len(m.Field3) > 0 {
29511 for _, e := range m.Field3 {
29512 l = e.Size()
29513 n += 1 + l + sovThetest(uint64(l))
29514 }
29515 }
29516 if len(m.Field4) > 0 {
29517 for _, e := range m.Field4 {
29518 l = e.Size()
29519 n += 1 + l + sovThetest(uint64(l))
29520 }
29521 }
29522 if len(m.Field6) > 0 {
29523 for _, e := range m.Field6 {
29524 n += 1 + sovThetest(uint64(e))
29525 }
29526 }
29527 if len(m.Field7) > 0 {
29528 for _, e := range m.Field7 {
29529 n += 1 + sozThetest(uint64(e))
29530 }
29531 }
29532 if len(m.Field8) > 0 {
29533 for _, e := range m.Field8 {
29534 l = e.Size()
29535 n += 1 + l + sovThetest(uint64(l))
29536 }
29537 }
29538 if len(m.Field13) > 0 {
29539 n += 2 * len(m.Field13)
29540 }
29541 if len(m.Field14) > 0 {
29542 for _, s := range m.Field14 {
29543 l = len(s)
29544 n += 1 + l + sovThetest(uint64(l))
29545 }
29546 }
29547 if len(m.Field15) > 0 {
29548 for _, b := range m.Field15 {
29549 l = len(b)
29550 n += 1 + l + sovThetest(uint64(l))
29551 }
29552 }
29553 if m.XXX_unrecognized != nil {
29554 n += len(m.XXX_unrecognized)
29555 }
29556 return n
29557 }
29558
29559 func (m *NinRepStruct) Size() (n int) {
29560 if m == nil {
29561 return 0
29562 }
29563 var l int
29564 _ = l
29565 if len(m.Field1) > 0 {
29566 n += 9 * len(m.Field1)
29567 }
29568 if len(m.Field2) > 0 {
29569 n += 5 * len(m.Field2)
29570 }
29571 if len(m.Field3) > 0 {
29572 for _, e := range m.Field3 {
29573 l = e.Size()
29574 n += 1 + l + sovThetest(uint64(l))
29575 }
29576 }
29577 if len(m.Field4) > 0 {
29578 for _, e := range m.Field4 {
29579 l = e.Size()
29580 n += 1 + l + sovThetest(uint64(l))
29581 }
29582 }
29583 if len(m.Field6) > 0 {
29584 for _, e := range m.Field6 {
29585 n += 1 + sovThetest(uint64(e))
29586 }
29587 }
29588 if len(m.Field7) > 0 {
29589 for _, e := range m.Field7 {
29590 n += 1 + sozThetest(uint64(e))
29591 }
29592 }
29593 if len(m.Field8) > 0 {
29594 for _, e := range m.Field8 {
29595 l = e.Size()
29596 n += 1 + l + sovThetest(uint64(l))
29597 }
29598 }
29599 if len(m.Field13) > 0 {
29600 n += 2 * len(m.Field13)
29601 }
29602 if len(m.Field14) > 0 {
29603 for _, s := range m.Field14 {
29604 l = len(s)
29605 n += 1 + l + sovThetest(uint64(l))
29606 }
29607 }
29608 if len(m.Field15) > 0 {
29609 for _, b := range m.Field15 {
29610 l = len(b)
29611 n += 1 + l + sovThetest(uint64(l))
29612 }
29613 }
29614 if m.XXX_unrecognized != nil {
29615 n += len(m.XXX_unrecognized)
29616 }
29617 return n
29618 }
29619
29620 func (m *NidEmbeddedStruct) Size() (n int) {
29621 if m == nil {
29622 return 0
29623 }
29624 var l int
29625 _ = l
29626 if m.NidOptNative != nil {
29627 l = m.NidOptNative.Size()
29628 n += 1 + l + sovThetest(uint64(l))
29629 }
29630 l = m.Field200.Size()
29631 n += 2 + l + sovThetest(uint64(l))
29632 n += 3
29633 if m.XXX_unrecognized != nil {
29634 n += len(m.XXX_unrecognized)
29635 }
29636 return n
29637 }
29638
29639 func (m *NinEmbeddedStruct) Size() (n int) {
29640 if m == nil {
29641 return 0
29642 }
29643 var l int
29644 _ = l
29645 if m.NidOptNative != nil {
29646 l = m.NidOptNative.Size()
29647 n += 1 + l + sovThetest(uint64(l))
29648 }
29649 if m.Field200 != nil {
29650 l = m.Field200.Size()
29651 n += 2 + l + sovThetest(uint64(l))
29652 }
29653 if m.Field210 != nil {
29654 n += 3
29655 }
29656 if m.XXX_unrecognized != nil {
29657 n += len(m.XXX_unrecognized)
29658 }
29659 return n
29660 }
29661
29662 func (m *NidNestedStruct) Size() (n int) {
29663 if m == nil {
29664 return 0
29665 }
29666 var l int
29667 _ = l
29668 l = m.Field1.Size()
29669 n += 1 + l + sovThetest(uint64(l))
29670 if len(m.Field2) > 0 {
29671 for _, e := range m.Field2 {
29672 l = e.Size()
29673 n += 1 + l + sovThetest(uint64(l))
29674 }
29675 }
29676 if m.XXX_unrecognized != nil {
29677 n += len(m.XXX_unrecognized)
29678 }
29679 return n
29680 }
29681
29682 func (m *NinNestedStruct) Size() (n int) {
29683 if m == nil {
29684 return 0
29685 }
29686 var l int
29687 _ = l
29688 if m.Field1 != nil {
29689 l = m.Field1.Size()
29690 n += 1 + l + sovThetest(uint64(l))
29691 }
29692 if len(m.Field2) > 0 {
29693 for _, e := range m.Field2 {
29694 l = e.Size()
29695 n += 1 + l + sovThetest(uint64(l))
29696 }
29697 }
29698 if m.XXX_unrecognized != nil {
29699 n += len(m.XXX_unrecognized)
29700 }
29701 return n
29702 }
29703
29704 func (m *NidOptCustom) Size() (n int) {
29705 if m == nil {
29706 return 0
29707 }
29708 var l int
29709 _ = l
29710 l = m.Id.Size()
29711 n += 1 + l + sovThetest(uint64(l))
29712 l = m.Value.Size()
29713 n += 1 + l + sovThetest(uint64(l))
29714 if m.XXX_unrecognized != nil {
29715 n += len(m.XXX_unrecognized)
29716 }
29717 return n
29718 }
29719
29720 func (m *CustomDash) Size() (n int) {
29721 if m == nil {
29722 return 0
29723 }
29724 var l int
29725 _ = l
29726 if m.Value != nil {
29727 l = m.Value.Size()
29728 n += 1 + l + sovThetest(uint64(l))
29729 }
29730 if m.XXX_unrecognized != nil {
29731 n += len(m.XXX_unrecognized)
29732 }
29733 return n
29734 }
29735
29736 func (m *NinOptCustom) Size() (n int) {
29737 if m == nil {
29738 return 0
29739 }
29740 var l int
29741 _ = l
29742 if m.Id != nil {
29743 l = m.Id.Size()
29744 n += 1 + l + sovThetest(uint64(l))
29745 }
29746 if m.Value != nil {
29747 l = m.Value.Size()
29748 n += 1 + l + sovThetest(uint64(l))
29749 }
29750 if m.XXX_unrecognized != nil {
29751 n += len(m.XXX_unrecognized)
29752 }
29753 return n
29754 }
29755
29756 func (m *NidRepCustom) Size() (n int) {
29757 if m == nil {
29758 return 0
29759 }
29760 var l int
29761 _ = l
29762 if len(m.Id) > 0 {
29763 for _, e := range m.Id {
29764 l = e.Size()
29765 n += 1 + l + sovThetest(uint64(l))
29766 }
29767 }
29768 if len(m.Value) > 0 {
29769 for _, e := range m.Value {
29770 l = e.Size()
29771 n += 1 + l + sovThetest(uint64(l))
29772 }
29773 }
29774 if m.XXX_unrecognized != nil {
29775 n += len(m.XXX_unrecognized)
29776 }
29777 return n
29778 }
29779
29780 func (m *NinRepCustom) Size() (n int) {
29781 if m == nil {
29782 return 0
29783 }
29784 var l int
29785 _ = l
29786 if len(m.Id) > 0 {
29787 for _, e := range m.Id {
29788 l = e.Size()
29789 n += 1 + l + sovThetest(uint64(l))
29790 }
29791 }
29792 if len(m.Value) > 0 {
29793 for _, e := range m.Value {
29794 l = e.Size()
29795 n += 1 + l + sovThetest(uint64(l))
29796 }
29797 }
29798 if m.XXX_unrecognized != nil {
29799 n += len(m.XXX_unrecognized)
29800 }
29801 return n
29802 }
29803
29804 func (m *NinOptNativeUnion) Size() (n int) {
29805 if m == nil {
29806 return 0
29807 }
29808 var l int
29809 _ = l
29810 if m.Field1 != nil {
29811 n += 9
29812 }
29813 if m.Field2 != nil {
29814 n += 5
29815 }
29816 if m.Field3 != nil {
29817 n += 1 + sovThetest(uint64(*m.Field3))
29818 }
29819 if m.Field4 != nil {
29820 n += 1 + sovThetest(uint64(*m.Field4))
29821 }
29822 if m.Field5 != nil {
29823 n += 1 + sovThetest(uint64(*m.Field5))
29824 }
29825 if m.Field6 != nil {
29826 n += 1 + sovThetest(uint64(*m.Field6))
29827 }
29828 if m.Field13 != nil {
29829 n += 2
29830 }
29831 if m.Field14 != nil {
29832 l = len(*m.Field14)
29833 n += 1 + l + sovThetest(uint64(l))
29834 }
29835 if m.Field15 != nil {
29836 l = len(m.Field15)
29837 n += 1 + l + sovThetest(uint64(l))
29838 }
29839 if m.XXX_unrecognized != nil {
29840 n += len(m.XXX_unrecognized)
29841 }
29842 return n
29843 }
29844
29845 func (m *NinOptStructUnion) Size() (n int) {
29846 if m == nil {
29847 return 0
29848 }
29849 var l int
29850 _ = l
29851 if m.Field1 != nil {
29852 n += 9
29853 }
29854 if m.Field2 != nil {
29855 n += 5
29856 }
29857 if m.Field3 != nil {
29858 l = m.Field3.Size()
29859 n += 1 + l + sovThetest(uint64(l))
29860 }
29861 if m.Field4 != nil {
29862 l = m.Field4.Size()
29863 n += 1 + l + sovThetest(uint64(l))
29864 }
29865 if m.Field6 != nil {
29866 n += 1 + sovThetest(uint64(*m.Field6))
29867 }
29868 if m.Field7 != nil {
29869 n += 1 + sozThetest(uint64(*m.Field7))
29870 }
29871 if m.Field13 != nil {
29872 n += 2
29873 }
29874 if m.Field14 != nil {
29875 l = len(*m.Field14)
29876 n += 1 + l + sovThetest(uint64(l))
29877 }
29878 if m.Field15 != nil {
29879 l = len(m.Field15)
29880 n += 1 + l + sovThetest(uint64(l))
29881 }
29882 if m.XXX_unrecognized != nil {
29883 n += len(m.XXX_unrecognized)
29884 }
29885 return n
29886 }
29887
29888 func (m *NinEmbeddedStructUnion) Size() (n int) {
29889 if m == nil {
29890 return 0
29891 }
29892 var l int
29893 _ = l
29894 if m.NidOptNative != nil {
29895 l = m.NidOptNative.Size()
29896 n += 1 + l + sovThetest(uint64(l))
29897 }
29898 if m.Field200 != nil {
29899 l = m.Field200.Size()
29900 n += 2 + l + sovThetest(uint64(l))
29901 }
29902 if m.Field210 != nil {
29903 n += 3
29904 }
29905 if m.XXX_unrecognized != nil {
29906 n += len(m.XXX_unrecognized)
29907 }
29908 return n
29909 }
29910
29911 func (m *NinNestedStructUnion) Size() (n int) {
29912 if m == nil {
29913 return 0
29914 }
29915 var l int
29916 _ = l
29917 if m.Field1 != nil {
29918 l = m.Field1.Size()
29919 n += 1 + l + sovThetest(uint64(l))
29920 }
29921 if m.Field2 != nil {
29922 l = m.Field2.Size()
29923 n += 1 + l + sovThetest(uint64(l))
29924 }
29925 if m.Field3 != nil {
29926 l = m.Field3.Size()
29927 n += 1 + l + sovThetest(uint64(l))
29928 }
29929 if m.XXX_unrecognized != nil {
29930 n += len(m.XXX_unrecognized)
29931 }
29932 return n
29933 }
29934
29935 func (m *Tree) Size() (n int) {
29936 if m == nil {
29937 return 0
29938 }
29939 var l int
29940 _ = l
29941 if m.Or != nil {
29942 l = m.Or.Size()
29943 n += 1 + l + sovThetest(uint64(l))
29944 }
29945 if m.And != nil {
29946 l = m.And.Size()
29947 n += 1 + l + sovThetest(uint64(l))
29948 }
29949 if m.Leaf != nil {
29950 l = m.Leaf.Size()
29951 n += 1 + l + sovThetest(uint64(l))
29952 }
29953 if m.XXX_unrecognized != nil {
29954 n += len(m.XXX_unrecognized)
29955 }
29956 return n
29957 }
29958
29959 func (m *OrBranch) Size() (n int) {
29960 if m == nil {
29961 return 0
29962 }
29963 var l int
29964 _ = l
29965 l = m.Left.Size()
29966 n += 1 + l + sovThetest(uint64(l))
29967 l = m.Right.Size()
29968 n += 1 + l + sovThetest(uint64(l))
29969 if m.XXX_unrecognized != nil {
29970 n += len(m.XXX_unrecognized)
29971 }
29972 return n
29973 }
29974
29975 func (m *AndBranch) Size() (n int) {
29976 if m == nil {
29977 return 0
29978 }
29979 var l int
29980 _ = l
29981 l = m.Left.Size()
29982 n += 1 + l + sovThetest(uint64(l))
29983 l = m.Right.Size()
29984 n += 1 + l + sovThetest(uint64(l))
29985 if m.XXX_unrecognized != nil {
29986 n += len(m.XXX_unrecognized)
29987 }
29988 return n
29989 }
29990
29991 func (m *Leaf) Size() (n int) {
29992 if m == nil {
29993 return 0
29994 }
29995 var l int
29996 _ = l
29997 n += 1 + sovThetest(uint64(m.Value))
29998 l = len(m.StrValue)
29999 n += 1 + l + sovThetest(uint64(l))
30000 if m.XXX_unrecognized != nil {
30001 n += len(m.XXX_unrecognized)
30002 }
30003 return n
30004 }
30005
30006 func (m *DeepTree) Size() (n int) {
30007 if m == nil {
30008 return 0
30009 }
30010 var l int
30011 _ = l
30012 if m.Down != nil {
30013 l = m.Down.Size()
30014 n += 1 + l + sovThetest(uint64(l))
30015 }
30016 if m.And != nil {
30017 l = m.And.Size()
30018 n += 1 + l + sovThetest(uint64(l))
30019 }
30020 if m.Leaf != nil {
30021 l = m.Leaf.Size()
30022 n += 1 + l + sovThetest(uint64(l))
30023 }
30024 if m.XXX_unrecognized != nil {
30025 n += len(m.XXX_unrecognized)
30026 }
30027 return n
30028 }
30029
30030 func (m *ADeepBranch) Size() (n int) {
30031 if m == nil {
30032 return 0
30033 }
30034 var l int
30035 _ = l
30036 l = m.Down.Size()
30037 n += 1 + l + sovThetest(uint64(l))
30038 if m.XXX_unrecognized != nil {
30039 n += len(m.XXX_unrecognized)
30040 }
30041 return n
30042 }
30043
30044 func (m *AndDeepBranch) Size() (n int) {
30045 if m == nil {
30046 return 0
30047 }
30048 var l int
30049 _ = l
30050 l = m.Left.Size()
30051 n += 1 + l + sovThetest(uint64(l))
30052 l = m.Right.Size()
30053 n += 1 + l + sovThetest(uint64(l))
30054 if m.XXX_unrecognized != nil {
30055 n += len(m.XXX_unrecognized)
30056 }
30057 return n
30058 }
30059
30060 func (m *DeepLeaf) Size() (n int) {
30061 if m == nil {
30062 return 0
30063 }
30064 var l int
30065 _ = l
30066 l = m.Tree.Size()
30067 n += 1 + l + sovThetest(uint64(l))
30068 if m.XXX_unrecognized != nil {
30069 n += len(m.XXX_unrecognized)
30070 }
30071 return n
30072 }
30073
30074 func (m *Nil) Size() (n int) {
30075 if m == nil {
30076 return 0
30077 }
30078 var l int
30079 _ = l
30080 if m.XXX_unrecognized != nil {
30081 n += len(m.XXX_unrecognized)
30082 }
30083 return n
30084 }
30085
30086 func (m *NidOptEnum) Size() (n int) {
30087 if m == nil {
30088 return 0
30089 }
30090 var l int
30091 _ = l
30092 n += 1 + sovThetest(uint64(m.Field1))
30093 if m.XXX_unrecognized != nil {
30094 n += len(m.XXX_unrecognized)
30095 }
30096 return n
30097 }
30098
30099 func (m *NinOptEnum) Size() (n int) {
30100 if m == nil {
30101 return 0
30102 }
30103 var l int
30104 _ = l
30105 if m.Field1 != nil {
30106 n += 1 + sovThetest(uint64(*m.Field1))
30107 }
30108 if m.Field2 != nil {
30109 n += 1 + sovThetest(uint64(*m.Field2))
30110 }
30111 if m.Field3 != nil {
30112 n += 1 + sovThetest(uint64(*m.Field3))
30113 }
30114 if m.XXX_unrecognized != nil {
30115 n += len(m.XXX_unrecognized)
30116 }
30117 return n
30118 }
30119
30120 func (m *NidRepEnum) Size() (n int) {
30121 if m == nil {
30122 return 0
30123 }
30124 var l int
30125 _ = l
30126 if len(m.Field1) > 0 {
30127 for _, e := range m.Field1 {
30128 n += 1 + sovThetest(uint64(e))
30129 }
30130 }
30131 if len(m.Field2) > 0 {
30132 for _, e := range m.Field2 {
30133 n += 1 + sovThetest(uint64(e))
30134 }
30135 }
30136 if len(m.Field3) > 0 {
30137 for _, e := range m.Field3 {
30138 n += 1 + sovThetest(uint64(e))
30139 }
30140 }
30141 if m.XXX_unrecognized != nil {
30142 n += len(m.XXX_unrecognized)
30143 }
30144 return n
30145 }
30146
30147 func (m *NinRepEnum) Size() (n int) {
30148 if m == nil {
30149 return 0
30150 }
30151 var l int
30152 _ = l
30153 if len(m.Field1) > 0 {
30154 for _, e := range m.Field1 {
30155 n += 1 + sovThetest(uint64(e))
30156 }
30157 }
30158 if len(m.Field2) > 0 {
30159 for _, e := range m.Field2 {
30160 n += 1 + sovThetest(uint64(e))
30161 }
30162 }
30163 if len(m.Field3) > 0 {
30164 for _, e := range m.Field3 {
30165 n += 1 + sovThetest(uint64(e))
30166 }
30167 }
30168 if m.XXX_unrecognized != nil {
30169 n += len(m.XXX_unrecognized)
30170 }
30171 return n
30172 }
30173
30174 func (m *NinOptEnumDefault) Size() (n int) {
30175 if m == nil {
30176 return 0
30177 }
30178 var l int
30179 _ = l
30180 if m.Field1 != nil {
30181 n += 1 + sovThetest(uint64(*m.Field1))
30182 }
30183 if m.Field2 != nil {
30184 n += 1 + sovThetest(uint64(*m.Field2))
30185 }
30186 if m.Field3 != nil {
30187 n += 1 + sovThetest(uint64(*m.Field3))
30188 }
30189 if m.XXX_unrecognized != nil {
30190 n += len(m.XXX_unrecognized)
30191 }
30192 return n
30193 }
30194
30195 func (m *AnotherNinOptEnum) Size() (n int) {
30196 if m == nil {
30197 return 0
30198 }
30199 var l int
30200 _ = l
30201 if m.Field1 != nil {
30202 n += 1 + sovThetest(uint64(*m.Field1))
30203 }
30204 if m.Field2 != nil {
30205 n += 1 + sovThetest(uint64(*m.Field2))
30206 }
30207 if m.Field3 != nil {
30208 n += 1 + sovThetest(uint64(*m.Field3))
30209 }
30210 if m.XXX_unrecognized != nil {
30211 n += len(m.XXX_unrecognized)
30212 }
30213 return n
30214 }
30215
30216 func (m *AnotherNinOptEnumDefault) Size() (n int) {
30217 if m == nil {
30218 return 0
30219 }
30220 var l int
30221 _ = l
30222 if m.Field1 != nil {
30223 n += 1 + sovThetest(uint64(*m.Field1))
30224 }
30225 if m.Field2 != nil {
30226 n += 1 + sovThetest(uint64(*m.Field2))
30227 }
30228 if m.Field3 != nil {
30229 n += 1 + sovThetest(uint64(*m.Field3))
30230 }
30231 if m.XXX_unrecognized != nil {
30232 n += len(m.XXX_unrecognized)
30233 }
30234 return n
30235 }
30236
30237 func (m *Timer) Size() (n int) {
30238 if m == nil {
30239 return 0
30240 }
30241 var l int
30242 _ = l
30243 n += 9
30244 n += 9
30245 if m.Data != nil {
30246 l = len(m.Data)
30247 n += 1 + l + sovThetest(uint64(l))
30248 }
30249 if m.XXX_unrecognized != nil {
30250 n += len(m.XXX_unrecognized)
30251 }
30252 return n
30253 }
30254
30255 func (m *MyExtendable) Size() (n int) {
30256 if m == nil {
30257 return 0
30258 }
30259 var l int
30260 _ = l
30261 if m.Field1 != nil {
30262 n += 1 + sovThetest(uint64(*m.Field1))
30263 }
30264 n += github_com_gogo_protobuf_proto.SizeOfInternalExtension(m)
30265 if m.XXX_unrecognized != nil {
30266 n += len(m.XXX_unrecognized)
30267 }
30268 return n
30269 }
30270
30271 func (m *OtherExtenable) Size() (n int) {
30272 if m == nil {
30273 return 0
30274 }
30275 var l int
30276 _ = l
30277 if m.M != nil {
30278 l = m.M.Size()
30279 n += 1 + l + sovThetest(uint64(l))
30280 }
30281 if m.Field2 != nil {
30282 n += 1 + sovThetest(uint64(*m.Field2))
30283 }
30284 if m.Field13 != nil {
30285 n += 1 + sovThetest(uint64(*m.Field13))
30286 }
30287 n += github_com_gogo_protobuf_proto.SizeOfInternalExtension(m)
30288 if m.XXX_unrecognized != nil {
30289 n += len(m.XXX_unrecognized)
30290 }
30291 return n
30292 }
30293
30294 func (m *NestedDefinition) Size() (n int) {
30295 if m == nil {
30296 return 0
30297 }
30298 var l int
30299 _ = l
30300 if m.Field1 != nil {
30301 n += 1 + sovThetest(uint64(*m.Field1))
30302 }
30303 if m.EnumField != nil {
30304 n += 1 + sovThetest(uint64(*m.EnumField))
30305 }
30306 if m.NNM != nil {
30307 l = m.NNM.Size()
30308 n += 1 + l + sovThetest(uint64(l))
30309 }
30310 if m.NM != nil {
30311 l = m.NM.Size()
30312 n += 1 + l + sovThetest(uint64(l))
30313 }
30314 if m.XXX_unrecognized != nil {
30315 n += len(m.XXX_unrecognized)
30316 }
30317 return n
30318 }
30319
30320 func (m *NestedDefinition_NestedMessage) Size() (n int) {
30321 if m == nil {
30322 return 0
30323 }
30324 var l int
30325 _ = l
30326 if m.NestedField1 != nil {
30327 n += 9
30328 }
30329 if m.NNM != nil {
30330 l = m.NNM.Size()
30331 n += 1 + l + sovThetest(uint64(l))
30332 }
30333 if m.XXX_unrecognized != nil {
30334 n += len(m.XXX_unrecognized)
30335 }
30336 return n
30337 }
30338
30339 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Size() (n int) {
30340 if m == nil {
30341 return 0
30342 }
30343 var l int
30344 _ = l
30345 if m.NestedNestedField1 != nil {
30346 l = len(*m.NestedNestedField1)
30347 n += 1 + l + sovThetest(uint64(l))
30348 }
30349 if m.XXX_unrecognized != nil {
30350 n += len(m.XXX_unrecognized)
30351 }
30352 return n
30353 }
30354
30355 func (m *NestedScope) Size() (n int) {
30356 if m == nil {
30357 return 0
30358 }
30359 var l int
30360 _ = l
30361 if m.A != nil {
30362 l = m.A.Size()
30363 n += 1 + l + sovThetest(uint64(l))
30364 }
30365 if m.B != nil {
30366 n += 1 + sovThetest(uint64(*m.B))
30367 }
30368 if m.C != nil {
30369 l = m.C.Size()
30370 n += 1 + l + sovThetest(uint64(l))
30371 }
30372 if m.XXX_unrecognized != nil {
30373 n += len(m.XXX_unrecognized)
30374 }
30375 return n
30376 }
30377
30378 func (m *NinOptNativeDefault) Size() (n int) {
30379 if m == nil {
30380 return 0
30381 }
30382 var l int
30383 _ = l
30384 if m.Field1 != nil {
30385 n += 9
30386 }
30387 if m.Field2 != nil {
30388 n += 5
30389 }
30390 if m.Field3 != nil {
30391 n += 1 + sovThetest(uint64(*m.Field3))
30392 }
30393 if m.Field4 != nil {
30394 n += 1 + sovThetest(uint64(*m.Field4))
30395 }
30396 if m.Field5 != nil {
30397 n += 1 + sovThetest(uint64(*m.Field5))
30398 }
30399 if m.Field6 != nil {
30400 n += 1 + sovThetest(uint64(*m.Field6))
30401 }
30402 if m.Field7 != nil {
30403 n += 1 + sozThetest(uint64(*m.Field7))
30404 }
30405 if m.Field8 != nil {
30406 n += 1 + sozThetest(uint64(*m.Field8))
30407 }
30408 if m.Field9 != nil {
30409 n += 5
30410 }
30411 if m.Field10 != nil {
30412 n += 5
30413 }
30414 if m.Field11 != nil {
30415 n += 9
30416 }
30417 if m.Field12 != nil {
30418 n += 9
30419 }
30420 if m.Field13 != nil {
30421 n += 2
30422 }
30423 if m.Field14 != nil {
30424 l = len(*m.Field14)
30425 n += 1 + l + sovThetest(uint64(l))
30426 }
30427 if m.Field15 != nil {
30428 l = len(m.Field15)
30429 n += 1 + l + sovThetest(uint64(l))
30430 }
30431 if m.XXX_unrecognized != nil {
30432 n += len(m.XXX_unrecognized)
30433 }
30434 return n
30435 }
30436
30437 func (m *CustomContainer) Size() (n int) {
30438 if m == nil {
30439 return 0
30440 }
30441 var l int
30442 _ = l
30443 l = m.CustomStruct.Size()
30444 n += 1 + l + sovThetest(uint64(l))
30445 if m.XXX_unrecognized != nil {
30446 n += len(m.XXX_unrecognized)
30447 }
30448 return n
30449 }
30450
30451 func (m *CustomNameNidOptNative) Size() (n int) {
30452 if m == nil {
30453 return 0
30454 }
30455 var l int
30456 _ = l
30457 n += 9
30458 n += 5
30459 n += 1 + sovThetest(uint64(m.FieldC))
30460 n += 1 + sovThetest(uint64(m.FieldD))
30461 n += 1 + sovThetest(uint64(m.FieldE))
30462 n += 1 + sovThetest(uint64(m.FieldF))
30463 n += 1 + sozThetest(uint64(m.FieldG))
30464 n += 1 + sozThetest(uint64(m.FieldH))
30465 n += 5
30466 n += 5
30467 n += 9
30468 n += 9
30469 n += 2
30470 l = len(m.FieldN)
30471 n += 1 + l + sovThetest(uint64(l))
30472 if m.FieldO != nil {
30473 l = len(m.FieldO)
30474 n += 1 + l + sovThetest(uint64(l))
30475 }
30476 if m.XXX_unrecognized != nil {
30477 n += len(m.XXX_unrecognized)
30478 }
30479 return n
30480 }
30481
30482 func (m *CustomNameNinOptNative) Size() (n int) {
30483 if m == nil {
30484 return 0
30485 }
30486 var l int
30487 _ = l
30488 if m.FieldA != nil {
30489 n += 9
30490 }
30491 if m.FieldB != nil {
30492 n += 5
30493 }
30494 if m.FieldC != nil {
30495 n += 1 + sovThetest(uint64(*m.FieldC))
30496 }
30497 if m.FieldD != nil {
30498 n += 1 + sovThetest(uint64(*m.FieldD))
30499 }
30500 if m.FieldE != nil {
30501 n += 1 + sovThetest(uint64(*m.FieldE))
30502 }
30503 if m.FieldF != nil {
30504 n += 1 + sovThetest(uint64(*m.FieldF))
30505 }
30506 if m.FieldG != nil {
30507 n += 1 + sozThetest(uint64(*m.FieldG))
30508 }
30509 if m.FieldH != nil {
30510 n += 1 + sozThetest(uint64(*m.FieldH))
30511 }
30512 if m.FieldI != nil {
30513 n += 5
30514 }
30515 if m.FieldJ != nil {
30516 n += 5
30517 }
30518 if m.FieldK != nil {
30519 n += 9
30520 }
30521 if m.FielL != nil {
30522 n += 9
30523 }
30524 if m.FieldM != nil {
30525 n += 2
30526 }
30527 if m.FieldN != nil {
30528 l = len(*m.FieldN)
30529 n += 1 + l + sovThetest(uint64(l))
30530 }
30531 if m.FieldO != nil {
30532 l = len(m.FieldO)
30533 n += 1 + l + sovThetest(uint64(l))
30534 }
30535 if m.XXX_unrecognized != nil {
30536 n += len(m.XXX_unrecognized)
30537 }
30538 return n
30539 }
30540
30541 func (m *CustomNameNinRepNative) Size() (n int) {
30542 if m == nil {
30543 return 0
30544 }
30545 var l int
30546 _ = l
30547 if len(m.FieldA) > 0 {
30548 n += 9 * len(m.FieldA)
30549 }
30550 if len(m.FieldB) > 0 {
30551 n += 5 * len(m.FieldB)
30552 }
30553 if len(m.FieldC) > 0 {
30554 for _, e := range m.FieldC {
30555 n += 1 + sovThetest(uint64(e))
30556 }
30557 }
30558 if len(m.FieldD) > 0 {
30559 for _, e := range m.FieldD {
30560 n += 1 + sovThetest(uint64(e))
30561 }
30562 }
30563 if len(m.FieldE) > 0 {
30564 for _, e := range m.FieldE {
30565 n += 1 + sovThetest(uint64(e))
30566 }
30567 }
30568 if len(m.FieldF) > 0 {
30569 for _, e := range m.FieldF {
30570 n += 1 + sovThetest(uint64(e))
30571 }
30572 }
30573 if len(m.FieldG) > 0 {
30574 for _, e := range m.FieldG {
30575 n += 1 + sozThetest(uint64(e))
30576 }
30577 }
30578 if len(m.FieldH) > 0 {
30579 for _, e := range m.FieldH {
30580 n += 1 + sozThetest(uint64(e))
30581 }
30582 }
30583 if len(m.FieldI) > 0 {
30584 n += 5 * len(m.FieldI)
30585 }
30586 if len(m.FieldJ) > 0 {
30587 n += 5 * len(m.FieldJ)
30588 }
30589 if len(m.FieldK) > 0 {
30590 n += 9 * len(m.FieldK)
30591 }
30592 if len(m.FieldL) > 0 {
30593 n += 9 * len(m.FieldL)
30594 }
30595 if len(m.FieldM) > 0 {
30596 n += 2 * len(m.FieldM)
30597 }
30598 if len(m.FieldN) > 0 {
30599 for _, s := range m.FieldN {
30600 l = len(s)
30601 n += 1 + l + sovThetest(uint64(l))
30602 }
30603 }
30604 if len(m.FieldO) > 0 {
30605 for _, b := range m.FieldO {
30606 l = len(b)
30607 n += 1 + l + sovThetest(uint64(l))
30608 }
30609 }
30610 if m.XXX_unrecognized != nil {
30611 n += len(m.XXX_unrecognized)
30612 }
30613 return n
30614 }
30615
30616 func (m *CustomNameNinStruct) Size() (n int) {
30617 if m == nil {
30618 return 0
30619 }
30620 var l int
30621 _ = l
30622 if m.FieldA != nil {
30623 n += 9
30624 }
30625 if m.FieldB != nil {
30626 n += 5
30627 }
30628 if m.FieldC != nil {
30629 l = m.FieldC.Size()
30630 n += 1 + l + sovThetest(uint64(l))
30631 }
30632 if len(m.FieldD) > 0 {
30633 for _, e := range m.FieldD {
30634 l = e.Size()
30635 n += 1 + l + sovThetest(uint64(l))
30636 }
30637 }
30638 if m.FieldE != nil {
30639 n += 1 + sovThetest(uint64(*m.FieldE))
30640 }
30641 if m.FieldF != nil {
30642 n += 1 + sozThetest(uint64(*m.FieldF))
30643 }
30644 if m.FieldG != nil {
30645 l = m.FieldG.Size()
30646 n += 1 + l + sovThetest(uint64(l))
30647 }
30648 if m.FieldH != nil {
30649 n += 2
30650 }
30651 if m.FieldI != nil {
30652 l = len(*m.FieldI)
30653 n += 1 + l + sovThetest(uint64(l))
30654 }
30655 if m.FieldJ != nil {
30656 l = len(m.FieldJ)
30657 n += 1 + l + sovThetest(uint64(l))
30658 }
30659 if m.XXX_unrecognized != nil {
30660 n += len(m.XXX_unrecognized)
30661 }
30662 return n
30663 }
30664
30665 func (m *CustomNameCustomType) Size() (n int) {
30666 if m == nil {
30667 return 0
30668 }
30669 var l int
30670 _ = l
30671 if m.FieldA != nil {
30672 l = m.FieldA.Size()
30673 n += 1 + l + sovThetest(uint64(l))
30674 }
30675 if m.FieldB != nil {
30676 l = m.FieldB.Size()
30677 n += 1 + l + sovThetest(uint64(l))
30678 }
30679 if len(m.FieldC) > 0 {
30680 for _, e := range m.FieldC {
30681 l = e.Size()
30682 n += 1 + l + sovThetest(uint64(l))
30683 }
30684 }
30685 if len(m.FieldD) > 0 {
30686 for _, e := range m.FieldD {
30687 l = e.Size()
30688 n += 1 + l + sovThetest(uint64(l))
30689 }
30690 }
30691 if m.XXX_unrecognized != nil {
30692 n += len(m.XXX_unrecognized)
30693 }
30694 return n
30695 }
30696
30697 func (m *CustomNameNinEmbeddedStructUnion) Size() (n int) {
30698 if m == nil {
30699 return 0
30700 }
30701 var l int
30702 _ = l
30703 if m.NidOptNative != nil {
30704 l = m.NidOptNative.Size()
30705 n += 1 + l + sovThetest(uint64(l))
30706 }
30707 if m.FieldA != nil {
30708 l = m.FieldA.Size()
30709 n += 2 + l + sovThetest(uint64(l))
30710 }
30711 if m.FieldB != nil {
30712 n += 3
30713 }
30714 if m.XXX_unrecognized != nil {
30715 n += len(m.XXX_unrecognized)
30716 }
30717 return n
30718 }
30719
30720 func (m *CustomNameEnum) Size() (n int) {
30721 if m == nil {
30722 return 0
30723 }
30724 var l int
30725 _ = l
30726 if m.FieldA != nil {
30727 n += 1 + sovThetest(uint64(*m.FieldA))
30728 }
30729 if len(m.FieldB) > 0 {
30730 for _, e := range m.FieldB {
30731 n += 1 + sovThetest(uint64(e))
30732 }
30733 }
30734 if m.XXX_unrecognized != nil {
30735 n += len(m.XXX_unrecognized)
30736 }
30737 return n
30738 }
30739
30740 func (m *NoExtensionsMap) Size() (n int) {
30741 if m == nil {
30742 return 0
30743 }
30744 var l int
30745 _ = l
30746 if m.Field1 != nil {
30747 n += 1 + sovThetest(uint64(*m.Field1))
30748 }
30749 if m.XXX_extensions != nil {
30750 n += len(m.XXX_extensions)
30751 }
30752 if m.XXX_unrecognized != nil {
30753 n += len(m.XXX_unrecognized)
30754 }
30755 return n
30756 }
30757
30758 func (m *Unrecognized) Size() (n int) {
30759 if m == nil {
30760 return 0
30761 }
30762 var l int
30763 _ = l
30764 if m.Field1 != nil {
30765 l = len(*m.Field1)
30766 n += 1 + l + sovThetest(uint64(l))
30767 }
30768 return n
30769 }
30770
30771 func (m *UnrecognizedWithInner) Size() (n int) {
30772 if m == nil {
30773 return 0
30774 }
30775 var l int
30776 _ = l
30777 if len(m.Embedded) > 0 {
30778 for _, e := range m.Embedded {
30779 l = e.Size()
30780 n += 1 + l + sovThetest(uint64(l))
30781 }
30782 }
30783 if m.Field2 != nil {
30784 l = len(*m.Field2)
30785 n += 1 + l + sovThetest(uint64(l))
30786 }
30787 if m.XXX_unrecognized != nil {
30788 n += len(m.XXX_unrecognized)
30789 }
30790 return n
30791 }
30792
30793 func (m *UnrecognizedWithInner_Inner) Size() (n int) {
30794 if m == nil {
30795 return 0
30796 }
30797 var l int
30798 _ = l
30799 if m.Field1 != nil {
30800 n += 1 + sovThetest(uint64(*m.Field1))
30801 }
30802 return n
30803 }
30804
30805 func (m *UnrecognizedWithEmbed) Size() (n int) {
30806 if m == nil {
30807 return 0
30808 }
30809 var l int
30810 _ = l
30811 l = m.UnrecognizedWithEmbed_Embedded.Size()
30812 n += 1 + l + sovThetest(uint64(l))
30813 if m.Field2 != nil {
30814 l = len(*m.Field2)
30815 n += 1 + l + sovThetest(uint64(l))
30816 }
30817 if m.XXX_unrecognized != nil {
30818 n += len(m.XXX_unrecognized)
30819 }
30820 return n
30821 }
30822
30823 func (m *UnrecognizedWithEmbed_Embedded) Size() (n int) {
30824 if m == nil {
30825 return 0
30826 }
30827 var l int
30828 _ = l
30829 if m.Field1 != nil {
30830 n += 1 + sovThetest(uint64(*m.Field1))
30831 }
30832 return n
30833 }
30834
30835 func (m *Node) Size() (n int) {
30836 if m == nil {
30837 return 0
30838 }
30839 var l int
30840 _ = l
30841 if m.Label != nil {
30842 l = len(*m.Label)
30843 n += 1 + l + sovThetest(uint64(l))
30844 }
30845 if len(m.Children) > 0 {
30846 for _, e := range m.Children {
30847 l = e.Size()
30848 n += 1 + l + sovThetest(uint64(l))
30849 }
30850 }
30851 if m.XXX_unrecognized != nil {
30852 n += len(m.XXX_unrecognized)
30853 }
30854 return n
30855 }
30856
30857 func (m *NonByteCustomType) Size() (n int) {
30858 if m == nil {
30859 return 0
30860 }
30861 var l int
30862 _ = l
30863 if m.Field1 != nil {
30864 l = m.Field1.Size()
30865 n += 1 + l + sovThetest(uint64(l))
30866 }
30867 if m.XXX_unrecognized != nil {
30868 n += len(m.XXX_unrecognized)
30869 }
30870 return n
30871 }
30872
30873 func (m *NidOptNonByteCustomType) Size() (n int) {
30874 if m == nil {
30875 return 0
30876 }
30877 var l int
30878 _ = l
30879 l = m.Field1.Size()
30880 n += 1 + l + sovThetest(uint64(l))
30881 if m.XXX_unrecognized != nil {
30882 n += len(m.XXX_unrecognized)
30883 }
30884 return n
30885 }
30886
30887 func (m *NinOptNonByteCustomType) Size() (n int) {
30888 if m == nil {
30889 return 0
30890 }
30891 var l int
30892 _ = l
30893 if m.Field1 != nil {
30894 l = m.Field1.Size()
30895 n += 1 + l + sovThetest(uint64(l))
30896 }
30897 if m.XXX_unrecognized != nil {
30898 n += len(m.XXX_unrecognized)
30899 }
30900 return n
30901 }
30902
30903 func (m *NidRepNonByteCustomType) Size() (n int) {
30904 if m == nil {
30905 return 0
30906 }
30907 var l int
30908 _ = l
30909 if len(m.Field1) > 0 {
30910 for _, e := range m.Field1 {
30911 l = e.Size()
30912 n += 1 + l + sovThetest(uint64(l))
30913 }
30914 }
30915 if m.XXX_unrecognized != nil {
30916 n += len(m.XXX_unrecognized)
30917 }
30918 return n
30919 }
30920
30921 func (m *NinRepNonByteCustomType) Size() (n int) {
30922 if m == nil {
30923 return 0
30924 }
30925 var l int
30926 _ = l
30927 if len(m.Field1) > 0 {
30928 for _, e := range m.Field1 {
30929 l = e.Size()
30930 n += 1 + l + sovThetest(uint64(l))
30931 }
30932 }
30933 if m.XXX_unrecognized != nil {
30934 n += len(m.XXX_unrecognized)
30935 }
30936 return n
30937 }
30938
30939 func (m *ProtoType) Size() (n int) {
30940 if m == nil {
30941 return 0
30942 }
30943 var l int
30944 _ = l
30945 if m.Field2 != nil {
30946 l = len(*m.Field2)
30947 n += 1 + l + sovThetest(uint64(l))
30948 }
30949 if m.XXX_unrecognized != nil {
30950 n += len(m.XXX_unrecognized)
30951 }
30952 return n
30953 }
30954
30955 func sovThetest(x uint64) (n int) {
30956 return (math_bits.Len64(x|1) + 6) / 7
30957 }
30958 func sozThetest(x uint64) (n int) {
30959 return sovThetest(uint64((x << 1) ^ uint64((int64(x) >> 63))))
30960 }
30961 func (this *NidOptNative) String() string {
30962 if this == nil {
30963 return "nil"
30964 }
30965 s := strings.Join([]string{`&NidOptNative{`,
30966 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
30967 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
30968 `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
30969 `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`,
30970 `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`,
30971 `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
30972 `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
30973 `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`,
30974 `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`,
30975 `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`,
30976 `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`,
30977 `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`,
30978 `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
30979 `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`,
30980 `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`,
30981 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
30982 `}`,
30983 }, "")
30984 return s
30985 }
30986 func (this *NinOptNative) String() string {
30987 if this == nil {
30988 return "nil"
30989 }
30990 s := strings.Join([]string{`&NinOptNative{`,
30991 `Field1:` + valueToStringThetest(this.Field1) + `,`,
30992 `Field2:` + valueToStringThetest(this.Field2) + `,`,
30993 `Field3:` + valueToStringThetest(this.Field3) + `,`,
30994 `Field4:` + valueToStringThetest(this.Field4) + `,`,
30995 `Field5:` + valueToStringThetest(this.Field5) + `,`,
30996 `Field6:` + valueToStringThetest(this.Field6) + `,`,
30997 `Field7:` + valueToStringThetest(this.Field7) + `,`,
30998 `Field8:` + valueToStringThetest(this.Field8) + `,`,
30999 `Field9:` + valueToStringThetest(this.Field9) + `,`,
31000 `Field10:` + valueToStringThetest(this.Field10) + `,`,
31001 `Field11:` + valueToStringThetest(this.Field11) + `,`,
31002 `Field12:` + valueToStringThetest(this.Field12) + `,`,
31003 `Field13:` + valueToStringThetest(this.Field13) + `,`,
31004 `Field14:` + valueToStringThetest(this.Field14) + `,`,
31005 `Field15:` + valueToStringThetest(this.Field15) + `,`,
31006 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31007 `}`,
31008 }, "")
31009 return s
31010 }
31011 func (this *NidRepNative) String() string {
31012 if this == nil {
31013 return "nil"
31014 }
31015 s := strings.Join([]string{`&NidRepNative{`,
31016 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31017 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
31018 `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
31019 `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`,
31020 `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`,
31021 `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
31022 `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
31023 `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`,
31024 `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`,
31025 `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`,
31026 `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`,
31027 `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`,
31028 `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
31029 `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`,
31030 `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`,
31031 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31032 `}`,
31033 }, "")
31034 return s
31035 }
31036 func (this *NinRepNative) String() string {
31037 if this == nil {
31038 return "nil"
31039 }
31040 s := strings.Join([]string{`&NinRepNative{`,
31041 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31042 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
31043 `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
31044 `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`,
31045 `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`,
31046 `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
31047 `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
31048 `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`,
31049 `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`,
31050 `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`,
31051 `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`,
31052 `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`,
31053 `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
31054 `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`,
31055 `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`,
31056 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31057 `}`,
31058 }, "")
31059 return s
31060 }
31061 func (this *NidRepPackedNative) String() string {
31062 if this == nil {
31063 return "nil"
31064 }
31065 s := strings.Join([]string{`&NidRepPackedNative{`,
31066 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31067 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
31068 `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
31069 `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`,
31070 `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`,
31071 `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
31072 `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
31073 `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`,
31074 `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`,
31075 `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`,
31076 `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`,
31077 `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`,
31078 `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
31079 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31080 `}`,
31081 }, "")
31082 return s
31083 }
31084 func (this *NinRepPackedNative) String() string {
31085 if this == nil {
31086 return "nil"
31087 }
31088 s := strings.Join([]string{`&NinRepPackedNative{`,
31089 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31090 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
31091 `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
31092 `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`,
31093 `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`,
31094 `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
31095 `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
31096 `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`,
31097 `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`,
31098 `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`,
31099 `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`,
31100 `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`,
31101 `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
31102 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31103 `}`,
31104 }, "")
31105 return s
31106 }
31107 func (this *NidOptStruct) String() string {
31108 if this == nil {
31109 return "nil"
31110 }
31111 s := strings.Join([]string{`&NidOptStruct{`,
31112 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31113 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
31114 `Field3:` + strings.Replace(strings.Replace(this.Field3.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`,
31115 `Field4:` + strings.Replace(strings.Replace(this.Field4.String(), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`,
31116 `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
31117 `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
31118 `Field8:` + strings.Replace(strings.Replace(this.Field8.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`,
31119 `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
31120 `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`,
31121 `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`,
31122 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31123 `}`,
31124 }, "")
31125 return s
31126 }
31127 func (this *NinOptStruct) String() string {
31128 if this == nil {
31129 return "nil"
31130 }
31131 s := strings.Join([]string{`&NinOptStruct{`,
31132 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31133 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31134 `Field3:` + strings.Replace(this.Field3.String(), "NidOptNative", "NidOptNative", 1) + `,`,
31135 `Field4:` + strings.Replace(this.Field4.String(), "NinOptNative", "NinOptNative", 1) + `,`,
31136 `Field6:` + valueToStringThetest(this.Field6) + `,`,
31137 `Field7:` + valueToStringThetest(this.Field7) + `,`,
31138 `Field8:` + strings.Replace(this.Field8.String(), "NidOptNative", "NidOptNative", 1) + `,`,
31139 `Field13:` + valueToStringThetest(this.Field13) + `,`,
31140 `Field14:` + valueToStringThetest(this.Field14) + `,`,
31141 `Field15:` + valueToStringThetest(this.Field15) + `,`,
31142 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31143 `}`,
31144 }, "")
31145 return s
31146 }
31147 func (this *NidRepStruct) String() string {
31148 if this == nil {
31149 return "nil"
31150 }
31151 repeatedStringForField3 := "[]NidOptNative{"
31152 for _, f := range this.Field3 {
31153 repeatedStringForField3 += strings.Replace(strings.Replace(f.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + ","
31154 }
31155 repeatedStringForField3 += "}"
31156 repeatedStringForField4 := "[]NinOptNative{"
31157 for _, f := range this.Field4 {
31158 repeatedStringForField4 += strings.Replace(strings.Replace(f.String(), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + ","
31159 }
31160 repeatedStringForField4 += "}"
31161 repeatedStringForField8 := "[]NidOptNative{"
31162 for _, f := range this.Field8 {
31163 repeatedStringForField8 += strings.Replace(strings.Replace(f.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + ","
31164 }
31165 repeatedStringForField8 += "}"
31166 s := strings.Join([]string{`&NidRepStruct{`,
31167 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31168 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
31169 `Field3:` + repeatedStringForField3 + `,`,
31170 `Field4:` + repeatedStringForField4 + `,`,
31171 `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
31172 `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
31173 `Field8:` + repeatedStringForField8 + `,`,
31174 `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
31175 `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`,
31176 `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`,
31177 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31178 `}`,
31179 }, "")
31180 return s
31181 }
31182 func (this *NinRepStruct) String() string {
31183 if this == nil {
31184 return "nil"
31185 }
31186 repeatedStringForField3 := "[]*NidOptNative{"
31187 for _, f := range this.Field3 {
31188 repeatedStringForField3 += strings.Replace(f.String(), "NidOptNative", "NidOptNative", 1) + ","
31189 }
31190 repeatedStringForField3 += "}"
31191 repeatedStringForField4 := "[]*NinOptNative{"
31192 for _, f := range this.Field4 {
31193 repeatedStringForField4 += strings.Replace(f.String(), "NinOptNative", "NinOptNative", 1) + ","
31194 }
31195 repeatedStringForField4 += "}"
31196 repeatedStringForField8 := "[]*NidOptNative{"
31197 for _, f := range this.Field8 {
31198 repeatedStringForField8 += strings.Replace(f.String(), "NidOptNative", "NidOptNative", 1) + ","
31199 }
31200 repeatedStringForField8 += "}"
31201 s := strings.Join([]string{`&NinRepStruct{`,
31202 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31203 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
31204 `Field3:` + repeatedStringForField3 + `,`,
31205 `Field4:` + repeatedStringForField4 + `,`,
31206 `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
31207 `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
31208 `Field8:` + repeatedStringForField8 + `,`,
31209 `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
31210 `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`,
31211 `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`,
31212 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31213 `}`,
31214 }, "")
31215 return s
31216 }
31217 func (this *NidEmbeddedStruct) String() string {
31218 if this == nil {
31219 return "nil"
31220 }
31221 s := strings.Join([]string{`&NidEmbeddedStruct{`,
31222 `NidOptNative:` + strings.Replace(this.NidOptNative.String(), "NidOptNative", "NidOptNative", 1) + `,`,
31223 `Field200:` + strings.Replace(strings.Replace(this.Field200.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`,
31224 `Field210:` + fmt.Sprintf("%v", this.Field210) + `,`,
31225 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31226 `}`,
31227 }, "")
31228 return s
31229 }
31230 func (this *NinEmbeddedStruct) String() string {
31231 if this == nil {
31232 return "nil"
31233 }
31234 s := strings.Join([]string{`&NinEmbeddedStruct{`,
31235 `NidOptNative:` + strings.Replace(this.NidOptNative.String(), "NidOptNative", "NidOptNative", 1) + `,`,
31236 `Field200:` + strings.Replace(this.Field200.String(), "NidOptNative", "NidOptNative", 1) + `,`,
31237 `Field210:` + valueToStringThetest(this.Field210) + `,`,
31238 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31239 `}`,
31240 }, "")
31241 return s
31242 }
31243 func (this *NidNestedStruct) String() string {
31244 if this == nil {
31245 return "nil"
31246 }
31247 repeatedStringForField2 := "[]NidRepStruct{"
31248 for _, f := range this.Field2 {
31249 repeatedStringForField2 += strings.Replace(strings.Replace(f.String(), "NidRepStruct", "NidRepStruct", 1), `&`, ``, 1) + ","
31250 }
31251 repeatedStringForField2 += "}"
31252 s := strings.Join([]string{`&NidNestedStruct{`,
31253 `Field1:` + strings.Replace(strings.Replace(this.Field1.String(), "NidOptStruct", "NidOptStruct", 1), `&`, ``, 1) + `,`,
31254 `Field2:` + repeatedStringForField2 + `,`,
31255 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31256 `}`,
31257 }, "")
31258 return s
31259 }
31260 func (this *NinNestedStruct) String() string {
31261 if this == nil {
31262 return "nil"
31263 }
31264 repeatedStringForField2 := "[]*NinRepStruct{"
31265 for _, f := range this.Field2 {
31266 repeatedStringForField2 += strings.Replace(f.String(), "NinRepStruct", "NinRepStruct", 1) + ","
31267 }
31268 repeatedStringForField2 += "}"
31269 s := strings.Join([]string{`&NinNestedStruct{`,
31270 `Field1:` + strings.Replace(this.Field1.String(), "NinOptStruct", "NinOptStruct", 1) + `,`,
31271 `Field2:` + repeatedStringForField2 + `,`,
31272 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31273 `}`,
31274 }, "")
31275 return s
31276 }
31277 func (this *NidOptCustom) String() string {
31278 if this == nil {
31279 return "nil"
31280 }
31281 s := strings.Join([]string{`&NidOptCustom{`,
31282 `Id:` + fmt.Sprintf("%v", this.Id) + `,`,
31283 `Value:` + fmt.Sprintf("%v", this.Value) + `,`,
31284 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31285 `}`,
31286 }, "")
31287 return s
31288 }
31289 func (this *CustomDash) String() string {
31290 if this == nil {
31291 return "nil"
31292 }
31293 s := strings.Join([]string{`&CustomDash{`,
31294 `Value:` + valueToStringThetest(this.Value) + `,`,
31295 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31296 `}`,
31297 }, "")
31298 return s
31299 }
31300 func (this *NinOptCustom) String() string {
31301 if this == nil {
31302 return "nil"
31303 }
31304 s := strings.Join([]string{`&NinOptCustom{`,
31305 `Id:` + valueToStringThetest(this.Id) + `,`,
31306 `Value:` + valueToStringThetest(this.Value) + `,`,
31307 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31308 `}`,
31309 }, "")
31310 return s
31311 }
31312 func (this *NidRepCustom) String() string {
31313 if this == nil {
31314 return "nil"
31315 }
31316 s := strings.Join([]string{`&NidRepCustom{`,
31317 `Id:` + fmt.Sprintf("%v", this.Id) + `,`,
31318 `Value:` + fmt.Sprintf("%v", this.Value) + `,`,
31319 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31320 `}`,
31321 }, "")
31322 return s
31323 }
31324 func (this *NinRepCustom) String() string {
31325 if this == nil {
31326 return "nil"
31327 }
31328 s := strings.Join([]string{`&NinRepCustom{`,
31329 `Id:` + fmt.Sprintf("%v", this.Id) + `,`,
31330 `Value:` + fmt.Sprintf("%v", this.Value) + `,`,
31331 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31332 `}`,
31333 }, "")
31334 return s
31335 }
31336 func (this *NinOptNativeUnion) String() string {
31337 if this == nil {
31338 return "nil"
31339 }
31340 s := strings.Join([]string{`&NinOptNativeUnion{`,
31341 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31342 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31343 `Field3:` + valueToStringThetest(this.Field3) + `,`,
31344 `Field4:` + valueToStringThetest(this.Field4) + `,`,
31345 `Field5:` + valueToStringThetest(this.Field5) + `,`,
31346 `Field6:` + valueToStringThetest(this.Field6) + `,`,
31347 `Field13:` + valueToStringThetest(this.Field13) + `,`,
31348 `Field14:` + valueToStringThetest(this.Field14) + `,`,
31349 `Field15:` + valueToStringThetest(this.Field15) + `,`,
31350 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31351 `}`,
31352 }, "")
31353 return s
31354 }
31355 func (this *NinOptStructUnion) String() string {
31356 if this == nil {
31357 return "nil"
31358 }
31359 s := strings.Join([]string{`&NinOptStructUnion{`,
31360 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31361 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31362 `Field3:` + strings.Replace(this.Field3.String(), "NidOptNative", "NidOptNative", 1) + `,`,
31363 `Field4:` + strings.Replace(this.Field4.String(), "NinOptNative", "NinOptNative", 1) + `,`,
31364 `Field6:` + valueToStringThetest(this.Field6) + `,`,
31365 `Field7:` + valueToStringThetest(this.Field7) + `,`,
31366 `Field13:` + valueToStringThetest(this.Field13) + `,`,
31367 `Field14:` + valueToStringThetest(this.Field14) + `,`,
31368 `Field15:` + valueToStringThetest(this.Field15) + `,`,
31369 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31370 `}`,
31371 }, "")
31372 return s
31373 }
31374 func (this *NinEmbeddedStructUnion) String() string {
31375 if this == nil {
31376 return "nil"
31377 }
31378 s := strings.Join([]string{`&NinEmbeddedStructUnion{`,
31379 `NidOptNative:` + strings.Replace(this.NidOptNative.String(), "NidOptNative", "NidOptNative", 1) + `,`,
31380 `Field200:` + strings.Replace(this.Field200.String(), "NinOptNative", "NinOptNative", 1) + `,`,
31381 `Field210:` + valueToStringThetest(this.Field210) + `,`,
31382 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31383 `}`,
31384 }, "")
31385 return s
31386 }
31387 func (this *NinNestedStructUnion) String() string {
31388 if this == nil {
31389 return "nil"
31390 }
31391 s := strings.Join([]string{`&NinNestedStructUnion{`,
31392 `Field1:` + strings.Replace(this.Field1.String(), "NinOptNativeUnion", "NinOptNativeUnion", 1) + `,`,
31393 `Field2:` + strings.Replace(this.Field2.String(), "NinOptStructUnion", "NinOptStructUnion", 1) + `,`,
31394 `Field3:` + strings.Replace(this.Field3.String(), "NinEmbeddedStructUnion", "NinEmbeddedStructUnion", 1) + `,`,
31395 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31396 `}`,
31397 }, "")
31398 return s
31399 }
31400 func (this *Tree) String() string {
31401 if this == nil {
31402 return "nil"
31403 }
31404 s := strings.Join([]string{`&Tree{`,
31405 `Or:` + strings.Replace(this.Or.String(), "OrBranch", "OrBranch", 1) + `,`,
31406 `And:` + strings.Replace(this.And.String(), "AndBranch", "AndBranch", 1) + `,`,
31407 `Leaf:` + strings.Replace(this.Leaf.String(), "Leaf", "Leaf", 1) + `,`,
31408 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31409 `}`,
31410 }, "")
31411 return s
31412 }
31413 func (this *OrBranch) String() string {
31414 if this == nil {
31415 return "nil"
31416 }
31417 s := strings.Join([]string{`&OrBranch{`,
31418 `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`,
31419 `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`,
31420 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31421 `}`,
31422 }, "")
31423 return s
31424 }
31425 func (this *AndBranch) String() string {
31426 if this == nil {
31427 return "nil"
31428 }
31429 s := strings.Join([]string{`&AndBranch{`,
31430 `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`,
31431 `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`,
31432 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31433 `}`,
31434 }, "")
31435 return s
31436 }
31437 func (this *Leaf) String() string {
31438 if this == nil {
31439 return "nil"
31440 }
31441 s := strings.Join([]string{`&Leaf{`,
31442 `Value:` + fmt.Sprintf("%v", this.Value) + `,`,
31443 `StrValue:` + fmt.Sprintf("%v", this.StrValue) + `,`,
31444 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31445 `}`,
31446 }, "")
31447 return s
31448 }
31449 func (this *DeepTree) String() string {
31450 if this == nil {
31451 return "nil"
31452 }
31453 s := strings.Join([]string{`&DeepTree{`,
31454 `Down:` + strings.Replace(this.Down.String(), "ADeepBranch", "ADeepBranch", 1) + `,`,
31455 `And:` + strings.Replace(this.And.String(), "AndDeepBranch", "AndDeepBranch", 1) + `,`,
31456 `Leaf:` + strings.Replace(this.Leaf.String(), "DeepLeaf", "DeepLeaf", 1) + `,`,
31457 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31458 `}`,
31459 }, "")
31460 return s
31461 }
31462 func (this *ADeepBranch) String() string {
31463 if this == nil {
31464 return "nil"
31465 }
31466 s := strings.Join([]string{`&ADeepBranch{`,
31467 `Down:` + strings.Replace(strings.Replace(this.Down.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`,
31468 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31469 `}`,
31470 }, "")
31471 return s
31472 }
31473 func (this *AndDeepBranch) String() string {
31474 if this == nil {
31475 return "nil"
31476 }
31477 s := strings.Join([]string{`&AndDeepBranch{`,
31478 `Left:` + strings.Replace(strings.Replace(this.Left.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`,
31479 `Right:` + strings.Replace(strings.Replace(this.Right.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`,
31480 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31481 `}`,
31482 }, "")
31483 return s
31484 }
31485 func (this *DeepLeaf) String() string {
31486 if this == nil {
31487 return "nil"
31488 }
31489 s := strings.Join([]string{`&DeepLeaf{`,
31490 `Tree:` + strings.Replace(strings.Replace(this.Tree.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`,
31491 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31492 `}`,
31493 }, "")
31494 return s
31495 }
31496 func (this *Nil) String() string {
31497 if this == nil {
31498 return "nil"
31499 }
31500 s := strings.Join([]string{`&Nil{`,
31501 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31502 `}`,
31503 }, "")
31504 return s
31505 }
31506 func (this *NidOptEnum) String() string {
31507 if this == nil {
31508 return "nil"
31509 }
31510 s := strings.Join([]string{`&NidOptEnum{`,
31511 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31512 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31513 `}`,
31514 }, "")
31515 return s
31516 }
31517 func (this *NinOptEnum) String() string {
31518 if this == nil {
31519 return "nil"
31520 }
31521 s := strings.Join([]string{`&NinOptEnum{`,
31522 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31523 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31524 `Field3:` + valueToStringThetest(this.Field3) + `,`,
31525 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31526 `}`,
31527 }, "")
31528 return s
31529 }
31530 func (this *NidRepEnum) String() string {
31531 if this == nil {
31532 return "nil"
31533 }
31534 s := strings.Join([]string{`&NidRepEnum{`,
31535 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31536 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
31537 `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
31538 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31539 `}`,
31540 }, "")
31541 return s
31542 }
31543 func (this *NinRepEnum) String() string {
31544 if this == nil {
31545 return "nil"
31546 }
31547 s := strings.Join([]string{`&NinRepEnum{`,
31548 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31549 `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
31550 `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
31551 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31552 `}`,
31553 }, "")
31554 return s
31555 }
31556 func (this *NinOptEnumDefault) String() string {
31557 if this == nil {
31558 return "nil"
31559 }
31560 s := strings.Join([]string{`&NinOptEnumDefault{`,
31561 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31562 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31563 `Field3:` + valueToStringThetest(this.Field3) + `,`,
31564 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31565 `}`,
31566 }, "")
31567 return s
31568 }
31569 func (this *AnotherNinOptEnum) String() string {
31570 if this == nil {
31571 return "nil"
31572 }
31573 s := strings.Join([]string{`&AnotherNinOptEnum{`,
31574 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31575 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31576 `Field3:` + valueToStringThetest(this.Field3) + `,`,
31577 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31578 `}`,
31579 }, "")
31580 return s
31581 }
31582 func (this *AnotherNinOptEnumDefault) String() string {
31583 if this == nil {
31584 return "nil"
31585 }
31586 s := strings.Join([]string{`&AnotherNinOptEnumDefault{`,
31587 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31588 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31589 `Field3:` + valueToStringThetest(this.Field3) + `,`,
31590 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31591 `}`,
31592 }, "")
31593 return s
31594 }
31595 func (this *Timer) String() string {
31596 if this == nil {
31597 return "nil"
31598 }
31599 s := strings.Join([]string{`&Timer{`,
31600 `Time1:` + fmt.Sprintf("%v", this.Time1) + `,`,
31601 `Time2:` + fmt.Sprintf("%v", this.Time2) + `,`,
31602 `Data:` + fmt.Sprintf("%v", this.Data) + `,`,
31603 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31604 `}`,
31605 }, "")
31606 return s
31607 }
31608 func (this *MyExtendable) String() string {
31609 if this == nil {
31610 return "nil"
31611 }
31612 s := strings.Join([]string{`&MyExtendable{`,
31613 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31614 `XXX_InternalExtensions:` + github_com_gogo_protobuf_proto.StringFromInternalExtension(this) + `,`,
31615 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31616 `}`,
31617 }, "")
31618 return s
31619 }
31620 func (this *OtherExtenable) String() string {
31621 if this == nil {
31622 return "nil"
31623 }
31624 s := strings.Join([]string{`&OtherExtenable{`,
31625 `M:` + strings.Replace(this.M.String(), "MyExtendable", "MyExtendable", 1) + `,`,
31626 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31627 `Field13:` + valueToStringThetest(this.Field13) + `,`,
31628 `XXX_InternalExtensions:` + github_com_gogo_protobuf_proto.StringFromInternalExtension(this) + `,`,
31629 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31630 `}`,
31631 }, "")
31632 return s
31633 }
31634 func (this *NestedDefinition) String() string {
31635 if this == nil {
31636 return "nil"
31637 }
31638 s := strings.Join([]string{`&NestedDefinition{`,
31639 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31640 `EnumField:` + valueToStringThetest(this.EnumField) + `,`,
31641 `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`,
31642 `NM:` + strings.Replace(fmt.Sprintf("%v", this.NM), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`,
31643 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31644 `}`,
31645 }, "")
31646 return s
31647 }
31648 func (this *NestedDefinition_NestedMessage) String() string {
31649 if this == nil {
31650 return "nil"
31651 }
31652 s := strings.Join([]string{`&NestedDefinition_NestedMessage{`,
31653 `NestedField1:` + valueToStringThetest(this.NestedField1) + `,`,
31654 `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`,
31655 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31656 `}`,
31657 }, "")
31658 return s
31659 }
31660 func (this *NestedDefinition_NestedMessage_NestedNestedMsg) String() string {
31661 if this == nil {
31662 return "nil"
31663 }
31664 s := strings.Join([]string{`&NestedDefinition_NestedMessage_NestedNestedMsg{`,
31665 `NestedNestedField1:` + valueToStringThetest(this.NestedNestedField1) + `,`,
31666 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31667 `}`,
31668 }, "")
31669 return s
31670 }
31671 func (this *NestedScope) String() string {
31672 if this == nil {
31673 return "nil"
31674 }
31675 s := strings.Join([]string{`&NestedScope{`,
31676 `A:` + strings.Replace(fmt.Sprintf("%v", this.A), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`,
31677 `B:` + valueToStringThetest(this.B) + `,`,
31678 `C:` + strings.Replace(fmt.Sprintf("%v", this.C), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`,
31679 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31680 `}`,
31681 }, "")
31682 return s
31683 }
31684 func (this *NinOptNativeDefault) String() string {
31685 if this == nil {
31686 return "nil"
31687 }
31688 s := strings.Join([]string{`&NinOptNativeDefault{`,
31689 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31690 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31691 `Field3:` + valueToStringThetest(this.Field3) + `,`,
31692 `Field4:` + valueToStringThetest(this.Field4) + `,`,
31693 `Field5:` + valueToStringThetest(this.Field5) + `,`,
31694 `Field6:` + valueToStringThetest(this.Field6) + `,`,
31695 `Field7:` + valueToStringThetest(this.Field7) + `,`,
31696 `Field8:` + valueToStringThetest(this.Field8) + `,`,
31697 `Field9:` + valueToStringThetest(this.Field9) + `,`,
31698 `Field10:` + valueToStringThetest(this.Field10) + `,`,
31699 `Field11:` + valueToStringThetest(this.Field11) + `,`,
31700 `Field12:` + valueToStringThetest(this.Field12) + `,`,
31701 `Field13:` + valueToStringThetest(this.Field13) + `,`,
31702 `Field14:` + valueToStringThetest(this.Field14) + `,`,
31703 `Field15:` + valueToStringThetest(this.Field15) + `,`,
31704 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31705 `}`,
31706 }, "")
31707 return s
31708 }
31709 func (this *CustomContainer) String() string {
31710 if this == nil {
31711 return "nil"
31712 }
31713 s := strings.Join([]string{`&CustomContainer{`,
31714 `CustomStruct:` + strings.Replace(strings.Replace(this.CustomStruct.String(), "NidOptCustom", "NidOptCustom", 1), `&`, ``, 1) + `,`,
31715 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31716 `}`,
31717 }, "")
31718 return s
31719 }
31720 func (this *CustomNameNidOptNative) String() string {
31721 if this == nil {
31722 return "nil"
31723 }
31724 s := strings.Join([]string{`&CustomNameNidOptNative{`,
31725 `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`,
31726 `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`,
31727 `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`,
31728 `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`,
31729 `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`,
31730 `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`,
31731 `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`,
31732 `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`,
31733 `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`,
31734 `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`,
31735 `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`,
31736 `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`,
31737 `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`,
31738 `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`,
31739 `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`,
31740 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31741 `}`,
31742 }, "")
31743 return s
31744 }
31745 func (this *CustomNameNinOptNative) String() string {
31746 if this == nil {
31747 return "nil"
31748 }
31749 s := strings.Join([]string{`&CustomNameNinOptNative{`,
31750 `FieldA:` + valueToStringThetest(this.FieldA) + `,`,
31751 `FieldB:` + valueToStringThetest(this.FieldB) + `,`,
31752 `FieldC:` + valueToStringThetest(this.FieldC) + `,`,
31753 `FieldD:` + valueToStringThetest(this.FieldD) + `,`,
31754 `FieldE:` + valueToStringThetest(this.FieldE) + `,`,
31755 `FieldF:` + valueToStringThetest(this.FieldF) + `,`,
31756 `FieldG:` + valueToStringThetest(this.FieldG) + `,`,
31757 `FieldH:` + valueToStringThetest(this.FieldH) + `,`,
31758 `FieldI:` + valueToStringThetest(this.FieldI) + `,`,
31759 `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`,
31760 `FieldK:` + valueToStringThetest(this.FieldK) + `,`,
31761 `FielL:` + valueToStringThetest(this.FielL) + `,`,
31762 `FieldM:` + valueToStringThetest(this.FieldM) + `,`,
31763 `FieldN:` + valueToStringThetest(this.FieldN) + `,`,
31764 `FieldO:` + valueToStringThetest(this.FieldO) + `,`,
31765 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31766 `}`,
31767 }, "")
31768 return s
31769 }
31770 func (this *CustomNameNinRepNative) String() string {
31771 if this == nil {
31772 return "nil"
31773 }
31774 s := strings.Join([]string{`&CustomNameNinRepNative{`,
31775 `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`,
31776 `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`,
31777 `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`,
31778 `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`,
31779 `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`,
31780 `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`,
31781 `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`,
31782 `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`,
31783 `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`,
31784 `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`,
31785 `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`,
31786 `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`,
31787 `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`,
31788 `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`,
31789 `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`,
31790 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31791 `}`,
31792 }, "")
31793 return s
31794 }
31795 func (this *CustomNameNinStruct) String() string {
31796 if this == nil {
31797 return "nil"
31798 }
31799 repeatedStringForFieldD := "[]*NinOptNative{"
31800 for _, f := range this.FieldD {
31801 repeatedStringForFieldD += strings.Replace(f.String(), "NinOptNative", "NinOptNative", 1) + ","
31802 }
31803 repeatedStringForFieldD += "}"
31804 s := strings.Join([]string{`&CustomNameNinStruct{`,
31805 `FieldA:` + valueToStringThetest(this.FieldA) + `,`,
31806 `FieldB:` + valueToStringThetest(this.FieldB) + `,`,
31807 `FieldC:` + strings.Replace(this.FieldC.String(), "NidOptNative", "NidOptNative", 1) + `,`,
31808 `FieldD:` + repeatedStringForFieldD + `,`,
31809 `FieldE:` + valueToStringThetest(this.FieldE) + `,`,
31810 `FieldF:` + valueToStringThetest(this.FieldF) + `,`,
31811 `FieldG:` + strings.Replace(this.FieldG.String(), "NidOptNative", "NidOptNative", 1) + `,`,
31812 `FieldH:` + valueToStringThetest(this.FieldH) + `,`,
31813 `FieldI:` + valueToStringThetest(this.FieldI) + `,`,
31814 `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`,
31815 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31816 `}`,
31817 }, "")
31818 return s
31819 }
31820 func (this *CustomNameCustomType) String() string {
31821 if this == nil {
31822 return "nil"
31823 }
31824 s := strings.Join([]string{`&CustomNameCustomType{`,
31825 `FieldA:` + valueToStringThetest(this.FieldA) + `,`,
31826 `FieldB:` + valueToStringThetest(this.FieldB) + `,`,
31827 `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`,
31828 `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`,
31829 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31830 `}`,
31831 }, "")
31832 return s
31833 }
31834 func (this *CustomNameNinEmbeddedStructUnion) String() string {
31835 if this == nil {
31836 return "nil"
31837 }
31838 s := strings.Join([]string{`&CustomNameNinEmbeddedStructUnion{`,
31839 `NidOptNative:` + strings.Replace(this.NidOptNative.String(), "NidOptNative", "NidOptNative", 1) + `,`,
31840 `FieldA:` + strings.Replace(this.FieldA.String(), "NinOptNative", "NinOptNative", 1) + `,`,
31841 `FieldB:` + valueToStringThetest(this.FieldB) + `,`,
31842 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31843 `}`,
31844 }, "")
31845 return s
31846 }
31847 func (this *CustomNameEnum) String() string {
31848 if this == nil {
31849 return "nil"
31850 }
31851 s := strings.Join([]string{`&CustomNameEnum{`,
31852 `FieldA:` + valueToStringThetest(this.FieldA) + `,`,
31853 `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`,
31854 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31855 `}`,
31856 }, "")
31857 return s
31858 }
31859 func (this *NoExtensionsMap) String() string {
31860 if this == nil {
31861 return "nil"
31862 }
31863 s := strings.Join([]string{`&NoExtensionsMap{`,
31864 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31865 `XXX_extensions:` + github_com_gogo_protobuf_proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`,
31866 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31867 `}`,
31868 }, "")
31869 return s
31870 }
31871 func (this *Unrecognized) String() string {
31872 if this == nil {
31873 return "nil"
31874 }
31875 s := strings.Join([]string{`&Unrecognized{`,
31876 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31877 `}`,
31878 }, "")
31879 return s
31880 }
31881 func (this *UnrecognizedWithInner) String() string {
31882 if this == nil {
31883 return "nil"
31884 }
31885 repeatedStringForEmbedded := "[]*UnrecognizedWithInner_Inner{"
31886 for _, f := range this.Embedded {
31887 repeatedStringForEmbedded += strings.Replace(fmt.Sprintf("%v", f), "UnrecognizedWithInner_Inner", "UnrecognizedWithInner_Inner", 1) + ","
31888 }
31889 repeatedStringForEmbedded += "}"
31890 s := strings.Join([]string{`&UnrecognizedWithInner{`,
31891 `Embedded:` + repeatedStringForEmbedded + `,`,
31892 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31893 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31894 `}`,
31895 }, "")
31896 return s
31897 }
31898 func (this *UnrecognizedWithInner_Inner) String() string {
31899 if this == nil {
31900 return "nil"
31901 }
31902 s := strings.Join([]string{`&UnrecognizedWithInner_Inner{`,
31903 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31904 `}`,
31905 }, "")
31906 return s
31907 }
31908 func (this *UnrecognizedWithEmbed) String() string {
31909 if this == nil {
31910 return "nil"
31911 }
31912 s := strings.Join([]string{`&UnrecognizedWithEmbed{`,
31913 `UnrecognizedWithEmbed_Embedded:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.UnrecognizedWithEmbed_Embedded), "UnrecognizedWithEmbed_Embedded", "UnrecognizedWithEmbed_Embedded", 1), `&`, ``, 1) + `,`,
31914 `Field2:` + valueToStringThetest(this.Field2) + `,`,
31915 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31916 `}`,
31917 }, "")
31918 return s
31919 }
31920 func (this *UnrecognizedWithEmbed_Embedded) String() string {
31921 if this == nil {
31922 return "nil"
31923 }
31924 s := strings.Join([]string{`&UnrecognizedWithEmbed_Embedded{`,
31925 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31926 `}`,
31927 }, "")
31928 return s
31929 }
31930 func (this *Node) String() string {
31931 if this == nil {
31932 return "nil"
31933 }
31934 repeatedStringForChildren := "[]*Node{"
31935 for _, f := range this.Children {
31936 repeatedStringForChildren += strings.Replace(f.String(), "Node", "Node", 1) + ","
31937 }
31938 repeatedStringForChildren += "}"
31939 s := strings.Join([]string{`&Node{`,
31940 `Label:` + valueToStringThetest(this.Label) + `,`,
31941 `Children:` + repeatedStringForChildren + `,`,
31942 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31943 `}`,
31944 }, "")
31945 return s
31946 }
31947 func (this *NonByteCustomType) String() string {
31948 if this == nil {
31949 return "nil"
31950 }
31951 s := strings.Join([]string{`&NonByteCustomType{`,
31952 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31953 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31954 `}`,
31955 }, "")
31956 return s
31957 }
31958 func (this *NidOptNonByteCustomType) String() string {
31959 if this == nil {
31960 return "nil"
31961 }
31962 s := strings.Join([]string{`&NidOptNonByteCustomType{`,
31963 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31964 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31965 `}`,
31966 }, "")
31967 return s
31968 }
31969 func (this *NinOptNonByteCustomType) String() string {
31970 if this == nil {
31971 return "nil"
31972 }
31973 s := strings.Join([]string{`&NinOptNonByteCustomType{`,
31974 `Field1:` + valueToStringThetest(this.Field1) + `,`,
31975 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31976 `}`,
31977 }, "")
31978 return s
31979 }
31980 func (this *NidRepNonByteCustomType) String() string {
31981 if this == nil {
31982 return "nil"
31983 }
31984 s := strings.Join([]string{`&NidRepNonByteCustomType{`,
31985 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31986 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31987 `}`,
31988 }, "")
31989 return s
31990 }
31991 func (this *NinRepNonByteCustomType) String() string {
31992 if this == nil {
31993 return "nil"
31994 }
31995 s := strings.Join([]string{`&NinRepNonByteCustomType{`,
31996 `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
31997 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
31998 `}`,
31999 }, "")
32000 return s
32001 }
32002 func (this *ProtoType) String() string {
32003 if this == nil {
32004 return "nil"
32005 }
32006 s := strings.Join([]string{`&ProtoType{`,
32007 `Field2:` + valueToStringThetest(this.Field2) + `,`,
32008 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
32009 `}`,
32010 }, "")
32011 return s
32012 }
32013 func valueToStringThetest(v interface{}) string {
32014 rv := reflect.ValueOf(v)
32015 if rv.IsNil() {
32016 return "nil"
32017 }
32018 pv := reflect.Indirect(rv).Interface()
32019 return fmt.Sprintf("*%v", pv)
32020 }
32021 func (this *NinOptNativeUnion) GetValue() interface{} {
32022 if this.Field1 != nil {
32023 return this.Field1
32024 }
32025 if this.Field2 != nil {
32026 return this.Field2
32027 }
32028 if this.Field3 != nil {
32029 return this.Field3
32030 }
32031 if this.Field4 != nil {
32032 return this.Field4
32033 }
32034 if this.Field5 != nil {
32035 return this.Field5
32036 }
32037 if this.Field6 != nil {
32038 return this.Field6
32039 }
32040 if this.Field13 != nil {
32041 return this.Field13
32042 }
32043 if this.Field14 != nil {
32044 return this.Field14
32045 }
32046 if this.Field15 != nil {
32047 return this.Field15
32048 }
32049 return nil
32050 }
32051
32052 func (this *NinOptNativeUnion) SetValue(value interface{}) bool {
32053 switch vt := value.(type) {
32054 case *float64:
32055 this.Field1 = vt
32056 case *float32:
32057 this.Field2 = vt
32058 case *int32:
32059 this.Field3 = vt
32060 case *int64:
32061 this.Field4 = vt
32062 case *uint32:
32063 this.Field5 = vt
32064 case *uint64:
32065 this.Field6 = vt
32066 case *bool:
32067 this.Field13 = vt
32068 case *string:
32069 this.Field14 = vt
32070 case []byte:
32071 this.Field15 = vt
32072 default:
32073 return false
32074 }
32075 return true
32076 }
32077 func (this *NinOptStructUnion) GetValue() interface{} {
32078 if this.Field1 != nil {
32079 return this.Field1
32080 }
32081 if this.Field2 != nil {
32082 return this.Field2
32083 }
32084 if this.Field3 != nil {
32085 return this.Field3
32086 }
32087 if this.Field4 != nil {
32088 return this.Field4
32089 }
32090 if this.Field6 != nil {
32091 return this.Field6
32092 }
32093 if this.Field7 != nil {
32094 return this.Field7
32095 }
32096 if this.Field13 != nil {
32097 return this.Field13
32098 }
32099 if this.Field14 != nil {
32100 return this.Field14
32101 }
32102 if this.Field15 != nil {
32103 return this.Field15
32104 }
32105 return nil
32106 }
32107
32108 func (this *NinOptStructUnion) SetValue(value interface{}) bool {
32109 switch vt := value.(type) {
32110 case *float64:
32111 this.Field1 = vt
32112 case *float32:
32113 this.Field2 = vt
32114 case *NidOptNative:
32115 this.Field3 = vt
32116 case *NinOptNative:
32117 this.Field4 = vt
32118 case *uint64:
32119 this.Field6 = vt
32120 case *int32:
32121 this.Field7 = vt
32122 case *bool:
32123 this.Field13 = vt
32124 case *string:
32125 this.Field14 = vt
32126 case []byte:
32127 this.Field15 = vt
32128 default:
32129 return false
32130 }
32131 return true
32132 }
32133 func (this *NinEmbeddedStructUnion) GetValue() interface{} {
32134 if this.NidOptNative != nil {
32135 return this.NidOptNative
32136 }
32137 if this.Field200 != nil {
32138 return this.Field200
32139 }
32140 if this.Field210 != nil {
32141 return this.Field210
32142 }
32143 return nil
32144 }
32145
32146 func (this *NinEmbeddedStructUnion) SetValue(value interface{}) bool {
32147 switch vt := value.(type) {
32148 case *NidOptNative:
32149 this.NidOptNative = vt
32150 case *NinOptNative:
32151 this.Field200 = vt
32152 case *bool:
32153 this.Field210 = vt
32154 default:
32155 return false
32156 }
32157 return true
32158 }
32159 func (this *NinNestedStructUnion) GetValue() interface{} {
32160 if this.Field1 != nil {
32161 return this.Field1
32162 }
32163 if this.Field2 != nil {
32164 return this.Field2
32165 }
32166 if this.Field3 != nil {
32167 return this.Field3
32168 }
32169 return nil
32170 }
32171
32172 func (this *NinNestedStructUnion) SetValue(value interface{}) bool {
32173 switch vt := value.(type) {
32174 case *NinOptNativeUnion:
32175 this.Field1 = vt
32176 case *NinOptStructUnion:
32177 this.Field2 = vt
32178 case *NinEmbeddedStructUnion:
32179 this.Field3 = vt
32180 default:
32181 this.Field1 = new(NinOptNativeUnion)
32182 if set := this.Field1.SetValue(value); set {
32183 return true
32184 }
32185 this.Field1 = nil
32186 this.Field2 = new(NinOptStructUnion)
32187 if set := this.Field2.SetValue(value); set {
32188 return true
32189 }
32190 this.Field2 = nil
32191 this.Field3 = new(NinEmbeddedStructUnion)
32192 if set := this.Field3.SetValue(value); set {
32193 return true
32194 }
32195 this.Field3 = nil
32196 return false
32197 }
32198 return true
32199 }
32200 func (this *Tree) GetValue() interface{} {
32201 if this.Or != nil {
32202 return this.Or
32203 }
32204 if this.And != nil {
32205 return this.And
32206 }
32207 if this.Leaf != nil {
32208 return this.Leaf
32209 }
32210 return nil
32211 }
32212
32213 func (this *Tree) SetValue(value interface{}) bool {
32214 switch vt := value.(type) {
32215 case *OrBranch:
32216 this.Or = vt
32217 case *AndBranch:
32218 this.And = vt
32219 case *Leaf:
32220 this.Leaf = vt
32221 default:
32222 return false
32223 }
32224 return true
32225 }
32226 func (this *DeepTree) GetValue() interface{} {
32227 if this.Down != nil {
32228 return this.Down
32229 }
32230 if this.And != nil {
32231 return this.And
32232 }
32233 if this.Leaf != nil {
32234 return this.Leaf
32235 }
32236 return nil
32237 }
32238
32239 func (this *DeepTree) SetValue(value interface{}) bool {
32240 switch vt := value.(type) {
32241 case *ADeepBranch:
32242 this.Down = vt
32243 case *AndDeepBranch:
32244 this.And = vt
32245 case *DeepLeaf:
32246 this.Leaf = vt
32247 default:
32248 return false
32249 }
32250 return true
32251 }
32252 func (this *CustomNameNinEmbeddedStructUnion) GetValue() interface{} {
32253 if this.NidOptNative != nil {
32254 return this.NidOptNative
32255 }
32256 if this.FieldA != nil {
32257 return this.FieldA
32258 }
32259 if this.FieldB != nil {
32260 return this.FieldB
32261 }
32262 return nil
32263 }
32264
32265 func (this *CustomNameNinEmbeddedStructUnion) SetValue(value interface{}) bool {
32266 switch vt := value.(type) {
32267 case *NidOptNative:
32268 this.NidOptNative = vt
32269 case *NinOptNative:
32270 this.FieldA = vt
32271 case *bool:
32272 this.FieldB = vt
32273 default:
32274 return false
32275 }
32276 return true
32277 }
32278 func (m *NidOptNative) Unmarshal(dAtA []byte) error {
32279 l := len(dAtA)
32280 iNdEx := 0
32281 for iNdEx < l {
32282 preIndex := iNdEx
32283 var wire uint64
32284 for shift := uint(0); ; shift += 7 {
32285 if shift >= 64 {
32286 return ErrIntOverflowThetest
32287 }
32288 if iNdEx >= l {
32289 return io.ErrUnexpectedEOF
32290 }
32291 b := dAtA[iNdEx]
32292 iNdEx++
32293 wire |= uint64(b&0x7F) << shift
32294 if b < 0x80 {
32295 break
32296 }
32297 }
32298 fieldNum := int32(wire >> 3)
32299 wireType := int(wire & 0x7)
32300 if wireType == 4 {
32301 return fmt.Errorf("proto: NidOptNative: wiretype end group for non-group")
32302 }
32303 if fieldNum <= 0 {
32304 return fmt.Errorf("proto: NidOptNative: illegal tag %d (wire type %d)", fieldNum, wire)
32305 }
32306 switch fieldNum {
32307 case 1:
32308 if wireType != 1 {
32309 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
32310 }
32311 var v uint64
32312 if (iNdEx + 8) > l {
32313 return io.ErrUnexpectedEOF
32314 }
32315 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
32316 iNdEx += 8
32317 m.Field1 = float64(math.Float64frombits(v))
32318 case 2:
32319 if wireType != 5 {
32320 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
32321 }
32322 var v uint32
32323 if (iNdEx + 4) > l {
32324 return io.ErrUnexpectedEOF
32325 }
32326 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
32327 iNdEx += 4
32328 m.Field2 = float32(math.Float32frombits(v))
32329 case 3:
32330 if wireType != 0 {
32331 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
32332 }
32333 m.Field3 = 0
32334 for shift := uint(0); ; shift += 7 {
32335 if shift >= 64 {
32336 return ErrIntOverflowThetest
32337 }
32338 if iNdEx >= l {
32339 return io.ErrUnexpectedEOF
32340 }
32341 b := dAtA[iNdEx]
32342 iNdEx++
32343 m.Field3 |= int32(b&0x7F) << shift
32344 if b < 0x80 {
32345 break
32346 }
32347 }
32348 case 4:
32349 if wireType != 0 {
32350 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
32351 }
32352 m.Field4 = 0
32353 for shift := uint(0); ; shift += 7 {
32354 if shift >= 64 {
32355 return ErrIntOverflowThetest
32356 }
32357 if iNdEx >= l {
32358 return io.ErrUnexpectedEOF
32359 }
32360 b := dAtA[iNdEx]
32361 iNdEx++
32362 m.Field4 |= int64(b&0x7F) << shift
32363 if b < 0x80 {
32364 break
32365 }
32366 }
32367 case 5:
32368 if wireType != 0 {
32369 return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
32370 }
32371 m.Field5 = 0
32372 for shift := uint(0); ; shift += 7 {
32373 if shift >= 64 {
32374 return ErrIntOverflowThetest
32375 }
32376 if iNdEx >= l {
32377 return io.ErrUnexpectedEOF
32378 }
32379 b := dAtA[iNdEx]
32380 iNdEx++
32381 m.Field5 |= uint32(b&0x7F) << shift
32382 if b < 0x80 {
32383 break
32384 }
32385 }
32386 case 6:
32387 if wireType != 0 {
32388 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
32389 }
32390 m.Field6 = 0
32391 for shift := uint(0); ; shift += 7 {
32392 if shift >= 64 {
32393 return ErrIntOverflowThetest
32394 }
32395 if iNdEx >= l {
32396 return io.ErrUnexpectedEOF
32397 }
32398 b := dAtA[iNdEx]
32399 iNdEx++
32400 m.Field6 |= uint64(b&0x7F) << shift
32401 if b < 0x80 {
32402 break
32403 }
32404 }
32405 case 7:
32406 if wireType != 0 {
32407 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
32408 }
32409 var v int32
32410 for shift := uint(0); ; shift += 7 {
32411 if shift >= 64 {
32412 return ErrIntOverflowThetest
32413 }
32414 if iNdEx >= l {
32415 return io.ErrUnexpectedEOF
32416 }
32417 b := dAtA[iNdEx]
32418 iNdEx++
32419 v |= int32(b&0x7F) << shift
32420 if b < 0x80 {
32421 break
32422 }
32423 }
32424 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
32425 m.Field7 = v
32426 case 8:
32427 if wireType != 0 {
32428 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
32429 }
32430 var v uint64
32431 for shift := uint(0); ; shift += 7 {
32432 if shift >= 64 {
32433 return ErrIntOverflowThetest
32434 }
32435 if iNdEx >= l {
32436 return io.ErrUnexpectedEOF
32437 }
32438 b := dAtA[iNdEx]
32439 iNdEx++
32440 v |= uint64(b&0x7F) << shift
32441 if b < 0x80 {
32442 break
32443 }
32444 }
32445 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
32446 m.Field8 = int64(v)
32447 case 9:
32448 if wireType != 5 {
32449 return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
32450 }
32451 m.Field9 = 0
32452 if (iNdEx + 4) > l {
32453 return io.ErrUnexpectedEOF
32454 }
32455 m.Field9 = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
32456 iNdEx += 4
32457 case 10:
32458 if wireType != 5 {
32459 return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
32460 }
32461 m.Field10 = 0
32462 if (iNdEx + 4) > l {
32463 return io.ErrUnexpectedEOF
32464 }
32465 m.Field10 = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
32466 iNdEx += 4
32467 case 11:
32468 if wireType != 1 {
32469 return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
32470 }
32471 m.Field11 = 0
32472 if (iNdEx + 8) > l {
32473 return io.ErrUnexpectedEOF
32474 }
32475 m.Field11 = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
32476 iNdEx += 8
32477 case 12:
32478 if wireType != 1 {
32479 return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
32480 }
32481 m.Field12 = 0
32482 if (iNdEx + 8) > l {
32483 return io.ErrUnexpectedEOF
32484 }
32485 m.Field12 = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
32486 iNdEx += 8
32487 case 13:
32488 if wireType != 0 {
32489 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
32490 }
32491 var v int
32492 for shift := uint(0); ; shift += 7 {
32493 if shift >= 64 {
32494 return ErrIntOverflowThetest
32495 }
32496 if iNdEx >= l {
32497 return io.ErrUnexpectedEOF
32498 }
32499 b := dAtA[iNdEx]
32500 iNdEx++
32501 v |= int(b&0x7F) << shift
32502 if b < 0x80 {
32503 break
32504 }
32505 }
32506 m.Field13 = bool(v != 0)
32507 case 14:
32508 if wireType != 2 {
32509 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
32510 }
32511 var stringLen uint64
32512 for shift := uint(0); ; shift += 7 {
32513 if shift >= 64 {
32514 return ErrIntOverflowThetest
32515 }
32516 if iNdEx >= l {
32517 return io.ErrUnexpectedEOF
32518 }
32519 b := dAtA[iNdEx]
32520 iNdEx++
32521 stringLen |= uint64(b&0x7F) << shift
32522 if b < 0x80 {
32523 break
32524 }
32525 }
32526 intStringLen := int(stringLen)
32527 if intStringLen < 0 {
32528 return ErrInvalidLengthThetest
32529 }
32530 postIndex := iNdEx + intStringLen
32531 if postIndex < 0 {
32532 return ErrInvalidLengthThetest
32533 }
32534 if postIndex > l {
32535 return io.ErrUnexpectedEOF
32536 }
32537 m.Field14 = string(dAtA[iNdEx:postIndex])
32538 iNdEx = postIndex
32539 case 15:
32540 if wireType != 2 {
32541 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
32542 }
32543 var byteLen int
32544 for shift := uint(0); ; shift += 7 {
32545 if shift >= 64 {
32546 return ErrIntOverflowThetest
32547 }
32548 if iNdEx >= l {
32549 return io.ErrUnexpectedEOF
32550 }
32551 b := dAtA[iNdEx]
32552 iNdEx++
32553 byteLen |= int(b&0x7F) << shift
32554 if b < 0x80 {
32555 break
32556 }
32557 }
32558 if byteLen < 0 {
32559 return ErrInvalidLengthThetest
32560 }
32561 postIndex := iNdEx + byteLen
32562 if postIndex < 0 {
32563 return ErrInvalidLengthThetest
32564 }
32565 if postIndex > l {
32566 return io.ErrUnexpectedEOF
32567 }
32568 m.Field15 = append(m.Field15[:0], dAtA[iNdEx:postIndex]...)
32569 if m.Field15 == nil {
32570 m.Field15 = []byte{}
32571 }
32572 iNdEx = postIndex
32573 default:
32574 iNdEx = preIndex
32575 skippy, err := skipThetest(dAtA[iNdEx:])
32576 if err != nil {
32577 return err
32578 }
32579 if (skippy < 0) || (iNdEx+skippy) < 0 {
32580 return ErrInvalidLengthThetest
32581 }
32582 if (iNdEx + skippy) > l {
32583 return io.ErrUnexpectedEOF
32584 }
32585 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
32586 iNdEx += skippy
32587 }
32588 }
32589
32590 if iNdEx > l {
32591 return io.ErrUnexpectedEOF
32592 }
32593 return nil
32594 }
32595 func (m *NinOptNative) Unmarshal(dAtA []byte) error {
32596 l := len(dAtA)
32597 iNdEx := 0
32598 for iNdEx < l {
32599 preIndex := iNdEx
32600 var wire uint64
32601 for shift := uint(0); ; shift += 7 {
32602 if shift >= 64 {
32603 return ErrIntOverflowThetest
32604 }
32605 if iNdEx >= l {
32606 return io.ErrUnexpectedEOF
32607 }
32608 b := dAtA[iNdEx]
32609 iNdEx++
32610 wire |= uint64(b&0x7F) << shift
32611 if b < 0x80 {
32612 break
32613 }
32614 }
32615 fieldNum := int32(wire >> 3)
32616 wireType := int(wire & 0x7)
32617 if wireType == 4 {
32618 return fmt.Errorf("proto: NinOptNative: wiretype end group for non-group")
32619 }
32620 if fieldNum <= 0 {
32621 return fmt.Errorf("proto: NinOptNative: illegal tag %d (wire type %d)", fieldNum, wire)
32622 }
32623 switch fieldNum {
32624 case 1:
32625 if wireType != 1 {
32626 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
32627 }
32628 var v uint64
32629 if (iNdEx + 8) > l {
32630 return io.ErrUnexpectedEOF
32631 }
32632 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
32633 iNdEx += 8
32634 v2 := float64(math.Float64frombits(v))
32635 m.Field1 = &v2
32636 case 2:
32637 if wireType != 5 {
32638 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
32639 }
32640 var v uint32
32641 if (iNdEx + 4) > l {
32642 return io.ErrUnexpectedEOF
32643 }
32644 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
32645 iNdEx += 4
32646 v2 := float32(math.Float32frombits(v))
32647 m.Field2 = &v2
32648 case 3:
32649 if wireType != 0 {
32650 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
32651 }
32652 var v int32
32653 for shift := uint(0); ; shift += 7 {
32654 if shift >= 64 {
32655 return ErrIntOverflowThetest
32656 }
32657 if iNdEx >= l {
32658 return io.ErrUnexpectedEOF
32659 }
32660 b := dAtA[iNdEx]
32661 iNdEx++
32662 v |= int32(b&0x7F) << shift
32663 if b < 0x80 {
32664 break
32665 }
32666 }
32667 m.Field3 = &v
32668 case 4:
32669 if wireType != 0 {
32670 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
32671 }
32672 var v int64
32673 for shift := uint(0); ; shift += 7 {
32674 if shift >= 64 {
32675 return ErrIntOverflowThetest
32676 }
32677 if iNdEx >= l {
32678 return io.ErrUnexpectedEOF
32679 }
32680 b := dAtA[iNdEx]
32681 iNdEx++
32682 v |= int64(b&0x7F) << shift
32683 if b < 0x80 {
32684 break
32685 }
32686 }
32687 m.Field4 = &v
32688 case 5:
32689 if wireType != 0 {
32690 return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
32691 }
32692 var v uint32
32693 for shift := uint(0); ; shift += 7 {
32694 if shift >= 64 {
32695 return ErrIntOverflowThetest
32696 }
32697 if iNdEx >= l {
32698 return io.ErrUnexpectedEOF
32699 }
32700 b := dAtA[iNdEx]
32701 iNdEx++
32702 v |= uint32(b&0x7F) << shift
32703 if b < 0x80 {
32704 break
32705 }
32706 }
32707 m.Field5 = &v
32708 case 6:
32709 if wireType != 0 {
32710 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
32711 }
32712 var v uint64
32713 for shift := uint(0); ; shift += 7 {
32714 if shift >= 64 {
32715 return ErrIntOverflowThetest
32716 }
32717 if iNdEx >= l {
32718 return io.ErrUnexpectedEOF
32719 }
32720 b := dAtA[iNdEx]
32721 iNdEx++
32722 v |= uint64(b&0x7F) << shift
32723 if b < 0x80 {
32724 break
32725 }
32726 }
32727 m.Field6 = &v
32728 case 7:
32729 if wireType != 0 {
32730 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
32731 }
32732 var v int32
32733 for shift := uint(0); ; shift += 7 {
32734 if shift >= 64 {
32735 return ErrIntOverflowThetest
32736 }
32737 if iNdEx >= l {
32738 return io.ErrUnexpectedEOF
32739 }
32740 b := dAtA[iNdEx]
32741 iNdEx++
32742 v |= int32(b&0x7F) << shift
32743 if b < 0x80 {
32744 break
32745 }
32746 }
32747 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
32748 m.Field7 = &v
32749 case 8:
32750 if wireType != 0 {
32751 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
32752 }
32753 var v uint64
32754 for shift := uint(0); ; shift += 7 {
32755 if shift >= 64 {
32756 return ErrIntOverflowThetest
32757 }
32758 if iNdEx >= l {
32759 return io.ErrUnexpectedEOF
32760 }
32761 b := dAtA[iNdEx]
32762 iNdEx++
32763 v |= uint64(b&0x7F) << shift
32764 if b < 0x80 {
32765 break
32766 }
32767 }
32768 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
32769 v2 := int64(v)
32770 m.Field8 = &v2
32771 case 9:
32772 if wireType != 5 {
32773 return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
32774 }
32775 var v uint32
32776 if (iNdEx + 4) > l {
32777 return io.ErrUnexpectedEOF
32778 }
32779 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
32780 iNdEx += 4
32781 m.Field9 = &v
32782 case 10:
32783 if wireType != 5 {
32784 return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
32785 }
32786 var v int32
32787 if (iNdEx + 4) > l {
32788 return io.ErrUnexpectedEOF
32789 }
32790 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
32791 iNdEx += 4
32792 m.Field10 = &v
32793 case 11:
32794 if wireType != 1 {
32795 return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
32796 }
32797 var v uint64
32798 if (iNdEx + 8) > l {
32799 return io.ErrUnexpectedEOF
32800 }
32801 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
32802 iNdEx += 8
32803 m.Field11 = &v
32804 case 12:
32805 if wireType != 1 {
32806 return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
32807 }
32808 var v int64
32809 if (iNdEx + 8) > l {
32810 return io.ErrUnexpectedEOF
32811 }
32812 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
32813 iNdEx += 8
32814 m.Field12 = &v
32815 case 13:
32816 if wireType != 0 {
32817 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
32818 }
32819 var v int
32820 for shift := uint(0); ; shift += 7 {
32821 if shift >= 64 {
32822 return ErrIntOverflowThetest
32823 }
32824 if iNdEx >= l {
32825 return io.ErrUnexpectedEOF
32826 }
32827 b := dAtA[iNdEx]
32828 iNdEx++
32829 v |= int(b&0x7F) << shift
32830 if b < 0x80 {
32831 break
32832 }
32833 }
32834 b := bool(v != 0)
32835 m.Field13 = &b
32836 case 14:
32837 if wireType != 2 {
32838 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
32839 }
32840 var stringLen uint64
32841 for shift := uint(0); ; shift += 7 {
32842 if shift >= 64 {
32843 return ErrIntOverflowThetest
32844 }
32845 if iNdEx >= l {
32846 return io.ErrUnexpectedEOF
32847 }
32848 b := dAtA[iNdEx]
32849 iNdEx++
32850 stringLen |= uint64(b&0x7F) << shift
32851 if b < 0x80 {
32852 break
32853 }
32854 }
32855 intStringLen := int(stringLen)
32856 if intStringLen < 0 {
32857 return ErrInvalidLengthThetest
32858 }
32859 postIndex := iNdEx + intStringLen
32860 if postIndex < 0 {
32861 return ErrInvalidLengthThetest
32862 }
32863 if postIndex > l {
32864 return io.ErrUnexpectedEOF
32865 }
32866 s := string(dAtA[iNdEx:postIndex])
32867 m.Field14 = &s
32868 iNdEx = postIndex
32869 case 15:
32870 if wireType != 2 {
32871 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
32872 }
32873 var byteLen int
32874 for shift := uint(0); ; shift += 7 {
32875 if shift >= 64 {
32876 return ErrIntOverflowThetest
32877 }
32878 if iNdEx >= l {
32879 return io.ErrUnexpectedEOF
32880 }
32881 b := dAtA[iNdEx]
32882 iNdEx++
32883 byteLen |= int(b&0x7F) << shift
32884 if b < 0x80 {
32885 break
32886 }
32887 }
32888 if byteLen < 0 {
32889 return ErrInvalidLengthThetest
32890 }
32891 postIndex := iNdEx + byteLen
32892 if postIndex < 0 {
32893 return ErrInvalidLengthThetest
32894 }
32895 if postIndex > l {
32896 return io.ErrUnexpectedEOF
32897 }
32898 m.Field15 = append(m.Field15[:0], dAtA[iNdEx:postIndex]...)
32899 if m.Field15 == nil {
32900 m.Field15 = []byte{}
32901 }
32902 iNdEx = postIndex
32903 default:
32904 iNdEx = preIndex
32905 skippy, err := skipThetest(dAtA[iNdEx:])
32906 if err != nil {
32907 return err
32908 }
32909 if (skippy < 0) || (iNdEx+skippy) < 0 {
32910 return ErrInvalidLengthThetest
32911 }
32912 if (iNdEx + skippy) > l {
32913 return io.ErrUnexpectedEOF
32914 }
32915 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
32916 iNdEx += skippy
32917 }
32918 }
32919
32920 if iNdEx > l {
32921 return io.ErrUnexpectedEOF
32922 }
32923 return nil
32924 }
32925 func (m *NidRepNative) Unmarshal(dAtA []byte) error {
32926 l := len(dAtA)
32927 iNdEx := 0
32928 for iNdEx < l {
32929 preIndex := iNdEx
32930 var wire uint64
32931 for shift := uint(0); ; shift += 7 {
32932 if shift >= 64 {
32933 return ErrIntOverflowThetest
32934 }
32935 if iNdEx >= l {
32936 return io.ErrUnexpectedEOF
32937 }
32938 b := dAtA[iNdEx]
32939 iNdEx++
32940 wire |= uint64(b&0x7F) << shift
32941 if b < 0x80 {
32942 break
32943 }
32944 }
32945 fieldNum := int32(wire >> 3)
32946 wireType := int(wire & 0x7)
32947 if wireType == 4 {
32948 return fmt.Errorf("proto: NidRepNative: wiretype end group for non-group")
32949 }
32950 if fieldNum <= 0 {
32951 return fmt.Errorf("proto: NidRepNative: illegal tag %d (wire type %d)", fieldNum, wire)
32952 }
32953 switch fieldNum {
32954 case 1:
32955 if wireType == 1 {
32956 var v uint64
32957 if (iNdEx + 8) > l {
32958 return io.ErrUnexpectedEOF
32959 }
32960 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
32961 iNdEx += 8
32962 v2 := float64(math.Float64frombits(v))
32963 m.Field1 = append(m.Field1, v2)
32964 } else if wireType == 2 {
32965 var packedLen int
32966 for shift := uint(0); ; shift += 7 {
32967 if shift >= 64 {
32968 return ErrIntOverflowThetest
32969 }
32970 if iNdEx >= l {
32971 return io.ErrUnexpectedEOF
32972 }
32973 b := dAtA[iNdEx]
32974 iNdEx++
32975 packedLen |= int(b&0x7F) << shift
32976 if b < 0x80 {
32977 break
32978 }
32979 }
32980 if packedLen < 0 {
32981 return ErrInvalidLengthThetest
32982 }
32983 postIndex := iNdEx + packedLen
32984 if postIndex < 0 {
32985 return ErrInvalidLengthThetest
32986 }
32987 if postIndex > l {
32988 return io.ErrUnexpectedEOF
32989 }
32990 var elementCount int
32991 elementCount = packedLen / 8
32992 if elementCount != 0 && len(m.Field1) == 0 {
32993 m.Field1 = make([]float64, 0, elementCount)
32994 }
32995 for iNdEx < postIndex {
32996 var v uint64
32997 if (iNdEx + 8) > l {
32998 return io.ErrUnexpectedEOF
32999 }
33000 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
33001 iNdEx += 8
33002 v2 := float64(math.Float64frombits(v))
33003 m.Field1 = append(m.Field1, v2)
33004 }
33005 } else {
33006 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
33007 }
33008 case 2:
33009 if wireType == 5 {
33010 var v uint32
33011 if (iNdEx + 4) > l {
33012 return io.ErrUnexpectedEOF
33013 }
33014 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
33015 iNdEx += 4
33016 v2 := float32(math.Float32frombits(v))
33017 m.Field2 = append(m.Field2, v2)
33018 } else if wireType == 2 {
33019 var packedLen int
33020 for shift := uint(0); ; shift += 7 {
33021 if shift >= 64 {
33022 return ErrIntOverflowThetest
33023 }
33024 if iNdEx >= l {
33025 return io.ErrUnexpectedEOF
33026 }
33027 b := dAtA[iNdEx]
33028 iNdEx++
33029 packedLen |= int(b&0x7F) << shift
33030 if b < 0x80 {
33031 break
33032 }
33033 }
33034 if packedLen < 0 {
33035 return ErrInvalidLengthThetest
33036 }
33037 postIndex := iNdEx + packedLen
33038 if postIndex < 0 {
33039 return ErrInvalidLengthThetest
33040 }
33041 if postIndex > l {
33042 return io.ErrUnexpectedEOF
33043 }
33044 var elementCount int
33045 elementCount = packedLen / 4
33046 if elementCount != 0 && len(m.Field2) == 0 {
33047 m.Field2 = make([]float32, 0, elementCount)
33048 }
33049 for iNdEx < postIndex {
33050 var v uint32
33051 if (iNdEx + 4) > l {
33052 return io.ErrUnexpectedEOF
33053 }
33054 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
33055 iNdEx += 4
33056 v2 := float32(math.Float32frombits(v))
33057 m.Field2 = append(m.Field2, v2)
33058 }
33059 } else {
33060 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
33061 }
33062 case 3:
33063 if wireType == 0 {
33064 var v int32
33065 for shift := uint(0); ; shift += 7 {
33066 if shift >= 64 {
33067 return ErrIntOverflowThetest
33068 }
33069 if iNdEx >= l {
33070 return io.ErrUnexpectedEOF
33071 }
33072 b := dAtA[iNdEx]
33073 iNdEx++
33074 v |= int32(b&0x7F) << shift
33075 if b < 0x80 {
33076 break
33077 }
33078 }
33079 m.Field3 = append(m.Field3, v)
33080 } else if wireType == 2 {
33081 var packedLen int
33082 for shift := uint(0); ; shift += 7 {
33083 if shift >= 64 {
33084 return ErrIntOverflowThetest
33085 }
33086 if iNdEx >= l {
33087 return io.ErrUnexpectedEOF
33088 }
33089 b := dAtA[iNdEx]
33090 iNdEx++
33091 packedLen |= int(b&0x7F) << shift
33092 if b < 0x80 {
33093 break
33094 }
33095 }
33096 if packedLen < 0 {
33097 return ErrInvalidLengthThetest
33098 }
33099 postIndex := iNdEx + packedLen
33100 if postIndex < 0 {
33101 return ErrInvalidLengthThetest
33102 }
33103 if postIndex > l {
33104 return io.ErrUnexpectedEOF
33105 }
33106 var elementCount int
33107 var count int
33108 for _, integer := range dAtA[iNdEx:postIndex] {
33109 if integer < 128 {
33110 count++
33111 }
33112 }
33113 elementCount = count
33114 if elementCount != 0 && len(m.Field3) == 0 {
33115 m.Field3 = make([]int32, 0, elementCount)
33116 }
33117 for iNdEx < postIndex {
33118 var v int32
33119 for shift := uint(0); ; shift += 7 {
33120 if shift >= 64 {
33121 return ErrIntOverflowThetest
33122 }
33123 if iNdEx >= l {
33124 return io.ErrUnexpectedEOF
33125 }
33126 b := dAtA[iNdEx]
33127 iNdEx++
33128 v |= int32(b&0x7F) << shift
33129 if b < 0x80 {
33130 break
33131 }
33132 }
33133 m.Field3 = append(m.Field3, v)
33134 }
33135 } else {
33136 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
33137 }
33138 case 4:
33139 if wireType == 0 {
33140 var v int64
33141 for shift := uint(0); ; shift += 7 {
33142 if shift >= 64 {
33143 return ErrIntOverflowThetest
33144 }
33145 if iNdEx >= l {
33146 return io.ErrUnexpectedEOF
33147 }
33148 b := dAtA[iNdEx]
33149 iNdEx++
33150 v |= int64(b&0x7F) << shift
33151 if b < 0x80 {
33152 break
33153 }
33154 }
33155 m.Field4 = append(m.Field4, v)
33156 } else if wireType == 2 {
33157 var packedLen int
33158 for shift := uint(0); ; shift += 7 {
33159 if shift >= 64 {
33160 return ErrIntOverflowThetest
33161 }
33162 if iNdEx >= l {
33163 return io.ErrUnexpectedEOF
33164 }
33165 b := dAtA[iNdEx]
33166 iNdEx++
33167 packedLen |= int(b&0x7F) << shift
33168 if b < 0x80 {
33169 break
33170 }
33171 }
33172 if packedLen < 0 {
33173 return ErrInvalidLengthThetest
33174 }
33175 postIndex := iNdEx + packedLen
33176 if postIndex < 0 {
33177 return ErrInvalidLengthThetest
33178 }
33179 if postIndex > l {
33180 return io.ErrUnexpectedEOF
33181 }
33182 var elementCount int
33183 var count int
33184 for _, integer := range dAtA[iNdEx:postIndex] {
33185 if integer < 128 {
33186 count++
33187 }
33188 }
33189 elementCount = count
33190 if elementCount != 0 && len(m.Field4) == 0 {
33191 m.Field4 = make([]int64, 0, elementCount)
33192 }
33193 for iNdEx < postIndex {
33194 var v int64
33195 for shift := uint(0); ; shift += 7 {
33196 if shift >= 64 {
33197 return ErrIntOverflowThetest
33198 }
33199 if iNdEx >= l {
33200 return io.ErrUnexpectedEOF
33201 }
33202 b := dAtA[iNdEx]
33203 iNdEx++
33204 v |= int64(b&0x7F) << shift
33205 if b < 0x80 {
33206 break
33207 }
33208 }
33209 m.Field4 = append(m.Field4, v)
33210 }
33211 } else {
33212 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
33213 }
33214 case 5:
33215 if wireType == 0 {
33216 var v uint32
33217 for shift := uint(0); ; shift += 7 {
33218 if shift >= 64 {
33219 return ErrIntOverflowThetest
33220 }
33221 if iNdEx >= l {
33222 return io.ErrUnexpectedEOF
33223 }
33224 b := dAtA[iNdEx]
33225 iNdEx++
33226 v |= uint32(b&0x7F) << shift
33227 if b < 0x80 {
33228 break
33229 }
33230 }
33231 m.Field5 = append(m.Field5, v)
33232 } else if wireType == 2 {
33233 var packedLen int
33234 for shift := uint(0); ; shift += 7 {
33235 if shift >= 64 {
33236 return ErrIntOverflowThetest
33237 }
33238 if iNdEx >= l {
33239 return io.ErrUnexpectedEOF
33240 }
33241 b := dAtA[iNdEx]
33242 iNdEx++
33243 packedLen |= int(b&0x7F) << shift
33244 if b < 0x80 {
33245 break
33246 }
33247 }
33248 if packedLen < 0 {
33249 return ErrInvalidLengthThetest
33250 }
33251 postIndex := iNdEx + packedLen
33252 if postIndex < 0 {
33253 return ErrInvalidLengthThetest
33254 }
33255 if postIndex > l {
33256 return io.ErrUnexpectedEOF
33257 }
33258 var elementCount int
33259 var count int
33260 for _, integer := range dAtA[iNdEx:postIndex] {
33261 if integer < 128 {
33262 count++
33263 }
33264 }
33265 elementCount = count
33266 if elementCount != 0 && len(m.Field5) == 0 {
33267 m.Field5 = make([]uint32, 0, elementCount)
33268 }
33269 for iNdEx < postIndex {
33270 var v uint32
33271 for shift := uint(0); ; shift += 7 {
33272 if shift >= 64 {
33273 return ErrIntOverflowThetest
33274 }
33275 if iNdEx >= l {
33276 return io.ErrUnexpectedEOF
33277 }
33278 b := dAtA[iNdEx]
33279 iNdEx++
33280 v |= uint32(b&0x7F) << shift
33281 if b < 0x80 {
33282 break
33283 }
33284 }
33285 m.Field5 = append(m.Field5, v)
33286 }
33287 } else {
33288 return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
33289 }
33290 case 6:
33291 if wireType == 0 {
33292 var v uint64
33293 for shift := uint(0); ; shift += 7 {
33294 if shift >= 64 {
33295 return ErrIntOverflowThetest
33296 }
33297 if iNdEx >= l {
33298 return io.ErrUnexpectedEOF
33299 }
33300 b := dAtA[iNdEx]
33301 iNdEx++
33302 v |= uint64(b&0x7F) << shift
33303 if b < 0x80 {
33304 break
33305 }
33306 }
33307 m.Field6 = append(m.Field6, v)
33308 } else if wireType == 2 {
33309 var packedLen int
33310 for shift := uint(0); ; shift += 7 {
33311 if shift >= 64 {
33312 return ErrIntOverflowThetest
33313 }
33314 if iNdEx >= l {
33315 return io.ErrUnexpectedEOF
33316 }
33317 b := dAtA[iNdEx]
33318 iNdEx++
33319 packedLen |= int(b&0x7F) << shift
33320 if b < 0x80 {
33321 break
33322 }
33323 }
33324 if packedLen < 0 {
33325 return ErrInvalidLengthThetest
33326 }
33327 postIndex := iNdEx + packedLen
33328 if postIndex < 0 {
33329 return ErrInvalidLengthThetest
33330 }
33331 if postIndex > l {
33332 return io.ErrUnexpectedEOF
33333 }
33334 var elementCount int
33335 var count int
33336 for _, integer := range dAtA[iNdEx:postIndex] {
33337 if integer < 128 {
33338 count++
33339 }
33340 }
33341 elementCount = count
33342 if elementCount != 0 && len(m.Field6) == 0 {
33343 m.Field6 = make([]uint64, 0, elementCount)
33344 }
33345 for iNdEx < postIndex {
33346 var v uint64
33347 for shift := uint(0); ; shift += 7 {
33348 if shift >= 64 {
33349 return ErrIntOverflowThetest
33350 }
33351 if iNdEx >= l {
33352 return io.ErrUnexpectedEOF
33353 }
33354 b := dAtA[iNdEx]
33355 iNdEx++
33356 v |= uint64(b&0x7F) << shift
33357 if b < 0x80 {
33358 break
33359 }
33360 }
33361 m.Field6 = append(m.Field6, v)
33362 }
33363 } else {
33364 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
33365 }
33366 case 7:
33367 if wireType == 0 {
33368 var v int32
33369 for shift := uint(0); ; shift += 7 {
33370 if shift >= 64 {
33371 return ErrIntOverflowThetest
33372 }
33373 if iNdEx >= l {
33374 return io.ErrUnexpectedEOF
33375 }
33376 b := dAtA[iNdEx]
33377 iNdEx++
33378 v |= int32(b&0x7F) << shift
33379 if b < 0x80 {
33380 break
33381 }
33382 }
33383 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
33384 m.Field7 = append(m.Field7, v)
33385 } else if wireType == 2 {
33386 var packedLen int
33387 for shift := uint(0); ; shift += 7 {
33388 if shift >= 64 {
33389 return ErrIntOverflowThetest
33390 }
33391 if iNdEx >= l {
33392 return io.ErrUnexpectedEOF
33393 }
33394 b := dAtA[iNdEx]
33395 iNdEx++
33396 packedLen |= int(b&0x7F) << shift
33397 if b < 0x80 {
33398 break
33399 }
33400 }
33401 if packedLen < 0 {
33402 return ErrInvalidLengthThetest
33403 }
33404 postIndex := iNdEx + packedLen
33405 if postIndex < 0 {
33406 return ErrInvalidLengthThetest
33407 }
33408 if postIndex > l {
33409 return io.ErrUnexpectedEOF
33410 }
33411 var elementCount int
33412 var count int
33413 for _, integer := range dAtA[iNdEx:postIndex] {
33414 if integer < 128 {
33415 count++
33416 }
33417 }
33418 elementCount = count
33419 if elementCount != 0 && len(m.Field7) == 0 {
33420 m.Field7 = make([]int32, 0, elementCount)
33421 }
33422 for iNdEx < postIndex {
33423 var v int32
33424 for shift := uint(0); ; shift += 7 {
33425 if shift >= 64 {
33426 return ErrIntOverflowThetest
33427 }
33428 if iNdEx >= l {
33429 return io.ErrUnexpectedEOF
33430 }
33431 b := dAtA[iNdEx]
33432 iNdEx++
33433 v |= int32(b&0x7F) << shift
33434 if b < 0x80 {
33435 break
33436 }
33437 }
33438 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
33439 m.Field7 = append(m.Field7, v)
33440 }
33441 } else {
33442 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
33443 }
33444 case 8:
33445 if wireType == 0 {
33446 var v uint64
33447 for shift := uint(0); ; shift += 7 {
33448 if shift >= 64 {
33449 return ErrIntOverflowThetest
33450 }
33451 if iNdEx >= l {
33452 return io.ErrUnexpectedEOF
33453 }
33454 b := dAtA[iNdEx]
33455 iNdEx++
33456 v |= uint64(b&0x7F) << shift
33457 if b < 0x80 {
33458 break
33459 }
33460 }
33461 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
33462 m.Field8 = append(m.Field8, int64(v))
33463 } else if wireType == 2 {
33464 var packedLen int
33465 for shift := uint(0); ; shift += 7 {
33466 if shift >= 64 {
33467 return ErrIntOverflowThetest
33468 }
33469 if iNdEx >= l {
33470 return io.ErrUnexpectedEOF
33471 }
33472 b := dAtA[iNdEx]
33473 iNdEx++
33474 packedLen |= int(b&0x7F) << shift
33475 if b < 0x80 {
33476 break
33477 }
33478 }
33479 if packedLen < 0 {
33480 return ErrInvalidLengthThetest
33481 }
33482 postIndex := iNdEx + packedLen
33483 if postIndex < 0 {
33484 return ErrInvalidLengthThetest
33485 }
33486 if postIndex > l {
33487 return io.ErrUnexpectedEOF
33488 }
33489 var elementCount int
33490 var count int
33491 for _, integer := range dAtA[iNdEx:postIndex] {
33492 if integer < 128 {
33493 count++
33494 }
33495 }
33496 elementCount = count
33497 if elementCount != 0 && len(m.Field8) == 0 {
33498 m.Field8 = make([]int64, 0, elementCount)
33499 }
33500 for iNdEx < postIndex {
33501 var v uint64
33502 for shift := uint(0); ; shift += 7 {
33503 if shift >= 64 {
33504 return ErrIntOverflowThetest
33505 }
33506 if iNdEx >= l {
33507 return io.ErrUnexpectedEOF
33508 }
33509 b := dAtA[iNdEx]
33510 iNdEx++
33511 v |= uint64(b&0x7F) << shift
33512 if b < 0x80 {
33513 break
33514 }
33515 }
33516 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
33517 m.Field8 = append(m.Field8, int64(v))
33518 }
33519 } else {
33520 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
33521 }
33522 case 9:
33523 if wireType == 5 {
33524 var v uint32
33525 if (iNdEx + 4) > l {
33526 return io.ErrUnexpectedEOF
33527 }
33528 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
33529 iNdEx += 4
33530 m.Field9 = append(m.Field9, v)
33531 } else if wireType == 2 {
33532 var packedLen int
33533 for shift := uint(0); ; shift += 7 {
33534 if shift >= 64 {
33535 return ErrIntOverflowThetest
33536 }
33537 if iNdEx >= l {
33538 return io.ErrUnexpectedEOF
33539 }
33540 b := dAtA[iNdEx]
33541 iNdEx++
33542 packedLen |= int(b&0x7F) << shift
33543 if b < 0x80 {
33544 break
33545 }
33546 }
33547 if packedLen < 0 {
33548 return ErrInvalidLengthThetest
33549 }
33550 postIndex := iNdEx + packedLen
33551 if postIndex < 0 {
33552 return ErrInvalidLengthThetest
33553 }
33554 if postIndex > l {
33555 return io.ErrUnexpectedEOF
33556 }
33557 var elementCount int
33558 elementCount = packedLen / 4
33559 if elementCount != 0 && len(m.Field9) == 0 {
33560 m.Field9 = make([]uint32, 0, elementCount)
33561 }
33562 for iNdEx < postIndex {
33563 var v uint32
33564 if (iNdEx + 4) > l {
33565 return io.ErrUnexpectedEOF
33566 }
33567 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
33568 iNdEx += 4
33569 m.Field9 = append(m.Field9, v)
33570 }
33571 } else {
33572 return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
33573 }
33574 case 10:
33575 if wireType == 5 {
33576 var v int32
33577 if (iNdEx + 4) > l {
33578 return io.ErrUnexpectedEOF
33579 }
33580 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
33581 iNdEx += 4
33582 m.Field10 = append(m.Field10, v)
33583 } else if wireType == 2 {
33584 var packedLen int
33585 for shift := uint(0); ; shift += 7 {
33586 if shift >= 64 {
33587 return ErrIntOverflowThetest
33588 }
33589 if iNdEx >= l {
33590 return io.ErrUnexpectedEOF
33591 }
33592 b := dAtA[iNdEx]
33593 iNdEx++
33594 packedLen |= int(b&0x7F) << shift
33595 if b < 0x80 {
33596 break
33597 }
33598 }
33599 if packedLen < 0 {
33600 return ErrInvalidLengthThetest
33601 }
33602 postIndex := iNdEx + packedLen
33603 if postIndex < 0 {
33604 return ErrInvalidLengthThetest
33605 }
33606 if postIndex > l {
33607 return io.ErrUnexpectedEOF
33608 }
33609 var elementCount int
33610 elementCount = packedLen / 4
33611 if elementCount != 0 && len(m.Field10) == 0 {
33612 m.Field10 = make([]int32, 0, elementCount)
33613 }
33614 for iNdEx < postIndex {
33615 var v int32
33616 if (iNdEx + 4) > l {
33617 return io.ErrUnexpectedEOF
33618 }
33619 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
33620 iNdEx += 4
33621 m.Field10 = append(m.Field10, v)
33622 }
33623 } else {
33624 return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
33625 }
33626 case 11:
33627 if wireType == 1 {
33628 var v uint64
33629 if (iNdEx + 8) > l {
33630 return io.ErrUnexpectedEOF
33631 }
33632 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
33633 iNdEx += 8
33634 m.Field11 = append(m.Field11, v)
33635 } else if wireType == 2 {
33636 var packedLen int
33637 for shift := uint(0); ; shift += 7 {
33638 if shift >= 64 {
33639 return ErrIntOverflowThetest
33640 }
33641 if iNdEx >= l {
33642 return io.ErrUnexpectedEOF
33643 }
33644 b := dAtA[iNdEx]
33645 iNdEx++
33646 packedLen |= int(b&0x7F) << shift
33647 if b < 0x80 {
33648 break
33649 }
33650 }
33651 if packedLen < 0 {
33652 return ErrInvalidLengthThetest
33653 }
33654 postIndex := iNdEx + packedLen
33655 if postIndex < 0 {
33656 return ErrInvalidLengthThetest
33657 }
33658 if postIndex > l {
33659 return io.ErrUnexpectedEOF
33660 }
33661 var elementCount int
33662 elementCount = packedLen / 8
33663 if elementCount != 0 && len(m.Field11) == 0 {
33664 m.Field11 = make([]uint64, 0, elementCount)
33665 }
33666 for iNdEx < postIndex {
33667 var v uint64
33668 if (iNdEx + 8) > l {
33669 return io.ErrUnexpectedEOF
33670 }
33671 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
33672 iNdEx += 8
33673 m.Field11 = append(m.Field11, v)
33674 }
33675 } else {
33676 return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
33677 }
33678 case 12:
33679 if wireType == 1 {
33680 var v int64
33681 if (iNdEx + 8) > l {
33682 return io.ErrUnexpectedEOF
33683 }
33684 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
33685 iNdEx += 8
33686 m.Field12 = append(m.Field12, v)
33687 } else if wireType == 2 {
33688 var packedLen int
33689 for shift := uint(0); ; shift += 7 {
33690 if shift >= 64 {
33691 return ErrIntOverflowThetest
33692 }
33693 if iNdEx >= l {
33694 return io.ErrUnexpectedEOF
33695 }
33696 b := dAtA[iNdEx]
33697 iNdEx++
33698 packedLen |= int(b&0x7F) << shift
33699 if b < 0x80 {
33700 break
33701 }
33702 }
33703 if packedLen < 0 {
33704 return ErrInvalidLengthThetest
33705 }
33706 postIndex := iNdEx + packedLen
33707 if postIndex < 0 {
33708 return ErrInvalidLengthThetest
33709 }
33710 if postIndex > l {
33711 return io.ErrUnexpectedEOF
33712 }
33713 var elementCount int
33714 elementCount = packedLen / 8
33715 if elementCount != 0 && len(m.Field12) == 0 {
33716 m.Field12 = make([]int64, 0, elementCount)
33717 }
33718 for iNdEx < postIndex {
33719 var v int64
33720 if (iNdEx + 8) > l {
33721 return io.ErrUnexpectedEOF
33722 }
33723 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
33724 iNdEx += 8
33725 m.Field12 = append(m.Field12, v)
33726 }
33727 } else {
33728 return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
33729 }
33730 case 13:
33731 if wireType == 0 {
33732 var v int
33733 for shift := uint(0); ; shift += 7 {
33734 if shift >= 64 {
33735 return ErrIntOverflowThetest
33736 }
33737 if iNdEx >= l {
33738 return io.ErrUnexpectedEOF
33739 }
33740 b := dAtA[iNdEx]
33741 iNdEx++
33742 v |= int(b&0x7F) << shift
33743 if b < 0x80 {
33744 break
33745 }
33746 }
33747 m.Field13 = append(m.Field13, bool(v != 0))
33748 } else if wireType == 2 {
33749 var packedLen int
33750 for shift := uint(0); ; shift += 7 {
33751 if shift >= 64 {
33752 return ErrIntOverflowThetest
33753 }
33754 if iNdEx >= l {
33755 return io.ErrUnexpectedEOF
33756 }
33757 b := dAtA[iNdEx]
33758 iNdEx++
33759 packedLen |= int(b&0x7F) << shift
33760 if b < 0x80 {
33761 break
33762 }
33763 }
33764 if packedLen < 0 {
33765 return ErrInvalidLengthThetest
33766 }
33767 postIndex := iNdEx + packedLen
33768 if postIndex < 0 {
33769 return ErrInvalidLengthThetest
33770 }
33771 if postIndex > l {
33772 return io.ErrUnexpectedEOF
33773 }
33774 var elementCount int
33775 elementCount = packedLen
33776 if elementCount != 0 && len(m.Field13) == 0 {
33777 m.Field13 = make([]bool, 0, elementCount)
33778 }
33779 for iNdEx < postIndex {
33780 var v int
33781 for shift := uint(0); ; shift += 7 {
33782 if shift >= 64 {
33783 return ErrIntOverflowThetest
33784 }
33785 if iNdEx >= l {
33786 return io.ErrUnexpectedEOF
33787 }
33788 b := dAtA[iNdEx]
33789 iNdEx++
33790 v |= int(b&0x7F) << shift
33791 if b < 0x80 {
33792 break
33793 }
33794 }
33795 m.Field13 = append(m.Field13, bool(v != 0))
33796 }
33797 } else {
33798 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
33799 }
33800 case 14:
33801 if wireType != 2 {
33802 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
33803 }
33804 var stringLen uint64
33805 for shift := uint(0); ; shift += 7 {
33806 if shift >= 64 {
33807 return ErrIntOverflowThetest
33808 }
33809 if iNdEx >= l {
33810 return io.ErrUnexpectedEOF
33811 }
33812 b := dAtA[iNdEx]
33813 iNdEx++
33814 stringLen |= uint64(b&0x7F) << shift
33815 if b < 0x80 {
33816 break
33817 }
33818 }
33819 intStringLen := int(stringLen)
33820 if intStringLen < 0 {
33821 return ErrInvalidLengthThetest
33822 }
33823 postIndex := iNdEx + intStringLen
33824 if postIndex < 0 {
33825 return ErrInvalidLengthThetest
33826 }
33827 if postIndex > l {
33828 return io.ErrUnexpectedEOF
33829 }
33830 m.Field14 = append(m.Field14, string(dAtA[iNdEx:postIndex]))
33831 iNdEx = postIndex
33832 case 15:
33833 if wireType != 2 {
33834 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
33835 }
33836 var byteLen int
33837 for shift := uint(0); ; shift += 7 {
33838 if shift >= 64 {
33839 return ErrIntOverflowThetest
33840 }
33841 if iNdEx >= l {
33842 return io.ErrUnexpectedEOF
33843 }
33844 b := dAtA[iNdEx]
33845 iNdEx++
33846 byteLen |= int(b&0x7F) << shift
33847 if b < 0x80 {
33848 break
33849 }
33850 }
33851 if byteLen < 0 {
33852 return ErrInvalidLengthThetest
33853 }
33854 postIndex := iNdEx + byteLen
33855 if postIndex < 0 {
33856 return ErrInvalidLengthThetest
33857 }
33858 if postIndex > l {
33859 return io.ErrUnexpectedEOF
33860 }
33861 m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx))
33862 copy(m.Field15[len(m.Field15)-1], dAtA[iNdEx:postIndex])
33863 iNdEx = postIndex
33864 default:
33865 iNdEx = preIndex
33866 skippy, err := skipThetest(dAtA[iNdEx:])
33867 if err != nil {
33868 return err
33869 }
33870 if (skippy < 0) || (iNdEx+skippy) < 0 {
33871 return ErrInvalidLengthThetest
33872 }
33873 if (iNdEx + skippy) > l {
33874 return io.ErrUnexpectedEOF
33875 }
33876 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
33877 iNdEx += skippy
33878 }
33879 }
33880
33881 if iNdEx > l {
33882 return io.ErrUnexpectedEOF
33883 }
33884 return nil
33885 }
33886 func (m *NinRepNative) Unmarshal(dAtA []byte) error {
33887 l := len(dAtA)
33888 iNdEx := 0
33889 for iNdEx < l {
33890 preIndex := iNdEx
33891 var wire uint64
33892 for shift := uint(0); ; shift += 7 {
33893 if shift >= 64 {
33894 return ErrIntOverflowThetest
33895 }
33896 if iNdEx >= l {
33897 return io.ErrUnexpectedEOF
33898 }
33899 b := dAtA[iNdEx]
33900 iNdEx++
33901 wire |= uint64(b&0x7F) << shift
33902 if b < 0x80 {
33903 break
33904 }
33905 }
33906 fieldNum := int32(wire >> 3)
33907 wireType := int(wire & 0x7)
33908 if wireType == 4 {
33909 return fmt.Errorf("proto: NinRepNative: wiretype end group for non-group")
33910 }
33911 if fieldNum <= 0 {
33912 return fmt.Errorf("proto: NinRepNative: illegal tag %d (wire type %d)", fieldNum, wire)
33913 }
33914 switch fieldNum {
33915 case 1:
33916 if wireType == 1 {
33917 var v uint64
33918 if (iNdEx + 8) > l {
33919 return io.ErrUnexpectedEOF
33920 }
33921 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
33922 iNdEx += 8
33923 v2 := float64(math.Float64frombits(v))
33924 m.Field1 = append(m.Field1, v2)
33925 } else if wireType == 2 {
33926 var packedLen int
33927 for shift := uint(0); ; shift += 7 {
33928 if shift >= 64 {
33929 return ErrIntOverflowThetest
33930 }
33931 if iNdEx >= l {
33932 return io.ErrUnexpectedEOF
33933 }
33934 b := dAtA[iNdEx]
33935 iNdEx++
33936 packedLen |= int(b&0x7F) << shift
33937 if b < 0x80 {
33938 break
33939 }
33940 }
33941 if packedLen < 0 {
33942 return ErrInvalidLengthThetest
33943 }
33944 postIndex := iNdEx + packedLen
33945 if postIndex < 0 {
33946 return ErrInvalidLengthThetest
33947 }
33948 if postIndex > l {
33949 return io.ErrUnexpectedEOF
33950 }
33951 var elementCount int
33952 elementCount = packedLen / 8
33953 if elementCount != 0 && len(m.Field1) == 0 {
33954 m.Field1 = make([]float64, 0, elementCount)
33955 }
33956 for iNdEx < postIndex {
33957 var v uint64
33958 if (iNdEx + 8) > l {
33959 return io.ErrUnexpectedEOF
33960 }
33961 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
33962 iNdEx += 8
33963 v2 := float64(math.Float64frombits(v))
33964 m.Field1 = append(m.Field1, v2)
33965 }
33966 } else {
33967 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
33968 }
33969 case 2:
33970 if wireType == 5 {
33971 var v uint32
33972 if (iNdEx + 4) > l {
33973 return io.ErrUnexpectedEOF
33974 }
33975 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
33976 iNdEx += 4
33977 v2 := float32(math.Float32frombits(v))
33978 m.Field2 = append(m.Field2, v2)
33979 } else if wireType == 2 {
33980 var packedLen int
33981 for shift := uint(0); ; shift += 7 {
33982 if shift >= 64 {
33983 return ErrIntOverflowThetest
33984 }
33985 if iNdEx >= l {
33986 return io.ErrUnexpectedEOF
33987 }
33988 b := dAtA[iNdEx]
33989 iNdEx++
33990 packedLen |= int(b&0x7F) << shift
33991 if b < 0x80 {
33992 break
33993 }
33994 }
33995 if packedLen < 0 {
33996 return ErrInvalidLengthThetest
33997 }
33998 postIndex := iNdEx + packedLen
33999 if postIndex < 0 {
34000 return ErrInvalidLengthThetest
34001 }
34002 if postIndex > l {
34003 return io.ErrUnexpectedEOF
34004 }
34005 var elementCount int
34006 elementCount = packedLen / 4
34007 if elementCount != 0 && len(m.Field2) == 0 {
34008 m.Field2 = make([]float32, 0, elementCount)
34009 }
34010 for iNdEx < postIndex {
34011 var v uint32
34012 if (iNdEx + 4) > l {
34013 return io.ErrUnexpectedEOF
34014 }
34015 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
34016 iNdEx += 4
34017 v2 := float32(math.Float32frombits(v))
34018 m.Field2 = append(m.Field2, v2)
34019 }
34020 } else {
34021 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
34022 }
34023 case 3:
34024 if wireType == 0 {
34025 var v int32
34026 for shift := uint(0); ; shift += 7 {
34027 if shift >= 64 {
34028 return ErrIntOverflowThetest
34029 }
34030 if iNdEx >= l {
34031 return io.ErrUnexpectedEOF
34032 }
34033 b := dAtA[iNdEx]
34034 iNdEx++
34035 v |= int32(b&0x7F) << shift
34036 if b < 0x80 {
34037 break
34038 }
34039 }
34040 m.Field3 = append(m.Field3, v)
34041 } else if wireType == 2 {
34042 var packedLen int
34043 for shift := uint(0); ; shift += 7 {
34044 if shift >= 64 {
34045 return ErrIntOverflowThetest
34046 }
34047 if iNdEx >= l {
34048 return io.ErrUnexpectedEOF
34049 }
34050 b := dAtA[iNdEx]
34051 iNdEx++
34052 packedLen |= int(b&0x7F) << shift
34053 if b < 0x80 {
34054 break
34055 }
34056 }
34057 if packedLen < 0 {
34058 return ErrInvalidLengthThetest
34059 }
34060 postIndex := iNdEx + packedLen
34061 if postIndex < 0 {
34062 return ErrInvalidLengthThetest
34063 }
34064 if postIndex > l {
34065 return io.ErrUnexpectedEOF
34066 }
34067 var elementCount int
34068 var count int
34069 for _, integer := range dAtA[iNdEx:postIndex] {
34070 if integer < 128 {
34071 count++
34072 }
34073 }
34074 elementCount = count
34075 if elementCount != 0 && len(m.Field3) == 0 {
34076 m.Field3 = make([]int32, 0, elementCount)
34077 }
34078 for iNdEx < postIndex {
34079 var v int32
34080 for shift := uint(0); ; shift += 7 {
34081 if shift >= 64 {
34082 return ErrIntOverflowThetest
34083 }
34084 if iNdEx >= l {
34085 return io.ErrUnexpectedEOF
34086 }
34087 b := dAtA[iNdEx]
34088 iNdEx++
34089 v |= int32(b&0x7F) << shift
34090 if b < 0x80 {
34091 break
34092 }
34093 }
34094 m.Field3 = append(m.Field3, v)
34095 }
34096 } else {
34097 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
34098 }
34099 case 4:
34100 if wireType == 0 {
34101 var v int64
34102 for shift := uint(0); ; shift += 7 {
34103 if shift >= 64 {
34104 return ErrIntOverflowThetest
34105 }
34106 if iNdEx >= l {
34107 return io.ErrUnexpectedEOF
34108 }
34109 b := dAtA[iNdEx]
34110 iNdEx++
34111 v |= int64(b&0x7F) << shift
34112 if b < 0x80 {
34113 break
34114 }
34115 }
34116 m.Field4 = append(m.Field4, v)
34117 } else if wireType == 2 {
34118 var packedLen int
34119 for shift := uint(0); ; shift += 7 {
34120 if shift >= 64 {
34121 return ErrIntOverflowThetest
34122 }
34123 if iNdEx >= l {
34124 return io.ErrUnexpectedEOF
34125 }
34126 b := dAtA[iNdEx]
34127 iNdEx++
34128 packedLen |= int(b&0x7F) << shift
34129 if b < 0x80 {
34130 break
34131 }
34132 }
34133 if packedLen < 0 {
34134 return ErrInvalidLengthThetest
34135 }
34136 postIndex := iNdEx + packedLen
34137 if postIndex < 0 {
34138 return ErrInvalidLengthThetest
34139 }
34140 if postIndex > l {
34141 return io.ErrUnexpectedEOF
34142 }
34143 var elementCount int
34144 var count int
34145 for _, integer := range dAtA[iNdEx:postIndex] {
34146 if integer < 128 {
34147 count++
34148 }
34149 }
34150 elementCount = count
34151 if elementCount != 0 && len(m.Field4) == 0 {
34152 m.Field4 = make([]int64, 0, elementCount)
34153 }
34154 for iNdEx < postIndex {
34155 var v int64
34156 for shift := uint(0); ; shift += 7 {
34157 if shift >= 64 {
34158 return ErrIntOverflowThetest
34159 }
34160 if iNdEx >= l {
34161 return io.ErrUnexpectedEOF
34162 }
34163 b := dAtA[iNdEx]
34164 iNdEx++
34165 v |= int64(b&0x7F) << shift
34166 if b < 0x80 {
34167 break
34168 }
34169 }
34170 m.Field4 = append(m.Field4, v)
34171 }
34172 } else {
34173 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
34174 }
34175 case 5:
34176 if wireType == 0 {
34177 var v uint32
34178 for shift := uint(0); ; shift += 7 {
34179 if shift >= 64 {
34180 return ErrIntOverflowThetest
34181 }
34182 if iNdEx >= l {
34183 return io.ErrUnexpectedEOF
34184 }
34185 b := dAtA[iNdEx]
34186 iNdEx++
34187 v |= uint32(b&0x7F) << shift
34188 if b < 0x80 {
34189 break
34190 }
34191 }
34192 m.Field5 = append(m.Field5, v)
34193 } else if wireType == 2 {
34194 var packedLen int
34195 for shift := uint(0); ; shift += 7 {
34196 if shift >= 64 {
34197 return ErrIntOverflowThetest
34198 }
34199 if iNdEx >= l {
34200 return io.ErrUnexpectedEOF
34201 }
34202 b := dAtA[iNdEx]
34203 iNdEx++
34204 packedLen |= int(b&0x7F) << shift
34205 if b < 0x80 {
34206 break
34207 }
34208 }
34209 if packedLen < 0 {
34210 return ErrInvalidLengthThetest
34211 }
34212 postIndex := iNdEx + packedLen
34213 if postIndex < 0 {
34214 return ErrInvalidLengthThetest
34215 }
34216 if postIndex > l {
34217 return io.ErrUnexpectedEOF
34218 }
34219 var elementCount int
34220 var count int
34221 for _, integer := range dAtA[iNdEx:postIndex] {
34222 if integer < 128 {
34223 count++
34224 }
34225 }
34226 elementCount = count
34227 if elementCount != 0 && len(m.Field5) == 0 {
34228 m.Field5 = make([]uint32, 0, elementCount)
34229 }
34230 for iNdEx < postIndex {
34231 var v uint32
34232 for shift := uint(0); ; shift += 7 {
34233 if shift >= 64 {
34234 return ErrIntOverflowThetest
34235 }
34236 if iNdEx >= l {
34237 return io.ErrUnexpectedEOF
34238 }
34239 b := dAtA[iNdEx]
34240 iNdEx++
34241 v |= uint32(b&0x7F) << shift
34242 if b < 0x80 {
34243 break
34244 }
34245 }
34246 m.Field5 = append(m.Field5, v)
34247 }
34248 } else {
34249 return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
34250 }
34251 case 6:
34252 if wireType == 0 {
34253 var v uint64
34254 for shift := uint(0); ; shift += 7 {
34255 if shift >= 64 {
34256 return ErrIntOverflowThetest
34257 }
34258 if iNdEx >= l {
34259 return io.ErrUnexpectedEOF
34260 }
34261 b := dAtA[iNdEx]
34262 iNdEx++
34263 v |= uint64(b&0x7F) << shift
34264 if b < 0x80 {
34265 break
34266 }
34267 }
34268 m.Field6 = append(m.Field6, v)
34269 } else if wireType == 2 {
34270 var packedLen int
34271 for shift := uint(0); ; shift += 7 {
34272 if shift >= 64 {
34273 return ErrIntOverflowThetest
34274 }
34275 if iNdEx >= l {
34276 return io.ErrUnexpectedEOF
34277 }
34278 b := dAtA[iNdEx]
34279 iNdEx++
34280 packedLen |= int(b&0x7F) << shift
34281 if b < 0x80 {
34282 break
34283 }
34284 }
34285 if packedLen < 0 {
34286 return ErrInvalidLengthThetest
34287 }
34288 postIndex := iNdEx + packedLen
34289 if postIndex < 0 {
34290 return ErrInvalidLengthThetest
34291 }
34292 if postIndex > l {
34293 return io.ErrUnexpectedEOF
34294 }
34295 var elementCount int
34296 var count int
34297 for _, integer := range dAtA[iNdEx:postIndex] {
34298 if integer < 128 {
34299 count++
34300 }
34301 }
34302 elementCount = count
34303 if elementCount != 0 && len(m.Field6) == 0 {
34304 m.Field6 = make([]uint64, 0, elementCount)
34305 }
34306 for iNdEx < postIndex {
34307 var v uint64
34308 for shift := uint(0); ; shift += 7 {
34309 if shift >= 64 {
34310 return ErrIntOverflowThetest
34311 }
34312 if iNdEx >= l {
34313 return io.ErrUnexpectedEOF
34314 }
34315 b := dAtA[iNdEx]
34316 iNdEx++
34317 v |= uint64(b&0x7F) << shift
34318 if b < 0x80 {
34319 break
34320 }
34321 }
34322 m.Field6 = append(m.Field6, v)
34323 }
34324 } else {
34325 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
34326 }
34327 case 7:
34328 if wireType == 0 {
34329 var v int32
34330 for shift := uint(0); ; shift += 7 {
34331 if shift >= 64 {
34332 return ErrIntOverflowThetest
34333 }
34334 if iNdEx >= l {
34335 return io.ErrUnexpectedEOF
34336 }
34337 b := dAtA[iNdEx]
34338 iNdEx++
34339 v |= int32(b&0x7F) << shift
34340 if b < 0x80 {
34341 break
34342 }
34343 }
34344 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
34345 m.Field7 = append(m.Field7, v)
34346 } else if wireType == 2 {
34347 var packedLen int
34348 for shift := uint(0); ; shift += 7 {
34349 if shift >= 64 {
34350 return ErrIntOverflowThetest
34351 }
34352 if iNdEx >= l {
34353 return io.ErrUnexpectedEOF
34354 }
34355 b := dAtA[iNdEx]
34356 iNdEx++
34357 packedLen |= int(b&0x7F) << shift
34358 if b < 0x80 {
34359 break
34360 }
34361 }
34362 if packedLen < 0 {
34363 return ErrInvalidLengthThetest
34364 }
34365 postIndex := iNdEx + packedLen
34366 if postIndex < 0 {
34367 return ErrInvalidLengthThetest
34368 }
34369 if postIndex > l {
34370 return io.ErrUnexpectedEOF
34371 }
34372 var elementCount int
34373 var count int
34374 for _, integer := range dAtA[iNdEx:postIndex] {
34375 if integer < 128 {
34376 count++
34377 }
34378 }
34379 elementCount = count
34380 if elementCount != 0 && len(m.Field7) == 0 {
34381 m.Field7 = make([]int32, 0, elementCount)
34382 }
34383 for iNdEx < postIndex {
34384 var v int32
34385 for shift := uint(0); ; shift += 7 {
34386 if shift >= 64 {
34387 return ErrIntOverflowThetest
34388 }
34389 if iNdEx >= l {
34390 return io.ErrUnexpectedEOF
34391 }
34392 b := dAtA[iNdEx]
34393 iNdEx++
34394 v |= int32(b&0x7F) << shift
34395 if b < 0x80 {
34396 break
34397 }
34398 }
34399 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
34400 m.Field7 = append(m.Field7, v)
34401 }
34402 } else {
34403 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
34404 }
34405 case 8:
34406 if wireType == 0 {
34407 var v uint64
34408 for shift := uint(0); ; shift += 7 {
34409 if shift >= 64 {
34410 return ErrIntOverflowThetest
34411 }
34412 if iNdEx >= l {
34413 return io.ErrUnexpectedEOF
34414 }
34415 b := dAtA[iNdEx]
34416 iNdEx++
34417 v |= uint64(b&0x7F) << shift
34418 if b < 0x80 {
34419 break
34420 }
34421 }
34422 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
34423 m.Field8 = append(m.Field8, int64(v))
34424 } else if wireType == 2 {
34425 var packedLen int
34426 for shift := uint(0); ; shift += 7 {
34427 if shift >= 64 {
34428 return ErrIntOverflowThetest
34429 }
34430 if iNdEx >= l {
34431 return io.ErrUnexpectedEOF
34432 }
34433 b := dAtA[iNdEx]
34434 iNdEx++
34435 packedLen |= int(b&0x7F) << shift
34436 if b < 0x80 {
34437 break
34438 }
34439 }
34440 if packedLen < 0 {
34441 return ErrInvalidLengthThetest
34442 }
34443 postIndex := iNdEx + packedLen
34444 if postIndex < 0 {
34445 return ErrInvalidLengthThetest
34446 }
34447 if postIndex > l {
34448 return io.ErrUnexpectedEOF
34449 }
34450 var elementCount int
34451 var count int
34452 for _, integer := range dAtA[iNdEx:postIndex] {
34453 if integer < 128 {
34454 count++
34455 }
34456 }
34457 elementCount = count
34458 if elementCount != 0 && len(m.Field8) == 0 {
34459 m.Field8 = make([]int64, 0, elementCount)
34460 }
34461 for iNdEx < postIndex {
34462 var v uint64
34463 for shift := uint(0); ; shift += 7 {
34464 if shift >= 64 {
34465 return ErrIntOverflowThetest
34466 }
34467 if iNdEx >= l {
34468 return io.ErrUnexpectedEOF
34469 }
34470 b := dAtA[iNdEx]
34471 iNdEx++
34472 v |= uint64(b&0x7F) << shift
34473 if b < 0x80 {
34474 break
34475 }
34476 }
34477 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
34478 m.Field8 = append(m.Field8, int64(v))
34479 }
34480 } else {
34481 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
34482 }
34483 case 9:
34484 if wireType == 5 {
34485 var v uint32
34486 if (iNdEx + 4) > l {
34487 return io.ErrUnexpectedEOF
34488 }
34489 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
34490 iNdEx += 4
34491 m.Field9 = append(m.Field9, v)
34492 } else if wireType == 2 {
34493 var packedLen int
34494 for shift := uint(0); ; shift += 7 {
34495 if shift >= 64 {
34496 return ErrIntOverflowThetest
34497 }
34498 if iNdEx >= l {
34499 return io.ErrUnexpectedEOF
34500 }
34501 b := dAtA[iNdEx]
34502 iNdEx++
34503 packedLen |= int(b&0x7F) << shift
34504 if b < 0x80 {
34505 break
34506 }
34507 }
34508 if packedLen < 0 {
34509 return ErrInvalidLengthThetest
34510 }
34511 postIndex := iNdEx + packedLen
34512 if postIndex < 0 {
34513 return ErrInvalidLengthThetest
34514 }
34515 if postIndex > l {
34516 return io.ErrUnexpectedEOF
34517 }
34518 var elementCount int
34519 elementCount = packedLen / 4
34520 if elementCount != 0 && len(m.Field9) == 0 {
34521 m.Field9 = make([]uint32, 0, elementCount)
34522 }
34523 for iNdEx < postIndex {
34524 var v uint32
34525 if (iNdEx + 4) > l {
34526 return io.ErrUnexpectedEOF
34527 }
34528 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
34529 iNdEx += 4
34530 m.Field9 = append(m.Field9, v)
34531 }
34532 } else {
34533 return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
34534 }
34535 case 10:
34536 if wireType == 5 {
34537 var v int32
34538 if (iNdEx + 4) > l {
34539 return io.ErrUnexpectedEOF
34540 }
34541 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
34542 iNdEx += 4
34543 m.Field10 = append(m.Field10, v)
34544 } else if wireType == 2 {
34545 var packedLen int
34546 for shift := uint(0); ; shift += 7 {
34547 if shift >= 64 {
34548 return ErrIntOverflowThetest
34549 }
34550 if iNdEx >= l {
34551 return io.ErrUnexpectedEOF
34552 }
34553 b := dAtA[iNdEx]
34554 iNdEx++
34555 packedLen |= int(b&0x7F) << shift
34556 if b < 0x80 {
34557 break
34558 }
34559 }
34560 if packedLen < 0 {
34561 return ErrInvalidLengthThetest
34562 }
34563 postIndex := iNdEx + packedLen
34564 if postIndex < 0 {
34565 return ErrInvalidLengthThetest
34566 }
34567 if postIndex > l {
34568 return io.ErrUnexpectedEOF
34569 }
34570 var elementCount int
34571 elementCount = packedLen / 4
34572 if elementCount != 0 && len(m.Field10) == 0 {
34573 m.Field10 = make([]int32, 0, elementCount)
34574 }
34575 for iNdEx < postIndex {
34576 var v int32
34577 if (iNdEx + 4) > l {
34578 return io.ErrUnexpectedEOF
34579 }
34580 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
34581 iNdEx += 4
34582 m.Field10 = append(m.Field10, v)
34583 }
34584 } else {
34585 return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
34586 }
34587 case 11:
34588 if wireType == 1 {
34589 var v uint64
34590 if (iNdEx + 8) > l {
34591 return io.ErrUnexpectedEOF
34592 }
34593 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
34594 iNdEx += 8
34595 m.Field11 = append(m.Field11, v)
34596 } else if wireType == 2 {
34597 var packedLen int
34598 for shift := uint(0); ; shift += 7 {
34599 if shift >= 64 {
34600 return ErrIntOverflowThetest
34601 }
34602 if iNdEx >= l {
34603 return io.ErrUnexpectedEOF
34604 }
34605 b := dAtA[iNdEx]
34606 iNdEx++
34607 packedLen |= int(b&0x7F) << shift
34608 if b < 0x80 {
34609 break
34610 }
34611 }
34612 if packedLen < 0 {
34613 return ErrInvalidLengthThetest
34614 }
34615 postIndex := iNdEx + packedLen
34616 if postIndex < 0 {
34617 return ErrInvalidLengthThetest
34618 }
34619 if postIndex > l {
34620 return io.ErrUnexpectedEOF
34621 }
34622 var elementCount int
34623 elementCount = packedLen / 8
34624 if elementCount != 0 && len(m.Field11) == 0 {
34625 m.Field11 = make([]uint64, 0, elementCount)
34626 }
34627 for iNdEx < postIndex {
34628 var v uint64
34629 if (iNdEx + 8) > l {
34630 return io.ErrUnexpectedEOF
34631 }
34632 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
34633 iNdEx += 8
34634 m.Field11 = append(m.Field11, v)
34635 }
34636 } else {
34637 return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
34638 }
34639 case 12:
34640 if wireType == 1 {
34641 var v int64
34642 if (iNdEx + 8) > l {
34643 return io.ErrUnexpectedEOF
34644 }
34645 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
34646 iNdEx += 8
34647 m.Field12 = append(m.Field12, v)
34648 } else if wireType == 2 {
34649 var packedLen int
34650 for shift := uint(0); ; shift += 7 {
34651 if shift >= 64 {
34652 return ErrIntOverflowThetest
34653 }
34654 if iNdEx >= l {
34655 return io.ErrUnexpectedEOF
34656 }
34657 b := dAtA[iNdEx]
34658 iNdEx++
34659 packedLen |= int(b&0x7F) << shift
34660 if b < 0x80 {
34661 break
34662 }
34663 }
34664 if packedLen < 0 {
34665 return ErrInvalidLengthThetest
34666 }
34667 postIndex := iNdEx + packedLen
34668 if postIndex < 0 {
34669 return ErrInvalidLengthThetest
34670 }
34671 if postIndex > l {
34672 return io.ErrUnexpectedEOF
34673 }
34674 var elementCount int
34675 elementCount = packedLen / 8
34676 if elementCount != 0 && len(m.Field12) == 0 {
34677 m.Field12 = make([]int64, 0, elementCount)
34678 }
34679 for iNdEx < postIndex {
34680 var v int64
34681 if (iNdEx + 8) > l {
34682 return io.ErrUnexpectedEOF
34683 }
34684 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
34685 iNdEx += 8
34686 m.Field12 = append(m.Field12, v)
34687 }
34688 } else {
34689 return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
34690 }
34691 case 13:
34692 if wireType == 0 {
34693 var v int
34694 for shift := uint(0); ; shift += 7 {
34695 if shift >= 64 {
34696 return ErrIntOverflowThetest
34697 }
34698 if iNdEx >= l {
34699 return io.ErrUnexpectedEOF
34700 }
34701 b := dAtA[iNdEx]
34702 iNdEx++
34703 v |= int(b&0x7F) << shift
34704 if b < 0x80 {
34705 break
34706 }
34707 }
34708 m.Field13 = append(m.Field13, bool(v != 0))
34709 } else if wireType == 2 {
34710 var packedLen int
34711 for shift := uint(0); ; shift += 7 {
34712 if shift >= 64 {
34713 return ErrIntOverflowThetest
34714 }
34715 if iNdEx >= l {
34716 return io.ErrUnexpectedEOF
34717 }
34718 b := dAtA[iNdEx]
34719 iNdEx++
34720 packedLen |= int(b&0x7F) << shift
34721 if b < 0x80 {
34722 break
34723 }
34724 }
34725 if packedLen < 0 {
34726 return ErrInvalidLengthThetest
34727 }
34728 postIndex := iNdEx + packedLen
34729 if postIndex < 0 {
34730 return ErrInvalidLengthThetest
34731 }
34732 if postIndex > l {
34733 return io.ErrUnexpectedEOF
34734 }
34735 var elementCount int
34736 elementCount = packedLen
34737 if elementCount != 0 && len(m.Field13) == 0 {
34738 m.Field13 = make([]bool, 0, elementCount)
34739 }
34740 for iNdEx < postIndex {
34741 var v int
34742 for shift := uint(0); ; shift += 7 {
34743 if shift >= 64 {
34744 return ErrIntOverflowThetest
34745 }
34746 if iNdEx >= l {
34747 return io.ErrUnexpectedEOF
34748 }
34749 b := dAtA[iNdEx]
34750 iNdEx++
34751 v |= int(b&0x7F) << shift
34752 if b < 0x80 {
34753 break
34754 }
34755 }
34756 m.Field13 = append(m.Field13, bool(v != 0))
34757 }
34758 } else {
34759 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
34760 }
34761 case 14:
34762 if wireType != 2 {
34763 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
34764 }
34765 var stringLen uint64
34766 for shift := uint(0); ; shift += 7 {
34767 if shift >= 64 {
34768 return ErrIntOverflowThetest
34769 }
34770 if iNdEx >= l {
34771 return io.ErrUnexpectedEOF
34772 }
34773 b := dAtA[iNdEx]
34774 iNdEx++
34775 stringLen |= uint64(b&0x7F) << shift
34776 if b < 0x80 {
34777 break
34778 }
34779 }
34780 intStringLen := int(stringLen)
34781 if intStringLen < 0 {
34782 return ErrInvalidLengthThetest
34783 }
34784 postIndex := iNdEx + intStringLen
34785 if postIndex < 0 {
34786 return ErrInvalidLengthThetest
34787 }
34788 if postIndex > l {
34789 return io.ErrUnexpectedEOF
34790 }
34791 m.Field14 = append(m.Field14, string(dAtA[iNdEx:postIndex]))
34792 iNdEx = postIndex
34793 case 15:
34794 if wireType != 2 {
34795 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
34796 }
34797 var byteLen int
34798 for shift := uint(0); ; shift += 7 {
34799 if shift >= 64 {
34800 return ErrIntOverflowThetest
34801 }
34802 if iNdEx >= l {
34803 return io.ErrUnexpectedEOF
34804 }
34805 b := dAtA[iNdEx]
34806 iNdEx++
34807 byteLen |= int(b&0x7F) << shift
34808 if b < 0x80 {
34809 break
34810 }
34811 }
34812 if byteLen < 0 {
34813 return ErrInvalidLengthThetest
34814 }
34815 postIndex := iNdEx + byteLen
34816 if postIndex < 0 {
34817 return ErrInvalidLengthThetest
34818 }
34819 if postIndex > l {
34820 return io.ErrUnexpectedEOF
34821 }
34822 m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx))
34823 copy(m.Field15[len(m.Field15)-1], dAtA[iNdEx:postIndex])
34824 iNdEx = postIndex
34825 default:
34826 iNdEx = preIndex
34827 skippy, err := skipThetest(dAtA[iNdEx:])
34828 if err != nil {
34829 return err
34830 }
34831 if (skippy < 0) || (iNdEx+skippy) < 0 {
34832 return ErrInvalidLengthThetest
34833 }
34834 if (iNdEx + skippy) > l {
34835 return io.ErrUnexpectedEOF
34836 }
34837 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
34838 iNdEx += skippy
34839 }
34840 }
34841
34842 if iNdEx > l {
34843 return io.ErrUnexpectedEOF
34844 }
34845 return nil
34846 }
34847 func (m *NidRepPackedNative) Unmarshal(dAtA []byte) error {
34848 l := len(dAtA)
34849 iNdEx := 0
34850 for iNdEx < l {
34851 preIndex := iNdEx
34852 var wire uint64
34853 for shift := uint(0); ; shift += 7 {
34854 if shift >= 64 {
34855 return ErrIntOverflowThetest
34856 }
34857 if iNdEx >= l {
34858 return io.ErrUnexpectedEOF
34859 }
34860 b := dAtA[iNdEx]
34861 iNdEx++
34862 wire |= uint64(b&0x7F) << shift
34863 if b < 0x80 {
34864 break
34865 }
34866 }
34867 fieldNum := int32(wire >> 3)
34868 wireType := int(wire & 0x7)
34869 if wireType == 4 {
34870 return fmt.Errorf("proto: NidRepPackedNative: wiretype end group for non-group")
34871 }
34872 if fieldNum <= 0 {
34873 return fmt.Errorf("proto: NidRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire)
34874 }
34875 switch fieldNum {
34876 case 1:
34877 if wireType == 1 {
34878 var v uint64
34879 if (iNdEx + 8) > l {
34880 return io.ErrUnexpectedEOF
34881 }
34882 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
34883 iNdEx += 8
34884 v2 := float64(math.Float64frombits(v))
34885 m.Field1 = append(m.Field1, v2)
34886 } else if wireType == 2 {
34887 var packedLen int
34888 for shift := uint(0); ; shift += 7 {
34889 if shift >= 64 {
34890 return ErrIntOverflowThetest
34891 }
34892 if iNdEx >= l {
34893 return io.ErrUnexpectedEOF
34894 }
34895 b := dAtA[iNdEx]
34896 iNdEx++
34897 packedLen |= int(b&0x7F) << shift
34898 if b < 0x80 {
34899 break
34900 }
34901 }
34902 if packedLen < 0 {
34903 return ErrInvalidLengthThetest
34904 }
34905 postIndex := iNdEx + packedLen
34906 if postIndex < 0 {
34907 return ErrInvalidLengthThetest
34908 }
34909 if postIndex > l {
34910 return io.ErrUnexpectedEOF
34911 }
34912 var elementCount int
34913 elementCount = packedLen / 8
34914 if elementCount != 0 && len(m.Field1) == 0 {
34915 m.Field1 = make([]float64, 0, elementCount)
34916 }
34917 for iNdEx < postIndex {
34918 var v uint64
34919 if (iNdEx + 8) > l {
34920 return io.ErrUnexpectedEOF
34921 }
34922 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
34923 iNdEx += 8
34924 v2 := float64(math.Float64frombits(v))
34925 m.Field1 = append(m.Field1, v2)
34926 }
34927 } else {
34928 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
34929 }
34930 case 2:
34931 if wireType == 5 {
34932 var v uint32
34933 if (iNdEx + 4) > l {
34934 return io.ErrUnexpectedEOF
34935 }
34936 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
34937 iNdEx += 4
34938 v2 := float32(math.Float32frombits(v))
34939 m.Field2 = append(m.Field2, v2)
34940 } else if wireType == 2 {
34941 var packedLen int
34942 for shift := uint(0); ; shift += 7 {
34943 if shift >= 64 {
34944 return ErrIntOverflowThetest
34945 }
34946 if iNdEx >= l {
34947 return io.ErrUnexpectedEOF
34948 }
34949 b := dAtA[iNdEx]
34950 iNdEx++
34951 packedLen |= int(b&0x7F) << shift
34952 if b < 0x80 {
34953 break
34954 }
34955 }
34956 if packedLen < 0 {
34957 return ErrInvalidLengthThetest
34958 }
34959 postIndex := iNdEx + packedLen
34960 if postIndex < 0 {
34961 return ErrInvalidLengthThetest
34962 }
34963 if postIndex > l {
34964 return io.ErrUnexpectedEOF
34965 }
34966 var elementCount int
34967 elementCount = packedLen / 4
34968 if elementCount != 0 && len(m.Field2) == 0 {
34969 m.Field2 = make([]float32, 0, elementCount)
34970 }
34971 for iNdEx < postIndex {
34972 var v uint32
34973 if (iNdEx + 4) > l {
34974 return io.ErrUnexpectedEOF
34975 }
34976 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
34977 iNdEx += 4
34978 v2 := float32(math.Float32frombits(v))
34979 m.Field2 = append(m.Field2, v2)
34980 }
34981 } else {
34982 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
34983 }
34984 case 3:
34985 if wireType == 0 {
34986 var v int32
34987 for shift := uint(0); ; shift += 7 {
34988 if shift >= 64 {
34989 return ErrIntOverflowThetest
34990 }
34991 if iNdEx >= l {
34992 return io.ErrUnexpectedEOF
34993 }
34994 b := dAtA[iNdEx]
34995 iNdEx++
34996 v |= int32(b&0x7F) << shift
34997 if b < 0x80 {
34998 break
34999 }
35000 }
35001 m.Field3 = append(m.Field3, v)
35002 } else if wireType == 2 {
35003 var packedLen int
35004 for shift := uint(0); ; shift += 7 {
35005 if shift >= 64 {
35006 return ErrIntOverflowThetest
35007 }
35008 if iNdEx >= l {
35009 return io.ErrUnexpectedEOF
35010 }
35011 b := dAtA[iNdEx]
35012 iNdEx++
35013 packedLen |= int(b&0x7F) << shift
35014 if b < 0x80 {
35015 break
35016 }
35017 }
35018 if packedLen < 0 {
35019 return ErrInvalidLengthThetest
35020 }
35021 postIndex := iNdEx + packedLen
35022 if postIndex < 0 {
35023 return ErrInvalidLengthThetest
35024 }
35025 if postIndex > l {
35026 return io.ErrUnexpectedEOF
35027 }
35028 var elementCount int
35029 var count int
35030 for _, integer := range dAtA[iNdEx:postIndex] {
35031 if integer < 128 {
35032 count++
35033 }
35034 }
35035 elementCount = count
35036 if elementCount != 0 && len(m.Field3) == 0 {
35037 m.Field3 = make([]int32, 0, elementCount)
35038 }
35039 for iNdEx < postIndex {
35040 var v int32
35041 for shift := uint(0); ; shift += 7 {
35042 if shift >= 64 {
35043 return ErrIntOverflowThetest
35044 }
35045 if iNdEx >= l {
35046 return io.ErrUnexpectedEOF
35047 }
35048 b := dAtA[iNdEx]
35049 iNdEx++
35050 v |= int32(b&0x7F) << shift
35051 if b < 0x80 {
35052 break
35053 }
35054 }
35055 m.Field3 = append(m.Field3, v)
35056 }
35057 } else {
35058 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
35059 }
35060 case 4:
35061 if wireType == 0 {
35062 var v int64
35063 for shift := uint(0); ; shift += 7 {
35064 if shift >= 64 {
35065 return ErrIntOverflowThetest
35066 }
35067 if iNdEx >= l {
35068 return io.ErrUnexpectedEOF
35069 }
35070 b := dAtA[iNdEx]
35071 iNdEx++
35072 v |= int64(b&0x7F) << shift
35073 if b < 0x80 {
35074 break
35075 }
35076 }
35077 m.Field4 = append(m.Field4, v)
35078 } else if wireType == 2 {
35079 var packedLen int
35080 for shift := uint(0); ; shift += 7 {
35081 if shift >= 64 {
35082 return ErrIntOverflowThetest
35083 }
35084 if iNdEx >= l {
35085 return io.ErrUnexpectedEOF
35086 }
35087 b := dAtA[iNdEx]
35088 iNdEx++
35089 packedLen |= int(b&0x7F) << shift
35090 if b < 0x80 {
35091 break
35092 }
35093 }
35094 if packedLen < 0 {
35095 return ErrInvalidLengthThetest
35096 }
35097 postIndex := iNdEx + packedLen
35098 if postIndex < 0 {
35099 return ErrInvalidLengthThetest
35100 }
35101 if postIndex > l {
35102 return io.ErrUnexpectedEOF
35103 }
35104 var elementCount int
35105 var count int
35106 for _, integer := range dAtA[iNdEx:postIndex] {
35107 if integer < 128 {
35108 count++
35109 }
35110 }
35111 elementCount = count
35112 if elementCount != 0 && len(m.Field4) == 0 {
35113 m.Field4 = make([]int64, 0, elementCount)
35114 }
35115 for iNdEx < postIndex {
35116 var v int64
35117 for shift := uint(0); ; shift += 7 {
35118 if shift >= 64 {
35119 return ErrIntOverflowThetest
35120 }
35121 if iNdEx >= l {
35122 return io.ErrUnexpectedEOF
35123 }
35124 b := dAtA[iNdEx]
35125 iNdEx++
35126 v |= int64(b&0x7F) << shift
35127 if b < 0x80 {
35128 break
35129 }
35130 }
35131 m.Field4 = append(m.Field4, v)
35132 }
35133 } else {
35134 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
35135 }
35136 case 5:
35137 if wireType == 0 {
35138 var v uint32
35139 for shift := uint(0); ; shift += 7 {
35140 if shift >= 64 {
35141 return ErrIntOverflowThetest
35142 }
35143 if iNdEx >= l {
35144 return io.ErrUnexpectedEOF
35145 }
35146 b := dAtA[iNdEx]
35147 iNdEx++
35148 v |= uint32(b&0x7F) << shift
35149 if b < 0x80 {
35150 break
35151 }
35152 }
35153 m.Field5 = append(m.Field5, v)
35154 } else if wireType == 2 {
35155 var packedLen int
35156 for shift := uint(0); ; shift += 7 {
35157 if shift >= 64 {
35158 return ErrIntOverflowThetest
35159 }
35160 if iNdEx >= l {
35161 return io.ErrUnexpectedEOF
35162 }
35163 b := dAtA[iNdEx]
35164 iNdEx++
35165 packedLen |= int(b&0x7F) << shift
35166 if b < 0x80 {
35167 break
35168 }
35169 }
35170 if packedLen < 0 {
35171 return ErrInvalidLengthThetest
35172 }
35173 postIndex := iNdEx + packedLen
35174 if postIndex < 0 {
35175 return ErrInvalidLengthThetest
35176 }
35177 if postIndex > l {
35178 return io.ErrUnexpectedEOF
35179 }
35180 var elementCount int
35181 var count int
35182 for _, integer := range dAtA[iNdEx:postIndex] {
35183 if integer < 128 {
35184 count++
35185 }
35186 }
35187 elementCount = count
35188 if elementCount != 0 && len(m.Field5) == 0 {
35189 m.Field5 = make([]uint32, 0, elementCount)
35190 }
35191 for iNdEx < postIndex {
35192 var v uint32
35193 for shift := uint(0); ; shift += 7 {
35194 if shift >= 64 {
35195 return ErrIntOverflowThetest
35196 }
35197 if iNdEx >= l {
35198 return io.ErrUnexpectedEOF
35199 }
35200 b := dAtA[iNdEx]
35201 iNdEx++
35202 v |= uint32(b&0x7F) << shift
35203 if b < 0x80 {
35204 break
35205 }
35206 }
35207 m.Field5 = append(m.Field5, v)
35208 }
35209 } else {
35210 return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
35211 }
35212 case 6:
35213 if wireType == 0 {
35214 var v uint64
35215 for shift := uint(0); ; shift += 7 {
35216 if shift >= 64 {
35217 return ErrIntOverflowThetest
35218 }
35219 if iNdEx >= l {
35220 return io.ErrUnexpectedEOF
35221 }
35222 b := dAtA[iNdEx]
35223 iNdEx++
35224 v |= uint64(b&0x7F) << shift
35225 if b < 0x80 {
35226 break
35227 }
35228 }
35229 m.Field6 = append(m.Field6, v)
35230 } else if wireType == 2 {
35231 var packedLen int
35232 for shift := uint(0); ; shift += 7 {
35233 if shift >= 64 {
35234 return ErrIntOverflowThetest
35235 }
35236 if iNdEx >= l {
35237 return io.ErrUnexpectedEOF
35238 }
35239 b := dAtA[iNdEx]
35240 iNdEx++
35241 packedLen |= int(b&0x7F) << shift
35242 if b < 0x80 {
35243 break
35244 }
35245 }
35246 if packedLen < 0 {
35247 return ErrInvalidLengthThetest
35248 }
35249 postIndex := iNdEx + packedLen
35250 if postIndex < 0 {
35251 return ErrInvalidLengthThetest
35252 }
35253 if postIndex > l {
35254 return io.ErrUnexpectedEOF
35255 }
35256 var elementCount int
35257 var count int
35258 for _, integer := range dAtA[iNdEx:postIndex] {
35259 if integer < 128 {
35260 count++
35261 }
35262 }
35263 elementCount = count
35264 if elementCount != 0 && len(m.Field6) == 0 {
35265 m.Field6 = make([]uint64, 0, elementCount)
35266 }
35267 for iNdEx < postIndex {
35268 var v uint64
35269 for shift := uint(0); ; shift += 7 {
35270 if shift >= 64 {
35271 return ErrIntOverflowThetest
35272 }
35273 if iNdEx >= l {
35274 return io.ErrUnexpectedEOF
35275 }
35276 b := dAtA[iNdEx]
35277 iNdEx++
35278 v |= uint64(b&0x7F) << shift
35279 if b < 0x80 {
35280 break
35281 }
35282 }
35283 m.Field6 = append(m.Field6, v)
35284 }
35285 } else {
35286 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
35287 }
35288 case 7:
35289 if wireType == 0 {
35290 var v int32
35291 for shift := uint(0); ; shift += 7 {
35292 if shift >= 64 {
35293 return ErrIntOverflowThetest
35294 }
35295 if iNdEx >= l {
35296 return io.ErrUnexpectedEOF
35297 }
35298 b := dAtA[iNdEx]
35299 iNdEx++
35300 v |= int32(b&0x7F) << shift
35301 if b < 0x80 {
35302 break
35303 }
35304 }
35305 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
35306 m.Field7 = append(m.Field7, v)
35307 } else if wireType == 2 {
35308 var packedLen int
35309 for shift := uint(0); ; shift += 7 {
35310 if shift >= 64 {
35311 return ErrIntOverflowThetest
35312 }
35313 if iNdEx >= l {
35314 return io.ErrUnexpectedEOF
35315 }
35316 b := dAtA[iNdEx]
35317 iNdEx++
35318 packedLen |= int(b&0x7F) << shift
35319 if b < 0x80 {
35320 break
35321 }
35322 }
35323 if packedLen < 0 {
35324 return ErrInvalidLengthThetest
35325 }
35326 postIndex := iNdEx + packedLen
35327 if postIndex < 0 {
35328 return ErrInvalidLengthThetest
35329 }
35330 if postIndex > l {
35331 return io.ErrUnexpectedEOF
35332 }
35333 var elementCount int
35334 var count int
35335 for _, integer := range dAtA[iNdEx:postIndex] {
35336 if integer < 128 {
35337 count++
35338 }
35339 }
35340 elementCount = count
35341 if elementCount != 0 && len(m.Field7) == 0 {
35342 m.Field7 = make([]int32, 0, elementCount)
35343 }
35344 for iNdEx < postIndex {
35345 var v int32
35346 for shift := uint(0); ; shift += 7 {
35347 if shift >= 64 {
35348 return ErrIntOverflowThetest
35349 }
35350 if iNdEx >= l {
35351 return io.ErrUnexpectedEOF
35352 }
35353 b := dAtA[iNdEx]
35354 iNdEx++
35355 v |= int32(b&0x7F) << shift
35356 if b < 0x80 {
35357 break
35358 }
35359 }
35360 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
35361 m.Field7 = append(m.Field7, v)
35362 }
35363 } else {
35364 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
35365 }
35366 case 8:
35367 if wireType == 0 {
35368 var v uint64
35369 for shift := uint(0); ; shift += 7 {
35370 if shift >= 64 {
35371 return ErrIntOverflowThetest
35372 }
35373 if iNdEx >= l {
35374 return io.ErrUnexpectedEOF
35375 }
35376 b := dAtA[iNdEx]
35377 iNdEx++
35378 v |= uint64(b&0x7F) << shift
35379 if b < 0x80 {
35380 break
35381 }
35382 }
35383 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
35384 m.Field8 = append(m.Field8, int64(v))
35385 } else if wireType == 2 {
35386 var packedLen int
35387 for shift := uint(0); ; shift += 7 {
35388 if shift >= 64 {
35389 return ErrIntOverflowThetest
35390 }
35391 if iNdEx >= l {
35392 return io.ErrUnexpectedEOF
35393 }
35394 b := dAtA[iNdEx]
35395 iNdEx++
35396 packedLen |= int(b&0x7F) << shift
35397 if b < 0x80 {
35398 break
35399 }
35400 }
35401 if packedLen < 0 {
35402 return ErrInvalidLengthThetest
35403 }
35404 postIndex := iNdEx + packedLen
35405 if postIndex < 0 {
35406 return ErrInvalidLengthThetest
35407 }
35408 if postIndex > l {
35409 return io.ErrUnexpectedEOF
35410 }
35411 var elementCount int
35412 var count int
35413 for _, integer := range dAtA[iNdEx:postIndex] {
35414 if integer < 128 {
35415 count++
35416 }
35417 }
35418 elementCount = count
35419 if elementCount != 0 && len(m.Field8) == 0 {
35420 m.Field8 = make([]int64, 0, elementCount)
35421 }
35422 for iNdEx < postIndex {
35423 var v uint64
35424 for shift := uint(0); ; shift += 7 {
35425 if shift >= 64 {
35426 return ErrIntOverflowThetest
35427 }
35428 if iNdEx >= l {
35429 return io.ErrUnexpectedEOF
35430 }
35431 b := dAtA[iNdEx]
35432 iNdEx++
35433 v |= uint64(b&0x7F) << shift
35434 if b < 0x80 {
35435 break
35436 }
35437 }
35438 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
35439 m.Field8 = append(m.Field8, int64(v))
35440 }
35441 } else {
35442 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
35443 }
35444 case 9:
35445 if wireType == 5 {
35446 var v uint32
35447 if (iNdEx + 4) > l {
35448 return io.ErrUnexpectedEOF
35449 }
35450 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
35451 iNdEx += 4
35452 m.Field9 = append(m.Field9, v)
35453 } else if wireType == 2 {
35454 var packedLen int
35455 for shift := uint(0); ; shift += 7 {
35456 if shift >= 64 {
35457 return ErrIntOverflowThetest
35458 }
35459 if iNdEx >= l {
35460 return io.ErrUnexpectedEOF
35461 }
35462 b := dAtA[iNdEx]
35463 iNdEx++
35464 packedLen |= int(b&0x7F) << shift
35465 if b < 0x80 {
35466 break
35467 }
35468 }
35469 if packedLen < 0 {
35470 return ErrInvalidLengthThetest
35471 }
35472 postIndex := iNdEx + packedLen
35473 if postIndex < 0 {
35474 return ErrInvalidLengthThetest
35475 }
35476 if postIndex > l {
35477 return io.ErrUnexpectedEOF
35478 }
35479 var elementCount int
35480 elementCount = packedLen / 4
35481 if elementCount != 0 && len(m.Field9) == 0 {
35482 m.Field9 = make([]uint32, 0, elementCount)
35483 }
35484 for iNdEx < postIndex {
35485 var v uint32
35486 if (iNdEx + 4) > l {
35487 return io.ErrUnexpectedEOF
35488 }
35489 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
35490 iNdEx += 4
35491 m.Field9 = append(m.Field9, v)
35492 }
35493 } else {
35494 return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
35495 }
35496 case 10:
35497 if wireType == 5 {
35498 var v int32
35499 if (iNdEx + 4) > l {
35500 return io.ErrUnexpectedEOF
35501 }
35502 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
35503 iNdEx += 4
35504 m.Field10 = append(m.Field10, v)
35505 } else if wireType == 2 {
35506 var packedLen int
35507 for shift := uint(0); ; shift += 7 {
35508 if shift >= 64 {
35509 return ErrIntOverflowThetest
35510 }
35511 if iNdEx >= l {
35512 return io.ErrUnexpectedEOF
35513 }
35514 b := dAtA[iNdEx]
35515 iNdEx++
35516 packedLen |= int(b&0x7F) << shift
35517 if b < 0x80 {
35518 break
35519 }
35520 }
35521 if packedLen < 0 {
35522 return ErrInvalidLengthThetest
35523 }
35524 postIndex := iNdEx + packedLen
35525 if postIndex < 0 {
35526 return ErrInvalidLengthThetest
35527 }
35528 if postIndex > l {
35529 return io.ErrUnexpectedEOF
35530 }
35531 var elementCount int
35532 elementCount = packedLen / 4
35533 if elementCount != 0 && len(m.Field10) == 0 {
35534 m.Field10 = make([]int32, 0, elementCount)
35535 }
35536 for iNdEx < postIndex {
35537 var v int32
35538 if (iNdEx + 4) > l {
35539 return io.ErrUnexpectedEOF
35540 }
35541 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
35542 iNdEx += 4
35543 m.Field10 = append(m.Field10, v)
35544 }
35545 } else {
35546 return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
35547 }
35548 case 11:
35549 if wireType == 1 {
35550 var v uint64
35551 if (iNdEx + 8) > l {
35552 return io.ErrUnexpectedEOF
35553 }
35554 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
35555 iNdEx += 8
35556 m.Field11 = append(m.Field11, v)
35557 } else if wireType == 2 {
35558 var packedLen int
35559 for shift := uint(0); ; shift += 7 {
35560 if shift >= 64 {
35561 return ErrIntOverflowThetest
35562 }
35563 if iNdEx >= l {
35564 return io.ErrUnexpectedEOF
35565 }
35566 b := dAtA[iNdEx]
35567 iNdEx++
35568 packedLen |= int(b&0x7F) << shift
35569 if b < 0x80 {
35570 break
35571 }
35572 }
35573 if packedLen < 0 {
35574 return ErrInvalidLengthThetest
35575 }
35576 postIndex := iNdEx + packedLen
35577 if postIndex < 0 {
35578 return ErrInvalidLengthThetest
35579 }
35580 if postIndex > l {
35581 return io.ErrUnexpectedEOF
35582 }
35583 var elementCount int
35584 elementCount = packedLen / 8
35585 if elementCount != 0 && len(m.Field11) == 0 {
35586 m.Field11 = make([]uint64, 0, elementCount)
35587 }
35588 for iNdEx < postIndex {
35589 var v uint64
35590 if (iNdEx + 8) > l {
35591 return io.ErrUnexpectedEOF
35592 }
35593 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
35594 iNdEx += 8
35595 m.Field11 = append(m.Field11, v)
35596 }
35597 } else {
35598 return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
35599 }
35600 case 12:
35601 if wireType == 1 {
35602 var v int64
35603 if (iNdEx + 8) > l {
35604 return io.ErrUnexpectedEOF
35605 }
35606 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
35607 iNdEx += 8
35608 m.Field12 = append(m.Field12, v)
35609 } else if wireType == 2 {
35610 var packedLen int
35611 for shift := uint(0); ; shift += 7 {
35612 if shift >= 64 {
35613 return ErrIntOverflowThetest
35614 }
35615 if iNdEx >= l {
35616 return io.ErrUnexpectedEOF
35617 }
35618 b := dAtA[iNdEx]
35619 iNdEx++
35620 packedLen |= int(b&0x7F) << shift
35621 if b < 0x80 {
35622 break
35623 }
35624 }
35625 if packedLen < 0 {
35626 return ErrInvalidLengthThetest
35627 }
35628 postIndex := iNdEx + packedLen
35629 if postIndex < 0 {
35630 return ErrInvalidLengthThetest
35631 }
35632 if postIndex > l {
35633 return io.ErrUnexpectedEOF
35634 }
35635 var elementCount int
35636 elementCount = packedLen / 8
35637 if elementCount != 0 && len(m.Field12) == 0 {
35638 m.Field12 = make([]int64, 0, elementCount)
35639 }
35640 for iNdEx < postIndex {
35641 var v int64
35642 if (iNdEx + 8) > l {
35643 return io.ErrUnexpectedEOF
35644 }
35645 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
35646 iNdEx += 8
35647 m.Field12 = append(m.Field12, v)
35648 }
35649 } else {
35650 return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
35651 }
35652 case 13:
35653 if wireType == 0 {
35654 var v int
35655 for shift := uint(0); ; shift += 7 {
35656 if shift >= 64 {
35657 return ErrIntOverflowThetest
35658 }
35659 if iNdEx >= l {
35660 return io.ErrUnexpectedEOF
35661 }
35662 b := dAtA[iNdEx]
35663 iNdEx++
35664 v |= int(b&0x7F) << shift
35665 if b < 0x80 {
35666 break
35667 }
35668 }
35669 m.Field13 = append(m.Field13, bool(v != 0))
35670 } else if wireType == 2 {
35671 var packedLen int
35672 for shift := uint(0); ; shift += 7 {
35673 if shift >= 64 {
35674 return ErrIntOverflowThetest
35675 }
35676 if iNdEx >= l {
35677 return io.ErrUnexpectedEOF
35678 }
35679 b := dAtA[iNdEx]
35680 iNdEx++
35681 packedLen |= int(b&0x7F) << shift
35682 if b < 0x80 {
35683 break
35684 }
35685 }
35686 if packedLen < 0 {
35687 return ErrInvalidLengthThetest
35688 }
35689 postIndex := iNdEx + packedLen
35690 if postIndex < 0 {
35691 return ErrInvalidLengthThetest
35692 }
35693 if postIndex > l {
35694 return io.ErrUnexpectedEOF
35695 }
35696 var elementCount int
35697 elementCount = packedLen
35698 if elementCount != 0 && len(m.Field13) == 0 {
35699 m.Field13 = make([]bool, 0, elementCount)
35700 }
35701 for iNdEx < postIndex {
35702 var v int
35703 for shift := uint(0); ; shift += 7 {
35704 if shift >= 64 {
35705 return ErrIntOverflowThetest
35706 }
35707 if iNdEx >= l {
35708 return io.ErrUnexpectedEOF
35709 }
35710 b := dAtA[iNdEx]
35711 iNdEx++
35712 v |= int(b&0x7F) << shift
35713 if b < 0x80 {
35714 break
35715 }
35716 }
35717 m.Field13 = append(m.Field13, bool(v != 0))
35718 }
35719 } else {
35720 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
35721 }
35722 default:
35723 iNdEx = preIndex
35724 skippy, err := skipThetest(dAtA[iNdEx:])
35725 if err != nil {
35726 return err
35727 }
35728 if (skippy < 0) || (iNdEx+skippy) < 0 {
35729 return ErrInvalidLengthThetest
35730 }
35731 if (iNdEx + skippy) > l {
35732 return io.ErrUnexpectedEOF
35733 }
35734 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
35735 iNdEx += skippy
35736 }
35737 }
35738
35739 if iNdEx > l {
35740 return io.ErrUnexpectedEOF
35741 }
35742 return nil
35743 }
35744 func (m *NinRepPackedNative) Unmarshal(dAtA []byte) error {
35745 l := len(dAtA)
35746 iNdEx := 0
35747 for iNdEx < l {
35748 preIndex := iNdEx
35749 var wire uint64
35750 for shift := uint(0); ; shift += 7 {
35751 if shift >= 64 {
35752 return ErrIntOverflowThetest
35753 }
35754 if iNdEx >= l {
35755 return io.ErrUnexpectedEOF
35756 }
35757 b := dAtA[iNdEx]
35758 iNdEx++
35759 wire |= uint64(b&0x7F) << shift
35760 if b < 0x80 {
35761 break
35762 }
35763 }
35764 fieldNum := int32(wire >> 3)
35765 wireType := int(wire & 0x7)
35766 if wireType == 4 {
35767 return fmt.Errorf("proto: NinRepPackedNative: wiretype end group for non-group")
35768 }
35769 if fieldNum <= 0 {
35770 return fmt.Errorf("proto: NinRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire)
35771 }
35772 switch fieldNum {
35773 case 1:
35774 if wireType == 1 {
35775 var v uint64
35776 if (iNdEx + 8) > l {
35777 return io.ErrUnexpectedEOF
35778 }
35779 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
35780 iNdEx += 8
35781 v2 := float64(math.Float64frombits(v))
35782 m.Field1 = append(m.Field1, v2)
35783 } else if wireType == 2 {
35784 var packedLen int
35785 for shift := uint(0); ; shift += 7 {
35786 if shift >= 64 {
35787 return ErrIntOverflowThetest
35788 }
35789 if iNdEx >= l {
35790 return io.ErrUnexpectedEOF
35791 }
35792 b := dAtA[iNdEx]
35793 iNdEx++
35794 packedLen |= int(b&0x7F) << shift
35795 if b < 0x80 {
35796 break
35797 }
35798 }
35799 if packedLen < 0 {
35800 return ErrInvalidLengthThetest
35801 }
35802 postIndex := iNdEx + packedLen
35803 if postIndex < 0 {
35804 return ErrInvalidLengthThetest
35805 }
35806 if postIndex > l {
35807 return io.ErrUnexpectedEOF
35808 }
35809 var elementCount int
35810 elementCount = packedLen / 8
35811 if elementCount != 0 && len(m.Field1) == 0 {
35812 m.Field1 = make([]float64, 0, elementCount)
35813 }
35814 for iNdEx < postIndex {
35815 var v uint64
35816 if (iNdEx + 8) > l {
35817 return io.ErrUnexpectedEOF
35818 }
35819 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
35820 iNdEx += 8
35821 v2 := float64(math.Float64frombits(v))
35822 m.Field1 = append(m.Field1, v2)
35823 }
35824 } else {
35825 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
35826 }
35827 case 2:
35828 if wireType == 5 {
35829 var v uint32
35830 if (iNdEx + 4) > l {
35831 return io.ErrUnexpectedEOF
35832 }
35833 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
35834 iNdEx += 4
35835 v2 := float32(math.Float32frombits(v))
35836 m.Field2 = append(m.Field2, v2)
35837 } else if wireType == 2 {
35838 var packedLen int
35839 for shift := uint(0); ; shift += 7 {
35840 if shift >= 64 {
35841 return ErrIntOverflowThetest
35842 }
35843 if iNdEx >= l {
35844 return io.ErrUnexpectedEOF
35845 }
35846 b := dAtA[iNdEx]
35847 iNdEx++
35848 packedLen |= int(b&0x7F) << shift
35849 if b < 0x80 {
35850 break
35851 }
35852 }
35853 if packedLen < 0 {
35854 return ErrInvalidLengthThetest
35855 }
35856 postIndex := iNdEx + packedLen
35857 if postIndex < 0 {
35858 return ErrInvalidLengthThetest
35859 }
35860 if postIndex > l {
35861 return io.ErrUnexpectedEOF
35862 }
35863 var elementCount int
35864 elementCount = packedLen / 4
35865 if elementCount != 0 && len(m.Field2) == 0 {
35866 m.Field2 = make([]float32, 0, elementCount)
35867 }
35868 for iNdEx < postIndex {
35869 var v uint32
35870 if (iNdEx + 4) > l {
35871 return io.ErrUnexpectedEOF
35872 }
35873 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
35874 iNdEx += 4
35875 v2 := float32(math.Float32frombits(v))
35876 m.Field2 = append(m.Field2, v2)
35877 }
35878 } else {
35879 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
35880 }
35881 case 3:
35882 if wireType == 0 {
35883 var v int32
35884 for shift := uint(0); ; shift += 7 {
35885 if shift >= 64 {
35886 return ErrIntOverflowThetest
35887 }
35888 if iNdEx >= l {
35889 return io.ErrUnexpectedEOF
35890 }
35891 b := dAtA[iNdEx]
35892 iNdEx++
35893 v |= int32(b&0x7F) << shift
35894 if b < 0x80 {
35895 break
35896 }
35897 }
35898 m.Field3 = append(m.Field3, v)
35899 } else if wireType == 2 {
35900 var packedLen int
35901 for shift := uint(0); ; shift += 7 {
35902 if shift >= 64 {
35903 return ErrIntOverflowThetest
35904 }
35905 if iNdEx >= l {
35906 return io.ErrUnexpectedEOF
35907 }
35908 b := dAtA[iNdEx]
35909 iNdEx++
35910 packedLen |= int(b&0x7F) << shift
35911 if b < 0x80 {
35912 break
35913 }
35914 }
35915 if packedLen < 0 {
35916 return ErrInvalidLengthThetest
35917 }
35918 postIndex := iNdEx + packedLen
35919 if postIndex < 0 {
35920 return ErrInvalidLengthThetest
35921 }
35922 if postIndex > l {
35923 return io.ErrUnexpectedEOF
35924 }
35925 var elementCount int
35926 var count int
35927 for _, integer := range dAtA[iNdEx:postIndex] {
35928 if integer < 128 {
35929 count++
35930 }
35931 }
35932 elementCount = count
35933 if elementCount != 0 && len(m.Field3) == 0 {
35934 m.Field3 = make([]int32, 0, elementCount)
35935 }
35936 for iNdEx < postIndex {
35937 var v int32
35938 for shift := uint(0); ; shift += 7 {
35939 if shift >= 64 {
35940 return ErrIntOverflowThetest
35941 }
35942 if iNdEx >= l {
35943 return io.ErrUnexpectedEOF
35944 }
35945 b := dAtA[iNdEx]
35946 iNdEx++
35947 v |= int32(b&0x7F) << shift
35948 if b < 0x80 {
35949 break
35950 }
35951 }
35952 m.Field3 = append(m.Field3, v)
35953 }
35954 } else {
35955 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
35956 }
35957 case 4:
35958 if wireType == 0 {
35959 var v int64
35960 for shift := uint(0); ; shift += 7 {
35961 if shift >= 64 {
35962 return ErrIntOverflowThetest
35963 }
35964 if iNdEx >= l {
35965 return io.ErrUnexpectedEOF
35966 }
35967 b := dAtA[iNdEx]
35968 iNdEx++
35969 v |= int64(b&0x7F) << shift
35970 if b < 0x80 {
35971 break
35972 }
35973 }
35974 m.Field4 = append(m.Field4, v)
35975 } else if wireType == 2 {
35976 var packedLen int
35977 for shift := uint(0); ; shift += 7 {
35978 if shift >= 64 {
35979 return ErrIntOverflowThetest
35980 }
35981 if iNdEx >= l {
35982 return io.ErrUnexpectedEOF
35983 }
35984 b := dAtA[iNdEx]
35985 iNdEx++
35986 packedLen |= int(b&0x7F) << shift
35987 if b < 0x80 {
35988 break
35989 }
35990 }
35991 if packedLen < 0 {
35992 return ErrInvalidLengthThetest
35993 }
35994 postIndex := iNdEx + packedLen
35995 if postIndex < 0 {
35996 return ErrInvalidLengthThetest
35997 }
35998 if postIndex > l {
35999 return io.ErrUnexpectedEOF
36000 }
36001 var elementCount int
36002 var count int
36003 for _, integer := range dAtA[iNdEx:postIndex] {
36004 if integer < 128 {
36005 count++
36006 }
36007 }
36008 elementCount = count
36009 if elementCount != 0 && len(m.Field4) == 0 {
36010 m.Field4 = make([]int64, 0, elementCount)
36011 }
36012 for iNdEx < postIndex {
36013 var v int64
36014 for shift := uint(0); ; shift += 7 {
36015 if shift >= 64 {
36016 return ErrIntOverflowThetest
36017 }
36018 if iNdEx >= l {
36019 return io.ErrUnexpectedEOF
36020 }
36021 b := dAtA[iNdEx]
36022 iNdEx++
36023 v |= int64(b&0x7F) << shift
36024 if b < 0x80 {
36025 break
36026 }
36027 }
36028 m.Field4 = append(m.Field4, v)
36029 }
36030 } else {
36031 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
36032 }
36033 case 5:
36034 if wireType == 0 {
36035 var v uint32
36036 for shift := uint(0); ; shift += 7 {
36037 if shift >= 64 {
36038 return ErrIntOverflowThetest
36039 }
36040 if iNdEx >= l {
36041 return io.ErrUnexpectedEOF
36042 }
36043 b := dAtA[iNdEx]
36044 iNdEx++
36045 v |= uint32(b&0x7F) << shift
36046 if b < 0x80 {
36047 break
36048 }
36049 }
36050 m.Field5 = append(m.Field5, v)
36051 } else if wireType == 2 {
36052 var packedLen int
36053 for shift := uint(0); ; shift += 7 {
36054 if shift >= 64 {
36055 return ErrIntOverflowThetest
36056 }
36057 if iNdEx >= l {
36058 return io.ErrUnexpectedEOF
36059 }
36060 b := dAtA[iNdEx]
36061 iNdEx++
36062 packedLen |= int(b&0x7F) << shift
36063 if b < 0x80 {
36064 break
36065 }
36066 }
36067 if packedLen < 0 {
36068 return ErrInvalidLengthThetest
36069 }
36070 postIndex := iNdEx + packedLen
36071 if postIndex < 0 {
36072 return ErrInvalidLengthThetest
36073 }
36074 if postIndex > l {
36075 return io.ErrUnexpectedEOF
36076 }
36077 var elementCount int
36078 var count int
36079 for _, integer := range dAtA[iNdEx:postIndex] {
36080 if integer < 128 {
36081 count++
36082 }
36083 }
36084 elementCount = count
36085 if elementCount != 0 && len(m.Field5) == 0 {
36086 m.Field5 = make([]uint32, 0, elementCount)
36087 }
36088 for iNdEx < postIndex {
36089 var v uint32
36090 for shift := uint(0); ; shift += 7 {
36091 if shift >= 64 {
36092 return ErrIntOverflowThetest
36093 }
36094 if iNdEx >= l {
36095 return io.ErrUnexpectedEOF
36096 }
36097 b := dAtA[iNdEx]
36098 iNdEx++
36099 v |= uint32(b&0x7F) << shift
36100 if b < 0x80 {
36101 break
36102 }
36103 }
36104 m.Field5 = append(m.Field5, v)
36105 }
36106 } else {
36107 return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
36108 }
36109 case 6:
36110 if wireType == 0 {
36111 var v uint64
36112 for shift := uint(0); ; shift += 7 {
36113 if shift >= 64 {
36114 return ErrIntOverflowThetest
36115 }
36116 if iNdEx >= l {
36117 return io.ErrUnexpectedEOF
36118 }
36119 b := dAtA[iNdEx]
36120 iNdEx++
36121 v |= uint64(b&0x7F) << shift
36122 if b < 0x80 {
36123 break
36124 }
36125 }
36126 m.Field6 = append(m.Field6, v)
36127 } else if wireType == 2 {
36128 var packedLen int
36129 for shift := uint(0); ; shift += 7 {
36130 if shift >= 64 {
36131 return ErrIntOverflowThetest
36132 }
36133 if iNdEx >= l {
36134 return io.ErrUnexpectedEOF
36135 }
36136 b := dAtA[iNdEx]
36137 iNdEx++
36138 packedLen |= int(b&0x7F) << shift
36139 if b < 0x80 {
36140 break
36141 }
36142 }
36143 if packedLen < 0 {
36144 return ErrInvalidLengthThetest
36145 }
36146 postIndex := iNdEx + packedLen
36147 if postIndex < 0 {
36148 return ErrInvalidLengthThetest
36149 }
36150 if postIndex > l {
36151 return io.ErrUnexpectedEOF
36152 }
36153 var elementCount int
36154 var count int
36155 for _, integer := range dAtA[iNdEx:postIndex] {
36156 if integer < 128 {
36157 count++
36158 }
36159 }
36160 elementCount = count
36161 if elementCount != 0 && len(m.Field6) == 0 {
36162 m.Field6 = make([]uint64, 0, elementCount)
36163 }
36164 for iNdEx < postIndex {
36165 var v uint64
36166 for shift := uint(0); ; shift += 7 {
36167 if shift >= 64 {
36168 return ErrIntOverflowThetest
36169 }
36170 if iNdEx >= l {
36171 return io.ErrUnexpectedEOF
36172 }
36173 b := dAtA[iNdEx]
36174 iNdEx++
36175 v |= uint64(b&0x7F) << shift
36176 if b < 0x80 {
36177 break
36178 }
36179 }
36180 m.Field6 = append(m.Field6, v)
36181 }
36182 } else {
36183 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
36184 }
36185 case 7:
36186 if wireType == 0 {
36187 var v int32
36188 for shift := uint(0); ; shift += 7 {
36189 if shift >= 64 {
36190 return ErrIntOverflowThetest
36191 }
36192 if iNdEx >= l {
36193 return io.ErrUnexpectedEOF
36194 }
36195 b := dAtA[iNdEx]
36196 iNdEx++
36197 v |= int32(b&0x7F) << shift
36198 if b < 0x80 {
36199 break
36200 }
36201 }
36202 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
36203 m.Field7 = append(m.Field7, v)
36204 } else if wireType == 2 {
36205 var packedLen int
36206 for shift := uint(0); ; shift += 7 {
36207 if shift >= 64 {
36208 return ErrIntOverflowThetest
36209 }
36210 if iNdEx >= l {
36211 return io.ErrUnexpectedEOF
36212 }
36213 b := dAtA[iNdEx]
36214 iNdEx++
36215 packedLen |= int(b&0x7F) << shift
36216 if b < 0x80 {
36217 break
36218 }
36219 }
36220 if packedLen < 0 {
36221 return ErrInvalidLengthThetest
36222 }
36223 postIndex := iNdEx + packedLen
36224 if postIndex < 0 {
36225 return ErrInvalidLengthThetest
36226 }
36227 if postIndex > l {
36228 return io.ErrUnexpectedEOF
36229 }
36230 var elementCount int
36231 var count int
36232 for _, integer := range dAtA[iNdEx:postIndex] {
36233 if integer < 128 {
36234 count++
36235 }
36236 }
36237 elementCount = count
36238 if elementCount != 0 && len(m.Field7) == 0 {
36239 m.Field7 = make([]int32, 0, elementCount)
36240 }
36241 for iNdEx < postIndex {
36242 var v int32
36243 for shift := uint(0); ; shift += 7 {
36244 if shift >= 64 {
36245 return ErrIntOverflowThetest
36246 }
36247 if iNdEx >= l {
36248 return io.ErrUnexpectedEOF
36249 }
36250 b := dAtA[iNdEx]
36251 iNdEx++
36252 v |= int32(b&0x7F) << shift
36253 if b < 0x80 {
36254 break
36255 }
36256 }
36257 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
36258 m.Field7 = append(m.Field7, v)
36259 }
36260 } else {
36261 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
36262 }
36263 case 8:
36264 if wireType == 0 {
36265 var v uint64
36266 for shift := uint(0); ; shift += 7 {
36267 if shift >= 64 {
36268 return ErrIntOverflowThetest
36269 }
36270 if iNdEx >= l {
36271 return io.ErrUnexpectedEOF
36272 }
36273 b := dAtA[iNdEx]
36274 iNdEx++
36275 v |= uint64(b&0x7F) << shift
36276 if b < 0x80 {
36277 break
36278 }
36279 }
36280 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
36281 m.Field8 = append(m.Field8, int64(v))
36282 } else if wireType == 2 {
36283 var packedLen int
36284 for shift := uint(0); ; shift += 7 {
36285 if shift >= 64 {
36286 return ErrIntOverflowThetest
36287 }
36288 if iNdEx >= l {
36289 return io.ErrUnexpectedEOF
36290 }
36291 b := dAtA[iNdEx]
36292 iNdEx++
36293 packedLen |= int(b&0x7F) << shift
36294 if b < 0x80 {
36295 break
36296 }
36297 }
36298 if packedLen < 0 {
36299 return ErrInvalidLengthThetest
36300 }
36301 postIndex := iNdEx + packedLen
36302 if postIndex < 0 {
36303 return ErrInvalidLengthThetest
36304 }
36305 if postIndex > l {
36306 return io.ErrUnexpectedEOF
36307 }
36308 var elementCount int
36309 var count int
36310 for _, integer := range dAtA[iNdEx:postIndex] {
36311 if integer < 128 {
36312 count++
36313 }
36314 }
36315 elementCount = count
36316 if elementCount != 0 && len(m.Field8) == 0 {
36317 m.Field8 = make([]int64, 0, elementCount)
36318 }
36319 for iNdEx < postIndex {
36320 var v uint64
36321 for shift := uint(0); ; shift += 7 {
36322 if shift >= 64 {
36323 return ErrIntOverflowThetest
36324 }
36325 if iNdEx >= l {
36326 return io.ErrUnexpectedEOF
36327 }
36328 b := dAtA[iNdEx]
36329 iNdEx++
36330 v |= uint64(b&0x7F) << shift
36331 if b < 0x80 {
36332 break
36333 }
36334 }
36335 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
36336 m.Field8 = append(m.Field8, int64(v))
36337 }
36338 } else {
36339 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
36340 }
36341 case 9:
36342 if wireType == 5 {
36343 var v uint32
36344 if (iNdEx + 4) > l {
36345 return io.ErrUnexpectedEOF
36346 }
36347 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
36348 iNdEx += 4
36349 m.Field9 = append(m.Field9, v)
36350 } else if wireType == 2 {
36351 var packedLen int
36352 for shift := uint(0); ; shift += 7 {
36353 if shift >= 64 {
36354 return ErrIntOverflowThetest
36355 }
36356 if iNdEx >= l {
36357 return io.ErrUnexpectedEOF
36358 }
36359 b := dAtA[iNdEx]
36360 iNdEx++
36361 packedLen |= int(b&0x7F) << shift
36362 if b < 0x80 {
36363 break
36364 }
36365 }
36366 if packedLen < 0 {
36367 return ErrInvalidLengthThetest
36368 }
36369 postIndex := iNdEx + packedLen
36370 if postIndex < 0 {
36371 return ErrInvalidLengthThetest
36372 }
36373 if postIndex > l {
36374 return io.ErrUnexpectedEOF
36375 }
36376 var elementCount int
36377 elementCount = packedLen / 4
36378 if elementCount != 0 && len(m.Field9) == 0 {
36379 m.Field9 = make([]uint32, 0, elementCount)
36380 }
36381 for iNdEx < postIndex {
36382 var v uint32
36383 if (iNdEx + 4) > l {
36384 return io.ErrUnexpectedEOF
36385 }
36386 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
36387 iNdEx += 4
36388 m.Field9 = append(m.Field9, v)
36389 }
36390 } else {
36391 return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
36392 }
36393 case 10:
36394 if wireType == 5 {
36395 var v int32
36396 if (iNdEx + 4) > l {
36397 return io.ErrUnexpectedEOF
36398 }
36399 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
36400 iNdEx += 4
36401 m.Field10 = append(m.Field10, v)
36402 } else if wireType == 2 {
36403 var packedLen int
36404 for shift := uint(0); ; shift += 7 {
36405 if shift >= 64 {
36406 return ErrIntOverflowThetest
36407 }
36408 if iNdEx >= l {
36409 return io.ErrUnexpectedEOF
36410 }
36411 b := dAtA[iNdEx]
36412 iNdEx++
36413 packedLen |= int(b&0x7F) << shift
36414 if b < 0x80 {
36415 break
36416 }
36417 }
36418 if packedLen < 0 {
36419 return ErrInvalidLengthThetest
36420 }
36421 postIndex := iNdEx + packedLen
36422 if postIndex < 0 {
36423 return ErrInvalidLengthThetest
36424 }
36425 if postIndex > l {
36426 return io.ErrUnexpectedEOF
36427 }
36428 var elementCount int
36429 elementCount = packedLen / 4
36430 if elementCount != 0 && len(m.Field10) == 0 {
36431 m.Field10 = make([]int32, 0, elementCount)
36432 }
36433 for iNdEx < postIndex {
36434 var v int32
36435 if (iNdEx + 4) > l {
36436 return io.ErrUnexpectedEOF
36437 }
36438 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
36439 iNdEx += 4
36440 m.Field10 = append(m.Field10, v)
36441 }
36442 } else {
36443 return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
36444 }
36445 case 11:
36446 if wireType == 1 {
36447 var v uint64
36448 if (iNdEx + 8) > l {
36449 return io.ErrUnexpectedEOF
36450 }
36451 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
36452 iNdEx += 8
36453 m.Field11 = append(m.Field11, v)
36454 } else if wireType == 2 {
36455 var packedLen int
36456 for shift := uint(0); ; shift += 7 {
36457 if shift >= 64 {
36458 return ErrIntOverflowThetest
36459 }
36460 if iNdEx >= l {
36461 return io.ErrUnexpectedEOF
36462 }
36463 b := dAtA[iNdEx]
36464 iNdEx++
36465 packedLen |= int(b&0x7F) << shift
36466 if b < 0x80 {
36467 break
36468 }
36469 }
36470 if packedLen < 0 {
36471 return ErrInvalidLengthThetest
36472 }
36473 postIndex := iNdEx + packedLen
36474 if postIndex < 0 {
36475 return ErrInvalidLengthThetest
36476 }
36477 if postIndex > l {
36478 return io.ErrUnexpectedEOF
36479 }
36480 var elementCount int
36481 elementCount = packedLen / 8
36482 if elementCount != 0 && len(m.Field11) == 0 {
36483 m.Field11 = make([]uint64, 0, elementCount)
36484 }
36485 for iNdEx < postIndex {
36486 var v uint64
36487 if (iNdEx + 8) > l {
36488 return io.ErrUnexpectedEOF
36489 }
36490 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
36491 iNdEx += 8
36492 m.Field11 = append(m.Field11, v)
36493 }
36494 } else {
36495 return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
36496 }
36497 case 12:
36498 if wireType == 1 {
36499 var v int64
36500 if (iNdEx + 8) > l {
36501 return io.ErrUnexpectedEOF
36502 }
36503 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
36504 iNdEx += 8
36505 m.Field12 = append(m.Field12, v)
36506 } else if wireType == 2 {
36507 var packedLen int
36508 for shift := uint(0); ; shift += 7 {
36509 if shift >= 64 {
36510 return ErrIntOverflowThetest
36511 }
36512 if iNdEx >= l {
36513 return io.ErrUnexpectedEOF
36514 }
36515 b := dAtA[iNdEx]
36516 iNdEx++
36517 packedLen |= int(b&0x7F) << shift
36518 if b < 0x80 {
36519 break
36520 }
36521 }
36522 if packedLen < 0 {
36523 return ErrInvalidLengthThetest
36524 }
36525 postIndex := iNdEx + packedLen
36526 if postIndex < 0 {
36527 return ErrInvalidLengthThetest
36528 }
36529 if postIndex > l {
36530 return io.ErrUnexpectedEOF
36531 }
36532 var elementCount int
36533 elementCount = packedLen / 8
36534 if elementCount != 0 && len(m.Field12) == 0 {
36535 m.Field12 = make([]int64, 0, elementCount)
36536 }
36537 for iNdEx < postIndex {
36538 var v int64
36539 if (iNdEx + 8) > l {
36540 return io.ErrUnexpectedEOF
36541 }
36542 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
36543 iNdEx += 8
36544 m.Field12 = append(m.Field12, v)
36545 }
36546 } else {
36547 return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
36548 }
36549 case 13:
36550 if wireType == 0 {
36551 var v int
36552 for shift := uint(0); ; shift += 7 {
36553 if shift >= 64 {
36554 return ErrIntOverflowThetest
36555 }
36556 if iNdEx >= l {
36557 return io.ErrUnexpectedEOF
36558 }
36559 b := dAtA[iNdEx]
36560 iNdEx++
36561 v |= int(b&0x7F) << shift
36562 if b < 0x80 {
36563 break
36564 }
36565 }
36566 m.Field13 = append(m.Field13, bool(v != 0))
36567 } else if wireType == 2 {
36568 var packedLen int
36569 for shift := uint(0); ; shift += 7 {
36570 if shift >= 64 {
36571 return ErrIntOverflowThetest
36572 }
36573 if iNdEx >= l {
36574 return io.ErrUnexpectedEOF
36575 }
36576 b := dAtA[iNdEx]
36577 iNdEx++
36578 packedLen |= int(b&0x7F) << shift
36579 if b < 0x80 {
36580 break
36581 }
36582 }
36583 if packedLen < 0 {
36584 return ErrInvalidLengthThetest
36585 }
36586 postIndex := iNdEx + packedLen
36587 if postIndex < 0 {
36588 return ErrInvalidLengthThetest
36589 }
36590 if postIndex > l {
36591 return io.ErrUnexpectedEOF
36592 }
36593 var elementCount int
36594 elementCount = packedLen
36595 if elementCount != 0 && len(m.Field13) == 0 {
36596 m.Field13 = make([]bool, 0, elementCount)
36597 }
36598 for iNdEx < postIndex {
36599 var v int
36600 for shift := uint(0); ; shift += 7 {
36601 if shift >= 64 {
36602 return ErrIntOverflowThetest
36603 }
36604 if iNdEx >= l {
36605 return io.ErrUnexpectedEOF
36606 }
36607 b := dAtA[iNdEx]
36608 iNdEx++
36609 v |= int(b&0x7F) << shift
36610 if b < 0x80 {
36611 break
36612 }
36613 }
36614 m.Field13 = append(m.Field13, bool(v != 0))
36615 }
36616 } else {
36617 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
36618 }
36619 default:
36620 iNdEx = preIndex
36621 skippy, err := skipThetest(dAtA[iNdEx:])
36622 if err != nil {
36623 return err
36624 }
36625 if (skippy < 0) || (iNdEx+skippy) < 0 {
36626 return ErrInvalidLengthThetest
36627 }
36628 if (iNdEx + skippy) > l {
36629 return io.ErrUnexpectedEOF
36630 }
36631 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
36632 iNdEx += skippy
36633 }
36634 }
36635
36636 if iNdEx > l {
36637 return io.ErrUnexpectedEOF
36638 }
36639 return nil
36640 }
36641 func (m *NidOptStruct) Unmarshal(dAtA []byte) error {
36642 l := len(dAtA)
36643 iNdEx := 0
36644 for iNdEx < l {
36645 preIndex := iNdEx
36646 var wire uint64
36647 for shift := uint(0); ; shift += 7 {
36648 if shift >= 64 {
36649 return ErrIntOverflowThetest
36650 }
36651 if iNdEx >= l {
36652 return io.ErrUnexpectedEOF
36653 }
36654 b := dAtA[iNdEx]
36655 iNdEx++
36656 wire |= uint64(b&0x7F) << shift
36657 if b < 0x80 {
36658 break
36659 }
36660 }
36661 fieldNum := int32(wire >> 3)
36662 wireType := int(wire & 0x7)
36663 if wireType == 4 {
36664 return fmt.Errorf("proto: NidOptStruct: wiretype end group for non-group")
36665 }
36666 if fieldNum <= 0 {
36667 return fmt.Errorf("proto: NidOptStruct: illegal tag %d (wire type %d)", fieldNum, wire)
36668 }
36669 switch fieldNum {
36670 case 1:
36671 if wireType != 1 {
36672 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
36673 }
36674 var v uint64
36675 if (iNdEx + 8) > l {
36676 return io.ErrUnexpectedEOF
36677 }
36678 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
36679 iNdEx += 8
36680 m.Field1 = float64(math.Float64frombits(v))
36681 case 2:
36682 if wireType != 5 {
36683 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
36684 }
36685 var v uint32
36686 if (iNdEx + 4) > l {
36687 return io.ErrUnexpectedEOF
36688 }
36689 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
36690 iNdEx += 4
36691 m.Field2 = float32(math.Float32frombits(v))
36692 case 3:
36693 if wireType != 2 {
36694 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
36695 }
36696 var msglen int
36697 for shift := uint(0); ; shift += 7 {
36698 if shift >= 64 {
36699 return ErrIntOverflowThetest
36700 }
36701 if iNdEx >= l {
36702 return io.ErrUnexpectedEOF
36703 }
36704 b := dAtA[iNdEx]
36705 iNdEx++
36706 msglen |= int(b&0x7F) << shift
36707 if b < 0x80 {
36708 break
36709 }
36710 }
36711 if msglen < 0 {
36712 return ErrInvalidLengthThetest
36713 }
36714 postIndex := iNdEx + msglen
36715 if postIndex < 0 {
36716 return ErrInvalidLengthThetest
36717 }
36718 if postIndex > l {
36719 return io.ErrUnexpectedEOF
36720 }
36721 if err := m.Field3.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
36722 return err
36723 }
36724 iNdEx = postIndex
36725 case 4:
36726 if wireType != 2 {
36727 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
36728 }
36729 var msglen int
36730 for shift := uint(0); ; shift += 7 {
36731 if shift >= 64 {
36732 return ErrIntOverflowThetest
36733 }
36734 if iNdEx >= l {
36735 return io.ErrUnexpectedEOF
36736 }
36737 b := dAtA[iNdEx]
36738 iNdEx++
36739 msglen |= int(b&0x7F) << shift
36740 if b < 0x80 {
36741 break
36742 }
36743 }
36744 if msglen < 0 {
36745 return ErrInvalidLengthThetest
36746 }
36747 postIndex := iNdEx + msglen
36748 if postIndex < 0 {
36749 return ErrInvalidLengthThetest
36750 }
36751 if postIndex > l {
36752 return io.ErrUnexpectedEOF
36753 }
36754 if err := m.Field4.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
36755 return err
36756 }
36757 iNdEx = postIndex
36758 case 6:
36759 if wireType != 0 {
36760 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
36761 }
36762 m.Field6 = 0
36763 for shift := uint(0); ; shift += 7 {
36764 if shift >= 64 {
36765 return ErrIntOverflowThetest
36766 }
36767 if iNdEx >= l {
36768 return io.ErrUnexpectedEOF
36769 }
36770 b := dAtA[iNdEx]
36771 iNdEx++
36772 m.Field6 |= uint64(b&0x7F) << shift
36773 if b < 0x80 {
36774 break
36775 }
36776 }
36777 case 7:
36778 if wireType != 0 {
36779 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
36780 }
36781 var v int32
36782 for shift := uint(0); ; shift += 7 {
36783 if shift >= 64 {
36784 return ErrIntOverflowThetest
36785 }
36786 if iNdEx >= l {
36787 return io.ErrUnexpectedEOF
36788 }
36789 b := dAtA[iNdEx]
36790 iNdEx++
36791 v |= int32(b&0x7F) << shift
36792 if b < 0x80 {
36793 break
36794 }
36795 }
36796 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
36797 m.Field7 = v
36798 case 8:
36799 if wireType != 2 {
36800 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
36801 }
36802 var msglen int
36803 for shift := uint(0); ; shift += 7 {
36804 if shift >= 64 {
36805 return ErrIntOverflowThetest
36806 }
36807 if iNdEx >= l {
36808 return io.ErrUnexpectedEOF
36809 }
36810 b := dAtA[iNdEx]
36811 iNdEx++
36812 msglen |= int(b&0x7F) << shift
36813 if b < 0x80 {
36814 break
36815 }
36816 }
36817 if msglen < 0 {
36818 return ErrInvalidLengthThetest
36819 }
36820 postIndex := iNdEx + msglen
36821 if postIndex < 0 {
36822 return ErrInvalidLengthThetest
36823 }
36824 if postIndex > l {
36825 return io.ErrUnexpectedEOF
36826 }
36827 if err := m.Field8.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
36828 return err
36829 }
36830 iNdEx = postIndex
36831 case 13:
36832 if wireType != 0 {
36833 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
36834 }
36835 var v int
36836 for shift := uint(0); ; shift += 7 {
36837 if shift >= 64 {
36838 return ErrIntOverflowThetest
36839 }
36840 if iNdEx >= l {
36841 return io.ErrUnexpectedEOF
36842 }
36843 b := dAtA[iNdEx]
36844 iNdEx++
36845 v |= int(b&0x7F) << shift
36846 if b < 0x80 {
36847 break
36848 }
36849 }
36850 m.Field13 = bool(v != 0)
36851 case 14:
36852 if wireType != 2 {
36853 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
36854 }
36855 var stringLen uint64
36856 for shift := uint(0); ; shift += 7 {
36857 if shift >= 64 {
36858 return ErrIntOverflowThetest
36859 }
36860 if iNdEx >= l {
36861 return io.ErrUnexpectedEOF
36862 }
36863 b := dAtA[iNdEx]
36864 iNdEx++
36865 stringLen |= uint64(b&0x7F) << shift
36866 if b < 0x80 {
36867 break
36868 }
36869 }
36870 intStringLen := int(stringLen)
36871 if intStringLen < 0 {
36872 return ErrInvalidLengthThetest
36873 }
36874 postIndex := iNdEx + intStringLen
36875 if postIndex < 0 {
36876 return ErrInvalidLengthThetest
36877 }
36878 if postIndex > l {
36879 return io.ErrUnexpectedEOF
36880 }
36881 m.Field14 = string(dAtA[iNdEx:postIndex])
36882 iNdEx = postIndex
36883 case 15:
36884 if wireType != 2 {
36885 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
36886 }
36887 var byteLen int
36888 for shift := uint(0); ; shift += 7 {
36889 if shift >= 64 {
36890 return ErrIntOverflowThetest
36891 }
36892 if iNdEx >= l {
36893 return io.ErrUnexpectedEOF
36894 }
36895 b := dAtA[iNdEx]
36896 iNdEx++
36897 byteLen |= int(b&0x7F) << shift
36898 if b < 0x80 {
36899 break
36900 }
36901 }
36902 if byteLen < 0 {
36903 return ErrInvalidLengthThetest
36904 }
36905 postIndex := iNdEx + byteLen
36906 if postIndex < 0 {
36907 return ErrInvalidLengthThetest
36908 }
36909 if postIndex > l {
36910 return io.ErrUnexpectedEOF
36911 }
36912 m.Field15 = append(m.Field15[:0], dAtA[iNdEx:postIndex]...)
36913 if m.Field15 == nil {
36914 m.Field15 = []byte{}
36915 }
36916 iNdEx = postIndex
36917 default:
36918 iNdEx = preIndex
36919 skippy, err := skipThetest(dAtA[iNdEx:])
36920 if err != nil {
36921 return err
36922 }
36923 if (skippy < 0) || (iNdEx+skippy) < 0 {
36924 return ErrInvalidLengthThetest
36925 }
36926 if (iNdEx + skippy) > l {
36927 return io.ErrUnexpectedEOF
36928 }
36929 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
36930 iNdEx += skippy
36931 }
36932 }
36933
36934 if iNdEx > l {
36935 return io.ErrUnexpectedEOF
36936 }
36937 return nil
36938 }
36939 func (m *NinOptStruct) Unmarshal(dAtA []byte) error {
36940 l := len(dAtA)
36941 iNdEx := 0
36942 for iNdEx < l {
36943 preIndex := iNdEx
36944 var wire uint64
36945 for shift := uint(0); ; shift += 7 {
36946 if shift >= 64 {
36947 return ErrIntOverflowThetest
36948 }
36949 if iNdEx >= l {
36950 return io.ErrUnexpectedEOF
36951 }
36952 b := dAtA[iNdEx]
36953 iNdEx++
36954 wire |= uint64(b&0x7F) << shift
36955 if b < 0x80 {
36956 break
36957 }
36958 }
36959 fieldNum := int32(wire >> 3)
36960 wireType := int(wire & 0x7)
36961 if wireType == 4 {
36962 return fmt.Errorf("proto: NinOptStruct: wiretype end group for non-group")
36963 }
36964 if fieldNum <= 0 {
36965 return fmt.Errorf("proto: NinOptStruct: illegal tag %d (wire type %d)", fieldNum, wire)
36966 }
36967 switch fieldNum {
36968 case 1:
36969 if wireType != 1 {
36970 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
36971 }
36972 var v uint64
36973 if (iNdEx + 8) > l {
36974 return io.ErrUnexpectedEOF
36975 }
36976 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
36977 iNdEx += 8
36978 v2 := float64(math.Float64frombits(v))
36979 m.Field1 = &v2
36980 case 2:
36981 if wireType != 5 {
36982 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
36983 }
36984 var v uint32
36985 if (iNdEx + 4) > l {
36986 return io.ErrUnexpectedEOF
36987 }
36988 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
36989 iNdEx += 4
36990 v2 := float32(math.Float32frombits(v))
36991 m.Field2 = &v2
36992 case 3:
36993 if wireType != 2 {
36994 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
36995 }
36996 var msglen int
36997 for shift := uint(0); ; shift += 7 {
36998 if shift >= 64 {
36999 return ErrIntOverflowThetest
37000 }
37001 if iNdEx >= l {
37002 return io.ErrUnexpectedEOF
37003 }
37004 b := dAtA[iNdEx]
37005 iNdEx++
37006 msglen |= int(b&0x7F) << shift
37007 if b < 0x80 {
37008 break
37009 }
37010 }
37011 if msglen < 0 {
37012 return ErrInvalidLengthThetest
37013 }
37014 postIndex := iNdEx + msglen
37015 if postIndex < 0 {
37016 return ErrInvalidLengthThetest
37017 }
37018 if postIndex > l {
37019 return io.ErrUnexpectedEOF
37020 }
37021 if m.Field3 == nil {
37022 m.Field3 = &NidOptNative{}
37023 }
37024 if err := m.Field3.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
37025 return err
37026 }
37027 iNdEx = postIndex
37028 case 4:
37029 if wireType != 2 {
37030 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
37031 }
37032 var msglen int
37033 for shift := uint(0); ; shift += 7 {
37034 if shift >= 64 {
37035 return ErrIntOverflowThetest
37036 }
37037 if iNdEx >= l {
37038 return io.ErrUnexpectedEOF
37039 }
37040 b := dAtA[iNdEx]
37041 iNdEx++
37042 msglen |= int(b&0x7F) << shift
37043 if b < 0x80 {
37044 break
37045 }
37046 }
37047 if msglen < 0 {
37048 return ErrInvalidLengthThetest
37049 }
37050 postIndex := iNdEx + msglen
37051 if postIndex < 0 {
37052 return ErrInvalidLengthThetest
37053 }
37054 if postIndex > l {
37055 return io.ErrUnexpectedEOF
37056 }
37057 if m.Field4 == nil {
37058 m.Field4 = &NinOptNative{}
37059 }
37060 if err := m.Field4.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
37061 return err
37062 }
37063 iNdEx = postIndex
37064 case 6:
37065 if wireType != 0 {
37066 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
37067 }
37068 var v uint64
37069 for shift := uint(0); ; shift += 7 {
37070 if shift >= 64 {
37071 return ErrIntOverflowThetest
37072 }
37073 if iNdEx >= l {
37074 return io.ErrUnexpectedEOF
37075 }
37076 b := dAtA[iNdEx]
37077 iNdEx++
37078 v |= uint64(b&0x7F) << shift
37079 if b < 0x80 {
37080 break
37081 }
37082 }
37083 m.Field6 = &v
37084 case 7:
37085 if wireType != 0 {
37086 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
37087 }
37088 var v int32
37089 for shift := uint(0); ; shift += 7 {
37090 if shift >= 64 {
37091 return ErrIntOverflowThetest
37092 }
37093 if iNdEx >= l {
37094 return io.ErrUnexpectedEOF
37095 }
37096 b := dAtA[iNdEx]
37097 iNdEx++
37098 v |= int32(b&0x7F) << shift
37099 if b < 0x80 {
37100 break
37101 }
37102 }
37103 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
37104 m.Field7 = &v
37105 case 8:
37106 if wireType != 2 {
37107 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
37108 }
37109 var msglen int
37110 for shift := uint(0); ; shift += 7 {
37111 if shift >= 64 {
37112 return ErrIntOverflowThetest
37113 }
37114 if iNdEx >= l {
37115 return io.ErrUnexpectedEOF
37116 }
37117 b := dAtA[iNdEx]
37118 iNdEx++
37119 msglen |= int(b&0x7F) << shift
37120 if b < 0x80 {
37121 break
37122 }
37123 }
37124 if msglen < 0 {
37125 return ErrInvalidLengthThetest
37126 }
37127 postIndex := iNdEx + msglen
37128 if postIndex < 0 {
37129 return ErrInvalidLengthThetest
37130 }
37131 if postIndex > l {
37132 return io.ErrUnexpectedEOF
37133 }
37134 if m.Field8 == nil {
37135 m.Field8 = &NidOptNative{}
37136 }
37137 if err := m.Field8.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
37138 return err
37139 }
37140 iNdEx = postIndex
37141 case 13:
37142 if wireType != 0 {
37143 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
37144 }
37145 var v int
37146 for shift := uint(0); ; shift += 7 {
37147 if shift >= 64 {
37148 return ErrIntOverflowThetest
37149 }
37150 if iNdEx >= l {
37151 return io.ErrUnexpectedEOF
37152 }
37153 b := dAtA[iNdEx]
37154 iNdEx++
37155 v |= int(b&0x7F) << shift
37156 if b < 0x80 {
37157 break
37158 }
37159 }
37160 b := bool(v != 0)
37161 m.Field13 = &b
37162 case 14:
37163 if wireType != 2 {
37164 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
37165 }
37166 var stringLen uint64
37167 for shift := uint(0); ; shift += 7 {
37168 if shift >= 64 {
37169 return ErrIntOverflowThetest
37170 }
37171 if iNdEx >= l {
37172 return io.ErrUnexpectedEOF
37173 }
37174 b := dAtA[iNdEx]
37175 iNdEx++
37176 stringLen |= uint64(b&0x7F) << shift
37177 if b < 0x80 {
37178 break
37179 }
37180 }
37181 intStringLen := int(stringLen)
37182 if intStringLen < 0 {
37183 return ErrInvalidLengthThetest
37184 }
37185 postIndex := iNdEx + intStringLen
37186 if postIndex < 0 {
37187 return ErrInvalidLengthThetest
37188 }
37189 if postIndex > l {
37190 return io.ErrUnexpectedEOF
37191 }
37192 s := string(dAtA[iNdEx:postIndex])
37193 m.Field14 = &s
37194 iNdEx = postIndex
37195 case 15:
37196 if wireType != 2 {
37197 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
37198 }
37199 var byteLen int
37200 for shift := uint(0); ; shift += 7 {
37201 if shift >= 64 {
37202 return ErrIntOverflowThetest
37203 }
37204 if iNdEx >= l {
37205 return io.ErrUnexpectedEOF
37206 }
37207 b := dAtA[iNdEx]
37208 iNdEx++
37209 byteLen |= int(b&0x7F) << shift
37210 if b < 0x80 {
37211 break
37212 }
37213 }
37214 if byteLen < 0 {
37215 return ErrInvalidLengthThetest
37216 }
37217 postIndex := iNdEx + byteLen
37218 if postIndex < 0 {
37219 return ErrInvalidLengthThetest
37220 }
37221 if postIndex > l {
37222 return io.ErrUnexpectedEOF
37223 }
37224 m.Field15 = append(m.Field15[:0], dAtA[iNdEx:postIndex]...)
37225 if m.Field15 == nil {
37226 m.Field15 = []byte{}
37227 }
37228 iNdEx = postIndex
37229 default:
37230 iNdEx = preIndex
37231 skippy, err := skipThetest(dAtA[iNdEx:])
37232 if err != nil {
37233 return err
37234 }
37235 if (skippy < 0) || (iNdEx+skippy) < 0 {
37236 return ErrInvalidLengthThetest
37237 }
37238 if (iNdEx + skippy) > l {
37239 return io.ErrUnexpectedEOF
37240 }
37241 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
37242 iNdEx += skippy
37243 }
37244 }
37245
37246 if iNdEx > l {
37247 return io.ErrUnexpectedEOF
37248 }
37249 return nil
37250 }
37251 func (m *NidRepStruct) Unmarshal(dAtA []byte) error {
37252 l := len(dAtA)
37253 iNdEx := 0
37254 for iNdEx < l {
37255 preIndex := iNdEx
37256 var wire uint64
37257 for shift := uint(0); ; shift += 7 {
37258 if shift >= 64 {
37259 return ErrIntOverflowThetest
37260 }
37261 if iNdEx >= l {
37262 return io.ErrUnexpectedEOF
37263 }
37264 b := dAtA[iNdEx]
37265 iNdEx++
37266 wire |= uint64(b&0x7F) << shift
37267 if b < 0x80 {
37268 break
37269 }
37270 }
37271 fieldNum := int32(wire >> 3)
37272 wireType := int(wire & 0x7)
37273 if wireType == 4 {
37274 return fmt.Errorf("proto: NidRepStruct: wiretype end group for non-group")
37275 }
37276 if fieldNum <= 0 {
37277 return fmt.Errorf("proto: NidRepStruct: illegal tag %d (wire type %d)", fieldNum, wire)
37278 }
37279 switch fieldNum {
37280 case 1:
37281 if wireType == 1 {
37282 var v uint64
37283 if (iNdEx + 8) > l {
37284 return io.ErrUnexpectedEOF
37285 }
37286 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
37287 iNdEx += 8
37288 v2 := float64(math.Float64frombits(v))
37289 m.Field1 = append(m.Field1, v2)
37290 } else if wireType == 2 {
37291 var packedLen int
37292 for shift := uint(0); ; shift += 7 {
37293 if shift >= 64 {
37294 return ErrIntOverflowThetest
37295 }
37296 if iNdEx >= l {
37297 return io.ErrUnexpectedEOF
37298 }
37299 b := dAtA[iNdEx]
37300 iNdEx++
37301 packedLen |= int(b&0x7F) << shift
37302 if b < 0x80 {
37303 break
37304 }
37305 }
37306 if packedLen < 0 {
37307 return ErrInvalidLengthThetest
37308 }
37309 postIndex := iNdEx + packedLen
37310 if postIndex < 0 {
37311 return ErrInvalidLengthThetest
37312 }
37313 if postIndex > l {
37314 return io.ErrUnexpectedEOF
37315 }
37316 var elementCount int
37317 elementCount = packedLen / 8
37318 if elementCount != 0 && len(m.Field1) == 0 {
37319 m.Field1 = make([]float64, 0, elementCount)
37320 }
37321 for iNdEx < postIndex {
37322 var v uint64
37323 if (iNdEx + 8) > l {
37324 return io.ErrUnexpectedEOF
37325 }
37326 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
37327 iNdEx += 8
37328 v2 := float64(math.Float64frombits(v))
37329 m.Field1 = append(m.Field1, v2)
37330 }
37331 } else {
37332 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
37333 }
37334 case 2:
37335 if wireType == 5 {
37336 var v uint32
37337 if (iNdEx + 4) > l {
37338 return io.ErrUnexpectedEOF
37339 }
37340 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
37341 iNdEx += 4
37342 v2 := float32(math.Float32frombits(v))
37343 m.Field2 = append(m.Field2, v2)
37344 } else if wireType == 2 {
37345 var packedLen int
37346 for shift := uint(0); ; shift += 7 {
37347 if shift >= 64 {
37348 return ErrIntOverflowThetest
37349 }
37350 if iNdEx >= l {
37351 return io.ErrUnexpectedEOF
37352 }
37353 b := dAtA[iNdEx]
37354 iNdEx++
37355 packedLen |= int(b&0x7F) << shift
37356 if b < 0x80 {
37357 break
37358 }
37359 }
37360 if packedLen < 0 {
37361 return ErrInvalidLengthThetest
37362 }
37363 postIndex := iNdEx + packedLen
37364 if postIndex < 0 {
37365 return ErrInvalidLengthThetest
37366 }
37367 if postIndex > l {
37368 return io.ErrUnexpectedEOF
37369 }
37370 var elementCount int
37371 elementCount = packedLen / 4
37372 if elementCount != 0 && len(m.Field2) == 0 {
37373 m.Field2 = make([]float32, 0, elementCount)
37374 }
37375 for iNdEx < postIndex {
37376 var v uint32
37377 if (iNdEx + 4) > l {
37378 return io.ErrUnexpectedEOF
37379 }
37380 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
37381 iNdEx += 4
37382 v2 := float32(math.Float32frombits(v))
37383 m.Field2 = append(m.Field2, v2)
37384 }
37385 } else {
37386 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
37387 }
37388 case 3:
37389 if wireType != 2 {
37390 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
37391 }
37392 var msglen int
37393 for shift := uint(0); ; shift += 7 {
37394 if shift >= 64 {
37395 return ErrIntOverflowThetest
37396 }
37397 if iNdEx >= l {
37398 return io.ErrUnexpectedEOF
37399 }
37400 b := dAtA[iNdEx]
37401 iNdEx++
37402 msglen |= int(b&0x7F) << shift
37403 if b < 0x80 {
37404 break
37405 }
37406 }
37407 if msglen < 0 {
37408 return ErrInvalidLengthThetest
37409 }
37410 postIndex := iNdEx + msglen
37411 if postIndex < 0 {
37412 return ErrInvalidLengthThetest
37413 }
37414 if postIndex > l {
37415 return io.ErrUnexpectedEOF
37416 }
37417 m.Field3 = append(m.Field3, NidOptNative{})
37418 if err := m.Field3[len(m.Field3)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
37419 return err
37420 }
37421 iNdEx = postIndex
37422 case 4:
37423 if wireType != 2 {
37424 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
37425 }
37426 var msglen int
37427 for shift := uint(0); ; shift += 7 {
37428 if shift >= 64 {
37429 return ErrIntOverflowThetest
37430 }
37431 if iNdEx >= l {
37432 return io.ErrUnexpectedEOF
37433 }
37434 b := dAtA[iNdEx]
37435 iNdEx++
37436 msglen |= int(b&0x7F) << shift
37437 if b < 0x80 {
37438 break
37439 }
37440 }
37441 if msglen < 0 {
37442 return ErrInvalidLengthThetest
37443 }
37444 postIndex := iNdEx + msglen
37445 if postIndex < 0 {
37446 return ErrInvalidLengthThetest
37447 }
37448 if postIndex > l {
37449 return io.ErrUnexpectedEOF
37450 }
37451 m.Field4 = append(m.Field4, NinOptNative{})
37452 if err := m.Field4[len(m.Field4)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
37453 return err
37454 }
37455 iNdEx = postIndex
37456 case 6:
37457 if wireType == 0 {
37458 var v uint64
37459 for shift := uint(0); ; shift += 7 {
37460 if shift >= 64 {
37461 return ErrIntOverflowThetest
37462 }
37463 if iNdEx >= l {
37464 return io.ErrUnexpectedEOF
37465 }
37466 b := dAtA[iNdEx]
37467 iNdEx++
37468 v |= uint64(b&0x7F) << shift
37469 if b < 0x80 {
37470 break
37471 }
37472 }
37473 m.Field6 = append(m.Field6, v)
37474 } else if wireType == 2 {
37475 var packedLen int
37476 for shift := uint(0); ; shift += 7 {
37477 if shift >= 64 {
37478 return ErrIntOverflowThetest
37479 }
37480 if iNdEx >= l {
37481 return io.ErrUnexpectedEOF
37482 }
37483 b := dAtA[iNdEx]
37484 iNdEx++
37485 packedLen |= int(b&0x7F) << shift
37486 if b < 0x80 {
37487 break
37488 }
37489 }
37490 if packedLen < 0 {
37491 return ErrInvalidLengthThetest
37492 }
37493 postIndex := iNdEx + packedLen
37494 if postIndex < 0 {
37495 return ErrInvalidLengthThetest
37496 }
37497 if postIndex > l {
37498 return io.ErrUnexpectedEOF
37499 }
37500 var elementCount int
37501 var count int
37502 for _, integer := range dAtA[iNdEx:postIndex] {
37503 if integer < 128 {
37504 count++
37505 }
37506 }
37507 elementCount = count
37508 if elementCount != 0 && len(m.Field6) == 0 {
37509 m.Field6 = make([]uint64, 0, elementCount)
37510 }
37511 for iNdEx < postIndex {
37512 var v uint64
37513 for shift := uint(0); ; shift += 7 {
37514 if shift >= 64 {
37515 return ErrIntOverflowThetest
37516 }
37517 if iNdEx >= l {
37518 return io.ErrUnexpectedEOF
37519 }
37520 b := dAtA[iNdEx]
37521 iNdEx++
37522 v |= uint64(b&0x7F) << shift
37523 if b < 0x80 {
37524 break
37525 }
37526 }
37527 m.Field6 = append(m.Field6, v)
37528 }
37529 } else {
37530 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
37531 }
37532 case 7:
37533 if wireType == 0 {
37534 var v int32
37535 for shift := uint(0); ; shift += 7 {
37536 if shift >= 64 {
37537 return ErrIntOverflowThetest
37538 }
37539 if iNdEx >= l {
37540 return io.ErrUnexpectedEOF
37541 }
37542 b := dAtA[iNdEx]
37543 iNdEx++
37544 v |= int32(b&0x7F) << shift
37545 if b < 0x80 {
37546 break
37547 }
37548 }
37549 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
37550 m.Field7 = append(m.Field7, v)
37551 } else if wireType == 2 {
37552 var packedLen int
37553 for shift := uint(0); ; shift += 7 {
37554 if shift >= 64 {
37555 return ErrIntOverflowThetest
37556 }
37557 if iNdEx >= l {
37558 return io.ErrUnexpectedEOF
37559 }
37560 b := dAtA[iNdEx]
37561 iNdEx++
37562 packedLen |= int(b&0x7F) << shift
37563 if b < 0x80 {
37564 break
37565 }
37566 }
37567 if packedLen < 0 {
37568 return ErrInvalidLengthThetest
37569 }
37570 postIndex := iNdEx + packedLen
37571 if postIndex < 0 {
37572 return ErrInvalidLengthThetest
37573 }
37574 if postIndex > l {
37575 return io.ErrUnexpectedEOF
37576 }
37577 var elementCount int
37578 var count int
37579 for _, integer := range dAtA[iNdEx:postIndex] {
37580 if integer < 128 {
37581 count++
37582 }
37583 }
37584 elementCount = count
37585 if elementCount != 0 && len(m.Field7) == 0 {
37586 m.Field7 = make([]int32, 0, elementCount)
37587 }
37588 for iNdEx < postIndex {
37589 var v int32
37590 for shift := uint(0); ; shift += 7 {
37591 if shift >= 64 {
37592 return ErrIntOverflowThetest
37593 }
37594 if iNdEx >= l {
37595 return io.ErrUnexpectedEOF
37596 }
37597 b := dAtA[iNdEx]
37598 iNdEx++
37599 v |= int32(b&0x7F) << shift
37600 if b < 0x80 {
37601 break
37602 }
37603 }
37604 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
37605 m.Field7 = append(m.Field7, v)
37606 }
37607 } else {
37608 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
37609 }
37610 case 8:
37611 if wireType != 2 {
37612 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
37613 }
37614 var msglen int
37615 for shift := uint(0); ; shift += 7 {
37616 if shift >= 64 {
37617 return ErrIntOverflowThetest
37618 }
37619 if iNdEx >= l {
37620 return io.ErrUnexpectedEOF
37621 }
37622 b := dAtA[iNdEx]
37623 iNdEx++
37624 msglen |= int(b&0x7F) << shift
37625 if b < 0x80 {
37626 break
37627 }
37628 }
37629 if msglen < 0 {
37630 return ErrInvalidLengthThetest
37631 }
37632 postIndex := iNdEx + msglen
37633 if postIndex < 0 {
37634 return ErrInvalidLengthThetest
37635 }
37636 if postIndex > l {
37637 return io.ErrUnexpectedEOF
37638 }
37639 m.Field8 = append(m.Field8, NidOptNative{})
37640 if err := m.Field8[len(m.Field8)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
37641 return err
37642 }
37643 iNdEx = postIndex
37644 case 13:
37645 if wireType == 0 {
37646 var v int
37647 for shift := uint(0); ; shift += 7 {
37648 if shift >= 64 {
37649 return ErrIntOverflowThetest
37650 }
37651 if iNdEx >= l {
37652 return io.ErrUnexpectedEOF
37653 }
37654 b := dAtA[iNdEx]
37655 iNdEx++
37656 v |= int(b&0x7F) << shift
37657 if b < 0x80 {
37658 break
37659 }
37660 }
37661 m.Field13 = append(m.Field13, bool(v != 0))
37662 } else if wireType == 2 {
37663 var packedLen int
37664 for shift := uint(0); ; shift += 7 {
37665 if shift >= 64 {
37666 return ErrIntOverflowThetest
37667 }
37668 if iNdEx >= l {
37669 return io.ErrUnexpectedEOF
37670 }
37671 b := dAtA[iNdEx]
37672 iNdEx++
37673 packedLen |= int(b&0x7F) << shift
37674 if b < 0x80 {
37675 break
37676 }
37677 }
37678 if packedLen < 0 {
37679 return ErrInvalidLengthThetest
37680 }
37681 postIndex := iNdEx + packedLen
37682 if postIndex < 0 {
37683 return ErrInvalidLengthThetest
37684 }
37685 if postIndex > l {
37686 return io.ErrUnexpectedEOF
37687 }
37688 var elementCount int
37689 elementCount = packedLen
37690 if elementCount != 0 && len(m.Field13) == 0 {
37691 m.Field13 = make([]bool, 0, elementCount)
37692 }
37693 for iNdEx < postIndex {
37694 var v int
37695 for shift := uint(0); ; shift += 7 {
37696 if shift >= 64 {
37697 return ErrIntOverflowThetest
37698 }
37699 if iNdEx >= l {
37700 return io.ErrUnexpectedEOF
37701 }
37702 b := dAtA[iNdEx]
37703 iNdEx++
37704 v |= int(b&0x7F) << shift
37705 if b < 0x80 {
37706 break
37707 }
37708 }
37709 m.Field13 = append(m.Field13, bool(v != 0))
37710 }
37711 } else {
37712 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
37713 }
37714 case 14:
37715 if wireType != 2 {
37716 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
37717 }
37718 var stringLen uint64
37719 for shift := uint(0); ; shift += 7 {
37720 if shift >= 64 {
37721 return ErrIntOverflowThetest
37722 }
37723 if iNdEx >= l {
37724 return io.ErrUnexpectedEOF
37725 }
37726 b := dAtA[iNdEx]
37727 iNdEx++
37728 stringLen |= uint64(b&0x7F) << shift
37729 if b < 0x80 {
37730 break
37731 }
37732 }
37733 intStringLen := int(stringLen)
37734 if intStringLen < 0 {
37735 return ErrInvalidLengthThetest
37736 }
37737 postIndex := iNdEx + intStringLen
37738 if postIndex < 0 {
37739 return ErrInvalidLengthThetest
37740 }
37741 if postIndex > l {
37742 return io.ErrUnexpectedEOF
37743 }
37744 m.Field14 = append(m.Field14, string(dAtA[iNdEx:postIndex]))
37745 iNdEx = postIndex
37746 case 15:
37747 if wireType != 2 {
37748 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
37749 }
37750 var byteLen int
37751 for shift := uint(0); ; shift += 7 {
37752 if shift >= 64 {
37753 return ErrIntOverflowThetest
37754 }
37755 if iNdEx >= l {
37756 return io.ErrUnexpectedEOF
37757 }
37758 b := dAtA[iNdEx]
37759 iNdEx++
37760 byteLen |= int(b&0x7F) << shift
37761 if b < 0x80 {
37762 break
37763 }
37764 }
37765 if byteLen < 0 {
37766 return ErrInvalidLengthThetest
37767 }
37768 postIndex := iNdEx + byteLen
37769 if postIndex < 0 {
37770 return ErrInvalidLengthThetest
37771 }
37772 if postIndex > l {
37773 return io.ErrUnexpectedEOF
37774 }
37775 m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx))
37776 copy(m.Field15[len(m.Field15)-1], dAtA[iNdEx:postIndex])
37777 iNdEx = postIndex
37778 default:
37779 iNdEx = preIndex
37780 skippy, err := skipThetest(dAtA[iNdEx:])
37781 if err != nil {
37782 return err
37783 }
37784 if (skippy < 0) || (iNdEx+skippy) < 0 {
37785 return ErrInvalidLengthThetest
37786 }
37787 if (iNdEx + skippy) > l {
37788 return io.ErrUnexpectedEOF
37789 }
37790 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
37791 iNdEx += skippy
37792 }
37793 }
37794
37795 if iNdEx > l {
37796 return io.ErrUnexpectedEOF
37797 }
37798 return nil
37799 }
37800 func (m *NinRepStruct) Unmarshal(dAtA []byte) error {
37801 l := len(dAtA)
37802 iNdEx := 0
37803 for iNdEx < l {
37804 preIndex := iNdEx
37805 var wire uint64
37806 for shift := uint(0); ; shift += 7 {
37807 if shift >= 64 {
37808 return ErrIntOverflowThetest
37809 }
37810 if iNdEx >= l {
37811 return io.ErrUnexpectedEOF
37812 }
37813 b := dAtA[iNdEx]
37814 iNdEx++
37815 wire |= uint64(b&0x7F) << shift
37816 if b < 0x80 {
37817 break
37818 }
37819 }
37820 fieldNum := int32(wire >> 3)
37821 wireType := int(wire & 0x7)
37822 if wireType == 4 {
37823 return fmt.Errorf("proto: NinRepStruct: wiretype end group for non-group")
37824 }
37825 if fieldNum <= 0 {
37826 return fmt.Errorf("proto: NinRepStruct: illegal tag %d (wire type %d)", fieldNum, wire)
37827 }
37828 switch fieldNum {
37829 case 1:
37830 if wireType == 1 {
37831 var v uint64
37832 if (iNdEx + 8) > l {
37833 return io.ErrUnexpectedEOF
37834 }
37835 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
37836 iNdEx += 8
37837 v2 := float64(math.Float64frombits(v))
37838 m.Field1 = append(m.Field1, v2)
37839 } else if wireType == 2 {
37840 var packedLen int
37841 for shift := uint(0); ; shift += 7 {
37842 if shift >= 64 {
37843 return ErrIntOverflowThetest
37844 }
37845 if iNdEx >= l {
37846 return io.ErrUnexpectedEOF
37847 }
37848 b := dAtA[iNdEx]
37849 iNdEx++
37850 packedLen |= int(b&0x7F) << shift
37851 if b < 0x80 {
37852 break
37853 }
37854 }
37855 if packedLen < 0 {
37856 return ErrInvalidLengthThetest
37857 }
37858 postIndex := iNdEx + packedLen
37859 if postIndex < 0 {
37860 return ErrInvalidLengthThetest
37861 }
37862 if postIndex > l {
37863 return io.ErrUnexpectedEOF
37864 }
37865 var elementCount int
37866 elementCount = packedLen / 8
37867 if elementCount != 0 && len(m.Field1) == 0 {
37868 m.Field1 = make([]float64, 0, elementCount)
37869 }
37870 for iNdEx < postIndex {
37871 var v uint64
37872 if (iNdEx + 8) > l {
37873 return io.ErrUnexpectedEOF
37874 }
37875 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
37876 iNdEx += 8
37877 v2 := float64(math.Float64frombits(v))
37878 m.Field1 = append(m.Field1, v2)
37879 }
37880 } else {
37881 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
37882 }
37883 case 2:
37884 if wireType == 5 {
37885 var v uint32
37886 if (iNdEx + 4) > l {
37887 return io.ErrUnexpectedEOF
37888 }
37889 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
37890 iNdEx += 4
37891 v2 := float32(math.Float32frombits(v))
37892 m.Field2 = append(m.Field2, v2)
37893 } else if wireType == 2 {
37894 var packedLen int
37895 for shift := uint(0); ; shift += 7 {
37896 if shift >= 64 {
37897 return ErrIntOverflowThetest
37898 }
37899 if iNdEx >= l {
37900 return io.ErrUnexpectedEOF
37901 }
37902 b := dAtA[iNdEx]
37903 iNdEx++
37904 packedLen |= int(b&0x7F) << shift
37905 if b < 0x80 {
37906 break
37907 }
37908 }
37909 if packedLen < 0 {
37910 return ErrInvalidLengthThetest
37911 }
37912 postIndex := iNdEx + packedLen
37913 if postIndex < 0 {
37914 return ErrInvalidLengthThetest
37915 }
37916 if postIndex > l {
37917 return io.ErrUnexpectedEOF
37918 }
37919 var elementCount int
37920 elementCount = packedLen / 4
37921 if elementCount != 0 && len(m.Field2) == 0 {
37922 m.Field2 = make([]float32, 0, elementCount)
37923 }
37924 for iNdEx < postIndex {
37925 var v uint32
37926 if (iNdEx + 4) > l {
37927 return io.ErrUnexpectedEOF
37928 }
37929 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
37930 iNdEx += 4
37931 v2 := float32(math.Float32frombits(v))
37932 m.Field2 = append(m.Field2, v2)
37933 }
37934 } else {
37935 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
37936 }
37937 case 3:
37938 if wireType != 2 {
37939 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
37940 }
37941 var msglen int
37942 for shift := uint(0); ; shift += 7 {
37943 if shift >= 64 {
37944 return ErrIntOverflowThetest
37945 }
37946 if iNdEx >= l {
37947 return io.ErrUnexpectedEOF
37948 }
37949 b := dAtA[iNdEx]
37950 iNdEx++
37951 msglen |= int(b&0x7F) << shift
37952 if b < 0x80 {
37953 break
37954 }
37955 }
37956 if msglen < 0 {
37957 return ErrInvalidLengthThetest
37958 }
37959 postIndex := iNdEx + msglen
37960 if postIndex < 0 {
37961 return ErrInvalidLengthThetest
37962 }
37963 if postIndex > l {
37964 return io.ErrUnexpectedEOF
37965 }
37966 m.Field3 = append(m.Field3, &NidOptNative{})
37967 if err := m.Field3[len(m.Field3)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
37968 return err
37969 }
37970 iNdEx = postIndex
37971 case 4:
37972 if wireType != 2 {
37973 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
37974 }
37975 var msglen int
37976 for shift := uint(0); ; shift += 7 {
37977 if shift >= 64 {
37978 return ErrIntOverflowThetest
37979 }
37980 if iNdEx >= l {
37981 return io.ErrUnexpectedEOF
37982 }
37983 b := dAtA[iNdEx]
37984 iNdEx++
37985 msglen |= int(b&0x7F) << shift
37986 if b < 0x80 {
37987 break
37988 }
37989 }
37990 if msglen < 0 {
37991 return ErrInvalidLengthThetest
37992 }
37993 postIndex := iNdEx + msglen
37994 if postIndex < 0 {
37995 return ErrInvalidLengthThetest
37996 }
37997 if postIndex > l {
37998 return io.ErrUnexpectedEOF
37999 }
38000 m.Field4 = append(m.Field4, &NinOptNative{})
38001 if err := m.Field4[len(m.Field4)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38002 return err
38003 }
38004 iNdEx = postIndex
38005 case 6:
38006 if wireType == 0 {
38007 var v uint64
38008 for shift := uint(0); ; shift += 7 {
38009 if shift >= 64 {
38010 return ErrIntOverflowThetest
38011 }
38012 if iNdEx >= l {
38013 return io.ErrUnexpectedEOF
38014 }
38015 b := dAtA[iNdEx]
38016 iNdEx++
38017 v |= uint64(b&0x7F) << shift
38018 if b < 0x80 {
38019 break
38020 }
38021 }
38022 m.Field6 = append(m.Field6, v)
38023 } else if wireType == 2 {
38024 var packedLen int
38025 for shift := uint(0); ; shift += 7 {
38026 if shift >= 64 {
38027 return ErrIntOverflowThetest
38028 }
38029 if iNdEx >= l {
38030 return io.ErrUnexpectedEOF
38031 }
38032 b := dAtA[iNdEx]
38033 iNdEx++
38034 packedLen |= int(b&0x7F) << shift
38035 if b < 0x80 {
38036 break
38037 }
38038 }
38039 if packedLen < 0 {
38040 return ErrInvalidLengthThetest
38041 }
38042 postIndex := iNdEx + packedLen
38043 if postIndex < 0 {
38044 return ErrInvalidLengthThetest
38045 }
38046 if postIndex > l {
38047 return io.ErrUnexpectedEOF
38048 }
38049 var elementCount int
38050 var count int
38051 for _, integer := range dAtA[iNdEx:postIndex] {
38052 if integer < 128 {
38053 count++
38054 }
38055 }
38056 elementCount = count
38057 if elementCount != 0 && len(m.Field6) == 0 {
38058 m.Field6 = make([]uint64, 0, elementCount)
38059 }
38060 for iNdEx < postIndex {
38061 var v uint64
38062 for shift := uint(0); ; shift += 7 {
38063 if shift >= 64 {
38064 return ErrIntOverflowThetest
38065 }
38066 if iNdEx >= l {
38067 return io.ErrUnexpectedEOF
38068 }
38069 b := dAtA[iNdEx]
38070 iNdEx++
38071 v |= uint64(b&0x7F) << shift
38072 if b < 0x80 {
38073 break
38074 }
38075 }
38076 m.Field6 = append(m.Field6, v)
38077 }
38078 } else {
38079 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
38080 }
38081 case 7:
38082 if wireType == 0 {
38083 var v int32
38084 for shift := uint(0); ; shift += 7 {
38085 if shift >= 64 {
38086 return ErrIntOverflowThetest
38087 }
38088 if iNdEx >= l {
38089 return io.ErrUnexpectedEOF
38090 }
38091 b := dAtA[iNdEx]
38092 iNdEx++
38093 v |= int32(b&0x7F) << shift
38094 if b < 0x80 {
38095 break
38096 }
38097 }
38098 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
38099 m.Field7 = append(m.Field7, v)
38100 } else if wireType == 2 {
38101 var packedLen int
38102 for shift := uint(0); ; shift += 7 {
38103 if shift >= 64 {
38104 return ErrIntOverflowThetest
38105 }
38106 if iNdEx >= l {
38107 return io.ErrUnexpectedEOF
38108 }
38109 b := dAtA[iNdEx]
38110 iNdEx++
38111 packedLen |= int(b&0x7F) << shift
38112 if b < 0x80 {
38113 break
38114 }
38115 }
38116 if packedLen < 0 {
38117 return ErrInvalidLengthThetest
38118 }
38119 postIndex := iNdEx + packedLen
38120 if postIndex < 0 {
38121 return ErrInvalidLengthThetest
38122 }
38123 if postIndex > l {
38124 return io.ErrUnexpectedEOF
38125 }
38126 var elementCount int
38127 var count int
38128 for _, integer := range dAtA[iNdEx:postIndex] {
38129 if integer < 128 {
38130 count++
38131 }
38132 }
38133 elementCount = count
38134 if elementCount != 0 && len(m.Field7) == 0 {
38135 m.Field7 = make([]int32, 0, elementCount)
38136 }
38137 for iNdEx < postIndex {
38138 var v int32
38139 for shift := uint(0); ; shift += 7 {
38140 if shift >= 64 {
38141 return ErrIntOverflowThetest
38142 }
38143 if iNdEx >= l {
38144 return io.ErrUnexpectedEOF
38145 }
38146 b := dAtA[iNdEx]
38147 iNdEx++
38148 v |= int32(b&0x7F) << shift
38149 if b < 0x80 {
38150 break
38151 }
38152 }
38153 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
38154 m.Field7 = append(m.Field7, v)
38155 }
38156 } else {
38157 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
38158 }
38159 case 8:
38160 if wireType != 2 {
38161 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
38162 }
38163 var msglen int
38164 for shift := uint(0); ; shift += 7 {
38165 if shift >= 64 {
38166 return ErrIntOverflowThetest
38167 }
38168 if iNdEx >= l {
38169 return io.ErrUnexpectedEOF
38170 }
38171 b := dAtA[iNdEx]
38172 iNdEx++
38173 msglen |= int(b&0x7F) << shift
38174 if b < 0x80 {
38175 break
38176 }
38177 }
38178 if msglen < 0 {
38179 return ErrInvalidLengthThetest
38180 }
38181 postIndex := iNdEx + msglen
38182 if postIndex < 0 {
38183 return ErrInvalidLengthThetest
38184 }
38185 if postIndex > l {
38186 return io.ErrUnexpectedEOF
38187 }
38188 m.Field8 = append(m.Field8, &NidOptNative{})
38189 if err := m.Field8[len(m.Field8)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38190 return err
38191 }
38192 iNdEx = postIndex
38193 case 13:
38194 if wireType == 0 {
38195 var v int
38196 for shift := uint(0); ; shift += 7 {
38197 if shift >= 64 {
38198 return ErrIntOverflowThetest
38199 }
38200 if iNdEx >= l {
38201 return io.ErrUnexpectedEOF
38202 }
38203 b := dAtA[iNdEx]
38204 iNdEx++
38205 v |= int(b&0x7F) << shift
38206 if b < 0x80 {
38207 break
38208 }
38209 }
38210 m.Field13 = append(m.Field13, bool(v != 0))
38211 } else if wireType == 2 {
38212 var packedLen int
38213 for shift := uint(0); ; shift += 7 {
38214 if shift >= 64 {
38215 return ErrIntOverflowThetest
38216 }
38217 if iNdEx >= l {
38218 return io.ErrUnexpectedEOF
38219 }
38220 b := dAtA[iNdEx]
38221 iNdEx++
38222 packedLen |= int(b&0x7F) << shift
38223 if b < 0x80 {
38224 break
38225 }
38226 }
38227 if packedLen < 0 {
38228 return ErrInvalidLengthThetest
38229 }
38230 postIndex := iNdEx + packedLen
38231 if postIndex < 0 {
38232 return ErrInvalidLengthThetest
38233 }
38234 if postIndex > l {
38235 return io.ErrUnexpectedEOF
38236 }
38237 var elementCount int
38238 elementCount = packedLen
38239 if elementCount != 0 && len(m.Field13) == 0 {
38240 m.Field13 = make([]bool, 0, elementCount)
38241 }
38242 for iNdEx < postIndex {
38243 var v int
38244 for shift := uint(0); ; shift += 7 {
38245 if shift >= 64 {
38246 return ErrIntOverflowThetest
38247 }
38248 if iNdEx >= l {
38249 return io.ErrUnexpectedEOF
38250 }
38251 b := dAtA[iNdEx]
38252 iNdEx++
38253 v |= int(b&0x7F) << shift
38254 if b < 0x80 {
38255 break
38256 }
38257 }
38258 m.Field13 = append(m.Field13, bool(v != 0))
38259 }
38260 } else {
38261 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
38262 }
38263 case 14:
38264 if wireType != 2 {
38265 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
38266 }
38267 var stringLen uint64
38268 for shift := uint(0); ; shift += 7 {
38269 if shift >= 64 {
38270 return ErrIntOverflowThetest
38271 }
38272 if iNdEx >= l {
38273 return io.ErrUnexpectedEOF
38274 }
38275 b := dAtA[iNdEx]
38276 iNdEx++
38277 stringLen |= uint64(b&0x7F) << shift
38278 if b < 0x80 {
38279 break
38280 }
38281 }
38282 intStringLen := int(stringLen)
38283 if intStringLen < 0 {
38284 return ErrInvalidLengthThetest
38285 }
38286 postIndex := iNdEx + intStringLen
38287 if postIndex < 0 {
38288 return ErrInvalidLengthThetest
38289 }
38290 if postIndex > l {
38291 return io.ErrUnexpectedEOF
38292 }
38293 m.Field14 = append(m.Field14, string(dAtA[iNdEx:postIndex]))
38294 iNdEx = postIndex
38295 case 15:
38296 if wireType != 2 {
38297 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
38298 }
38299 var byteLen int
38300 for shift := uint(0); ; shift += 7 {
38301 if shift >= 64 {
38302 return ErrIntOverflowThetest
38303 }
38304 if iNdEx >= l {
38305 return io.ErrUnexpectedEOF
38306 }
38307 b := dAtA[iNdEx]
38308 iNdEx++
38309 byteLen |= int(b&0x7F) << shift
38310 if b < 0x80 {
38311 break
38312 }
38313 }
38314 if byteLen < 0 {
38315 return ErrInvalidLengthThetest
38316 }
38317 postIndex := iNdEx + byteLen
38318 if postIndex < 0 {
38319 return ErrInvalidLengthThetest
38320 }
38321 if postIndex > l {
38322 return io.ErrUnexpectedEOF
38323 }
38324 m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx))
38325 copy(m.Field15[len(m.Field15)-1], dAtA[iNdEx:postIndex])
38326 iNdEx = postIndex
38327 default:
38328 iNdEx = preIndex
38329 skippy, err := skipThetest(dAtA[iNdEx:])
38330 if err != nil {
38331 return err
38332 }
38333 if (skippy < 0) || (iNdEx+skippy) < 0 {
38334 return ErrInvalidLengthThetest
38335 }
38336 if (iNdEx + skippy) > l {
38337 return io.ErrUnexpectedEOF
38338 }
38339 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
38340 iNdEx += skippy
38341 }
38342 }
38343
38344 if iNdEx > l {
38345 return io.ErrUnexpectedEOF
38346 }
38347 return nil
38348 }
38349 func (m *NidEmbeddedStruct) Unmarshal(dAtA []byte) error {
38350 l := len(dAtA)
38351 iNdEx := 0
38352 for iNdEx < l {
38353 preIndex := iNdEx
38354 var wire uint64
38355 for shift := uint(0); ; shift += 7 {
38356 if shift >= 64 {
38357 return ErrIntOverflowThetest
38358 }
38359 if iNdEx >= l {
38360 return io.ErrUnexpectedEOF
38361 }
38362 b := dAtA[iNdEx]
38363 iNdEx++
38364 wire |= uint64(b&0x7F) << shift
38365 if b < 0x80 {
38366 break
38367 }
38368 }
38369 fieldNum := int32(wire >> 3)
38370 wireType := int(wire & 0x7)
38371 if wireType == 4 {
38372 return fmt.Errorf("proto: NidEmbeddedStruct: wiretype end group for non-group")
38373 }
38374 if fieldNum <= 0 {
38375 return fmt.Errorf("proto: NidEmbeddedStruct: illegal tag %d (wire type %d)", fieldNum, wire)
38376 }
38377 switch fieldNum {
38378 case 1:
38379 if wireType != 2 {
38380 return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType)
38381 }
38382 var msglen int
38383 for shift := uint(0); ; shift += 7 {
38384 if shift >= 64 {
38385 return ErrIntOverflowThetest
38386 }
38387 if iNdEx >= l {
38388 return io.ErrUnexpectedEOF
38389 }
38390 b := dAtA[iNdEx]
38391 iNdEx++
38392 msglen |= int(b&0x7F) << shift
38393 if b < 0x80 {
38394 break
38395 }
38396 }
38397 if msglen < 0 {
38398 return ErrInvalidLengthThetest
38399 }
38400 postIndex := iNdEx + msglen
38401 if postIndex < 0 {
38402 return ErrInvalidLengthThetest
38403 }
38404 if postIndex > l {
38405 return io.ErrUnexpectedEOF
38406 }
38407 if m.NidOptNative == nil {
38408 m.NidOptNative = &NidOptNative{}
38409 }
38410 if err := m.NidOptNative.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38411 return err
38412 }
38413 iNdEx = postIndex
38414 case 200:
38415 if wireType != 2 {
38416 return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType)
38417 }
38418 var msglen int
38419 for shift := uint(0); ; shift += 7 {
38420 if shift >= 64 {
38421 return ErrIntOverflowThetest
38422 }
38423 if iNdEx >= l {
38424 return io.ErrUnexpectedEOF
38425 }
38426 b := dAtA[iNdEx]
38427 iNdEx++
38428 msglen |= int(b&0x7F) << shift
38429 if b < 0x80 {
38430 break
38431 }
38432 }
38433 if msglen < 0 {
38434 return ErrInvalidLengthThetest
38435 }
38436 postIndex := iNdEx + msglen
38437 if postIndex < 0 {
38438 return ErrInvalidLengthThetest
38439 }
38440 if postIndex > l {
38441 return io.ErrUnexpectedEOF
38442 }
38443 if err := m.Field200.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38444 return err
38445 }
38446 iNdEx = postIndex
38447 case 210:
38448 if wireType != 0 {
38449 return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType)
38450 }
38451 var v int
38452 for shift := uint(0); ; shift += 7 {
38453 if shift >= 64 {
38454 return ErrIntOverflowThetest
38455 }
38456 if iNdEx >= l {
38457 return io.ErrUnexpectedEOF
38458 }
38459 b := dAtA[iNdEx]
38460 iNdEx++
38461 v |= int(b&0x7F) << shift
38462 if b < 0x80 {
38463 break
38464 }
38465 }
38466 m.Field210 = bool(v != 0)
38467 default:
38468 iNdEx = preIndex
38469 skippy, err := skipThetest(dAtA[iNdEx:])
38470 if err != nil {
38471 return err
38472 }
38473 if (skippy < 0) || (iNdEx+skippy) < 0 {
38474 return ErrInvalidLengthThetest
38475 }
38476 if (iNdEx + skippy) > l {
38477 return io.ErrUnexpectedEOF
38478 }
38479 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
38480 iNdEx += skippy
38481 }
38482 }
38483
38484 if iNdEx > l {
38485 return io.ErrUnexpectedEOF
38486 }
38487 return nil
38488 }
38489 func (m *NinEmbeddedStruct) Unmarshal(dAtA []byte) error {
38490 l := len(dAtA)
38491 iNdEx := 0
38492 for iNdEx < l {
38493 preIndex := iNdEx
38494 var wire uint64
38495 for shift := uint(0); ; shift += 7 {
38496 if shift >= 64 {
38497 return ErrIntOverflowThetest
38498 }
38499 if iNdEx >= l {
38500 return io.ErrUnexpectedEOF
38501 }
38502 b := dAtA[iNdEx]
38503 iNdEx++
38504 wire |= uint64(b&0x7F) << shift
38505 if b < 0x80 {
38506 break
38507 }
38508 }
38509 fieldNum := int32(wire >> 3)
38510 wireType := int(wire & 0x7)
38511 if wireType == 4 {
38512 return fmt.Errorf("proto: NinEmbeddedStruct: wiretype end group for non-group")
38513 }
38514 if fieldNum <= 0 {
38515 return fmt.Errorf("proto: NinEmbeddedStruct: illegal tag %d (wire type %d)", fieldNum, wire)
38516 }
38517 switch fieldNum {
38518 case 1:
38519 if wireType != 2 {
38520 return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType)
38521 }
38522 var msglen int
38523 for shift := uint(0); ; shift += 7 {
38524 if shift >= 64 {
38525 return ErrIntOverflowThetest
38526 }
38527 if iNdEx >= l {
38528 return io.ErrUnexpectedEOF
38529 }
38530 b := dAtA[iNdEx]
38531 iNdEx++
38532 msglen |= int(b&0x7F) << shift
38533 if b < 0x80 {
38534 break
38535 }
38536 }
38537 if msglen < 0 {
38538 return ErrInvalidLengthThetest
38539 }
38540 postIndex := iNdEx + msglen
38541 if postIndex < 0 {
38542 return ErrInvalidLengthThetest
38543 }
38544 if postIndex > l {
38545 return io.ErrUnexpectedEOF
38546 }
38547 if m.NidOptNative == nil {
38548 m.NidOptNative = &NidOptNative{}
38549 }
38550 if err := m.NidOptNative.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38551 return err
38552 }
38553 iNdEx = postIndex
38554 case 200:
38555 if wireType != 2 {
38556 return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType)
38557 }
38558 var msglen int
38559 for shift := uint(0); ; shift += 7 {
38560 if shift >= 64 {
38561 return ErrIntOverflowThetest
38562 }
38563 if iNdEx >= l {
38564 return io.ErrUnexpectedEOF
38565 }
38566 b := dAtA[iNdEx]
38567 iNdEx++
38568 msglen |= int(b&0x7F) << shift
38569 if b < 0x80 {
38570 break
38571 }
38572 }
38573 if msglen < 0 {
38574 return ErrInvalidLengthThetest
38575 }
38576 postIndex := iNdEx + msglen
38577 if postIndex < 0 {
38578 return ErrInvalidLengthThetest
38579 }
38580 if postIndex > l {
38581 return io.ErrUnexpectedEOF
38582 }
38583 if m.Field200 == nil {
38584 m.Field200 = &NidOptNative{}
38585 }
38586 if err := m.Field200.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38587 return err
38588 }
38589 iNdEx = postIndex
38590 case 210:
38591 if wireType != 0 {
38592 return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType)
38593 }
38594 var v int
38595 for shift := uint(0); ; shift += 7 {
38596 if shift >= 64 {
38597 return ErrIntOverflowThetest
38598 }
38599 if iNdEx >= l {
38600 return io.ErrUnexpectedEOF
38601 }
38602 b := dAtA[iNdEx]
38603 iNdEx++
38604 v |= int(b&0x7F) << shift
38605 if b < 0x80 {
38606 break
38607 }
38608 }
38609 b := bool(v != 0)
38610 m.Field210 = &b
38611 default:
38612 iNdEx = preIndex
38613 skippy, err := skipThetest(dAtA[iNdEx:])
38614 if err != nil {
38615 return err
38616 }
38617 if (skippy < 0) || (iNdEx+skippy) < 0 {
38618 return ErrInvalidLengthThetest
38619 }
38620 if (iNdEx + skippy) > l {
38621 return io.ErrUnexpectedEOF
38622 }
38623 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
38624 iNdEx += skippy
38625 }
38626 }
38627
38628 if iNdEx > l {
38629 return io.ErrUnexpectedEOF
38630 }
38631 return nil
38632 }
38633 func (m *NidNestedStruct) Unmarshal(dAtA []byte) error {
38634 l := len(dAtA)
38635 iNdEx := 0
38636 for iNdEx < l {
38637 preIndex := iNdEx
38638 var wire uint64
38639 for shift := uint(0); ; shift += 7 {
38640 if shift >= 64 {
38641 return ErrIntOverflowThetest
38642 }
38643 if iNdEx >= l {
38644 return io.ErrUnexpectedEOF
38645 }
38646 b := dAtA[iNdEx]
38647 iNdEx++
38648 wire |= uint64(b&0x7F) << shift
38649 if b < 0x80 {
38650 break
38651 }
38652 }
38653 fieldNum := int32(wire >> 3)
38654 wireType := int(wire & 0x7)
38655 if wireType == 4 {
38656 return fmt.Errorf("proto: NidNestedStruct: wiretype end group for non-group")
38657 }
38658 if fieldNum <= 0 {
38659 return fmt.Errorf("proto: NidNestedStruct: illegal tag %d (wire type %d)", fieldNum, wire)
38660 }
38661 switch fieldNum {
38662 case 1:
38663 if wireType != 2 {
38664 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
38665 }
38666 var msglen int
38667 for shift := uint(0); ; shift += 7 {
38668 if shift >= 64 {
38669 return ErrIntOverflowThetest
38670 }
38671 if iNdEx >= l {
38672 return io.ErrUnexpectedEOF
38673 }
38674 b := dAtA[iNdEx]
38675 iNdEx++
38676 msglen |= int(b&0x7F) << shift
38677 if b < 0x80 {
38678 break
38679 }
38680 }
38681 if msglen < 0 {
38682 return ErrInvalidLengthThetest
38683 }
38684 postIndex := iNdEx + msglen
38685 if postIndex < 0 {
38686 return ErrInvalidLengthThetest
38687 }
38688 if postIndex > l {
38689 return io.ErrUnexpectedEOF
38690 }
38691 if err := m.Field1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38692 return err
38693 }
38694 iNdEx = postIndex
38695 case 2:
38696 if wireType != 2 {
38697 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
38698 }
38699 var msglen int
38700 for shift := uint(0); ; shift += 7 {
38701 if shift >= 64 {
38702 return ErrIntOverflowThetest
38703 }
38704 if iNdEx >= l {
38705 return io.ErrUnexpectedEOF
38706 }
38707 b := dAtA[iNdEx]
38708 iNdEx++
38709 msglen |= int(b&0x7F) << shift
38710 if b < 0x80 {
38711 break
38712 }
38713 }
38714 if msglen < 0 {
38715 return ErrInvalidLengthThetest
38716 }
38717 postIndex := iNdEx + msglen
38718 if postIndex < 0 {
38719 return ErrInvalidLengthThetest
38720 }
38721 if postIndex > l {
38722 return io.ErrUnexpectedEOF
38723 }
38724 m.Field2 = append(m.Field2, NidRepStruct{})
38725 if err := m.Field2[len(m.Field2)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38726 return err
38727 }
38728 iNdEx = postIndex
38729 default:
38730 iNdEx = preIndex
38731 skippy, err := skipThetest(dAtA[iNdEx:])
38732 if err != nil {
38733 return err
38734 }
38735 if (skippy < 0) || (iNdEx+skippy) < 0 {
38736 return ErrInvalidLengthThetest
38737 }
38738 if (iNdEx + skippy) > l {
38739 return io.ErrUnexpectedEOF
38740 }
38741 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
38742 iNdEx += skippy
38743 }
38744 }
38745
38746 if iNdEx > l {
38747 return io.ErrUnexpectedEOF
38748 }
38749 return nil
38750 }
38751 func (m *NinNestedStruct) Unmarshal(dAtA []byte) error {
38752 l := len(dAtA)
38753 iNdEx := 0
38754 for iNdEx < l {
38755 preIndex := iNdEx
38756 var wire uint64
38757 for shift := uint(0); ; shift += 7 {
38758 if shift >= 64 {
38759 return ErrIntOverflowThetest
38760 }
38761 if iNdEx >= l {
38762 return io.ErrUnexpectedEOF
38763 }
38764 b := dAtA[iNdEx]
38765 iNdEx++
38766 wire |= uint64(b&0x7F) << shift
38767 if b < 0x80 {
38768 break
38769 }
38770 }
38771 fieldNum := int32(wire >> 3)
38772 wireType := int(wire & 0x7)
38773 if wireType == 4 {
38774 return fmt.Errorf("proto: NinNestedStruct: wiretype end group for non-group")
38775 }
38776 if fieldNum <= 0 {
38777 return fmt.Errorf("proto: NinNestedStruct: illegal tag %d (wire type %d)", fieldNum, wire)
38778 }
38779 switch fieldNum {
38780 case 1:
38781 if wireType != 2 {
38782 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
38783 }
38784 var msglen int
38785 for shift := uint(0); ; shift += 7 {
38786 if shift >= 64 {
38787 return ErrIntOverflowThetest
38788 }
38789 if iNdEx >= l {
38790 return io.ErrUnexpectedEOF
38791 }
38792 b := dAtA[iNdEx]
38793 iNdEx++
38794 msglen |= int(b&0x7F) << shift
38795 if b < 0x80 {
38796 break
38797 }
38798 }
38799 if msglen < 0 {
38800 return ErrInvalidLengthThetest
38801 }
38802 postIndex := iNdEx + msglen
38803 if postIndex < 0 {
38804 return ErrInvalidLengthThetest
38805 }
38806 if postIndex > l {
38807 return io.ErrUnexpectedEOF
38808 }
38809 if m.Field1 == nil {
38810 m.Field1 = &NinOptStruct{}
38811 }
38812 if err := m.Field1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38813 return err
38814 }
38815 iNdEx = postIndex
38816 case 2:
38817 if wireType != 2 {
38818 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
38819 }
38820 var msglen int
38821 for shift := uint(0); ; shift += 7 {
38822 if shift >= 64 {
38823 return ErrIntOverflowThetest
38824 }
38825 if iNdEx >= l {
38826 return io.ErrUnexpectedEOF
38827 }
38828 b := dAtA[iNdEx]
38829 iNdEx++
38830 msglen |= int(b&0x7F) << shift
38831 if b < 0x80 {
38832 break
38833 }
38834 }
38835 if msglen < 0 {
38836 return ErrInvalidLengthThetest
38837 }
38838 postIndex := iNdEx + msglen
38839 if postIndex < 0 {
38840 return ErrInvalidLengthThetest
38841 }
38842 if postIndex > l {
38843 return io.ErrUnexpectedEOF
38844 }
38845 m.Field2 = append(m.Field2, &NinRepStruct{})
38846 if err := m.Field2[len(m.Field2)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38847 return err
38848 }
38849 iNdEx = postIndex
38850 default:
38851 iNdEx = preIndex
38852 skippy, err := skipThetest(dAtA[iNdEx:])
38853 if err != nil {
38854 return err
38855 }
38856 if (skippy < 0) || (iNdEx+skippy) < 0 {
38857 return ErrInvalidLengthThetest
38858 }
38859 if (iNdEx + skippy) > l {
38860 return io.ErrUnexpectedEOF
38861 }
38862 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
38863 iNdEx += skippy
38864 }
38865 }
38866
38867 if iNdEx > l {
38868 return io.ErrUnexpectedEOF
38869 }
38870 return nil
38871 }
38872 func (m *NidOptCustom) Unmarshal(dAtA []byte) error {
38873 l := len(dAtA)
38874 iNdEx := 0
38875 for iNdEx < l {
38876 preIndex := iNdEx
38877 var wire uint64
38878 for shift := uint(0); ; shift += 7 {
38879 if shift >= 64 {
38880 return ErrIntOverflowThetest
38881 }
38882 if iNdEx >= l {
38883 return io.ErrUnexpectedEOF
38884 }
38885 b := dAtA[iNdEx]
38886 iNdEx++
38887 wire |= uint64(b&0x7F) << shift
38888 if b < 0x80 {
38889 break
38890 }
38891 }
38892 fieldNum := int32(wire >> 3)
38893 wireType := int(wire & 0x7)
38894 if wireType == 4 {
38895 return fmt.Errorf("proto: NidOptCustom: wiretype end group for non-group")
38896 }
38897 if fieldNum <= 0 {
38898 return fmt.Errorf("proto: NidOptCustom: illegal tag %d (wire type %d)", fieldNum, wire)
38899 }
38900 switch fieldNum {
38901 case 1:
38902 if wireType != 2 {
38903 return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
38904 }
38905 var byteLen int
38906 for shift := uint(0); ; shift += 7 {
38907 if shift >= 64 {
38908 return ErrIntOverflowThetest
38909 }
38910 if iNdEx >= l {
38911 return io.ErrUnexpectedEOF
38912 }
38913 b := dAtA[iNdEx]
38914 iNdEx++
38915 byteLen |= int(b&0x7F) << shift
38916 if b < 0x80 {
38917 break
38918 }
38919 }
38920 if byteLen < 0 {
38921 return ErrInvalidLengthThetest
38922 }
38923 postIndex := iNdEx + byteLen
38924 if postIndex < 0 {
38925 return ErrInvalidLengthThetest
38926 }
38927 if postIndex > l {
38928 return io.ErrUnexpectedEOF
38929 }
38930 if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38931 return err
38932 }
38933 iNdEx = postIndex
38934 case 2:
38935 if wireType != 2 {
38936 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
38937 }
38938 var byteLen int
38939 for shift := uint(0); ; shift += 7 {
38940 if shift >= 64 {
38941 return ErrIntOverflowThetest
38942 }
38943 if iNdEx >= l {
38944 return io.ErrUnexpectedEOF
38945 }
38946 b := dAtA[iNdEx]
38947 iNdEx++
38948 byteLen |= int(b&0x7F) << shift
38949 if b < 0x80 {
38950 break
38951 }
38952 }
38953 if byteLen < 0 {
38954 return ErrInvalidLengthThetest
38955 }
38956 postIndex := iNdEx + byteLen
38957 if postIndex < 0 {
38958 return ErrInvalidLengthThetest
38959 }
38960 if postIndex > l {
38961 return io.ErrUnexpectedEOF
38962 }
38963 if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
38964 return err
38965 }
38966 iNdEx = postIndex
38967 default:
38968 iNdEx = preIndex
38969 skippy, err := skipThetest(dAtA[iNdEx:])
38970 if err != nil {
38971 return err
38972 }
38973 if (skippy < 0) || (iNdEx+skippy) < 0 {
38974 return ErrInvalidLengthThetest
38975 }
38976 if (iNdEx + skippy) > l {
38977 return io.ErrUnexpectedEOF
38978 }
38979 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
38980 iNdEx += skippy
38981 }
38982 }
38983
38984 if iNdEx > l {
38985 return io.ErrUnexpectedEOF
38986 }
38987 return nil
38988 }
38989 func (m *CustomDash) Unmarshal(dAtA []byte) error {
38990 l := len(dAtA)
38991 iNdEx := 0
38992 for iNdEx < l {
38993 preIndex := iNdEx
38994 var wire uint64
38995 for shift := uint(0); ; shift += 7 {
38996 if shift >= 64 {
38997 return ErrIntOverflowThetest
38998 }
38999 if iNdEx >= l {
39000 return io.ErrUnexpectedEOF
39001 }
39002 b := dAtA[iNdEx]
39003 iNdEx++
39004 wire |= uint64(b&0x7F) << shift
39005 if b < 0x80 {
39006 break
39007 }
39008 }
39009 fieldNum := int32(wire >> 3)
39010 wireType := int(wire & 0x7)
39011 if wireType == 4 {
39012 return fmt.Errorf("proto: CustomDash: wiretype end group for non-group")
39013 }
39014 if fieldNum <= 0 {
39015 return fmt.Errorf("proto: CustomDash: illegal tag %d (wire type %d)", fieldNum, wire)
39016 }
39017 switch fieldNum {
39018 case 1:
39019 if wireType != 2 {
39020 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
39021 }
39022 var byteLen int
39023 for shift := uint(0); ; shift += 7 {
39024 if shift >= 64 {
39025 return ErrIntOverflowThetest
39026 }
39027 if iNdEx >= l {
39028 return io.ErrUnexpectedEOF
39029 }
39030 b := dAtA[iNdEx]
39031 iNdEx++
39032 byteLen |= int(b&0x7F) << shift
39033 if b < 0x80 {
39034 break
39035 }
39036 }
39037 if byteLen < 0 {
39038 return ErrInvalidLengthThetest
39039 }
39040 postIndex := iNdEx + byteLen
39041 if postIndex < 0 {
39042 return ErrInvalidLengthThetest
39043 }
39044 if postIndex > l {
39045 return io.ErrUnexpectedEOF
39046 }
39047 var v github_com_gogo_protobuf_test_custom_dash_type.Bytes
39048 m.Value = &v
39049 if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
39050 return err
39051 }
39052 iNdEx = postIndex
39053 default:
39054 iNdEx = preIndex
39055 skippy, err := skipThetest(dAtA[iNdEx:])
39056 if err != nil {
39057 return err
39058 }
39059 if (skippy < 0) || (iNdEx+skippy) < 0 {
39060 return ErrInvalidLengthThetest
39061 }
39062 if (iNdEx + skippy) > l {
39063 return io.ErrUnexpectedEOF
39064 }
39065 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
39066 iNdEx += skippy
39067 }
39068 }
39069
39070 if iNdEx > l {
39071 return io.ErrUnexpectedEOF
39072 }
39073 return nil
39074 }
39075 func (m *NinOptCustom) Unmarshal(dAtA []byte) error {
39076 l := len(dAtA)
39077 iNdEx := 0
39078 for iNdEx < l {
39079 preIndex := iNdEx
39080 var wire uint64
39081 for shift := uint(0); ; shift += 7 {
39082 if shift >= 64 {
39083 return ErrIntOverflowThetest
39084 }
39085 if iNdEx >= l {
39086 return io.ErrUnexpectedEOF
39087 }
39088 b := dAtA[iNdEx]
39089 iNdEx++
39090 wire |= uint64(b&0x7F) << shift
39091 if b < 0x80 {
39092 break
39093 }
39094 }
39095 fieldNum := int32(wire >> 3)
39096 wireType := int(wire & 0x7)
39097 if wireType == 4 {
39098 return fmt.Errorf("proto: NinOptCustom: wiretype end group for non-group")
39099 }
39100 if fieldNum <= 0 {
39101 return fmt.Errorf("proto: NinOptCustom: illegal tag %d (wire type %d)", fieldNum, wire)
39102 }
39103 switch fieldNum {
39104 case 1:
39105 if wireType != 2 {
39106 return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
39107 }
39108 var byteLen int
39109 for shift := uint(0); ; shift += 7 {
39110 if shift >= 64 {
39111 return ErrIntOverflowThetest
39112 }
39113 if iNdEx >= l {
39114 return io.ErrUnexpectedEOF
39115 }
39116 b := dAtA[iNdEx]
39117 iNdEx++
39118 byteLen |= int(b&0x7F) << shift
39119 if b < 0x80 {
39120 break
39121 }
39122 }
39123 if byteLen < 0 {
39124 return ErrInvalidLengthThetest
39125 }
39126 postIndex := iNdEx + byteLen
39127 if postIndex < 0 {
39128 return ErrInvalidLengthThetest
39129 }
39130 if postIndex > l {
39131 return io.ErrUnexpectedEOF
39132 }
39133 var v Uuid
39134 m.Id = &v
39135 if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
39136 return err
39137 }
39138 iNdEx = postIndex
39139 case 2:
39140 if wireType != 2 {
39141 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
39142 }
39143 var byteLen int
39144 for shift := uint(0); ; shift += 7 {
39145 if shift >= 64 {
39146 return ErrIntOverflowThetest
39147 }
39148 if iNdEx >= l {
39149 return io.ErrUnexpectedEOF
39150 }
39151 b := dAtA[iNdEx]
39152 iNdEx++
39153 byteLen |= int(b&0x7F) << shift
39154 if b < 0x80 {
39155 break
39156 }
39157 }
39158 if byteLen < 0 {
39159 return ErrInvalidLengthThetest
39160 }
39161 postIndex := iNdEx + byteLen
39162 if postIndex < 0 {
39163 return ErrInvalidLengthThetest
39164 }
39165 if postIndex > l {
39166 return io.ErrUnexpectedEOF
39167 }
39168 var v github_com_gogo_protobuf_test_custom.Uint128
39169 m.Value = &v
39170 if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
39171 return err
39172 }
39173 iNdEx = postIndex
39174 default:
39175 iNdEx = preIndex
39176 skippy, err := skipThetest(dAtA[iNdEx:])
39177 if err != nil {
39178 return err
39179 }
39180 if (skippy < 0) || (iNdEx+skippy) < 0 {
39181 return ErrInvalidLengthThetest
39182 }
39183 if (iNdEx + skippy) > l {
39184 return io.ErrUnexpectedEOF
39185 }
39186 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
39187 iNdEx += skippy
39188 }
39189 }
39190
39191 if iNdEx > l {
39192 return io.ErrUnexpectedEOF
39193 }
39194 return nil
39195 }
39196 func (m *NidRepCustom) Unmarshal(dAtA []byte) error {
39197 l := len(dAtA)
39198 iNdEx := 0
39199 for iNdEx < l {
39200 preIndex := iNdEx
39201 var wire uint64
39202 for shift := uint(0); ; shift += 7 {
39203 if shift >= 64 {
39204 return ErrIntOverflowThetest
39205 }
39206 if iNdEx >= l {
39207 return io.ErrUnexpectedEOF
39208 }
39209 b := dAtA[iNdEx]
39210 iNdEx++
39211 wire |= uint64(b&0x7F) << shift
39212 if b < 0x80 {
39213 break
39214 }
39215 }
39216 fieldNum := int32(wire >> 3)
39217 wireType := int(wire & 0x7)
39218 if wireType == 4 {
39219 return fmt.Errorf("proto: NidRepCustom: wiretype end group for non-group")
39220 }
39221 if fieldNum <= 0 {
39222 return fmt.Errorf("proto: NidRepCustom: illegal tag %d (wire type %d)", fieldNum, wire)
39223 }
39224 switch fieldNum {
39225 case 1:
39226 if wireType != 2 {
39227 return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
39228 }
39229 var byteLen int
39230 for shift := uint(0); ; shift += 7 {
39231 if shift >= 64 {
39232 return ErrIntOverflowThetest
39233 }
39234 if iNdEx >= l {
39235 return io.ErrUnexpectedEOF
39236 }
39237 b := dAtA[iNdEx]
39238 iNdEx++
39239 byteLen |= int(b&0x7F) << shift
39240 if b < 0x80 {
39241 break
39242 }
39243 }
39244 if byteLen < 0 {
39245 return ErrInvalidLengthThetest
39246 }
39247 postIndex := iNdEx + byteLen
39248 if postIndex < 0 {
39249 return ErrInvalidLengthThetest
39250 }
39251 if postIndex > l {
39252 return io.ErrUnexpectedEOF
39253 }
39254 var v Uuid
39255 m.Id = append(m.Id, v)
39256 if err := m.Id[len(m.Id)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
39257 return err
39258 }
39259 iNdEx = postIndex
39260 case 2:
39261 if wireType != 2 {
39262 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
39263 }
39264 var byteLen int
39265 for shift := uint(0); ; shift += 7 {
39266 if shift >= 64 {
39267 return ErrIntOverflowThetest
39268 }
39269 if iNdEx >= l {
39270 return io.ErrUnexpectedEOF
39271 }
39272 b := dAtA[iNdEx]
39273 iNdEx++
39274 byteLen |= int(b&0x7F) << shift
39275 if b < 0x80 {
39276 break
39277 }
39278 }
39279 if byteLen < 0 {
39280 return ErrInvalidLengthThetest
39281 }
39282 postIndex := iNdEx + byteLen
39283 if postIndex < 0 {
39284 return ErrInvalidLengthThetest
39285 }
39286 if postIndex > l {
39287 return io.ErrUnexpectedEOF
39288 }
39289 var v github_com_gogo_protobuf_test_custom.Uint128
39290 m.Value = append(m.Value, v)
39291 if err := m.Value[len(m.Value)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
39292 return err
39293 }
39294 iNdEx = postIndex
39295 default:
39296 iNdEx = preIndex
39297 skippy, err := skipThetest(dAtA[iNdEx:])
39298 if err != nil {
39299 return err
39300 }
39301 if (skippy < 0) || (iNdEx+skippy) < 0 {
39302 return ErrInvalidLengthThetest
39303 }
39304 if (iNdEx + skippy) > l {
39305 return io.ErrUnexpectedEOF
39306 }
39307 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
39308 iNdEx += skippy
39309 }
39310 }
39311
39312 if iNdEx > l {
39313 return io.ErrUnexpectedEOF
39314 }
39315 return nil
39316 }
39317 func (m *NinRepCustom) Unmarshal(dAtA []byte) error {
39318 l := len(dAtA)
39319 iNdEx := 0
39320 for iNdEx < l {
39321 preIndex := iNdEx
39322 var wire uint64
39323 for shift := uint(0); ; shift += 7 {
39324 if shift >= 64 {
39325 return ErrIntOverflowThetest
39326 }
39327 if iNdEx >= l {
39328 return io.ErrUnexpectedEOF
39329 }
39330 b := dAtA[iNdEx]
39331 iNdEx++
39332 wire |= uint64(b&0x7F) << shift
39333 if b < 0x80 {
39334 break
39335 }
39336 }
39337 fieldNum := int32(wire >> 3)
39338 wireType := int(wire & 0x7)
39339 if wireType == 4 {
39340 return fmt.Errorf("proto: NinRepCustom: wiretype end group for non-group")
39341 }
39342 if fieldNum <= 0 {
39343 return fmt.Errorf("proto: NinRepCustom: illegal tag %d (wire type %d)", fieldNum, wire)
39344 }
39345 switch fieldNum {
39346 case 1:
39347 if wireType != 2 {
39348 return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
39349 }
39350 var byteLen int
39351 for shift := uint(0); ; shift += 7 {
39352 if shift >= 64 {
39353 return ErrIntOverflowThetest
39354 }
39355 if iNdEx >= l {
39356 return io.ErrUnexpectedEOF
39357 }
39358 b := dAtA[iNdEx]
39359 iNdEx++
39360 byteLen |= int(b&0x7F) << shift
39361 if b < 0x80 {
39362 break
39363 }
39364 }
39365 if byteLen < 0 {
39366 return ErrInvalidLengthThetest
39367 }
39368 postIndex := iNdEx + byteLen
39369 if postIndex < 0 {
39370 return ErrInvalidLengthThetest
39371 }
39372 if postIndex > l {
39373 return io.ErrUnexpectedEOF
39374 }
39375 var v Uuid
39376 m.Id = append(m.Id, v)
39377 if err := m.Id[len(m.Id)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
39378 return err
39379 }
39380 iNdEx = postIndex
39381 case 2:
39382 if wireType != 2 {
39383 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
39384 }
39385 var byteLen int
39386 for shift := uint(0); ; shift += 7 {
39387 if shift >= 64 {
39388 return ErrIntOverflowThetest
39389 }
39390 if iNdEx >= l {
39391 return io.ErrUnexpectedEOF
39392 }
39393 b := dAtA[iNdEx]
39394 iNdEx++
39395 byteLen |= int(b&0x7F) << shift
39396 if b < 0x80 {
39397 break
39398 }
39399 }
39400 if byteLen < 0 {
39401 return ErrInvalidLengthThetest
39402 }
39403 postIndex := iNdEx + byteLen
39404 if postIndex < 0 {
39405 return ErrInvalidLengthThetest
39406 }
39407 if postIndex > l {
39408 return io.ErrUnexpectedEOF
39409 }
39410 var v github_com_gogo_protobuf_test_custom.Uint128
39411 m.Value = append(m.Value, v)
39412 if err := m.Value[len(m.Value)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
39413 return err
39414 }
39415 iNdEx = postIndex
39416 default:
39417 iNdEx = preIndex
39418 skippy, err := skipThetest(dAtA[iNdEx:])
39419 if err != nil {
39420 return err
39421 }
39422 if (skippy < 0) || (iNdEx+skippy) < 0 {
39423 return ErrInvalidLengthThetest
39424 }
39425 if (iNdEx + skippy) > l {
39426 return io.ErrUnexpectedEOF
39427 }
39428 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
39429 iNdEx += skippy
39430 }
39431 }
39432
39433 if iNdEx > l {
39434 return io.ErrUnexpectedEOF
39435 }
39436 return nil
39437 }
39438 func (m *NinOptNativeUnion) Unmarshal(dAtA []byte) error {
39439 l := len(dAtA)
39440 iNdEx := 0
39441 for iNdEx < l {
39442 preIndex := iNdEx
39443 var wire uint64
39444 for shift := uint(0); ; shift += 7 {
39445 if shift >= 64 {
39446 return ErrIntOverflowThetest
39447 }
39448 if iNdEx >= l {
39449 return io.ErrUnexpectedEOF
39450 }
39451 b := dAtA[iNdEx]
39452 iNdEx++
39453 wire |= uint64(b&0x7F) << shift
39454 if b < 0x80 {
39455 break
39456 }
39457 }
39458 fieldNum := int32(wire >> 3)
39459 wireType := int(wire & 0x7)
39460 if wireType == 4 {
39461 return fmt.Errorf("proto: NinOptNativeUnion: wiretype end group for non-group")
39462 }
39463 if fieldNum <= 0 {
39464 return fmt.Errorf("proto: NinOptNativeUnion: illegal tag %d (wire type %d)", fieldNum, wire)
39465 }
39466 switch fieldNum {
39467 case 1:
39468 if wireType != 1 {
39469 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
39470 }
39471 var v uint64
39472 if (iNdEx + 8) > l {
39473 return io.ErrUnexpectedEOF
39474 }
39475 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
39476 iNdEx += 8
39477 v2 := float64(math.Float64frombits(v))
39478 m.Field1 = &v2
39479 case 2:
39480 if wireType != 5 {
39481 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
39482 }
39483 var v uint32
39484 if (iNdEx + 4) > l {
39485 return io.ErrUnexpectedEOF
39486 }
39487 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
39488 iNdEx += 4
39489 v2 := float32(math.Float32frombits(v))
39490 m.Field2 = &v2
39491 case 3:
39492 if wireType != 0 {
39493 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
39494 }
39495 var v int32
39496 for shift := uint(0); ; shift += 7 {
39497 if shift >= 64 {
39498 return ErrIntOverflowThetest
39499 }
39500 if iNdEx >= l {
39501 return io.ErrUnexpectedEOF
39502 }
39503 b := dAtA[iNdEx]
39504 iNdEx++
39505 v |= int32(b&0x7F) << shift
39506 if b < 0x80 {
39507 break
39508 }
39509 }
39510 m.Field3 = &v
39511 case 4:
39512 if wireType != 0 {
39513 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
39514 }
39515 var v int64
39516 for shift := uint(0); ; shift += 7 {
39517 if shift >= 64 {
39518 return ErrIntOverflowThetest
39519 }
39520 if iNdEx >= l {
39521 return io.ErrUnexpectedEOF
39522 }
39523 b := dAtA[iNdEx]
39524 iNdEx++
39525 v |= int64(b&0x7F) << shift
39526 if b < 0x80 {
39527 break
39528 }
39529 }
39530 m.Field4 = &v
39531 case 5:
39532 if wireType != 0 {
39533 return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
39534 }
39535 var v uint32
39536 for shift := uint(0); ; shift += 7 {
39537 if shift >= 64 {
39538 return ErrIntOverflowThetest
39539 }
39540 if iNdEx >= l {
39541 return io.ErrUnexpectedEOF
39542 }
39543 b := dAtA[iNdEx]
39544 iNdEx++
39545 v |= uint32(b&0x7F) << shift
39546 if b < 0x80 {
39547 break
39548 }
39549 }
39550 m.Field5 = &v
39551 case 6:
39552 if wireType != 0 {
39553 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
39554 }
39555 var v uint64
39556 for shift := uint(0); ; shift += 7 {
39557 if shift >= 64 {
39558 return ErrIntOverflowThetest
39559 }
39560 if iNdEx >= l {
39561 return io.ErrUnexpectedEOF
39562 }
39563 b := dAtA[iNdEx]
39564 iNdEx++
39565 v |= uint64(b&0x7F) << shift
39566 if b < 0x80 {
39567 break
39568 }
39569 }
39570 m.Field6 = &v
39571 case 13:
39572 if wireType != 0 {
39573 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
39574 }
39575 var v int
39576 for shift := uint(0); ; shift += 7 {
39577 if shift >= 64 {
39578 return ErrIntOverflowThetest
39579 }
39580 if iNdEx >= l {
39581 return io.ErrUnexpectedEOF
39582 }
39583 b := dAtA[iNdEx]
39584 iNdEx++
39585 v |= int(b&0x7F) << shift
39586 if b < 0x80 {
39587 break
39588 }
39589 }
39590 b := bool(v != 0)
39591 m.Field13 = &b
39592 case 14:
39593 if wireType != 2 {
39594 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
39595 }
39596 var stringLen uint64
39597 for shift := uint(0); ; shift += 7 {
39598 if shift >= 64 {
39599 return ErrIntOverflowThetest
39600 }
39601 if iNdEx >= l {
39602 return io.ErrUnexpectedEOF
39603 }
39604 b := dAtA[iNdEx]
39605 iNdEx++
39606 stringLen |= uint64(b&0x7F) << shift
39607 if b < 0x80 {
39608 break
39609 }
39610 }
39611 intStringLen := int(stringLen)
39612 if intStringLen < 0 {
39613 return ErrInvalidLengthThetest
39614 }
39615 postIndex := iNdEx + intStringLen
39616 if postIndex < 0 {
39617 return ErrInvalidLengthThetest
39618 }
39619 if postIndex > l {
39620 return io.ErrUnexpectedEOF
39621 }
39622 s := string(dAtA[iNdEx:postIndex])
39623 m.Field14 = &s
39624 iNdEx = postIndex
39625 case 15:
39626 if wireType != 2 {
39627 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
39628 }
39629 var byteLen int
39630 for shift := uint(0); ; shift += 7 {
39631 if shift >= 64 {
39632 return ErrIntOverflowThetest
39633 }
39634 if iNdEx >= l {
39635 return io.ErrUnexpectedEOF
39636 }
39637 b := dAtA[iNdEx]
39638 iNdEx++
39639 byteLen |= int(b&0x7F) << shift
39640 if b < 0x80 {
39641 break
39642 }
39643 }
39644 if byteLen < 0 {
39645 return ErrInvalidLengthThetest
39646 }
39647 postIndex := iNdEx + byteLen
39648 if postIndex < 0 {
39649 return ErrInvalidLengthThetest
39650 }
39651 if postIndex > l {
39652 return io.ErrUnexpectedEOF
39653 }
39654 m.Field15 = append(m.Field15[:0], dAtA[iNdEx:postIndex]...)
39655 if m.Field15 == nil {
39656 m.Field15 = []byte{}
39657 }
39658 iNdEx = postIndex
39659 default:
39660 iNdEx = preIndex
39661 skippy, err := skipThetest(dAtA[iNdEx:])
39662 if err != nil {
39663 return err
39664 }
39665 if (skippy < 0) || (iNdEx+skippy) < 0 {
39666 return ErrInvalidLengthThetest
39667 }
39668 if (iNdEx + skippy) > l {
39669 return io.ErrUnexpectedEOF
39670 }
39671 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
39672 iNdEx += skippy
39673 }
39674 }
39675
39676 if iNdEx > l {
39677 return io.ErrUnexpectedEOF
39678 }
39679 return nil
39680 }
39681 func (m *NinOptStructUnion) Unmarshal(dAtA []byte) error {
39682 l := len(dAtA)
39683 iNdEx := 0
39684 for iNdEx < l {
39685 preIndex := iNdEx
39686 var wire uint64
39687 for shift := uint(0); ; shift += 7 {
39688 if shift >= 64 {
39689 return ErrIntOverflowThetest
39690 }
39691 if iNdEx >= l {
39692 return io.ErrUnexpectedEOF
39693 }
39694 b := dAtA[iNdEx]
39695 iNdEx++
39696 wire |= uint64(b&0x7F) << shift
39697 if b < 0x80 {
39698 break
39699 }
39700 }
39701 fieldNum := int32(wire >> 3)
39702 wireType := int(wire & 0x7)
39703 if wireType == 4 {
39704 return fmt.Errorf("proto: NinOptStructUnion: wiretype end group for non-group")
39705 }
39706 if fieldNum <= 0 {
39707 return fmt.Errorf("proto: NinOptStructUnion: illegal tag %d (wire type %d)", fieldNum, wire)
39708 }
39709 switch fieldNum {
39710 case 1:
39711 if wireType != 1 {
39712 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
39713 }
39714 var v uint64
39715 if (iNdEx + 8) > l {
39716 return io.ErrUnexpectedEOF
39717 }
39718 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
39719 iNdEx += 8
39720 v2 := float64(math.Float64frombits(v))
39721 m.Field1 = &v2
39722 case 2:
39723 if wireType != 5 {
39724 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
39725 }
39726 var v uint32
39727 if (iNdEx + 4) > l {
39728 return io.ErrUnexpectedEOF
39729 }
39730 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
39731 iNdEx += 4
39732 v2 := float32(math.Float32frombits(v))
39733 m.Field2 = &v2
39734 case 3:
39735 if wireType != 2 {
39736 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
39737 }
39738 var msglen int
39739 for shift := uint(0); ; shift += 7 {
39740 if shift >= 64 {
39741 return ErrIntOverflowThetest
39742 }
39743 if iNdEx >= l {
39744 return io.ErrUnexpectedEOF
39745 }
39746 b := dAtA[iNdEx]
39747 iNdEx++
39748 msglen |= int(b&0x7F) << shift
39749 if b < 0x80 {
39750 break
39751 }
39752 }
39753 if msglen < 0 {
39754 return ErrInvalidLengthThetest
39755 }
39756 postIndex := iNdEx + msglen
39757 if postIndex < 0 {
39758 return ErrInvalidLengthThetest
39759 }
39760 if postIndex > l {
39761 return io.ErrUnexpectedEOF
39762 }
39763 if m.Field3 == nil {
39764 m.Field3 = &NidOptNative{}
39765 }
39766 if err := m.Field3.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
39767 return err
39768 }
39769 iNdEx = postIndex
39770 case 4:
39771 if wireType != 2 {
39772 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
39773 }
39774 var msglen int
39775 for shift := uint(0); ; shift += 7 {
39776 if shift >= 64 {
39777 return ErrIntOverflowThetest
39778 }
39779 if iNdEx >= l {
39780 return io.ErrUnexpectedEOF
39781 }
39782 b := dAtA[iNdEx]
39783 iNdEx++
39784 msglen |= int(b&0x7F) << shift
39785 if b < 0x80 {
39786 break
39787 }
39788 }
39789 if msglen < 0 {
39790 return ErrInvalidLengthThetest
39791 }
39792 postIndex := iNdEx + msglen
39793 if postIndex < 0 {
39794 return ErrInvalidLengthThetest
39795 }
39796 if postIndex > l {
39797 return io.ErrUnexpectedEOF
39798 }
39799 if m.Field4 == nil {
39800 m.Field4 = &NinOptNative{}
39801 }
39802 if err := m.Field4.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
39803 return err
39804 }
39805 iNdEx = postIndex
39806 case 6:
39807 if wireType != 0 {
39808 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
39809 }
39810 var v uint64
39811 for shift := uint(0); ; shift += 7 {
39812 if shift >= 64 {
39813 return ErrIntOverflowThetest
39814 }
39815 if iNdEx >= l {
39816 return io.ErrUnexpectedEOF
39817 }
39818 b := dAtA[iNdEx]
39819 iNdEx++
39820 v |= uint64(b&0x7F) << shift
39821 if b < 0x80 {
39822 break
39823 }
39824 }
39825 m.Field6 = &v
39826 case 7:
39827 if wireType != 0 {
39828 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
39829 }
39830 var v int32
39831 for shift := uint(0); ; shift += 7 {
39832 if shift >= 64 {
39833 return ErrIntOverflowThetest
39834 }
39835 if iNdEx >= l {
39836 return io.ErrUnexpectedEOF
39837 }
39838 b := dAtA[iNdEx]
39839 iNdEx++
39840 v |= int32(b&0x7F) << shift
39841 if b < 0x80 {
39842 break
39843 }
39844 }
39845 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
39846 m.Field7 = &v
39847 case 13:
39848 if wireType != 0 {
39849 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
39850 }
39851 var v int
39852 for shift := uint(0); ; shift += 7 {
39853 if shift >= 64 {
39854 return ErrIntOverflowThetest
39855 }
39856 if iNdEx >= l {
39857 return io.ErrUnexpectedEOF
39858 }
39859 b := dAtA[iNdEx]
39860 iNdEx++
39861 v |= int(b&0x7F) << shift
39862 if b < 0x80 {
39863 break
39864 }
39865 }
39866 b := bool(v != 0)
39867 m.Field13 = &b
39868 case 14:
39869 if wireType != 2 {
39870 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
39871 }
39872 var stringLen uint64
39873 for shift := uint(0); ; shift += 7 {
39874 if shift >= 64 {
39875 return ErrIntOverflowThetest
39876 }
39877 if iNdEx >= l {
39878 return io.ErrUnexpectedEOF
39879 }
39880 b := dAtA[iNdEx]
39881 iNdEx++
39882 stringLen |= uint64(b&0x7F) << shift
39883 if b < 0x80 {
39884 break
39885 }
39886 }
39887 intStringLen := int(stringLen)
39888 if intStringLen < 0 {
39889 return ErrInvalidLengthThetest
39890 }
39891 postIndex := iNdEx + intStringLen
39892 if postIndex < 0 {
39893 return ErrInvalidLengthThetest
39894 }
39895 if postIndex > l {
39896 return io.ErrUnexpectedEOF
39897 }
39898 s := string(dAtA[iNdEx:postIndex])
39899 m.Field14 = &s
39900 iNdEx = postIndex
39901 case 15:
39902 if wireType != 2 {
39903 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
39904 }
39905 var byteLen int
39906 for shift := uint(0); ; shift += 7 {
39907 if shift >= 64 {
39908 return ErrIntOverflowThetest
39909 }
39910 if iNdEx >= l {
39911 return io.ErrUnexpectedEOF
39912 }
39913 b := dAtA[iNdEx]
39914 iNdEx++
39915 byteLen |= int(b&0x7F) << shift
39916 if b < 0x80 {
39917 break
39918 }
39919 }
39920 if byteLen < 0 {
39921 return ErrInvalidLengthThetest
39922 }
39923 postIndex := iNdEx + byteLen
39924 if postIndex < 0 {
39925 return ErrInvalidLengthThetest
39926 }
39927 if postIndex > l {
39928 return io.ErrUnexpectedEOF
39929 }
39930 m.Field15 = append(m.Field15[:0], dAtA[iNdEx:postIndex]...)
39931 if m.Field15 == nil {
39932 m.Field15 = []byte{}
39933 }
39934 iNdEx = postIndex
39935 default:
39936 iNdEx = preIndex
39937 skippy, err := skipThetest(dAtA[iNdEx:])
39938 if err != nil {
39939 return err
39940 }
39941 if (skippy < 0) || (iNdEx+skippy) < 0 {
39942 return ErrInvalidLengthThetest
39943 }
39944 if (iNdEx + skippy) > l {
39945 return io.ErrUnexpectedEOF
39946 }
39947 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
39948 iNdEx += skippy
39949 }
39950 }
39951
39952 if iNdEx > l {
39953 return io.ErrUnexpectedEOF
39954 }
39955 return nil
39956 }
39957 func (m *NinEmbeddedStructUnion) Unmarshal(dAtA []byte) error {
39958 l := len(dAtA)
39959 iNdEx := 0
39960 for iNdEx < l {
39961 preIndex := iNdEx
39962 var wire uint64
39963 for shift := uint(0); ; shift += 7 {
39964 if shift >= 64 {
39965 return ErrIntOverflowThetest
39966 }
39967 if iNdEx >= l {
39968 return io.ErrUnexpectedEOF
39969 }
39970 b := dAtA[iNdEx]
39971 iNdEx++
39972 wire |= uint64(b&0x7F) << shift
39973 if b < 0x80 {
39974 break
39975 }
39976 }
39977 fieldNum := int32(wire >> 3)
39978 wireType := int(wire & 0x7)
39979 if wireType == 4 {
39980 return fmt.Errorf("proto: NinEmbeddedStructUnion: wiretype end group for non-group")
39981 }
39982 if fieldNum <= 0 {
39983 return fmt.Errorf("proto: NinEmbeddedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire)
39984 }
39985 switch fieldNum {
39986 case 1:
39987 if wireType != 2 {
39988 return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType)
39989 }
39990 var msglen int
39991 for shift := uint(0); ; shift += 7 {
39992 if shift >= 64 {
39993 return ErrIntOverflowThetest
39994 }
39995 if iNdEx >= l {
39996 return io.ErrUnexpectedEOF
39997 }
39998 b := dAtA[iNdEx]
39999 iNdEx++
40000 msglen |= int(b&0x7F) << shift
40001 if b < 0x80 {
40002 break
40003 }
40004 }
40005 if msglen < 0 {
40006 return ErrInvalidLengthThetest
40007 }
40008 postIndex := iNdEx + msglen
40009 if postIndex < 0 {
40010 return ErrInvalidLengthThetest
40011 }
40012 if postIndex > l {
40013 return io.ErrUnexpectedEOF
40014 }
40015 if m.NidOptNative == nil {
40016 m.NidOptNative = &NidOptNative{}
40017 }
40018 if err := m.NidOptNative.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40019 return err
40020 }
40021 iNdEx = postIndex
40022 case 200:
40023 if wireType != 2 {
40024 return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType)
40025 }
40026 var msglen int
40027 for shift := uint(0); ; shift += 7 {
40028 if shift >= 64 {
40029 return ErrIntOverflowThetest
40030 }
40031 if iNdEx >= l {
40032 return io.ErrUnexpectedEOF
40033 }
40034 b := dAtA[iNdEx]
40035 iNdEx++
40036 msglen |= int(b&0x7F) << shift
40037 if b < 0x80 {
40038 break
40039 }
40040 }
40041 if msglen < 0 {
40042 return ErrInvalidLengthThetest
40043 }
40044 postIndex := iNdEx + msglen
40045 if postIndex < 0 {
40046 return ErrInvalidLengthThetest
40047 }
40048 if postIndex > l {
40049 return io.ErrUnexpectedEOF
40050 }
40051 if m.Field200 == nil {
40052 m.Field200 = &NinOptNative{}
40053 }
40054 if err := m.Field200.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40055 return err
40056 }
40057 iNdEx = postIndex
40058 case 210:
40059 if wireType != 0 {
40060 return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType)
40061 }
40062 var v int
40063 for shift := uint(0); ; shift += 7 {
40064 if shift >= 64 {
40065 return ErrIntOverflowThetest
40066 }
40067 if iNdEx >= l {
40068 return io.ErrUnexpectedEOF
40069 }
40070 b := dAtA[iNdEx]
40071 iNdEx++
40072 v |= int(b&0x7F) << shift
40073 if b < 0x80 {
40074 break
40075 }
40076 }
40077 b := bool(v != 0)
40078 m.Field210 = &b
40079 default:
40080 iNdEx = preIndex
40081 skippy, err := skipThetest(dAtA[iNdEx:])
40082 if err != nil {
40083 return err
40084 }
40085 if (skippy < 0) || (iNdEx+skippy) < 0 {
40086 return ErrInvalidLengthThetest
40087 }
40088 if (iNdEx + skippy) > l {
40089 return io.ErrUnexpectedEOF
40090 }
40091 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
40092 iNdEx += skippy
40093 }
40094 }
40095
40096 if iNdEx > l {
40097 return io.ErrUnexpectedEOF
40098 }
40099 return nil
40100 }
40101 func (m *NinNestedStructUnion) Unmarshal(dAtA []byte) error {
40102 l := len(dAtA)
40103 iNdEx := 0
40104 for iNdEx < l {
40105 preIndex := iNdEx
40106 var wire uint64
40107 for shift := uint(0); ; shift += 7 {
40108 if shift >= 64 {
40109 return ErrIntOverflowThetest
40110 }
40111 if iNdEx >= l {
40112 return io.ErrUnexpectedEOF
40113 }
40114 b := dAtA[iNdEx]
40115 iNdEx++
40116 wire |= uint64(b&0x7F) << shift
40117 if b < 0x80 {
40118 break
40119 }
40120 }
40121 fieldNum := int32(wire >> 3)
40122 wireType := int(wire & 0x7)
40123 if wireType == 4 {
40124 return fmt.Errorf("proto: NinNestedStructUnion: wiretype end group for non-group")
40125 }
40126 if fieldNum <= 0 {
40127 return fmt.Errorf("proto: NinNestedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire)
40128 }
40129 switch fieldNum {
40130 case 1:
40131 if wireType != 2 {
40132 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
40133 }
40134 var msglen int
40135 for shift := uint(0); ; shift += 7 {
40136 if shift >= 64 {
40137 return ErrIntOverflowThetest
40138 }
40139 if iNdEx >= l {
40140 return io.ErrUnexpectedEOF
40141 }
40142 b := dAtA[iNdEx]
40143 iNdEx++
40144 msglen |= int(b&0x7F) << shift
40145 if b < 0x80 {
40146 break
40147 }
40148 }
40149 if msglen < 0 {
40150 return ErrInvalidLengthThetest
40151 }
40152 postIndex := iNdEx + msglen
40153 if postIndex < 0 {
40154 return ErrInvalidLengthThetest
40155 }
40156 if postIndex > l {
40157 return io.ErrUnexpectedEOF
40158 }
40159 if m.Field1 == nil {
40160 m.Field1 = &NinOptNativeUnion{}
40161 }
40162 if err := m.Field1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40163 return err
40164 }
40165 iNdEx = postIndex
40166 case 2:
40167 if wireType != 2 {
40168 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
40169 }
40170 var msglen int
40171 for shift := uint(0); ; shift += 7 {
40172 if shift >= 64 {
40173 return ErrIntOverflowThetest
40174 }
40175 if iNdEx >= l {
40176 return io.ErrUnexpectedEOF
40177 }
40178 b := dAtA[iNdEx]
40179 iNdEx++
40180 msglen |= int(b&0x7F) << shift
40181 if b < 0x80 {
40182 break
40183 }
40184 }
40185 if msglen < 0 {
40186 return ErrInvalidLengthThetest
40187 }
40188 postIndex := iNdEx + msglen
40189 if postIndex < 0 {
40190 return ErrInvalidLengthThetest
40191 }
40192 if postIndex > l {
40193 return io.ErrUnexpectedEOF
40194 }
40195 if m.Field2 == nil {
40196 m.Field2 = &NinOptStructUnion{}
40197 }
40198 if err := m.Field2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40199 return err
40200 }
40201 iNdEx = postIndex
40202 case 3:
40203 if wireType != 2 {
40204 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
40205 }
40206 var msglen int
40207 for shift := uint(0); ; shift += 7 {
40208 if shift >= 64 {
40209 return ErrIntOverflowThetest
40210 }
40211 if iNdEx >= l {
40212 return io.ErrUnexpectedEOF
40213 }
40214 b := dAtA[iNdEx]
40215 iNdEx++
40216 msglen |= int(b&0x7F) << shift
40217 if b < 0x80 {
40218 break
40219 }
40220 }
40221 if msglen < 0 {
40222 return ErrInvalidLengthThetest
40223 }
40224 postIndex := iNdEx + msglen
40225 if postIndex < 0 {
40226 return ErrInvalidLengthThetest
40227 }
40228 if postIndex > l {
40229 return io.ErrUnexpectedEOF
40230 }
40231 if m.Field3 == nil {
40232 m.Field3 = &NinEmbeddedStructUnion{}
40233 }
40234 if err := m.Field3.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40235 return err
40236 }
40237 iNdEx = postIndex
40238 default:
40239 iNdEx = preIndex
40240 skippy, err := skipThetest(dAtA[iNdEx:])
40241 if err != nil {
40242 return err
40243 }
40244 if (skippy < 0) || (iNdEx+skippy) < 0 {
40245 return ErrInvalidLengthThetest
40246 }
40247 if (iNdEx + skippy) > l {
40248 return io.ErrUnexpectedEOF
40249 }
40250 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
40251 iNdEx += skippy
40252 }
40253 }
40254
40255 if iNdEx > l {
40256 return io.ErrUnexpectedEOF
40257 }
40258 return nil
40259 }
40260 func (m *Tree) Unmarshal(dAtA []byte) error {
40261 l := len(dAtA)
40262 iNdEx := 0
40263 for iNdEx < l {
40264 preIndex := iNdEx
40265 var wire uint64
40266 for shift := uint(0); ; shift += 7 {
40267 if shift >= 64 {
40268 return ErrIntOverflowThetest
40269 }
40270 if iNdEx >= l {
40271 return io.ErrUnexpectedEOF
40272 }
40273 b := dAtA[iNdEx]
40274 iNdEx++
40275 wire |= uint64(b&0x7F) << shift
40276 if b < 0x80 {
40277 break
40278 }
40279 }
40280 fieldNum := int32(wire >> 3)
40281 wireType := int(wire & 0x7)
40282 if wireType == 4 {
40283 return fmt.Errorf("proto: Tree: wiretype end group for non-group")
40284 }
40285 if fieldNum <= 0 {
40286 return fmt.Errorf("proto: Tree: illegal tag %d (wire type %d)", fieldNum, wire)
40287 }
40288 switch fieldNum {
40289 case 1:
40290 if wireType != 2 {
40291 return fmt.Errorf("proto: wrong wireType = %d for field Or", wireType)
40292 }
40293 var msglen int
40294 for shift := uint(0); ; shift += 7 {
40295 if shift >= 64 {
40296 return ErrIntOverflowThetest
40297 }
40298 if iNdEx >= l {
40299 return io.ErrUnexpectedEOF
40300 }
40301 b := dAtA[iNdEx]
40302 iNdEx++
40303 msglen |= int(b&0x7F) << shift
40304 if b < 0x80 {
40305 break
40306 }
40307 }
40308 if msglen < 0 {
40309 return ErrInvalidLengthThetest
40310 }
40311 postIndex := iNdEx + msglen
40312 if postIndex < 0 {
40313 return ErrInvalidLengthThetest
40314 }
40315 if postIndex > l {
40316 return io.ErrUnexpectedEOF
40317 }
40318 if m.Or == nil {
40319 m.Or = &OrBranch{}
40320 }
40321 if err := m.Or.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40322 return err
40323 }
40324 iNdEx = postIndex
40325 case 2:
40326 if wireType != 2 {
40327 return fmt.Errorf("proto: wrong wireType = %d for field And", wireType)
40328 }
40329 var msglen int
40330 for shift := uint(0); ; shift += 7 {
40331 if shift >= 64 {
40332 return ErrIntOverflowThetest
40333 }
40334 if iNdEx >= l {
40335 return io.ErrUnexpectedEOF
40336 }
40337 b := dAtA[iNdEx]
40338 iNdEx++
40339 msglen |= int(b&0x7F) << shift
40340 if b < 0x80 {
40341 break
40342 }
40343 }
40344 if msglen < 0 {
40345 return ErrInvalidLengthThetest
40346 }
40347 postIndex := iNdEx + msglen
40348 if postIndex < 0 {
40349 return ErrInvalidLengthThetest
40350 }
40351 if postIndex > l {
40352 return io.ErrUnexpectedEOF
40353 }
40354 if m.And == nil {
40355 m.And = &AndBranch{}
40356 }
40357 if err := m.And.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40358 return err
40359 }
40360 iNdEx = postIndex
40361 case 3:
40362 if wireType != 2 {
40363 return fmt.Errorf("proto: wrong wireType = %d for field Leaf", wireType)
40364 }
40365 var msglen int
40366 for shift := uint(0); ; shift += 7 {
40367 if shift >= 64 {
40368 return ErrIntOverflowThetest
40369 }
40370 if iNdEx >= l {
40371 return io.ErrUnexpectedEOF
40372 }
40373 b := dAtA[iNdEx]
40374 iNdEx++
40375 msglen |= int(b&0x7F) << shift
40376 if b < 0x80 {
40377 break
40378 }
40379 }
40380 if msglen < 0 {
40381 return ErrInvalidLengthThetest
40382 }
40383 postIndex := iNdEx + msglen
40384 if postIndex < 0 {
40385 return ErrInvalidLengthThetest
40386 }
40387 if postIndex > l {
40388 return io.ErrUnexpectedEOF
40389 }
40390 if m.Leaf == nil {
40391 m.Leaf = &Leaf{}
40392 }
40393 if err := m.Leaf.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40394 return err
40395 }
40396 iNdEx = postIndex
40397 default:
40398 iNdEx = preIndex
40399 skippy, err := skipThetest(dAtA[iNdEx:])
40400 if err != nil {
40401 return err
40402 }
40403 if (skippy < 0) || (iNdEx+skippy) < 0 {
40404 return ErrInvalidLengthThetest
40405 }
40406 if (iNdEx + skippy) > l {
40407 return io.ErrUnexpectedEOF
40408 }
40409 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
40410 iNdEx += skippy
40411 }
40412 }
40413
40414 if iNdEx > l {
40415 return io.ErrUnexpectedEOF
40416 }
40417 return nil
40418 }
40419 func (m *OrBranch) Unmarshal(dAtA []byte) error {
40420 l := len(dAtA)
40421 iNdEx := 0
40422 for iNdEx < l {
40423 preIndex := iNdEx
40424 var wire uint64
40425 for shift := uint(0); ; shift += 7 {
40426 if shift >= 64 {
40427 return ErrIntOverflowThetest
40428 }
40429 if iNdEx >= l {
40430 return io.ErrUnexpectedEOF
40431 }
40432 b := dAtA[iNdEx]
40433 iNdEx++
40434 wire |= uint64(b&0x7F) << shift
40435 if b < 0x80 {
40436 break
40437 }
40438 }
40439 fieldNum := int32(wire >> 3)
40440 wireType := int(wire & 0x7)
40441 if wireType == 4 {
40442 return fmt.Errorf("proto: OrBranch: wiretype end group for non-group")
40443 }
40444 if fieldNum <= 0 {
40445 return fmt.Errorf("proto: OrBranch: illegal tag %d (wire type %d)", fieldNum, wire)
40446 }
40447 switch fieldNum {
40448 case 1:
40449 if wireType != 2 {
40450 return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
40451 }
40452 var msglen int
40453 for shift := uint(0); ; shift += 7 {
40454 if shift >= 64 {
40455 return ErrIntOverflowThetest
40456 }
40457 if iNdEx >= l {
40458 return io.ErrUnexpectedEOF
40459 }
40460 b := dAtA[iNdEx]
40461 iNdEx++
40462 msglen |= int(b&0x7F) << shift
40463 if b < 0x80 {
40464 break
40465 }
40466 }
40467 if msglen < 0 {
40468 return ErrInvalidLengthThetest
40469 }
40470 postIndex := iNdEx + msglen
40471 if postIndex < 0 {
40472 return ErrInvalidLengthThetest
40473 }
40474 if postIndex > l {
40475 return io.ErrUnexpectedEOF
40476 }
40477 if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40478 return err
40479 }
40480 iNdEx = postIndex
40481 case 2:
40482 if wireType != 2 {
40483 return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
40484 }
40485 var msglen int
40486 for shift := uint(0); ; shift += 7 {
40487 if shift >= 64 {
40488 return ErrIntOverflowThetest
40489 }
40490 if iNdEx >= l {
40491 return io.ErrUnexpectedEOF
40492 }
40493 b := dAtA[iNdEx]
40494 iNdEx++
40495 msglen |= int(b&0x7F) << shift
40496 if b < 0x80 {
40497 break
40498 }
40499 }
40500 if msglen < 0 {
40501 return ErrInvalidLengthThetest
40502 }
40503 postIndex := iNdEx + msglen
40504 if postIndex < 0 {
40505 return ErrInvalidLengthThetest
40506 }
40507 if postIndex > l {
40508 return io.ErrUnexpectedEOF
40509 }
40510 if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40511 return err
40512 }
40513 iNdEx = postIndex
40514 default:
40515 iNdEx = preIndex
40516 skippy, err := skipThetest(dAtA[iNdEx:])
40517 if err != nil {
40518 return err
40519 }
40520 if (skippy < 0) || (iNdEx+skippy) < 0 {
40521 return ErrInvalidLengthThetest
40522 }
40523 if (iNdEx + skippy) > l {
40524 return io.ErrUnexpectedEOF
40525 }
40526 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
40527 iNdEx += skippy
40528 }
40529 }
40530
40531 if iNdEx > l {
40532 return io.ErrUnexpectedEOF
40533 }
40534 return nil
40535 }
40536 func (m *AndBranch) Unmarshal(dAtA []byte) error {
40537 l := len(dAtA)
40538 iNdEx := 0
40539 for iNdEx < l {
40540 preIndex := iNdEx
40541 var wire uint64
40542 for shift := uint(0); ; shift += 7 {
40543 if shift >= 64 {
40544 return ErrIntOverflowThetest
40545 }
40546 if iNdEx >= l {
40547 return io.ErrUnexpectedEOF
40548 }
40549 b := dAtA[iNdEx]
40550 iNdEx++
40551 wire |= uint64(b&0x7F) << shift
40552 if b < 0x80 {
40553 break
40554 }
40555 }
40556 fieldNum := int32(wire >> 3)
40557 wireType := int(wire & 0x7)
40558 if wireType == 4 {
40559 return fmt.Errorf("proto: AndBranch: wiretype end group for non-group")
40560 }
40561 if fieldNum <= 0 {
40562 return fmt.Errorf("proto: AndBranch: illegal tag %d (wire type %d)", fieldNum, wire)
40563 }
40564 switch fieldNum {
40565 case 1:
40566 if wireType != 2 {
40567 return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
40568 }
40569 var msglen int
40570 for shift := uint(0); ; shift += 7 {
40571 if shift >= 64 {
40572 return ErrIntOverflowThetest
40573 }
40574 if iNdEx >= l {
40575 return io.ErrUnexpectedEOF
40576 }
40577 b := dAtA[iNdEx]
40578 iNdEx++
40579 msglen |= int(b&0x7F) << shift
40580 if b < 0x80 {
40581 break
40582 }
40583 }
40584 if msglen < 0 {
40585 return ErrInvalidLengthThetest
40586 }
40587 postIndex := iNdEx + msglen
40588 if postIndex < 0 {
40589 return ErrInvalidLengthThetest
40590 }
40591 if postIndex > l {
40592 return io.ErrUnexpectedEOF
40593 }
40594 if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40595 return err
40596 }
40597 iNdEx = postIndex
40598 case 2:
40599 if wireType != 2 {
40600 return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
40601 }
40602 var msglen int
40603 for shift := uint(0); ; shift += 7 {
40604 if shift >= 64 {
40605 return ErrIntOverflowThetest
40606 }
40607 if iNdEx >= l {
40608 return io.ErrUnexpectedEOF
40609 }
40610 b := dAtA[iNdEx]
40611 iNdEx++
40612 msglen |= int(b&0x7F) << shift
40613 if b < 0x80 {
40614 break
40615 }
40616 }
40617 if msglen < 0 {
40618 return ErrInvalidLengthThetest
40619 }
40620 postIndex := iNdEx + msglen
40621 if postIndex < 0 {
40622 return ErrInvalidLengthThetest
40623 }
40624 if postIndex > l {
40625 return io.ErrUnexpectedEOF
40626 }
40627 if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40628 return err
40629 }
40630 iNdEx = postIndex
40631 default:
40632 iNdEx = preIndex
40633 skippy, err := skipThetest(dAtA[iNdEx:])
40634 if err != nil {
40635 return err
40636 }
40637 if (skippy < 0) || (iNdEx+skippy) < 0 {
40638 return ErrInvalidLengthThetest
40639 }
40640 if (iNdEx + skippy) > l {
40641 return io.ErrUnexpectedEOF
40642 }
40643 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
40644 iNdEx += skippy
40645 }
40646 }
40647
40648 if iNdEx > l {
40649 return io.ErrUnexpectedEOF
40650 }
40651 return nil
40652 }
40653 func (m *Leaf) Unmarshal(dAtA []byte) error {
40654 l := len(dAtA)
40655 iNdEx := 0
40656 for iNdEx < l {
40657 preIndex := iNdEx
40658 var wire uint64
40659 for shift := uint(0); ; shift += 7 {
40660 if shift >= 64 {
40661 return ErrIntOverflowThetest
40662 }
40663 if iNdEx >= l {
40664 return io.ErrUnexpectedEOF
40665 }
40666 b := dAtA[iNdEx]
40667 iNdEx++
40668 wire |= uint64(b&0x7F) << shift
40669 if b < 0x80 {
40670 break
40671 }
40672 }
40673 fieldNum := int32(wire >> 3)
40674 wireType := int(wire & 0x7)
40675 if wireType == 4 {
40676 return fmt.Errorf("proto: Leaf: wiretype end group for non-group")
40677 }
40678 if fieldNum <= 0 {
40679 return fmt.Errorf("proto: Leaf: illegal tag %d (wire type %d)", fieldNum, wire)
40680 }
40681 switch fieldNum {
40682 case 1:
40683 if wireType != 0 {
40684 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
40685 }
40686 m.Value = 0
40687 for shift := uint(0); ; shift += 7 {
40688 if shift >= 64 {
40689 return ErrIntOverflowThetest
40690 }
40691 if iNdEx >= l {
40692 return io.ErrUnexpectedEOF
40693 }
40694 b := dAtA[iNdEx]
40695 iNdEx++
40696 m.Value |= int64(b&0x7F) << shift
40697 if b < 0x80 {
40698 break
40699 }
40700 }
40701 case 2:
40702 if wireType != 2 {
40703 return fmt.Errorf("proto: wrong wireType = %d for field StrValue", wireType)
40704 }
40705 var stringLen uint64
40706 for shift := uint(0); ; shift += 7 {
40707 if shift >= 64 {
40708 return ErrIntOverflowThetest
40709 }
40710 if iNdEx >= l {
40711 return io.ErrUnexpectedEOF
40712 }
40713 b := dAtA[iNdEx]
40714 iNdEx++
40715 stringLen |= uint64(b&0x7F) << shift
40716 if b < 0x80 {
40717 break
40718 }
40719 }
40720 intStringLen := int(stringLen)
40721 if intStringLen < 0 {
40722 return ErrInvalidLengthThetest
40723 }
40724 postIndex := iNdEx + intStringLen
40725 if postIndex < 0 {
40726 return ErrInvalidLengthThetest
40727 }
40728 if postIndex > l {
40729 return io.ErrUnexpectedEOF
40730 }
40731 m.StrValue = string(dAtA[iNdEx:postIndex])
40732 iNdEx = postIndex
40733 default:
40734 iNdEx = preIndex
40735 skippy, err := skipThetest(dAtA[iNdEx:])
40736 if err != nil {
40737 return err
40738 }
40739 if (skippy < 0) || (iNdEx+skippy) < 0 {
40740 return ErrInvalidLengthThetest
40741 }
40742 if (iNdEx + skippy) > l {
40743 return io.ErrUnexpectedEOF
40744 }
40745 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
40746 iNdEx += skippy
40747 }
40748 }
40749
40750 if iNdEx > l {
40751 return io.ErrUnexpectedEOF
40752 }
40753 return nil
40754 }
40755 func (m *DeepTree) Unmarshal(dAtA []byte) error {
40756 l := len(dAtA)
40757 iNdEx := 0
40758 for iNdEx < l {
40759 preIndex := iNdEx
40760 var wire uint64
40761 for shift := uint(0); ; shift += 7 {
40762 if shift >= 64 {
40763 return ErrIntOverflowThetest
40764 }
40765 if iNdEx >= l {
40766 return io.ErrUnexpectedEOF
40767 }
40768 b := dAtA[iNdEx]
40769 iNdEx++
40770 wire |= uint64(b&0x7F) << shift
40771 if b < 0x80 {
40772 break
40773 }
40774 }
40775 fieldNum := int32(wire >> 3)
40776 wireType := int(wire & 0x7)
40777 if wireType == 4 {
40778 return fmt.Errorf("proto: DeepTree: wiretype end group for non-group")
40779 }
40780 if fieldNum <= 0 {
40781 return fmt.Errorf("proto: DeepTree: illegal tag %d (wire type %d)", fieldNum, wire)
40782 }
40783 switch fieldNum {
40784 case 1:
40785 if wireType != 2 {
40786 return fmt.Errorf("proto: wrong wireType = %d for field Down", wireType)
40787 }
40788 var msglen int
40789 for shift := uint(0); ; shift += 7 {
40790 if shift >= 64 {
40791 return ErrIntOverflowThetest
40792 }
40793 if iNdEx >= l {
40794 return io.ErrUnexpectedEOF
40795 }
40796 b := dAtA[iNdEx]
40797 iNdEx++
40798 msglen |= int(b&0x7F) << shift
40799 if b < 0x80 {
40800 break
40801 }
40802 }
40803 if msglen < 0 {
40804 return ErrInvalidLengthThetest
40805 }
40806 postIndex := iNdEx + msglen
40807 if postIndex < 0 {
40808 return ErrInvalidLengthThetest
40809 }
40810 if postIndex > l {
40811 return io.ErrUnexpectedEOF
40812 }
40813 if m.Down == nil {
40814 m.Down = &ADeepBranch{}
40815 }
40816 if err := m.Down.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40817 return err
40818 }
40819 iNdEx = postIndex
40820 case 2:
40821 if wireType != 2 {
40822 return fmt.Errorf("proto: wrong wireType = %d for field And", wireType)
40823 }
40824 var msglen int
40825 for shift := uint(0); ; shift += 7 {
40826 if shift >= 64 {
40827 return ErrIntOverflowThetest
40828 }
40829 if iNdEx >= l {
40830 return io.ErrUnexpectedEOF
40831 }
40832 b := dAtA[iNdEx]
40833 iNdEx++
40834 msglen |= int(b&0x7F) << shift
40835 if b < 0x80 {
40836 break
40837 }
40838 }
40839 if msglen < 0 {
40840 return ErrInvalidLengthThetest
40841 }
40842 postIndex := iNdEx + msglen
40843 if postIndex < 0 {
40844 return ErrInvalidLengthThetest
40845 }
40846 if postIndex > l {
40847 return io.ErrUnexpectedEOF
40848 }
40849 if m.And == nil {
40850 m.And = &AndDeepBranch{}
40851 }
40852 if err := m.And.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40853 return err
40854 }
40855 iNdEx = postIndex
40856 case 3:
40857 if wireType != 2 {
40858 return fmt.Errorf("proto: wrong wireType = %d for field Leaf", wireType)
40859 }
40860 var msglen int
40861 for shift := uint(0); ; shift += 7 {
40862 if shift >= 64 {
40863 return ErrIntOverflowThetest
40864 }
40865 if iNdEx >= l {
40866 return io.ErrUnexpectedEOF
40867 }
40868 b := dAtA[iNdEx]
40869 iNdEx++
40870 msglen |= int(b&0x7F) << shift
40871 if b < 0x80 {
40872 break
40873 }
40874 }
40875 if msglen < 0 {
40876 return ErrInvalidLengthThetest
40877 }
40878 postIndex := iNdEx + msglen
40879 if postIndex < 0 {
40880 return ErrInvalidLengthThetest
40881 }
40882 if postIndex > l {
40883 return io.ErrUnexpectedEOF
40884 }
40885 if m.Leaf == nil {
40886 m.Leaf = &DeepLeaf{}
40887 }
40888 if err := m.Leaf.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40889 return err
40890 }
40891 iNdEx = postIndex
40892 default:
40893 iNdEx = preIndex
40894 skippy, err := skipThetest(dAtA[iNdEx:])
40895 if err != nil {
40896 return err
40897 }
40898 if (skippy < 0) || (iNdEx+skippy) < 0 {
40899 return ErrInvalidLengthThetest
40900 }
40901 if (iNdEx + skippy) > l {
40902 return io.ErrUnexpectedEOF
40903 }
40904 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
40905 iNdEx += skippy
40906 }
40907 }
40908
40909 if iNdEx > l {
40910 return io.ErrUnexpectedEOF
40911 }
40912 return nil
40913 }
40914 func (m *ADeepBranch) Unmarshal(dAtA []byte) error {
40915 l := len(dAtA)
40916 iNdEx := 0
40917 for iNdEx < l {
40918 preIndex := iNdEx
40919 var wire uint64
40920 for shift := uint(0); ; shift += 7 {
40921 if shift >= 64 {
40922 return ErrIntOverflowThetest
40923 }
40924 if iNdEx >= l {
40925 return io.ErrUnexpectedEOF
40926 }
40927 b := dAtA[iNdEx]
40928 iNdEx++
40929 wire |= uint64(b&0x7F) << shift
40930 if b < 0x80 {
40931 break
40932 }
40933 }
40934 fieldNum := int32(wire >> 3)
40935 wireType := int(wire & 0x7)
40936 if wireType == 4 {
40937 return fmt.Errorf("proto: ADeepBranch: wiretype end group for non-group")
40938 }
40939 if fieldNum <= 0 {
40940 return fmt.Errorf("proto: ADeepBranch: illegal tag %d (wire type %d)", fieldNum, wire)
40941 }
40942 switch fieldNum {
40943 case 2:
40944 if wireType != 2 {
40945 return fmt.Errorf("proto: wrong wireType = %d for field Down", wireType)
40946 }
40947 var msglen int
40948 for shift := uint(0); ; shift += 7 {
40949 if shift >= 64 {
40950 return ErrIntOverflowThetest
40951 }
40952 if iNdEx >= l {
40953 return io.ErrUnexpectedEOF
40954 }
40955 b := dAtA[iNdEx]
40956 iNdEx++
40957 msglen |= int(b&0x7F) << shift
40958 if b < 0x80 {
40959 break
40960 }
40961 }
40962 if msglen < 0 {
40963 return ErrInvalidLengthThetest
40964 }
40965 postIndex := iNdEx + msglen
40966 if postIndex < 0 {
40967 return ErrInvalidLengthThetest
40968 }
40969 if postIndex > l {
40970 return io.ErrUnexpectedEOF
40971 }
40972 if err := m.Down.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
40973 return err
40974 }
40975 iNdEx = postIndex
40976 default:
40977 iNdEx = preIndex
40978 skippy, err := skipThetest(dAtA[iNdEx:])
40979 if err != nil {
40980 return err
40981 }
40982 if (skippy < 0) || (iNdEx+skippy) < 0 {
40983 return ErrInvalidLengthThetest
40984 }
40985 if (iNdEx + skippy) > l {
40986 return io.ErrUnexpectedEOF
40987 }
40988 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
40989 iNdEx += skippy
40990 }
40991 }
40992
40993 if iNdEx > l {
40994 return io.ErrUnexpectedEOF
40995 }
40996 return nil
40997 }
40998 func (m *AndDeepBranch) Unmarshal(dAtA []byte) error {
40999 l := len(dAtA)
41000 iNdEx := 0
41001 for iNdEx < l {
41002 preIndex := iNdEx
41003 var wire uint64
41004 for shift := uint(0); ; shift += 7 {
41005 if shift >= 64 {
41006 return ErrIntOverflowThetest
41007 }
41008 if iNdEx >= l {
41009 return io.ErrUnexpectedEOF
41010 }
41011 b := dAtA[iNdEx]
41012 iNdEx++
41013 wire |= uint64(b&0x7F) << shift
41014 if b < 0x80 {
41015 break
41016 }
41017 }
41018 fieldNum := int32(wire >> 3)
41019 wireType := int(wire & 0x7)
41020 if wireType == 4 {
41021 return fmt.Errorf("proto: AndDeepBranch: wiretype end group for non-group")
41022 }
41023 if fieldNum <= 0 {
41024 return fmt.Errorf("proto: AndDeepBranch: illegal tag %d (wire type %d)", fieldNum, wire)
41025 }
41026 switch fieldNum {
41027 case 1:
41028 if wireType != 2 {
41029 return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
41030 }
41031 var msglen int
41032 for shift := uint(0); ; shift += 7 {
41033 if shift >= 64 {
41034 return ErrIntOverflowThetest
41035 }
41036 if iNdEx >= l {
41037 return io.ErrUnexpectedEOF
41038 }
41039 b := dAtA[iNdEx]
41040 iNdEx++
41041 msglen |= int(b&0x7F) << shift
41042 if b < 0x80 {
41043 break
41044 }
41045 }
41046 if msglen < 0 {
41047 return ErrInvalidLengthThetest
41048 }
41049 postIndex := iNdEx + msglen
41050 if postIndex < 0 {
41051 return ErrInvalidLengthThetest
41052 }
41053 if postIndex > l {
41054 return io.ErrUnexpectedEOF
41055 }
41056 if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
41057 return err
41058 }
41059 iNdEx = postIndex
41060 case 2:
41061 if wireType != 2 {
41062 return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
41063 }
41064 var msglen int
41065 for shift := uint(0); ; shift += 7 {
41066 if shift >= 64 {
41067 return ErrIntOverflowThetest
41068 }
41069 if iNdEx >= l {
41070 return io.ErrUnexpectedEOF
41071 }
41072 b := dAtA[iNdEx]
41073 iNdEx++
41074 msglen |= int(b&0x7F) << shift
41075 if b < 0x80 {
41076 break
41077 }
41078 }
41079 if msglen < 0 {
41080 return ErrInvalidLengthThetest
41081 }
41082 postIndex := iNdEx + msglen
41083 if postIndex < 0 {
41084 return ErrInvalidLengthThetest
41085 }
41086 if postIndex > l {
41087 return io.ErrUnexpectedEOF
41088 }
41089 if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
41090 return err
41091 }
41092 iNdEx = postIndex
41093 default:
41094 iNdEx = preIndex
41095 skippy, err := skipThetest(dAtA[iNdEx:])
41096 if err != nil {
41097 return err
41098 }
41099 if (skippy < 0) || (iNdEx+skippy) < 0 {
41100 return ErrInvalidLengthThetest
41101 }
41102 if (iNdEx + skippy) > l {
41103 return io.ErrUnexpectedEOF
41104 }
41105 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
41106 iNdEx += skippy
41107 }
41108 }
41109
41110 if iNdEx > l {
41111 return io.ErrUnexpectedEOF
41112 }
41113 return nil
41114 }
41115 func (m *DeepLeaf) Unmarshal(dAtA []byte) error {
41116 l := len(dAtA)
41117 iNdEx := 0
41118 for iNdEx < l {
41119 preIndex := iNdEx
41120 var wire uint64
41121 for shift := uint(0); ; shift += 7 {
41122 if shift >= 64 {
41123 return ErrIntOverflowThetest
41124 }
41125 if iNdEx >= l {
41126 return io.ErrUnexpectedEOF
41127 }
41128 b := dAtA[iNdEx]
41129 iNdEx++
41130 wire |= uint64(b&0x7F) << shift
41131 if b < 0x80 {
41132 break
41133 }
41134 }
41135 fieldNum := int32(wire >> 3)
41136 wireType := int(wire & 0x7)
41137 if wireType == 4 {
41138 return fmt.Errorf("proto: DeepLeaf: wiretype end group for non-group")
41139 }
41140 if fieldNum <= 0 {
41141 return fmt.Errorf("proto: DeepLeaf: illegal tag %d (wire type %d)", fieldNum, wire)
41142 }
41143 switch fieldNum {
41144 case 1:
41145 if wireType != 2 {
41146 return fmt.Errorf("proto: wrong wireType = %d for field Tree", wireType)
41147 }
41148 var msglen int
41149 for shift := uint(0); ; shift += 7 {
41150 if shift >= 64 {
41151 return ErrIntOverflowThetest
41152 }
41153 if iNdEx >= l {
41154 return io.ErrUnexpectedEOF
41155 }
41156 b := dAtA[iNdEx]
41157 iNdEx++
41158 msglen |= int(b&0x7F) << shift
41159 if b < 0x80 {
41160 break
41161 }
41162 }
41163 if msglen < 0 {
41164 return ErrInvalidLengthThetest
41165 }
41166 postIndex := iNdEx + msglen
41167 if postIndex < 0 {
41168 return ErrInvalidLengthThetest
41169 }
41170 if postIndex > l {
41171 return io.ErrUnexpectedEOF
41172 }
41173 if err := m.Tree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
41174 return err
41175 }
41176 iNdEx = postIndex
41177 default:
41178 iNdEx = preIndex
41179 skippy, err := skipThetest(dAtA[iNdEx:])
41180 if err != nil {
41181 return err
41182 }
41183 if (skippy < 0) || (iNdEx+skippy) < 0 {
41184 return ErrInvalidLengthThetest
41185 }
41186 if (iNdEx + skippy) > l {
41187 return io.ErrUnexpectedEOF
41188 }
41189 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
41190 iNdEx += skippy
41191 }
41192 }
41193
41194 if iNdEx > l {
41195 return io.ErrUnexpectedEOF
41196 }
41197 return nil
41198 }
41199 func (m *Nil) Unmarshal(dAtA []byte) error {
41200 l := len(dAtA)
41201 iNdEx := 0
41202 for iNdEx < l {
41203 preIndex := iNdEx
41204 var wire uint64
41205 for shift := uint(0); ; shift += 7 {
41206 if shift >= 64 {
41207 return ErrIntOverflowThetest
41208 }
41209 if iNdEx >= l {
41210 return io.ErrUnexpectedEOF
41211 }
41212 b := dAtA[iNdEx]
41213 iNdEx++
41214 wire |= uint64(b&0x7F) << shift
41215 if b < 0x80 {
41216 break
41217 }
41218 }
41219 fieldNum := int32(wire >> 3)
41220 wireType := int(wire & 0x7)
41221 if wireType == 4 {
41222 return fmt.Errorf("proto: Nil: wiretype end group for non-group")
41223 }
41224 if fieldNum <= 0 {
41225 return fmt.Errorf("proto: Nil: illegal tag %d (wire type %d)", fieldNum, wire)
41226 }
41227 switch fieldNum {
41228 default:
41229 iNdEx = preIndex
41230 skippy, err := skipThetest(dAtA[iNdEx:])
41231 if err != nil {
41232 return err
41233 }
41234 if (skippy < 0) || (iNdEx+skippy) < 0 {
41235 return ErrInvalidLengthThetest
41236 }
41237 if (iNdEx + skippy) > l {
41238 return io.ErrUnexpectedEOF
41239 }
41240 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
41241 iNdEx += skippy
41242 }
41243 }
41244
41245 if iNdEx > l {
41246 return io.ErrUnexpectedEOF
41247 }
41248 return nil
41249 }
41250 func (m *NidOptEnum) Unmarshal(dAtA []byte) error {
41251 l := len(dAtA)
41252 iNdEx := 0
41253 for iNdEx < l {
41254 preIndex := iNdEx
41255 var wire uint64
41256 for shift := uint(0); ; shift += 7 {
41257 if shift >= 64 {
41258 return ErrIntOverflowThetest
41259 }
41260 if iNdEx >= l {
41261 return io.ErrUnexpectedEOF
41262 }
41263 b := dAtA[iNdEx]
41264 iNdEx++
41265 wire |= uint64(b&0x7F) << shift
41266 if b < 0x80 {
41267 break
41268 }
41269 }
41270 fieldNum := int32(wire >> 3)
41271 wireType := int(wire & 0x7)
41272 if wireType == 4 {
41273 return fmt.Errorf("proto: NidOptEnum: wiretype end group for non-group")
41274 }
41275 if fieldNum <= 0 {
41276 return fmt.Errorf("proto: NidOptEnum: illegal tag %d (wire type %d)", fieldNum, wire)
41277 }
41278 switch fieldNum {
41279 case 1:
41280 if wireType != 0 {
41281 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
41282 }
41283 m.Field1 = 0
41284 for shift := uint(0); ; shift += 7 {
41285 if shift >= 64 {
41286 return ErrIntOverflowThetest
41287 }
41288 if iNdEx >= l {
41289 return io.ErrUnexpectedEOF
41290 }
41291 b := dAtA[iNdEx]
41292 iNdEx++
41293 m.Field1 |= TheTestEnum(b&0x7F) << shift
41294 if b < 0x80 {
41295 break
41296 }
41297 }
41298 default:
41299 iNdEx = preIndex
41300 skippy, err := skipThetest(dAtA[iNdEx:])
41301 if err != nil {
41302 return err
41303 }
41304 if (skippy < 0) || (iNdEx+skippy) < 0 {
41305 return ErrInvalidLengthThetest
41306 }
41307 if (iNdEx + skippy) > l {
41308 return io.ErrUnexpectedEOF
41309 }
41310 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
41311 iNdEx += skippy
41312 }
41313 }
41314
41315 if iNdEx > l {
41316 return io.ErrUnexpectedEOF
41317 }
41318 return nil
41319 }
41320 func (m *NinOptEnum) Unmarshal(dAtA []byte) error {
41321 l := len(dAtA)
41322 iNdEx := 0
41323 for iNdEx < l {
41324 preIndex := iNdEx
41325 var wire uint64
41326 for shift := uint(0); ; shift += 7 {
41327 if shift >= 64 {
41328 return ErrIntOverflowThetest
41329 }
41330 if iNdEx >= l {
41331 return io.ErrUnexpectedEOF
41332 }
41333 b := dAtA[iNdEx]
41334 iNdEx++
41335 wire |= uint64(b&0x7F) << shift
41336 if b < 0x80 {
41337 break
41338 }
41339 }
41340 fieldNum := int32(wire >> 3)
41341 wireType := int(wire & 0x7)
41342 if wireType == 4 {
41343 return fmt.Errorf("proto: NinOptEnum: wiretype end group for non-group")
41344 }
41345 if fieldNum <= 0 {
41346 return fmt.Errorf("proto: NinOptEnum: illegal tag %d (wire type %d)", fieldNum, wire)
41347 }
41348 switch fieldNum {
41349 case 1:
41350 if wireType != 0 {
41351 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
41352 }
41353 var v TheTestEnum
41354 for shift := uint(0); ; shift += 7 {
41355 if shift >= 64 {
41356 return ErrIntOverflowThetest
41357 }
41358 if iNdEx >= l {
41359 return io.ErrUnexpectedEOF
41360 }
41361 b := dAtA[iNdEx]
41362 iNdEx++
41363 v |= TheTestEnum(b&0x7F) << shift
41364 if b < 0x80 {
41365 break
41366 }
41367 }
41368 m.Field1 = &v
41369 case 2:
41370 if wireType != 0 {
41371 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
41372 }
41373 var v YetAnotherTestEnum
41374 for shift := uint(0); ; shift += 7 {
41375 if shift >= 64 {
41376 return ErrIntOverflowThetest
41377 }
41378 if iNdEx >= l {
41379 return io.ErrUnexpectedEOF
41380 }
41381 b := dAtA[iNdEx]
41382 iNdEx++
41383 v |= YetAnotherTestEnum(b&0x7F) << shift
41384 if b < 0x80 {
41385 break
41386 }
41387 }
41388 m.Field2 = &v
41389 case 3:
41390 if wireType != 0 {
41391 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
41392 }
41393 var v YetYetAnotherTestEnum
41394 for shift := uint(0); ; shift += 7 {
41395 if shift >= 64 {
41396 return ErrIntOverflowThetest
41397 }
41398 if iNdEx >= l {
41399 return io.ErrUnexpectedEOF
41400 }
41401 b := dAtA[iNdEx]
41402 iNdEx++
41403 v |= YetYetAnotherTestEnum(b&0x7F) << shift
41404 if b < 0x80 {
41405 break
41406 }
41407 }
41408 m.Field3 = &v
41409 default:
41410 iNdEx = preIndex
41411 skippy, err := skipThetest(dAtA[iNdEx:])
41412 if err != nil {
41413 return err
41414 }
41415 if (skippy < 0) || (iNdEx+skippy) < 0 {
41416 return ErrInvalidLengthThetest
41417 }
41418 if (iNdEx + skippy) > l {
41419 return io.ErrUnexpectedEOF
41420 }
41421 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
41422 iNdEx += skippy
41423 }
41424 }
41425
41426 if iNdEx > l {
41427 return io.ErrUnexpectedEOF
41428 }
41429 return nil
41430 }
41431 func (m *NidRepEnum) Unmarshal(dAtA []byte) error {
41432 l := len(dAtA)
41433 iNdEx := 0
41434 for iNdEx < l {
41435 preIndex := iNdEx
41436 var wire uint64
41437 for shift := uint(0); ; shift += 7 {
41438 if shift >= 64 {
41439 return ErrIntOverflowThetest
41440 }
41441 if iNdEx >= l {
41442 return io.ErrUnexpectedEOF
41443 }
41444 b := dAtA[iNdEx]
41445 iNdEx++
41446 wire |= uint64(b&0x7F) << shift
41447 if b < 0x80 {
41448 break
41449 }
41450 }
41451 fieldNum := int32(wire >> 3)
41452 wireType := int(wire & 0x7)
41453 if wireType == 4 {
41454 return fmt.Errorf("proto: NidRepEnum: wiretype end group for non-group")
41455 }
41456 if fieldNum <= 0 {
41457 return fmt.Errorf("proto: NidRepEnum: illegal tag %d (wire type %d)", fieldNum, wire)
41458 }
41459 switch fieldNum {
41460 case 1:
41461 if wireType == 0 {
41462 var v TheTestEnum
41463 for shift := uint(0); ; shift += 7 {
41464 if shift >= 64 {
41465 return ErrIntOverflowThetest
41466 }
41467 if iNdEx >= l {
41468 return io.ErrUnexpectedEOF
41469 }
41470 b := dAtA[iNdEx]
41471 iNdEx++
41472 v |= TheTestEnum(b&0x7F) << shift
41473 if b < 0x80 {
41474 break
41475 }
41476 }
41477 m.Field1 = append(m.Field1, v)
41478 } else if wireType == 2 {
41479 var packedLen int
41480 for shift := uint(0); ; shift += 7 {
41481 if shift >= 64 {
41482 return ErrIntOverflowThetest
41483 }
41484 if iNdEx >= l {
41485 return io.ErrUnexpectedEOF
41486 }
41487 b := dAtA[iNdEx]
41488 iNdEx++
41489 packedLen |= int(b&0x7F) << shift
41490 if b < 0x80 {
41491 break
41492 }
41493 }
41494 if packedLen < 0 {
41495 return ErrInvalidLengthThetest
41496 }
41497 postIndex := iNdEx + packedLen
41498 if postIndex < 0 {
41499 return ErrInvalidLengthThetest
41500 }
41501 if postIndex > l {
41502 return io.ErrUnexpectedEOF
41503 }
41504 var elementCount int
41505 if elementCount != 0 && len(m.Field1) == 0 {
41506 m.Field1 = make([]TheTestEnum, 0, elementCount)
41507 }
41508 for iNdEx < postIndex {
41509 var v TheTestEnum
41510 for shift := uint(0); ; shift += 7 {
41511 if shift >= 64 {
41512 return ErrIntOverflowThetest
41513 }
41514 if iNdEx >= l {
41515 return io.ErrUnexpectedEOF
41516 }
41517 b := dAtA[iNdEx]
41518 iNdEx++
41519 v |= TheTestEnum(b&0x7F) << shift
41520 if b < 0x80 {
41521 break
41522 }
41523 }
41524 m.Field1 = append(m.Field1, v)
41525 }
41526 } else {
41527 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
41528 }
41529 case 2:
41530 if wireType == 0 {
41531 var v YetAnotherTestEnum
41532 for shift := uint(0); ; shift += 7 {
41533 if shift >= 64 {
41534 return ErrIntOverflowThetest
41535 }
41536 if iNdEx >= l {
41537 return io.ErrUnexpectedEOF
41538 }
41539 b := dAtA[iNdEx]
41540 iNdEx++
41541 v |= YetAnotherTestEnum(b&0x7F) << shift
41542 if b < 0x80 {
41543 break
41544 }
41545 }
41546 m.Field2 = append(m.Field2, v)
41547 } else if wireType == 2 {
41548 var packedLen int
41549 for shift := uint(0); ; shift += 7 {
41550 if shift >= 64 {
41551 return ErrIntOverflowThetest
41552 }
41553 if iNdEx >= l {
41554 return io.ErrUnexpectedEOF
41555 }
41556 b := dAtA[iNdEx]
41557 iNdEx++
41558 packedLen |= int(b&0x7F) << shift
41559 if b < 0x80 {
41560 break
41561 }
41562 }
41563 if packedLen < 0 {
41564 return ErrInvalidLengthThetest
41565 }
41566 postIndex := iNdEx + packedLen
41567 if postIndex < 0 {
41568 return ErrInvalidLengthThetest
41569 }
41570 if postIndex > l {
41571 return io.ErrUnexpectedEOF
41572 }
41573 var elementCount int
41574 if elementCount != 0 && len(m.Field2) == 0 {
41575 m.Field2 = make([]YetAnotherTestEnum, 0, elementCount)
41576 }
41577 for iNdEx < postIndex {
41578 var v YetAnotherTestEnum
41579 for shift := uint(0); ; shift += 7 {
41580 if shift >= 64 {
41581 return ErrIntOverflowThetest
41582 }
41583 if iNdEx >= l {
41584 return io.ErrUnexpectedEOF
41585 }
41586 b := dAtA[iNdEx]
41587 iNdEx++
41588 v |= YetAnotherTestEnum(b&0x7F) << shift
41589 if b < 0x80 {
41590 break
41591 }
41592 }
41593 m.Field2 = append(m.Field2, v)
41594 }
41595 } else {
41596 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
41597 }
41598 case 3:
41599 if wireType == 0 {
41600 var v YetYetAnotherTestEnum
41601 for shift := uint(0); ; shift += 7 {
41602 if shift >= 64 {
41603 return ErrIntOverflowThetest
41604 }
41605 if iNdEx >= l {
41606 return io.ErrUnexpectedEOF
41607 }
41608 b := dAtA[iNdEx]
41609 iNdEx++
41610 v |= YetYetAnotherTestEnum(b&0x7F) << shift
41611 if b < 0x80 {
41612 break
41613 }
41614 }
41615 m.Field3 = append(m.Field3, v)
41616 } else if wireType == 2 {
41617 var packedLen int
41618 for shift := uint(0); ; shift += 7 {
41619 if shift >= 64 {
41620 return ErrIntOverflowThetest
41621 }
41622 if iNdEx >= l {
41623 return io.ErrUnexpectedEOF
41624 }
41625 b := dAtA[iNdEx]
41626 iNdEx++
41627 packedLen |= int(b&0x7F) << shift
41628 if b < 0x80 {
41629 break
41630 }
41631 }
41632 if packedLen < 0 {
41633 return ErrInvalidLengthThetest
41634 }
41635 postIndex := iNdEx + packedLen
41636 if postIndex < 0 {
41637 return ErrInvalidLengthThetest
41638 }
41639 if postIndex > l {
41640 return io.ErrUnexpectedEOF
41641 }
41642 var elementCount int
41643 if elementCount != 0 && len(m.Field3) == 0 {
41644 m.Field3 = make([]YetYetAnotherTestEnum, 0, elementCount)
41645 }
41646 for iNdEx < postIndex {
41647 var v YetYetAnotherTestEnum
41648 for shift := uint(0); ; shift += 7 {
41649 if shift >= 64 {
41650 return ErrIntOverflowThetest
41651 }
41652 if iNdEx >= l {
41653 return io.ErrUnexpectedEOF
41654 }
41655 b := dAtA[iNdEx]
41656 iNdEx++
41657 v |= YetYetAnotherTestEnum(b&0x7F) << shift
41658 if b < 0x80 {
41659 break
41660 }
41661 }
41662 m.Field3 = append(m.Field3, v)
41663 }
41664 } else {
41665 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
41666 }
41667 default:
41668 iNdEx = preIndex
41669 skippy, err := skipThetest(dAtA[iNdEx:])
41670 if err != nil {
41671 return err
41672 }
41673 if (skippy < 0) || (iNdEx+skippy) < 0 {
41674 return ErrInvalidLengthThetest
41675 }
41676 if (iNdEx + skippy) > l {
41677 return io.ErrUnexpectedEOF
41678 }
41679 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
41680 iNdEx += skippy
41681 }
41682 }
41683
41684 if iNdEx > l {
41685 return io.ErrUnexpectedEOF
41686 }
41687 return nil
41688 }
41689 func (m *NinRepEnum) Unmarshal(dAtA []byte) error {
41690 l := len(dAtA)
41691 iNdEx := 0
41692 for iNdEx < l {
41693 preIndex := iNdEx
41694 var wire uint64
41695 for shift := uint(0); ; shift += 7 {
41696 if shift >= 64 {
41697 return ErrIntOverflowThetest
41698 }
41699 if iNdEx >= l {
41700 return io.ErrUnexpectedEOF
41701 }
41702 b := dAtA[iNdEx]
41703 iNdEx++
41704 wire |= uint64(b&0x7F) << shift
41705 if b < 0x80 {
41706 break
41707 }
41708 }
41709 fieldNum := int32(wire >> 3)
41710 wireType := int(wire & 0x7)
41711 if wireType == 4 {
41712 return fmt.Errorf("proto: NinRepEnum: wiretype end group for non-group")
41713 }
41714 if fieldNum <= 0 {
41715 return fmt.Errorf("proto: NinRepEnum: illegal tag %d (wire type %d)", fieldNum, wire)
41716 }
41717 switch fieldNum {
41718 case 1:
41719 if wireType == 0 {
41720 var v TheTestEnum
41721 for shift := uint(0); ; shift += 7 {
41722 if shift >= 64 {
41723 return ErrIntOverflowThetest
41724 }
41725 if iNdEx >= l {
41726 return io.ErrUnexpectedEOF
41727 }
41728 b := dAtA[iNdEx]
41729 iNdEx++
41730 v |= TheTestEnum(b&0x7F) << shift
41731 if b < 0x80 {
41732 break
41733 }
41734 }
41735 m.Field1 = append(m.Field1, v)
41736 } else if wireType == 2 {
41737 var packedLen int
41738 for shift := uint(0); ; shift += 7 {
41739 if shift >= 64 {
41740 return ErrIntOverflowThetest
41741 }
41742 if iNdEx >= l {
41743 return io.ErrUnexpectedEOF
41744 }
41745 b := dAtA[iNdEx]
41746 iNdEx++
41747 packedLen |= int(b&0x7F) << shift
41748 if b < 0x80 {
41749 break
41750 }
41751 }
41752 if packedLen < 0 {
41753 return ErrInvalidLengthThetest
41754 }
41755 postIndex := iNdEx + packedLen
41756 if postIndex < 0 {
41757 return ErrInvalidLengthThetest
41758 }
41759 if postIndex > l {
41760 return io.ErrUnexpectedEOF
41761 }
41762 var elementCount int
41763 if elementCount != 0 && len(m.Field1) == 0 {
41764 m.Field1 = make([]TheTestEnum, 0, elementCount)
41765 }
41766 for iNdEx < postIndex {
41767 var v TheTestEnum
41768 for shift := uint(0); ; shift += 7 {
41769 if shift >= 64 {
41770 return ErrIntOverflowThetest
41771 }
41772 if iNdEx >= l {
41773 return io.ErrUnexpectedEOF
41774 }
41775 b := dAtA[iNdEx]
41776 iNdEx++
41777 v |= TheTestEnum(b&0x7F) << shift
41778 if b < 0x80 {
41779 break
41780 }
41781 }
41782 m.Field1 = append(m.Field1, v)
41783 }
41784 } else {
41785 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
41786 }
41787 case 2:
41788 if wireType == 0 {
41789 var v YetAnotherTestEnum
41790 for shift := uint(0); ; shift += 7 {
41791 if shift >= 64 {
41792 return ErrIntOverflowThetest
41793 }
41794 if iNdEx >= l {
41795 return io.ErrUnexpectedEOF
41796 }
41797 b := dAtA[iNdEx]
41798 iNdEx++
41799 v |= YetAnotherTestEnum(b&0x7F) << shift
41800 if b < 0x80 {
41801 break
41802 }
41803 }
41804 m.Field2 = append(m.Field2, v)
41805 } else if wireType == 2 {
41806 var packedLen int
41807 for shift := uint(0); ; shift += 7 {
41808 if shift >= 64 {
41809 return ErrIntOverflowThetest
41810 }
41811 if iNdEx >= l {
41812 return io.ErrUnexpectedEOF
41813 }
41814 b := dAtA[iNdEx]
41815 iNdEx++
41816 packedLen |= int(b&0x7F) << shift
41817 if b < 0x80 {
41818 break
41819 }
41820 }
41821 if packedLen < 0 {
41822 return ErrInvalidLengthThetest
41823 }
41824 postIndex := iNdEx + packedLen
41825 if postIndex < 0 {
41826 return ErrInvalidLengthThetest
41827 }
41828 if postIndex > l {
41829 return io.ErrUnexpectedEOF
41830 }
41831 var elementCount int
41832 if elementCount != 0 && len(m.Field2) == 0 {
41833 m.Field2 = make([]YetAnotherTestEnum, 0, elementCount)
41834 }
41835 for iNdEx < postIndex {
41836 var v YetAnotherTestEnum
41837 for shift := uint(0); ; shift += 7 {
41838 if shift >= 64 {
41839 return ErrIntOverflowThetest
41840 }
41841 if iNdEx >= l {
41842 return io.ErrUnexpectedEOF
41843 }
41844 b := dAtA[iNdEx]
41845 iNdEx++
41846 v |= YetAnotherTestEnum(b&0x7F) << shift
41847 if b < 0x80 {
41848 break
41849 }
41850 }
41851 m.Field2 = append(m.Field2, v)
41852 }
41853 } else {
41854 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
41855 }
41856 case 3:
41857 if wireType == 0 {
41858 var v YetYetAnotherTestEnum
41859 for shift := uint(0); ; shift += 7 {
41860 if shift >= 64 {
41861 return ErrIntOverflowThetest
41862 }
41863 if iNdEx >= l {
41864 return io.ErrUnexpectedEOF
41865 }
41866 b := dAtA[iNdEx]
41867 iNdEx++
41868 v |= YetYetAnotherTestEnum(b&0x7F) << shift
41869 if b < 0x80 {
41870 break
41871 }
41872 }
41873 m.Field3 = append(m.Field3, v)
41874 } else if wireType == 2 {
41875 var packedLen int
41876 for shift := uint(0); ; shift += 7 {
41877 if shift >= 64 {
41878 return ErrIntOverflowThetest
41879 }
41880 if iNdEx >= l {
41881 return io.ErrUnexpectedEOF
41882 }
41883 b := dAtA[iNdEx]
41884 iNdEx++
41885 packedLen |= int(b&0x7F) << shift
41886 if b < 0x80 {
41887 break
41888 }
41889 }
41890 if packedLen < 0 {
41891 return ErrInvalidLengthThetest
41892 }
41893 postIndex := iNdEx + packedLen
41894 if postIndex < 0 {
41895 return ErrInvalidLengthThetest
41896 }
41897 if postIndex > l {
41898 return io.ErrUnexpectedEOF
41899 }
41900 var elementCount int
41901 if elementCount != 0 && len(m.Field3) == 0 {
41902 m.Field3 = make([]YetYetAnotherTestEnum, 0, elementCount)
41903 }
41904 for iNdEx < postIndex {
41905 var v YetYetAnotherTestEnum
41906 for shift := uint(0); ; shift += 7 {
41907 if shift >= 64 {
41908 return ErrIntOverflowThetest
41909 }
41910 if iNdEx >= l {
41911 return io.ErrUnexpectedEOF
41912 }
41913 b := dAtA[iNdEx]
41914 iNdEx++
41915 v |= YetYetAnotherTestEnum(b&0x7F) << shift
41916 if b < 0x80 {
41917 break
41918 }
41919 }
41920 m.Field3 = append(m.Field3, v)
41921 }
41922 } else {
41923 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
41924 }
41925 default:
41926 iNdEx = preIndex
41927 skippy, err := skipThetest(dAtA[iNdEx:])
41928 if err != nil {
41929 return err
41930 }
41931 if (skippy < 0) || (iNdEx+skippy) < 0 {
41932 return ErrInvalidLengthThetest
41933 }
41934 if (iNdEx + skippy) > l {
41935 return io.ErrUnexpectedEOF
41936 }
41937 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
41938 iNdEx += skippy
41939 }
41940 }
41941
41942 if iNdEx > l {
41943 return io.ErrUnexpectedEOF
41944 }
41945 return nil
41946 }
41947 func (m *NinOptEnumDefault) Unmarshal(dAtA []byte) error {
41948 l := len(dAtA)
41949 iNdEx := 0
41950 for iNdEx < l {
41951 preIndex := iNdEx
41952 var wire uint64
41953 for shift := uint(0); ; shift += 7 {
41954 if shift >= 64 {
41955 return ErrIntOverflowThetest
41956 }
41957 if iNdEx >= l {
41958 return io.ErrUnexpectedEOF
41959 }
41960 b := dAtA[iNdEx]
41961 iNdEx++
41962 wire |= uint64(b&0x7F) << shift
41963 if b < 0x80 {
41964 break
41965 }
41966 }
41967 fieldNum := int32(wire >> 3)
41968 wireType := int(wire & 0x7)
41969 if wireType == 4 {
41970 return fmt.Errorf("proto: NinOptEnumDefault: wiretype end group for non-group")
41971 }
41972 if fieldNum <= 0 {
41973 return fmt.Errorf("proto: NinOptEnumDefault: illegal tag %d (wire type %d)", fieldNum, wire)
41974 }
41975 switch fieldNum {
41976 case 1:
41977 if wireType != 0 {
41978 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
41979 }
41980 var v TheTestEnum
41981 for shift := uint(0); ; shift += 7 {
41982 if shift >= 64 {
41983 return ErrIntOverflowThetest
41984 }
41985 if iNdEx >= l {
41986 return io.ErrUnexpectedEOF
41987 }
41988 b := dAtA[iNdEx]
41989 iNdEx++
41990 v |= TheTestEnum(b&0x7F) << shift
41991 if b < 0x80 {
41992 break
41993 }
41994 }
41995 m.Field1 = &v
41996 case 2:
41997 if wireType != 0 {
41998 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
41999 }
42000 var v YetAnotherTestEnum
42001 for shift := uint(0); ; shift += 7 {
42002 if shift >= 64 {
42003 return ErrIntOverflowThetest
42004 }
42005 if iNdEx >= l {
42006 return io.ErrUnexpectedEOF
42007 }
42008 b := dAtA[iNdEx]
42009 iNdEx++
42010 v |= YetAnotherTestEnum(b&0x7F) << shift
42011 if b < 0x80 {
42012 break
42013 }
42014 }
42015 m.Field2 = &v
42016 case 3:
42017 if wireType != 0 {
42018 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
42019 }
42020 var v YetYetAnotherTestEnum
42021 for shift := uint(0); ; shift += 7 {
42022 if shift >= 64 {
42023 return ErrIntOverflowThetest
42024 }
42025 if iNdEx >= l {
42026 return io.ErrUnexpectedEOF
42027 }
42028 b := dAtA[iNdEx]
42029 iNdEx++
42030 v |= YetYetAnotherTestEnum(b&0x7F) << shift
42031 if b < 0x80 {
42032 break
42033 }
42034 }
42035 m.Field3 = &v
42036 default:
42037 iNdEx = preIndex
42038 skippy, err := skipThetest(dAtA[iNdEx:])
42039 if err != nil {
42040 return err
42041 }
42042 if (skippy < 0) || (iNdEx+skippy) < 0 {
42043 return ErrInvalidLengthThetest
42044 }
42045 if (iNdEx + skippy) > l {
42046 return io.ErrUnexpectedEOF
42047 }
42048 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
42049 iNdEx += skippy
42050 }
42051 }
42052
42053 if iNdEx > l {
42054 return io.ErrUnexpectedEOF
42055 }
42056 return nil
42057 }
42058 func (m *AnotherNinOptEnum) Unmarshal(dAtA []byte) error {
42059 l := len(dAtA)
42060 iNdEx := 0
42061 for iNdEx < l {
42062 preIndex := iNdEx
42063 var wire uint64
42064 for shift := uint(0); ; shift += 7 {
42065 if shift >= 64 {
42066 return ErrIntOverflowThetest
42067 }
42068 if iNdEx >= l {
42069 return io.ErrUnexpectedEOF
42070 }
42071 b := dAtA[iNdEx]
42072 iNdEx++
42073 wire |= uint64(b&0x7F) << shift
42074 if b < 0x80 {
42075 break
42076 }
42077 }
42078 fieldNum := int32(wire >> 3)
42079 wireType := int(wire & 0x7)
42080 if wireType == 4 {
42081 return fmt.Errorf("proto: AnotherNinOptEnum: wiretype end group for non-group")
42082 }
42083 if fieldNum <= 0 {
42084 return fmt.Errorf("proto: AnotherNinOptEnum: illegal tag %d (wire type %d)", fieldNum, wire)
42085 }
42086 switch fieldNum {
42087 case 1:
42088 if wireType != 0 {
42089 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
42090 }
42091 var v AnotherTestEnum
42092 for shift := uint(0); ; shift += 7 {
42093 if shift >= 64 {
42094 return ErrIntOverflowThetest
42095 }
42096 if iNdEx >= l {
42097 return io.ErrUnexpectedEOF
42098 }
42099 b := dAtA[iNdEx]
42100 iNdEx++
42101 v |= AnotherTestEnum(b&0x7F) << shift
42102 if b < 0x80 {
42103 break
42104 }
42105 }
42106 m.Field1 = &v
42107 case 2:
42108 if wireType != 0 {
42109 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
42110 }
42111 var v YetAnotherTestEnum
42112 for shift := uint(0); ; shift += 7 {
42113 if shift >= 64 {
42114 return ErrIntOverflowThetest
42115 }
42116 if iNdEx >= l {
42117 return io.ErrUnexpectedEOF
42118 }
42119 b := dAtA[iNdEx]
42120 iNdEx++
42121 v |= YetAnotherTestEnum(b&0x7F) << shift
42122 if b < 0x80 {
42123 break
42124 }
42125 }
42126 m.Field2 = &v
42127 case 3:
42128 if wireType != 0 {
42129 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
42130 }
42131 var v YetYetAnotherTestEnum
42132 for shift := uint(0); ; shift += 7 {
42133 if shift >= 64 {
42134 return ErrIntOverflowThetest
42135 }
42136 if iNdEx >= l {
42137 return io.ErrUnexpectedEOF
42138 }
42139 b := dAtA[iNdEx]
42140 iNdEx++
42141 v |= YetYetAnotherTestEnum(b&0x7F) << shift
42142 if b < 0x80 {
42143 break
42144 }
42145 }
42146 m.Field3 = &v
42147 default:
42148 iNdEx = preIndex
42149 skippy, err := skipThetest(dAtA[iNdEx:])
42150 if err != nil {
42151 return err
42152 }
42153 if (skippy < 0) || (iNdEx+skippy) < 0 {
42154 return ErrInvalidLengthThetest
42155 }
42156 if (iNdEx + skippy) > l {
42157 return io.ErrUnexpectedEOF
42158 }
42159 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
42160 iNdEx += skippy
42161 }
42162 }
42163
42164 if iNdEx > l {
42165 return io.ErrUnexpectedEOF
42166 }
42167 return nil
42168 }
42169 func (m *AnotherNinOptEnumDefault) Unmarshal(dAtA []byte) error {
42170 l := len(dAtA)
42171 iNdEx := 0
42172 for iNdEx < l {
42173 preIndex := iNdEx
42174 var wire uint64
42175 for shift := uint(0); ; shift += 7 {
42176 if shift >= 64 {
42177 return ErrIntOverflowThetest
42178 }
42179 if iNdEx >= l {
42180 return io.ErrUnexpectedEOF
42181 }
42182 b := dAtA[iNdEx]
42183 iNdEx++
42184 wire |= uint64(b&0x7F) << shift
42185 if b < 0x80 {
42186 break
42187 }
42188 }
42189 fieldNum := int32(wire >> 3)
42190 wireType := int(wire & 0x7)
42191 if wireType == 4 {
42192 return fmt.Errorf("proto: AnotherNinOptEnumDefault: wiretype end group for non-group")
42193 }
42194 if fieldNum <= 0 {
42195 return fmt.Errorf("proto: AnotherNinOptEnumDefault: illegal tag %d (wire type %d)", fieldNum, wire)
42196 }
42197 switch fieldNum {
42198 case 1:
42199 if wireType != 0 {
42200 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
42201 }
42202 var v AnotherTestEnum
42203 for shift := uint(0); ; shift += 7 {
42204 if shift >= 64 {
42205 return ErrIntOverflowThetest
42206 }
42207 if iNdEx >= l {
42208 return io.ErrUnexpectedEOF
42209 }
42210 b := dAtA[iNdEx]
42211 iNdEx++
42212 v |= AnotherTestEnum(b&0x7F) << shift
42213 if b < 0x80 {
42214 break
42215 }
42216 }
42217 m.Field1 = &v
42218 case 2:
42219 if wireType != 0 {
42220 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
42221 }
42222 var v YetAnotherTestEnum
42223 for shift := uint(0); ; shift += 7 {
42224 if shift >= 64 {
42225 return ErrIntOverflowThetest
42226 }
42227 if iNdEx >= l {
42228 return io.ErrUnexpectedEOF
42229 }
42230 b := dAtA[iNdEx]
42231 iNdEx++
42232 v |= YetAnotherTestEnum(b&0x7F) << shift
42233 if b < 0x80 {
42234 break
42235 }
42236 }
42237 m.Field2 = &v
42238 case 3:
42239 if wireType != 0 {
42240 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
42241 }
42242 var v YetYetAnotherTestEnum
42243 for shift := uint(0); ; shift += 7 {
42244 if shift >= 64 {
42245 return ErrIntOverflowThetest
42246 }
42247 if iNdEx >= l {
42248 return io.ErrUnexpectedEOF
42249 }
42250 b := dAtA[iNdEx]
42251 iNdEx++
42252 v |= YetYetAnotherTestEnum(b&0x7F) << shift
42253 if b < 0x80 {
42254 break
42255 }
42256 }
42257 m.Field3 = &v
42258 default:
42259 iNdEx = preIndex
42260 skippy, err := skipThetest(dAtA[iNdEx:])
42261 if err != nil {
42262 return err
42263 }
42264 if (skippy < 0) || (iNdEx+skippy) < 0 {
42265 return ErrInvalidLengthThetest
42266 }
42267 if (iNdEx + skippy) > l {
42268 return io.ErrUnexpectedEOF
42269 }
42270 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
42271 iNdEx += skippy
42272 }
42273 }
42274
42275 if iNdEx > l {
42276 return io.ErrUnexpectedEOF
42277 }
42278 return nil
42279 }
42280 func (m *Timer) Unmarshal(dAtA []byte) error {
42281 l := len(dAtA)
42282 iNdEx := 0
42283 for iNdEx < l {
42284 preIndex := iNdEx
42285 var wire uint64
42286 for shift := uint(0); ; shift += 7 {
42287 if shift >= 64 {
42288 return ErrIntOverflowThetest
42289 }
42290 if iNdEx >= l {
42291 return io.ErrUnexpectedEOF
42292 }
42293 b := dAtA[iNdEx]
42294 iNdEx++
42295 wire |= uint64(b&0x7F) << shift
42296 if b < 0x80 {
42297 break
42298 }
42299 }
42300 fieldNum := int32(wire >> 3)
42301 wireType := int(wire & 0x7)
42302 if wireType == 4 {
42303 return fmt.Errorf("proto: Timer: wiretype end group for non-group")
42304 }
42305 if fieldNum <= 0 {
42306 return fmt.Errorf("proto: Timer: illegal tag %d (wire type %d)", fieldNum, wire)
42307 }
42308 switch fieldNum {
42309 case 1:
42310 if wireType != 1 {
42311 return fmt.Errorf("proto: wrong wireType = %d for field Time1", wireType)
42312 }
42313 m.Time1 = 0
42314 if (iNdEx + 8) > l {
42315 return io.ErrUnexpectedEOF
42316 }
42317 m.Time1 = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
42318 iNdEx += 8
42319 case 2:
42320 if wireType != 1 {
42321 return fmt.Errorf("proto: wrong wireType = %d for field Time2", wireType)
42322 }
42323 m.Time2 = 0
42324 if (iNdEx + 8) > l {
42325 return io.ErrUnexpectedEOF
42326 }
42327 m.Time2 = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
42328 iNdEx += 8
42329 case 3:
42330 if wireType != 2 {
42331 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
42332 }
42333 var byteLen int
42334 for shift := uint(0); ; shift += 7 {
42335 if shift >= 64 {
42336 return ErrIntOverflowThetest
42337 }
42338 if iNdEx >= l {
42339 return io.ErrUnexpectedEOF
42340 }
42341 b := dAtA[iNdEx]
42342 iNdEx++
42343 byteLen |= int(b&0x7F) << shift
42344 if b < 0x80 {
42345 break
42346 }
42347 }
42348 if byteLen < 0 {
42349 return ErrInvalidLengthThetest
42350 }
42351 postIndex := iNdEx + byteLen
42352 if postIndex < 0 {
42353 return ErrInvalidLengthThetest
42354 }
42355 if postIndex > l {
42356 return io.ErrUnexpectedEOF
42357 }
42358 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
42359 if m.Data == nil {
42360 m.Data = []byte{}
42361 }
42362 iNdEx = postIndex
42363 default:
42364 iNdEx = preIndex
42365 skippy, err := skipThetest(dAtA[iNdEx:])
42366 if err != nil {
42367 return err
42368 }
42369 if (skippy < 0) || (iNdEx+skippy) < 0 {
42370 return ErrInvalidLengthThetest
42371 }
42372 if (iNdEx + skippy) > l {
42373 return io.ErrUnexpectedEOF
42374 }
42375 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
42376 iNdEx += skippy
42377 }
42378 }
42379
42380 if iNdEx > l {
42381 return io.ErrUnexpectedEOF
42382 }
42383 return nil
42384 }
42385 func (m *MyExtendable) Unmarshal(dAtA []byte) error {
42386 l := len(dAtA)
42387 iNdEx := 0
42388 for iNdEx < l {
42389 preIndex := iNdEx
42390 var wire uint64
42391 for shift := uint(0); ; shift += 7 {
42392 if shift >= 64 {
42393 return ErrIntOverflowThetest
42394 }
42395 if iNdEx >= l {
42396 return io.ErrUnexpectedEOF
42397 }
42398 b := dAtA[iNdEx]
42399 iNdEx++
42400 wire |= uint64(b&0x7F) << shift
42401 if b < 0x80 {
42402 break
42403 }
42404 }
42405 fieldNum := int32(wire >> 3)
42406 wireType := int(wire & 0x7)
42407 if wireType == 4 {
42408 return fmt.Errorf("proto: MyExtendable: wiretype end group for non-group")
42409 }
42410 if fieldNum <= 0 {
42411 return fmt.Errorf("proto: MyExtendable: illegal tag %d (wire type %d)", fieldNum, wire)
42412 }
42413 switch fieldNum {
42414 case 1:
42415 if wireType != 0 {
42416 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
42417 }
42418 var v int64
42419 for shift := uint(0); ; shift += 7 {
42420 if shift >= 64 {
42421 return ErrIntOverflowThetest
42422 }
42423 if iNdEx >= l {
42424 return io.ErrUnexpectedEOF
42425 }
42426 b := dAtA[iNdEx]
42427 iNdEx++
42428 v |= int64(b&0x7F) << shift
42429 if b < 0x80 {
42430 break
42431 }
42432 }
42433 m.Field1 = &v
42434 default:
42435 if (fieldNum >= 100) && (fieldNum < 200) {
42436 var sizeOfWire int
42437 for {
42438 sizeOfWire++
42439 wire >>= 7
42440 if wire == 0 {
42441 break
42442 }
42443 }
42444 iNdEx -= sizeOfWire
42445 skippy, err := skipThetest(dAtA[iNdEx:])
42446 if err != nil {
42447 return err
42448 }
42449 if (skippy < 0) || (iNdEx+skippy) < 0 {
42450 return ErrInvalidLengthThetest
42451 }
42452 if (iNdEx + skippy) > l {
42453 return io.ErrUnexpectedEOF
42454 }
42455 github_com_gogo_protobuf_proto.AppendExtension(m, int32(fieldNum), dAtA[iNdEx:iNdEx+skippy])
42456 iNdEx += skippy
42457 } else {
42458 iNdEx = preIndex
42459 skippy, err := skipThetest(dAtA[iNdEx:])
42460 if err != nil {
42461 return err
42462 }
42463 if (skippy < 0) || (iNdEx+skippy) < 0 {
42464 return ErrInvalidLengthThetest
42465 }
42466 if (iNdEx + skippy) > l {
42467 return io.ErrUnexpectedEOF
42468 }
42469 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
42470 iNdEx += skippy
42471 }
42472 }
42473 }
42474
42475 if iNdEx > l {
42476 return io.ErrUnexpectedEOF
42477 }
42478 return nil
42479 }
42480 func (m *OtherExtenable) Unmarshal(dAtA []byte) error {
42481 l := len(dAtA)
42482 iNdEx := 0
42483 for iNdEx < l {
42484 preIndex := iNdEx
42485 var wire uint64
42486 for shift := uint(0); ; shift += 7 {
42487 if shift >= 64 {
42488 return ErrIntOverflowThetest
42489 }
42490 if iNdEx >= l {
42491 return io.ErrUnexpectedEOF
42492 }
42493 b := dAtA[iNdEx]
42494 iNdEx++
42495 wire |= uint64(b&0x7F) << shift
42496 if b < 0x80 {
42497 break
42498 }
42499 }
42500 fieldNum := int32(wire >> 3)
42501 wireType := int(wire & 0x7)
42502 if wireType == 4 {
42503 return fmt.Errorf("proto: OtherExtenable: wiretype end group for non-group")
42504 }
42505 if fieldNum <= 0 {
42506 return fmt.Errorf("proto: OtherExtenable: illegal tag %d (wire type %d)", fieldNum, wire)
42507 }
42508 switch fieldNum {
42509 case 1:
42510 if wireType != 2 {
42511 return fmt.Errorf("proto: wrong wireType = %d for field M", wireType)
42512 }
42513 var msglen int
42514 for shift := uint(0); ; shift += 7 {
42515 if shift >= 64 {
42516 return ErrIntOverflowThetest
42517 }
42518 if iNdEx >= l {
42519 return io.ErrUnexpectedEOF
42520 }
42521 b := dAtA[iNdEx]
42522 iNdEx++
42523 msglen |= int(b&0x7F) << shift
42524 if b < 0x80 {
42525 break
42526 }
42527 }
42528 if msglen < 0 {
42529 return ErrInvalidLengthThetest
42530 }
42531 postIndex := iNdEx + msglen
42532 if postIndex < 0 {
42533 return ErrInvalidLengthThetest
42534 }
42535 if postIndex > l {
42536 return io.ErrUnexpectedEOF
42537 }
42538 if m.M == nil {
42539 m.M = &MyExtendable{}
42540 }
42541 if err := m.M.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
42542 return err
42543 }
42544 iNdEx = postIndex
42545 case 2:
42546 if wireType != 0 {
42547 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
42548 }
42549 var v int64
42550 for shift := uint(0); ; shift += 7 {
42551 if shift >= 64 {
42552 return ErrIntOverflowThetest
42553 }
42554 if iNdEx >= l {
42555 return io.ErrUnexpectedEOF
42556 }
42557 b := dAtA[iNdEx]
42558 iNdEx++
42559 v |= int64(b&0x7F) << shift
42560 if b < 0x80 {
42561 break
42562 }
42563 }
42564 m.Field2 = &v
42565 case 13:
42566 if wireType != 0 {
42567 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
42568 }
42569 var v int64
42570 for shift := uint(0); ; shift += 7 {
42571 if shift >= 64 {
42572 return ErrIntOverflowThetest
42573 }
42574 if iNdEx >= l {
42575 return io.ErrUnexpectedEOF
42576 }
42577 b := dAtA[iNdEx]
42578 iNdEx++
42579 v |= int64(b&0x7F) << shift
42580 if b < 0x80 {
42581 break
42582 }
42583 }
42584 m.Field13 = &v
42585 default:
42586 if ((fieldNum >= 14) && (fieldNum < 17)) || ((fieldNum >= 10) && (fieldNum < 13)) {
42587 var sizeOfWire int
42588 for {
42589 sizeOfWire++
42590 wire >>= 7
42591 if wire == 0 {
42592 break
42593 }
42594 }
42595 iNdEx -= sizeOfWire
42596 skippy, err := skipThetest(dAtA[iNdEx:])
42597 if err != nil {
42598 return err
42599 }
42600 if (skippy < 0) || (iNdEx+skippy) < 0 {
42601 return ErrInvalidLengthThetest
42602 }
42603 if (iNdEx + skippy) > l {
42604 return io.ErrUnexpectedEOF
42605 }
42606 github_com_gogo_protobuf_proto.AppendExtension(m, int32(fieldNum), dAtA[iNdEx:iNdEx+skippy])
42607 iNdEx += skippy
42608 } else {
42609 iNdEx = preIndex
42610 skippy, err := skipThetest(dAtA[iNdEx:])
42611 if err != nil {
42612 return err
42613 }
42614 if (skippy < 0) || (iNdEx+skippy) < 0 {
42615 return ErrInvalidLengthThetest
42616 }
42617 if (iNdEx + skippy) > l {
42618 return io.ErrUnexpectedEOF
42619 }
42620 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
42621 iNdEx += skippy
42622 }
42623 }
42624 }
42625
42626 if iNdEx > l {
42627 return io.ErrUnexpectedEOF
42628 }
42629 return nil
42630 }
42631 func (m *NestedDefinition) Unmarshal(dAtA []byte) error {
42632 l := len(dAtA)
42633 iNdEx := 0
42634 for iNdEx < l {
42635 preIndex := iNdEx
42636 var wire uint64
42637 for shift := uint(0); ; shift += 7 {
42638 if shift >= 64 {
42639 return ErrIntOverflowThetest
42640 }
42641 if iNdEx >= l {
42642 return io.ErrUnexpectedEOF
42643 }
42644 b := dAtA[iNdEx]
42645 iNdEx++
42646 wire |= uint64(b&0x7F) << shift
42647 if b < 0x80 {
42648 break
42649 }
42650 }
42651 fieldNum := int32(wire >> 3)
42652 wireType := int(wire & 0x7)
42653 if wireType == 4 {
42654 return fmt.Errorf("proto: NestedDefinition: wiretype end group for non-group")
42655 }
42656 if fieldNum <= 0 {
42657 return fmt.Errorf("proto: NestedDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
42658 }
42659 switch fieldNum {
42660 case 1:
42661 if wireType != 0 {
42662 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
42663 }
42664 var v int64
42665 for shift := uint(0); ; shift += 7 {
42666 if shift >= 64 {
42667 return ErrIntOverflowThetest
42668 }
42669 if iNdEx >= l {
42670 return io.ErrUnexpectedEOF
42671 }
42672 b := dAtA[iNdEx]
42673 iNdEx++
42674 v |= int64(b&0x7F) << shift
42675 if b < 0x80 {
42676 break
42677 }
42678 }
42679 m.Field1 = &v
42680 case 2:
42681 if wireType != 0 {
42682 return fmt.Errorf("proto: wrong wireType = %d for field EnumField", wireType)
42683 }
42684 var v NestedDefinition_NestedEnum
42685 for shift := uint(0); ; shift += 7 {
42686 if shift >= 64 {
42687 return ErrIntOverflowThetest
42688 }
42689 if iNdEx >= l {
42690 return io.ErrUnexpectedEOF
42691 }
42692 b := dAtA[iNdEx]
42693 iNdEx++
42694 v |= NestedDefinition_NestedEnum(b&0x7F) << shift
42695 if b < 0x80 {
42696 break
42697 }
42698 }
42699 m.EnumField = &v
42700 case 3:
42701 if wireType != 2 {
42702 return fmt.Errorf("proto: wrong wireType = %d for field NNM", wireType)
42703 }
42704 var msglen int
42705 for shift := uint(0); ; shift += 7 {
42706 if shift >= 64 {
42707 return ErrIntOverflowThetest
42708 }
42709 if iNdEx >= l {
42710 return io.ErrUnexpectedEOF
42711 }
42712 b := dAtA[iNdEx]
42713 iNdEx++
42714 msglen |= int(b&0x7F) << shift
42715 if b < 0x80 {
42716 break
42717 }
42718 }
42719 if msglen < 0 {
42720 return ErrInvalidLengthThetest
42721 }
42722 postIndex := iNdEx + msglen
42723 if postIndex < 0 {
42724 return ErrInvalidLengthThetest
42725 }
42726 if postIndex > l {
42727 return io.ErrUnexpectedEOF
42728 }
42729 if m.NNM == nil {
42730 m.NNM = &NestedDefinition_NestedMessage_NestedNestedMsg{}
42731 }
42732 if err := m.NNM.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
42733 return err
42734 }
42735 iNdEx = postIndex
42736 case 4:
42737 if wireType != 2 {
42738 return fmt.Errorf("proto: wrong wireType = %d for field NM", wireType)
42739 }
42740 var msglen int
42741 for shift := uint(0); ; shift += 7 {
42742 if shift >= 64 {
42743 return ErrIntOverflowThetest
42744 }
42745 if iNdEx >= l {
42746 return io.ErrUnexpectedEOF
42747 }
42748 b := dAtA[iNdEx]
42749 iNdEx++
42750 msglen |= int(b&0x7F) << shift
42751 if b < 0x80 {
42752 break
42753 }
42754 }
42755 if msglen < 0 {
42756 return ErrInvalidLengthThetest
42757 }
42758 postIndex := iNdEx + msglen
42759 if postIndex < 0 {
42760 return ErrInvalidLengthThetest
42761 }
42762 if postIndex > l {
42763 return io.ErrUnexpectedEOF
42764 }
42765 if m.NM == nil {
42766 m.NM = &NestedDefinition_NestedMessage{}
42767 }
42768 if err := m.NM.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
42769 return err
42770 }
42771 iNdEx = postIndex
42772 default:
42773 iNdEx = preIndex
42774 skippy, err := skipThetest(dAtA[iNdEx:])
42775 if err != nil {
42776 return err
42777 }
42778 if (skippy < 0) || (iNdEx+skippy) < 0 {
42779 return ErrInvalidLengthThetest
42780 }
42781 if (iNdEx + skippy) > l {
42782 return io.ErrUnexpectedEOF
42783 }
42784 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
42785 iNdEx += skippy
42786 }
42787 }
42788
42789 if iNdEx > l {
42790 return io.ErrUnexpectedEOF
42791 }
42792 return nil
42793 }
42794 func (m *NestedDefinition_NestedMessage) Unmarshal(dAtA []byte) error {
42795 l := len(dAtA)
42796 iNdEx := 0
42797 for iNdEx < l {
42798 preIndex := iNdEx
42799 var wire uint64
42800 for shift := uint(0); ; shift += 7 {
42801 if shift >= 64 {
42802 return ErrIntOverflowThetest
42803 }
42804 if iNdEx >= l {
42805 return io.ErrUnexpectedEOF
42806 }
42807 b := dAtA[iNdEx]
42808 iNdEx++
42809 wire |= uint64(b&0x7F) << shift
42810 if b < 0x80 {
42811 break
42812 }
42813 }
42814 fieldNum := int32(wire >> 3)
42815 wireType := int(wire & 0x7)
42816 if wireType == 4 {
42817 return fmt.Errorf("proto: NestedMessage: wiretype end group for non-group")
42818 }
42819 if fieldNum <= 0 {
42820 return fmt.Errorf("proto: NestedMessage: illegal tag %d (wire type %d)", fieldNum, wire)
42821 }
42822 switch fieldNum {
42823 case 1:
42824 if wireType != 1 {
42825 return fmt.Errorf("proto: wrong wireType = %d for field NestedField1", wireType)
42826 }
42827 var v uint64
42828 if (iNdEx + 8) > l {
42829 return io.ErrUnexpectedEOF
42830 }
42831 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
42832 iNdEx += 8
42833 m.NestedField1 = &v
42834 case 2:
42835 if wireType != 2 {
42836 return fmt.Errorf("proto: wrong wireType = %d for field NNM", wireType)
42837 }
42838 var msglen int
42839 for shift := uint(0); ; shift += 7 {
42840 if shift >= 64 {
42841 return ErrIntOverflowThetest
42842 }
42843 if iNdEx >= l {
42844 return io.ErrUnexpectedEOF
42845 }
42846 b := dAtA[iNdEx]
42847 iNdEx++
42848 msglen |= int(b&0x7F) << shift
42849 if b < 0x80 {
42850 break
42851 }
42852 }
42853 if msglen < 0 {
42854 return ErrInvalidLengthThetest
42855 }
42856 postIndex := iNdEx + msglen
42857 if postIndex < 0 {
42858 return ErrInvalidLengthThetest
42859 }
42860 if postIndex > l {
42861 return io.ErrUnexpectedEOF
42862 }
42863 if m.NNM == nil {
42864 m.NNM = &NestedDefinition_NestedMessage_NestedNestedMsg{}
42865 }
42866 if err := m.NNM.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
42867 return err
42868 }
42869 iNdEx = postIndex
42870 default:
42871 iNdEx = preIndex
42872 skippy, err := skipThetest(dAtA[iNdEx:])
42873 if err != nil {
42874 return err
42875 }
42876 if (skippy < 0) || (iNdEx+skippy) < 0 {
42877 return ErrInvalidLengthThetest
42878 }
42879 if (iNdEx + skippy) > l {
42880 return io.ErrUnexpectedEOF
42881 }
42882 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
42883 iNdEx += skippy
42884 }
42885 }
42886
42887 if iNdEx > l {
42888 return io.ErrUnexpectedEOF
42889 }
42890 return nil
42891 }
42892 func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Unmarshal(dAtA []byte) error {
42893 l := len(dAtA)
42894 iNdEx := 0
42895 for iNdEx < l {
42896 preIndex := iNdEx
42897 var wire uint64
42898 for shift := uint(0); ; shift += 7 {
42899 if shift >= 64 {
42900 return ErrIntOverflowThetest
42901 }
42902 if iNdEx >= l {
42903 return io.ErrUnexpectedEOF
42904 }
42905 b := dAtA[iNdEx]
42906 iNdEx++
42907 wire |= uint64(b&0x7F) << shift
42908 if b < 0x80 {
42909 break
42910 }
42911 }
42912 fieldNum := int32(wire >> 3)
42913 wireType := int(wire & 0x7)
42914 if wireType == 4 {
42915 return fmt.Errorf("proto: NestedNestedMsg: wiretype end group for non-group")
42916 }
42917 if fieldNum <= 0 {
42918 return fmt.Errorf("proto: NestedNestedMsg: illegal tag %d (wire type %d)", fieldNum, wire)
42919 }
42920 switch fieldNum {
42921 case 10:
42922 if wireType != 2 {
42923 return fmt.Errorf("proto: wrong wireType = %d for field NestedNestedField1", wireType)
42924 }
42925 var stringLen uint64
42926 for shift := uint(0); ; shift += 7 {
42927 if shift >= 64 {
42928 return ErrIntOverflowThetest
42929 }
42930 if iNdEx >= l {
42931 return io.ErrUnexpectedEOF
42932 }
42933 b := dAtA[iNdEx]
42934 iNdEx++
42935 stringLen |= uint64(b&0x7F) << shift
42936 if b < 0x80 {
42937 break
42938 }
42939 }
42940 intStringLen := int(stringLen)
42941 if intStringLen < 0 {
42942 return ErrInvalidLengthThetest
42943 }
42944 postIndex := iNdEx + intStringLen
42945 if postIndex < 0 {
42946 return ErrInvalidLengthThetest
42947 }
42948 if postIndex > l {
42949 return io.ErrUnexpectedEOF
42950 }
42951 s := string(dAtA[iNdEx:postIndex])
42952 m.NestedNestedField1 = &s
42953 iNdEx = postIndex
42954 default:
42955 iNdEx = preIndex
42956 skippy, err := skipThetest(dAtA[iNdEx:])
42957 if err != nil {
42958 return err
42959 }
42960 if (skippy < 0) || (iNdEx+skippy) < 0 {
42961 return ErrInvalidLengthThetest
42962 }
42963 if (iNdEx + skippy) > l {
42964 return io.ErrUnexpectedEOF
42965 }
42966 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
42967 iNdEx += skippy
42968 }
42969 }
42970
42971 if iNdEx > l {
42972 return io.ErrUnexpectedEOF
42973 }
42974 return nil
42975 }
42976 func (m *NestedScope) Unmarshal(dAtA []byte) error {
42977 l := len(dAtA)
42978 iNdEx := 0
42979 for iNdEx < l {
42980 preIndex := iNdEx
42981 var wire uint64
42982 for shift := uint(0); ; shift += 7 {
42983 if shift >= 64 {
42984 return ErrIntOverflowThetest
42985 }
42986 if iNdEx >= l {
42987 return io.ErrUnexpectedEOF
42988 }
42989 b := dAtA[iNdEx]
42990 iNdEx++
42991 wire |= uint64(b&0x7F) << shift
42992 if b < 0x80 {
42993 break
42994 }
42995 }
42996 fieldNum := int32(wire >> 3)
42997 wireType := int(wire & 0x7)
42998 if wireType == 4 {
42999 return fmt.Errorf("proto: NestedScope: wiretype end group for non-group")
43000 }
43001 if fieldNum <= 0 {
43002 return fmt.Errorf("proto: NestedScope: illegal tag %d (wire type %d)", fieldNum, wire)
43003 }
43004 switch fieldNum {
43005 case 1:
43006 if wireType != 2 {
43007 return fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
43008 }
43009 var msglen int
43010 for shift := uint(0); ; shift += 7 {
43011 if shift >= 64 {
43012 return ErrIntOverflowThetest
43013 }
43014 if iNdEx >= l {
43015 return io.ErrUnexpectedEOF
43016 }
43017 b := dAtA[iNdEx]
43018 iNdEx++
43019 msglen |= int(b&0x7F) << shift
43020 if b < 0x80 {
43021 break
43022 }
43023 }
43024 if msglen < 0 {
43025 return ErrInvalidLengthThetest
43026 }
43027 postIndex := iNdEx + msglen
43028 if postIndex < 0 {
43029 return ErrInvalidLengthThetest
43030 }
43031 if postIndex > l {
43032 return io.ErrUnexpectedEOF
43033 }
43034 if m.A == nil {
43035 m.A = &NestedDefinition_NestedMessage_NestedNestedMsg{}
43036 }
43037 if err := m.A.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
43038 return err
43039 }
43040 iNdEx = postIndex
43041 case 2:
43042 if wireType != 0 {
43043 return fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
43044 }
43045 var v NestedDefinition_NestedEnum
43046 for shift := uint(0); ; shift += 7 {
43047 if shift >= 64 {
43048 return ErrIntOverflowThetest
43049 }
43050 if iNdEx >= l {
43051 return io.ErrUnexpectedEOF
43052 }
43053 b := dAtA[iNdEx]
43054 iNdEx++
43055 v |= NestedDefinition_NestedEnum(b&0x7F) << shift
43056 if b < 0x80 {
43057 break
43058 }
43059 }
43060 m.B = &v
43061 case 3:
43062 if wireType != 2 {
43063 return fmt.Errorf("proto: wrong wireType = %d for field C", wireType)
43064 }
43065 var msglen int
43066 for shift := uint(0); ; shift += 7 {
43067 if shift >= 64 {
43068 return ErrIntOverflowThetest
43069 }
43070 if iNdEx >= l {
43071 return io.ErrUnexpectedEOF
43072 }
43073 b := dAtA[iNdEx]
43074 iNdEx++
43075 msglen |= int(b&0x7F) << shift
43076 if b < 0x80 {
43077 break
43078 }
43079 }
43080 if msglen < 0 {
43081 return ErrInvalidLengthThetest
43082 }
43083 postIndex := iNdEx + msglen
43084 if postIndex < 0 {
43085 return ErrInvalidLengthThetest
43086 }
43087 if postIndex > l {
43088 return io.ErrUnexpectedEOF
43089 }
43090 if m.C == nil {
43091 m.C = &NestedDefinition_NestedMessage{}
43092 }
43093 if err := m.C.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
43094 return err
43095 }
43096 iNdEx = postIndex
43097 default:
43098 iNdEx = preIndex
43099 skippy, err := skipThetest(dAtA[iNdEx:])
43100 if err != nil {
43101 return err
43102 }
43103 if (skippy < 0) || (iNdEx+skippy) < 0 {
43104 return ErrInvalidLengthThetest
43105 }
43106 if (iNdEx + skippy) > l {
43107 return io.ErrUnexpectedEOF
43108 }
43109 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
43110 iNdEx += skippy
43111 }
43112 }
43113
43114 if iNdEx > l {
43115 return io.ErrUnexpectedEOF
43116 }
43117 return nil
43118 }
43119 func (m *NinOptNativeDefault) Unmarshal(dAtA []byte) error {
43120 l := len(dAtA)
43121 iNdEx := 0
43122 for iNdEx < l {
43123 preIndex := iNdEx
43124 var wire uint64
43125 for shift := uint(0); ; shift += 7 {
43126 if shift >= 64 {
43127 return ErrIntOverflowThetest
43128 }
43129 if iNdEx >= l {
43130 return io.ErrUnexpectedEOF
43131 }
43132 b := dAtA[iNdEx]
43133 iNdEx++
43134 wire |= uint64(b&0x7F) << shift
43135 if b < 0x80 {
43136 break
43137 }
43138 }
43139 fieldNum := int32(wire >> 3)
43140 wireType := int(wire & 0x7)
43141 if wireType == 4 {
43142 return fmt.Errorf("proto: NinOptNativeDefault: wiretype end group for non-group")
43143 }
43144 if fieldNum <= 0 {
43145 return fmt.Errorf("proto: NinOptNativeDefault: illegal tag %d (wire type %d)", fieldNum, wire)
43146 }
43147 switch fieldNum {
43148 case 1:
43149 if wireType != 1 {
43150 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
43151 }
43152 var v uint64
43153 if (iNdEx + 8) > l {
43154 return io.ErrUnexpectedEOF
43155 }
43156 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
43157 iNdEx += 8
43158 v2 := float64(math.Float64frombits(v))
43159 m.Field1 = &v2
43160 case 2:
43161 if wireType != 5 {
43162 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
43163 }
43164 var v uint32
43165 if (iNdEx + 4) > l {
43166 return io.ErrUnexpectedEOF
43167 }
43168 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
43169 iNdEx += 4
43170 v2 := float32(math.Float32frombits(v))
43171 m.Field2 = &v2
43172 case 3:
43173 if wireType != 0 {
43174 return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
43175 }
43176 var v int32
43177 for shift := uint(0); ; shift += 7 {
43178 if shift >= 64 {
43179 return ErrIntOverflowThetest
43180 }
43181 if iNdEx >= l {
43182 return io.ErrUnexpectedEOF
43183 }
43184 b := dAtA[iNdEx]
43185 iNdEx++
43186 v |= int32(b&0x7F) << shift
43187 if b < 0x80 {
43188 break
43189 }
43190 }
43191 m.Field3 = &v
43192 case 4:
43193 if wireType != 0 {
43194 return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
43195 }
43196 var v int64
43197 for shift := uint(0); ; shift += 7 {
43198 if shift >= 64 {
43199 return ErrIntOverflowThetest
43200 }
43201 if iNdEx >= l {
43202 return io.ErrUnexpectedEOF
43203 }
43204 b := dAtA[iNdEx]
43205 iNdEx++
43206 v |= int64(b&0x7F) << shift
43207 if b < 0x80 {
43208 break
43209 }
43210 }
43211 m.Field4 = &v
43212 case 5:
43213 if wireType != 0 {
43214 return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
43215 }
43216 var v uint32
43217 for shift := uint(0); ; shift += 7 {
43218 if shift >= 64 {
43219 return ErrIntOverflowThetest
43220 }
43221 if iNdEx >= l {
43222 return io.ErrUnexpectedEOF
43223 }
43224 b := dAtA[iNdEx]
43225 iNdEx++
43226 v |= uint32(b&0x7F) << shift
43227 if b < 0x80 {
43228 break
43229 }
43230 }
43231 m.Field5 = &v
43232 case 6:
43233 if wireType != 0 {
43234 return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
43235 }
43236 var v uint64
43237 for shift := uint(0); ; shift += 7 {
43238 if shift >= 64 {
43239 return ErrIntOverflowThetest
43240 }
43241 if iNdEx >= l {
43242 return io.ErrUnexpectedEOF
43243 }
43244 b := dAtA[iNdEx]
43245 iNdEx++
43246 v |= uint64(b&0x7F) << shift
43247 if b < 0x80 {
43248 break
43249 }
43250 }
43251 m.Field6 = &v
43252 case 7:
43253 if wireType != 0 {
43254 return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
43255 }
43256 var v int32
43257 for shift := uint(0); ; shift += 7 {
43258 if shift >= 64 {
43259 return ErrIntOverflowThetest
43260 }
43261 if iNdEx >= l {
43262 return io.ErrUnexpectedEOF
43263 }
43264 b := dAtA[iNdEx]
43265 iNdEx++
43266 v |= int32(b&0x7F) << shift
43267 if b < 0x80 {
43268 break
43269 }
43270 }
43271 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
43272 m.Field7 = &v
43273 case 8:
43274 if wireType != 0 {
43275 return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
43276 }
43277 var v uint64
43278 for shift := uint(0); ; shift += 7 {
43279 if shift >= 64 {
43280 return ErrIntOverflowThetest
43281 }
43282 if iNdEx >= l {
43283 return io.ErrUnexpectedEOF
43284 }
43285 b := dAtA[iNdEx]
43286 iNdEx++
43287 v |= uint64(b&0x7F) << shift
43288 if b < 0x80 {
43289 break
43290 }
43291 }
43292 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
43293 v2 := int64(v)
43294 m.Field8 = &v2
43295 case 9:
43296 if wireType != 5 {
43297 return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
43298 }
43299 var v uint32
43300 if (iNdEx + 4) > l {
43301 return io.ErrUnexpectedEOF
43302 }
43303 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
43304 iNdEx += 4
43305 m.Field9 = &v
43306 case 10:
43307 if wireType != 5 {
43308 return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
43309 }
43310 var v int32
43311 if (iNdEx + 4) > l {
43312 return io.ErrUnexpectedEOF
43313 }
43314 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
43315 iNdEx += 4
43316 m.Field10 = &v
43317 case 11:
43318 if wireType != 1 {
43319 return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
43320 }
43321 var v uint64
43322 if (iNdEx + 8) > l {
43323 return io.ErrUnexpectedEOF
43324 }
43325 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
43326 iNdEx += 8
43327 m.Field11 = &v
43328 case 12:
43329 if wireType != 1 {
43330 return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
43331 }
43332 var v int64
43333 if (iNdEx + 8) > l {
43334 return io.ErrUnexpectedEOF
43335 }
43336 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
43337 iNdEx += 8
43338 m.Field12 = &v
43339 case 13:
43340 if wireType != 0 {
43341 return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
43342 }
43343 var v int
43344 for shift := uint(0); ; shift += 7 {
43345 if shift >= 64 {
43346 return ErrIntOverflowThetest
43347 }
43348 if iNdEx >= l {
43349 return io.ErrUnexpectedEOF
43350 }
43351 b := dAtA[iNdEx]
43352 iNdEx++
43353 v |= int(b&0x7F) << shift
43354 if b < 0x80 {
43355 break
43356 }
43357 }
43358 b := bool(v != 0)
43359 m.Field13 = &b
43360 case 14:
43361 if wireType != 2 {
43362 return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
43363 }
43364 var stringLen uint64
43365 for shift := uint(0); ; shift += 7 {
43366 if shift >= 64 {
43367 return ErrIntOverflowThetest
43368 }
43369 if iNdEx >= l {
43370 return io.ErrUnexpectedEOF
43371 }
43372 b := dAtA[iNdEx]
43373 iNdEx++
43374 stringLen |= uint64(b&0x7F) << shift
43375 if b < 0x80 {
43376 break
43377 }
43378 }
43379 intStringLen := int(stringLen)
43380 if intStringLen < 0 {
43381 return ErrInvalidLengthThetest
43382 }
43383 postIndex := iNdEx + intStringLen
43384 if postIndex < 0 {
43385 return ErrInvalidLengthThetest
43386 }
43387 if postIndex > l {
43388 return io.ErrUnexpectedEOF
43389 }
43390 s := string(dAtA[iNdEx:postIndex])
43391 m.Field14 = &s
43392 iNdEx = postIndex
43393 case 15:
43394 if wireType != 2 {
43395 return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
43396 }
43397 var byteLen int
43398 for shift := uint(0); ; shift += 7 {
43399 if shift >= 64 {
43400 return ErrIntOverflowThetest
43401 }
43402 if iNdEx >= l {
43403 return io.ErrUnexpectedEOF
43404 }
43405 b := dAtA[iNdEx]
43406 iNdEx++
43407 byteLen |= int(b&0x7F) << shift
43408 if b < 0x80 {
43409 break
43410 }
43411 }
43412 if byteLen < 0 {
43413 return ErrInvalidLengthThetest
43414 }
43415 postIndex := iNdEx + byteLen
43416 if postIndex < 0 {
43417 return ErrInvalidLengthThetest
43418 }
43419 if postIndex > l {
43420 return io.ErrUnexpectedEOF
43421 }
43422 m.Field15 = append(m.Field15[:0], dAtA[iNdEx:postIndex]...)
43423 if m.Field15 == nil {
43424 m.Field15 = []byte{}
43425 }
43426 iNdEx = postIndex
43427 default:
43428 iNdEx = preIndex
43429 skippy, err := skipThetest(dAtA[iNdEx:])
43430 if err != nil {
43431 return err
43432 }
43433 if (skippy < 0) || (iNdEx+skippy) < 0 {
43434 return ErrInvalidLengthThetest
43435 }
43436 if (iNdEx + skippy) > l {
43437 return io.ErrUnexpectedEOF
43438 }
43439 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
43440 iNdEx += skippy
43441 }
43442 }
43443
43444 if iNdEx > l {
43445 return io.ErrUnexpectedEOF
43446 }
43447 return nil
43448 }
43449 func (m *CustomContainer) Unmarshal(dAtA []byte) error {
43450 l := len(dAtA)
43451 iNdEx := 0
43452 for iNdEx < l {
43453 preIndex := iNdEx
43454 var wire uint64
43455 for shift := uint(0); ; shift += 7 {
43456 if shift >= 64 {
43457 return ErrIntOverflowThetest
43458 }
43459 if iNdEx >= l {
43460 return io.ErrUnexpectedEOF
43461 }
43462 b := dAtA[iNdEx]
43463 iNdEx++
43464 wire |= uint64(b&0x7F) << shift
43465 if b < 0x80 {
43466 break
43467 }
43468 }
43469 fieldNum := int32(wire >> 3)
43470 wireType := int(wire & 0x7)
43471 if wireType == 4 {
43472 return fmt.Errorf("proto: CustomContainer: wiretype end group for non-group")
43473 }
43474 if fieldNum <= 0 {
43475 return fmt.Errorf("proto: CustomContainer: illegal tag %d (wire type %d)", fieldNum, wire)
43476 }
43477 switch fieldNum {
43478 case 1:
43479 if wireType != 2 {
43480 return fmt.Errorf("proto: wrong wireType = %d for field CustomStruct", wireType)
43481 }
43482 var msglen int
43483 for shift := uint(0); ; shift += 7 {
43484 if shift >= 64 {
43485 return ErrIntOverflowThetest
43486 }
43487 if iNdEx >= l {
43488 return io.ErrUnexpectedEOF
43489 }
43490 b := dAtA[iNdEx]
43491 iNdEx++
43492 msglen |= int(b&0x7F) << shift
43493 if b < 0x80 {
43494 break
43495 }
43496 }
43497 if msglen < 0 {
43498 return ErrInvalidLengthThetest
43499 }
43500 postIndex := iNdEx + msglen
43501 if postIndex < 0 {
43502 return ErrInvalidLengthThetest
43503 }
43504 if postIndex > l {
43505 return io.ErrUnexpectedEOF
43506 }
43507 if err := m.CustomStruct.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
43508 return err
43509 }
43510 iNdEx = postIndex
43511 default:
43512 iNdEx = preIndex
43513 skippy, err := skipThetest(dAtA[iNdEx:])
43514 if err != nil {
43515 return err
43516 }
43517 if (skippy < 0) || (iNdEx+skippy) < 0 {
43518 return ErrInvalidLengthThetest
43519 }
43520 if (iNdEx + skippy) > l {
43521 return io.ErrUnexpectedEOF
43522 }
43523 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
43524 iNdEx += skippy
43525 }
43526 }
43527
43528 if iNdEx > l {
43529 return io.ErrUnexpectedEOF
43530 }
43531 return nil
43532 }
43533 func (m *CustomNameNidOptNative) Unmarshal(dAtA []byte) error {
43534 l := len(dAtA)
43535 iNdEx := 0
43536 for iNdEx < l {
43537 preIndex := iNdEx
43538 var wire uint64
43539 for shift := uint(0); ; shift += 7 {
43540 if shift >= 64 {
43541 return ErrIntOverflowThetest
43542 }
43543 if iNdEx >= l {
43544 return io.ErrUnexpectedEOF
43545 }
43546 b := dAtA[iNdEx]
43547 iNdEx++
43548 wire |= uint64(b&0x7F) << shift
43549 if b < 0x80 {
43550 break
43551 }
43552 }
43553 fieldNum := int32(wire >> 3)
43554 wireType := int(wire & 0x7)
43555 if wireType == 4 {
43556 return fmt.Errorf("proto: CustomNameNidOptNative: wiretype end group for non-group")
43557 }
43558 if fieldNum <= 0 {
43559 return fmt.Errorf("proto: CustomNameNidOptNative: illegal tag %d (wire type %d)", fieldNum, wire)
43560 }
43561 switch fieldNum {
43562 case 1:
43563 if wireType != 1 {
43564 return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType)
43565 }
43566 var v uint64
43567 if (iNdEx + 8) > l {
43568 return io.ErrUnexpectedEOF
43569 }
43570 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
43571 iNdEx += 8
43572 m.FieldA = float64(math.Float64frombits(v))
43573 case 2:
43574 if wireType != 5 {
43575 return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType)
43576 }
43577 var v uint32
43578 if (iNdEx + 4) > l {
43579 return io.ErrUnexpectedEOF
43580 }
43581 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
43582 iNdEx += 4
43583 m.FieldB = float32(math.Float32frombits(v))
43584 case 3:
43585 if wireType != 0 {
43586 return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType)
43587 }
43588 m.FieldC = 0
43589 for shift := uint(0); ; shift += 7 {
43590 if shift >= 64 {
43591 return ErrIntOverflowThetest
43592 }
43593 if iNdEx >= l {
43594 return io.ErrUnexpectedEOF
43595 }
43596 b := dAtA[iNdEx]
43597 iNdEx++
43598 m.FieldC |= int32(b&0x7F) << shift
43599 if b < 0x80 {
43600 break
43601 }
43602 }
43603 case 4:
43604 if wireType != 0 {
43605 return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType)
43606 }
43607 m.FieldD = 0
43608 for shift := uint(0); ; shift += 7 {
43609 if shift >= 64 {
43610 return ErrIntOverflowThetest
43611 }
43612 if iNdEx >= l {
43613 return io.ErrUnexpectedEOF
43614 }
43615 b := dAtA[iNdEx]
43616 iNdEx++
43617 m.FieldD |= int64(b&0x7F) << shift
43618 if b < 0x80 {
43619 break
43620 }
43621 }
43622 case 5:
43623 if wireType != 0 {
43624 return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType)
43625 }
43626 m.FieldE = 0
43627 for shift := uint(0); ; shift += 7 {
43628 if shift >= 64 {
43629 return ErrIntOverflowThetest
43630 }
43631 if iNdEx >= l {
43632 return io.ErrUnexpectedEOF
43633 }
43634 b := dAtA[iNdEx]
43635 iNdEx++
43636 m.FieldE |= uint32(b&0x7F) << shift
43637 if b < 0x80 {
43638 break
43639 }
43640 }
43641 case 6:
43642 if wireType != 0 {
43643 return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType)
43644 }
43645 m.FieldF = 0
43646 for shift := uint(0); ; shift += 7 {
43647 if shift >= 64 {
43648 return ErrIntOverflowThetest
43649 }
43650 if iNdEx >= l {
43651 return io.ErrUnexpectedEOF
43652 }
43653 b := dAtA[iNdEx]
43654 iNdEx++
43655 m.FieldF |= uint64(b&0x7F) << shift
43656 if b < 0x80 {
43657 break
43658 }
43659 }
43660 case 7:
43661 if wireType != 0 {
43662 return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType)
43663 }
43664 var v int32
43665 for shift := uint(0); ; shift += 7 {
43666 if shift >= 64 {
43667 return ErrIntOverflowThetest
43668 }
43669 if iNdEx >= l {
43670 return io.ErrUnexpectedEOF
43671 }
43672 b := dAtA[iNdEx]
43673 iNdEx++
43674 v |= int32(b&0x7F) << shift
43675 if b < 0x80 {
43676 break
43677 }
43678 }
43679 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
43680 m.FieldG = v
43681 case 8:
43682 if wireType != 0 {
43683 return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType)
43684 }
43685 var v uint64
43686 for shift := uint(0); ; shift += 7 {
43687 if shift >= 64 {
43688 return ErrIntOverflowThetest
43689 }
43690 if iNdEx >= l {
43691 return io.ErrUnexpectedEOF
43692 }
43693 b := dAtA[iNdEx]
43694 iNdEx++
43695 v |= uint64(b&0x7F) << shift
43696 if b < 0x80 {
43697 break
43698 }
43699 }
43700 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
43701 m.FieldH = int64(v)
43702 case 9:
43703 if wireType != 5 {
43704 return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType)
43705 }
43706 m.FieldI = 0
43707 if (iNdEx + 4) > l {
43708 return io.ErrUnexpectedEOF
43709 }
43710 m.FieldI = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
43711 iNdEx += 4
43712 case 10:
43713 if wireType != 5 {
43714 return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType)
43715 }
43716 m.FieldJ = 0
43717 if (iNdEx + 4) > l {
43718 return io.ErrUnexpectedEOF
43719 }
43720 m.FieldJ = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
43721 iNdEx += 4
43722 case 11:
43723 if wireType != 1 {
43724 return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType)
43725 }
43726 m.FieldK = 0
43727 if (iNdEx + 8) > l {
43728 return io.ErrUnexpectedEOF
43729 }
43730 m.FieldK = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
43731 iNdEx += 8
43732 case 12:
43733 if wireType != 1 {
43734 return fmt.Errorf("proto: wrong wireType = %d for field FieldL", wireType)
43735 }
43736 m.FieldL = 0
43737 if (iNdEx + 8) > l {
43738 return io.ErrUnexpectedEOF
43739 }
43740 m.FieldL = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
43741 iNdEx += 8
43742 case 13:
43743 if wireType != 0 {
43744 return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType)
43745 }
43746 var v int
43747 for shift := uint(0); ; shift += 7 {
43748 if shift >= 64 {
43749 return ErrIntOverflowThetest
43750 }
43751 if iNdEx >= l {
43752 return io.ErrUnexpectedEOF
43753 }
43754 b := dAtA[iNdEx]
43755 iNdEx++
43756 v |= int(b&0x7F) << shift
43757 if b < 0x80 {
43758 break
43759 }
43760 }
43761 m.FieldM = bool(v != 0)
43762 case 14:
43763 if wireType != 2 {
43764 return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType)
43765 }
43766 var stringLen uint64
43767 for shift := uint(0); ; shift += 7 {
43768 if shift >= 64 {
43769 return ErrIntOverflowThetest
43770 }
43771 if iNdEx >= l {
43772 return io.ErrUnexpectedEOF
43773 }
43774 b := dAtA[iNdEx]
43775 iNdEx++
43776 stringLen |= uint64(b&0x7F) << shift
43777 if b < 0x80 {
43778 break
43779 }
43780 }
43781 intStringLen := int(stringLen)
43782 if intStringLen < 0 {
43783 return ErrInvalidLengthThetest
43784 }
43785 postIndex := iNdEx + intStringLen
43786 if postIndex < 0 {
43787 return ErrInvalidLengthThetest
43788 }
43789 if postIndex > l {
43790 return io.ErrUnexpectedEOF
43791 }
43792 m.FieldN = string(dAtA[iNdEx:postIndex])
43793 iNdEx = postIndex
43794 case 15:
43795 if wireType != 2 {
43796 return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType)
43797 }
43798 var byteLen int
43799 for shift := uint(0); ; shift += 7 {
43800 if shift >= 64 {
43801 return ErrIntOverflowThetest
43802 }
43803 if iNdEx >= l {
43804 return io.ErrUnexpectedEOF
43805 }
43806 b := dAtA[iNdEx]
43807 iNdEx++
43808 byteLen |= int(b&0x7F) << shift
43809 if b < 0x80 {
43810 break
43811 }
43812 }
43813 if byteLen < 0 {
43814 return ErrInvalidLengthThetest
43815 }
43816 postIndex := iNdEx + byteLen
43817 if postIndex < 0 {
43818 return ErrInvalidLengthThetest
43819 }
43820 if postIndex > l {
43821 return io.ErrUnexpectedEOF
43822 }
43823 m.FieldO = append(m.FieldO[:0], dAtA[iNdEx:postIndex]...)
43824 if m.FieldO == nil {
43825 m.FieldO = []byte{}
43826 }
43827 iNdEx = postIndex
43828 default:
43829 iNdEx = preIndex
43830 skippy, err := skipThetest(dAtA[iNdEx:])
43831 if err != nil {
43832 return err
43833 }
43834 if (skippy < 0) || (iNdEx+skippy) < 0 {
43835 return ErrInvalidLengthThetest
43836 }
43837 if (iNdEx + skippy) > l {
43838 return io.ErrUnexpectedEOF
43839 }
43840 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
43841 iNdEx += skippy
43842 }
43843 }
43844
43845 if iNdEx > l {
43846 return io.ErrUnexpectedEOF
43847 }
43848 return nil
43849 }
43850 func (m *CustomNameNinOptNative) Unmarshal(dAtA []byte) error {
43851 l := len(dAtA)
43852 iNdEx := 0
43853 for iNdEx < l {
43854 preIndex := iNdEx
43855 var wire uint64
43856 for shift := uint(0); ; shift += 7 {
43857 if shift >= 64 {
43858 return ErrIntOverflowThetest
43859 }
43860 if iNdEx >= l {
43861 return io.ErrUnexpectedEOF
43862 }
43863 b := dAtA[iNdEx]
43864 iNdEx++
43865 wire |= uint64(b&0x7F) << shift
43866 if b < 0x80 {
43867 break
43868 }
43869 }
43870 fieldNum := int32(wire >> 3)
43871 wireType := int(wire & 0x7)
43872 if wireType == 4 {
43873 return fmt.Errorf("proto: CustomNameNinOptNative: wiretype end group for non-group")
43874 }
43875 if fieldNum <= 0 {
43876 return fmt.Errorf("proto: CustomNameNinOptNative: illegal tag %d (wire type %d)", fieldNum, wire)
43877 }
43878 switch fieldNum {
43879 case 1:
43880 if wireType != 1 {
43881 return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType)
43882 }
43883 var v uint64
43884 if (iNdEx + 8) > l {
43885 return io.ErrUnexpectedEOF
43886 }
43887 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
43888 iNdEx += 8
43889 v2 := float64(math.Float64frombits(v))
43890 m.FieldA = &v2
43891 case 2:
43892 if wireType != 5 {
43893 return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType)
43894 }
43895 var v uint32
43896 if (iNdEx + 4) > l {
43897 return io.ErrUnexpectedEOF
43898 }
43899 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
43900 iNdEx += 4
43901 v2 := float32(math.Float32frombits(v))
43902 m.FieldB = &v2
43903 case 3:
43904 if wireType != 0 {
43905 return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType)
43906 }
43907 var v int32
43908 for shift := uint(0); ; shift += 7 {
43909 if shift >= 64 {
43910 return ErrIntOverflowThetest
43911 }
43912 if iNdEx >= l {
43913 return io.ErrUnexpectedEOF
43914 }
43915 b := dAtA[iNdEx]
43916 iNdEx++
43917 v |= int32(b&0x7F) << shift
43918 if b < 0x80 {
43919 break
43920 }
43921 }
43922 m.FieldC = &v
43923 case 4:
43924 if wireType != 0 {
43925 return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType)
43926 }
43927 var v int64
43928 for shift := uint(0); ; shift += 7 {
43929 if shift >= 64 {
43930 return ErrIntOverflowThetest
43931 }
43932 if iNdEx >= l {
43933 return io.ErrUnexpectedEOF
43934 }
43935 b := dAtA[iNdEx]
43936 iNdEx++
43937 v |= int64(b&0x7F) << shift
43938 if b < 0x80 {
43939 break
43940 }
43941 }
43942 m.FieldD = &v
43943 case 5:
43944 if wireType != 0 {
43945 return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType)
43946 }
43947 var v uint32
43948 for shift := uint(0); ; shift += 7 {
43949 if shift >= 64 {
43950 return ErrIntOverflowThetest
43951 }
43952 if iNdEx >= l {
43953 return io.ErrUnexpectedEOF
43954 }
43955 b := dAtA[iNdEx]
43956 iNdEx++
43957 v |= uint32(b&0x7F) << shift
43958 if b < 0x80 {
43959 break
43960 }
43961 }
43962 m.FieldE = &v
43963 case 6:
43964 if wireType != 0 {
43965 return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType)
43966 }
43967 var v uint64
43968 for shift := uint(0); ; shift += 7 {
43969 if shift >= 64 {
43970 return ErrIntOverflowThetest
43971 }
43972 if iNdEx >= l {
43973 return io.ErrUnexpectedEOF
43974 }
43975 b := dAtA[iNdEx]
43976 iNdEx++
43977 v |= uint64(b&0x7F) << shift
43978 if b < 0x80 {
43979 break
43980 }
43981 }
43982 m.FieldF = &v
43983 case 7:
43984 if wireType != 0 {
43985 return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType)
43986 }
43987 var v int32
43988 for shift := uint(0); ; shift += 7 {
43989 if shift >= 64 {
43990 return ErrIntOverflowThetest
43991 }
43992 if iNdEx >= l {
43993 return io.ErrUnexpectedEOF
43994 }
43995 b := dAtA[iNdEx]
43996 iNdEx++
43997 v |= int32(b&0x7F) << shift
43998 if b < 0x80 {
43999 break
44000 }
44001 }
44002 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
44003 m.FieldG = &v
44004 case 8:
44005 if wireType != 0 {
44006 return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType)
44007 }
44008 var v uint64
44009 for shift := uint(0); ; shift += 7 {
44010 if shift >= 64 {
44011 return ErrIntOverflowThetest
44012 }
44013 if iNdEx >= l {
44014 return io.ErrUnexpectedEOF
44015 }
44016 b := dAtA[iNdEx]
44017 iNdEx++
44018 v |= uint64(b&0x7F) << shift
44019 if b < 0x80 {
44020 break
44021 }
44022 }
44023 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
44024 v2 := int64(v)
44025 m.FieldH = &v2
44026 case 9:
44027 if wireType != 5 {
44028 return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType)
44029 }
44030 var v uint32
44031 if (iNdEx + 4) > l {
44032 return io.ErrUnexpectedEOF
44033 }
44034 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
44035 iNdEx += 4
44036 m.FieldI = &v
44037 case 10:
44038 if wireType != 5 {
44039 return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType)
44040 }
44041 var v int32
44042 if (iNdEx + 4) > l {
44043 return io.ErrUnexpectedEOF
44044 }
44045 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
44046 iNdEx += 4
44047 m.FieldJ = &v
44048 case 11:
44049 if wireType != 1 {
44050 return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType)
44051 }
44052 var v uint64
44053 if (iNdEx + 8) > l {
44054 return io.ErrUnexpectedEOF
44055 }
44056 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
44057 iNdEx += 8
44058 m.FieldK = &v
44059 case 12:
44060 if wireType != 1 {
44061 return fmt.Errorf("proto: wrong wireType = %d for field FielL", wireType)
44062 }
44063 var v int64
44064 if (iNdEx + 8) > l {
44065 return io.ErrUnexpectedEOF
44066 }
44067 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
44068 iNdEx += 8
44069 m.FielL = &v
44070 case 13:
44071 if wireType != 0 {
44072 return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType)
44073 }
44074 var v int
44075 for shift := uint(0); ; shift += 7 {
44076 if shift >= 64 {
44077 return ErrIntOverflowThetest
44078 }
44079 if iNdEx >= l {
44080 return io.ErrUnexpectedEOF
44081 }
44082 b := dAtA[iNdEx]
44083 iNdEx++
44084 v |= int(b&0x7F) << shift
44085 if b < 0x80 {
44086 break
44087 }
44088 }
44089 b := bool(v != 0)
44090 m.FieldM = &b
44091 case 14:
44092 if wireType != 2 {
44093 return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType)
44094 }
44095 var stringLen uint64
44096 for shift := uint(0); ; shift += 7 {
44097 if shift >= 64 {
44098 return ErrIntOverflowThetest
44099 }
44100 if iNdEx >= l {
44101 return io.ErrUnexpectedEOF
44102 }
44103 b := dAtA[iNdEx]
44104 iNdEx++
44105 stringLen |= uint64(b&0x7F) << shift
44106 if b < 0x80 {
44107 break
44108 }
44109 }
44110 intStringLen := int(stringLen)
44111 if intStringLen < 0 {
44112 return ErrInvalidLengthThetest
44113 }
44114 postIndex := iNdEx + intStringLen
44115 if postIndex < 0 {
44116 return ErrInvalidLengthThetest
44117 }
44118 if postIndex > l {
44119 return io.ErrUnexpectedEOF
44120 }
44121 s := string(dAtA[iNdEx:postIndex])
44122 m.FieldN = &s
44123 iNdEx = postIndex
44124 case 15:
44125 if wireType != 2 {
44126 return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType)
44127 }
44128 var byteLen int
44129 for shift := uint(0); ; shift += 7 {
44130 if shift >= 64 {
44131 return ErrIntOverflowThetest
44132 }
44133 if iNdEx >= l {
44134 return io.ErrUnexpectedEOF
44135 }
44136 b := dAtA[iNdEx]
44137 iNdEx++
44138 byteLen |= int(b&0x7F) << shift
44139 if b < 0x80 {
44140 break
44141 }
44142 }
44143 if byteLen < 0 {
44144 return ErrInvalidLengthThetest
44145 }
44146 postIndex := iNdEx + byteLen
44147 if postIndex < 0 {
44148 return ErrInvalidLengthThetest
44149 }
44150 if postIndex > l {
44151 return io.ErrUnexpectedEOF
44152 }
44153 m.FieldO = append(m.FieldO[:0], dAtA[iNdEx:postIndex]...)
44154 if m.FieldO == nil {
44155 m.FieldO = []byte{}
44156 }
44157 iNdEx = postIndex
44158 default:
44159 iNdEx = preIndex
44160 skippy, err := skipThetest(dAtA[iNdEx:])
44161 if err != nil {
44162 return err
44163 }
44164 if (skippy < 0) || (iNdEx+skippy) < 0 {
44165 return ErrInvalidLengthThetest
44166 }
44167 if (iNdEx + skippy) > l {
44168 return io.ErrUnexpectedEOF
44169 }
44170 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
44171 iNdEx += skippy
44172 }
44173 }
44174
44175 if iNdEx > l {
44176 return io.ErrUnexpectedEOF
44177 }
44178 return nil
44179 }
44180 func (m *CustomNameNinRepNative) Unmarshal(dAtA []byte) error {
44181 l := len(dAtA)
44182 iNdEx := 0
44183 for iNdEx < l {
44184 preIndex := iNdEx
44185 var wire uint64
44186 for shift := uint(0); ; shift += 7 {
44187 if shift >= 64 {
44188 return ErrIntOverflowThetest
44189 }
44190 if iNdEx >= l {
44191 return io.ErrUnexpectedEOF
44192 }
44193 b := dAtA[iNdEx]
44194 iNdEx++
44195 wire |= uint64(b&0x7F) << shift
44196 if b < 0x80 {
44197 break
44198 }
44199 }
44200 fieldNum := int32(wire >> 3)
44201 wireType := int(wire & 0x7)
44202 if wireType == 4 {
44203 return fmt.Errorf("proto: CustomNameNinRepNative: wiretype end group for non-group")
44204 }
44205 if fieldNum <= 0 {
44206 return fmt.Errorf("proto: CustomNameNinRepNative: illegal tag %d (wire type %d)", fieldNum, wire)
44207 }
44208 switch fieldNum {
44209 case 1:
44210 if wireType == 1 {
44211 var v uint64
44212 if (iNdEx + 8) > l {
44213 return io.ErrUnexpectedEOF
44214 }
44215 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
44216 iNdEx += 8
44217 v2 := float64(math.Float64frombits(v))
44218 m.FieldA = append(m.FieldA, v2)
44219 } else if wireType == 2 {
44220 var packedLen int
44221 for shift := uint(0); ; shift += 7 {
44222 if shift >= 64 {
44223 return ErrIntOverflowThetest
44224 }
44225 if iNdEx >= l {
44226 return io.ErrUnexpectedEOF
44227 }
44228 b := dAtA[iNdEx]
44229 iNdEx++
44230 packedLen |= int(b&0x7F) << shift
44231 if b < 0x80 {
44232 break
44233 }
44234 }
44235 if packedLen < 0 {
44236 return ErrInvalidLengthThetest
44237 }
44238 postIndex := iNdEx + packedLen
44239 if postIndex < 0 {
44240 return ErrInvalidLengthThetest
44241 }
44242 if postIndex > l {
44243 return io.ErrUnexpectedEOF
44244 }
44245 var elementCount int
44246 elementCount = packedLen / 8
44247 if elementCount != 0 && len(m.FieldA) == 0 {
44248 m.FieldA = make([]float64, 0, elementCount)
44249 }
44250 for iNdEx < postIndex {
44251 var v uint64
44252 if (iNdEx + 8) > l {
44253 return io.ErrUnexpectedEOF
44254 }
44255 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
44256 iNdEx += 8
44257 v2 := float64(math.Float64frombits(v))
44258 m.FieldA = append(m.FieldA, v2)
44259 }
44260 } else {
44261 return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType)
44262 }
44263 case 2:
44264 if wireType == 5 {
44265 var v uint32
44266 if (iNdEx + 4) > l {
44267 return io.ErrUnexpectedEOF
44268 }
44269 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
44270 iNdEx += 4
44271 v2 := float32(math.Float32frombits(v))
44272 m.FieldB = append(m.FieldB, v2)
44273 } else if wireType == 2 {
44274 var packedLen int
44275 for shift := uint(0); ; shift += 7 {
44276 if shift >= 64 {
44277 return ErrIntOverflowThetest
44278 }
44279 if iNdEx >= l {
44280 return io.ErrUnexpectedEOF
44281 }
44282 b := dAtA[iNdEx]
44283 iNdEx++
44284 packedLen |= int(b&0x7F) << shift
44285 if b < 0x80 {
44286 break
44287 }
44288 }
44289 if packedLen < 0 {
44290 return ErrInvalidLengthThetest
44291 }
44292 postIndex := iNdEx + packedLen
44293 if postIndex < 0 {
44294 return ErrInvalidLengthThetest
44295 }
44296 if postIndex > l {
44297 return io.ErrUnexpectedEOF
44298 }
44299 var elementCount int
44300 elementCount = packedLen / 4
44301 if elementCount != 0 && len(m.FieldB) == 0 {
44302 m.FieldB = make([]float32, 0, elementCount)
44303 }
44304 for iNdEx < postIndex {
44305 var v uint32
44306 if (iNdEx + 4) > l {
44307 return io.ErrUnexpectedEOF
44308 }
44309 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
44310 iNdEx += 4
44311 v2 := float32(math.Float32frombits(v))
44312 m.FieldB = append(m.FieldB, v2)
44313 }
44314 } else {
44315 return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType)
44316 }
44317 case 3:
44318 if wireType == 0 {
44319 var v int32
44320 for shift := uint(0); ; shift += 7 {
44321 if shift >= 64 {
44322 return ErrIntOverflowThetest
44323 }
44324 if iNdEx >= l {
44325 return io.ErrUnexpectedEOF
44326 }
44327 b := dAtA[iNdEx]
44328 iNdEx++
44329 v |= int32(b&0x7F) << shift
44330 if b < 0x80 {
44331 break
44332 }
44333 }
44334 m.FieldC = append(m.FieldC, v)
44335 } else if wireType == 2 {
44336 var packedLen int
44337 for shift := uint(0); ; shift += 7 {
44338 if shift >= 64 {
44339 return ErrIntOverflowThetest
44340 }
44341 if iNdEx >= l {
44342 return io.ErrUnexpectedEOF
44343 }
44344 b := dAtA[iNdEx]
44345 iNdEx++
44346 packedLen |= int(b&0x7F) << shift
44347 if b < 0x80 {
44348 break
44349 }
44350 }
44351 if packedLen < 0 {
44352 return ErrInvalidLengthThetest
44353 }
44354 postIndex := iNdEx + packedLen
44355 if postIndex < 0 {
44356 return ErrInvalidLengthThetest
44357 }
44358 if postIndex > l {
44359 return io.ErrUnexpectedEOF
44360 }
44361 var elementCount int
44362 var count int
44363 for _, integer := range dAtA[iNdEx:postIndex] {
44364 if integer < 128 {
44365 count++
44366 }
44367 }
44368 elementCount = count
44369 if elementCount != 0 && len(m.FieldC) == 0 {
44370 m.FieldC = make([]int32, 0, elementCount)
44371 }
44372 for iNdEx < postIndex {
44373 var v int32
44374 for shift := uint(0); ; shift += 7 {
44375 if shift >= 64 {
44376 return ErrIntOverflowThetest
44377 }
44378 if iNdEx >= l {
44379 return io.ErrUnexpectedEOF
44380 }
44381 b := dAtA[iNdEx]
44382 iNdEx++
44383 v |= int32(b&0x7F) << shift
44384 if b < 0x80 {
44385 break
44386 }
44387 }
44388 m.FieldC = append(m.FieldC, v)
44389 }
44390 } else {
44391 return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType)
44392 }
44393 case 4:
44394 if wireType == 0 {
44395 var v int64
44396 for shift := uint(0); ; shift += 7 {
44397 if shift >= 64 {
44398 return ErrIntOverflowThetest
44399 }
44400 if iNdEx >= l {
44401 return io.ErrUnexpectedEOF
44402 }
44403 b := dAtA[iNdEx]
44404 iNdEx++
44405 v |= int64(b&0x7F) << shift
44406 if b < 0x80 {
44407 break
44408 }
44409 }
44410 m.FieldD = append(m.FieldD, v)
44411 } else if wireType == 2 {
44412 var packedLen int
44413 for shift := uint(0); ; shift += 7 {
44414 if shift >= 64 {
44415 return ErrIntOverflowThetest
44416 }
44417 if iNdEx >= l {
44418 return io.ErrUnexpectedEOF
44419 }
44420 b := dAtA[iNdEx]
44421 iNdEx++
44422 packedLen |= int(b&0x7F) << shift
44423 if b < 0x80 {
44424 break
44425 }
44426 }
44427 if packedLen < 0 {
44428 return ErrInvalidLengthThetest
44429 }
44430 postIndex := iNdEx + packedLen
44431 if postIndex < 0 {
44432 return ErrInvalidLengthThetest
44433 }
44434 if postIndex > l {
44435 return io.ErrUnexpectedEOF
44436 }
44437 var elementCount int
44438 var count int
44439 for _, integer := range dAtA[iNdEx:postIndex] {
44440 if integer < 128 {
44441 count++
44442 }
44443 }
44444 elementCount = count
44445 if elementCount != 0 && len(m.FieldD) == 0 {
44446 m.FieldD = make([]int64, 0, elementCount)
44447 }
44448 for iNdEx < postIndex {
44449 var v int64
44450 for shift := uint(0); ; shift += 7 {
44451 if shift >= 64 {
44452 return ErrIntOverflowThetest
44453 }
44454 if iNdEx >= l {
44455 return io.ErrUnexpectedEOF
44456 }
44457 b := dAtA[iNdEx]
44458 iNdEx++
44459 v |= int64(b&0x7F) << shift
44460 if b < 0x80 {
44461 break
44462 }
44463 }
44464 m.FieldD = append(m.FieldD, v)
44465 }
44466 } else {
44467 return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType)
44468 }
44469 case 5:
44470 if wireType == 0 {
44471 var v uint32
44472 for shift := uint(0); ; shift += 7 {
44473 if shift >= 64 {
44474 return ErrIntOverflowThetest
44475 }
44476 if iNdEx >= l {
44477 return io.ErrUnexpectedEOF
44478 }
44479 b := dAtA[iNdEx]
44480 iNdEx++
44481 v |= uint32(b&0x7F) << shift
44482 if b < 0x80 {
44483 break
44484 }
44485 }
44486 m.FieldE = append(m.FieldE, v)
44487 } else if wireType == 2 {
44488 var packedLen int
44489 for shift := uint(0); ; shift += 7 {
44490 if shift >= 64 {
44491 return ErrIntOverflowThetest
44492 }
44493 if iNdEx >= l {
44494 return io.ErrUnexpectedEOF
44495 }
44496 b := dAtA[iNdEx]
44497 iNdEx++
44498 packedLen |= int(b&0x7F) << shift
44499 if b < 0x80 {
44500 break
44501 }
44502 }
44503 if packedLen < 0 {
44504 return ErrInvalidLengthThetest
44505 }
44506 postIndex := iNdEx + packedLen
44507 if postIndex < 0 {
44508 return ErrInvalidLengthThetest
44509 }
44510 if postIndex > l {
44511 return io.ErrUnexpectedEOF
44512 }
44513 var elementCount int
44514 var count int
44515 for _, integer := range dAtA[iNdEx:postIndex] {
44516 if integer < 128 {
44517 count++
44518 }
44519 }
44520 elementCount = count
44521 if elementCount != 0 && len(m.FieldE) == 0 {
44522 m.FieldE = make([]uint32, 0, elementCount)
44523 }
44524 for iNdEx < postIndex {
44525 var v uint32
44526 for shift := uint(0); ; shift += 7 {
44527 if shift >= 64 {
44528 return ErrIntOverflowThetest
44529 }
44530 if iNdEx >= l {
44531 return io.ErrUnexpectedEOF
44532 }
44533 b := dAtA[iNdEx]
44534 iNdEx++
44535 v |= uint32(b&0x7F) << shift
44536 if b < 0x80 {
44537 break
44538 }
44539 }
44540 m.FieldE = append(m.FieldE, v)
44541 }
44542 } else {
44543 return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType)
44544 }
44545 case 6:
44546 if wireType == 0 {
44547 var v uint64
44548 for shift := uint(0); ; shift += 7 {
44549 if shift >= 64 {
44550 return ErrIntOverflowThetest
44551 }
44552 if iNdEx >= l {
44553 return io.ErrUnexpectedEOF
44554 }
44555 b := dAtA[iNdEx]
44556 iNdEx++
44557 v |= uint64(b&0x7F) << shift
44558 if b < 0x80 {
44559 break
44560 }
44561 }
44562 m.FieldF = append(m.FieldF, v)
44563 } else if wireType == 2 {
44564 var packedLen int
44565 for shift := uint(0); ; shift += 7 {
44566 if shift >= 64 {
44567 return ErrIntOverflowThetest
44568 }
44569 if iNdEx >= l {
44570 return io.ErrUnexpectedEOF
44571 }
44572 b := dAtA[iNdEx]
44573 iNdEx++
44574 packedLen |= int(b&0x7F) << shift
44575 if b < 0x80 {
44576 break
44577 }
44578 }
44579 if packedLen < 0 {
44580 return ErrInvalidLengthThetest
44581 }
44582 postIndex := iNdEx + packedLen
44583 if postIndex < 0 {
44584 return ErrInvalidLengthThetest
44585 }
44586 if postIndex > l {
44587 return io.ErrUnexpectedEOF
44588 }
44589 var elementCount int
44590 var count int
44591 for _, integer := range dAtA[iNdEx:postIndex] {
44592 if integer < 128 {
44593 count++
44594 }
44595 }
44596 elementCount = count
44597 if elementCount != 0 && len(m.FieldF) == 0 {
44598 m.FieldF = make([]uint64, 0, elementCount)
44599 }
44600 for iNdEx < postIndex {
44601 var v uint64
44602 for shift := uint(0); ; shift += 7 {
44603 if shift >= 64 {
44604 return ErrIntOverflowThetest
44605 }
44606 if iNdEx >= l {
44607 return io.ErrUnexpectedEOF
44608 }
44609 b := dAtA[iNdEx]
44610 iNdEx++
44611 v |= uint64(b&0x7F) << shift
44612 if b < 0x80 {
44613 break
44614 }
44615 }
44616 m.FieldF = append(m.FieldF, v)
44617 }
44618 } else {
44619 return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType)
44620 }
44621 case 7:
44622 if wireType == 0 {
44623 var v int32
44624 for shift := uint(0); ; shift += 7 {
44625 if shift >= 64 {
44626 return ErrIntOverflowThetest
44627 }
44628 if iNdEx >= l {
44629 return io.ErrUnexpectedEOF
44630 }
44631 b := dAtA[iNdEx]
44632 iNdEx++
44633 v |= int32(b&0x7F) << shift
44634 if b < 0x80 {
44635 break
44636 }
44637 }
44638 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
44639 m.FieldG = append(m.FieldG, v)
44640 } else if wireType == 2 {
44641 var packedLen int
44642 for shift := uint(0); ; shift += 7 {
44643 if shift >= 64 {
44644 return ErrIntOverflowThetest
44645 }
44646 if iNdEx >= l {
44647 return io.ErrUnexpectedEOF
44648 }
44649 b := dAtA[iNdEx]
44650 iNdEx++
44651 packedLen |= int(b&0x7F) << shift
44652 if b < 0x80 {
44653 break
44654 }
44655 }
44656 if packedLen < 0 {
44657 return ErrInvalidLengthThetest
44658 }
44659 postIndex := iNdEx + packedLen
44660 if postIndex < 0 {
44661 return ErrInvalidLengthThetest
44662 }
44663 if postIndex > l {
44664 return io.ErrUnexpectedEOF
44665 }
44666 var elementCount int
44667 var count int
44668 for _, integer := range dAtA[iNdEx:postIndex] {
44669 if integer < 128 {
44670 count++
44671 }
44672 }
44673 elementCount = count
44674 if elementCount != 0 && len(m.FieldG) == 0 {
44675 m.FieldG = make([]int32, 0, elementCount)
44676 }
44677 for iNdEx < postIndex {
44678 var v int32
44679 for shift := uint(0); ; shift += 7 {
44680 if shift >= 64 {
44681 return ErrIntOverflowThetest
44682 }
44683 if iNdEx >= l {
44684 return io.ErrUnexpectedEOF
44685 }
44686 b := dAtA[iNdEx]
44687 iNdEx++
44688 v |= int32(b&0x7F) << shift
44689 if b < 0x80 {
44690 break
44691 }
44692 }
44693 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
44694 m.FieldG = append(m.FieldG, v)
44695 }
44696 } else {
44697 return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType)
44698 }
44699 case 8:
44700 if wireType == 0 {
44701 var v uint64
44702 for shift := uint(0); ; shift += 7 {
44703 if shift >= 64 {
44704 return ErrIntOverflowThetest
44705 }
44706 if iNdEx >= l {
44707 return io.ErrUnexpectedEOF
44708 }
44709 b := dAtA[iNdEx]
44710 iNdEx++
44711 v |= uint64(b&0x7F) << shift
44712 if b < 0x80 {
44713 break
44714 }
44715 }
44716 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
44717 m.FieldH = append(m.FieldH, int64(v))
44718 } else if wireType == 2 {
44719 var packedLen int
44720 for shift := uint(0); ; shift += 7 {
44721 if shift >= 64 {
44722 return ErrIntOverflowThetest
44723 }
44724 if iNdEx >= l {
44725 return io.ErrUnexpectedEOF
44726 }
44727 b := dAtA[iNdEx]
44728 iNdEx++
44729 packedLen |= int(b&0x7F) << shift
44730 if b < 0x80 {
44731 break
44732 }
44733 }
44734 if packedLen < 0 {
44735 return ErrInvalidLengthThetest
44736 }
44737 postIndex := iNdEx + packedLen
44738 if postIndex < 0 {
44739 return ErrInvalidLengthThetest
44740 }
44741 if postIndex > l {
44742 return io.ErrUnexpectedEOF
44743 }
44744 var elementCount int
44745 var count int
44746 for _, integer := range dAtA[iNdEx:postIndex] {
44747 if integer < 128 {
44748 count++
44749 }
44750 }
44751 elementCount = count
44752 if elementCount != 0 && len(m.FieldH) == 0 {
44753 m.FieldH = make([]int64, 0, elementCount)
44754 }
44755 for iNdEx < postIndex {
44756 var v uint64
44757 for shift := uint(0); ; shift += 7 {
44758 if shift >= 64 {
44759 return ErrIntOverflowThetest
44760 }
44761 if iNdEx >= l {
44762 return io.ErrUnexpectedEOF
44763 }
44764 b := dAtA[iNdEx]
44765 iNdEx++
44766 v |= uint64(b&0x7F) << shift
44767 if b < 0x80 {
44768 break
44769 }
44770 }
44771 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
44772 m.FieldH = append(m.FieldH, int64(v))
44773 }
44774 } else {
44775 return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType)
44776 }
44777 case 9:
44778 if wireType == 5 {
44779 var v uint32
44780 if (iNdEx + 4) > l {
44781 return io.ErrUnexpectedEOF
44782 }
44783 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
44784 iNdEx += 4
44785 m.FieldI = append(m.FieldI, v)
44786 } else if wireType == 2 {
44787 var packedLen int
44788 for shift := uint(0); ; shift += 7 {
44789 if shift >= 64 {
44790 return ErrIntOverflowThetest
44791 }
44792 if iNdEx >= l {
44793 return io.ErrUnexpectedEOF
44794 }
44795 b := dAtA[iNdEx]
44796 iNdEx++
44797 packedLen |= int(b&0x7F) << shift
44798 if b < 0x80 {
44799 break
44800 }
44801 }
44802 if packedLen < 0 {
44803 return ErrInvalidLengthThetest
44804 }
44805 postIndex := iNdEx + packedLen
44806 if postIndex < 0 {
44807 return ErrInvalidLengthThetest
44808 }
44809 if postIndex > l {
44810 return io.ErrUnexpectedEOF
44811 }
44812 var elementCount int
44813 elementCount = packedLen / 4
44814 if elementCount != 0 && len(m.FieldI) == 0 {
44815 m.FieldI = make([]uint32, 0, elementCount)
44816 }
44817 for iNdEx < postIndex {
44818 var v uint32
44819 if (iNdEx + 4) > l {
44820 return io.ErrUnexpectedEOF
44821 }
44822 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
44823 iNdEx += 4
44824 m.FieldI = append(m.FieldI, v)
44825 }
44826 } else {
44827 return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType)
44828 }
44829 case 10:
44830 if wireType == 5 {
44831 var v int32
44832 if (iNdEx + 4) > l {
44833 return io.ErrUnexpectedEOF
44834 }
44835 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
44836 iNdEx += 4
44837 m.FieldJ = append(m.FieldJ, v)
44838 } else if wireType == 2 {
44839 var packedLen int
44840 for shift := uint(0); ; shift += 7 {
44841 if shift >= 64 {
44842 return ErrIntOverflowThetest
44843 }
44844 if iNdEx >= l {
44845 return io.ErrUnexpectedEOF
44846 }
44847 b := dAtA[iNdEx]
44848 iNdEx++
44849 packedLen |= int(b&0x7F) << shift
44850 if b < 0x80 {
44851 break
44852 }
44853 }
44854 if packedLen < 0 {
44855 return ErrInvalidLengthThetest
44856 }
44857 postIndex := iNdEx + packedLen
44858 if postIndex < 0 {
44859 return ErrInvalidLengthThetest
44860 }
44861 if postIndex > l {
44862 return io.ErrUnexpectedEOF
44863 }
44864 var elementCount int
44865 elementCount = packedLen / 4
44866 if elementCount != 0 && len(m.FieldJ) == 0 {
44867 m.FieldJ = make([]int32, 0, elementCount)
44868 }
44869 for iNdEx < postIndex {
44870 var v int32
44871 if (iNdEx + 4) > l {
44872 return io.ErrUnexpectedEOF
44873 }
44874 v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
44875 iNdEx += 4
44876 m.FieldJ = append(m.FieldJ, v)
44877 }
44878 } else {
44879 return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType)
44880 }
44881 case 11:
44882 if wireType == 1 {
44883 var v uint64
44884 if (iNdEx + 8) > l {
44885 return io.ErrUnexpectedEOF
44886 }
44887 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
44888 iNdEx += 8
44889 m.FieldK = append(m.FieldK, v)
44890 } else if wireType == 2 {
44891 var packedLen int
44892 for shift := uint(0); ; shift += 7 {
44893 if shift >= 64 {
44894 return ErrIntOverflowThetest
44895 }
44896 if iNdEx >= l {
44897 return io.ErrUnexpectedEOF
44898 }
44899 b := dAtA[iNdEx]
44900 iNdEx++
44901 packedLen |= int(b&0x7F) << shift
44902 if b < 0x80 {
44903 break
44904 }
44905 }
44906 if packedLen < 0 {
44907 return ErrInvalidLengthThetest
44908 }
44909 postIndex := iNdEx + packedLen
44910 if postIndex < 0 {
44911 return ErrInvalidLengthThetest
44912 }
44913 if postIndex > l {
44914 return io.ErrUnexpectedEOF
44915 }
44916 var elementCount int
44917 elementCount = packedLen / 8
44918 if elementCount != 0 && len(m.FieldK) == 0 {
44919 m.FieldK = make([]uint64, 0, elementCount)
44920 }
44921 for iNdEx < postIndex {
44922 var v uint64
44923 if (iNdEx + 8) > l {
44924 return io.ErrUnexpectedEOF
44925 }
44926 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
44927 iNdEx += 8
44928 m.FieldK = append(m.FieldK, v)
44929 }
44930 } else {
44931 return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType)
44932 }
44933 case 12:
44934 if wireType == 1 {
44935 var v int64
44936 if (iNdEx + 8) > l {
44937 return io.ErrUnexpectedEOF
44938 }
44939 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
44940 iNdEx += 8
44941 m.FieldL = append(m.FieldL, v)
44942 } else if wireType == 2 {
44943 var packedLen int
44944 for shift := uint(0); ; shift += 7 {
44945 if shift >= 64 {
44946 return ErrIntOverflowThetest
44947 }
44948 if iNdEx >= l {
44949 return io.ErrUnexpectedEOF
44950 }
44951 b := dAtA[iNdEx]
44952 iNdEx++
44953 packedLen |= int(b&0x7F) << shift
44954 if b < 0x80 {
44955 break
44956 }
44957 }
44958 if packedLen < 0 {
44959 return ErrInvalidLengthThetest
44960 }
44961 postIndex := iNdEx + packedLen
44962 if postIndex < 0 {
44963 return ErrInvalidLengthThetest
44964 }
44965 if postIndex > l {
44966 return io.ErrUnexpectedEOF
44967 }
44968 var elementCount int
44969 elementCount = packedLen / 8
44970 if elementCount != 0 && len(m.FieldL) == 0 {
44971 m.FieldL = make([]int64, 0, elementCount)
44972 }
44973 for iNdEx < postIndex {
44974 var v int64
44975 if (iNdEx + 8) > l {
44976 return io.ErrUnexpectedEOF
44977 }
44978 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
44979 iNdEx += 8
44980 m.FieldL = append(m.FieldL, v)
44981 }
44982 } else {
44983 return fmt.Errorf("proto: wrong wireType = %d for field FieldL", wireType)
44984 }
44985 case 13:
44986 if wireType == 0 {
44987 var v int
44988 for shift := uint(0); ; shift += 7 {
44989 if shift >= 64 {
44990 return ErrIntOverflowThetest
44991 }
44992 if iNdEx >= l {
44993 return io.ErrUnexpectedEOF
44994 }
44995 b := dAtA[iNdEx]
44996 iNdEx++
44997 v |= int(b&0x7F) << shift
44998 if b < 0x80 {
44999 break
45000 }
45001 }
45002 m.FieldM = append(m.FieldM, bool(v != 0))
45003 } else if wireType == 2 {
45004 var packedLen int
45005 for shift := uint(0); ; shift += 7 {
45006 if shift >= 64 {
45007 return ErrIntOverflowThetest
45008 }
45009 if iNdEx >= l {
45010 return io.ErrUnexpectedEOF
45011 }
45012 b := dAtA[iNdEx]
45013 iNdEx++
45014 packedLen |= int(b&0x7F) << shift
45015 if b < 0x80 {
45016 break
45017 }
45018 }
45019 if packedLen < 0 {
45020 return ErrInvalidLengthThetest
45021 }
45022 postIndex := iNdEx + packedLen
45023 if postIndex < 0 {
45024 return ErrInvalidLengthThetest
45025 }
45026 if postIndex > l {
45027 return io.ErrUnexpectedEOF
45028 }
45029 var elementCount int
45030 elementCount = packedLen
45031 if elementCount != 0 && len(m.FieldM) == 0 {
45032 m.FieldM = make([]bool, 0, elementCount)
45033 }
45034 for iNdEx < postIndex {
45035 var v int
45036 for shift := uint(0); ; shift += 7 {
45037 if shift >= 64 {
45038 return ErrIntOverflowThetest
45039 }
45040 if iNdEx >= l {
45041 return io.ErrUnexpectedEOF
45042 }
45043 b := dAtA[iNdEx]
45044 iNdEx++
45045 v |= int(b&0x7F) << shift
45046 if b < 0x80 {
45047 break
45048 }
45049 }
45050 m.FieldM = append(m.FieldM, bool(v != 0))
45051 }
45052 } else {
45053 return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType)
45054 }
45055 case 14:
45056 if wireType != 2 {
45057 return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType)
45058 }
45059 var stringLen uint64
45060 for shift := uint(0); ; shift += 7 {
45061 if shift >= 64 {
45062 return ErrIntOverflowThetest
45063 }
45064 if iNdEx >= l {
45065 return io.ErrUnexpectedEOF
45066 }
45067 b := dAtA[iNdEx]
45068 iNdEx++
45069 stringLen |= uint64(b&0x7F) << shift
45070 if b < 0x80 {
45071 break
45072 }
45073 }
45074 intStringLen := int(stringLen)
45075 if intStringLen < 0 {
45076 return ErrInvalidLengthThetest
45077 }
45078 postIndex := iNdEx + intStringLen
45079 if postIndex < 0 {
45080 return ErrInvalidLengthThetest
45081 }
45082 if postIndex > l {
45083 return io.ErrUnexpectedEOF
45084 }
45085 m.FieldN = append(m.FieldN, string(dAtA[iNdEx:postIndex]))
45086 iNdEx = postIndex
45087 case 15:
45088 if wireType != 2 {
45089 return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType)
45090 }
45091 var byteLen int
45092 for shift := uint(0); ; shift += 7 {
45093 if shift >= 64 {
45094 return ErrIntOverflowThetest
45095 }
45096 if iNdEx >= l {
45097 return io.ErrUnexpectedEOF
45098 }
45099 b := dAtA[iNdEx]
45100 iNdEx++
45101 byteLen |= int(b&0x7F) << shift
45102 if b < 0x80 {
45103 break
45104 }
45105 }
45106 if byteLen < 0 {
45107 return ErrInvalidLengthThetest
45108 }
45109 postIndex := iNdEx + byteLen
45110 if postIndex < 0 {
45111 return ErrInvalidLengthThetest
45112 }
45113 if postIndex > l {
45114 return io.ErrUnexpectedEOF
45115 }
45116 m.FieldO = append(m.FieldO, make([]byte, postIndex-iNdEx))
45117 copy(m.FieldO[len(m.FieldO)-1], dAtA[iNdEx:postIndex])
45118 iNdEx = postIndex
45119 default:
45120 iNdEx = preIndex
45121 skippy, err := skipThetest(dAtA[iNdEx:])
45122 if err != nil {
45123 return err
45124 }
45125 if (skippy < 0) || (iNdEx+skippy) < 0 {
45126 return ErrInvalidLengthThetest
45127 }
45128 if (iNdEx + skippy) > l {
45129 return io.ErrUnexpectedEOF
45130 }
45131 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
45132 iNdEx += skippy
45133 }
45134 }
45135
45136 if iNdEx > l {
45137 return io.ErrUnexpectedEOF
45138 }
45139 return nil
45140 }
45141 func (m *CustomNameNinStruct) Unmarshal(dAtA []byte) error {
45142 l := len(dAtA)
45143 iNdEx := 0
45144 for iNdEx < l {
45145 preIndex := iNdEx
45146 var wire uint64
45147 for shift := uint(0); ; shift += 7 {
45148 if shift >= 64 {
45149 return ErrIntOverflowThetest
45150 }
45151 if iNdEx >= l {
45152 return io.ErrUnexpectedEOF
45153 }
45154 b := dAtA[iNdEx]
45155 iNdEx++
45156 wire |= uint64(b&0x7F) << shift
45157 if b < 0x80 {
45158 break
45159 }
45160 }
45161 fieldNum := int32(wire >> 3)
45162 wireType := int(wire & 0x7)
45163 if wireType == 4 {
45164 return fmt.Errorf("proto: CustomNameNinStruct: wiretype end group for non-group")
45165 }
45166 if fieldNum <= 0 {
45167 return fmt.Errorf("proto: CustomNameNinStruct: illegal tag %d (wire type %d)", fieldNum, wire)
45168 }
45169 switch fieldNum {
45170 case 1:
45171 if wireType != 1 {
45172 return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType)
45173 }
45174 var v uint64
45175 if (iNdEx + 8) > l {
45176 return io.ErrUnexpectedEOF
45177 }
45178 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
45179 iNdEx += 8
45180 v2 := float64(math.Float64frombits(v))
45181 m.FieldA = &v2
45182 case 2:
45183 if wireType != 5 {
45184 return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType)
45185 }
45186 var v uint32
45187 if (iNdEx + 4) > l {
45188 return io.ErrUnexpectedEOF
45189 }
45190 v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
45191 iNdEx += 4
45192 v2 := float32(math.Float32frombits(v))
45193 m.FieldB = &v2
45194 case 3:
45195 if wireType != 2 {
45196 return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType)
45197 }
45198 var msglen int
45199 for shift := uint(0); ; shift += 7 {
45200 if shift >= 64 {
45201 return ErrIntOverflowThetest
45202 }
45203 if iNdEx >= l {
45204 return io.ErrUnexpectedEOF
45205 }
45206 b := dAtA[iNdEx]
45207 iNdEx++
45208 msglen |= int(b&0x7F) << shift
45209 if b < 0x80 {
45210 break
45211 }
45212 }
45213 if msglen < 0 {
45214 return ErrInvalidLengthThetest
45215 }
45216 postIndex := iNdEx + msglen
45217 if postIndex < 0 {
45218 return ErrInvalidLengthThetest
45219 }
45220 if postIndex > l {
45221 return io.ErrUnexpectedEOF
45222 }
45223 if m.FieldC == nil {
45224 m.FieldC = &NidOptNative{}
45225 }
45226 if err := m.FieldC.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
45227 return err
45228 }
45229 iNdEx = postIndex
45230 case 4:
45231 if wireType != 2 {
45232 return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType)
45233 }
45234 var msglen int
45235 for shift := uint(0); ; shift += 7 {
45236 if shift >= 64 {
45237 return ErrIntOverflowThetest
45238 }
45239 if iNdEx >= l {
45240 return io.ErrUnexpectedEOF
45241 }
45242 b := dAtA[iNdEx]
45243 iNdEx++
45244 msglen |= int(b&0x7F) << shift
45245 if b < 0x80 {
45246 break
45247 }
45248 }
45249 if msglen < 0 {
45250 return ErrInvalidLengthThetest
45251 }
45252 postIndex := iNdEx + msglen
45253 if postIndex < 0 {
45254 return ErrInvalidLengthThetest
45255 }
45256 if postIndex > l {
45257 return io.ErrUnexpectedEOF
45258 }
45259 m.FieldD = append(m.FieldD, &NinOptNative{})
45260 if err := m.FieldD[len(m.FieldD)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
45261 return err
45262 }
45263 iNdEx = postIndex
45264 case 6:
45265 if wireType != 0 {
45266 return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType)
45267 }
45268 var v uint64
45269 for shift := uint(0); ; shift += 7 {
45270 if shift >= 64 {
45271 return ErrIntOverflowThetest
45272 }
45273 if iNdEx >= l {
45274 return io.ErrUnexpectedEOF
45275 }
45276 b := dAtA[iNdEx]
45277 iNdEx++
45278 v |= uint64(b&0x7F) << shift
45279 if b < 0x80 {
45280 break
45281 }
45282 }
45283 m.FieldE = &v
45284 case 7:
45285 if wireType != 0 {
45286 return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType)
45287 }
45288 var v int32
45289 for shift := uint(0); ; shift += 7 {
45290 if shift >= 64 {
45291 return ErrIntOverflowThetest
45292 }
45293 if iNdEx >= l {
45294 return io.ErrUnexpectedEOF
45295 }
45296 b := dAtA[iNdEx]
45297 iNdEx++
45298 v |= int32(b&0x7F) << shift
45299 if b < 0x80 {
45300 break
45301 }
45302 }
45303 v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
45304 m.FieldF = &v
45305 case 8:
45306 if wireType != 2 {
45307 return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType)
45308 }
45309 var msglen int
45310 for shift := uint(0); ; shift += 7 {
45311 if shift >= 64 {
45312 return ErrIntOverflowThetest
45313 }
45314 if iNdEx >= l {
45315 return io.ErrUnexpectedEOF
45316 }
45317 b := dAtA[iNdEx]
45318 iNdEx++
45319 msglen |= int(b&0x7F) << shift
45320 if b < 0x80 {
45321 break
45322 }
45323 }
45324 if msglen < 0 {
45325 return ErrInvalidLengthThetest
45326 }
45327 postIndex := iNdEx + msglen
45328 if postIndex < 0 {
45329 return ErrInvalidLengthThetest
45330 }
45331 if postIndex > l {
45332 return io.ErrUnexpectedEOF
45333 }
45334 if m.FieldG == nil {
45335 m.FieldG = &NidOptNative{}
45336 }
45337 if err := m.FieldG.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
45338 return err
45339 }
45340 iNdEx = postIndex
45341 case 13:
45342 if wireType != 0 {
45343 return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType)
45344 }
45345 var v int
45346 for shift := uint(0); ; shift += 7 {
45347 if shift >= 64 {
45348 return ErrIntOverflowThetest
45349 }
45350 if iNdEx >= l {
45351 return io.ErrUnexpectedEOF
45352 }
45353 b := dAtA[iNdEx]
45354 iNdEx++
45355 v |= int(b&0x7F) << shift
45356 if b < 0x80 {
45357 break
45358 }
45359 }
45360 b := bool(v != 0)
45361 m.FieldH = &b
45362 case 14:
45363 if wireType != 2 {
45364 return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType)
45365 }
45366 var stringLen uint64
45367 for shift := uint(0); ; shift += 7 {
45368 if shift >= 64 {
45369 return ErrIntOverflowThetest
45370 }
45371 if iNdEx >= l {
45372 return io.ErrUnexpectedEOF
45373 }
45374 b := dAtA[iNdEx]
45375 iNdEx++
45376 stringLen |= uint64(b&0x7F) << shift
45377 if b < 0x80 {
45378 break
45379 }
45380 }
45381 intStringLen := int(stringLen)
45382 if intStringLen < 0 {
45383 return ErrInvalidLengthThetest
45384 }
45385 postIndex := iNdEx + intStringLen
45386 if postIndex < 0 {
45387 return ErrInvalidLengthThetest
45388 }
45389 if postIndex > l {
45390 return io.ErrUnexpectedEOF
45391 }
45392 s := string(dAtA[iNdEx:postIndex])
45393 m.FieldI = &s
45394 iNdEx = postIndex
45395 case 15:
45396 if wireType != 2 {
45397 return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType)
45398 }
45399 var byteLen int
45400 for shift := uint(0); ; shift += 7 {
45401 if shift >= 64 {
45402 return ErrIntOverflowThetest
45403 }
45404 if iNdEx >= l {
45405 return io.ErrUnexpectedEOF
45406 }
45407 b := dAtA[iNdEx]
45408 iNdEx++
45409 byteLen |= int(b&0x7F) << shift
45410 if b < 0x80 {
45411 break
45412 }
45413 }
45414 if byteLen < 0 {
45415 return ErrInvalidLengthThetest
45416 }
45417 postIndex := iNdEx + byteLen
45418 if postIndex < 0 {
45419 return ErrInvalidLengthThetest
45420 }
45421 if postIndex > l {
45422 return io.ErrUnexpectedEOF
45423 }
45424 m.FieldJ = append(m.FieldJ[:0], dAtA[iNdEx:postIndex]...)
45425 if m.FieldJ == nil {
45426 m.FieldJ = []byte{}
45427 }
45428 iNdEx = postIndex
45429 default:
45430 iNdEx = preIndex
45431 skippy, err := skipThetest(dAtA[iNdEx:])
45432 if err != nil {
45433 return err
45434 }
45435 if (skippy < 0) || (iNdEx+skippy) < 0 {
45436 return ErrInvalidLengthThetest
45437 }
45438 if (iNdEx + skippy) > l {
45439 return io.ErrUnexpectedEOF
45440 }
45441 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
45442 iNdEx += skippy
45443 }
45444 }
45445
45446 if iNdEx > l {
45447 return io.ErrUnexpectedEOF
45448 }
45449 return nil
45450 }
45451 func (m *CustomNameCustomType) Unmarshal(dAtA []byte) error {
45452 l := len(dAtA)
45453 iNdEx := 0
45454 for iNdEx < l {
45455 preIndex := iNdEx
45456 var wire uint64
45457 for shift := uint(0); ; shift += 7 {
45458 if shift >= 64 {
45459 return ErrIntOverflowThetest
45460 }
45461 if iNdEx >= l {
45462 return io.ErrUnexpectedEOF
45463 }
45464 b := dAtA[iNdEx]
45465 iNdEx++
45466 wire |= uint64(b&0x7F) << shift
45467 if b < 0x80 {
45468 break
45469 }
45470 }
45471 fieldNum := int32(wire >> 3)
45472 wireType := int(wire & 0x7)
45473 if wireType == 4 {
45474 return fmt.Errorf("proto: CustomNameCustomType: wiretype end group for non-group")
45475 }
45476 if fieldNum <= 0 {
45477 return fmt.Errorf("proto: CustomNameCustomType: illegal tag %d (wire type %d)", fieldNum, wire)
45478 }
45479 switch fieldNum {
45480 case 1:
45481 if wireType != 2 {
45482 return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType)
45483 }
45484 var byteLen int
45485 for shift := uint(0); ; shift += 7 {
45486 if shift >= 64 {
45487 return ErrIntOverflowThetest
45488 }
45489 if iNdEx >= l {
45490 return io.ErrUnexpectedEOF
45491 }
45492 b := dAtA[iNdEx]
45493 iNdEx++
45494 byteLen |= int(b&0x7F) << shift
45495 if b < 0x80 {
45496 break
45497 }
45498 }
45499 if byteLen < 0 {
45500 return ErrInvalidLengthThetest
45501 }
45502 postIndex := iNdEx + byteLen
45503 if postIndex < 0 {
45504 return ErrInvalidLengthThetest
45505 }
45506 if postIndex > l {
45507 return io.ErrUnexpectedEOF
45508 }
45509 var v Uuid
45510 m.FieldA = &v
45511 if err := m.FieldA.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
45512 return err
45513 }
45514 iNdEx = postIndex
45515 case 2:
45516 if wireType != 2 {
45517 return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType)
45518 }
45519 var byteLen int
45520 for shift := uint(0); ; shift += 7 {
45521 if shift >= 64 {
45522 return ErrIntOverflowThetest
45523 }
45524 if iNdEx >= l {
45525 return io.ErrUnexpectedEOF
45526 }
45527 b := dAtA[iNdEx]
45528 iNdEx++
45529 byteLen |= int(b&0x7F) << shift
45530 if b < 0x80 {
45531 break
45532 }
45533 }
45534 if byteLen < 0 {
45535 return ErrInvalidLengthThetest
45536 }
45537 postIndex := iNdEx + byteLen
45538 if postIndex < 0 {
45539 return ErrInvalidLengthThetest
45540 }
45541 if postIndex > l {
45542 return io.ErrUnexpectedEOF
45543 }
45544 var v github_com_gogo_protobuf_test_custom.Uint128
45545 m.FieldB = &v
45546 if err := m.FieldB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
45547 return err
45548 }
45549 iNdEx = postIndex
45550 case 3:
45551 if wireType != 2 {
45552 return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType)
45553 }
45554 var byteLen int
45555 for shift := uint(0); ; shift += 7 {
45556 if shift >= 64 {
45557 return ErrIntOverflowThetest
45558 }
45559 if iNdEx >= l {
45560 return io.ErrUnexpectedEOF
45561 }
45562 b := dAtA[iNdEx]
45563 iNdEx++
45564 byteLen |= int(b&0x7F) << shift
45565 if b < 0x80 {
45566 break
45567 }
45568 }
45569 if byteLen < 0 {
45570 return ErrInvalidLengthThetest
45571 }
45572 postIndex := iNdEx + byteLen
45573 if postIndex < 0 {
45574 return ErrInvalidLengthThetest
45575 }
45576 if postIndex > l {
45577 return io.ErrUnexpectedEOF
45578 }
45579 var v Uuid
45580 m.FieldC = append(m.FieldC, v)
45581 if err := m.FieldC[len(m.FieldC)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
45582 return err
45583 }
45584 iNdEx = postIndex
45585 case 4:
45586 if wireType != 2 {
45587 return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType)
45588 }
45589 var byteLen int
45590 for shift := uint(0); ; shift += 7 {
45591 if shift >= 64 {
45592 return ErrIntOverflowThetest
45593 }
45594 if iNdEx >= l {
45595 return io.ErrUnexpectedEOF
45596 }
45597 b := dAtA[iNdEx]
45598 iNdEx++
45599 byteLen |= int(b&0x7F) << shift
45600 if b < 0x80 {
45601 break
45602 }
45603 }
45604 if byteLen < 0 {
45605 return ErrInvalidLengthThetest
45606 }
45607 postIndex := iNdEx + byteLen
45608 if postIndex < 0 {
45609 return ErrInvalidLengthThetest
45610 }
45611 if postIndex > l {
45612 return io.ErrUnexpectedEOF
45613 }
45614 var v github_com_gogo_protobuf_test_custom.Uint128
45615 m.FieldD = append(m.FieldD, v)
45616 if err := m.FieldD[len(m.FieldD)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
45617 return err
45618 }
45619 iNdEx = postIndex
45620 default:
45621 iNdEx = preIndex
45622 skippy, err := skipThetest(dAtA[iNdEx:])
45623 if err != nil {
45624 return err
45625 }
45626 if (skippy < 0) || (iNdEx+skippy) < 0 {
45627 return ErrInvalidLengthThetest
45628 }
45629 if (iNdEx + skippy) > l {
45630 return io.ErrUnexpectedEOF
45631 }
45632 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
45633 iNdEx += skippy
45634 }
45635 }
45636
45637 if iNdEx > l {
45638 return io.ErrUnexpectedEOF
45639 }
45640 return nil
45641 }
45642 func (m *CustomNameNinEmbeddedStructUnion) Unmarshal(dAtA []byte) error {
45643 l := len(dAtA)
45644 iNdEx := 0
45645 for iNdEx < l {
45646 preIndex := iNdEx
45647 var wire uint64
45648 for shift := uint(0); ; shift += 7 {
45649 if shift >= 64 {
45650 return ErrIntOverflowThetest
45651 }
45652 if iNdEx >= l {
45653 return io.ErrUnexpectedEOF
45654 }
45655 b := dAtA[iNdEx]
45656 iNdEx++
45657 wire |= uint64(b&0x7F) << shift
45658 if b < 0x80 {
45659 break
45660 }
45661 }
45662 fieldNum := int32(wire >> 3)
45663 wireType := int(wire & 0x7)
45664 if wireType == 4 {
45665 return fmt.Errorf("proto: CustomNameNinEmbeddedStructUnion: wiretype end group for non-group")
45666 }
45667 if fieldNum <= 0 {
45668 return fmt.Errorf("proto: CustomNameNinEmbeddedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire)
45669 }
45670 switch fieldNum {
45671 case 1:
45672 if wireType != 2 {
45673 return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType)
45674 }
45675 var msglen int
45676 for shift := uint(0); ; shift += 7 {
45677 if shift >= 64 {
45678 return ErrIntOverflowThetest
45679 }
45680 if iNdEx >= l {
45681 return io.ErrUnexpectedEOF
45682 }
45683 b := dAtA[iNdEx]
45684 iNdEx++
45685 msglen |= int(b&0x7F) << shift
45686 if b < 0x80 {
45687 break
45688 }
45689 }
45690 if msglen < 0 {
45691 return ErrInvalidLengthThetest
45692 }
45693 postIndex := iNdEx + msglen
45694 if postIndex < 0 {
45695 return ErrInvalidLengthThetest
45696 }
45697 if postIndex > l {
45698 return io.ErrUnexpectedEOF
45699 }
45700 if m.NidOptNative == nil {
45701 m.NidOptNative = &NidOptNative{}
45702 }
45703 if err := m.NidOptNative.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
45704 return err
45705 }
45706 iNdEx = postIndex
45707 case 200:
45708 if wireType != 2 {
45709 return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType)
45710 }
45711 var msglen int
45712 for shift := uint(0); ; shift += 7 {
45713 if shift >= 64 {
45714 return ErrIntOverflowThetest
45715 }
45716 if iNdEx >= l {
45717 return io.ErrUnexpectedEOF
45718 }
45719 b := dAtA[iNdEx]
45720 iNdEx++
45721 msglen |= int(b&0x7F) << shift
45722 if b < 0x80 {
45723 break
45724 }
45725 }
45726 if msglen < 0 {
45727 return ErrInvalidLengthThetest
45728 }
45729 postIndex := iNdEx + msglen
45730 if postIndex < 0 {
45731 return ErrInvalidLengthThetest
45732 }
45733 if postIndex > l {
45734 return io.ErrUnexpectedEOF
45735 }
45736 if m.FieldA == nil {
45737 m.FieldA = &NinOptNative{}
45738 }
45739 if err := m.FieldA.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
45740 return err
45741 }
45742 iNdEx = postIndex
45743 case 210:
45744 if wireType != 0 {
45745 return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType)
45746 }
45747 var v int
45748 for shift := uint(0); ; shift += 7 {
45749 if shift >= 64 {
45750 return ErrIntOverflowThetest
45751 }
45752 if iNdEx >= l {
45753 return io.ErrUnexpectedEOF
45754 }
45755 b := dAtA[iNdEx]
45756 iNdEx++
45757 v |= int(b&0x7F) << shift
45758 if b < 0x80 {
45759 break
45760 }
45761 }
45762 b := bool(v != 0)
45763 m.FieldB = &b
45764 default:
45765 iNdEx = preIndex
45766 skippy, err := skipThetest(dAtA[iNdEx:])
45767 if err != nil {
45768 return err
45769 }
45770 if (skippy < 0) || (iNdEx+skippy) < 0 {
45771 return ErrInvalidLengthThetest
45772 }
45773 if (iNdEx + skippy) > l {
45774 return io.ErrUnexpectedEOF
45775 }
45776 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
45777 iNdEx += skippy
45778 }
45779 }
45780
45781 if iNdEx > l {
45782 return io.ErrUnexpectedEOF
45783 }
45784 return nil
45785 }
45786 func (m *CustomNameEnum) Unmarshal(dAtA []byte) error {
45787 l := len(dAtA)
45788 iNdEx := 0
45789 for iNdEx < l {
45790 preIndex := iNdEx
45791 var wire uint64
45792 for shift := uint(0); ; shift += 7 {
45793 if shift >= 64 {
45794 return ErrIntOverflowThetest
45795 }
45796 if iNdEx >= l {
45797 return io.ErrUnexpectedEOF
45798 }
45799 b := dAtA[iNdEx]
45800 iNdEx++
45801 wire |= uint64(b&0x7F) << shift
45802 if b < 0x80 {
45803 break
45804 }
45805 }
45806 fieldNum := int32(wire >> 3)
45807 wireType := int(wire & 0x7)
45808 if wireType == 4 {
45809 return fmt.Errorf("proto: CustomNameEnum: wiretype end group for non-group")
45810 }
45811 if fieldNum <= 0 {
45812 return fmt.Errorf("proto: CustomNameEnum: illegal tag %d (wire type %d)", fieldNum, wire)
45813 }
45814 switch fieldNum {
45815 case 1:
45816 if wireType != 0 {
45817 return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType)
45818 }
45819 var v TheTestEnum
45820 for shift := uint(0); ; shift += 7 {
45821 if shift >= 64 {
45822 return ErrIntOverflowThetest
45823 }
45824 if iNdEx >= l {
45825 return io.ErrUnexpectedEOF
45826 }
45827 b := dAtA[iNdEx]
45828 iNdEx++
45829 v |= TheTestEnum(b&0x7F) << shift
45830 if b < 0x80 {
45831 break
45832 }
45833 }
45834 m.FieldA = &v
45835 case 2:
45836 if wireType == 0 {
45837 var v TheTestEnum
45838 for shift := uint(0); ; shift += 7 {
45839 if shift >= 64 {
45840 return ErrIntOverflowThetest
45841 }
45842 if iNdEx >= l {
45843 return io.ErrUnexpectedEOF
45844 }
45845 b := dAtA[iNdEx]
45846 iNdEx++
45847 v |= TheTestEnum(b&0x7F) << shift
45848 if b < 0x80 {
45849 break
45850 }
45851 }
45852 m.FieldB = append(m.FieldB, v)
45853 } else if wireType == 2 {
45854 var packedLen int
45855 for shift := uint(0); ; shift += 7 {
45856 if shift >= 64 {
45857 return ErrIntOverflowThetest
45858 }
45859 if iNdEx >= l {
45860 return io.ErrUnexpectedEOF
45861 }
45862 b := dAtA[iNdEx]
45863 iNdEx++
45864 packedLen |= int(b&0x7F) << shift
45865 if b < 0x80 {
45866 break
45867 }
45868 }
45869 if packedLen < 0 {
45870 return ErrInvalidLengthThetest
45871 }
45872 postIndex := iNdEx + packedLen
45873 if postIndex < 0 {
45874 return ErrInvalidLengthThetest
45875 }
45876 if postIndex > l {
45877 return io.ErrUnexpectedEOF
45878 }
45879 var elementCount int
45880 if elementCount != 0 && len(m.FieldB) == 0 {
45881 m.FieldB = make([]TheTestEnum, 0, elementCount)
45882 }
45883 for iNdEx < postIndex {
45884 var v TheTestEnum
45885 for shift := uint(0); ; shift += 7 {
45886 if shift >= 64 {
45887 return ErrIntOverflowThetest
45888 }
45889 if iNdEx >= l {
45890 return io.ErrUnexpectedEOF
45891 }
45892 b := dAtA[iNdEx]
45893 iNdEx++
45894 v |= TheTestEnum(b&0x7F) << shift
45895 if b < 0x80 {
45896 break
45897 }
45898 }
45899 m.FieldB = append(m.FieldB, v)
45900 }
45901 } else {
45902 return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType)
45903 }
45904 default:
45905 iNdEx = preIndex
45906 skippy, err := skipThetest(dAtA[iNdEx:])
45907 if err != nil {
45908 return err
45909 }
45910 if (skippy < 0) || (iNdEx+skippy) < 0 {
45911 return ErrInvalidLengthThetest
45912 }
45913 if (iNdEx + skippy) > l {
45914 return io.ErrUnexpectedEOF
45915 }
45916 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
45917 iNdEx += skippy
45918 }
45919 }
45920
45921 if iNdEx > l {
45922 return io.ErrUnexpectedEOF
45923 }
45924 return nil
45925 }
45926 func (m *NoExtensionsMap) Unmarshal(dAtA []byte) error {
45927 l := len(dAtA)
45928 iNdEx := 0
45929 for iNdEx < l {
45930 preIndex := iNdEx
45931 var wire uint64
45932 for shift := uint(0); ; shift += 7 {
45933 if shift >= 64 {
45934 return ErrIntOverflowThetest
45935 }
45936 if iNdEx >= l {
45937 return io.ErrUnexpectedEOF
45938 }
45939 b := dAtA[iNdEx]
45940 iNdEx++
45941 wire |= uint64(b&0x7F) << shift
45942 if b < 0x80 {
45943 break
45944 }
45945 }
45946 fieldNum := int32(wire >> 3)
45947 wireType := int(wire & 0x7)
45948 if wireType == 4 {
45949 return fmt.Errorf("proto: NoExtensionsMap: wiretype end group for non-group")
45950 }
45951 if fieldNum <= 0 {
45952 return fmt.Errorf("proto: NoExtensionsMap: illegal tag %d (wire type %d)", fieldNum, wire)
45953 }
45954 switch fieldNum {
45955 case 1:
45956 if wireType != 0 {
45957 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
45958 }
45959 var v int64
45960 for shift := uint(0); ; shift += 7 {
45961 if shift >= 64 {
45962 return ErrIntOverflowThetest
45963 }
45964 if iNdEx >= l {
45965 return io.ErrUnexpectedEOF
45966 }
45967 b := dAtA[iNdEx]
45968 iNdEx++
45969 v |= int64(b&0x7F) << shift
45970 if b < 0x80 {
45971 break
45972 }
45973 }
45974 m.Field1 = &v
45975 default:
45976 if (fieldNum >= 100) && (fieldNum < 200) {
45977 var sizeOfWire int
45978 for {
45979 sizeOfWire++
45980 wire >>= 7
45981 if wire == 0 {
45982 break
45983 }
45984 }
45985 iNdEx -= sizeOfWire
45986 skippy, err := skipThetest(dAtA[iNdEx:])
45987 if err != nil {
45988 return err
45989 }
45990 if (skippy < 0) || (iNdEx+skippy) < 0 {
45991 return ErrInvalidLengthThetest
45992 }
45993 if (iNdEx + skippy) > l {
45994 return io.ErrUnexpectedEOF
45995 }
45996 github_com_gogo_protobuf_proto.AppendExtension(m, int32(fieldNum), dAtA[iNdEx:iNdEx+skippy])
45997 iNdEx += skippy
45998 } else {
45999 iNdEx = preIndex
46000 skippy, err := skipThetest(dAtA[iNdEx:])
46001 if err != nil {
46002 return err
46003 }
46004 if (skippy < 0) || (iNdEx+skippy) < 0 {
46005 return ErrInvalidLengthThetest
46006 }
46007 if (iNdEx + skippy) > l {
46008 return io.ErrUnexpectedEOF
46009 }
46010 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
46011 iNdEx += skippy
46012 }
46013 }
46014 }
46015
46016 if iNdEx > l {
46017 return io.ErrUnexpectedEOF
46018 }
46019 return nil
46020 }
46021 func (m *Unrecognized) Unmarshal(dAtA []byte) error {
46022 l := len(dAtA)
46023 iNdEx := 0
46024 for iNdEx < l {
46025 preIndex := iNdEx
46026 var wire uint64
46027 for shift := uint(0); ; shift += 7 {
46028 if shift >= 64 {
46029 return ErrIntOverflowThetest
46030 }
46031 if iNdEx >= l {
46032 return io.ErrUnexpectedEOF
46033 }
46034 b := dAtA[iNdEx]
46035 iNdEx++
46036 wire |= uint64(b&0x7F) << shift
46037 if b < 0x80 {
46038 break
46039 }
46040 }
46041 fieldNum := int32(wire >> 3)
46042 wireType := int(wire & 0x7)
46043 if wireType == 4 {
46044 return fmt.Errorf("proto: Unrecognized: wiretype end group for non-group")
46045 }
46046 if fieldNum <= 0 {
46047 return fmt.Errorf("proto: Unrecognized: illegal tag %d (wire type %d)", fieldNum, wire)
46048 }
46049 switch fieldNum {
46050 case 1:
46051 if wireType != 2 {
46052 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
46053 }
46054 var stringLen uint64
46055 for shift := uint(0); ; shift += 7 {
46056 if shift >= 64 {
46057 return ErrIntOverflowThetest
46058 }
46059 if iNdEx >= l {
46060 return io.ErrUnexpectedEOF
46061 }
46062 b := dAtA[iNdEx]
46063 iNdEx++
46064 stringLen |= uint64(b&0x7F) << shift
46065 if b < 0x80 {
46066 break
46067 }
46068 }
46069 intStringLen := int(stringLen)
46070 if intStringLen < 0 {
46071 return ErrInvalidLengthThetest
46072 }
46073 postIndex := iNdEx + intStringLen
46074 if postIndex < 0 {
46075 return ErrInvalidLengthThetest
46076 }
46077 if postIndex > l {
46078 return io.ErrUnexpectedEOF
46079 }
46080 s := string(dAtA[iNdEx:postIndex])
46081 m.Field1 = &s
46082 iNdEx = postIndex
46083 default:
46084 iNdEx = preIndex
46085 skippy, err := skipThetest(dAtA[iNdEx:])
46086 if err != nil {
46087 return err
46088 }
46089 if (skippy < 0) || (iNdEx+skippy) < 0 {
46090 return ErrInvalidLengthThetest
46091 }
46092 if (iNdEx + skippy) > l {
46093 return io.ErrUnexpectedEOF
46094 }
46095 iNdEx += skippy
46096 }
46097 }
46098
46099 if iNdEx > l {
46100 return io.ErrUnexpectedEOF
46101 }
46102 return nil
46103 }
46104 func (m *UnrecognizedWithInner) Unmarshal(dAtA []byte) error {
46105 l := len(dAtA)
46106 iNdEx := 0
46107 for iNdEx < l {
46108 preIndex := iNdEx
46109 var wire uint64
46110 for shift := uint(0); ; shift += 7 {
46111 if shift >= 64 {
46112 return ErrIntOverflowThetest
46113 }
46114 if iNdEx >= l {
46115 return io.ErrUnexpectedEOF
46116 }
46117 b := dAtA[iNdEx]
46118 iNdEx++
46119 wire |= uint64(b&0x7F) << shift
46120 if b < 0x80 {
46121 break
46122 }
46123 }
46124 fieldNum := int32(wire >> 3)
46125 wireType := int(wire & 0x7)
46126 if wireType == 4 {
46127 return fmt.Errorf("proto: UnrecognizedWithInner: wiretype end group for non-group")
46128 }
46129 if fieldNum <= 0 {
46130 return fmt.Errorf("proto: UnrecognizedWithInner: illegal tag %d (wire type %d)", fieldNum, wire)
46131 }
46132 switch fieldNum {
46133 case 1:
46134 if wireType != 2 {
46135 return fmt.Errorf("proto: wrong wireType = %d for field Embedded", wireType)
46136 }
46137 var msglen int
46138 for shift := uint(0); ; shift += 7 {
46139 if shift >= 64 {
46140 return ErrIntOverflowThetest
46141 }
46142 if iNdEx >= l {
46143 return io.ErrUnexpectedEOF
46144 }
46145 b := dAtA[iNdEx]
46146 iNdEx++
46147 msglen |= int(b&0x7F) << shift
46148 if b < 0x80 {
46149 break
46150 }
46151 }
46152 if msglen < 0 {
46153 return ErrInvalidLengthThetest
46154 }
46155 postIndex := iNdEx + msglen
46156 if postIndex < 0 {
46157 return ErrInvalidLengthThetest
46158 }
46159 if postIndex > l {
46160 return io.ErrUnexpectedEOF
46161 }
46162 m.Embedded = append(m.Embedded, &UnrecognizedWithInner_Inner{})
46163 if err := m.Embedded[len(m.Embedded)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
46164 return err
46165 }
46166 iNdEx = postIndex
46167 case 2:
46168 if wireType != 2 {
46169 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
46170 }
46171 var stringLen uint64
46172 for shift := uint(0); ; shift += 7 {
46173 if shift >= 64 {
46174 return ErrIntOverflowThetest
46175 }
46176 if iNdEx >= l {
46177 return io.ErrUnexpectedEOF
46178 }
46179 b := dAtA[iNdEx]
46180 iNdEx++
46181 stringLen |= uint64(b&0x7F) << shift
46182 if b < 0x80 {
46183 break
46184 }
46185 }
46186 intStringLen := int(stringLen)
46187 if intStringLen < 0 {
46188 return ErrInvalidLengthThetest
46189 }
46190 postIndex := iNdEx + intStringLen
46191 if postIndex < 0 {
46192 return ErrInvalidLengthThetest
46193 }
46194 if postIndex > l {
46195 return io.ErrUnexpectedEOF
46196 }
46197 s := string(dAtA[iNdEx:postIndex])
46198 m.Field2 = &s
46199 iNdEx = postIndex
46200 default:
46201 iNdEx = preIndex
46202 skippy, err := skipThetest(dAtA[iNdEx:])
46203 if err != nil {
46204 return err
46205 }
46206 if (skippy < 0) || (iNdEx+skippy) < 0 {
46207 return ErrInvalidLengthThetest
46208 }
46209 if (iNdEx + skippy) > l {
46210 return io.ErrUnexpectedEOF
46211 }
46212 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
46213 iNdEx += skippy
46214 }
46215 }
46216
46217 if iNdEx > l {
46218 return io.ErrUnexpectedEOF
46219 }
46220 return nil
46221 }
46222 func (m *UnrecognizedWithInner_Inner) Unmarshal(dAtA []byte) error {
46223 l := len(dAtA)
46224 iNdEx := 0
46225 for iNdEx < l {
46226 preIndex := iNdEx
46227 var wire uint64
46228 for shift := uint(0); ; shift += 7 {
46229 if shift >= 64 {
46230 return ErrIntOverflowThetest
46231 }
46232 if iNdEx >= l {
46233 return io.ErrUnexpectedEOF
46234 }
46235 b := dAtA[iNdEx]
46236 iNdEx++
46237 wire |= uint64(b&0x7F) << shift
46238 if b < 0x80 {
46239 break
46240 }
46241 }
46242 fieldNum := int32(wire >> 3)
46243 wireType := int(wire & 0x7)
46244 if wireType == 4 {
46245 return fmt.Errorf("proto: Inner: wiretype end group for non-group")
46246 }
46247 if fieldNum <= 0 {
46248 return fmt.Errorf("proto: Inner: illegal tag %d (wire type %d)", fieldNum, wire)
46249 }
46250 switch fieldNum {
46251 case 1:
46252 if wireType != 0 {
46253 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
46254 }
46255 var v uint32
46256 for shift := uint(0); ; shift += 7 {
46257 if shift >= 64 {
46258 return ErrIntOverflowThetest
46259 }
46260 if iNdEx >= l {
46261 return io.ErrUnexpectedEOF
46262 }
46263 b := dAtA[iNdEx]
46264 iNdEx++
46265 v |= uint32(b&0x7F) << shift
46266 if b < 0x80 {
46267 break
46268 }
46269 }
46270 m.Field1 = &v
46271 default:
46272 iNdEx = preIndex
46273 skippy, err := skipThetest(dAtA[iNdEx:])
46274 if err != nil {
46275 return err
46276 }
46277 if (skippy < 0) || (iNdEx+skippy) < 0 {
46278 return ErrInvalidLengthThetest
46279 }
46280 if (iNdEx + skippy) > l {
46281 return io.ErrUnexpectedEOF
46282 }
46283 iNdEx += skippy
46284 }
46285 }
46286
46287 if iNdEx > l {
46288 return io.ErrUnexpectedEOF
46289 }
46290 return nil
46291 }
46292 func (m *UnrecognizedWithEmbed) Unmarshal(dAtA []byte) error {
46293 l := len(dAtA)
46294 iNdEx := 0
46295 for iNdEx < l {
46296 preIndex := iNdEx
46297 var wire uint64
46298 for shift := uint(0); ; shift += 7 {
46299 if shift >= 64 {
46300 return ErrIntOverflowThetest
46301 }
46302 if iNdEx >= l {
46303 return io.ErrUnexpectedEOF
46304 }
46305 b := dAtA[iNdEx]
46306 iNdEx++
46307 wire |= uint64(b&0x7F) << shift
46308 if b < 0x80 {
46309 break
46310 }
46311 }
46312 fieldNum := int32(wire >> 3)
46313 wireType := int(wire & 0x7)
46314 if wireType == 4 {
46315 return fmt.Errorf("proto: UnrecognizedWithEmbed: wiretype end group for non-group")
46316 }
46317 if fieldNum <= 0 {
46318 return fmt.Errorf("proto: UnrecognizedWithEmbed: illegal tag %d (wire type %d)", fieldNum, wire)
46319 }
46320 switch fieldNum {
46321 case 1:
46322 if wireType != 2 {
46323 return fmt.Errorf("proto: wrong wireType = %d for field UnrecognizedWithEmbed_Embedded", wireType)
46324 }
46325 var msglen int
46326 for shift := uint(0); ; shift += 7 {
46327 if shift >= 64 {
46328 return ErrIntOverflowThetest
46329 }
46330 if iNdEx >= l {
46331 return io.ErrUnexpectedEOF
46332 }
46333 b := dAtA[iNdEx]
46334 iNdEx++
46335 msglen |= int(b&0x7F) << shift
46336 if b < 0x80 {
46337 break
46338 }
46339 }
46340 if msglen < 0 {
46341 return ErrInvalidLengthThetest
46342 }
46343 postIndex := iNdEx + msglen
46344 if postIndex < 0 {
46345 return ErrInvalidLengthThetest
46346 }
46347 if postIndex > l {
46348 return io.ErrUnexpectedEOF
46349 }
46350 if err := m.UnrecognizedWithEmbed_Embedded.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
46351 return err
46352 }
46353 iNdEx = postIndex
46354 case 2:
46355 if wireType != 2 {
46356 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
46357 }
46358 var stringLen uint64
46359 for shift := uint(0); ; shift += 7 {
46360 if shift >= 64 {
46361 return ErrIntOverflowThetest
46362 }
46363 if iNdEx >= l {
46364 return io.ErrUnexpectedEOF
46365 }
46366 b := dAtA[iNdEx]
46367 iNdEx++
46368 stringLen |= uint64(b&0x7F) << shift
46369 if b < 0x80 {
46370 break
46371 }
46372 }
46373 intStringLen := int(stringLen)
46374 if intStringLen < 0 {
46375 return ErrInvalidLengthThetest
46376 }
46377 postIndex := iNdEx + intStringLen
46378 if postIndex < 0 {
46379 return ErrInvalidLengthThetest
46380 }
46381 if postIndex > l {
46382 return io.ErrUnexpectedEOF
46383 }
46384 s := string(dAtA[iNdEx:postIndex])
46385 m.Field2 = &s
46386 iNdEx = postIndex
46387 default:
46388 iNdEx = preIndex
46389 skippy, err := skipThetest(dAtA[iNdEx:])
46390 if err != nil {
46391 return err
46392 }
46393 if (skippy < 0) || (iNdEx+skippy) < 0 {
46394 return ErrInvalidLengthThetest
46395 }
46396 if (iNdEx + skippy) > l {
46397 return io.ErrUnexpectedEOF
46398 }
46399 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
46400 iNdEx += skippy
46401 }
46402 }
46403
46404 if iNdEx > l {
46405 return io.ErrUnexpectedEOF
46406 }
46407 return nil
46408 }
46409 func (m *UnrecognizedWithEmbed_Embedded) Unmarshal(dAtA []byte) error {
46410 l := len(dAtA)
46411 iNdEx := 0
46412 for iNdEx < l {
46413 preIndex := iNdEx
46414 var wire uint64
46415 for shift := uint(0); ; shift += 7 {
46416 if shift >= 64 {
46417 return ErrIntOverflowThetest
46418 }
46419 if iNdEx >= l {
46420 return io.ErrUnexpectedEOF
46421 }
46422 b := dAtA[iNdEx]
46423 iNdEx++
46424 wire |= uint64(b&0x7F) << shift
46425 if b < 0x80 {
46426 break
46427 }
46428 }
46429 fieldNum := int32(wire >> 3)
46430 wireType := int(wire & 0x7)
46431 if wireType == 4 {
46432 return fmt.Errorf("proto: Embedded: wiretype end group for non-group")
46433 }
46434 if fieldNum <= 0 {
46435 return fmt.Errorf("proto: Embedded: illegal tag %d (wire type %d)", fieldNum, wire)
46436 }
46437 switch fieldNum {
46438 case 1:
46439 if wireType != 0 {
46440 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
46441 }
46442 var v uint32
46443 for shift := uint(0); ; shift += 7 {
46444 if shift >= 64 {
46445 return ErrIntOverflowThetest
46446 }
46447 if iNdEx >= l {
46448 return io.ErrUnexpectedEOF
46449 }
46450 b := dAtA[iNdEx]
46451 iNdEx++
46452 v |= uint32(b&0x7F) << shift
46453 if b < 0x80 {
46454 break
46455 }
46456 }
46457 m.Field1 = &v
46458 default:
46459 iNdEx = preIndex
46460 skippy, err := skipThetest(dAtA[iNdEx:])
46461 if err != nil {
46462 return err
46463 }
46464 if (skippy < 0) || (iNdEx+skippy) < 0 {
46465 return ErrInvalidLengthThetest
46466 }
46467 if (iNdEx + skippy) > l {
46468 return io.ErrUnexpectedEOF
46469 }
46470 iNdEx += skippy
46471 }
46472 }
46473
46474 if iNdEx > l {
46475 return io.ErrUnexpectedEOF
46476 }
46477 return nil
46478 }
46479 func (m *Node) Unmarshal(dAtA []byte) error {
46480 l := len(dAtA)
46481 iNdEx := 0
46482 for iNdEx < l {
46483 preIndex := iNdEx
46484 var wire uint64
46485 for shift := uint(0); ; shift += 7 {
46486 if shift >= 64 {
46487 return ErrIntOverflowThetest
46488 }
46489 if iNdEx >= l {
46490 return io.ErrUnexpectedEOF
46491 }
46492 b := dAtA[iNdEx]
46493 iNdEx++
46494 wire |= uint64(b&0x7F) << shift
46495 if b < 0x80 {
46496 break
46497 }
46498 }
46499 fieldNum := int32(wire >> 3)
46500 wireType := int(wire & 0x7)
46501 if wireType == 4 {
46502 return fmt.Errorf("proto: Node: wiretype end group for non-group")
46503 }
46504 if fieldNum <= 0 {
46505 return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire)
46506 }
46507 switch fieldNum {
46508 case 1:
46509 if wireType != 2 {
46510 return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
46511 }
46512 var stringLen uint64
46513 for shift := uint(0); ; shift += 7 {
46514 if shift >= 64 {
46515 return ErrIntOverflowThetest
46516 }
46517 if iNdEx >= l {
46518 return io.ErrUnexpectedEOF
46519 }
46520 b := dAtA[iNdEx]
46521 iNdEx++
46522 stringLen |= uint64(b&0x7F) << shift
46523 if b < 0x80 {
46524 break
46525 }
46526 }
46527 intStringLen := int(stringLen)
46528 if intStringLen < 0 {
46529 return ErrInvalidLengthThetest
46530 }
46531 postIndex := iNdEx + intStringLen
46532 if postIndex < 0 {
46533 return ErrInvalidLengthThetest
46534 }
46535 if postIndex > l {
46536 return io.ErrUnexpectedEOF
46537 }
46538 s := string(dAtA[iNdEx:postIndex])
46539 m.Label = &s
46540 iNdEx = postIndex
46541 case 2:
46542 if wireType != 2 {
46543 return fmt.Errorf("proto: wrong wireType = %d for field Children", wireType)
46544 }
46545 var msglen int
46546 for shift := uint(0); ; shift += 7 {
46547 if shift >= 64 {
46548 return ErrIntOverflowThetest
46549 }
46550 if iNdEx >= l {
46551 return io.ErrUnexpectedEOF
46552 }
46553 b := dAtA[iNdEx]
46554 iNdEx++
46555 msglen |= int(b&0x7F) << shift
46556 if b < 0x80 {
46557 break
46558 }
46559 }
46560 if msglen < 0 {
46561 return ErrInvalidLengthThetest
46562 }
46563 postIndex := iNdEx + msglen
46564 if postIndex < 0 {
46565 return ErrInvalidLengthThetest
46566 }
46567 if postIndex > l {
46568 return io.ErrUnexpectedEOF
46569 }
46570 m.Children = append(m.Children, &Node{})
46571 if err := m.Children[len(m.Children)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
46572 return err
46573 }
46574 iNdEx = postIndex
46575 default:
46576 iNdEx = preIndex
46577 skippy, err := skipThetest(dAtA[iNdEx:])
46578 if err != nil {
46579 return err
46580 }
46581 if (skippy < 0) || (iNdEx+skippy) < 0 {
46582 return ErrInvalidLengthThetest
46583 }
46584 if (iNdEx + skippy) > l {
46585 return io.ErrUnexpectedEOF
46586 }
46587 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
46588 iNdEx += skippy
46589 }
46590 }
46591
46592 if iNdEx > l {
46593 return io.ErrUnexpectedEOF
46594 }
46595 return nil
46596 }
46597 func (m *NonByteCustomType) Unmarshal(dAtA []byte) error {
46598 l := len(dAtA)
46599 iNdEx := 0
46600 for iNdEx < l {
46601 preIndex := iNdEx
46602 var wire uint64
46603 for shift := uint(0); ; shift += 7 {
46604 if shift >= 64 {
46605 return ErrIntOverflowThetest
46606 }
46607 if iNdEx >= l {
46608 return io.ErrUnexpectedEOF
46609 }
46610 b := dAtA[iNdEx]
46611 iNdEx++
46612 wire |= uint64(b&0x7F) << shift
46613 if b < 0x80 {
46614 break
46615 }
46616 }
46617 fieldNum := int32(wire >> 3)
46618 wireType := int(wire & 0x7)
46619 if wireType == 4 {
46620 return fmt.Errorf("proto: NonByteCustomType: wiretype end group for non-group")
46621 }
46622 if fieldNum <= 0 {
46623 return fmt.Errorf("proto: NonByteCustomType: illegal tag %d (wire type %d)", fieldNum, wire)
46624 }
46625 switch fieldNum {
46626 case 1:
46627 if wireType != 2 {
46628 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
46629 }
46630 var msglen int
46631 for shift := uint(0); ; shift += 7 {
46632 if shift >= 64 {
46633 return ErrIntOverflowThetest
46634 }
46635 if iNdEx >= l {
46636 return io.ErrUnexpectedEOF
46637 }
46638 b := dAtA[iNdEx]
46639 iNdEx++
46640 msglen |= int(b&0x7F) << shift
46641 if b < 0x80 {
46642 break
46643 }
46644 }
46645 if msglen < 0 {
46646 return ErrInvalidLengthThetest
46647 }
46648 postIndex := iNdEx + msglen
46649 if postIndex < 0 {
46650 return ErrInvalidLengthThetest
46651 }
46652 if postIndex > l {
46653 return io.ErrUnexpectedEOF
46654 }
46655 if m.Field1 == nil {
46656 m.Field1 = &T{}
46657 }
46658 if err := m.Field1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
46659 return err
46660 }
46661 iNdEx = postIndex
46662 default:
46663 iNdEx = preIndex
46664 skippy, err := skipThetest(dAtA[iNdEx:])
46665 if err != nil {
46666 return err
46667 }
46668 if (skippy < 0) || (iNdEx+skippy) < 0 {
46669 return ErrInvalidLengthThetest
46670 }
46671 if (iNdEx + skippy) > l {
46672 return io.ErrUnexpectedEOF
46673 }
46674 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
46675 iNdEx += skippy
46676 }
46677 }
46678
46679 if iNdEx > l {
46680 return io.ErrUnexpectedEOF
46681 }
46682 return nil
46683 }
46684 func (m *NidOptNonByteCustomType) Unmarshal(dAtA []byte) error {
46685 l := len(dAtA)
46686 iNdEx := 0
46687 for iNdEx < l {
46688 preIndex := iNdEx
46689 var wire uint64
46690 for shift := uint(0); ; shift += 7 {
46691 if shift >= 64 {
46692 return ErrIntOverflowThetest
46693 }
46694 if iNdEx >= l {
46695 return io.ErrUnexpectedEOF
46696 }
46697 b := dAtA[iNdEx]
46698 iNdEx++
46699 wire |= uint64(b&0x7F) << shift
46700 if b < 0x80 {
46701 break
46702 }
46703 }
46704 fieldNum := int32(wire >> 3)
46705 wireType := int(wire & 0x7)
46706 if wireType == 4 {
46707 return fmt.Errorf("proto: NidOptNonByteCustomType: wiretype end group for non-group")
46708 }
46709 if fieldNum <= 0 {
46710 return fmt.Errorf("proto: NidOptNonByteCustomType: illegal tag %d (wire type %d)", fieldNum, wire)
46711 }
46712 switch fieldNum {
46713 case 1:
46714 if wireType != 2 {
46715 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
46716 }
46717 var msglen int
46718 for shift := uint(0); ; shift += 7 {
46719 if shift >= 64 {
46720 return ErrIntOverflowThetest
46721 }
46722 if iNdEx >= l {
46723 return io.ErrUnexpectedEOF
46724 }
46725 b := dAtA[iNdEx]
46726 iNdEx++
46727 msglen |= int(b&0x7F) << shift
46728 if b < 0x80 {
46729 break
46730 }
46731 }
46732 if msglen < 0 {
46733 return ErrInvalidLengthThetest
46734 }
46735 postIndex := iNdEx + msglen
46736 if postIndex < 0 {
46737 return ErrInvalidLengthThetest
46738 }
46739 if postIndex > l {
46740 return io.ErrUnexpectedEOF
46741 }
46742 if err := m.Field1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
46743 return err
46744 }
46745 iNdEx = postIndex
46746 default:
46747 iNdEx = preIndex
46748 skippy, err := skipThetest(dAtA[iNdEx:])
46749 if err != nil {
46750 return err
46751 }
46752 if (skippy < 0) || (iNdEx+skippy) < 0 {
46753 return ErrInvalidLengthThetest
46754 }
46755 if (iNdEx + skippy) > l {
46756 return io.ErrUnexpectedEOF
46757 }
46758 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
46759 iNdEx += skippy
46760 }
46761 }
46762
46763 if iNdEx > l {
46764 return io.ErrUnexpectedEOF
46765 }
46766 return nil
46767 }
46768 func (m *NinOptNonByteCustomType) Unmarshal(dAtA []byte) error {
46769 l := len(dAtA)
46770 iNdEx := 0
46771 for iNdEx < l {
46772 preIndex := iNdEx
46773 var wire uint64
46774 for shift := uint(0); ; shift += 7 {
46775 if shift >= 64 {
46776 return ErrIntOverflowThetest
46777 }
46778 if iNdEx >= l {
46779 return io.ErrUnexpectedEOF
46780 }
46781 b := dAtA[iNdEx]
46782 iNdEx++
46783 wire |= uint64(b&0x7F) << shift
46784 if b < 0x80 {
46785 break
46786 }
46787 }
46788 fieldNum := int32(wire >> 3)
46789 wireType := int(wire & 0x7)
46790 if wireType == 4 {
46791 return fmt.Errorf("proto: NinOptNonByteCustomType: wiretype end group for non-group")
46792 }
46793 if fieldNum <= 0 {
46794 return fmt.Errorf("proto: NinOptNonByteCustomType: illegal tag %d (wire type %d)", fieldNum, wire)
46795 }
46796 switch fieldNum {
46797 case 1:
46798 if wireType != 2 {
46799 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
46800 }
46801 var msglen int
46802 for shift := uint(0); ; shift += 7 {
46803 if shift >= 64 {
46804 return ErrIntOverflowThetest
46805 }
46806 if iNdEx >= l {
46807 return io.ErrUnexpectedEOF
46808 }
46809 b := dAtA[iNdEx]
46810 iNdEx++
46811 msglen |= int(b&0x7F) << shift
46812 if b < 0x80 {
46813 break
46814 }
46815 }
46816 if msglen < 0 {
46817 return ErrInvalidLengthThetest
46818 }
46819 postIndex := iNdEx + msglen
46820 if postIndex < 0 {
46821 return ErrInvalidLengthThetest
46822 }
46823 if postIndex > l {
46824 return io.ErrUnexpectedEOF
46825 }
46826 if m.Field1 == nil {
46827 m.Field1 = &T{}
46828 }
46829 if err := m.Field1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
46830 return err
46831 }
46832 iNdEx = postIndex
46833 default:
46834 iNdEx = preIndex
46835 skippy, err := skipThetest(dAtA[iNdEx:])
46836 if err != nil {
46837 return err
46838 }
46839 if (skippy < 0) || (iNdEx+skippy) < 0 {
46840 return ErrInvalidLengthThetest
46841 }
46842 if (iNdEx + skippy) > l {
46843 return io.ErrUnexpectedEOF
46844 }
46845 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
46846 iNdEx += skippy
46847 }
46848 }
46849
46850 if iNdEx > l {
46851 return io.ErrUnexpectedEOF
46852 }
46853 return nil
46854 }
46855 func (m *NidRepNonByteCustomType) Unmarshal(dAtA []byte) error {
46856 l := len(dAtA)
46857 iNdEx := 0
46858 for iNdEx < l {
46859 preIndex := iNdEx
46860 var wire uint64
46861 for shift := uint(0); ; shift += 7 {
46862 if shift >= 64 {
46863 return ErrIntOverflowThetest
46864 }
46865 if iNdEx >= l {
46866 return io.ErrUnexpectedEOF
46867 }
46868 b := dAtA[iNdEx]
46869 iNdEx++
46870 wire |= uint64(b&0x7F) << shift
46871 if b < 0x80 {
46872 break
46873 }
46874 }
46875 fieldNum := int32(wire >> 3)
46876 wireType := int(wire & 0x7)
46877 if wireType == 4 {
46878 return fmt.Errorf("proto: NidRepNonByteCustomType: wiretype end group for non-group")
46879 }
46880 if fieldNum <= 0 {
46881 return fmt.Errorf("proto: NidRepNonByteCustomType: illegal tag %d (wire type %d)", fieldNum, wire)
46882 }
46883 switch fieldNum {
46884 case 1:
46885 if wireType != 2 {
46886 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
46887 }
46888 var msglen int
46889 for shift := uint(0); ; shift += 7 {
46890 if shift >= 64 {
46891 return ErrIntOverflowThetest
46892 }
46893 if iNdEx >= l {
46894 return io.ErrUnexpectedEOF
46895 }
46896 b := dAtA[iNdEx]
46897 iNdEx++
46898 msglen |= int(b&0x7F) << shift
46899 if b < 0x80 {
46900 break
46901 }
46902 }
46903 if msglen < 0 {
46904 return ErrInvalidLengthThetest
46905 }
46906 postIndex := iNdEx + msglen
46907 if postIndex < 0 {
46908 return ErrInvalidLengthThetest
46909 }
46910 if postIndex > l {
46911 return io.ErrUnexpectedEOF
46912 }
46913 m.Field1 = append(m.Field1, T{})
46914 if err := m.Field1[len(m.Field1)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
46915 return err
46916 }
46917 iNdEx = postIndex
46918 default:
46919 iNdEx = preIndex
46920 skippy, err := skipThetest(dAtA[iNdEx:])
46921 if err != nil {
46922 return err
46923 }
46924 if (skippy < 0) || (iNdEx+skippy) < 0 {
46925 return ErrInvalidLengthThetest
46926 }
46927 if (iNdEx + skippy) > l {
46928 return io.ErrUnexpectedEOF
46929 }
46930 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
46931 iNdEx += skippy
46932 }
46933 }
46934
46935 if iNdEx > l {
46936 return io.ErrUnexpectedEOF
46937 }
46938 return nil
46939 }
46940 func (m *NinRepNonByteCustomType) Unmarshal(dAtA []byte) error {
46941 l := len(dAtA)
46942 iNdEx := 0
46943 for iNdEx < l {
46944 preIndex := iNdEx
46945 var wire uint64
46946 for shift := uint(0); ; shift += 7 {
46947 if shift >= 64 {
46948 return ErrIntOverflowThetest
46949 }
46950 if iNdEx >= l {
46951 return io.ErrUnexpectedEOF
46952 }
46953 b := dAtA[iNdEx]
46954 iNdEx++
46955 wire |= uint64(b&0x7F) << shift
46956 if b < 0x80 {
46957 break
46958 }
46959 }
46960 fieldNum := int32(wire >> 3)
46961 wireType := int(wire & 0x7)
46962 if wireType == 4 {
46963 return fmt.Errorf("proto: NinRepNonByteCustomType: wiretype end group for non-group")
46964 }
46965 if fieldNum <= 0 {
46966 return fmt.Errorf("proto: NinRepNonByteCustomType: illegal tag %d (wire type %d)", fieldNum, wire)
46967 }
46968 switch fieldNum {
46969 case 1:
46970 if wireType != 2 {
46971 return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
46972 }
46973 var msglen int
46974 for shift := uint(0); ; shift += 7 {
46975 if shift >= 64 {
46976 return ErrIntOverflowThetest
46977 }
46978 if iNdEx >= l {
46979 return io.ErrUnexpectedEOF
46980 }
46981 b := dAtA[iNdEx]
46982 iNdEx++
46983 msglen |= int(b&0x7F) << shift
46984 if b < 0x80 {
46985 break
46986 }
46987 }
46988 if msglen < 0 {
46989 return ErrInvalidLengthThetest
46990 }
46991 postIndex := iNdEx + msglen
46992 if postIndex < 0 {
46993 return ErrInvalidLengthThetest
46994 }
46995 if postIndex > l {
46996 return io.ErrUnexpectedEOF
46997 }
46998 m.Field1 = append(m.Field1, T{})
46999 if err := m.Field1[len(m.Field1)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
47000 return err
47001 }
47002 iNdEx = postIndex
47003 default:
47004 iNdEx = preIndex
47005 skippy, err := skipThetest(dAtA[iNdEx:])
47006 if err != nil {
47007 return err
47008 }
47009 if (skippy < 0) || (iNdEx+skippy) < 0 {
47010 return ErrInvalidLengthThetest
47011 }
47012 if (iNdEx + skippy) > l {
47013 return io.ErrUnexpectedEOF
47014 }
47015 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
47016 iNdEx += skippy
47017 }
47018 }
47019
47020 if iNdEx > l {
47021 return io.ErrUnexpectedEOF
47022 }
47023 return nil
47024 }
47025 func (m *ProtoType) Unmarshal(dAtA []byte) error {
47026 l := len(dAtA)
47027 iNdEx := 0
47028 for iNdEx < l {
47029 preIndex := iNdEx
47030 var wire uint64
47031 for shift := uint(0); ; shift += 7 {
47032 if shift >= 64 {
47033 return ErrIntOverflowThetest
47034 }
47035 if iNdEx >= l {
47036 return io.ErrUnexpectedEOF
47037 }
47038 b := dAtA[iNdEx]
47039 iNdEx++
47040 wire |= uint64(b&0x7F) << shift
47041 if b < 0x80 {
47042 break
47043 }
47044 }
47045 fieldNum := int32(wire >> 3)
47046 wireType := int(wire & 0x7)
47047 if wireType == 4 {
47048 return fmt.Errorf("proto: ProtoType: wiretype end group for non-group")
47049 }
47050 if fieldNum <= 0 {
47051 return fmt.Errorf("proto: ProtoType: illegal tag %d (wire type %d)", fieldNum, wire)
47052 }
47053 switch fieldNum {
47054 case 1:
47055 if wireType != 2 {
47056 return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
47057 }
47058 var stringLen uint64
47059 for shift := uint(0); ; shift += 7 {
47060 if shift >= 64 {
47061 return ErrIntOverflowThetest
47062 }
47063 if iNdEx >= l {
47064 return io.ErrUnexpectedEOF
47065 }
47066 b := dAtA[iNdEx]
47067 iNdEx++
47068 stringLen |= uint64(b&0x7F) << shift
47069 if b < 0x80 {
47070 break
47071 }
47072 }
47073 intStringLen := int(stringLen)
47074 if intStringLen < 0 {
47075 return ErrInvalidLengthThetest
47076 }
47077 postIndex := iNdEx + intStringLen
47078 if postIndex < 0 {
47079 return ErrInvalidLengthThetest
47080 }
47081 if postIndex > l {
47082 return io.ErrUnexpectedEOF
47083 }
47084 s := string(dAtA[iNdEx:postIndex])
47085 m.Field2 = &s
47086 iNdEx = postIndex
47087 default:
47088 iNdEx = preIndex
47089 skippy, err := skipThetest(dAtA[iNdEx:])
47090 if err != nil {
47091 return err
47092 }
47093 if (skippy < 0) || (iNdEx+skippy) < 0 {
47094 return ErrInvalidLengthThetest
47095 }
47096 if (iNdEx + skippy) > l {
47097 return io.ErrUnexpectedEOF
47098 }
47099 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
47100 iNdEx += skippy
47101 }
47102 }
47103
47104 if iNdEx > l {
47105 return io.ErrUnexpectedEOF
47106 }
47107 return nil
47108 }
47109 func skipThetest(dAtA []byte) (n int, err error) {
47110 l := len(dAtA)
47111 iNdEx := 0
47112 depth := 0
47113 for iNdEx < l {
47114 var wire uint64
47115 for shift := uint(0); ; shift += 7 {
47116 if shift >= 64 {
47117 return 0, ErrIntOverflowThetest
47118 }
47119 if iNdEx >= l {
47120 return 0, io.ErrUnexpectedEOF
47121 }
47122 b := dAtA[iNdEx]
47123 iNdEx++
47124 wire |= (uint64(b) & 0x7F) << shift
47125 if b < 0x80 {
47126 break
47127 }
47128 }
47129 wireType := int(wire & 0x7)
47130 switch wireType {
47131 case 0:
47132 for shift := uint(0); ; shift += 7 {
47133 if shift >= 64 {
47134 return 0, ErrIntOverflowThetest
47135 }
47136 if iNdEx >= l {
47137 return 0, io.ErrUnexpectedEOF
47138 }
47139 iNdEx++
47140 if dAtA[iNdEx-1] < 0x80 {
47141 break
47142 }
47143 }
47144 case 1:
47145 iNdEx += 8
47146 case 2:
47147 var length int
47148 for shift := uint(0); ; shift += 7 {
47149 if shift >= 64 {
47150 return 0, ErrIntOverflowThetest
47151 }
47152 if iNdEx >= l {
47153 return 0, io.ErrUnexpectedEOF
47154 }
47155 b := dAtA[iNdEx]
47156 iNdEx++
47157 length |= (int(b) & 0x7F) << shift
47158 if b < 0x80 {
47159 break
47160 }
47161 }
47162 if length < 0 {
47163 return 0, ErrInvalidLengthThetest
47164 }
47165 iNdEx += length
47166 case 3:
47167 depth++
47168 case 4:
47169 if depth == 0 {
47170 return 0, ErrUnexpectedEndOfGroupThetest
47171 }
47172 depth--
47173 case 5:
47174 iNdEx += 4
47175 default:
47176 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
47177 }
47178 if iNdEx < 0 {
47179 return 0, ErrInvalidLengthThetest
47180 }
47181 if depth == 0 {
47182 return iNdEx, nil
47183 }
47184 }
47185 return 0, io.ErrUnexpectedEOF
47186 }
47187
47188 var (
47189 ErrInvalidLengthThetest = fmt.Errorf("proto: negative length found during unmarshaling")
47190 ErrIntOverflowThetest = fmt.Errorf("proto: integer overflow")
47191 ErrUnexpectedEndOfGroupThetest = fmt.Errorf("proto: unexpected end of group")
47192 )
47193
View as plain text