// Code generated by protoc-gen-go-lite. DO NOT EDIT.
// protoc-gen-go-lite version: v0.8.1
// source: github.com/aperturerobotics/protobuf-go-lite/testproto/basic/basic.proto

package basic

import (
	base64 "encoding/base64"
	binary "encoding/binary"
	fmt "fmt"
	io "io"
	maps "maps"
	math "math"
	slices "slices"
	strconv "strconv"
	strings "strings"
	unsafe "unsafe"

	protobuf_go_lite "github.com/aperturerobotics/protobuf-go-lite"
	json "github.com/aperturerobotics/protobuf-go-lite/json"
)

type BasicMsg_MyEnum int32

const (
	BasicMsg_UNKNOWN BasicMsg_MyEnum = 0
	BasicMsg_FIRST   BasicMsg_MyEnum = 1
	BasicMsg_SECOND  BasicMsg_MyEnum = 2
)

// Enum value maps for BasicMsg_MyEnum.
var (
	BasicMsg_MyEnum_name = map[int32]string{
		0: "UNKNOWN",
		1: "FIRST",
		2: "SECOND",
	}
	BasicMsg_MyEnum_value = map[string]int32{
		"UNKNOWN": 0,
		"FIRST":   1,
		"SECOND":  2,
	}
)

func (x BasicMsg_MyEnum) Enum() *BasicMsg_MyEnum {
	p := new(BasicMsg_MyEnum)
	*p = x
	return p
}

func (x BasicMsg_MyEnum) String() string {
	name, valid := BasicMsg_MyEnum_name[int32(x)]
	if valid {
		return name
	}
	return strconv.Itoa(int(x))
}

type BasicMsg struct {
	unknownFields       []byte
	Int32Field          int32            `protobuf:"varint,1,opt,name=int32_field,json=int32Field,proto3" json:"int32Field,omitempty"`
	Int64Field          int64            `protobuf:"varint,2,opt,name=int64_field,json=int64Field,proto3" json:"int64Field,omitempty"`
	Uint32Field         uint32           `protobuf:"varint,3,opt,name=uint32_field,json=uint32Field,proto3" json:"uint32Field,omitempty"`
	Uint64Field         uint64           `protobuf:"varint,4,opt,name=uint64_field,json=uint64Field,proto3" json:"uint64Field,omitempty"`
	Sint32Field         int32            `protobuf:"zigzag32,5,opt,name=sint32_field,json=sint32Field,proto3" json:"sint32Field,omitempty"`
	Sint64Field         int64            `protobuf:"zigzag64,6,opt,name=sint64_field,json=sint64Field,proto3" json:"sint64Field,omitempty"`
	Fixed32Field        uint32           `protobuf:"fixed32,7,opt,name=fixed32_field,json=fixed32Field,proto3" json:"fixed32Field,omitempty"`
	Fixed64Field        uint64           `protobuf:"fixed64,8,opt,name=fixed64_field,json=fixed64Field,proto3" json:"fixed64Field,omitempty"`
	Sfixed32Field       int32            `protobuf:"fixed32,9,opt,name=sfixed32_field,json=sfixed32Field,proto3" json:"sfixed32Field,omitempty"`
	Sfixed64Field       int64            `protobuf:"fixed64,10,opt,name=sfixed64_field,json=sfixed64Field,proto3" json:"sfixed64Field,omitempty"`
	FloatField          float32          `protobuf:"fixed32,11,opt,name=float_field,json=floatField,proto3" json:"floatField,omitempty"`
	DoubleField         float64          `protobuf:"fixed64,12,opt,name=double_field,json=doubleField,proto3" json:"doubleField,omitempty"`
	BoolField           bool             `protobuf:"varint,13,opt,name=bool_field,json=boolField,proto3" json:"boolField,omitempty"`
	StringField         string           `protobuf:"bytes,14,opt,name=string_field,json=stringField,proto3" json:"stringField,omitempty"`
	BytesField          []byte           `protobuf:"bytes,15,opt,name=bytes_field,json=bytesField,proto3" json:"bytesField,omitempty"`
	RepeatedInt32Field  []int32          `protobuf:"varint,16,rep,packed,name=repeated_int32_field,json=repeatedInt32Field,proto3" json:"repeatedInt32Field,omitempty"`
	MapStringInt32Field map[string]int32 `protobuf:"bytes,17,rep,name=map_string_int32_field,json=mapStringInt32Field,proto3" json:"mapStringInt32Field,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	// Types that are assignable to MyOneof:
	//
	//	*BasicMsg_OneofString
	//	*BasicMsg_OneofInt32
	MyOneof       isBasicMsg_MyOneof  `protobuf_oneof:"my_oneof"`
	EnumField     BasicMsg_MyEnum     `protobuf:"varint,20,opt,name=enum_field,json=enumField,proto3" json:"enumField,omitempty"`
	NestedMessage *BasicMsg_NestedMsg `protobuf:"bytes,21,opt,name=nested_message,json=nestedMessage,proto3" json:"nestedMessage,omitempty"`
}

func (x *BasicMsg) Reset() {
	*x = BasicMsg{}
}

func (*BasicMsg) ProtoMessage() {}

func (x *BasicMsg) GetInt32Field() int32 {
	if x != nil {
		return x.Int32Field
	}
	return 0
}

func (x *BasicMsg) GetInt64Field() int64 {
	if x != nil {
		return x.Int64Field
	}
	return 0
}

func (x *BasicMsg) GetUint32Field() uint32 {
	if x != nil {
		return x.Uint32Field
	}
	return 0
}

func (x *BasicMsg) GetUint64Field() uint64 {
	if x != nil {
		return x.Uint64Field
	}
	return 0
}

func (x *BasicMsg) GetSint32Field() int32 {
	if x != nil {
		return x.Sint32Field
	}
	return 0
}

func (x *BasicMsg) GetSint64Field() int64 {
	if x != nil {
		return x.Sint64Field
	}
	return 0
}

func (x *BasicMsg) GetFixed32Field() uint32 {
	if x != nil {
		return x.Fixed32Field
	}
	return 0
}

func (x *BasicMsg) GetFixed64Field() uint64 {
	if x != nil {
		return x.Fixed64Field
	}
	return 0
}

func (x *BasicMsg) GetSfixed32Field() int32 {
	if x != nil {
		return x.Sfixed32Field
	}
	return 0
}

func (x *BasicMsg) GetSfixed64Field() int64 {
	if x != nil {
		return x.Sfixed64Field
	}
	return 0
}

func (x *BasicMsg) GetFloatField() float32 {
	if x != nil {
		return x.FloatField
	}
	return 0
}

func (x *BasicMsg) GetDoubleField() float64 {
	if x != nil {
		return x.DoubleField
	}
	return 0
}

func (x *BasicMsg) GetBoolField() bool {
	if x != nil {
		return x.BoolField
	}
	return false
}

func (x *BasicMsg) GetStringField() string {
	if x != nil {
		return x.StringField
	}
	return ""
}

func (x *BasicMsg) GetBytesField() []byte {
	if x != nil {
		return x.BytesField
	}
	return nil
}

func (x *BasicMsg) GetRepeatedInt32Field() []int32 {
	if x != nil {
		return x.RepeatedInt32Field
	}
	return nil
}

func (x *BasicMsg) GetMapStringInt32Field() map[string]int32 {
	if x != nil {
		return x.MapStringInt32Field
	}
	return nil
}

func (m *BasicMsg) GetMyOneof() isBasicMsg_MyOneof {
	if m != nil {
		return m.MyOneof
	}
	return nil
}

func (x *BasicMsg) GetOneofString() string {
	if x, ok := x.GetMyOneof().(*BasicMsg_OneofString); ok {
		return x.OneofString
	}
	return ""
}

func (x *BasicMsg) GetOneofInt32() int32 {
	if x, ok := x.GetMyOneof().(*BasicMsg_OneofInt32); ok {
		return x.OneofInt32
	}
	return 0
}

func (x *BasicMsg) GetEnumField() BasicMsg_MyEnum {
	if x != nil {
		return x.EnumField
	}
	return BasicMsg_UNKNOWN
}

func (x *BasicMsg) GetNestedMessage() *BasicMsg_NestedMsg {
	if x != nil {
		return x.NestedMessage
	}
	return nil
}

type isBasicMsg_MyOneof interface {
	isBasicMsg_MyOneof()
}

type BasicMsg_OneofString struct {
	OneofString string `protobuf:"bytes,18,opt,name=oneof_string,json=oneofString,proto3,oneof"`
}

type BasicMsg_OneofInt32 struct {
	OneofInt32 int32 `protobuf:"varint,19,opt,name=oneof_int32,json=oneofInt32,proto3,oneof"`
}

func (*BasicMsg_OneofString) isBasicMsg_MyOneof() {}

func (*BasicMsg_OneofInt32) isBasicMsg_MyOneof() {}

type BasicMsg_MapStringInt32FieldEntry struct {
	unknownFields []byte
	Key           string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value         int32  `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (x *BasicMsg_MapStringInt32FieldEntry) Reset() {
	*x = BasicMsg_MapStringInt32FieldEntry{}
}

func (*BasicMsg_MapStringInt32FieldEntry) ProtoMessage() {}

func (x *BasicMsg_MapStringInt32FieldEntry) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *BasicMsg_MapStringInt32FieldEntry) GetValue() int32 {
	if x != nil {
		return x.Value
	}
	return 0
}

