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