types.pb.go

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

/*
	Package types is a generated protocol buffer package.

	It is generated from these files:
		combos/unsafeboth/types.proto

	It has these top-level messages:
		KnownTypes
		ProtoTypes
		StdTypes
		RepProtoTypes
		RepStdTypes
		MapProtoTypes
		MapStdTypes
		OneofProtoTypes
		OneofStdTypes
*/
package types

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import google_protobuf1 "github.com/gogo/protobuf/types"
import google_protobuf2 "github.com/gogo/protobuf/types"
import google_protobuf3 "github.com/gogo/protobuf/types"

import time "time"
import github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"

import io "io"

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

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

type KnownTypes struct {
	Dur   *google_protobuf1.Duration    `protobuf:"bytes,1,opt,name=dur" json:"dur,omitempty"`
	Ts    *google_protobuf2.Timestamp   `protobuf:"bytes,2,opt,name=ts" json:"ts,omitempty"`
	Dbl   *google_protobuf3.DoubleValue `protobuf:"bytes,3,opt,name=dbl" json:"dbl,omitempty"`
	Flt   *google_protobuf3.FloatValue  `protobuf:"bytes,4,opt,name=flt" json:"flt,omitempty"`
	I64   *google_protobuf3.Int64Value  `protobuf:"bytes,5,opt,name=i64" json:"i64,omitempty"`
	U64   *google_protobuf3.UInt64Value `protobuf:"bytes,6,opt,name=u64" json:"u64,omitempty"`
	I32   *google_protobuf3.Int32Value  `protobuf:"bytes,7,opt,name=i32" json:"i32,omitempty"`
	U32   *google_protobuf3.UInt32Value `protobuf:"bytes,8,opt,name=u32" json:"u32,omitempty"`
	Bool  *google_protobuf3.BoolValue   `protobuf:"bytes,9,opt,name=bool" json:"bool,omitempty"`
	Str   *google_protobuf3.StringValue `protobuf:"bytes,10,opt,name=str" json:"str,omitempty"`
	Bytes *google_protobuf3.BytesValue  `protobuf:"bytes,11,opt,name=bytes" json:"bytes,omitempty"`
}

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

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

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

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

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

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

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

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

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

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

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

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

type ProtoTypes struct {
	NullableTimestamp *google_protobuf2.Timestamp `protobuf:"bytes,1,opt,name=nullableTimestamp" json:"nullableTimestamp,omitempty"`
	NullableDuration  *google_protobuf1.Duration  `protobuf:"bytes,2,opt,name=nullableDuration" json:"nullableDuration,omitempty"`
	Timestamp         google_protobuf2.Timestamp  `protobuf:"bytes,3,opt,name=timestamp" json:"timestamp"`
	Duration          google_protobuf1.Duration   `protobuf:"bytes,4,opt,name=duration" json:"duration"`
}

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

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

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

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

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

type StdTypes struct {
	NullableTimestamp *time.Time     `protobuf:"bytes,1,opt,name=nullableTimestamp,stdtime" json:"nullableTimestamp,omitempty"`
	NullableDuration  *time.Duration `protobuf:"bytes,2,opt,name=nullableDuration,stdduration" json:"nullableDuration,omitempty"`
	Timestamp         time.Time      `protobuf:"bytes,3,opt,name=timestamp,stdtime" json:"timestamp"`
	Duration          time.Duration  `protobuf:"bytes,4,opt,name=duration,stdduration" json:"duration"`
}

func (m *StdTypes) Reset()                    { *m = StdTypes{} }
func (m *StdTypes) String() string            { return proto.CompactTextString(m) }
func (*StdTypes) ProtoMessage()               {}
func (*StdTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{2} }

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) 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
}

type RepProtoTypes struct {
	NullableTimestamps []*google_protobuf2.Timestamp `protobuf:"bytes,1,rep,name=nullableTimestamps" json:"nullableTimestamps,omitempty"`
	NullableDurations  []*google_protobuf1.Duration  `protobuf:"bytes,2,rep,name=nullableDurations" json:"nullableDurations,omitempty"`
	Timestamps         []google_protobuf2.Timestamp  `protobuf:"bytes,3,rep,name=timestamps" json:"timestamps"`
	Durations          []google_protobuf1.Duration   `protobuf:"bytes,4,rep,name=durations" json:"durations"`
}

func (m *RepProtoTypes) Reset()                    { *m = RepProtoTypes{} }
func (m *RepProtoTypes) String() string            { return proto.CompactTextString(m) }
func (*RepProtoTypes) ProtoMessage()               {}
func (*RepProtoTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{3} }

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

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

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

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