type BasicMsg_NestedMsg struct {
	unknownFields []byte
	NestedInt32   int32  `protobuf:"varint,1,opt,name=nested_int32,json=nestedInt32,proto3" json:"nestedInt32,omitempty"`
	NestedString  string `protobuf:"bytes,2,opt,name=nested_string,json=nestedString,proto3" json:"nestedString,omitempty"`
}

func (x *BasicMsg_NestedMsg) Reset() {
	*x = BasicMsg_NestedMsg{}
}

func (*BasicMsg_NestedMsg) ProtoMessage() {}

func (x *BasicMsg_NestedMsg) GetNestedInt32() int32 {
	if x != nil {
		return x.NestedInt32
	}
	return 0
}

func (x *BasicMsg_NestedMsg) GetNestedString() string {
	if x != nil {
		return x.NestedString
	}
	return ""
}

func (m *BasicMsg_NestedMsg) CloneVT() *BasicMsg_NestedMsg {
	if m == nil {
		return (*BasicMsg_NestedMsg)(nil)
	}
	r := new(BasicMsg_NestedMsg)
	r.NestedInt32 = m.NestedInt32
	r.NestedString = m.NestedString
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *BasicMsg_NestedMsg) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *BasicMsg) CloneVT() *BasicMsg {
	if m == nil {
		return (*BasicMsg)(nil)
	}
	r := new(BasicMsg)
	r.Int32Field = m.Int32Field
	r.Int64Field = m.Int64Field
	r.Uint32Field = m.Uint32Field
	r.Uint64Field = m.Uint64Field
	r.Sint32Field = m.Sint32Field
	r.Sint64Field = m.Sint64Field
	r.Fixed32Field = m.Fixed32Field
	r.Fixed64Field = m.Fixed64Field
	r.Sfixed32Field = m.Sfixed32Field
	r.Sfixed64Field = m.Sfixed64Field
	r.FloatField = m.FloatField
	r.DoubleField = m.DoubleField
	r.BoolField = m.BoolField
	r.StringField = m.StringField
	r.EnumField = m.EnumField
	r.NestedMessage = m.NestedMessage.CloneVT()
	if rhs := m.BytesField; rhs != nil {
		r.BytesField = slices.Clone(rhs)
	}
	if rhs := m.RepeatedInt32Field; rhs != nil {
		r.RepeatedInt32Field = slices.Clone(rhs)
	}
	if rhs := m.MapStringInt32Field; rhs != nil {
		r.MapStringInt32Field = maps.Clone(rhs)
	}
	if m.MyOneof != nil {
		r.MyOneof = m.MyOneof.(interface{ CloneOneofVT() isBasicMsg_MyOneof }).CloneOneofVT()
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *BasicMsg) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *BasicMsg_OneofString) CloneVT() *BasicMsg_OneofString {
	if m == nil {
		return (*BasicMsg_OneofString)(nil)
	}
	r := new(BasicMsg_OneofString)
	r.OneofString = m.OneofString
	return r
}

