| // Code generated by protoc-gen-gogo. DO NOT EDIT. |
| // source: fuzz.proto |
| |
| 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 reflect "reflect" |
| |
| import encoding_binary "encoding/binary" |
| |
| 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_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `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 fileDescriptor_fuzz_a9783a48f1b0a0f4, []int{0} |
| } |
| func (m *Nil) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Nil) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| if deterministic { |
| return xxx_messageInfo_Nil.Marshal(b, m, deterministic) |
| } else { |
| b = b[:cap(b)] |
| n, err := m.MarshalTo(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| } |
| func (dst *Nil) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Nil.Merge(dst, src) |
| } |
| func (m *Nil) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Nil) XXX_DiscardUnknown() { |
| xxx_messageInfo_Nil.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Nil proto.InternalMessageInfo |
| |
| type NinRepPackedNative struct { |
| Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` |
| Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` |
| Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` |
| Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` |
| Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` |
| Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` |
| Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` |
| Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` |
| Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` |
| Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` |
| Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` |
| Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` |
| Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `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 fileDescriptor_fuzz_a9783a48f1b0a0f4, []int{1} |
| } |
| func (m *NinRepPackedNative) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NinRepPackedNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| if deterministic { |
| return xxx_messageInfo_NinRepPackedNative.Marshal(b, m, deterministic) |
| } else { |
| b = b[:cap(b)] |
| n, err := m.MarshalTo(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| } |
| func (dst *NinRepPackedNative) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NinRepPackedNative.Merge(dst, src) |
| } |
| func (m *NinRepPackedNative) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NinRepPackedNative) XXX_DiscardUnknown() { |
| xxx_messageInfo_NinRepPackedNative.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NinRepPackedNative proto.InternalMessageInfo |
| |
| 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,omitempty"` |
| Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` |
| Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` |
| Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` |
| Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` |
| Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` |
| Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` |
| Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` |
| Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` |
| Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` |
| Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` |
| Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` |
| Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` |
| Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` |
| Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `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 fileDescriptor_fuzz_a9783a48f1b0a0f4, []int{2} |
| } |
| func (m *NinOptNative) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NinOptNative) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| if deterministic { |
| return xxx_messageInfo_NinOptNative.Marshal(b, m, deterministic) |
| } else { |
| b = b[:cap(b)] |
| n, err := m.MarshalTo(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| } |
| func (dst *NinOptNative) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NinOptNative.Merge(dst, src) |
| } |
| func (m *NinOptNative) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NinOptNative) XXX_DiscardUnknown() { |
| xxx_messageInfo_NinOptNative.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NinOptNative proto.InternalMessageInfo |
| |
| 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,omitempty"` |
| Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` |
| Field3 *NinOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` |
| Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` |
| Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` |
| Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` |
| Field8 *NinOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` |
| Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` |
| Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` |
| Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `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 fileDescriptor_fuzz_a9783a48f1b0a0f4, []int{3} |
| } |
| func (m *NinOptStruct) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NinOptStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| if deterministic { |
| return xxx_messageInfo_NinOptStruct.Marshal(b, m, deterministic) |
| } else { |
| b = b[:cap(b)] |
| n, err := m.MarshalTo(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| } |
| func (dst *NinOptStruct) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NinOptStruct.Merge(dst, src) |
| } |
| func (m *NinOptStruct) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NinOptStruct) XXX_DiscardUnknown() { |
| xxx_messageInfo_NinOptStruct.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NinOptStruct proto.InternalMessageInfo |
| |
| 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 (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)) |
| encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1)) |
| i += 8 |
| } |
| } |
| 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)) |
| encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f2)) |
| i += 4 |
| } |
| } |
| 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 { |
| encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(num)) |
| i += 4 |
| } |
| } |
| if len(m.Field10) > 0 { |
| dAtA[i] = 0x52 |
| i++ |
| i = encodeVarintFuzz(dAtA, i, uint64(len(m.Field10)*4)) |
| for _, num := range m.Field10 { |
| encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(num)) |
| i += 4 |
| } |
| } |
| if len(m.Field11) > 0 { |
| dAtA[i] = 0x5a |
| i++ |
| i = encodeVarintFuzz(dAtA, i, uint64(len(m.Field11)*8)) |
| for _, num := range m.Field11 { |
| encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(num)) |
| i += 8 |
| } |
| } |
| if len(m.Field12) > 0 { |
| dAtA[i] = 0x62 |
| i++ |
| i = encodeVarintFuzz(dAtA, i, uint64(len(m.Field12)*8)) |
| for _, num := range m.Field12 { |
| encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(num)) |
| i += 8 |
| } |
| } |
| 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++ |
| encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Field1)))) |
| i += 8 |
| } |
| if m.Field2 != nil { |
| dAtA[i] = 0x15 |
| i++ |
| encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.Field2)))) |
| i += 4 |
| } |
| 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++ |
| encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.Field9)) |
| i += 4 |
| } |
| if m.Field10 != nil { |
| dAtA[i] = 0x55 |
| i++ |
| encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.Field10)) |
| i += 4 |
| } |
| if m.Field11 != nil { |
| dAtA[i] = 0x59 |
| i++ |
| encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.Field11)) |
| i += 8 |
| } |
| if m.Field12 != nil { |
| dAtA[i] = 0x61 |
| i++ |
| encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.Field12)) |
| i += 8 |
| } |
| 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++ |
| encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Field1)))) |
| i += 8 |
| } |
| if m.Field2 != nil { |
| dAtA[i] = 0x15 |
| i++ |
| encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.Field2)))) |
| i += 4 |
| } |
| 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 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 == 1 { |
| var v uint64 |
| if (iNdEx + 8) > l { |
| return io.ErrUnexpectedEOF |
| } |
| v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
| iNdEx += 8 |
| v2 := float64(math.Float64frombits(v)) |
| m.Field1 = append(m.Field1, v2) |
| } else 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 |
| } |
| v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
| iNdEx += 8 |
| 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 == 5 { |
| var v uint32 |
| if (iNdEx + 4) > l { |
| return io.ErrUnexpectedEOF |
| } |
| v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) |
| iNdEx += 4 |
| v2 := float32(math.Float32frombits(v)) |
| m.Field2 = append(m.Field2, v2) |
| } else 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 |
| } |
| v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) |
| iNdEx += 4 |
| 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 == 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 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 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) |
| } |
| case 4: |
| 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 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 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) |
| } |
| case 5: |
| 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 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 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) |
| } |
| case 6: |
| 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 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 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) |
| } |
| case 7: |
| 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 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 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) |
| } |
| case 8: |
| 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 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 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) |
| } |
| case 9: |
| if wireType == 5 { |
| var v uint32 |
| if (iNdEx + 4) > l { |
| return io.ErrUnexpectedEOF |
| } |
| v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) |
| iNdEx += 4 |
| m.Field9 = append(m.Field9, v) |
| } else 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 |
| } |
| v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) |
| iNdEx += 4 |
| m.Field9 = append(m.Field9, v) |
| } |
| } else { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) |
| } |
| case 10: |
| if wireType == 5 { |
| var v int32 |
| if (iNdEx + 4) > l { |
| return io.ErrUnexpectedEOF |
| } |
| v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) |
| iNdEx += 4 |
| m.Field10 = append(m.Field10, v) |
| } else 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 |
| } |
| v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) |
| iNdEx += 4 |
| m.Field10 = append(m.Field10, v) |
| } |
| } else { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) |
| } |
| case 11: |
| if wireType == 1 { |
| var v uint64 |
| if (iNdEx + 8) > l { |
| return io.ErrUnexpectedEOF |
| } |
| v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
| iNdEx += 8 |
| m.Field11 = append(m.Field11, v) |
| } else 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 |
| } |
| v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
| iNdEx += 8 |
| m.Field11 = append(m.Field11, v) |
| } |
| } else { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) |
| } |
| case 12: |
| if wireType == 1 { |
| var v int64 |
| if (iNdEx + 8) > l { |
| return io.ErrUnexpectedEOF |
| } |
| v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
| iNdEx += 8 |
| m.Field12 = append(m.Field12, v) |
| } else 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 |
| } |
| v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
| iNdEx += 8 |
| m.Field12 = append(m.Field12, v) |
| } |
| } else { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) |
| } |
| case 13: |
| 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 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 { |
| 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 |
| } |
| v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
| iNdEx += 8 |
| 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 |
| } |
| v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) |
| iNdEx += 4 |
| 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 |
| } |
| v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) |
| iNdEx += 4 |
| 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 |
| } |
| v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) |
| iNdEx += 4 |
| 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 |
| } |
| v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
| iNdEx += 8 |
| 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 |
| } |
| v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
| iNdEx += 8 |
| 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 |
| } |
| v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
| iNdEx += 8 |
| 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 |
| } |
| v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) |
| iNdEx += 4 |
| 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", fileDescriptor_fuzz_a9783a48f1b0a0f4) } |
| |
| var fileDescriptor_fuzz_a9783a48f1b0a0f4 = []byte{ |
| // 445 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0xd3, 0xbf, 0x6e, 0x1a, 0x41, |
| 0x10, 0xc7, 0x71, 0xcd, 0x0d, 0x7f, 0xd7, 0x10, 0xf0, 0x15, 0x9b, 0x91, 0x15, 0xa1, 0x15, 0xd5, |
| 0x34, 0xe1, 0xc2, 0x71, 0xd8, 0xb8, 0x75, 0x91, 0x92, 0x44, 0xce, 0x13, 0xd8, 0xf8, 0x4c, 0x4e, |
| 0x71, 0x7c, 0xc8, 0x5e, 0x52, 0xb8, 0x4c, 0x95, 0x47, 0x4b, 0x97, 0x3c, 0x42, 0xc2, 0x13, 0xe4, |
| 0x11, 0xa2, 0x9c, 0xcd, 0xec, 0x50, 0x59, 0x48, 0xe9, 0xee, 0xf6, 0xc3, 0x0a, 0xf1, 0xfd, 0x09, |
| 0x63, 0xae, 0xd7, 0x0f, 0x0f, 0xa3, 0xd5, 0x5d, 0xe9, 0xcb, 0xb8, 0xfd, 0xef, 0xd9, 0xe7, 0xf7, |
| 0xfe, 0xfe, 0xe8, 0xf5, 0xb2, 0xf0, 0x1f, 0xd7, 0x97, 0xa3, 0x45, 0xf9, 0x39, 0x59, 0x96, 0xcb, |
| 0x32, 0xa9, 0x3e, 0x71, 0xb9, 0xbe, 0xae, 0xde, 0xaa, 0x97, 0xea, 0xe9, 0xf1, 0xe6, 0xb0, 0x6e, |
| 0x70, 0x5e, 0xdc, 0x0c, 0xbf, 0xa1, 0x89, 0xe7, 0xc5, 0xed, 0x79, 0xbe, 0x7a, 0x7f, 0xb1, 0xf8, |
| 0x94, 0x5f, 0xcd, 0x2f, 0x7c, 0xf1, 0x25, 0x8f, 0x8f, 0x4c, 0xe3, 0x6d, 0x91, 0xdf, 0x5c, 0x8d, |
| 0x09, 0x1c, 0x32, 0x9c, 0x45, 0x7d, 0x38, 0x7f, 0x3a, 0x11, 0x4b, 0x29, 0x72, 0xc8, 0x91, 0xb2, |
| 0x54, 0x6c, 0x42, 0xe8, 0x90, 0xeb, 0xca, 0x26, 0x62, 0x19, 0xd5, 0x1c, 0x32, 0x2a, 0xcb, 0xc4, |
| 0xa6, 0x54, 0x77, 0xc8, 0x5d, 0x65, 0x53, 0xb1, 0x63, 0x6a, 0x38, 0xe4, 0x9a, 0xb2, 0x63, 0xb1, |
| 0x13, 0x6a, 0x3a, 0xe4, 0x43, 0x65, 0x27, 0x62, 0x33, 0x6a, 0x39, 0xe4, 0x58, 0xd9, 0x4c, 0xec, |
| 0x94, 0xda, 0x0e, 0xb9, 0xa9, 0xec, 0x34, 0x7e, 0x65, 0x9a, 0x8f, 0xbf, 0xf4, 0x0d, 0x19, 0x87, |
| 0xdc, 0xab, 0x70, 0x7b, 0x14, 0x74, 0x4c, 0x07, 0x0e, 0xb9, 0xa1, 0x75, 0x1c, 0x34, 0xa5, 0x8e, |
| 0x43, 0xee, 0x6b, 0x4d, 0x83, 0x4e, 0xa8, 0xeb, 0x90, 0x5b, 0x5a, 0x27, 0xc3, 0xaf, 0x68, 0x3a, |
| 0xf3, 0xe2, 0xf6, 0xdd, 0xca, 0x3f, 0x8d, 0x60, 0xd5, 0x08, 0xc0, 0x61, 0x00, 0xab, 0x06, 0x00, |
| 0x8e, 0x24, 0xbe, 0x55, 0xf1, 0x81, 0xeb, 0x12, 0xde, 0xaa, 0xf0, 0xc0, 0x28, 0xd1, 0xad, 0x8a, |
| 0x0e, 0xdc, 0x95, 0xe0, 0x56, 0x05, 0x07, 0xae, 0x49, 0x6c, 0xab, 0x62, 0x03, 0x1f, 0x4a, 0x68, |
| 0xab, 0x42, 0x03, 0xc7, 0x12, 0xd9, 0xaa, 0xc8, 0xc0, 0x4d, 0x09, 0x4c, 0x3a, 0x30, 0x70, 0x2f, |
| 0xc4, 0x25, 0x1d, 0x17, 0xb8, 0x11, 0xc2, 0x92, 0x0e, 0x0b, 0xdc, 0x0f, 0x51, 0x49, 0x47, 0x05, |
| 0x6e, 0x49, 0xd0, 0x20, 0x19, 0xbd, 0x70, 0xc0, 0xed, 0xad, 0x64, 0x41, 0xa6, 0xd4, 0x73, 0xc0, |
| 0x9d, 0xad, 0x4c, 0x87, 0x3f, 0xa2, 0xed, 0x08, 0x1f, 0xfc, 0xdd, 0x7a, 0xe1, 0xf7, 0x1e, 0x21, |
| 0xd9, 0x19, 0xe1, 0x20, 0x7d, 0x39, 0x92, 0xbf, 0xe8, 0x48, 0xaf, 0x2b, 0xeb, 0x24, 0x3b, 0xeb, |
| 0x3c, 0x7b, 0x21, 0xdb, 0x7b, 0x9e, 0x64, 0x67, 0x9e, 0x67, 0xbf, 0x60, 0xf6, 0x7f, 0x8b, 0x9e, |
| 0xf5, 0xff, 0xfc, 0x1e, 0xc0, 0xf7, 0xcd, 0x00, 0x7e, 0x6e, 0x06, 0xf0, 0x6b, 0x33, 0x80, 0xbf, |
| 0x01, 0x00, 0x00, 0xff, 0xff, 0xc0, 0x67, 0xe2, 0xa2, 0xc1, 0x04, 0x00, 0x00, |
| } |
