| // 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. |
| // A compilation error at this line likely means your copy of the |
| // proto package needs to be updated. |
| const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package |
| |
| 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(m github_com_gogo_protobuf_proto.Message) string { |
| e := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(m) |
| if e == nil { |
| return "nil" |
| } |
| s := "proto.NewUnsafeXXX_InternalExtensions(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") |
| ) |
| |
| func init() { proto.RegisterFile("fuzz.proto", fileDescriptorFuzz) } |
| |
| var fileDescriptorFuzz = []byte{ |
| // 448 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0xd3, 0xb1, 0x6e, 0xda, 0x50, |
| 0x14, 0xc6, 0x71, 0x1d, 0x1f, 0xb0, 0xc1, 0x81, 0x42, 0x3c, 0xdc, 0x1e, 0x45, 0x15, 0xba, 0x62, |
| 0x3a, 0x4b, 0x71, 0x30, 0x26, 0x21, 0x6b, 0x86, 0x8e, 0xb4, 0x4a, 0x9f, 0x20, 0x21, 0x86, 0x5a, |
| 0x4d, 0x63, 0x94, 0xd8, 0x1d, 0x32, 0x76, 0xea, 0xa3, 0x75, 0x6b, 0x1f, 0xa1, 0xe5, 0x09, 0xfa, |
| 0x08, 0x55, 0x4d, 0x39, 0xf7, 0x30, 0x45, 0x48, 0xdd, 0x6c, 0x7e, 0x5c, 0xa1, 0xfb, 0xff, 0x44, |
| 0x18, 0x2e, 0xab, 0xa7, 0xa7, 0xd1, 0xfa, 0xa1, 0x28, 0x8b, 0xa8, 0xfd, 0xf7, 0xb9, 0xcc, 0x1e, |
| 0xcb, 0xc7, 0x93, 0xd7, 0xab, 0xbc, 0xfc, 0x50, 0xdd, 0x8c, 0x16, 0xc5, 0xa7, 0x78, 0x55, 0xac, |
| 0x8a, 0xb8, 0xfe, 0xc6, 0x4d, 0xb5, 0xac, 0xdf, 0xea, 0x97, 0xfa, 0x69, 0x7b, 0x72, 0xd8, 0x0c, |
| 0x71, 0x9e, 0xdf, 0x0d, 0xbf, 0x62, 0x18, 0xcd, 0xf3, 0xfb, 0xab, 0x6c, 0xfd, 0xee, 0x7a, 0xf1, |
| 0x31, 0xbb, 0x9d, 0x5f, 0x97, 0xf9, 0xe7, 0x2c, 0x3a, 0x09, 0xfd, 0x37, 0x79, 0x76, 0x77, 0x3b, |
| 0x26, 0xb0, 0xc8, 0x70, 0xe9, 0xf5, 0xe1, 0xca, 0x5f, 0xd6, 0x9f, 0x88, 0x25, 0xe4, 0x59, 0x64, |
| 0x4f, 0x59, 0x22, 0x36, 0x21, 0xb4, 0xc8, 0x4d, 0x65, 0x13, 0xb1, 0x94, 0x1a, 0x16, 0x19, 0x95, |
| 0xa5, 0x62, 0x53, 0x6a, 0x5a, 0xe4, 0xae, 0xb2, 0xa9, 0xd8, 0x19, 0xf9, 0x16, 0xb9, 0xa1, 0xec, |
| 0x4c, 0xec, 0x9c, 0x02, 0x8b, 0x7c, 0xac, 0xec, 0x5c, 0x6c, 0x46, 0x2d, 0x8b, 0x1c, 0x29, 0x9b, |
| 0x89, 0x5d, 0x50, 0xdb, 0x22, 0x07, 0xca, 0x2e, 0xa2, 0x57, 0x61, 0xb0, 0xbd, 0xfb, 0x29, 0x85, |
| 0x16, 0xb9, 0x57, 0x63, 0xb0, 0xbd, 0xfc, 0xa9, 0xd3, 0x31, 0x1d, 0x59, 0x64, 0x5f, 0xeb, 0xd8, |
| 0x69, 0x42, 0x1d, 0x8b, 0xdc, 0xd7, 0x9a, 0x38, 0x9d, 0x50, 0xd7, 0x22, 0xb7, 0xb4, 0x4e, 0x86, |
| 0x5f, 0x30, 0xec, 0xcc, 0xf3, 0xfb, 0xb7, 0xeb, 0xf2, 0xdf, 0x08, 0x46, 0x8d, 0x00, 0xec, 0x06, |
| 0x30, 0x6a, 0x00, 0x60, 0x4f, 0xe2, 0x1b, 0x15, 0x1f, 0xb8, 0x29, 0xe1, 0x8d, 0x0a, 0x0f, 0x8c, |
| 0x12, 0xdd, 0xa8, 0xe8, 0xc0, 0x5d, 0x09, 0x6e, 0x54, 0x70, 0xe0, 0x86, 0xc4, 0x36, 0x2a, 0x36, |
| 0xf0, 0xb1, 0x84, 0x36, 0x2a, 0x34, 0x70, 0x24, 0x91, 0x8d, 0x8a, 0x0c, 0x1c, 0x48, 0x60, 0xd2, |
| 0x81, 0x81, 0x7b, 0x2e, 0x2e, 0xe9, 0xb8, 0xc0, 0xbe, 0x0b, 0x4b, 0x3a, 0x2c, 0x70, 0xdf, 0x45, |
| 0x25, 0x1d, 0x15, 0xb8, 0x25, 0x41, 0x9d, 0xa4, 0xf4, 0xc2, 0x02, 0xb7, 0x77, 0x92, 0x3a, 0x99, |
| 0x52, 0xcf, 0x02, 0x77, 0x76, 0x32, 0x1d, 0x7e, 0xf7, 0x76, 0x23, 0xbc, 0x2f, 0x1f, 0xaa, 0x45, |
| 0x79, 0xf0, 0x08, 0xf1, 0xde, 0x08, 0x47, 0xc9, 0xcb, 0x91, 0xfc, 0x45, 0x47, 0x7a, 0x5d, 0x59, |
| 0x27, 0xde, 0x5b, 0xe7, 0xd9, 0x03, 0xe9, 0xc1, 0xf3, 0xc4, 0x7b, 0xf3, 0x3c, 0xfb, 0x03, 0xb3, |
| 0xff, 0x5b, 0xf4, 0xb2, 0xff, 0xfb, 0xd7, 0x00, 0xbe, 0x6d, 0x06, 0xf0, 0x63, 0x33, 0x80, 0x9f, |
| 0x9b, 0x01, 0xfc, 0x09, 0x00, 0x00, 0xff, 0xff, 0xce, 0xa6, 0x95, 0x94, 0xc1, 0x04, 0x00, 0x00, |
| } |