func (m *BasicMsg_OneofString) CloneOneofVT() isBasicMsg_MyOneof {
	return m.CloneVT()
}

func (m *BasicMsg_OneofInt32) CloneVT() *BasicMsg_OneofInt32 {
	if m == nil {
		return (*BasicMsg_OneofInt32)(nil)
	}
	r := new(BasicMsg_OneofInt32)
	r.OneofInt32 = m.OneofInt32
	return r
}

func (m *BasicMsg_OneofInt32) CloneOneofVT() isBasicMsg_MyOneof {
	return m.CloneVT()
}

func (this *BasicMsg_NestedMsg) EqualVT(that *BasicMsg_NestedMsg) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.NestedInt32 != that.NestedInt32 {
		return false
	}
	if this.NestedString != that.NestedString {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *BasicMsg_NestedMsg) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*BasicMsg_NestedMsg)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *BasicMsg) EqualVT(that *BasicMsg) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.MyOneof == nil && that.MyOneof != nil {
		return false
	} else if this.MyOneof != nil {
		if that.MyOneof == nil {
			return false
		}
		if !this.MyOneof.(interface{ EqualVT(isBasicMsg_MyOneof) bool }).EqualVT(that.MyOneof) {
			return false
		}
	}
	if this.Int32Field != that.Int32Field {
		return false
	}
	if this.Int64Field != that.Int64Field {
		return false
	}
	if this.Uint32Field != that.Uint32Field {
		return false
	}
	if this.Uint64Field != that.Uint64Field {
		return false
	}
	if this.Sint32Field != that.Sint32Field {
		return false
	}
	if this.Sint64Field != that.Sint64Field {
		return false
	}
	if this.Fixed32Field != that.Fixed32Field {
		return false
	}
	if this.Fixed64Field != that.Fixed64Field {
		return false
	}
	if this.Sfixed32Field != that.Sfixed32Field {
		return false
	}
	if this.Sfixed64Field != that.Sfixed64Field {
		return false
	}
	if this.FloatField != that.FloatField {
		return false
	}
	if this.DoubleField != that.DoubleField {
		return false
	}
	if this.BoolField != that.BoolField {
		return false
	}
	if this.StringField != that.StringField {
		return false
	}
	if string(this.BytesField) != string(that.BytesField) {
		return false
	}
	if len(this.RepeatedInt32Field) != len(that.RepeatedInt32Field) {
		return false
	}
	for i, vx := range this.RepeatedInt32Field {
		vy := that.RepeatedInt32Field[i]
		if vx != vy {
			return false
		}
	}
	if len(this.MapStringInt32Field) != len(that.MapStringInt32Field) {
		return false
	}
	for i, vx := range this.MapStringInt32Field {
		vy, ok := that.MapStringInt32Field[i]
		if !ok {
			return false
		}
		if vx != vy {
			return false
		}
	}
	if this.EnumField != that.EnumField {
		return false
	}
	if !this.NestedMessage.EqualVT(that.NestedMessage) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *BasicMsg) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*BasicMsg)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *BasicMsg_OneofString) EqualVT(thatIface isBasicMsg_MyOneof) bool {
	that, ok := thatIface.(*BasicMsg_OneofString)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if this.OneofString != that.OneofString {
		return false
	}
	return true
}

func (this *BasicMsg_OneofInt32) EqualVT(thatIface isBasicMsg_MyOneof) bool {
	that, ok := thatIface.(*BasicMsg_OneofInt32)
	if !ok {
		return false
	}
	if this == that {
		return true
	}
	if this == nil && that != nil || this != nil && that == nil {
		return false
	}
	if this.OneofInt32 != that.OneofInt32 {
		return false
	}
	return true
}

// MarshalProtoJSON marshals the BasicMsg_MyEnum to JSON.
func (x BasicMsg_MyEnum) MarshalProtoJSON(s *json.MarshalState) {
	s.WriteEnum(int32(x), BasicMsg_MyEnum_name)
}

// MarshalText marshals the BasicMsg_MyEnum to text.
func (x BasicMsg_MyEnum) MarshalText() ([]byte, error) {
	return []byte(json.GetEnumString(int32(x), BasicMsg_MyEnum_name)), nil
}

// MarshalJSON marshals the BasicMsg_MyEnum to JSON.
func (x BasicMsg_MyEnum) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the BasicMsg_MyEnum from JSON.
func (x *BasicMsg_MyEnum) UnmarshalProtoJSON(s *json.UnmarshalState) {
	v := s.ReadEnum(BasicMsg_MyEnum_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read MyEnum enum: %v", err)
		return
	}
	*x = BasicMsg_MyEnum(v)
}

// UnmarshalText unmarshals the BasicMsg_MyEnum from text.
func (x *BasicMsg_MyEnum) UnmarshalText(b []byte) error {
	i, err := json.ParseEnumString(string(b), BasicMsg_MyEnum_value)
	if err != nil {
		return err
	}
	*x = BasicMsg_MyEnum(i)
	return nil
}

