// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: stdtypes.proto

package stdtypes

import (
	bytes "bytes"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	_ "github.com/gogo/protobuf/types"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	math "math"
	reflect "reflect"
	strings "strings"
	time "time"
)

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

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

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

func (m *StdTypes) Reset()         { *m = StdTypes{} }
func (m *StdTypes) String() string { return proto.CompactTextString(m) }
func (*StdTypes) ProtoMessage()    {}
func (*StdTypes) Descriptor() ([]byte, []int) {
	return fileDescriptor_fa784ced32c4280a, []int{0}
}
func (m *StdTypes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StdTypes.Unmarshal(m, b)
}
func (m *StdTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StdTypes.Marshal(b, m, deterministic)
}
func (m *StdTypes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StdTypes.Merge(m, src)
}
func (m *StdTypes) XXX_Size() int {
	return xxx_messageInfo_StdTypes.Size(m)
}
func (m *StdTypes) XXX_DiscardUnknown() {
	xxx_messageInfo_StdTypes.DiscardUnknown(m)
}

var xxx_messageInfo_StdTypes proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *RepStdTypes) Reset()         { *m = RepStdTypes{} }
func (m *RepStdTypes) String() string { return proto.CompactTextString(m) }
func (*RepStdTypes) ProtoMessage()    {}
func (*RepStdTypes) Descriptor() ([]byte, []int) {
	return fileDescriptor_fa784ced32c4280a, []int{1}
}
func (m *RepStdTypes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RepStdTypes.Unmarshal(m, b)
}
func (m *RepStdTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RepStdTypes.Marshal(b, m, deterministic)
}
func (m *RepStdTypes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepStdTypes.Merge(m, src)
}
func (m *RepStdTypes) XXX_Size() int {
	return xxx_messageInfo_RepStdTypes.Size(m)
}
func (m *RepStdTypes) XXX_DiscardUnknown() {
	xxx_messageInfo_RepStdTypes.DiscardUnknown(m)
}

var xxx_messageInfo_RepStdTypes proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *MapStdTypes) Reset()         { *m = MapStdTypes{} }
func (m *MapStdTypes) String() string { return proto.CompactTextString(m) }
func (*MapStdTypes) ProtoMessage()    {}
func (*MapStdTypes) Descriptor() ([]byte, []int) {
	return fileDescriptor_fa784ced32c4280a, []int{2}
}
func (m *MapStdTypes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MapStdTypes.Unmarshal(m, b)
}
func (m *MapStdTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MapStdTypes.Marshal(b, m, deterministic)
}
func (m *MapStdTypes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MapStdTypes.Merge(m, src)
}
func (m *MapStdTypes) XXX_Size() int {
	return xxx_messageInfo_MapStdTypes.Size(m)
}
func (m *MapStdTypes) XXX_DiscardUnknown() {
	xxx_messageInfo_MapStdTypes.DiscardUnknown(m)
}

var xxx_messageInfo_MapStdTypes proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *OneofStdTypes) Reset()         { *m = OneofStdTypes{} }
func (m *OneofStdTypes) String() string { return proto.CompactTextString(m) }
func (*OneofStdTypes) ProtoMessage()    {}
func (*OneofStdTypes) Descriptor() ([]byte, []int) {
	return fileDescriptor_fa784ced32c4280a, []int{3}
}
func (m *OneofStdTypes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OneofStdTypes.Unmarshal(m, b)
}
func (m *OneofStdTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OneofStdTypes.Marshal(b, m, deterministic)
}
func (m *OneofStdTypes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OneofStdTypes.Merge(m, src)
}
func (m *OneofStdTypes) XXX_Size() int {
	return xxx_messageInfo_OneofStdTypes.Size(m)
}
func (m *OneofStdTypes) XXX_DiscardUnknown() {
	xxx_messageInfo_OneofStdTypes.DiscardUnknown(m)
}

var xxx_messageInfo_OneofStdTypes proto.InternalMessageInfo

type isOneofStdTypes_OneOfStdTimes interface {
	isOneofStdTypes_OneOfStdTimes()
	Equal(interface{}) bool
	VerboseEqual(interface{}) error
	Size() int
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// XXX_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),
		(*OneofStdTypes_RepDouble)(nil),
		(*OneofStdTypes_RepFloat)(nil),
		(*OneofStdTypes_RepInt64)(nil),
		(*OneofStdTypes_RepUInt64)(nil),
		(*OneofStdTypes_RepInt32)(nil),
		(*OneofStdTypes_RepUInt32)(nil),
		(*OneofStdTypes_RepBool)(nil),
		(*OneofStdTypes_RepString)(nil),
		(*OneofStdTypes_RepBytes)(nil),
	}
}