type RepStdTypes struct {
	NullableTimestamps []*time.Time     `protobuf:"bytes,1,rep,name=nullableTimestamps,stdtime" json:"nullableTimestamps,omitempty"`
	NullableDurations  []*time.Duration `protobuf:"bytes,2,rep,name=nullableDurations,stdduration" json:"nullableDurations,omitempty"`
	Timestamps         []time.Time      `protobuf:"bytes,3,rep,name=timestamps,stdtime" json:"timestamps"`
	Durations          []time.Duration  `protobuf:"bytes,4,rep,name=durations,stdduration" json:"durations"`
}

func (m *RepStdTypes) Reset()                    { *m = RepStdTypes{} }
func (m *RepStdTypes) String() string            { return proto.CompactTextString(m) }
func (*RepStdTypes) ProtoMessage()               {}
func (*RepStdTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{4} }

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
}

type MapProtoTypes struct {
	NullableTimestamp map[int32]*google_protobuf2.Timestamp `protobuf:"bytes,1,rep,name=nullableTimestamp" json:"nullableTimestamp,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	Timestamp         map[int32]google_protobuf2.Timestamp  `protobuf:"bytes,2,rep,name=timestamp" json:"timestamp" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	NullableDuration  map[int32]*google_protobuf1.Duration  `protobuf:"bytes,3,rep,name=nullableDuration" json:"nullableDuration,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	Duration          map[int32]google_protobuf1.Duration   `protobuf:"bytes,4,rep,name=duration" json:"duration" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *MapProtoTypes) Reset()                    { *m = MapProtoTypes{} }
func (m *MapProtoTypes) String() string            { return proto.CompactTextString(m) }
func (*MapProtoTypes) ProtoMessage()               {}
func (*MapProtoTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{5} }

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

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

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

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

type MapStdTypes struct {
	NullableTimestamp map[int32]*time.Time     `protobuf:"bytes,1,rep,name=nullableTimestamp,stdtime" json:"nullableTimestamp,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	Timestamp         map[int32]time.Time      `protobuf:"bytes,2,rep,name=timestamp,stdtime" json:"timestamp" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	NullableDuration  map[int32]*time.Duration `protobuf:"bytes,3,rep,name=nullableDuration,stdduration" json:"nullableDuration,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	Duration          map[int32]time.Duration  `protobuf:"bytes,4,rep,name=duration,stdduration" json:"duration" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *MapStdTypes) Reset()                    { *m = MapStdTypes{} }
func (m *MapStdTypes) String() string            { return proto.CompactTextString(m) }
func (*MapStdTypes) ProtoMessage()               {}
func (*MapStdTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{6} }

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
}

type OneofProtoTypes struct {
	// Types that are valid to be assigned to OneOfProtoTimes:
	//	*OneofProtoTypes_Timestamp
	//	*OneofProtoTypes_Duration
	OneOfProtoTimes isOneofProtoTypes_OneOfProtoTimes `protobuf_oneof:"OneOfProtoTimes"`
}

func (m *OneofProtoTypes) Reset()                    { *m = OneofProtoTypes{} }
func (m *OneofProtoTypes) String() string            { return proto.CompactTextString(m) }
func (*OneofProtoTypes) ProtoMessage()               {}
func (*OneofProtoTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{7} }

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

type OneofProtoTypes_Timestamp struct {
	Timestamp *google_protobuf2.Timestamp `protobuf:"bytes,1,opt,name=timestamp,oneof"`
}
type OneofProtoTypes_Duration struct {
	Duration *google_protobuf1.Duration `protobuf:"bytes,2,opt,name=duration,oneof"`
}

func (*OneofProtoTypes_Timestamp) isOneofProtoTypes_OneOfProtoTimes() {}
func (*OneofProtoTypes_Duration) isOneofProtoTypes_OneOfProtoTimes()  {}

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

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

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

// XXX_OneofFuncs is for the internal use of the proto package.
func (*OneofProtoTypes) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _OneofProtoTypes_OneofMarshaler, _OneofProtoTypes_OneofUnmarshaler, _OneofProtoTypes_OneofSizer, []interface{}{
		(*OneofProtoTypes_Timestamp)(nil),
		(*OneofProtoTypes_Duration)(nil),
	}
}

func _OneofProtoTypes_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*OneofProtoTypes)
	// OneOfProtoTimes
	switch x := m.OneOfProtoTimes.(type) {
	case *OneofProtoTypes_Timestamp:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Timestamp); err != nil {
			return err
		}
	case *OneofProtoTypes_Duration:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Duration); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("OneofProtoTypes.OneOfProtoTimes has unexpected type %T", x)
	}
	return nil
}