// UnmarshalJSON unmarshals the BasicMsg_MyEnum from JSON.
func (x *BasicMsg_MyEnum) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the BasicMsg_MapStringInt32FieldEntry message to JSON.
func (x *BasicMsg_MapStringInt32FieldEntry) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Key != "" || s.HasField("key") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("key")
		s.WriteString(x.Key)
	}
	if x.Value != 0 || s.HasField("value") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("value")
		s.WriteInt32(x.Value)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the BasicMsg_MapStringInt32FieldEntry to JSON.
func (x *BasicMsg_MapStringInt32FieldEntry) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the BasicMsg_MapStringInt32FieldEntry message from JSON.
func (x *BasicMsg_MapStringInt32FieldEntry) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "key":
			s.AddField("key")
			x.Key = s.ReadString()
		case "value":
			s.AddField("value")
			x.Value = s.ReadInt32()
		}
	})
}

// UnmarshalJSON unmarshals the BasicMsg_MapStringInt32FieldEntry from JSON.
func (x *BasicMsg_MapStringInt32FieldEntry) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the BasicMsg_NestedMsg message to JSON.
func (x *BasicMsg_NestedMsg) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.NestedInt32 != 0 || s.HasField("nestedInt32") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("nestedInt32")
		s.WriteInt32(x.NestedInt32)
	}
	if x.NestedString != "" || s.HasField("nestedString") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("nestedString")
		s.WriteString(x.NestedString)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the BasicMsg_NestedMsg to JSON.
func (x *BasicMsg_NestedMsg) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the BasicMsg_NestedMsg message from JSON.
func (x *BasicMsg_NestedMsg) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "nested_int32", "nestedInt32":
			s.AddField("nested_int32")
			x.NestedInt32 = s.ReadInt32()
		case "nested_string", "nestedString":
			s.AddField("nested_string")
			x.NestedString = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the BasicMsg_NestedMsg from JSON.
func (x *BasicMsg_NestedMsg) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the BasicMsg message to JSON.
func (x *BasicMsg) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Int32Field != 0 || s.HasField("int32Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("int32Field")
		s.WriteInt32(x.Int32Field)
	}
	if x.Int64Field != 0 || s.HasField("int64Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("int64Field")
		s.WriteInt64(x.Int64Field)
	}
	if x.Uint32Field != 0 || s.HasField("uint32Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("uint32Field")
		s.WriteUint32(x.Uint32Field)
	}
	if x.Uint64Field != 0 || s.HasField("uint64Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("uint64Field")
		s.WriteUint64(x.Uint64Field)
	}
	if x.Sint32Field != 0 || s.HasField("sint32Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("sint32Field")
		s.WriteInt32(x.Sint32Field)
	}
	if x.Sint64Field != 0 || s.HasField("sint64Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("sint64Field")
		s.WriteInt64(x.Sint64Field)
	}
	if x.Fixed32Field != 0 || s.HasField("fixed32Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("fixed32Field")
		s.WriteUint32(x.Fixed32Field)
	}
	if x.Fixed64Field != 0 || s.HasField("fixed64Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("fixed64Field")
		s.WriteUint64(x.Fixed64Field)
	}
	if x.Sfixed32Field != 0 || s.HasField("sfixed32Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("sfixed32Field")
		s.WriteInt32(x.Sfixed32Field)
	}
	if x.Sfixed64Field != 0 || s.HasField("sfixed64Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("sfixed64Field")
		s.WriteInt64(x.Sfixed64Field)
	}
	if x.FloatField != 0 || s.HasField("floatField") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("floatField")
		s.WriteFloat32(x.FloatField)
	}
	if x.DoubleField != 0 || s.HasField("doubleField") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("doubleField")
		s.WriteFloat64(x.DoubleField)
	}
	if x.BoolField || s.HasField("boolField") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("boolField")
		s.WriteBool(x.BoolField)
	}
	if x.StringField != "" || s.HasField("stringField") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("stringField")
		s.WriteString(x.StringField)
	}
	if len(x.BytesField) > 0 || s.HasField("bytesField") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("bytesField")
		s.WriteBytes(x.BytesField)
	}
	if len(x.RepeatedInt32Field) > 0 || s.HasField("repeatedInt32Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("repeatedInt32Field")
		s.WriteInt32Array(x.RepeatedInt32Field)
	}
	if x.MapStringInt32Field != nil || s.HasField("mapStringInt32Field") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("mapStringInt32Field")
		s.WriteObjectStart()
		var wroteElement bool
		for k, v := range x.MapStringInt32Field {
			s.WriteMoreIf(&wroteElement)
			s.WriteObjectStringField(k)
			s.WriteInt32(v)
		}
		s.WriteObjectEnd()
	}
	if x.MyOneof != nil {
		switch ov := x.MyOneof.(type) {
		case *BasicMsg_OneofString:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("oneofString")
			s.WriteString(ov.OneofString)
		case *BasicMsg_OneofInt32:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("oneofInt32")
			s.WriteInt32(ov.OneofInt32)
		}
	}
	if x.EnumField != 0 || s.HasField("enumField") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("enumField")
		x.EnumField.MarshalProtoJSON(s)
	}
	if x.NestedMessage != nil || s.HasField("nestedMessage") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("nestedMessage")
		x.NestedMessage.MarshalProtoJSON(s.WithField("nestedMessage"))
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the BasicMsg to JSON.
func (x *BasicMsg) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the BasicMsg message from JSON.
func (x *BasicMsg) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "int32_field", "int32Field":
			s.AddField("int32_field")
			x.Int32Field = s.ReadInt32()
		case "int64_field", "int64Field":
			s.AddField("int64_field")
			x.Int64Field = s.ReadInt64()
		case "uint32_field", "uint32Field":
			s.AddField("uint32_field")
			x.Uint32Field = s.ReadUint32()
		case "uint64_field", "uint64Field":
			s.AddField("uint64_field")
			x.Uint64Field = s.ReadUint64()
		case "sint32_field", "sint32Field":
			s.AddField("sint32_field")
			x.Sint32Field = s.ReadInt32()
		case "sint64_field", "sint64Field":
			s.AddField("sint64_field")
			x.Sint64Field = s.ReadInt64()
		case "fixed32_field", "fixed32Field":
			s.AddField("fixed32_field")
			x.Fixed32Field = s.ReadUint32()
		case "fixed64_field", "fixed64Field":
			s.AddField("fixed64_field")
			x.Fixed64Field = s.ReadUint64()
		case "sfixed32_field", "sfixed32Field":
			s.AddField("sfixed32_field")
			x.Sfixed32Field = s.ReadInt32()
		case "sfixed64_field", "sfixed64Field":
			s.AddField("sfixed64_field")
			x.Sfixed64Field = s.ReadInt64()
		case "float_field", "floatField":
			s.AddField("float_field")
			x.FloatField = s.ReadFloat32()
		case "double_field", "doubleField":
			s.AddField("double_field")
			x.DoubleField = s.ReadFloat64()
		case "bool_field", "boolField":
			s.AddField("bool_field")
			x.BoolField = s.ReadBool()
		case "string_field", "stringField":
			s.AddField("string_field")
			x.StringField = s.ReadString()
		case "bytes_field", "bytesField":
			s.AddField("bytes_field")
			x.BytesField = s.ReadBytes()
		case "repeated_int32_field", "repeatedInt32Field":
			s.AddField("repeated_int32_field")
			if s.ReadNil() {
				x.RepeatedInt32Field = nil
				return
			}
			x.RepeatedInt32Field = s.ReadInt32Array()
		case "map_string_int32_field", "mapStringInt32Field":
			s.AddField("map_string_int32_field")
			if s.ReadNil() {
				x.MapStringInt32Field = nil
				return
			}
			x.MapStringInt32Field = make(map[string]int32)
			s.ReadStringMap(func(key string) {
				x.MapStringInt32Field[key] = s.ReadInt32()
			})
		case "oneof_string", "oneofString":
			s.AddField("oneof_string")
			ov := &BasicMsg_OneofString{}
			x.MyOneof = ov
			ov.OneofString = s.ReadString()
		case "oneof_int32", "oneofInt32":
			s.AddField("oneof_int32")
			ov := &BasicMsg_OneofInt32{}
			x.MyOneof = ov
			ov.OneofInt32 = s.ReadInt32()
		case "enum_field", "enumField":
			s.AddField("enum_field")
			x.EnumField.UnmarshalProtoJSON(s)
		case "nested_message", "nestedMessage":
			if s.ReadNil() {
				x.NestedMessage = nil
				return
			}
			x.NestedMessage = &BasicMsg_NestedMsg{}
			x.NestedMessage.UnmarshalProtoJSON(s.WithField("nested_message", true))
		}
	})
}

