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

/*
	Package foo is a generated protocol buffer package.

	It is generated from these files:
		mixer/pkg/protobuf/yaml/testdata/all/types.proto

	It has these top-level messages:
		Empty
		Simple
		Other
		Outer
*/
package foo

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import istio_policy_v1beta1 "istio.io/api/policy/v1beta1"

import strconv "strconv"

import bytes "bytes"

import strings "strings"
import reflect "reflect"
import sortkeys "github.com/gogo/protobuf/sortkeys"

import binary "encoding/binary"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type 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 fileDescriptorTypes, []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 fileDescriptorTypes, []int{2, 0} }

type Empty struct {
}

func (m *Empty) Reset()                    { *m = Empty{} }
func (*Empty) ProtoMessage()               {}
func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{0} }

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" 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" json:"map_str_msg,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	MapI32Msg        map[int32]*Other                       `protobuf:"bytes,20,rep,name=map_i32_msg,json=mapI32Msg" json:"map_i32_msg,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	MapStrEnum       map[string]Myenum                      `protobuf:"bytes,21,rep,name=map_str_enum,json=mapStrEnum" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" json:"oth,omitempty"`
	ROth             []*Other                               `protobuf:"bytes,26,rep,name=r_oth,json=rOth" 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,enum=foo.Myenum" json:"r_enm,omitempty"`
	REnmUnpacked     []Myenum                               `protobuf:"varint,281,rep,name=r_enm_unpacked,json=rEnmUnpacked,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" json:"r_dbl,omitempty"`
	RDblUnpacked     []float64                              `protobuf:"fixed64,24,rep,name=r_dbl_unpacked,json=rDblUnpacked" 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" json:"r_flt,omitempty"`
	RFltUnpacked     []float32                              `protobuf:"fixed32,31,rep,name=r_flt_unpacked,json=rFltUnpacked" 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" json:"r_i64,omitempty"`
	RI64Unpacked     []int64                                `protobuf:"varint,34,rep,name=r_i64_unpacked,json=rI64Unpacked" 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" json:"r_i32,omitempty"`
	RI32Unpacked     []int32                                `protobuf:"varint,37,rep,name=r_i32_unpacked,json=rI32Unpacked" 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" json:"r_ui64,omitempty"`
	RUi64Unpacked    []uint64                               `protobuf:"varint,40,rep,name=r_ui64_unpacked,json=rUi64Unpacked" 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" json:"r_ui32,omitempty"`
	RUi32Unpacked    []uint32                               `protobuf:"varint,43,rep,name=r_ui32_unpacked,json=rUi32Unpacked" 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" json:"r_f64,omitempty"`
	RF64Unpacked     []uint64                               `protobuf:"fixed64,46,rep,name=r_f64_unpacked,json=rF64Unpacked" 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" json:"r_sf64,omitempty"`
	RSf64Unpacked    []int64                                `protobuf:"fixed64,49,rep,name=r_sf64_unpacked,json=rSf64Unpacked" 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" json:"r_f32,omitempty"`
	RF32Unpacked     []uint32                               `protobuf:"fixed32,52,rep,name=r_f32_unpacked,json=rF32Unpacked" 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" json:"r_sf32,omitempty"`
	RSf32Unpacked    []int32                                `protobuf:"fixed32,55,rep,name=r_sf32_unpacked,json=rSf32Unpacked" 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" json:"r_b,omitempty"`
	RBUnpacked       []bool                                 `protobuf:"varint,57,rep,name=r_b_unpacked,json=rBUnpacked" 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" 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" json:"r_si32,omitempty"`
	RSi32Unpacked    []int32                                `protobuf:"zigzag32,61,rep,name=r_si32_unpacked,json=rSi32Unpacked" 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" json:"r_si64,omitempty"`
	RSi64Unpacked    []int64                                `protobuf:"zigzag64,64,rep,name=r_si64_unpacked,json=rSi64Unpacked" json:"r_si64_unpacked,omitempty"`
	IstioValue       *istio_policy_v1beta1.Value            `protobuf:"bytes,65,opt,name=istio_value,json=istioValue" json:"istio_value,omitempty"`
	MapStrIstioValue map[string]*istio_policy_v1beta1.Value `protobuf:"bytes,66,rep,name=map_str_istio_value,json=mapStrIstioValue" json:"map_str_istio_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *Simple) Reset()                    { *m = Simple{} }
func (*Simple) ProtoMessage()               {}
func (*Simple) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{1} }

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() *istio_policy_v1beta1.Value {
	if m != nil {
		return m.IstioValue
	}
	return nil
}

func (m *Simple) GetMapStrIstioValue() map[string]*istio_policy_v1beta1.Value {
	if m != nil {
		return m.MapStrIstioValue
	}
	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" json:"inmsg,omitempty"`
}

