// 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 "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto"
import fmt "fmt"
import math "math"

// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto"

import strings "strings"
import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/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

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()    {}

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_unrecognized []byte    `json:"-"`
}

func (m *NinRepPackedNative) Reset()         { *m = NinRepPackedNative{} }
func (m *NinRepPackedNative) String() string { return proto.CompactTextString(m) }
func (*NinRepPackedNative) ProtoMessage()    {}

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_unrecognized []byte   `json:"-"`
}

func (m *NinOptNative) Reset()         { *m = NinOptNative{} }
func (m *NinOptNative) String() string { return proto.CompactTextString(m) }
func (*NinOptNative) ProtoMessage()    {}

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_unrecognized []byte        `json:"-"`
}

func (m *NinOptStruct) Reset()         { *m = NinOptStruct{} }
func (m *NinOptStruct) String() string { return proto.CompactTextString(m) }
func (*NinOptStruct) ProtoMessage()    {}

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 (this *Nil) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&fuzztests.Nil{")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NinRepPackedNative) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 17)
	s = append(s, "&fuzztests.NinRepPackedNative{")
	if this.Field1 != nil {
		s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n")
	}
	if this.Field2 != nil {
		s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n")
	}
	if this.Field3 != nil {
		s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
	}
	if this.Field4 != nil {
		s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
	}
	if this.Field5 != nil {
		s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n")
	}
	if this.Field6 != nil {
		s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n")
	}
	if this.Field7 != nil {
		s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n")
	}
	if this.Field8 != nil {
		s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
	}
	if this.Field9 != nil {
		s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n")
	}
	if this.Field10 != nil {
		s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n")
	}
	if this.Field11 != nil {
		s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n")
	}
	if this.Field12 != nil {
		s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n")
	}
	if this.Field13 != nil {
		s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NinOptNative) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 19)
	s = append(s, "&fuzztests.NinOptNative{")
	if this.Field1 != nil {
		s = append(s, "Field1: "+valueToGoStringFuzz(this.Field1, "float64")+",\n")
	}
	if this.Field2 != nil {
		s = append(s, "Field2: "+valueToGoStringFuzz(this.Field2, "float32")+",\n")
	}
	if this.Field3 != nil {
		s = append(s, "Field3: "+valueToGoStringFuzz(this.Field3, "int32")+",\n")
	}
	if this.Field4 != nil {
		s = append(s, "Field4: "+valueToGoStringFuzz(this.Field4, "int64")+",\n")
	}
	if this.Field5 != nil {
		s = append(s, "Field5: "+valueToGoStringFuzz(this.Field5, "uint32")+",\n")
	}
	if this.Field6 != nil {
		s = append(s, "Field6: "+valueToGoStringFuzz(this.Field6, "uint64")+",\n")
	}
	if this.Field7 != nil {
		s = append(s, "Field7: "+valueToGoStringFuzz(this.Field7, "int32")+",\n")
	}
	if this.Field8 != nil {
		s = append(s, "Field8: "+valueToGoStringFuzz(this.Field8, "int64")+",\n")
	}
	if this.Field9 != nil {
		s = append(s, "Field9: "+valueToGoStringFuzz(this.Field9, "uint32")+",\n")
	}
	if this.Field10 != nil {
		s = append(s, "Field10: "+valueToGoStringFuzz(this.Field10, "int32")+",\n")
	}
	if this.Field11 != nil {
		s = append(s, "Field11: "+valueToGoStringFuzz(this.Field11, "uint64")+",\n")
	}
	if this.Field12 != nil {
		s = append(s, "Field12: "+valueToGoStringFuzz(this.Field12, "int64")+",\n")
	}
	if this.Field13 != nil {
		s = append(s, "Field13: "+valueToGoStringFuzz(this.Field13, "bool")+",\n")
	}
	if this.Field14 != nil {
		s = append(s, "Field14: "+valueToGoStringFuzz(this.Field14, "string")+",\n")
	}
	if this.Field15 != nil {
		s = append(s, "Field15: "+valueToGoStringFuzz(this.Field15, "byte")+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NinOptStruct) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 14)
	s = append(s, "&fuzztests.NinOptStruct{")
	if this.Field1 != nil {
		s = append(s, "Field1: "+valueToGoStringFuzz(this.Field1, "float64")+",\n")
	}
	if this.Field2 != nil {
		s = append(s, "Field2: "+valueToGoStringFuzz(this.Field2, "float32")+",\n")
	}
	if this.Field3 != nil {
		s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n")
	}
	if this.Field4 != nil {
		s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n")
	}
	if this.Field6 != nil {
		s = append(s, "Field6: "+valueToGoStringFuzz(this.Field6, "uint64")+",\n")
	}
	if this.Field7 != nil {
		s = append(s, "Field7: "+valueToGoStringFuzz(this.Field7, "int32")+",\n")
	}
	if this.Field8 != nil {
		s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n")
	}
	if this.Field13 != nil {
		s = append(s, "Field13: "+valueToGoStringFuzz(this.Field13, "bool")+",\n")
	}
	if this.Field14 != nil {
		s = append(s, "Field14: "+valueToGoStringFuzz(this.Field14, "string")+",\n")
	}
	if this.Field15 != nil {
		s = append(s, "Field15: "+valueToGoStringFuzz(this.Field15, "byte")+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringFuzz(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func extensionToGoStringFuzz(e map[int32]github_com_gogo_protobuf_proto.Extension) string {
	if e == nil {
		return "nil"
	}
	s := "map[int32]proto.Extension{"
	keys := make([]int, 0, len(e))
	for k := range e {
		keys = append(keys, int(k))
	}
	sort.Ints(keys)
	ss := []string{}
	for _, k := range keys {
		ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
	}
	s += strings.Join(ss, ",") + "}"
	return s
}
func (m *Nil) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Nil) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(data[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *NinRepPackedNative) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *NinRepPackedNative) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Field1) > 0 {
		data[i] = 0xa
		i++
		i = encodeVarintFuzz(data, i, uint64(len(m.Field1)*8))
		for _, num := range m.Field1 {
			f1 := math.Float64bits(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(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(*m.Field1)))
	}
	if m.Field2 != nil {
		data[i] = 0x15
		i++
		i = encodeFixed32Fuzz(data, i, uint32(math.Float32bits(*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(*m.Field1)))
	}
	if m.Field2 != nil {
		data[i] = 0x15
		i++
		i = encodeFixed32Fuzz(data, i, uint32(math.Float32bits(*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([]byte{}, data[iNdEx:postIndex]...)
			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([]byte{}, data[iNdEx:postIndex]...)
			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")
)
