// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: mixer/pkg/protobuf/yaml/testdata/all/types.proto

package foo

import (
	bytes "bytes"
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	types "github.com/gogo/protobuf/types"
	io "io"
	v1beta1 "istio.io/api/policy/v1beta1"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

// 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 Myenum int32

const (
	ONE   Myenum = 0
	TWO   Myenum = 1
	THREE Myenum = 2
)

var Myenum_name = map[int32]string{
	0: "ONE",
	1: "TWO",
	2: "THREE",
}

var Myenum_value = map[string]int32{
	"ONE":   0,
	"TWO":   1,
	"THREE": 2,
}

func (Myenum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6bec8cece9fd961c, []int{0}
}

type OtherInnerenum int32

const (
	INNERONE   OtherInnerenum = 0
	INNERTWO   OtherInnerenum = 1
	INNERTHREE OtherInnerenum = 2
)

var OtherInnerenum_name = map[int32]string{
	0: "INNERONE",
	1: "INNERTWO",
	2: "INNERTHREE",
}

var OtherInnerenum_value = map[string]int32{
	"INNERONE":   0,
	"INNERTWO":   1,
	"INNERTHREE": 2,
}

func (OtherInnerenum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6bec8cece9fd961c, []int{2, 0}
}

type Empty struct {
}

func (m *Empty) Reset()      { *m = Empty{} }
func (*Empty) ProtoMessage() {}
func (*Empty) Descriptor() ([]byte, []int) {
	return fileDescriptor_6bec8cece9fd961c, []int{0}
}
func (m *Empty) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(m, src)
}
func (m *Empty) XXX_Size() int {
	return m.Size()
}
func (m *Empty) XXX_DiscardUnknown() {
	xxx_messageInfo_Empty.DiscardUnknown(m)
}

var xxx_messageInfo_Empty proto.InternalMessageInfo

type Simple struct {
	Byts []byte `protobuf:"bytes,12,opt,name=byts,proto3" json:"byts,omitempty"`
	// complex types
	MapStrStr                    map[string]string                `protobuf:"bytes,18,rep,name=map_str_str,json=mapStrStr,proto3" json:"map_str_str,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	MapStrMsg                    map[string]*Other                `protobuf:"bytes,19,rep,name=map_str_msg,json=mapStrMsg,proto3" json:"map_str_msg,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	MapI32Msg                    map[int32]*Other                 `protobuf:"bytes,20,rep,name=map_i32_msg,json=mapI32Msg,proto3" json:"map_i32_msg,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	MapStrEnum                   map[string]Myenum                `protobuf:"bytes,21,rep,name=map_str_enum,json=mapStrEnum,proto3" json:"map_str_enum,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=foo.Myenum"`
	MapInt64Double               map[int64]float64                `protobuf:"bytes,123,rep,name=map_int64_double,json=mapInt64Double,proto3" json:"map_int64_double,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	MapFixed32Enum               map[uint32]Myenum                `protobuf:"bytes,124,rep,name=map_fixed32_enum,json=mapFixed32Enum,proto3" json:"map_fixed32_enum,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=foo.Myenum"`
	MapStrFloat                  map[string]float32               `protobuf:"bytes,125,rep,name=map_str_float,json=mapStrFloat,proto3" json:"map_str_float,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	MapStrUint64                 map[string]uint64                `protobuf:"bytes,126,rep,name=map_str_uint64,json=mapStrUint64,proto3" json:"map_str_uint64,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	MapStrUint32                 map[string]uint32                `protobuf:"bytes,132,rep,name=map_str_uint32,json=mapStrUint32,proto3" json:"map_str_uint32,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	MapStrFixed64                map[string]uint64                `protobuf:"bytes,133,rep,name=map_str_fixed64,json=mapStrFixed64,proto3" json:"map_str_fixed64,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	MapStrBool                   map[string]bool                  `protobuf:"bytes,134,rep,name=map_str_bool,json=mapStrBool,proto3" json:"map_str_bool,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	MapStrSfixed32               map[string]int32                 `protobuf:"bytes,127,rep,name=map_str_sfixed32,json=mapStrSfixed32,proto3" json:"map_str_sfixed32,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	MapStrSfixed64               map[string]int64                 `protobuf:"bytes,128,rep,name=map_str_sfixed64,json=mapStrSfixed64,proto3" json:"map_str_sfixed64,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	MapStrSint32                 map[string]int32                 `protobuf:"bytes,129,rep,name=map_str_sint32,json=mapStrSint32,proto3" json:"map_str_sint32,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"`
	MapStrSint64                 map[string]int64                 `protobuf:"bytes,130,rep,name=map_str_sint64,json=mapStrSint64,proto3" json:"map_str_sint64,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
	Oth                          *Other                           `protobuf:"bytes,11,opt,name=oth,proto3" json:"oth,omitempty"`
	ROth                         []*Other                         `protobuf:"bytes,26,rep,name=r_oth,json=rOth,proto3" json:"r_oth,omitempty"`
	Enm                          Myenum                           `protobuf:"varint,13,opt,name=enm,proto3,enum=foo.Myenum" json:"enm,omitempty"`
	REnm                         []Myenum                         `protobuf:"varint,28,rep,packed,name=r_enm,json=rEnm,proto3,enum=foo.Myenum" json:"r_enm,omitempty"`
	REnmUnpacked                 []Myenum                         `protobuf:"varint,281,rep,name=r_enm_unpacked,json=rEnmUnpacked,proto3,enum=foo.Myenum" json:"r_enm_unpacked,omitempty"`
	Dbl                          float64                          `protobuf:"fixed64,2,opt,name=dbl,proto3" json:"dbl,omitempty"`
	RDbl                         []float64                        `protobuf:"fixed64,23,rep,packed,name=r_dbl,json=rDbl,proto3" json:"r_dbl,omitempty"`
	RDblUnpacked                 []float64                        `protobuf:"fixed64,24,rep,name=r_dbl_unpacked,json=rDblUnpacked,proto3" json:"r_dbl_unpacked,omitempty"`
	Flt                          float32                          `protobuf:"fixed32,29,opt,name=flt,proto3" json:"flt,omitempty"`
	RFlt                         []float32                        `protobuf:"fixed32,30,rep,packed,name=r_flt,json=rFlt,proto3" json:"r_flt,omitempty"`
	RFltUnpacked                 []float32                        `protobuf:"fixed32,31,rep,name=r_flt_unpacked,json=rFltUnpacked,proto3" json:"r_flt_unpacked,omitempty"`
	I64                          int64                            `protobuf:"varint,32,opt,name=i64,proto3" json:"i64,omitempty"`
	RI64                         []int64                          `protobuf:"varint,33,rep,packed,name=r_i64,json=rI64,proto3" json:"r_i64,omitempty"`
	RI64Unpacked                 []int64                          `protobuf:"varint,34,rep,name=r_i64_unpacked,json=rI64Unpacked,proto3" json:"r_i64_unpacked,omitempty"`
	I32                          int32                            `protobuf:"varint,35,opt,name=i32,proto3" json:"i32,omitempty"`
	RI32                         []int32                          `protobuf:"varint,36,rep,packed,name=r_i32,json=rI32,proto3" json:"r_i32,omitempty"`
	RI32Unpacked                 []int32                          `protobuf:"varint,37,rep,name=r_i32_unpacked,json=rI32Unpacked,proto3" json:"r_i32_unpacked,omitempty"`
	Ui64                         uint64                           `protobuf:"varint,38,opt,name=ui64,proto3" json:"ui64,omitempty"`
	RUi64                        []uint64                         `protobuf:"varint,39,rep,packed,name=r_ui64,json=rUi64,proto3" json:"r_ui64,omitempty"`
	RUi64Unpacked                []uint64                         `protobuf:"varint,40,rep,name=r_ui64_unpacked,json=rUi64Unpacked,proto3" json:"r_ui64_unpacked,omitempty"`
	Ui32                         uint32                           `protobuf:"varint,41,opt,name=ui32,proto3" json:"ui32,omitempty"`
	RUi32                        []uint32                         `protobuf:"varint,42,rep,packed,name=r_ui32,json=rUi32,proto3" json:"r_ui32,omitempty"`
	RUi32Unpacked                []uint32                         `protobuf:"varint,43,rep,name=r_ui32_unpacked,json=rUi32Unpacked,proto3" json:"r_ui32_unpacked,omitempty"`
	F64                          uint64                           `protobuf:"fixed64,44,opt,name=f64,proto3" json:"f64,omitempty"`
	RF64                         []uint64                         `protobuf:"fixed64,45,rep,packed,name=r_f64,json=rF64,proto3" json:"r_f64,omitempty"`
	RF64Unpacked                 []uint64                         `protobuf:"fixed64,46,rep,name=r_f64_unpacked,json=rF64Unpacked,proto3" json:"r_f64_unpacked,omitempty"`
	Sf64                         int64                            `protobuf:"fixed64,47,opt,name=sf64,proto3" json:"sf64,omitempty"`
	RSf64                        []int64                          `protobuf:"fixed64,48,rep,packed,name=r_sf64,json=rSf64,proto3" json:"r_sf64,omitempty"`
	RSf64Unpacked                []int64                          `protobuf:"fixed64,49,rep,name=r_sf64_unpacked,json=rSf64Unpacked,proto3" json:"r_sf64_unpacked,omitempty"`
	F32                          uint32                           `protobuf:"fixed32,50,opt,name=f32,proto3" json:"f32,omitempty"`
	RF32                         []uint32                         `protobuf:"fixed32,51,rep,packed,name=r_f32,json=rF32,proto3" json:"r_f32,omitempty"`
	RF32Unpacked                 []uint32                         `protobuf:"fixed32,52,rep,name=r_f32_unpacked,json=rF32Unpacked,proto3" json:"r_f32_unpacked,omitempty"`
	Sf32                         int32                            `protobuf:"fixed32,53,opt,name=sf32,proto3" json:"sf32,omitempty"`
	RSf32                        []int32                          `protobuf:"fixed32,54,rep,packed,name=r_sf32,json=rSf32,proto3" json:"r_sf32,omitempty"`
	RSf32Unpacked                []int32                          `protobuf:"fixed32,55,rep,name=r_sf32_unpacked,json=rSf32Unpacked,proto3" json:"r_sf32_unpacked,omitempty"`
	B                            bool                             `protobuf:"varint,4,opt,name=b,proto3" json:"b,omitempty"`
	RB                           []bool                           `protobuf:"varint,56,rep,packed,name=r_b,json=rB,proto3" json:"r_b,omitempty"`
	RBUnpacked                   []bool                           `protobuf:"varint,57,rep,name=r_b_unpacked,json=rBUnpacked,proto3" json:"r_b_unpacked,omitempty"`
	Str                          string                           `protobuf:"bytes,1,opt,name=str,proto3" json:"str,omitempty"`
	RStr                         []string                         `protobuf:"bytes,58,rep,name=r_str,json=rStr,proto3" json:"r_str,omitempty"`
	Si32                         int32                            `protobuf:"zigzag32,59,opt,name=si32,proto3" json:"si32,omitempty"`
	RSi32                        []int32                          `protobuf:"zigzag32,60,rep,packed,name=r_si32,json=rSi32,proto3" json:"r_si32,omitempty"`
	RSi32Unpacked                []int32                          `protobuf:"zigzag32,61,rep,name=r_si32_unpacked,json=rSi32Unpacked,proto3" json:"r_si32_unpacked,omitempty"`
	Si64                         int64                            `protobuf:"zigzag64,62,opt,name=si64,proto3" json:"si64,omitempty"`
	RSi64                        []int64                          `protobuf:"zigzag64,63,rep,packed,name=r_si64,json=rSi64,proto3" json:"r_si64,omitempty"`
	RSi64Unpacked                []int64                          `protobuf:"zigzag64,64,rep,name=r_si64_unpacked,json=rSi64Unpacked,proto3" json:"r_si64_unpacked,omitempty"`
	IstioValue                   *v1beta1.Value                   `protobuf:"bytes,65,opt,name=istio_value,json=istioValue,proto3" json:"istio_value,omitempty"`
	MapStrIstioValue             map[string]*v1beta1.Value        `protobuf:"bytes,66,rep,name=map_str_istio_value,json=mapStrIstioValue,proto3" json:"map_str_istio_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	IpaddressIstioValue          *v1beta1.IPAddress               `protobuf:"bytes,67,opt,name=ipaddress_istio_value,json=ipaddressIstioValue,proto3" json:"ipaddress_istio_value,omitempty"`
	MapStrIpaddressIstioValue    map[string]*v1beta1.IPAddress    `protobuf:"bytes,68,rep,name=map_str_ipaddress_istio_value,json=mapStrIpaddressIstioValue,proto3" json:"map_str_ipaddress_istio_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	DurationIstioValue           *v1beta1.Duration                `protobuf:"bytes,69,opt,name=duration_istio_value,json=durationIstioValue,proto3" json:"duration_istio_value,omitempty"`
	MapStrDurationIstioValue     map[string]*v1beta1.Duration     `protobuf:"bytes,70,rep,name=map_str_duration_istio_value,json=mapStrDurationIstioValue,proto3" json:"map_str_duration_istio_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	TimestampIstioValue          *v1beta1.TimeStamp               `protobuf:"bytes,71,opt,name=timestamp_istio_value,json=timestampIstioValue,proto3" json:"timestamp_istio_value,omitempty"`
	MapStrTimestampIstioValue    map[string]*v1beta1.TimeStamp    `protobuf:"bytes,72,rep,name=map_str_timestamp_istio_value,json=mapStrTimestampIstioValue,proto3" json:"map_str_timestamp_istio_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	DnsnameIstioValue            *v1beta1.DNSName                 `protobuf:"bytes,73,opt,name=dnsname_istio_value,json=dnsnameIstioValue,proto3" json:"dnsname_istio_value,omitempty"`
	MapStrDnsnameIstioValue      map[string]*v1beta1.DNSName      `protobuf:"bytes,74,rep,name=map_str_dnsname_istio_value,json=mapStrDnsnameIstioValue,proto3" json:"map_str_dnsname_istio_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	EmailaddressIstioValue       *v1beta1.EmailAddress            `protobuf:"bytes,75,opt,name=emailaddress_istio_value,json=emailaddressIstioValue,proto3" json:"emailaddress_istio_value,omitempty"`
	MapStrEmailaddressIstioValue map[string]*v1beta1.EmailAddress `protobuf:"bytes,76,rep,name=map_str_emailaddress_istio_value,json=mapStrEmailaddressIstioValue,proto3" json:"map_str_emailaddress_istio_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	UriIstioValue                *v1beta1.Uri                     `protobuf:"bytes,77,opt,name=uri_istio_value,json=uriIstioValue,proto3" json:"uri_istio_value,omitempty"`
	MapStrUriIstioValue          map[string]*v1beta1.Uri          `protobuf:"bytes,78,rep,name=map_str_uri_istio_value,json=mapStrUriIstioValue,proto3" json:"map_str_uri_istio_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	GoogleProtobufDuration       *types.Duration                  `protobuf:"bytes,79,opt,name=google_protobuf_duration,json=googleProtobufDuration,proto3" json:"google_protobuf_duration,omitempty"`
	GoogleProtobufTimestamp      *types.Timestamp                 `protobuf:"bytes,80,opt,name=google_protobuf_timestamp,json=googleProtobufTimestamp,proto3" json:"google_protobuf_timestamp,omitempty"`
}

func (m *Simple) Reset()      { *m = Simple{} }
func (*Simple) ProtoMessage() {}
func (*Simple) Descriptor() ([]byte, []int) {
	return fileDescriptor_6bec8cece9fd961c, []int{1}
}
func (m *Simple) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Simple) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Simple.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Simple) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Simple.Merge(m, src)
}
func (m *Simple) XXX_Size() int {
	return m.Size()
}
func (m *Simple) XXX_DiscardUnknown() {
	xxx_messageInfo_Simple.DiscardUnknown(m)
}

var xxx_messageInfo_Simple proto.InternalMessageInfo

func (m *Simple) GetByts() []byte {
	if m != nil {
		return m.Byts
	}
	return nil
}

func (m *Simple) GetMapStrStr() map[string]string {
	if m != nil {
		return m.MapStrStr
	}
	return nil
}

func (m *Simple) GetMapStrMsg() map[string]*Other {
	if m != nil {
		return m.MapStrMsg
	}
	return nil
}

func (m *Simple) GetMapI32Msg() map[int32]*Other {
	if m != nil {
		return m.MapI32Msg
	}
	return nil
}

func (m *Simple) GetMapStrEnum() map[string]Myenum {
	if m != nil {
		return m.MapStrEnum
	}
	return nil
}

func (m *Simple) GetMapInt64Double() map[int64]float64 {
	if m != nil {
		return m.MapInt64Double
	}
	return nil
}

func (m *Simple) GetMapFixed32Enum() map[uint32]Myenum {
	if m != nil {
		return m.MapFixed32Enum
	}
	return nil
}

func (m *Simple) GetMapStrFloat() map[string]float32 {
	if m != nil {
		return m.MapStrFloat
	}
	return nil
}

func (m *Simple) GetMapStrUint64() map[string]uint64 {
	if m != nil {
		return m.MapStrUint64
	}
	return nil
}

func (m *Simple) GetMapStrUint32() map[string]uint32 {
	if m != nil {
		return m.MapStrUint32
	}
	return nil
}

func (m *Simple) GetMapStrFixed64() map[string]uint64 {
	if m != nil {
		return m.MapStrFixed64
	}
	return nil
}

func (m *Simple) GetMapStrBool() map[string]bool {
	if m != nil {
		return m.MapStrBool
	}
	return nil
}

func (m *Simple) GetMapStrSfixed32() map[string]int32 {
	if m != nil {
		return m.MapStrSfixed32
	}
	return nil
}

func (m *Simple) GetMapStrSfixed64() map[string]int64 {
	if m != nil {
		return m.MapStrSfixed64
	}
	return nil
}

func (m *Simple) GetMapStrSint32() map[string]int32 {
	if m != nil {
		return m.MapStrSint32
	}
	return nil
}

func (m *Simple) GetMapStrSint64() map[string]int64 {
	if m != nil {
		return m.MapStrSint64
	}
	return nil
}

func (m *Simple) GetOth() *Other {
	if m != nil {
		return m.Oth
	}
	return nil
}

func (m *Simple) GetROth() []*Other {
	if m != nil {
		return m.ROth
	}
	return nil
}

func (m *Simple) GetEnm() Myenum {
	if m != nil {
		return m.Enm
	}
	return ONE
}

func (m *Simple) GetREnm() []Myenum {
	if m != nil {
		return m.REnm
	}
	return nil
}

func (m *Simple) GetREnmUnpacked() []Myenum {
	if m != nil {
		return m.REnmUnpacked
	}
	return nil
}

func (m *Simple) GetDbl() float64 {
	if m != nil {
		return m.Dbl
	}
	return 0
}

func (m *Simple) GetRDbl() []float64 {
	if m != nil {
		return m.RDbl
	}
	return nil
}

func (m *Simple) GetRDblUnpacked() []float64 {
	if m != nil {
		return m.RDblUnpacked
	}
	return nil
}

func (m *Simple) GetFlt() float32 {
	if m != nil {
		return m.Flt
	}
	return 0
}

func (m *Simple) GetRFlt() []float32 {
	if m != nil {
		return m.RFlt
	}
	return nil
}

func (m *Simple) GetRFltUnpacked() []float32 {
	if m != nil {
		return m.RFltUnpacked
	}
	return nil
}

func (m *Simple) GetI64() int64 {
	if m != nil {
		return m.I64
	}
	return 0
}

func (m *Simple) GetRI64() []int64 {
	if m != nil {
		return m.RI64
	}
	return nil
}

func (m *Simple) GetRI64Unpacked() []int64 {
	if m != nil {
		return m.RI64Unpacked
	}
	return nil
}

func (m *Simple) GetI32() int32 {
	if m != nil {
		return m.I32
	}
	return 0
}

func (m *Simple) GetRI32() []int32 {
	if m != nil {
		return m.RI32
	}
	return nil
}

func (m *Simple) GetRI32Unpacked() []int32 {
	if m != nil {
		return m.RI32Unpacked
	}
	return nil
}

func (m *Simple) GetUi64() uint64 {
	if m != nil {
		return m.Ui64
	}
	return 0
}

func (m *Simple) GetRUi64() []uint64 {
	if m != nil {
		return m.RUi64
	}
	return nil
}

func (m *Simple) GetRUi64Unpacked() []uint64 {
	if m != nil {
		return m.RUi64Unpacked
	}
	return nil
}

func (m *Simple) GetUi32() uint32 {
	if m != nil {
		return m.Ui32
	}
	return 0
}

func (m *Simple) GetRUi32() []uint32 {
	if m != nil {
		return m.RUi32
	}
	return nil
}

