github.com/fananchong/cstruct-go@v0.0.0-20220616060855-b65d9a2f2e17/benchmarks/myproto2.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: myproto2.proto

/*
	Package benchmarks is a generated protocol buffer package.

	It is generated from these files:
		myproto2.proto

	It has these top-level messages:
		Myproto4
		Myproto3
*/
package benchmarks

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"

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 Myproto4 struct {
	F3 float64 `protobuf:"fixed64,3,opt,name=F3,proto3" json:"F3,omitempty"`
	F4 string  `protobuf:"bytes,4,opt,name=F4,proto3" json:"F4,omitempty"`
}

func (m *Myproto4) Reset()                    { *m = Myproto4{} }
func (m *Myproto4) String() string            { return proto.CompactTextString(m) }
func (*Myproto4) ProtoMessage()               {}
func (*Myproto4) Descriptor() ([]byte, []int) { return fileDescriptorMyproto2, []int{0} }

func (m *Myproto4) GetF3() float64 {
	if m != nil {
		return m.F3
	}
	return 0
}

func (m *Myproto4) GetF4() string {
	if m != nil {
		return m.F4
	}
	return ""
}

type Myproto3 struct {
	F1  bool        `protobuf:"varint,1,opt,name=F1,proto3" json:"F1,omitempty"`
	F2  float32     `protobuf:"fixed32,2,opt,name=F2,proto3" json:"F2,omitempty"`
	F3  float64     `protobuf:"fixed64,3,opt,name=F3,proto3" json:"F3,omitempty"`
	F4  string      `protobuf:"bytes,4,opt,name=F4,proto3" json:"F4,omitempty"`
	F5  []byte      `protobuf:"bytes,5,opt,name=F5,proto3" json:"F5,omitempty"`
	F6  int32       `protobuf:"varint,6,opt,name=F6,proto3" json:"F6,omitempty"`
	F7  int32       `protobuf:"varint,7,opt,name=F7,proto3" json:"F7,omitempty"`
	F8  int32       `protobuf:"varint,8,opt,name=F8,proto3" json:"F8,omitempty"`
	F9  int32       `protobuf:"varint,9,opt,name=F9,proto3" json:"F9,omitempty"`
	F10 int64       `protobuf:"varint,10,opt,name=F10,proto3" json:"F10,omitempty"`
	F11 int64       `protobuf:"varint,11,opt,name=F11,proto3" json:"F11,omitempty"`
	F12 uint32      `protobuf:"varint,12,opt,name=F12,proto3" json:"F12,omitempty"`
	F13 uint32      `protobuf:"varint,13,opt,name=F13,proto3" json:"F13,omitempty"`
	F14 uint32      `protobuf:"varint,14,opt,name=F14,proto3" json:"F14,omitempty"`
	F15 uint32      `protobuf:"varint,15,opt,name=F15,proto3" json:"F15,omitempty"`
	F16 uint64      `protobuf:"varint,16,opt,name=F16,proto3" json:"F16,omitempty"`
	F17 uint64      `protobuf:"varint,17,opt,name=F17,proto3" json:"F17,omitempty"`
	S0  *Myproto4   `protobuf:"bytes,18,opt,name=S0" json:"S0,omitempty"`
	F29 []string    `protobuf:"bytes,19,rep,name=F29" json:"F29,omitempty"`
	F30 []*Myproto4 `protobuf:"bytes,20,rep,name=F30" json:"F30,omitempty"`
}

func (m *Myproto3) Reset()                    { *m = Myproto3{} }
func (m *Myproto3) String() string            { return proto.CompactTextString(m) }
func (*Myproto3) ProtoMessage()               {}
func (*Myproto3) Descriptor() ([]byte, []int) { return fileDescriptorMyproto2, []int{1} }

func (m *Myproto3) GetF1() bool {
	if m != nil {
		return m.F1
	}
	return false
}

func (m *Myproto3) GetF2() float32 {
	if m != nil {
		return m.F2
	}
	return 0
}

func (m *Myproto3) GetF3() float64 {
	if m != nil {
		return m.F3
	}
	return 0
}

func (m *Myproto3) GetF4() string {
	if m != nil {
		return m.F4
	}
	return ""
}

func (m *Myproto3) GetF5() []byte {
	if m != nil {
		return m.F5
	}
	return nil
}

func (m *Myproto3) GetF6() int32 {
	if m != nil {
		return m.F6
	}
	return 0
}