func _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 *OneofStdTypes_RepDouble:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdDoubleMarshal(*x.RepDouble)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case *OneofStdTypes_RepFloat:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdFloatMarshal(*x.RepFloat)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case *OneofStdTypes_RepInt64:
		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdInt64Marshal(*x.RepInt64)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case *OneofStdTypes_RepUInt64:
		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdUInt64Marshal(*x.RepUInt64)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case *OneofStdTypes_RepInt32:
		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdInt32Marshal(*x.RepInt32)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case *OneofStdTypes_RepUInt32:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdUInt32Marshal(*x.RepUInt32)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case *OneofStdTypes_RepBool:
		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdBoolMarshal(*x.RepBool)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case *OneofStdTypes_RepString:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdStringMarshal(*x.RepString)
		if err != nil {
			return err
		}
		if err := b.EncodeRawBytes(dAtA); err != nil {
			return err
		}
	case *OneofStdTypes_RepBytes:
		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
		dAtA, err := github_com_gogo_protobuf_types.StdBytesMarshal(*x.RepBytes)
		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
	case 3: // OneOfStdTimes.repDouble
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(float64)
		if err2 := github_com_gogo_protobuf_types.StdDoubleUnmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_RepDouble{c}
		return true, err
	case 4: // OneOfStdTimes.repFloat
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(float32)
		if err2 := github_com_gogo_protobuf_types.StdFloatUnmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_RepFloat{c}
		return true, err
	case 5: // OneOfStdTimes.repInt64
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(int64)
		if err2 := github_com_gogo_protobuf_types.StdInt64Unmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_RepInt64{c}
		return true, err
	case 6: // OneOfStdTimes.repUInt64
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(uint64)
		if err2 := github_com_gogo_protobuf_types.StdUInt64Unmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_RepUInt64{c}
		return true, err
	case 7: // OneOfStdTimes.repInt32
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(int32)
		if err2 := github_com_gogo_protobuf_types.StdInt32Unmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_RepInt32{c}
		return true, err
	case 8: // OneOfStdTimes.repUInt32
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(uint32)
		if err2 := github_com_gogo_protobuf_types.StdUInt32Unmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_RepUInt32{c}
		return true, err
	case 9: // OneOfStdTimes.repBool
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(bool)
		if err2 := github_com_gogo_protobuf_types.StdBoolUnmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_RepBool{c}
		return true, err
	case 10: // OneOfStdTimes.repString
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new(string)
		if err2 := github_com_gogo_protobuf_types.StdStringUnmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_RepString{c}
		return true, err
	case 11: // OneOfStdTimes.repBytes
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		if err != nil {
			return true, err
		}
		c := new([]byte)
		if err2 := github_com_gogo_protobuf_types.StdBytesUnmarshal(c, x); err2 != nil {
			return true, err
		}
		m.OneOfStdTimes = &OneofStdTypes_RepBytes{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 += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_Duration:
		s := github_com_gogo_protobuf_types.SizeOfStdDuration(*x.Duration)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_RepDouble:
		s := github_com_gogo_protobuf_types.SizeOfStdDouble(*x.RepDouble)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_RepFloat:
		s := github_com_gogo_protobuf_types.SizeOfStdFloat(*x.RepFloat)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_RepInt64:
		s := github_com_gogo_protobuf_types.SizeOfStdInt64(*x.RepInt64)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_RepUInt64:
		s := github_com_gogo_protobuf_types.SizeOfStdUInt64(*x.RepUInt64)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_RepInt32:
		s := github_com_gogo_protobuf_types.SizeOfStdInt32(*x.RepInt32)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_RepUInt32:
		s := github_com_gogo_protobuf_types.SizeOfStdUInt32(*x.RepUInt32)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_RepBool:
		s := github_com_gogo_protobuf_types.SizeOfStdBool(*x.RepBool)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_RepString:
		s := github_com_gogo_protobuf_types.SizeOfStdString(*x.RepString)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneofStdTypes_RepBytes:
		s := github_com_gogo_protobuf_types.SizeOfStdBytes(*x.RepBytes)
		n += 1 // tag and wire
		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((*StdTypes)(nil), "stdtypes.StdTypes")
	proto.RegisterType((*RepStdTypes)(nil), "stdtypes.RepStdTypes")
	proto.RegisterType((*MapStdTypes)(nil), "stdtypes.MapStdTypes")
	proto.RegisterMapType((map[int32]time.Duration)(nil), "stdtypes.MapStdTypes.DurationEntry")
	proto.RegisterMapType((map[int32]bool)(nil), "stdtypes.MapStdTypes.NonnullBoolEntry")
	proto.RegisterMapType((map[int32][]byte)(nil), "stdtypes.MapStdTypes.NonnullBytesEntry")
	proto.RegisterMapType((map[int32]float64)(nil), "stdtypes.MapStdTypes.NonnullDoubleEntry")
	proto.RegisterMapType((map[int32]float32)(nil), "stdtypes.MapStdTypes.NonnullFloatEntry")
	proto.RegisterMapType((map[int32]int32)(nil), "stdtypes.MapStdTypes.NonnullInt32Entry")
	proto.RegisterMapType((map[int32]int64)(nil), "stdtypes.MapStdTypes.NonnullInt64Entry")
	proto.RegisterMapType((map[int32]string)(nil), "stdtypes.MapStdTypes.NonnullStringEntry")
	proto.RegisterMapType((map[int32]uint32)(nil), "stdtypes.MapStdTypes.NonnullUInt32Entry")
	proto.RegisterMapType((map[int32]uint64)(nil), "stdtypes.MapStdTypes.NonnullUInt64Entry")
	proto.RegisterMapType((map[int32]*bool)(nil), "stdtypes.MapStdTypes.NullableBoolEntry")
	proto.RegisterMapType((map[int32]*[]byte)(nil), "stdtypes.MapStdTypes.NullableBytesEntry")
	proto.RegisterMapType((map[int32]*float64)(nil), "stdtypes.MapStdTypes.NullableDoubleEntry")
	proto.RegisterMapType((map[int32]*time.Duration)(nil), "stdtypes.MapStdTypes.NullableDurationEntry")
	proto.RegisterMapType((map[int32]*float32)(nil), "stdtypes.MapStdTypes.NullableFloatEntry")
	proto.RegisterMapType((map[int32]*int32)(nil), "stdtypes.MapStdTypes.NullableInt32Entry")
	proto.RegisterMapType((map[int32]*int64)(nil), "stdtypes.MapStdTypes.NullableInt64Entry")
	proto.RegisterMapType((map[int32]*string)(nil), "stdtypes.MapStdTypes.NullableStringEntry")
	proto.RegisterMapType((map[int32]*time.Time)(nil), "stdtypes.MapStdTypes.NullableTimestampEntry")
	proto.RegisterMapType((map[int32]*uint32)(nil), "stdtypes.MapStdTypes.NullableUInt32Entry")
	proto.RegisterMapType((map[int32]*uint64)(nil), "stdtypes.MapStdTypes.NullableUInt64Entry")
	proto.RegisterMapType((map[int32]time.Time)(nil), "stdtypes.MapStdTypes.TimestampEntry")
	proto.RegisterType((*OneofStdTypes)(nil), "stdtypes.OneofStdTypes")
}