func (m *Simple) GetRUi32Unpacked() []uint32 {
	if m != nil {
		return m.RUi32Unpacked
	}
	return nil
}

func (m *Simple) GetF64() uint64 {
	if m != nil {
		return m.F64
	}
	return 0
}

func (m *Simple) GetRF64() []uint64 {
	if m != nil {
		return m.RF64
	}
	return nil
}

func (m *Simple) GetRF64Unpacked() []uint64 {
	if m != nil {
		return m.RF64Unpacked
	}
	return nil
}

func (m *Simple) GetSf64() int64 {
	if m != nil {
		return m.Sf64
	}
	return 0
}

func (m *Simple) GetRSf64() []int64 {
	if m != nil {
		return m.RSf64
	}
	return nil
}

func (m *Simple) GetRSf64Unpacked() []int64 {
	if m != nil {
		return m.RSf64Unpacked
	}
	return nil
}

func (m *Simple) GetF32() uint32 {
	if m != nil {
		return m.F32
	}
	return 0
}

func (m *Simple) GetRF32() []uint32 {
	if m != nil {
		return m.RF32
	}
	return nil
}

func (m *Simple) GetRF32Unpacked() []uint32 {
	if m != nil {
		return m.RF32Unpacked
	}
	return nil
}

func (m *Simple) GetSf32() int32 {
	if m != nil {
		return m.Sf32
	}
	return 0
}

func (m *Simple) GetRSf32() []int32 {
	if m != nil {
		return m.RSf32
	}
	return nil
}

func (m *Simple) GetRSf32Unpacked() []int32 {
	if m != nil {
		return m.RSf32Unpacked
	}
	return nil
}

func (m *Simple) GetB() bool {
	if m != nil {
		return m.B
	}
	return false
}

func (m *Simple) GetRB() []bool {
	if m != nil {
		return m.RB
	}
	return nil
}

func (m *Simple) GetRBUnpacked() []bool {
	if m != nil {
		return m.RBUnpacked
	}
	return nil
}

func (m *Simple) GetStr() string {
	if m != nil {
		return m.Str
	}
	return ""
}

func (m *Simple) GetRStr() []string {
	if m != nil {
		return m.RStr
	}
	return nil
}

func (m *Simple) GetSi32() int32 {
	if m != nil {
		return m.Si32
	}
	return 0
}

func (m *Simple) GetRSi32() []int32 {
	if m != nil {
		return m.RSi32
	}
	return nil
}

func (m *Simple) GetRSi32Unpacked() []int32 {
	if m != nil {
		return m.RSi32Unpacked
	}
	return nil
}

func (m *Simple) GetSi64() int64 {
	if m != nil {
		return m.Si64
	}
	return 0
}

func (m *Simple) GetRSi64() []int64 {
	if m != nil {
		return m.RSi64
	}
	return nil
}

func (m *Simple) GetRSi64Unpacked() []int64 {
	if m != nil {
		return m.RSi64Unpacked
	}
	return nil
}

func (m *Simple) GetIstioValue() *v1beta1.Value {
	if m != nil {
		return m.IstioValue
	}
	return nil
}

func (m *Simple) GetMapStrIstioValue() map[string]*v1beta1.Value {
	if m != nil {
		return m.MapStrIstioValue
	}
	return nil
}

func (m *Simple) GetIpaddressIstioValue() *v1beta1.IPAddress {
	if m != nil {
		return m.IpaddressIstioValue
	}
	return nil
}

func (m *Simple) GetMapStrIpaddressIstioValue() map[string]*v1beta1.IPAddress {
	if m != nil {
		return m.MapStrIpaddressIstioValue
	}
	return nil
}

func (m *Simple) GetDurationIstioValue() *v1beta1.Duration {
	if m != nil {
		return m.DurationIstioValue
	}
	return nil
}

func (m *Simple) GetMapStrDurationIstioValue() map[string]*v1beta1.Duration {
	if m != nil {
		return m.MapStrDurationIstioValue
	}
	return nil
}

func (m *Simple) GetTimestampIstioValue() *v1beta1.TimeStamp {
	if m != nil {
		return m.TimestampIstioValue
	}
	return nil
}

func (m *Simple) GetMapStrTimestampIstioValue() map[string]*v1beta1.TimeStamp {
	if m != nil {
		return m.MapStrTimestampIstioValue
	}
	return nil
}

func (m *Simple) GetDnsnameIstioValue() *v1beta1.DNSName {
	if m != nil {
		return m.DnsnameIstioValue
	}
	return nil
}

func (m *Simple) GetMapStrDnsnameIstioValue() map[string]*v1beta1.DNSName {
	if m != nil {
		return m.MapStrDnsnameIstioValue
	}
	return nil
}

func (m *Simple) GetEmailaddressIstioValue() *v1beta1.EmailAddress {
	if m != nil {
		return m.EmailaddressIstioValue
	}
	return nil
}

func (m *Simple) GetMapStrEmailaddressIstioValue() map[string]*v1beta1.EmailAddress {
	if m != nil {
		return m.MapStrEmailaddressIstioValue
	}
	return nil
}

func (m *Simple) GetUriIstioValue() *v1beta1.Uri {
	if m != nil {
		return m.UriIstioValue
	}
	return nil
}

func (m *Simple) GetMapStrUriIstioValue() map[string]*v1beta1.Uri {
	if m != nil {
		return m.MapStrUriIstioValue
	}
	return nil
}

func (m *Simple) GetGoogleProtobufDuration() *types.Duration {
	if m != nil {
		return m.GoogleProtobufDuration
	}
	return nil
}

func (m *Simple) GetGoogleProtobufTimestamp() *types.Timestamp {
	if m != nil {
		return m.GoogleProtobufTimestamp
	}
	return nil
}

type Other struct {
	Str    string         `protobuf:"bytes,1,opt,name=str,proto3" json:"str,omitempty"`
	Dbl    float64        `protobuf:"fixed64,2,opt,name=dbl,proto3" json:"dbl,omitempty"`
	I64    int64          `protobuf:"varint,3,opt,name=i64,proto3" json:"i64,omitempty"`
	B      bool           `protobuf:"varint,4,opt,name=b,proto3" json:"b,omitempty"`
	Inenum OtherInnerenum `protobuf:"varint,5,opt,name=inenum,proto3,enum=foo.OtherInnerenum" json:"inenum,omitempty"`
	Inmsg  *OtherInnerMsg `protobuf:"bytes,6,opt,name=inmsg,proto3" json:"inmsg,omitempty"`
}

func (m *Other) Reset()      { *m = Other{} }
func (*Other) ProtoMessage() {}
func (*Other) Descriptor() ([]byte, []int) {
	return fileDescriptor_6bec8cece9fd961c, []int{2}
}
func (m *Other) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Other) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Other.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Other) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Other.Merge(m, src)
}
func (m *Other) XXX_Size() int {
	return m.Size()
}
func (m *Other) XXX_DiscardUnknown() {
	xxx_messageInfo_Other.DiscardUnknown(m)
}

var xxx_messageInfo_Other proto.InternalMessageInfo

func (m *Other) GetStr() string {
	if m != nil {
		return m.Str
	}
	return ""
}

func (m *Other) GetDbl() float64 {
	if m != nil {
		return m.Dbl
	}
	return 0
}

func (m *Other) GetI64() int64 {
	if m != nil {
		return m.I64
	}
	return 0
}

func (m *Other) GetB() bool {
	if m != nil {
		return m.B
	}
	return false
}

func (m *Other) GetInenum() OtherInnerenum {
	if m != nil {
		return m.Inenum
	}
	return INNERONE
}

func (m *Other) GetInmsg() *OtherInnerMsg {
	if m != nil {
		return m.Inmsg
	}
	return nil
}

type OtherInnerMsg struct {
	Str string  `protobuf:"bytes,1,opt,name=str,proto3" json:"str,omitempty"`
	Dbl float64 `protobuf:"fixed64,2,opt,name=dbl,proto3" json:"dbl,omitempty"`
	I64 int64   `protobuf:"varint,3,opt,name=i64,proto3" json:"i64,omitempty"`
}

func (m *OtherInnerMsg) Reset()      { *m = OtherInnerMsg{} }
func (*OtherInnerMsg) ProtoMessage() {}
func (*OtherInnerMsg) Descriptor() ([]byte, []int) {
	return fileDescriptor_6bec8cece9fd961c, []int{2, 0}
}
func (m *OtherInnerMsg) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OtherInnerMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OtherInnerMsg.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OtherInnerMsg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OtherInnerMsg.Merge(m, src)
}
func (m *OtherInnerMsg) XXX_Size() int {
	return m.Size()
}
func (m *OtherInnerMsg) XXX_DiscardUnknown() {
	xxx_messageInfo_OtherInnerMsg.DiscardUnknown(m)
}

var xxx_messageInfo_OtherInnerMsg proto.InternalMessageInfo

func (m *OtherInnerMsg) GetStr() string {
	if m != nil {
		return m.Str
	}
	return ""
}

func (m *OtherInnerMsg) GetDbl() float64 {
	if m != nil {
		return m.Dbl
	}
	return 0
}

func (m *OtherInnerMsg) GetI64() int64 {
	if m != nil {
		return m.I64
	}
	return 0
}

type Outer struct {
	In *Outer_Inner `protobuf:"bytes,1,opt,name=in,proto3" json:"in,omitempty"`
}

func (m *Outer) Reset()      { *m = Outer{} }
func (*Outer) ProtoMessage() {}
func (*Outer) Descriptor() ([]byte, []int) {
	return fileDescriptor_6bec8cece9fd961c, []int{3}
}
func (m *Outer) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Outer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Outer.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Outer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Outer.Merge(m, src)
}
func (m *Outer) XXX_Size() int {
	return m.Size()
}
func (m *Outer) XXX_DiscardUnknown() {
	xxx_messageInfo_Outer.DiscardUnknown(m)
}

var xxx_messageInfo_Outer proto.InternalMessageInfo

func (m *Outer) GetIn() *Outer_Inner {
	if m != nil {
		return m.In
	}
	return nil
}

type Outer_Inner struct {
	Str string  `protobuf:"bytes,1,opt,name=str,proto3" json:"str,omitempty"`
	Dbl float64 `protobuf:"fixed64,2,opt,name=dbl,proto3" json:"dbl,omitempty"`
	I64 int64   `protobuf:"varint,3,opt,name=i64,proto3" json:"i64,omitempty"`
	B   bool    `protobuf:"varint,4,opt,name=b,proto3" json:"b,omitempty"`
}

func (m *Outer_Inner) Reset()      { *m = Outer_Inner{} }
func (*Outer_Inner) ProtoMessage() {}
func (*Outer_Inner) Descriptor() ([]byte, []int) {
	return fileDescriptor_6bec8cece9fd961c, []int{3, 0}
}
func (m *Outer_Inner) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Outer_Inner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Outer_Inner.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Outer_Inner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Outer_Inner.Merge(m, src)
}
func (m *Outer_Inner) XXX_Size() int {
	return m.Size()
}
func (m *Outer_Inner) XXX_DiscardUnknown() {
	xxx_messageInfo_Outer_Inner.DiscardUnknown(m)
}

var xxx_messageInfo_Outer_Inner proto.InternalMessageInfo

func (m *Outer_Inner) GetStr() string {
	if m != nil {
		return m.Str
	}
	return ""
}

func (m *Outer_Inner) GetDbl() float64 {
	if m != nil {
		return m.Dbl
	}
	return 0
}

func (m *Outer_Inner) GetI64() int64 {
	if m != nil {
		return m.I64
	}
	return 0
}

func (m *Outer_Inner) GetB() bool {
	if m != nil {
		return m.B
	}
	return false
}

func init() {
	proto.RegisterEnum("foo.Myenum", Myenum_name, Myenum_value)
	proto.RegisterEnum("foo.OtherInnerenum", OtherInnerenum_name, OtherInnerenum_value)
	proto.RegisterType((*Empty)(nil), "foo.Empty")
	proto.RegisterType((*Simple)(nil), "foo.Simple")
	proto.RegisterMapType((map[uint32]Myenum)(nil), "foo.Simple.MapFixed32EnumEntry")
	proto.RegisterMapType((map[int32]*Other)(nil), "foo.Simple.MapI32MsgEntry")
	proto.RegisterMapType((map[int64]float64)(nil), "foo.Simple.MapInt64DoubleEntry")
	proto.RegisterMapType((map[string]bool)(nil), "foo.Simple.MapStrBoolEntry")
	proto.RegisterMapType((map[string]*v1beta1.DNSName)(nil), "foo.Simple.MapStrDnsnameIstioValueEntry")
	proto.RegisterMapType((map[string]*v1beta1.Duration)(nil), "foo.Simple.MapStrDurationIstioValueEntry")
	proto.RegisterMapType((map[string]*v1beta1.EmailAddress)(nil), "foo.Simple.MapStrEmailaddressIstioValueEntry")
	proto.RegisterMapType((map[string]Myenum)(nil), "foo.Simple.MapStrEnumEntry")
	proto.RegisterMapType((map[string]uint64)(nil), "foo.Simple.MapStrFixed64Entry")
	proto.RegisterMapType((map[string]float32)(nil), "foo.Simple.MapStrFloatEntry")
	proto.RegisterMapType((map[string]*v1beta1.IPAddress)(nil), "foo.Simple.MapStrIpaddressIstioValueEntry")
	proto.RegisterMapType((map[string]*v1beta1.Value)(nil), "foo.Simple.MapStrIstioValueEntry")
	proto.RegisterMapType((map[string]*Other)(nil), "foo.Simple.MapStrMsgEntry")
	proto.RegisterMapType((map[string]int32)(nil), "foo.Simple.MapStrSfixed32Entry")
	proto.RegisterMapType((map[string]int64)(nil), "foo.Simple.MapStrSfixed64Entry")
	proto.RegisterMapType((map[string]int32)(nil), "foo.Simple.MapStrSint32Entry")
	proto.RegisterMapType((map[string]int64)(nil), "foo.Simple.MapStrSint64Entry")
	proto.RegisterMapType((map[string]string)(nil), "foo.Simple.MapStrStrEntry")
	proto.RegisterMapType((map[string]*v1beta1.TimeStamp)(nil), "foo.Simple.MapStrTimestampIstioValueEntry")
	proto.RegisterMapType((map[string]uint32)(nil), "foo.Simple.MapStrUint32Entry")
	proto.RegisterMapType((map[string]uint64)(nil), "foo.Simple.MapStrUint64Entry")
	proto.RegisterMapType((map[string]*v1beta1.Uri)(nil), "foo.Simple.MapStrUriIstioValueEntry")
	proto.RegisterType((*Other)(nil), "foo.other")
	proto.RegisterType((*OtherInnerMsg)(nil), "foo.other.innerMsg")
	proto.RegisterType((*Outer)(nil), "foo.Outer")
	proto.RegisterType((*Outer_Inner)(nil), "foo.Outer.Inner")
}

func init() {
	proto.RegisterFile("mixer/pkg/protobuf/yaml/testdata/all/types.proto", fileDescriptor_6bec8cece9fd961c)
}