func (m *Myproto3) GetF7() int32 {
	if m != nil {
		return m.F7
	}
	return 0
}

func (m *Myproto3) GetF8() int32 {
	if m != nil {
		return m.F8
	}
	return 0
}

func (m *Myproto3) GetF9() int32 {
	if m != nil {
		return m.F9
	}
	return 0
}

func (m *Myproto3) GetF10() int64 {
	if m != nil {
		return m.F10
	}
	return 0
}

func (m *Myproto3) GetF11() int64 {
	if m != nil {
		return m.F11
	}
	return 0
}

func (m *Myproto3) GetF12() uint32 {
	if m != nil {
		return m.F12
	}
	return 0
}

func (m *Myproto3) GetF13() uint32 {
	if m != nil {
		return m.F13
	}
	return 0
}

func (m *Myproto3) GetF14() uint32 {
	if m != nil {
		return m.F14
	}
	return 0
}

func (m *Myproto3) GetF15() uint32 {
	if m != nil {
		return m.F15
	}
	return 0
}

func (m *Myproto3) GetF16() uint64 {
	if m != nil {
		return m.F16
	}
	return 0
}

func (m *Myproto3) GetF17() uint64 {
	if m != nil {
		return m.F17
	}
	return 0
}

func (m *Myproto3) GetS0() *Myproto4 {
	if m != nil {
		return m.S0
	}
	return nil
}

func (m *Myproto3) GetF29() []string {
	if m != nil {
		return m.F29
	}
	return nil
}

func (m *Myproto3) GetF30() []*Myproto4 {
	if m != nil {
		return m.F30
	}
	return nil
}

func init() {
	proto.RegisterType((*Myproto4)(nil), "benchmarks.Myproto4")
	proto.RegisterType((*Myproto3)(nil), "benchmarks.Myproto3")
}
func (m *Myproto4) 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 *Myproto4) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.F3 != 0 {
		dAtA[i] = 0x19
		i++
		i = encodeFixed64Myproto2(dAtA, i, uint64(math.Float64bits(float64(m.F3))))
	}
	if len(m.F4) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(len(m.F4)))
		i += copy(dAtA[i:], m.F4)
	}
	return i, nil
}