func init() { proto.RegisterFile("stdtypes.proto", fileDescriptor_fa784ced32c4280a) }

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

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)
	}
	if this.NullableDouble != nil && that1.NullableDouble != nil {
		if *this.NullableDouble != *that1.NullableDouble {
			return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", *this.NullableDouble, *that1.NullableDouble)
		}
	} else if this.NullableDouble != nil {
		return fmt.Errorf("this.NullableDouble == nil && that.NullableDouble != nil")
	} else if that1.NullableDouble != nil {
		return fmt.Errorf("NullableDouble this(%v) Not Equal that(%v)", this.NullableDouble, that1.NullableDouble)
	}
	if this.NonnullDouble != that1.NonnullDouble {
		return fmt.Errorf("NonnullDouble this(%v) Not Equal that(%v)", this.NonnullDouble, that1.NonnullDouble)
	}
	if this.NullableFloat != nil && that1.NullableFloat != nil {
		if *this.NullableFloat != *that1.NullableFloat {
			return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", *this.NullableFloat, *that1.NullableFloat)
		}
	} else if this.NullableFloat != nil {
		return fmt.Errorf("this.NullableFloat == nil && that.NullableFloat != nil")
	} else if that1.NullableFloat != nil {
		return fmt.Errorf("NullableFloat this(%v) Not Equal that(%v)", this.NullableFloat, that1.NullableFloat)
	}
	if this.NonnullFloat != that1.NonnullFloat {
		return fmt.Errorf("NonnullFloat this(%v) Not Equal that(%v)", this.NonnullFloat, that1.NonnullFloat)
	}
	if this.NullableInt64 != nil && that1.NullableInt64 != nil {
		if *this.NullableInt64 != *that1.NullableInt64 {
			return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", *this.NullableInt64, *that1.NullableInt64)
		}
	} else if this.NullableInt64 != nil {
		return fmt.Errorf("this.NullableInt64 == nil && that.NullableInt64 != nil")
	} else if that1.NullableInt64 != nil {
		return fmt.Errorf("NullableInt64 this(%v) Not Equal that(%v)", this.NullableInt64, that1.NullableInt64)
	}
	if this.NonnullInt64 != that1.NonnullInt64 {
		return fmt.Errorf("NonnullInt64 this(%v) Not Equal that(%v)", this.NonnullInt64, that1.NonnullInt64)
	}
	if this.NullableUInt64 != nil && that1.NullableUInt64 != nil {
		if *this.NullableUInt64 != *that1.NullableUInt64 {
			return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", *this.NullableUInt64, *that1.NullableUInt64)
		}
	} else if this.NullableUInt64 != nil {
		return fmt.Errorf("this.NullableUInt64 == nil && that.NullableUInt64 != nil")
	} else if that1.NullableUInt64 != nil {
		return fmt.Errorf("NullableUInt64 this(%v) Not Equal that(%v)", this.NullableUInt64, that1.NullableUInt64)
	}
	if this.NonnullUInt64 != that1.NonnullUInt64 {
		return fmt.Errorf("NonnullUInt64 this(%v) Not Equal that(%v)", this.NonnullUInt64, that1.NonnullUInt64)
	}
	if this.NullableInt32 != nil && that1.NullableInt32 != nil {
		if *this.NullableInt32 != *that1.NullableInt32 {
			return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", *this.NullableInt32, *that1.NullableInt32)
		}
	} else if this.NullableInt32 != nil {
		return fmt.Errorf("this.NullableInt32 == nil && that.NullableInt32 != nil")
	} else if that1.NullableInt32 != nil {
		return fmt.Errorf("NullableInt32 this(%v) Not Equal that(%v)", this.NullableInt32, that1.NullableInt32)
	}
	if this.NonnullInt32 != that1.NonnullInt32 {
		return fmt.Errorf("NonnullInt32 this(%v) Not Equal that(%v)", this.NonnullInt32, that1.NonnullInt32)
	}
	if this.NullableUInt32 != nil && that1.NullableUInt32 != nil {
		if *this.NullableUInt32 != *that1.NullableUInt32 {
			return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", *this.NullableUInt32, *that1.NullableUInt32)
		}
	} else if this.NullableUInt32 != nil {
		return fmt.Errorf("this.NullableUInt32 == nil && that.NullableUInt32 != nil")
	} else if that1.NullableUInt32 != nil {
		return fmt.Errorf("NullableUInt32 this(%v) Not Equal that(%v)", this.NullableUInt32, that1.NullableUInt32)
	}
	if this.NonnullUInt32 != that1.NonnullUInt32 {
		return fmt.Errorf("NonnullUInt32 this(%v) Not Equal that(%v)", this.NonnullUInt32, that1.NonnullUInt32)
	}
	if this.NullableBool != nil && that1.NullableBool != nil {
		if *this.NullableBool != *that1.NullableBool {
			return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", *this.NullableBool, *that1.NullableBool)
		}
	} else if this.NullableBool != nil {
		return fmt.Errorf("this.NullableBool == nil && that.NullableBool != nil")
	} else if that1.NullableBool != nil {
		return fmt.Errorf("NullableBool this(%v) Not Equal that(%v)", this.NullableBool, that1.NullableBool)
	}
	if this.NonnullBool != that1.NonnullBool {
		return fmt.Errorf("NonnullBool this(%v) Not Equal that(%v)", this.NonnullBool, that1.NonnullBool)
	}
	if this.NullableString != nil && that1.NullableString != nil {
		if *this.NullableString != *that1.NullableString {
			return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", *this.NullableString, *that1.NullableString)
		}
	} else if this.NullableString != nil {
		return fmt.Errorf("this.NullableString == nil && that.NullableString != nil")
	} else if that1.NullableString != nil {
		return fmt.Errorf("NullableString this(%v) Not Equal that(%v)", this.NullableString, that1.NullableString)
	}
	if this.NonnullString != that1.NonnullString {
		return fmt.Errorf("NonnullString this(%v) Not Equal that(%v)", this.NonnullString, that1.NonnullString)
	}
	if that1.NullableBytes == nil {
		if this.NullableBytes != nil {
			return fmt.Errorf("this.NullableBytes != nil && that1.NullableBytes == nil")
		}
	} else if !bytes.Equal(*this.NullableBytes, *that1.NullableBytes) {
		return fmt.Errorf("NullableBytes this(%v) Not Equal that(%v)", this.NullableBytes, that1.NullableBytes)
	}
	if !bytes.Equal(this.NonnullBytes, that1.NonnullBytes) {
		return fmt.Errorf("NonnullBytes this(%v) Not Equal that(%v)", this.NonnullBytes, that1.NonnullBytes)
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *StdTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	that1, ok := that.(*OneofStdTypes_RepBytes)
	if !ok {
		that2, ok := that.(OneofStdTypes_RepBytes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.RepBytes == nil {
		if this.RepBytes != nil {
			return false
		}
	} else if !bytes.Equal(*this.RepBytes, *that1.RepBytes) {
		return false
	}
	return true
}
func (this *StdTypes) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 26)
	s = append(s, "&stdtypes.StdTypes{")
	s = append(s, "NullableTimestamp: "+fmt.Sprintf("%#v", this.NullableTimestamp)+",\n")
	s = append(s, "NullableDuration: "+fmt.Sprintf("%#v", this.NullableDuration)+",\n")
	s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	s = append(s, "Duration: "+fmt.Sprintf("%#v", this.Duration)+",\n")
	s = append(s, "NullableDouble: "+fmt.Sprintf("%#v", this.NullableDouble)+",\n")
	s = append(s, "NonnullDouble: "+fmt.Sprintf("%#v", this.NonnullDouble)+",\n")
	s = append(s, "NullableFloat: "+fmt.Sprintf("%#v", this.NullableFloat)+",\n")
	s = append(s, "NonnullFloat: "+fmt.Sprintf("%#v", this.NonnullFloat)+",\n")
	s = append(s, "NullableInt64: "+fmt.Sprintf("%#v", this.NullableInt64)+",\n")
	s = append(s, "NonnullInt64: "+fmt.Sprintf("%#v", this.NonnullInt64)+",\n")
	s = append(s, "NullableUInt64: "+fmt.Sprintf("%#v", this.NullableUInt64)+",\n")
	s = append(s, "NonnullUInt64: "+fmt.Sprintf("%#v", this.NonnullUInt64)+",\n")
	s = append(s, "NullableInt32: "+fmt.Sprintf("%#v", this.NullableInt32)+",\n")
	s = append(s, "NonnullInt32: "+fmt.Sprintf("%#v", this.NonnullInt32)+",\n")
	s = append(s, "NullableUInt32: "+fmt.Sprintf("%#v", this.NullableUInt32)+",\n")
	s = append(s, "NonnullUInt32: "+fmt.Sprintf("%#v", this.NonnullUInt32)+",\n")
	s = append(s, "NullableBool: "+fmt.Sprintf("%#v", this.NullableBool)+",\n")
	s = append(s, "NonnullBool: "+fmt.Sprintf("%#v", this.NonnullBool)+",\n")
	s = append(s, "NullableString: "+fmt.Sprintf("%#v", this.NullableString)+",\n")
	s = append(s, "NonnullString: "+fmt.Sprintf("%#v", this.NonnullString)+",\n")
	s = append(s, "NullableBytes: "+fmt.Sprintf("%#v", this.NullableBytes)+",\n")
	s = append(s, "NonnullBytes: "+fmt.Sprintf("%#v", this.NonnullBytes)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RepStdTypes) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 26)
	s = append(s, "&stdtypes.RepStdTypes{")
	s = append(s, "NullableTimestamps: "+fmt.Sprintf("%#v", this.NullableTimestamps)+",\n")
	s = append(s, "NullableDurations: "+fmt.Sprintf("%#v", this.NullableDurations)+",\n")
	s = append(s, "Timestamps: "+fmt.Sprintf("%#v", this.Timestamps)+",\n")
	s = append(s, "Durations: "+fmt.Sprintf("%#v", this.Durations)+",\n")
	s = append(s, "NullableDouble: "+fmt.Sprintf("%#v", this.NullableDouble)+",\n")
	s = append(s, "NonnullDouble: "+fmt.Sprintf("%#v", this.NonnullDouble)+",\n")
	s = append(s, "NullableFloat: "+fmt.Sprintf("%#v", this.NullableFloat)+",\n")
	s = append(s, "NonnullFloat: "+fmt.Sprintf("%#v", this.NonnullFloat)+",\n")
	s = append(s, "NullableInt64: "+fmt.Sprintf("%#v", this.NullableInt64)+",\n")
	s = append(s, "NonnullInt64: "+fmt.Sprintf("%#v", this.NonnullInt64)+",\n")
	s = append(s, "NullableUInt64: "+fmt.Sprintf("%#v", this.NullableUInt64)+",\n")
	s = append(s, "NonnullUInt64: "+fmt.Sprintf("%#v", this.NonnullUInt64)+",\n")
	s = append(s, "NullableInt32: "+fmt.Sprintf("%#v", this.NullableInt32)+",\n")
	s = append(s, "NonnullInt32: "+fmt.Sprintf("%#v", this.NonnullInt32)+",\n")
	s = append(s, "NullableUInt32: "+fmt.Sprintf("%#v", this.NullableUInt32)+",\n")
	s = append(s, "NonnullUInt32: "+fmt.Sprintf("%#v", this.NonnullUInt32)+",\n")
	s = append(s, "NullableBool: "+fmt.Sprintf("%#v", this.NullableBool)+",\n")
	s = append(s, "NonnullBool: "+fmt.Sprintf("%#v", this.NonnullBool)+",\n")
	s = append(s, "NullableString: "+fmt.Sprintf("%#v", this.NullableString)+",\n")
	s = append(s, "NonnullString: "+fmt.Sprintf("%#v", this.NonnullString)+",\n")
	s = append(s, "NullableBytes: "+fmt.Sprintf("%#v", this.NullableBytes)+",\n")
	s = append(s, "NonnullBytes: "+fmt.Sprintf("%#v", this.NonnullBytes)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MapStdTypes) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 26)
	s = append(s, "&stdtypes.MapStdTypes{")
	keysForNullableTimestamp := make([]int32, 0, len(this.NullableTimestamp))
	for k := range this.NullableTimestamp {
		keysForNullableTimestamp = append(keysForNullableTimestamp, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableTimestamp)
	mapStringForNullableTimestamp := "map[int32]*time.Time{"
	for _, k := range keysForNullableTimestamp {
		mapStringForNullableTimestamp += fmt.Sprintf("%#v: %#v,", k, this.NullableTimestamp[k])
	}
	mapStringForNullableTimestamp += "}"
	if this.NullableTimestamp != nil {
		s = append(s, "NullableTimestamp: "+mapStringForNullableTimestamp+",\n")
	}
	keysForTimestamp := make([]int32, 0, len(this.Timestamp))
	for k := range this.Timestamp {
		keysForTimestamp = append(keysForTimestamp, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForTimestamp)
	mapStringForTimestamp := "map[int32]time.Time{"
	for _, k := range keysForTimestamp {
		mapStringForTimestamp += fmt.Sprintf("%#v: %#v,", k, this.Timestamp[k])
	}
	mapStringForTimestamp += "}"
	if this.Timestamp != nil {
		s = append(s, "Timestamp: "+mapStringForTimestamp+",\n")
	}
	keysForNullableDuration := make([]int32, 0, len(this.NullableDuration))
	for k := range this.NullableDuration {
		keysForNullableDuration = append(keysForNullableDuration, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableDuration)
	mapStringForNullableDuration := "map[int32]*time.Duration{"
	for _, k := range keysForNullableDuration {
		mapStringForNullableDuration += fmt.Sprintf("%#v: %#v,", k, this.NullableDuration[k])
	}
	mapStringForNullableDuration += "}"
	if this.NullableDuration != nil {
		s = append(s, "NullableDuration: "+mapStringForNullableDuration+",\n")
	}
	keysForDuration := make([]int32, 0, len(this.Duration))
	for k := range this.Duration {
		keysForDuration = append(keysForDuration, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForDuration)
	mapStringForDuration := "map[int32]time.Duration{"
	for _, k := range keysForDuration {
		mapStringForDuration += fmt.Sprintf("%#v: %#v,", k, this.Duration[k])
	}
	mapStringForDuration += "}"
	if this.Duration != nil {
		s = append(s, "Duration: "+mapStringForDuration+",\n")
	}
	keysForNullableDouble := make([]int32, 0, len(this.NullableDouble))
	for k := range this.NullableDouble {
		keysForNullableDouble = append(keysForNullableDouble, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableDouble)
	mapStringForNullableDouble := "map[int32]*float64{"
	for _, k := range keysForNullableDouble {
		mapStringForNullableDouble += fmt.Sprintf("%#v: %#v,", k, this.NullableDouble[k])
	}
	mapStringForNullableDouble += "}"
	if this.NullableDouble != nil {
		s = append(s, "NullableDouble: "+mapStringForNullableDouble+",\n")
	}
	keysForNonnullDouble := make([]int32, 0, len(this.NonnullDouble))
	for k := range this.NonnullDouble {
		keysForNonnullDouble = append(keysForNonnullDouble, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullDouble)
	mapStringForNonnullDouble := "map[int32]float64{"
	for _, k := range keysForNonnullDouble {
		mapStringForNonnullDouble += fmt.Sprintf("%#v: %#v,", k, this.NonnullDouble[k])
	}
	mapStringForNonnullDouble += "}"
	if this.NonnullDouble != nil {
		s = append(s, "NonnullDouble: "+mapStringForNonnullDouble+",\n")
	}
	keysForNullableFloat := make([]int32, 0, len(this.NullableFloat))
	for k := range this.NullableFloat {
		keysForNullableFloat = append(keysForNullableFloat, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableFloat)
	mapStringForNullableFloat := "map[int32]*float32{"
	for _, k := range keysForNullableFloat {
		mapStringForNullableFloat += fmt.Sprintf("%#v: %#v,", k, this.NullableFloat[k])
	}
	mapStringForNullableFloat += "}"
	if this.NullableFloat != nil {
		s = append(s, "NullableFloat: "+mapStringForNullableFloat+",\n")
	}
	keysForNonnullFloat := make([]int32, 0, len(this.NonnullFloat))
	for k := range this.NonnullFloat {
		keysForNonnullFloat = append(keysForNonnullFloat, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullFloat)
	mapStringForNonnullFloat := "map[int32]float32{"
	for _, k := range keysForNonnullFloat {
		mapStringForNonnullFloat += fmt.Sprintf("%#v: %#v,", k, this.NonnullFloat[k])
	}
	mapStringForNonnullFloat += "}"
	if this.NonnullFloat != nil {
		s = append(s, "NonnullFloat: "+mapStringForNonnullFloat+",\n")
	}
	keysForNullableInt64 := make([]int32, 0, len(this.NullableInt64))
	for k := range this.NullableInt64 {
		keysForNullableInt64 = append(keysForNullableInt64, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableInt64)
	mapStringForNullableInt64 := "map[int32]*int64{"
	for _, k := range keysForNullableInt64 {
		mapStringForNullableInt64 += fmt.Sprintf("%#v: %#v,", k, this.NullableInt64[k])
	}
	mapStringForNullableInt64 += "}"
	if this.NullableInt64 != nil {
		s = append(s, "NullableInt64: "+mapStringForNullableInt64+",\n")
	}
	keysForNonnullInt64 := make([]int32, 0, len(this.NonnullInt64))
	for k := range this.NonnullInt64 {
		keysForNonnullInt64 = append(keysForNonnullInt64, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullInt64)
	mapStringForNonnullInt64 := "map[int32]int64{"
	for _, k := range keysForNonnullInt64 {
		mapStringForNonnullInt64 += fmt.Sprintf("%#v: %#v,", k, this.NonnullInt64[k])
	}
	mapStringForNonnullInt64 += "}"
	if this.NonnullInt64 != nil {
		s = append(s, "NonnullInt64: "+mapStringForNonnullInt64+",\n")
	}
	keysForNullableUInt64 := make([]int32, 0, len(this.NullableUInt64))
	for k := range this.NullableUInt64 {
		keysForNullableUInt64 = append(keysForNullableUInt64, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableUInt64)
	mapStringForNullableUInt64 := "map[int32]*uint64{"
	for _, k := range keysForNullableUInt64 {
		mapStringForNullableUInt64 += fmt.Sprintf("%#v: %#v,", k, this.NullableUInt64[k])
	}
	mapStringForNullableUInt64 += "}"
	if this.NullableUInt64 != nil {
		s = append(s, "NullableUInt64: "+mapStringForNullableUInt64+",\n")
	}
	keysForNonnullUInt64 := make([]int32, 0, len(this.NonnullUInt64))
	for k := range this.NonnullUInt64 {
		keysForNonnullUInt64 = append(keysForNonnullUInt64, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullUInt64)
	mapStringForNonnullUInt64 := "map[int32]uint64{"
	for _, k := range keysForNonnullUInt64 {
		mapStringForNonnullUInt64 += fmt.Sprintf("%#v: %#v,", k, this.NonnullUInt64[k])
	}
	mapStringForNonnullUInt64 += "}"
	if this.NonnullUInt64 != nil {
		s = append(s, "NonnullUInt64: "+mapStringForNonnullUInt64+",\n")
	}
	keysForNullableInt32 := make([]int32, 0, len(this.NullableInt32))
	for k := range this.NullableInt32 {
		keysForNullableInt32 = append(keysForNullableInt32, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableInt32)
	mapStringForNullableInt32 := "map[int32]*int32{"
	for _, k := range keysForNullableInt32 {
		mapStringForNullableInt32 += fmt.Sprintf("%#v: %#v,", k, this.NullableInt32[k])
	}
	mapStringForNullableInt32 += "}"
	if this.NullableInt32 != nil {
		s = append(s, "NullableInt32: "+mapStringForNullableInt32+",\n")
	}
	keysForNonnullInt32 := make([]int32, 0, len(this.NonnullInt32))
	for k := range this.NonnullInt32 {
		keysForNonnullInt32 = append(keysForNonnullInt32, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullInt32)
	mapStringForNonnullInt32 := "map[int32]int32{"
	for _, k := range keysForNonnullInt32 {
		mapStringForNonnullInt32 += fmt.Sprintf("%#v: %#v,", k, this.NonnullInt32[k])
	}
	mapStringForNonnullInt32 += "}"
	if this.NonnullInt32 != nil {
		s = append(s, "NonnullInt32: "+mapStringForNonnullInt32+",\n")
	}
	keysForNullableUInt32 := make([]int32, 0, len(this.NullableUInt32))
	for k := range this.NullableUInt32 {
		keysForNullableUInt32 = append(keysForNullableUInt32, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableUInt32)
	mapStringForNullableUInt32 := "map[int32]*uint32{"
	for _, k := range keysForNullableUInt32 {
		mapStringForNullableUInt32 += fmt.Sprintf("%#v: %#v,", k, this.NullableUInt32[k])
	}
	mapStringForNullableUInt32 += "}"
	if this.NullableUInt32 != nil {
		s = append(s, "NullableUInt32: "+mapStringForNullableUInt32+",\n")
	}
	keysForNonnullUInt32 := make([]int32, 0, len(this.NonnullUInt32))
	for k := range this.NonnullUInt32 {
		keysForNonnullUInt32 = append(keysForNonnullUInt32, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullUInt32)
	mapStringForNonnullUInt32 := "map[int32]uint32{"
	for _, k := range keysForNonnullUInt32 {
		mapStringForNonnullUInt32 += fmt.Sprintf("%#v: %#v,", k, this.NonnullUInt32[k])
	}
	mapStringForNonnullUInt32 += "}"
	if this.NonnullUInt32 != nil {
		s = append(s, "NonnullUInt32: "+mapStringForNonnullUInt32+",\n")
	}
	keysForNullableBool := make([]int32, 0, len(this.NullableBool))
	for k := range this.NullableBool {
		keysForNullableBool = append(keysForNullableBool, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableBool)
	mapStringForNullableBool := "map[int32]*bool{"
	for _, k := range keysForNullableBool {
		mapStringForNullableBool += fmt.Sprintf("%#v: %#v,", k, this.NullableBool[k])
	}
	mapStringForNullableBool += "}"
	if this.NullableBool != nil {
		s = append(s, "NullableBool: "+mapStringForNullableBool+",\n")
	}
	keysForNonnullBool := make([]int32, 0, len(this.NonnullBool))
	for k := range this.NonnullBool {
		keysForNonnullBool = append(keysForNonnullBool, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullBool)
	mapStringForNonnullBool := "map[int32]bool{"
	for _, k := range keysForNonnullBool {
		mapStringForNonnullBool += fmt.Sprintf("%#v: %#v,", k, this.NonnullBool[k])
	}
	mapStringForNonnullBool += "}"
	if this.NonnullBool != nil {
		s = append(s, "NonnullBool: "+mapStringForNonnullBool+",\n")
	}
	keysForNullableString := make([]int32, 0, len(this.NullableString))
	for k := range this.NullableString {
		keysForNullableString = append(keysForNullableString, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableString)
	mapStringForNullableString := "map[int32]*string{"
	for _, k := range keysForNullableString {
		mapStringForNullableString += fmt.Sprintf("%#v: %#v,", k, this.NullableString[k])
	}
	mapStringForNullableString += "}"
	if this.NullableString != nil {
		s = append(s, "NullableString: "+mapStringForNullableString+",\n")
	}
	keysForNonnullString := make([]int32, 0, len(this.NonnullString))
	for k := range this.NonnullString {
		keysForNonnullString = append(keysForNonnullString, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullString)
	mapStringForNonnullString := "map[int32]string{"
	for _, k := range keysForNonnullString {
		mapStringForNonnullString += fmt.Sprintf("%#v: %#v,", k, this.NonnullString[k])
	}
	mapStringForNonnullString += "}"
	if this.NonnullString != nil {
		s = append(s, "NonnullString: "+mapStringForNonnullString+",\n")
	}
	keysForNullableBytes := make([]int32, 0, len(this.NullableBytes))
	for k := range this.NullableBytes {
		keysForNullableBytes = append(keysForNullableBytes, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNullableBytes)
	mapStringForNullableBytes := "map[int32]*[]byte{"
	for _, k := range keysForNullableBytes {
		mapStringForNullableBytes += fmt.Sprintf("%#v: %#v,", k, this.NullableBytes[k])
	}
	mapStringForNullableBytes += "}"
	if this.NullableBytes != nil {
		s = append(s, "NullableBytes: "+mapStringForNullableBytes+",\n")
	}
	keysForNonnullBytes := make([]int32, 0, len(this.NonnullBytes))
	for k := range this.NonnullBytes {
		keysForNonnullBytes = append(keysForNonnullBytes, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNonnullBytes)
	mapStringForNonnullBytes := "map[int32][]byte{"
	for _, k := range keysForNonnullBytes {
		mapStringForNonnullBytes += fmt.Sprintf("%#v: %#v,", k, this.NonnullBytes[k])
	}
	mapStringForNonnullBytes += "}"
	if this.NonnullBytes != nil {
		s = append(s, "NonnullBytes: "+mapStringForNonnullBytes+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *OneofStdTypes) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&stdtypes.OneofStdTypes{")
	if this.OneOfStdTimes != nil {
		s = append(s, "OneOfStdTimes: "+fmt.Sprintf("%#v", this.OneOfStdTimes)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *OneofStdTypes_Timestamp) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_Timestamp{` +
		`Timestamp:` + fmt.Sprintf("%#v", this.Timestamp) + `}`}, ", ")
	return s
}
func (this *OneofStdTypes_Duration) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_Duration{` +
		`Duration:` + fmt.Sprintf("%#v", this.Duration) + `}`}, ", ")
	return s
}
func (this *OneofStdTypes_RepDouble) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepDouble{` +
		`RepDouble:` + fmt.Sprintf("%#v", this.RepDouble) + `}`}, ", ")
	return s
}
func (this *OneofStdTypes_RepFloat) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepFloat{` +
		`RepFloat:` + fmt.Sprintf("%#v", this.RepFloat) + `}`}, ", ")
	return s
}
func (this *OneofStdTypes_RepInt64) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepInt64{` +
		`RepInt64:` + fmt.Sprintf("%#v", this.RepInt64) + `}`}, ", ")
	return s
}
func (this *OneofStdTypes_RepUInt64) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepUInt64{` +
		`RepUInt64:` + fmt.Sprintf("%#v", this.RepUInt64) + `}`}, ", ")
	return s
}
func (this *OneofStdTypes_RepInt32) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepInt32{` +
		`RepInt32:` + fmt.Sprintf("%#v", this.RepInt32) + `}`}, ", ")
	return s
}
func (this *OneofStdTypes_RepUInt32) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepUInt32{` +
		`RepUInt32:` + fmt.Sprintf("%#v", this.RepUInt32) + `}`}, ", ")
	return s
}
func (this *OneofStdTypes_RepBool) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepBool{` +
		`RepBool:` + fmt.Sprintf("%#v", this.RepBool) + `}`}, ", ")
	return s
}
func (this *OneofStdTypes_RepString) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepString{` +
		`RepString:` + fmt.Sprintf("%#v", this.RepString) + `}`}, ", ")
	return s
}
func (this *OneofStdTypes_RepBytes) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&stdtypes.OneofStdTypes_RepBytes{` +
		`RepBytes:` + fmt.Sprintf("%#v", this.RepBytes) + `}`}, ", ")
	return s
}
func valueToGoStringStdtypes(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func NewPopulatedStdTypes(r randyStdtypes, 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)
	}
	v1 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.Timestamp = *v1
	v2 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
	this.Duration = *v2
	if r.Intn(10) != 0 {
		this.NullableDouble = github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
	}
	v3 := github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
	this.NonnullDouble = *v3
	if r.Intn(10) != 0 {
		this.NullableFloat = github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
	}
	v4 := github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
	this.NonnullFloat = *v4
	if r.Intn(10) != 0 {
		this.NullableInt64 = github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
	}
	v5 := github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
	this.NonnullInt64 = *v5
	if r.Intn(10) != 0 {
		this.NullableUInt64 = github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
	}
	v6 := github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
	this.NonnullUInt64 = *v6
	if r.Intn(10) != 0 {
		this.NullableInt32 = github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
	}
	v7 := github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
	this.NonnullInt32 = *v7
	if r.Intn(10) != 0 {
		this.NullableUInt32 = github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
	}
	v8 := github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
	this.NonnullUInt32 = *v8
	if r.Intn(10) != 0 {
		this.NullableBool = github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
	}
	v9 := github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
	this.NonnullBool = *v9
	if r.Intn(10) != 0 {
		this.NullableString = github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
	}
	v10 := github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
	this.NonnullString = *v10
	if r.Intn(10) != 0 {
		this.NullableBytes = github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
	}
	v11 := github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
	this.NonnullBytes = *v11
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedStdtypes(r, 23)
	}
	return this
}

func NewPopulatedRepStdTypes(r randyStdtypes, easy bool) *RepStdTypes {
	this := &RepStdTypes{}
	if r.Intn(10) != 0 {
		v12 := r.Intn(5)
		this.NullableTimestamps = make([]*time.Time, v12)
		for i := 0; i < v12; i++ {
			this.NullableTimestamps[i] = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v13 := r.Intn(5)
		this.NullableDurations = make([]*time.Duration, v13)
		for i := 0; i < v13; i++ {
			this.NullableDurations[i] = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v14 := r.Intn(5)
		this.Timestamps = make([]time.Time, v14)
		for i := 0; i < v14; i++ {
			v15 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
			this.Timestamps[i] = *v15
		}
	}
	if r.Intn(10) != 0 {
		v16 := r.Intn(5)
		this.Durations = make([]time.Duration, v16)
		for i := 0; i < v16; i++ {
			v17 := github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
			this.Durations[i] = *v17
		}
	}
	if r.Intn(10) != 0 {
		v18 := r.Intn(5)
		this.NullableDouble = make([]*float64, v18)
		for i := 0; i < v18; i++ {
			this.NullableDouble[i] = github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v19 := r.Intn(5)
		this.NonnullDouble = make([]float64, v19)
		for i := 0; i < v19; i++ {
			v20 := github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy)
			this.NonnullDouble[i] = *v20
		}
	}
	if r.Intn(10) != 0 {
		v21 := r.Intn(5)
		this.NullableFloat = make([]*float32, v21)
		for i := 0; i < v21; i++ {
			this.NullableFloat[i] = github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v22 := r.Intn(5)
		this.NonnullFloat = make([]float32, v22)
		for i := 0; i < v22; i++ {
			v23 := github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy)
			this.NonnullFloat[i] = *v23
		}
	}
	if r.Intn(10) != 0 {
		v24 := r.Intn(5)
		this.NullableInt64 = make([]*int64, v24)
		for i := 0; i < v24; i++ {
			this.NullableInt64[i] = github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v25 := r.Intn(5)
		this.NonnullInt64 = make([]int64, v25)
		for i := 0; i < v25; i++ {
			v26 := github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy)
			this.NonnullInt64[i] = *v26
		}
	}
	if r.Intn(10) != 0 {
		v27 := r.Intn(5)
		this.NullableUInt64 = make([]*uint64, v27)
		for i := 0; i < v27; i++ {
			this.NullableUInt64[i] = github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v28 := r.Intn(5)
		this.NonnullUInt64 = make([]uint64, v28)
		for i := 0; i < v28; i++ {
			v29 := github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy)
			this.NonnullUInt64[i] = *v29
		}
	}
	if r.Intn(10) != 0 {
		v30 := r.Intn(5)
		this.NullableInt32 = make([]*int32, v30)
		for i := 0; i < v30; i++ {
			this.NullableInt32[i] = github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v31 := r.Intn(5)
		this.NonnullInt32 = make([]int32, v31)
		for i := 0; i < v31; i++ {
			v32 := github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy)
			this.NonnullInt32[i] = *v32
		}
	}
	if r.Intn(10) != 0 {
		v33 := r.Intn(5)
		this.NullableUInt32 = make([]*uint32, v33)
		for i := 0; i < v33; i++ {
			this.NullableUInt32[i] = github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v34 := r.Intn(5)
		this.NonnullUInt32 = make([]uint32, v34)
		for i := 0; i < v34; i++ {
			v35 := github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy)
			this.NonnullUInt32[i] = *v35
		}
	}
	if r.Intn(10) != 0 {
		v36 := r.Intn(5)
		this.NullableBool = make([]*bool, v36)
		for i := 0; i < v36; i++ {
			this.NullableBool[i] = github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v37 := r.Intn(5)
		this.NonnullBool = make([]bool, v37)
		for i := 0; i < v37; i++ {
			v38 := github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy)
			this.NonnullBool[i] = *v38
		}
	}
	if r.Intn(10) != 0 {
		v39 := r.Intn(5)
		this.NullableString = make([]*string, v39)
		for i := 0; i < v39; i++ {
			this.NullableString[i] = github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v40 := r.Intn(5)
		this.NonnullString = make([]string, v40)
		for i := 0; i < v40; i++ {
			v41 := github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy)
			this.NonnullString[i] = *v41
		}
	}
	if r.Intn(10) != 0 {
		v42 := r.Intn(5)
		this.NullableBytes = make([]*[]byte, v42)
		for i := 0; i < v42; i++ {
			this.NullableBytes[i] = github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v43 := r.Intn(5)
		this.NonnullBytes = make([][]byte, v43)
		for i := 0; i < v43; i++ {
			v44 := github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy)
			this.NonnullBytes[i] = *v44
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedStdtypes(r, 23)
	}
	return this
}

func NewPopulatedMapStdTypes(r randyStdtypes, easy bool) *MapStdTypes {
	this := &MapStdTypes{}
	if r.Intn(10) != 0 {
		v45 := r.Intn(10)
		this.NullableTimestamp = make(map[int32]*time.Time)
		for i := 0; i < v45; i++ {
			this.NullableTimestamp[int32(r.Int31())] = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v46 := r.Intn(10)
		this.Timestamp = make(map[int32]time.Time)
		for i := 0; i < v46; i++ {
			this.Timestamp[int32(r.Int31())] = *github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v47 := r.Intn(10)
		this.NullableDuration = make(map[int32]*time.Duration)
		for i := 0; i < v47; i++ {
			this.NullableDuration[int32(r.Int31())] = github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v48 := r.Intn(10)
		this.Duration = make(map[int32]time.Duration)
		for i := 0; i < v48; i++ {
			this.Duration[int32(r.Int31())] = *github_com_gogo_protobuf_types.NewPopulatedStdDuration(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v49 := r.Intn(10)
		this.NullableDouble = make(map[int32]*float64)
		for i := 0; i < v49; i++ {
			this.NullableDouble[int32(r.Int31())] = (*float64)(github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v50 := r.Intn(10)
		this.NonnullDouble = make(map[int32]float64)
		for i := 0; i < v50; i++ {
			this.NonnullDouble[int32(r.Int31())] = (float64)(*github_com_gogo_protobuf_types.NewPopulatedStdDouble(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v51 := r.Intn(10)
		this.NullableFloat = make(map[int32]*float32)
		for i := 0; i < v51; i++ {
			this.NullableFloat[int32(r.Int31())] = (*float32)(github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v52 := r.Intn(10)
		this.NonnullFloat = make(map[int32]float32)
		for i := 0; i < v52; i++ {
			this.NonnullFloat[int32(r.Int31())] = (float32)(*github_com_gogo_protobuf_types.NewPopulatedStdFloat(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v53 := r.Intn(10)
		this.NullableInt64 = make(map[int32]*int64)
		for i := 0; i < v53; i++ {
			this.NullableInt64[int32(r.Int31())] = (*int64)(github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v54 := r.Intn(10)
		this.NonnullInt64 = make(map[int32]int64)
		for i := 0; i < v54; i++ {
			this.NonnullInt64[int32(r.Int31())] = (int64)(*github_com_gogo_protobuf_types.NewPopulatedStdInt64(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v55 := r.Intn(10)
		this.NullableUInt64 = make(map[int32]*uint64)
		for i := 0; i < v55; i++ {
			this.NullableUInt64[int32(r.Int31())] = (*uint64)(github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v56 := r.Intn(10)
		this.NonnullUInt64 = make(map[int32]uint64)
		for i := 0; i < v56; i++ {
			this.NonnullUInt64[int32(r.Int31())] = (uint64)(*github_com_gogo_protobuf_types.NewPopulatedStdUInt64(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v57 := r.Intn(10)
		this.NullableInt32 = make(map[int32]*int32)
		for i := 0; i < v57; i++ {
			this.NullableInt32[int32(r.Int31())] = (*int32)(github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v58 := r.Intn(10)
		this.NonnullInt32 = make(map[int32]int32)
		for i := 0; i < v58; i++ {
			this.NonnullInt32[int32(r.Int31())] = (int32)(*github_com_gogo_protobuf_types.NewPopulatedStdInt32(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v59 := r.Intn(10)
		this.NullableUInt32 = make(map[int32]*uint32)
		for i := 0; i < v59; i++ {
			this.NullableUInt32[int32(r.Int31())] = (*uint32)(github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v60 := r.Intn(10)
		this.NonnullUInt32 = make(map[int32]uint32)
		for i := 0; i < v60; i++ {
			this.NonnullUInt32[int32(r.Int31())] = (uint32)(*github_com_gogo_protobuf_types.NewPopulatedStdUInt32(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v61 := r.Intn(10)
		this.NullableBool = make(map[int32]*bool)
		for i := 0; i < v61; i++ {
			this.NullableBool[int32(r.Int31())] = (*bool)(github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v62 := r.Intn(10)
		this.NonnullBool = make(map[int32]bool)
		for i := 0; i < v62; i++ {
			this.NonnullBool[int32(r.Int31())] = (bool)(*github_com_gogo_protobuf_types.NewPopulatedStdBool(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v63 := r.Intn(10)
		this.NullableString = make(map[int32]*string)
		for i := 0; i < v63; i++ {
			this.NullableString[int32(r.Int31())] = (*string)(github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v64 := r.Intn(10)
		this.NonnullString = make(map[int32]string)
		for i := 0; i < v64; i++ {
			this.NonnullString[int32(r.Int31())] = (string)(*github_com_gogo_protobuf_types.NewPopulatedStdString(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v65 := r.Intn(10)
		this.NullableBytes = make(map[int32]*[]byte)
		for i := 0; i < v65; i++ {
			this.NullableBytes[int32(r.Int31())] = (*[]byte)(github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy))
		}
	}
	if r.Intn(10) != 0 {
		v66 := r.Intn(10)
		this.NonnullBytes = make(map[int32][]byte)
		for i := 0; i < v66; i++ {
			this.NonnullBytes[int32(r.Int31())] = ([]byte)(*github_com_gogo_protobuf_types.NewPopulatedStdBytes(r, easy))
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedStdtypes(r, 23)
	}
	return this
}

func NewPopulatedOneofStdTypes(r randyStdtypes, easy bool) *OneofStdTypes {
	this := &OneofStdTypes{}
	oneofNumber_OneOfStdTimes := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}[r.Intn(11)]
	switch oneofNumber_OneOfStdTimes {
	case 1:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_Timestamp(r, easy)
	case 2:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_Duration(r, easy)
	case 3:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepDouble(r, easy)
	case 4:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepFloat(r, easy)
	case 5:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepInt64(r, easy)
	case 6:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepUInt64(r, easy)
	case 7:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepInt32(r, easy)
	case 8:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepUInt32(r, easy)
	case 9:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepBool(r, easy)
	case 10:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepString(r, easy)
	case 11:
		this.OneOfStdTimes = NewPopulatedOneofStdTypes_RepBytes(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedStdtypes(r, 12)
	}
	return this
}

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

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

func randUTF8RuneStdtypes(r randyStdtypes) 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 randStringStdtypes(r randyStdtypes) string {
	v67 := r.Intn(100)
	tmps := make([]rune, v67)
	for i := 0; i < v67; i++ {
		tmps[i] = randUTF8RuneStdtypes(r)
	}
	return string(tmps)
}
func randUnrecognizedStdtypes(r randyStdtypes, 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 = randFieldStdtypes(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldStdtypes(dAtA []byte, r randyStdtypes, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateStdtypes(dAtA, uint64(key))
		v68 := r.Int63()
		if r.Intn(2) == 0 {
			v68 *= -1
		}
		dAtA = encodeVarintPopulateStdtypes(dAtA, uint64(v68))
	case 1:
		dAtA = encodeVarintPopulateStdtypes(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 = encodeVarintPopulateStdtypes(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateStdtypes(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateStdtypes(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 encodeVarintPopulateStdtypes(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 *StdTypes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NullableTimestamp != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.NullableTimestamp)
		n += 1 + l + sovStdtypes(uint64(l))
	}
	if m.NullableDuration != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.NullableDuration)
		n += 1 + l + sovStdtypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
	n += 1 + l + sovStdtypes(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration)
	n += 1 + l + sovStdtypes(uint64(l))
	if m.NullableDouble != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDouble(*m.NullableDouble)
		n += 1 + l + sovStdtypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdDouble(m.NonnullDouble)
	n += 1 + l + sovStdtypes(uint64(l))
	if m.NullableFloat != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdFloat(*m.NullableFloat)
		n += 1 + l + sovStdtypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdFloat(m.NonnullFloat)
	n += 1 + l + sovStdtypes(uint64(l))
	if m.NullableInt64 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdInt64(*m.NullableInt64)
		n += 1 + l + sovStdtypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdInt64(m.NonnullInt64)
	n += 1 + l + sovStdtypes(uint64(l))
	if m.NullableUInt64 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdUInt64(*m.NullableUInt64)
		n += 1 + l + sovStdtypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdUInt64(m.NonnullUInt64)
	n += 1 + l + sovStdtypes(uint64(l))
	if m.NullableInt32 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdInt32(*m.NullableInt32)
		n += 1 + l + sovStdtypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdInt32(m.NonnullInt32)
	n += 1 + l + sovStdtypes(uint64(l))
	if m.NullableUInt32 != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.NullableUInt32)
		n += 1 + l + sovStdtypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdUInt32(m.NonnullUInt32)
	n += 2 + l + sovStdtypes(uint64(l))
	if m.NullableBool != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdBool(*m.NullableBool)
		n += 2 + l + sovStdtypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdBool(m.NonnullBool)
	n += 2 + l + sovStdtypes(uint64(l))
	if m.NullableString != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdString(*m.NullableString)
		n += 2 + l + sovStdtypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdString(m.NonnullString)
	n += 2 + l + sovStdtypes(uint64(l))
	if m.NullableBytes != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdBytes(*m.NullableBytes)
		n += 2 + l + sovStdtypes(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdBytes(m.NonnullBytes)
	n += 2 + l + sovStdtypes(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

func sovStdtypes(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozStdtypes(x uint64) (n int) {
	return sovStdtypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
