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

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

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

View as plain text