func (m *Myproto3) 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 *Myproto3) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.F1 {
		dAtA[i] = 0x8
		i++
		if m.F1 {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.F2 != 0 {
		dAtA[i] = 0x15
		i++
		i = encodeFixed32Myproto2(dAtA, i, uint32(math.Float32bits(float32(m.F2))))
	}
	if m.F3 != 0 {
		dAtA[i] = 0x19
		i++
		i = encodeFixed64Myproto2(dAtA, i, uint64(math.Float64bits(float64(m.F3))))
	}
	if len(m.F4) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(len(m.F4)))
		i += copy(dAtA[i:], m.F4)
	}
	if len(m.F5) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(len(m.F5)))
		i += copy(dAtA[i:], m.F5)
	}
	if m.F6 != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F6))
	}
	if m.F7 != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F7))
	}
	if m.F8 != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F8))
	}
	if m.F9 != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F9))
	}
	if m.F10 != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F10))
	}
	if m.F11 != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F11))
	}
	if m.F12 != 0 {
		dAtA[i] = 0x60
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F12))
	}
	if m.F13 != 0 {
		dAtA[i] = 0x68
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F13))
	}
	if m.F14 != 0 {
		dAtA[i] = 0x70
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F14))
	}
	if m.F15 != 0 {
		dAtA[i] = 0x78
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F15))
	}
	if m.F16 != 0 {
		dAtA[i] = 0x80
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F16))
	}
	if m.F17 != 0 {
		dAtA[i] = 0x88
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.F17))
	}
	if m.S0 != nil {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintMyproto2(dAtA, i, uint64(m.S0.Size()))
		n1, err := m.S0.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.F29) > 0 {
		for _, s := range m.F29 {
			dAtA[i] = 0x9a
			i++
			dAtA[i] = 0x1
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.F30) > 0 {
		for _, msg := range m.F30 {
			dAtA[i] = 0xa2
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintMyproto2(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func encodeFixed64Myproto2(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 encodeFixed32Myproto2(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 encodeVarintMyproto2(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 *Myproto4) Size() (n int) {
	var l int
	_ = l
	if m.F3 != 0 {
		n += 9
	}
	l = len(m.F4)
	if l > 0 {
		n += 1 + l + sovMyproto2(uint64(l))
	}
	return n
}

func (m *Myproto3) Size() (n int) {
	var l int
	_ = l
	if m.F1 {
		n += 2
	}
	if m.F2 != 0 {
		n += 5
	}
	if m.F3 != 0 {
		n += 9
	}
	l = len(m.F4)
	if l > 0 {
		n += 1 + l + sovMyproto2(uint64(l))
	}
	l = len(m.F5)
	if l > 0 {
		n += 1 + l + sovMyproto2(uint64(l))
	}
	if m.F6 != 0 {
		n += 1 + sovMyproto2(uint64(m.F6))
	}
	if m.F7 != 0 {
		n += 1 + sovMyproto2(uint64(m.F7))
	}
	if m.F8 != 0 {
		n += 1 + sovMyproto2(uint64(m.F8))
	}
	if m.F9 != 0 {
		n += 1 + sovMyproto2(uint64(m.F9))
	}
	if m.F10 != 0 {
		n += 1 + sovMyproto2(uint64(m.F10))
	}
	if m.F11 != 0 {
		n += 1 + sovMyproto2(uint64(m.F11))
	}
	if m.F12 != 0 {
		n += 1 + sovMyproto2(uint64(m.F12))
	}
	if m.F13 != 0 {
		n += 1 + sovMyproto2(uint64(m.F13))
	}
	if m.F14 != 0 {
		n += 1 + sovMyproto2(uint64(m.F14))
	}
	if m.F15 != 0 {
		n += 1 + sovMyproto2(uint64(m.F15))
	}
	if m.F16 != 0 {
		n += 2 + sovMyproto2(uint64(m.F16))
	}
	if m.F17 != 0 {
		n += 2 + sovMyproto2(uint64(m.F17))
	}
	if m.S0 != nil {
		l = m.S0.Size()
		n += 2 + l + sovMyproto2(uint64(l))
	}
	if len(m.F29) > 0 {
		for _, s := range m.F29 {
			l = len(s)
			n += 2 + l + sovMyproto2(uint64(l))
		}
	}
	if len(m.F30) > 0 {
		for _, e := range m.F30 {
			l = e.Size()
			n += 2 + l + sovMyproto2(uint64(l))
		}
	}
	return n
}

func sovMyproto2(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozMyproto2(x uint64) (n int) {
	return sovMyproto2(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Myproto4) 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 ErrIntOverflowMyproto2
			}
			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: Myproto4: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Myproto4: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field F3", 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.F3 = float64(math.Float64frombits(v))
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field F4", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				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 ErrInvalidLengthMyproto2
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.F4 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMyproto2(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMyproto2
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Myproto3) 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 ErrIntOverflowMyproto2
			}
			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: Myproto3: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Myproto3: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F1", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.F1 = bool(v != 0)
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field F2", 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.F2 = float32(math.Float32frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field F3", 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.F3 = float64(math.Float64frombits(v))
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field F4", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				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 ErrInvalidLengthMyproto2
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.F4 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field F5", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMyproto2
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.F5 = append(m.F5[:0], dAtA[iNdEx:postIndex]...)
			if m.F5 == nil {
				m.F5 = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F6", wireType)
			}
			m.F6 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F6 |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F7", wireType)
			}
			m.F7 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F7 |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F8", wireType)
			}
			m.F8 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F8 |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F9", wireType)
			}
			m.F9 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F9 |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F10", wireType)
			}
			m.F10 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F10 |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F11", wireType)
			}
			m.F11 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F11 |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F12", wireType)
			}
			m.F12 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F12 |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F13", wireType)
			}
			m.F13 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F13 |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F14", wireType)
			}
			m.F14 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F14 |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F15", wireType)
			}
			m.F15 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F15 |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F16", wireType)
			}
			m.F16 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F16 |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field F17", wireType)
			}
			m.F17 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.F17 |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field S0", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMyproto2
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.S0 == nil {
				m.S0 = &Myproto4{}
			}
			if err := m.S0.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field F29", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				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 ErrInvalidLengthMyproto2
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.F29 = append(m.F29, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field F30", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMyproto2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMyproto2
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.F30 = append(m.F30, &Myproto4{})
			if err := m.F30[len(m.F30)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMyproto2(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMyproto2
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMyproto2(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, ErrIntOverflowMyproto2
			}
			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, ErrIntOverflowMyproto2
				}
				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, ErrIntOverflowMyproto2
				}
				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, ErrInvalidLengthMyproto2
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowMyproto2
					}
					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 := skipMyproto2(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 (
	ErrInvalidLengthMyproto2 = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMyproto2   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("myproto2.proto", fileDescriptorMyproto2) }

var fileDescriptorMyproto2 = []byte{
	// 300 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0xd1, 0xbb, 0x4e, 0xf3, 0x30,
	0x14, 0xc0, 0xf1, 0xef, 0xd8, 0x6d, 0xbf, 0xd6, 0xbd, 0x10, 0x4c, 0x87, 0x33, 0x45, 0x47, 0x15,
	0x42, 0x16, 0x43, 0x94, 0x38, 0xb7, 0x66, 0x65, 0xf0, 0xc6, 0xe2, 0x3e, 0x01, 0x45, 0x48, 0x48,
	0xa8, 0x14, 0x15, 0x16, 0x5e, 0x81, 0x89, 0xc7, 0x62, 0xe4, 0x11, 0x50, 0x78, 0x11, 0x14, 0x3b,
	0x86, 0x09, 0x31, 0xc5, 0xff, 0x9f, 0x9d, 0x28, 0x3a, 0x16, 0x8b, 0xdd, 0xf3, 0xc3, 0x61, 0xff,
	0xb4, 0xd7, 0x89, 0x7b, 0x48, 0xb1, 0xbd, 0xb9, 0xbf, 0xbe, 0xdd, 0x5d, 0x1d, 0xee, 0x1e, 0x57,
	0xe7, 0x62, 0x7c, 0xe9, 0x77, 0x0b, 0xb9, 0x10, 0xcc, 0xe4, 0xc8, 0x09, 0x14, 0x58, 0x66, 0x72,
	0xd7, 0x05, 0x0e, 0x08, 0xd4, 0xc4, 0x32, 0x53, 0xac, 0x5e, 0xf8, 0xf7, 0x61, 0xbf, 0x99, 0x21,
	0x10, 0xa8, 0xb1, 0x65, 0x26, 0x73, 0xad, 0x91, 0x11, 0x28, 0x66, 0x99, 0xd1, 0x7f, 0x7d, 0xcc,
	0x75, 0x89, 0x43, 0x02, 0x35, 0xb3, 0xcc, 0x94, 0xae, 0x2b, 0x1c, 0x11, 0xa8, 0xa1, 0x65, 0xa6,
	0x72, 0x5d, 0xe3, 0xff, 0xbe, 0x6b, 0xd7, 0x6b, 0x1c, 0xf7, 0xbd, 0x76, 0xdd, 0xe0, 0xa4, 0xef,
	0x46, 0x46, 0x82, 0x9b, 0x2c, 0x45, 0x41, 0xa0, 0xb8, 0xed, 0x96, 0x5e, 0x32, 0x9c, 0x06, 0xc9,
	0xbc, 0x68, 0x9c, 0x11, 0xa8, 0x79, 0x27, 0xda, 0x4b, 0x8e, 0xf3, 0x20, 0xb9, 0x97, 0x02, 0x17,
	0x41, 0x0a, 0x2f, 0x25, 0x1e, 0x05, 0x29, 0xbd, 0x54, 0x18, 0x11, 0xa8, 0x41, 0x27, 0x95, 0x97,
	0x1a, 0x8f, 0x83, 0xd4, 0xf2, 0x54, 0xb0, 0x4d, 0x8a, 0x92, 0x40, 0x4d, 0xf5, 0x32, 0xf9, 0x99,
	0x78, 0x12, 0xc6, 0x6d, 0xd9, 0xc6, 0xff, 0xa3, 0x6e, 0xf0, 0x84, 0xb8, 0x9a, 0xd8, 0x6e, 0x29,
	0xcf, 0x04, 0x37, 0x79, 0x8a, 0x4b, 0xe2, 0xbf, 0xbe, 0xd8, 0x1d, 0xb8, 0x88, 0xde, 0xda, 0x18,
	0xde, 0xdb, 0x18, 0x3e, 0xda, 0x18, 0x5e, 0x3f, 0xe3, 0x7f, 0xdb, 0x91, 0xbf, 0x99, 0xaf, 0x00,
	0x00, 0x00, 0xff, 0xff, 0x6f, 0xb4, 0xde, 0x3c, 0xef, 0x01, 0x00, 0x00,
}