func _OneofProtoTypes_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*OneofProtoTypes)
	switch tag {
	case 1: // OneOfProtoTimes.timestamp
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(google_protobuf2.Timestamp)
		err := b.DecodeMessage(msg)
		m.OneOfProtoTimes = &OneofProtoTypes_Timestamp{msg}
		return true, err
	case 2: // OneOfProtoTimes.duration
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(google_protobuf1.Duration)
		err := b.DecodeMessage(msg)
		m.OneOfProtoTimes = &OneofProtoTypes_Duration{msg}
		return true, err
	default:
		return false, nil
	}
}

func _OneofProtoTypes_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*OneofProtoTypes)
	// OneOfProtoTimes
	switch x := m.OneOfProtoTimes.(type) {
	case *OneofProtoTypes_Timestamp:
		s := proto.Size(x.Timestamp)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofProtoTypes_Duration:
		s := proto.Size(x.Duration)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type OneofStdTypes struct {
	// Types that are valid to be assigned to OneOfStdTimes:
	//	*OneofStdTypes_Timestamp
	//	*OneofStdTypes_Duration
	OneOfStdTimes isOneofStdTypes_OneOfStdTimes `protobuf_oneof:"OneOfStdTimes"`
}

func (m *OneofStdTypes) Reset()                    { *m = OneofStdTypes{} }
func (m *OneofStdTypes) String() string            { return proto.CompactTextString(m) }
func (*OneofStdTypes) ProtoMessage()               {}
func (*OneofStdTypes) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{8} }

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,oneof,stdtime"`
}
type OneofStdTypes_Duration struct {
	Duration *time.Duration `protobuf:"bytes,2,opt,name=duration,oneof,stdduration"`
}

func (*OneofStdTypes_Timestamp) isOneofStdTypes_OneOfStdTimes() {}
func (*OneofStdTypes_Duration) 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
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*OneofStdTypes) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _OneofStdTypes_OneofMarshaler, _OneofStdTypes_OneofUnmarshaler, _OneofStdTypes_OneofSizer, []interface{}{
		(*OneofStdTypes_Timestamp)(nil),
		(*OneofStdTypes_Duration)(nil),
	}
}

func _OneofStdTypes_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*OneofStdTypes)
	// OneOfStdTimes
	switch x := m.OneOfStdTimes.(type) {
	case *OneofStdTypes_Timestamp:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdTimeMarshal(*x.Timestamp)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case *OneofStdTypes_Duration:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdDurationMarshal(*x.Duration)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("OneofStdTypes.OneOfStdTimes has unexpected type %T", x)
	}
	return nil
}

func _OneofStdTypes_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*OneofStdTypes)
	switch tag {
	case 1: // OneOfStdTimes.timestamp
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(time.Time)
		if err2 := github_com_gogo_protobuf_types.StdTimeUnmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_Timestamp{c}
		return true, err
	case 2: // OneOfStdTimes.duration
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(time.Duration)
		if err2 := github_com_gogo_protobuf_types.StdDurationUnmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_Duration{c}
		return true, err
	default:
		return false, nil
	}
}