// UnmarshalJSON unmarshals the BasicMsg from JSON.
func (x *BasicMsg) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

func (m *BasicMsg_NestedMsg) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BasicMsg_NestedMsg) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *BasicMsg_NestedMsg) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.NestedString) > 0 {
		i -= len(m.NestedString)
		copy(dAtA[i:], m.NestedString)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.NestedString)))
		i--
		dAtA[i] = 0x12
	}
	if m.NestedInt32 != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.NestedInt32))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BasicMsg) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BasicMsg) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *BasicMsg) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if vtmsg, ok := m.MyOneof.(interface {
		MarshalToSizedBufferVT([]byte) (int, error)
	}); ok {
		size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
	}
	if m.NestedMessage != nil {
		size, err := m.NestedMessage.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if m.EnumField != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.EnumField))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	if len(m.MapStringInt32Field) > 0 {
		for k := range m.MapStringInt32Field {
			v := m.MapStringInt32Field[k]
			baseI := i
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.RepeatedInt32Field) > 0 {
		var pksize2 int
		for _, num := range m.RepeatedInt32Field {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num1 := range m.RepeatedInt32Field {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if len(m.BytesField) > 0 {
		i -= len(m.BytesField)
		copy(dAtA[i:], m.BytesField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.BytesField)))
		i--
		dAtA[i] = 0x7a
	}
	if len(m.StringField) > 0 {
		i -= len(m.StringField)
		copy(dAtA[i:], m.StringField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.StringField)))
		i--
		dAtA[i] = 0x72
	}
	if m.BoolField {
		i--
		if m.BoolField {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if m.DoubleField != 0 {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.DoubleField))))
		i--
		dAtA[i] = 0x61
	}
	if m.FloatField != 0 {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FloatField))))
		i--
		dAtA[i] = 0x5d
	}
	if m.Sfixed64Field != 0 {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Sfixed64Field))
		i--
		dAtA[i] = 0x51
	}
	if m.Sfixed32Field != 0 {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Sfixed32Field))
		i--
		dAtA[i] = 0x4d
	}
	if m.Fixed64Field != 0 {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Fixed64Field))
		i--
		dAtA[i] = 0x41
	}
	if m.Fixed32Field != 0 {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Fixed32Field))
		i--
		dAtA[i] = 0x3d
	}
	if m.Sint64Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint64(m.Sint64Field)<<1)^uint64((m.Sint64Field>>63))))
		i--
		dAtA[i] = 0x30
	}
	if m.Sint32Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint32(m.Sint32Field)<<1)^uint32((m.Sint32Field>>31))))
		i--
		dAtA[i] = 0x28
	}
	if m.Uint64Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Uint64Field))
		i--
		dAtA[i] = 0x20
	}
	if m.Uint32Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Uint32Field))
		i--
		dAtA[i] = 0x18
	}
	if m.Int64Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Int64Field))
		i--
		dAtA[i] = 0x10
	}
	if m.Int32Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Int32Field))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BasicMsg_OneofString) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *BasicMsg_OneofString) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.OneofString)
	copy(dAtA[i:], m.OneofString)
	i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.OneofString)))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	return len(dAtA) - i, nil
}
func (m *BasicMsg_OneofInt32) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *BasicMsg_OneofInt32) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.OneofInt32))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x98
	return len(dAtA) - i, nil
}
func (m *BasicMsg_NestedMsg) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BasicMsg_NestedMsg) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *BasicMsg_NestedMsg) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.NestedString) > 0 {
		i -= len(m.NestedString)
		copy(dAtA[i:], m.NestedString)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.NestedString)))
		i--
		dAtA[i] = 0x12
	}
	if m.NestedInt32 != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.NestedInt32))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BasicMsg) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BasicMsg) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *BasicMsg) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.NestedMessage != nil {
		size, err := m.NestedMessage.MarshalToSizedBufferVTStrict(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if m.EnumField != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.EnumField))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	if msg, ok := m.MyOneof.(*BasicMsg_OneofInt32); ok {
		size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
	}
	if msg, ok := m.MyOneof.(*BasicMsg_OneofString); ok {
		size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
	}
	if len(m.MapStringInt32Field) > 0 {
		for k := range m.MapStringInt32Field {
			v := m.MapStringInt32Field[k]
			baseI := i
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.RepeatedInt32Field) > 0 {
		var pksize2 int
		for _, num := range m.RepeatedInt32Field {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num1 := range m.RepeatedInt32Field {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if len(m.BytesField) > 0 {
		i -= len(m.BytesField)
		copy(dAtA[i:], m.BytesField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.BytesField)))
		i--
		dAtA[i] = 0x7a
	}
	if len(m.StringField) > 0 {
		i -= len(m.StringField)
		copy(dAtA[i:], m.StringField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.StringField)))
		i--
		dAtA[i] = 0x72
	}
	if m.BoolField {
		i--
		if m.BoolField {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if m.DoubleField != 0 {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.DoubleField))))
		i--
		dAtA[i] = 0x61
	}
	if m.FloatField != 0 {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FloatField))))
		i--
		dAtA[i] = 0x5d
	}
	if m.Sfixed64Field != 0 {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Sfixed64Field))
		i--
		dAtA[i] = 0x51
	}
	if m.Sfixed32Field != 0 {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Sfixed32Field))
		i--
		dAtA[i] = 0x4d
	}
	if m.Fixed64Field != 0 {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Fixed64Field))
		i--
		dAtA[i] = 0x41
	}
	if m.Fixed32Field != 0 {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Fixed32Field))
		i--
		dAtA[i] = 0x3d
	}
	if m.Sint64Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint64(m.Sint64Field)<<1)^uint64((m.Sint64Field>>63))))
		i--
		dAtA[i] = 0x30
	}
	if m.Sint32Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint32(m.Sint32Field)<<1)^uint32((m.Sint32Field>>31))))
		i--
		dAtA[i] = 0x28
	}
	if m.Uint64Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Uint64Field))
		i--
		dAtA[i] = 0x20
	}
	if m.Uint32Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Uint32Field))
		i--
		dAtA[i] = 0x18
	}
	if m.Int64Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Int64Field))
		i--
		dAtA[i] = 0x10
	}
	if m.Int32Field != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Int32Field))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BasicMsg_OneofString) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *BasicMsg_OneofString) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.OneofString)
	copy(dAtA[i:], m.OneofString)
	i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.OneofString)))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	return len(dAtA) - i, nil
}
func (m *BasicMsg_OneofInt32) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *BasicMsg_OneofInt32) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.OneofInt32))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x98
	return len(dAtA) - i, nil
}
func (m *BasicMsg_NestedMsg) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NestedInt32 != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.NestedInt32))
	}
	l = len(m.NestedString)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *BasicMsg) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Int32Field != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.Int32Field))
	}
	if m.Int64Field != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.Int64Field))
	}
	if m.Uint32Field != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.Uint32Field))
	}
	if m.Uint64Field != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.Uint64Field))
	}
	if m.Sint32Field != 0 {
		n += 1 + protobuf_go_lite.SizeOfZigzag(uint64(m.Sint32Field))
	}
	if m.Sint64Field != 0 {
		n += 1 + protobuf_go_lite.SizeOfZigzag(uint64(m.Sint64Field))
	}
	if m.Fixed32Field != 0 {
		n += 5
	}
	if m.Fixed64Field != 0 {
		n += 9
	}
	if m.Sfixed32Field != 0 {
		n += 5
	}
	if m.Sfixed64Field != 0 {
		n += 9
	}
	if m.FloatField != 0 {
		n += 5
	}
	if m.DoubleField != 0 {
		n += 9
	}
	if m.BoolField {
		n += 2
	}
	l = len(m.StringField)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	l = len(m.BytesField)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if len(m.RepeatedInt32Field) > 0 {
		l = 0
		for _, e := range m.RepeatedInt32Field {
			l += protobuf_go_lite.SizeOfVarint(uint64(e))
		}
		n += 2 + protobuf_go_lite.SizeOfVarint(uint64(l)) + l
	}
	if len(m.MapStringInt32Field) > 0 {
		for k, v := range m.MapStringInt32Field {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + protobuf_go_lite.SizeOfVarint(uint64(len(k))) + 1 + protobuf_go_lite.SizeOfVarint(uint64(v))
			n += mapEntrySize + 2 + protobuf_go_lite.SizeOfVarint(uint64(mapEntrySize))
		}
	}
	if vtmsg, ok := m.MyOneof.(interface{ SizeVT() int }); ok {
		n += vtmsg.SizeVT()
	}
	if m.EnumField != 0 {
		n += 2 + protobuf_go_lite.SizeOfVarint(uint64(m.EnumField))
	}
	if m.NestedMessage != nil {
		l = m.NestedMessage.SizeVT()
		n += 2 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *BasicMsg_OneofString) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OneofString)
	n += 2 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	return n
}
func (m *BasicMsg_OneofInt32) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2 + protobuf_go_lite.SizeOfVarint(uint64(m.OneofInt32))
	return n
}
func (x BasicMsg_MyEnum) MarshalProtoText() string {
	return x.String()
}
func (x *BasicMsg_MapStringInt32FieldEntry) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("MapStringInt32FieldEntry {")
	if x.Key != "" {
		if sb.Len() > 26 {
			sb.WriteString(" ")
		}
		sb.WriteString("key: ")
		sb.WriteString(strconv.Quote(x.Key))
	}
	if x.Value != 0 {
		if sb.Len() > 26 {
			sb.WriteString(" ")
		}
		sb.WriteString("value: ")
		sb.WriteString(strconv.FormatInt(int64(x.Value), 10))
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *BasicMsg_MapStringInt32FieldEntry) String() string {
	return x.MarshalProtoText()
}
func (x *BasicMsg_NestedMsg) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("NestedMsg {")
	if x.NestedInt32 != 0 {
		if sb.Len() > 11 {
			sb.WriteString(" ")
		}
		sb.WriteString("nested_int32: ")
		sb.WriteString(strconv.FormatInt(int64(x.NestedInt32), 10))
	}
	if x.NestedString != "" {
		if sb.Len() > 11 {
			sb.WriteString(" ")
		}
		sb.WriteString("nested_string: ")
		sb.WriteString(strconv.Quote(x.NestedString))
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *BasicMsg_NestedMsg) String() string {
	return x.MarshalProtoText()
}
func (x *BasicMsg) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("BasicMsg {")
	if x.Int32Field != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("int32_field: ")
		sb.WriteString(strconv.FormatInt(int64(x.Int32Field), 10))
	}
	if x.Int64Field != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("int64_field: ")
		sb.WriteString(strconv.FormatInt(int64(x.Int64Field), 10))
	}
	if x.Uint32Field != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("uint32_field: ")
		sb.WriteString(strconv.FormatUint(uint64(x.Uint32Field), 10))
	}
	if x.Uint64Field != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("uint64_field: ")
		sb.WriteString(strconv.FormatUint(uint64(x.Uint64Field), 10))
	}
	if x.Sint32Field != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("sint32_field: ")
		sb.WriteString(strconv.FormatInt(int64(x.Sint32Field), 10))
	}
	if x.Sint64Field != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("sint64_field: ")
		sb.WriteString(strconv.FormatInt(int64(x.Sint64Field), 10))
	}
	if x.Fixed32Field != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("fixed32_field: ")
		sb.WriteString(strconv.FormatUint(uint64(x.Fixed32Field), 10))
	}
	if x.Fixed64Field != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("fixed64_field: ")
		sb.WriteString(strconv.FormatUint(uint64(x.Fixed64Field), 10))
	}
	if x.Sfixed32Field != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("sfixed32_field: ")
		sb.WriteString(strconv.FormatInt(int64(x.Sfixed32Field), 10))
	}
	if x.Sfixed64Field != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("sfixed64_field: ")
		sb.WriteString(strconv.FormatInt(int64(x.Sfixed64Field), 10))
	}
	if x.FloatField != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("float_field: ")
		sb.WriteString(strconv.FormatFloat(float64(x.FloatField), 'g', -1, 32))
	}
	if x.DoubleField != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("double_field: ")
		sb.WriteString(strconv.FormatFloat(x.DoubleField, 'g', -1, 64))
	}
	if x.BoolField != false {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("bool_field: ")
		sb.WriteString(strconv.FormatBool(x.BoolField))
	}
	if x.StringField != "" {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("string_field: ")
		sb.WriteString(strconv.Quote(x.StringField))
	}
	if x.BytesField != nil {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("bytes_field: ")
		sb.WriteString("\"")
		sb.WriteString(base64.StdEncoding.EncodeToString(x.BytesField))
		sb.WriteString("\"")
	}
	if len(x.RepeatedInt32Field) > 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_int32_field: [")
		for i, v := range x.RepeatedInt32Field {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.MapStringInt32Field) > 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("map_string_int32_field: {")
		for _, k := range slices.Sorted(maps.Keys(x.MapStringInt32Field)) {
			v := x.MapStringInt32Field[k]
			sb.WriteString(" ")
			sb.WriteString(strconv.Quote(k))
			sb.WriteString(": ")
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString(" }")
	}
	switch body := x.MyOneof.(type) {
	case *BasicMsg_OneofString:
		if body.OneofString != "" {
			if sb.Len() > 10 {
				sb.WriteString(" ")
			}
			sb.WriteString("oneof_string: ")
			sb.WriteString(strconv.Quote(body.OneofString))
		}
	case *BasicMsg_OneofInt32:
		if body.OneofInt32 != 0 {
			if sb.Len() > 10 {
				sb.WriteString(" ")
			}
			sb.WriteString("oneof_int32: ")
			sb.WriteString(strconv.FormatInt(int64(body.OneofInt32), 10))
		}
	}
	if x.EnumField != 0 {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("enum_field: ")
		sb.WriteString("\"")
		sb.WriteString(BasicMsg_MyEnum(x.EnumField).String())
		sb.WriteString("\"")
	}
	if x.NestedMessage != nil {
		if sb.Len() > 10 {
			sb.WriteString(" ")
		}
		sb.WriteString("nested_message: ")
		sb.WriteString(x.NestedMessage.MarshalProtoText())
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *BasicMsg) String() string {
	return x.MarshalProtoText()
}
func (m *BasicMsg_NestedMsg) UnmarshalVT(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 protobuf_go_lite.ErrIntOverflow
			}
			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: BasicMsg_NestedMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BasicMsg_NestedMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NestedInt32", wireType)
			}
			m.NestedInt32 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NestedInt32 |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NestedString", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				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 protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NestedString = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BasicMsg) UnmarshalVT(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 protobuf_go_lite.ErrIntOverflow
			}
			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: BasicMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BasicMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int32Field", wireType)
			}
			m.Int32Field = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Int32Field |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Field", wireType)
			}
			m.Int64Field = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Int64Field |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint32Field", wireType)
			}
			m.Uint32Field = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uint32Field |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint64Field", wireType)
			}
			m.Uint64Field = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uint64Field |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sint32Field", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				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.Sint32Field = v
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sint64Field", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				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.Sint64Field = int64(v)
		case 7:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Field", wireType)
			}
			m.Fixed32Field = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Fixed32Field = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 8:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Field", wireType)
			}
			m.Fixed64Field = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.Fixed64Field = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 9:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Field", wireType)
			}
			m.Sfixed32Field = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Sfixed32Field = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 10:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Field", wireType)
			}
			m.Sfixed64Field = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.Sfixed64Field = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 11:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field FloatField", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.FloatField = float32(math.Float32frombits(v))
		case 12:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field DoubleField", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.DoubleField = float64(math.Float64frombits(v))
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoolField", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.BoolField = bool(v != 0)
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				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 protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StringField = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesField", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BytesField = append(m.BytesField[:0], dAtA[iNdEx:postIndex]...)
			if m.BytesField == nil {
				m.BytesField = []byte{}
			}
			iNdEx = postIndex
		case 16:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedInt32Field = append(m.RepeatedInt32Field, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedInt32Field) == 0 {
					m.RepeatedInt32Field = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedInt32Field = append(m.RepeatedInt32Field, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedInt32Field", wireType)
			}
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStringInt32Field", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStringInt32Field == nil {
				m.MapStringInt32Field = make(map[string]int32)
			}
			var mapkey string
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStringInt32Field[mapkey] = mapvalue
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneofString", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				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 protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MyOneof = &BasicMsg_OneofString{OneofString: string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneofInt32", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MyOneof = &BasicMsg_OneofInt32{OneofInt32: v}
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnumField", wireType)
			}
			m.EnumField = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EnumField |= BasicMsg_MyEnum(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NestedMessage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NestedMessage == nil {
				m.NestedMessage = &BasicMsg_NestedMsg{}
			}
			if err := m.NestedMessage.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BasicMsg_NestedMsg) UnmarshalVTUnsafe(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 protobuf_go_lite.ErrIntOverflow
			}
			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: BasicMsg_NestedMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BasicMsg_NestedMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NestedInt32", wireType)
			}
			m.NestedInt32 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NestedInt32 |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NestedString", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				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 protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var stringValue string
			if intStringLen > 0 {
				stringValue = unsafe.String(&dAtA[iNdEx], intStringLen)
			}
			m.NestedString = stringValue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BasicMsg) UnmarshalVTUnsafe(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 protobuf_go_lite.ErrIntOverflow
			}
			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: BasicMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BasicMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int32Field", wireType)
			}
			m.Int32Field = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Int32Field |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Field", wireType)
			}
			m.Int64Field = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Int64Field |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint32Field", wireType)
			}
			m.Uint32Field = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uint32Field |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint64Field", wireType)
			}
			m.Uint64Field = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uint64Field |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sint32Field", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				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.Sint32Field = v
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sint64Field", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				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.Sint64Field = int64(v)
		case 7:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Field", wireType)
			}
			m.Fixed32Field = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Fixed32Field = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 8:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Field", wireType)
			}
			m.Fixed64Field = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.Fixed64Field = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 9:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Field", wireType)
			}
			m.Sfixed32Field = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Sfixed32Field = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 10:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Field", wireType)
			}
			m.Sfixed64Field = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.Sfixed64Field = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 11:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field FloatField", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.FloatField = float32(math.Float32frombits(v))
		case 12:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field DoubleField", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.DoubleField = float64(math.Float64frombits(v))
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoolField", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.BoolField = bool(v != 0)
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				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 protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var stringValue string
			if intStringLen > 0 {
				stringValue = unsafe.String(&dAtA[iNdEx], intStringLen)
			}
			m.StringField = stringValue
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesField", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BytesField = dAtA[iNdEx:postIndex]
			iNdEx = postIndex
		case 16:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedInt32Field = append(m.RepeatedInt32Field, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedInt32Field) == 0 {
					m.RepeatedInt32Field = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedInt32Field = append(m.RepeatedInt32Field, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedInt32Field", wireType)
			}
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStringInt32Field", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStringInt32Field == nil {
				m.MapStringInt32Field = make(map[string]int32)
			}
			var mapkey string
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					if intStringLenmapkey == 0 {
						mapkey = ""
					} else {
						mapkey = unsafe.String(&dAtA[iNdEx], intStringLenmapkey)
					}
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return protobuf_go_lite.ErrInvalidLength
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStringInt32Field[mapkey] = mapvalue
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneofString", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				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 protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var stringValue string
			if intStringLen > 0 {
				stringValue = unsafe.String(&dAtA[iNdEx], intStringLen)
			}
			m.MyOneof = &BasicMsg_OneofString{OneofString: stringValue}
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneofInt32", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MyOneof = &BasicMsg_OneofInt32{OneofInt32: v}
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnumField", wireType)
			}
			m.EnumField = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EnumField |= BasicMsg_MyEnum(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NestedMessage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NestedMessage == nil {
				m.NestedMessage = &BasicMsg_NestedMsg{}
			}
			if err := m.NestedMessage.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
