types.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: combos/both/types.proto

package types

import (
	bytes "bytes"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type KnownTypes struct {
	Dur   *types.Duration    `protobuf:"bytes,1,opt,name=dur,proto3" json:"dur,omitempty"`
	Ts    *types.Timestamp   `protobuf:"bytes,2,opt,name=ts,proto3" json:"ts,omitempty"`
	Dbl   *types.DoubleValue `protobuf:"bytes,3,opt,name=dbl,proto3" json:"dbl,omitempty"`
	Flt   *types.FloatValue  `protobuf:"bytes,4,opt,name=flt,proto3" json:"flt,omitempty"`
	I64   *types.Int64Value  `protobuf:"bytes,5,opt,name=i64,proto3" json:"i64,omitempty"`
	U64   *types.UInt64Value `protobuf:"bytes,6,opt,name=u64,proto3" json:"u64,omitempty"`
	I32   *types.Int32Value  `protobuf:"bytes,7,opt,name=i32,proto3" json:"i32,omitempty"`
	U32   *types.UInt32Value `protobuf:"bytes,8,opt,name=u32,proto3" json:"u32,omitempty"`
	Bool  *types.BoolValue   `protobuf:"bytes,9,opt,name=bool,proto3" json:"bool,omitempty"`
	Str   *types.StringValue `protobuf:"bytes,10,opt,name=str,proto3" json:"str,omitempty"`
	Bytes *types.BytesValue  `protobuf:"bytes,11,opt,name=bytes,proto3" json:"bytes,omitempty"`
	// TODO uncomment this once https://github.com/gogo/protobuf/issues/197 is fixed
	St                   *types.Struct `protobuf:"bytes,12,opt,name=st,proto3" json:"st,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_KnownTypes proto.InternalMessageInfo

func (m *KnownTypes) GetDur() *types.Duration {
	if m != nil {
		return m.Dur
	}
	return nil
}

func (m *KnownTypes) GetTs() *types.Timestamp {
	if m != nil {
		return m.Ts
	}
	return nil
}

func (m *KnownTypes) GetDbl() *types.DoubleValue {
	if m != nil {
		return m.Dbl
	}
	return nil
}

func (m *KnownTypes) GetFlt() *types.FloatValue {
	if m != nil {
		return m.Flt
	}
	return nil
}

func (m *KnownTypes) GetI64() *types.Int64Value {
	if m != nil {
		return m.I64
	}
	return nil
}

func (m *KnownTypes) GetU64() *types.UInt64Value {
	if m != nil {
		return m.U64
	}
	return nil
}

func (m *KnownTypes) GetI32() *types.Int32Value {
	if m != nil {
		return m.I32
	}
	return nil
}

func (m *KnownTypes) GetU32() *types.UInt32Value {
	if m != nil {
		return m.U32
	}
	return nil
}

func (m *KnownTypes) GetBool() *types.BoolValue {
	if m != nil {
		return m.Bool
	}
	return nil
}

func (m *KnownTypes) GetStr() *types.StringValue {
	if m != nil {
		return m.Str
	}
	return nil
}

func (m *KnownTypes) GetBytes() *types.BytesValue {
	if m != nil {
		return m.Bytes
	}
	return nil
}

func (m *KnownTypes) GetSt() *types.Struct {
	if m != nil {
		return m.St
	}
	return nil
}

type ProtoTypes struct {
	NullableTimestamp    *types.Timestamp   `protobuf:"bytes,1,opt,name=nullableTimestamp,proto3" json:"nullableTimestamp,omitempty"`
	NullableDuration     *types.Duration    `protobuf:"bytes,2,opt,name=nullableDuration,proto3" json:"nullableDuration,omitempty"`
	NullableDouble       *types.DoubleValue `protobuf:"bytes,3,opt,name=nullableDouble,proto3" json:"nullableDouble,omitempty"`
	NullableFloat        *types.FloatValue  `protobuf:"bytes,4,opt,name=nullableFloat,proto3" json:"nullableFloat,omitempty"`
	NullableInt64        *types.Int64Value  `protobuf:"bytes,5,opt,name=nullableInt64,proto3" json:"nullableInt64,omitempty"`
	NullableUInt64       *types.UInt64Value `protobuf:"bytes,6,opt,name=nullableUInt64,proto3" json:"nullableUInt64,omitempty"`
	NullableInt32        *types.Int32Value  `protobuf:"bytes,7,opt,name=nullableInt32,proto3" json:"nullableInt32,omitempty"`
	NullableUInt32       *types.UInt32Value `protobuf:"bytes,8,opt,name=nullableUInt32,proto3" json:"nullableUInt32,omitempty"`
	NullableBool         *types.BoolValue   `protobuf:"bytes,9,opt,name=nullableBool,proto3" json:"nullableBool,omitempty"`
	NullableString       *types.StringValue `protobuf:"bytes,10,opt,name=nullableString,proto3" json:"nullableString,omitempty"`
	NullableBytes        *types.BytesValue  `protobuf:"bytes,11,opt,name=nullableBytes,proto3" json:"nullableBytes,omitempty"`
	Timestamp            types.Timestamp    `protobuf:"bytes,12,opt,name=timestamp,proto3" json:"timestamp"`
	Duration             types.Duration     `protobuf:"bytes,13,opt,name=duration,proto3" json:"duration"`
	NonnullDouble        types.DoubleValue  `protobuf:"bytes,14,opt,name=nonnullDouble,proto3" json:"nonnullDouble"`
	NonnullFloat         types.FloatValue   `protobuf:"bytes,15,opt,name=nonnullFloat,proto3" json:"nonnullFloat"`
	NonnullInt64         types.Int64Value   `protobuf:"bytes,16,opt,name=nonnullInt64,proto3" json:"nonnullInt64"`
	NonnullUInt64        types.UInt64Value  `protobuf:"bytes,17,opt,name=nonnullUInt64,proto3" json:"nonnullUInt64"`
	NonnullInt32         types.Int32Value   `protobuf:"bytes,18,opt,name=nonnullInt32,proto3" json:"nonnullInt32"`
	NonnullUInt32        types.UInt32Value  `protobuf:"bytes,19,opt,name=nonnullUInt32,proto3" json:"nonnullUInt32"`
	NonnullBool          types.BoolValue    `protobuf:"bytes,20,opt,name=nonnullBool,proto3" json:"nonnullBool"`
	NonnullString        types.StringValue  `protobuf:"bytes,21,opt,name=nonnullString,proto3" json:"nonnullString"`
	NonnullBytes         types.BytesValue   `protobuf:"bytes,22,opt,name=nonnullBytes,proto3" json:"nonnullBytes"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_ProtoTypes proto.InternalMessageInfo

func (m *ProtoTypes) GetNullableTimestamp() *types.Timestamp {
	if m != nil {
		return m.NullableTimestamp
	}
	return nil
}

func (m *ProtoTypes) GetNullableDuration() *types.Duration {
	if m != nil {
		return m.NullableDuration
	}
	return nil
}

func (m *ProtoTypes) GetNullableDouble() *types.DoubleValue {
	if m != nil {
		return m.NullableDouble
	}
	return nil
}

func (m *ProtoTypes) GetNullableFloat() *types.FloatValue {
	if m != nil {
		return m.NullableFloat
	}
	return nil
}

func (m *ProtoTypes) GetNullableInt64() *types.Int64Value {
	if m != nil {
		return m.NullableInt64
	}
	return nil
}

func (m *ProtoTypes) GetNullableUInt64() *types.UInt64Value {
	if m != nil {
		return m.NullableUInt64
	}
	return nil
}

func (m *ProtoTypes) GetNullableInt32() *types.Int32Value {
	if m != nil {
		return m.NullableInt32
	}
	return nil
}

func (m *ProtoTypes) GetNullableUInt32() *types.UInt32Value {
	if m != nil {
		return m.NullableUInt32
	}
	return nil
}

func (m *ProtoTypes) GetNullableBool() *types.BoolValue {
	if m != nil {
		return m.NullableBool
	}
	return nil
}

func (m *ProtoTypes) GetNullableString() *types.StringValue {
	if m != nil {
		return m.NullableString
	}
	return nil
}

func (m *ProtoTypes) GetNullableBytes() *types.BytesValue {
	if m != nil {
		return m.NullableBytes
	}
	return nil
}

func (m *ProtoTypes) GetTimestamp() types.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return types.Timestamp{}
}

func (m *ProtoTypes) GetDuration() types.Duration {
	if m != nil {
		return m.Duration
	}
	return types.Duration{}
}

func (m *ProtoTypes) GetNonnullDouble() types.DoubleValue {
	if m != nil {
		return m.NonnullDouble
	}
	return types.DoubleValue{}
}

func (m *ProtoTypes) GetNonnullFloat() types.FloatValue {
	if m != nil {
		return m.NonnullFloat
	}
	return types.FloatValue{}
}

func (m *ProtoTypes) GetNonnullInt64() types.Int64Value {
	if m != nil {
		return m.NonnullInt64
	}
	return types.Int64Value{}
}

func (m *ProtoTypes) GetNonnullUInt64() types.UInt64Value {
	if m != nil {
		return m.NonnullUInt64
	}
	return types.UInt64Value{}
}

func (m *ProtoTypes) GetNonnullInt32() types.Int32Value {
	if m != nil {
		return m.NonnullInt32
	}
	return types.Int32Value{}
}

func (m *ProtoTypes) GetNonnullUInt32() types.UInt32Value {
	if m != nil {
		return m.NonnullUInt32
	}
	return types.UInt32Value{}
}

func (m *ProtoTypes) GetNonnullBool() types.BoolValue {
	if m != nil {
		return m.NonnullBool
	}
	return types.BoolValue{}
}

func (m *ProtoTypes) GetNonnullString() types.StringValue {
	if m != nil {
		return m.NonnullString
	}
	return types.StringValue{}
}

func (m *ProtoTypes) GetNonnullBytes() types.BytesValue {
	if m != nil {
		return m.NonnullBytes
	}
	return types.BytesValue{}
}

type StdTypes struct {
	NullableTimestamp    *time.Time     `protobuf:"bytes,1,opt,name=nullableTimestamp,proto3,stdtime" json:"nullableTimestamp,omitempty"`
	NullableDuration     *time.Duration `protobuf:"bytes,2,opt,name=nullableDuration,proto3,stdduration" json:"nullableDuration,omitempty"`
	NullableDouble       *float64       `protobuf:"bytes,3,opt,name=nullableDouble,proto3,wktptr" json:"nullableDouble,omitempty"`
	NullableFloat        *float32       `protobuf:"bytes,4,opt,name=nullableFloat,proto3,wktptr" json:"nullableFloat,omitempty"`
	NullableInt64        *int64         `protobuf:"bytes,5,opt,name=nullableInt64,proto3,wktptr" json:"nullableInt64,omitempty"`
	NullableUInt64       *uint64        `protobuf:"bytes,6,opt,name=nullableUInt64,proto3,wktptr" json:"nullableUInt64,omitempty"`
	NullableInt32        *int32         `protobuf:"bytes,7,opt,name=nullableInt32,proto3,wktptr" json:"nullableInt32,omitempty"`
	NullableUInt32       *uint32        `protobuf:"bytes,8,opt,name=nullableUInt32,proto3,wktptr" json:"nullableUInt32,omitempty"`
	NullableBool         *bool          `protobuf:"bytes,9,opt,name=nullableBool,proto3,wktptr" json:"nullableBool,omitempty"`
	NullableString       *string        `protobuf:"bytes,10,opt,name=nullableString,proto3,wktptr" json:"nullableString,omitempty"`
	NullableBytes        *[]byte        `protobuf:"bytes,11,opt,name=nullableBytes,proto3,wktptr" json:"nullableBytes,omitempty"`
	Timestamp            time.Time      `protobuf:"bytes,12,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
	Duration             time.Duration  `protobuf:"bytes,13,opt,name=duration,proto3,stdduration" json:"duration"`
	NonnullDouble        float64        `protobuf:"bytes,14,opt,name=nonnullDouble,proto3,wktptr" json:"nonnullDouble"`
	NonnullFloat         float32        `protobuf:"bytes,15,opt,name=nonnullFloat,proto3,wktptr" json:"nonnullFloat"`
	NonnullInt64         int64          `protobuf:"bytes,16,opt,name=nonnullInt64,proto3,wktptr" json:"nonnullInt64"`
	NonnullUInt64        uint64         `protobuf:"bytes,17,opt,name=nonnullUInt64,proto3,wktptr" json:"nonnullUInt64"`
	NonnullInt32         int32          `protobuf:"bytes,18,opt,name=nonnullInt32,proto3,wktptr" json:"nonnullInt32"`
	NonnullUInt32        uint32         `protobuf:"bytes,19,opt,name=nonnullUInt32,proto3,wktptr" json:"nonnullUInt32"`
	NonnullBool          bool           `protobuf:"bytes,20,opt,name=nonnullBool,proto3,wktptr" json:"nonnullBool"`
	NonnullString        string         `protobuf:"bytes,21,opt,name=nonnullString,proto3,wktptr" json:"nonnullString"`
	NonnullBytes         []byte         `protobuf:"bytes,22,opt,name=nonnullBytes,proto3,wktptr" json:"nonnullBytes"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_StdTypes proto.InternalMessageInfo

func (m *StdTypes) GetNullableTimestamp() *time.Time {
	if m != nil {
		return m.NullableTimestamp
	}
	return nil
}

func (m *StdTypes) GetNullableDuration() *time.Duration {
	if m != nil {
		return m.NullableDuration
	}
	return nil
}

func (m *StdTypes) GetNullableDouble() *float64 {
	if m != nil {
		return m.NullableDouble
	}
	return nil
}

func (m *StdTypes) GetNullableFloat() *float32 {
	if m != nil {
		return m.NullableFloat
	}
	return nil
}

func (m *StdTypes) GetNullableInt64() *int64 {
	if m != nil {
		return m.NullableInt64
	}
	return nil
}

func (m *StdTypes) GetNullableUInt64() *uint64 {
	if m != nil {
		return m.NullableUInt64
	}
	return nil
}

func (m *StdTypes) GetNullableInt32() *int32 {
	if m != nil {
		return m.NullableInt32
	}
	return nil
}

func (m *StdTypes) GetNullableUInt32() *uint32 {
	if m != nil {
		return m.NullableUInt32
	}
	return nil
}

func (m *StdTypes) GetNullableBool() *bool {
	if m != nil {
		return m.NullableBool
	}
	return nil
}

func (m *StdTypes) GetNullableString() *string {
	if m != nil {
		return m.NullableString
	}
	return nil
}

func (m *StdTypes) GetNullableBytes() *[]byte {
	if m != nil {
		return m.NullableBytes
	}
	return nil
}

func (m *StdTypes) GetTimestamp() time.Time {
	if m != nil {
		return m.Timestamp
	}
	return time.Time{}
}

func (m *StdTypes) GetDuration() time.Duration {
	if m != nil {
		return m.Duration
	}
	return 0
}

func (m *StdTypes) GetNonnullDouble() float64 {
	if m != nil {
		return m.NonnullDouble
	}
	return 0
}

func (m *StdTypes) GetNonnullFloat() float32 {
	if m != nil {
		return m.NonnullFloat
	}
	return 0
}

func (m *StdTypes) GetNonnullInt64() int64 {
	if m != nil {
		return m.NonnullInt64
	}
	return 0
}

func (m *StdTypes) GetNonnullUInt64() uint64 {
	if m != nil {
		return m.NonnullUInt64
	}
	return 0
}

func (m *StdTypes) GetNonnullInt32() int32 {
	if m != nil {
		return m.NonnullInt32
	}
	return 0
}

func (m *StdTypes) GetNonnullUInt32() uint32 {
	if m != nil {
		return m.NonnullUInt32
	}
	return 0
}

func (m *StdTypes) GetNonnullBool() bool {
	if m != nil {
		return m.NonnullBool
	}
	return false
}

func (m *StdTypes) GetNonnullString() string {
	if m != nil {
		return m.NonnullString
	}
	return ""
}

func (m *StdTypes) GetNonnullBytes() []byte {
	if m != nil {
		return m.NonnullBytes
	}
	return []byte{}
}

type RepProtoTypes struct {
	NullableTimestamps   []*types.Timestamp   `protobuf:"bytes,1,rep,name=nullableTimestamps,proto3" json:"nullableTimestamps,omitempty"`
	NullableDurations    []*types.Duration    `protobuf:"bytes,2,rep,name=nullableDurations,proto3" json:"nullableDurations,omitempty"`
	Timestamps           []types.Timestamp    `protobuf:"bytes,3,rep,name=timestamps,proto3" json:"timestamps"`
	Durations            []types.Duration     `protobuf:"bytes,4,rep,name=durations,proto3" json:"durations"`
	NullableDouble       []*types.DoubleValue `protobuf:"bytes,5,rep,name=nullableDouble,proto3" json:"nullableDouble,omitempty"`
	NonnullDouble        []types.DoubleValue  `protobuf:"bytes,6,rep,name=nonnullDouble,proto3" json:"nonnullDouble"`
	NullableFloat        []*types.FloatValue  `protobuf:"bytes,7,rep,name=nullableFloat,proto3" json:"nullableFloat,omitempty"`
	NonnullFloat         []types.FloatValue   `protobuf:"bytes,8,rep,name=nonnullFloat,proto3" json:"nonnullFloat"`
	NullableInt64        []*types.Int64Value  `protobuf:"bytes,9,rep,name=nullableInt64,proto3" json:"nullableInt64,omitempty"`
	NonnullInt64         []types.Int64Value   `protobuf:"bytes,10,rep,name=nonnullInt64,proto3" json:"nonnullInt64"`
	NullableUInt64       []*types.UInt64Value `protobuf:"bytes,11,rep,name=nullableUInt64,proto3" json:"nullableUInt64,omitempty"`
	NonnullUInt64        []types.UInt64Value  `protobuf:"bytes,12,rep,name=nonnullUInt64,proto3" json:"nonnullUInt64"`
	NullableInt32        []*types.Int32Value  `protobuf:"bytes,13,rep,name=nullableInt32,proto3" json:"nullableInt32,omitempty"`
	NonnullInt32         []types.Int32Value   `protobuf:"bytes,14,rep,name=nonnullInt32,proto3" json:"nonnullInt32"`
	NullableUInt32       []*types.UInt32Value `protobuf:"bytes,15,rep,name=nullableUInt32,proto3" json:"nullableUInt32,omitempty"`
	NonnullUInt32        []types.UInt32Value  `protobuf:"bytes,16,rep,name=nonnullUInt32,proto3" json:"nonnullUInt32"`
	NullableBool         []*types.BoolValue   `protobuf:"bytes,17,rep,name=nullableBool,proto3" json:"nullableBool,omitempty"`
	NonnullBool          []types.BoolValue    `protobuf:"bytes,18,rep,name=nonnullBool,proto3" json:"nonnullBool"`
	NullableString       []*types.StringValue `protobuf:"bytes,19,rep,name=nullableString,proto3" json:"nullableString,omitempty"`
	NonnullString        []types.StringValue  `protobuf:"bytes,20,rep,name=nonnullString,proto3" json:"nonnullString"`
	NullableBytes        []*types.BytesValue  `protobuf:"bytes,21,rep,name=nullableBytes,proto3" json:"nullableBytes,omitempty"`
	NonnullBytes         []types.BytesValue   `protobuf:"bytes,22,rep,name=nonnullBytes,proto3" json:"nonnullBytes"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_RepProtoTypes proto.InternalMessageInfo

func (m *RepProtoTypes) GetNullableTimestamps() []*types.Timestamp {
	if m != nil {
		return m.NullableTimestamps
	}
	return nil
}

func (m *RepProtoTypes) GetNullableDurations() []*types.Duration {
	if m != nil {
		return m.NullableDurations
	}
	return nil
}

func (m *RepProtoTypes) GetTimestamps() []types.Timestamp {
	if m != nil {
		return m.Timestamps
	}
	return nil
}

func (m *RepProtoTypes) GetDurations() []types.Duration {
	if m != nil {
		return m.Durations
	}
	return nil
}

func (m *RepProtoTypes) GetNullableDouble() []*types.DoubleValue {
	if m != nil {
		return m.NullableDouble
	}
	return nil
}

func (m *RepProtoTypes) GetNonnullDouble() []types.DoubleValue {
	if m != nil {
		return m.NonnullDouble
	}
	return nil
}

func (m *RepProtoTypes) GetNullableFloat() []*types.FloatValue {
	if m != nil {
		return m.NullableFloat
	}
	return nil
}

func (m *RepProtoTypes) GetNonnullFloat() []types.FloatValue {
	if m != nil {
		return m.NonnullFloat
	}
	return nil
}

func (m *RepProtoTypes) GetNullableInt64() []*types.Int64Value {
	if m != nil {
		return m.NullableInt64
	}
	return nil
}

func (m *RepProtoTypes) GetNonnullInt64() []types.Int64Value {
	if m != nil {
		return m.NonnullInt64
	}
	return nil
}

func (m *RepProtoTypes) GetNullableUInt64() []*types.UInt64Value {
	if m != nil {
		return m.NullableUInt64
	}
	return nil
}

func (m *RepProtoTypes) GetNonnullUInt64() []types.UInt64Value {
	if m != nil {
		return m.NonnullUInt64
	}
	return nil
}

func (m *RepProtoTypes) GetNullableInt32() []*types.Int32Value {
	if m != nil {
		return m.NullableInt32
	}
	return nil
}

func (m *RepProtoTypes) GetNonnullInt32() []types.Int32Value {
	if m != nil {
		return m.NonnullInt32
	}
	return nil
}

func (m *RepProtoTypes) GetNullableUInt32() []*types.UInt32Value {
	if m != nil {
		return m.NullableUInt32
	}
	return nil
}

func (m *RepProtoTypes) GetNonnullUInt32() []types.UInt32Value {
	if m != nil {
		return m.NonnullUInt32
	}
	return nil
}

func (m *RepProtoTypes) GetNullableBool() []*types.BoolValue {
	if m != nil {
		return m.NullableBool
	}
	return nil
}

func (m *RepProtoTypes) GetNonnullBool() []types.BoolValue {
	if m != nil {
		return m.NonnullBool
	}
	return nil
}

func (m *RepProtoTypes) GetNullableString() []*types.StringValue {
	if m != nil {
		return m.NullableString
	}
	return nil
}

func (m *RepProtoTypes) GetNonnullString() []types.StringValue {
	if m != nil {
		return m.NonnullString
	}
	return nil
}

func (m *RepProtoTypes) GetNullableBytes() []*types.BytesValue {
	if m != nil {
		return m.NullableBytes
	}
	return nil
}

func (m *RepProtoTypes) GetNonnullBytes() []types.BytesValue {
	if m != nil {
		return m.NonnullBytes
	}
	return nil
}

type RepStdTypes struct {
	NullableTimestamps   []*time.Time     `protobuf:"bytes,1,rep,name=nullableTimestamps,proto3,stdtime" json:"nullableTimestamps,omitempty"`
	NullableDurations    []*time.Duration `protobuf:"bytes,2,rep,name=nullableDurations,proto3,stdduration" json:"nullableDurations,omitempty"`
	Timestamps           []time.Time      `protobuf:"bytes,3,rep,name=timestamps,proto3,stdtime" json:"timestamps"`
	Durations            []time.Duration  `protobuf:"bytes,4,rep,name=durations,proto3,stdduration" json:"durations"`
	NullableDouble       []*float64       `protobuf:"bytes,5,rep,name=nullableDouble,proto3,wktptr" json:"nullableDouble,omitempty"`
	NonnullDouble        []float64        `protobuf:"bytes,6,rep,name=nonnullDouble,proto3,wktptr" json:"nonnullDouble"`
	NullableFloat        []*float32       `protobuf:"bytes,7,rep,name=nullableFloat,proto3,wktptr" json:"nullableFloat,omitempty"`
	NonnullFloat         []float32        `protobuf:"bytes,8,rep,name=nonnullFloat,proto3,wktptr" json:"nonnullFloat"`
	NullableInt64        []*int64         `protobuf:"bytes,9,rep,name=nullableInt64,proto3,wktptr" json:"nullableInt64,omitempty"`
	NonnullInt64         []int64          `protobuf:"bytes,10,rep,name=nonnullInt64,proto3,wktptr" json:"nonnullInt64"`
	NullableUInt64       []*uint64        `protobuf:"bytes,11,rep,name=nullableUInt64,proto3,wktptr" json:"nullableUInt64,omitempty"`
	NonnullUInt64        []uint64         `protobuf:"bytes,12,rep,name=nonnullUInt64,proto3,wktptr" json:"nonnullUInt64"`
	NullableInt32        []*int32         `protobuf:"bytes,13,rep,name=nullableInt32,proto3,wktptr" json:"nullableInt32,omitempty"`
	NonnullInt32         []int32          `protobuf:"bytes,14,rep,name=nonnullInt32,proto3,wktptr" json:"nonnullInt32"`
	NullableUInt32       []*uint32        `protobuf:"bytes,15,rep,name=nullableUInt32,proto3,wktptr" json:"nullableUInt32,omitempty"`
	NonnullUInt32        []uint32         `protobuf:"bytes,16,rep,name=nonnullUInt32,proto3,wktptr" json:"nonnullUInt32"`
	NullableBool         []*bool          `protobuf:"bytes,17,rep,name=nullableBool,proto3,wktptr" json:"nullableBool,omitempty"`
	NonnullBool          []bool           `protobuf:"bytes,18,rep,name=nonnullBool,proto3,wktptr" json:"nonnullBool"`
	NullableString       []*string        `protobuf:"bytes,19,rep,name=nullableString,proto3,wktptr" json:"nullableString,omitempty"`
	NonnullString        []string         `protobuf:"bytes,20,rep,name=nonnullString,proto3,wktptr" json:"nonnullString"`
	NullableBytes        []*[]byte        `protobuf:"bytes,21,rep,name=nullableBytes,proto3,wktptr" json:"nullableBytes,omitempty"`
	NonnullBytes         [][]byte         `protobuf:"bytes,22,rep,name=nonnullBytes,proto3,wktptr" json:"nonnullBytes"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_RepStdTypes proto.InternalMessageInfo

func (m *RepStdTypes) GetNullableTimestamps() []*time.Time {
	if m != nil {
		return m.NullableTimestamps
	}
	return nil
}

func (m *RepStdTypes) GetNullableDurations() []*time.Duration {
	if m != nil {
		return m.NullableDurations
	}
	return nil
}

func (m *RepStdTypes) GetTimestamps() []time.Time {
	if m != nil {
		return m.Timestamps
	}
	return nil
}

func (m *RepStdTypes) GetDurations() []time.Duration {
	if m != nil {
		return m.Durations
	}
	return nil
}

func (m *RepStdTypes) GetNullableDouble() []*float64 {
	if m != nil {
		return m.NullableDouble
	}
	return nil
}

func (m *RepStdTypes) GetNonnullDouble() []float64 {
	if m != nil {
		return m.NonnullDouble
	}
	return nil
}

func (m *RepStdTypes) GetNullableFloat() []*float32 {
	if m != nil {
		return m.NullableFloat
	}
	return nil
}

func (m *RepStdTypes) GetNonnullFloat() []float32 {
	if m != nil {
		return m.NonnullFloat
	}
	return nil
}

func (m *RepStdTypes) GetNullableInt64() []*int64 {
	if m != nil {
		return m.NullableInt64
	}
	return nil
}

func (m *RepStdTypes) GetNonnullInt64() []int64 {
	if m != nil {
		return m.NonnullInt64
	}
	return nil
}

func (m *RepStdTypes) GetNullableUInt64() []*uint64 {
	if m != nil {
		return m.NullableUInt64
	}
	return nil
}

func (m *RepStdTypes) GetNonnullUInt64() []uint64 {
	if m != nil {
		return m.NonnullUInt64
	}
	return nil
}

func (m *RepStdTypes) GetNullableInt32() []*int32 {
	if m != nil {
		return m.NullableInt32
	}
	return nil
}

func (m *RepStdTypes) GetNonnullInt32() []int32 {
	if m != nil {
		return m.NonnullInt32
	}
	return nil
}

func (m *RepStdTypes) GetNullableUInt32() []*uint32 {
	if m != nil {
		return m.NullableUInt32
	}
	return nil
}

func (m *RepStdTypes) GetNonnullUInt32() []uint32 {
	if m != nil {
		return m.NonnullUInt32
	}
	return nil
}

func (m *RepStdTypes) GetNullableBool() []*bool {
	if m != nil {
		return m.NullableBool
	}
	return nil
}

func (m *RepStdTypes) GetNonnullBool() []bool {
	if m != nil {
		return m.NonnullBool
	}
	return nil
}

func (m *RepStdTypes) GetNullableString() []*string {
	if m != nil {
		return m.NullableString
	}
	return nil
}

func (m *RepStdTypes) GetNonnullString() []string {
	if m != nil {
		return m.NonnullString
	}
	return nil
}

func (m *RepStdTypes) GetNullableBytes() []*[]byte {
	if m != nil {
		return m.NullableBytes
	}
	return nil
}

func (m *RepStdTypes) GetNonnullBytes() [][]byte {
	if m != nil {
		return m.NonnullBytes
	}
	return nil
}

type MapProtoTypes struct {
	NullableTimestamp    map[int32]*types.Timestamp   `protobuf:"bytes,1,rep,name=nullableTimestamp,proto3" json:"nullableTimestamp,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Timestamp            map[int32]types.Timestamp    `protobuf:"bytes,2,rep,name=timestamp,proto3" json:"timestamp" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableDuration     map[int32]*types.Duration    `protobuf:"bytes,3,rep,name=nullableDuration,proto3" json:"nullableDuration,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Duration             map[int32]types.Duration     `protobuf:"bytes,4,rep,name=duration,proto3" json:"duration" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableDouble       map[int32]*types.DoubleValue `protobuf:"bytes,5,rep,name=nullableDouble,proto3" json:"nullableDouble,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullDouble        map[int32]types.DoubleValue  `protobuf:"bytes,6,rep,name=nonnullDouble,proto3" json:"nonnullDouble" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableFloat        map[int32]*types.FloatValue  `protobuf:"bytes,7,rep,name=nullableFloat,proto3" json:"nullableFloat,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullFloat         map[int32]types.FloatValue   `protobuf:"bytes,8,rep,name=nonnullFloat,proto3" json:"nonnullFloat" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableInt64        map[int32]*types.Int64Value  `protobuf:"bytes,9,rep,name=nullableInt64,proto3" json:"nullableInt64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullInt64         map[int32]types.Int64Value   `protobuf:"bytes,10,rep,name=nonnullInt64,proto3" json:"nonnullInt64" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableUInt64       map[int32]*types.UInt64Value `protobuf:"bytes,11,rep,name=nullableUInt64,proto3" json:"nullableUInt64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullUInt64        map[int32]types.UInt64Value  `protobuf:"bytes,12,rep,name=nonnullUInt64,proto3" json:"nonnullUInt64" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableInt32        map[int32]*types.Int32Value  `protobuf:"bytes,13,rep,name=nullableInt32,proto3" json:"nullableInt32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullInt32         map[int32]types.Int32Value   `protobuf:"bytes,14,rep,name=nonnullInt32,proto3" json:"nonnullInt32" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableUInt32       map[int32]*types.UInt32Value `protobuf:"bytes,15,rep,name=nullableUInt32,proto3" json:"nullableUInt32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullUInt32        map[int32]types.UInt32Value  `protobuf:"bytes,16,rep,name=nonnullUInt32,proto3" json:"nonnullUInt32" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableBool         map[int32]*types.BoolValue   `protobuf:"bytes,17,rep,name=nullableBool,proto3" json:"nullableBool,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullBool          map[int32]types.BoolValue    `protobuf:"bytes,18,rep,name=nonnullBool,proto3" json:"nonnullBool" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableString       map[int32]*types.StringValue `protobuf:"bytes,19,rep,name=nullableString,proto3" json:"nullableString,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullString        map[int32]types.StringValue  `protobuf:"bytes,20,rep,name=nonnullString,proto3" json:"nonnullString" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableBytes        map[int32]*types.BytesValue  `protobuf:"bytes,21,rep,name=nullableBytes,proto3" json:"nullableBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullBytes         map[int32]types.BytesValue   `protobuf:"bytes,22,rep,name=nonnullBytes,proto3" json:"nonnullBytes" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

var xxx_messageInfo_MapProtoTypes proto.InternalMessageInfo

func (m *MapProtoTypes) GetNullableTimestamp() map[int32]*types.Timestamp {
	if m != nil {
		return m.NullableTimestamp
	}
	return nil
}

func (m *MapProtoTypes) GetTimestamp() map[int32]types.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *MapProtoTypes) GetNullableDuration() map[int32]*types.Duration {
	if m != nil {
		return m.NullableDuration
	}
	return nil
}

func (m *MapProtoTypes) GetDuration() map[int32]types.Duration {
	if m != nil {
		return m.Duration
	}
	return nil
}

func (m *MapProtoTypes) GetNullableDouble() map[int32]*types.DoubleValue {
	if m != nil {
		return m.NullableDouble
	}
	return nil
}

func (m *MapProtoTypes) GetNonnullDouble() map[int32]types.DoubleValue {
	if m != nil {
		return m.NonnullDouble
	}
	return nil
}

func (m *MapProtoTypes) GetNullableFloat() map[int32]*types.FloatValue {
	if m != nil {
		return m.NullableFloat
	}
	return nil
}

func (m *MapProtoTypes) GetNonnullFloat() map[int32]types.FloatValue {
	if m != nil {
		return m.NonnullFloat
	}
	return nil
}

func (m *MapProtoTypes) GetNullableInt64() map[int32]*types.Int64Value {
	if m != nil {
		return m.NullableInt64
	}
	return nil
}

func (m *MapProtoTypes) GetNonnullInt64() map[int32]types.Int64Value {
	if m != nil {
		return m.NonnullInt64
	}
	return nil
}

func (m *MapProtoTypes) GetNullableUInt64() map[int32]*types.UInt64Value {
	if m != nil {
		return m.NullableUInt64
	}
	return nil
}

func (m *MapProtoTypes) GetNonnullUInt64() map[int32]types.UInt64Value {
	if m != nil {
		return m.NonnullUInt64
	}
	return nil
}

func (m *MapProtoTypes) GetNullableInt32() map[int32]*types.Int32Value {
	if m != nil {
		return m.NullableInt32
	}
	return nil
}

func (m *MapProtoTypes) GetNonnullInt32() map[int32]types.Int32Value {
	if m != nil {
		return m.NonnullInt32
	}
	return nil
}

func (m *MapProtoTypes) GetNullableUInt32() map[int32]*types.UInt32Value {
	if m != nil {
		return m.NullableUInt32
	}
	return nil
}

func (m *MapProtoTypes) GetNonnullUInt32() map[int32]types.UInt32Value {
	if m != nil {
		return m.NonnullUInt32
	}
	return nil
}

func (m *MapProtoTypes) GetNullableBool() map[int32]*types.BoolValue {
	if m != nil {
		return m.NullableBool
	}
	return nil
}

func (m *MapProtoTypes) GetNonnullBool() map[int32]types.BoolValue {
	if m != nil {
		return m.NonnullBool
	}
	return nil
}

func (m *MapProtoTypes) GetNullableString() map[int32]*types.StringValue {
	if m != nil {
		return m.NullableString
	}
	return nil
}

func (m *MapProtoTypes) GetNonnullString() map[int32]types.StringValue {
	if m != nil {
		return m.NonnullString
	}
	return nil
}

func (m *MapProtoTypes) GetNullableBytes() map[int32]*types.BytesValue {
	if m != nil {
		return m.NullableBytes
	}
	return nil
}

func (m *MapProtoTypes) GetNonnullBytes() map[int32]types.BytesValue {
	if m != nil {
		return m.NonnullBytes
	}
	return nil
}

type MapStdTypes struct {
	NullableTimestamp    map[int32]*time.Time     `protobuf:"bytes,1,rep,name=nullableTimestamp,proto3,stdtime" json:"nullableTimestamp,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Timestamp            map[int32]time.Time      `protobuf:"bytes,2,rep,name=timestamp,proto3,stdtime" json:"timestamp" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableDuration     map[int32]*time.Duration `protobuf:"bytes,3,rep,name=nullableDuration,proto3,stdduration" json:"nullableDuration,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Duration             map[int32]time.Duration  `protobuf:"bytes,4,rep,name=duration,proto3,stdduration" json:"duration" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableDouble       map[int32]*float64       `protobuf:"bytes,5,rep,name=nullableDouble,proto3,wktptr" json:"nullableDouble,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullDouble        map[int32]float64        `protobuf:"bytes,6,rep,name=nonnullDouble,proto3,wktptr" json:"nonnullDouble" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableFloat        map[int32]*float32       `protobuf:"bytes,7,rep,name=nullableFloat,proto3,wktptr" json:"nullableFloat,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullFloat         map[int32]float32        `protobuf:"bytes,8,rep,name=nonnullFloat,proto3,wktptr" json:"nonnullFloat" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableInt64        map[int32]*int64         `protobuf:"bytes,9,rep,name=nullableInt64,proto3,wktptr" json:"nullableInt64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullInt64         map[int32]int64          `protobuf:"bytes,10,rep,name=nonnullInt64,proto3,wktptr" json:"nonnullInt64" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableUInt64       map[int32]*uint64        `protobuf:"bytes,11,rep,name=nullableUInt64,proto3,wktptr" json:"nullableUInt64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullUInt64        map[int32]uint64         `protobuf:"bytes,12,rep,name=nonnullUInt64,proto3,wktptr" json:"nonnullUInt64" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableInt32        map[int32]*int32         `protobuf:"bytes,13,rep,name=nullableInt32,proto3,wktptr" json:"nullableInt32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullInt32         map[int32]int32          `protobuf:"bytes,14,rep,name=nonnullInt32,proto3,wktptr" json:"nonnullInt32" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableUInt32       map[int32]*uint32        `protobuf:"bytes,15,rep,name=nullableUInt32,proto3,wktptr" json:"nullableUInt32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullUInt32        map[int32]uint32         `protobuf:"bytes,16,rep,name=nonnullUInt32,proto3,wktptr" json:"nonnullUInt32" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableBool         map[int32]*bool          `protobuf:"bytes,17,rep,name=nullableBool,proto3,wktptr" json:"nullableBool,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullBool          map[int32]bool           `protobuf:"bytes,18,rep,name=nonnullBool,proto3,wktptr" json:"nonnullBool" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableString       map[int32]*string        `protobuf:"bytes,19,rep,name=nullableString,proto3,wktptr" json:"nullableString,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullString        map[int32]string         `protobuf:"bytes,20,rep,name=nonnullString,proto3,wktptr" json:"nonnullString" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NullableBytes        map[int32]*[]byte        `protobuf:"bytes,21,rep,name=nullableBytes,proto3,wktptr" json:"nullableBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullBytes         map[int32][]byte         `protobuf:"bytes,22,rep,name=nonnullBytes,proto3,wktptr" json:"nonnullBytes" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

var xxx_messageInfo_MapStdTypes proto.InternalMessageInfo

func (m *MapStdTypes) GetNullableTimestamp() map[int32]*time.Time {
	if m != nil {
		return m.NullableTimestamp
	}
	return nil
}

func (m *MapStdTypes) GetTimestamp() map[int32]time.Time {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *MapStdTypes) GetNullableDuration() map[int32]*time.Duration {
	if m != nil {
		return m.NullableDuration
	}
	return nil
}

func (m *MapStdTypes) GetDuration() map[int32]time.Duration {
	if m != nil {
		return m.Duration
	}
	return nil
}

func (m *MapStdTypes) GetNullableDouble() map[int32]*float64 {
	if m != nil {
		return m.NullableDouble
	}
	return nil
}

func (m *MapStdTypes) GetNonnullDouble() map[int32]float64 {
	if m != nil {
		return m.NonnullDouble
	}
	return nil
}

func (m *MapStdTypes) GetNullableFloat() map[int32]*float32 {
	if m != nil {
		return m.NullableFloat
	}
	return nil
}

func (m *MapStdTypes) GetNonnullFloat() map[int32]float32 {
	if m != nil {
		return m.NonnullFloat
	}
	return nil
}

func (m *MapStdTypes) GetNullableInt64() map[int32]*int64 {
	if m != nil {
		return m.NullableInt64
	}
	return nil
}

func (m *MapStdTypes) GetNonnullInt64() map[int32]int64 {
	if m != nil {
		return m.NonnullInt64
	}
	return nil
}

func (m *MapStdTypes) GetNullableUInt64() map[int32]*uint64 {
	if m != nil {
		return m.NullableUInt64
	}
	return nil
}

func (m *MapStdTypes) GetNonnullUInt64() map[int32]uint64 {
	if m != nil {
		return m.NonnullUInt64
	}
	return nil
}

func (m *MapStdTypes) GetNullableInt32() map[int32]*int32 {
	if m != nil {
		return m.NullableInt32
	}
	return nil
}

func (m *MapStdTypes) GetNonnullInt32() map[int32]int32 {
	if m != nil {
		return m.NonnullInt32
	}
	return nil
}

func (m *MapStdTypes) GetNullableUInt32() map[int32]*uint32 {
	if m != nil {
		return m.NullableUInt32
	}
	return nil
}

func (m *MapStdTypes) GetNonnullUInt32() map[int32]uint32 {
	if m != nil {
		return m.NonnullUInt32
	}
	return nil
}

func (m *MapStdTypes) GetNullableBool() map[int32]*bool {
	if m != nil {
		return m.NullableBool
	}
	return nil
}

func (m *MapStdTypes) GetNonnullBool() map[int32]bool {
	if m != nil {
		return m.NonnullBool
	}
	return nil
}

func (m *MapStdTypes) GetNullableString() map[int32]*string {
	if m != nil {
		return m.NullableString
	}
	return nil
}

func (m *MapStdTypes) GetNonnullString() map[int32]string {
	if m != nil {
		return m.NonnullString
	}
	return nil
}

func (m *MapStdTypes) GetNullableBytes() map[int32]*[]byte {
	if m != nil {
		return m.NullableBytes
	}
	return nil
}

func (m *MapStdTypes) GetNonnullBytes() map[int32][]byte {
	if m != nil {
		return m.NonnullBytes
	}
	return nil
}

type OneofProtoTypes struct {
	// Types that are valid to be assigned to OneOfProtoTimes:
	//	*OneofProtoTypes_Timestamp
	//	*OneofProtoTypes_Duration
	//	*OneofProtoTypes_RepDouble
	//	*OneofProtoTypes_RepFloat
	//	*OneofProtoTypes_RepInt64
	//	*OneofProtoTypes_RepUInt64
	//	*OneofProtoTypes_RepInt32
	//	*OneofProtoTypes_RepUInt32
	//	*OneofProtoTypes_RepBool
	//	*OneofProtoTypes_RepString
	//	*OneofProtoTypes_RepBytes
	OneOfProtoTimes      isOneofProtoTypes_OneOfProtoTimes `protobuf_oneof:"OneOfProtoTimes"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

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

var xxx_messageInfo_OneofProtoTypes proto.InternalMessageInfo

type isOneofProtoTypes_OneOfProtoTimes interface {
	isOneofProtoTypes_OneOfProtoTimes()
	Equal(interface{}) bool
	VerboseEqual(interface{}) error
	MarshalTo([]byte) (int, error)
	Size() int
}

type OneofProtoTypes_Timestamp struct {
	Timestamp *types.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3,oneof"`
}
type OneofProtoTypes_Duration struct {
	Duration *types.Duration `protobuf:"bytes,2,opt,name=duration,proto3,oneof"`
}
type OneofProtoTypes_RepDouble struct {
	RepDouble *types.DoubleValue `protobuf:"bytes,3,opt,name=repDouble,proto3,oneof"`
}
type OneofProtoTypes_RepFloat struct {
	RepFloat *types.FloatValue `protobuf:"bytes,4,opt,name=repFloat,proto3,oneof"`
}
type OneofProtoTypes_RepInt64 struct {
	RepInt64 *types.Int64Value `protobuf:"bytes,5,opt,name=repInt64,proto3,oneof"`
}
type OneofProtoTypes_RepUInt64 struct {
	RepUInt64 *types.UInt64Value `protobuf:"bytes,6,opt,name=repUInt64,proto3,oneof"`
}
type OneofProtoTypes_RepInt32 struct {
	RepInt32 *types.Int32Value `protobuf:"bytes,7,opt,name=repInt32,proto3,oneof"`
}
type OneofProtoTypes_RepUInt32 struct {
	RepUInt32 *types.UInt32Value `protobuf:"bytes,8,opt,name=repUInt32,proto3,oneof"`
}
type OneofProtoTypes_RepBool struct {
	RepBool *types.BoolValue `protobuf:"bytes,9,opt,name=repBool,proto3,oneof"`
}
type OneofProtoTypes_RepString struct {
	RepString *types.StringValue `protobuf:"bytes,10,opt,name=repString,proto3,oneof"`
}
type OneofProtoTypes_RepBytes struct {
	RepBytes *types.BytesValue `protobuf:"bytes,11,opt,name=repBytes,proto3,oneof"`
}

func (*OneofProtoTypes_Timestamp) isOneofProtoTypes_OneOfProtoTimes() {}
func (*OneofProtoTypes_Duration) isOneofProtoTypes_OneOfProtoTimes()  {}
func (*OneofProtoTypes_RepDouble) isOneofProtoTypes_OneOfProtoTimes() {}
func (*OneofProtoTypes_RepFloat) isOneofProtoTypes_OneOfProtoTimes()  {}
func (*OneofProtoTypes_RepInt64) isOneofProtoTypes_OneOfProtoTimes()  {}
func (*OneofProtoTypes_RepUInt64) isOneofProtoTypes_OneOfProtoTimes() {}
func (*OneofProtoTypes_RepInt32) isOneofProtoTypes_OneOfProtoTimes()  {}
func (*OneofProtoTypes_RepUInt32) isOneofProtoTypes_OneOfProtoTimes() {}
func (*OneofProtoTypes_RepBool) isOneofProtoTypes_OneOfProtoTimes()   {}
func (*OneofProtoTypes_RepString) isOneofProtoTypes_OneOfProtoTimes() {}
func (*OneofProtoTypes_RepBytes) isOneofProtoTypes_OneOfProtoTimes()  {}

func (m *OneofProtoTypes) GetOneOfProtoTimes() isOneofProtoTypes_OneOfProtoTimes {
	if m != nil {
		return m.OneOfProtoTimes
	}
	return nil
}

func (m *OneofProtoTypes) GetTimestamp() *types.Timestamp {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_Timestamp); ok {
		return x.Timestamp
	}
	return nil
}

func (m *OneofProtoTypes) GetDuration() *types.Duration {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_Duration); ok {
		return x.Duration
	}
	return nil
}

func (m *OneofProtoTypes) GetRepDouble() *types.DoubleValue {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_RepDouble); ok {
		return x.RepDouble
	}
	return nil
}

func (m *OneofProtoTypes) GetRepFloat() *types.FloatValue {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_RepFloat); ok {
		return x.RepFloat
	}
	return nil
}

