1
2
3
4 package test
5
6 import (
7 bytes "bytes"
8 compress_gzip "compress/gzip"
9 fmt "fmt"
10 _ "github.com/gogo/protobuf/gogoproto"
11 github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
12 proto "github.com/gogo/protobuf/proto"
13 github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
14 github_com_gogo_protobuf_test "github.com/gogo/protobuf/test"
15 github_com_gogo_protobuf_test_custom "github.com/gogo/protobuf/test/custom"
16 io "io"
17 io_ioutil "io/ioutil"
18 math "math"
19 math_bits "math/bits"
20 reflect "reflect"
21 strings "strings"
22 )
23
24
25 var _ = proto.Marshal
26 var _ = fmt.Errorf
27 var _ = math.Inf
28
29
30
31
32
33 const _ = proto.GoGoProtoPackageIsVersion3
34
35 type A struct {
36 Description string `protobuf:"bytes,1,opt,name=Description" json:"Description"`
37 Number int64 `protobuf:"varint,2,opt,name=Number" json:"Number"`
38 Id github_com_gogo_protobuf_test.Uuid `protobuf:"bytes,3,opt,name=Id,customtype=github.com/gogo/protobuf/test.Uuid" json:"Id"`
39 XXX_NoUnkeyedLiteral struct{} `json:"-"`
40 XXX_unrecognized []byte `json:"-"`
41 XXX_sizecache int32 `json:"-"`
42 }
43
44 func (m *A) Reset() { *m = A{} }
45 func (*A) ProtoMessage() {}
46 func (*A) Descriptor() ([]byte, []int) {
47 return fileDescriptor_15a1dc8d40dadaa6, []int{0}
48 }
49 func (m *A) XXX_Unmarshal(b []byte) error {
50 return m.Unmarshal(b)
51 }
52 func (m *A) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
53 if deterministic {
54 return xxx_messageInfo_A.Marshal(b, m, deterministic)
55 } else {
56 b = b[:cap(b)]
57 n, err := m.MarshalToSizedBuffer(b)
58 if err != nil {
59 return nil, err
60 }
61 return b[:n], nil
62 }
63 }
64 func (m *A) XXX_Merge(src proto.Message) {
65 xxx_messageInfo_A.Merge(m, src)
66 }
67 func (m *A) XXX_Size() int {
68 return m.Size()
69 }
70 func (m *A) XXX_DiscardUnknown() {
71 xxx_messageInfo_A.DiscardUnknown(m)
72 }
73
74 var xxx_messageInfo_A proto.InternalMessageInfo
75
76 type B struct {
77 A `protobuf:"bytes,1,opt,name=A,embedded=A" json:"A"`
78 G []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=G,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"G"`
79 XXX_NoUnkeyedLiteral struct{} `json:"-"`
80 XXX_unrecognized []byte `json:"-"`
81 XXX_sizecache int32 `json:"-"`
82 }
83
84 func (m *B) Reset() { *m = B{} }
85 func (*B) ProtoMessage() {}
86 func (*B) Descriptor() ([]byte, []int) {
87 return fileDescriptor_15a1dc8d40dadaa6, []int{1}
88 }
89 func (m *B) XXX_Unmarshal(b []byte) error {
90 return m.Unmarshal(b)
91 }
92 func (m *B) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
93 if deterministic {
94 return xxx_messageInfo_B.Marshal(b, m, deterministic)
95 } else {
96 b = b[:cap(b)]
97 n, err := m.MarshalToSizedBuffer(b)
98 if err != nil {
99 return nil, err
100 }
101 return b[:n], nil
102 }
103 }
104 func (m *B) XXX_Merge(src proto.Message) {
105 xxx_messageInfo_B.Merge(m, src)
106 }
107 func (m *B) XXX_Size() int {
108 return m.Size()
109 }
110 func (m *B) XXX_DiscardUnknown() {
111 xxx_messageInfo_B.DiscardUnknown(m)
112 }
113
114 var xxx_messageInfo_B proto.InternalMessageInfo
115
116 type C struct {
117 MySize *int64 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
118 XXX_NoUnkeyedLiteral struct{} `json:"-"`
119 XXX_unrecognized []byte `json:"-"`
120 XXX_sizecache int32 `json:"-"`
121 }
122
123 func (m *C) Reset() { *m = C{} }
124 func (*C) ProtoMessage() {}
125 func (*C) Descriptor() ([]byte, []int) {
126 return fileDescriptor_15a1dc8d40dadaa6, []int{2}
127 }
128 func (m *C) XXX_Unmarshal(b []byte) error {
129 return m.Unmarshal(b)
130 }
131 func (m *C) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
132 if deterministic {
133 return xxx_messageInfo_C.Marshal(b, m, deterministic)
134 } else {
135 b = b[:cap(b)]
136 n, err := m.MarshalToSizedBuffer(b)
137 if err != nil {
138 return nil, err
139 }
140 return b[:n], nil
141 }
142 }
143 func (m *C) XXX_Merge(src proto.Message) {
144 xxx_messageInfo_C.Merge(m, src)
145 }
146 func (m *C) XXX_Size() int {
147 return m.Size()
148 }
149 func (m *C) XXX_DiscardUnknown() {
150 xxx_messageInfo_C.DiscardUnknown(m)
151 }
152
153 var xxx_messageInfo_C proto.InternalMessageInfo
154
155 func (m *C) GetMySize() int64 {
156 if m != nil && m.MySize != nil {
157 return *m.MySize
158 }
159 return 0
160 }
161
162 type U struct {
163 A *A `protobuf:"bytes,1,opt,name=A" json:"A,omitempty"`
164 B *B `protobuf:"bytes,2,opt,name=B" json:"B,omitempty"`
165 XXX_NoUnkeyedLiteral struct{} `json:"-"`
166 XXX_unrecognized []byte `json:"-"`
167 XXX_sizecache int32 `json:"-"`
168 }
169
170 func (m *U) Reset() { *m = U{} }
171 func (*U) ProtoMessage() {}
172 func (*U) Descriptor() ([]byte, []int) {
173 return fileDescriptor_15a1dc8d40dadaa6, []int{3}
174 }
175 func (m *U) XXX_Unmarshal(b []byte) error {
176 return m.Unmarshal(b)
177 }
178 func (m *U) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
179 if deterministic {
180 return xxx_messageInfo_U.Marshal(b, m, deterministic)
181 } else {
182 b = b[:cap(b)]
183 n, err := m.MarshalToSizedBuffer(b)
184 if err != nil {
185 return nil, err
186 }
187 return b[:n], nil
188 }
189 }
190 func (m *U) XXX_Merge(src proto.Message) {
191 xxx_messageInfo_U.Merge(m, src)
192 }
193 func (m *U) XXX_Size() int {
194 return m.Size()
195 }
196 func (m *U) XXX_DiscardUnknown() {
197 xxx_messageInfo_U.DiscardUnknown(m)
198 }
199
200 var xxx_messageInfo_U proto.InternalMessageInfo
201
202 func (m *U) GetA() *A {
203 if m != nil {
204 return m.A
205 }
206 return nil
207 }
208
209 func (m *U) GetB() *B {
210 if m != nil {
211 return m.B
212 }
213 return nil
214 }
215
216 type E struct {
217 XXX_NoUnkeyedLiteral struct{} `json:"-"`
218 XXX_extensions []byte `protobuf:"bytes,0,opt" json:"-"`
219 XXX_unrecognized []byte `json:"-"`
220 XXX_sizecache int32 `json:"-"`
221 }
222
223 func (m *E) Reset() { *m = E{} }
224 func (*E) ProtoMessage() {}
225 func (*E) Descriptor() ([]byte, []int) {
226 return fileDescriptor_15a1dc8d40dadaa6, []int{4}
227 }
228
229 var extRange_E = []proto.ExtensionRange{
230 {Start: 1, End: 536870911},
231 }
232
233 func (*E) ExtensionRangeArray() []proto.ExtensionRange {
234 return extRange_E
235 }
236
237 func (m *E) GetExtensions() *[]byte {
238 if m.XXX_extensions == nil {
239 m.XXX_extensions = make([]byte, 0)
240 }
241 return &m.XXX_extensions
242 }
243 func (m *E) XXX_Unmarshal(b []byte) error {
244 return m.Unmarshal(b)
245 }
246 func (m *E) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
247 if deterministic {
248 return xxx_messageInfo_E.Marshal(b, m, deterministic)
249 } else {
250 b = b[:cap(b)]
251 n, err := m.MarshalToSizedBuffer(b)
252 if err != nil {
253 return nil, err
254 }
255 return b[:n], nil
256 }
257 }
258 func (m *E) XXX_Merge(src proto.Message) {
259 xxx_messageInfo_E.Merge(m, src)
260 }
261 func (m *E) XXX_Size() int {
262 return m.Size()
263 }
264 func (m *E) XXX_DiscardUnknown() {
265 xxx_messageInfo_E.DiscardUnknown(m)
266 }
267
268 var xxx_messageInfo_E proto.InternalMessageInfo
269
270 type R struct {
271 Recognized *uint32 `protobuf:"varint,1,opt,name=recognized" json:"recognized,omitempty"`
272 XXX_NoUnkeyedLiteral struct{} `json:"-"`
273 XXX_sizecache int32 `json:"-"`
274 }
275
276 func (m *R) Reset() { *m = R{} }
277 func (*R) ProtoMessage() {}
278 func (*R) Descriptor() ([]byte, []int) {
279 return fileDescriptor_15a1dc8d40dadaa6, []int{5}
280 }
281 func (m *R) XXX_Unmarshal(b []byte) error {
282 return m.Unmarshal(b)
283 }
284 func (m *R) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
285 if deterministic {
286 return xxx_messageInfo_R.Marshal(b, m, deterministic)
287 } else {
288 b = b[:cap(b)]
289 n, err := m.MarshalToSizedBuffer(b)
290 if err != nil {
291 return nil, err
292 }
293 return b[:n], nil
294 }
295 }
296 func (m *R) XXX_Merge(src proto.Message) {
297 xxx_messageInfo_R.Merge(m, src)
298 }
299 func (m *R) XXX_Size() int {
300 return m.Size()
301 }
302 func (m *R) XXX_DiscardUnknown() {
303 xxx_messageInfo_R.DiscardUnknown(m)
304 }
305
306 var xxx_messageInfo_R proto.InternalMessageInfo
307
308 func (m *R) GetRecognized() uint32 {
309 if m != nil && m.Recognized != nil {
310 return *m.Recognized
311 }
312 return 0
313 }
314
315 type CastType struct {
316 Int32 *int32 `protobuf:"varint,1,opt,name=Int32,casttype=int32" json:"Int32,omitempty"`
317 XXX_NoUnkeyedLiteral struct{} `json:"-"`
318 XXX_unrecognized []byte `json:"-"`
319 XXX_sizecache int32 `json:"-"`
320 }
321
322 func (m *CastType) Reset() { *m = CastType{} }
323 func (*CastType) ProtoMessage() {}
324 func (*CastType) Descriptor() ([]byte, []int) {
325 return fileDescriptor_15a1dc8d40dadaa6, []int{6}
326 }
327 func (m *CastType) XXX_Unmarshal(b []byte) error {
328 return m.Unmarshal(b)
329 }
330 func (m *CastType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
331 if deterministic {
332 return xxx_messageInfo_CastType.Marshal(b, m, deterministic)
333 } else {
334 b = b[:cap(b)]
335 n, err := m.MarshalToSizedBuffer(b)
336 if err != nil {
337 return nil, err
338 }
339 return b[:n], nil
340 }
341 }
342 func (m *CastType) XXX_Merge(src proto.Message) {
343 xxx_messageInfo_CastType.Merge(m, src)
344 }
345 func (m *CastType) XXX_Size() int {
346 return m.Size()
347 }
348 func (m *CastType) XXX_DiscardUnknown() {
349 xxx_messageInfo_CastType.DiscardUnknown(m)
350 }
351
352 var xxx_messageInfo_CastType proto.InternalMessageInfo
353
354 func (m *CastType) GetInt32() int32 {
355 if m != nil && m.Int32 != nil {
356 return *m.Int32
357 }
358 return 0
359 }
360
361 func init() {
362 proto.RegisterType((*A)(nil), "test.A")
363 proto.RegisterType((*B)(nil), "test.B")
364 proto.RegisterType((*C)(nil), "test.C")
365 proto.RegisterType((*U)(nil), "test.U")
366 proto.RegisterType((*E)(nil), "test.E")
367 proto.RegisterType((*R)(nil), "test.R")
368 proto.RegisterType((*CastType)(nil), "test.CastType")
369 }
370
371 func init() { proto.RegisterFile("example.proto", fileDescriptor_15a1dc8d40dadaa6) }
372
373 var fileDescriptor_15a1dc8d40dadaa6 = []byte{
374
375 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0x41, 0x6b, 0x13, 0x41,
376 0x14, 0xc7, 0xf3, 0x36, 0xdb, 0xba, 0x7d, 0x6d, 0x41, 0x46, 0x0a, 0x41, 0x64, 0x26, 0xac, 0x20,
377 0xb1, 0xd6, 0x0d, 0x46, 0x41, 0xd9, 0x5b, 0xa6, 0x4a, 0xc9, 0x41, 0x0f, 0xa3, 0xf9, 0x00, 0x4d,
378 0x32, 0xc6, 0x01, 0xb3, 0x13, 0xb2, 0xb3, 0x60, 0x73, 0xda, 0xa3, 0x37, 0xbf, 0x42, 0xbd, 0xf5,
379 0x23, 0x78, 0xf4, 0x98, 0x63, 0x8e, 0xe2, 0x61, 0x69, 0xe6, 0x13, 0xf4, 0x28, 0x9e, 0x64, 0xa6,
380 0x41, 0x02, 0x62, 0x6f, 0xfb, 0x7e, 0xef, 0xed, 0xff, 0xff, 0x63, 0x70, 0x5f, 0x7e, 0x3a, 0x9d,
381 0x4c, 0x3f, 0xca, 0x64, 0x3a, 0xd3, 0x46, 0x93, 0xd0, 0xc8, 0xdc, 0xdc, 0x7d, 0x3c, 0x56, 0xe6,
382 0x43, 0x31, 0x48, 0x86, 0x7a, 0xd2, 0x1e, 0xeb, 0xb1, 0x6e, 0xfb, 0xe5, 0xa0, 0x78, 0xef, 0x27,
383 0x3f, 0xf8, 0xaf, 0xeb, 0x9f, 0xe2, 0x2f, 0x80, 0xd0, 0x25, 0x0f, 0x70, 0xf7, 0xa5, 0xcc, 0x87,
384 0x33, 0x35, 0x35, 0x4a, 0x67, 0x0d, 0x68, 0x42, 0x6b, 0x87, 0x87, 0x8b, 0x8a, 0xd5, 0xc4, 0xe6,
385 0x82, 0xdc, 0xc3, 0xed, 0x37, 0xc5, 0x64, 0x20, 0x67, 0x8d, 0xa0, 0x09, 0xad, 0xfa, 0xfa, 0x64,
386 0xcd, 0x48, 0x8a, 0x41, 0x6f, 0xd4, 0xa8, 0x37, 0xa1, 0xb5, 0xc7, 0x0f, 0xdd, 0xe6, 0x67, 0xc5,
387 0xe2, 0xff, 0xea, 0x38, 0xdb, 0xa4, 0x5f, 0xa8, 0x91, 0x08, 0x7a, 0xa3, 0x34, 0xfa, 0x7c, 0xce,
388 0x6a, 0x17, 0xe7, 0x0c, 0xe2, 0x0c, 0x81, 0x13, 0x86, 0xd0, 0xf5, 0x1a, 0xbb, 0x9d, 0x5b, 0x89,
389 0xbf, 0xec, 0xf2, 0xc8, 0x45, 0x2e, 0x2b, 0x06, 0x02, 0xba, 0x84, 0x23, 0x9c, 0x34, 0x82, 0x66,
390 0xbd, 0xb5, 0xc7, 0x9f, 0xad, 0xab, 0x8e, 0x6e, 0xac, 0x6a, 0x0f, 0x8b, 0xdc, 0xe8, 0x49, 0xd2,
391 0x57, 0x99, 0x79, 0xd2, 0x79, 0x21, 0xe0, 0x24, 0x0d, 0xaf, 0x5c, 0xdf, 0x7d, 0x84, 0x63, 0x42,
392 0x31, 0xcc, 0xd5, 0x5c, 0xfa, 0xca, 0x3a, 0x47, 0x5b, 0xb1, 0xed, 0xd7, 0x67, 0x6f, 0xd5, 0x5c,
393 0x0a, 0xcf, 0xe3, 0xe7, 0x08, 0x7d, 0x72, 0xf0, 0xaf, 0x94, 0x53, 0x39, 0x40, 0xe0, 0xfe, 0x3d,
394 0xfe, 0x62, 0x2e, 0x80, 0xa7, 0xe1, 0xc2, 0xa5, 0xdf, 0x41, 0x78, 0x75, 0x18, 0x45, 0x70, 0xbb,
395 0x2c, 0xcb, 0x32, 0x48, 0xc3, 0xc5, 0x57, 0x56, 0x8b, 0x1f, 0x22, 0x08, 0x42, 0x11, 0x67, 0x72,
396 0xa8, 0xc7, 0x99, 0x9a, 0xcb, 0x91, 0x8f, 0xdd, 0x17, 0x1b, 0x24, 0x0d, 0x97, 0xee, 0xf4, 0x11,
397 0x46, 0xc7, 0xa7, 0xb9, 0x79, 0x77, 0x36, 0x95, 0x84, 0xe1, 0x56, 0x2f, 0x33, 0x4f, 0x3b, 0x6b,
398 0xcb, 0x9d, 0xdf, 0x15, 0xdb, 0x52, 0x0e, 0x88, 0x6b, 0xce, 0x8f, 0x7e, 0xac, 0x68, 0xed, 0x72,
399 0x45, 0xe1, 0x6a, 0x45, 0xe1, 0xd7, 0x8a, 0x42, 0x69, 0x29, 0x5c, 0x58, 0x0a, 0xdf, 0x2c, 0x85,
400 0xef, 0x96, 0xc2, 0xc2, 0x52, 0x58, 0x5a, 0x0a, 0x97, 0x96, 0xc2, 0x9f, 0x00, 0x00, 0x00, 0xff,
401 0xff, 0x71, 0x9d, 0xd3, 0x01, 0x3f, 0x02, 0x00, 0x00,
402 }
403
404 func (this *B) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
405 return ExampleDescription()
406 }
407 func ExampleDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
408 d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
409 var gzipped = []byte{
410
411 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x59, 0x70, 0x1c, 0xd7,
412 0x75, 0x65, 0xcf, 0x02, 0xcc, 0xdc, 0x19, 0x0c, 0x1a, 0x0f, 0x20, 0x39, 0x84, 0x24, 0x80, 0x1c,
413 0x6d, 0x20, 0x29, 0x81, 0x0e, 0xc5, 0x4d, 0xcd, 0xd8, 0xca, 0xcc, 0x60, 0x08, 0x8f, 0x82, 0xcd,
414 0x0d, 0xc0, 0x5a, 0x5c, 0xa9, 0xae, 0x46, 0xcf, 0xc3, 0xa0, 0xc9, 0x9e, 0xee, 0x76, 0x77, 0x0f,
415 0x49, 0xb0, 0xf2, 0xc1, 0x94, 0xb2, 0xb9, 0xb2, 0x38, 0x5b, 0x55, 0x6c, 0x45, 0x56, 0x24, 0xa7,
416 0x62, 0x29, 0xce, 0xea, 0x2c, 0x8e, 0xed, 0x7c, 0xc4, 0x3f, 0x4e, 0xf8, 0x95, 0x92, 0xff, 0x52,
417 0xa9, 0x14, 0x4b, 0x62, 0x54, 0x95, 0x4d, 0x49, 0x94, 0x84, 0x1f, 0xae, 0xe8, 0x27, 0xf5, 0xb6,
418 0x9e, 0x9e, 0x05, 0xe8, 0x81, 0xab, 0x24, 0x7d, 0x01, 0x7d, 0xdf, 0x3d, 0xa7, 0xef, 0xbb, 0xef,
419 0xbe, 0x7b, 0xef, 0x7b, 0x3d, 0x70, 0x47, 0x81, 0xe3, 0x4d, 0xc7, 0x69, 0x5a, 0xf8, 0x8c, 0xeb,
420 0x39, 0x81, 0xb3, 0xd5, 0xde, 0x3e, 0xd3, 0xc0, 0xbe, 0xe1, 0x99, 0x6e, 0xe0, 0x78, 0xf3, 0x54,
421 0x86, 0xc6, 0x99, 0xc6, 0xbc, 0xd0, 0x28, 0x2d, 0xc3, 0xc4, 0x15, 0xd3, 0xc2, 0x0b, 0xa1, 0xe2,
422 0x3a, 0x0e, 0xd0, 0x25, 0x48, 0x6d, 0x9b, 0x16, 0x2e, 0x4a, 0xc7, 0x93, 0x73, 0xb9, 0xb3, 0x8f,
423 0xcc, 0xf7, 0x80, 0xe6, 0xbb, 0x11, 0x6b, 0x44, 0xac, 0x52, 0x44, 0xe9, 0xdd, 0x14, 0x4c, 0x0e,
424 0x18, 0x45, 0x08, 0x52, 0xb6, 0xde, 0x22, 0x8c, 0xd2, 0x5c, 0x56, 0xa5, 0xff, 0xa3, 0x22, 0x8c,
425 0xba, 0xba, 0x71, 0x4d, 0x6f, 0xe2, 0x62, 0x82, 0x8a, 0xc5, 0x23, 0x9a, 0x01, 0x68, 0x60, 0x17,
426 0xdb, 0x0d, 0x6c, 0x1b, 0xbb, 0xc5, 0xe4, 0xf1, 0xe4, 0x5c, 0x56, 0x8d, 0x48, 0xd0, 0x69, 0x98,
427 0x70, 0xdb, 0x5b, 0x96, 0x69, 0x68, 0x11, 0x35, 0x38, 0x9e, 0x9c, 0x4b, 0xab, 0x32, 0x1b, 0x58,
428 0xe8, 0x28, 0x3f, 0x0e, 0xe3, 0x37, 0xb0, 0x7e, 0x2d, 0xaa, 0x9a, 0xa3, 0xaa, 0x05, 0x22, 0x8e,
429 0x28, 0x56, 0x21, 0xdf, 0xc2, 0xbe, 0xaf, 0x37, 0xb1, 0x16, 0xec, 0xba, 0xb8, 0x98, 0xa2, 0xb3,
430 0x3f, 0xde, 0x37, 0xfb, 0xde, 0x99, 0xe7, 0x38, 0x6a, 0x63, 0xd7, 0xc5, 0xa8, 0x0c, 0x59, 0x6c,
431 0xb7, 0x5b, 0x8c, 0x21, 0xbd, 0x87, 0xff, 0x6a, 0x76, 0xbb, 0xd5, 0xcb, 0x92, 0x21, 0x30, 0x4e,
432 0x31, 0xea, 0x63, 0xef, 0xba, 0x69, 0xe0, 0xe2, 0x08, 0x25, 0x78, 0xbc, 0x8f, 0x60, 0x9d, 0x8d,
433 0xf7, 0x72, 0x08, 0x1c, 0xaa, 0x42, 0x16, 0xdf, 0x0c, 0xb0, 0xed, 0x9b, 0x8e, 0x5d, 0x1c, 0xa5,
434 0x24, 0x8f, 0x0e, 0x58, 0x45, 0x6c, 0x35, 0x7a, 0x29, 0x3a, 0x38, 0x74, 0x01, 0x46, 0x1d, 0x37,
435 0x30, 0x1d, 0xdb, 0x2f, 0x66, 0x8e, 0x4b, 0x73, 0xb9, 0xb3, 0x0f, 0x0e, 0x0c, 0x84, 0x55, 0xa6,
436 0xa3, 0x0a, 0x65, 0x54, 0x07, 0xd9, 0x77, 0xda, 0x9e, 0x81, 0x35, 0xc3, 0x69, 0x60, 0xcd, 0xb4,
437 0xb7, 0x9d, 0x62, 0x96, 0x12, 0xcc, 0xf6, 0x4f, 0x84, 0x2a, 0x56, 0x9d, 0x06, 0xae, 0xdb, 0xdb,
438 0x8e, 0x5a, 0xf0, 0xbb, 0x9e, 0xd1, 0x11, 0x18, 0xf1, 0x77, 0xed, 0x40, 0xbf, 0x59, 0xcc, 0xd3,
439 0x08, 0xe1, 0x4f, 0xa5, 0x6f, 0x8f, 0xc0, 0xf8, 0x30, 0x21, 0x76, 0x19, 0xd2, 0xdb, 0x64, 0x96,
440 0xc5, 0xc4, 0x41, 0x7c, 0xc0, 0x30, 0xdd, 0x4e, 0x1c, 0xf9, 0x21, 0x9d, 0x58, 0x86, 0x9c, 0x8d,
441 0xfd, 0x00, 0x37, 0x58, 0x44, 0x24, 0x87, 0x8c, 0x29, 0x60, 0xa0, 0xfe, 0x90, 0x4a, 0xfd, 0x50,
442 0x21, 0xf5, 0x3c, 0x8c, 0x87, 0x26, 0x69, 0x9e, 0x6e, 0x37, 0x45, 0x6c, 0x9e, 0x89, 0xb3, 0x64,
443 0xbe, 0x26, 0x70, 0x2a, 0x81, 0xa9, 0x05, 0xdc, 0xf5, 0x8c, 0x16, 0x00, 0x1c, 0x1b, 0x3b, 0xdb,
444 0x5a, 0x03, 0x1b, 0x56, 0x31, 0xb3, 0x87, 0x97, 0x56, 0x89, 0x4a, 0x9f, 0x97, 0x1c, 0x26, 0x35,
445 0x2c, 0xf4, 0x74, 0x27, 0xd4, 0x46, 0xf7, 0x88, 0x94, 0x65, 0xb6, 0xc9, 0xfa, 0xa2, 0x6d, 0x13,
446 0x0a, 0x1e, 0x26, 0x71, 0x8f, 0x1b, 0x7c, 0x66, 0x59, 0x6a, 0xc4, 0x7c, 0xec, 0xcc, 0x54, 0x0e,
447 0x63, 0x13, 0x1b, 0xf3, 0xa2, 0x8f, 0xe8, 0x61, 0x08, 0x05, 0x1a, 0x0d, 0x2b, 0xa0, 0x59, 0x28,
448 0x2f, 0x84, 0x2b, 0x7a, 0x0b, 0x4f, 0xdf, 0x82, 0x42, 0xb7, 0x7b, 0xd0, 0x14, 0xa4, 0xfd, 0x40,
449 0xf7, 0x02, 0x1a, 0x85, 0x69, 0x95, 0x3d, 0x20, 0x19, 0x92, 0xd8, 0x6e, 0xd0, 0x2c, 0x97, 0x56,
450 0xc9, 0xbf, 0xe8, 0xc7, 0x3a, 0x13, 0x4e, 0xd2, 0x09, 0x3f, 0xd6, 0xbf, 0xa2, 0x5d, 0xcc, 0xbd,
451 0xf3, 0x9e, 0xbe, 0x08, 0x63, 0x5d, 0x13, 0x18, 0xf6, 0xd5, 0xa5, 0x9f, 0x84, 0xc3, 0x03, 0xa9,
452 0xd1, 0xf3, 0x30, 0xd5, 0xb6, 0x4d, 0x3b, 0xc0, 0x9e, 0xeb, 0x61, 0x12, 0xb1, 0xec, 0x55, 0xc5,
453 0x7f, 0x1e, 0xdd, 0x23, 0xe6, 0x36, 0xa3, 0xda, 0x8c, 0x45, 0x9d, 0x6c, 0xf7, 0x0b, 0x4f, 0x65,
454 0x33, 0xff, 0x32, 0x2a, 0xdf, 0xbe, 0x7d, 0xfb, 0x76, 0xa2, 0xf4, 0xa5, 0x11, 0x98, 0x1a, 0xb4,
455 0x67, 0x06, 0x6e, 0xdf, 0x23, 0x30, 0x62, 0xb7, 0x5b, 0x5b, 0xd8, 0xa3, 0x4e, 0x4a, 0xab, 0xfc,
456 0x09, 0x95, 0x21, 0x6d, 0xe9, 0x5b, 0xd8, 0x2a, 0xa6, 0x8e, 0x4b, 0x73, 0x85, 0xb3, 0xa7, 0x87,
457 0xda, 0x95, 0xf3, 0x4b, 0x04, 0xa2, 0x32, 0x24, 0xfa, 0x14, 0xa4, 0x78, 0x8a, 0x26, 0x0c, 0xa7,
458 0x86, 0x63, 0x20, 0x7b, 0x49, 0xa5, 0x38, 0xf4, 0x00, 0x64, 0xc9, 0x5f, 0x16, 0x1b, 0x23, 0xd4,
459 0xe6, 0x0c, 0x11, 0x90, 0xb8, 0x40, 0xd3, 0x90, 0xa1, 0xdb, 0xa4, 0x81, 0x45, 0x69, 0x0b, 0x9f,
460 0x49, 0x60, 0x35, 0xf0, 0xb6, 0xde, 0xb6, 0x02, 0xed, 0xba, 0x6e, 0xb5, 0x31, 0x0d, 0xf8, 0xac,
461 0x9a, 0xe7, 0xc2, 0xcf, 0x12, 0x19, 0x9a, 0x85, 0x1c, 0xdb, 0x55, 0xa6, 0xdd, 0xc0, 0x37, 0x69,
462 0xf6, 0x4c, 0xab, 0x6c, 0xa3, 0xd5, 0x89, 0x84, 0xbc, 0xfe, 0xaa, 0xef, 0xd8, 0x22, 0x34, 0xe9,
463 0x2b, 0x88, 0x80, 0xbe, 0xfe, 0x62, 0x6f, 0xe2, 0x7e, 0x68, 0xf0, 0xf4, 0x7a, 0x63, 0xaa, 0xf4,
464 0xcd, 0x04, 0xa4, 0x68, 0xbe, 0x18, 0x87, 0xdc, 0xc6, 0x0b, 0x6b, 0x35, 0x6d, 0x61, 0x75, 0xb3,
465 0xb2, 0x54, 0x93, 0x25, 0x54, 0x00, 0xa0, 0x82, 0x2b, 0x4b, 0xab, 0xe5, 0x0d, 0x39, 0x11, 0x3e,
466 0xd7, 0x57, 0x36, 0x2e, 0x9c, 0x93, 0x93, 0x21, 0x60, 0x93, 0x09, 0x52, 0x51, 0x85, 0xa7, 0xce,
467 0xca, 0x69, 0x24, 0x43, 0x9e, 0x11, 0xd4, 0x9f, 0xaf, 0x2d, 0x5c, 0x38, 0x27, 0x8f, 0x74, 0x4b,
468 0x9e, 0x3a, 0x2b, 0x8f, 0xa2, 0x31, 0xc8, 0x52, 0x49, 0x65, 0x75, 0x75, 0x49, 0xce, 0x84, 0x9c,
469 0xeb, 0x1b, 0x6a, 0x7d, 0x65, 0x51, 0xce, 0x86, 0x9c, 0x8b, 0xea, 0xea, 0xe6, 0x9a, 0x0c, 0x21,
470 0xc3, 0x72, 0x6d, 0x7d, 0xbd, 0xbc, 0x58, 0x93, 0x73, 0xa1, 0x46, 0xe5, 0x85, 0x8d, 0xda, 0xba,
471 0x9c, 0xef, 0x32, 0xeb, 0xa9, 0xb3, 0xf2, 0x58, 0xf8, 0x8a, 0xda, 0xca, 0xe6, 0xb2, 0x5c, 0x40,
472 0x13, 0x30, 0xc6, 0x5e, 0x21, 0x8c, 0x18, 0xef, 0x11, 0x5d, 0x38, 0x27, 0xcb, 0x1d, 0x43, 0x18,
473 0xcb, 0x44, 0x97, 0xe0, 0xc2, 0x39, 0x19, 0x95, 0xaa, 0x90, 0xa6, 0xd1, 0x85, 0x10, 0x14, 0x96,
474 0xca, 0x95, 0xda, 0x92, 0xb6, 0xba, 0xb6, 0x51, 0x5f, 0x5d, 0x29, 0x2f, 0xc9, 0x52, 0x47, 0xa6,
475 0xd6, 0x3e, 0xb3, 0x59, 0x57, 0x6b, 0x0b, 0x72, 0x22, 0x2a, 0x5b, 0xab, 0x95, 0x37, 0x6a, 0x0b,
476 0x72, 0xb2, 0x64, 0xc0, 0xd4, 0xa0, 0x3c, 0x39, 0x70, 0x67, 0x44, 0x96, 0x38, 0xb1, 0xc7, 0x12,
477 0x53, 0xae, 0xbe, 0x25, 0xfe, 0xa7, 0x04, 0x4c, 0x0e, 0xa8, 0x15, 0x03, 0x5f, 0xf2, 0x0c, 0xa4,
478 0x59, 0x88, 0xb2, 0xea, 0x79, 0x72, 0x60, 0xd1, 0xa1, 0x01, 0xdb, 0x57, 0x41, 0x29, 0x2e, 0xda,
479 0x41, 0x24, 0xf7, 0xe8, 0x20, 0x08, 0x45, 0x5f, 0x4e, 0xff, 0x89, 0xbe, 0x9c, 0xce, 0xca, 0xde,
480 0x85, 0x61, 0xca, 0x1e, 0x95, 0x1d, 0x2c, 0xb7, 0xa7, 0x07, 0xe4, 0xf6, 0xcb, 0x30, 0xd1, 0x47,
481 0x34, 0x74, 0x8e, 0x7d, 0x49, 0x82, 0xe2, 0x5e, 0xce, 0x89, 0xc9, 0x74, 0x89, 0xae, 0x4c, 0x77,
482 0xb9, 0xd7, 0x83, 0x27, 0xf6, 0x5e, 0x84, 0xbe, 0xb5, 0x7e, 0x43, 0x82, 0x23, 0x83, 0x3b, 0xc5,
483 0x81, 0x36, 0x7c, 0x0a, 0x46, 0x5a, 0x38, 0xd8, 0x71, 0x44, 0xb7, 0xf4, 0xd8, 0x80, 0x1a, 0x4c,
484 0x86, 0x7b, 0x17, 0x9b, 0xa3, 0xa2, 0x45, 0x3c, 0xb9, 0x57, 0xbb, 0xc7, 0xac, 0xe9, 0xb3, 0xf4,
485 0x0b, 0x09, 0x38, 0x3c, 0x90, 0x7c, 0xa0, 0xa1, 0x0f, 0x01, 0x98, 0xb6, 0xdb, 0x0e, 0x58, 0x47,
486 0xc4, 0x12, 0x6c, 0x96, 0x4a, 0x68, 0xf2, 0x22, 0xc9, 0xb3, 0x1d, 0x84, 0xe3, 0x49, 0x3a, 0x0e,
487 0x4c, 0x44, 0x15, 0x2e, 0x75, 0x0c, 0x4d, 0x51, 0x43, 0x67, 0xf6, 0x98, 0x69, 0x5f, 0x60, 0x7e,
488 0x02, 0x64, 0xc3, 0x32, 0xb1, 0x1d, 0x68, 0x7e, 0xe0, 0x61, 0xbd, 0x65, 0xda, 0x4d, 0x5a, 0x41,
489 0x32, 0x4a, 0x7a, 0x5b, 0xb7, 0x7c, 0xac, 0x8e, 0xb3, 0xe1, 0x75, 0x31, 0x4a, 0x10, 0x34, 0x80,
490 0xbc, 0x08, 0x62, 0xa4, 0x0b, 0xc1, 0x86, 0x43, 0x44, 0xe9, 0x17, 0xb3, 0x90, 0x8b, 0xf4, 0xd5,
491 0xe8, 0x04, 0xe4, 0xaf, 0xea, 0xd7, 0x75, 0x4d, 0x9c, 0x95, 0x98, 0x27, 0x72, 0x44, 0xb6, 0xc6,
492 0xcf, 0x4b, 0x9f, 0x80, 0x29, 0xaa, 0xe2, 0xb4, 0x03, 0xec, 0x69, 0x86, 0xa5, 0xfb, 0x3e, 0x75,
493 0x5a, 0x86, 0xaa, 0x22, 0x32, 0xb6, 0x4a, 0x86, 0xaa, 0x62, 0x04, 0x9d, 0x87, 0x49, 0x8a, 0x68,
494 0xb5, 0xad, 0xc0, 0x74, 0x2d, 0xac, 0x91, 0xd3, 0x9b, 0x4f, 0x2b, 0x49, 0x68, 0xd9, 0x04, 0xd1,
495 0x58, 0xe6, 0x0a, 0xc4, 0x22, 0x1f, 0x2d, 0xc0, 0x43, 0x14, 0xd6, 0xc4, 0x36, 0xf6, 0xf4, 0x00,
496 0x6b, 0xf8, 0xf3, 0x6d, 0xdd, 0xf2, 0x35, 0xdd, 0x6e, 0x68, 0x3b, 0xba, 0xbf, 0x53, 0x9c, 0x22,
497 0x04, 0x95, 0x44, 0x51, 0x52, 0x8f, 0x11, 0xc5, 0x45, 0xae, 0x57, 0xa3, 0x6a, 0x65, 0xbb, 0xf1,
498 0x69, 0xdd, 0xdf, 0x41, 0x0a, 0x1c, 0xa1, 0x2c, 0x7e, 0xe0, 0x99, 0x76, 0x53, 0x33, 0x76, 0xb0,
499 0x71, 0x4d, 0x6b, 0x07, 0xdb, 0x97, 0x8a, 0x0f, 0x44, 0xdf, 0x4f, 0x2d, 0x5c, 0xa7, 0x3a, 0x55,
500 0xa2, 0xb2, 0x19, 0x6c, 0x5f, 0x42, 0xeb, 0x90, 0x27, 0x8b, 0xd1, 0x32, 0x6f, 0x61, 0x6d, 0xdb,
501 0xf1, 0x68, 0x69, 0x2c, 0x0c, 0x48, 0x4d, 0x11, 0x0f, 0xce, 0xaf, 0x72, 0xc0, 0xb2, 0xd3, 0xc0,
502 0x4a, 0x7a, 0x7d, 0xad, 0x56, 0x5b, 0x50, 0x73, 0x82, 0xe5, 0x8a, 0xe3, 0x91, 0x80, 0x6a, 0x3a,
503 0xa1, 0x83, 0x73, 0x2c, 0xa0, 0x9a, 0x8e, 0x70, 0xef, 0x79, 0x98, 0x34, 0x0c, 0x36, 0x67, 0xd3,
504 0xd0, 0xf8, 0x19, 0xcb, 0x2f, 0xca, 0x5d, 0xce, 0x32, 0x8c, 0x45, 0xa6, 0xc0, 0x63, 0xdc, 0x47,
505 0x4f, 0xc3, 0xe1, 0x8e, 0xb3, 0xa2, 0xc0, 0x89, 0xbe, 0x59, 0xf6, 0x42, 0xcf, 0xc3, 0xa4, 0xbb,
506 0xdb, 0x0f, 0x44, 0x5d, 0x6f, 0x74, 0x77, 0x7b, 0x61, 0x17, 0x61, 0xca, 0xdd, 0x71, 0xfb, 0x71,
507 0xa7, 0xa2, 0x38, 0xe4, 0xee, 0xb8, 0xbd, 0xc0, 0x47, 0xe9, 0x81, 0xdb, 0xc3, 0x86, 0x1e, 0xe0,
508 0x46, 0xf1, 0x68, 0x54, 0x3d, 0x32, 0x80, 0xce, 0x80, 0x6c, 0x18, 0x1a, 0xb6, 0xf5, 0x2d, 0x0b,
509 0x6b, 0xba, 0x87, 0x6d, 0xdd, 0x2f, 0xce, 0x46, 0x95, 0x0b, 0x86, 0x51, 0xa3, 0xa3, 0x65, 0x3a,
510 0x88, 0x4e, 0xc1, 0x84, 0xb3, 0x75, 0xd5, 0x60, 0x21, 0xa9, 0xb9, 0x1e, 0xde, 0x36, 0x6f, 0x16,
511 0x1f, 0xa1, 0xfe, 0x1d, 0x27, 0x03, 0x34, 0x20, 0xd7, 0xa8, 0x18, 0x9d, 0x04, 0xd9, 0xf0, 0x77,
512 0x74, 0xcf, 0xa5, 0x39, 0xd9, 0x77, 0x75, 0x03, 0x17, 0x1f, 0x65, 0xaa, 0x4c, 0xbe, 0x22, 0xc4,
513 0x64, 0x4b, 0xf8, 0x37, 0xcc, 0xed, 0x40, 0x30, 0x3e, 0xce, 0xb6, 0x04, 0x95, 0x71, 0xb6, 0x39,
514 0x90, 0x89, 0x2b, 0xba, 0x5e, 0x3c, 0x47, 0xd5, 0x0a, 0xee, 0x8e, 0x1b, 0x7d, 0xef, 0xc3, 0x30,
515 0x46, 0x34, 0x3b, 0x2f, 0x3d, 0xc9, 0x1a, 0x32, 0x77, 0x27, 0xf2, 0xc6, 0x73, 0x70, 0x84, 0x28,
516 0xb5, 0x70, 0xa0, 0x37, 0xf4, 0x40, 0x8f, 0x68, 0x3f, 0x41, 0xb5, 0x89, 0xdf, 0x97, 0xf9, 0x60,
517 0x97, 0x9d, 0x5e, 0x7b, 0x6b, 0x37, 0x8c, 0xac, 0x27, 0x99, 0x9d, 0x44, 0x26, 0x62, 0xeb, 0x43,
518 0x6b, 0xba, 0x4b, 0x0a, 0xe4, 0xa3, 0x81, 0x8f, 0xb2, 0xc0, 0x42, 0x5f, 0x96, 0x48, 0x17, 0x54,
519 0x5d, 0x5d, 0x20, 0xfd, 0xcb, 0x8b, 0x35, 0x39, 0x41, 0xfa, 0xa8, 0xa5, 0xfa, 0x46, 0x4d, 0x53,
520 0x37, 0x57, 0x36, 0xea, 0xcb, 0x35, 0x39, 0x19, 0x6d, 0xd8, 0xbf, 0x97, 0x80, 0x42, 0xf7, 0xd9,
521 0x0b, 0xfd, 0x28, 0x1c, 0x15, 0x17, 0x25, 0x3e, 0x0e, 0xb4, 0x1b, 0xa6, 0x47, 0xf7, 0x62, 0x4b,
522 0x67, 0x75, 0x31, 0x8c, 0x86, 0x29, 0xae, 0xb5, 0x8e, 0x83, 0xe7, 0x4c, 0x8f, 0xec, 0xb4, 0x96,
523 0x1e, 0xa0, 0x25, 0x98, 0xb5, 0x1d, 0xcd, 0x0f, 0x74, 0xbb, 0xa1, 0x7b, 0x0d, 0xad, 0x73, 0x45,
524 0xa5, 0xe9, 0x86, 0x81, 0x7d, 0xdf, 0x61, 0x35, 0x30, 0x64, 0x79, 0xd0, 0x76, 0xd6, 0xb9, 0x72,
525 0xa7, 0x38, 0x94, 0xb9, 0x6a, 0x4f, 0xe4, 0x26, 0xf7, 0x8a, 0xdc, 0x07, 0x20, 0xdb, 0xd2, 0x5d,
526 0x0d, 0xdb, 0x81, 0xb7, 0x4b, 0x3b, 0xee, 0x8c, 0x9a, 0x69, 0xe9, 0x6e, 0x8d, 0x3c, 0x7f, 0x34,
527 0x07, 0x9f, 0x7f, 0x4c, 0x42, 0x3e, 0xda, 0x75, 0x93, 0x43, 0x8c, 0x41, 0x0b, 0x94, 0x44, 0x53,
528 0xd8, 0xc3, 0xfb, 0xf6, 0xe8, 0xf3, 0x55, 0x52, 0xb9, 0x94, 0x11, 0xd6, 0x0b, 0xab, 0x0c, 0x49,
529 0xba, 0x06, 0x12, 0x5a, 0x98, 0xf5, 0x1e, 0x19, 0x95, 0x3f, 0xa1, 0x45, 0x18, 0xb9, 0xea, 0x53,
530 0xee, 0x11, 0xca, 0xfd, 0xc8, 0xfe, 0xdc, 0xcf, 0xae, 0x53, 0xf2, 0xec, 0xb3, 0xeb, 0xda, 0xca,
531 0xaa, 0xba, 0x5c, 0x5e, 0x52, 0x39, 0x1c, 0x1d, 0x83, 0x94, 0xa5, 0xdf, 0xda, 0xed, 0xae, 0x71,
532 0x54, 0x34, 0xac, 0xe3, 0x8f, 0x41, 0xea, 0x06, 0xd6, 0xaf, 0x75, 0x57, 0x16, 0x2a, 0xfa, 0x10,
533 0x43, 0xff, 0x0c, 0xa4, 0xa9, 0xbf, 0x10, 0x00, 0xf7, 0x98, 0x7c, 0x08, 0x65, 0x20, 0x55, 0x5d,
534 0x55, 0x49, 0xf8, 0xcb, 0x90, 0x67, 0x52, 0x6d, 0xad, 0x5e, 0xab, 0xd6, 0xe4, 0x44, 0xe9, 0x3c,
535 0x8c, 0x30, 0x27, 0x90, 0xad, 0x11, 0xba, 0x41, 0x3e, 0xc4, 0x1f, 0x39, 0x87, 0x24, 0x46, 0x37,
536 0x97, 0x2b, 0x35, 0x55, 0x4e, 0x44, 0x97, 0xd7, 0x87, 0x7c, 0xb4, 0xe1, 0xfe, 0x68, 0x62, 0xea,
537 0x3b, 0x12, 0xe4, 0x22, 0x0d, 0x34, 0xe9, 0x7c, 0x74, 0xcb, 0x72, 0x6e, 0x68, 0xba, 0x65, 0xea,
538 0x3e, 0x0f, 0x0a, 0xa0, 0xa2, 0x32, 0x91, 0x0c, 0xbb, 0x68, 0x1f, 0x89, 0xf1, 0xaf, 0x4a, 0x20,
539 0xf7, 0xf6, 0xae, 0x3d, 0x06, 0x4a, 0x1f, 0xab, 0x81, 0xaf, 0x48, 0x50, 0xe8, 0x6e, 0x58, 0x7b,
540 0xcc, 0x3b, 0xf1, 0xb1, 0x9a, 0xf7, 0x76, 0x02, 0xc6, 0xba, 0xda, 0xd4, 0x61, 0xad, 0xfb, 0x3c,
541 0x4c, 0x98, 0x0d, 0xdc, 0x72, 0x9d, 0x00, 0xdb, 0xc6, 0xae, 0x66, 0xe1, 0xeb, 0xd8, 0x2a, 0x96,
542 0x68, 0xa2, 0x38, 0xb3, 0x7f, 0x23, 0x3c, 0x5f, 0xef, 0xe0, 0x96, 0x08, 0x4c, 0x99, 0xac, 0x2f,
543 0xd4, 0x96, 0xd7, 0x56, 0x37, 0x6a, 0x2b, 0xd5, 0x17, 0xb4, 0xcd, 0x95, 0x1f, 0x5f, 0x59, 0x7d,
544 0x6e, 0x45, 0x95, 0xcd, 0x1e, 0xb5, 0x0f, 0x71, 0xab, 0xaf, 0x81, 0xdc, 0x6b, 0x14, 0x3a, 0x0a,
545 0x83, 0xcc, 0x92, 0x0f, 0xa1, 0x49, 0x18, 0x5f, 0x59, 0xd5, 0xd6, 0xeb, 0x0b, 0x35, 0xad, 0x76,
546 0xe5, 0x4a, 0xad, 0xba, 0xb1, 0xce, 0xae, 0x36, 0x42, 0xed, 0x8d, 0xee, 0x4d, 0xfd, 0x72, 0x12,
547 0x26, 0x07, 0x58, 0x82, 0xca, 0xfc, 0x50, 0xc2, 0xce, 0x49, 0x4f, 0x0e, 0x63, 0xfd, 0x3c, 0xe9,
548 0x0a, 0xd6, 0x74, 0x2f, 0xe0, 0x67, 0x98, 0x93, 0x40, 0xbc, 0x64, 0x07, 0xe6, 0xb6, 0x89, 0x3d,
549 0x7e, 0x13, 0xc4, 0x4e, 0x2a, 0xe3, 0x1d, 0x39, 0xbb, 0x0c, 0x7a, 0x02, 0x90, 0xeb, 0xf8, 0x66,
550 0x60, 0x5e, 0xc7, 0x9a, 0x69, 0x8b, 0x6b, 0x23, 0x72, 0x72, 0x49, 0xa9, 0xb2, 0x18, 0xa9, 0xdb,
551 0x41, 0xa8, 0x6d, 0xe3, 0xa6, 0xde, 0xa3, 0x4d, 0x12, 0x78, 0x52, 0x95, 0xc5, 0x48, 0xa8, 0x7d,
552 0x02, 0xf2, 0x0d, 0xa7, 0x4d, 0xda, 0x39, 0xa6, 0x47, 0xea, 0x85, 0xa4, 0xe6, 0x98, 0x2c, 0x54,
553 0xe1, 0x8d, 0x7a, 0xe7, 0xbe, 0x2a, 0xaf, 0xe6, 0x98, 0x8c, 0xa9, 0x3c, 0x0e, 0xe3, 0x7a, 0xb3,
554 0xe9, 0x11, 0x72, 0x41, 0xc4, 0x8e, 0x1e, 0x85, 0x50, 0x4c, 0x15, 0xa7, 0x9f, 0x85, 0x8c, 0xf0,
555 0x03, 0x29, 0xc9, 0xc4, 0x13, 0x9a, 0xcb, 0xce, 0xd3, 0x89, 0xb9, 0xac, 0x9a, 0xb1, 0xc5, 0xe0,
556 0x09, 0xc8, 0x9b, 0xbe, 0xd6, 0xb9, 0x7e, 0x4f, 0x1c, 0x4f, 0xcc, 0x65, 0xd4, 0x9c, 0xe9, 0x87,
557 0x57, 0x97, 0xa5, 0x37, 0x12, 0x50, 0xe8, 0xfe, 0x7c, 0x80, 0x16, 0x20, 0x63, 0x39, 0x86, 0x4e,
558 0x43, 0x8b, 0x7d, 0xbb, 0x9a, 0x8b, 0xf9, 0xe2, 0x30, 0xbf, 0xc4, 0xf5, 0xd5, 0x10, 0x39, 0xfd,
559 0x77, 0x12, 0x64, 0x84, 0x18, 0x1d, 0x81, 0x94, 0xab, 0x07, 0x3b, 0x94, 0x2e, 0x5d, 0x49, 0xc8,
560 0x92, 0x4a, 0x9f, 0x89, 0xdc, 0x77, 0x75, 0x9b, 0x86, 0x00, 0x97, 0x93, 0x67, 0xb2, 0xae, 0x16,
561 0xd6, 0x1b, 0xf4, 0x5c, 0xe3, 0xb4, 0x5a, 0xd8, 0x0e, 0x7c, 0xb1, 0xae, 0x5c, 0x5e, 0xe5, 0x62,
562 0x74, 0x1a, 0x26, 0x02, 0x4f, 0x37, 0xad, 0x2e, 0xdd, 0x14, 0xd5, 0x95, 0xc5, 0x40, 0xa8, 0xac,
563 0xc0, 0x31, 0xc1, 0xdb, 0xc0, 0x81, 0x6e, 0xec, 0xe0, 0x46, 0x07, 0x34, 0x42, 0xef, 0x2f, 0x8e,
564 0x72, 0x85, 0x05, 0x3e, 0x2e, 0xb0, 0xa5, 0xef, 0x4b, 0x30, 0x21, 0x4e, 0x62, 0x8d, 0xd0, 0x59,
565 0xcb, 0x00, 0xba, 0x6d, 0x3b, 0x41, 0xd4, 0x5d, 0xfd, 0xa1, 0xdc, 0x87, 0x9b, 0x2f, 0x87, 0x20,
566 0x35, 0x42, 0x30, 0xdd, 0x02, 0xe8, 0x8c, 0xec, 0xe9, 0xb6, 0x59, 0xc8, 0xf1, 0x6f, 0x43, 0xf4,
567 0x03, 0x23, 0x3b, 0xbb, 0x03, 0x13, 0x91, 0x23, 0x1b, 0x9a, 0x82, 0xf4, 0x16, 0x6e, 0x9a, 0x36,
568 0xbf, 0xf1, 0x65, 0x0f, 0xe2, 0x86, 0x25, 0x15, 0xde, 0xb0, 0x54, 0x3e, 0x07, 0x93, 0x86, 0xd3,
569 0xea, 0x35, 0xb7, 0x22, 0xf7, 0xdc, 0x1f, 0xf8, 0x9f, 0x96, 0x5e, 0x84, 0x4e, 0x8b, 0xf9, 0x03,
570 0x49, 0xfa, 0x6a, 0x22, 0xb9, 0xb8, 0x56, 0xf9, 0x7a, 0x62, 0x7a, 0x91, 0x41, 0xd7, 0xc4, 0x4c,
571 0x55, 0xbc, 0x6d, 0x61, 0x83, 0x58, 0x0f, 0x5f, 0x3b, 0x0d, 0x4f, 0x36, 0xcd, 0x60, 0xa7, 0xbd,
572 0x35, 0x6f, 0x38, 0xad, 0x33, 0x4d, 0xa7, 0xe9, 0x74, 0xbe, 0xa9, 0x92, 0x27, 0xfa, 0x40, 0xff,
573 0xe3, 0xdf, 0x55, 0xb3, 0xa1, 0x74, 0x3a, 0xf6, 0x23, 0xac, 0xb2, 0x02, 0x93, 0x5c, 0x59, 0xa3,
574 0x1f, 0x76, 0xd8, 0xf1, 0x04, 0xed, 0x7b, 0x39, 0x56, 0xfc, 0xc6, 0xbb, 0xb4, 0x5c, 0xab, 0x13,
575 0x1c, 0x4a, 0xc6, 0xd8, 0x09, 0x46, 0x51, 0xe1, 0x70, 0x17, 0x1f, 0xdb, 0x9a, 0xd8, 0x8b, 0x61,
576 0xfc, 0x1e, 0x67, 0x9c, 0x8c, 0x30, 0xae, 0x73, 0xa8, 0x52, 0x85, 0xb1, 0x83, 0x70, 0xfd, 0x0d,
577 0xe7, 0xca, 0xe3, 0x28, 0xc9, 0x22, 0x8c, 0x53, 0x12, 0xa3, 0xed, 0x07, 0x4e, 0x8b, 0xe6, 0xbd,
578 0xfd, 0x69, 0xfe, 0xf6, 0x5d, 0xb6, 0x57, 0x0a, 0x04, 0x56, 0x0d, 0x51, 0x8a, 0x02, 0xf4, 0x5b,
579 0x56, 0x03, 0x1b, 0x56, 0x0c, 0xc3, 0x1d, 0x6e, 0x48, 0xa8, 0xaf, 0x7c, 0x16, 0xa6, 0xc8, 0xff,
580 0x34, 0x2d, 0x45, 0x2d, 0x89, 0xbf, 0x49, 0x2b, 0x7e, 0xff, 0x25, 0xb6, 0x1d, 0x27, 0x43, 0x82,
581 0x88, 0x4d, 0x91, 0x55, 0x6c, 0xe2, 0x20, 0xc0, 0x9e, 0xaf, 0xe9, 0xd6, 0x20, 0xf3, 0x22, 0x57,
582 0x11, 0xc5, 0x2f, 0xbf, 0xd7, 0xbd, 0x8a, 0x8b, 0x0c, 0x59, 0xb6, 0x2c, 0x65, 0x13, 0x8e, 0x0e,
583 0x88, 0x8a, 0x21, 0x38, 0x5f, 0xe6, 0x9c, 0x53, 0x7d, 0x91, 0x41, 0x68, 0xd7, 0x40, 0xc8, 0xc3,
584 0xb5, 0x1c, 0x82, 0xf3, 0xb7, 0x38, 0x27, 0xe2, 0x58, 0xb1, 0xa4, 0x84, 0xf1, 0x59, 0x98, 0xb8,
585 0x8e, 0xbd, 0x2d, 0xc7, 0xe7, 0xd7, 0x3f, 0x43, 0xd0, 0xbd, 0xc2, 0xe9, 0xc6, 0x39, 0x90, 0xde,
586 0x07, 0x11, 0xae, 0xa7, 0x21, 0xb3, 0xad, 0x1b, 0x78, 0x08, 0x8a, 0xaf, 0x70, 0x8a, 0x51, 0xa2,
587 0x4f, 0xa0, 0x65, 0xc8, 0x37, 0x1d, 0x5e, 0x99, 0xe2, 0xe1, 0xaf, 0x72, 0x78, 0x4e, 0x60, 0x38,
588 0x85, 0xeb, 0xb8, 0x6d, 0x8b, 0x94, 0xad, 0x78, 0x8a, 0xdf, 0x16, 0x14, 0x02, 0xc3, 0x29, 0x0e,
589 0xe0, 0xd6, 0xd7, 0x04, 0x85, 0x1f, 0xf1, 0xe7, 0x33, 0x90, 0x73, 0x6c, 0x6b, 0xd7, 0xb1, 0x87,
590 0x31, 0xe2, 0x75, 0xce, 0x00, 0x1c, 0x42, 0x08, 0x2e, 0x43, 0x76, 0xd8, 0x85, 0xf8, 0xdd, 0xf7,
591 0xc4, 0xf6, 0x10, 0x2b, 0xb0, 0x08, 0xe3, 0x22, 0x41, 0x99, 0x8e, 0x3d, 0x04, 0xc5, 0xd7, 0x38,
592 0x45, 0x21, 0x02, 0xe3, 0xd3, 0x08, 0xb0, 0x1f, 0x34, 0xf1, 0x30, 0x24, 0x6f, 0x88, 0x69, 0x70,
593 0x08, 0x77, 0xe5, 0x16, 0xb6, 0x8d, 0x9d, 0xe1, 0x18, 0xde, 0x14, 0xae, 0x14, 0x18, 0x42, 0x51,
594 0x85, 0xb1, 0x96, 0xee, 0xf9, 0x3b, 0xba, 0x35, 0xd4, 0x72, 0xfc, 0x1e, 0xe7, 0xc8, 0x87, 0x20,
595 0xee, 0x91, 0xb6, 0x7d, 0x10, 0x9a, 0xaf, 0x0b, 0x8f, 0x44, 0x60, 0x7c, 0xeb, 0xf9, 0x01, 0xbd,
596 0x2b, 0x3b, 0x08, 0xdb, 0xef, 0x8b, 0xad, 0xc7, 0xb0, 0xcb, 0x51, 0xc6, 0xcb, 0x90, 0xf5, 0xcd,
597 0x5b, 0x43, 0xd1, 0xfc, 0x81, 0x58, 0x69, 0x0a, 0x20, 0xe0, 0x17, 0xe0, 0xd8, 0xc0, 0x32, 0x31,
598 0x04, 0xd9, 0x1f, 0x72, 0xb2, 0x23, 0x03, 0x4a, 0x05, 0x4f, 0x09, 0x07, 0xa5, 0xfc, 0x23, 0x91,
599 0x12, 0x70, 0x0f, 0xd7, 0x1a, 0x39, 0x2b, 0xf8, 0xfa, 0xf6, 0xc1, 0xbc, 0xf6, 0xc7, 0xc2, 0x6b,
600 0x0c, 0xdb, 0xe5, 0xb5, 0x0d, 0x38, 0xc2, 0x19, 0x0f, 0xb6, 0xae, 0x7f, 0x22, 0x12, 0x2b, 0x43,
601 0x6f, 0x76, 0xaf, 0xee, 0xe7, 0x60, 0x3a, 0x74, 0xa7, 0x68, 0x4a, 0x7d, 0xad, 0xa5, 0xbb, 0x43,
602 0x30, 0x7f, 0x83, 0x33, 0x8b, 0x8c, 0x1f, 0x76, 0xb5, 0xfe, 0xb2, 0xee, 0x12, 0xf2, 0xe7, 0xa1,
603 0x28, 0xc8, 0xdb, 0xb6, 0x87, 0x0d, 0xa7, 0x69, 0x9b, 0xb7, 0x70, 0x63, 0x08, 0xea, 0x3f, 0xed,
604 0x59, 0xaa, 0xcd, 0x08, 0x9c, 0x30, 0xd7, 0x41, 0x0e, 0x7b, 0x15, 0xcd, 0x6c, 0xb9, 0x8e, 0x17,
605 0xc4, 0x30, 0xfe, 0x99, 0x58, 0xa9, 0x10, 0x57, 0xa7, 0x30, 0xa5, 0x06, 0x05, 0xfa, 0x38, 0x6c,
606 0x48, 0xfe, 0x39, 0x27, 0x1a, 0xeb, 0xa0, 0x78, 0xe2, 0x30, 0x9c, 0x96, 0xab, 0x7b, 0xc3, 0xe4,
607 0xbf, 0xbf, 0x10, 0x89, 0x83, 0x43, 0x78, 0xe2, 0x08, 0x76, 0x5d, 0x4c, 0xaa, 0xfd, 0x10, 0x0c,
608 0xdf, 0x14, 0x89, 0x43, 0x60, 0x38, 0x85, 0x68, 0x18, 0x86, 0xa0, 0xf8, 0x4b, 0x41, 0x21, 0x30,
609 0x84, 0xe2, 0x33, 0x9d, 0x42, 0xeb, 0xe1, 0xa6, 0xe9, 0x07, 0x1e, 0x6b, 0x85, 0xf7, 0xa7, 0xfa,
610 0xd6, 0x7b, 0xdd, 0x4d, 0x98, 0x1a, 0x81, 0x92, 0x4c, 0xc4, 0xaf, 0x50, 0xe9, 0x49, 0x29, 0xde,
611 0xb0, 0x6f, 0x8b, 0x4c, 0x14, 0x81, 0x11, 0xdb, 0x22, 0x1d, 0x22, 0x71, 0xbb, 0x41, 0xce, 0x07,
612 0x43, 0xd0, 0x7d, 0xa7, 0xc7, 0xb8, 0x75, 0x81, 0x25, 0x9c, 0x91, 0xfe, 0xa7, 0x6d, 0x5f, 0xc3,
613 0xbb, 0x43, 0x45, 0xe7, 0x5f, 0xf5, 0xf4, 0x3f, 0x9b, 0x0c, 0xc9, 0x72, 0xc8, 0x78, 0x4f, 0x3f,
614 0x85, 0xe2, 0x7e, 0x05, 0x54, 0xfc, 0xa9, 0xfb, 0x7c, 0xbe, 0xdd, 0xed, 0x94, 0xb2, 0x44, 0x82,
615 0xbc, 0xbb, 0xe9, 0x89, 0x27, 0x7b, 0xe9, 0x7e, 0x18, 0xe7, 0x5d, 0x3d, 0x8f, 0x72, 0x05, 0xc6,
616 0xba, 0x1a, 0x9e, 0x78, 0xaa, 0x9f, 0xe6, 0x54, 0xf9, 0x68, 0xbf, 0xa3, 0x9c, 0x87, 0x14, 0x69,
617 0x5e, 0xe2, 0xe1, 0x3f, 0xc3, 0xe1, 0x54, 0x5d, 0xf9, 0x24, 0x64, 0x44, 0xd3, 0x12, 0x0f, 0xfd,
618 0x59, 0x0e, 0x0d, 0x21, 0x04, 0x2e, 0x1a, 0x96, 0x78, 0xf8, 0xcf, 0x09, 0xb8, 0x80, 0x10, 0xf8,
619 0xf0, 0x2e, 0xfc, 0xee, 0x2f, 0xa4, 0x78, 0xd1, 0x11, 0xbe, 0xbb, 0x0c, 0xa3, 0xbc, 0x53, 0x89,
620 0x47, 0x7f, 0x81, 0xbf, 0x5c, 0x20, 0x94, 0x8b, 0x90, 0x1e, 0xd2, 0xe1, 0xbf, 0xc4, 0xa1, 0x4c,
621 0x5f, 0xa9, 0x42, 0x2e, 0xd2, 0x9d, 0xc4, 0xc3, 0x7f, 0x99, 0xc3, 0xa3, 0x28, 0x62, 0x3a, 0xef,
622 0x4e, 0xe2, 0x09, 0xbe, 0x28, 0x4c, 0xe7, 0x08, 0xe2, 0x36, 0xd1, 0x98, 0xc4, 0xa3, 0x7f, 0x45,
623 0x78, 0x5d, 0x40, 0x94, 0x67, 0x20, 0x1b, 0x16, 0x9b, 0x78, 0xfc, 0xaf, 0x72, 0x7c, 0x07, 0x43,
624 0x3c, 0x10, 0x29, 0x76, 0xf1, 0x14, 0xbf, 0x26, 0x3c, 0x10, 0x41, 0x91, 0x6d, 0xd4, 0xdb, 0xc0,
625 0xc4, 0x33, 0xfd, 0xba, 0xd8, 0x46, 0x3d, 0xfd, 0x0b, 0x59, 0x4d, 0x9a, 0xf3, 0xe3, 0x29, 0x7e,
626 0x43, 0xac, 0x26, 0xd5, 0x27, 0x66, 0xf4, 0x76, 0x04, 0xf1, 0x1c, 0xbf, 0x29, 0xcc, 0xe8, 0x69,
627 0x08, 0x94, 0x35, 0x40, 0xfd, 0xdd, 0x40, 0x3c, 0xdf, 0x97, 0x38, 0xdf, 0x44, 0x5f, 0x33, 0xa0,
628 0x3c, 0x07, 0x47, 0x06, 0x77, 0x02, 0xf1, 0xac, 0x5f, 0xbe, 0xdf, 0x73, 0x76, 0x8b, 0x36, 0x02,
629 0xca, 0x46, 0xa7, 0xa4, 0x44, 0xbb, 0x80, 0x78, 0xda, 0x97, 0xef, 0x77, 0x27, 0xee, 0x68, 0x13,
630 0xa0, 0x94, 0x01, 0x3a, 0x05, 0x38, 0x9e, 0xeb, 0x15, 0xce, 0x15, 0x01, 0x91, 0xad, 0xc1, 0xeb,
631 0x6f, 0x3c, 0xfe, 0x2b, 0x62, 0x6b, 0x70, 0x04, 0xd9, 0x1a, 0xa2, 0xf4, 0xc6, 0xa3, 0x5f, 0x15,
632 0x5b, 0x43, 0x40, 0x48, 0x64, 0x47, 0xaa, 0x5b, 0x3c, 0xc3, 0xeb, 0x22, 0xb2, 0x23, 0x28, 0x65,
633 0x05, 0x26, 0xfa, 0x0a, 0x62, 0x3c, 0xd5, 0x57, 0x39, 0x95, 0xdc, 0x5b, 0x0f, 0xa3, 0xc5, 0x8b,
634 0x17, 0xc3, 0x78, 0xb6, 0xdf, 0xe9, 0x29, 0x5e, 0xbc, 0x16, 0x2a, 0x97, 0x21, 0x63, 0xb7, 0x2d,
635 0x8b, 0x6c, 0x1e, 0xb4, 0xff, 0x2f, 0xf7, 0x8a, 0xff, 0xfa, 0x01, 0xf7, 0x8e, 0x00, 0x28, 0xe7,
636 0x21, 0x8d, 0x5b, 0x5b, 0xb8, 0x11, 0x87, 0xfc, 0xb7, 0x0f, 0x44, 0xc2, 0x24, 0xda, 0xca, 0x33,
637 0x00, 0xec, 0x6a, 0x84, 0x7e, 0xf6, 0x8b, 0xc1, 0xfe, 0xfb, 0x07, 0xfc, 0x37, 0x35, 0x1d, 0x48,
638 0x87, 0x80, 0xfd, 0x42, 0x67, 0x7f, 0x82, 0xf7, 0xba, 0x09, 0xe8, 0x8a, 0x3c, 0x0d, 0xa3, 0x57,
639 0x7d, 0xc7, 0x0e, 0xf4, 0x66, 0x1c, 0xfa, 0x3f, 0x38, 0x5a, 0xe8, 0x13, 0x87, 0xb5, 0x1c, 0x0f,
640 0x07, 0x7a, 0xd3, 0x8f, 0xc3, 0xfe, 0x27, 0xc7, 0x86, 0x00, 0x02, 0x36, 0x74, 0x3f, 0x18, 0x66,
641 0xde, 0xff, 0x25, 0xc0, 0x02, 0x40, 0x8c, 0x26, 0xff, 0x5f, 0xc3, 0xbb, 0x71, 0xd8, 0xf7, 0x85,
642 0xd1, 0x5c, 0x5f, 0xf9, 0x24, 0x64, 0xc9, 0xbf, 0xec, 0x87, 0x72, 0x31, 0xe0, 0xff, 0xe6, 0xe0,
643 0x0e, 0x82, 0xbc, 0xd9, 0x0f, 0x1a, 0x81, 0x19, 0xef, 0xec, 0xff, 0xe1, 0x2b, 0x2d, 0xf4, 0x95,
644 0x32, 0xe4, 0xfc, 0xa0, 0xd1, 0x68, 0xf3, 0xfe, 0x34, 0x06, 0xfe, 0xbf, 0x1f, 0x84, 0x57, 0x16,
645 0x21, 0x86, 0xac, 0xf6, 0x8d, 0x6b, 0x81, 0xeb, 0xd0, 0xcf, 0x1c, 0x71, 0x0c, 0xf7, 0x39, 0x43,
646 0x04, 0x52, 0xa9, 0x0d, 0xbe, 0xbe, 0x85, 0x45, 0x67, 0xd1, 0x61, 0x17, 0xb7, 0x2f, 0x96, 0xe2,
647 0x6f, 0x60, 0xe1, 0xaf, 0x53, 0x30, 0x86, 0x6f, 0xea, 0x2d, 0x57, 0x90, 0xa0, 0x14, 0x29, 0xc0,
648 0xd3, 0x07, 0xbb, 0xbd, 0x2d, 0x7d, 0x51, 0x02, 0xa9, 0x8c, 0x1e, 0x83, 0xdc, 0x42, 0xa7, 0xfc,
649 0xb3, 0xdf, 0x59, 0x55, 0x52, 0x77, 0xee, 0xce, 0x1e, 0x52, 0xa3, 0x03, 0xe8, 0x41, 0x18, 0x59,
650 0xe9, 0xfc, 0x56, 0x2f, 0xc9, 0x55, 0xb8, 0x0c, 0x29, 0x90, 0xa8, 0xb3, 0x4f, 0xab, 0xf9, 0xca,
651 0x29, 0x32, 0xf2, 0x0f, 0x77, 0x67, 0xf7, 0x9e, 0x0a, 0xb1, 0x76, 0x7e, 0xb3, 0x6d, 0x36, 0xd4,
652 0x44, 0xbd, 0xa1, 0x64, 0x7e, 0xfe, 0xb5, 0xd9, 0x43, 0x6f, 0xbe, 0x36, 0x2b, 0x95, 0x6c, 0x90,
653 0x2a, 0x68, 0x16, 0xa4, 0x32, 0x35, 0x23, 0x77, 0x76, 0x74, 0x9e, 0x6a, 0x96, 0x2b, 0x19, 0x42,
654 0xf9, 0xd6, 0xdd, 0x59, 0x49, 0x95, 0xca, 0xa8, 0x02, 0xd2, 0x22, 0xfd, 0x02, 0x91, 0xaf, 0x9c,
655 0xe3, 0xaf, 0x7a, 0x62, 0xdf, 0x57, 0x9d, 0x61, 0x1b, 0x6e, 0x7e, 0xd3, 0xb4, 0x83, 0x1f, 0x39,
656 0x7b, 0x49, 0x95, 0x16, 0x95, 0xd4, 0xfb, 0xe4, 0x7d, 0x0f, 0x83, 0x54, 0x45, 0x33, 0x90, 0x22,
657 0xc9, 0x90, 0xbe, 0x32, 0x59, 0x81, 0x7b, 0x77, 0x67, 0x47, 0x96, 0x77, 0x49, 0x8e, 0x53, 0xa9,
658 0xbc, 0x74, 0x11, 0xa4, 0x4d, 0x74, 0xb8, 0xdf, 0x28, 0x62, 0xca, 0x61, 0x90, 0x2a, 0xfc, 0xa7,
659 0xa8, 0x5c, 0x5c, 0x51, 0xa5, 0x8a, 0x92, 0xba, 0x43, 0xd8, 0x27, 0x41, 0xaa, 0x9d, 0xca, 0x64,
660 0x24, 0xf6, 0x59, 0x4d, 0x49, 0xdd, 0x79, 0x7d, 0xf6, 0x50, 0xe9, 0x24, 0x48, 0x2a, 0x9a, 0x01,
661 0xe8, 0x54, 0x26, 0x4a, 0x3b, 0xa6, 0x46, 0x24, 0x4a, 0xea, 0x2d, 0xa2, 0x7a, 0x1a, 0x32, 0x55,
662 0xdd, 0x17, 0xbf, 0xee, 0x4b, 0xd7, 0xed, 0xe0, 0xa9, 0xb3, 0xdc, 0xca, 0xec, 0xff, 0xdd, 0x9d,
663 0x4d, 0x9b, 0x44, 0xa0, 0x32, 0x79, 0xe5, 0x89, 0xbf, 0x7f, 0x67, 0xe6, 0xd0, 0xdb, 0xef, 0xcc,
664 0x48, 0xef, 0xbf, 0x33, 0x23, 0xfd, 0xe0, 0x9d, 0x19, 0xe9, 0xf6, 0xbd, 0x19, 0xe9, 0xcd, 0x7b,
665 0x33, 0xd2, 0xb7, 0xee, 0xcd, 0x48, 0xdf, 0xbd, 0x37, 0x23, 0xdd, 0xb9, 0x37, 0x23, 0xbd, 0x75,
666 0x6f, 0x46, 0x7a, 0xfb, 0xde, 0x8c, 0xf4, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x67, 0x48, 0x0f,
667 0x02, 0x36, 0x35, 0x00, 0x00,
668 }
669 r := bytes.NewReader(gzipped)
670 gzipr, err := compress_gzip.NewReader(r)
671 if err != nil {
672 panic(err)
673 }
674 ungzipped, err := io_ioutil.ReadAll(gzipr)
675 if err != nil {
676 panic(err)
677 }
678 if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
679 panic(err)
680 }
681 return d
682 }
683 func (this *A) VerboseEqual(that interface{}) error {
684 if that == nil {
685 if this == nil {
686 return nil
687 }
688 return fmt.Errorf("that == nil && this != nil")
689 }
690
691 that1, ok := that.(*A)
692 if !ok {
693 that2, ok := that.(A)
694 if ok {
695 that1 = &that2
696 } else {
697 return fmt.Errorf("that is not of type *A")
698 }
699 }
700 if that1 == nil {
701 if this == nil {
702 return nil
703 }
704 return fmt.Errorf("that is type *A but is nil && this != nil")
705 } else if this == nil {
706 return fmt.Errorf("that is type *A but is not nil && this == nil")
707 }
708 if this.Description != that1.Description {
709 return fmt.Errorf("Description this(%v) Not Equal that(%v)", this.Description, that1.Description)
710 }
711 if this.Number != that1.Number {
712 return fmt.Errorf("Number this(%v) Not Equal that(%v)", this.Number, that1.Number)
713 }
714 if !this.Id.Equal(that1.Id) {
715 return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id)
716 }
717 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
718 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
719 }
720 return nil
721 }
722 func (this *A) Equal(that interface{}) bool {
723 if that == nil {
724 return this == nil
725 }
726
727 that1, ok := that.(*A)
728 if !ok {
729 that2, ok := that.(A)
730 if ok {
731 that1 = &that2
732 } else {
733 return false
734 }
735 }
736 if that1 == nil {
737 return this == nil
738 } else if this == nil {
739 return false
740 }
741 if this.Description != that1.Description {
742 return false
743 }
744 if this.Number != that1.Number {
745 return false
746 }
747 if !this.Id.Equal(that1.Id) {
748 return false
749 }
750 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
751 return false
752 }
753 return true
754 }
755 func (this *B) VerboseEqual(that interface{}) error {
756 if that == nil {
757 if this == nil {
758 return nil
759 }
760 return fmt.Errorf("that == nil && this != nil")
761 }
762
763 that1, ok := that.(*B)
764 if !ok {
765 that2, ok := that.(B)
766 if ok {
767 that1 = &that2
768 } else {
769 return fmt.Errorf("that is not of type *B")
770 }
771 }
772 if that1 == nil {
773 if this == nil {
774 return nil
775 }
776 return fmt.Errorf("that is type *B but is nil && this != nil")
777 } else if this == nil {
778 return fmt.Errorf("that is type *B but is not nil && this == nil")
779 }
780 if !this.A.Equal(&that1.A) {
781 return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A)
782 }
783 if len(this.G) != len(that1.G) {
784 return fmt.Errorf("G this(%v) Not Equal that(%v)", len(this.G), len(that1.G))
785 }
786 for i := range this.G {
787 if !this.G[i].Equal(that1.G[i]) {
788 return fmt.Errorf("G this[%v](%v) Not Equal that[%v](%v)", i, this.G[i], i, that1.G[i])
789 }
790 }
791 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
792 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
793 }
794 return nil
795 }
796 func (this *B) Equal(that interface{}) bool {
797 if that == nil {
798 return this == nil
799 }
800
801 that1, ok := that.(*B)
802 if !ok {
803 that2, ok := that.(B)
804 if ok {
805 that1 = &that2
806 } else {
807 return false
808 }
809 }
810 if that1 == nil {
811 return this == nil
812 } else if this == nil {
813 return false
814 }
815 if !this.A.Equal(&that1.A) {
816 return false
817 }
818 if len(this.G) != len(that1.G) {
819 return false
820 }
821 for i := range this.G {
822 if !this.G[i].Equal(that1.G[i]) {
823 return false
824 }
825 }
826 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
827 return false
828 }
829 return true
830 }
831 func (this *C) VerboseEqual(that interface{}) error {
832 if that == nil {
833 if this == nil {
834 return nil
835 }
836 return fmt.Errorf("that == nil && this != nil")
837 }
838
839 that1, ok := that.(*C)
840 if !ok {
841 that2, ok := that.(C)
842 if ok {
843 that1 = &that2
844 } else {
845 return fmt.Errorf("that is not of type *C")
846 }
847 }
848 if that1 == nil {
849 if this == nil {
850 return nil
851 }
852 return fmt.Errorf("that is type *C but is nil && this != nil")
853 } else if this == nil {
854 return fmt.Errorf("that is type *C but is not nil && this == nil")
855 }
856 if this.MySize != nil && that1.MySize != nil {
857 if *this.MySize != *that1.MySize {
858 return fmt.Errorf("MySize this(%v) Not Equal that(%v)", *this.MySize, *that1.MySize)
859 }
860 } else if this.MySize != nil {
861 return fmt.Errorf("this.MySize == nil && that.MySize != nil")
862 } else if that1.MySize != nil {
863 return fmt.Errorf("MySize this(%v) Not Equal that(%v)", this.MySize, that1.MySize)
864 }
865 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
866 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
867 }
868 return nil
869 }
870 func (this *C) Equal(that interface{}) bool {
871 if that == nil {
872 return this == nil
873 }
874
875 that1, ok := that.(*C)
876 if !ok {
877 that2, ok := that.(C)
878 if ok {
879 that1 = &that2
880 } else {
881 return false
882 }
883 }
884 if that1 == nil {
885 return this == nil
886 } else if this == nil {
887 return false
888 }
889 if this.MySize != nil && that1.MySize != nil {
890 if *this.MySize != *that1.MySize {
891 return false
892 }
893 } else if this.MySize != nil {
894 return false
895 } else if that1.MySize != nil {
896 return false
897 }
898 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
899 return false
900 }
901 return true
902 }
903 func (this *U) VerboseEqual(that interface{}) error {
904 if that == nil {
905 if this == nil {
906 return nil
907 }
908 return fmt.Errorf("that == nil && this != nil")
909 }
910
911 that1, ok := that.(*U)
912 if !ok {
913 that2, ok := that.(U)
914 if ok {
915 that1 = &that2
916 } else {
917 return fmt.Errorf("that is not of type *U")
918 }
919 }
920 if that1 == nil {
921 if this == nil {
922 return nil
923 }
924 return fmt.Errorf("that is type *U but is nil && this != nil")
925 } else if this == nil {
926 return fmt.Errorf("that is type *U but is not nil && this == nil")
927 }
928 if !this.A.Equal(that1.A) {
929 return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A)
930 }
931 if !this.B.Equal(that1.B) {
932 return fmt.Errorf("B this(%v) Not Equal that(%v)", this.B, that1.B)
933 }
934 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
935 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
936 }
937 return nil
938 }
939 func (this *U) Equal(that interface{}) bool {
940 if that == nil {
941 return this == nil
942 }
943
944 that1, ok := that.(*U)
945 if !ok {
946 that2, ok := that.(U)
947 if ok {
948 that1 = &that2
949 } else {
950 return false
951 }
952 }
953 if that1 == nil {
954 return this == nil
955 } else if this == nil {
956 return false
957 }
958 if !this.A.Equal(that1.A) {
959 return false
960 }
961 if !this.B.Equal(that1.B) {
962 return false
963 }
964 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
965 return false
966 }
967 return true
968 }
969 func (this *E) VerboseEqual(that interface{}) error {
970 if that == nil {
971 if this == nil {
972 return nil
973 }
974 return fmt.Errorf("that == nil && this != nil")
975 }
976
977 that1, ok := that.(*E)
978 if !ok {
979 that2, ok := that.(E)
980 if ok {
981 that1 = &that2
982 } else {
983 return fmt.Errorf("that is not of type *E")
984 }
985 }
986 if that1 == nil {
987 if this == nil {
988 return nil
989 }
990 return fmt.Errorf("that is type *E but is nil && this != nil")
991 } else if this == nil {
992 return fmt.Errorf("that is type *E but is not nil && this == nil")
993 }
994 if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) {
995 return fmt.Errorf("XXX_extensions this(%v) Not Equal that(%v)", this.XXX_extensions, that1.XXX_extensions)
996 }
997 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
998 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
999 }
1000 return nil
1001 }
1002 func (this *E) Equal(that interface{}) bool {
1003 if that == nil {
1004 return this == nil
1005 }
1006
1007 that1, ok := that.(*E)
1008 if !ok {
1009 that2, ok := that.(E)
1010 if ok {
1011 that1 = &that2
1012 } else {
1013 return false
1014 }
1015 }
1016 if that1 == nil {
1017 return this == nil
1018 } else if this == nil {
1019 return false
1020 }
1021 if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) {
1022 return false
1023 }
1024 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1025 return false
1026 }
1027 return true
1028 }
1029 func (this *R) VerboseEqual(that interface{}) error {
1030 if that == nil {
1031 if this == nil {
1032 return nil
1033 }
1034 return fmt.Errorf("that == nil && this != nil")
1035 }
1036
1037 that1, ok := that.(*R)
1038 if !ok {
1039 that2, ok := that.(R)
1040 if ok {
1041 that1 = &that2
1042 } else {
1043 return fmt.Errorf("that is not of type *R")
1044 }
1045 }
1046 if that1 == nil {
1047 if this == nil {
1048 return nil
1049 }
1050 return fmt.Errorf("that is type *R but is nil && this != nil")
1051 } else if this == nil {
1052 return fmt.Errorf("that is type *R but is not nil && this == nil")
1053 }
1054 if this.Recognized != nil && that1.Recognized != nil {
1055 if *this.Recognized != *that1.Recognized {
1056 return fmt.Errorf("Recognized this(%v) Not Equal that(%v)", *this.Recognized, *that1.Recognized)
1057 }
1058 } else if this.Recognized != nil {
1059 return fmt.Errorf("this.Recognized == nil && that.Recognized != nil")
1060 } else if that1.Recognized != nil {
1061 return fmt.Errorf("Recognized this(%v) Not Equal that(%v)", this.Recognized, that1.Recognized)
1062 }
1063 return nil
1064 }
1065 func (this *R) Equal(that interface{}) bool {
1066 if that == nil {
1067 return this == nil
1068 }
1069
1070 that1, ok := that.(*R)
1071 if !ok {
1072 that2, ok := that.(R)
1073 if ok {
1074 that1 = &that2
1075 } else {
1076 return false
1077 }
1078 }
1079 if that1 == nil {
1080 return this == nil
1081 } else if this == nil {
1082 return false
1083 }
1084 if this.Recognized != nil && that1.Recognized != nil {
1085 if *this.Recognized != *that1.Recognized {
1086 return false
1087 }
1088 } else if this.Recognized != nil {
1089 return false
1090 } else if that1.Recognized != nil {
1091 return false
1092 }
1093 return true
1094 }
1095 func (this *CastType) VerboseEqual(that interface{}) error {
1096 if that == nil {
1097 if this == nil {
1098 return nil
1099 }
1100 return fmt.Errorf("that == nil && this != nil")
1101 }
1102
1103 that1, ok := that.(*CastType)
1104 if !ok {
1105 that2, ok := that.(CastType)
1106 if ok {
1107 that1 = &that2
1108 } else {
1109 return fmt.Errorf("that is not of type *CastType")
1110 }
1111 }
1112 if that1 == nil {
1113 if this == nil {
1114 return nil
1115 }
1116 return fmt.Errorf("that is type *CastType but is nil && this != nil")
1117 } else if this == nil {
1118 return fmt.Errorf("that is type *CastType but is not nil && this == nil")
1119 }
1120 if this.Int32 != nil && that1.Int32 != nil {
1121 if *this.Int32 != *that1.Int32 {
1122 return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", *this.Int32, *that1.Int32)
1123 }
1124 } else if this.Int32 != nil {
1125 return fmt.Errorf("this.Int32 == nil && that.Int32 != nil")
1126 } else if that1.Int32 != nil {
1127 return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32)
1128 }
1129 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1130 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1131 }
1132 return nil
1133 }
1134 func (this *CastType) Equal(that interface{}) bool {
1135 if that == nil {
1136 return this == nil
1137 }
1138
1139 that1, ok := that.(*CastType)
1140 if !ok {
1141 that2, ok := that.(CastType)
1142 if ok {
1143 that1 = &that2
1144 } else {
1145 return false
1146 }
1147 }
1148 if that1 == nil {
1149 return this == nil
1150 } else if this == nil {
1151 return false
1152 }
1153 if this.Int32 != nil && that1.Int32 != nil {
1154 if *this.Int32 != *that1.Int32 {
1155 return false
1156 }
1157 } else if this.Int32 != nil {
1158 return false
1159 } else if that1.Int32 != nil {
1160 return false
1161 }
1162 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1163 return false
1164 }
1165 return true
1166 }
1167
1168 type AFace interface {
1169 Proto() github_com_gogo_protobuf_proto.Message
1170 GetDescription() string
1171 GetNumber() int64
1172 GetId() github_com_gogo_protobuf_test.Uuid
1173 }
1174
1175 func (this *A) Proto() github_com_gogo_protobuf_proto.Message {
1176 return this
1177 }
1178
1179 func (this *A) TestProto() github_com_gogo_protobuf_proto.Message {
1180 return NewAFromFace(this)
1181 }
1182
1183 func (this *A) GetDescription() string {
1184 return this.Description
1185 }
1186
1187 func (this *A) GetNumber() int64 {
1188 return this.Number
1189 }
1190
1191 func (this *A) GetId() github_com_gogo_protobuf_test.Uuid {
1192 return this.Id
1193 }
1194
1195 func NewAFromFace(that AFace) *A {
1196 this := &A{}
1197 this.Description = that.GetDescription()
1198 this.Number = that.GetNumber()
1199 this.Id = that.GetId()
1200 return this
1201 }
1202
1203 func (this *A) GoString() string {
1204 if this == nil {
1205 return "nil"
1206 }
1207 s := make([]string, 0, 7)
1208 s = append(s, "&test.A{")
1209 s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n")
1210 s = append(s, "Number: "+fmt.Sprintf("%#v", this.Number)+",\n")
1211 s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
1212 if this.XXX_unrecognized != nil {
1213 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1214 }
1215 s = append(s, "}")
1216 return strings.Join(s, "")
1217 }
1218 func (this *B) GoString() string {
1219 if this == nil {
1220 return "nil"
1221 }
1222 s := make([]string, 0, 6)
1223 s = append(s, "&test.B{")
1224 s = append(s, "A: "+strings.Replace(this.A.GoString(), `&`, ``, 1)+",\n")
1225 if this.G != nil {
1226 s = append(s, "G: "+fmt.Sprintf("%#v", this.G)+",\n")
1227 }
1228 if this.XXX_unrecognized != nil {
1229 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1230 }
1231 s = append(s, "}")
1232 return strings.Join(s, "")
1233 }
1234 func (this *C) GoString() string {
1235 if this == nil {
1236 return "nil"
1237 }
1238 s := make([]string, 0, 5)
1239 s = append(s, "&test.C{")
1240 if this.MySize != nil {
1241 s = append(s, "MySize: "+valueToGoStringExample(this.MySize, "int64")+",\n")
1242 }
1243 if this.XXX_unrecognized != nil {
1244 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1245 }
1246 s = append(s, "}")
1247 return strings.Join(s, "")
1248 }
1249 func (this *U) GoString() string {
1250 if this == nil {
1251 return "nil"
1252 }
1253 s := make([]string, 0, 6)
1254 s = append(s, "&test.U{")
1255 if this.A != nil {
1256 s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n")
1257 }
1258 if this.B != nil {
1259 s = append(s, "B: "+fmt.Sprintf("%#v", this.B)+",\n")
1260 }
1261 if this.XXX_unrecognized != nil {
1262 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1263 }
1264 s = append(s, "}")
1265 return strings.Join(s, "")
1266 }
1267 func (this *E) GoString() string {
1268 if this == nil {
1269 return "nil"
1270 }
1271 s := make([]string, 0, 4)
1272 s = append(s, "&test.E{")
1273 if this.XXX_extensions != nil {
1274 s = append(s, "XXX_extensions: "+fmt.Sprintf("%#v", this.XXX_extensions)+",\n")
1275 }
1276 if this.XXX_unrecognized != nil {
1277 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1278 }
1279 s = append(s, "}")
1280 return strings.Join(s, "")
1281 }
1282 func (this *R) GoString() string {
1283 if this == nil {
1284 return "nil"
1285 }
1286 s := make([]string, 0, 5)
1287 s = append(s, "&test.R{")
1288 if this.Recognized != nil {
1289 s = append(s, "Recognized: "+valueToGoStringExample(this.Recognized, "uint32")+",\n")
1290 }
1291 s = append(s, "}")
1292 return strings.Join(s, "")
1293 }
1294 func (this *CastType) GoString() string {
1295 if this == nil {
1296 return "nil"
1297 }
1298 s := make([]string, 0, 5)
1299 s = append(s, "&test.CastType{")
1300 if this.Int32 != nil {
1301 s = append(s, "Int32: "+valueToGoStringExample(this.Int32, "int32")+",\n")
1302 }
1303 if this.XXX_unrecognized != nil {
1304 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1305 }
1306 s = append(s, "}")
1307 return strings.Join(s, "")
1308 }
1309 func valueToGoStringExample(v interface{}, typ string) string {
1310 rv := reflect.ValueOf(v)
1311 if rv.IsNil() {
1312 return "nil"
1313 }
1314 pv := reflect.Indirect(rv).Interface()
1315 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
1316 }
1317 func (m *A) Marshal() (dAtA []byte, err error) {
1318 size := m.Size()
1319 dAtA = make([]byte, size)
1320 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1321 if err != nil {
1322 return nil, err
1323 }
1324 return dAtA[:n], nil
1325 }
1326
1327 func (m *A) MarshalTo(dAtA []byte) (int, error) {
1328 size := m.Size()
1329 return m.MarshalToSizedBuffer(dAtA[:size])
1330 }
1331
1332 func (m *A) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1333 i := len(dAtA)
1334 _ = i
1335 var l int
1336 _ = l
1337 if m.XXX_unrecognized != nil {
1338 i -= len(m.XXX_unrecognized)
1339 copy(dAtA[i:], m.XXX_unrecognized)
1340 }
1341 {
1342 size := m.Id.Size()
1343 i -= size
1344 if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil {
1345 return 0, err
1346 }
1347 i = encodeVarintExample(dAtA, i, uint64(size))
1348 }
1349 i--
1350 dAtA[i] = 0x1a
1351 i = encodeVarintExample(dAtA, i, uint64(m.Number))
1352 i--
1353 dAtA[i] = 0x10
1354 i -= len(m.Description)
1355 copy(dAtA[i:], m.Description)
1356 i = encodeVarintExample(dAtA, i, uint64(len(m.Description)))
1357 i--
1358 dAtA[i] = 0xa
1359 return len(dAtA) - i, nil
1360 }
1361
1362 func (m *B) Marshal() (dAtA []byte, err error) {
1363 size := m.Size()
1364 dAtA = make([]byte, size)
1365 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1366 if err != nil {
1367 return nil, err
1368 }
1369 return dAtA[:n], nil
1370 }
1371
1372 func (m *B) MarshalTo(dAtA []byte) (int, error) {
1373 size := m.Size()
1374 return m.MarshalToSizedBuffer(dAtA[:size])
1375 }
1376
1377 func (m *B) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1378 i := len(dAtA)
1379 _ = i
1380 var l int
1381 _ = l
1382 if m.XXX_unrecognized != nil {
1383 i -= len(m.XXX_unrecognized)
1384 copy(dAtA[i:], m.XXX_unrecognized)
1385 }
1386 if len(m.G) > 0 {
1387 for iNdEx := len(m.G) - 1; iNdEx >= 0; iNdEx-- {
1388 {
1389 size := m.G[iNdEx].Size()
1390 i -= size
1391 if _, err := m.G[iNdEx].MarshalTo(dAtA[i:]); err != nil {
1392 return 0, err
1393 }
1394 i = encodeVarintExample(dAtA, i, uint64(size))
1395 }
1396 i--
1397 dAtA[i] = 0x12
1398 }
1399 }
1400 {
1401 size, err := m.A.MarshalToSizedBuffer(dAtA[:i])
1402 if err != nil {
1403 return 0, err
1404 }
1405 i -= size
1406 i = encodeVarintExample(dAtA, i, uint64(size))
1407 }
1408 i--
1409 dAtA[i] = 0xa
1410 return len(dAtA) - i, nil
1411 }
1412
1413 func (m *C) Marshal() (dAtA []byte, err error) {
1414 size := m.Size()
1415 dAtA = make([]byte, size)
1416 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1417 if err != nil {
1418 return nil, err
1419 }
1420 return dAtA[:n], nil
1421 }
1422
1423 func (m *C) MarshalTo(dAtA []byte) (int, error) {
1424 size := m.Size()
1425 return m.MarshalToSizedBuffer(dAtA[:size])
1426 }
1427
1428 func (m *C) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1429 i := len(dAtA)
1430 _ = i
1431 var l int
1432 _ = l
1433 if m.XXX_unrecognized != nil {
1434 i -= len(m.XXX_unrecognized)
1435 copy(dAtA[i:], m.XXX_unrecognized)
1436 }
1437 if m.MySize != nil {
1438 i = encodeVarintExample(dAtA, i, uint64(*m.MySize))
1439 i--
1440 dAtA[i] = 0x8
1441 }
1442 return len(dAtA) - i, nil
1443 }
1444
1445 func (m *U) Marshal() (dAtA []byte, err error) {
1446 size := m.Size()
1447 dAtA = make([]byte, size)
1448 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1449 if err != nil {
1450 return nil, err
1451 }
1452 return dAtA[:n], nil
1453 }
1454
1455 func (m *U) MarshalTo(dAtA []byte) (int, error) {
1456 size := m.Size()
1457 return m.MarshalToSizedBuffer(dAtA[:size])
1458 }
1459
1460 func (m *U) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1461 i := len(dAtA)
1462 _ = i
1463 var l int
1464 _ = l
1465 if m.XXX_unrecognized != nil {
1466 i -= len(m.XXX_unrecognized)
1467 copy(dAtA[i:], m.XXX_unrecognized)
1468 }
1469 if m.B != nil {
1470 {
1471 size, err := m.B.MarshalToSizedBuffer(dAtA[:i])
1472 if err != nil {
1473 return 0, err
1474 }
1475 i -= size
1476 i = encodeVarintExample(dAtA, i, uint64(size))
1477 }
1478 i--
1479 dAtA[i] = 0x12
1480 }
1481 if m.A != nil {
1482 {
1483 size, err := m.A.MarshalToSizedBuffer(dAtA[:i])
1484 if err != nil {
1485 return 0, err
1486 }
1487 i -= size
1488 i = encodeVarintExample(dAtA, i, uint64(size))
1489 }
1490 i--
1491 dAtA[i] = 0xa
1492 }
1493 return len(dAtA) - i, nil
1494 }
1495
1496 func (m *E) Marshal() (dAtA []byte, err error) {
1497 size := m.Size()
1498 dAtA = make([]byte, size)
1499 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1500 if err != nil {
1501 return nil, err
1502 }
1503 return dAtA[:n], nil
1504 }
1505
1506 func (m *E) MarshalTo(dAtA []byte) (int, error) {
1507 size := m.Size()
1508 return m.MarshalToSizedBuffer(dAtA[:size])
1509 }
1510
1511 func (m *E) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1512 i := len(dAtA)
1513 _ = i
1514 var l int
1515 _ = l
1516 if m.XXX_unrecognized != nil {
1517 i -= len(m.XXX_unrecognized)
1518 copy(dAtA[i:], m.XXX_unrecognized)
1519 }
1520 if m.XXX_extensions != nil {
1521 i -= len(m.XXX_extensions)
1522 copy(dAtA[i:], m.XXX_extensions)
1523 }
1524 return len(dAtA) - i, nil
1525 }
1526
1527 func (m *R) Marshal() (dAtA []byte, err error) {
1528 size := m.Size()
1529 dAtA = make([]byte, size)
1530 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1531 if err != nil {
1532 return nil, err
1533 }
1534 return dAtA[:n], nil
1535 }
1536
1537 func (m *R) MarshalTo(dAtA []byte) (int, error) {
1538 size := m.Size()
1539 return m.MarshalToSizedBuffer(dAtA[:size])
1540 }
1541
1542 func (m *R) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1543 i := len(dAtA)
1544 _ = i
1545 var l int
1546 _ = l
1547 if m.Recognized != nil {
1548 i = encodeVarintExample(dAtA, i, uint64(*m.Recognized))
1549 i--
1550 dAtA[i] = 0x8
1551 }
1552 return len(dAtA) - i, nil
1553 }
1554
1555 func (m *CastType) Marshal() (dAtA []byte, err error) {
1556 size := m.Size()
1557 dAtA = make([]byte, size)
1558 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1559 if err != nil {
1560 return nil, err
1561 }
1562 return dAtA[:n], nil
1563 }
1564
1565 func (m *CastType) MarshalTo(dAtA []byte) (int, error) {
1566 size := m.Size()
1567 return m.MarshalToSizedBuffer(dAtA[:size])
1568 }
1569
1570 func (m *CastType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1571 i := len(dAtA)
1572 _ = i
1573 var l int
1574 _ = l
1575 if m.XXX_unrecognized != nil {
1576 i -= len(m.XXX_unrecognized)
1577 copy(dAtA[i:], m.XXX_unrecognized)
1578 }
1579 if m.Int32 != nil {
1580 i = encodeVarintExample(dAtA, i, uint64(*m.Int32))
1581 i--
1582 dAtA[i] = 0x8
1583 }
1584 return len(dAtA) - i, nil
1585 }
1586
1587 func encodeVarintExample(dAtA []byte, offset int, v uint64) int {
1588 offset -= sovExample(v)
1589 base := offset
1590 for v >= 1<<7 {
1591 dAtA[offset] = uint8(v&0x7f | 0x80)
1592 v >>= 7
1593 offset++
1594 }
1595 dAtA[offset] = uint8(v)
1596 return base
1597 }
1598 func NewPopulatedA(r randyExample, easy bool) *A {
1599 this := &A{}
1600 this.Description = string(randStringExample(r))
1601 this.Number = int64(r.Int63())
1602 if r.Intn(2) == 0 {
1603 this.Number *= -1
1604 }
1605 v1 := github_com_gogo_protobuf_test.NewPopulatedUuid(r)
1606 this.Id = *v1
1607 if !easy && r.Intn(10) != 0 {
1608 this.XXX_unrecognized = randUnrecognizedExample(r, 4)
1609 }
1610 return this
1611 }
1612
1613 func NewPopulatedB(r randyExample, easy bool) *B {
1614 this := &B{}
1615 v2 := NewPopulatedA(r, easy)
1616 this.A = *v2
1617 if r.Intn(5) != 0 {
1618 v3 := r.Intn(10)
1619 this.G = make([]github_com_gogo_protobuf_test_custom.Uint128, v3)
1620 for i := 0; i < v3; i++ {
1621 v4 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
1622 this.G[i] = *v4
1623 }
1624 }
1625 if !easy && r.Intn(10) != 0 {
1626 this.XXX_unrecognized = randUnrecognizedExample(r, 3)
1627 }
1628 return this
1629 }
1630
1631 func NewPopulatedC(r randyExample, easy bool) *C {
1632 this := &C{}
1633 if r.Intn(5) != 0 {
1634 v5 := int64(r.Int63())
1635 if r.Intn(2) == 0 {
1636 v5 *= -1
1637 }
1638 this.MySize = &v5
1639 }
1640 if !easy && r.Intn(10) != 0 {
1641 this.XXX_unrecognized = randUnrecognizedExample(r, 2)
1642 }
1643 return this
1644 }
1645
1646 func NewPopulatedU(r randyExample, easy bool) *U {
1647 this := &U{}
1648 fieldNum := r.Intn(2)
1649 switch fieldNum {
1650 case 0:
1651 this.A = NewPopulatedA(r, easy)
1652 case 1:
1653 this.B = NewPopulatedB(r, easy)
1654 }
1655 return this
1656 }
1657
1658 func NewPopulatedE(r randyExample, easy bool) *E {
1659 this := &E{}
1660 if !easy && r.Intn(10) != 0 {
1661 l := r.Intn(5)
1662 for i := 0; i < l; i++ {
1663 fieldNumber := r.Intn(536870911) + 1
1664 wire := r.Intn(4)
1665 if wire == 3 {
1666 wire = 5
1667 }
1668 dAtA := randFieldExample(nil, r, fieldNumber, wire)
1669 github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), dAtA)
1670 }
1671 }
1672 return this
1673 }
1674
1675 func NewPopulatedR(r randyExample, easy bool) *R {
1676 this := &R{}
1677 if r.Intn(5) != 0 {
1678 v6 := uint32(r.Uint32())
1679 this.Recognized = &v6
1680 }
1681 if !easy && r.Intn(10) != 0 {
1682 }
1683 return this
1684 }
1685
1686 func NewPopulatedCastType(r randyExample, easy bool) *CastType {
1687 this := &CastType{}
1688 if r.Intn(5) != 0 {
1689 v7 := int32(r.Int63())
1690 if r.Intn(2) == 0 {
1691 v7 *= -1
1692 }
1693 this.Int32 = &v7
1694 }
1695 if !easy && r.Intn(10) != 0 {
1696 this.XXX_unrecognized = randUnrecognizedExample(r, 2)
1697 }
1698 return this
1699 }
1700
1701 type randyExample interface {
1702 Float32() float32
1703 Float64() float64
1704 Int63() int64
1705 Int31() int32
1706 Uint32() uint32
1707 Intn(n int) int
1708 }
1709
1710 func randUTF8RuneExample(r randyExample) rune {
1711 ru := r.Intn(62)
1712 if ru < 10 {
1713 return rune(ru + 48)
1714 } else if ru < 36 {
1715 return rune(ru + 55)
1716 }
1717 return rune(ru + 61)
1718 }
1719 func randStringExample(r randyExample) string {
1720 v8 := r.Intn(100)
1721 tmps := make([]rune, v8)
1722 for i := 0; i < v8; i++ {
1723 tmps[i] = randUTF8RuneExample(r)
1724 }
1725 return string(tmps)
1726 }
1727 func randUnrecognizedExample(r randyExample, maxFieldNumber int) (dAtA []byte) {
1728 l := r.Intn(5)
1729 for i := 0; i < l; i++ {
1730 wire := r.Intn(4)
1731 if wire == 3 {
1732 wire = 5
1733 }
1734 fieldNumber := maxFieldNumber + r.Intn(100)
1735 dAtA = randFieldExample(dAtA, r, fieldNumber, wire)
1736 }
1737 return dAtA
1738 }
1739 func randFieldExample(dAtA []byte, r randyExample, fieldNumber int, wire int) []byte {
1740 key := uint32(fieldNumber)<<3 | uint32(wire)
1741 switch wire {
1742 case 0:
1743 dAtA = encodeVarintPopulateExample(dAtA, uint64(key))
1744 v9 := r.Int63()
1745 if r.Intn(2) == 0 {
1746 v9 *= -1
1747 }
1748 dAtA = encodeVarintPopulateExample(dAtA, uint64(v9))
1749 case 1:
1750 dAtA = encodeVarintPopulateExample(dAtA, uint64(key))
1751 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)))
1752 case 2:
1753 dAtA = encodeVarintPopulateExample(dAtA, uint64(key))
1754 ll := r.Intn(100)
1755 dAtA = encodeVarintPopulateExample(dAtA, uint64(ll))
1756 for j := 0; j < ll; j++ {
1757 dAtA = append(dAtA, byte(r.Intn(256)))
1758 }
1759 default:
1760 dAtA = encodeVarintPopulateExample(dAtA, uint64(key))
1761 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
1762 }
1763 return dAtA
1764 }
1765 func encodeVarintPopulateExample(dAtA []byte, v uint64) []byte {
1766 for v >= 1<<7 {
1767 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
1768 v >>= 7
1769 }
1770 dAtA = append(dAtA, uint8(v))
1771 return dAtA
1772 }
1773 func (m *A) Size() (n int) {
1774 if m == nil {
1775 return 0
1776 }
1777 var l int
1778 _ = l
1779 l = len(m.Description)
1780 n += 1 + l + sovExample(uint64(l))
1781 n += 1 + sovExample(uint64(m.Number))
1782 l = m.Id.Size()
1783 n += 1 + l + sovExample(uint64(l))
1784 if m.XXX_unrecognized != nil {
1785 n += len(m.XXX_unrecognized)
1786 }
1787 return n
1788 }
1789
1790 func (m *B) Size() (n int) {
1791 if m == nil {
1792 return 0
1793 }
1794 var l int
1795 _ = l
1796 l = m.A.Size()
1797 n += 1 + l + sovExample(uint64(l))
1798 if len(m.G) > 0 {
1799 for _, e := range m.G {
1800 l = e.Size()
1801 n += 1 + l + sovExample(uint64(l))
1802 }
1803 }
1804 if m.XXX_unrecognized != nil {
1805 n += len(m.XXX_unrecognized)
1806 }
1807 return n
1808 }
1809
1810 func (m *C) Size() (n int) {
1811 if m == nil {
1812 return 0
1813 }
1814 var l int
1815 _ = l
1816 if m.MySize != nil {
1817 n += 1 + sovExample(uint64(*m.MySize))
1818 }
1819 if m.XXX_unrecognized != nil {
1820 n += len(m.XXX_unrecognized)
1821 }
1822 return n
1823 }
1824
1825 func (m *U) Size() (n int) {
1826 if m == nil {
1827 return 0
1828 }
1829 var l int
1830 _ = l
1831 if m.A != nil {
1832 l = m.A.Size()
1833 n += 1 + l + sovExample(uint64(l))
1834 }
1835 if m.B != nil {
1836 l = m.B.Size()
1837 n += 1 + l + sovExample(uint64(l))
1838 }
1839 if m.XXX_unrecognized != nil {
1840 n += len(m.XXX_unrecognized)
1841 }
1842 return n
1843 }
1844
1845 func (m *E) Size() (n int) {
1846 if m == nil {
1847 return 0
1848 }
1849 var l int
1850 _ = l
1851 if m.XXX_extensions != nil {
1852 n += len(m.XXX_extensions)
1853 }
1854 if m.XXX_unrecognized != nil {
1855 n += len(m.XXX_unrecognized)
1856 }
1857 return n
1858 }
1859
1860 func (m *R) Size() (n int) {
1861 if m == nil {
1862 return 0
1863 }
1864 var l int
1865 _ = l
1866 if m.Recognized != nil {
1867 n += 1 + sovExample(uint64(*m.Recognized))
1868 }
1869 return n
1870 }
1871
1872 func (m *CastType) Size() (n int) {
1873 if m == nil {
1874 return 0
1875 }
1876 var l int
1877 _ = l
1878 if m.Int32 != nil {
1879 n += 1 + sovExample(uint64(*m.Int32))
1880 }
1881 if m.XXX_unrecognized != nil {
1882 n += len(m.XXX_unrecognized)
1883 }
1884 return n
1885 }
1886
1887 func sovExample(x uint64) (n int) {
1888 return (math_bits.Len64(x|1) + 6) / 7
1889 }
1890 func sozExample(x uint64) (n int) {
1891 return sovExample(uint64((x << 1) ^ uint64((int64(x) >> 63))))
1892 }
1893 func (this *A) String() string {
1894 if this == nil {
1895 return "nil"
1896 }
1897 s := strings.Join([]string{`&A{`,
1898 `Description:` + fmt.Sprintf("%v", this.Description) + `,`,
1899 `Number:` + fmt.Sprintf("%v", this.Number) + `,`,
1900 `Id:` + fmt.Sprintf("%v", this.Id) + `,`,
1901 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1902 `}`,
1903 }, "")
1904 return s
1905 }
1906 func (this *B) String() string {
1907 if this == nil {
1908 return "nil"
1909 }
1910 s := strings.Join([]string{`&B{`,
1911 `A:` + strings.Replace(strings.Replace(this.A.String(), "A", "A", 1), `&`, ``, 1) + `,`,
1912 `G:` + fmt.Sprintf("%v", this.G) + `,`,
1913 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1914 `}`,
1915 }, "")
1916 return s
1917 }
1918 func (this *C) String() string {
1919 if this == nil {
1920 return "nil"
1921 }
1922 s := strings.Join([]string{`&C{`,
1923 `MySize:` + valueToStringExample(this.MySize) + `,`,
1924 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1925 `}`,
1926 }, "")
1927 return s
1928 }
1929 func (this *U) String() string {
1930 if this == nil {
1931 return "nil"
1932 }
1933 s := strings.Join([]string{`&U{`,
1934 `A:` + strings.Replace(this.A.String(), "A", "A", 1) + `,`,
1935 `B:` + strings.Replace(this.B.String(), "B", "B", 1) + `,`,
1936 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1937 `}`,
1938 }, "")
1939 return s
1940 }
1941 func (this *E) String() string {
1942 if this == nil {
1943 return "nil"
1944 }
1945 s := strings.Join([]string{`&E{`,
1946 `XXX_extensions:` + github_com_gogo_protobuf_proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`,
1947 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1948 `}`,
1949 }, "")
1950 return s
1951 }
1952 func (this *R) String() string {
1953 if this == nil {
1954 return "nil"
1955 }
1956 s := strings.Join([]string{`&R{`,
1957 `Recognized:` + valueToStringExample(this.Recognized) + `,`,
1958 `}`,
1959 }, "")
1960 return s
1961 }
1962 func (this *CastType) String() string {
1963 if this == nil {
1964 return "nil"
1965 }
1966 s := strings.Join([]string{`&CastType{`,
1967 `Int32:` + valueToStringExample(this.Int32) + `,`,
1968 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
1969 `}`,
1970 }, "")
1971 return s
1972 }
1973 func valueToStringExample(v interface{}) string {
1974 rv := reflect.ValueOf(v)
1975 if rv.IsNil() {
1976 return "nil"
1977 }
1978 pv := reflect.Indirect(rv).Interface()
1979 return fmt.Sprintf("*%v", pv)
1980 }
1981 func (this *U) GetValue() interface{} {
1982 if this.A != nil {
1983 return this.A
1984 }
1985 if this.B != nil {
1986 return this.B
1987 }
1988 return nil
1989 }
1990
1991 func (this *U) SetValue(value interface{}) bool {
1992 switch vt := value.(type) {
1993 case *A:
1994 this.A = vt
1995 case *B:
1996 this.B = vt
1997 default:
1998 return false
1999 }
2000 return true
2001 }
2002 func (m *A) Unmarshal(dAtA []byte) error {
2003 l := len(dAtA)
2004 iNdEx := 0
2005 for iNdEx < l {
2006 preIndex := iNdEx
2007 var wire uint64
2008 for shift := uint(0); ; shift += 7 {
2009 if shift >= 64 {
2010 return ErrIntOverflowExample
2011 }
2012 if iNdEx >= l {
2013 return io.ErrUnexpectedEOF
2014 }
2015 b := dAtA[iNdEx]
2016 iNdEx++
2017 wire |= uint64(b&0x7F) << shift
2018 if b < 0x80 {
2019 break
2020 }
2021 }
2022 fieldNum := int32(wire >> 3)
2023 wireType := int(wire & 0x7)
2024 if wireType == 4 {
2025 return fmt.Errorf("proto: A: wiretype end group for non-group")
2026 }
2027 if fieldNum <= 0 {
2028 return fmt.Errorf("proto: A: illegal tag %d (wire type %d)", fieldNum, wire)
2029 }
2030 switch fieldNum {
2031 case 1:
2032 if wireType != 2 {
2033 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
2034 }
2035 var stringLen uint64
2036 for shift := uint(0); ; shift += 7 {
2037 if shift >= 64 {
2038 return ErrIntOverflowExample
2039 }
2040 if iNdEx >= l {
2041 return io.ErrUnexpectedEOF
2042 }
2043 b := dAtA[iNdEx]
2044 iNdEx++
2045 stringLen |= uint64(b&0x7F) << shift
2046 if b < 0x80 {
2047 break
2048 }
2049 }
2050 intStringLen := int(stringLen)
2051 if intStringLen < 0 {
2052 return ErrInvalidLengthExample
2053 }
2054 postIndex := iNdEx + intStringLen
2055 if postIndex < 0 {
2056 return ErrInvalidLengthExample
2057 }
2058 if postIndex > l {
2059 return io.ErrUnexpectedEOF
2060 }
2061 m.Description = string(dAtA[iNdEx:postIndex])
2062 iNdEx = postIndex
2063 case 2:
2064 if wireType != 0 {
2065 return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType)
2066 }
2067 m.Number = 0
2068 for shift := uint(0); ; shift += 7 {
2069 if shift >= 64 {
2070 return ErrIntOverflowExample
2071 }
2072 if iNdEx >= l {
2073 return io.ErrUnexpectedEOF
2074 }
2075 b := dAtA[iNdEx]
2076 iNdEx++
2077 m.Number |= int64(b&0x7F) << shift
2078 if b < 0x80 {
2079 break
2080 }
2081 }
2082 case 3:
2083 if wireType != 2 {
2084 return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
2085 }
2086 var byteLen int
2087 for shift := uint(0); ; shift += 7 {
2088 if shift >= 64 {
2089 return ErrIntOverflowExample
2090 }
2091 if iNdEx >= l {
2092 return io.ErrUnexpectedEOF
2093 }
2094 b := dAtA[iNdEx]
2095 iNdEx++
2096 byteLen |= int(b&0x7F) << shift
2097 if b < 0x80 {
2098 break
2099 }
2100 }
2101 if byteLen < 0 {
2102 return ErrInvalidLengthExample
2103 }
2104 postIndex := iNdEx + byteLen
2105 if postIndex < 0 {
2106 return ErrInvalidLengthExample
2107 }
2108 if postIndex > l {
2109 return io.ErrUnexpectedEOF
2110 }
2111 if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2112 return err
2113 }
2114 iNdEx = postIndex
2115 default:
2116 iNdEx = preIndex
2117 skippy, err := skipExample(dAtA[iNdEx:])
2118 if err != nil {
2119 return err
2120 }
2121 if (skippy < 0) || (iNdEx+skippy) < 0 {
2122 return ErrInvalidLengthExample
2123 }
2124 if (iNdEx + skippy) > l {
2125 return io.ErrUnexpectedEOF
2126 }
2127 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2128 iNdEx += skippy
2129 }
2130 }
2131
2132 if iNdEx > l {
2133 return io.ErrUnexpectedEOF
2134 }
2135 return nil
2136 }
2137 func (m *B) Unmarshal(dAtA []byte) error {
2138 l := len(dAtA)
2139 iNdEx := 0
2140 for iNdEx < l {
2141 preIndex := iNdEx
2142 var wire uint64
2143 for shift := uint(0); ; shift += 7 {
2144 if shift >= 64 {
2145 return ErrIntOverflowExample
2146 }
2147 if iNdEx >= l {
2148 return io.ErrUnexpectedEOF
2149 }
2150 b := dAtA[iNdEx]
2151 iNdEx++
2152 wire |= uint64(b&0x7F) << shift
2153 if b < 0x80 {
2154 break
2155 }
2156 }
2157 fieldNum := int32(wire >> 3)
2158 wireType := int(wire & 0x7)
2159 if wireType == 4 {
2160 return fmt.Errorf("proto: B: wiretype end group for non-group")
2161 }
2162 if fieldNum <= 0 {
2163 return fmt.Errorf("proto: B: illegal tag %d (wire type %d)", fieldNum, wire)
2164 }
2165 switch fieldNum {
2166 case 1:
2167 if wireType != 2 {
2168 return fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
2169 }
2170 var msglen int
2171 for shift := uint(0); ; shift += 7 {
2172 if shift >= 64 {
2173 return ErrIntOverflowExample
2174 }
2175 if iNdEx >= l {
2176 return io.ErrUnexpectedEOF
2177 }
2178 b := dAtA[iNdEx]
2179 iNdEx++
2180 msglen |= int(b&0x7F) << shift
2181 if b < 0x80 {
2182 break
2183 }
2184 }
2185 if msglen < 0 {
2186 return ErrInvalidLengthExample
2187 }
2188 postIndex := iNdEx + msglen
2189 if postIndex < 0 {
2190 return ErrInvalidLengthExample
2191 }
2192 if postIndex > l {
2193 return io.ErrUnexpectedEOF
2194 }
2195 if err := m.A.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2196 return err
2197 }
2198 iNdEx = postIndex
2199 case 2:
2200 if wireType != 2 {
2201 return fmt.Errorf("proto: wrong wireType = %d for field G", wireType)
2202 }
2203 var byteLen int
2204 for shift := uint(0); ; shift += 7 {
2205 if shift >= 64 {
2206 return ErrIntOverflowExample
2207 }
2208 if iNdEx >= l {
2209 return io.ErrUnexpectedEOF
2210 }
2211 b := dAtA[iNdEx]
2212 iNdEx++
2213 byteLen |= int(b&0x7F) << shift
2214 if b < 0x80 {
2215 break
2216 }
2217 }
2218 if byteLen < 0 {
2219 return ErrInvalidLengthExample
2220 }
2221 postIndex := iNdEx + byteLen
2222 if postIndex < 0 {
2223 return ErrInvalidLengthExample
2224 }
2225 if postIndex > l {
2226 return io.ErrUnexpectedEOF
2227 }
2228 var v github_com_gogo_protobuf_test_custom.Uint128
2229 m.G = append(m.G, v)
2230 if err := m.G[len(m.G)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2231 return err
2232 }
2233 iNdEx = postIndex
2234 default:
2235 iNdEx = preIndex
2236 skippy, err := skipExample(dAtA[iNdEx:])
2237 if err != nil {
2238 return err
2239 }
2240 if (skippy < 0) || (iNdEx+skippy) < 0 {
2241 return ErrInvalidLengthExample
2242 }
2243 if (iNdEx + skippy) > l {
2244 return io.ErrUnexpectedEOF
2245 }
2246 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2247 iNdEx += skippy
2248 }
2249 }
2250
2251 if iNdEx > l {
2252 return io.ErrUnexpectedEOF
2253 }
2254 return nil
2255 }
2256 func (m *C) Unmarshal(dAtA []byte) error {
2257 l := len(dAtA)
2258 iNdEx := 0
2259 for iNdEx < l {
2260 preIndex := iNdEx
2261 var wire uint64
2262 for shift := uint(0); ; shift += 7 {
2263 if shift >= 64 {
2264 return ErrIntOverflowExample
2265 }
2266 if iNdEx >= l {
2267 return io.ErrUnexpectedEOF
2268 }
2269 b := dAtA[iNdEx]
2270 iNdEx++
2271 wire |= uint64(b&0x7F) << shift
2272 if b < 0x80 {
2273 break
2274 }
2275 }
2276 fieldNum := int32(wire >> 3)
2277 wireType := int(wire & 0x7)
2278 if wireType == 4 {
2279 return fmt.Errorf("proto: C: wiretype end group for non-group")
2280 }
2281 if fieldNum <= 0 {
2282 return fmt.Errorf("proto: C: illegal tag %d (wire type %d)", fieldNum, wire)
2283 }
2284 switch fieldNum {
2285 case 1:
2286 if wireType != 0 {
2287 return fmt.Errorf("proto: wrong wireType = %d for field MySize", wireType)
2288 }
2289 var v int64
2290 for shift := uint(0); ; shift += 7 {
2291 if shift >= 64 {
2292 return ErrIntOverflowExample
2293 }
2294 if iNdEx >= l {
2295 return io.ErrUnexpectedEOF
2296 }
2297 b := dAtA[iNdEx]
2298 iNdEx++
2299 v |= int64(b&0x7F) << shift
2300 if b < 0x80 {
2301 break
2302 }
2303 }
2304 m.MySize = &v
2305 default:
2306 iNdEx = preIndex
2307 skippy, err := skipExample(dAtA[iNdEx:])
2308 if err != nil {
2309 return err
2310 }
2311 if (skippy < 0) || (iNdEx+skippy) < 0 {
2312 return ErrInvalidLengthExample
2313 }
2314 if (iNdEx + skippy) > l {
2315 return io.ErrUnexpectedEOF
2316 }
2317 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2318 iNdEx += skippy
2319 }
2320 }
2321
2322 if iNdEx > l {
2323 return io.ErrUnexpectedEOF
2324 }
2325 return nil
2326 }
2327 func (m *U) Unmarshal(dAtA []byte) error {
2328 l := len(dAtA)
2329 iNdEx := 0
2330 for iNdEx < l {
2331 preIndex := iNdEx
2332 var wire uint64
2333 for shift := uint(0); ; shift += 7 {
2334 if shift >= 64 {
2335 return ErrIntOverflowExample
2336 }
2337 if iNdEx >= l {
2338 return io.ErrUnexpectedEOF
2339 }
2340 b := dAtA[iNdEx]
2341 iNdEx++
2342 wire |= uint64(b&0x7F) << shift
2343 if b < 0x80 {
2344 break
2345 }
2346 }
2347 fieldNum := int32(wire >> 3)
2348 wireType := int(wire & 0x7)
2349 if wireType == 4 {
2350 return fmt.Errorf("proto: U: wiretype end group for non-group")
2351 }
2352 if fieldNum <= 0 {
2353 return fmt.Errorf("proto: U: illegal tag %d (wire type %d)", fieldNum, wire)
2354 }
2355 switch fieldNum {
2356 case 1:
2357 if wireType != 2 {
2358 return fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
2359 }
2360 var msglen int
2361 for shift := uint(0); ; shift += 7 {
2362 if shift >= 64 {
2363 return ErrIntOverflowExample
2364 }
2365 if iNdEx >= l {
2366 return io.ErrUnexpectedEOF
2367 }
2368 b := dAtA[iNdEx]
2369 iNdEx++
2370 msglen |= int(b&0x7F) << shift
2371 if b < 0x80 {
2372 break
2373 }
2374 }
2375 if msglen < 0 {
2376 return ErrInvalidLengthExample
2377 }
2378 postIndex := iNdEx + msglen
2379 if postIndex < 0 {
2380 return ErrInvalidLengthExample
2381 }
2382 if postIndex > l {
2383 return io.ErrUnexpectedEOF
2384 }
2385 if m.A == nil {
2386 m.A = &A{}
2387 }
2388 if err := m.A.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2389 return err
2390 }
2391 iNdEx = postIndex
2392 case 2:
2393 if wireType != 2 {
2394 return fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
2395 }
2396 var msglen int
2397 for shift := uint(0); ; shift += 7 {
2398 if shift >= 64 {
2399 return ErrIntOverflowExample
2400 }
2401 if iNdEx >= l {
2402 return io.ErrUnexpectedEOF
2403 }
2404 b := dAtA[iNdEx]
2405 iNdEx++
2406 msglen |= int(b&0x7F) << shift
2407 if b < 0x80 {
2408 break
2409 }
2410 }
2411 if msglen < 0 {
2412 return ErrInvalidLengthExample
2413 }
2414 postIndex := iNdEx + msglen
2415 if postIndex < 0 {
2416 return ErrInvalidLengthExample
2417 }
2418 if postIndex > l {
2419 return io.ErrUnexpectedEOF
2420 }
2421 if m.B == nil {
2422 m.B = &B{}
2423 }
2424 if err := m.B.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2425 return err
2426 }
2427 iNdEx = postIndex
2428 default:
2429 iNdEx = preIndex
2430 skippy, err := skipExample(dAtA[iNdEx:])
2431 if err != nil {
2432 return err
2433 }
2434 if (skippy < 0) || (iNdEx+skippy) < 0 {
2435 return ErrInvalidLengthExample
2436 }
2437 if (iNdEx + skippy) > l {
2438 return io.ErrUnexpectedEOF
2439 }
2440 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2441 iNdEx += skippy
2442 }
2443 }
2444
2445 if iNdEx > l {
2446 return io.ErrUnexpectedEOF
2447 }
2448 return nil
2449 }
2450 func (m *E) Unmarshal(dAtA []byte) error {
2451 l := len(dAtA)
2452 iNdEx := 0
2453 for iNdEx < l {
2454 preIndex := iNdEx
2455 var wire uint64
2456 for shift := uint(0); ; shift += 7 {
2457 if shift >= 64 {
2458 return ErrIntOverflowExample
2459 }
2460 if iNdEx >= l {
2461 return io.ErrUnexpectedEOF
2462 }
2463 b := dAtA[iNdEx]
2464 iNdEx++
2465 wire |= uint64(b&0x7F) << shift
2466 if b < 0x80 {
2467 break
2468 }
2469 }
2470 fieldNum := int32(wire >> 3)
2471 wireType := int(wire & 0x7)
2472 if wireType == 4 {
2473 return fmt.Errorf("proto: E: wiretype end group for non-group")
2474 }
2475 if fieldNum <= 0 {
2476 return fmt.Errorf("proto: E: illegal tag %d (wire type %d)", fieldNum, wire)
2477 }
2478 switch fieldNum {
2479 default:
2480 if (fieldNum >= 1) && (fieldNum < 536870912) {
2481 var sizeOfWire int
2482 for {
2483 sizeOfWire++
2484 wire >>= 7
2485 if wire == 0 {
2486 break
2487 }
2488 }
2489 iNdEx -= sizeOfWire
2490 skippy, err := skipExample(dAtA[iNdEx:])
2491 if err != nil {
2492 return err
2493 }
2494 if (skippy < 0) || (iNdEx+skippy) < 0 {
2495 return ErrInvalidLengthExample
2496 }
2497 if (iNdEx + skippy) > l {
2498 return io.ErrUnexpectedEOF
2499 }
2500 github_com_gogo_protobuf_proto.AppendExtension(m, int32(fieldNum), dAtA[iNdEx:iNdEx+skippy])
2501 iNdEx += skippy
2502 } else {
2503 iNdEx = preIndex
2504 skippy, err := skipExample(dAtA[iNdEx:])
2505 if err != nil {
2506 return err
2507 }
2508 if (skippy < 0) || (iNdEx+skippy) < 0 {
2509 return ErrInvalidLengthExample
2510 }
2511 if (iNdEx + skippy) > l {
2512 return io.ErrUnexpectedEOF
2513 }
2514 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2515 iNdEx += skippy
2516 }
2517 }
2518 }
2519
2520 if iNdEx > l {
2521 return io.ErrUnexpectedEOF
2522 }
2523 return nil
2524 }
2525 func (m *R) Unmarshal(dAtA []byte) error {
2526 l := len(dAtA)
2527 iNdEx := 0
2528 for iNdEx < l {
2529 preIndex := iNdEx
2530 var wire uint64
2531 for shift := uint(0); ; shift += 7 {
2532 if shift >= 64 {
2533 return ErrIntOverflowExample
2534 }
2535 if iNdEx >= l {
2536 return io.ErrUnexpectedEOF
2537 }
2538 b := dAtA[iNdEx]
2539 iNdEx++
2540 wire |= uint64(b&0x7F) << shift
2541 if b < 0x80 {
2542 break
2543 }
2544 }
2545 fieldNum := int32(wire >> 3)
2546 wireType := int(wire & 0x7)
2547 if wireType == 4 {
2548 return fmt.Errorf("proto: R: wiretype end group for non-group")
2549 }
2550 if fieldNum <= 0 {
2551 return fmt.Errorf("proto: R: illegal tag %d (wire type %d)", fieldNum, wire)
2552 }
2553 switch fieldNum {
2554 case 1:
2555 if wireType != 0 {
2556 return fmt.Errorf("proto: wrong wireType = %d for field Recognized", wireType)
2557 }
2558 var v uint32
2559 for shift := uint(0); ; shift += 7 {
2560 if shift >= 64 {
2561 return ErrIntOverflowExample
2562 }
2563 if iNdEx >= l {
2564 return io.ErrUnexpectedEOF
2565 }
2566 b := dAtA[iNdEx]
2567 iNdEx++
2568 v |= uint32(b&0x7F) << shift
2569 if b < 0x80 {
2570 break
2571 }
2572 }
2573 m.Recognized = &v
2574 default:
2575 iNdEx = preIndex
2576 skippy, err := skipExample(dAtA[iNdEx:])
2577 if err != nil {
2578 return err
2579 }
2580 if (skippy < 0) || (iNdEx+skippy) < 0 {
2581 return ErrInvalidLengthExample
2582 }
2583 if (iNdEx + skippy) > l {
2584 return io.ErrUnexpectedEOF
2585 }
2586 iNdEx += skippy
2587 }
2588 }
2589
2590 if iNdEx > l {
2591 return io.ErrUnexpectedEOF
2592 }
2593 return nil
2594 }
2595 func (m *CastType) Unmarshal(dAtA []byte) error {
2596 l := len(dAtA)
2597 iNdEx := 0
2598 for iNdEx < l {
2599 preIndex := iNdEx
2600 var wire uint64
2601 for shift := uint(0); ; shift += 7 {
2602 if shift >= 64 {
2603 return ErrIntOverflowExample
2604 }
2605 if iNdEx >= l {
2606 return io.ErrUnexpectedEOF
2607 }
2608 b := dAtA[iNdEx]
2609 iNdEx++
2610 wire |= uint64(b&0x7F) << shift
2611 if b < 0x80 {
2612 break
2613 }
2614 }
2615 fieldNum := int32(wire >> 3)
2616 wireType := int(wire & 0x7)
2617 if wireType == 4 {
2618 return fmt.Errorf("proto: CastType: wiretype end group for non-group")
2619 }
2620 if fieldNum <= 0 {
2621 return fmt.Errorf("proto: CastType: illegal tag %d (wire type %d)", fieldNum, wire)
2622 }
2623 switch fieldNum {
2624 case 1:
2625 if wireType != 0 {
2626 return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType)
2627 }
2628 var v int32
2629 for shift := uint(0); ; shift += 7 {
2630 if shift >= 64 {
2631 return ErrIntOverflowExample
2632 }
2633 if iNdEx >= l {
2634 return io.ErrUnexpectedEOF
2635 }
2636 b := dAtA[iNdEx]
2637 iNdEx++
2638 v |= int32(b&0x7F) << shift
2639 if b < 0x80 {
2640 break
2641 }
2642 }
2643 m.Int32 = &v
2644 default:
2645 iNdEx = preIndex
2646 skippy, err := skipExample(dAtA[iNdEx:])
2647 if err != nil {
2648 return err
2649 }
2650 if (skippy < 0) || (iNdEx+skippy) < 0 {
2651 return ErrInvalidLengthExample
2652 }
2653 if (iNdEx + skippy) > l {
2654 return io.ErrUnexpectedEOF
2655 }
2656 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
2657 iNdEx += skippy
2658 }
2659 }
2660
2661 if iNdEx > l {
2662 return io.ErrUnexpectedEOF
2663 }
2664 return nil
2665 }
2666 func skipExample(dAtA []byte) (n int, err error) {
2667 l := len(dAtA)
2668 iNdEx := 0
2669 depth := 0
2670 for iNdEx < l {
2671 var wire uint64
2672 for shift := uint(0); ; shift += 7 {
2673 if shift >= 64 {
2674 return 0, ErrIntOverflowExample
2675 }
2676 if iNdEx >= l {
2677 return 0, io.ErrUnexpectedEOF
2678 }
2679 b := dAtA[iNdEx]
2680 iNdEx++
2681 wire |= (uint64(b) & 0x7F) << shift
2682 if b < 0x80 {
2683 break
2684 }
2685 }
2686 wireType := int(wire & 0x7)
2687 switch wireType {
2688 case 0:
2689 for shift := uint(0); ; shift += 7 {
2690 if shift >= 64 {
2691 return 0, ErrIntOverflowExample
2692 }
2693 if iNdEx >= l {
2694 return 0, io.ErrUnexpectedEOF
2695 }
2696 iNdEx++
2697 if dAtA[iNdEx-1] < 0x80 {
2698 break
2699 }
2700 }
2701 case 1:
2702 iNdEx += 8
2703 case 2:
2704 var length int
2705 for shift := uint(0); ; shift += 7 {
2706 if shift >= 64 {
2707 return 0, ErrIntOverflowExample
2708 }
2709 if iNdEx >= l {
2710 return 0, io.ErrUnexpectedEOF
2711 }
2712 b := dAtA[iNdEx]
2713 iNdEx++
2714 length |= (int(b) & 0x7F) << shift
2715 if b < 0x80 {
2716 break
2717 }
2718 }
2719 if length < 0 {
2720 return 0, ErrInvalidLengthExample
2721 }
2722 iNdEx += length
2723 case 3:
2724 depth++
2725 case 4:
2726 if depth == 0 {
2727 return 0, ErrUnexpectedEndOfGroupExample
2728 }
2729 depth--
2730 case 5:
2731 iNdEx += 4
2732 default:
2733 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
2734 }
2735 if iNdEx < 0 {
2736 return 0, ErrInvalidLengthExample
2737 }
2738 if depth == 0 {
2739 return iNdEx, nil
2740 }
2741 }
2742 return 0, io.ErrUnexpectedEOF
2743 }
2744
2745 var (
2746 ErrInvalidLengthExample = fmt.Errorf("proto: negative length found during unmarshaling")
2747 ErrIntOverflowExample = fmt.Errorf("proto: integer overflow")
2748 ErrUnexpectedEndOfGroupExample = fmt.Errorf("proto: unexpected end of group")
2749 )
2750
View as plain text