func _OneofStdTypes_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*OneofStdTypes)
	// OneOfStdTimes
	switch x := m.OneOfStdTimes.(type) {
	case *OneofStdTypes_Timestamp:
		s := github_com_gogo_protobuf_types.SizeOfStdTime(*x.Timestamp)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_Duration:
		s := github_com_gogo_protobuf_types.SizeOfStdDuration(*x.Duration)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

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.RegisterType((*MapStdTypes)(nil), "types.MapStdTypes")
	proto.RegisterType((*OneofProtoTypes)(nil), "types.OneofProtoTypes")
	proto.RegisterType((*OneofStdTypes)(nil), "types.OneofStdTypes")
}
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
	}
	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.Timestamp.Compare(&that1.Timestamp); c != 0 {
		return c
	}
	if c := this.Duration.Compare(&that1.Duration); 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
		}
	}
	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)
	}
	return nil
}
func (this *KnownTypes) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*KnownTypes)
	if !ok {
		that2, ok := that.(KnownTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
	}
	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.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)
	}
	return nil
}
func (this *ProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ProtoTypes)
	if !ok {
		that2, ok := that.(ProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.NullableTimestamp.Equal(that1.NullableTimestamp) {
		return false
	}
	if !this.NullableDuration.Equal(that1.NullableDuration) {
		return false
	}
	if !this.Timestamp.Equal(&that1.Timestamp) {
		return false
	}
	if !this.Duration.Equal(&that1.Duration) {
		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.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)
	}
	return nil
}
func (this *StdTypes) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StdTypes)
	if !ok {
		that2, ok := that.(StdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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.Timestamp.Equal(that1.Timestamp) {
		return false
	}
	if this.Duration != that1.Duration {
		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])
		}
	}
	return nil
}
func (this *RepProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*RepProtoTypes)
	if !ok {
		that2, ok := that.(RepProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
		}
	}
	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])
		}
	}
	return nil
}
func (this *RepStdTypes) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*RepStdTypes)
	if !ok {
		that2, ok := that.(RepStdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
		}
	}
	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])
		}
	}
	return nil
}
func (this *MapProtoTypes) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*MapProtoTypes)
	if !ok {
		that2, ok := that.(MapProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
		}
	}
	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])
		}
	}
	return nil
}
func (this *MapStdTypes) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*MapStdTypes)
	if !ok {
		that2, ok := that.(MapStdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
		}
	}
	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
	}
	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) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*OneofProtoTypes)
	if !ok {
		that2, ok := that.(OneofProtoTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
	}
	return true
}
func (this *OneofProtoTypes_Timestamp) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*OneofProtoTypes_Timestamp)
	if !ok {
		that2, ok := that.(OneofProtoTypes_Timestamp)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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 {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*OneofProtoTypes_Duration)
	if !ok {
		that2, ok := that.(OneofProtoTypes_Duration)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Duration.Equal(that1.Duration) {
		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
	}
	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) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*OneofStdTypes)
	if !ok {
		that2, ok := that.(OneofStdTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
	}
	return true
}
func (this *OneofStdTypes_Timestamp) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*OneofStdTypes_Timestamp)
	if !ok {
		that2, ok := that.(OneofStdTypes_Timestamp)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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 {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*OneofStdTypes_Duration)
	if !ok {
		that2, ok := that.(OneofStdTypes_Duration)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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 NewPopulatedKnownTypes(r randyTypes, easy bool) *KnownTypes {
	this := &KnownTypes{}
	if r.Intn(10) != 0 {
		this.Dur = google_protobuf1.NewPopulatedDuration(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Ts = google_protobuf2.NewPopulatedTimestamp(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Dbl = google_protobuf3.NewPopulatedDoubleValue(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Flt = google_protobuf3.NewPopulatedFloatValue(r, easy)
	}
	if r.Intn(10) != 0 {
		this.I64 = google_protobuf3.NewPopulatedInt64Value(r, easy)
	}
	if r.Intn(10) != 0 {
		this.U64 = google_protobuf3.NewPopulatedUInt64Value(r, easy)
	}
	if r.Intn(10) != 0 {
		this.I32 = google_protobuf3.NewPopulatedInt32Value(r, easy)
	}
	if r.Intn(10) != 0 {
		this.U32 = google_protobuf3.NewPopulatedUInt32Value(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Bool = google_protobuf3.NewPopulatedBoolValue(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Str = google_protobuf3.NewPopulatedStringValue(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Bytes = google_protobuf3.NewPopulatedBytesValue(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedProtoTypes(r randyTypes, easy bool) *ProtoTypes {
	this := &ProtoTypes{}
	if r.Intn(10) != 0 {
		this.NullableTimestamp = google_protobuf2.NewPopulatedTimestamp(r, easy)
	}
	if r.Intn(10) != 0 {
		this.NullableDuration = google_protobuf1.NewPopulatedDuration(r, easy)
	}
	v1 := google_protobuf2.NewPopulatedTimestamp(r, easy)
	this.Timestamp = *v1
	v2 := google_protobuf1.NewPopulatedDuration(r, easy)
	this.Duration = *v2
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedStdTypes(r randyTypes, easy bool) *StdTypes {
	this := &StdTypes{}
	if r.Intn(10) != 0 {
		this.NullableTimestamp = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	if r.Intn(10) != 0 {
		this.NullableDuration = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
	}
	v3 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.Timestamp = *v3
	v4 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
	this.Duration = *v4
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRepProtoTypes(r randyTypes, easy bool) *RepProtoTypes {
	this := &RepProtoTypes{}
	if r.Intn(10) != 0 {
		v5 := r.Intn(5)
		this.NullableTimestamps = make([]*google_protobuf2.Timestamp, v5)
		for i := 0; i < v5; i++ {
			this.NullableTimestamps[i] = google_protobuf2.NewPopulatedTimestamp(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v6 := r.Intn(5)
		this.NullableDurations = make([]*google_protobuf1.Duration, v6)
		for i := 0; i < v6; i++ {
			this.NullableDurations[i] = google_protobuf1.NewPopulatedDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v7 := r.Intn(5)
		this.Timestamps = make([]google_protobuf2.Timestamp, v7)
		for i := 0; i < v7; i++ {
			v8 := google_protobuf2.NewPopulatedTimestamp(r, easy)
			this.Timestamps[i] = *v8
		}
	}
	if r.Intn(10) != 0 {
		v9 := r.Intn(5)
		this.Durations = make([]google_protobuf1.Duration, v9)
		for i := 0; i < v9; i++ {
			v10 := google_protobuf1.NewPopulatedDuration(r, easy)
			this.Durations[i] = *v10
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRepStdTypes(r randyTypes, easy bool) *RepStdTypes {
	this := &RepStdTypes{}
	if r.Intn(10) != 0 {
		v11 := r.Intn(5)
		this.NullableTimestamps = make([]*time.Time, v11)
		for i := 0; i < v11; i++ {
			this.NullableTimestamps[i] = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v12 := r.Intn(5)
		this.NullableDurations = make([]*time.Duration, v12)
		for i := 0; i < v12; i++ {
			this.NullableDurations[i] = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v13 := r.Intn(5)
		this.Timestamps = make([]time.Time, v13)
		for i := 0; i < v13; i++ {
			v14 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
			this.Timestamps[i] = *v14
		}
	}
	if r.Intn(10) != 0 {
		v15 := r.Intn(5)
		this.Durations = make([]time.Duration, v15)
		for i := 0; i < v15; i++ {
			v16 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
			this.Durations[i] = *v16
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedMapProtoTypes(r randyTypes, easy bool) *MapProtoTypes {
	this := &MapProtoTypes{}
	if r.Intn(10) != 0 {
		v17 := r.Intn(10)
		this.NullableTimestamp = make(map[int32]*google_protobuf2.Timestamp)
		for i := 0; i < v17; i++ {
			this.NullableTimestamp[int32(r.Int31())] = google_protobuf2.NewPopulatedTimestamp(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v18 := r.Intn(10)
		this.Timestamp = make(map[int32]google_protobuf2.Timestamp)
		for i := 0; i < v18; i++ {
			this.Timestamp[int32(r.Int31())] = *google_protobuf2.NewPopulatedTimestamp(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v19 := r.Intn(10)
		this.NullableDuration = make(map[int32]*google_protobuf1.Duration)
		for i := 0; i < v19; i++ {
			this.NullableDuration[int32(r.Int31())] = google_protobuf1.NewPopulatedDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v20 := r.Intn(10)
		this.Duration = make(map[int32]google_protobuf1.Duration)
		for i := 0; i < v20; i++ {
			this.Duration[int32(r.Int31())] = *google_protobuf1.NewPopulatedDuration(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedMapStdTypes(r randyTypes, easy bool) *MapStdTypes {
	this := &MapStdTypes{}
	if r.Intn(10) != 0 {
		v21 := r.Intn(10)
		this.NullableTimestamp = make(map[int32]*time.Time)
		for i := 0; i < v21; i++ {
			this.NullableTimestamp[int32(r.Int31())] = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v22 := r.Intn(10)
		this.Timestamp = make(map[int32]time.Time)
		for i := 0; i < v22; i++ {
			this.Timestamp[int32(r.Int31())] = *github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v23 := r.Intn(10)
		this.NullableDuration = make(map[int32]*time.Duration)
		for i := 0; i < v23; i++ {
			this.NullableDuration[int32(r.Int31())] = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v24 := r.Intn(10)
		this.Duration = make(map[int32]time.Duration)
		for i := 0; i < v24; i++ {
			this.Duration[int32(r.Int31())] = *github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedOneofProtoTypes(r randyTypes, easy bool) *OneofProtoTypes {
	this := &OneofProtoTypes{}
	oneofNumber_OneOfProtoTimes := []int32{1, 2}[r.Intn(2)]
	switch oneofNumber_OneOfProtoTimes {
	case 1:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_Timestamp(r, easy)
	case 2:
		this.OneOfProtoTimes = NewPopulatedOneofProtoTypes_Duration(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedOneofProtoTypes_Timestamp(r randyTypes, easy bool) *OneofProtoTypes_Timestamp {
	this := &OneofProtoTypes_Timestamp{}
	this.Timestamp = google_protobuf2.NewPopulatedTimestamp(r, easy)
	return this
}
func NewPopulatedOneofProtoTypes_Duration(r randyTypes, easy bool) *OneofProtoTypes_Duration {
	this := &OneofProtoTypes_Duration{}
	this.Duration = google_protobuf1.NewPopulatedDuration(r, easy)
	return this
}
func NewPopulatedOneofStdTypes(r randyTypes, easy bool) *OneofStdTypes {
	this := &OneofStdTypes{}
	oneofNumber_OneOfStdTimes := []int32{1, 2}[r.Intn(2)]
	switch oneofNumber_OneOfStdTimes {
	case 1:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_Timestamp(r, easy)
	case 2:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_Duration(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	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
}

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 {
	v25 := r.Intn(100)
	tmps := make([]rune, v25)
	for i := 0; i < v25; 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))
		v26 := r.Int63()
		if r.Intn(2) == 0 {
			v26 *= -1
		}
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(v26))
	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) {
	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))
	}
	return n
}

func (m *ProtoTypes) Size() (n int) {
	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))
	}
	l = m.Timestamp.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.Duration.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *StdTypes) Size() (n int) {
	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))
	}
	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))
	return n
}

func (m *RepProtoTypes) Size() (n int) {
	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))
		}
	}
	return n
}

func (m *RepStdTypes) Size() (n int) {
	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))
		}
	}
	return n
}

func (m *MapProtoTypes) Size() (n int) {
	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))
		}
	}
	return n
}

func (m *MapStdTypes) Size() (n int) {
	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))
		}
	}
	return n
}

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

func (m *OneofProtoTypes_Timestamp) Size() (n int) {
	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) {
	var l int
	_ = l
	if m.Duration != nil {
		l = m.Duration.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *OneofStdTypes) Size() (n int) {
	var l int
	_ = l
	if m.OneOfStdTimes != nil {
		n += m.OneOfStdTimes.Size()
	}
	return n
}

func (m *OneofStdTypes_Timestamp) Size() (n int) {
	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) {
	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 sovTypes(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *KnownTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *KnownTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Dur != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Dur.Size()))
		n1, err := m.Dur.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.Ts != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Ts.Size()))
		n2, err := m.Ts.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Dbl != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Dbl.Size()))
		n3, err := m.Dbl.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Flt != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Flt.Size()))
		n4, err := m.Flt.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.I64 != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.I64.Size()))
		n5, err := m.I64.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.U64 != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.U64.Size()))
		n6, err := m.U64.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.I32 != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.I32.Size()))
		n7, err := m.I32.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.U32 != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.U32.Size()))
		n8, err := m.U32.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.Bool != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Bool.Size()))
		n9, err := m.Bool.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.Str != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Str.Size()))
		n10, err := m.Str.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if m.Bytes != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Bytes.Size()))
		n11, err := m.Bytes.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}

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