func (m *OneofProtoTypes) GetRepInt64() *types.Int64Value {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_RepInt64); ok {
		return x.RepInt64
	}
	return nil
}

func (m *OneofProtoTypes) GetRepUInt64() *types.UInt64Value {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_RepUInt64); ok {
		return x.RepUInt64
	}
	return nil
}

func (m *OneofProtoTypes) GetRepInt32() *types.Int32Value {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_RepInt32); ok {
		return x.RepInt32
	}
	return nil
}

func (m *OneofProtoTypes) GetRepUInt32() *types.UInt32Value {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_RepUInt32); ok {
		return x.RepUInt32
	}
	return nil
}

func (m *OneofProtoTypes) GetRepBool() *types.BoolValue {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_RepBool); ok {
		return x.RepBool
	}
	return nil
}

func (m *OneofProtoTypes) GetRepString() *types.StringValue {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_RepString); ok {
		return x.RepString
	}
	return nil
}

func (m *OneofProtoTypes) GetRepBytes() *types.BytesValue {
	if x, ok := m.GetOneOfProtoTimes().(*OneofProtoTypes_RepBytes); ok {
		return x.RepBytes
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*OneofProtoTypes) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*OneofProtoTypes_Timestamp)(nil),
		(*OneofProtoTypes_Duration)(nil),
		(*OneofProtoTypes_RepDouble)(nil),
		(*OneofProtoTypes_RepFloat)(nil),
		(*OneofProtoTypes_RepInt64)(nil),
		(*OneofProtoTypes_RepUInt64)(nil),
		(*OneofProtoTypes_RepInt32)(nil),
		(*OneofProtoTypes_RepUInt32)(nil),
		(*OneofProtoTypes_RepBool)(nil),
		(*OneofProtoTypes_RepString)(nil),
		(*OneofProtoTypes_RepBytes)(nil),
	}
}