var fileDescriptor_6bec8cece9fd961c = []byte{
	// 1962 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x98, 0xcf, 0x73, 0xdb, 0xc6,
	0x15, 0xc7, 0x05, 0x82, 0xd4, 0x8f, 0xd5, 0x2f, 0x6a, 0x69, 0xc7, 0x6b, 0x46, 0x82, 0xd6, 0xaa,
	0xd3, 0xc2, 0x4e, 0x42, 0xc6, 0x00, 0xc3, 0xb8, 0xae, 0xed, 0xd8, 0x8a, 0xa8, 0x98, 0x4e, 0xf5,
	0x63, 0x96, 0x76, 0x3a, 0xd3, 0xe9, 0x8c, 0x4a, 0x86, 0xa0, 0x8c, 0x11, 0x40, 0x70, 0x00, 0xd0,
	0x13, 0x4e, 0x7f, 0xa5, 0x9d, 0xb6, 0xe7, 0x5e, 0x7b, 0xea, 0xb5, 0x7f, 0x4a, 0x7b, 0xf3, 0x31,
	0xc7, 0x5a, 0xbe, 0xf4, 0x98, 0x3f, 0xa1, 0xb3, 0xbb, 0x00, 0xb8, 0x00, 0x97, 0xa4, 0x93, 0xe9,
	0x41, 0x33, 0x8b, 0xf7, 0xf6, 0x7d, 0xde, 0xf7, 0xed, 0x2e, 0x81, 0xb7, 0x02, 0x1f, 0xb9, 0xf6,
	0xd7, 0x96, 0x5f, 0x1d, 0x5c, 0x9c, 0x57, 0x07, 0xbe, 0x17, 0x7a, 0x9d, 0x61, 0xaf, 0x3a, 0x6a,
	0xbb, 0x4e, 0x35, 0xb4, 0x82, 0xb0, 0xdb, 0x0e, 0xdb, 0xd5, 0xb6, 0xe3, 0x54, 0xc3, 0xd1, 0xc0,
	0x0a, 0x2a, 0x6c, 0x02, 0x54, 0x7b, 0x9e, 0x57, 0xd6, 0xce, 0x3d, 0xef, 0xdc, 0xb1, 0xc6, 0x31,
	0xdd, 0xa1, 0xdf, 0x0e, 0x6d, 0xaf, 0xcf, 0x27, 0x95, 0x77, 0xb3, 0xfe, 0xd0, 0x76, 0xad, 0x20,
	0x6c, 0xbb, 0x83, 0x68, 0xc2, 0xf5, 0x81, 0xe7, 0xd8, 0x5f, 0x8d, 0xaa, 0x2f, 0xef, 0x74, 0xac,
	0xb0, 0x7d, 0x87, 0x65, 0xe0, 0xae, 0xbd, 0x25, 0x50, 0x68, 0xb8, 0x83, 0x70, 0xb4, 0xf7, 0xef,
	0xf7, 0xc1, 0x62, 0xcb, 0x76, 0x07, 0x8e, 0x05, 0x21, 0xc8, 0x77, 0x46, 0x61, 0x80, 0xd6, 0xb0,
	0xa2, 0xaf, 0x11, 0x36, 0x86, 0xf7, 0xc0, 0xaa, 0xdb, 0x1e, 0x9c, 0x05, 0xa1, 0x4f, 0xff, 0x10,
	0xc4, 0xaa, 0xbe, 0x6a, 0x94, 0x2b, 0x3d, 0xcf, 0xab, 0xf0, 0xa8, 0xca, 0x51, 0x7b, 0xd0, 0x0a,
	0xfd, 0x56, 0xe8, 0x37, 0xfa, 0xa1, 0x3f, 0x22, 0x2b, 0x6e, 0xfc, 0x2c, 0xc6, 0xba, 0xc1, 0x39,
	0x2a, 0x4d, 0x8b, 0x3d, 0x0a, 0xce, 0x53, 0xb1, 0x47, 0xc1, 0x79, 0x1c, 0x6b, 0x9b, 0x06, 0x8b,
	0xbd, 0x22, 0x8d, 0x6d, 0x9a, 0x46, 0x2a, 0x96, 0x3f, 0xc3, 0x07, 0x60, 0x2d, 0xce, 0x6b, 0xf5,
	0x87, 0x2e, 0xba, 0xca, 0x82, 0xdf, 0x9d, 0x4c, 0xdc, 0xe8, 0x0f, 0x5d, 0x1e, 0x0d, 0xdc, 0xc4,
	0x00, 0x9b, 0xa0, 0xc8, 0x52, 0xf7, 0xc3, 0x7a, 0xed, 0xac, 0xeb, 0x0d, 0x3b, 0x8e, 0x85, 0x7e,
	0xc3, 0x10, 0xbb, 0xd9, 0xfc, 0x74, 0xca, 0x01, 0x9b, 0xc1, 0x31, 0x1b, 0x6e, 0xca, 0x18, 0xa3,
	0x7a, 0xf6, 0xd7, 0x56, 0xd7, 0x34, 0xb8, 0x9a, 0xdf, 0x4a, 0x51, 0x87, 0x7c, 0xca, 0x58, 0x11,
	0x45, 0x09, 0x46, 0xf8, 0x08, 0xac, 0xc7, 0x45, 0xf5, 0x1c, 0xaf, 0x1d, 0xa2, 0xdf, 0x31, 0xce,
	0xf6, 0x64, 0x55, 0x87, 0xd4, 0xcd, 0x21, 0xab, 0xee, 0xd8, 0x02, 0x3f, 0x03, 0x1b, 0x31, 0x61,
	0xc8, 0x8a, 0x43, 0xbf, 0x67, 0x88, 0x9d, 0x49, 0xc4, 0x73, 0xe6, 0xe7, 0x8c, 0x35, 0x57, 0x30,
	0xc1, 0x83, 0x34, 0xc4, 0x34, 0xd0, 0x9f, 0x95, 0x59, 0x14, 0xaa, 0x3e, 0x43, 0x31, 0x0d, 0xf8,
	0x39, 0xd8, 0x4c, 0x8a, 0xa1, 0x35, 0xd6, 0x6b, 0xe8, 0x2f, 0x1c, 0xa3, 0x49, 0xea, 0xe1, 0x33,
	0x38, 0x67, 0xdd, 0x15, 0x6d, 0xf0, 0xe1, 0x78, 0xab, 0x3b, 0x9e, 0xe7, 0xa0, 0xbf, 0x2a, 0xd3,
	0xf6, 0x7a, 0xdf, 0xf3, 0x9c, 0xd4, 0x5e, 0x53, 0x43, 0xbc, 0x41, 0xec, 0x78, 0x47, 0xbb, 0x84,
	0xfe, 0x20, 0xdd, 0x20, 0x7a, 0xa6, 0x7b, 0xf1, 0x7e, 0xc4, 0x1b, 0x24, 0x18, 0xe1, 0xd3, 0x2c,
	0xaa, 0x5e, 0x43, 0xdf, 0x28, 0xb3, 0x59, 0x71, 0x55, 0x29, 0x56, 0x7a, 0x95, 0x03, 0xbe, 0xca,
	0x7f, 0x9c, 0xba, 0xca, 0xad, 0xc9, 0x55, 0xe6, 0xa6, 0x2c, 0xa5, 0x5e, 0x43, 0x7f, 0x9a, 0x49,
	0xc9, 0xec, 0x38, 0x37, 0xc1, 0x6d, 0xa0, 0x7a, 0xe1, 0x0b, 0xb4, 0x8a, 0x15, 0x7d, 0xd5, 0x00,
	0x2c, 0xd2, 0x0b, 0x5f, 0x58, 0x3e, 0xa1, 0x66, 0xb8, 0x0b, 0x0a, 0xfe, 0x19, 0xf5, 0x97, 0x19,
	0x59, 0xf4, 0xe7, 0xfd, 0x93, 0xf0, 0x05, 0xdc, 0x01, 0xaa, 0xd5, 0x77, 0xd1, 0x3a, 0x56, 0xf4,
	0x0d, 0x63, 0x95, 0xb9, 0xdd, 0x11, 0xfd, 0x21, 0x10, 0x6a, 0x87, 0x98, 0xc6, 0xd3, 0x09, 0xdb,
	0x58, 0xcd, 0x4e, 0xc8, 0xfb, 0x8d, 0xbe, 0x0b, 0xeb, 0x60, 0x83, 0xcd, 0x38, 0x1b, 0xf6, 0x07,
	0xed, 0xaf, 0x2e, 0xac, 0x2e, 0xfa, 0x7b, 0x6e, 0x62, 0xee, 0x7e, 0xae, 0xb8, 0x40, 0xd6, 0xe8,
	0xfc, 0xe7, 0xd1, 0x2c, 0x58, 0x04, 0x6a, 0xb7, 0xe3, 0xa0, 0x1c, 0x56, 0x74, 0x85, 0xd0, 0x21,
	0x2c, 0xd1, 0x5c, 0xd4, 0x76, 0x0d, 0xab, 0xba, 0x42, 0xf2, 0xfe, 0x41, 0xc7, 0x81, 0x3a, 0xc5,
	0x77, 0x3b, 0xce, 0x18, 0x8f, 0xa8, 0x37, 0x02, 0x1e, 0x74, 0x1c, 0x11, 0xd8, 0x73, 0x42, 0xb4,
	0x83, 0x15, 0x3d, 0x47, 0xe8, 0x90, 0x03, 0xa9, 0x4d, 0xc3, 0xaa, 0x9e, 0x23, 0x79, 0xff, 0xd0,
	0x09, 0x39, 0xb0, 0xe7, 0x84, 0x63, 0xe0, 0x2e, 0xf5, 0x46, 0xc0, 0x43, 0x27, 0x14, 0x81, 0x76,
	0xbd, 0x86, 0x30, 0x56, 0x74, 0x95, 0xd0, 0x21, 0x07, 0x52, 0xdb, 0x0d, 0xac, 0xea, 0x2a, 0xc9,
	0xfb, 0xcd, 0x7a, 0x8d, 0x03, 0xed, 0x7a, 0x6d, 0x0c, 0xdc, 0xa3, 0xde, 0x08, 0xd8, 0xac, 0xd7,
	0x52, 0x40, 0xd3, 0x40, 0x3f, 0xc2, 0x8a, 0x5e, 0x20, 0x74, 0x18, 0x01, 0x4d, 0x03, 0xdd, 0xc4,
	0xaa, 0x5e, 0xa0, 0x40, 0xd3, 0x88, 0x80, 0xa6, 0x31, 0x06, 0xbe, 0x47, 0xbd, 0x31, 0xd0, 0x34,
	0x12, 0x20, 0x04, 0xf9, 0x21, 0x95, 0xf3, 0x63, 0xac, 0xe8, 0x79, 0xc2, 0xc6, 0xf0, 0x2a, 0x58,
	0xa4, 0xbf, 0xfd, 0x7a, 0x0d, 0xfd, 0x04, 0xab, 0x7a, 0x9e, 0x14, 0xfc, 0xe7, 0xd4, 0x7c, 0x1b,
	0x6c, 0x72, 0xf3, 0x98, 0xaa, 0x53, 0x3f, 0xa3, 0xae, 0xb3, 0x39, 0x69, 0xac, 0x69, 0xa0, 0x5b,
	0x58, 0xd1, 0xd7, 0x09, 0x1b, 0xc7, 0x58, 0xd3, 0x40, 0xb7, 0xb1, 0xaa, 0xaf, 0x33, 0xac, 0x69,
	0xc4, 0x58, 0x51, 0xec, 0xfb, 0xd4, 0x9f, 0x60, 0x05, 0xb5, 0x74, 0x83, 0xea, 0x35, 0xf4, 0x01,
	0x56, 0xf4, 0x45, 0x42, 0x87, 0xd1, 0x06, 0xd5, 0x6b, 0xe8, 0x43, 0xac, 0xea, 0x8b, 0x74, 0x83,
	0xe2, 0xf5, 0xec, 0x89, 0x42, 0x2b, 0xd4, 0x1b, 0x6f, 0x50, 0x5a, 0x67, 0x40, 0xa3, 0xab, 0x58,
	0xd1, 0x8b, 0x84, 0x8d, 0xb9, 0x4e, 0x66, 0xfd, 0x08, 0xab, 0x7a, 0x91, 0x14, 0xfc, 0x56, 0x2f,
	0x2e, 0x3f, 0x48, 0x51, 0xef, 0x50, 0x7f, 0xa4, 0x93, 0xce, 0x49, 0xe9, 0x34, 0x0d, 0x64, 0x60,
	0x45, 0x5f, 0x22, 0x74, 0x18, 0xe9, 0x34, 0x0d, 0x64, 0x62, 0x55, 0x5f, 0xa2, 0x3a, 0xe3, 0x6d,
	0xea, 0x89, 0x95, 0xd7, 0xa8, 0x37, 0xd6, 0x99, 0xde, 0xa6, 0x80, 0x46, 0x7f, 0x8c, 0x15, 0x7d,
	0x93, 0xb0, 0x71, 0xac, 0xd3, 0x34, 0x50, 0x1d, 0xab, 0xfa, 0x26, 0xd3, 0x19, 0xaf, 0x67, 0x90,
	0xa2, 0x7e, 0x42, 0xfd, 0x89, 0x4e, 0x01, 0xbb, 0x06, 0x94, 0x0e, 0xca, 0x63, 0x45, 0x5f, 0x26,
	0x4a, 0x07, 0x6e, 0x02, 0xd5, 0x3f, 0xeb, 0xa0, 0xbb, 0x58, 0xd5, 0x97, 0x49, 0xce, 0xdf, 0x87,
	0x37, 0xc1, 0x9a, 0x7f, 0xd6, 0x19, 0x73, 0x7e, 0x4a, 0x3d, 0x8c, 0x03, 0xfc, 0x7d, 0xb1, 0x58,
	0xda, 0x38, 0x28, 0x58, 0xd1, 0x57, 0x08, 0x1d, 0xf2, 0x62, 0xa9, 0xed, 0x1e, 0x56, 0xf5, 0x15,
	0x92, 0x67, 0xbd, 0x02, 0x2d, 0x81, 0x6e, 0xfe, 0xcf, 0xb0, 0xa2, 0x6f, 0x11, 0x36, 0x8e, 0x4a,
	0xa0, 0xd6, 0xfb, 0x58, 0xd5, 0xb7, 0x68, 0x09, 0xc9, 0x91, 0x08, 0x52, 0x47, 0xe2, 0x01, 0xf5,
	0xc7, 0x25, 0xd8, 0x99, 0x95, 0xa1, 0x47, 0xf5, 0x21, 0x56, 0x74, 0x48, 0xd8, 0x38, 0xc6, 0xd6,
	0x6b, 0xe8, 0x53, 0xac, 0xea, 0x90, 0x61, 0x93, 0x1d, 0x4c, 0x1d, 0xe0, 0x47, 0xd4, 0x9f, 0x60,
	0x85, 0x1d, 0xbc, 0x0f, 0x56, 0xed, 0x20, 0xb4, 0xbd, 0xb3, 0x97, 0x6d, 0x67, 0x68, 0xa1, 0xc7,
	0xec, 0xdd, 0xf8, 0x6e, 0x85, 0xd9, 0x2a, 0xbc, 0xe9, 0xaa, 0x44, 0x4d, 0x57, 0xe5, 0x4b, 0x3a,
	0x85, 0x00, 0xe6, 0x63, 0x63, 0x78, 0x0a, 0x4a, 0xf1, 0x7b, 0x59, 0xa4, 0xec, 0xb3, 0x37, 0xe8,
	0x8d, 0xc9, 0x77, 0x73, 0x33, 0x09, 0xe5, 0xef, 0xe7, 0xa2, 0x9b, 0x31, 0xc3, 0x16, 0xb8, 0x6a,
	0x0f, 0xda, 0xdd, 0xae, 0x6f, 0x05, 0x41, 0x8a, 0xf9, 0x19, 0x53, 0xb6, 0x2b, 0x57, 0xd6, 0x3c,
	0x7d, 0xcc, 0x43, 0x48, 0x29, 0x89, 0x16, 0xa0, 0x0e, 0xd8, 0x49, 0x64, 0x4a, 0xe1, 0x07, 0x4c,
	0xf0, 0x6d, 0x89, 0xe0, 0x49, 0x1a, 0x57, 0x7e, 0xdd, 0x9d, 0xe6, 0x87, 0xa7, 0xe0, 0x4a, 0xdc,
	0xde, 0xa6, 0x92, 0x34, 0x58, 0x05, 0x9a, 0xbc, 0x82, 0x83, 0x28, 0x82, 0xc0, 0x38, 0x56, 0x20,
	0xda, 0x60, 0x3b, 0xd6, 0x2f, 0x25, 0x1f, 0x32, 0xf9, 0xb7, 0x26, 0xe5, 0x1f, 0x4c, 0xb0, 0xb8,
	0x7a, 0xe4, 0x4e, 0x71, 0xd3, 0xf5, 0x4f, 0x7a, 0xef, 0x54, 0x8e, 0xcf, 0x67, 0xad, 0xff, 0x33,
	0xdb, 0xb5, 0x5a, 0x34, 0x84, 0x94, 0x92, 0x68, 0xf9, 0xfa, 0xcb, 0xe1, 0x4f, 0xa6, 0xad, 0xff,
	0xb3, 0x49, 0x5a, 0x6a, 0xfd, 0x25, 0x7e, 0x78, 0x04, 0x4a, 0xdd, 0x7e, 0xd0, 0x6f, 0xbb, 0x56,
	0x2a, 0x47, 0x93, 0x15, 0xb0, 0x33, 0x65, 0xf9, 0x8f, 0x5b, 0xc7, 0x6d, 0xd7, 0x22, 0x5b, 0x51,
	0xa4, 0x80, 0xeb, 0x81, 0x77, 0x93, 0xc5, 0x97, 0x60, 0x9f, 0x32, 0xe9, 0xba, 0x64, 0xed, 0xb3,
	0x24, 0x2e, 0xfc, 0x9a, 0x2b, 0xf7, 0xc2, 0x5f, 0x01, 0x64, 0xb9, 0x6d, 0xdb, 0x91, 0x9d, 0xcf,
	0x2f, 0x98, 0xf6, 0x3d, 0xb9, 0xf6, 0x06, 0x8d, 0x8a, 0xcf, 0xff, 0x3b, 0x22, 0x43, 0xa0, 0x0f,
	0x01, 0x4e, 0x6e, 0x12, 0xd3, 0xb2, 0xfc, 0x9c, 0x95, 0xf2, 0xa1, 0xe4, 0x76, 0x21, 0x65, 0xf2,
	0x7a, 0xb6, 0xdd, 0x19, 0x53, 0xe0, 0x63, 0xb0, 0x39, 0xf4, 0xed, 0x54, 0x96, 0x23, 0x56, 0xcb,
	0x75, 0x79, 0x2d, 0xcf, 0x7d, 0x9b, 0xac, 0x0f, 0x7d, 0x5b, 0x40, 0xfc, 0x12, 0x5c, 0x4b, 0xfa,
	0xf4, 0x0c, 0xea, 0x98, 0x09, 0xbe, 0x29, 0xe9, 0xd7, 0x45, 0x02, 0xd7, 0x59, 0x72, 0x27, 0x3d,
	0xb0, 0x05, 0x10, 0xbf, 0x79, 0x9e, 0xc5, 0x37, 0xcf, 0xe4, 0x07, 0x86, 0x4e, 0x22, 0x9d, 0x7c,
	0x42, 0x25, 0x9e, 0x30, 0xfe, 0xa5, 0xbe, 0xc3, 0x3d, 0xa7, 0x91, 0x23, 0xb6, 0xc3, 0x2f, 0xc1,
	0xf5, 0x2c, 0x34, 0x39, 0xf5, 0xe8, 0x94, 0x51, 0xcb, 0x13, 0xd4, 0xe4, 0x20, 0x93, 0x6b, 0x69,
	0x6c, 0xe2, 0x28, 0xdf, 0x07, 0x1b, 0xe9, 0x1b, 0x2a, 0xfd, 0x22, 0x5d, 0x58, 0xa3, 0xf8, 0x8b,
	0x74, 0x61, 0x8d, 0xe0, 0x15, 0x50, 0xe0, 0x4b, 0x93, 0x63, 0x36, 0xfe, 0x70, 0x2f, 0x77, 0x57,
	0x29, 0x3f, 0x89, 0xa3, 0xe3, 0x7b, 0xa6, 0x24, 0x1a, 0x8b, 0xd1, 0xe9, 0x16, 0x78, 0x82, 0x24,
	0xdc, 0x58, 0x45, 0x52, 0xe1, 0xfb, 0x90, 0x9e, 0x82, 0xcd, 0xcc, 0xf5, 0x55, 0x22, 0xea, 0x86,
	0x88, 0xca, 0xf4, 0xd5, 0x02, 0xeb, 0x31, 0x28, 0x49, 0xee, 0xb1, 0x22, 0x4f, 0x95, 0x2c, 0x91,
	0x22, 0x22, 0x8e, 0x19, 0x22, 0x7b, 0x7f, 0x15, 0x11, 0x4b, 0xdf, 0x4b, 0xd2, 0x43, 0x50, 0xcc,
	0xde, 0x63, 0xe7, 0x6d, 0x59, 0x4e, 0x8c, 0xff, 0x14, 0x6c, 0x4d, 0x5c, 0x62, 0xe7, 0x01, 0xf2,
	0x53, 0x01, 0xd1, 0xcd, 0x6a, 0x1e, 0x60, 0x5d, 0x04, 0x3c, 0x02, 0x70, 0xf2, 0xe6, 0x3a, 0x8f,
	0xb0, 0x28, 0x12, 0x1e, 0xc4, 0x5b, 0x9c, 0xdc, 0x5a, 0xe7, 0x85, 0x2f, 0x4f, 0xee, 0x6a, 0xf6,
	0xc6, 0x3a, 0x0f, 0xb1, 0x39, 0x03, 0xf1, 0x96, 0x45, 0x14, 0xa5, 0xeb, 0xd8, 0x7a, 0xfb, 0x75,
	0xdc, 0x9a, 0x0a, 0x78, 0x4b, 0x05, 0x50, 0x04, 0xfc, 0x1a, 0x5c, 0x95, 0x76, 0x50, 0x12, 0xc8,
	0x9d, 0xf4, 0x4f, 0x6f, 0x66, 0x2f, 0x27, 0x64, 0x70, 0x81, 0x36, 0xbb, 0xe5, 0x91, 0xa4, 0xfa,
	0x38, 0x9d, 0x6a, 0x6e, 0x73, 0x26, 0xa4, 0xbb, 0x00, 0x3b, 0x33, 0x5b, 0x14, 0x49, 0xb6, 0x5a,
	0x3a, 0xdb, 0xbc, 0x46, 0x4a, 0x56, 0xdb, 0xb4, 0x76, 0xe2, 0x07, 0xd7, 0x36, 0x6e, 0x7c, 0x84,
	0x74, 0x36, 0xd8, 0x9e, 0xd5, 0x02, 0x48, 0x92, 0x99, 0xe9, 0x64, 0x73, 0x9a, 0x14, 0x21, 0x55,
	0x00, 0x6e, 0xcc, 0xfd, 0x44, 0x4b, 0xf2, 0xdd, 0x4d, 0xe7, 0x7b, 0x9b, 0xc6, 0x42, 0x48, 0xda,
	0x06, 0x68, 0xda, 0x67, 0x56, 0x92, 0xab, 0x9a, 0xce, 0x35, 0xe3, 0xc3, 0x3f, 0x4e, 0xb1, 0xf7,
	0x8f, 0x1c, 0x28, 0xb0, 0xcf, 0x85, 0xe4, 0xd6, 0x35, 0xf9, 0xef, 0x90, 0xe8, 0xdf, 0x0f, 0xea,
	0xf8, 0xdf, 0x0f, 0xe9, 0x0b, 0xdf, 0x07, 0x60, 0xd1, 0xee, 0xb3, 0x7f, 0x59, 0x16, 0xd8, 0x0b,
	0xfb, 0xca, 0xf8, 0x73, 0x54, 0xb1, 0xfb, 0x7d, 0xcb, 0x67, 0x6f, 0xee, 0x68, 0x0e, 0xbc, 0x05,
	0x0a, 0x76, 0xdf, 0x0d, 0xce, 0xd1, 0x22, 0x13, 0x5c, 0xca, 0x4e, 0x3e, 0x0a, 0xce, 0x09, 0x9f,
	0x51, 0x7e, 0x04, 0x96, 0x63, 0xd3, 0x0f, 0x13, 0xba, 0xf7, 0x09, 0x58, 0x49, 0x14, 0xc0, 0x35,
	0xb0, 0xdc, 0x3c, 0x3e, 0x6e, 0x90, 0x93, 0xe3, 0x46, 0x71, 0x21, 0x79, 0x7a, 0xf6, 0x8b, 0x93,
	0xa2, 0x02, 0x37, 0x00, 0xe0, 0x4f, 0x4f, 0x48, 0xa3, 0x51, 0xcc, 0xed, 0xbd, 0x04, 0x85, 0x93,
	0x61, 0x68, 0xf9, 0x10, 0x83, 0x9c, 0xdd, 0x67, 0x69, 0x57, 0x8d, 0x22, 0xd3, 0xca, 0xec, 0x95,
	0x26, 0xc5, 0x92, 0x9c, 0xdd, 0x2f, 0x7f, 0x01, 0x0a, 0xec, 0xe1, 0xff, 0xb1, 0x96, 0xb7, 0xdf,
	0x03, 0x8b, 0xfc, 0x4b, 0x07, 0x97, 0x80, 0xca, 0x85, 0x2e, 0x01, 0x95, 0x6b, 0x5c, 0x01, 0x85,
	0x48, 0xde, 0x7e, 0xed, 0xd5, 0x6b, 0x6d, 0xe1, 0xdb, 0xd7, 0xda, 0xc2, 0x77, 0xaf, 0x35, 0xe5,
	0x9b, 0x4b, 0x4d, 0xf9, 0xe7, 0xa5, 0xa6, 0xfc, 0xeb, 0x52, 0x53, 0x5e, 0x5d, 0x6a, 0xca, 0x7f,
	0x2e, 0x35, 0xe5, 0xbf, 0x97, 0xda, 0xc2, 0x77, 0x97, 0x9a, 0xf2, 0xb7, 0x37, 0xda, 0xc2, 0xab,
	0x37, 0xda, 0xc2, 0xb7, 0x6f, 0xb4, 0x85, 0xce, 0x22, 0xeb, 0x87, 0xcc, 0xff, 0x05, 0x00, 0x00,
	0xff, 0xff, 0xaf, 0x80, 0xbc, 0x9b, 0x67, 0x18, 0x00, 0x00,
}

