Source file src/github.com/gogo/protobuf/test/packed/packed.pb.go

Documentation: github.com/gogo/protobuf/test/packed

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

View as plain text