type OneofStdTypes struct {
	// Types that are valid to be assigned to OneOfStdTimes:
	//	*OneofStdTypes_Timestamp
	//	*OneofStdTypes_Duration
	//	*OneofStdTypes_RepDouble
	//	*OneofStdTypes_RepFloat
	//	*OneofStdTypes_RepInt64
	//	*OneofStdTypes_RepUInt64
	//	*OneofStdTypes_RepInt32
	//	*OneofStdTypes_RepUInt32
	//	*OneofStdTypes_RepBool
	//	*OneofStdTypes_RepString
	//	*OneofStdTypes_RepBytes
	OneOfStdTimes        isOneofStdTypes_OneOfStdTimes `protobuf_oneof:"OneOfStdTimes"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

var xxx_messageInfo_OneofStdTypes proto.InternalMessageInfo

type isOneofStdTypes_OneOfStdTimes interface {
	isOneofStdTypes_OneOfStdTimes()
	Equal(interface{}) bool
	VerboseEqual(interface{}) error
	MarshalTo([]byte) (int, error)
	Size() int
}

type OneofStdTypes_Timestamp struct {
	Timestamp *time.Time `protobuf:"bytes,1,opt,name=timestamp,proto3,oneof,stdtime"`
}
type OneofStdTypes_Duration struct {
	Duration *time.Duration `protobuf:"bytes,2,opt,name=duration,proto3,oneof,stdduration"`
}
type OneofStdTypes_RepDouble struct {
	RepDouble *float64 `protobuf:"bytes,3,opt,name=repDouble,proto3,oneof,wktptr"`
}
type OneofStdTypes_RepFloat struct {
	RepFloat *float32 `protobuf:"bytes,4,opt,name=repFloat,proto3,oneof,wktptr"`
}
type OneofStdTypes_RepInt64 struct {
	RepInt64 *int64 `protobuf:"bytes,5,opt,name=repInt64,proto3,oneof,wktptr"`
}
type OneofStdTypes_RepUInt64 struct {
	RepUInt64 *uint64 `protobuf:"bytes,6,opt,name=repUInt64,proto3,oneof,wktptr"`
}
type OneofStdTypes_RepInt32 struct {
	RepInt32 *int32 `protobuf:"bytes,7,opt,name=repInt32,proto3,oneof,wktptr"`
}
type OneofStdTypes_RepUInt32 struct {
	RepUInt32 *uint32 `protobuf:"bytes,8,opt,name=repUInt32,proto3,oneof,wktptr"`
}
type OneofStdTypes_RepBool struct {
	RepBool *bool `protobuf:"bytes,9,opt,name=repBool,proto3,oneof,wktptr"`
}
type OneofStdTypes_RepString struct {
	RepString *string `protobuf:"bytes,10,opt,name=repString,proto3,oneof,wktptr"`
}
type OneofStdTypes_RepBytes struct {
	RepBytes *[]byte `protobuf:"bytes,11,opt,name=repBytes,proto3,oneof,wktptr"`
}

func (*OneofStdTypes_Timestamp) isOneofStdTypes_OneOfStdTimes() {}
func (*OneofStdTypes_Duration) isOneofStdTypes_OneOfStdTimes()  {}
func (*OneofStdTypes_RepDouble) isOneofStdTypes_OneOfStdTimes() {}
func (*OneofStdTypes_RepFloat) isOneofStdTypes_OneOfStdTimes()  {}
func (*OneofStdTypes_RepInt64) isOneofStdTypes_OneOfStdTimes()  {}
func (*OneofStdTypes_RepUInt64) isOneofStdTypes_OneOfStdTimes() {}
func (*OneofStdTypes_RepInt32) isOneofStdTypes_OneOfStdTimes()  {}
func (*OneofStdTypes_RepUInt32) isOneofStdTypes_OneOfStdTimes() {}
func (*OneofStdTypes_RepBool) isOneofStdTypes_OneOfStdTimes()   {}
func (*OneofStdTypes_RepString) isOneofStdTypes_OneOfStdTimes() {}
func (*OneofStdTypes_RepBytes) isOneofStdTypes_OneOfStdTimes()  {}

func (m *OneofStdTypes) GetOneOfStdTimes() isOneofStdTypes_OneOfStdTimes {
	if m != nil {
		return m.OneOfStdTimes
	}
	return nil
}

func (m *OneofStdTypes) GetTimestamp() *time.Time {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_Timestamp); ok {
		return x.Timestamp
	}
	return nil
}

func (m *OneofStdTypes) GetDuration() *time.Duration {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_Duration); ok {
		return x.Duration
	}
	return nil
}

func (m *OneofStdTypes) GetRepDouble() *float64 {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepDouble); ok {
		return x.RepDouble
	}
	return nil
}

func (m *OneofStdTypes) GetRepFloat() *float32 {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepFloat); ok {
		return x.RepFloat
	}
	return nil
}

func (m *OneofStdTypes) GetRepInt64() *int64 {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepInt64); ok {
		return x.RepInt64
	}
	return nil
}

func (m *OneofStdTypes) GetRepUInt64() *uint64 {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepUInt64); ok {
		return x.RepUInt64
	}
	return nil
}

func (m *OneofStdTypes) GetRepInt32() *int32 {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepInt32); ok {
		return x.RepInt32
	}
	return nil
}

func (m *OneofStdTypes) GetRepUInt32() *uint32 {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepUInt32); ok {
		return x.RepUInt32
	}
	return nil
}

func (m *OneofStdTypes) GetRepBool() *bool {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepBool); ok {
		return x.RepBool
	}
	return nil
}

func (m *OneofStdTypes) GetRepString() *string {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepString); ok {
		return x.RepString
	}
	return nil
}

func (m *OneofStdTypes) GetRepBytes() *[]byte {
	if x, ok := m.GetOneOfStdTimes().(*OneofStdTypes_RepBytes); ok {
		return x.RepBytes
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*OneofStdTypes) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*OneofStdTypes_Timestamp)(nil),
		(*OneofStdTypes_Duration)(nil),
		(*OneofStdTypes_RepDouble)(nil),
		(*OneofStdTypes_RepFloat)(nil),
		(*OneofStdTypes_RepInt64)(nil),
		(*OneofStdTypes_RepUInt64)(nil),
		(*OneofStdTypes_RepInt32)(nil),
		(*OneofStdTypes_RepUInt32)(nil),
		(*OneofStdTypes_RepBool)(nil),
		(*OneofStdTypes_RepString)(nil),
		(*OneofStdTypes_RepBytes)(nil),
	}
}

func init() {
	proto.RegisterType((*KnownTypes)(nil), "types.KnownTypes")
	proto.RegisterType((*ProtoTypes)(nil), "types.ProtoTypes")
	proto.RegisterType((*StdTypes)(nil), "types.StdTypes")
	proto.RegisterType((*RepProtoTypes)(nil), "types.RepProtoTypes")
	proto.RegisterType((*RepStdTypes)(nil), "types.RepStdTypes")
	proto.RegisterType((*MapProtoTypes)(nil), "types.MapProtoTypes")
	proto.RegisterMapType((map[int32]types.Duration)(nil), "types.MapProtoTypes.DurationEntry")
	proto.RegisterMapType((map[int32]types.BoolValue)(nil), "types.MapProtoTypes.NonnullBoolEntry")
	proto.RegisterMapType((map[int32]types.BytesValue)(nil), "types.MapProtoTypes.NonnullBytesEntry")
	proto.RegisterMapType((map[int32]types.DoubleValue)(nil), "types.MapProtoTypes.NonnullDoubleEntry")
	proto.RegisterMapType((map[int32]types.FloatValue)(nil), "types.MapProtoTypes.NonnullFloatEntry")
	proto.RegisterMapType((map[int32]types.Int32Value)(nil), "types.MapProtoTypes.NonnullInt32Entry")
	proto.RegisterMapType((map[int32]types.Int64Value)(nil), "types.MapProtoTypes.NonnullInt64Entry")
	proto.RegisterMapType((map[int32]types.StringValue)(nil), "types.MapProtoTypes.NonnullStringEntry")
	proto.RegisterMapType((map[int32]types.UInt32Value)(nil), "types.MapProtoTypes.NonnullUInt32Entry")
	proto.RegisterMapType((map[int32]types.UInt64Value)(nil), "types.MapProtoTypes.NonnullUInt64Entry")
	proto.RegisterMapType((map[int32]*types.BoolValue)(nil), "types.MapProtoTypes.NullableBoolEntry")
	proto.RegisterMapType((map[int32]*types.BytesValue)(nil), "types.MapProtoTypes.NullableBytesEntry")
	proto.RegisterMapType((map[int32]*types.DoubleValue)(nil), "types.MapProtoTypes.NullableDoubleEntry")
	proto.RegisterMapType((map[int32]*types.Duration)(nil), "types.MapProtoTypes.NullableDurationEntry")
	proto.RegisterMapType((map[int32]*types.FloatValue)(nil), "types.MapProtoTypes.NullableFloatEntry")
	proto.RegisterMapType((map[int32]*types.Int32Value)(nil), "types.MapProtoTypes.NullableInt32Entry")
	proto.RegisterMapType((map[int32]*types.Int64Value)(nil), "types.MapProtoTypes.NullableInt64Entry")
	proto.RegisterMapType((map[int32]*types.StringValue)(nil), "types.MapProtoTypes.NullableStringEntry")
	proto.RegisterMapType((map[int32]*types.Timestamp)(nil), "types.MapProtoTypes.NullableTimestampEntry")
	proto.RegisterMapType((map[int32]*types.UInt32Value)(nil), "types.MapProtoTypes.NullableUInt32Entry")
	proto.RegisterMapType((map[int32]*types.UInt64Value)(nil), "types.MapProtoTypes.NullableUInt64Entry")
	proto.RegisterMapType((map[int32]types.Timestamp)(nil), "types.MapProtoTypes.TimestampEntry")
	proto.RegisterType((*MapStdTypes)(nil), "types.MapStdTypes")
	proto.RegisterMapType((map[int32]time.Duration)(nil), "types.MapStdTypes.DurationEntry")
	proto.RegisterMapType((map[int32]bool)(nil), "types.MapStdTypes.NonnullBoolEntry")
	proto.RegisterMapType((map[int32][]byte)(nil), "types.MapStdTypes.NonnullBytesEntry")
	proto.RegisterMapType((map[int32]float64)(nil), "types.MapStdTypes.NonnullDoubleEntry")
	proto.RegisterMapType((map[int32]float32)(nil), "types.MapStdTypes.NonnullFloatEntry")
	proto.RegisterMapType((map[int32]int32)(nil), "types.MapStdTypes.NonnullInt32Entry")
	proto.RegisterMapType((map[int32]int64)(nil), "types.MapStdTypes.NonnullInt64Entry")
	proto.RegisterMapType((map[int32]string)(nil), "types.MapStdTypes.NonnullStringEntry")
	proto.RegisterMapType((map[int32]uint32)(nil), "types.MapStdTypes.NonnullUInt32Entry")
	proto.RegisterMapType((map[int32]uint64)(nil), "types.MapStdTypes.NonnullUInt64Entry")
	proto.RegisterMapType((map[int32]*bool)(nil), "types.MapStdTypes.NullableBoolEntry")
	proto.RegisterMapType((map[int32]*[]byte)(nil), "types.MapStdTypes.NullableBytesEntry")
	proto.RegisterMapType((map[int32]*float64)(nil), "types.MapStdTypes.NullableDoubleEntry")
	proto.RegisterMapType((map[int32]*time.Duration)(nil), "types.MapStdTypes.NullableDurationEntry")
	proto.RegisterMapType((map[int32]*float32)(nil), "types.MapStdTypes.NullableFloatEntry")
	proto.RegisterMapType((map[int32]*int32)(nil), "types.MapStdTypes.NullableInt32Entry")
	proto.RegisterMapType((map[int32]*int64)(nil), "types.MapStdTypes.NullableInt64Entry")
	proto.RegisterMapType((map[int32]*string)(nil), "types.MapStdTypes.NullableStringEntry")
	proto.RegisterMapType((map[int32]*time.Time)(nil), "types.MapStdTypes.NullableTimestampEntry")
	proto.RegisterMapType((map[int32]*uint32)(nil), "types.MapStdTypes.NullableUInt32Entry")
	proto.RegisterMapType((map[int32]*uint64)(nil), "types.MapStdTypes.NullableUInt64Entry")
	proto.RegisterMapType((map[int32]time.Time)(nil), "types.MapStdTypes.TimestampEntry")
	proto.RegisterType((*OneofProtoTypes)(nil), "types.OneofProtoTypes")
	proto.RegisterType((*OneofStdTypes)(nil), "types.OneofStdTypes")
}

func init() { proto.RegisterFile("combos/both/types.proto", fileDescriptor_54557d2dac6675e4) }

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

func (this *KnownTypes) Compare(that interface{}) int {
	if that == nil {
		if this == nil {
			return 0
		}
		return 1
	}

	that1, ok := that.(*KnownTypes)
	if !ok {
		that2, ok := that.(KnownTypes)
		if ok {
			that1 = &that2
		} else {
			return 1
		}
	}
	if that1 == nil {
		if this == nil {
			return 0
		}
		return 1
	} else if this == nil {
		return -1
	}
	if c := this.Dur.Compare(that1.Dur); c != 0 {
		return c
	}
	if c := this.Ts.Compare(that1.Ts); c != 0 {
		return c
	}
	if c := this.Dbl.Compare(that1.Dbl); c != 0 {
		return c
	}
	if c := this.Flt.Compare(that1.Flt); c != 0 {
		return c
	}
	if c := this.I64.Compare(that1.I64); c != 0 {
		return c
	}
	if c := this.U64.Compare(that1.U64); c != 0 {
		return c
	}
	if c := this.I32.Compare(that1.I32); c != 0 {
		return c
	}
	if c := this.U32.Compare(that1.U32); c != 0 {
		return c
	}
	if c := this.Bool.Compare(that1.Bool); c != 0 {
		return c
	}
	if c := this.Str.Compare(that1.Str); c != 0 {
		return c
	}
	if c := this.Bytes.Compare(that1.Bytes); c != 0 {
		return c
	}
	if c := this.St.Compare(that1.St); c != 0 {
		return c
	}
	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
		return c
	}
	return 0
}
func (this *ProtoTypes) Compare(that interface{}) int {
	if that == nil {
		if this == nil {
			return 0
		}
		return 1
	}

	that1, ok := that.(*ProtoTypes)
	if !ok {
		that2, ok := that.(ProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return 1
		}
	}
	if that1 == nil {
		if this == nil {
			return 0
		}
		return 1
	} else if this == nil {
		return -1
	}
	if c := this.NullableTimestamp.Compare(that1.NullableTimestamp); c != 0 {
		return c
	}
	if c := this.NullableDuration.Compare(that1.NullableDuration); c != 0 {
		return c
	}
	if c := this.NullableDouble.Compare(that1.NullableDouble); c != 0 {
		return c
	}
	if c := this.NullableFloat.Compare(that1.NullableFloat); c != 0 {
		return c
	}
	if c := this.NullableInt64.Compare(that1.NullableInt64); c != 0 {
		return c
	}
	if c := this.NullableUInt64.Compare(that1.NullableUInt64); c != 0 {
		return c
	}
	if c := this.NullableInt32.Compare(that1.NullableInt32); c != 0 {
		return c
	}
	if c := this.NullableUInt32.Compare(that1.NullableUInt32); c != 0 {
		return c
	}
	if c := this.NullableBool.Compare(that1.NullableBool); c != 0 {
		return c
	}
	if c := this.NullableString.Compare(that1.NullableString); c != 0 {
		return c
	}
	if c := this.NullableBytes.Compare(that1.NullableBytes); c != 0 {
		return c
	}
	if c := this.Timestamp.Compare(&that1.Timestamp); c != 0 {
		return c
	}
	if c := this.Duration.Compare(&that1.Duration); c != 0 {
		return c
	}
	if c := this.NonnullDouble.Compare(&that1.NonnullDouble); c != 0 {
		return c
	}
	if c := this.NonnullFloat.Compare(&that1.NonnullFloat); c != 0 {
		return c
	}
	if c := this.NonnullInt64.Compare(&that1.NonnullInt64); c != 0 {
		return c
	}
	if c := this.NonnullUInt64.Compare(&that1.NonnullUInt64); c != 0 {
		return c
	}
	if c := this.NonnullInt32.Compare(&that1.NonnullInt32); c != 0 {
		return c
	}
	if c := this.NonnullUInt32.Compare(&that1.NonnullUInt32); c != 0 {
		return c
	}
	if c := this.NonnullBool.Compare(&that1.NonnullBool); c != 0 {
		return c
	}
	if c := this.NonnullString.Compare(&that1.NonnullString); c != 0 {
		return c
	}
	if c := this.NonnullBytes.Compare(&that1.NonnullBytes); c != 0 {
		return c
	}
	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
		return c
	}
	return 0
}
func (this *RepProtoTypes) Compare(that interface{}) int {
	if that == nil {
		if this == nil {
			return 0
		}
		return 1
	}

	that1, ok := that.(*RepProtoTypes)
	if !ok {
		that2, ok := that.(RepProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return 1
		}
	}
	if that1 == nil {
		if this == nil {
			return 0
		}
		return 1
	} else if this == nil {
		return -1
	}
	if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
		if len(this.NullableTimestamps) < len(that1.NullableTimestamps) {
			return -1
		}
		return 1
	}
	for i := range this.NullableTimestamps {
		if c := this.NullableTimestamps[i].Compare(that1.NullableTimestamps[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableDurations) != len(that1.NullableDurations) {
		if len(this.NullableDurations) < len(that1.NullableDurations) {
			return -1
		}
		return 1
	}
	for i := range this.NullableDurations {
		if c := this.NullableDurations[i].Compare(that1.NullableDurations[i]); c != 0 {
			return c
		}
	}
	if len(this.Timestamps) != len(that1.Timestamps) {
		if len(this.Timestamps) < len(that1.Timestamps) {
			return -1
		}
		return 1
	}
	for i := range this.Timestamps {
		if c := this.Timestamps[i].Compare(&that1.Timestamps[i]); c != 0 {
			return c
		}
	}
	if len(this.Durations) != len(that1.Durations) {
		if len(this.Durations) < len(that1.Durations) {
			return -1
		}
		return 1
	}
	for i := range this.Durations {
		if c := this.Durations[i].Compare(&that1.Durations[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableDouble) != len(that1.NullableDouble) {
		if len(this.NullableDouble) < len(that1.NullableDouble) {
			return -1
		}
		return 1
	}
	for i := range this.NullableDouble {
		if c := this.NullableDouble[i].Compare(that1.NullableDouble[i]); c != 0 {
			return c
		}
	}
	if len(this.NonnullDouble) != len(that1.NonnullDouble) {
		if len(this.NonnullDouble) < len(that1.NonnullDouble) {
			return -1
		}
		return 1
	}
	for i := range this.NonnullDouble {
		if c := this.NonnullDouble[i].Compare(&that1.NonnullDouble[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableFloat) != len(that1.NullableFloat) {
		if len(this.NullableFloat) < len(that1.NullableFloat) {
			return -1
		}
		return 1
	}
	for i := range this.NullableFloat {
		if c := this.NullableFloat[i].Compare(that1.NullableFloat[i]); c != 0 {
			return c
		}
	}
	if len(this.NonnullFloat) != len(that1.NonnullFloat) {
		if len(this.NonnullFloat) < len(that1.NonnullFloat) {
			return -1
		}
		return 1
	}
	for i := range this.NonnullFloat {
		if c := this.NonnullFloat[i].Compare(&that1.NonnullFloat[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableInt64) != len(that1.NullableInt64) {
		if len(this.NullableInt64) < len(that1.NullableInt64) {
			return -1
		}
		return 1
	}
	for i := range this.NullableInt64 {
		if c := this.NullableInt64[i].Compare(that1.NullableInt64[i]); c != 0 {
			return c
		}
	}
	if len(this.NonnullInt64) != len(that1.NonnullInt64) {
		if len(this.NonnullInt64) < len(that1.NonnullInt64) {
			return -1
		}
		return 1
	}
	for i := range this.NonnullInt64 {
		if c := this.NonnullInt64[i].Compare(&that1.NonnullInt64[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableUInt64) != len(that1.NullableUInt64) {
		if len(this.NullableUInt64) < len(that1.NullableUInt64) {
			return -1
		}
		return 1
	}
	for i := range this.NullableUInt64 {
		if c := this.NullableUInt64[i].Compare(that1.NullableUInt64[i]); c != 0 {
			return c
		}
	}
	if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
		if len(this.NonnullUInt64) < len(that1.NonnullUInt64) {
			return -1
		}
		return 1
	}
	for i := range this.NonnullUInt64 {
		if c := this.NonnullUInt64[i].Compare(&that1.NonnullUInt64[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableInt32) != len(that1.NullableInt32) {
		if len(this.NullableInt32) < len(that1.NullableInt32) {
			return -1
		}
		return 1
	}
	for i := range this.NullableInt32 {
		if c := this.NullableInt32[i].Compare(that1.NullableInt32[i]); c != 0 {
			return c
		}
	}
	if len(this.NonnullInt32) != len(that1.NonnullInt32) {
		if len(this.NonnullInt32) < len(that1.NonnullInt32) {
			return -1
		}
		return 1
	}
	for i := range this.NonnullInt32 {
		if c := this.NonnullInt32[i].Compare(&that1.NonnullInt32[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableUInt32) != len(that1.NullableUInt32) {
		if len(this.NullableUInt32) < len(that1.NullableUInt32) {
			return -1
		}
		return 1
	}
	for i := range this.NullableUInt32 {
		if c := this.NullableUInt32[i].Compare(that1.NullableUInt32[i]); c != 0 {
			return c
		}
	}
	if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
		if len(this.NonnullUInt32) < len(that1.NonnullUInt32) {
			return -1
		}
		return 1
	}
	for i := range this.NonnullUInt32 {
		if c := this.NonnullUInt32[i].Compare(&that1.NonnullUInt32[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableBool) != len(that1.NullableBool) {
		if len(this.NullableBool) < len(that1.NullableBool) {
			return -1
		}
		return 1
	}
	for i := range this.NullableBool {
		if c := this.NullableBool[i].Compare(that1.NullableBool[i]); c != 0 {
			return c
		}
	}
	if len(this.NonnullBool) != len(that1.NonnullBool) {
		if len(this.NonnullBool) < len(that1.NonnullBool) {
			return -1
		}
		return 1
	}
	for i := range this.NonnullBool {
		if c := this.NonnullBool[i].Compare(&that1.NonnullBool[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableString) != len(that1.NullableString) {
		if len(this.NullableString) < len(that1.NullableString) {
			return -1
		}
		return 1
	}
	for i := range this.NullableString {
		if c := this.NullableString[i].Compare(that1.NullableString[i]); c != 0 {
			return c
		}
	}
	if len(this.NonnullString) != len(that1.NonnullString) {
		if len(this.NonnullString) < len(that1.NonnullString) {
			return -1
		}
		return 1
	}
	for i := range this.NonnullString {
		if c := this.NonnullString[i].Compare(&that1.NonnullString[i]); c != 0 {
			return c
		}
	}
	if len(this.NullableBytes) != len(that1.NullableBytes) {
		if len(this.NullableBytes) < len(that1.NullableBytes) {
			return -1
		}
		return 1
	}
	for i := range this.NullableBytes {
		if c := this.NullableBytes[i].Compare(that1.NullableBytes[i]); c != 0 {
			return c
		}
	}
	if len(this.NonnullBytes) != len(that1.NonnullBytes) {
		if len(this.NonnullBytes) < len(that1.NonnullBytes) {
			return -1
		}
		return 1
	}
	for i := range this.NonnullBytes {
		if c := this.NonnullBytes[i].Compare(&that1.NonnullBytes[i]); c != 0 {
			return c
		}
	}
	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
		return c
	}
	return 0
}
func (this *KnownTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*KnownTypes)
	if !ok {
		that2, ok := that.(KnownTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *KnownTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *KnownTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *KnownTypes but is not nil && this == nil")
	}
	if !this.Dur.Equal(that1.Dur) {
		return fmt.Errorf("Dur this(%v) Not Equal that(%v)", this.Dur, that1.Dur)
	}
	if !this.Ts.Equal(that1.Ts) {
		return fmt.Errorf("Ts this(%v) Not Equal that(%v)", this.Ts, that1.Ts)
	}
	if !this.Dbl.Equal(that1.Dbl) {
		return fmt.Errorf("Dbl this(%v) Not Equal that(%v)", this.Dbl, that1.Dbl)
	}
	if !this.Flt.Equal(that1.Flt) {
		return fmt.Errorf("Flt this(%v) Not Equal that(%v)", this.Flt, that1.Flt)
	}
	if !this.I64.Equal(that1.I64) {
		return fmt.Errorf("I64 this(%v) Not Equal that(%v)", this.I64, that1.I64)
	}
	if !this.U64.Equal(that1.U64) {
		return fmt.Errorf("U64 this(%v) Not Equal that(%v)", this.U64, that1.U64)
	}
	if !this.I32.Equal(that1.I32) {
		return fmt.Errorf("I32 this(%v) Not Equal that(%v)", this.I32, that1.I32)
	}
	if !this.U32.Equal(that1.U32) {
		return fmt.Errorf("U32 this(%v) Not Equal that(%v)", this.U32, that1.U32)
	}
	if !this.Bool.Equal(that1.Bool) {
		return fmt.Errorf("Bool this(%v) Not Equal that(%v)", this.Bool, that1.Bool)
	}
	if !this.Str.Equal(that1.Str) {
		return fmt.Errorf("Str this(%v) Not Equal that(%v)", this.Str, that1.Str)
	}
	if !this.Bytes.Equal(that1.Bytes) {
		return fmt.Errorf("Bytes this(%v) Not Equal that(%v)", this.Bytes, that1.Bytes)
	}
	if !this.St.Equal(that1.St) {
		return fmt.Errorf("St this(%v) Not Equal that(%v)", this.St, that1.St)
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *KnownTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*KnownTypes)
	if !ok {
		that2, ok := that.(KnownTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Dur.Equal(that1.Dur) {
		return false
	}
	if !this.Ts.Equal(that1.Ts) {
		return false
	}
	if !this.Dbl.Equal(that1.Dbl) {
		return false
	}
	if !this.Flt.Equal(that1.Flt) {
		return false
	}
	if !this.I64.Equal(that1.I64) {
		return false
	}
	if !this.U64.Equal(that1.U64) {
		return false
	}
	if !this.I32.Equal(that1.I32) {
		return false
	}
	if !this.U32.Equal(that1.U32) {
		return false
	}
	if !this.Bool.Equal(that1.Bool) {
		return false
	}
	if !this.Str.Equal(that1.Str) {
		return false
	}
	if !this.Bytes.Equal(that1.Bytes) {
		return false
	}
	if !this.St.Equal(that1.St) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *ProtoTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ProtoTypes)
	if !ok {
		that2, ok := that.(ProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *ProtoTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ProtoTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ProtoTypes but is not nil && this == nil")
	}
	if !this.NullableTimestamp.Equal(that1.NullableTimestamp) {
		return fmt.Errorf("NullableTimestamp this(%v) Not Equal that(%v)", this.NullableTimestamp, that1.NullableTimestamp)
	}
	if !this.NullableDuration.Equal(that1.NullableDuration) {
		return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", this.NullableDuration, that1.NullableDuration)
	}
	if !this.NullableDouble.Equal(that1.NullableDouble) {
		return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", this.NullableDouble, that1.NullableDouble)
	}
	if !this.NullableFloat.Equal(that1.NullableFloat) {
		return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", this.NullableFloat, that1.NullableFloat)
	}
	if !this.NullableInt64.Equal(that1.NullableInt64) {
		return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", this.NullableInt64, that1.NullableInt64)
	}
	if !this.NullableUInt64.Equal(that1.NullableUInt64) {
		return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", this.NullableUInt64, that1.NullableUInt64)
	}
	if !this.NullableInt32.Equal(that1.NullableInt32) {
		return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", this.NullableInt32, that1.NullableInt32)
	}
	if !this.NullableUInt32.Equal(that1.NullableUInt32) {
		return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", this.NullableUInt32, that1.NullableUInt32)
	}
	if !this.NullableBool.Equal(that1.NullableBool) {
		return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", this.NullableBool, that1.NullableBool)
	}
	if !this.NullableString.Equal(that1.NullableString) {
		return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", this.NullableString, that1.NullableString)
	}
	if !this.NullableBytes.Equal(that1.NullableBytes) {
		return fmt.Errorf("NullableBytes this(%v) Not Equal that(%v)", this.NullableBytes, that1.NullableBytes)
	}
	if !this.Timestamp.Equal(&that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", this.Timestamp, that1.Timestamp)
	}
	if !this.Duration.Equal(&that1.Duration) {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
	}
	if !this.NonnullDouble.Equal(&that1.NonnullDouble) {
		return fmt.Errorf("NonnullDouble this(%v) Not Equal that(%v)", this.NonnullDouble, that1.NonnullDouble)
	}
	if !this.NonnullFloat.Equal(&that1.NonnullFloat) {
		return fmt.Errorf("NonnullFloat this(%v) Not Equal that(%v)", this.NonnullFloat, that1.NonnullFloat)
	}
	if !this.NonnullInt64.Equal(&that1.NonnullInt64) {
		return fmt.Errorf("NonnullInt64 this(%v) Not Equal that(%v)", this.NonnullInt64, that1.NonnullInt64)
	}
	if !this.NonnullUInt64.Equal(&that1.NonnullUInt64) {
		return fmt.Errorf("NonnullUInt64 this(%v) Not Equal that(%v)", this.NonnullUInt64, that1.NonnullUInt64)
	}
	if !this.NonnullInt32.Equal(&that1.NonnullInt32) {
		return fmt.Errorf("NonnullInt32 this(%v) Not Equal that(%v)", this.NonnullInt32, that1.NonnullInt32)
	}
	if !this.NonnullUInt32.Equal(&that1.NonnullUInt32) {
		return fmt.Errorf("NonnullUInt32 this(%v) Not Equal that(%v)", this.NonnullUInt32, that1.NonnullUInt32)
	}
	if !this.NonnullBool.Equal(&that1.NonnullBool) {
		return fmt.Errorf("NonnullBool this(%v) Not Equal that(%v)", this.NonnullBool, that1.NonnullBool)
	}
	if !this.NonnullString.Equal(&that1.NonnullString) {
		return fmt.Errorf("NonnullString this(%v) Not Equal that(%v)", this.NonnullString, that1.NonnullString)
	}
	if !this.NonnullBytes.Equal(&that1.NonnullBytes) {
		return fmt.Errorf("NonnullBytes this(%v) Not Equal that(%v)", this.NonnullBytes, that1.NonnullBytes)
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *ProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ProtoTypes)
	if !ok {
		that2, ok := that.(ProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.NullableTimestamp.Equal(that1.NullableTimestamp) {
		return false
	}
	if !this.NullableDuration.Equal(that1.NullableDuration) {
		return false
	}
	if !this.NullableDouble.Equal(that1.NullableDouble) {
		return false
	}
	if !this.NullableFloat.Equal(that1.NullableFloat) {
		return false
	}
	if !this.NullableInt64.Equal(that1.NullableInt64) {
		return false
	}
	if !this.NullableUInt64.Equal(that1.NullableUInt64) {
		return false
	}
	if !this.NullableInt32.Equal(that1.NullableInt32) {
		return false
	}
	if !this.NullableUInt32.Equal(that1.NullableUInt32) {
		return false
	}
	if !this.NullableBool.Equal(that1.NullableBool) {
		return false
	}
	if !this.NullableString.Equal(that1.NullableString) {
		return false
	}
	if !this.NullableBytes.Equal(that1.NullableBytes) {
		return false
	}
	if !this.Timestamp.Equal(&that1.Timestamp) {
		return false
	}
	if !this.Duration.Equal(&that1.Duration) {
		return false
	}
	if !this.NonnullDouble.Equal(&that1.NonnullDouble) {
		return false
	}
	if !this.NonnullFloat.Equal(&that1.NonnullFloat) {
		return false
	}
	if !this.NonnullInt64.Equal(&that1.NonnullInt64) {
		return false
	}
	if !this.NonnullUInt64.Equal(&that1.NonnullUInt64) {
		return false
	}
	if !this.NonnullInt32.Equal(&that1.NonnullInt32) {
		return false
	}
	if !this.NonnullUInt32.Equal(&that1.NonnullUInt32) {
		return false
	}
	if !this.NonnullBool.Equal(&that1.NonnullBool) {
		return false
	}
	if !this.NonnullString.Equal(&that1.NonnullString) {
		return false
	}
	if !this.NonnullBytes.Equal(&that1.NonnullBytes) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *StdTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StdTypes)
	if !ok {
		that2, ok := that.(StdTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StdTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StdTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StdTypes but is not nil && this == nil")
	}
	if that1.NullableTimestamp == nil {
		if this.NullableTimestamp != nil {
			return fmt.Errorf("this.NullableTimestamp != nil && that1.NullableTimestamp == nil")
		}
	} else if !this.NullableTimestamp.Equal(*that1.NullableTimestamp) {
		return fmt.Errorf("NullableTimestamp this(%v) Not Equal that(%v)", this.NullableTimestamp, that1.NullableTimestamp)
	}
	if this.NullableDuration != nil && that1.NullableDuration != nil {
		if *this.NullableDuration != *that1.NullableDuration {
			return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", *this.NullableDuration, *that1.NullableDuration)
		}
	} else if this.NullableDuration != nil {
		return fmt.Errorf("this.NullableDuration == nil && that.NullableDuration != nil")
	} else if that1.NullableDuration != nil {
		return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", this.NullableDuration, that1.NullableDuration)
	}
	if this.NullableDouble != nil && that1.NullableDouble != nil {
		if *this.NullableDouble != *that1.NullableDouble {
			return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", *this.NullableDouble, *that1.NullableDouble)
		}
	} else if this.NullableDouble != nil {
		return fmt.Errorf("this.NullableDouble == nil && that.NullableDouble != nil")
	} else if that1.NullableDouble != nil {
		return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", this.NullableDouble, that1.NullableDouble)
	}
	if this.NullableFloat != nil && that1.NullableFloat != nil {
		if *this.NullableFloat != *that1.NullableFloat {
			return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", *this.NullableFloat, *that1.NullableFloat)
		}
	} else if this.NullableFloat != nil {
		return fmt.Errorf("this.NullableFloat == nil && that.NullableFloat != nil")
	} else if that1.NullableFloat != nil {
		return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", this.NullableFloat, that1.NullableFloat)
	}
	if this.NullableInt64 != nil && that1.NullableInt64 != nil {
		if *this.NullableInt64 != *that1.NullableInt64 {
			return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", *this.NullableInt64, *that1.NullableInt64)
		}
	} else if this.NullableInt64 != nil {
		return fmt.Errorf("this.NullableInt64 == nil && that.NullableInt64 != nil")
	} else if that1.NullableInt64 != nil {
		return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", this.NullableInt64, that1.NullableInt64)
	}
	if this.NullableUInt64 != nil && that1.NullableUInt64 != nil {
		if *this.NullableUInt64 != *that1.NullableUInt64 {
			return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", *this.NullableUInt64, *that1.NullableUInt64)
		}
	} else if this.NullableUInt64 != nil {
		return fmt.Errorf("this.NullableUInt64 == nil && that.NullableUInt64 != nil")
	} else if that1.NullableUInt64 != nil {
		return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", this.NullableUInt64, that1.NullableUInt64)
	}
	if this.NullableInt32 != nil && that1.NullableInt32 != nil {
		if *this.NullableInt32 != *that1.NullableInt32 {
			return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", *this.NullableInt32, *that1.NullableInt32)
		}
	} else if this.NullableInt32 != nil {
		return fmt.Errorf("this.NullableInt32 == nil && that.NullableInt32 != nil")
	} else if that1.NullableInt32 != nil {
		return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", this.NullableInt32, that1.NullableInt32)
	}
	if this.NullableUInt32 != nil && that1.NullableUInt32 != nil {
		if *this.NullableUInt32 != *that1.NullableUInt32 {
			return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", *this.NullableUInt32, *that1.NullableUInt32)
		}
	} else if this.NullableUInt32 != nil {
		return fmt.Errorf("this.NullableUInt32 == nil && that.NullableUInt32 != nil")
	} else if that1.NullableUInt32 != nil {
		return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", this.NullableUInt32, that1.NullableUInt32)
	}
	if this.NullableBool != nil && that1.NullableBool != nil {
		if *this.NullableBool != *that1.NullableBool {
			return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", *this.NullableBool, *that1.NullableBool)
		}
	} else if this.NullableBool != nil {
		return fmt.Errorf("this.NullableBool == nil && that.NullableBool != nil")
	} else if that1.NullableBool != nil {
		return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", this.NullableBool, that1.NullableBool)
	}
	if this.NullableString != nil && that1.NullableString != nil {
		if *this.NullableString != *that1.NullableString {
			return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", *this.NullableString, *that1.NullableString)
		}
	} else if this.NullableString != nil {
		return fmt.Errorf("this.NullableString == nil && that.NullableString != nil")
	} else if that1.NullableString != nil {
		return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", this.NullableString, that1.NullableString)
	}
	if that1.NullableBytes == nil {
		if this.NullableBytes != nil {
			return fmt.Errorf("this.NullableBytes != nil && that1.NullableBytes == nil")
		}
	} else if !bytes.Equal(*this.NullableBytes, *that1.NullableBytes) {
		return fmt.Errorf("NullableBytes this(%v) Not Equal that(%v)", this.NullableBytes, that1.NullableBytes)
	}
	if !this.Timestamp.Equal(that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", this.Timestamp, that1.Timestamp)
	}
	if this.Duration != that1.Duration {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
	}
	if this.NonnullDouble != that1.NonnullDouble {
		return fmt.Errorf("NonnullDouble this(%v) Not Equal that(%v)", this.NonnullDouble, that1.NonnullDouble)
	}
	if this.NonnullFloat != that1.NonnullFloat {
		return fmt.Errorf("NonnullFloat this(%v) Not Equal that(%v)", this.NonnullFloat, that1.NonnullFloat)
	}
	if this.NonnullInt64 != that1.NonnullInt64 {
		return fmt.Errorf("NonnullInt64 this(%v) Not Equal that(%v)", this.NonnullInt64, that1.NonnullInt64)
	}
	if this.NonnullUInt64 != that1.NonnullUInt64 {
		return fmt.Errorf("NonnullUInt64 this(%v) Not Equal that(%v)", this.NonnullUInt64, that1.NonnullUInt64)
	}
	if this.NonnullInt32 != that1.NonnullInt32 {
		return fmt.Errorf("NonnullInt32 this(%v) Not Equal that(%v)", this.NonnullInt32, that1.NonnullInt32)
	}
	if this.NonnullUInt32 != that1.NonnullUInt32 {
		return fmt.Errorf("NonnullUInt32 this(%v) Not Equal that(%v)", this.NonnullUInt32, that1.NonnullUInt32)
	}
	if this.NonnullBool != that1.NonnullBool {
		return fmt.Errorf("NonnullBool this(%v) Not Equal that(%v)", this.NonnullBool, that1.NonnullBool)
	}
	if this.NonnullString != that1.NonnullString {
		return fmt.Errorf("NonnullString this(%v) Not Equal that(%v)", this.NonnullString, that1.NonnullString)
	}
	if !bytes.Equal(this.NonnullBytes, that1.NonnullBytes) {
		return fmt.Errorf("NonnullBytes this(%v) Not Equal that(%v)", this.NonnullBytes, that1.NonnullBytes)
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *StdTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*StdTypes)
	if !ok {
		that2, ok := that.(StdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.NullableTimestamp == nil {
		if this.NullableTimestamp != nil {
			return false
		}
	} else if !this.NullableTimestamp.Equal(*that1.NullableTimestamp) {
		return false
	}
	if this.NullableDuration != nil && that1.NullableDuration != nil {
		if *this.NullableDuration != *that1.NullableDuration {
			return false
		}
	} else if this.NullableDuration != nil {
		return false
	} else if that1.NullableDuration != nil {
		return false
	}
	if this.NullableDouble != nil && that1.NullableDouble != nil {
		if *this.NullableDouble != *that1.NullableDouble {
			return false
		}
	} else if this.NullableDouble != nil {
		return false
	} else if that1.NullableDouble != nil {
		return false
	}
	if this.NullableFloat != nil && that1.NullableFloat != nil {
		if *this.NullableFloat != *that1.NullableFloat {
			return false
		}
	} else if this.NullableFloat != nil {
		return false
	} else if that1.NullableFloat != nil {
		return false
	}
	if this.NullableInt64 != nil && that1.NullableInt64 != nil {
		if *this.NullableInt64 != *that1.NullableInt64 {
			return false
		}
	} else if this.NullableInt64 != nil {
		return false
	} else if that1.NullableInt64 != nil {
		return false
	}
	if this.NullableUInt64 != nil && that1.NullableUInt64 != nil {
		if *this.NullableUInt64 != *that1.NullableUInt64 {
			return false
		}
	} else if this.NullableUInt64 != nil {
		return false
	} else if that1.NullableUInt64 != nil {
		return false
	}
	if this.NullableInt32 != nil && that1.NullableInt32 != nil {
		if *this.NullableInt32 != *that1.NullableInt32 {
			return false
		}
	} else if this.NullableInt32 != nil {
		return false
	} else if that1.NullableInt32 != nil {
		return false
	}
	if this.NullableUInt32 != nil && that1.NullableUInt32 != nil {
		if *this.NullableUInt32 != *that1.NullableUInt32 {
			return false
		}
	} else if this.NullableUInt32 != nil {
		return false
	} else if that1.NullableUInt32 != nil {
		return false
	}
	if this.NullableBool != nil && that1.NullableBool != nil {
		if *this.NullableBool != *that1.NullableBool {
			return false
		}
	} else if this.NullableBool != nil {
		return false
	} else if that1.NullableBool != nil {
		return false
	}
	if this.NullableString != nil && that1.NullableString != nil {
		if *this.NullableString != *that1.NullableString {
			return false
		}
	} else if this.NullableString != nil {
		return false
	} else if that1.NullableString != nil {
		return false
	}
	if that1.NullableBytes == nil {
		if this.NullableBytes != nil {
			return false
		}
	} else if !bytes.Equal(*this.NullableBytes, *that1.NullableBytes) {
		return false
	}
	if !this.Timestamp.Equal(that1.Timestamp) {
		return false
	}
	if this.Duration != that1.Duration {
		return false
	}
	if this.NonnullDouble != that1.NonnullDouble {
		return false
	}
	if this.NonnullFloat != that1.NonnullFloat {
		return false
	}
	if this.NonnullInt64 != that1.NonnullInt64 {
		return false
	}
	if this.NonnullUInt64 != that1.NonnullUInt64 {
		return false
	}
	if this.NonnullInt32 != that1.NonnullInt32 {
		return false
	}
	if this.NonnullUInt32 != that1.NonnullUInt32 {
		return false
	}
	if this.NonnullBool != that1.NonnullBool {
		return false
	}
	if this.NonnullString != that1.NonnullString {
		return false
	}
	if !bytes.Equal(this.NonnullBytes, that1.NonnullBytes) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *RepProtoTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*RepProtoTypes)
	if !ok {
		that2, ok := that.(RepProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *RepProtoTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *RepProtoTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *RepProtoTypes but is not nil && this == nil")
	}
	if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
		return fmt.Errorf("NullableTimestamps this(%v) Not Equal that(%v)", len(this.NullableTimestamps), len(that1.NullableTimestamps))
	}
	for i := range this.NullableTimestamps {
		if !this.NullableTimestamps[i].Equal(that1.NullableTimestamps[i]) {
			return fmt.Errorf("NullableTimestamps this[%v](%v) Not Equal that[%v](%v)", i, this.NullableTimestamps[i], i, that1.NullableTimestamps[i])
		}
	}
	if len(this.NullableDurations) != len(that1.NullableDurations) {
		return fmt.Errorf("NullableDurations this(%v) Not Equal that(%v)", len(this.NullableDurations), len(that1.NullableDurations))
	}
	for i := range this.NullableDurations {
		if !this.NullableDurations[i].Equal(that1.NullableDurations[i]) {
			return fmt.Errorf("NullableDurations this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDurations[i], i, that1.NullableDurations[i])
		}
	}
	if len(this.Timestamps) != len(that1.Timestamps) {
		return fmt.Errorf("Timestamps this(%v) Not Equal that(%v)", len(this.Timestamps), len(that1.Timestamps))
	}
	for i := range this.Timestamps {
		if !this.Timestamps[i].Equal(&that1.Timestamps[i]) {
			return fmt.Errorf("Timestamps this[%v](%v) Not Equal that[%v](%v)", i, this.Timestamps[i], i, that1.Timestamps[i])
		}
	}
	if len(this.Durations) != len(that1.Durations) {
		return fmt.Errorf("Durations this(%v) Not Equal that(%v)", len(this.Durations), len(that1.Durations))
	}
	for i := range this.Durations {
		if !this.Durations[i].Equal(&that1.Durations[i]) {
			return fmt.Errorf("Durations this[%v](%v) Not Equal that[%v](%v)", i, this.Durations[i], i, that1.Durations[i])
		}
	}
	if len(this.NullableDouble) != len(that1.NullableDouble) {
		return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", len(this.NullableDouble), len(that1.NullableDouble))
	}
	for i := range this.NullableDouble {
		if !this.NullableDouble[i].Equal(that1.NullableDouble[i]) {
			return fmt.Errorf("NullableDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDouble[i], i, that1.NullableDouble[i])
		}
	}
	if len(this.NonnullDouble) != len(that1.NonnullDouble) {
		return fmt.Errorf("NonnullDouble this(%v) Not Equal that(%v)", len(this.NonnullDouble), len(that1.NonnullDouble))
	}
	for i := range this.NonnullDouble {
		if !this.NonnullDouble[i].Equal(&that1.NonnullDouble[i]) {
			return fmt.Errorf("NonnullDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullDouble[i], i, that1.NonnullDouble[i])
		}
	}
	if len(this.NullableFloat) != len(that1.NullableFloat) {
		return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", len(this.NullableFloat), len(that1.NullableFloat))
	}
	for i := range this.NullableFloat {
		if !this.NullableFloat[i].Equal(that1.NullableFloat[i]) {
			return fmt.Errorf("NullableFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NullableFloat[i], i, that1.NullableFloat[i])
		}
	}
	if len(this.NonnullFloat) != len(that1.NonnullFloat) {
		return fmt.Errorf("NonnullFloat this(%v) Not Equal that(%v)", len(this.NonnullFloat), len(that1.NonnullFloat))
	}
	for i := range this.NonnullFloat {
		if !this.NonnullFloat[i].Equal(&that1.NonnullFloat[i]) {
			return fmt.Errorf("NonnullFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullFloat[i], i, that1.NonnullFloat[i])
		}
	}
	if len(this.NullableInt64) != len(that1.NullableInt64) {
		return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", len(this.NullableInt64), len(that1.NullableInt64))
	}
	for i := range this.NullableInt64 {
		if !this.NullableInt64[i].Equal(that1.NullableInt64[i]) {
			return fmt.Errorf("NullableInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt64[i], i, that1.NullableInt64[i])
		}
	}
	if len(this.NonnullInt64) != len(that1.NonnullInt64) {
		return fmt.Errorf("NonnullInt64 this(%v) Not Equal that(%v)", len(this.NonnullInt64), len(that1.NonnullInt64))
	}
	for i := range this.NonnullInt64 {
		if !this.NonnullInt64[i].Equal(&that1.NonnullInt64[i]) {
			return fmt.Errorf("NonnullInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt64[i], i, that1.NonnullInt64[i])
		}
	}
	if len(this.NullableUInt64) != len(that1.NullableUInt64) {
		return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", len(this.NullableUInt64), len(that1.NullableUInt64))
	}
	for i := range this.NullableUInt64 {
		if !this.NullableUInt64[i].Equal(that1.NullableUInt64[i]) {
			return fmt.Errorf("NullableUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt64[i], i, that1.NullableUInt64[i])
		}
	}
	if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
		return fmt.Errorf("NonnullUInt64 this(%v) Not Equal that(%v)", len(this.NonnullUInt64), len(that1.NonnullUInt64))
	}
	for i := range this.NonnullUInt64 {
		if !this.NonnullUInt64[i].Equal(&that1.NonnullUInt64[i]) {
			return fmt.Errorf("NonnullUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt64[i], i, that1.NonnullUInt64[i])
		}
	}
	if len(this.NullableInt32) != len(that1.NullableInt32) {
		return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", len(this.NullableInt32), len(that1.NullableInt32))
	}
	for i := range this.NullableInt32 {
		if !this.NullableInt32[i].Equal(that1.NullableInt32[i]) {
			return fmt.Errorf("NullableInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt32[i], i, that1.NullableInt32[i])
		}
	}
	if len(this.NonnullInt32) != len(that1.NonnullInt32) {
		return fmt.Errorf("NonnullInt32 this(%v) Not Equal that(%v)", len(this.NonnullInt32), len(that1.NonnullInt32))
	}
	for i := range this.NonnullInt32 {
		if !this.NonnullInt32[i].Equal(&that1.NonnullInt32[i]) {
			return fmt.Errorf("NonnullInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt32[i], i, that1.NonnullInt32[i])
		}
	}
	if len(this.NullableUInt32) != len(that1.NullableUInt32) {
		return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", len(this.NullableUInt32), len(that1.NullableUInt32))
	}
	for i := range this.NullableUInt32 {
		if !this.NullableUInt32[i].Equal(that1.NullableUInt32[i]) {
			return fmt.Errorf("NullableUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt32[i], i, that1.NullableUInt32[i])
		}
	}
	if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
		return fmt.Errorf("NonnullUInt32 this(%v) Not Equal that(%v)", len(this.NonnullUInt32), len(that1.NonnullUInt32))
	}
	for i := range this.NonnullUInt32 {
		if !this.NonnullUInt32[i].Equal(&that1.NonnullUInt32[i]) {
			return fmt.Errorf("NonnullUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt32[i], i, that1.NonnullUInt32[i])
		}
	}
	if len(this.NullableBool) != len(that1.NullableBool) {
		return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", len(this.NullableBool), len(that1.NullableBool))
	}
	for i := range this.NullableBool {
		if !this.NullableBool[i].Equal(that1.NullableBool[i]) {
			return fmt.Errorf("NullableBool this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBool[i], i, that1.NullableBool[i])
		}
	}
	if len(this.NonnullBool) != len(that1.NonnullBool) {
		return fmt.Errorf("NonnullBool this(%v) Not Equal that(%v)", len(this.NonnullBool), len(that1.NonnullBool))
	}
	for i := range this.NonnullBool {
		if !this.NonnullBool[i].Equal(&that1.NonnullBool[i]) {
			return fmt.Errorf("NonnullBool this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBool[i], i, that1.NonnullBool[i])
		}
	}
	if len(this.NullableString) != len(that1.NullableString) {
		return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", len(this.NullableString), len(that1.NullableString))
	}
	for i := range this.NullableString {
		if !this.NullableString[i].Equal(that1.NullableString[i]) {
			return fmt.Errorf("NullableString this[%v](%v) Not Equal that[%v](%v)", i, this.NullableString[i], i, that1.NullableString[i])
		}
	}
	if len(this.NonnullString) != len(that1.NonnullString) {
		return fmt.Errorf("NonnullString this(%v) Not Equal that(%v)", len(this.NonnullString), len(that1.NonnullString))
	}
	for i := range this.NonnullString {
		if !this.NonnullString[i].Equal(&that1.NonnullString[i]) {
			return fmt.Errorf("NonnullString this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullString[i], i, that1.NonnullString[i])
		}
	}
	if len(this.NullableBytes) != len(that1.NullableBytes) {
		return fmt.Errorf("NullableBytes this(%v) Not Equal that(%v)", len(this.NullableBytes), len(that1.NullableBytes))
	}
	for i := range this.NullableBytes {
		if !this.NullableBytes[i].Equal(that1.NullableBytes[i]) {
			return fmt.Errorf("NullableBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBytes[i], i, that1.NullableBytes[i])
		}
	}
	if len(this.NonnullBytes) != len(that1.NonnullBytes) {
		return fmt.Errorf("NonnullBytes this(%v) Not Equal that(%v)", len(this.NonnullBytes), len(that1.NonnullBytes))
	}
	for i := range this.NonnullBytes {
		if !this.NonnullBytes[i].Equal(&that1.NonnullBytes[i]) {
			return fmt.Errorf("NonnullBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBytes[i], i, that1.NonnullBytes[i])
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *RepProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RepProtoTypes)
	if !ok {
		that2, ok := that.(RepProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
		return false
	}
	for i := range this.NullableTimestamps {
		if !this.NullableTimestamps[i].Equal(that1.NullableTimestamps[i]) {
			return false
		}
	}
	if len(this.NullableDurations) != len(that1.NullableDurations) {
		return false
	}
	for i := range this.NullableDurations {
		if !this.NullableDurations[i].Equal(that1.NullableDurations[i]) {
			return false
		}
	}
	if len(this.Timestamps) != len(that1.Timestamps) {
		return false
	}
	for i := range this.Timestamps {
		if !this.Timestamps[i].Equal(&that1.Timestamps[i]) {
			return false
		}
	}
	if len(this.Durations) != len(that1.Durations) {
		return false
	}
	for i := range this.Durations {
		if !this.Durations[i].Equal(&that1.Durations[i]) {
			return false
		}
	}
	if len(this.NullableDouble) != len(that1.NullableDouble) {
		return false
	}
	for i := range this.NullableDouble {
		if !this.NullableDouble[i].Equal(that1.NullableDouble[i]) {
			return false
		}
	}
	if len(this.NonnullDouble) != len(that1.NonnullDouble) {
		return false
	}
	for i := range this.NonnullDouble {
		if !this.NonnullDouble[i].Equal(&that1.NonnullDouble[i]) {
			return false
		}
	}
	if len(this.NullableFloat) != len(that1.NullableFloat) {
		return false
	}
	for i := range this.NullableFloat {
		if !this.NullableFloat[i].Equal(that1.NullableFloat[i]) {
			return false
		}
	}
	if len(this.NonnullFloat) != len(that1.NonnullFloat) {
		return false
	}
	for i := range this.NonnullFloat {
		if !this.NonnullFloat[i].Equal(&that1.NonnullFloat[i]) {
			return false
		}
	}
	if len(this.NullableInt64) != len(that1.NullableInt64) {
		return false
	}
	for i := range this.NullableInt64 {
		if !this.NullableInt64[i].Equal(that1.NullableInt64[i]) {
			return false
		}
	}
	if len(this.NonnullInt64) != len(that1.NonnullInt64) {
		return false
	}
	for i := range this.NonnullInt64 {
		if !this.NonnullInt64[i].Equal(&that1.NonnullInt64[i]) {
			return false
		}
	}
	if len(this.NullableUInt64) != len(that1.NullableUInt64) {
		return false
	}
	for i := range this.NullableUInt64 {
		if !this.NullableUInt64[i].Equal(that1.NullableUInt64[i]) {
			return false
		}
	}
	if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
		return false
	}
	for i := range this.NonnullUInt64 {
		if !this.NonnullUInt64[i].Equal(&that1.NonnullUInt64[i]) {
			return false
		}
	}
	if len(this.NullableInt32) != len(that1.NullableInt32) {
		return false
	}
	for i := range this.NullableInt32 {
		if !this.NullableInt32[i].Equal(that1.NullableInt32[i]) {
			return false
		}
	}
	if len(this.NonnullInt32) != len(that1.NonnullInt32) {
		return false
	}
	for i := range this.NonnullInt32 {
		if !this.NonnullInt32[i].Equal(&that1.NonnullInt32[i]) {
			return false
		}
	}
	if len(this.NullableUInt32) != len(that1.NullableUInt32) {
		return false
	}
	for i := range this.NullableUInt32 {
		if !this.NullableUInt32[i].Equal(that1.NullableUInt32[i]) {
			return false
		}
	}
	if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
		return false
	}
	for i := range this.NonnullUInt32 {
		if !this.NonnullUInt32[i].Equal(&that1.NonnullUInt32[i]) {
			return false
		}
	}
	if len(this.NullableBool) != len(that1.NullableBool) {
		return false
	}
	for i := range this.NullableBool {
		if !this.NullableBool[i].Equal(that1.NullableBool[i]) {
			return false
		}
	}
	if len(this.NonnullBool) != len(that1.NonnullBool) {
		return false
	}
	for i := range this.NonnullBool {
		if !this.NonnullBool[i].Equal(&that1.NonnullBool[i]) {
			return false
		}
	}
	if len(this.NullableString) != len(that1.NullableString) {
		return false
	}
	for i := range this.NullableString {
		if !this.NullableString[i].Equal(that1.NullableString[i]) {
			return false
		}
	}
	if len(this.NonnullString) != len(that1.NonnullString) {
		return false
	}
	for i := range this.NonnullString {
		if !this.NonnullString[i].Equal(&that1.NonnullString[i]) {
			return false
		}
	}
	if len(this.NullableBytes) != len(that1.NullableBytes) {
		return false
	}
	for i := range this.NullableBytes {
		if !this.NullableBytes[i].Equal(that1.NullableBytes[i]) {
			return false
		}
	}
	if len(this.NonnullBytes) != len(that1.NonnullBytes) {
		return false
	}
	for i := range this.NonnullBytes {
		if !this.NonnullBytes[i].Equal(&that1.NonnullBytes[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *RepStdTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*RepStdTypes)
	if !ok {
		that2, ok := that.(RepStdTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *RepStdTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *RepStdTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *RepStdTypes but is not nil && this == nil")
	}
	if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
		return fmt.Errorf("NullableTimestamps this(%v) Not Equal that(%v)", len(this.NullableTimestamps), len(that1.NullableTimestamps))
	}
	for i := range this.NullableTimestamps {
		if !this.NullableTimestamps[i].Equal(*that1.NullableTimestamps[i]) {
			return fmt.Errorf("NullableTimestamps this[%v](%v) Not Equal that[%v](%v)", i, this.NullableTimestamps[i], i, that1.NullableTimestamps[i])
		}
	}
	if len(this.NullableDurations) != len(that1.NullableDurations) {
		return fmt.Errorf("NullableDurations this(%v) Not Equal that(%v)", len(this.NullableDurations), len(that1.NullableDurations))
	}
	for i := range this.NullableDurations {
		if dthis, dthat := this.NullableDurations[i], that1.NullableDurations[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableDurations this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDurations[i], i, that1.NullableDurations[i])
		}
	}
	if len(this.Timestamps) != len(that1.Timestamps) {
		return fmt.Errorf("Timestamps this(%v) Not Equal that(%v)", len(this.Timestamps), len(that1.Timestamps))
	}
	for i := range this.Timestamps {
		if !this.Timestamps[i].Equal(that1.Timestamps[i]) {
			return fmt.Errorf("Timestamps this[%v](%v) Not Equal that[%v](%v)", i, this.Timestamps[i], i, that1.Timestamps[i])
		}
	}
	if len(this.Durations) != len(that1.Durations) {
		return fmt.Errorf("Durations this(%v) Not Equal that(%v)", len(this.Durations), len(that1.Durations))
	}
	for i := range this.Durations {
		if this.Durations[i] != that1.Durations[i] {
			return fmt.Errorf("Durations this[%v](%v) Not Equal that[%v](%v)", i, this.Durations[i], i, that1.Durations[i])
		}
	}
	if len(this.NullableDouble) != len(that1.NullableDouble) {
		return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", len(this.NullableDouble), len(that1.NullableDouble))
	}
	for i := range this.NullableDouble {
		if dthis, dthat := this.NullableDouble[i], that1.NullableDouble[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDouble[i], i, that1.NullableDouble[i])
		}
	}
	if len(this.NonnullDouble) != len(that1.NonnullDouble) {
		return fmt.Errorf("NonnullDouble this(%v) Not Equal that(%v)", len(this.NonnullDouble), len(that1.NonnullDouble))
	}
	for i := range this.NonnullDouble {
		if this.NonnullDouble[i] != that1.NonnullDouble[i] {
			return fmt.Errorf("NonnullDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullDouble[i], i, that1.NonnullDouble[i])
		}
	}
	if len(this.NullableFloat) != len(that1.NullableFloat) {
		return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", len(this.NullableFloat), len(that1.NullableFloat))
	}
	for i := range this.NullableFloat {
		if dthis, dthat := this.NullableFloat[i], that1.NullableFloat[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NullableFloat[i], i, that1.NullableFloat[i])
		}
	}
	if len(this.NonnullFloat) != len(that1.NonnullFloat) {
		return fmt.Errorf("NonnullFloat this(%v) Not Equal that(%v)", len(this.NonnullFloat), len(that1.NonnullFloat))
	}
	for i := range this.NonnullFloat {
		if this.NonnullFloat[i] != that1.NonnullFloat[i] {
			return fmt.Errorf("NonnullFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullFloat[i], i, that1.NonnullFloat[i])
		}
	}
	if len(this.NullableInt64) != len(that1.NullableInt64) {
		return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", len(this.NullableInt64), len(that1.NullableInt64))
	}
	for i := range this.NullableInt64 {
		if dthis, dthat := this.NullableInt64[i], that1.NullableInt64[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt64[i], i, that1.NullableInt64[i])
		}
	}
	if len(this.NonnullInt64) != len(that1.NonnullInt64) {
		return fmt.Errorf("NonnullInt64 this(%v) Not Equal that(%v)", len(this.NonnullInt64), len(that1.NonnullInt64))
	}
	for i := range this.NonnullInt64 {
		if this.NonnullInt64[i] != that1.NonnullInt64[i] {
			return fmt.Errorf("NonnullInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt64[i], i, that1.NonnullInt64[i])
		}
	}
	if len(this.NullableUInt64) != len(that1.NullableUInt64) {
		return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", len(this.NullableUInt64), len(that1.NullableUInt64))
	}
	for i := range this.NullableUInt64 {
		if dthis, dthat := this.NullableUInt64[i], that1.NullableUInt64[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt64[i], i, that1.NullableUInt64[i])
		}
	}
	if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
		return fmt.Errorf("NonnullUInt64 this(%v) Not Equal that(%v)", len(this.NonnullUInt64), len(that1.NonnullUInt64))
	}
	for i := range this.NonnullUInt64 {
		if this.NonnullUInt64[i] != that1.NonnullUInt64[i] {
			return fmt.Errorf("NonnullUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt64[i], i, that1.NonnullUInt64[i])
		}
	}
	if len(this.NullableInt32) != len(that1.NullableInt32) {
		return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", len(this.NullableInt32), len(that1.NullableInt32))
	}
	for i := range this.NullableInt32 {
		if dthis, dthat := this.NullableInt32[i], that1.NullableInt32[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt32[i], i, that1.NullableInt32[i])
		}
	}
	if len(this.NonnullInt32) != len(that1.NonnullInt32) {
		return fmt.Errorf("NonnullInt32 this(%v) Not Equal that(%v)", len(this.NonnullInt32), len(that1.NonnullInt32))
	}
	for i := range this.NonnullInt32 {
		if this.NonnullInt32[i] != that1.NonnullInt32[i] {
			return fmt.Errorf("NonnullInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt32[i], i, that1.NonnullInt32[i])
		}
	}
	if len(this.NullableUInt32) != len(that1.NullableUInt32) {
		return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", len(this.NullableUInt32), len(that1.NullableUInt32))
	}
	for i := range this.NullableUInt32 {
		if dthis, dthat := this.NullableUInt32[i], that1.NullableUInt32[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt32[i], i, that1.NullableUInt32[i])
		}
	}
	if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
		return fmt.Errorf("NonnullUInt32 this(%v) Not Equal that(%v)", len(this.NonnullUInt32), len(that1.NonnullUInt32))
	}
	for i := range this.NonnullUInt32 {
		if this.NonnullUInt32[i] != that1.NonnullUInt32[i] {
			return fmt.Errorf("NonnullUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt32[i], i, that1.NonnullUInt32[i])
		}
	}
	if len(this.NullableBool) != len(that1.NullableBool) {
		return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", len(this.NullableBool), len(that1.NullableBool))
	}
	for i := range this.NullableBool {
		if dthis, dthat := this.NullableBool[i], that1.NullableBool[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableBool this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBool[i], i, that1.NullableBool[i])
		}
	}
	if len(this.NonnullBool) != len(that1.NonnullBool) {
		return fmt.Errorf("NonnullBool this(%v) Not Equal that(%v)", len(this.NonnullBool), len(that1.NonnullBool))
	}
	for i := range this.NonnullBool {
		if this.NonnullBool[i] != that1.NonnullBool[i] {
			return fmt.Errorf("NonnullBool this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBool[i], i, that1.NonnullBool[i])
		}
	}
	if len(this.NullableString) != len(that1.NullableString) {
		return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", len(this.NullableString), len(that1.NullableString))
	}
	for i := range this.NullableString {
		if dthis, dthat := this.NullableString[i], that1.NullableString[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableString this[%v](%v) Not Equal that[%v](%v)", i, this.NullableString[i], i, that1.NullableString[i])
		}
	}
	if len(this.NonnullString) != len(that1.NonnullString) {
		return fmt.Errorf("NonnullString this(%v) Not Equal that(%v)", len(this.NonnullString), len(that1.NonnullString))
	}
	for i := range this.NonnullString {
		if this.NonnullString[i] != that1.NonnullString[i] {
			return fmt.Errorf("NonnullString this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullString[i], i, that1.NonnullString[i])
		}
	}
	if len(this.NullableBytes) != len(that1.NullableBytes) {
		return fmt.Errorf("NullableBytes this(%v) Not Equal that(%v)", len(this.NullableBytes), len(that1.NullableBytes))
	}
	for i := range this.NullableBytes {
		if !bytes.Equal(*this.NullableBytes[i], *that1.NullableBytes[i]) {
			return fmt.Errorf("NullableBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBytes[i], i, that1.NullableBytes[i])
		}
	}
	if len(this.NonnullBytes) != len(that1.NonnullBytes) {
		return fmt.Errorf("NonnullBytes this(%v) Not Equal that(%v)", len(this.NonnullBytes), len(that1.NonnullBytes))
	}
	for i := range this.NonnullBytes {
		if !bytes.Equal(this.NonnullBytes[i], that1.NonnullBytes[i]) {
			return fmt.Errorf("NonnullBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBytes[i], i, that1.NonnullBytes[i])
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *RepStdTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RepStdTypes)
	if !ok {
		that2, ok := that.(RepStdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NullableTimestamps) != len(that1.NullableTimestamps) {
		return false
	}
	for i := range this.NullableTimestamps {
		if !this.NullableTimestamps[i].Equal(*that1.NullableTimestamps[i]) {
			return false
		}
	}
	if len(this.NullableDurations) != len(that1.NullableDurations) {
		return false
	}
	for i := range this.NullableDurations {
		if dthis, dthat := this.NullableDurations[i], that1.NullableDurations[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.Timestamps) != len(that1.Timestamps) {
		return false
	}
	for i := range this.Timestamps {
		if !this.Timestamps[i].Equal(that1.Timestamps[i]) {
			return false
		}
	}
	if len(this.Durations) != len(that1.Durations) {
		return false
	}
	for i := range this.Durations {
		if this.Durations[i] != that1.Durations[i] {
			return false
		}
	}
	if len(this.NullableDouble) != len(that1.NullableDouble) {
		return false
	}
	for i := range this.NullableDouble {
		if dthis, dthat := this.NullableDouble[i], that1.NullableDouble[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.NonnullDouble) != len(that1.NonnullDouble) {
		return false
	}
	for i := range this.NonnullDouble {
		if this.NonnullDouble[i] != that1.NonnullDouble[i] {
			return false
		}
	}
	if len(this.NullableFloat) != len(that1.NullableFloat) {
		return false
	}
	for i := range this.NullableFloat {
		if dthis, dthat := this.NullableFloat[i], that1.NullableFloat[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.NonnullFloat) != len(that1.NonnullFloat) {
		return false
	}
	for i := range this.NonnullFloat {
		if this.NonnullFloat[i] != that1.NonnullFloat[i] {
			return false
		}
	}
	if len(this.NullableInt64) != len(that1.NullableInt64) {
		return false
	}
	for i := range this.NullableInt64 {
		if dthis, dthat := this.NullableInt64[i], that1.NullableInt64[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.NonnullInt64) != len(that1.NonnullInt64) {
		return false
	}
	for i := range this.NonnullInt64 {
		if this.NonnullInt64[i] != that1.NonnullInt64[i] {
			return false
		}
	}
	if len(this.NullableUInt64) != len(that1.NullableUInt64) {
		return false
	}
	for i := range this.NullableUInt64 {
		if dthis, dthat := this.NullableUInt64[i], that1.NullableUInt64[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
		return false
	}
	for i := range this.NonnullUInt64 {
		if this.NonnullUInt64[i] != that1.NonnullUInt64[i] {
			return false
		}
	}
	if len(this.NullableInt32) != len(that1.NullableInt32) {
		return false
	}
	for i := range this.NullableInt32 {
		if dthis, dthat := this.NullableInt32[i], that1.NullableInt32[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.NonnullInt32) != len(that1.NonnullInt32) {
		return false
	}
	for i := range this.NonnullInt32 {
		if this.NonnullInt32[i] != that1.NonnullInt32[i] {
			return false
		}
	}
	if len(this.NullableUInt32) != len(that1.NullableUInt32) {
		return false
	}
	for i := range this.NullableUInt32 {
		if dthis, dthat := this.NullableUInt32[i], that1.NullableUInt32[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
		return false
	}
	for i := range this.NonnullUInt32 {
		if this.NonnullUInt32[i] != that1.NonnullUInt32[i] {
			return false
		}
	}
	if len(this.NullableBool) != len(that1.NullableBool) {
		return false
	}
	for i := range this.NullableBool {
		if dthis, dthat := this.NullableBool[i], that1.NullableBool[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.NonnullBool) != len(that1.NonnullBool) {
		return false
	}
	for i := range this.NonnullBool {
		if this.NonnullBool[i] != that1.NonnullBool[i] {
			return false
		}
	}
	if len(this.NullableString) != len(that1.NullableString) {
		return false
	}
	for i := range this.NullableString {
		if dthis, dthat := this.NullableString[i], that1.NullableString[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.NonnullString) != len(that1.NonnullString) {
		return false
	}
	for i := range this.NonnullString {
		if this.NonnullString[i] != that1.NonnullString[i] {
			return false
		}
	}
	if len(this.NullableBytes) != len(that1.NullableBytes) {
		return false
	}
	for i := range this.NullableBytes {
		if !bytes.Equal(*this.NullableBytes[i], *that1.NullableBytes[i]) {
			return false
		}
	}
	if len(this.NonnullBytes) != len(that1.NonnullBytes) {
		return false
	}
	for i := range this.NonnullBytes {
		if !bytes.Equal(this.NonnullBytes[i], that1.NonnullBytes[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *MapProtoTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*MapProtoTypes)
	if !ok {
		that2, ok := that.(MapProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *MapProtoTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *MapProtoTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *MapProtoTypes but is not nil && this == nil")
	}
	if len(this.NullableTimestamp) != len(that1.NullableTimestamp) {
		return fmt.Errorf("NullableTimestamp this(%v) Not Equal that(%v)", len(this.NullableTimestamp), len(that1.NullableTimestamp))
	}
	for i := range this.NullableTimestamp {
		if !this.NullableTimestamp[i].Equal(that1.NullableTimestamp[i]) {
			return fmt.Errorf("NullableTimestamp this[%v](%v) Not Equal that[%v](%v)", i, this.NullableTimestamp[i], i, that1.NullableTimestamp[i])
		}
	}
	if len(this.Timestamp) != len(that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", len(this.Timestamp), len(that1.Timestamp))
	}
	for i := range this.Timestamp {
		a := this.Timestamp[i]
		b := that1.Timestamp[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("Timestamp this[%v](%v) Not Equal that[%v](%v)", i, this.Timestamp[i], i, that1.Timestamp[i])
		}
	}
	if len(this.NullableDuration) != len(that1.NullableDuration) {
		return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", len(this.NullableDuration), len(that1.NullableDuration))
	}
	for i := range this.NullableDuration {
		if !this.NullableDuration[i].Equal(that1.NullableDuration[i]) {
			return fmt.Errorf("NullableDuration this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDuration[i], i, that1.NullableDuration[i])
		}
	}
	if len(this.Duration) != len(that1.Duration) {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", len(this.Duration), len(that1.Duration))
	}
	for i := range this.Duration {
		a := this.Duration[i]
		b := that1.Duration[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("Duration this[%v](%v) Not Equal that[%v](%v)", i, this.Duration[i], i, that1.Duration[i])
		}
	}
	if len(this.NullableDouble) != len(that1.NullableDouble) {
		return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", len(this.NullableDouble), len(that1.NullableDouble))
	}
	for i := range this.NullableDouble {
		if !this.NullableDouble[i].Equal(that1.NullableDouble[i]) {
			return fmt.Errorf("NullableDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDouble[i], i, that1.NullableDouble[i])
		}
	}
	if len(this.NonnullDouble) != len(that1.NonnullDouble) {
		return fmt.Errorf("NonnullDouble this(%v) Not Equal that(%v)", len(this.NonnullDouble), len(that1.NonnullDouble))
	}
	for i := range this.NonnullDouble {
		a := this.NonnullDouble[i]
		b := that1.NonnullDouble[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("NonnullDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullDouble[i], i, that1.NonnullDouble[i])
		}
	}
	if len(this.NullableFloat) != len(that1.NullableFloat) {
		return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", len(this.NullableFloat), len(that1.NullableFloat))
	}
	for i := range this.NullableFloat {
		if !this.NullableFloat[i].Equal(that1.NullableFloat[i]) {
			return fmt.Errorf("NullableFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NullableFloat[i], i, that1.NullableFloat[i])
		}
	}
	if len(this.NonnullFloat) != len(that1.NonnullFloat) {
		return fmt.Errorf("NonnullFloat this(%v) Not Equal that(%v)", len(this.NonnullFloat), len(that1.NonnullFloat))
	}
	for i := range this.NonnullFloat {
		a := this.NonnullFloat[i]
		b := that1.NonnullFloat[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("NonnullFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullFloat[i], i, that1.NonnullFloat[i])
		}
	}
	if len(this.NullableInt64) != len(that1.NullableInt64) {
		return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", len(this.NullableInt64), len(that1.NullableInt64))
	}
	for i := range this.NullableInt64 {
		if !this.NullableInt64[i].Equal(that1.NullableInt64[i]) {
			return fmt.Errorf("NullableInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt64[i], i, that1.NullableInt64[i])
		}
	}
	if len(this.NonnullInt64) != len(that1.NonnullInt64) {
		return fmt.Errorf("NonnullInt64 this(%v) Not Equal that(%v)", len(this.NonnullInt64), len(that1.NonnullInt64))
	}
	for i := range this.NonnullInt64 {
		a := this.NonnullInt64[i]
		b := that1.NonnullInt64[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("NonnullInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt64[i], i, that1.NonnullInt64[i])
		}
	}
	if len(this.NullableUInt64) != len(that1.NullableUInt64) {
		return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", len(this.NullableUInt64), len(that1.NullableUInt64))
	}
	for i := range this.NullableUInt64 {
		if !this.NullableUInt64[i].Equal(that1.NullableUInt64[i]) {
			return fmt.Errorf("NullableUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt64[i], i, that1.NullableUInt64[i])
		}
	}
	if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
		return fmt.Errorf("NonnullUInt64 this(%v) Not Equal that(%v)", len(this.NonnullUInt64), len(that1.NonnullUInt64))
	}
	for i := range this.NonnullUInt64 {
		a := this.NonnullUInt64[i]
		b := that1.NonnullUInt64[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("NonnullUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt64[i], i, that1.NonnullUInt64[i])
		}
	}
	if len(this.NullableInt32) != len(that1.NullableInt32) {
		return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", len(this.NullableInt32), len(that1.NullableInt32))
	}
	for i := range this.NullableInt32 {
		if !this.NullableInt32[i].Equal(that1.NullableInt32[i]) {
			return fmt.Errorf("NullableInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt32[i], i, that1.NullableInt32[i])
		}
	}
	if len(this.NonnullInt32) != len(that1.NonnullInt32) {
		return fmt.Errorf("NonnullInt32 this(%v) Not Equal that(%v)", len(this.NonnullInt32), len(that1.NonnullInt32))
	}
	for i := range this.NonnullInt32 {
		a := this.NonnullInt32[i]
		b := that1.NonnullInt32[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("NonnullInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt32[i], i, that1.NonnullInt32[i])
		}
	}
	if len(this.NullableUInt32) != len(that1.NullableUInt32) {
		return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", len(this.NullableUInt32), len(that1.NullableUInt32))
	}
	for i := range this.NullableUInt32 {
		if !this.NullableUInt32[i].Equal(that1.NullableUInt32[i]) {
			return fmt.Errorf("NullableUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt32[i], i, that1.NullableUInt32[i])
		}
	}
	if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
		return fmt.Errorf("NonnullUInt32 this(%v) Not Equal that(%v)", len(this.NonnullUInt32), len(that1.NonnullUInt32))
	}
	for i := range this.NonnullUInt32 {
		a := this.NonnullUInt32[i]
		b := that1.NonnullUInt32[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("NonnullUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt32[i], i, that1.NonnullUInt32[i])
		}
	}
	if len(this.NullableBool) != len(that1.NullableBool) {
		return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", len(this.NullableBool), len(that1.NullableBool))
	}
	for i := range this.NullableBool {
		if !this.NullableBool[i].Equal(that1.NullableBool[i]) {
			return fmt.Errorf("NullableBool this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBool[i], i, that1.NullableBool[i])
		}
	}
	if len(this.NonnullBool) != len(that1.NonnullBool) {
		return fmt.Errorf("NonnullBool this(%v) Not Equal that(%v)", len(this.NonnullBool), len(that1.NonnullBool))
	}
	for i := range this.NonnullBool {
		a := this.NonnullBool[i]
		b := that1.NonnullBool[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("NonnullBool this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBool[i], i, that1.NonnullBool[i])
		}
	}
	if len(this.NullableString) != len(that1.NullableString) {
		return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", len(this.NullableString), len(that1.NullableString))
	}
	for i := range this.NullableString {
		if !this.NullableString[i].Equal(that1.NullableString[i]) {
			return fmt.Errorf("NullableString this[%v](%v) Not Equal that[%v](%v)", i, this.NullableString[i], i, that1.NullableString[i])
		}
	}
	if len(this.NonnullString) != len(that1.NonnullString) {
		return fmt.Errorf("NonnullString this(%v) Not Equal that(%v)", len(this.NonnullString), len(that1.NonnullString))
	}
	for i := range this.NonnullString {
		a := this.NonnullString[i]
		b := that1.NonnullString[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("NonnullString this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullString[i], i, that1.NonnullString[i])
		}
	}
	if len(this.NullableBytes) != len(that1.NullableBytes) {
		return fmt.Errorf("NullableBytes this(%v) Not Equal that(%v)", len(this.NullableBytes), len(that1.NullableBytes))
	}
	for i := range this.NullableBytes {
		if !this.NullableBytes[i].Equal(that1.NullableBytes[i]) {
			return fmt.Errorf("NullableBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBytes[i], i, that1.NullableBytes[i])
		}
	}
	if len(this.NonnullBytes) != len(that1.NonnullBytes) {
		return fmt.Errorf("NonnullBytes this(%v) Not Equal that(%v)", len(this.NonnullBytes), len(that1.NonnullBytes))
	}
	for i := range this.NonnullBytes {
		a := this.NonnullBytes[i]
		b := that1.NonnullBytes[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("NonnullBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBytes[i], i, that1.NonnullBytes[i])
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *MapProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MapProtoTypes)
	if !ok {
		that2, ok := that.(MapProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NullableTimestamp) != len(that1.NullableTimestamp) {
		return false
	}
	for i := range this.NullableTimestamp {
		if !this.NullableTimestamp[i].Equal(that1.NullableTimestamp[i]) {
			return false
		}
	}
	if len(this.Timestamp) != len(that1.Timestamp) {
		return false
	}
	for i := range this.Timestamp {
		a := this.Timestamp[i]
		b := that1.Timestamp[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableDuration) != len(that1.NullableDuration) {
		return false
	}
	for i := range this.NullableDuration {
		if !this.NullableDuration[i].Equal(that1.NullableDuration[i]) {
			return false
		}
	}
	if len(this.Duration) != len(that1.Duration) {
		return false
	}
	for i := range this.Duration {
		a := this.Duration[i]
		b := that1.Duration[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableDouble) != len(that1.NullableDouble) {
		return false
	}
	for i := range this.NullableDouble {
		if !this.NullableDouble[i].Equal(that1.NullableDouble[i]) {
			return false
		}
	}
	if len(this.NonnullDouble) != len(that1.NonnullDouble) {
		return false
	}
	for i := range this.NonnullDouble {
		a := this.NonnullDouble[i]
		b := that1.NonnullDouble[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableFloat) != len(that1.NullableFloat) {
		return false
	}
	for i := range this.NullableFloat {
		if !this.NullableFloat[i].Equal(that1.NullableFloat[i]) {
			return false
		}
	}
	if len(this.NonnullFloat) != len(that1.NonnullFloat) {
		return false
	}
	for i := range this.NonnullFloat {
		a := this.NonnullFloat[i]
		b := that1.NonnullFloat[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableInt64) != len(that1.NullableInt64) {
		return false
	}
	for i := range this.NullableInt64 {
		if !this.NullableInt64[i].Equal(that1.NullableInt64[i]) {
			return false
		}
	}
	if len(this.NonnullInt64) != len(that1.NonnullInt64) {
		return false
	}
	for i := range this.NonnullInt64 {
		a := this.NonnullInt64[i]
		b := that1.NonnullInt64[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableUInt64) != len(that1.NullableUInt64) {
		return false
	}
	for i := range this.NullableUInt64 {
		if !this.NullableUInt64[i].Equal(that1.NullableUInt64[i]) {
			return false
		}
	}
	if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
		return false
	}
	for i := range this.NonnullUInt64 {
		a := this.NonnullUInt64[i]
		b := that1.NonnullUInt64[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableInt32) != len(that1.NullableInt32) {
		return false
	}
	for i := range this.NullableInt32 {
		if !this.NullableInt32[i].Equal(that1.NullableInt32[i]) {
			return false
		}
	}
	if len(this.NonnullInt32) != len(that1.NonnullInt32) {
		return false
	}
	for i := range this.NonnullInt32 {
		a := this.NonnullInt32[i]
		b := that1.NonnullInt32[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableUInt32) != len(that1.NullableUInt32) {
		return false
	}
	for i := range this.NullableUInt32 {
		if !this.NullableUInt32[i].Equal(that1.NullableUInt32[i]) {
			return false
		}
	}
	if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
		return false
	}
	for i := range this.NonnullUInt32 {
		a := this.NonnullUInt32[i]
		b := that1.NonnullUInt32[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableBool) != len(that1.NullableBool) {
		return false
	}
	for i := range this.NullableBool {
		if !this.NullableBool[i].Equal(that1.NullableBool[i]) {
			return false
		}
	}
	if len(this.NonnullBool) != len(that1.NonnullBool) {
		return false
	}
	for i := range this.NonnullBool {
		a := this.NonnullBool[i]
		b := that1.NonnullBool[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableString) != len(that1.NullableString) {
		return false
	}
	for i := range this.NullableString {
		if !this.NullableString[i].Equal(that1.NullableString[i]) {
			return false
		}
	}
	if len(this.NonnullString) != len(that1.NonnullString) {
		return false
	}
	for i := range this.NonnullString {
		a := this.NonnullString[i]
		b := that1.NonnullString[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if len(this.NullableBytes) != len(that1.NullableBytes) {
		return false
	}
	for i := range this.NullableBytes {
		if !this.NullableBytes[i].Equal(that1.NullableBytes[i]) {
			return false
		}
	}
	if len(this.NonnullBytes) != len(that1.NonnullBytes) {
		return false
	}
	for i := range this.NonnullBytes {
		a := this.NonnullBytes[i]
		b := that1.NonnullBytes[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *MapStdTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*MapStdTypes)
	if !ok {
		that2, ok := that.(MapStdTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *MapStdTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *MapStdTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *MapStdTypes but is not nil && this == nil")
	}
	if len(this.NullableTimestamp) != len(that1.NullableTimestamp) {
		return fmt.Errorf("NullableTimestamp this(%v) Not Equal that(%v)", len(this.NullableTimestamp), len(that1.NullableTimestamp))
	}
	for i := range this.NullableTimestamp {
		if !this.NullableTimestamp[i].Equal(*that1.NullableTimestamp[i]) {
			return fmt.Errorf("NullableTimestamp this[%v](%v) Not Equal that[%v](%v)", i, this.NullableTimestamp[i], i, that1.NullableTimestamp[i])
		}
	}
	if len(this.Timestamp) != len(that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", len(this.Timestamp), len(that1.Timestamp))
	}
	for i := range this.Timestamp {
		if !this.Timestamp[i].Equal(that1.Timestamp[i]) {
			return fmt.Errorf("Timestamp this[%v](%v) Not Equal that[%v](%v)", i, this.Timestamp[i], i, that1.Timestamp[i])
		}
	}
	if len(this.NullableDuration) != len(that1.NullableDuration) {
		return fmt.Errorf("NullableDuration this(%v) Not Equal that(%v)", len(this.NullableDuration), len(that1.NullableDuration))
	}
	for i := range this.NullableDuration {
		if dthis, dthat := this.NullableDuration[i], that1.NullableDuration[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return fmt.Errorf("NullableDuration this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDuration[i], i, that1.NullableDuration[i])
		}
	}
	if len(this.Duration) != len(that1.Duration) {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", len(this.Duration), len(that1.Duration))
	}
	for i := range this.Duration {
		if this.Duration[i] != that1.Duration[i] {
			return fmt.Errorf("Duration this[%v](%v) Not Equal that[%v](%v)", i, this.Duration[i], i, that1.Duration[i])
		}
	}
	if len(this.NullableDouble) != len(that1.NullableDouble) {
		return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", len(this.NullableDouble), len(that1.NullableDouble))
	}
	for i := range this.NullableDouble {
		a := this.NullableDouble[i]
		b := that1.NullableDouble[i]
		if *a != *b {
			return fmt.Errorf("NullableDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NullableDouble[i], i, that1.NullableDouble[i])
		}
	}
	if len(this.NonnullDouble) != len(that1.NonnullDouble) {
		return fmt.Errorf("NonnullDouble this(%v) Not Equal that(%v)", len(this.NonnullDouble), len(that1.NonnullDouble))
	}
	for i := range this.NonnullDouble {
		a := this.NonnullDouble[i]
		b := that1.NonnullDouble[i]
		if a != b {
			return fmt.Errorf("NonnullDouble this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullDouble[i], i, that1.NonnullDouble[i])
		}
	}
	if len(this.NullableFloat) != len(that1.NullableFloat) {
		return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", len(this.NullableFloat), len(that1.NullableFloat))
	}
	for i := range this.NullableFloat {
		a := this.NullableFloat[i]
		b := that1.NullableFloat[i]
		if *a != *b {
			return fmt.Errorf("NullableFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NullableFloat[i], i, that1.NullableFloat[i])
		}
	}
	if len(this.NonnullFloat) != len(that1.NonnullFloat) {
		return fmt.Errorf("NonnullFloat this(%v) Not Equal that(%v)", len(this.NonnullFloat), len(that1.NonnullFloat))
	}
	for i := range this.NonnullFloat {
		a := this.NonnullFloat[i]
		b := that1.NonnullFloat[i]
		if a != b {
			return fmt.Errorf("NonnullFloat this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullFloat[i], i, that1.NonnullFloat[i])
		}
	}
	if len(this.NullableInt64) != len(that1.NullableInt64) {
		return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", len(this.NullableInt64), len(that1.NullableInt64))
	}
	for i := range this.NullableInt64 {
		a := this.NullableInt64[i]
		b := that1.NullableInt64[i]
		if *a != *b {
			return fmt.Errorf("NullableInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt64[i], i, that1.NullableInt64[i])
		}
	}
	if len(this.NonnullInt64) != len(that1.NonnullInt64) {
		return fmt.Errorf("NonnullInt64 this(%v) Not Equal that(%v)", len(this.NonnullInt64), len(that1.NonnullInt64))
	}
	for i := range this.NonnullInt64 {
		a := this.NonnullInt64[i]
		b := that1.NonnullInt64[i]
		if a != b {
			return fmt.Errorf("NonnullInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt64[i], i, that1.NonnullInt64[i])
		}
	}
	if len(this.NullableUInt64) != len(that1.NullableUInt64) {
		return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", len(this.NullableUInt64), len(that1.NullableUInt64))
	}
	for i := range this.NullableUInt64 {
		a := this.NullableUInt64[i]
		b := that1.NullableUInt64[i]
		if *a != *b {
			return fmt.Errorf("NullableUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt64[i], i, that1.NullableUInt64[i])
		}
	}
	if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
		return fmt.Errorf("NonnullUInt64 this(%v) Not Equal that(%v)", len(this.NonnullUInt64), len(that1.NonnullUInt64))
	}
	for i := range this.NonnullUInt64 {
		a := this.NonnullUInt64[i]
		b := that1.NonnullUInt64[i]
		if a != b {
			return fmt.Errorf("NonnullUInt64 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt64[i], i, that1.NonnullUInt64[i])
		}
	}
	if len(this.NullableInt32) != len(that1.NullableInt32) {
		return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", len(this.NullableInt32), len(that1.NullableInt32))
	}
	for i := range this.NullableInt32 {
		a := this.NullableInt32[i]
		b := that1.NullableInt32[i]
		if *a != *b {
			return fmt.Errorf("NullableInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableInt32[i], i, that1.NullableInt32[i])
		}
	}
	if len(this.NonnullInt32) != len(that1.NonnullInt32) {
		return fmt.Errorf("NonnullInt32 this(%v) Not Equal that(%v)", len(this.NonnullInt32), len(that1.NonnullInt32))
	}
	for i := range this.NonnullInt32 {
		a := this.NonnullInt32[i]
		b := that1.NonnullInt32[i]
		if a != b {
			return fmt.Errorf("NonnullInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullInt32[i], i, that1.NonnullInt32[i])
		}
	}
	if len(this.NullableUInt32) != len(that1.NullableUInt32) {
		return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", len(this.NullableUInt32), len(that1.NullableUInt32))
	}
	for i := range this.NullableUInt32 {
		a := this.NullableUInt32[i]
		b := that1.NullableUInt32[i]
		if *a != *b {
			return fmt.Errorf("NullableUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NullableUInt32[i], i, that1.NullableUInt32[i])
		}
	}
	if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
		return fmt.Errorf("NonnullUInt32 this(%v) Not Equal that(%v)", len(this.NonnullUInt32), len(that1.NonnullUInt32))
	}
	for i := range this.NonnullUInt32 {
		a := this.NonnullUInt32[i]
		b := that1.NonnullUInt32[i]
		if a != b {
			return fmt.Errorf("NonnullUInt32 this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullUInt32[i], i, that1.NonnullUInt32[i])
		}
	}
	if len(this.NullableBool) != len(that1.NullableBool) {
		return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", len(this.NullableBool), len(that1.NullableBool))
	}
	for i := range this.NullableBool {
		a := this.NullableBool[i]
		b := that1.NullableBool[i]
		if *a != *b {
			return fmt.Errorf("NullableBool this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBool[i], i, that1.NullableBool[i])
		}
	}
	if len(this.NonnullBool) != len(that1.NonnullBool) {
		return fmt.Errorf("NonnullBool this(%v) Not Equal that(%v)", len(this.NonnullBool), len(that1.NonnullBool))
	}
	for i := range this.NonnullBool {
		a := this.NonnullBool[i]
		b := that1.NonnullBool[i]
		if a != b {
			return fmt.Errorf("NonnullBool this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBool[i], i, that1.NonnullBool[i])
		}
	}
	if len(this.NullableString) != len(that1.NullableString) {
		return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", len(this.NullableString), len(that1.NullableString))
	}
	for i := range this.NullableString {
		a := this.NullableString[i]
		b := that1.NullableString[i]
		if *a != *b {
			return fmt.Errorf("NullableString this[%v](%v) Not Equal that[%v](%v)", i, this.NullableString[i], i, that1.NullableString[i])
		}
	}
	if len(this.NonnullString) != len(that1.NonnullString) {
		return fmt.Errorf("NonnullString this(%v) Not Equal that(%v)", len(this.NonnullString), len(that1.NonnullString))
	}
	for i := range this.NonnullString {
		a := this.NonnullString[i]
		b := that1.NonnullString[i]
		if a != b {
			return fmt.Errorf("NonnullString this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullString[i], i, that1.NonnullString[i])
		}
	}
	if len(this.NullableBytes) != len(that1.NullableBytes) {
		return fmt.Errorf("NullableBytes this(%v) Not Equal that(%v)", len(this.NullableBytes), len(that1.NullableBytes))
	}
	for i := range this.NullableBytes {
		a := this.NullableBytes[i]
		b := that1.NullableBytes[i]
		if !bytes.Equal(*a, *b) {
			return fmt.Errorf("NullableBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NullableBytes[i], i, that1.NullableBytes[i])
		}
	}
	if len(this.NonnullBytes) != len(that1.NonnullBytes) {
		return fmt.Errorf("NonnullBytes this(%v) Not Equal that(%v)", len(this.NonnullBytes), len(that1.NonnullBytes))
	}
	for i := range this.NonnullBytes {
		a := this.NonnullBytes[i]
		b := that1.NonnullBytes[i]
		if !bytes.Equal(a, b) {
			return fmt.Errorf("NonnullBytes this[%v](%v) Not Equal that[%v](%v)", i, this.NonnullBytes[i], i, that1.NonnullBytes[i])
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *MapStdTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MapStdTypes)
	if !ok {
		that2, ok := that.(MapStdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NullableTimestamp) != len(that1.NullableTimestamp) {
		return false
	}
	for i := range this.NullableTimestamp {
		if !this.NullableTimestamp[i].Equal(*that1.NullableTimestamp[i]) {
			return false
		}
	}
	if len(this.Timestamp) != len(that1.Timestamp) {
		return false
	}
	for i := range this.Timestamp {
		if !this.Timestamp[i].Equal(that1.Timestamp[i]) {
			return false
		}
	}
	if len(this.NullableDuration) != len(that1.NullableDuration) {
		return false
	}
	for i := range this.NullableDuration {
		if dthis, dthat := this.NullableDuration[i], that1.NullableDuration[i]; (dthis != nil && dthat != nil && *dthis != *dthat) || (dthis != nil && dthat == nil) || (dthis == nil && dthat != nil) {
			return false
		}
	}
	if len(this.Duration) != len(that1.Duration) {
		return false
	}
	for i := range this.Duration {
		if this.Duration[i] != that1.Duration[i] {
			return false
		}
	}
	if len(this.NullableDouble) != len(that1.NullableDouble) {
		return false
	}
	for i := range this.NullableDouble {
		a := this.NullableDouble[i]
		b := that1.NullableDouble[i]
		if *a != *b {
			return false
		}
	}
	if len(this.NonnullDouble) != len(that1.NonnullDouble) {
		return false
	}
	for i := range this.NonnullDouble {
		a := this.NonnullDouble[i]
		b := that1.NonnullDouble[i]
		if a != b {
			return false
		}
	}
	if len(this.NullableFloat) != len(that1.NullableFloat) {
		return false
	}
	for i := range this.NullableFloat {
		a := this.NullableFloat[i]
		b := that1.NullableFloat[i]
		if *a != *b {
			return false
		}
	}
	if len(this.NonnullFloat) != len(that1.NonnullFloat) {
		return false
	}
	for i := range this.NonnullFloat {
		a := this.NonnullFloat[i]
		b := that1.NonnullFloat[i]
		if a != b {
			return false
		}
	}
	if len(this.NullableInt64) != len(that1.NullableInt64) {
		return false
	}
	for i := range this.NullableInt64 {
		a := this.NullableInt64[i]
		b := that1.NullableInt64[i]
		if *a != *b {
			return false
		}
	}
	if len(this.NonnullInt64) != len(that1.NonnullInt64) {
		return false
	}
	for i := range this.NonnullInt64 {
		a := this.NonnullInt64[i]
		b := that1.NonnullInt64[i]
		if a != b {
			return false
		}
	}
	if len(this.NullableUInt64) != len(that1.NullableUInt64) {
		return false
	}
	for i := range this.NullableUInt64 {
		a := this.NullableUInt64[i]
		b := that1.NullableUInt64[i]
		if *a != *b {
			return false
		}
	}
	if len(this.NonnullUInt64) != len(that1.NonnullUInt64) {
		return false
	}
	for i := range this.NonnullUInt64 {
		a := this.NonnullUInt64[i]
		b := that1.NonnullUInt64[i]
		if a != b {
			return false
		}
	}
	if len(this.NullableInt32) != len(that1.NullableInt32) {
		return false
	}
	for i := range this.NullableInt32 {
		a := this.NullableInt32[i]
		b := that1.NullableInt32[i]
		if *a != *b {
			return false
		}
	}
	if len(this.NonnullInt32) != len(that1.NonnullInt32) {
		return false
	}
	for i := range this.NonnullInt32 {
		a := this.NonnullInt32[i]
		b := that1.NonnullInt32[i]
		if a != b {
			return false
		}
	}
	if len(this.NullableUInt32) != len(that1.NullableUInt32) {
		return false
	}
	for i := range this.NullableUInt32 {
		a := this.NullableUInt32[i]
		b := that1.NullableUInt32[i]
		if *a != *b {
			return false
		}
	}
	if len(this.NonnullUInt32) != len(that1.NonnullUInt32) {
		return false
	}
	for i := range this.NonnullUInt32 {
		a := this.NonnullUInt32[i]
		b := that1.NonnullUInt32[i]
		if a != b {
			return false
		}
	}
	if len(this.NullableBool) != len(that1.NullableBool) {
		return false
	}
	for i := range this.NullableBool {
		a := this.NullableBool[i]
		b := that1.NullableBool[i]
		if *a != *b {
			return false
		}
	}
	if len(this.NonnullBool) != len(that1.NonnullBool) {
		return false
	}
	for i := range this.NonnullBool {
		a := this.NonnullBool[i]
		b := that1.NonnullBool[i]
		if a != b {
			return false
		}
	}
	if len(this.NullableString) != len(that1.NullableString) {
		return false
	}
	for i := range this.NullableString {
		a := this.NullableString[i]
		b := that1.NullableString[i]
		if *a != *b {
			return false
		}
	}
	if len(this.NonnullString) != len(that1.NonnullString) {
		return false
	}
	for i := range this.NonnullString {
		a := this.NonnullString[i]
		b := that1.NonnullString[i]
		if a != b {
			return false
		}
	}
	if len(this.NullableBytes) != len(that1.NullableBytes) {
		return false
	}
	for i := range this.NullableBytes {
		a := this.NullableBytes[i]
		b := that1.NullableBytes[i]
		if !bytes.Equal(*a, *b) {
			return false
		}
	}
	if len(this.NonnullBytes) != len(that1.NonnullBytes) {
		return false
	}
	for i := range this.NonnullBytes {
		a := this.NonnullBytes[i]
		b := that1.NonnullBytes[i]
		if !bytes.Equal(a, b) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *OneofProtoTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes)
	if !ok {
		that2, ok := that.(OneofProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes but is not nil && this == nil")
	}
	if that1.OneOfProtoTimes == nil {
		if this.OneOfProtoTimes != nil {
			return fmt.Errorf("this.OneOfProtoTimes != nil && that1.OneOfProtoTimes == nil")
		}
	} else if this.OneOfProtoTimes == nil {
		return fmt.Errorf("this.OneOfProtoTimes == nil && that1.OneOfProtoTimes != nil")
	} else if err := this.OneOfProtoTimes.VerboseEqual(that1.OneOfProtoTimes); err != nil {
		return err
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *OneofProtoTypes_Timestamp) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_Timestamp)
	if !ok {
		that2, ok := that.(OneofProtoTypes_Timestamp)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_Timestamp")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_Timestamp but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_Timestamp but is not nil && this == nil")
	}
	if !this.Timestamp.Equal(that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", this.Timestamp, that1.Timestamp)
	}
	return nil
}
func (this *OneofProtoTypes_Duration) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_Duration)
	if !ok {
		that2, ok := that.(OneofProtoTypes_Duration)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_Duration")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_Duration but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_Duration but is not nil && this == nil")
	}
	if !this.Duration.Equal(that1.Duration) {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
	}
	return nil
}
func (this *OneofProtoTypes_RepDouble) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_RepDouble)
	if !ok {
		that2, ok := that.(OneofProtoTypes_RepDouble)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_RepDouble")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_RepDouble but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_RepDouble but is not nil && this == nil")
	}
	if !this.RepDouble.Equal(that1.RepDouble) {
		return fmt.Errorf("RepDouble this(%v) Not Equal that(%v)", this.RepDouble, that1.RepDouble)
	}
	return nil
}
func (this *OneofProtoTypes_RepFloat) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_RepFloat)
	if !ok {
		that2, ok := that.(OneofProtoTypes_RepFloat)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_RepFloat")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_RepFloat but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_RepFloat but is not nil && this == nil")
	}
	if !this.RepFloat.Equal(that1.RepFloat) {
		return fmt.Errorf("RepFloat this(%v) Not Equal that(%v)", this.RepFloat, that1.RepFloat)
	}
	return nil
}
func (this *OneofProtoTypes_RepInt64) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_RepInt64)
	if !ok {
		that2, ok := that.(OneofProtoTypes_RepInt64)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_RepInt64")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_RepInt64 but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_RepInt64 but is not nil && this == nil")
	}
	if !this.RepInt64.Equal(that1.RepInt64) {
		return fmt.Errorf("RepInt64 this(%v) Not Equal that(%v)", this.RepInt64, that1.RepInt64)
	}
	return nil
}
func (this *OneofProtoTypes_RepUInt64) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_RepUInt64)
	if !ok {
		that2, ok := that.(OneofProtoTypes_RepUInt64)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_RepUInt64")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_RepUInt64 but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_RepUInt64 but is not nil && this == nil")
	}
	if !this.RepUInt64.Equal(that1.RepUInt64) {
		return fmt.Errorf("RepUInt64 this(%v) Not Equal that(%v)", this.RepUInt64, that1.RepUInt64)
	}
	return nil
}
func (this *OneofProtoTypes_RepInt32) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_RepInt32)
	if !ok {
		that2, ok := that.(OneofProtoTypes_RepInt32)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_RepInt32")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_RepInt32 but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_RepInt32 but is not nil && this == nil")
	}
	if !this.RepInt32.Equal(that1.RepInt32) {
		return fmt.Errorf("RepInt32 this(%v) Not Equal that(%v)", this.RepInt32, that1.RepInt32)
	}
	return nil
}
func (this *OneofProtoTypes_RepUInt32) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_RepUInt32)
	if !ok {
		that2, ok := that.(OneofProtoTypes_RepUInt32)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_RepUInt32")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_RepUInt32 but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_RepUInt32 but is not nil && this == nil")
	}
	if !this.RepUInt32.Equal(that1.RepUInt32) {
		return fmt.Errorf("RepUInt32 this(%v) Not Equal that(%v)", this.RepUInt32, that1.RepUInt32)
	}
	return nil
}
func (this *OneofProtoTypes_RepBool) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_RepBool)
	if !ok {
		that2, ok := that.(OneofProtoTypes_RepBool)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_RepBool")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_RepBool but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_RepBool but is not nil && this == nil")
	}
	if !this.RepBool.Equal(that1.RepBool) {
		return fmt.Errorf("RepBool this(%v) Not Equal that(%v)", this.RepBool, that1.RepBool)
	}
	return nil
}
func (this *OneofProtoTypes_RepString) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_RepString)
	if !ok {
		that2, ok := that.(OneofProtoTypes_RepString)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_RepString")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_RepString but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_RepString but is not nil && this == nil")
	}
	if !this.RepString.Equal(that1.RepString) {
		return fmt.Errorf("RepString this(%v) Not Equal that(%v)", this.RepString, that1.RepString)
	}
	return nil
}
func (this *OneofProtoTypes_RepBytes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofProtoTypes_RepBytes)
	if !ok {
		that2, ok := that.(OneofProtoTypes_RepBytes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofProtoTypes_RepBytes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofProtoTypes_RepBytes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofProtoTypes_RepBytes but is not nil && this == nil")
	}
	if !this.RepBytes.Equal(that1.RepBytes) {
		return fmt.Errorf("RepBytes this(%v) Not Equal that(%v)", this.RepBytes, that1.RepBytes)
	}
	return nil
}
func (this *OneofProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OneofProtoTypes)
	if !ok {
		that2, ok := that.(OneofProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.OneOfProtoTimes == nil {
		if this.OneOfProtoTimes != nil {
			return false
		}
	} else if this.OneOfProtoTimes == nil {
		return false
	} else if !this.OneOfProtoTimes.Equal(that1.OneOfProtoTimes) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *OneofProtoTypes_Timestamp) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

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

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

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

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

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

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

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

	that1, ok := that.(*OneofProtoTypes_RepBytes)
	if !ok {
		that2, ok := that.(OneofProtoTypes_RepBytes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RepBytes.Equal(that1.RepBytes) {
		return false
	}
	return true
}
func (this *OneofStdTypes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes)
	if !ok {
		that2, ok := that.(OneofStdTypes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes but is not nil && this == nil")
	}
	if that1.OneOfStdTimes == nil {
		if this.OneOfStdTimes != nil {
			return fmt.Errorf("this.OneOfStdTimes != nil && that1.OneOfStdTimes == nil")
		}
	} else if this.OneOfStdTimes == nil {
		return fmt.Errorf("this.OneOfStdTimes == nil && that1.OneOfStdTimes != nil")
	} else if err := this.OneOfStdTimes.VerboseEqual(that1.OneOfStdTimes); err != nil {
		return err
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *OneofStdTypes_Timestamp) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_Timestamp)
	if !ok {
		that2, ok := that.(OneofStdTypes_Timestamp)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_Timestamp")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_Timestamp but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_Timestamp but is not nil && this == nil")
	}
	if that1.Timestamp == nil {
		if this.Timestamp != nil {
			return fmt.Errorf("this.Timestamp != nil && that1.Timestamp == nil")
		}
	} else if !this.Timestamp.Equal(*that1.Timestamp) {
		return fmt.Errorf("Timestamp this(%v) Not Equal that(%v)", this.Timestamp, that1.Timestamp)
	}
	return nil
}
func (this *OneofStdTypes_Duration) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_Duration)
	if !ok {
		that2, ok := that.(OneofStdTypes_Duration)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_Duration")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_Duration but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_Duration but is not nil && this == nil")
	}
	if this.Duration != nil && that1.Duration != nil {
		if *this.Duration != *that1.Duration {
			return fmt.Errorf("Duration this(%v) Not Equal that(%v)", *this.Duration, *that1.Duration)
		}
	} else if this.Duration != nil {
		return fmt.Errorf("this.Duration == nil && that.Duration != nil")
	} else if that1.Duration != nil {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
	}
	return nil
}
func (this *OneofStdTypes_RepDouble) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_RepDouble)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepDouble)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_RepDouble")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_RepDouble but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_RepDouble but is not nil && this == nil")
	}
	if this.RepDouble != nil && that1.RepDouble != nil {
		if *this.RepDouble != *that1.RepDouble {
			return fmt.Errorf("RepDouble this(%v) Not Equal that(%v)", *this.RepDouble, *that1.RepDouble)
		}
	} else if this.RepDouble != nil {
		return fmt.Errorf("this.RepDouble == nil && that.RepDouble != nil")
	} else if that1.RepDouble != nil {
		return fmt.Errorf("RepDouble this(%v) Not Equal that(%v)", this.RepDouble, that1.RepDouble)
	}
	return nil
}
func (this *OneofStdTypes_RepFloat) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_RepFloat)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepFloat)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_RepFloat")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_RepFloat but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_RepFloat but is not nil && this == nil")
	}
	if this.RepFloat != nil && that1.RepFloat != nil {
		if *this.RepFloat != *that1.RepFloat {
			return fmt.Errorf("RepFloat this(%v) Not Equal that(%v)", *this.RepFloat, *that1.RepFloat)
		}
	} else if this.RepFloat != nil {
		return fmt.Errorf("this.RepFloat == nil && that.RepFloat != nil")
	} else if that1.RepFloat != nil {
		return fmt.Errorf("RepFloat this(%v) Not Equal that(%v)", this.RepFloat, that1.RepFloat)
	}
	return nil
}
func (this *OneofStdTypes_RepInt64) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_RepInt64)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepInt64)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_RepInt64")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_RepInt64 but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_RepInt64 but is not nil && this == nil")
	}
	if this.RepInt64 != nil && that1.RepInt64 != nil {
		if *this.RepInt64 != *that1.RepInt64 {
			return fmt.Errorf("RepInt64 this(%v) Not Equal that(%v)", *this.RepInt64, *that1.RepInt64)
		}
	} else if this.RepInt64 != nil {
		return fmt.Errorf("this.RepInt64 == nil && that.RepInt64 != nil")
	} else if that1.RepInt64 != nil {
		return fmt.Errorf("RepInt64 this(%v) Not Equal that(%v)", this.RepInt64, that1.RepInt64)
	}
	return nil
}
func (this *OneofStdTypes_RepUInt64) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_RepUInt64)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepUInt64)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_RepUInt64")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_RepUInt64 but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_RepUInt64 but is not nil && this == nil")
	}
	if this.RepUInt64 != nil && that1.RepUInt64 != nil {
		if *this.RepUInt64 != *that1.RepUInt64 {
			return fmt.Errorf("RepUInt64 this(%v) Not Equal that(%v)", *this.RepUInt64, *that1.RepUInt64)
		}
	} else if this.RepUInt64 != nil {
		return fmt.Errorf("this.RepUInt64 == nil && that.RepUInt64 != nil")
	} else if that1.RepUInt64 != nil {
		return fmt.Errorf("RepUInt64 this(%v) Not Equal that(%v)", this.RepUInt64, that1.RepUInt64)
	}
	return nil
}
func (this *OneofStdTypes_RepInt32) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_RepInt32)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepInt32)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_RepInt32")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_RepInt32 but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_RepInt32 but is not nil && this == nil")
	}
	if this.RepInt32 != nil && that1.RepInt32 != nil {
		if *this.RepInt32 != *that1.RepInt32 {
			return fmt.Errorf("RepInt32 this(%v) Not Equal that(%v)", *this.RepInt32, *that1.RepInt32)
		}
	} else if this.RepInt32 != nil {
		return fmt.Errorf("this.RepInt32 == nil && that.RepInt32 != nil")
	} else if that1.RepInt32 != nil {
		return fmt.Errorf("RepInt32 this(%v) Not Equal that(%v)", this.RepInt32, that1.RepInt32)
	}
	return nil
}
func (this *OneofStdTypes_RepUInt32) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_RepUInt32)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepUInt32)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_RepUInt32")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_RepUInt32 but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_RepUInt32 but is not nil && this == nil")
	}
	if this.RepUInt32 != nil && that1.RepUInt32 != nil {
		if *this.RepUInt32 != *that1.RepUInt32 {
			return fmt.Errorf("RepUInt32 this(%v) Not Equal that(%v)", *this.RepUInt32, *that1.RepUInt32)
		}
	} else if this.RepUInt32 != nil {
		return fmt.Errorf("this.RepUInt32 == nil && that.RepUInt32 != nil")
	} else if that1.RepUInt32 != nil {
		return fmt.Errorf("RepUInt32 this(%v) Not Equal that(%v)", this.RepUInt32, that1.RepUInt32)
	}
	return nil
}
func (this *OneofStdTypes_RepBool) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_RepBool)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepBool)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_RepBool")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_RepBool but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_RepBool but is not nil && this == nil")
	}
	if this.RepBool != nil && that1.RepBool != nil {
		if *this.RepBool != *that1.RepBool {
			return fmt.Errorf("RepBool this(%v) Not Equal that(%v)", *this.RepBool, *that1.RepBool)
		}
	} else if this.RepBool != nil {
		return fmt.Errorf("this.RepBool == nil && that.RepBool != nil")
	} else if that1.RepBool != nil {
		return fmt.Errorf("RepBool this(%v) Not Equal that(%v)", this.RepBool, that1.RepBool)
	}
	return nil
}
func (this *OneofStdTypes_RepString) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_RepString)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepString)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_RepString")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_RepString but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_RepString but is not nil && this == nil")
	}
	if this.RepString != nil && that1.RepString != nil {
		if *this.RepString != *that1.RepString {
			return fmt.Errorf("RepString this(%v) Not Equal that(%v)", *this.RepString, *that1.RepString)
		}
	} else if this.RepString != nil {
		return fmt.Errorf("this.RepString == nil && that.RepString != nil")
	} else if that1.RepString != nil {
		return fmt.Errorf("RepString this(%v) Not Equal that(%v)", this.RepString, that1.RepString)
	}
	return nil
}
func (this *OneofStdTypes_RepBytes) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*OneofStdTypes_RepBytes)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepBytes)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *OneofStdTypes_RepBytes")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *OneofStdTypes_RepBytes but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *OneofStdTypes_RepBytes but is not nil && this == nil")
	}
	if that1.RepBytes == nil {
		if this.RepBytes != nil {
			return fmt.Errorf("this.RepBytes != nil && that1.RepBytes == nil")
		}
	} else if !bytes.Equal(*this.RepBytes, *that1.RepBytes) {
		return fmt.Errorf("RepBytes this(%v) Not Equal that(%v)", this.RepBytes, that1.RepBytes)
	}
	return nil
}
func (this *OneofStdTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OneofStdTypes)
	if !ok {
		that2, ok := that.(OneofStdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.OneOfStdTimes == nil {
		if this.OneOfStdTimes != nil {
			return false
		}
	} else if this.OneOfStdTimes == nil {
		return false
	} else if !this.OneOfStdTimes.Equal(that1.OneOfStdTimes) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *OneofStdTypes_Timestamp) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

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

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

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

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

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

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

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

	that1, ok := that.(*OneofStdTypes_RepBytes)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepBytes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.RepBytes == nil {
		if this.RepBytes != nil {
			return false
		}
	} else if !bytes.Equal(*this.RepBytes, *that1.RepBytes) {
		return false
	}
	return true
}
func (m *KnownTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *KnownTypes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.St != nil {
		{
			size, err := m.St.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.Bytes != nil {
		{
			size, err := m.Bytes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.Str != nil {
		{
			size, err := m.Str.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.Bool != nil {
		{
			size, err := m.Bool.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.U32 != nil {
		{
			size, err := m.U32.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.I32 != nil {
		{
			size, err := m.I32.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.U64 != nil {
		{
			size, err := m.U64.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.I64 != nil {
		{
			size, err := m.I64.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Flt != nil {
		{
			size, err := m.Flt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Dbl != nil {
		{
			size, err := m.Dbl.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Ts != nil {
		{
			size, err := m.Ts.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Dur != nil {
		{
			size, err := m.Dur.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ProtoTypes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.NonnullBytes.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xb2
	{
		size, err := m.NonnullString.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xaa
	{
		size, err := m.NonnullBool.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xa2
	{
		size, err := m.NonnullUInt32.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x9a
	{
		size, err := m.NonnullInt32.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	{
		size, err := m.NonnullUInt64.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	{
		size, err := m.NonnullInt64.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size, err := m.NonnullFloat.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	{
		size, err := m.NonnullDouble.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x72
	{
		size, err := m.Duration.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6a
	{
		size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	if m.NullableBytes != nil {
		{
			size, err := m.NullableBytes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.NullableString != nil {
		{
			size, err := m.NullableString.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.NullableBool != nil {
		{
			size, err := m.NullableBool.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.NullableUInt32 != nil {
		{
			size, err := m.NullableUInt32.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.NullableInt32 != nil {
		{
			size, err := m.NullableInt32.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.NullableUInt64 != nil {
		{
			size, err := m.NullableUInt64.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.NullableInt64 != nil {
		{
			size, err := m.NullableInt64.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.NullableFloat != nil {
		{
			size, err := m.NullableFloat.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.NullableDouble != nil {
		{
			size, err := m.NullableDouble.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.NullableDuration != nil {
		{
			size, err := m.NullableDuration.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.NullableTimestamp != nil {
		{
			size, err := m.NullableTimestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *StdTypes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	n35, err35 := github_com_gogo_protobuf_types.StdBytesMarshalTo(m.NonnullBytes, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBytes(m.NonnullBytes):])
	if err35 != nil {
		return 0, err35
	}
	i -= n35
	i = encodeVarintTypes(dAtA, i, uint64(n35))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xb2
	n36, err36 := github_com_gogo_protobuf_types.StdStringMarshalTo(m.NonnullString, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdString(m.NonnullString):])
	if err36 != nil {
		return 0, err36
	}
	i -= n36
	i = encodeVarintTypes(dAtA, i, uint64(n36))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xaa
	n37, err37 := github_com_gogo_protobuf_types.StdBoolMarshalTo(m.NonnullBool, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBool(m.NonnullBool):])
	if err37 != nil {
		return 0, err37
	}
	i -= n37
	i = encodeVarintTypes(dAtA, i, uint64(n37))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xa2
	n38, err38 := github_com_gogo_protobuf_types.StdUInt32MarshalTo(m.NonnullUInt32, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(m.NonnullUInt32):])
	if err38 != nil {
		return 0, err38
	}
	i -= n38
	i = encodeVarintTypes(dAtA, i, uint64(n38))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x9a
	n39, err39 := github_com_gogo_protobuf_types.StdInt32MarshalTo(m.NonnullInt32, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt32(m.NonnullInt32):])
	if err39 != nil {
		return 0, err39
	}
	i -= n39
	i = encodeVarintTypes(dAtA, i, uint64(n39))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	n40, err40 := github_com_gogo_protobuf_types.StdUInt64MarshalTo(m.NonnullUInt64, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt64(m.NonnullUInt64):])
	if err40 != nil {
		return 0, err40
	}
	i -= n40
	i = encodeVarintTypes(dAtA, i, uint64(n40))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	n41, err41 := github_com_gogo_protobuf_types.StdInt64MarshalTo(m.NonnullInt64, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt64(m.NonnullInt64):])
	if err41 != nil {
		return 0, err41
	}
	i -= n41
	i = encodeVarintTypes(dAtA, i, uint64(n41))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	n42, err42 := github_com_gogo_protobuf_types.StdFloatMarshalTo(m.NonnullFloat, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdFloat(m.NonnullFloat):])
	if err42 != nil {
		return 0, err42
	}
	i -= n42
	i = encodeVarintTypes(dAtA, i, uint64(n42))
	i--
	dAtA[i] = 0x7a
	n43, err43 := github_com_gogo_protobuf_types.StdDoubleMarshalTo(m.NonnullDouble, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDouble(m.NonnullDouble):])
	if err43 != nil {
		return 0, err43
	}
	i -= n43
	i = encodeVarintTypes(dAtA, i, uint64(n43))
	i--
	dAtA[i] = 0x72
	n44, err44 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):])
	if err44 != nil {
		return 0, err44
	}
	i -= n44
	i = encodeVarintTypes(dAtA, i, uint64(n44))
	i--
	dAtA[i] = 0x6a
	n45, err45 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
	if err45 != nil {
		return 0, err45
	}
	i -= n45
	i = encodeVarintTypes(dAtA, i, uint64(n45))
	i--
	dAtA[i] = 0x62
	if m.NullableBytes != nil {
		n46, err46 := github_com_gogo_protobuf_types.StdBytesMarshalTo(*m.NullableBytes, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBytes(*m.NullableBytes):])
		if err46 != nil {
			return 0, err46
		}
		i -= n46
		i = encodeVarintTypes(dAtA, i, uint64(n46))
		i--
		dAtA[i] = 0x5a
	}
	if m.NullableString != nil {
		n47, err47 := github_com_gogo_protobuf_types.StdStringMarshalTo(*m.NullableString, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdString(*m.NullableString):])
		if err47 != nil {
			return 0, err47
		}
		i -= n47
		i = encodeVarintTypes(dAtA, i, uint64(n47))
		i--
		dAtA[i] = 0x52
	}
	if m.NullableBool != nil {
		n48, err48 := github_com_gogo_protobuf_types.StdBoolMarshalTo(*m.NullableBool, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBool(*m.NullableBool):])
		if err48 != nil {
			return 0, err48
		}
		i -= n48
		i = encodeVarintTypes(dAtA, i, uint64(n48))
		i--
		dAtA[i] = 0x4a
	}
	if m.NullableUInt32 != nil {
		n49, err49 := github_com_gogo_protobuf_types.StdUInt32MarshalTo(*m.NullableUInt32, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.NullableUInt32):])
		if err49 != nil {
			return 0, err49
		}
		i -= n49
		i = encodeVarintTypes(dAtA, i, uint64(n49))
		i--
		dAtA[i] = 0x42
	}
	if m.NullableInt32 != nil {
		n50, err50 := github_com_gogo_protobuf_types.StdInt32MarshalTo(*m.NullableInt32, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt32(*m.NullableInt32):])
		if err50 != nil {
			return 0, err50
		}
		i -= n50
		i = encodeVarintTypes(dAtA, i, uint64(n50))
		i--
		dAtA[i] = 0x3a
	}
	if m.NullableUInt64 != nil {
		n51, err51 := github_com_gogo_protobuf_types.StdUInt64MarshalTo(*m.NullableUInt64, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt64(*m.NullableUInt64):])
		if err51 != nil {
			return 0, err51
		}
		i -= n51
		i = encodeVarintTypes(dAtA, i, uint64(n51))
		i--
		dAtA[i] = 0x32
	}
	if m.NullableInt64 != nil {
		n52, err52 := github_com_gogo_protobuf_types.StdInt64MarshalTo(*m.NullableInt64, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt64(*m.NullableInt64):])
		if err52 != nil {
			return 0, err52
		}
		i -= n52
		i = encodeVarintTypes(dAtA, i, uint64(n52))
		i--
		dAtA[i] = 0x2a
	}
	if m.NullableFloat != nil {
		n53, err53 := github_com_gogo_protobuf_types.StdFloatMarshalTo(*m.NullableFloat, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdFloat(*m.NullableFloat):])
		if err53 != nil {
			return 0, err53
		}
		i -= n53
		i = encodeVarintTypes(dAtA, i, uint64(n53))
		i--
		dAtA[i] = 0x22
	}
	if m.NullableDouble != nil {
		n54, err54 := github_com_gogo_protobuf_types.StdDoubleMarshalTo(*m.NullableDouble, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDouble(*m.NullableDouble):])
		if err54 != nil {
			return 0, err54
		}
		i -= n54
		i = encodeVarintTypes(dAtA, i, uint64(n54))
		i--
		dAtA[i] = 0x1a
	}
	if m.NullableDuration != nil {
		n55, err55 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.NullableDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.NullableDuration):])
		if err55 != nil {
			return 0, err55
		}
		i -= n55
		i = encodeVarintTypes(dAtA, i, uint64(n55))
		i--
		dAtA[i] = 0x12
	}
	if m.NullableTimestamp != nil {
		n56, err56 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.NullableTimestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.NullableTimestamp):])
		if err56 != nil {
			return 0, err56
		}
		i -= n56
		i = encodeVarintTypes(dAtA, i, uint64(n56))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *RepProtoTypes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.NonnullBytes) > 0 {
		for iNdEx := len(m.NonnullBytes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NonnullBytes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.NullableBytes) > 0 {
		for iNdEx := len(m.NullableBytes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableBytes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.NonnullString) > 0 {
		for iNdEx := len(m.NonnullString) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NonnullString[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.NullableString) > 0 {
		for iNdEx := len(m.NullableString) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableString[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.NonnullBool) > 0 {
		for iNdEx := len(m.NonnullBool) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NonnullBool[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.NullableBool) > 0 {
		for iNdEx := len(m.NullableBool) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableBool[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.NonnullUInt32) > 0 {
		for iNdEx := len(m.NonnullUInt32) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NonnullUInt32[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.NullableUInt32) > 0 {
		for iNdEx := len(m.NullableUInt32) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableUInt32[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.NonnullInt32) > 0 {
		for iNdEx := len(m.NonnullInt32) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NonnullInt32[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.NullableInt32) > 0 {
		for iNdEx := len(m.NullableInt32) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableInt32[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.NonnullUInt64) > 0 {
		for iNdEx := len(m.NonnullUInt64) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NonnullUInt64[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.NullableUInt64) > 0 {
		for iNdEx := len(m.NullableUInt64) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableUInt64[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.NonnullInt64) > 0 {
		for iNdEx := len(m.NonnullInt64) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NonnullInt64[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.NullableInt64) > 0 {
		for iNdEx := len(m.NullableInt64) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableInt64[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.NonnullFloat) > 0 {
		for iNdEx := len(m.NonnullFloat) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NonnullFloat[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.NullableFloat) > 0 {
		for iNdEx := len(m.NullableFloat) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableFloat[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.NonnullDouble) > 0 {
		for iNdEx := len(m.NonnullDouble) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NonnullDouble[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.NullableDouble) > 0 {
		for iNdEx := len(m.NullableDouble) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableDouble[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Durations) > 0 {
		for iNdEx := len(m.Durations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Durations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Timestamps) > 0 {
		for iNdEx := len(m.Timestamps) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Timestamps[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.NullableDurations) > 0 {
		for iNdEx := len(m.NullableDurations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableDurations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.NullableTimestamps) > 0 {
		for iNdEx := len(m.NullableTimestamps) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NullableTimestamps[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *RepStdTypes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.NonnullBytes) > 0 {
		for iNdEx := len(m.NonnullBytes) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdBytesMarshalTo(m.NonnullBytes[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBytes(m.NonnullBytes[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.NullableBytes) > 0 {
		for iNdEx := len(m.NullableBytes) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdBytesMarshalTo(*m.NullableBytes[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBytes(*m.NullableBytes[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.NonnullString) > 0 {
		for iNdEx := len(m.NonnullString) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdStringMarshalTo(m.NonnullString[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdString(m.NonnullString[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.NullableString) > 0 {
		for iNdEx := len(m.NullableString) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdStringMarshalTo(*m.NullableString[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdString(*m.NullableString[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.NonnullBool) > 0 {
		for iNdEx := len(m.NonnullBool) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdBoolMarshalTo(m.NonnullBool[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBool(m.NonnullBool[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.NullableBool) > 0 {
		for iNdEx := len(m.NullableBool) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdBoolMarshalTo(*m.NullableBool[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBool(*m.NullableBool[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.NonnullUInt32) > 0 {
		for iNdEx := len(m.NonnullUInt32) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdUInt32MarshalTo(m.NonnullUInt32[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(m.NonnullUInt32[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.NullableUInt32) > 0 {
		for iNdEx := len(m.NullableUInt32) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdUInt32MarshalTo(*m.NullableUInt32[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.NullableUInt32[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.NonnullInt32) > 0 {
		for iNdEx := len(m.NonnullInt32) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdInt32MarshalTo(m.NonnullInt32[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt32(m.NonnullInt32[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.NullableInt32) > 0 {
		for iNdEx := len(m.NullableInt32) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdInt32MarshalTo(*m.NullableInt32[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt32(*m.NullableInt32[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.NonnullUInt64) > 0 {
		for iNdEx := len(m.NonnullUInt64) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdUInt64MarshalTo(m.NonnullUInt64[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt64(m.NonnullUInt64[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.NullableUInt64) > 0 {
		for iNdEx := len(m.NullableUInt64) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdUInt64MarshalTo(*m.NullableUInt64[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt64(*m.NullableUInt64[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.NonnullInt64) > 0 {
		for iNdEx := len(m.NonnullInt64) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdInt64MarshalTo(m.NonnullInt64[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt64(m.NonnullInt64[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.NullableInt64) > 0 {
		for iNdEx := len(m.NullableInt64) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdInt64MarshalTo(*m.NullableInt64[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt64(*m.NullableInt64[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.NonnullFloat) > 0 {
		for iNdEx := len(m.NonnullFloat) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdFloatMarshalTo(m.NonnullFloat[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdFloat(m.NonnullFloat[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.NullableFloat) > 0 {
		for iNdEx := len(m.NullableFloat) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdFloatMarshalTo(*m.NullableFloat[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdFloat(*m.NullableFloat[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.NonnullDouble) > 0 {
		for iNdEx := len(m.NonnullDouble) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdDoubleMarshalTo(m.NonnullDouble[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDouble(m.NonnullDouble[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.NullableDouble) > 0 {
		for iNdEx := len(m.NullableDouble) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdDoubleMarshalTo(*m.NullableDouble[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDouble(*m.NullableDouble[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Durations) > 0 {
		for iNdEx := len(m.Durations) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Durations[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Durations[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Timestamps) > 0 {
		for iNdEx := len(m.Timestamps) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamps[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamps[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.NullableDurations) > 0 {
		for iNdEx := len(m.NullableDurations) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.NullableDurations[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.NullableDurations[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.NullableTimestamps) > 0 {
		for iNdEx := len(m.NullableTimestamps) - 1; iNdEx >= 0; iNdEx-- {
			n, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.NullableTimestamps[iNdEx], dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.NullableTimestamps[iNdEx]):])
			if err != nil {
				return 0, err
			}
			i -= n
			i = encodeVarintTypes(dAtA, i, uint64(n))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *MapProtoTypes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.NonnullBytes) > 0 {
		for k := range m.NonnullBytes {
			v := m.NonnullBytes[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.NullableBytes) > 0 {
		for k := range m.NullableBytes {
			v := m.NullableBytes[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.NonnullString) > 0 {
		for k := range m.NonnullString {
			v := m.NonnullString[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.NullableString) > 0 {
		for k := range m.NullableString {
			v := m.NullableString[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.NonnullBool) > 0 {
		for k := range m.NonnullBool {
			v := m.NonnullBool[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.NullableBool) > 0 {
		for k := range m.NullableBool {
			v := m.NullableBool[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.NonnullUInt32) > 0 {
		for k := range m.NonnullUInt32 {
			v := m.NonnullUInt32[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.NullableUInt32) > 0 {
		for k := range m.NullableUInt32 {
			v := m.NullableUInt32[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.NonnullInt32) > 0 {
		for k := range m.NonnullInt32 {
			v := m.NonnullInt32[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.NullableInt32) > 0 {
		for k := range m.NullableInt32 {
			v := m.NullableInt32[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.NonnullUInt64) > 0 {
		for k := range m.NonnullUInt64 {
			v := m.NonnullUInt64[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.NullableUInt64) > 0 {
		for k := range m.NullableUInt64 {
			v := m.NullableUInt64[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.NonnullInt64) > 0 {
		for k := range m.NonnullInt64 {
			v := m.NonnullInt64[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.NullableInt64) > 0 {
		for k := range m.NullableInt64 {
			v := m.NullableInt64[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.NonnullFloat) > 0 {
		for k := range m.NonnullFloat {
			v := m.NonnullFloat[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.NullableFloat) > 0 {
		for k := range m.NullableFloat {
			v := m.NullableFloat[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.NonnullDouble) > 0 {
		for k := range m.NonnullDouble {
			v := m.NonnullDouble[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.NullableDouble) > 0 {
		for k := range m.NullableDouble {
			v := m.NullableDouble[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Duration) > 0 {
		for k := range m.Duration {
			v := m.Duration[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.NullableDuration) > 0 {
		for k := range m.NullableDuration {
			v := m.NullableDuration[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Timestamp) > 0 {
		for k := range m.Timestamp {
			v := m.Timestamp[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.NullableTimestamp) > 0 {
		for k := range m.NullableTimestamp {
			v := m.NullableTimestamp[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTypes(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *MapStdTypes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.NonnullBytes) > 0 {
		for k := range m.NonnullBytes {
			v := m.NonnullBytes[k]
			baseI := i
			n79, err79 := github_com_gogo_protobuf_types.StdBytesMarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBytes((*(&v))):])
			if err79 != nil {
				return 0, err79
			}
			i -= n79
			i = encodeVarintTypes(dAtA, i, uint64(n79))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.NullableBytes) > 0 {
		for k := range m.NullableBytes {
			v := m.NullableBytes[k]
			baseI := i
			if v != nil {
				n80, err80 := github_com_gogo_protobuf_types.StdBytesMarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBytes((*v)):])
				if err80 != nil {
					return 0, err80
				}
				i -= n80
				i = encodeVarintTypes(dAtA, i, uint64(n80))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.NonnullString) > 0 {
		for k := range m.NonnullString {
			v := m.NonnullString[k]
			baseI := i
			n81, err81 := github_com_gogo_protobuf_types.StdStringMarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdString((*(&v))):])
			if err81 != nil {
				return 0, err81
			}
			i -= n81
			i = encodeVarintTypes(dAtA, i, uint64(n81))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.NullableString) > 0 {
		for k := range m.NullableString {
			v := m.NullableString[k]
			baseI := i
			if v != nil {
				n82, err82 := github_com_gogo_protobuf_types.StdStringMarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdString((*v)):])
				if err82 != nil {
					return 0, err82
				}
				i -= n82
				i = encodeVarintTypes(dAtA, i, uint64(n82))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.NonnullBool) > 0 {
		for k := range m.NonnullBool {
			v := m.NonnullBool[k]
			baseI := i
			n83, err83 := github_com_gogo_protobuf_types.StdBoolMarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBool((*(&v))):])
			if err83 != nil {
				return 0, err83
			}
			i -= n83
			i = encodeVarintTypes(dAtA, i, uint64(n83))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.NullableBool) > 0 {
		for k := range m.NullableBool {
			v := m.NullableBool[k]
			baseI := i
			if v != nil {
				n84, err84 := github_com_gogo_protobuf_types.StdBoolMarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBool((*v)):])
				if err84 != nil {
					return 0, err84
				}
				i -= n84
				i = encodeVarintTypes(dAtA, i, uint64(n84))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.NonnullUInt32) > 0 {
		for k := range m.NonnullUInt32 {
			v := m.NonnullUInt32[k]
			baseI := i
			n85, err85 := github_com_gogo_protobuf_types.StdUInt32MarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32((*(&v))):])
			if err85 != nil {
				return 0, err85
			}
			i -= n85
			i = encodeVarintTypes(dAtA, i, uint64(n85))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.NullableUInt32) > 0 {
		for k := range m.NullableUInt32 {
			v := m.NullableUInt32[k]
			baseI := i
			if v != nil {
				n86, err86 := github_com_gogo_protobuf_types.StdUInt32MarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32((*v)):])
				if err86 != nil {
					return 0, err86
				}
				i -= n86
				i = encodeVarintTypes(dAtA, i, uint64(n86))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.NonnullInt32) > 0 {
		for k := range m.NonnullInt32 {
			v := m.NonnullInt32[k]
			baseI := i
			n87, err87 := github_com_gogo_protobuf_types.StdInt32MarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt32((*(&v))):])
			if err87 != nil {
				return 0, err87
			}
			i -= n87
			i = encodeVarintTypes(dAtA, i, uint64(n87))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.NullableInt32) > 0 {
		for k := range m.NullableInt32 {
			v := m.NullableInt32[k]
			baseI := i
			if v != nil {
				n88, err88 := github_com_gogo_protobuf_types.StdInt32MarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt32((*v)):])
				if err88 != nil {
					return 0, err88
				}
				i -= n88
				i = encodeVarintTypes(dAtA, i, uint64(n88))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.NonnullUInt64) > 0 {
		for k := range m.NonnullUInt64 {
			v := m.NonnullUInt64[k]
			baseI := i
			n89, err89 := github_com_gogo_protobuf_types.StdUInt64MarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt64((*(&v))):])
			if err89 != nil {
				return 0, err89
			}
			i -= n89
			i = encodeVarintTypes(dAtA, i, uint64(n89))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.NullableUInt64) > 0 {
		for k := range m.NullableUInt64 {
			v := m.NullableUInt64[k]
			baseI := i
			if v != nil {
				n90, err90 := github_com_gogo_protobuf_types.StdUInt64MarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt64((*v)):])
				if err90 != nil {
					return 0, err90
				}
				i -= n90
				i = encodeVarintTypes(dAtA, i, uint64(n90))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.NonnullInt64) > 0 {
		for k := range m.NonnullInt64 {
			v := m.NonnullInt64[k]
			baseI := i
			n91, err91 := github_com_gogo_protobuf_types.StdInt64MarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt64((*(&v))):])
			if err91 != nil {
				return 0, err91
			}
			i -= n91
			i = encodeVarintTypes(dAtA, i, uint64(n91))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.NullableInt64) > 0 {
		for k := range m.NullableInt64 {
			v := m.NullableInt64[k]
			baseI := i
			if v != nil {
				n92, err92 := github_com_gogo_protobuf_types.StdInt64MarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt64((*v)):])
				if err92 != nil {
					return 0, err92
				}
				i -= n92
				i = encodeVarintTypes(dAtA, i, uint64(n92))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.NonnullFloat) > 0 {
		for k := range m.NonnullFloat {
			v := m.NonnullFloat[k]
			baseI := i
			n93, err93 := github_com_gogo_protobuf_types.StdFloatMarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdFloat((*(&v))):])
			if err93 != nil {
				return 0, err93
			}
			i -= n93
			i = encodeVarintTypes(dAtA, i, uint64(n93))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.NullableFloat) > 0 {
		for k := range m.NullableFloat {
			v := m.NullableFloat[k]
			baseI := i
			if v != nil {
				n94, err94 := github_com_gogo_protobuf_types.StdFloatMarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdFloat((*v)):])
				if err94 != nil {
					return 0, err94
				}
				i -= n94
				i = encodeVarintTypes(dAtA, i, uint64(n94))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.NonnullDouble) > 0 {
		for k := range m.NonnullDouble {
			v := m.NonnullDouble[k]
			baseI := i
			n95, err95 := github_com_gogo_protobuf_types.StdDoubleMarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDouble((*(&v))):])
			if err95 != nil {
				return 0, err95
			}
			i -= n95
			i = encodeVarintTypes(dAtA, i, uint64(n95))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.NullableDouble) > 0 {
		for k := range m.NullableDouble {
			v := m.NullableDouble[k]
			baseI := i
			if v != nil {
				n96, err96 := github_com_gogo_protobuf_types.StdDoubleMarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDouble((*v)):])
				if err96 != nil {
					return 0, err96
				}
				i -= n96
				i = encodeVarintTypes(dAtA, i, uint64(n96))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Duration) > 0 {
		for k := range m.Duration {
			v := m.Duration[k]
			baseI := i
			n97, err97 := github_com_gogo_protobuf_types.StdDurationMarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration((*(&v))):])
			if err97 != nil {
				return 0, err97
			}
			i -= n97
			i = encodeVarintTypes(dAtA, i, uint64(n97))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.NullableDuration) > 0 {
		for k := range m.NullableDuration {
			v := m.NullableDuration[k]
			baseI := i
			if v != nil {
				n98, err98 := github_com_gogo_protobuf_types.StdDurationMarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration((*v)):])
				if err98 != nil {
					return 0, err98
				}
				i -= n98
				i = encodeVarintTypes(dAtA, i, uint64(n98))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Timestamp) > 0 {
		for k := range m.Timestamp {
			v := m.Timestamp[k]
			baseI := i
			n99, err99 := github_com_gogo_protobuf_types.StdTimeMarshalTo((*(&v)), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime((*(&v))):])
			if err99 != nil {
				return 0, err99
			}
			i -= n99
			i = encodeVarintTypes(dAtA, i, uint64(n99))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.NullableTimestamp) > 0 {
		for k := range m.NullableTimestamp {
			v := m.NullableTimestamp[k]
			baseI := i
			if v != nil {
				n100, err100 := github_com_gogo_protobuf_types.StdTimeMarshalTo((*v), dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime((*v)):])
				if err100 != nil {
					return 0, err100
				}
				i -= n100
				i = encodeVarintTypes(dAtA, i, uint64(n100))
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *OneofProtoTypes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.OneOfProtoTimes != nil {
		{
			size := m.OneOfProtoTimes.Size()
			i -= size
			if _, err := m.OneOfProtoTimes.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *OneofProtoTypes_Timestamp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Timestamp != nil {
		{
			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *OneofProtoTypes_Duration) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofProtoTypes_Duration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Duration != nil {
		{
			size, err := m.Duration.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *OneofProtoTypes_RepDouble) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofProtoTypes_RepDouble) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepDouble != nil {
		{
			size, err := m.RepDouble.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *OneofProtoTypes_RepFloat) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofProtoTypes_RepFloat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepFloat != nil {
		{
			size, err := m.RepFloat.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *OneofProtoTypes_RepInt64) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofProtoTypes_RepInt64) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepInt64 != nil {
		{
			size, err := m.RepInt64.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *OneofProtoTypes_RepUInt64) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofProtoTypes_RepUInt64) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepUInt64 != nil {
		{
			size, err := m.RepUInt64.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *OneofProtoTypes_RepInt32) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofProtoTypes_RepInt32) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepInt32 != nil {
		{
			size, err := m.RepInt32.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *OneofProtoTypes_RepUInt32) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofProtoTypes_RepUInt32) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepUInt32 != nil {
		{
			size, err := m.RepUInt32.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *OneofProtoTypes_RepBool) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofProtoTypes_RepBool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepBool != nil {
		{
			size, err := m.RepBool.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *OneofProtoTypes_RepString) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofProtoTypes_RepString) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepString != nil {
		{
			size, err := m.RepString.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *OneofProtoTypes_RepBytes) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofProtoTypes_RepBytes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepBytes != nil {
		{
			size, err := m.RepBytes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *OneofStdTypes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.OneOfStdTimes != nil {
		{
			size := m.OneOfStdTimes.Size()
			i -= size
			if _, err := m.OneOfStdTimes.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *OneofStdTypes_Timestamp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Timestamp != nil {
		n112, err112 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp):])
		if err112 != nil {
			return 0, err112
		}
		i -= n112
		i = encodeVarintTypes(dAtA, i, uint64(n112))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes_Duration) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofStdTypes_Duration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Duration != nil {
		n113, err113 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Duration):])
		if err113 != nil {
			return 0, err113
		}
		i -= n113
		i = encodeVarintTypes(dAtA, i, uint64(n113))
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes_RepDouble) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofStdTypes_RepDouble) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepDouble != nil {
		n114, err114 := github_com_gogo_protobuf_types.StdDoubleMarshalTo(*m.RepDouble, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDouble(*m.RepDouble):])
		if err114 != nil {
			return 0, err114
		}
		i -= n114
		i = encodeVarintTypes(dAtA, i, uint64(n114))
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes_RepFloat) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofStdTypes_RepFloat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepFloat != nil {
		n115, err115 := github_com_gogo_protobuf_types.StdFloatMarshalTo(*m.RepFloat, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdFloat(*m.RepFloat):])
		if err115 != nil {
			return 0, err115
		}
		i -= n115
		i = encodeVarintTypes(dAtA, i, uint64(n115))
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes_RepInt64) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofStdTypes_RepInt64) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepInt64 != nil {
		n116, err116 := github_com_gogo_protobuf_types.StdInt64MarshalTo(*m.RepInt64, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt64(*m.RepInt64):])
		if err116 != nil {
			return 0, err116
		}
		i -= n116
		i = encodeVarintTypes(dAtA, i, uint64(n116))
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes_RepUInt64) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofStdTypes_RepUInt64) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepUInt64 != nil {
		n117, err117 := github_com_gogo_protobuf_types.StdUInt64MarshalTo(*m.RepUInt64, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt64(*m.RepUInt64):])
		if err117 != nil {
			return 0, err117
		}
		i -= n117
		i = encodeVarintTypes(dAtA, i, uint64(n117))
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes_RepInt32) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofStdTypes_RepInt32) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepInt32 != nil {
		n118, err118 := github_com_gogo_protobuf_types.StdInt32MarshalTo(*m.RepInt32, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdInt32(*m.RepInt32):])
		if err118 != nil {
			return 0, err118
		}
		i -= n118
		i = encodeVarintTypes(dAtA, i, uint64(n118))
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes_RepUInt32) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofStdTypes_RepUInt32) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepUInt32 != nil {
		n119, err119 := github_com_gogo_protobuf_types.StdUInt32MarshalTo(*m.RepUInt32, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.RepUInt32):])
		if err119 != nil {
			return 0, err119
		}
		i -= n119
		i = encodeVarintTypes(dAtA, i, uint64(n119))
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes_RepBool) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofStdTypes_RepBool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepBool != nil {
		n120, err120 := github_com_gogo_protobuf_types.StdBoolMarshalTo(*m.RepBool, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBool(*m.RepBool):])
		if err120 != nil {
			return 0, err120
		}
		i -= n120
		i = encodeVarintTypes(dAtA, i, uint64(n120))
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes_RepString) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofStdTypes_RepString) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepString != nil {
		n121, err121 := github_com_gogo_protobuf_types.StdStringMarshalTo(*m.RepString, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdString(*m.RepString):])
		if err121 != nil {
			return 0, err121
		}
		i -= n121
		i = encodeVarintTypes(dAtA, i, uint64(n121))
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *OneofStdTypes_RepBytes) MarshalTo(dAtA []byte) (int, error) {
	return m.MarshalToSizedBuffer(dAtA[:m.Size()])
}

func (m *OneofStdTypes_RepBytes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RepBytes != nil {
		n122, err122 := github_com_gogo_protobuf_types.StdBytesMarshalTo(*m.RepBytes, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdBytes(*m.RepBytes):])
		if err122 != nil {
			return 0, err122
		}
		i -= n122
		i = encodeVarintTypes(dAtA, i, uint64(n122))
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovTypes(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedKnownTypes(r randyTypes, easy bool) *KnownTypes {
	this := &KnownTypes{}
	if r.Intn(5) != 0 {
		this.Dur = types.NewPopulatedDuration(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Ts = types.NewPopulatedTimestamp(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Dbl = types.NewPopulatedDoubleValue(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Flt = types.NewPopulatedFloatValue(r, easy)
	}
	if r.Intn(5) != 0 {
		this.I64 = types.NewPopulatedInt64Value(r, easy)
	}
	if r.Intn(5) != 0 {
		this.U64 = types.NewPopulatedUInt64Value(r, easy)
	}
	if r.Intn(5) != 0 {
		this.I32 = types.NewPopulatedInt32Value(r, easy)
	}
	if r.Intn(5) != 0 {
		this.U32 = types.NewPopulatedUInt32Value(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Bool = types.NewPopulatedBoolValue(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Str = types.NewPopulatedStringValue(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Bytes = types.NewPopulatedBytesValue(r, easy)
	}
	if r.Intn(5) != 0 {
		this.St = types.NewPopulatedStruct(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 13)
	}
	return this
}

func NewPopulatedProtoTypes(r randyTypes, easy bool) *ProtoTypes {
	this := &ProtoTypes{}
	if r.Intn(5) != 0 {
		this.NullableTimestamp = types.NewPopulatedTimestamp(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableDuration = types.NewPopulatedDuration(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableDouble = types.NewPopulatedDoubleValue(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableFloat = types.NewPopulatedFloatValue(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableInt64 = types.NewPopulatedInt64Value(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableUInt64 = types.NewPopulatedUInt64Value(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableInt32 = types.NewPopulatedInt32Value(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableUInt32 = types.NewPopulatedUInt32Value(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableBool = types.NewPopulatedBoolValue(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableString = types.NewPopulatedStringValue(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableBytes = types.NewPopulatedBytesValue(r, easy)
	}
	v1 := types.NewPopulatedTimestamp(r, easy)
	this.Timestamp = *v1
	v2 := types.NewPopulatedDuration(r, easy)
	this.Duration = *v2
	v3 := types.NewPopulatedDoubleValue(r, easy)
	this.NonnullDouble = *v3
	v4 := types.NewPopulatedFloatValue(r, easy)
	this.NonnullFloat = *v4
	v5 := types.NewPopulatedInt64Value(r, easy)
	this.NonnullInt64 = *v5
	v6 := types.NewPopulatedUInt64Value(r, easy)
	this.NonnullUInt64 = *v6
	v7 := types.NewPopulatedInt32Value(r, easy)
	this.NonnullInt32 = *v7
	v8 := types.NewPopulatedUInt32Value(r, easy)
	this.NonnullUInt32 = *v8
	v9 := types.NewPopulatedBoolValue(r, easy)
	this.NonnullBool = *v9
	v10 := types.NewPopulatedStringValue(r, easy)
	this.NonnullString = *v10
	v11 := types.NewPopulatedBytesValue(r, easy)
	this.NonnullBytes = *v11
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 23)
	}
	return this
}

func NewPopulatedStdTypes(r randyTypes, easy bool) *StdTypes {
	this := &StdTypes{}
	if r.Intn(5) != 0 {
		this.NullableTimestamp = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableDuration = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableDouble = github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableFloat = github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableInt64 = github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableUInt64 = github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableInt32 = github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableUInt32 = github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableBool = github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableString = github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NullableBytes = github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
	}
	v12 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.Timestamp = *v12
	v13 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
	this.Duration = *v13
	v14 := github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
	this.NonnullDouble = *v14
	v15 := github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
	this.NonnullFloat = *v15
	v16 := github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
	this.NonnullInt64 = *v16
	v17 := github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
	this.NonnullUInt64 = *v17
	v18 := github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
	this.NonnullInt32 = *v18
	v19 := github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
	this.NonnullUInt32 = *v19
	v20 := github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
	this.NonnullBool = *v20
	v21 := github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
	this.NonnullString = *v21
	v22 := github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
	this.NonnullBytes = *v22
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 23)
	}
	return this
}

func NewPopulatedRepProtoTypes(r randyTypes, easy bool) *RepProtoTypes {
	this := &RepProtoTypes{}
	if r.Intn(5) != 0 {
		v23 := r.Intn(5)
		this.NullableTimestamps = make([]*types.Timestamp, v23)
		for i := 0; i < v23; i++ {
			this.NullableTimestamps[i] = types.NewPopulatedTimestamp(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v24 := r.Intn(5)
		this.NullableDurations = make([]*types.Duration, v24)
		for i := 0; i < v24; i++ {
			this.NullableDurations[i] = types.NewPopulatedDuration(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v25 := r.Intn(5)
		this.Timestamps = make([]types.Timestamp, v25)
		for i := 0; i < v25; i++ {
			v26 := types.NewPopulatedTimestamp(r, easy)
			this.Timestamps[i] = *v26
		}
	}
	if r.Intn(5) != 0 {
		v27 := r.Intn(5)
		this.Durations = make([]types.Duration, v27)
		for i := 0; i < v27; i++ {
			v28 := types.NewPopulatedDuration(r, easy)
			this.Durations[i] = *v28
		}
	}
	if r.Intn(5) != 0 {
		v29 := r.Intn(5)
		this.NullableDouble = make([]*types.DoubleValue, v29)
		for i := 0; i < v29; i++ {
			this.NullableDouble[i] = types.NewPopulatedDoubleValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v30 := r.Intn(5)
		this.NonnullDouble = make([]types.DoubleValue, v30)
		for i := 0; i < v30; i++ {
			v31 := types.NewPopulatedDoubleValue(r, easy)
			this.NonnullDouble[i] = *v31
		}
	}
	if r.Intn(5) != 0 {
		v32 := r.Intn(5)
		this.NullableFloat = make([]*types.FloatValue, v32)
		for i := 0; i < v32; i++ {
			this.NullableFloat[i] = types.NewPopulatedFloatValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v33 := r.Intn(5)
		this.NonnullFloat = make([]types.FloatValue, v33)
		for i := 0; i < v33; i++ {
			v34 := types.NewPopulatedFloatValue(r, easy)
			this.NonnullFloat[i] = *v34
		}
	}
	if r.Intn(5) != 0 {
		v35 := r.Intn(5)
		this.NullableInt64 = make([]*types.Int64Value, v35)
		for i := 0; i < v35; i++ {
			this.NullableInt64[i] = types.NewPopulatedInt64Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v36 := r.Intn(5)
		this.NonnullInt64 = make([]types.Int64Value, v36)
		for i := 0; i < v36; i++ {
			v37 := types.NewPopulatedInt64Value(r, easy)
			this.NonnullInt64[i] = *v37
		}
	}
	if r.Intn(5) != 0 {
		v38 := r.Intn(5)
		this.NullableUInt64 = make([]*types.UInt64Value, v38)
		for i := 0; i < v38; i++ {
			this.NullableUInt64[i] = types.NewPopulatedUInt64Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v39 := r.Intn(5)
		this.NonnullUInt64 = make([]types.UInt64Value, v39)
		for i := 0; i < v39; i++ {
			v40 := types.NewPopulatedUInt64Value(r, easy)
			this.NonnullUInt64[i] = *v40
		}
	}
	if r.Intn(5) != 0 {
		v41 := r.Intn(5)
		this.NullableInt32 = make([]*types.Int32Value, v41)
		for i := 0; i < v41; i++ {
			this.NullableInt32[i] = types.NewPopulatedInt32Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v42 := r.Intn(5)
		this.NonnullInt32 = make([]types.Int32Value, v42)
		for i := 0; i < v42; i++ {
			v43 := types.NewPopulatedInt32Value(r, easy)
			this.NonnullInt32[i] = *v43
		}
	}
	if r.Intn(5) != 0 {
		v44 := r.Intn(5)
		this.NullableUInt32 = make([]*types.UInt32Value, v44)
		for i := 0; i < v44; i++ {
			this.NullableUInt32[i] = types.NewPopulatedUInt32Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v45 := r.Intn(5)
		this.NonnullUInt32 = make([]types.UInt32Value, v45)
		for i := 0; i < v45; i++ {
			v46 := types.NewPopulatedUInt32Value(r, easy)
			this.NonnullUInt32[i] = *v46
		}
	}
	if r.Intn(5) != 0 {
		v47 := r.Intn(5)
		this.NullableBool = make([]*types.BoolValue, v47)
		for i := 0; i < v47; i++ {
			this.NullableBool[i] = types.NewPopulatedBoolValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v48 := r.Intn(5)
		this.NonnullBool = make([]types.BoolValue, v48)
		for i := 0; i < v48; i++ {
			v49 := types.NewPopulatedBoolValue(r, easy)
			this.NonnullBool[i] = *v49
		}
	}
	if r.Intn(5) != 0 {
		v50 := r.Intn(5)
		this.NullableString = make([]*types.StringValue, v50)
		for i := 0; i < v50; i++ {
			this.NullableString[i] = types.NewPopulatedStringValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v51 := r.Intn(5)
		this.NonnullString = make([]types.StringValue, v51)
		for i := 0; i < v51; i++ {
			v52 := types.NewPopulatedStringValue(r, easy)
			this.NonnullString[i] = *v52
		}
	}
	if r.Intn(5) != 0 {
		v53 := r.Intn(5)
		this.NullableBytes = make([]*types.BytesValue, v53)
		for i := 0; i < v53; i++ {
			this.NullableBytes[i] = types.NewPopulatedBytesValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v54 := r.Intn(5)
		this.NonnullBytes = make([]types.BytesValue, v54)
		for i := 0; i < v54; i++ {
			v55 := types.NewPopulatedBytesValue(r, easy)
			this.NonnullBytes[i] = *v55
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 23)
	}
	return this
}

func NewPopulatedRepStdTypes(r randyTypes, easy bool) *RepStdTypes {
	this := &RepStdTypes{}
	if r.Intn(5) != 0 {
		v56 := r.Intn(5)
		this.NullableTimestamps = make([]*time.Time, v56)
		for i := 0; i < v56; i++ {
			this.NullableTimestamps[i] = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v57 := r.Intn(5)
		this.NullableDurations = make([]*time.Duration, v57)
		for i := 0; i < v57; i++ {
			this.NullableDurations[i] = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v58 := r.Intn(5)
		this.Timestamps = make([]time.Time, v58)
		for i := 0; i < v58; i++ {
			v59 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
			this.Timestamps[i] = *v59
		}
	}
	if r.Intn(5) != 0 {
		v60 := r.Intn(5)
		this.Durations = make([]time.Duration, v60)
		for i := 0; i < v60; i++ {
			v61 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
			this.Durations[i] = *v61
		}
	}
	if r.Intn(5) != 0 {
		v62 := r.Intn(5)
		this.NullableDouble = make([]*float64, v62)
		for i := 0; i < v62; i++ {
			this.NullableDouble[i] = github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v63 := r.Intn(5)
		this.NonnullDouble = make([]float64, v63)
		for i := 0; i < v63; i++ {
			v64 := github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
			this.NonnullDouble[i] = *v64
		}
	}
	if r.Intn(5) != 0 {
		v65 := r.Intn(5)
		this.NullableFloat = make([]*float32, v65)
		for i := 0; i < v65; i++ {
			this.NullableFloat[i] = github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v66 := r.Intn(5)
		this.NonnullFloat = make([]float32, v66)
		for i := 0; i < v66; i++ {
			v67 := github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
			this.NonnullFloat[i] = *v67
		}
	}
	if r.Intn(5) != 0 {
		v68 := r.Intn(5)
		this.NullableInt64 = make([]*int64, v68)
		for i := 0; i < v68; i++ {
			this.NullableInt64[i] = github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v69 := r.Intn(5)
		this.NonnullInt64 = make([]int64, v69)
		for i := 0; i < v69; i++ {
			v70 := github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
			this.NonnullInt64[i] = *v70
		}
	}
	if r.Intn(5) != 0 {
		v71 := r.Intn(5)
		this.NullableUInt64 = make([]*uint64, v71)
		for i := 0; i < v71; i++ {
			this.NullableUInt64[i] = github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v72 := r.Intn(5)
		this.NonnullUInt64 = make([]uint64, v72)
		for i := 0; i < v72; i++ {
			v73 := github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
			this.NonnullUInt64[i] = *v73
		}
	}
	if r.Intn(5) != 0 {
		v74 := r.Intn(5)
		this.NullableInt32 = make([]*int32, v74)
		for i := 0; i < v74; i++ {
			this.NullableInt32[i] = github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v75 := r.Intn(5)
		this.NonnullInt32 = make([]int32, v75)
		for i := 0; i < v75; i++ {
			v76 := github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
			this.NonnullInt32[i] = *v76
		}
	}
	if r.Intn(5) != 0 {
		v77 := r.Intn(5)
		this.NullableUInt32 = make([]*uint32, v77)
		for i := 0; i < v77; i++ {
			this.NullableUInt32[i] = github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v78 := r.Intn(5)
		this.NonnullUInt32 = make([]uint32, v78)
		for i := 0; i < v78; i++ {
			v79 := github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
			this.NonnullUInt32[i] = *v79
		}
	}
	if r.Intn(5) != 0 {
		v80 := r.Intn(5)
		this.NullableBool = make([]*bool, v80)
		for i := 0; i < v80; i++ {
			this.NullableBool[i] = github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v81 := r.Intn(5)
		this.NonnullBool = make([]bool, v81)
		for i := 0; i < v81; i++ {
			v82 := github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
			this.NonnullBool[i] = *v82
		}
	}
	if r.Intn(5) != 0 {
		v83 := r.Intn(5)
		this.NullableString = make([]*string, v83)
		for i := 0; i < v83; i++ {
			this.NullableString[i] = github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v84 := r.Intn(5)
		this.NonnullString = make([]string, v84)
		for i := 0; i < v84; i++ {
			v85 := github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
			this.NonnullString[i] = *v85
		}
	}
	if r.Intn(5) != 0 {
		v86 := r.Intn(5)
		this.NullableBytes = make([]*[]byte, v86)
		for i := 0; i < v86; i++ {
			this.NullableBytes[i] = github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v87 := r.Intn(5)
		this.NonnullBytes = make([][]byte, v87)
		for i := 0; i < v87; i++ {
			v88 := github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
			this.NonnullBytes[i] = *v88
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 23)
	}
	return this
}

func NewPopulatedMapProtoTypes(r randyTypes, easy bool) *MapProtoTypes {
	this := &MapProtoTypes{}
	if r.Intn(5) != 0 {
		v89 := r.Intn(10)
		this.NullableTimestamp = make(map[int32]*types.Timestamp)
		for i := 0; i < v89; i++ {
			this.NullableTimestamp[int32(r.Int31())] = types.NewPopulatedTimestamp(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v90 := r.Intn(10)
		this.Timestamp = make(map[int32]types.Timestamp)
		for i := 0; i < v90; i++ {
			this.Timestamp[int32(r.Int31())] = *types.NewPopulatedTimestamp(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v91 := r.Intn(10)
		this.NullableDuration = make(map[int32]*types.Duration)
		for i := 0; i < v91; i++ {
			this.NullableDuration[int32(r.Int31())] = types.NewPopulatedDuration(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v92 := r.Intn(10)
		this.Duration = make(map[int32]types.Duration)
		for i := 0; i < v92; i++ {
			this.Duration[int32(r.Int31())] = *types.NewPopulatedDuration(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v93 := r.Intn(10)
		this.NullableDouble = make(map[int32]*types.DoubleValue)
		for i := 0; i < v93; i++ {
			this.NullableDouble[int32(r.Int31())] = types.NewPopulatedDoubleValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v94 := r.Intn(10)
		this.NonnullDouble = make(map[int32]types.DoubleValue)
		for i := 0; i < v94; i++ {
			this.NonnullDouble[int32(r.Int31())] = *types.NewPopulatedDoubleValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v95 := r.Intn(10)
		this.NullableFloat = make(map[int32]*types.FloatValue)
		for i := 0; i < v95; i++ {
			this.NullableFloat[int32(r.Int31())] = types.NewPopulatedFloatValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v96 := r.Intn(10)
		this.NonnullFloat = make(map[int32]types.FloatValue)
		for i := 0; i < v96; i++ {
			this.NonnullFloat[int32(r.Int31())] = *types.NewPopulatedFloatValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v97 := r.Intn(10)
		this.NullableInt64 = make(map[int32]*types.Int64Value)
		for i := 0; i < v97; i++ {
			this.NullableInt64[int32(r.Int31())] = types.NewPopulatedInt64Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v98 := r.Intn(10)
		this.NonnullInt64 = make(map[int32]types.Int64Value)
		for i := 0; i < v98; i++ {
			this.NonnullInt64[int32(r.Int31())] = *types.NewPopulatedInt64Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v99 := r.Intn(10)
		this.NullableUInt64 = make(map[int32]*types.UInt64Value)
		for i := 0; i < v99; i++ {
			this.NullableUInt64[int32(r.Int31())] = types.NewPopulatedUInt64Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v100 := r.Intn(10)
		this.NonnullUInt64 = make(map[int32]types.UInt64Value)
		for i := 0; i < v100; i++ {
			this.NonnullUInt64[int32(r.Int31())] = *types.NewPopulatedUInt64Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v101 := r.Intn(10)
		this.NullableInt32 = make(map[int32]*types.Int32Value)
		for i := 0; i < v101; i++ {
			this.NullableInt32[int32(r.Int31())] = types.NewPopulatedInt32Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v102 := r.Intn(10)
		this.NonnullInt32 = make(map[int32]types.Int32Value)
		for i := 0; i < v102; i++ {
			this.NonnullInt32[int32(r.Int31())] = *types.NewPopulatedInt32Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v103 := r.Intn(10)
		this.NullableUInt32 = make(map[int32]*types.UInt32Value)
		for i := 0; i < v103; i++ {
			this.NullableUInt32[int32(r.Int31())] = types.NewPopulatedUInt32Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v104 := r.Intn(10)
		this.NonnullUInt32 = make(map[int32]types.UInt32Value)
		for i := 0; i < v104; i++ {
			this.NonnullUInt32[int32(r.Int31())] = *types.NewPopulatedUInt32Value(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v105 := r.Intn(10)
		this.NullableBool = make(map[int32]*types.BoolValue)
		for i := 0; i < v105; i++ {
			this.NullableBool[int32(r.Int31())] = types.NewPopulatedBoolValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v106 := r.Intn(10)
		this.NonnullBool = make(map[int32]types.BoolValue)
		for i := 0; i < v106; i++ {
			this.NonnullBool[int32(r.Int31())] = *types.NewPopulatedBoolValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v107 := r.Intn(10)
		this.NullableString = make(map[int32]*types.StringValue)
		for i := 0; i < v107; i++ {
			this.NullableString[int32(r.Int31())] = types.NewPopulatedStringValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v108 := r.Intn(10)
		this.NonnullString = make(map[int32]types.StringValue)
		for i := 0; i < v108; i++ {
			this.NonnullString[int32(r.Int31())] = *types.NewPopulatedStringValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v109 := r.Intn(10)
		this.NullableBytes = make(map[int32]*types.BytesValue)
		for i := 0; i < v109; i++ {
			this.NullableBytes[int32(r.Int31())] = types.NewPopulatedBytesValue(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v110 := r.Intn(10)
		this.NonnullBytes = make(map[int32]types.BytesValue)
		for i := 0; i < v110; i++ {
			this.NonnullBytes[int32(r.Int31())] = *types.NewPopulatedBytesValue(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 23)
	}
	return this
}

func NewPopulatedMapStdTypes(r randyTypes, easy bool) *MapStdTypes {
	this := &MapStdTypes{}
	if r.Intn(5) != 0 {
		v111 := r.Intn(10)
		this.NullableTimestamp = make(map[int32]*time.Time)
		for i := 0; i < v111; i++ {
			this.NullableTimestamp[int32(r.Int31())] = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v112 := r.Intn(10)
		this.Timestamp = make(map[int32]time.Time)
		for i := 0; i < v112; i++ {
			this.Timestamp[int32(r.Int31())] = *github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v113 := r.Intn(10)
		this.NullableDuration = make(map[int32]*time.Duration)
		for i := 0; i < v113; i++ {
			this.NullableDuration[int32(r.Int31())] = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v114 := r.Intn(10)
		this.Duration = make(map[int32]time.Duration)
		for i := 0; i < v114; i++ {
			this.Duration[int32(r.Int31())] = *github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v115 := r.Intn(10)
		this.NullableDouble = make(map[int32]*float64)
		for i := 0; i < v115; i++ {
			this.NullableDouble[int32(r.Int31())] = (*float64)(github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v116 := r.Intn(10)
		this.NonnullDouble = make(map[int32]float64)
		for i := 0; i < v116; i++ {
			this.NonnullDouble[int32(r.Int31())] = (float64)(*github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v117 := r.Intn(10)
		this.NullableFloat = make(map[int32]*float32)
		for i := 0; i < v117; i++ {
			this.NullableFloat[int32(r.Int31())] = (*float32)(github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v118 := r.Intn(10)
		this.NonnullFloat = make(map[int32]float32)
		for i := 0; i < v118; i++ {
			this.NonnullFloat[int32(r.Int31())] = (float32)(*github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v119 := r.Intn(10)
		this.NullableInt64 = make(map[int32]*int64)
		for i := 0; i < v119; i++ {
			this.NullableInt64[int32(r.Int31())] = (*int64)(github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v120 := r.Intn(10)
		this.NonnullInt64 = make(map[int32]int64)
		for i := 0; i < v120; i++ {
			this.NonnullInt64[int32(r.Int31())] = (int64)(*github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v121 := r.Intn(10)
		this.NullableUInt64 = make(map[int32]*uint64)
		for i := 0; i < v121; i++ {
			this.NullableUInt64[int32(r.Int31())] = (*uint64)(github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v122 := r.Intn(10)
		this.NonnullUInt64 = make(map[int32]uint64)
		for i := 0; i < v122; i++ {
			this.NonnullUInt64[int32(r.Int31())] = (uint64)(*github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v123 := r.Intn(10)
		this.NullableInt32 = make(map[int32]*int32)
		for i := 0; i < v123; i++ {
			this.NullableInt32[int32(r.Int31())] = (*int32)(github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v124 := r.Intn(10)
		this.NonnullInt32 = make(map[int32]int32)
		for i := 0; i < v124; i++ {
			this.NonnullInt32[int32(r.Int31())] = (int32)(*github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v125 := r.Intn(10)
		this.NullableUInt32 = make(map[int32]*uint32)
		for i := 0; i < v125; i++ {
			this.NullableUInt32[int32(r.Int31())] = (*uint32)(github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v126 := r.Intn(10)
		this.NonnullUInt32 = make(map[int32]uint32)
		for i := 0; i < v126; i++ {
			this.NonnullUInt32[int32(r.Int31())] = (uint32)(*github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v127 := r.Intn(10)
		this.NullableBool = make(map[int32]*bool)
		for i := 0; i < v127; i++ {
			this.NullableBool[int32(r.Int31())] = (*bool)(github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v128 := r.Intn(10)
		this.NonnullBool = make(map[int32]bool)
		for i := 0; i < v128; i++ {
			this.NonnullBool[int32(r.Int31())] = (bool)(*github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v129 := r.Intn(10)
		this.NullableString = make(map[int32]*string)
		for i := 0; i < v129; i++ {
			this.NullableString[int32(r.Int31())] = (*string)(github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v130 := r.Intn(10)
		this.NonnullString = make(map[int32]string)
		for i := 0; i < v130; i++ {
			this.NonnullString[int32(r.Int31())] = (string)(*github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v131 := r.Intn(10)
		this.NullableBytes = make(map[int32]*[]byte)
		for i := 0; i < v131; i++ {
			this.NullableBytes[int32(r.Int31())] = (*[]byte)(github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy))
		}
	}
	if r.Intn(5) != 0 {
		v132 := r.Intn(10)
		this.NonnullBytes = make(map[int32][]byte)
		for i := 0; i < v132; i++ {
			this.NonnullBytes[int32(r.Int31())] = ([]byte)(*github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy))
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 23)
	}
	return this
}

func NewPopulatedOneofProtoTypes(r randyTypes, easy bool) *OneofProtoTypes {
	this := &OneofProtoTypes{}
	oneofNumber_OneOfProtoTimes := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}[r.Intn(11)]
	switch oneofNumber_OneOfProtoTimes {
	case 1:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_Timestamp(r, easy)
	case 2:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_Duration(r, easy)
	case 3:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_RepDouble(r, easy)
	case 4:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_RepFloat(r, easy)
	case 5:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_RepInt64(r, easy)
	case 6:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_RepUInt64(r, easy)
	case 7:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_RepInt32(r, easy)
	case 8:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_RepUInt32(r, easy)
	case 9:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_RepBool(r, easy)
	case 10:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_RepString(r, easy)
	case 11:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_RepBytes(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 12)
	}
	return this
}

func NewPopulatedOneofProtoTypes_Timestamp(r randyTypes, easy bool) *OneofProtoTypes_Timestamp {
	this := &OneofProtoTypes_Timestamp{}
	this.Timestamp = types.NewPopulatedTimestamp(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_Duration(r randyTypes, easy bool) *OneofProtoTypes_Duration {
	this := &OneofProtoTypes_Duration{}
	this.Duration = types.NewPopulatedDuration(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_RepDouble(r randyTypes, easy bool) *OneofProtoTypes_RepDouble {
	this := &OneofProtoTypes_RepDouble{}
	this.RepDouble = types.NewPopulatedDoubleValue(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_RepFloat(r randyTypes, easy bool) *OneofProtoTypes_RepFloat {
	this := &OneofProtoTypes_RepFloat{}
	this.RepFloat = types.NewPopulatedFloatValue(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_RepInt64(r randyTypes, easy bool) *OneofProtoTypes_RepInt64 {
	this := &OneofProtoTypes_RepInt64{}
	this.RepInt64 = types.NewPopulatedInt64Value(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_RepUInt64(r randyTypes, easy bool) *OneofProtoTypes_RepUInt64 {
	this := &OneofProtoTypes_RepUInt64{}
	this.RepUInt64 = types.NewPopulatedUInt64Value(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_RepInt32(r randyTypes, easy bool) *OneofProtoTypes_RepInt32 {
	this := &OneofProtoTypes_RepInt32{}
	this.RepInt32 = types.NewPopulatedInt32Value(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_RepUInt32(r randyTypes, easy bool) *OneofProtoTypes_RepUInt32 {
	this := &OneofProtoTypes_RepUInt32{}
	this.RepUInt32 = types.NewPopulatedUInt32Value(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_RepBool(r randyTypes, easy bool) *OneofProtoTypes_RepBool {
	this := &OneofProtoTypes_RepBool{}
	this.RepBool = types.NewPopulatedBoolValue(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_RepString(r randyTypes, easy bool) *OneofProtoTypes_RepString {
	this := &OneofProtoTypes_RepString{}
	this.RepString = types.NewPopulatedStringValue(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_RepBytes(r randyTypes, easy bool) *OneofProtoTypes_RepBytes {
	this := &OneofProtoTypes_RepBytes{}
	this.RepBytes = types.NewPopulatedBytesValue(r, easy)
	return this
}
func NewPopulatedOneofStdTypes(r randyTypes, easy bool) *OneofStdTypes {
	this := &OneofStdTypes{}
	oneofNumber_OneOfStdTimes := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}[r.Intn(11)]
	switch oneofNumber_OneOfStdTimes {
	case 1:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_Timestamp(r, easy)
	case 2:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_Duration(r, easy)
	case 3:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepDouble(r, easy)
	case 4:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepFloat(r, easy)
	case 5:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepInt64(r, easy)
	case 6:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepUInt64(r, easy)
	case 7:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepInt32(r, easy)
	case 8:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepUInt32(r, easy)
	case 9:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepBool(r, easy)
	case 10:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepString(r, easy)
	case 11:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepBytes(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 12)
	}
	return this
}

func NewPopulatedOneofStdTypes_Timestamp(r randyTypes, easy bool) *OneofStdTypes_Timestamp {
	this := &OneofStdTypes_Timestamp{}
	this.Timestamp = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_Duration(r randyTypes, easy bool) *OneofStdTypes_Duration {
	this := &OneofStdTypes_Duration{}
	this.Duration = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_RepDouble(r randyTypes, easy bool) *OneofStdTypes_RepDouble {
	this := &OneofStdTypes_RepDouble{}
	this.RepDouble = github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_RepFloat(r randyTypes, easy bool) *OneofStdTypes_RepFloat {
	this := &OneofStdTypes_RepFloat{}
	this.RepFloat = github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_RepInt64(r randyTypes, easy bool) *OneofStdTypes_RepInt64 {
	this := &OneofStdTypes_RepInt64{}
	this.RepInt64 = github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_RepUInt64(r randyTypes, easy bool) *OneofStdTypes_RepUInt64 {
	this := &OneofStdTypes_RepUInt64{}
	this.RepUInt64 = github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_RepInt32(r randyTypes, easy bool) *OneofStdTypes_RepInt32 {
	this := &OneofStdTypes_RepInt32{}
	this.RepInt32 = github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_RepUInt32(r randyTypes, easy bool) *OneofStdTypes_RepUInt32 {
	this := &OneofStdTypes_RepUInt32{}
	this.RepUInt32 = github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_RepBool(r randyTypes, easy bool) *OneofStdTypes_RepBool {
	this := &OneofStdTypes_RepBool{}
	this.RepBool = github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_RepString(r randyTypes, easy bool) *OneofStdTypes_RepString {
	this := &OneofStdTypes_RepString{}
	this.RepString = github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
	return this
}
func NewPopulatedOneofStdTypes_RepBytes(r randyTypes, easy bool) *OneofStdTypes_RepBytes {
	this := &OneofStdTypes_RepBytes{}
	this.RepBytes = github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
	return this
}

type randyTypes interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneTypes(r randyTypes) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringTypes(r randyTypes) string {
	v133 := r.Intn(100)
	tmps := make([]rune, v133)
	for i := 0; i < v133; i++ {
		tmps[i] = randUTF8RuneTypes(r)
	}
	return string(tmps)
}
func randUnrecognizedTypes(r randyTypes, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldTypes(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldTypes(dAtA []byte, r randyTypes, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
		v134 := r.Int63()
		if r.Intn(2) == 0 {
			v134 *= -1
		}
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(v134))
	case 1:
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateTypes(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *KnownTypes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Dur != nil {
		l = m.Dur.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Ts != nil {
		l = m.Ts.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Dbl != nil {
		l = m.Dbl.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Flt != nil {
		l = m.Flt.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.I64 != nil {
		l = m.I64.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.U64 != nil {
		l = m.U64.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.I32 != nil {
		l = m.I32.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.U32 != nil {
		l = m.U32.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Bool != nil {
		l = m.Bool.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Str != nil {
		l = m.Str.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Bytes != nil {
		l = m.Bytes.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.St != nil {
		l = m.St.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ProtoTypes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NullableTimestamp != nil {
		l = m.NullableTimestamp.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableDuration != nil {
		l = m.NullableDuration.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableDouble != nil {
		l = m.NullableDouble.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableFloat != nil {
		l = m.NullableFloat.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableInt64 != nil {
		l = m.NullableInt64.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableUInt64 != nil {
		l = m.NullableUInt64.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableInt32 != nil {
		l = m.NullableInt32.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableUInt32 != nil {
		l = m.NullableUInt32.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableBool != nil {
		l = m.NullableBool.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableString != nil {
		l = m.NullableString.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableBytes != nil {
		l = m.NullableBytes.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Timestamp.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.Duration.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.NonnullDouble.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.NonnullFloat.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.NonnullInt64.Size()
	n += 2 + l + sovTypes(uint64(l))
	l = m.NonnullUInt64.Size()
	n += 2 + l + sovTypes(uint64(l))
	l = m.NonnullInt32.Size()
	n += 2 + l + sovTypes(uint64(l))
	l = m.NonnullUInt32.Size()
	n += 2 + l + sovTypes(uint64(l))
	l = m.NonnullBool.Size()
	n += 2 + l + sovTypes(uint64(l))
	l = m.NonnullString.Size()
	n += 2 + l + sovTypes(uint64(l))
	l = m.NonnullBytes.Size()
	n += 2 + l + sovTypes(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StdTypes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NullableTimestamp != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.NullableTimestamp)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableDuration != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.NullableDuration)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableDouble != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDouble(*m.NullableDouble)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableFloat != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdFloat(*m.NullableFloat)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableInt64 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdInt64(*m.NullableInt64)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableUInt64 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdUInt64(*m.NullableUInt64)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableInt32 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdInt32(*m.NullableInt32)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableUInt32 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.NullableUInt32)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableBool != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdBool(*m.NullableBool)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableString != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdString(*m.NullableString)
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.NullableBytes != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdBytes(*m.NullableBytes)
		n += 1 + l + sovTypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
	n += 1 + l + sovTypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration)
	n += 1 + l + sovTypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDouble(m.NonnullDouble)
	n += 1 + l + sovTypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdFloat(m.NonnullFloat)
	n += 1 + l + sovTypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdInt64(m.NonnullInt64)
	n += 2 + l + sovTypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdUInt64(m.NonnullUInt64)
	n += 2 + l + sovTypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdInt32(m.NonnullInt32)
	n += 2 + l + sovTypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdUInt32(m.NonnullUInt32)
	n += 2 + l + sovTypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdBool(m.NonnullBool)
	n += 2 + l + sovTypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdString(m.NonnullString)
	n += 2 + l + sovTypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdBytes(m.NonnullBytes)
	n += 2 + l + sovTypes(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RepProtoTypes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.NullableTimestamps) > 0 {
		for _, e := range m.NullableTimestamps {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableDurations) > 0 {
		for _, e := range m.NullableDurations {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Timestamps) > 0 {
		for _, e := range m.Timestamps {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Durations) > 0 {
		for _, e := range m.Durations {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableDouble) > 0 {
		for _, e := range m.NullableDouble {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullDouble) > 0 {
		for _, e := range m.NonnullDouble {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableFloat) > 0 {
		for _, e := range m.NullableFloat {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullFloat) > 0 {
		for _, e := range m.NonnullFloat {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableInt64) > 0 {
		for _, e := range m.NullableInt64 {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullInt64) > 0 {
		for _, e := range m.NonnullInt64 {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableUInt64) > 0 {
		for _, e := range m.NullableUInt64 {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullUInt64) > 0 {
		for _, e := range m.NonnullUInt64 {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableInt32) > 0 {
		for _, e := range m.NullableInt32 {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullInt32) > 0 {
		for _, e := range m.NonnullInt32 {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableUInt32) > 0 {
		for _, e := range m.NullableUInt32 {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullUInt32) > 0 {
		for _, e := range m.NonnullUInt32 {
			l = e.Size()
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableBool) > 0 {
		for _, e := range m.NullableBool {
			l = e.Size()
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullBool) > 0 {
		for _, e := range m.NonnullBool {
			l = e.Size()
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableString) > 0 {
		for _, e := range m.NullableString {
			l = e.Size()
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullString) > 0 {
		for _, e := range m.NonnullString {
			l = e.Size()
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableBytes) > 0 {
		for _, e := range m.NullableBytes {
			l = e.Size()
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullBytes) > 0 {
		for _, e := range m.NonnullBytes {
			l = e.Size()
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RepStdTypes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.NullableTimestamps) > 0 {
		for _, e := range m.NullableTimestamps {
			l = github_com_gogo_protobuf_types.SizeOfStdTime(*e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableDurations) > 0 {
		for _, e := range m.NullableDurations {
			l = github_com_gogo_protobuf_types.SizeOfStdDuration(*e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Timestamps) > 0 {
		for _, e := range m.Timestamps {
			l = github_com_gogo_protobuf_types.SizeOfStdTime(e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Durations) > 0 {
		for _, e := range m.Durations {
			l = github_com_gogo_protobuf_types.SizeOfStdDuration(e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableDouble) > 0 {
		for _, e := range m.NullableDouble {
			l = github_com_gogo_protobuf_types.SizeOfStdDouble(*e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullDouble) > 0 {
		for _, e := range m.NonnullDouble {
			l = github_com_gogo_protobuf_types.SizeOfStdDouble(e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableFloat) > 0 {
		for _, e := range m.NullableFloat {
			l = github_com_gogo_protobuf_types.SizeOfStdFloat(*e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullFloat) > 0 {
		for _, e := range m.NonnullFloat {
			l = github_com_gogo_protobuf_types.SizeOfStdFloat(e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableInt64) > 0 {
		for _, e := range m.NullableInt64 {
			l = github_com_gogo_protobuf_types.SizeOfStdInt64(*e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullInt64) > 0 {
		for _, e := range m.NonnullInt64 {
			l = github_com_gogo_protobuf_types.SizeOfStdInt64(e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableUInt64) > 0 {
		for _, e := range m.NullableUInt64 {
			l = github_com_gogo_protobuf_types.SizeOfStdUInt64(*e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullUInt64) > 0 {
		for _, e := range m.NonnullUInt64 {
			l = github_com_gogo_protobuf_types.SizeOfStdUInt64(e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableInt32) > 0 {
		for _, e := range m.NullableInt32 {
			l = github_com_gogo_protobuf_types.SizeOfStdInt32(*e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullInt32) > 0 {
		for _, e := range m.NonnullInt32 {
			l = github_com_gogo_protobuf_types.SizeOfStdInt32(e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableUInt32) > 0 {
		for _, e := range m.NullableUInt32 {
			l = github_com_gogo_protobuf_types.SizeOfStdUInt32(*e)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullUInt32) > 0 {
		for _, e := range m.NonnullUInt32 {
			l = github_com_gogo_protobuf_types.SizeOfStdUInt32(e)
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableBool) > 0 {
		for _, e := range m.NullableBool {
			l = github_com_gogo_protobuf_types.SizeOfStdBool(*e)
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullBool) > 0 {
		for _, e := range m.NonnullBool {
			l = github_com_gogo_protobuf_types.SizeOfStdBool(e)
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableString) > 0 {
		for _, e := range m.NullableString {
			l = github_com_gogo_protobuf_types.SizeOfStdString(*e)
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullString) > 0 {
		for _, e := range m.NonnullString {
			l = github_com_gogo_protobuf_types.SizeOfStdString(e)
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NullableBytes) > 0 {
		for _, e := range m.NullableBytes {
			l = github_com_gogo_protobuf_types.SizeOfStdBytes(*e)
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if len(m.NonnullBytes) > 0 {
		for _, e := range m.NonnullBytes {
			l = github_com_gogo_protobuf_types.SizeOfStdBytes(e)
			n += 2 + l + sovTypes(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MapProtoTypes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.NullableTimestamp) > 0 {
		for k, v := range m.NullableTimestamp {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.Timestamp) > 0 {
		for k, v := range m.Timestamp {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableDuration) > 0 {
		for k, v := range m.NullableDuration {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.Duration) > 0 {
		for k, v := range m.Duration {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableDouble) > 0 {
		for k, v := range m.NullableDouble {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullDouble) > 0 {
		for k, v := range m.NonnullDouble {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableFloat) > 0 {
		for k, v := range m.NullableFloat {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullFloat) > 0 {
		for k, v := range m.NonnullFloat {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableInt64) > 0 {
		for k, v := range m.NullableInt64 {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullInt64) > 0 {
		for k, v := range m.NonnullInt64 {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableUInt64) > 0 {
		for k, v := range m.NullableUInt64 {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullUInt64) > 0 {
		for k, v := range m.NonnullUInt64 {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableInt32) > 0 {
		for k, v := range m.NullableInt32 {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullInt32) > 0 {
		for k, v := range m.NonnullInt32 {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableUInt32) > 0 {
		for k, v := range m.NullableUInt32 {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullUInt32) > 0 {
		for k, v := range m.NonnullUInt32 {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableBool) > 0 {
		for k, v := range m.NullableBool {
			_ = 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.NonnullBool) > 0 {
		for k, v := range m.NonnullBool {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableString) > 0 {
		for k, v := range m.NullableString {
			_ = 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.NonnullString) > 0 {
		for k, v := range m.NonnullString {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableBytes) > 0 {
		for k, v := range m.NullableBytes {
			_ = 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.NonnullBytes) > 0 {
		for k, v := range m.NonnullBytes {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MapStdTypes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.NullableTimestamp) > 0 {
		for k, v := range m.NullableTimestamp {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdTime(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.Timestamp) > 0 {
		for k, v := range m.Timestamp {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdTime(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableDuration) > 0 {
		for k, v := range m.NullableDuration {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdDuration(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.Duration) > 0 {
		for k, v := range m.Duration {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdDuration(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableDouble) > 0 {
		for k, v := range m.NullableDouble {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdDouble(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullDouble) > 0 {
		for k, v := range m.NonnullDouble {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdDouble(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableFloat) > 0 {
		for k, v := range m.NullableFloat {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdFloat(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullFloat) > 0 {
		for k, v := range m.NonnullFloat {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdFloat(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableInt64) > 0 {
		for k, v := range m.NullableInt64 {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdInt64(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullInt64) > 0 {
		for k, v := range m.NonnullInt64 {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdInt64(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableUInt64) > 0 {
		for k, v := range m.NullableUInt64 {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdUInt64(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullUInt64) > 0 {
		for k, v := range m.NonnullUInt64 {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdUInt64(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableInt32) > 0 {
		for k, v := range m.NullableInt32 {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdInt32(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullInt32) > 0 {
		for k, v := range m.NonnullInt32 {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdInt32(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableUInt32) > 0 {
		for k, v := range m.NullableUInt32 {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdUInt32(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullUInt32) > 0 {
		for k, v := range m.NonnullUInt32 {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdUInt32(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableBool) > 0 {
		for k, v := range m.NullableBool {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdBool(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullBool) > 0 {
		for k, v := range m.NonnullBool {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdBool(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableString) > 0 {
		for k, v := range m.NullableString {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdString(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullString) > 0 {
		for k, v := range m.NonnullString {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdString(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NullableBytes) > 0 {
		for k, v := range m.NullableBytes {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = github_com_gogo_protobuf_types.SizeOfStdBytes(*v)
				l += 1 + sovTypes(uint64(l))
			}
			mapEntrySize := 1 + sovTypes(uint64(k)) + l
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if len(m.NonnullBytes) > 0 {
		for k, v := range m.NonnullBytes {
			_ = k
			_ = v
			l = github_com_gogo_protobuf_types.SizeOfStdBytes(v)
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + l + sovTypes(uint64(l))
			n += mapEntrySize + 2 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OneofProtoTypes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OneOfProtoTimes != nil {
		n += m.OneOfProtoTimes.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OneofProtoTypes_Timestamp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_Duration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Duration != nil {
		l = m.Duration.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_RepDouble) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepDouble != nil {
		l = m.RepDouble.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_RepFloat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepFloat != nil {
		l = m.RepFloat.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_RepInt64) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepInt64 != nil {
		l = m.RepInt64.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_RepUInt64) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepUInt64 != nil {
		l = m.RepUInt64.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_RepInt32) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepInt32 != nil {
		l = m.RepInt32.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_RepUInt32) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepUInt32 != nil {
		l = m.RepUInt32.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_RepBool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepBool != nil {
		l = m.RepBool.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_RepString) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepString != nil {
		l = m.RepString.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofProtoTypes_RepBytes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepBytes != nil {
		l = m.RepBytes.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OneOfStdTimes != nil {
		n += m.OneOfStdTimes.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OneofStdTypes_Timestamp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Timestamp != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_Duration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Duration != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Duration)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_RepDouble) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepDouble != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDouble(*m.RepDouble)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_RepFloat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepFloat != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdFloat(*m.RepFloat)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_RepInt64) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepInt64 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdInt64(*m.RepInt64)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_RepUInt64) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepUInt64 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdUInt64(*m.RepUInt64)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_RepInt32) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepInt32 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdInt32(*m.RepInt32)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_RepUInt32) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepUInt32 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.RepUInt32)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_RepBool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepBool != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdBool(*m.RepBool)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_RepString) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepString != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdString(*m.RepString)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes_RepBytes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RepBytes != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdBytes(*m.RepBytes)
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func sovTypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *KnownTypes) 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: KnownTypes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KnownTypes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dur", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Dur == nil {
				m.Dur = &types.Duration{}
			}
			if err := m.Dur.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Ts == nil {
				m.Ts = &types.Timestamp{}
			}
			if err := m.Ts.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dbl", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Dbl == nil {
				m.Dbl = &types.DoubleValue{}
			}
			if err := m.Dbl.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Flt == nil {
				m.Flt = &types.FloatValue{}
			}
			if err := m.Flt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field I64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.I64 == nil {
				m.I64 = &types.Int64Value{}
			}
			if err := m.I64.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field U64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.U64 == nil {
				m.U64 = &types.UInt64Value{}
			}
			if err := m.U64.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field I32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.I32 == nil {
				m.I32 = &types.Int32Value{}
			}
			if err := m.I32.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field U32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.U32 == nil {
				m.U32 = &types.UInt32Value{}
			}
			if err := m.U32.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Bool == nil {
				m.Bool = &types.BoolValue{}
			}
			if err := m.Bool.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Str == nil {
				m.Str = &types.StringValue{}
			}
			if err := m.Str.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Bytes == nil {
				m.Bytes = &types.BytesValue{}
			}
			if err := m.Bytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field St", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.St == nil {
				m.St = &types.Struct{}
			}
			if err := m.St.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProtoTypes) 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: ProtoTypes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProtoTypes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableTimestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableTimestamp == nil {
				m.NullableTimestamp = &types.Timestamp{}
			}
			if err := m.NullableTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDuration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableDuration == nil {
				m.NullableDuration = &types.Duration{}
			}
			if err := m.NullableDuration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableDouble == nil {
				m.NullableDouble = &types.DoubleValue{}
			}
			if err := m.NullableDouble.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableFloat == nil {
				m.NullableFloat = &types.FloatValue{}
			}
			if err := m.NullableFloat.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableInt64 == nil {
				m.NullableInt64 = &types.Int64Value{}
			}
			if err := m.NullableInt64.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableUInt64 == nil {
				m.NullableUInt64 = &types.UInt64Value{}
			}
			if err := m.NullableUInt64.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableInt32 == nil {
				m.NullableInt32 = &types.Int32Value{}
			}
			if err := m.NullableInt32.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableUInt32 == nil {
				m.NullableUInt32 = &types.UInt32Value{}
			}
			if err := m.NullableUInt32.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableBool == nil {
				m.NullableBool = &types.BoolValue{}
			}
			if err := m.NullableBool.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableString == nil {
				m.NullableString = &types.StringValue{}
			}
			if err := m.NullableString.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableBytes == nil {
				m.NullableBytes = &types.BytesValue{}
			}
			if err := m.NullableBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Duration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NonnullDouble.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NonnullFloat.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NonnullInt64.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NonnullUInt64.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NonnullInt32.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NonnullUInt32.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NonnullBool.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NonnullString.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NonnullBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StdTypes) 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: StdTypes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StdTypes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableTimestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableTimestamp == nil {
				m.NullableTimestamp = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.NullableTimestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDuration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableDuration == nil {
				m.NullableDuration = new(time.Duration)
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.NullableDuration, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableDouble == nil {
				m.NullableDouble = new(float64)
			}
			if err := github_com_gogo_protobuf_types.StdDoubleUnmarshal(m.NullableDouble, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableFloat == nil {
				m.NullableFloat = new(float32)
			}
			if err := github_com_gogo_protobuf_types.StdFloatUnmarshal(m.NullableFloat, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableInt64 == nil {
				m.NullableInt64 = new(int64)
			}
			if err := github_com_gogo_protobuf_types.StdInt64Unmarshal(m.NullableInt64, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableUInt64 == nil {
				m.NullableUInt64 = new(uint64)
			}
			if err := github_com_gogo_protobuf_types.StdUInt64Unmarshal(m.NullableUInt64, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableInt32 == nil {
				m.NullableInt32 = new(int32)
			}
			if err := github_com_gogo_protobuf_types.StdInt32Unmarshal(m.NullableInt32, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableUInt32 == nil {
				m.NullableUInt32 = new(uint32)
			}
			if err := github_com_gogo_protobuf_types.StdUInt32Unmarshal(m.NullableUInt32, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableBool == nil {
				m.NullableBool = new(bool)
			}
			if err := github_com_gogo_protobuf_types.StdBoolUnmarshal(m.NullableBool, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableString == nil {
				m.NullableString = new(string)
			}
			if err := github_com_gogo_protobuf_types.StdStringUnmarshal(m.NullableString, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableBytes == nil {
				m.NullableBytes = new([]byte)
			}
			if err := github_com_gogo_protobuf_types.StdBytesUnmarshal(m.NullableBytes, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Duration, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDoubleUnmarshal(&m.NonnullDouble, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdFloatUnmarshal(&m.NonnullFloat, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdInt64Unmarshal(&m.NonnullInt64, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdUInt64Unmarshal(&m.NonnullUInt64, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdInt32Unmarshal(&m.NonnullInt32, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdUInt32Unmarshal(&m.NonnullUInt32, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdBoolUnmarshal(&m.NonnullBool, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdStringUnmarshal(&m.NonnullString, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdBytesUnmarshal(&m.NonnullBytes, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RepProtoTypes) 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: RepProtoTypes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RepProtoTypes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableTimestamps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableTimestamps = append(m.NullableTimestamps, &types.Timestamp{})
			if err := m.NullableTimestamps[len(m.NullableTimestamps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDurations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableDurations = append(m.NullableDurations, &types.Duration{})
			if err := m.NullableDurations[len(m.NullableDurations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Timestamps = append(m.Timestamps, types.Timestamp{})
			if err := m.Timestamps[len(m.Timestamps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Durations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Durations = append(m.Durations, types.Duration{})
			if err := m.Durations[len(m.Durations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableDouble = append(m.NullableDouble, &types.DoubleValue{})
			if err := m.NullableDouble[len(m.NullableDouble)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullDouble = append(m.NonnullDouble, types.DoubleValue{})
			if err := m.NonnullDouble[len(m.NonnullDouble)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableFloat = append(m.NullableFloat, &types.FloatValue{})
			if err := m.NullableFloat[len(m.NullableFloat)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullFloat = append(m.NonnullFloat, types.FloatValue{})
			if err := m.NonnullFloat[len(m.NonnullFloat)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableInt64 = append(m.NullableInt64, &types.Int64Value{})
			if err := m.NullableInt64[len(m.NullableInt64)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullInt64 = append(m.NonnullInt64, types.Int64Value{})
			if err := m.NonnullInt64[len(m.NonnullInt64)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableUInt64 = append(m.NullableUInt64, &types.UInt64Value{})
			if err := m.NullableUInt64[len(m.NullableUInt64)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullUInt64 = append(m.NonnullUInt64, types.UInt64Value{})
			if err := m.NonnullUInt64[len(m.NonnullUInt64)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableInt32 = append(m.NullableInt32, &types.Int32Value{})
			if err := m.NullableInt32[len(m.NullableInt32)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullInt32 = append(m.NonnullInt32, types.Int32Value{})
			if err := m.NonnullInt32[len(m.NonnullInt32)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableUInt32 = append(m.NullableUInt32, &types.UInt32Value{})
			if err := m.NullableUInt32[len(m.NullableUInt32)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullUInt32 = append(m.NonnullUInt32, types.UInt32Value{})
			if err := m.NonnullUInt32[len(m.NonnullUInt32)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableBool = append(m.NullableBool, &types.BoolValue{})
			if err := m.NullableBool[len(m.NullableBool)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullBool = append(m.NonnullBool, types.BoolValue{})
			if err := m.NonnullBool[len(m.NonnullBool)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableString = append(m.NullableString, &types.StringValue{})
			if err := m.NullableString[len(m.NullableString)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullString = append(m.NonnullString, types.StringValue{})
			if err := m.NonnullString[len(m.NonnullString)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableBytes = append(m.NullableBytes, &types.BytesValue{})
			if err := m.NullableBytes[len(m.NullableBytes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullBytes = append(m.NonnullBytes, types.BytesValue{})
			if err := m.NonnullBytes[len(m.NonnullBytes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RepStdTypes) 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: RepStdTypes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RepStdTypes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableTimestamps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableTimestamps = append(m.NullableTimestamps, new(time.Time))
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.NullableTimestamps[len(m.NullableTimestamps)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDurations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableDurations = append(m.NullableDurations, new(time.Duration))
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.NullableDurations[len(m.NullableDurations)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Timestamps = append(m.Timestamps, time.Time{})
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&(m.Timestamps[len(m.Timestamps)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Durations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Durations = append(m.Durations, time.Duration(0))
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&(m.Durations[len(m.Durations)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableDouble = append(m.NullableDouble, new(float64))
			if err := github_com_gogo_protobuf_types.StdDoubleUnmarshal(m.NullableDouble[len(m.NullableDouble)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullDouble = append(m.NonnullDouble, 0)
			if err := github_com_gogo_protobuf_types.StdDoubleUnmarshal(&(m.NonnullDouble[len(m.NonnullDouble)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableFloat = append(m.NullableFloat, new(float32))
			if err := github_com_gogo_protobuf_types.StdFloatUnmarshal(m.NullableFloat[len(m.NullableFloat)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullFloat = append(m.NonnullFloat, 0)
			if err := github_com_gogo_protobuf_types.StdFloatUnmarshal(&(m.NonnullFloat[len(m.NonnullFloat)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableInt64 = append(m.NullableInt64, new(int64))
			if err := github_com_gogo_protobuf_types.StdInt64Unmarshal(m.NullableInt64[len(m.NullableInt64)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullInt64 = append(m.NonnullInt64, 0)
			if err := github_com_gogo_protobuf_types.StdInt64Unmarshal(&(m.NonnullInt64[len(m.NonnullInt64)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableUInt64 = append(m.NullableUInt64, new(uint64))
			if err := github_com_gogo_protobuf_types.StdUInt64Unmarshal(m.NullableUInt64[len(m.NullableUInt64)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullUInt64 = append(m.NonnullUInt64, 0)
			if err := github_com_gogo_protobuf_types.StdUInt64Unmarshal(&(m.NonnullUInt64[len(m.NonnullUInt64)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableInt32 = append(m.NullableInt32, new(int32))
			if err := github_com_gogo_protobuf_types.StdInt32Unmarshal(m.NullableInt32[len(m.NullableInt32)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullInt32 = append(m.NonnullInt32, 0)
			if err := github_com_gogo_protobuf_types.StdInt32Unmarshal(&(m.NonnullInt32[len(m.NonnullInt32)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableUInt32 = append(m.NullableUInt32, new(uint32))
			if err := github_com_gogo_protobuf_types.StdUInt32Unmarshal(m.NullableUInt32[len(m.NullableUInt32)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullUInt32 = append(m.NonnullUInt32, 0)
			if err := github_com_gogo_protobuf_types.StdUInt32Unmarshal(&(m.NonnullUInt32[len(m.NonnullUInt32)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableBool = append(m.NullableBool, new(bool))
			if err := github_com_gogo_protobuf_types.StdBoolUnmarshal(m.NullableBool[len(m.NullableBool)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullBool = append(m.NonnullBool, false)
			if err := github_com_gogo_protobuf_types.StdBoolUnmarshal(&(m.NonnullBool[len(m.NonnullBool)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableString = append(m.NullableString, new(string))
			if err := github_com_gogo_protobuf_types.StdStringUnmarshal(m.NullableString[len(m.NullableString)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullString = append(m.NonnullString, "")
			if err := github_com_gogo_protobuf_types.StdStringUnmarshal(&(m.NonnullString[len(m.NonnullString)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableBytes = append(m.NullableBytes, new([]byte))
			if err := github_com_gogo_protobuf_types.StdBytesUnmarshal(m.NullableBytes[len(m.NullableBytes)-1], dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NonnullBytes = append(m.NonnullBytes, []byte{})
			if err := github_com_gogo_protobuf_types.StdBytesUnmarshal(&(m.NonnullBytes[len(m.NonnullBytes)-1]), dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MapProtoTypes) 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: MapProtoTypes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MapProtoTypes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableTimestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableTimestamp == nil {
				m.NullableTimestamp = make(map[int32]*types.Timestamp)
			}
			var mapkey int32
			var mapvalue *types.Timestamp
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.Timestamp{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.NullableTimestamp[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = make(map[int32]types.Timestamp)
			}
			var mapkey int32
			mapvalue := &types.Timestamp{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.Timestamp{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Timestamp[mapkey] = *mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDuration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableDuration == nil {
				m.NullableDuration = make(map[int32]*types.Duration)
			}
			var mapkey int32
			var mapvalue *types.Duration
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.Duration{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.NullableDuration[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Duration == nil {
				m.Duration = make(map[int32]types.Duration)
			}
			var mapkey int32
			mapvalue := &types.Duration{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.Duration{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Duration[mapkey] = *mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableDouble == nil {
				m.NullableDouble = make(map[int32]*types.DoubleValue)
			}
			var mapkey int32
			var mapvalue *types.DoubleValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.DoubleValue{}
					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.NullableDouble[mapkey] = mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullDouble == nil {
				m.NonnullDouble = make(map[int32]types.DoubleValue)
			}
			var mapkey int32
			mapvalue := &types.DoubleValue{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.DoubleValue{}
					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.NonnullDouble[mapkey] = *mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableFloat == nil {
				m.NullableFloat = make(map[int32]*types.FloatValue)
			}
			var mapkey int32
			var mapvalue *types.FloatValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.FloatValue{}
					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.NullableFloat[mapkey] = mapvalue
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullFloat == nil {
				m.NonnullFloat = make(map[int32]types.FloatValue)
			}
			var mapkey int32
			mapvalue := &types.FloatValue{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.FloatValue{}
					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.NonnullFloat[mapkey] = *mapvalue
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableInt64 == nil {
				m.NullableInt64 = make(map[int32]*types.Int64Value)
			}
			var mapkey int32
			var mapvalue *types.Int64Value
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.Int64Value{}
					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.NullableInt64[mapkey] = mapvalue
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullInt64 == nil {
				m.NonnullInt64 = make(map[int32]types.Int64Value)
			}
			var mapkey int32
			mapvalue := &types.Int64Value{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.Int64Value{}
					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.NonnullInt64[mapkey] = *mapvalue
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableUInt64 == nil {
				m.NullableUInt64 = make(map[int32]*types.UInt64Value)
			}
			var mapkey int32
			var mapvalue *types.UInt64Value
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.UInt64Value{}
					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.NullableUInt64[mapkey] = mapvalue
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullUInt64 == nil {
				m.NonnullUInt64 = make(map[int32]types.UInt64Value)
			}
			var mapkey int32
			mapvalue := &types.UInt64Value{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.UInt64Value{}
					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.NonnullUInt64[mapkey] = *mapvalue
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableInt32 == nil {
				m.NullableInt32 = make(map[int32]*types.Int32Value)
			}
			var mapkey int32
			var mapvalue *types.Int32Value
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.Int32Value{}
					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.NullableInt32[mapkey] = mapvalue
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullInt32 == nil {
				m.NonnullInt32 = make(map[int32]types.Int32Value)
			}
			var mapkey int32
			mapvalue := &types.Int32Value{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.Int32Value{}
					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.NonnullInt32[mapkey] = *mapvalue
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableUInt32 == nil {
				m.NullableUInt32 = make(map[int32]*types.UInt32Value)
			}
			var mapkey int32
			var mapvalue *types.UInt32Value
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.UInt32Value{}
					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.NullableUInt32[mapkey] = mapvalue
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullUInt32 == nil {
				m.NonnullUInt32 = make(map[int32]types.UInt32Value)
			}
			var mapkey int32
			mapvalue := &types.UInt32Value{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.UInt32Value{}
					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.NonnullUInt32[mapkey] = *mapvalue
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableBool == nil {
				m.NullableBool = make(map[int32]*types.BoolValue)
			}
			var mapkey int32
			var mapvalue *types.BoolValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.BoolValue{}
					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.NullableBool[mapkey] = mapvalue
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullBool == nil {
				m.NonnullBool = make(map[int32]types.BoolValue)
			}
			var mapkey int32
			mapvalue := &types.BoolValue{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.BoolValue{}
					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.NonnullBool[mapkey] = *mapvalue
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableString == nil {
				m.NullableString = make(map[int32]*types.StringValue)
			}
			var mapkey int32
			var mapvalue *types.StringValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.StringValue{}
					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.NullableString[mapkey] = mapvalue
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullString == nil {
				m.NonnullString = make(map[int32]types.StringValue)
			}
			var mapkey int32
			mapvalue := &types.StringValue{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.StringValue{}
					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.NonnullString[mapkey] = *mapvalue
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableBytes == nil {
				m.NullableBytes = make(map[int32]*types.BytesValue)
			}
			var mapkey int32
			var mapvalue *types.BytesValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.BytesValue{}
					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.NullableBytes[mapkey] = mapvalue
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullBytes == nil {
				m.NonnullBytes = make(map[int32]types.BytesValue)
			}
			var mapkey int32
			mapvalue := &types.BytesValue{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &types.BytesValue{}
					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.NonnullBytes[mapkey] = *mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MapStdTypes) 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: MapStdTypes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MapStdTypes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableTimestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableTimestamp == nil {
				m.NullableTimestamp = make(map[int32]*time.Time)
			}
			var mapkey int32
			mapvalue := new(time.Time)
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(mapvalue, 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.NullableTimestamp[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = make(map[int32]time.Time)
			}
			var mapkey int32
			mapvalue := new(time.Time)
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(mapvalue, 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.Timestamp[mapkey] = *mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDuration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableDuration == nil {
				m.NullableDuration = make(map[int32]*time.Duration)
			}
			var mapkey int32
			mapvalue := new(time.Duration)
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(mapvalue, 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.NullableDuration[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Duration == nil {
				m.Duration = make(map[int32]time.Duration)
			}
			var mapkey int32
			mapvalue := new(time.Duration)
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(mapvalue, 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.Duration[mapkey] = *mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableDouble == nil {
				m.NullableDouble = make(map[int32]*float64)
			}
			var mapkey int32
			mapvalue := new(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 |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdDoubleUnmarshal(mapvalue, 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.NullableDouble[mapkey] = ((*float64)(mapvalue))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullDouble == nil {
				m.NonnullDouble = make(map[int32]float64)
			}
			var mapkey int32
			mapvalue := new(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 |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdDoubleUnmarshal(mapvalue, 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.NonnullDouble[mapkey] = ((float64)(*mapvalue))
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableFloat == nil {
				m.NullableFloat = make(map[int32]*float32)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdFloatUnmarshal(mapvalue, 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.NullableFloat[mapkey] = ((*float32)(mapvalue))
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullFloat == nil {
				m.NonnullFloat = make(map[int32]float32)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdFloatUnmarshal(mapvalue, 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.NonnullFloat[mapkey] = ((float32)(*mapvalue))
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableInt64 == nil {
				m.NullableInt64 = make(map[int32]*int64)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdInt64Unmarshal(mapvalue, 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.NullableInt64[mapkey] = ((*int64)(mapvalue))
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullInt64 == nil {
				m.NonnullInt64 = make(map[int32]int64)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdInt64Unmarshal(mapvalue, 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.NonnullInt64[mapkey] = ((int64)(*mapvalue))
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableUInt64 == nil {
				m.NullableUInt64 = make(map[int32]*uint64)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdUInt64Unmarshal(mapvalue, 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.NullableUInt64[mapkey] = ((*uint64)(mapvalue))
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullUInt64 == nil {
				m.NonnullUInt64 = make(map[int32]uint64)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdUInt64Unmarshal(mapvalue, 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.NonnullUInt64[mapkey] = ((uint64)(*mapvalue))
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableInt32 == nil {
				m.NullableInt32 = make(map[int32]*int32)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdInt32Unmarshal(mapvalue, 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.NullableInt32[mapkey] = ((*int32)(mapvalue))
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullInt32 == nil {
				m.NonnullInt32 = make(map[int32]int32)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdInt32Unmarshal(mapvalue, 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.NonnullInt32[mapkey] = ((int32)(*mapvalue))
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableUInt32 == nil {
				m.NullableUInt32 = make(map[int32]*uint32)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdUInt32Unmarshal(mapvalue, 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.NullableUInt32[mapkey] = ((*uint32)(mapvalue))
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullUInt32 == nil {
				m.NonnullUInt32 = make(map[int32]uint32)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdUInt32Unmarshal(mapvalue, 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.NonnullUInt32[mapkey] = ((uint32)(*mapvalue))
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableBool == nil {
				m.NullableBool = make(map[int32]*bool)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdBoolUnmarshal(mapvalue, 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.NullableBool[mapkey] = ((*bool)(mapvalue))
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullBool == nil {
				m.NonnullBool = make(map[int32]bool)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdBoolUnmarshal(mapvalue, 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.NonnullBool[mapkey] = ((bool)(*mapvalue))
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableString == nil {
				m.NullableString = make(map[int32]*string)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdStringUnmarshal(mapvalue, 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.NullableString[mapkey] = ((*string)(mapvalue))
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullString == nil {
				m.NonnullString = make(map[int32]string)
			}
			var mapkey int32
			mapvalue := new(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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdStringUnmarshal(mapvalue, 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.NonnullString[mapkey] = ((string)(*mapvalue))
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullableBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableBytes == nil {
				m.NullableBytes = make(map[int32]*[]byte)
			}
			var mapkey int32
			mapvalue := new([]byte)
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdBytesUnmarshal(mapvalue, 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.NullableBytes[mapkey] = ((*[]byte)(mapvalue))
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonnullBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonnullBytes == nil {
				m.NonnullBytes = make(map[int32][]byte)
			}
			var mapkey int32
			mapvalue := new([]byte)
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTypes
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTypes
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					if err := github_com_gogo_protobuf_types.StdBytesUnmarshal(mapvalue, 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.NonnullBytes[mapkey] = (([]byte)(*mapvalue))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OneofProtoTypes) 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: OneofProtoTypes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OneofProtoTypes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Timestamp{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_Timestamp{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Duration{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_Duration{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.DoubleValue{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_RepDouble{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.FloatValue{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_RepFloat{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Int64Value{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_RepInt64{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.UInt64Value{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_RepUInt64{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Int32Value{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_RepInt32{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.UInt32Value{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_RepUInt32{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.BoolValue{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_RepBool{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.StringValue{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_RepString{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.BytesValue{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_RepBytes{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OneofStdTypes) 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: OneofStdTypes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OneofStdTypes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new(time.Time)
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_Timestamp{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new(time.Duration)
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_Duration{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepDouble", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new(float64)
			if err := github_com_gogo_protobuf_types.StdDoubleUnmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_RepDouble{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepFloat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new(float32)
			if err := github_com_gogo_protobuf_types.StdFloatUnmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_RepFloat{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new(int64)
			if err := github_com_gogo_protobuf_types.StdInt64Unmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_RepInt64{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepUInt64", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new(uint64)
			if err := github_com_gogo_protobuf_types.StdUInt64Unmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_RepUInt64{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new(int32)
			if err := github_com_gogo_protobuf_types.StdInt32Unmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_RepInt32{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepUInt32", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new(uint32)
			if err := github_com_gogo_protobuf_types.StdUInt32Unmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_RepUInt32{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepBool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new(bool)
			if err := github_com_gogo_protobuf_types.StdBoolUnmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_RepBool{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepString", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new(string)
			if err := github_com_gogo_protobuf_types.StdStringUnmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_RepString{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepBytes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := new([]byte)
			if err := github_com_gogo_protobuf_types.StdBytesUnmarshal(v, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfStdTimes = &OneofStdTypes_RepBytes{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTypes(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTypes
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTypes
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthTypes
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipTypes(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthTypes
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTypes   = fmt.Errorf("proto: integer overflow")
)