func (x Myenum) String() string {
	s, ok := Myenum_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x OtherInnerenum) String() string {
	s, ok := OtherInnerenum_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *Empty) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Empty)
	if !ok {
		that2, ok := that.(Empty)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *Simple) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Simple)
	if !ok {
		that2, ok := that.(Simple)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Byts, that1.Byts) {
		return false
	}
	if len(this.MapStrStr) != len(that1.MapStrStr) {
		return false
	}
	for i := range this.MapStrStr {
		if this.MapStrStr[i] != that1.MapStrStr[i] {
			return false
		}
	}
	if len(this.MapStrMsg) != len(that1.MapStrMsg) {
		return false
	}
	for i := range this.MapStrMsg {
		if !this.MapStrMsg[i].Equal(that1.MapStrMsg[i]) {
			return false
		}
	}
	if len(this.MapI32Msg) != len(that1.MapI32Msg) {
		return false
	}
	for i := range this.MapI32Msg {
		if !this.MapI32Msg[i].Equal(that1.MapI32Msg[i]) {
			return false
		}
	}
	if len(this.MapStrEnum) != len(that1.MapStrEnum) {
		return false
	}
	for i := range this.MapStrEnum {
		if this.MapStrEnum[i] != that1.MapStrEnum[i] {
			return false
		}
	}
	if len(this.MapInt64Double) != len(that1.MapInt64Double) {
		return false
	}
	for i := range this.MapInt64Double {
		if this.MapInt64Double[i] != that1.MapInt64Double[i] {
			return false
		}
	}
	if len(this.MapFixed32Enum) != len(that1.MapFixed32Enum) {
		return false
	}
	for i := range this.MapFixed32Enum {
		if this.MapFixed32Enum[i] != that1.MapFixed32Enum[i] {
			return false
		}
	}
	if len(this.MapStrFloat) != len(that1.MapStrFloat) {
		return false
	}
	for i := range this.MapStrFloat {
		if this.MapStrFloat[i] != that1.MapStrFloat[i] {
			return false
		}
	}
	if len(this.MapStrUint64) != len(that1.MapStrUint64) {
		return false
	}
	for i := range this.MapStrUint64 {
		if this.MapStrUint64[i] != that1.MapStrUint64[i] {
			return false
		}
	}
	if len(this.MapStrUint32) != len(that1.MapStrUint32) {
		return false
	}
	for i := range this.MapStrUint32 {
		if this.MapStrUint32[i] != that1.MapStrUint32[i] {
			return false
		}
	}
	if len(this.MapStrFixed64) != len(that1.MapStrFixed64) {
		return false
	}
	for i := range this.MapStrFixed64 {
		if this.MapStrFixed64[i] != that1.MapStrFixed64[i] {
			return false
		}
	}
	if len(this.MapStrBool) != len(that1.MapStrBool) {
		return false
	}
	for i := range this.MapStrBool {
		if this.MapStrBool[i] != that1.MapStrBool[i] {
			return false
		}
	}
	if len(this.MapStrSfixed32) != len(that1.MapStrSfixed32) {
		return false
	}
	for i := range this.MapStrSfixed32 {
		if this.MapStrSfixed32[i] != that1.MapStrSfixed32[i] {
			return false
		}
	}
	if len(this.MapStrSfixed64) != len(that1.MapStrSfixed64) {
		return false
	}
	for i := range this.MapStrSfixed64 {
		if this.MapStrSfixed64[i] != that1.MapStrSfixed64[i] {
			return false
		}
	}
	if len(this.MapStrSint32) != len(that1.MapStrSint32) {
		return false
	}
	for i := range this.MapStrSint32 {
		if this.MapStrSint32[i] != that1.MapStrSint32[i] {
			return false
		}
	}
	if len(this.MapStrSint64) != len(that1.MapStrSint64) {
		return false
	}
	for i := range this.MapStrSint64 {
		if this.MapStrSint64[i] != that1.MapStrSint64[i] {
			return false
		}
	}
	if !this.Oth.Equal(that1.Oth) {
		return false
	}
	if len(this.ROth) != len(that1.ROth) {
		return false
	}
	for i := range this.ROth {
		if !this.ROth[i].Equal(that1.ROth[i]) {
			return false
		}
	}
	if this.Enm != that1.Enm {
		return false
	}
	if len(this.REnm) != len(that1.REnm) {
		return false
	}
	for i := range this.REnm {
		if this.REnm[i] != that1.REnm[i] {
			return false
		}
	}
	if len(this.REnmUnpacked) != len(that1.REnmUnpacked) {
		return false
	}
	for i := range this.REnmUnpacked {
		if this.REnmUnpacked[i] != that1.REnmUnpacked[i] {
			return false
		}
	}
	if this.Dbl != that1.Dbl {
		return false
	}
	if len(this.RDbl) != len(that1.RDbl) {
		return false
	}
	for i := range this.RDbl {
		if this.RDbl[i] != that1.RDbl[i] {
			return false
		}
	}
	if len(this.RDblUnpacked) != len(that1.RDblUnpacked) {
		return false
	}
	for i := range this.RDblUnpacked {
		if this.RDblUnpacked[i] != that1.RDblUnpacked[i] {
			return false
		}
	}
	if this.Flt != that1.Flt {
		return false
	}
	if len(this.RFlt) != len(that1.RFlt) {
		return false
	}
	for i := range this.RFlt {
		if this.RFlt[i] != that1.RFlt[i] {
			return false
		}
	}
	if len(this.RFltUnpacked) != len(that1.RFltUnpacked) {
		return false
	}
	for i := range this.RFltUnpacked {
		if this.RFltUnpacked[i] != that1.RFltUnpacked[i] {
			return false
		}
	}
	if this.I64 != that1.I64 {
		return false
	}
	if len(this.RI64) != len(that1.RI64) {
		return false
	}
	for i := range this.RI64 {
		if this.RI64[i] != that1.RI64[i] {
			return false
		}
	}
	if len(this.RI64Unpacked) != len(that1.RI64Unpacked) {
		return false
	}
	for i := range this.RI64Unpacked {
		if this.RI64Unpacked[i] != that1.RI64Unpacked[i] {
			return false
		}
	}
	if this.I32 != that1.I32 {
		return false
	}
	if len(this.RI32) != len(that1.RI32) {
		return false
	}
	for i := range this.RI32 {
		if this.RI32[i] != that1.RI32[i] {
			return false
		}
	}
	if len(this.RI32Unpacked) != len(that1.RI32Unpacked) {
		return false
	}
	for i := range this.RI32Unpacked {
		if this.RI32Unpacked[i] != that1.RI32Unpacked[i] {
			return false
		}
	}
	if this.Ui64 != that1.Ui64 {
		return false
	}
	if len(this.RUi64) != len(that1.RUi64) {
		return false
	}
	for i := range this.RUi64 {
		if this.RUi64[i] != that1.RUi64[i] {
			return false
		}
	}
	if len(this.RUi64Unpacked) != len(that1.RUi64Unpacked) {
		return false
	}
	for i := range this.RUi64Unpacked {
		if this.RUi64Unpacked[i] != that1.RUi64Unpacked[i] {
			return false
		}
	}
	if this.Ui32 != that1.Ui32 {
		return false
	}
	if len(this.RUi32) != len(that1.RUi32) {
		return false
	}
	for i := range this.RUi32 {
		if this.RUi32[i] != that1.RUi32[i] {
			return false
		}
	}
	if len(this.RUi32Unpacked) != len(that1.RUi32Unpacked) {
		return false
	}
	for i := range this.RUi32Unpacked {
		if this.RUi32Unpacked[i] != that1.RUi32Unpacked[i] {
			return false
		}
	}
	if this.F64 != that1.F64 {
		return false
	}
	if len(this.RF64) != len(that1.RF64) {
		return false
	}
	for i := range this.RF64 {
		if this.RF64[i] != that1.RF64[i] {
			return false
		}
	}
	if len(this.RF64Unpacked) != len(that1.RF64Unpacked) {
		return false
	}
	for i := range this.RF64Unpacked {
		if this.RF64Unpacked[i] != that1.RF64Unpacked[i] {
			return false
		}
	}
	if this.Sf64 != that1.Sf64 {
		return false
	}
	if len(this.RSf64) != len(that1.RSf64) {
		return false
	}
	for i := range this.RSf64 {
		if this.RSf64[i] != that1.RSf64[i] {
			return false
		}
	}
	if len(this.RSf64Unpacked) != len(that1.RSf64Unpacked) {
		return false
	}
	for i := range this.RSf64Unpacked {
		if this.RSf64Unpacked[i] != that1.RSf64Unpacked[i] {
			return false
		}
	}
	if this.F32 != that1.F32 {
		return false
	}
	if len(this.RF32) != len(that1.RF32) {
		return false
	}
	for i := range this.RF32 {
		if this.RF32[i] != that1.RF32[i] {
			return false
		}
	}
	if len(this.RF32Unpacked) != len(that1.RF32Unpacked) {
		return false
	}
	for i := range this.RF32Unpacked {
		if this.RF32Unpacked[i] != that1.RF32Unpacked[i] {
			return false
		}
	}
	if this.Sf32 != that1.Sf32 {
		return false
	}
	if len(this.RSf32) != len(that1.RSf32) {
		return false
	}
	for i := range this.RSf32 {
		if this.RSf32[i] != that1.RSf32[i] {
			return false
		}
	}
	if len(this.RSf32Unpacked) != len(that1.RSf32Unpacked) {
		return false
	}
	for i := range this.RSf32Unpacked {
		if this.RSf32Unpacked[i] != that1.RSf32Unpacked[i] {
			return false
		}
	}
	if this.B != that1.B {
		return false
	}
	if len(this.RB) != len(that1.RB) {
		return false
	}
	for i := range this.RB {
		if this.RB[i] != that1.RB[i] {
			return false
		}
	}
	if len(this.RBUnpacked) != len(that1.RBUnpacked) {
		return false
	}
	for i := range this.RBUnpacked {
		if this.RBUnpacked[i] != that1.RBUnpacked[i] {
			return false
		}
	}
	if this.Str != that1.Str {
		return false
	}
	if len(this.RStr) != len(that1.RStr) {
		return false
	}
	for i := range this.RStr {
		if this.RStr[i] != that1.RStr[i] {
			return false
		}
	}
	if this.Si32 != that1.Si32 {
		return false
	}
	if len(this.RSi32) != len(that1.RSi32) {
		return false
	}
	for i := range this.RSi32 {
		if this.RSi32[i] != that1.RSi32[i] {
			return false
		}
	}
	if len(this.RSi32Unpacked) != len(that1.RSi32Unpacked) {
		return false
	}
	for i := range this.RSi32Unpacked {
		if this.RSi32Unpacked[i] != that1.RSi32Unpacked[i] {
			return false
		}
	}
	if this.Si64 != that1.Si64 {
		return false
	}
	if len(this.RSi64) != len(that1.RSi64) {
		return false
	}
	for i := range this.RSi64 {
		if this.RSi64[i] != that1.RSi64[i] {
			return false
		}
	}
	if len(this.RSi64Unpacked) != len(that1.RSi64Unpacked) {
		return false
	}
	for i := range this.RSi64Unpacked {
		if this.RSi64Unpacked[i] != that1.RSi64Unpacked[i] {
			return false
		}
	}
	if !this.IstioValue.Equal(that1.IstioValue) {
		return false
	}
	if len(this.MapStrIstioValue) != len(that1.MapStrIstioValue) {
		return false
	}
	for i := range this.MapStrIstioValue {
		if !this.MapStrIstioValue[i].Equal(that1.MapStrIstioValue[i]) {
			return false
		}
	}
	if !this.IpaddressIstioValue.Equal(that1.IpaddressIstioValue) {
		return false
	}
	if len(this.MapStrIpaddressIstioValue) != len(that1.MapStrIpaddressIstioValue) {
		return false
	}
	for i := range this.MapStrIpaddressIstioValue {
		if !this.MapStrIpaddressIstioValue[i].Equal(that1.MapStrIpaddressIstioValue[i]) {
			return false
		}
	}
	if !this.DurationIstioValue.Equal(that1.DurationIstioValue) {
		return false
	}
	if len(this.MapStrDurationIstioValue) != len(that1.MapStrDurationIstioValue) {
		return false
	}
	for i := range this.MapStrDurationIstioValue {
		if !this.MapStrDurationIstioValue[i].Equal(that1.MapStrDurationIstioValue[i]) {
			return false
		}
	}
	if !this.TimestampIstioValue.Equal(that1.TimestampIstioValue) {
		return false
	}
	if len(this.MapStrTimestampIstioValue) != len(that1.MapStrTimestampIstioValue) {
		return false
	}
	for i := range this.MapStrTimestampIstioValue {
		if !this.MapStrTimestampIstioValue[i].Equal(that1.MapStrTimestampIstioValue[i]) {
			return false
		}
	}
	if !this.DnsnameIstioValue.Equal(that1.DnsnameIstioValue) {
		return false
	}
	if len(this.MapStrDnsnameIstioValue) != len(that1.MapStrDnsnameIstioValue) {
		return false
	}
	for i := range this.MapStrDnsnameIstioValue {
		if !this.MapStrDnsnameIstioValue[i].Equal(that1.MapStrDnsnameIstioValue[i]) {
			return false
		}
	}
	if !this.EmailaddressIstioValue.Equal(that1.EmailaddressIstioValue) {
		return false
	}
	if len(this.MapStrEmailaddressIstioValue) != len(that1.MapStrEmailaddressIstioValue) {
		return false
	}
	for i := range this.MapStrEmailaddressIstioValue {
		if !this.MapStrEmailaddressIstioValue[i].Equal(that1.MapStrEmailaddressIstioValue[i]) {
			return false
		}
	}
	if !this.UriIstioValue.Equal(that1.UriIstioValue) {
		return false
	}
	if len(this.MapStrUriIstioValue) != len(that1.MapStrUriIstioValue) {
		return false
	}
	for i := range this.MapStrUriIstioValue {
		if !this.MapStrUriIstioValue[i].Equal(that1.MapStrUriIstioValue[i]) {
			return false
		}
	}
	if !this.GoogleProtobufDuration.Equal(that1.GoogleProtobufDuration) {
		return false
	}
	if !this.GoogleProtobufTimestamp.Equal(that1.GoogleProtobufTimestamp) {
		return false
	}
	return true
}
func (this *Other) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Other)
	if !ok {
		that2, ok := that.(Other)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Str != that1.Str {
		return false
	}
	if this.Dbl != that1.Dbl {
		return false
	}
	if this.I64 != that1.I64 {
		return false
	}
	if this.B != that1.B {
		return false
	}
	if this.Inenum != that1.Inenum {
		return false
	}
	if !this.Inmsg.Equal(that1.Inmsg) {
		return false
	}
	return true
}
func (this *OtherInnerMsg) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OtherInnerMsg)
	if !ok {
		that2, ok := that.(OtherInnerMsg)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Str != that1.Str {
		return false
	}
	if this.Dbl != that1.Dbl {
		return false
	}
	if this.I64 != that1.I64 {
		return false
	}
	return true
}
func (this *Outer) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Outer)
	if !ok {
		that2, ok := that.(Outer)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.In.Equal(that1.In) {
		return false
	}
	return true
}
func (this *Outer_Inner) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Outer_Inner)
	if !ok {
		that2, ok := that.(Outer_Inner)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Str != that1.Str {
		return false
	}
	if this.Dbl != that1.Dbl {
		return false
	}
	if this.I64 != that1.I64 {
		return false
	}
	if this.B != that1.B {
		return false
	}
	return true
}
func (this *Empty) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&foo.Empty{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Simple) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 82)
	s = append(s, "&foo.Simple{")
	s = append(s, "Byts: "+fmt.Sprintf("%#v", this.Byts)+",\n")
	keysForMapStrStr := make([]string, 0, len(this.MapStrStr))
	for k, _ := range this.MapStrStr {
		keysForMapStrStr = append(keysForMapStrStr, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrStr)
	mapStringForMapStrStr := "map[string]string{"
	for _, k := range keysForMapStrStr {
		mapStringForMapStrStr += fmt.Sprintf("%#v: %#v,", k, this.MapStrStr[k])
	}
	mapStringForMapStrStr += "}"
	if this.MapStrStr != nil {
		s = append(s, "MapStrStr: "+mapStringForMapStrStr+",\n")
	}
	keysForMapStrMsg := make([]string, 0, len(this.MapStrMsg))
	for k, _ := range this.MapStrMsg {
		keysForMapStrMsg = append(keysForMapStrMsg, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrMsg)
	mapStringForMapStrMsg := "map[string]*Other{"
	for _, k := range keysForMapStrMsg {
		mapStringForMapStrMsg += fmt.Sprintf("%#v: %#v,", k, this.MapStrMsg[k])
	}
	mapStringForMapStrMsg += "}"
	if this.MapStrMsg != nil {
		s = append(s, "MapStrMsg: "+mapStringForMapStrMsg+",\n")
	}
	keysForMapI32Msg := make([]int32, 0, len(this.MapI32Msg))
	for k, _ := range this.MapI32Msg {
		keysForMapI32Msg = append(keysForMapI32Msg, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForMapI32Msg)
	mapStringForMapI32Msg := "map[int32]*Other{"
	for _, k := range keysForMapI32Msg {
		mapStringForMapI32Msg += fmt.Sprintf("%#v: %#v,", k, this.MapI32Msg[k])
	}
	mapStringForMapI32Msg += "}"
	if this.MapI32Msg != nil {
		s = append(s, "MapI32Msg: "+mapStringForMapI32Msg+",\n")
	}
	keysForMapStrEnum := make([]string, 0, len(this.MapStrEnum))
	for k, _ := range this.MapStrEnum {
		keysForMapStrEnum = append(keysForMapStrEnum, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrEnum)
	mapStringForMapStrEnum := "map[string]Myenum{"
	for _, k := range keysForMapStrEnum {
		mapStringForMapStrEnum += fmt.Sprintf("%#v: %#v,", k, this.MapStrEnum[k])
	}
	mapStringForMapStrEnum += "}"
	if this.MapStrEnum != nil {
		s = append(s, "MapStrEnum: "+mapStringForMapStrEnum+",\n")
	}
	keysForMapInt64Double := make([]int64, 0, len(this.MapInt64Double))
	for k, _ := range this.MapInt64Double {
		keysForMapInt64Double = append(keysForMapInt64Double, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForMapInt64Double)
	mapStringForMapInt64Double := "map[int64]float64{"
	for _, k := range keysForMapInt64Double {
		mapStringForMapInt64Double += fmt.Sprintf("%#v: %#v,", k, this.MapInt64Double[k])
	}
	mapStringForMapInt64Double += "}"
	if this.MapInt64Double != nil {
		s = append(s, "MapInt64Double: "+mapStringForMapInt64Double+",\n")
	}
	keysForMapFixed32Enum := make([]uint32, 0, len(this.MapFixed32Enum))
	for k, _ := range this.MapFixed32Enum {
		keysForMapFixed32Enum = append(keysForMapFixed32Enum, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint32s(keysForMapFixed32Enum)
	mapStringForMapFixed32Enum := "map[uint32]Myenum{"
	for _, k := range keysForMapFixed32Enum {
		mapStringForMapFixed32Enum += fmt.Sprintf("%#v: %#v,", k, this.MapFixed32Enum[k])
	}
	mapStringForMapFixed32Enum += "}"
	if this.MapFixed32Enum != nil {
		s = append(s, "MapFixed32Enum: "+mapStringForMapFixed32Enum+",\n")
	}
	keysForMapStrFloat := make([]string, 0, len(this.MapStrFloat))
	for k, _ := range this.MapStrFloat {
		keysForMapStrFloat = append(keysForMapStrFloat, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrFloat)
	mapStringForMapStrFloat := "map[string]float32{"
	for _, k := range keysForMapStrFloat {
		mapStringForMapStrFloat += fmt.Sprintf("%#v: %#v,", k, this.MapStrFloat[k])
	}
	mapStringForMapStrFloat += "}"
	if this.MapStrFloat != nil {
		s = append(s, "MapStrFloat: "+mapStringForMapStrFloat+",\n")
	}
	keysForMapStrUint64 := make([]string, 0, len(this.MapStrUint64))
	for k, _ := range this.MapStrUint64 {
		keysForMapStrUint64 = append(keysForMapStrUint64, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrUint64)
	mapStringForMapStrUint64 := "map[string]uint64{"
	for _, k := range keysForMapStrUint64 {
		mapStringForMapStrUint64 += fmt.Sprintf("%#v: %#v,", k, this.MapStrUint64[k])
	}
	mapStringForMapStrUint64 += "}"
	if this.MapStrUint64 != nil {
		s = append(s, "MapStrUint64: "+mapStringForMapStrUint64+",\n")
	}
	keysForMapStrUint32 := make([]string, 0, len(this.MapStrUint32))
	for k, _ := range this.MapStrUint32 {
		keysForMapStrUint32 = append(keysForMapStrUint32, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrUint32)
	mapStringForMapStrUint32 := "map[string]uint32{"
	for _, k := range keysForMapStrUint32 {
		mapStringForMapStrUint32 += fmt.Sprintf("%#v: %#v,", k, this.MapStrUint32[k])
	}
	mapStringForMapStrUint32 += "}"
	if this.MapStrUint32 != nil {
		s = append(s, "MapStrUint32: "+mapStringForMapStrUint32+",\n")
	}
	keysForMapStrFixed64 := make([]string, 0, len(this.MapStrFixed64))
	for k, _ := range this.MapStrFixed64 {
		keysForMapStrFixed64 = append(keysForMapStrFixed64, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrFixed64)
	mapStringForMapStrFixed64 := "map[string]uint64{"
	for _, k := range keysForMapStrFixed64 {
		mapStringForMapStrFixed64 += fmt.Sprintf("%#v: %#v,", k, this.MapStrFixed64[k])
	}
	mapStringForMapStrFixed64 += "}"
	if this.MapStrFixed64 != nil {
		s = append(s, "MapStrFixed64: "+mapStringForMapStrFixed64+",\n")
	}
	keysForMapStrBool := make([]string, 0, len(this.MapStrBool))
	for k, _ := range this.MapStrBool {
		keysForMapStrBool = append(keysForMapStrBool, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrBool)
	mapStringForMapStrBool := "map[string]bool{"
	for _, k := range keysForMapStrBool {
		mapStringForMapStrBool += fmt.Sprintf("%#v: %#v,", k, this.MapStrBool[k])
	}
	mapStringForMapStrBool += "}"
	if this.MapStrBool != nil {
		s = append(s, "MapStrBool: "+mapStringForMapStrBool+",\n")
	}
	keysForMapStrSfixed32 := make([]string, 0, len(this.MapStrSfixed32))
	for k, _ := range this.MapStrSfixed32 {
		keysForMapStrSfixed32 = append(keysForMapStrSfixed32, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrSfixed32)
	mapStringForMapStrSfixed32 := "map[string]int32{"
	for _, k := range keysForMapStrSfixed32 {
		mapStringForMapStrSfixed32 += fmt.Sprintf("%#v: %#v,", k, this.MapStrSfixed32[k])
	}
	mapStringForMapStrSfixed32 += "}"
	if this.MapStrSfixed32 != nil {
		s = append(s, "MapStrSfixed32: "+mapStringForMapStrSfixed32+",\n")
	}
	keysForMapStrSfixed64 := make([]string, 0, len(this.MapStrSfixed64))
	for k, _ := range this.MapStrSfixed64 {
		keysForMapStrSfixed64 = append(keysForMapStrSfixed64, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrSfixed64)
	mapStringForMapStrSfixed64 := "map[string]int64{"
	for _, k := range keysForMapStrSfixed64 {
		mapStringForMapStrSfixed64 += fmt.Sprintf("%#v: %#v,", k, this.MapStrSfixed64[k])
	}
	mapStringForMapStrSfixed64 += "}"
	if this.MapStrSfixed64 != nil {
		s = append(s, "MapStrSfixed64: "+mapStringForMapStrSfixed64+",\n")
	}
	keysForMapStrSint32 := make([]string, 0, len(this.MapStrSint32))
	for k, _ := range this.MapStrSint32 {
		keysForMapStrSint32 = append(keysForMapStrSint32, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrSint32)
	mapStringForMapStrSint32 := "map[string]int32{"
	for _, k := range keysForMapStrSint32 {
		mapStringForMapStrSint32 += fmt.Sprintf("%#v: %#v,", k, this.MapStrSint32[k])
	}
	mapStringForMapStrSint32 += "}"
	if this.MapStrSint32 != nil {
		s = append(s, "MapStrSint32: "+mapStringForMapStrSint32+",\n")
	}
	keysForMapStrSint64 := make([]string, 0, len(this.MapStrSint64))
	for k, _ := range this.MapStrSint64 {
		keysForMapStrSint64 = append(keysForMapStrSint64, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrSint64)
	mapStringForMapStrSint64 := "map[string]int64{"
	for _, k := range keysForMapStrSint64 {
		mapStringForMapStrSint64 += fmt.Sprintf("%#v: %#v,", k, this.MapStrSint64[k])
	}
	mapStringForMapStrSint64 += "}"
	if this.MapStrSint64 != nil {
		s = append(s, "MapStrSint64: "+mapStringForMapStrSint64+",\n")
	}
	if this.Oth != nil {
		s = append(s, "Oth: "+fmt.Sprintf("%#v", this.Oth)+",\n")
	}
	if this.ROth != nil {
		s = append(s, "ROth: "+fmt.Sprintf("%#v", this.ROth)+",\n")
	}
	s = append(s, "Enm: "+fmt.Sprintf("%#v", this.Enm)+",\n")
	s = append(s, "REnm: "+fmt.Sprintf("%#v", this.REnm)+",\n")
	s = append(s, "REnmUnpacked: "+fmt.Sprintf("%#v", this.REnmUnpacked)+",\n")
	s = append(s, "Dbl: "+fmt.Sprintf("%#v", this.Dbl)+",\n")
	s = append(s, "RDbl: "+fmt.Sprintf("%#v", this.RDbl)+",\n")
	s = append(s, "RDblUnpacked: "+fmt.Sprintf("%#v", this.RDblUnpacked)+",\n")
	s = append(s, "Flt: "+fmt.Sprintf("%#v", this.Flt)+",\n")
	s = append(s, "RFlt: "+fmt.Sprintf("%#v", this.RFlt)+",\n")
	s = append(s, "RFltUnpacked: "+fmt.Sprintf("%#v", this.RFltUnpacked)+",\n")
	s = append(s, "I64: "+fmt.Sprintf("%#v", this.I64)+",\n")
	s = append(s, "RI64: "+fmt.Sprintf("%#v", this.RI64)+",\n")
	s = append(s, "RI64Unpacked: "+fmt.Sprintf("%#v", this.RI64Unpacked)+",\n")
	s = append(s, "I32: "+fmt.Sprintf("%#v", this.I32)+",\n")
	s = append(s, "RI32: "+fmt.Sprintf("%#v", this.RI32)+",\n")
	s = append(s, "RI32Unpacked: "+fmt.Sprintf("%#v", this.RI32Unpacked)+",\n")
	s = append(s, "Ui64: "+fmt.Sprintf("%#v", this.Ui64)+",\n")
	s = append(s, "RUi64: "+fmt.Sprintf("%#v", this.RUi64)+",\n")
	s = append(s, "RUi64Unpacked: "+fmt.Sprintf("%#v", this.RUi64Unpacked)+",\n")
	s = append(s, "Ui32: "+fmt.Sprintf("%#v", this.Ui32)+",\n")
	s = append(s, "RUi32: "+fmt.Sprintf("%#v", this.RUi32)+",\n")
	s = append(s, "RUi32Unpacked: "+fmt.Sprintf("%#v", this.RUi32Unpacked)+",\n")
	s = append(s, "F64: "+fmt.Sprintf("%#v", this.F64)+",\n")
	s = append(s, "RF64: "+fmt.Sprintf("%#v", this.RF64)+",\n")
	s = append(s, "RF64Unpacked: "+fmt.Sprintf("%#v", this.RF64Unpacked)+",\n")
	s = append(s, "Sf64: "+fmt.Sprintf("%#v", this.Sf64)+",\n")
	s = append(s, "RSf64: "+fmt.Sprintf("%#v", this.RSf64)+",\n")
	s = append(s, "RSf64Unpacked: "+fmt.Sprintf("%#v", this.RSf64Unpacked)+",\n")
	s = append(s, "F32: "+fmt.Sprintf("%#v", this.F32)+",\n")
	s = append(s, "RF32: "+fmt.Sprintf("%#v", this.RF32)+",\n")
	s = append(s, "RF32Unpacked: "+fmt.Sprintf("%#v", this.RF32Unpacked)+",\n")
	s = append(s, "Sf32: "+fmt.Sprintf("%#v", this.Sf32)+",\n")
	s = append(s, "RSf32: "+fmt.Sprintf("%#v", this.RSf32)+",\n")
	s = append(s, "RSf32Unpacked: "+fmt.Sprintf("%#v", this.RSf32Unpacked)+",\n")
	s = append(s, "B: "+fmt.Sprintf("%#v", this.B)+",\n")
	s = append(s, "RB: "+fmt.Sprintf("%#v", this.RB)+",\n")
	s = append(s, "RBUnpacked: "+fmt.Sprintf("%#v", this.RBUnpacked)+",\n")
	s = append(s, "Str: "+fmt.Sprintf("%#v", this.Str)+",\n")
	s = append(s, "RStr: "+fmt.Sprintf("%#v", this.RStr)+",\n")
	s = append(s, "Si32: "+fmt.Sprintf("%#v", this.Si32)+",\n")
	s = append(s, "RSi32: "+fmt.Sprintf("%#v", this.RSi32)+",\n")
	s = append(s, "RSi32Unpacked: "+fmt.Sprintf("%#v", this.RSi32Unpacked)+",\n")
	s = append(s, "Si64: "+fmt.Sprintf("%#v", this.Si64)+",\n")
	s = append(s, "RSi64: "+fmt.Sprintf("%#v", this.RSi64)+",\n")
	s = append(s, "RSi64Unpacked: "+fmt.Sprintf("%#v", this.RSi64Unpacked)+",\n")
	if this.IstioValue != nil {
		s = append(s, "IstioValue: "+fmt.Sprintf("%#v", this.IstioValue)+",\n")
	}
	keysForMapStrIstioValue := make([]string, 0, len(this.MapStrIstioValue))
	for k, _ := range this.MapStrIstioValue {
		keysForMapStrIstioValue = append(keysForMapStrIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrIstioValue)
	mapStringForMapStrIstioValue := "map[string]*v1beta1.Value{"
	for _, k := range keysForMapStrIstioValue {
		mapStringForMapStrIstioValue += fmt.Sprintf("%#v: %#v,", k, this.MapStrIstioValue[k])
	}
	mapStringForMapStrIstioValue += "}"
	if this.MapStrIstioValue != nil {
		s = append(s, "MapStrIstioValue: "+mapStringForMapStrIstioValue+",\n")
	}
	if this.IpaddressIstioValue != nil {
		s = append(s, "IpaddressIstioValue: "+fmt.Sprintf("%#v", this.IpaddressIstioValue)+",\n")
	}
	keysForMapStrIpaddressIstioValue := make([]string, 0, len(this.MapStrIpaddressIstioValue))
	for k, _ := range this.MapStrIpaddressIstioValue {
		keysForMapStrIpaddressIstioValue = append(keysForMapStrIpaddressIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrIpaddressIstioValue)
	mapStringForMapStrIpaddressIstioValue := "map[string]*v1beta1.IPAddress{"
	for _, k := range keysForMapStrIpaddressIstioValue {
		mapStringForMapStrIpaddressIstioValue += fmt.Sprintf("%#v: %#v,", k, this.MapStrIpaddressIstioValue[k])
	}
	mapStringForMapStrIpaddressIstioValue += "}"
	if this.MapStrIpaddressIstioValue != nil {
		s = append(s, "MapStrIpaddressIstioValue: "+mapStringForMapStrIpaddressIstioValue+",\n")
	}
	if this.DurationIstioValue != nil {
		s = append(s, "DurationIstioValue: "+fmt.Sprintf("%#v", this.DurationIstioValue)+",\n")
	}
	keysForMapStrDurationIstioValue := make([]string, 0, len(this.MapStrDurationIstioValue))
	for k, _ := range this.MapStrDurationIstioValue {
		keysForMapStrDurationIstioValue = append(keysForMapStrDurationIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrDurationIstioValue)
	mapStringForMapStrDurationIstioValue := "map[string]*v1beta1.Duration{"
	for _, k := range keysForMapStrDurationIstioValue {
		mapStringForMapStrDurationIstioValue += fmt.Sprintf("%#v: %#v,", k, this.MapStrDurationIstioValue[k])
	}
	mapStringForMapStrDurationIstioValue += "}"
	if this.MapStrDurationIstioValue != nil {
		s = append(s, "MapStrDurationIstioValue: "+mapStringForMapStrDurationIstioValue+",\n")
	}
	if this.TimestampIstioValue != nil {
		s = append(s, "TimestampIstioValue: "+fmt.Sprintf("%#v", this.TimestampIstioValue)+",\n")
	}
	keysForMapStrTimestampIstioValue := make([]string, 0, len(this.MapStrTimestampIstioValue))
	for k, _ := range this.MapStrTimestampIstioValue {
		keysForMapStrTimestampIstioValue = append(keysForMapStrTimestampIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrTimestampIstioValue)
	mapStringForMapStrTimestampIstioValue := "map[string]*v1beta1.TimeStamp{"
	for _, k := range keysForMapStrTimestampIstioValue {
		mapStringForMapStrTimestampIstioValue += fmt.Sprintf("%#v: %#v,", k, this.MapStrTimestampIstioValue[k])
	}
	mapStringForMapStrTimestampIstioValue += "}"
	if this.MapStrTimestampIstioValue != nil {
		s = append(s, "MapStrTimestampIstioValue: "+mapStringForMapStrTimestampIstioValue+",\n")
	}
	if this.DnsnameIstioValue != nil {
		s = append(s, "DnsnameIstioValue: "+fmt.Sprintf("%#v", this.DnsnameIstioValue)+",\n")
	}
	keysForMapStrDnsnameIstioValue := make([]string, 0, len(this.MapStrDnsnameIstioValue))
	for k, _ := range this.MapStrDnsnameIstioValue {
		keysForMapStrDnsnameIstioValue = append(keysForMapStrDnsnameIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrDnsnameIstioValue)
	mapStringForMapStrDnsnameIstioValue := "map[string]*v1beta1.DNSName{"
	for _, k := range keysForMapStrDnsnameIstioValue {
		mapStringForMapStrDnsnameIstioValue += fmt.Sprintf("%#v: %#v,", k, this.MapStrDnsnameIstioValue[k])
	}
	mapStringForMapStrDnsnameIstioValue += "}"
	if this.MapStrDnsnameIstioValue != nil {
		s = append(s, "MapStrDnsnameIstioValue: "+mapStringForMapStrDnsnameIstioValue+",\n")
	}
	if this.EmailaddressIstioValue != nil {
		s = append(s, "EmailaddressIstioValue: "+fmt.Sprintf("%#v", this.EmailaddressIstioValue)+",\n")
	}
	keysForMapStrEmailaddressIstioValue := make([]string, 0, len(this.MapStrEmailaddressIstioValue))
	for k, _ := range this.MapStrEmailaddressIstioValue {
		keysForMapStrEmailaddressIstioValue = append(keysForMapStrEmailaddressIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrEmailaddressIstioValue)
	mapStringForMapStrEmailaddressIstioValue := "map[string]*v1beta1.EmailAddress{"
	for _, k := range keysForMapStrEmailaddressIstioValue {
		mapStringForMapStrEmailaddressIstioValue += fmt.Sprintf("%#v: %#v,", k, this.MapStrEmailaddressIstioValue[k])
	}
	mapStringForMapStrEmailaddressIstioValue += "}"
	if this.MapStrEmailaddressIstioValue != nil {
		s = append(s, "MapStrEmailaddressIstioValue: "+mapStringForMapStrEmailaddressIstioValue+",\n")
	}
	if this.UriIstioValue != nil {
		s = append(s, "UriIstioValue: "+fmt.Sprintf("%#v", this.UriIstioValue)+",\n")
	}
	keysForMapStrUriIstioValue := make([]string, 0, len(this.MapStrUriIstioValue))
	for k, _ := range this.MapStrUriIstioValue {
		keysForMapStrUriIstioValue = append(keysForMapStrUriIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrUriIstioValue)
	mapStringForMapStrUriIstioValue := "map[string]*v1beta1.Uri{"
	for _, k := range keysForMapStrUriIstioValue {
		mapStringForMapStrUriIstioValue += fmt.Sprintf("%#v: %#v,", k, this.MapStrUriIstioValue[k])
	}
	mapStringForMapStrUriIstioValue += "}"
	if this.MapStrUriIstioValue != nil {
		s = append(s, "MapStrUriIstioValue: "+mapStringForMapStrUriIstioValue+",\n")
	}
	if this.GoogleProtobufDuration != nil {
		s = append(s, "GoogleProtobufDuration: "+fmt.Sprintf("%#v", this.GoogleProtobufDuration)+",\n")
	}
	if this.GoogleProtobufTimestamp != nil {
		s = append(s, "GoogleProtobufTimestamp: "+fmt.Sprintf("%#v", this.GoogleProtobufTimestamp)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Other) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&foo.Other{")
	s = append(s, "Str: "+fmt.Sprintf("%#v", this.Str)+",\n")
	s = append(s, "Dbl: "+fmt.Sprintf("%#v", this.Dbl)+",\n")
	s = append(s, "I64: "+fmt.Sprintf("%#v", this.I64)+",\n")
	s = append(s, "B: "+fmt.Sprintf("%#v", this.B)+",\n")
	s = append(s, "Inenum: "+fmt.Sprintf("%#v", this.Inenum)+",\n")
	if this.Inmsg != nil {
		s = append(s, "Inmsg: "+fmt.Sprintf("%#v", this.Inmsg)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *OtherInnerMsg) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&foo.OtherInnerMsg{")
	s = append(s, "Str: "+fmt.Sprintf("%#v", this.Str)+",\n")
	s = append(s, "Dbl: "+fmt.Sprintf("%#v", this.Dbl)+",\n")
	s = append(s, "I64: "+fmt.Sprintf("%#v", this.I64)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Outer) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&foo.Outer{")
	if this.In != nil {
		s = append(s, "In: "+fmt.Sprintf("%#v", this.In)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Outer_Inner) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&foo.Outer_Inner{")
	s = append(s, "Str: "+fmt.Sprintf("%#v", this.Str)+",\n")
	s = append(s, "Dbl: "+fmt.Sprintf("%#v", this.Dbl)+",\n")
	s = append(s, "I64: "+fmt.Sprintf("%#v", this.I64)+",\n")
	s = append(s, "B: "+fmt.Sprintf("%#v", this.B)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringTypes(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Empty) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Empty) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Empty) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *Simple) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Simple) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.REnmUnpacked) > 0 {
		for iNdEx := len(m.REnmUnpacked) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintTypes(dAtA, i, uint64(m.REnmUnpacked[iNdEx]))
			i--
			dAtA[i] = 0x11
			i--
			dAtA[i] = 0xc8
		}
	}
	if len(m.MapStrBool) > 0 {
		for k := range m.MapStrBool {
			v := m.MapStrBool[k]
			baseI := i
			i--
			if v {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x8
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.MapStrFixed64) > 0 {
		for k := range m.MapStrFixed64 {
			v := m.MapStrFixed64[k]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
			i--
			dAtA[i] = 0x11
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x8
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.MapStrUint32) > 0 {
		for k := range m.MapStrUint32 {
			v := m.MapStrUint32[k]
			baseI := i
			i = encodeVarintTypes(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x8
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.MapStrSint64) > 0 {
		for k := range m.MapStrSint64 {
			v := m.MapStrSint64[k]
			baseI := i
			i = encodeVarintTypes(dAtA, i, uint64((uint64(v)<<1)^uint64((v>>63))))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x8
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.MapStrSint32) > 0 {
		for k := range m.MapStrSint32 {
			v := m.MapStrSint32[k]
			baseI := i
			i = encodeVarintTypes(dAtA, i, uint64((uint32(v)<<1)^uint32((v>>31))))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x8
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.MapStrSfixed64) > 0 {
		for k := range m.MapStrSfixed64 {
			v := m.MapStrSfixed64[k]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
			i--
			dAtA[i] = 0x11
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x8
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.MapStrSfixed32) > 0 {
		for k := range m.MapStrSfixed32 {
			v := m.MapStrSfixed32[k]
			baseI := i
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
			i--
			dAtA[i] = 0x15
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x7
			i--
			dAtA[i] = 0xfa
		}
	}
	if len(m.MapStrUint64) > 0 {
		for k := range m.MapStrUint64 {
			v := m.MapStrUint64[k]
			baseI := i
			i = encodeVarintTypes(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x7
			i--
			dAtA[i] = 0xf2
		}
	}
	if len(m.MapStrFloat) > 0 {
		for k := range m.MapStrFloat {
			v := m.MapStrFloat[k]
			baseI := i
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(v))))
			i--
			dAtA[i] = 0x15
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x7
			i--
			dAtA[i] = 0xea
		}
	}
	if len(m.MapFixed32Enum) > 0 {
		for k := range m.MapFixed32Enum {
			v := m.MapFixed32Enum[k]
			baseI := i
			i = encodeVarintTypes(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(k))
			i--
			dAtA[i] = 0xd
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x7
			i--
			dAtA[i] = 0xe2
		}
	}
	if len(m.MapInt64Double) > 0 {
		for k := range m.MapInt64Double {
			v := m.MapInt64Double[k]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
			i--
			dAtA[i] = 0x11
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x7
			i--
			dAtA[i] = 0xda
		}
	}
	if m.GoogleProtobufTimestamp != nil {
		{
			size, err := m.GoogleProtobufTimestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5
		i--
		dAtA[i] = 0x82
	}
	if m.GoogleProtobufDuration != nil {
		{
			size, err := m.GoogleProtobufDuration.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0xfa
	}
	if len(m.MapStrUriIstioValue) > 0 {
		for k := range m.MapStrUriIstioValue {
			v := m.MapStrUriIstioValue[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xf2
		}
	}
	if m.UriIstioValue != nil {
		{
			size, err := m.UriIstioValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0xea
	}
	if len(m.MapStrEmailaddressIstioValue) > 0 {
		for k := range m.MapStrEmailaddressIstioValue {
			v := m.MapStrEmailaddressIstioValue[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xe2
		}
	}
	if m.EmailaddressIstioValue != nil {
		{
			size, err := m.EmailaddressIstioValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0xda
	}
	if len(m.MapStrDnsnameIstioValue) > 0 {
		for k := range m.MapStrDnsnameIstioValue {
			v := m.MapStrDnsnameIstioValue[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xd2
		}
	}
	if m.DnsnameIstioValue != nil {
		{
			size, err := m.DnsnameIstioValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0xca
	}
	if len(m.MapStrTimestampIstioValue) > 0 {
		for k := range m.MapStrTimestampIstioValue {
			v := m.MapStrTimestampIstioValue[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xc2
		}
	}
	if m.TimestampIstioValue != nil {
		{
			size, err := m.TimestampIstioValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0xba
	}
	if len(m.MapStrDurationIstioValue) > 0 {
		for k := range m.MapStrDurationIstioValue {
			v := m.MapStrDurationIstioValue[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xb2
		}
	}
	if m.DurationIstioValue != nil {
		{
			size, err := m.DurationIstioValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0xaa
	}
	if len(m.MapStrIpaddressIstioValue) > 0 {
		for k := range m.MapStrIpaddressIstioValue {
			v := m.MapStrIpaddressIstioValue[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xa2
		}
	}
	if m.IpaddressIstioValue != nil {
		{
			size, err := m.IpaddressIstioValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0x9a
	}
	if len(m.MapStrIstioValue) > 0 {
		for k := range m.MapStrIstioValue {
			v := m.MapStrIstioValue[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0x92
		}
	}
	if m.IstioValue != nil {
		{
			size, err := m.IstioValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0x8a
	}
	if len(m.RSi64Unpacked) > 0 {
		for iNdEx := len(m.RSi64Unpacked) - 1; iNdEx >= 0; iNdEx-- {
			x17 := (uint64(m.RSi64Unpacked[iNdEx]) << 1) ^ uint64((m.RSi64Unpacked[iNdEx] >> 63))
			i = encodeVarintTypes(dAtA, i, uint64(x17))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0x80
		}
	}
	if len(m.RSi64) > 0 {
		var j18 int
		dAtA20 := make([]byte, len(m.RSi64)*10)
		for _, num := range m.RSi64 {
			x19 := (uint64(num) << 1) ^ uint64((num >> 63))
			for x19 >= 1<<7 {
				dAtA20[j18] = uint8(uint64(x19)&0x7f | 0x80)
				j18++
				x19 >>= 7
			}
			dAtA20[j18] = uint8(x19)
			j18++
		}
		i -= j18
		copy(dAtA[i:], dAtA20[:j18])
		i = encodeVarintTypes(dAtA, i, uint64(j18))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xfa
	}
	if m.Si64 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64((uint64(m.Si64)<<1)^uint64((m.Si64>>63))))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xf0
	}
	if len(m.RSi32Unpacked) > 0 {
		for iNdEx := len(m.RSi32Unpacked) - 1; iNdEx >= 0; iNdEx-- {
			x21 := (uint32(m.RSi32Unpacked[iNdEx]) << 1) ^ uint32((m.RSi32Unpacked[iNdEx] >> 31))
			i = encodeVarintTypes(dAtA, i, uint64(x21))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xe8
		}
	}
	if len(m.RSi32) > 0 {
		dAtA22 := make([]byte, len(m.RSi32)*5)
		var j23 int
		for _, num := range m.RSi32 {
			x24 := (uint32(num) << 1) ^ uint32((num >> 31))
			for x24 >= 1<<7 {
				dAtA22[j23] = uint8(uint64(x24)&0x7f | 0x80)
				j23++
				x24 >>= 7
			}
			dAtA22[j23] = uint8(x24)
			j23++
		}
		i -= j23
		copy(dAtA[i:], dAtA22[:j23])
		i = encodeVarintTypes(dAtA, i, uint64(j23))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xe2
	}
	if m.Si32 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64((uint32(m.Si32)<<1)^uint32((m.Si32>>31))))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xd8
	}
	if len(m.RStr) > 0 {
		for iNdEx := len(m.RStr) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RStr[iNdEx])
			copy(dAtA[i:], m.RStr[iNdEx])
			i = encodeVarintTypes(dAtA, i, uint64(len(m.RStr[iNdEx])))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xd2
		}
	}
	if len(m.RBUnpacked) > 0 {
		for iNdEx := len(m.RBUnpacked) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.RBUnpacked[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xc8
		}
	}
	if len(m.RB) > 0 {
		for iNdEx := len(m.RB) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.RB[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RB)))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xc2
	}
	if len(m.RSf32Unpacked) > 0 {
		for iNdEx := len(m.RSf32Unpacked) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.RSf32Unpacked[iNdEx]))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xbd
		}
	}
	if len(m.RSf32) > 0 {
		for iNdEx := len(m.RSf32) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.RSf32[iNdEx]))
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RSf32)*4))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xb2
	}
	if m.Sf32 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Sf32))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xad
	}
	if len(m.RF32Unpacked) > 0 {
		for iNdEx := len(m.RF32Unpacked) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.RF32Unpacked[iNdEx]))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xa5
		}
	}
	if len(m.RF32) > 0 {
		for iNdEx := len(m.RF32) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.RF32[iNdEx]))
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RF32)*4))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x9a
	}
	if m.F32 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.F32))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x95
	}
	if len(m.RSf64Unpacked) > 0 {
		for iNdEx := len(m.RSf64Unpacked) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.RSf64Unpacked[iNdEx]))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x89
		}
	}
	if len(m.RSf64) > 0 {
		for iNdEx := len(m.RSf64) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.RSf64[iNdEx]))
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RSf64)*8))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x82
	}
	if m.Sf64 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Sf64))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xf9
	}
	if len(m.RF64Unpacked) > 0 {
		for iNdEx := len(m.RF64Unpacked) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.RF64Unpacked[iNdEx]))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xf1
		}
	}
	if len(m.RF64) > 0 {
		for iNdEx := len(m.RF64) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.RF64[iNdEx]))
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RF64)*8))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xea
	}
	if m.F64 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.F64))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xe1
	}
	if len(m.RUi32Unpacked) > 0 {
		for iNdEx := len(m.RUi32Unpacked) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintTypes(dAtA, i, uint64(m.RUi32Unpacked[iNdEx]))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xd8
		}
	}
	if len(m.RUi32) > 0 {
		dAtA26 := make([]byte, len(m.RUi32)*10)
		var j25 int
		for _, num := range m.RUi32 {
			for num >= 1<<7 {
				dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j25++
			}
			dAtA26[j25] = uint8(num)
			j25++
		}
		i -= j25
		copy(dAtA[i:], dAtA26[:j25])
		i = encodeVarintTypes(dAtA, i, uint64(j25))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd2
	}
	if m.Ui32 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Ui32))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc8
	}
	if len(m.RUi64Unpacked) > 0 {
		for iNdEx := len(m.RUi64Unpacked) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintTypes(dAtA, i, uint64(m.RUi64Unpacked[iNdEx]))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xc0
		}
	}
	if len(m.RUi64) > 0 {
		dAtA28 := make([]byte, len(m.RUi64)*10)
		var j27 int
		for _, num := range m.RUi64 {
			for num >= 1<<7 {
				dAtA28[j27] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j27++
			}
			dAtA28[j27] = uint8(num)
			j27++
		}
		i -= j27
		copy(dAtA[i:], dAtA28[:j27])
		i = encodeVarintTypes(dAtA, i, uint64(j27))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xba
	}
	if m.Ui64 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Ui64))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xb0
	}
	if len(m.RI32Unpacked) > 0 {
		for iNdEx := len(m.RI32Unpacked) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintTypes(dAtA, i, uint64(m.RI32Unpacked[iNdEx]))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xa8
		}
	}
	if len(m.RI32) > 0 {
		dAtA30 := make([]byte, len(m.RI32)*10)
		var j29 int
		for _, num1 := range m.RI32 {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA30[j29] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j29++
			}
			dAtA30[j29] = uint8(num)
			j29++
		}
		i -= j29
		copy(dAtA[i:], dAtA30[:j29])
		i = encodeVarintTypes(dAtA, i, uint64(j29))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xa2
	}
	if m.I32 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.I32))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x98
	}
	if len(m.RI64Unpacked) > 0 {
		for iNdEx := len(m.RI64Unpacked) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintTypes(dAtA, i, uint64(m.RI64Unpacked[iNdEx]))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x90
		}
	}
	if len(m.RI64) > 0 {
		dAtA32 := make([]byte, len(m.RI64)*10)
		var j31 int
		for _, num1 := range m.RI64 {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA32[j31] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j31++
			}
			dAtA32[j31] = uint8(num)
			j31++
		}
		i -= j31
		copy(dAtA[i:], dAtA32[:j31])
		i = encodeVarintTypes(dAtA, i, uint64(j31))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x8a
	}
	if m.I64 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.I64))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x80
	}
	if len(m.RFltUnpacked) > 0 {
		for iNdEx := len(m.RFltUnpacked) - 1; iNdEx >= 0; iNdEx-- {
			f33 := math.Float32bits(float32(m.RFltUnpacked[iNdEx]))
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f33))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xfd
		}
	}
	if len(m.RFlt) > 0 {
		for iNdEx := len(m.RFlt) - 1; iNdEx >= 0; iNdEx-- {
			f34 := math.Float32bits(float32(m.RFlt[iNdEx]))
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f34))
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RFlt)*4))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf2
	}
	if m.Flt != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Flt))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xed
	}
	if len(m.REnm) > 0 {
		dAtA36 := make([]byte, len(m.REnm)*10)
		var j35 int
		for _, num := range m.REnm {
			for num >= 1<<7 {
				dAtA36[j35] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j35++
			}
			dAtA36[j35] = uint8(num)
			j35++
		}
		i -= j35
		copy(dAtA[i:], dAtA36[:j35])
		i = encodeVarintTypes(dAtA, i, uint64(j35))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe2
	}
	if len(m.ROth) > 0 {
		for iNdEx := len(m.ROth) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ROth[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xd2
		}
	}
	if len(m.RDblUnpacked) > 0 {
		for iNdEx := len(m.RDblUnpacked) - 1; iNdEx >= 0; iNdEx-- {
			f37 := math.Float64bits(float64(m.RDblUnpacked[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f37))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc1
		}
	}
	if len(m.RDbl) > 0 {
		for iNdEx := len(m.RDbl) - 1; iNdEx >= 0; iNdEx-- {
			f38 := math.Float64bits(float64(m.RDbl[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f38))
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RDbl)*8))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xba
	}
	if len(m.MapStrEnum) > 0 {
		for k := range m.MapStrEnum {
			v := m.MapStrEnum[k]
			baseI := i
			i = encodeVarintTypes(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.MapI32Msg) > 0 {
		for k := range m.MapI32Msg {
			v := m.MapI32Msg[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.MapStrMsg) > 0 {
		for k := range m.MapStrMsg {
			v := m.MapStrMsg[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.MapStrStr) > 0 {
		for k := range m.MapStrStr {
			v := m.MapStrStr[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintTypes(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if m.Enm != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Enm))
		i--
		dAtA[i] = 0x68
	}
	if len(m.Byts) > 0 {
		i -= len(m.Byts)
		copy(dAtA[i:], m.Byts)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Byts)))
		i--
		dAtA[i] = 0x62
	}
	if m.Oth != nil {
		{
			size, err := m.Oth.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.B {
		i--
		if m.B {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Dbl != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Dbl))))
		i--
		dAtA[i] = 0x11
	}
	if len(m.Str) > 0 {
		i -= len(m.Str)
		copy(dAtA[i:], m.Str)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Str)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Other) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Other) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Inmsg != nil {
		{
			size, err := m.Inmsg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Inenum != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Inenum))
		i--
		dAtA[i] = 0x28
	}
	if m.B {
		i--
		if m.B {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.I64 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.I64))
		i--
		dAtA[i] = 0x18
	}
	if m.Dbl != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Dbl))))
		i--
		dAtA[i] = 0x11
	}
	if len(m.Str) > 0 {
		i -= len(m.Str)
		copy(dAtA[i:], m.Str)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Str)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *OtherInnerMsg) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OtherInnerMsg) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.I64 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.I64))
		i--
		dAtA[i] = 0x18
	}
	if m.Dbl != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Dbl))))
		i--
		dAtA[i] = 0x11
	}
	if len(m.Str) > 0 {
		i -= len(m.Str)
		copy(dAtA[i:], m.Str)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Str)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Outer) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Outer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.In != nil {
		{
			size, err := m.In.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Outer_Inner) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Outer_Inner) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.B {
		i--
		if m.B {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.I64 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.I64))
		i--
		dAtA[i] = 0x18
	}
	if m.Dbl != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Dbl))))
		i--
		dAtA[i] = 0x11
	}
	if len(m.Str) > 0 {
		i -= len(m.Str)
		copy(dAtA[i:], m.Str)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Str)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovTypes(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Empty) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *Simple) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Str)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Dbl != 0 {
		n += 9
	}
	if m.B {
		n += 2
	}
	if m.Oth != nil {
		l = m.Oth.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Byts)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Enm != 0 {
		n += 1 + sovTypes(uint64(m.Enm))
	}
	if len(m.MapStrStr) > 0 {
		for k, v := range m.MapStrStr {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + len(v) + sovTypes(uint64(len(v)))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrMsg) > 0 {
		for k, v := range m.MapStrMsg {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapI32Msg) > 0 {
		for k, v := range m.MapI32Msg {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrEnum) > 0 {
		for k, v := range m.MapStrEnum {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + sovTypes(uint64(v))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.RDbl) > 0 {
		n += 2 + sovTypes(uint64(len(m.RDbl)*8)) + len(m.RDbl)*8
	}
	if len(m.RDblUnpacked) > 0 {
		n += 10 * len(m.RDblUnpacked)
	}
	if len(m.ROth) > 0 {
		for _, e := range m.ROth {
			l = e.Size()
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.REnm) > 0 {
		l = 0
		for _, e := range m.REnm {
			l += sovTypes(uint64(e))
		}
		n += 2 + sovTypes(uint64(l)) + l
	}
	if m.Flt != 0 {
		n += 6
	}
	if len(m.RFlt) > 0 {
		n += 2 + sovTypes(uint64(len(m.RFlt)*4)) + len(m.RFlt)*4
	}
	if len(m.RFltUnpacked) > 0 {
		n += 6 * len(m.RFltUnpacked)
	}
	if m.I64 != 0 {
		n += 2 + sovTypes(uint64(m.I64))
	}
	if len(m.RI64) > 0 {
		l = 0
		for _, e := range m.RI64 {
			l += sovTypes(uint64(e))
		}
		n += 2 + sovTypes(uint64(l)) + l
	}
	if len(m.RI64Unpacked) > 0 {
		for _, e := range m.RI64Unpacked {
			n += 2 + sovTypes(uint64(e))
		}
	}
	if m.I32 != 0 {
		n += 2 + sovTypes(uint64(m.I32))
	}
	if len(m.RI32) > 0 {
		l = 0
		for _, e := range m.RI32 {
			l += sovTypes(uint64(e))
		}
		n += 2 + sovTypes(uint64(l)) + l
	}
	if len(m.RI32Unpacked) > 0 {
		for _, e := range m.RI32Unpacked {
			n += 2 + sovTypes(uint64(e))
		}
	}
	if m.Ui64 != 0 {
		n += 2 + sovTypes(uint64(m.Ui64))
	}
	if len(m.RUi64) > 0 {
		l = 0
		for _, e := range m.RUi64 {
			l += sovTypes(uint64(e))
		}
		n += 2 + sovTypes(uint64(l)) + l
	}
	if len(m.RUi64Unpacked) > 0 {
		for _, e := range m.RUi64Unpacked {
			n += 2 + sovTypes(uint64(e))
		}
	}
	if m.Ui32 != 0 {
		n += 2 + sovTypes(uint64(m.Ui32))
	}
	if len(m.RUi32) > 0 {
		l = 0
		for _, e := range m.RUi32 {
			l += sovTypes(uint64(e))
		}
		n += 2 + sovTypes(uint64(l)) + l
	}
	if len(m.RUi32Unpacked) > 0 {
		for _, e := range m.RUi32Unpacked {
			n += 2 + sovTypes(uint64(e))
		}
	}
	if m.F64 != 0 {
		n += 10
	}
	if len(m.RF64) > 0 {
		n += 2 + sovTypes(uint64(len(m.RF64)*8)) + len(m.RF64)*8
	}
	if len(m.RF64Unpacked) > 0 {
		n += 10 * len(m.RF64Unpacked)
	}
	if m.Sf64 != 0 {
		n += 10
	}
	if len(m.RSf64) > 0 {
		n += 2 + sovTypes(uint64(len(m.RSf64)*8)) + len(m.RSf64)*8
	}
	if len(m.RSf64Unpacked) > 0 {
		n += 10 * len(m.RSf64Unpacked)
	}
	if m.F32 != 0 {
		n += 6
	}
	if len(m.RF32) > 0 {
		n += 2 + sovTypes(uint64(len(m.RF32)*4)) + len(m.RF32)*4
	}
	if len(m.RF32Unpacked) > 0 {
		n += 6 * len(m.RF32Unpacked)
	}
	if m.Sf32 != 0 {
		n += 6
	}
	if len(m.RSf32) > 0 {
		n += 2 + sovTypes(uint64(len(m.RSf32)*4)) + len(m.RSf32)*4
	}
	if len(m.RSf32Unpacked) > 0 {
		n += 6 * len(m.RSf32Unpacked)
	}
	if len(m.RB) > 0 {
		n += 2 + sovTypes(uint64(len(m.RB))) + len(m.RB)*1
	}
	if len(m.RBUnpacked) > 0 {
		n += 3 * len(m.RBUnpacked)
	}
	if len(m.RStr) > 0 {
		for _, s := range m.RStr {
			l = len(s)
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if m.Si32 != 0 {
		n += 2 + sozTypes(uint64(m.Si32))
	}
	if len(m.RSi32) > 0 {
		l = 0
		for _, e := range m.RSi32 {
			l += sozTypes(uint64(e))
		}
		n += 2 + sovTypes(uint64(l)) + l
	}
	if len(m.RSi32Unpacked) > 0 {
		for _, e := range m.RSi32Unpacked {
			n += 2 + sozTypes(uint64(e))
		}
	}
	if m.Si64 != 0 {
		n += 2 + sozTypes(uint64(m.Si64))
	}
	if len(m.RSi64) > 0 {
		l = 0
		for _, e := range m.RSi64 {
			l += sozTypes(uint64(e))
		}
		n += 2 + sovTypes(uint64(l)) + l
	}
	if len(m.RSi64Unpacked) > 0 {
		for _, e := range m.RSi64Unpacked {
			n += 2 + sozTypes(uint64(e))
		}
	}
	if m.IstioValue != nil {
		l = m.IstioValue.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	if len(m.MapStrIstioValue) > 0 {
		for k, v := range m.MapStrIstioValue {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.IpaddressIstioValue != nil {
		l = m.IpaddressIstioValue.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	if len(m.MapStrIpaddressIstioValue) > 0 {
		for k, v := range m.MapStrIpaddressIstioValue {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.DurationIstioValue != nil {
		l = m.DurationIstioValue.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	if len(m.MapStrDurationIstioValue) > 0 {
		for k, v := range m.MapStrDurationIstioValue {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.TimestampIstioValue != nil {
		l = m.TimestampIstioValue.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	if len(m.MapStrTimestampIstioValue) > 0 {
		for k, v := range m.MapStrTimestampIstioValue {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.DnsnameIstioValue != nil {
		l = m.DnsnameIstioValue.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	if len(m.MapStrDnsnameIstioValue) > 0 {
		for k, v := range m.MapStrDnsnameIstioValue {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.EmailaddressIstioValue != nil {
		l = m.EmailaddressIstioValue.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	if len(m.MapStrEmailaddressIstioValue) > 0 {
		for k, v := range m.MapStrEmailaddressIstioValue {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.UriIstioValue != nil {
		l = m.UriIstioValue.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	if len(m.MapStrUriIstioValue) > 0 {
		for k, v := range m.MapStrUriIstioValue {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.GoogleProtobufDuration != nil {
		l = m.GoogleProtobufDuration.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	if m.GoogleProtobufTimestamp != nil {
		l = m.GoogleProtobufTimestamp.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	if len(m.MapInt64Double) > 0 {
		for k, v := range m.MapInt64Double {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + 8
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapFixed32Enum) > 0 {
		for k, v := range m.MapFixed32Enum {
			_ = k
			_ = v
			mapEntrySize := 1 + 4 + 1 + sovTypes(uint64(v))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrFloat) > 0 {
		for k, v := range m.MapStrFloat {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + 4
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrUint64) > 0 {
		for k, v := range m.MapStrUint64 {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + sovTypes(uint64(v))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrSfixed32) > 0 {
		for k, v := range m.MapStrSfixed32 {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + 4
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrSfixed64) > 0 {
		for k, v := range m.MapStrSfixed64 {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + 8
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrSint32) > 0 {
		for k, v := range m.MapStrSint32 {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + sozTypes(uint64(v))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrSint64) > 0 {
		for k, v := range m.MapStrSint64 {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + sozTypes(uint64(v))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrUint32) > 0 {
		for k, v := range m.MapStrUint32 {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + sovTypes(uint64(v))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrFixed64) > 0 {
		for k, v := range m.MapStrFixed64 {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + 8
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.MapStrBool) > 0 {
		for k, v := range m.MapStrBool {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + 1
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.REnmUnpacked) > 0 {
		for _, e := range m.REnmUnpacked {
			n += 2 + sovTypes(uint64(e))
		}
	}
	return n
}

func (m *Other) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Str)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Dbl != 0 {
		n += 9
	}
	if m.I64 != 0 {
		n += 1 + sovTypes(uint64(m.I64))
	}
	if m.B {
		n += 2
	}
	if m.Inenum != 0 {
		n += 1 + sovTypes(uint64(m.Inenum))
	}
	if m.Inmsg != nil {
		l = m.Inmsg.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *OtherInnerMsg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Str)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Dbl != 0 {
		n += 9
	}
	if m.I64 != 0 {
		n += 1 + sovTypes(uint64(m.I64))
	}
	return n
}

func (m *Outer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.In != nil {
		l = m.In.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *Outer_Inner) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Str)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Dbl != 0 {
		n += 9
	}
	if m.I64 != 0 {
		n += 1 + sovTypes(uint64(m.I64))
	}
	if m.B {
		n += 2
	}
	return n
}

func sovTypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Empty) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Empty{`,
		`}`,
	}, "")
	return s
}
func (this *Simple) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForROth := "[]*Other{"
	for _, f := range this.ROth {
		repeatedStringForROth += strings.Replace(fmt.Sprintf("%v", f), "Other", "Other", 1) + ","
	}
	repeatedStringForROth += "}"
	keysForMapStrStr := make([]string, 0, len(this.MapStrStr))
	for k, _ := range this.MapStrStr {
		keysForMapStrStr = append(keysForMapStrStr, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrStr)
	mapStringForMapStrStr := "map[string]string{"
	for _, k := range keysForMapStrStr {
		mapStringForMapStrStr += fmt.Sprintf("%v: %v,", k, this.MapStrStr[k])
	}
	mapStringForMapStrStr += "}"
	keysForMapStrMsg := make([]string, 0, len(this.MapStrMsg))
	for k, _ := range this.MapStrMsg {
		keysForMapStrMsg = append(keysForMapStrMsg, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrMsg)
	mapStringForMapStrMsg := "map[string]*Other{"
	for _, k := range keysForMapStrMsg {
		mapStringForMapStrMsg += fmt.Sprintf("%v: %v,", k, this.MapStrMsg[k])
	}
	mapStringForMapStrMsg += "}"
	keysForMapI32Msg := make([]int32, 0, len(this.MapI32Msg))
	for k, _ := range this.MapI32Msg {
		keysForMapI32Msg = append(keysForMapI32Msg, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForMapI32Msg)
	mapStringForMapI32Msg := "map[int32]*Other{"
	for _, k := range keysForMapI32Msg {
		mapStringForMapI32Msg += fmt.Sprintf("%v: %v,", k, this.MapI32Msg[k])
	}
	mapStringForMapI32Msg += "}"
	keysForMapStrEnum := make([]string, 0, len(this.MapStrEnum))
	for k, _ := range this.MapStrEnum {
		keysForMapStrEnum = append(keysForMapStrEnum, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrEnum)
	mapStringForMapStrEnum := "map[string]Myenum{"
	for _, k := range keysForMapStrEnum {
		mapStringForMapStrEnum += fmt.Sprintf("%v: %v,", k, this.MapStrEnum[k])
	}
	mapStringForMapStrEnum += "}"
	keysForMapStrIstioValue := make([]string, 0, len(this.MapStrIstioValue))
	for k, _ := range this.MapStrIstioValue {
		keysForMapStrIstioValue = append(keysForMapStrIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrIstioValue)
	mapStringForMapStrIstioValue := "map[string]*v1beta1.Value{"
	for _, k := range keysForMapStrIstioValue {
		mapStringForMapStrIstioValue += fmt.Sprintf("%v: %v,", k, this.MapStrIstioValue[k])
	}
	mapStringForMapStrIstioValue += "}"
	keysForMapStrIpaddressIstioValue := make([]string, 0, len(this.MapStrIpaddressIstioValue))
	for k, _ := range this.MapStrIpaddressIstioValue {
		keysForMapStrIpaddressIstioValue = append(keysForMapStrIpaddressIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrIpaddressIstioValue)
	mapStringForMapStrIpaddressIstioValue := "map[string]*v1beta1.IPAddress{"
	for _, k := range keysForMapStrIpaddressIstioValue {
		mapStringForMapStrIpaddressIstioValue += fmt.Sprintf("%v: %v,", k, this.MapStrIpaddressIstioValue[k])
	}
	mapStringForMapStrIpaddressIstioValue += "}"
	keysForMapStrDurationIstioValue := make([]string, 0, len(this.MapStrDurationIstioValue))
	for k, _ := range this.MapStrDurationIstioValue {
		keysForMapStrDurationIstioValue = append(keysForMapStrDurationIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrDurationIstioValue)
	mapStringForMapStrDurationIstioValue := "map[string]*v1beta1.Duration{"
	for _, k := range keysForMapStrDurationIstioValue {
		mapStringForMapStrDurationIstioValue += fmt.Sprintf("%v: %v,", k, this.MapStrDurationIstioValue[k])
	}
	mapStringForMapStrDurationIstioValue += "}"
	keysForMapStrTimestampIstioValue := make([]string, 0, len(this.MapStrTimestampIstioValue))
	for k, _ := range this.MapStrTimestampIstioValue {
		keysForMapStrTimestampIstioValue = append(keysForMapStrTimestampIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrTimestampIstioValue)
	mapStringForMapStrTimestampIstioValue := "map[string]*v1beta1.TimeStamp{"
	for _, k := range keysForMapStrTimestampIstioValue {
		mapStringForMapStrTimestampIstioValue += fmt.Sprintf("%v: %v,", k, this.MapStrTimestampIstioValue[k])
	}
	mapStringForMapStrTimestampIstioValue += "}"
	keysForMapStrDnsnameIstioValue := make([]string, 0, len(this.MapStrDnsnameIstioValue))
	for k, _ := range this.MapStrDnsnameIstioValue {
		keysForMapStrDnsnameIstioValue = append(keysForMapStrDnsnameIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrDnsnameIstioValue)
	mapStringForMapStrDnsnameIstioValue := "map[string]*v1beta1.DNSName{"
	for _, k := range keysForMapStrDnsnameIstioValue {
		mapStringForMapStrDnsnameIstioValue += fmt.Sprintf("%v: %v,", k, this.MapStrDnsnameIstioValue[k])
	}
	mapStringForMapStrDnsnameIstioValue += "}"
	keysForMapStrEmailaddressIstioValue := make([]string, 0, len(this.MapStrEmailaddressIstioValue))
	for k, _ := range this.MapStrEmailaddressIstioValue {
		keysForMapStrEmailaddressIstioValue = append(keysForMapStrEmailaddressIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrEmailaddressIstioValue)
	mapStringForMapStrEmailaddressIstioValue := "map[string]*v1beta1.EmailAddress{"
	for _, k := range keysForMapStrEmailaddressIstioValue {
		mapStringForMapStrEmailaddressIstioValue += fmt.Sprintf("%v: %v,", k, this.MapStrEmailaddressIstioValue[k])
	}
	mapStringForMapStrEmailaddressIstioValue += "}"
	keysForMapStrUriIstioValue := make([]string, 0, len(this.MapStrUriIstioValue))
	for k, _ := range this.MapStrUriIstioValue {
		keysForMapStrUriIstioValue = append(keysForMapStrUriIstioValue, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrUriIstioValue)
	mapStringForMapStrUriIstioValue := "map[string]*v1beta1.Uri{"
	for _, k := range keysForMapStrUriIstioValue {
		mapStringForMapStrUriIstioValue += fmt.Sprintf("%v: %v,", k, this.MapStrUriIstioValue[k])
	}
	mapStringForMapStrUriIstioValue += "}"
	keysForMapInt64Double := make([]int64, 0, len(this.MapInt64Double))
	for k, _ := range this.MapInt64Double {
		keysForMapInt64Double = append(keysForMapInt64Double, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForMapInt64Double)
	mapStringForMapInt64Double := "map[int64]float64{"
	for _, k := range keysForMapInt64Double {
		mapStringForMapInt64Double += fmt.Sprintf("%v: %v,", k, this.MapInt64Double[k])
	}
	mapStringForMapInt64Double += "}"
	keysForMapFixed32Enum := make([]uint32, 0, len(this.MapFixed32Enum))
	for k, _ := range this.MapFixed32Enum {
		keysForMapFixed32Enum = append(keysForMapFixed32Enum, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint32s(keysForMapFixed32Enum)
	mapStringForMapFixed32Enum := "map[uint32]Myenum{"
	for _, k := range keysForMapFixed32Enum {
		mapStringForMapFixed32Enum += fmt.Sprintf("%v: %v,", k, this.MapFixed32Enum[k])
	}
	mapStringForMapFixed32Enum += "}"
	keysForMapStrFloat := make([]string, 0, len(this.MapStrFloat))
	for k, _ := range this.MapStrFloat {
		keysForMapStrFloat = append(keysForMapStrFloat, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrFloat)
	mapStringForMapStrFloat := "map[string]float32{"
	for _, k := range keysForMapStrFloat {
		mapStringForMapStrFloat += fmt.Sprintf("%v: %v,", k, this.MapStrFloat[k])
	}
	mapStringForMapStrFloat += "}"
	keysForMapStrUint64 := make([]string, 0, len(this.MapStrUint64))
	for k, _ := range this.MapStrUint64 {
		keysForMapStrUint64 = append(keysForMapStrUint64, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrUint64)
	mapStringForMapStrUint64 := "map[string]uint64{"
	for _, k := range keysForMapStrUint64 {
		mapStringForMapStrUint64 += fmt.Sprintf("%v: %v,", k, this.MapStrUint64[k])
	}
	mapStringForMapStrUint64 += "}"
	keysForMapStrSfixed32 := make([]string, 0, len(this.MapStrSfixed32))
	for k, _ := range this.MapStrSfixed32 {
		keysForMapStrSfixed32 = append(keysForMapStrSfixed32, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrSfixed32)
	mapStringForMapStrSfixed32 := "map[string]int32{"
	for _, k := range keysForMapStrSfixed32 {
		mapStringForMapStrSfixed32 += fmt.Sprintf("%v: %v,", k, this.MapStrSfixed32[k])
	}
	mapStringForMapStrSfixed32 += "}"
	keysForMapStrSfixed64 := make([]string, 0, len(this.MapStrSfixed64))
	for k, _ := range this.MapStrSfixed64 {
		keysForMapStrSfixed64 = append(keysForMapStrSfixed64, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrSfixed64)
	mapStringForMapStrSfixed64 := "map[string]int64{"
	for _, k := range keysForMapStrSfixed64 {
		mapStringForMapStrSfixed64 += fmt.Sprintf("%v: %v,", k, this.MapStrSfixed64[k])
	}
	mapStringForMapStrSfixed64 += "}"
	keysForMapStrSint32 := make([]string, 0, len(this.MapStrSint32))
	for k, _ := range this.MapStrSint32 {
		keysForMapStrSint32 = append(keysForMapStrSint32, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrSint32)
	mapStringForMapStrSint32 := "map[string]int32{"
	for _, k := range keysForMapStrSint32 {
		mapStringForMapStrSint32 += fmt.Sprintf("%v: %v,", k, this.MapStrSint32[k])
	}
	mapStringForMapStrSint32 += "}"
	keysForMapStrSint64 := make([]string, 0, len(this.MapStrSint64))
	for k, _ := range this.MapStrSint64 {
		keysForMapStrSint64 = append(keysForMapStrSint64, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrSint64)
	mapStringForMapStrSint64 := "map[string]int64{"
	for _, k := range keysForMapStrSint64 {
		mapStringForMapStrSint64 += fmt.Sprintf("%v: %v,", k, this.MapStrSint64[k])
	}
	mapStringForMapStrSint64 += "}"
	keysForMapStrUint32 := make([]string, 0, len(this.MapStrUint32))
	for k, _ := range this.MapStrUint32 {
		keysForMapStrUint32 = append(keysForMapStrUint32, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrUint32)
	mapStringForMapStrUint32 := "map[string]uint32{"
	for _, k := range keysForMapStrUint32 {
		mapStringForMapStrUint32 += fmt.Sprintf("%v: %v,", k, this.MapStrUint32[k])
	}
	mapStringForMapStrUint32 += "}"
	keysForMapStrFixed64 := make([]string, 0, len(this.MapStrFixed64))
	for k, _ := range this.MapStrFixed64 {
		keysForMapStrFixed64 = append(keysForMapStrFixed64, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrFixed64)
	mapStringForMapStrFixed64 := "map[string]uint64{"
	for _, k := range keysForMapStrFixed64 {
		mapStringForMapStrFixed64 += fmt.Sprintf("%v: %v,", k, this.MapStrFixed64[k])
	}
	mapStringForMapStrFixed64 += "}"
	keysForMapStrBool := make([]string, 0, len(this.MapStrBool))
	for k, _ := range this.MapStrBool {
		keysForMapStrBool = append(keysForMapStrBool, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMapStrBool)
	mapStringForMapStrBool := "map[string]bool{"
	for _, k := range keysForMapStrBool {
		mapStringForMapStrBool += fmt.Sprintf("%v: %v,", k, this.MapStrBool[k])
	}
	mapStringForMapStrBool += "}"
	s := strings.Join([]string{`&Simple{`,
		`Str:` + fmt.Sprintf("%v", this.Str) + `,`,
		`Dbl:` + fmt.Sprintf("%v", this.Dbl) + `,`,
		`B:` + fmt.Sprintf("%v", this.B) + `,`,
		`Oth:` + strings.Replace(fmt.Sprintf("%v", this.Oth), "Other", "Other", 1) + `,`,
		`Byts:` + fmt.Sprintf("%v", this.Byts) + `,`,
		`Enm:` + fmt.Sprintf("%v", this.Enm) + `,`,
		`MapStrStr:` + mapStringForMapStrStr + `,`,
		`MapStrMsg:` + mapStringForMapStrMsg + `,`,
		`MapI32Msg:` + mapStringForMapI32Msg + `,`,
		`MapStrEnum:` + mapStringForMapStrEnum + `,`,
		`RDbl:` + fmt.Sprintf("%v", this.RDbl) + `,`,
		`RDblUnpacked:` + fmt.Sprintf("%v", this.RDblUnpacked) + `,`,
		`ROth:` + repeatedStringForROth + `,`,
		`REnm:` + fmt.Sprintf("%v", this.REnm) + `,`,
		`Flt:` + fmt.Sprintf("%v", this.Flt) + `,`,
		`RFlt:` + fmt.Sprintf("%v", this.RFlt) + `,`,
		`RFltUnpacked:` + fmt.Sprintf("%v", this.RFltUnpacked) + `,`,
		`I64:` + fmt.Sprintf("%v", this.I64) + `,`,
		`RI64:` + fmt.Sprintf("%v", this.RI64) + `,`,
		`RI64Unpacked:` + fmt.Sprintf("%v", this.RI64Unpacked) + `,`,
		`I32:` + fmt.Sprintf("%v", this.I32) + `,`,
		`RI32:` + fmt.Sprintf("%v", this.RI32) + `,`,
		`RI32Unpacked:` + fmt.Sprintf("%v", this.RI32Unpacked) + `,`,
		`Ui64:` + fmt.Sprintf("%v", this.Ui64) + `,`,
		`RUi64:` + fmt.Sprintf("%v", this.RUi64) + `,`,
		`RUi64Unpacked:` + fmt.Sprintf("%v", this.RUi64Unpacked) + `,`,
		`Ui32:` + fmt.Sprintf("%v", this.Ui32) + `,`,
		`RUi32:` + fmt.Sprintf("%v", this.RUi32) + `,`,
		`RUi32Unpacked:` + fmt.Sprintf("%v", this.RUi32Unpacked) + `,`,
		`F64:` + fmt.Sprintf("%v", this.F64) + `,`,
		`RF64:` + fmt.Sprintf("%v", this.RF64) + `,`,
		`RF64Unpacked:` + fmt.Sprintf("%v", this.RF64Unpacked) + `,`,
		`Sf64:` + fmt.Sprintf("%v", this.Sf64) + `,`,
		`RSf64:` + fmt.Sprintf("%v", this.RSf64) + `,`,
		`RSf64Unpacked:` + fmt.Sprintf("%v", this.RSf64Unpacked) + `,`,
		`F32:` + fmt.Sprintf("%v", this.F32) + `,`,
		`RF32:` + fmt.Sprintf("%v", this.RF32) + `,`,
		`RF32Unpacked:` + fmt.Sprintf("%v", this.RF32Unpacked) + `,`,
		`Sf32:` + fmt.Sprintf("%v", this.Sf32) + `,`,
		`RSf32:` + fmt.Sprintf("%v", this.RSf32) + `,`,
		`RSf32Unpacked:` + fmt.Sprintf("%v", this.RSf32Unpacked) + `,`,
		`RB:` + fmt.Sprintf("%v", this.RB) + `,`,
		`RBUnpacked:` + fmt.Sprintf("%v", this.RBUnpacked) + `,`,
		`RStr:` + fmt.Sprintf("%v", this.RStr) + `,`,
		`Si32:` + fmt.Sprintf("%v", this.Si32) + `,`,
		`RSi32:` + fmt.Sprintf("%v", this.RSi32) + `,`,
		`RSi32Unpacked:` + fmt.Sprintf("%v", this.RSi32Unpacked) + `,`,
		`Si64:` + fmt.Sprintf("%v", this.Si64) + `,`,
		`RSi64:` + fmt.Sprintf("%v", this.RSi64) + `,`,
		`RSi64Unpacked:` + fmt.Sprintf("%v", this.RSi64Unpacked) + `,`,
		`IstioValue:` + strings.Replace(fmt.Sprintf("%v", this.IstioValue), "Value", "v1beta1.Value", 1) + `,`,
		`MapStrIstioValue:` + mapStringForMapStrIstioValue + `,`,
		`IpaddressIstioValue:` + strings.Replace(fmt.Sprintf("%v", this.IpaddressIstioValue), "IPAddress", "v1beta1.IPAddress", 1) + `,`,
		`MapStrIpaddressIstioValue:` + mapStringForMapStrIpaddressIstioValue + `,`,
		`DurationIstioValue:` + strings.Replace(fmt.Sprintf("%v", this.DurationIstioValue), "Duration", "v1beta1.Duration", 1) + `,`,
		`MapStrDurationIstioValue:` + mapStringForMapStrDurationIstioValue + `,`,
		`TimestampIstioValue:` + strings.Replace(fmt.Sprintf("%v", this.TimestampIstioValue), "TimeStamp", "v1beta1.TimeStamp", 1) + `,`,
		`MapStrTimestampIstioValue:` + mapStringForMapStrTimestampIstioValue + `,`,
		`DnsnameIstioValue:` + strings.Replace(fmt.Sprintf("%v", this.DnsnameIstioValue), "DNSName", "v1beta1.DNSName", 1) + `,`,
		`MapStrDnsnameIstioValue:` + mapStringForMapStrDnsnameIstioValue + `,`,
		`EmailaddressIstioValue:` + strings.Replace(fmt.Sprintf("%v", this.EmailaddressIstioValue), "EmailAddress", "v1beta1.EmailAddress", 1) + `,`,
		`MapStrEmailaddressIstioValue:` + mapStringForMapStrEmailaddressIstioValue + `,`,
		`UriIstioValue:` + strings.Replace(fmt.Sprintf("%v", this.UriIstioValue), "Uri", "v1beta1.Uri", 1) + `,`,
		`MapStrUriIstioValue:` + mapStringForMapStrUriIstioValue + `,`,
		`GoogleProtobufDuration:` + strings.Replace(fmt.Sprintf("%v", this.GoogleProtobufDuration), "Duration", "types.Duration", 1) + `,`,
		`GoogleProtobufTimestamp:` + strings.Replace(fmt.Sprintf("%v", this.GoogleProtobufTimestamp), "Timestamp", "types.Timestamp", 1) + `,`,
		`MapInt64Double:` + mapStringForMapInt64Double + `,`,
		`MapFixed32Enum:` + mapStringForMapFixed32Enum + `,`,
		`MapStrFloat:` + mapStringForMapStrFloat + `,`,
		`MapStrUint64:` + mapStringForMapStrUint64 + `,`,
		`MapStrSfixed32:` + mapStringForMapStrSfixed32 + `,`,
		`MapStrSfixed64:` + mapStringForMapStrSfixed64 + `,`,
		`MapStrSint32:` + mapStringForMapStrSint32 + `,`,
		`MapStrSint64:` + mapStringForMapStrSint64 + `,`,
		`MapStrUint32:` + mapStringForMapStrUint32 + `,`,
		`MapStrFixed64:` + mapStringForMapStrFixed64 + `,`,
		`MapStrBool:` + mapStringForMapStrBool + `,`,
		`REnmUnpacked:` + fmt.Sprintf("%v", this.REnmUnpacked) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Other) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Other{`,
		`Str:` + fmt.Sprintf("%v", this.Str) + `,`,
		`Dbl:` + fmt.Sprintf("%v", this.Dbl) + `,`,
		`I64:` + fmt.Sprintf("%v", this.I64) + `,`,
		`B:` + fmt.Sprintf("%v", this.B) + `,`,
		`Inenum:` + fmt.Sprintf("%v", this.Inenum) + `,`,
		`Inmsg:` + strings.Replace(fmt.Sprintf("%v", this.Inmsg), "OtherInnerMsg", "OtherInnerMsg", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OtherInnerMsg) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OtherInnerMsg{`,
		`Str:` + fmt.Sprintf("%v", this.Str) + `,`,
		`Dbl:` + fmt.Sprintf("%v", this.Dbl) + `,`,
		`I64:` + fmt.Sprintf("%v", this.I64) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Outer) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Outer{`,
		`In:` + strings.Replace(fmt.Sprintf("%v", this.In), "Outer_Inner", "Outer_Inner", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Outer_Inner) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Outer_Inner{`,
		`Str:` + fmt.Sprintf("%v", this.Str) + `,`,
		`Dbl:` + fmt.Sprintf("%v", this.Dbl) + `,`,
		`I64:` + fmt.Sprintf("%v", this.I64) + `,`,
		`B:` + fmt.Sprintf("%v", this.B) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringTypes(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Empty) 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 ErrIntOverflowTypes
			}
			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: Empty: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Empty: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Simple) 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 ErrIntOverflowTypes
			}
			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: Simple: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Simple: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Str = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dbl", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Dbl = float64(math.Float64frombits(v))
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.B = bool(v != 0)
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Oth", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Oth == nil {
				m.Oth = &Other{}
			}
			if err := m.Oth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Byts", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Byts = append(m.Byts[:0], dAtA[iNdEx:postIndex]...)
			if m.Byts == nil {
				m.Byts = []byte{}
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enm", wireType)
			}
			m.Enm = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Enm |= Myenum(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrStr", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrStr == nil {
				m.MapStrStr = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthTypes
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrStr[mapkey] = mapvalue
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrMsg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrMsg == nil {
				m.MapStrMsg = make(map[string]*Other)
			}
			var mapkey string
			var mapvalue *Other
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &Other{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrMsg[mapkey] = mapvalue
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapI32Msg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapI32Msg == nil {
				m.MapI32Msg = make(map[int32]*Other)
			}
			var mapkey int32
			var mapvalue *Other
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &Other{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapI32Msg[mapkey] = mapvalue
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrEnum", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrEnum == nil {
				m.MapStrEnum = make(map[string]Myenum)
			}
			var mapkey string
			var mapvalue Myenum
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					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 ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= Myenum(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrEnum[mapkey] = mapvalue
			iNdEx = postIndex
		case 23:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.RDbl = append(m.RDbl, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RDbl) == 0 {
					m.RDbl = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.RDbl = append(m.RDbl, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RDbl", wireType)
			}
		case 24:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.RDblUnpacked = append(m.RDblUnpacked, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RDblUnpacked) == 0 {
					m.RDblUnpacked = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.RDblUnpacked = append(m.RDblUnpacked, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RDblUnpacked", wireType)
			}
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ROth", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ROth = append(m.ROth, &Other{})
			if err := m.ROth[len(m.ROth)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 28:
			if wireType == 0 {
				var v Myenum
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= Myenum(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.REnm = append(m.REnm, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.REnm) == 0 {
					m.REnm = make([]Myenum, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v Myenum
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= Myenum(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.REnm = append(m.REnm, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field REnm", wireType)
			}
		case 29:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flt", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Flt = float32(math.Float32frombits(v))
		case 30:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				v2 := float32(math.Float32frombits(v))
				m.RFlt = append(m.RFlt, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RFlt) == 0 {
					m.RFlt = make([]float32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					v2 := float32(math.Float32frombits(v))
					m.RFlt = append(m.RFlt, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RFlt", wireType)
			}
		case 31:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				v2 := float32(math.Float32frombits(v))
				m.RFltUnpacked = append(m.RFltUnpacked, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RFltUnpacked) == 0 {
					m.RFltUnpacked = make([]float32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					v2 := float32(math.Float32frombits(v))
					m.RFltUnpacked = append(m.RFltUnpacked, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RFltUnpacked", wireType)
			}
		case 32:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field I64", wireType)
			}
			m.I64 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.I64 |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 33:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RI64 = append(m.RI64, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RI64) == 0 {
					m.RI64 = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RI64 = append(m.RI64, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RI64", wireType)
			}
		case 34:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RI64Unpacked = append(m.RI64Unpacked, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RI64Unpacked) == 0 {
					m.RI64Unpacked = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RI64Unpacked = append(m.RI64Unpacked, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RI64Unpacked", wireType)
			}
		case 35:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field I32", wireType)
			}
			m.I32 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.I32 |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 36:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RI32 = append(m.RI32, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RI32) == 0 {
					m.RI32 = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RI32 = append(m.RI32, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RI32", wireType)
			}
		case 37:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RI32Unpacked = append(m.RI32Unpacked, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RI32Unpacked) == 0 {
					m.RI32Unpacked = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RI32Unpacked = append(m.RI32Unpacked, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RI32Unpacked", wireType)
			}
		case 38:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ui64", wireType)
			}
			m.Ui64 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ui64 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 39:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RUi64 = append(m.RUi64, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RUi64) == 0 {
					m.RUi64 = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RUi64 = append(m.RUi64, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RUi64", wireType)
			}
		case 40:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RUi64Unpacked = append(m.RUi64Unpacked, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RUi64Unpacked) == 0 {
					m.RUi64Unpacked = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RUi64Unpacked = append(m.RUi64Unpacked, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RUi64Unpacked", wireType)
			}
		case 41:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ui32", wireType)
			}
			m.Ui32 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ui32 |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 42:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RUi32 = append(m.RUi32, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RUi32) == 0 {
					m.RUi32 = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RUi32 = append(m.RUi32, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RUi32", wireType)
			}
		case 43:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RUi32Unpacked = append(m.RUi32Unpacked, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RUi32Unpacked) == 0 {
					m.RUi32Unpacked = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RUi32Unpacked = append(m.RUi32Unpacked, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RUi32Unpacked", wireType)
			}
		case 44:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field F64", wireType)
			}
			m.F64 = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.F64 = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 45:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.RF64 = append(m.RF64, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RF64) == 0 {
					m.RF64 = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.RF64 = append(m.RF64, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RF64", wireType)
			}
		case 46:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.RF64Unpacked = append(m.RF64Unpacked, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RF64Unpacked) == 0 {
					m.RF64Unpacked = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.RF64Unpacked = append(m.RF64Unpacked, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RF64Unpacked", wireType)
			}
		case 47:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sf64", wireType)
			}
			m.Sf64 = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.Sf64 = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 48:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.RSf64 = append(m.RSf64, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RSf64) == 0 {
					m.RSf64 = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.RSf64 = append(m.RSf64, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RSf64", wireType)
			}
		case 49:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.RSf64Unpacked = append(m.RSf64Unpacked, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RSf64Unpacked) == 0 {
					m.RSf64Unpacked = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.RSf64Unpacked = append(m.RSf64Unpacked, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RSf64Unpacked", wireType)
			}
		case 50:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field F32", wireType)
			}
			m.F32 = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.F32 = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 51:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.RF32 = append(m.RF32, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RF32) == 0 {
					m.RF32 = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.RF32 = append(m.RF32, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RF32", wireType)
			}
		case 52:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.RF32Unpacked = append(m.RF32Unpacked, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RF32Unpacked) == 0 {
					m.RF32Unpacked = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.RF32Unpacked = append(m.RF32Unpacked, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RF32Unpacked", wireType)
			}
		case 53:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sf32", wireType)
			}
			m.Sf32 = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Sf32 = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 54:
			if wireType == 5 {
				var v int32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.RSf32 = append(m.RSf32, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RSf32) == 0 {
					m.RSf32 = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.RSf32 = append(m.RSf32, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RSf32", wireType)
			}
		case 55:
			if wireType == 5 {
				var v int32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.RSf32Unpacked = append(m.RSf32Unpacked, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RSf32Unpacked) == 0 {
					m.RSf32Unpacked = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.RSf32Unpacked = append(m.RSf32Unpacked, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RSf32Unpacked", wireType)
			}
		case 56:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RB = append(m.RB, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.RB) == 0 {
					m.RB = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RB = append(m.RB, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RB", wireType)
			}
		case 57:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RBUnpacked = append(m.RBUnpacked, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.RBUnpacked) == 0 {
					m.RBUnpacked = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RBUnpacked = append(m.RBUnpacked, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RBUnpacked", wireType)
			}
		case 58:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RStr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RStr = append(m.RStr, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 59:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Si32", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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.Si32 = v
		case 60:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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.RSi32 = append(m.RSi32, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RSi32) == 0 {
					m.RSi32 = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						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.RSi32 = append(m.RSi32, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RSi32", wireType)
			}
		case 61:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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.RSi32Unpacked = append(m.RSi32Unpacked, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RSi32Unpacked) == 0 {
					m.RSi32Unpacked = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						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.RSi32Unpacked = append(m.RSi32Unpacked, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RSi32Unpacked", wireType)
			}
		case 62:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Si64", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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.Si64 = int64(v)
		case 63:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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.RSi64 = append(m.RSi64, int64(v))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RSi64) == 0 {
					m.RSi64 = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						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.RSi64 = append(m.RSi64, int64(v))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RSi64", wireType)
			}
		case 64:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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.RSi64Unpacked = append(m.RSi64Unpacked, int64(v))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.RSi64Unpacked) == 0 {
					m.RSi64Unpacked = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						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.RSi64Unpacked = append(m.RSi64Unpacked, int64(v))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RSi64Unpacked", wireType)
			}
		case 65:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IstioValue == nil {
				m.IstioValue = &v1beta1.Value{}
			}
			if err := m.IstioValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 66:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrIstioValue == nil {
				m.MapStrIstioValue = make(map[string]*v1beta1.Value)
			}
			var mapkey string
			var mapvalue *v1beta1.Value
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &v1beta1.Value{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrIstioValue[mapkey] = mapvalue
			iNdEx = postIndex
		case 67:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IpaddressIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IpaddressIstioValue == nil {
				m.IpaddressIstioValue = &v1beta1.IPAddress{}
			}
			if err := m.IpaddressIstioValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 68:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrIpaddressIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrIpaddressIstioValue == nil {
				m.MapStrIpaddressIstioValue = make(map[string]*v1beta1.IPAddress)
			}
			var mapkey string
			var mapvalue *v1beta1.IPAddress
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &v1beta1.IPAddress{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrIpaddressIstioValue[mapkey] = mapvalue
			iNdEx = postIndex
		case 69:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DurationIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DurationIstioValue == nil {
				m.DurationIstioValue = &v1beta1.Duration{}
			}
			if err := m.DurationIstioValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 70:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrDurationIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrDurationIstioValue == nil {
				m.MapStrDurationIstioValue = make(map[string]*v1beta1.Duration)
			}
			var mapkey string
			var mapvalue *v1beta1.Duration
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &v1beta1.Duration{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrDurationIstioValue[mapkey] = mapvalue
			iNdEx = postIndex
		case 71:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimestampIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TimestampIstioValue == nil {
				m.TimestampIstioValue = &v1beta1.TimeStamp{}
			}
			if err := m.TimestampIstioValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 72:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrTimestampIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrTimestampIstioValue == nil {
				m.MapStrTimestampIstioValue = make(map[string]*v1beta1.TimeStamp)
			}
			var mapkey string
			var mapvalue *v1beta1.TimeStamp
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &v1beta1.TimeStamp{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrTimestampIstioValue[mapkey] = mapvalue
			iNdEx = postIndex
		case 73:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DnsnameIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DnsnameIstioValue == nil {
				m.DnsnameIstioValue = &v1beta1.DNSName{}
			}
			if err := m.DnsnameIstioValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 74:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrDnsnameIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrDnsnameIstioValue == nil {
				m.MapStrDnsnameIstioValue = make(map[string]*v1beta1.DNSName)
			}
			var mapkey string
			var mapvalue *v1beta1.DNSName
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &v1beta1.DNSName{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrDnsnameIstioValue[mapkey] = mapvalue
			iNdEx = postIndex
		case 75:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EmailaddressIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EmailaddressIstioValue == nil {
				m.EmailaddressIstioValue = &v1beta1.EmailAddress{}
			}
			if err := m.EmailaddressIstioValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 76:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrEmailaddressIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrEmailaddressIstioValue == nil {
				m.MapStrEmailaddressIstioValue = make(map[string]*v1beta1.EmailAddress)
			}
			var mapkey string
			var mapvalue *v1beta1.EmailAddress
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &v1beta1.EmailAddress{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrEmailaddressIstioValue[mapkey] = mapvalue
			iNdEx = postIndex
		case 77:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UriIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UriIstioValue == nil {
				m.UriIstioValue = &v1beta1.Uri{}
			}
			if err := m.UriIstioValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 78:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrUriIstioValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrUriIstioValue == nil {
				m.MapStrUriIstioValue = make(map[string]*v1beta1.Uri)
			}
			var mapkey string
			var mapvalue *v1beta1.Uri
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &v1beta1.Uri{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrUriIstioValue[mapkey] = mapvalue
			iNdEx = postIndex
		case 79:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GoogleProtobufDuration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GoogleProtobufDuration == nil {
				m.GoogleProtobufDuration = &types.Duration{}
			}
			if err := m.GoogleProtobufDuration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 80:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GoogleProtobufTimestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GoogleProtobufTimestamp == nil {
				m.GoogleProtobufTimestamp = &types.Timestamp{}
			}
			if err := m.GoogleProtobufTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 123:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapInt64Double", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapInt64Double == nil {
				m.MapInt64Double = make(map[int64]float64)
			}
			var mapkey int64
			var mapvalue float64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapvaluetemp uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					mapvalue = math.Float64frombits(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapInt64Double[mapkey] = mapvalue
			iNdEx = postIndex
		case 124:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapFixed32Enum", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapFixed32Enum == nil {
				m.MapFixed32Enum = make(map[uint32]Myenum)
			}
			var mapkey uint32
			var mapvalue Myenum
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= Myenum(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapFixed32Enum[mapkey] = mapvalue
			iNdEx = postIndex
		case 125:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrFloat == nil {
				m.MapStrFloat = make(map[string]float32)
			}
			var mapkey string
			var mapvalue float32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					mapvalue = math.Float32frombits(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrFloat[mapkey] = mapvalue
			iNdEx = postIndex
		case 126:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrUint64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrUint64 == nil {
				m.MapStrUint64 = make(map[string]uint64)
			}
			var mapkey string
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					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 ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrUint64[mapkey] = mapvalue
			iNdEx = postIndex
		case 127:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrSfixed32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrSfixed32 == nil {
				m.MapStrSfixed32 = 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 ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrSfixed32[mapkey] = mapvalue
			iNdEx = postIndex
		case 128:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrSfixed64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrSfixed64 == nil {
				m.MapStrSfixed64 = make(map[string]int64)
			}
			var mapkey string
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrSfixed64[mapkey] = mapvalue
			iNdEx = postIndex
		case 129:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrSint32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrSint32 == nil {
				m.MapStrSint32 = 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 ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
					mapvalue = int32(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrSint32[mapkey] = mapvalue
			iNdEx = postIndex
		case 130:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrSint64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrSint64 == nil {
				m.MapStrSint64 = make(map[string]int64)
			}
			var mapkey string
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
					mapvalue = int64(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrSint64[mapkey] = mapvalue
			iNdEx = postIndex
		case 132:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrUint32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrUint32 == nil {
				m.MapStrUint32 = make(map[string]uint32)
			}
			var mapkey string
			var mapvalue uint32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					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 ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrUint32[mapkey] = mapvalue
			iNdEx = postIndex
		case 133:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrFixed64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrFixed64 == nil {
				m.MapStrFixed64 = make(map[string]uint64)
			}
			var mapkey string
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrFixed64[mapkey] = mapvalue
			iNdEx = postIndex
		case 134:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStrBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrBool == nil {
				m.MapStrBool = make(map[string]bool)
			}
			var mapkey string
			var mapvalue bool
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 ErrIntOverflowTypes
						}
						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 ErrInvalidLengthTypes
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTypes
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvalue = bool(mapvaluetemp != 0)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MapStrBool[mapkey] = mapvalue
			iNdEx = postIndex
		case 281:
			if wireType == 0 {
				var v Myenum
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= Myenum(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.REnmUnpacked = append(m.REnmUnpacked, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.REnmUnpacked) == 0 {
					m.REnmUnpacked = make([]Myenum, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v Myenum
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= Myenum(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.REnmUnpacked = append(m.REnmUnpacked, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field REnmUnpacked", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Other) 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 ErrIntOverflowTypes
			}
			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: other: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: other: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Str = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dbl", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Dbl = float64(math.Float64frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field I64", wireType)
			}
			m.I64 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.I64 |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.B = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inenum", wireType)
			}
			m.Inenum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Inenum |= OtherInnerenum(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inmsg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Inmsg == nil {
				m.Inmsg = &OtherInnerMsg{}
			}
			if err := m.Inmsg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OtherInnerMsg) 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 ErrIntOverflowTypes
			}
			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: innerMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: innerMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Str = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dbl", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Dbl = float64(math.Float64frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field I64", wireType)
			}
			m.I64 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.I64 |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Outer) 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 ErrIntOverflowTypes
			}
			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: Outer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Outer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field In", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.In == nil {
				m.In = &Outer_Inner{}
			}
			if err := m.In.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Outer_Inner) 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 ErrIntOverflowTypes
			}
			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: Inner: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Inner: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Str = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dbl", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Dbl = float64(math.Float64frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field I64", wireType)
			}
			m.I64 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.I64 |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.B = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTypes(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, ErrIntOverflowTypes
			}
			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, ErrIntOverflowTypes
				}
				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, ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTypes
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthTypes
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowTypes
					}
					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 := skipTypes(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthTypes
				}
			}
			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 (
	ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTypes   = fmt.Errorf("proto: integer overflow")
)
