mirror of
https://github.com/octoleo/syncthing.git
synced 2024-11-10 15:20:56 +00:00
fa0101bd60
This changes the BEP protocol to use protocol buffer serialization instead of XDR, and therefore also the database format. The local discovery protocol is also updated to be protocol buffer format. GitHub-Pull-Request: https://github.com/syncthing/syncthing/pull/3276 LGTM: AudriusButkevicius
2933 lines
69 KiB
Go
2933 lines
69 KiB
Go
// Code generated by protoc-gen-gogo.
|
|
// source: fuzz.proto
|
|
// DO NOT EDIT!
|
|
|
|
/*
|
|
Package fuzztests is a generated protocol buffer package.
|
|
|
|
It is generated from these files:
|
|
fuzz.proto
|
|
|
|
It has these top-level messages:
|
|
Nil
|
|
NinRepPackedNative
|
|
NinOptNative
|
|
NinOptStruct
|
|
*/
|
|
package fuzztests
|
|
|
|
import proto "github.com/gogo/protobuf/proto"
|
|
import fmt "fmt"
|
|
import math "math"
|
|
import _ "github.com/gogo/protobuf/gogoproto"
|
|
|
|
import strings "strings"
|
|
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
|
|
import sort "sort"
|
|
import strconv "strconv"
|
|
import reflect "reflect"
|
|
|
|
import io "io"
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the proto package it is being compiled against.
|
|
const _ = proto.GoGoProtoPackageIsVersion1
|
|
|
|
type Nil struct {
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *Nil) Reset() { *m = Nil{} }
|
|
func (m *Nil) String() string { return proto.CompactTextString(m) }
|
|
func (*Nil) ProtoMessage() {}
|
|
func (*Nil) Descriptor() ([]byte, []int) { return fileDescriptorFuzz, []int{0} }
|
|
|
|
type NinRepPackedNative struct {
|
|
Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1,json=field1" json:"Field1,omitempty"`
|
|
Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2,json=field2" json:"Field2,omitempty"`
|
|
Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3,json=field3" json:"Field3,omitempty"`
|
|
Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4,json=field4" json:"Field4,omitempty"`
|
|
Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5,json=field5" json:"Field5,omitempty"`
|
|
Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6,json=field6" json:"Field6,omitempty"`
|
|
Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7,json=field7" json:"Field7,omitempty"`
|
|
Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8,json=field8" json:"Field8,omitempty"`
|
|
Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9,json=field9" json:"Field9,omitempty"`
|
|
Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10,json=field10" json:"Field10,omitempty"`
|
|
Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11,json=field11" json:"Field11,omitempty"`
|
|
Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12,json=field12" json:"Field12,omitempty"`
|
|
Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13,json=field13" json:"Field13,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} }
|
|
func (m *NinRepPackedNative) String() string { return proto.CompactTextString(m) }
|
|
func (*NinRepPackedNative) ProtoMessage() {}
|
|
func (*NinRepPackedNative) Descriptor() ([]byte, []int) { return fileDescriptorFuzz, []int{1} }
|
|
|
|
func (m *NinRepPackedNative) GetField1() []float64 {
|
|
if m != nil {
|
|
return m.Field1
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField2() []float32 {
|
|
if m != nil {
|
|
return m.Field2
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField3() []int32 {
|
|
if m != nil {
|
|
return m.Field3
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField4() []int64 {
|
|
if m != nil {
|
|
return m.Field4
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField5() []uint32 {
|
|
if m != nil {
|
|
return m.Field5
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField6() []uint64 {
|
|
if m != nil {
|
|
return m.Field6
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField7() []int32 {
|
|
if m != nil {
|
|
return m.Field7
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField8() []int64 {
|
|
if m != nil {
|
|
return m.Field8
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField9() []uint32 {
|
|
if m != nil {
|
|
return m.Field9
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField10() []int32 {
|
|
if m != nil {
|
|
return m.Field10
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField11() []uint64 {
|
|
if m != nil {
|
|
return m.Field11
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField12() []int64 {
|
|
if m != nil {
|
|
return m.Field12
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) GetField13() []bool {
|
|
if m != nil {
|
|
return m.Field13
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type NinOptNative struct {
|
|
Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1,json=field1" json:"Field1,omitempty"`
|
|
Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2,json=field2" json:"Field2,omitempty"`
|
|
Field3 *int32 `protobuf:"varint,3,opt,name=Field3,json=field3" json:"Field3,omitempty"`
|
|
Field4 *int64 `protobuf:"varint,4,opt,name=Field4,json=field4" json:"Field4,omitempty"`
|
|
Field5 *uint32 `protobuf:"varint,5,opt,name=Field5,json=field5" json:"Field5,omitempty"`
|
|
Field6 *uint64 `protobuf:"varint,6,opt,name=Field6,json=field6" json:"Field6,omitempty"`
|
|
Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7,json=field7" json:"Field7,omitempty"`
|
|
Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8,json=field8" json:"Field8,omitempty"`
|
|
Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9,json=field9" json:"Field9,omitempty"`
|
|
Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10,json=field10" json:"Field10,omitempty"`
|
|
Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11,json=field11" json:"Field11,omitempty"`
|
|
Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12,json=field12" json:"Field12,omitempty"`
|
|
Field13 *bool `protobuf:"varint,13,opt,name=Field13,json=field13" json:"Field13,omitempty"`
|
|
Field14 *string `protobuf:"bytes,14,opt,name=Field14,json=field14" json:"Field14,omitempty"`
|
|
Field15 []byte `protobuf:"bytes,15,opt,name=Field15,json=field15" json:"Field15,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *NinOptNative) Reset() { *m = NinOptNative{} }
|
|
func (m *NinOptNative) String() string { return proto.CompactTextString(m) }
|
|
func (*NinOptNative) ProtoMessage() {}
|
|
func (*NinOptNative) Descriptor() ([]byte, []int) { return fileDescriptorFuzz, []int{2} }
|
|
|
|
func (m *NinOptNative) GetField1() float64 {
|
|
if m != nil && m.Field1 != nil {
|
|
return *m.Field1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField2() float32 {
|
|
if m != nil && m.Field2 != nil {
|
|
return *m.Field2
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField3() int32 {
|
|
if m != nil && m.Field3 != nil {
|
|
return *m.Field3
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField4() int64 {
|
|
if m != nil && m.Field4 != nil {
|
|
return *m.Field4
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField5() uint32 {
|
|
if m != nil && m.Field5 != nil {
|
|
return *m.Field5
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField6() uint64 {
|
|
if m != nil && m.Field6 != nil {
|
|
return *m.Field6
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField7() int32 {
|
|
if m != nil && m.Field7 != nil {
|
|
return *m.Field7
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField8() int64 {
|
|
if m != nil && m.Field8 != nil {
|
|
return *m.Field8
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField9() uint32 {
|
|
if m != nil && m.Field9 != nil {
|
|
return *m.Field9
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField10() int32 {
|
|
if m != nil && m.Field10 != nil {
|
|
return *m.Field10
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField11() uint64 {
|
|
if m != nil && m.Field11 != nil {
|
|
return *m.Field11
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField12() int64 {
|
|
if m != nil && m.Field12 != nil {
|
|
return *m.Field12
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptNative) GetField13() bool {
|
|
if m != nil && m.Field13 != nil {
|
|
return *m.Field13
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *NinOptNative) GetField14() string {
|
|
if m != nil && m.Field14 != nil {
|
|
return *m.Field14
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *NinOptNative) GetField15() []byte {
|
|
if m != nil {
|
|
return m.Field15
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type NinOptStruct struct {
|
|
Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1,json=field1" json:"Field1,omitempty"`
|
|
Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2,json=field2" json:"Field2,omitempty"`
|
|
Field3 *NinOptNative `protobuf:"bytes,3,opt,name=Field3,json=field3" json:"Field3,omitempty"`
|
|
Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4,json=field4" json:"Field4,omitempty"`
|
|
Field6 *uint64 `protobuf:"varint,6,opt,name=Field6,json=field6" json:"Field6,omitempty"`
|
|
Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7,json=field7" json:"Field7,omitempty"`
|
|
Field8 *NinOptNative `protobuf:"bytes,8,opt,name=Field8,json=field8" json:"Field8,omitempty"`
|
|
Field13 *bool `protobuf:"varint,13,opt,name=Field13,json=field13" json:"Field13,omitempty"`
|
|
Field14 *string `protobuf:"bytes,14,opt,name=Field14,json=field14" json:"Field14,omitempty"`
|
|
Field15 []byte `protobuf:"bytes,15,opt,name=Field15,json=field15" json:"Field15,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *NinOptStruct) Reset() { *m = NinOptStruct{} }
|
|
func (m *NinOptStruct) String() string { return proto.CompactTextString(m) }
|
|
func (*NinOptStruct) ProtoMessage() {}
|
|
func (*NinOptStruct) Descriptor() ([]byte, []int) { return fileDescriptorFuzz, []int{3} }
|
|
|
|
func (m *NinOptStruct) GetField1() float64 {
|
|
if m != nil && m.Field1 != nil {
|
|
return *m.Field1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptStruct) GetField2() float32 {
|
|
if m != nil && m.Field2 != nil {
|
|
return *m.Field2
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptStruct) GetField3() *NinOptNative {
|
|
if m != nil {
|
|
return m.Field3
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinOptStruct) GetField4() *NinOptNative {
|
|
if m != nil {
|
|
return m.Field4
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinOptStruct) GetField6() uint64 {
|
|
if m != nil && m.Field6 != nil {
|
|
return *m.Field6
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptStruct) GetField7() int32 {
|
|
if m != nil && m.Field7 != nil {
|
|
return *m.Field7
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *NinOptStruct) GetField8() *NinOptNative {
|
|
if m != nil {
|
|
return m.Field8
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *NinOptStruct) GetField13() bool {
|
|
if m != nil && m.Field13 != nil {
|
|
return *m.Field13
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *NinOptStruct) GetField14() string {
|
|
if m != nil && m.Field14 != nil {
|
|
return *m.Field14
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *NinOptStruct) GetField15() []byte {
|
|
if m != nil {
|
|
return m.Field15
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterType((*Nil)(nil), "fuzztests.Nil")
|
|
proto.RegisterType((*NinRepPackedNative)(nil), "fuzztests.NinRepPackedNative")
|
|
proto.RegisterType((*NinOptNative)(nil), "fuzztests.NinOptNative")
|
|
proto.RegisterType((*NinOptStruct)(nil), "fuzztests.NinOptStruct")
|
|
}
|
|
func (this *Nil) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 4)
|
|
s = append(s, "&fuzztests.Nil{")
|
|
if this.XXX_unrecognized != nil {
|
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *NinRepPackedNative) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 17)
|
|
s = append(s, "&fuzztests.NinRepPackedNative{")
|
|
if this.Field1 != nil {
|
|
s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
|
|
}
|
|
if this.Field2 != nil {
|
|
s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
|
|
}
|
|
if this.Field3 != nil {
|
|
s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
|
|
}
|
|
if this.Field4 != nil {
|
|
s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
|
|
}
|
|
if this.Field5 != nil {
|
|
s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n")
|
|
}
|
|
if this.Field6 != nil {
|
|
s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n")
|
|
}
|
|
if this.Field7 != nil {
|
|
s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
|
|
}
|
|
if this.Field8 != nil {
|
|
s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
|
|
}
|
|
if this.Field9 != nil {
|
|
s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n")
|
|
}
|
|
if this.Field10 != nil {
|
|
s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n")
|
|
}
|
|
if this.Field11 != nil {
|
|
s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n")
|
|
}
|
|
if this.Field12 != nil {
|
|
s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n")
|
|
}
|
|
if this.Field13 != nil {
|
|
s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n")
|
|
}
|
|
if this.XXX_unrecognized != nil {
|
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *NinOptNative) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 19)
|
|
s = append(s, "&fuzztests.NinOptNative{")
|
|
if this.Field1 != nil {
|
|
s = append(s, "Field1: "+valueToGoStringFuzz(this.Field1, "float64")+",\n")
|
|
}
|
|
if this.Field2 != nil {
|
|
s = append(s, "Field2: "+valueToGoStringFuzz(this.Field2, "float32")+",\n")
|
|
}
|
|
if this.Field3 != nil {
|
|
s = append(s, "Field3: "+valueToGoStringFuzz(this.Field3, "int32")+",\n")
|
|
}
|
|
if this.Field4 != nil {
|
|
s = append(s, "Field4: "+valueToGoStringFuzz(this.Field4, "int64")+",\n")
|
|
}
|
|
if this.Field5 != nil {
|
|
s = append(s, "Field5: "+valueToGoStringFuzz(this.Field5, "uint32")+",\n")
|
|
}
|
|
if this.Field6 != nil {
|
|
s = append(s, "Field6: "+valueToGoStringFuzz(this.Field6, "uint64")+",\n")
|
|
}
|
|
if this.Field7 != nil {
|
|
s = append(s, "Field7: "+valueToGoStringFuzz(this.Field7, "int32")+",\n")
|
|
}
|
|
if this.Field8 != nil {
|
|
s = append(s, "Field8: "+valueToGoStringFuzz(this.Field8, "int64")+",\n")
|
|
}
|
|
if this.Field9 != nil {
|
|
s = append(s, "Field9: "+valueToGoStringFuzz(this.Field9, "uint32")+",\n")
|
|
}
|
|
if this.Field10 != nil {
|
|
s = append(s, "Field10: "+valueToGoStringFuzz(this.Field10, "int32")+",\n")
|
|
}
|
|
if this.Field11 != nil {
|
|
s = append(s, "Field11: "+valueToGoStringFuzz(this.Field11, "uint64")+",\n")
|
|
}
|
|
if this.Field12 != nil {
|
|
s = append(s, "Field12: "+valueToGoStringFuzz(this.Field12, "int64")+",\n")
|
|
}
|
|
if this.Field13 != nil {
|
|
s = append(s, "Field13: "+valueToGoStringFuzz(this.Field13, "bool")+",\n")
|
|
}
|
|
if this.Field14 != nil {
|
|
s = append(s, "Field14: "+valueToGoStringFuzz(this.Field14, "string")+",\n")
|
|
}
|
|
if this.Field15 != nil {
|
|
s = append(s, "Field15: "+valueToGoStringFuzz(this.Field15, "byte")+",\n")
|
|
}
|
|
if this.XXX_unrecognized != nil {
|
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *NinOptStruct) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 14)
|
|
s = append(s, "&fuzztests.NinOptStruct{")
|
|
if this.Field1 != nil {
|
|
s = append(s, "Field1: "+valueToGoStringFuzz(this.Field1, "float64")+",\n")
|
|
}
|
|
if this.Field2 != nil {
|
|
s = append(s, "Field2: "+valueToGoStringFuzz(this.Field2, "float32")+",\n")
|
|
}
|
|
if this.Field3 != nil {
|
|
s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
|
|
}
|
|
if this.Field4 != nil {
|
|
s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
|
|
}
|
|
if this.Field6 != nil {
|
|
s = append(s, "Field6: "+valueToGoStringFuzz(this.Field6, "uint64")+",\n")
|
|
}
|
|
if this.Field7 != nil {
|
|
s = append(s, "Field7: "+valueToGoStringFuzz(this.Field7, "int32")+",\n")
|
|
}
|
|
if this.Field8 != nil {
|
|
s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
|
|
}
|
|
if this.Field13 != nil {
|
|
s = append(s, "Field13: "+valueToGoStringFuzz(this.Field13, "bool")+",\n")
|
|
}
|
|
if this.Field14 != nil {
|
|
s = append(s, "Field14: "+valueToGoStringFuzz(this.Field14, "string")+",\n")
|
|
}
|
|
if this.Field15 != nil {
|
|
s = append(s, "Field15: "+valueToGoStringFuzz(this.Field15, "byte")+",\n")
|
|
}
|
|
if this.XXX_unrecognized != nil {
|
|
s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func valueToGoStringFuzz(v interface{}, typ string) string {
|
|
rv := reflect.ValueOf(v)
|
|
if rv.IsNil() {
|
|
return "nil"
|
|
}
|
|
pv := reflect.Indirect(rv).Interface()
|
|
return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
|
|
}
|
|
func extensionToGoStringFuzz(e map[int32]github_com_gogo_protobuf_proto.Extension) string {
|
|
if e == nil {
|
|
return "nil"
|
|
}
|
|
s := "map[int32]proto.Extension{"
|
|
keys := make([]int, 0, len(e))
|
|
for k := range e {
|
|
keys = append(keys, int(k))
|
|
}
|
|
sort.Ints(keys)
|
|
ss := []string{}
|
|
for _, k := range keys {
|
|
ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
|
|
}
|
|
s += strings.Join(ss, ",") + "}"
|
|
return s
|
|
}
|
|
func (m *Nil) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *Nil) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *NinRepPackedNative) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Field1) > 0 {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(m.Field1)*8))
|
|
for _, num := range m.Field1 {
|
|
f1 := math.Float64bits(float64(num))
|
|
data[i] = uint8(f1)
|
|
i++
|
|
data[i] = uint8(f1 >> 8)
|
|
i++
|
|
data[i] = uint8(f1 >> 16)
|
|
i++
|
|
data[i] = uint8(f1 >> 24)
|
|
i++
|
|
data[i] = uint8(f1 >> 32)
|
|
i++
|
|
data[i] = uint8(f1 >> 40)
|
|
i++
|
|
data[i] = uint8(f1 >> 48)
|
|
i++
|
|
data[i] = uint8(f1 >> 56)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Field2) > 0 {
|
|
data[i] = 0x12
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(m.Field2)*4))
|
|
for _, num := range m.Field2 {
|
|
f2 := math.Float32bits(float32(num))
|
|
data[i] = uint8(f2)
|
|
i++
|
|
data[i] = uint8(f2 >> 8)
|
|
i++
|
|
data[i] = uint8(f2 >> 16)
|
|
i++
|
|
data[i] = uint8(f2 >> 24)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Field3) > 0 {
|
|
data4 := make([]byte, len(m.Field3)*10)
|
|
var j3 int
|
|
for _, num1 := range m.Field3 {
|
|
num := uint64(num1)
|
|
for num >= 1<<7 {
|
|
data4[j3] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j3++
|
|
}
|
|
data4[j3] = uint8(num)
|
|
j3++
|
|
}
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(j3))
|
|
i += copy(data[i:], data4[:j3])
|
|
}
|
|
if len(m.Field4) > 0 {
|
|
data6 := make([]byte, len(m.Field4)*10)
|
|
var j5 int
|
|
for _, num1 := range m.Field4 {
|
|
num := uint64(num1)
|
|
for num >= 1<<7 {
|
|
data6[j5] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j5++
|
|
}
|
|
data6[j5] = uint8(num)
|
|
j5++
|
|
}
|
|
data[i] = 0x22
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(j5))
|
|
i += copy(data[i:], data6[:j5])
|
|
}
|
|
if len(m.Field5) > 0 {
|
|
data8 := make([]byte, len(m.Field5)*10)
|
|
var j7 int
|
|
for _, num := range m.Field5 {
|
|
for num >= 1<<7 {
|
|
data8[j7] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j7++
|
|
}
|
|
data8[j7] = uint8(num)
|
|
j7++
|
|
}
|
|
data[i] = 0x2a
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(j7))
|
|
i += copy(data[i:], data8[:j7])
|
|
}
|
|
if len(m.Field6) > 0 {
|
|
data10 := make([]byte, len(m.Field6)*10)
|
|
var j9 int
|
|
for _, num := range m.Field6 {
|
|
for num >= 1<<7 {
|
|
data10[j9] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j9++
|
|
}
|
|
data10[j9] = uint8(num)
|
|
j9++
|
|
}
|
|
data[i] = 0x32
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(j9))
|
|
i += copy(data[i:], data10[:j9])
|
|
}
|
|
if len(m.Field7) > 0 {
|
|
data11 := make([]byte, len(m.Field7)*5)
|
|
var j12 int
|
|
for _, num := range m.Field7 {
|
|
x13 := (uint32(num) << 1) ^ uint32((num >> 31))
|
|
for x13 >= 1<<7 {
|
|
data11[j12] = uint8(uint64(x13)&0x7f | 0x80)
|
|
j12++
|
|
x13 >>= 7
|
|
}
|
|
data11[j12] = uint8(x13)
|
|
j12++
|
|
}
|
|
data[i] = 0x3a
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(j12))
|
|
i += copy(data[i:], data11[:j12])
|
|
}
|
|
if len(m.Field8) > 0 {
|
|
var j14 int
|
|
data16 := make([]byte, len(m.Field8)*10)
|
|
for _, num := range m.Field8 {
|
|
x15 := (uint64(num) << 1) ^ uint64((num >> 63))
|
|
for x15 >= 1<<7 {
|
|
data16[j14] = uint8(uint64(x15)&0x7f | 0x80)
|
|
j14++
|
|
x15 >>= 7
|
|
}
|
|
data16[j14] = uint8(x15)
|
|
j14++
|
|
}
|
|
data[i] = 0x42
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(j14))
|
|
i += copy(data[i:], data16[:j14])
|
|
}
|
|
if len(m.Field9) > 0 {
|
|
data[i] = 0x4a
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(m.Field9)*4))
|
|
for _, num := range m.Field9 {
|
|
data[i] = uint8(num)
|
|
i++
|
|
data[i] = uint8(num >> 8)
|
|
i++
|
|
data[i] = uint8(num >> 16)
|
|
i++
|
|
data[i] = uint8(num >> 24)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Field10) > 0 {
|
|
data[i] = 0x52
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(m.Field10)*4))
|
|
for _, num := range m.Field10 {
|
|
data[i] = uint8(num)
|
|
i++
|
|
data[i] = uint8(num >> 8)
|
|
i++
|
|
data[i] = uint8(num >> 16)
|
|
i++
|
|
data[i] = uint8(num >> 24)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Field11) > 0 {
|
|
data[i] = 0x5a
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(m.Field11)*8))
|
|
for _, num := range m.Field11 {
|
|
data[i] = uint8(num)
|
|
i++
|
|
data[i] = uint8(num >> 8)
|
|
i++
|
|
data[i] = uint8(num >> 16)
|
|
i++
|
|
data[i] = uint8(num >> 24)
|
|
i++
|
|
data[i] = uint8(num >> 32)
|
|
i++
|
|
data[i] = uint8(num >> 40)
|
|
i++
|
|
data[i] = uint8(num >> 48)
|
|
i++
|
|
data[i] = uint8(num >> 56)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Field12) > 0 {
|
|
data[i] = 0x62
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(m.Field12)*8))
|
|
for _, num := range m.Field12 {
|
|
data[i] = uint8(num)
|
|
i++
|
|
data[i] = uint8(num >> 8)
|
|
i++
|
|
data[i] = uint8(num >> 16)
|
|
i++
|
|
data[i] = uint8(num >> 24)
|
|
i++
|
|
data[i] = uint8(num >> 32)
|
|
i++
|
|
data[i] = uint8(num >> 40)
|
|
i++
|
|
data[i] = uint8(num >> 48)
|
|
i++
|
|
data[i] = uint8(num >> 56)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Field13) > 0 {
|
|
data[i] = 0x6a
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(m.Field13)))
|
|
for _, b := range m.Field13 {
|
|
if b {
|
|
data[i] = 1
|
|
} else {
|
|
data[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *NinOptNative) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *NinOptNative) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Field1 != nil {
|
|
data[i] = 0x9
|
|
i++
|
|
i = encodeFixed64Fuzz(data, i, uint64(math.Float64bits(float64(*m.Field1))))
|
|
}
|
|
if m.Field2 != nil {
|
|
data[i] = 0x15
|
|
i++
|
|
i = encodeFixed32Fuzz(data, i, uint32(math.Float32bits(float32(*m.Field2))))
|
|
}
|
|
if m.Field3 != nil {
|
|
data[i] = 0x18
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(*m.Field3))
|
|
}
|
|
if m.Field4 != nil {
|
|
data[i] = 0x20
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(*m.Field4))
|
|
}
|
|
if m.Field5 != nil {
|
|
data[i] = 0x28
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(*m.Field5))
|
|
}
|
|
if m.Field6 != nil {
|
|
data[i] = 0x30
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(*m.Field6))
|
|
}
|
|
if m.Field7 != nil {
|
|
data[i] = 0x38
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31))))
|
|
}
|
|
if m.Field8 != nil {
|
|
data[i] = 0x40
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63))))
|
|
}
|
|
if m.Field9 != nil {
|
|
data[i] = 0x4d
|
|
i++
|
|
i = encodeFixed32Fuzz(data, i, uint32(*m.Field9))
|
|
}
|
|
if m.Field10 != nil {
|
|
data[i] = 0x55
|
|
i++
|
|
i = encodeFixed32Fuzz(data, i, uint32(*m.Field10))
|
|
}
|
|
if m.Field11 != nil {
|
|
data[i] = 0x59
|
|
i++
|
|
i = encodeFixed64Fuzz(data, i, uint64(*m.Field11))
|
|
}
|
|
if m.Field12 != nil {
|
|
data[i] = 0x61
|
|
i++
|
|
i = encodeFixed64Fuzz(data, i, uint64(*m.Field12))
|
|
}
|
|
if m.Field13 != nil {
|
|
data[i] = 0x68
|
|
i++
|
|
if *m.Field13 {
|
|
data[i] = 1
|
|
} else {
|
|
data[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if m.Field14 != nil {
|
|
data[i] = 0x72
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(*m.Field14)))
|
|
i += copy(data[i:], *m.Field14)
|
|
}
|
|
if m.Field15 != nil {
|
|
data[i] = 0x7a
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(m.Field15)))
|
|
i += copy(data[i:], m.Field15)
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *NinOptStruct) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *NinOptStruct) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Field1 != nil {
|
|
data[i] = 0x9
|
|
i++
|
|
i = encodeFixed64Fuzz(data, i, uint64(math.Float64bits(float64(*m.Field1))))
|
|
}
|
|
if m.Field2 != nil {
|
|
data[i] = 0x15
|
|
i++
|
|
i = encodeFixed32Fuzz(data, i, uint32(math.Float32bits(float32(*m.Field2))))
|
|
}
|
|
if m.Field3 != nil {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(m.Field3.Size()))
|
|
n17, err := m.Field3.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n17
|
|
}
|
|
if m.Field4 != nil {
|
|
data[i] = 0x22
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(m.Field4.Size()))
|
|
n18, err := m.Field4.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n18
|
|
}
|
|
if m.Field6 != nil {
|
|
data[i] = 0x30
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(*m.Field6))
|
|
}
|
|
if m.Field7 != nil {
|
|
data[i] = 0x38
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31))))
|
|
}
|
|
if m.Field8 != nil {
|
|
data[i] = 0x42
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(m.Field8.Size()))
|
|
n19, err := m.Field8.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n19
|
|
}
|
|
if m.Field13 != nil {
|
|
data[i] = 0x68
|
|
i++
|
|
if *m.Field13 {
|
|
data[i] = 1
|
|
} else {
|
|
data[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if m.Field14 != nil {
|
|
data[i] = 0x72
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(*m.Field14)))
|
|
i += copy(data[i:], *m.Field14)
|
|
}
|
|
if m.Field15 != nil {
|
|
data[i] = 0x7a
|
|
i++
|
|
i = encodeVarintFuzz(data, i, uint64(len(m.Field15)))
|
|
i += copy(data[i:], m.Field15)
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
i += copy(data[i:], m.XXX_unrecognized)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func encodeFixed64Fuzz(data []byte, offset int, v uint64) int {
|
|
data[offset] = uint8(v)
|
|
data[offset+1] = uint8(v >> 8)
|
|
data[offset+2] = uint8(v >> 16)
|
|
data[offset+3] = uint8(v >> 24)
|
|
data[offset+4] = uint8(v >> 32)
|
|
data[offset+5] = uint8(v >> 40)
|
|
data[offset+6] = uint8(v >> 48)
|
|
data[offset+7] = uint8(v >> 56)
|
|
return offset + 8
|
|
}
|
|
func encodeFixed32Fuzz(data []byte, offset int, v uint32) int {
|
|
data[offset] = uint8(v)
|
|
data[offset+1] = uint8(v >> 8)
|
|
data[offset+2] = uint8(v >> 16)
|
|
data[offset+3] = uint8(v >> 24)
|
|
return offset + 4
|
|
}
|
|
func encodeVarintFuzz(data []byte, offset int, v uint64) int {
|
|
for v >= 1<<7 {
|
|
data[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
data[offset] = uint8(v)
|
|
return offset + 1
|
|
}
|
|
func (m *Nil) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *NinRepPackedNative) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Field1) > 0 {
|
|
n += 1 + sovFuzz(uint64(len(m.Field1)*8)) + len(m.Field1)*8
|
|
}
|
|
if len(m.Field2) > 0 {
|
|
n += 1 + sovFuzz(uint64(len(m.Field2)*4)) + len(m.Field2)*4
|
|
}
|
|
if len(m.Field3) > 0 {
|
|
l = 0
|
|
for _, e := range m.Field3 {
|
|
l += sovFuzz(uint64(e))
|
|
}
|
|
n += 1 + sovFuzz(uint64(l)) + l
|
|
}
|
|
if len(m.Field4) > 0 {
|
|
l = 0
|
|
for _, e := range m.Field4 {
|
|
l += sovFuzz(uint64(e))
|
|
}
|
|
n += 1 + sovFuzz(uint64(l)) + l
|
|
}
|
|
if len(m.Field5) > 0 {
|
|
l = 0
|
|
for _, e := range m.Field5 {
|
|
l += sovFuzz(uint64(e))
|
|
}
|
|
n += 1 + sovFuzz(uint64(l)) + l
|
|
}
|
|
if len(m.Field6) > 0 {
|
|
l = 0
|
|
for _, e := range m.Field6 {
|
|
l += sovFuzz(uint64(e))
|
|
}
|
|
n += 1 + sovFuzz(uint64(l)) + l
|
|
}
|
|
if len(m.Field7) > 0 {
|
|
l = 0
|
|
for _, e := range m.Field7 {
|
|
l += sozFuzz(uint64(e))
|
|
}
|
|
n += 1 + sovFuzz(uint64(l)) + l
|
|
}
|
|
if len(m.Field8) > 0 {
|
|
l = 0
|
|
for _, e := range m.Field8 {
|
|
l += sozFuzz(uint64(e))
|
|
}
|
|
n += 1 + sovFuzz(uint64(l)) + l
|
|
}
|
|
if len(m.Field9) > 0 {
|
|
n += 1 + sovFuzz(uint64(len(m.Field9)*4)) + len(m.Field9)*4
|
|
}
|
|
if len(m.Field10) > 0 {
|
|
n += 1 + sovFuzz(uint64(len(m.Field10)*4)) + len(m.Field10)*4
|
|
}
|
|
if len(m.Field11) > 0 {
|
|
n += 1 + sovFuzz(uint64(len(m.Field11)*8)) + len(m.Field11)*8
|
|
}
|
|
if len(m.Field12) > 0 {
|
|
n += 1 + sovFuzz(uint64(len(m.Field12)*8)) + len(m.Field12)*8
|
|
}
|
|
if len(m.Field13) > 0 {
|
|
n += 1 + sovFuzz(uint64(len(m.Field13))) + len(m.Field13)*1
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *NinOptNative) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Field1 != nil {
|
|
n += 9
|
|
}
|
|
if m.Field2 != nil {
|
|
n += 5
|
|
}
|
|
if m.Field3 != nil {
|
|
n += 1 + sovFuzz(uint64(*m.Field3))
|
|
}
|
|
if m.Field4 != nil {
|
|
n += 1 + sovFuzz(uint64(*m.Field4))
|
|
}
|
|
if m.Field5 != nil {
|
|
n += 1 + sovFuzz(uint64(*m.Field5))
|
|
}
|
|
if m.Field6 != nil {
|
|
n += 1 + sovFuzz(uint64(*m.Field6))
|
|
}
|
|
if m.Field7 != nil {
|
|
n += 1 + sozFuzz(uint64(*m.Field7))
|
|
}
|
|
if m.Field8 != nil {
|
|
n += 1 + sozFuzz(uint64(*m.Field8))
|
|
}
|
|
if m.Field9 != nil {
|
|
n += 5
|
|
}
|
|
if m.Field10 != nil {
|
|
n += 5
|
|
}
|
|
if m.Field11 != nil {
|
|
n += 9
|
|
}
|
|
if m.Field12 != nil {
|
|
n += 9
|
|
}
|
|
if m.Field13 != nil {
|
|
n += 2
|
|
}
|
|
if m.Field14 != nil {
|
|
l = len(*m.Field14)
|
|
n += 1 + l + sovFuzz(uint64(l))
|
|
}
|
|
if m.Field15 != nil {
|
|
l = len(m.Field15)
|
|
n += 1 + l + sovFuzz(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *NinOptStruct) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Field1 != nil {
|
|
n += 9
|
|
}
|
|
if m.Field2 != nil {
|
|
n += 5
|
|
}
|
|
if m.Field3 != nil {
|
|
l = m.Field3.Size()
|
|
n += 1 + l + sovFuzz(uint64(l))
|
|
}
|
|
if m.Field4 != nil {
|
|
l = m.Field4.Size()
|
|
n += 1 + l + sovFuzz(uint64(l))
|
|
}
|
|
if m.Field6 != nil {
|
|
n += 1 + sovFuzz(uint64(*m.Field6))
|
|
}
|
|
if m.Field7 != nil {
|
|
n += 1 + sozFuzz(uint64(*m.Field7))
|
|
}
|
|
if m.Field8 != nil {
|
|
l = m.Field8.Size()
|
|
n += 1 + l + sovFuzz(uint64(l))
|
|
}
|
|
if m.Field13 != nil {
|
|
n += 2
|
|
}
|
|
if m.Field14 != nil {
|
|
l = len(*m.Field14)
|
|
n += 1 + l + sovFuzz(uint64(l))
|
|
}
|
|
if m.Field15 != nil {
|
|
l = len(m.Field15)
|
|
n += 1 + l + sovFuzz(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovFuzz(x uint64) (n int) {
|
|
for {
|
|
n++
|
|
x >>= 7
|
|
if x == 0 {
|
|
break
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
func sozFuzz(x uint64) (n int) {
|
|
return sovFuzz(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (m *Nil) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: Nil: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Nil: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipFuzz(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *NinRepPackedNative) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: NinRepPackedNative: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: NinRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = uint64(data[iNdEx-8])
|
|
v |= uint64(data[iNdEx-7]) << 8
|
|
v |= uint64(data[iNdEx-6]) << 16
|
|
v |= uint64(data[iNdEx-5]) << 24
|
|
v |= uint64(data[iNdEx-4]) << 32
|
|
v |= uint64(data[iNdEx-3]) << 40
|
|
v |= uint64(data[iNdEx-2]) << 48
|
|
v |= uint64(data[iNdEx-1]) << 56
|
|
v2 := float64(math.Float64frombits(v))
|
|
m.Field1 = append(m.Field1, v2)
|
|
}
|
|
} else if wireType == 1 {
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = uint64(data[iNdEx-8])
|
|
v |= uint64(data[iNdEx-7]) << 8
|
|
v |= uint64(data[iNdEx-6]) << 16
|
|
v |= uint64(data[iNdEx-5]) << 24
|
|
v |= uint64(data[iNdEx-4]) << 32
|
|
v |= uint64(data[iNdEx-3]) << 40
|
|
v |= uint64(data[iNdEx-2]) << 48
|
|
v |= uint64(data[iNdEx-1]) << 56
|
|
v2 := float64(math.Float64frombits(v))
|
|
m.Field1 = append(m.Field1, v2)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
|
|
}
|
|
case 2:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint32
|
|
if (iNdEx + 4) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 4
|
|
v = uint32(data[iNdEx-4])
|
|
v |= uint32(data[iNdEx-3]) << 8
|
|
v |= uint32(data[iNdEx-2]) << 16
|
|
v |= uint32(data[iNdEx-1]) << 24
|
|
v2 := float32(math.Float32frombits(v))
|
|
m.Field2 = append(m.Field2, v2)
|
|
}
|
|
} else if wireType == 5 {
|
|
var v uint32
|
|
if (iNdEx + 4) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 4
|
|
v = uint32(data[iNdEx-4])
|
|
v |= uint32(data[iNdEx-3]) << 8
|
|
v |= uint32(data[iNdEx-2]) << 16
|
|
v |= uint32(data[iNdEx-1]) << 24
|
|
v2 := float32(math.Float32frombits(v))
|
|
m.Field2 = append(m.Field2, v2)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
|
|
}
|
|
case 3:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int32
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field3 = append(m.Field3, v)
|
|
}
|
|
} else if wireType == 0 {
|
|
var v int32
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field3 = append(m.Field3, v)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
|
|
}
|
|
case 4:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field4 = append(m.Field4, v)
|
|
}
|
|
} else if wireType == 0 {
|
|
var v int64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field4 = append(m.Field4, v)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
|
|
}
|
|
case 5:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint32
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (uint32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field5 = append(m.Field5, v)
|
|
}
|
|
} else if wireType == 0 {
|
|
var v uint32
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (uint32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field5 = append(m.Field5, v)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
|
|
}
|
|
case 6:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field6 = append(m.Field6, v)
|
|
}
|
|
} else if wireType == 0 {
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field6 = append(m.Field6, v)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
|
|
}
|
|
case 7:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int32
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
|
|
m.Field7 = append(m.Field7, v)
|
|
}
|
|
} else if wireType == 0 {
|
|
var v int32
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
|
|
m.Field7 = append(m.Field7, v)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
|
|
}
|
|
case 8:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
|
|
m.Field8 = append(m.Field8, int64(v))
|
|
}
|
|
} else if wireType == 0 {
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
|
|
m.Field8 = append(m.Field8, int64(v))
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
|
|
}
|
|
case 9:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint32
|
|
if (iNdEx + 4) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 4
|
|
v = uint32(data[iNdEx-4])
|
|
v |= uint32(data[iNdEx-3]) << 8
|
|
v |= uint32(data[iNdEx-2]) << 16
|
|
v |= uint32(data[iNdEx-1]) << 24
|
|
m.Field9 = append(m.Field9, v)
|
|
}
|
|
} else if wireType == 5 {
|
|
var v uint32
|
|
if (iNdEx + 4) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 4
|
|
v = uint32(data[iNdEx-4])
|
|
v |= uint32(data[iNdEx-3]) << 8
|
|
v |= uint32(data[iNdEx-2]) << 16
|
|
v |= uint32(data[iNdEx-1]) << 24
|
|
m.Field9 = append(m.Field9, v)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
|
|
}
|
|
case 10:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int32
|
|
if (iNdEx + 4) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 4
|
|
v = int32(data[iNdEx-4])
|
|
v |= int32(data[iNdEx-3]) << 8
|
|
v |= int32(data[iNdEx-2]) << 16
|
|
v |= int32(data[iNdEx-1]) << 24
|
|
m.Field10 = append(m.Field10, v)
|
|
}
|
|
} else if wireType == 5 {
|
|
var v int32
|
|
if (iNdEx + 4) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 4
|
|
v = int32(data[iNdEx-4])
|
|
v |= int32(data[iNdEx-3]) << 8
|
|
v |= int32(data[iNdEx-2]) << 16
|
|
v |= int32(data[iNdEx-1]) << 24
|
|
m.Field10 = append(m.Field10, v)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
|
|
}
|
|
case 11:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = uint64(data[iNdEx-8])
|
|
v |= uint64(data[iNdEx-7]) << 8
|
|
v |= uint64(data[iNdEx-6]) << 16
|
|
v |= uint64(data[iNdEx-5]) << 24
|
|
v |= uint64(data[iNdEx-4]) << 32
|
|
v |= uint64(data[iNdEx-3]) << 40
|
|
v |= uint64(data[iNdEx-2]) << 48
|
|
v |= uint64(data[iNdEx-1]) << 56
|
|
m.Field11 = append(m.Field11, v)
|
|
}
|
|
} else if wireType == 1 {
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = uint64(data[iNdEx-8])
|
|
v |= uint64(data[iNdEx-7]) << 8
|
|
v |= uint64(data[iNdEx-6]) << 16
|
|
v |= uint64(data[iNdEx-5]) << 24
|
|
v |= uint64(data[iNdEx-4]) << 32
|
|
v |= uint64(data[iNdEx-3]) << 40
|
|
v |= uint64(data[iNdEx-2]) << 48
|
|
v |= uint64(data[iNdEx-1]) << 56
|
|
m.Field11 = append(m.Field11, v)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
|
|
}
|
|
case 12:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(data[iNdEx-8])
|
|
v |= int64(data[iNdEx-7]) << 8
|
|
v |= int64(data[iNdEx-6]) << 16
|
|
v |= int64(data[iNdEx-5]) << 24
|
|
v |= int64(data[iNdEx-4]) << 32
|
|
v |= int64(data[iNdEx-3]) << 40
|
|
v |= int64(data[iNdEx-2]) << 48
|
|
v |= int64(data[iNdEx-1]) << 56
|
|
m.Field12 = append(m.Field12, v)
|
|
}
|
|
} else if wireType == 1 {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(data[iNdEx-8])
|
|
v |= int64(data[iNdEx-7]) << 8
|
|
v |= int64(data[iNdEx-6]) << 16
|
|
v |= int64(data[iNdEx-5]) << 24
|
|
v |= int64(data[iNdEx-4]) << 32
|
|
v |= int64(data[iNdEx-3]) << 40
|
|
v |= int64(data[iNdEx-2]) << 48
|
|
v |= int64(data[iNdEx-1]) << 56
|
|
m.Field12 = append(m.Field12, v)
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
|
|
}
|
|
case 13:
|
|
if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field13 = append(m.Field13, bool(v != 0))
|
|
}
|
|
} else if wireType == 0 {
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field13 = append(m.Field13, bool(v != 0))
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipFuzz(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *NinOptNative) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: NinOptNative: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: NinOptNative: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 1 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
|
|
}
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = uint64(data[iNdEx-8])
|
|
v |= uint64(data[iNdEx-7]) << 8
|
|
v |= uint64(data[iNdEx-6]) << 16
|
|
v |= uint64(data[iNdEx-5]) << 24
|
|
v |= uint64(data[iNdEx-4]) << 32
|
|
v |= uint64(data[iNdEx-3]) << 40
|
|
v |= uint64(data[iNdEx-2]) << 48
|
|
v |= uint64(data[iNdEx-1]) << 56
|
|
v2 := float64(math.Float64frombits(v))
|
|
m.Field1 = &v2
|
|
case 2:
|
|
if wireType != 5 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
|
|
}
|
|
var v uint32
|
|
if (iNdEx + 4) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 4
|
|
v = uint32(data[iNdEx-4])
|
|
v |= uint32(data[iNdEx-3]) << 8
|
|
v |= uint32(data[iNdEx-2]) << 16
|
|
v |= uint32(data[iNdEx-1]) << 24
|
|
v2 := float32(math.Float32frombits(v))
|
|
m.Field2 = &v2
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
|
|
}
|
|
var v int32
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field3 = &v
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
|
|
}
|
|
var v int64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field4 = &v
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
|
|
}
|
|
var v uint32
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (uint32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field5 = &v
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
|
|
}
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field6 = &v
|
|
case 7:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
|
|
}
|
|
var v int32
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
|
|
m.Field7 = &v
|
|
case 8:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
|
|
}
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
|
|
v2 := int64(v)
|
|
m.Field8 = &v2
|
|
case 9:
|
|
if wireType != 5 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
|
|
}
|
|
var v uint32
|
|
if (iNdEx + 4) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 4
|
|
v = uint32(data[iNdEx-4])
|
|
v |= uint32(data[iNdEx-3]) << 8
|
|
v |= uint32(data[iNdEx-2]) << 16
|
|
v |= uint32(data[iNdEx-1]) << 24
|
|
m.Field9 = &v
|
|
case 10:
|
|
if wireType != 5 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
|
|
}
|
|
var v int32
|
|
if (iNdEx + 4) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 4
|
|
v = int32(data[iNdEx-4])
|
|
v |= int32(data[iNdEx-3]) << 8
|
|
v |= int32(data[iNdEx-2]) << 16
|
|
v |= int32(data[iNdEx-1]) << 24
|
|
m.Field10 = &v
|
|
case 11:
|
|
if wireType != 1 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
|
|
}
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = uint64(data[iNdEx-8])
|
|
v |= uint64(data[iNdEx-7]) << 8
|
|
v |= uint64(data[iNdEx-6]) << 16
|
|
v |= uint64(data[iNdEx-5]) << 24
|
|
v |= uint64(data[iNdEx-4]) << 32
|
|
v |= uint64(data[iNdEx-3]) << 40
|
|
v |= uint64(data[iNdEx-2]) << 48
|
|
v |= uint64(data[iNdEx-1]) << 56
|
|
m.Field11 = &v
|
|
case 12:
|
|
if wireType != 1 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
|
|
}
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(data[iNdEx-8])
|
|
v |= int64(data[iNdEx-7]) << 8
|
|
v |= int64(data[iNdEx-6]) << 16
|
|
v |= int64(data[iNdEx-5]) << 24
|
|
v |= int64(data[iNdEx-4]) << 32
|
|
v |= int64(data[iNdEx-3]) << 40
|
|
v |= int64(data[iNdEx-2]) << 48
|
|
v |= int64(data[iNdEx-1]) << 56
|
|
m.Field12 = &v
|
|
case 13:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
b := bool(v != 0)
|
|
m.Field13 = &b
|
|
case 14:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
s := string(data[iNdEx:postIndex])
|
|
m.Field14 = &s
|
|
iNdEx = postIndex
|
|
case 15:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Field15 = append(m.Field15[:0], data[iNdEx:postIndex]...)
|
|
if m.Field15 == nil {
|
|
m.Field15 = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipFuzz(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *NinOptStruct) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: NinOptStruct: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: NinOptStruct: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 1 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
|
|
}
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = uint64(data[iNdEx-8])
|
|
v |= uint64(data[iNdEx-7]) << 8
|
|
v |= uint64(data[iNdEx-6]) << 16
|
|
v |= uint64(data[iNdEx-5]) << 24
|
|
v |= uint64(data[iNdEx-4]) << 32
|
|
v |= uint64(data[iNdEx-3]) << 40
|
|
v |= uint64(data[iNdEx-2]) << 48
|
|
v |= uint64(data[iNdEx-1]) << 56
|
|
v2 := float64(math.Float64frombits(v))
|
|
m.Field1 = &v2
|
|
case 2:
|
|
if wireType != 5 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
|
|
}
|
|
var v uint32
|
|
if (iNdEx + 4) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 4
|
|
v = uint32(data[iNdEx-4])
|
|
v |= uint32(data[iNdEx-3]) << 8
|
|
v |= uint32(data[iNdEx-2]) << 16
|
|
v |= uint32(data[iNdEx-1]) << 24
|
|
v2 := float32(math.Float32frombits(v))
|
|
m.Field2 = &v2
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Field3 == nil {
|
|
m.Field3 = &NinOptNative{}
|
|
}
|
|
if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Field4 == nil {
|
|
m.Field4 = &NinOptNative{}
|
|
}
|
|
if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
|
|
}
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Field6 = &v
|
|
case 7:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
|
|
}
|
|
var v int32
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int32(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
|
|
m.Field7 = &v
|
|
case 8:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Field8 == nil {
|
|
m.Field8 = &NinOptNative{}
|
|
}
|
|
if err := m.Field8.Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 13:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
b := bool(v != 0)
|
|
m.Field13 = &b
|
|
case 14:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
s := string(data[iNdEx:postIndex])
|
|
m.Field14 = &s
|
|
iNdEx = postIndex
|
|
case 15:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Field15 = append(m.Field15[:0], data[iNdEx:postIndex]...)
|
|
if m.Field15 == nil {
|
|
m.Field15 = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipFuzz(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthFuzz
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func skipFuzz(data []byte) (n int, err error) {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
wireType := int(wire & 0x7)
|
|
switch wireType {
|
|
case 0:
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx++
|
|
if data[iNdEx-1] < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
return iNdEx, nil
|
|
case 1:
|
|
iNdEx += 8
|
|
return iNdEx, nil
|
|
case 2:
|
|
var length int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
length |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx += length
|
|
if length < 0 {
|
|
return 0, ErrInvalidLengthFuzz
|
|
}
|
|
return iNdEx, nil
|
|
case 3:
|
|
for {
|
|
var innerWire uint64
|
|
var start int = iNdEx
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowFuzz
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
innerWire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
innerWireType := int(innerWire & 0x7)
|
|
if innerWireType == 4 {
|
|
break
|
|
}
|
|
next, err := skipFuzz(data[start:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
iNdEx = start + next
|
|
}
|
|
return iNdEx, nil
|
|
case 4:
|
|
return iNdEx, nil
|
|
case 5:
|
|
iNdEx += 4
|
|
return iNdEx, nil
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthFuzz = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
ErrIntOverflowFuzz = fmt.Errorf("proto: integer overflow")
|
|
)
|
|
|
|
var fileDescriptorFuzz = []byte{
|
|
// 439 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0xd3, 0xbf, 0x6e, 0xd3, 0x50,
|
|
0x14, 0xc7, 0x71, 0x1d, 0x3b, 0xb1, 0x93, 0xdb, 0x84, 0xa4, 0x1e, 0x2e, 0x47, 0x15, 0xaa, 0x50,
|
|
0xa6, 0xbb, 0x60, 0x37, 0xfe, 0xd3, 0xa6, 0x6b, 0x07, 0xc6, 0x80, 0xca, 0x13, 0xb4, 0xa9, 0x13,
|
|
0x2c, 0x0a, 0x8e, 0xda, 0x6b, 0x86, 0x8e, 0x4c, 0x3c, 0x1a, 0x1b, 0x3c, 0x02, 0xf0, 0x04, 0x3c,
|
|
0x02, 0x07, 0x87, 0x9c, 0x7b, 0x32, 0x55, 0x91, 0x3a, 0x58, 0xb2, 0xf3, 0x89, 0x15, 0xdd, 0xef,
|
|
0x4f, 0x51, 0x6a, 0xd9, 0x3c, 0x3c, 0xc4, 0xeb, 0xbb, 0xda, 0xd6, 0x51, 0xff, 0xdf, 0xbd, 0x2d,
|
|
0xef, 0xed, 0xfd, 0xd1, 0xab, 0x55, 0x65, 0xdf, 0x37, 0xd7, 0xf1, 0xa2, 0xfe, 0x98, 0xac, 0xea,
|
|
0x55, 0x9d, 0xb4, 0xdf, 0xb8, 0x6e, 0x96, 0xed, 0x53, 0xfb, 0xd0, 0xde, 0x6d, 0xde, 0x9c, 0x74,
|
|
0x95, 0x3f, 0xaf, 0x6e, 0x27, 0x5f, 0x7d, 0x15, 0xcd, 0xab, 0x4f, 0x97, 0xe5, 0xfa, 0xed, 0xd5,
|
|
0xe2, 0x43, 0x79, 0x33, 0xbf, 0xb2, 0xd5, 0xe7, 0x32, 0x3a, 0x52, 0xc1, 0xeb, 0xaa, 0xbc, 0xbd,
|
|
0x99, 0x22, 0xbc, 0xf4, 0x0d, 0x5c, 0x78, 0x63, 0xb8, 0x0c, 0x96, 0xed, 0x27, 0x6c, 0x29, 0x7a,
|
|
0x64, 0x9e, 0xb0, 0x94, 0x2d, 0x43, 0x9f, 0xac, 0x2b, 0x2c, 0x63, 0xcb, 0xb1, 0x43, 0xe6, 0x0b,
|
|
0xcb, 0xd9, 0x0a, 0xec, 0x92, 0x0d, 0x85, 0x15, 0x6c, 0xa7, 0x18, 0x90, 0x75, 0x84, 0x9d, 0xb2,
|
|
0x9d, 0x61, 0x48, 0x76, 0x28, 0xec, 0x8c, 0x6d, 0x86, 0x3d, 0xb2, 0x48, 0xd8, 0x8c, 0xed, 0x1c,
|
|
0xfb, 0x64, 0xa1, 0xb0, 0xf3, 0xe8, 0x85, 0x0a, 0x37, 0x67, 0x3f, 0x41, 0x45, 0x38, 0x6a, 0x31,
|
|
0xdc, 0x1c, 0xfe, 0xc4, 0xe9, 0x14, 0x0f, 0x48, 0x03, 0xa9, 0x53, 0xa7, 0x29, 0x0e, 0x48, 0xc7,
|
|
0x52, 0x53, 0xa7, 0x19, 0x0e, 0x49, 0x7b, 0x52, 0xb3, 0xc9, 0x17, 0x5f, 0x0d, 0x68, 0x8a, 0x37,
|
|
0x6b, 0xfb, 0x7f, 0x04, 0x2d, 0x46, 0x00, 0xe3, 0x06, 0xd0, 0x62, 0x00, 0x30, 0x1e, 0xc7, 0xd7,
|
|
0x22, 0x3e, 0x98, 0x2e, 0x87, 0xd7, 0x22, 0x3c, 0x18, 0x9f, 0xa3, 0x6b, 0x11, 0x1d, 0xcc, 0x90,
|
|
0x83, 0x6b, 0x11, 0x1c, 0x4c, 0x87, 0x63, 0x6b, 0x11, 0x1b, 0xcc, 0x21, 0x87, 0xd6, 0x22, 0x34,
|
|
0x98, 0x88, 0x23, 0x6b, 0x11, 0x19, 0x4c, 0xc8, 0x81, 0x51, 0x06, 0x06, 0x33, 0x72, 0x71, 0x51,
|
|
0xc6, 0x05, 0x13, 0xb8, 0xb0, 0x28, 0xc3, 0x82, 0x19, 0xbb, 0xa8, 0x28, 0xa3, 0x82, 0xe9, 0x71,
|
|
0x50, 0x27, 0x39, 0x3e, 0x23, 0xe9, 0x6f, 0x25, 0x77, 0x52, 0xe0, 0x88, 0x64, 0xb0, 0x95, 0x62,
|
|
0xf2, 0xdd, 0xdb, 0x8e, 0xf0, 0xce, 0xde, 0x35, 0x0b, 0xbb, 0xf7, 0x08, 0xc9, 0xce, 0x08, 0x07,
|
|
0xe9, 0xf3, 0x98, 0xff, 0xa2, 0xb1, 0x5c, 0x97, 0xd7, 0x49, 0x76, 0xd6, 0x79, 0xf4, 0x85, 0x7c,
|
|
0xef, 0x79, 0x92, 0x9d, 0x79, 0x1e, 0xfd, 0x81, 0xd9, 0xd3, 0x16, 0xbd, 0x18, 0xff, 0xf9, 0x75,
|
|
0x0c, 0xdf, 0x7e, 0x1f, 0xc3, 0x0f, 0xba, 0x7e, 0xd2, 0xf5, 0x37, 0x00, 0x00, 0xff, 0xff, 0xce,
|
|
0xa6, 0x95, 0x94, 0xc1, 0x04, 0x00, 0x00,
|
|
}
|