func (m *ProtoTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.NullableTimestamp != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.NullableTimestamp.Size()))
		n12, err := m.NullableTimestamp.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.NullableDuration != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.NullableDuration.Size()))
		n13, err := m.NullableDuration.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintTypes(dAtA, i, uint64(m.Timestamp.Size()))
	n14, err := m.Timestamp.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n14
	dAtA[i] = 0x22
	i++
	i = encodeVarintTypes(dAtA, i, uint64(m.Duration.Size()))
	n15, err := m.Duration.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n15
	return i, nil
}

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

func (m *StdTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.NullableTimestamp != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.NullableTimestamp)))
		n16, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.NullableTimestamp, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	if m.NullableDuration != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*m.NullableDuration)))
		n17, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.NullableDuration, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)))
	n18, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n18
	dAtA[i] = 0x22
	i++
	i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration)))
	n19, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n19
	return i, nil
}

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

func (m *RepProtoTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NullableTimestamps) > 0 {
		for _, msg := range m.NullableTimestamps {
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.NullableDurations) > 0 {
		for _, msg := range m.NullableDurations {
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Timestamps) > 0 {
		for _, msg := range m.Timestamps {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Durations) > 0 {
		for _, msg := range m.Durations {
			dAtA[i] = 0x22
			i++
			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *RepStdTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NullableTimestamps) > 0 {
		for _, msg := range m.NullableTimestamps {
			dAtA[i] = 0xa
			i++
			i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*msg)))
			n, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*msg, dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.NullableDurations) > 0 {
		for _, msg := range m.NullableDurations {
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*msg)))
			n, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*msg, dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Timestamps) > 0 {
		for _, msg := range m.Timestamps {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(msg)))
			n, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(msg, dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Durations) > 0 {
		for _, msg := range m.Durations {
			dAtA[i] = 0x22
			i++
			i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(msg)))
			n, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(msg, dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *MapProtoTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NullableTimestamp) > 0 {
		for k := range m.NullableTimestamp {
			dAtA[i] = 0xa
			i++
			v := m.NullableTimestamp[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(v.Size()))
				n20, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n20
			}
		}
	}
	if len(m.Timestamp) > 0 {
		for k := range m.Timestamp {
			dAtA[i] = 0x12
			i++
			v := m.Timestamp[k]
			msgSize := 0
			if (&v) != nil {
				msgSize = (&v).Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64((&v).Size()))
			n21, err := (&v).MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n21
		}
	}
	if len(m.NullableDuration) > 0 {
		for k := range m.NullableDuration {
			dAtA[i] = 0x1a
			i++
			v := m.NullableDuration[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(v.Size()))
				n22, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n22
			}
		}
	}
	if len(m.Duration) > 0 {
		for k := range m.Duration {
			dAtA[i] = 0x22
			i++
			v := m.Duration[k]
			msgSize := 0
			if (&v) != nil {
				msgSize = (&v).Size()
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64((&v).Size()))
			n23, err := (&v).MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n23
		}
	}
	return i, nil
}

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