func (m *Other) Reset()                    { *m = Other{} }
func (*Other) ProtoMessage()               {}
func (*Other) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{2} }

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 fileDescriptorTypes, []int{2, 0} }

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" json:"in,omitempty"`
}

func (m *Outer) Reset()                    { *m = Outer{} }
func (*Outer) ProtoMessage()               {}
func (*Outer) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{3} }

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 fileDescriptorTypes, []int{3, 0} }

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.RegisterType((*Empty)(nil), "foo.Empty")
	proto.RegisterType((*Simple)(nil), "foo.Simple")
	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")
	proto.RegisterEnum("foo.Myenum", Myenum_name, Myenum_value)
	proto.RegisterEnum("foo.OtherInnerenum", OtherInnerenum_name, OtherInnerenum_value)
}
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
		}
	}
	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, 68)
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	sortkeys.Strings(keysForMapStrIstioValue)
	mapStringForMapStrIstioValue := "map[string]*istio_policy_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")
	}
	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.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

func (m *Simple) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Str) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Str)))
		i += copy(dAtA[i:], m.Str)
	}
	if m.Dbl != 0 {
		dAtA[i] = 0x11
		i++
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Dbl))))
		i += 8
	}
	if m.B {
		dAtA[i] = 0x20
		i++
		if m.B {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Oth != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Oth.Size()))
		n1, err := m.Oth.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.Byts) > 0 {
		dAtA[i] = 0x62
		i++
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Byts)))
		i += copy(dAtA[i:], m.Byts)
	}
	if m.Enm != 0 {
		dAtA[i] = 0x68
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Enm))
	}
	if len(m.MapStrStr) > 0 {
		for k, _ := range m.MapStrStr {
			dAtA[i] = 0x92
			i++
			dAtA[i] = 0x1
			i++
			v := m.MapStrStr[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + len(v) + sovTypes(uint64(len(v)))
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if len(m.MapStrMsg) > 0 {
		for k, _ := range m.MapStrMsg {
			dAtA[i] = 0x9a
			i++
			dAtA[i] = 0x1
			i++
			v := m.MapStrMsg[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(v.Size()))
				n2, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n2
			}
		}
	}
	if len(m.MapI32Msg) > 0 {
		for k, _ := range m.MapI32Msg {
			dAtA[i] = 0xa2
			i++
			dAtA[i] = 0x1
			i++
			v := m.MapI32Msg[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(v.Size()))
				n3, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n3
			}
		}
	}
	if len(m.MapStrEnum) > 0 {
		for k, _ := range m.MapStrEnum {
			dAtA[i] = 0xaa
			i++
			dAtA[i] = 0x1
			i++
			v := m.MapStrEnum[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + sovTypes(uint64(v))
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			i = encodeVarintTypes(dAtA, i, uint64(v))
		}
	}
	if len(m.RDbl) > 0 {
		dAtA[i] = 0xba
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RDbl)*8))
		for _, num := range m.RDbl {
			f4 := math.Float64bits(float64(num))
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(f4))
			i += 8
		}
	}
	if len(m.RDblUnpacked) > 0 {
		for _, num := range m.RDblUnpacked {
			dAtA[i] = 0xc1
			i++
			dAtA[i] = 0x1
			i++
			f5 := math.Float64bits(float64(num))
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(f5))
			i += 8
		}
	}
	if len(m.ROth) > 0 {
		for _, msg := range m.ROth {
			dAtA[i] = 0xd2
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.REnm) > 0 {
		dAtA7 := make([]byte, len(m.REnm)*10)
		var j6 int
		for _, num := range m.REnm {
			for num >= 1<<7 {
				dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j6++
			}
			dAtA7[j6] = uint8(num)
			j6++
		}
		dAtA[i] = 0xe2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTypes(dAtA, i, uint64(j6))
		i += copy(dAtA[i:], dAtA7[:j6])
	}
	if m.Flt != 0 {
		dAtA[i] = 0xed
		i++
		dAtA[i] = 0x1
		i++
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Flt))))
		i += 4
	}
	if len(m.RFlt) > 0 {
		dAtA[i] = 0xf2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RFlt)*4))
		for _, num := range m.RFlt {
			f8 := math.Float32bits(float32(num))
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(f8))
			i += 4
		}
	}
	if len(m.RFltUnpacked) > 0 {
		for _, num := range m.RFltUnpacked {
			dAtA[i] = 0xfd
			i++
			dAtA[i] = 0x1
			i++
			f9 := math.Float32bits(float32(num))
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(f9))
			i += 4
		}
	}
	if m.I64 != 0 {
		dAtA[i] = 0x80
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.I64))
	}
	if len(m.RI64) > 0 {
		dAtA11 := make([]byte, len(m.RI64)*10)
		var j10 int
		for _, num1 := range m.RI64 {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j10++
			}
			dAtA11[j10] = uint8(num)
			j10++
		}
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTypes(dAtA, i, uint64(j10))
		i += copy(dAtA[i:], dAtA11[:j10])
	}
	if len(m.RI64Unpacked) > 0 {
		for _, num := range m.RI64Unpacked {
			dAtA[i] = 0x90
			i++
			dAtA[i] = 0x2
			i++
			i = encodeVarintTypes(dAtA, i, uint64(num))
		}
	}
	if m.I32 != 0 {
		dAtA[i] = 0x98
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.I32))
	}
	if len(m.RI32) > 0 {
		dAtA13 := make([]byte, len(m.RI32)*10)
		var j12 int
		for _, num1 := range m.RI32 {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j12++
			}
			dAtA13[j12] = uint8(num)
			j12++
		}
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTypes(dAtA, i, uint64(j12))
		i += copy(dAtA[i:], dAtA13[:j12])
	}
	if len(m.RI32Unpacked) > 0 {
		for _, num := range m.RI32Unpacked {
			dAtA[i] = 0xa8
			i++
			dAtA[i] = 0x2
			i++
			i = encodeVarintTypes(dAtA, i, uint64(num))
		}
	}
	if m.Ui64 != 0 {
		dAtA[i] = 0xb0
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Ui64))
	}
	if len(m.RUi64) > 0 {
		dAtA15 := make([]byte, len(m.RUi64)*10)
		var j14 int
		for _, num := range m.RUi64 {
			for num >= 1<<7 {
				dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j14++
			}
			dAtA15[j14] = uint8(num)
			j14++
		}
		dAtA[i] = 0xba
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTypes(dAtA, i, uint64(j14))
		i += copy(dAtA[i:], dAtA15[:j14])
	}
	if len(m.RUi64Unpacked) > 0 {
		for _, num := range m.RUi64Unpacked {
			dAtA[i] = 0xc0
			i++
			dAtA[i] = 0x2
			i++
			i = encodeVarintTypes(dAtA, i, uint64(num))
		}
	}
	if m.Ui32 != 0 {
		dAtA[i] = 0xc8
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Ui32))
	}
	if len(m.RUi32) > 0 {
		dAtA17 := make([]byte, len(m.RUi32)*10)
		var j16 int
		for _, num := range m.RUi32 {
			for num >= 1<<7 {
				dAtA17[j16] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j16++
			}
			dAtA17[j16] = uint8(num)
			j16++
		}
		dAtA[i] = 0xd2
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTypes(dAtA, i, uint64(j16))
		i += copy(dAtA[i:], dAtA17[:j16])
	}
	if len(m.RUi32Unpacked) > 0 {
		for _, num := range m.RUi32Unpacked {
			dAtA[i] = 0xd8
			i++
			dAtA[i] = 0x2
			i++
			i = encodeVarintTypes(dAtA, i, uint64(num))
		}
	}
	if m.F64 != 0 {
		dAtA[i] = 0xe1
		i++
		dAtA[i] = 0x2
		i++
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.F64))
		i += 8
	}
	if len(m.RF64) > 0 {
		dAtA[i] = 0xea
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RF64)*8))
		for _, num := range m.RF64 {
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(num))
			i += 8
		}
	}
	if len(m.RF64Unpacked) > 0 {
		for _, num := range m.RF64Unpacked {
			dAtA[i] = 0xf1
			i++
			dAtA[i] = 0x2
			i++
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(num))
			i += 8
		}
	}
	if m.Sf64 != 0 {
		dAtA[i] = 0xf9
		i++
		dAtA[i] = 0x2
		i++
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Sf64))
		i += 8
	}
	if len(m.RSf64) > 0 {
		dAtA[i] = 0x82
		i++
		dAtA[i] = 0x3
		i++
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RSf64)*8))
		for _, num := range m.RSf64 {
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(num))
			i += 8
		}
	}
	if len(m.RSf64Unpacked) > 0 {
		for _, num := range m.RSf64Unpacked {
			dAtA[i] = 0x89
			i++
			dAtA[i] = 0x3
			i++
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(num))
			i += 8
		}
	}
	if m.F32 != 0 {
		dAtA[i] = 0x95
		i++
		dAtA[i] = 0x3
		i++
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.F32))
		i += 4
	}
	if len(m.RF32) > 0 {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x3
		i++
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RF32)*4))
		for _, num := range m.RF32 {
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(num))
			i += 4
		}
	}
	if len(m.RF32Unpacked) > 0 {
		for _, num := range m.RF32Unpacked {
			dAtA[i] = 0xa5
			i++
			dAtA[i] = 0x3
			i++
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(num))
			i += 4
		}
	}
	if m.Sf32 != 0 {
		dAtA[i] = 0xad
		i++
		dAtA[i] = 0x3
		i++
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Sf32))
		i += 4
	}
	if len(m.RSf32) > 0 {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x3
		i++
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RSf32)*4))
		for _, num := range m.RSf32 {
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(num))
			i += 4
		}
	}
	if len(m.RSf32Unpacked) > 0 {
		for _, num := range m.RSf32Unpacked {
			dAtA[i] = 0xbd
			i++
			dAtA[i] = 0x3
			i++
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(num))
			i += 4
		}
	}
	if len(m.RB) > 0 {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x3
		i++
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RB)))
		for _, b := range m.RB {
			if b {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i++
		}
	}
	if len(m.RBUnpacked) > 0 {
		for _, b := range m.RBUnpacked {
			dAtA[i] = 0xc8
			i++
			dAtA[i] = 0x3
			i++
			if b {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i++
		}
	}
	if len(m.RStr) > 0 {
		for _, s := range m.RStr {
			dAtA[i] = 0xd2
			i++
			dAtA[i] = 0x3
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.Si32 != 0 {
		dAtA[i] = 0xd8
		i++
		dAtA[i] = 0x3
		i++
		i = encodeVarintTypes(dAtA, i, uint64((uint32(m.Si32)<<1)^uint32((m.Si32>>31))))
	}
	if len(m.RSi32) > 0 {
		dAtA18 := make([]byte, len(m.RSi32)*5)
		var j19 int
		for _, num := range m.RSi32 {
			x20 := (uint32(num) << 1) ^ uint32((num >> 31))
			for x20 >= 1<<7 {
				dAtA18[j19] = uint8(uint64(x20)&0x7f | 0x80)
				j19++
				x20 >>= 7
			}
			dAtA18[j19] = uint8(x20)
			j19++
		}
		dAtA[i] = 0xe2
		i++
		dAtA[i] = 0x3
		i++
		i = encodeVarintTypes(dAtA, i, uint64(j19))
		i += copy(dAtA[i:], dAtA18[:j19])
	}
	if len(m.RSi32Unpacked) > 0 {
		for _, num := range m.RSi32Unpacked {
			dAtA[i] = 0xe8
			i++
			dAtA[i] = 0x3
			i++
			x21 := (uint32(num) << 1) ^ uint32((num >> 31))
			for x21 >= 1<<7 {
				dAtA[i] = uint8(uint64(x21)&0x7f | 0x80)
				x21 >>= 7
				i++
			}
			dAtA[i] = uint8(x21)
			i++
		}
	}
	if m.Si64 != 0 {
		dAtA[i] = 0xf0
		i++
		dAtA[i] = 0x3
		i++
		i = encodeVarintTypes(dAtA, i, uint64((uint64(m.Si64)<<1)^uint64((m.Si64>>63))))
	}
	if len(m.RSi64) > 0 {
		var j22 int
		dAtA24 := make([]byte, len(m.RSi64)*10)
		for _, num := range m.RSi64 {
			x23 := (uint64(num) << 1) ^ uint64((num >> 63))
			for x23 >= 1<<7 {
				dAtA24[j22] = uint8(uint64(x23)&0x7f | 0x80)
				j22++
				x23 >>= 7
			}
			dAtA24[j22] = uint8(x23)
			j22++
		}
		dAtA[i] = 0xfa
		i++
		dAtA[i] = 0x3
		i++
		i = encodeVarintTypes(dAtA, i, uint64(j22))
		i += copy(dAtA[i:], dAtA24[:j22])
	}
	if len(m.RSi64Unpacked) > 0 {
		for _, num := range m.RSi64Unpacked {
			dAtA[i] = 0x80
			i++
			dAtA[i] = 0x4
			i++
			x25 := (uint64(num) << 1) ^ uint64((num >> 63))
			for x25 >= 1<<7 {
				dAtA[i] = uint8(uint64(x25)&0x7f | 0x80)
				x25 >>= 7
				i++
			}
			dAtA[i] = uint8(x25)
			i++
		}
	}
	if m.IstioValue != nil {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x4
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.IstioValue.Size()))
		n26, err := m.IstioValue.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n26
	}
	if len(m.MapStrIstioValue) > 0 {
		for k, _ := range m.MapStrIstioValue {
			dAtA[i] = 0x92
			i++
			dAtA[i] = 0x4
			i++
			v := m.MapStrIstioValue[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(v.Size()))
				n27, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n27
			}
		}
	}
	if len(m.MapInt64Double) > 0 {
		for k, _ := range m.MapInt64Double {
			dAtA[i] = 0xda
			i++
			dAtA[i] = 0x7
			i++
			v := m.MapInt64Double[k]
			mapSize := 1 + sovTypes(uint64(k)) + 1 + 8
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			dAtA[i] = 0x11
			i++
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
			i += 8
		}
	}
	if len(m.MapFixed32Enum) > 0 {
		for k, _ := range m.MapFixed32Enum {
			dAtA[i] = 0xe2
			i++
			dAtA[i] = 0x7
			i++
			v := m.MapFixed32Enum[k]
			mapSize := 1 + 4 + 1 + sovTypes(uint64(v))
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xd
			i++
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(k))
			i += 4
			dAtA[i] = 0x10
			i++
			i = encodeVarintTypes(dAtA, i, uint64(v))
		}
	}
	if len(m.MapStrFloat) > 0 {
		for k, _ := range m.MapStrFloat {
			dAtA[i] = 0xea
			i++
			dAtA[i] = 0x7
			i++
			v := m.MapStrFloat[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + 4
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x15
			i++
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(v))))
			i += 4
		}
	}
	if len(m.MapStrUint64) > 0 {
		for k, _ := range m.MapStrUint64 {
			dAtA[i] = 0xf2
			i++
			dAtA[i] = 0x7
			i++
			v := m.MapStrUint64[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + sovTypes(uint64(v))
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			i = encodeVarintTypes(dAtA, i, uint64(v))
		}
	}
	if len(m.MapStrSfixed32) > 0 {
		for k, _ := range m.MapStrSfixed32 {
			dAtA[i] = 0xfa
			i++
			dAtA[i] = 0x7
			i++
			v := m.MapStrSfixed32[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + 4
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x15
			i++
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
			i += 4
		}
	}
	if len(m.MapStrSfixed64) > 0 {
		for k, _ := range m.MapStrSfixed64 {
			dAtA[i] = 0x82
			i++
			dAtA[i] = 0x8
			i++
			v := m.MapStrSfixed64[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + 8
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x11
			i++
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
			i += 8
		}
	}
	if len(m.MapStrSint32) > 0 {
		for k, _ := range m.MapStrSint32 {
			dAtA[i] = 0x8a
			i++
			dAtA[i] = 0x8
			i++
			v := m.MapStrSint32[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + sozTypes(uint64(v))
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			i = encodeVarintTypes(dAtA, i, uint64((uint32(v)<<1)^uint32((v>>31))))
		}
	}
	if len(m.MapStrSint64) > 0 {
		for k, _ := range m.MapStrSint64 {
			dAtA[i] = 0x92
			i++
			dAtA[i] = 0x8
			i++
			v := m.MapStrSint64[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + sozTypes(uint64(v))
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			i = encodeVarintTypes(dAtA, i, uint64((uint64(v)<<1)^uint64((v>>63))))
		}
	}
	if len(m.MapStrUint32) > 0 {
		for k, _ := range m.MapStrUint32 {
			dAtA[i] = 0xa2
			i++
			dAtA[i] = 0x8
			i++
			v := m.MapStrUint32[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + sovTypes(uint64(v))
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			i = encodeVarintTypes(dAtA, i, uint64(v))
		}
	}
	if len(m.MapStrFixed64) > 0 {
		for k, _ := range m.MapStrFixed64 {
			dAtA[i] = 0xaa
			i++
			dAtA[i] = 0x8
			i++
			v := m.MapStrFixed64[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + 8
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x11
			i++
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
			i += 8
		}
	}
	if len(m.MapStrBool) > 0 {
		for k, _ := range m.MapStrBool {
			dAtA[i] = 0xb2
			i++
			dAtA[i] = 0x8
			i++
			v := m.MapStrBool[k]
			mapSize := 1 + len(k) + sovTypes(uint64(len(k))) + 1 + 1
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			if v {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i++
		}
	}
	if len(m.REnmUnpacked) > 0 {
		for _, num := range m.REnmUnpacked {
			dAtA[i] = 0xc8
			i++
			dAtA[i] = 0x11
			i++
			i = encodeVarintTypes(dAtA, i, uint64(num))
		}
	}
	return i, nil
}

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

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

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

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

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

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

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

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

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

func (m *Simple) Size() (n int) {
	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 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) {
	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) {
	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) {
	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) {
	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) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
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"
	}
	keysForMapStrStr := make([]string, 0, len(this.MapStrStr))
	for k, _ := range this.MapStrStr {
		keysForMapStrStr = append(keysForMapStrStr, k)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	sortkeys.Strings(keysForMapStrIstioValue)
	mapStringForMapStrIstioValue := "map[string]*istio_policy_v1beta1.Value{"
	for _, k := range keysForMapStrIstioValue {
		mapStringForMapStrIstioValue += fmt.Sprintf("%v: %v,", k, this.MapStrIstioValue[k])
	}
	mapStringForMapStrIstioValue += "}"
	keysForMapInt64Double := make([]int64, 0, len(this.MapInt64Double))
	for k, _ := range this.MapInt64Double {
		keysForMapInt64Double = append(keysForMapInt64Double, k)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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)
	}
	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:` + strings.Replace(fmt.Sprintf("%v", this.ROth), "Other", "Other", 1) + `,`,
		`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", "istio_policy_v1beta1.Value", 1) + `,`,
		`MapStrIstioValue:` + mapStringForMapStrIstioValue + `,`,
		`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) > 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 > 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(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 > 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 > 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 > 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 > 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 > 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 > 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 > 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 mapmsglen < 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 > 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 mapmsglen < 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 > 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 > 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(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(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(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(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 > 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 > l {
					return io.ErrUnexpectedEOF
				}
				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(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(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(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(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 45:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(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(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(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(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 48:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(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(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(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(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 51:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(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(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(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(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 54:
			if wireType == 5 {
				var v int32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = int32(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v int32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = int32(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(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 > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v int32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = int32(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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > 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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > l {
				return io.ErrUnexpectedEOF
			}
			if m.IstioValue == nil {
				m.IstioValue = &istio_policy_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 > l {
				return io.ErrUnexpectedEOF
			}
			if m.MapStrIstioValue == nil {
				m.MapStrIstioValue = make(map[string]*istio_policy_v1beta1.Value)
			}
			var mapkey string
			var mapvalue *istio_policy_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 > 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 mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &istio_policy_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 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 > 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(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 > 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(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 > 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 > 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(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 > 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 > 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 > 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 > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = int32(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 > 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 > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = int64(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 > 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 > 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 > 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 > 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 > 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 > 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 > 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 > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = uint64(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 > 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 > 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 > l {
					return io.ErrUnexpectedEOF
				}
				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) > 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 > 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(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 > 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) > 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 > 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(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) > 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 > 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) > 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 > 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(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) > 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
				}
			}
			iNdEx += length
			if length < 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
			}
			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")
)

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

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