func (m *MapStdTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NullableTimestamp) > 0 {
		for k := range m.NullableTimestamp {
			dAtA[i] = 0xa
			i++
			v := m.NullableTimestamp[k]
			msgSize := 0
			if v != nil {
				msgSize = github_com_gogo_protobuf_types.SizeOfStdTime(*v)
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*v)))
				n24, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*v, dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n24
			}
		}
	}
	if len(m.Timestamp) > 0 {
		for k := range m.Timestamp {
			dAtA[i] = 0x12
			i++
			v := m.Timestamp[k]
			msgSize := 0
			if (&v) != nil {
				msgSize = github_com_gogo_protobuf_types.SizeOfStdTime(*(&v))
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*(&v))))
			n25, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*(&v), dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n25
		}
	}
	if len(m.NullableDuration) > 0 {
		for k := range m.NullableDuration {
			dAtA[i] = 0x1a
			i++
			v := m.NullableDuration[k]
			msgSize := 0
			if v != nil {
				msgSize = github_com_gogo_protobuf_types.SizeOfStdDuration(*v)
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*v)))
				n26, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*v, dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n26
			}
		}
	}
	if len(m.Duration) > 0 {
		for k := range m.Duration {
			dAtA[i] = 0x22
			i++
			v := m.Duration[k]
			msgSize := 0
			if (&v) != nil {
				msgSize = github_com_gogo_protobuf_types.SizeOfStdDuration(*(&v))
				msgSize += 1 + sovTypes(uint64(msgSize))
			}
			mapSize := 1 + sovTypes(uint64(k)) + msgSize
			i = encodeVarintTypes(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTypes(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*(&v))))
			n27, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*(&v), dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n27
		}
	}
	return i, nil
}

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

func (m *OneofProtoTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OneOfProtoTimes != nil {
		nn28, err := m.OneOfProtoTimes.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn28
	}
	return i, nil
}

func (m *OneofProtoTypes_Timestamp) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Timestamp != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Timestamp.Size()))
		n29, err := m.Timestamp.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n29
	}
	return i, nil
}
func (m *OneofProtoTypes_Duration) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Duration != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTypes(dAtA, i, uint64(m.Duration.Size()))
		n30, err := m.Duration.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n30
	}
	return i, nil
}
func (m *OneofStdTypes) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OneofStdTypes) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OneOfStdTimes != nil {
		nn31, err := m.OneOfStdTimes.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn31
	}
	return i, nil
}

func (m *OneofStdTypes_Timestamp) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Timestamp != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp)))
		n32, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Timestamp, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n32
	}
	return i, nil
}
func (m *OneofStdTypes_Duration) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Duration != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Duration)))
		n33, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.Duration, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n33
	}
	return i, nil
}
func encodeFixed64Types(dAtA []byte, offset int, v uint64) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	dAtA[offset+4] = uint8(v >> 32)
	dAtA[offset+5] = uint8(v >> 40)
	dAtA[offset+6] = uint8(v >> 48)
	dAtA[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Types(dAtA []byte, offset int, v uint32) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *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 ErrIntOverflowTypesUnsafe
			}
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Dur == nil {
				m.Dur = &google_protobuf1.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Ts == nil {
				m.Ts = &google_protobuf2.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Dbl == nil {
				m.Dbl = &google_protobuf3.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Flt == nil {
				m.Flt = &google_protobuf3.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.I64 == nil {
				m.I64 = &google_protobuf3.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.U64 == nil {
				m.U64 = &google_protobuf3.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.I32 == nil {
				m.I32 = &google_protobuf3.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.U32 == nil {
				m.U32 = &google_protobuf3.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Bool == nil {
				m.Bool = &google_protobuf3.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Str == nil {
				m.Str = &google_protobuf3.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Bytes == nil {
				m.Bytes = &google_protobuf3.BytesValue{}
			}
			if err := m.Bytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypesUnsafe(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowTypesUnsafe
			}
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableTimestamp == nil {
				m.NullableTimestamp = &google_protobuf2.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NullableDuration == nil {
				m.NullableDuration = &google_protobuf1.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 Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Duration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypesUnsafe(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowTypesUnsafe
			}
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			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 Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			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 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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			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
		default:
			iNdEx = preIndex
			skippy, err := skipTypesUnsafe(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowTypesUnsafe
			}
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableTimestamps = append(m.NullableTimestamps, &google_protobuf2.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NullableDurations = append(m.NullableDurations, &google_protobuf1.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Timestamps = append(m.Timestamps, google_protobuf2.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Durations = append(m.Durations, google_protobuf1.Duration{})
			if err := m.Durations[len(m.Durations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypesUnsafe(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowTypesUnsafe
			}
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			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
		default:
			iNdEx = preIndex
			skippy, err := skipTypesUnsafe(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowTypesUnsafe
			}
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				mapkey |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if m.NullableTimestamp == nil {
				m.NullableTimestamp = make(map[int32]*google_protobuf2.Timestamp)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapmsglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					mapmsglen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				postmsgIndex := iNdEx + mapmsglen
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &google_protobuf2.Timestamp{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.NullableTimestamp[mapkey] = mapvalue
			} else {
				var mapvalue *google_protobuf2.Timestamp
				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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				mapkey |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if m.Timestamp == nil {
				m.Timestamp = make(map[int32]google_protobuf2.Timestamp)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapmsglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					mapmsglen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				postmsgIndex := iNdEx + mapmsglen
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &google_protobuf2.Timestamp{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.Timestamp[mapkey] = *mapvalue
			} else {
				var mapvalue google_protobuf2.Timestamp
				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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				mapkey |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if m.NullableDuration == nil {
				m.NullableDuration = make(map[int32]*google_protobuf1.Duration)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapmsglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					mapmsglen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				postmsgIndex := iNdEx + mapmsglen
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &google_protobuf1.Duration{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.NullableDuration[mapkey] = mapvalue
			} else {
				var mapvalue *google_protobuf1.Duration
				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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				mapkey |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if m.Duration == nil {
				m.Duration = make(map[int32]google_protobuf1.Duration)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapmsglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					mapmsglen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				postmsgIndex := iNdEx + mapmsglen
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &google_protobuf1.Duration{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.Duration[mapkey] = *mapvalue
			} else {
				var mapvalue google_protobuf1.Duration
				m.Duration[mapkey] = mapvalue
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypesUnsafe(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowTypesUnsafe
			}
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				mapkey |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if m.NullableTimestamp == nil {
				m.NullableTimestamp = make(map[int32]*time.Time)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapmsglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					mapmsglen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				postmsgIndex := iNdEx + mapmsglen
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := new(time.Time)
				if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(mapvalue, dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.NullableTimestamp[mapkey] = mapvalue
			} else {
				var mapvalue = new(time.Time)
				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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				mapkey |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if m.Timestamp == nil {
				m.Timestamp = make(map[int32]time.Time)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapmsglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					mapmsglen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				postmsgIndex := iNdEx + mapmsglen
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := new(time.Time)
				if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(mapvalue, dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.Timestamp[mapkey] = *mapvalue
			} else {
				var mapvalue = new(time.Time)
				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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				mapkey |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if m.NullableDuration == nil {
				m.NullableDuration = make(map[int32]*time.Duration)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapmsglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					mapmsglen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				postmsgIndex := iNdEx + mapmsglen
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := new(time.Duration)
				if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(mapvalue, dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.NullableDuration[mapkey] = mapvalue
			} else {
				var mapvalue = new(time.Duration)
				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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				mapkey |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if m.Duration == nil {
				m.Duration = make(map[int32]time.Duration)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapmsglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypesUnsafe
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					mapmsglen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				postmsgIndex := iNdEx + mapmsglen
				if mapmsglen < 0 {
					return ErrInvalidLengthTypesUnsafe
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := new(time.Duration)
				if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(mapvalue, dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.Duration[mapkey] = *mapvalue
			} else {
				var mapvalue = new(time.Duration)
				m.Duration[mapkey] = *mapvalue
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypesUnsafe(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowTypesUnsafe
			}
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &google_protobuf2.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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &google_protobuf1.Duration{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.OneOfProtoTimes = &OneofProtoTypes_Duration{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypesUnsafe(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowTypesUnsafe
			}
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			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 ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			postIndex := iNdEx + msglen
			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
		default:
			iNdEx = preIndex
			skippy, err := skipTypesUnsafe(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypesUnsafe
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTypesUnsafe(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, ErrIntOverflowTypesUnsafe
			}
			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, ErrIntOverflowTypesUnsafe
				}
				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, ErrIntOverflowTypesUnsafe
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthTypesUnsafe
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowTypesUnsafe
					}
					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 := skipTypesUnsafe(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

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

func init() { proto.RegisterFile("combos/unsafeboth/types.proto", fileDescriptorTypes) }

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