github.com/kaisenlinux/docker.io@v0.0.0-20230510090727-ea55db55fac7/swarmkit/protobuf/plugin/deepcopy/test/deepcopy.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/docker/swarmkit/protobuf/plugin/deepcopy/test/deepcopy.proto

package test

import (
	bytes "bytes"
	fmt "fmt"
	github_com_docker_swarmkit_api_deepcopy "github.com/docker/swarmkit/api/deepcopy"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	math "math"
	reflect "reflect"
	strings "strings"
)

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

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

type BasicScalar struct {
	Field1  float64 `protobuf:"fixed64,1,opt,name=Field1,proto3" json:"Field1,omitempty"`
	Field2  float32 `protobuf:"fixed32,2,opt,name=Field2,proto3" json:"Field2,omitempty"`
	Field3  int32   `protobuf:"varint,3,opt,name=Field3,proto3" json:"Field3,omitempty"`
	Field4  int64   `protobuf:"varint,4,opt,name=Field4,proto3" json:"Field4,omitempty"`
	Field5  uint32  `protobuf:"varint,5,opt,name=Field5,proto3" json:"Field5,omitempty"`
	Field6  uint64  `protobuf:"varint,6,opt,name=Field6,proto3" json:"Field6,omitempty"`
	Field7  int32   `protobuf:"zigzag32,7,opt,name=Field7,proto3" json:"Field7,omitempty"`
	Field8  int64   `protobuf:"zigzag64,8,opt,name=Field8,proto3" json:"Field8,omitempty"`
	Field9  uint32  `protobuf:"fixed32,9,opt,name=Field9,proto3" json:"Field9,omitempty"`
	Field10 int32   `protobuf:"fixed32,10,opt,name=Field10,proto3" json:"Field10,omitempty"`
	Field11 uint64  `protobuf:"fixed64,11,opt,name=Field11,proto3" json:"Field11,omitempty"`
	Field12 int64   `protobuf:"fixed64,12,opt,name=Field12,proto3" json:"Field12,omitempty"`
	Field13 bool    `protobuf:"varint,13,opt,name=Field13,proto3" json:"Field13,omitempty"`
	Field14 string  `protobuf:"bytes,14,opt,name=Field14,proto3" json:"Field14,omitempty"`
	Field15 []byte  `protobuf:"bytes,15,opt,name=Field15,proto3" json:"Field15,omitempty"`
}

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

var xxx_messageInfo_BasicScalar proto.InternalMessageInfo

type RepeatedScalar struct {
	Field1  []float64 `protobuf:"fixed64,1,rep,packed,name=Field1,proto3" json:"Field1,omitempty"`
	Field2  []float32 `protobuf:"fixed32,2,rep,packed,name=Field2,proto3" json:"Field2,omitempty"`
	Field3  []int32   `protobuf:"varint,3,rep,packed,name=Field3,proto3" json:"Field3,omitempty"`
	Field4  []int64   `protobuf:"varint,4,rep,packed,name=Field4,proto3" json:"Field4,omitempty"`
	Field5  []uint32  `protobuf:"varint,5,rep,packed,name=Field5,proto3" json:"Field5,omitempty"`
	Field6  []uint64  `protobuf:"varint,6,rep,packed,name=Field6,proto3" json:"Field6,omitempty"`
	Field7  []int32   `protobuf:"zigzag32,7,rep,packed,name=Field7,proto3" json:"Field7,omitempty"`
	Field8  []int64   `protobuf:"zigzag64,8,rep,packed,name=Field8,proto3" json:"Field8,omitempty"`
	Field9  []uint32  `protobuf:"fixed32,9,rep,packed,name=Field9,proto3" json:"Field9,omitempty"`
	Field10 []int32   `protobuf:"fixed32,10,rep,packed,name=Field10,proto3" json:"Field10,omitempty"`
	Field11 []uint64  `protobuf:"fixed64,11,rep,packed,name=Field11,proto3" json:"Field11,omitempty"`
	Field12 []int64   `protobuf:"fixed64,12,rep,packed,name=Field12,proto3" json:"Field12,omitempty"`
	Field13 []bool    `protobuf:"varint,13,rep,packed,name=Field13,proto3" json:"Field13,omitempty"`
	Field14 []string  `protobuf:"bytes,14,rep,name=Field14,proto3" json:"Field14,omitempty"`
	Field15 [][]byte  `protobuf:"bytes,15,rep,name=Field15,proto3" json:"Field15,omitempty"`
}

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

var xxx_messageInfo_RepeatedScalar proto.InternalMessageInfo

type RepeatedScalarPacked struct {
	Field1  []float64 `protobuf:"fixed64,1,rep,packed,name=Field1,proto3" json:"Field1,omitempty"`
	Field2  []float32 `protobuf:"fixed32,2,rep,packed,name=Field2,proto3" json:"Field2,omitempty"`
	Field3  []int32   `protobuf:"varint,3,rep,packed,name=Field3,proto3" json:"Field3,omitempty"`
	Field4  []int64   `protobuf:"varint,4,rep,packed,name=Field4,proto3" json:"Field4,omitempty"`
	Field5  []uint32  `protobuf:"varint,5,rep,packed,name=Field5,proto3" json:"Field5,omitempty"`
	Field6  []uint64  `protobuf:"varint,6,rep,packed,name=Field6,proto3" json:"Field6,omitempty"`
	Field7  []int32   `protobuf:"zigzag32,7,rep,packed,name=Field7,proto3" json:"Field7,omitempty"`
	Field8  []int64   `protobuf:"zigzag64,8,rep,packed,name=Field8,proto3" json:"Field8,omitempty"`
	Field9  []uint32  `protobuf:"fixed32,9,rep,packed,name=Field9,proto3" json:"Field9,omitempty"`
	Field10 []int32   `protobuf:"fixed32,10,rep,packed,name=Field10,proto3" json:"Field10,omitempty"`
	Field11 []uint64  `protobuf:"fixed64,11,rep,packed,name=Field11,proto3" json:"Field11,omitempty"`
	Field12 []int64   `protobuf:"fixed64,12,rep,packed,name=Field12,proto3" json:"Field12,omitempty"`
	Field13 []bool    `protobuf:"varint,13,rep,packed,name=Field13,proto3" json:"Field13,omitempty"`
}

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

var xxx_messageInfo_RepeatedScalarPacked proto.InternalMessageInfo

type ExternalStruct struct {
	Field1 *BasicScalar          `protobuf:"bytes,1,opt,name=Field1,proto3" json:"Field1,omitempty"`
	Field2 *RepeatedScalar       `protobuf:"bytes,2,opt,name=Field2,proto3" json:"Field2,omitempty"`
	Field3 *RepeatedScalarPacked `protobuf:"bytes,3,opt,name=Field3,proto3" json:"Field3,omitempty"`
}

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

var xxx_messageInfo_ExternalStruct proto.InternalMessageInfo

type RepeatedExternalStruct struct {
	Field1 []*BasicScalar          `protobuf:"bytes,1,rep,name=Field1,proto3" json:"Field1,omitempty"`
	Field2 []*RepeatedScalar       `protobuf:"bytes,2,rep,name=Field2,proto3" json:"Field2,omitempty"`
	Field3 []*RepeatedScalarPacked `protobuf:"bytes,3,rep,name=Field3,proto3" json:"Field3,omitempty"`
}

func (m *RepeatedExternalStruct) Reset()      { *m = RepeatedExternalStruct{} }
func (*RepeatedExternalStruct) ProtoMessage() {}
func (*RepeatedExternalStruct) Descriptor() ([]byte, []int) {
	return fileDescriptor_32a357b2839a6c60, []int{4}
}
func (m *RepeatedExternalStruct) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RepeatedExternalStruct.Unmarshal(m, b)
}
func (m *RepeatedExternalStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RepeatedExternalStruct.Marshal(b, m, deterministic)
}
func (m *RepeatedExternalStruct) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepeatedExternalStruct.Merge(m, src)
}
func (m *RepeatedExternalStruct) XXX_Size() int {
	return xxx_messageInfo_RepeatedExternalStruct.Size(m)
}
func (m *RepeatedExternalStruct) XXX_DiscardUnknown() {
	xxx_messageInfo_RepeatedExternalStruct.DiscardUnknown(m)
}

var xxx_messageInfo_RepeatedExternalStruct proto.InternalMessageInfo

type NonNullableExternalStruct struct {
	Field1 BasicScalar          `protobuf:"bytes,1,opt,name=Field1,proto3" json:"Field1"`
	Field2 RepeatedScalar       `protobuf:"bytes,2,opt,name=Field2,proto3" json:"Field2"`
	Field3 RepeatedScalarPacked `protobuf:"bytes,3,opt,name=Field3,proto3" json:"Field3"`
}

func (m *NonNullableExternalStruct) Reset()      { *m = NonNullableExternalStruct{} }
func (*NonNullableExternalStruct) ProtoMessage() {}
func (*NonNullableExternalStruct) Descriptor() ([]byte, []int) {
	return fileDescriptor_32a357b2839a6c60, []int{5}
}
func (m *NonNullableExternalStruct) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NonNullableExternalStruct.Unmarshal(m, b)
}
func (m *NonNullableExternalStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NonNullableExternalStruct.Marshal(b, m, deterministic)
}
func (m *NonNullableExternalStruct) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NonNullableExternalStruct.Merge(m, src)
}
func (m *NonNullableExternalStruct) XXX_Size() int {
	return xxx_messageInfo_NonNullableExternalStruct.Size(m)
}
func (m *NonNullableExternalStruct) XXX_DiscardUnknown() {
	xxx_messageInfo_NonNullableExternalStruct.DiscardUnknown(m)
}

var xxx_messageInfo_NonNullableExternalStruct proto.InternalMessageInfo

type RepeatedNonNullableExternalStruct struct {
	Field1 []BasicScalar          `protobuf:"bytes,1,rep,name=Field1,proto3" json:"Field1"`
	Field2 []RepeatedScalar       `protobuf:"bytes,2,rep,name=Field2,proto3" json:"Field2"`
	Field3 []RepeatedScalarPacked `protobuf:"bytes,3,rep,name=Field3,proto3" json:"Field3"`
}

func (m *RepeatedNonNullableExternalStruct) Reset()      { *m = RepeatedNonNullableExternalStruct{} }
func (*RepeatedNonNullableExternalStruct) ProtoMessage() {}
func (*RepeatedNonNullableExternalStruct) Descriptor() ([]byte, []int) {
	return fileDescriptor_32a357b2839a6c60, []int{6}
}
func (m *RepeatedNonNullableExternalStruct) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RepeatedNonNullableExternalStruct.Unmarshal(m, b)
}
func (m *RepeatedNonNullableExternalStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RepeatedNonNullableExternalStruct.Marshal(b, m, deterministic)
}
func (m *RepeatedNonNullableExternalStruct) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepeatedNonNullableExternalStruct.Merge(m, src)
}
func (m *RepeatedNonNullableExternalStruct) XXX_Size() int {
	return xxx_messageInfo_RepeatedNonNullableExternalStruct.Size(m)
}
func (m *RepeatedNonNullableExternalStruct) XXX_DiscardUnknown() {
	xxx_messageInfo_RepeatedNonNullableExternalStruct.DiscardUnknown(m)
}

var xxx_messageInfo_RepeatedNonNullableExternalStruct proto.InternalMessageInfo

type MapStruct struct {
	NullableMap    map[string]*BasicScalar `protobuf:"bytes,1,rep,name=nullable_map,json=nullableMap,proto3" json:"nullable_map,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NonnullableMap map[string]BasicScalar  `protobuf:"bytes,2,rep,name=nonnullable_map,json=nonnullableMap,proto3" json:"nonnullable_map" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *MapStruct) Reset()      { *m = MapStruct{} }
func (*MapStruct) ProtoMessage() {}
func (*MapStruct) Descriptor() ([]byte, []int) {
	return fileDescriptor_32a357b2839a6c60, []int{7}
}
func (m *MapStruct) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MapStruct.Unmarshal(m, b)
}
func (m *MapStruct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MapStruct.Marshal(b, m, deterministic)
}
func (m *MapStruct) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MapStruct.Merge(m, src)
}
func (m *MapStruct) XXX_Size() int {
	return xxx_messageInfo_MapStruct.Size(m)
}
func (m *MapStruct) XXX_DiscardUnknown() {
	xxx_messageInfo_MapStruct.DiscardUnknown(m)
}

var xxx_messageInfo_MapStruct proto.InternalMessageInfo

type OneOf struct {
	// Types that are valid to be assigned to Fields:
	//	*OneOf_Field1
	//	*OneOf_Field2
	//	*OneOf_Field3
	//	*OneOf_Field4
	//	*OneOf_Field5
	//	*OneOf_Field6
	//	*OneOf_Field7
	//	*OneOf_Field8
	//	*OneOf_Field9
	Fields isOneOf_Fields `protobuf_oneof:"fields"`
	// Types that are valid to be assigned to FieldsTwo:
	//	*OneOf_Field10
	//	*OneOf_Field11
	FieldsTwo isOneOf_FieldsTwo `protobuf_oneof:"fieldsTwo"`
}

func (m *OneOf) Reset()      { *m = OneOf{} }
func (*OneOf) ProtoMessage() {}
func (*OneOf) Descriptor() ([]byte, []int) {
	return fileDescriptor_32a357b2839a6c60, []int{8}
}
func (m *OneOf) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OneOf.Unmarshal(m, b)
}
func (m *OneOf) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OneOf.Marshal(b, m, deterministic)
}
func (m *OneOf) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OneOf.Merge(m, src)
}
func (m *OneOf) XXX_Size() int {
	return xxx_messageInfo_OneOf.Size(m)
}
func (m *OneOf) XXX_DiscardUnknown() {
	xxx_messageInfo_OneOf.DiscardUnknown(m)
}

var xxx_messageInfo_OneOf proto.InternalMessageInfo

type isOneOf_Fields interface {
	isOneOf_Fields()
	Equal(interface{}) bool
}
type isOneOf_FieldsTwo interface {
	isOneOf_FieldsTwo()
	Equal(interface{}) bool
}

type OneOf_Field1 struct {
	Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,proto3,oneof"`
}
type OneOf_Field2 struct {
	Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,proto3,oneof"`
}
type OneOf_Field3 struct {
	Field3 int32 `protobuf:"varint,3,opt,name=Field3,proto3,oneof"`
}
type OneOf_Field4 struct {
	Field4 int64 `protobuf:"varint,4,opt,name=Field4,proto3,oneof"`
}
type OneOf_Field5 struct {
	Field5 uint32 `protobuf:"varint,5,opt,name=Field5,proto3,oneof"`
}
type OneOf_Field6 struct {
	Field6 string `protobuf:"bytes,6,opt,name=Field6,proto3,oneof"`
}
type OneOf_Field7 struct {
	Field7 []byte `protobuf:"bytes,7,opt,name=Field7,proto3,oneof"`
}
type OneOf_Field8 struct {
	Field8 *MapStruct `protobuf:"bytes,8,opt,name=Field8,proto3,oneof"`
}
type OneOf_Field9 struct {
	Field9 *RepeatedNonNullableExternalStruct `protobuf:"bytes,9,opt,name=Field9,proto3,oneof"`
}
type OneOf_Field10 struct {
	Field10 *NonNullableExternalStruct `protobuf:"bytes,10,opt,name=Field10,proto3,oneof"`
}
type OneOf_Field11 struct {
	Field11 *RepeatedExternalStruct `protobuf:"bytes,11,opt,name=Field11,proto3,oneof"`
}

func (*OneOf_Field1) isOneOf_Fields()     {}
func (*OneOf_Field2) isOneOf_Fields()     {}
func (*OneOf_Field3) isOneOf_Fields()     {}
func (*OneOf_Field4) isOneOf_Fields()     {}
func (*OneOf_Field5) isOneOf_Fields()     {}
func (*OneOf_Field6) isOneOf_Fields()     {}
func (*OneOf_Field7) isOneOf_Fields()     {}
func (*OneOf_Field8) isOneOf_Fields()     {}
func (*OneOf_Field9) isOneOf_Fields()     {}
func (*OneOf_Field10) isOneOf_FieldsTwo() {}
func (*OneOf_Field11) isOneOf_FieldsTwo() {}

func (m *OneOf) GetFields() isOneOf_Fields {
	if m != nil {
		return m.Fields
	}
	return nil
}
func (m *OneOf) GetFieldsTwo() isOneOf_FieldsTwo {
	if m != nil {
		return m.FieldsTwo
	}
	return nil
}

func (m *OneOf) GetField1() float64 {
	if x, ok := m.GetFields().(*OneOf_Field1); ok {
		return x.Field1
	}
	return 0
}

func (m *OneOf) GetField2() float32 {
	if x, ok := m.GetFields().(*OneOf_Field2); ok {
		return x.Field2
	}
	return 0
}

func (m *OneOf) GetField3() int32 {
	if x, ok := m.GetFields().(*OneOf_Field3); ok {
		return x.Field3
	}
	return 0
}

func (m *OneOf) GetField4() int64 {
	if x, ok := m.GetFields().(*OneOf_Field4); ok {
		return x.Field4
	}
	return 0
}

func (m *OneOf) GetField5() uint32 {
	if x, ok := m.GetFields().(*OneOf_Field5); ok {
		return x.Field5
	}
	return 0
}

func (m *OneOf) GetField6() string {
	if x, ok := m.GetFields().(*OneOf_Field6); ok {
		return x.Field6
	}
	return ""
}

func (m *OneOf) GetField7() []byte {
	if x, ok := m.GetFields().(*OneOf_Field7); ok {
		return x.Field7
	}
	return nil
}

func (m *OneOf) GetField8() *MapStruct {
	if x, ok := m.GetFields().(*OneOf_Field8); ok {
		return x.Field8
	}
	return nil
}

func (m *OneOf) GetField9() *RepeatedNonNullableExternalStruct {
	if x, ok := m.GetFields().(*OneOf_Field9); ok {
		return x.Field9
	}
	return nil
}

func (m *OneOf) GetField10() *NonNullableExternalStruct {
	if x, ok := m.GetFieldsTwo().(*OneOf_Field10); ok {
		return x.Field10
	}
	return nil
}

func (m *OneOf) GetField11() *RepeatedExternalStruct {
	if x, ok := m.GetFieldsTwo().(*OneOf_Field11); ok {
		return x.Field11
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*OneOf) 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 _OneOf_OneofMarshaler, _OneOf_OneofUnmarshaler, _OneOf_OneofSizer, []interface{}{
		(*OneOf_Field1)(nil),
		(*OneOf_Field2)(nil),
		(*OneOf_Field3)(nil),
		(*OneOf_Field4)(nil),
		(*OneOf_Field5)(nil),
		(*OneOf_Field6)(nil),
		(*OneOf_Field7)(nil),
		(*OneOf_Field8)(nil),
		(*OneOf_Field9)(nil),
		(*OneOf_Field10)(nil),
		(*OneOf_Field11)(nil),
	}
}

func _OneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*OneOf)
	// fields
	switch x := m.Fields.(type) {
	case *OneOf_Field1:
		_ = b.EncodeVarint(1<<3 | proto.WireFixed64)
		_ = b.EncodeFixed64(math.Float64bits(x.Field1))
	case *OneOf_Field2:
		_ = b.EncodeVarint(2<<3 | proto.WireFixed32)
		_ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2)))
	case *OneOf_Field3:
		_ = b.EncodeVarint(3<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.Field3))
	case *OneOf_Field4:
		_ = b.EncodeVarint(4<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.Field4))
	case *OneOf_Field5:
		_ = b.EncodeVarint(5<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.Field5))
	case *OneOf_Field6:
		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
		_ = b.EncodeStringBytes(x.Field6)
	case *OneOf_Field7:
		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
		_ = b.EncodeRawBytes(x.Field7)
	case *OneOf_Field8:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Field8); err != nil {
			return err
		}
	case *OneOf_Field9:
		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Field9); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("OneOf.Fields has unexpected type %T", x)
	}
	// fieldsTwo
	switch x := m.FieldsTwo.(type) {
	case *OneOf_Field10:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Field10); err != nil {
			return err
		}
	case *OneOf_Field11:
		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Field11); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("OneOf.FieldsTwo has unexpected type %T", x)
	}
	return nil
}

func _OneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*OneOf)
	switch tag {
	case 1: // fields.Field1
		if wire != proto.WireFixed64 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed64()
		m.Fields = &OneOf_Field1{math.Float64frombits(x)}
		return true, err
	case 2: // fields.Field2
		if wire != proto.WireFixed32 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed32()
		m.Fields = &OneOf_Field2{math.Float32frombits(uint32(x))}
		return true, err
	case 3: // fields.Field3
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Fields = &OneOf_Field3{int32(x)}
		return true, err
	case 4: // fields.Field4
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Fields = &OneOf_Field4{int64(x)}
		return true, err
	case 5: // fields.Field5
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Fields = &OneOf_Field5{uint32(x)}
		return true, err
	case 6: // fields.Field6
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Fields = &OneOf_Field6{x}
		return true, err
	case 7: // fields.Field7
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.Fields = &OneOf_Field7{x}
		return true, err
	case 8: // fields.Field8
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MapStruct)
		err := b.DecodeMessage(msg)
		m.Fields = &OneOf_Field8{msg}
		return true, err
	case 9: // fields.Field9
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RepeatedNonNullableExternalStruct)
		err := b.DecodeMessage(msg)
		m.Fields = &OneOf_Field9{msg}
		return true, err
	case 10: // fieldsTwo.Field10
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NonNullableExternalStruct)
		err := b.DecodeMessage(msg)
		m.FieldsTwo = &OneOf_Field10{msg}
		return true, err
	case 11: // fieldsTwo.Field11
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RepeatedExternalStruct)
		err := b.DecodeMessage(msg)
		m.FieldsTwo = &OneOf_Field11{msg}
		return true, err
	default:
		return false, nil
	}
}

func _OneOf_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*OneOf)
	// fields
	switch x := m.Fields.(type) {
	case *OneOf_Field1:
		n += 1 // tag and wire
		n += 8
	case *OneOf_Field2:
		n += 1 // tag and wire
		n += 4
	case *OneOf_Field3:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Field3))
	case *OneOf_Field4:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Field4))
	case *OneOf_Field5:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Field5))
	case *OneOf_Field6:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Field6)))
		n += len(x.Field6)
	case *OneOf_Field7:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Field7)))
		n += len(x.Field7)
	case *OneOf_Field8:
		s := proto.Size(x.Field8)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneOf_Field9:
		s := proto.Size(x.Field9)
		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))
	}
	// fieldsTwo
	switch x := m.FieldsTwo.(type) {
	case *OneOf_Field10:
		s := proto.Size(x.Field10)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneOf_Field11:
		s := proto.Size(x.Field11)
		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((*BasicScalar)(nil), "test.BasicScalar")
	proto.RegisterType((*RepeatedScalar)(nil), "test.RepeatedScalar")
	proto.RegisterType((*RepeatedScalarPacked)(nil), "test.RepeatedScalarPacked")
	proto.RegisterType((*ExternalStruct)(nil), "test.ExternalStruct")
	proto.RegisterType((*RepeatedExternalStruct)(nil), "test.RepeatedExternalStruct")
	proto.RegisterType((*NonNullableExternalStruct)(nil), "test.NonNullableExternalStruct")
	proto.RegisterType((*RepeatedNonNullableExternalStruct)(nil), "test.RepeatedNonNullableExternalStruct")
	proto.RegisterType((*MapStruct)(nil), "test.MapStruct")
	proto.RegisterMapType((map[string]BasicScalar)(nil), "test.MapStruct.NonnullableMapEntry")
	proto.RegisterMapType((map[string]*BasicScalar)(nil), "test.MapStruct.NullableMapEntry")
	proto.RegisterType((*OneOf)(nil), "test.OneOf")
}

func init() {
	proto.RegisterFile("github.com/docker/swarmkit/protobuf/plugin/deepcopy/test/deepcopy.proto", fileDescriptor_32a357b2839a6c60)
}

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

func (m *BasicScalar) Copy() *BasicScalar {
	if m == nil {
		return nil
	}
	o := &BasicScalar{}
	o.CopyFrom(m)
	return o
}

func (m *BasicScalar) CopyFrom(src interface{}) {

	o := src.(*BasicScalar)
	*m = *o
	if o.Field15 != nil {
		m.Field15 = make([]byte, len(o.Field15))
		copy(m.Field15, o.Field15)
	}
}

func (m *RepeatedScalar) Copy() *RepeatedScalar {
	if m == nil {
		return nil
	}
	o := &RepeatedScalar{}
	o.CopyFrom(m)
	return o
}

func (m *RepeatedScalar) CopyFrom(src interface{}) {

	o := src.(*RepeatedScalar)
	*m = *o
	if o.Field1 != nil {
		m.Field1 = make([]float64, len(o.Field1))
		copy(m.Field1, o.Field1)
	}

	if o.Field2 != nil {
		m.Field2 = make([]float32, len(o.Field2))
		copy(m.Field2, o.Field2)
	}

	if o.Field3 != nil {
		m.Field3 = make([]int32, len(o.Field3))
		copy(m.Field3, o.Field3)
	}

	if o.Field4 != nil {
		m.Field4 = make([]int64, len(o.Field4))
		copy(m.Field4, o.Field4)
	}

	if o.Field5 != nil {
		m.Field5 = make([]uint32, len(o.Field5))
		copy(m.Field5, o.Field5)
	}

	if o.Field6 != nil {
		m.Field6 = make([]uint64, len(o.Field6))
		copy(m.Field6, o.Field6)
	}

	if o.Field7 != nil {
		m.Field7 = make([]int32, len(o.Field7))
		copy(m.Field7, o.Field7)
	}

	if o.Field8 != nil {
		m.Field8 = make([]int64, len(o.Field8))
		copy(m.Field8, o.Field8)
	}

	if o.Field9 != nil {
		m.Field9 = make([]uint32, len(o.Field9))
		copy(m.Field9, o.Field9)
	}

	if o.Field10 != nil {
		m.Field10 = make([]int32, len(o.Field10))
		copy(m.Field10, o.Field10)
	}

	if o.Field11 != nil {
		m.Field11 = make([]uint64, len(o.Field11))
		copy(m.Field11, o.Field11)
	}

	if o.Field12 != nil {
		m.Field12 = make([]int64, len(o.Field12))
		copy(m.Field12, o.Field12)
	}

	if o.Field13 != nil {
		m.Field13 = make([]bool, len(o.Field13))
		copy(m.Field13, o.Field13)
	}

	if o.Field14 != nil {
		m.Field14 = make([]string, len(o.Field14))
		copy(m.Field14, o.Field14)
	}

	if o.Field15 != nil {
		m.Field15 = make([][]byte, len(o.Field15))
		for i := range m.Field15 {
			if o.Field15[i] != nil {
				m.Field15[i] = make([]byte, len(o.Field15[i]))
				copy(m.Field15[i], o.Field15[i])
			}
		}
	}

}

func (m *RepeatedScalarPacked) Copy() *RepeatedScalarPacked {
	if m == nil {
		return nil
	}
	o := &RepeatedScalarPacked{}
	o.CopyFrom(m)
	return o
}

func (m *RepeatedScalarPacked) CopyFrom(src interface{}) {

	o := src.(*RepeatedScalarPacked)
	*m = *o
	if o.Field1 != nil {
		m.Field1 = make([]float64, len(o.Field1))
		copy(m.Field1, o.Field1)
	}

	if o.Field2 != nil {
		m.Field2 = make([]float32, len(o.Field2))
		copy(m.Field2, o.Field2)
	}

	if o.Field3 != nil {
		m.Field3 = make([]int32, len(o.Field3))
		copy(m.Field3, o.Field3)
	}

	if o.Field4 != nil {
		m.Field4 = make([]int64, len(o.Field4))
		copy(m.Field4, o.Field4)
	}

	if o.Field5 != nil {
		m.Field5 = make([]uint32, len(o.Field5))
		copy(m.Field5, o.Field5)
	}

	if o.Field6 != nil {
		m.Field6 = make([]uint64, len(o.Field6))
		copy(m.Field6, o.Field6)
	}

	if o.Field7 != nil {
		m.Field7 = make([]int32, len(o.Field7))
		copy(m.Field7, o.Field7)
	}

	if o.Field8 != nil {
		m.Field8 = make([]int64, len(o.Field8))
		copy(m.Field8, o.Field8)
	}

	if o.Field9 != nil {
		m.Field9 = make([]uint32, len(o.Field9))
		copy(m.Field9, o.Field9)
	}

	if o.Field10 != nil {
		m.Field10 = make([]int32, len(o.Field10))
		copy(m.Field10, o.Field10)
	}

	if o.Field11 != nil {
		m.Field11 = make([]uint64, len(o.Field11))
		copy(m.Field11, o.Field11)
	}

	if o.Field12 != nil {
		m.Field12 = make([]int64, len(o.Field12))
		copy(m.Field12, o.Field12)
	}

	if o.Field13 != nil {
		m.Field13 = make([]bool, len(o.Field13))
		copy(m.Field13, o.Field13)
	}

}

func (m *ExternalStruct) Copy() *ExternalStruct {
	if m == nil {
		return nil
	}
	o := &ExternalStruct{}
	o.CopyFrom(m)
	return o
}

func (m *ExternalStruct) CopyFrom(src interface{}) {

	o := src.(*ExternalStruct)
	*m = *o
	if o.Field1 != nil {
		m.Field1 = &BasicScalar{}
		github_com_docker_swarmkit_api_deepcopy.Copy(m.Field1, o.Field1)
	}
	if o.Field2 != nil {
		m.Field2 = &RepeatedScalar{}
		github_com_docker_swarmkit_api_deepcopy.Copy(m.Field2, o.Field2)
	}
	if o.Field3 != nil {
		m.Field3 = &RepeatedScalarPacked{}
		github_com_docker_swarmkit_api_deepcopy.Copy(m.Field3, o.Field3)
	}
}

func (m *RepeatedExternalStruct) Copy() *RepeatedExternalStruct {
	if m == nil {
		return nil
	}
	o := &RepeatedExternalStruct{}
	o.CopyFrom(m)
	return o
}

func (m *RepeatedExternalStruct) CopyFrom(src interface{}) {

	o := src.(*RepeatedExternalStruct)
	*m = *o
	if o.Field1 != nil {
		m.Field1 = make([]*BasicScalar, len(o.Field1))
		for i := range m.Field1 {
			m.Field1[i] = &BasicScalar{}
			github_com_docker_swarmkit_api_deepcopy.Copy(m.Field1[i], o.Field1[i])
		}
	}

	if o.Field2 != nil {
		m.Field2 = make([]*RepeatedScalar, len(o.Field2))
		for i := range m.Field2 {
			m.Field2[i] = &RepeatedScalar{}
			github_com_docker_swarmkit_api_deepcopy.Copy(m.Field2[i], o.Field2[i])
		}
	}

	if o.Field3 != nil {
		m.Field3 = make([]*RepeatedScalarPacked, len(o.Field3))
		for i := range m.Field3 {
			m.Field3[i] = &RepeatedScalarPacked{}
			github_com_docker_swarmkit_api_deepcopy.Copy(m.Field3[i], o.Field3[i])
		}
	}

}

func (m *NonNullableExternalStruct) Copy() *NonNullableExternalStruct {
	if m == nil {
		return nil
	}
	o := &NonNullableExternalStruct{}
	o.CopyFrom(m)
	return o
}

func (m *NonNullableExternalStruct) CopyFrom(src interface{}) {

	o := src.(*NonNullableExternalStruct)
	*m = *o
	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Field1, &o.Field1)
	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Field2, &o.Field2)
	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Field3, &o.Field3)
}

func (m *RepeatedNonNullableExternalStruct) Copy() *RepeatedNonNullableExternalStruct {
	if m == nil {
		return nil
	}
	o := &RepeatedNonNullableExternalStruct{}
	o.CopyFrom(m)
	return o
}

func (m *RepeatedNonNullableExternalStruct) CopyFrom(src interface{}) {

	o := src.(*RepeatedNonNullableExternalStruct)
	*m = *o
	if o.Field1 != nil {
		m.Field1 = make([]BasicScalar, len(o.Field1))
		for i := range m.Field1 {
			github_com_docker_swarmkit_api_deepcopy.Copy(&m.Field1[i], &o.Field1[i])
		}
	}

	if o.Field2 != nil {
		m.Field2 = make([]RepeatedScalar, len(o.Field2))
		for i := range m.Field2 {
			github_com_docker_swarmkit_api_deepcopy.Copy(&m.Field2[i], &o.Field2[i])
		}
	}

	if o.Field3 != nil {
		m.Field3 = make([]RepeatedScalarPacked, len(o.Field3))
		for i := range m.Field3 {
			github_com_docker_swarmkit_api_deepcopy.Copy(&m.Field3[i], &o.Field3[i])
		}
	}

}

func (m *MapStruct) Copy() *MapStruct {
	if m == nil {
		return nil
	}
	o := &MapStruct{}
	o.CopyFrom(m)
	return o
}

func (m *MapStruct) CopyFrom(src interface{}) {

	o := src.(*MapStruct)
	*m = *o
	if o.NullableMap != nil {
		m.NullableMap = make(map[string]*BasicScalar, len(o.NullableMap))
		for k, v := range o.NullableMap {
			m.NullableMap[k] = &BasicScalar{}
			github_com_docker_swarmkit_api_deepcopy.Copy(m.NullableMap[k], v)
		}
	}

	if o.NonnullableMap != nil {
		m.NonnullableMap = make(map[string]BasicScalar, len(o.NonnullableMap))
		for k, v := range o.NonnullableMap {
			n := BasicScalar{}
			github_com_docker_swarmkit_api_deepcopy.Copy(&n, &v)
			m.NonnullableMap[k] = n
		}
	}

}

func (m *OneOf) Copy() *OneOf {
	if m == nil {
		return nil
	}
	o := &OneOf{}
	o.CopyFrom(m)
	return o
}

func (m *OneOf) CopyFrom(src interface{}) {

	o := src.(*OneOf)
	*m = *o
	if o.Fields != nil {
		switch o.Fields.(type) {
		case *OneOf_Field1:
			v := OneOf_Field1{
				Field1: o.GetField1(),
			}
			m.Fields = &v
		case *OneOf_Field2:
			v := OneOf_Field2{
				Field2: o.GetField2(),
			}
			m.Fields = &v
		case *OneOf_Field3:
			v := OneOf_Field3{
				Field3: o.GetField3(),
			}
			m.Fields = &v
		case *OneOf_Field4:
			v := OneOf_Field4{
				Field4: o.GetField4(),
			}
			m.Fields = &v
		case *OneOf_Field5:
			v := OneOf_Field5{
				Field5: o.GetField5(),
			}
			m.Fields = &v
		case *OneOf_Field6:
			v := OneOf_Field6{
				Field6: o.GetField6(),
			}
			m.Fields = &v
		case *OneOf_Field7:
			v := OneOf_Field7{
				Field7: make([]byte, len(o.GetField7())),
			}
			if o.GetField7() != nil {
				v.Field7 = make([]byte, len(o.GetField7()))
				copy(v.Field7, o.GetField7())
			}
			m.Fields = &v
		case *OneOf_Field8:
			v := OneOf_Field8{
				Field8: &MapStruct{},
			}
			github_com_docker_swarmkit_api_deepcopy.Copy(v.Field8, o.GetField8())
			m.Fields = &v
		case *OneOf_Field9:
			v := OneOf_Field9{
				Field9: &RepeatedNonNullableExternalStruct{},
			}
			github_com_docker_swarmkit_api_deepcopy.Copy(v.Field9, o.GetField9())
			m.Fields = &v
		}
	}

	if o.FieldsTwo != nil {
		switch o.FieldsTwo.(type) {
		case *OneOf_Field10:
			v := OneOf_Field10{
				Field10: &NonNullableExternalStruct{},
			}
			github_com_docker_swarmkit_api_deepcopy.Copy(v.Field10, o.GetField10())
			m.FieldsTwo = &v
		case *OneOf_Field11:
			v := OneOf_Field11{
				Field11: &RepeatedExternalStruct{},
			}
			github_com_docker_swarmkit_api_deepcopy.Copy(v.Field11, o.GetField11())
			m.FieldsTwo = &v
		}
	}

}

func (this *BasicScalar) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BasicScalar)
	if !ok {
		that2, ok := that.(BasicScalar)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Field1 != that1.Field1 {
		return false
	}
	if this.Field2 != that1.Field2 {
		return false
	}
	if this.Field3 != that1.Field3 {
		return false
	}
	if this.Field4 != that1.Field4 {
		return false
	}
	if this.Field5 != that1.Field5 {
		return false
	}
	if this.Field6 != that1.Field6 {
		return false
	}
	if this.Field7 != that1.Field7 {
		return false
	}
	if this.Field8 != that1.Field8 {
		return false
	}
	if this.Field9 != that1.Field9 {
		return false
	}
	if this.Field10 != that1.Field10 {
		return false
	}
	if this.Field11 != that1.Field11 {
		return false
	}
	if this.Field12 != that1.Field12 {
		return false
	}
	if this.Field13 != that1.Field13 {
		return false
	}
	if this.Field14 != that1.Field14 {
		return false
	}
	if !bytes.Equal(this.Field15, that1.Field15) {
		return false
	}
	return true
}
func (this *RepeatedScalar) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RepeatedScalar)
	if !ok {
		that2, ok := that.(RepeatedScalar)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Field1) != len(that1.Field1) {
		return false
	}
	for i := range this.Field1 {
		if this.Field1[i] != that1.Field1[i] {
			return false
		}
	}
	if len(this.Field2) != len(that1.Field2) {
		return false
	}
	for i := range this.Field2 {
		if this.Field2[i] != that1.Field2[i] {
			return false
		}
	}
	if len(this.Field3) != len(that1.Field3) {
		return false
	}
	for i := range this.Field3 {
		if this.Field3[i] != that1.Field3[i] {
			return false
		}
	}
	if len(this.Field4) != len(that1.Field4) {
		return false
	}
	for i := range this.Field4 {
		if this.Field4[i] != that1.Field4[i] {
			return false
		}
	}
	if len(this.Field5) != len(that1.Field5) {
		return false
	}
	for i := range this.Field5 {
		if this.Field5[i] != that1.Field5[i] {
			return false
		}
	}
	if len(this.Field6) != len(that1.Field6) {
		return false
	}
	for i := range this.Field6 {
		if this.Field6[i] != that1.Field6[i] {
			return false
		}
	}
	if len(this.Field7) != len(that1.Field7) {
		return false
	}
	for i := range this.Field7 {
		if this.Field7[i] != that1.Field7[i] {
			return false
		}
	}
	if len(this.Field8) != len(that1.Field8) {
		return false
	}
	for i := range this.Field8 {
		if this.Field8[i] != that1.Field8[i] {
			return false
		}
	}
	if len(this.Field9) != len(that1.Field9) {
		return false
	}
	for i := range this.Field9 {
		if this.Field9[i] != that1.Field9[i] {
			return false
		}
	}
	if len(this.Field10) != len(that1.Field10) {
		return false
	}
	for i := range this.Field10 {
		if this.Field10[i] != that1.Field10[i] {
			return false
		}
	}
	if len(this.Field11) != len(that1.Field11) {
		return false
	}
	for i := range this.Field11 {
		if this.Field11[i] != that1.Field11[i] {
			return false
		}
	}
	if len(this.Field12) != len(that1.Field12) {
		return false
	}
	for i := range this.Field12 {
		if this.Field12[i] != that1.Field12[i] {
			return false
		}
	}
	if len(this.Field13) != len(that1.Field13) {
		return false
	}
	for i := range this.Field13 {
		if this.Field13[i] != that1.Field13[i] {
			return false
		}
	}
	if len(this.Field14) != len(that1.Field14) {
		return false
	}
	for i := range this.Field14 {
		if this.Field14[i] != that1.Field14[i] {
			return false
		}
	}
	if len(this.Field15) != len(that1.Field15) {
		return false
	}
	for i := range this.Field15 {
		if !bytes.Equal(this.Field15[i], that1.Field15[i]) {
			return false
		}
	}
	return true
}
func (this *RepeatedScalarPacked) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RepeatedScalarPacked)
	if !ok {
		that2, ok := that.(RepeatedScalarPacked)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Field1) != len(that1.Field1) {
		return false
	}
	for i := range this.Field1 {
		if this.Field1[i] != that1.Field1[i] {
			return false
		}
	}
	if len(this.Field2) != len(that1.Field2) {
		return false
	}
	for i := range this.Field2 {
		if this.Field2[i] != that1.Field2[i] {
			return false
		}
	}
	if len(this.Field3) != len(that1.Field3) {
		return false
	}
	for i := range this.Field3 {
		if this.Field3[i] != that1.Field3[i] {
			return false
		}
	}
	if len(this.Field4) != len(that1.Field4) {
		return false
	}
	for i := range this.Field4 {
		if this.Field4[i] != that1.Field4[i] {
			return false
		}
	}
	if len(this.Field5) != len(that1.Field5) {
		return false
	}
	for i := range this.Field5 {
		if this.Field5[i] != that1.Field5[i] {
			return false
		}
	}
	if len(this.Field6) != len(that1.Field6) {
		return false
	}
	for i := range this.Field6 {
		if this.Field6[i] != that1.Field6[i] {
			return false
		}
	}
	if len(this.Field7) != len(that1.Field7) {
		return false
	}
	for i := range this.Field7 {
		if this.Field7[i] != that1.Field7[i] {
			return false
		}
	}
	if len(this.Field8) != len(that1.Field8) {
		return false
	}
	for i := range this.Field8 {
		if this.Field8[i] != that1.Field8[i] {
			return false
		}
	}
	if len(this.Field9) != len(that1.Field9) {
		return false
	}
	for i := range this.Field9 {
		if this.Field9[i] != that1.Field9[i] {
			return false
		}
	}
	if len(this.Field10) != len(that1.Field10) {
		return false
	}
	for i := range this.Field10 {
		if this.Field10[i] != that1.Field10[i] {
			return false
		}
	}
	if len(this.Field11) != len(that1.Field11) {
		return false
	}
	for i := range this.Field11 {
		if this.Field11[i] != that1.Field11[i] {
			return false
		}
	}
	if len(this.Field12) != len(that1.Field12) {
		return false
	}
	for i := range this.Field12 {
		if this.Field12[i] != that1.Field12[i] {
			return false
		}
	}
	if len(this.Field13) != len(that1.Field13) {
		return false
	}
	for i := range this.Field13 {
		if this.Field13[i] != that1.Field13[i] {
			return false
		}
	}
	return true
}
func (this *ExternalStruct) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExternalStruct)
	if !ok {
		that2, ok := that.(ExternalStruct)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Field1.Equal(that1.Field1) {
		return false
	}
	if !this.Field2.Equal(that1.Field2) {
		return false
	}
	if !this.Field3.Equal(that1.Field3) {
		return false
	}
	return true
}
func (this *RepeatedExternalStruct) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RepeatedExternalStruct)
	if !ok {
		that2, ok := that.(RepeatedExternalStruct)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Field1) != len(that1.Field1) {
		return false
	}
	for i := range this.Field1 {
		if !this.Field1[i].Equal(that1.Field1[i]) {
			return false
		}
	}
	if len(this.Field2) != len(that1.Field2) {
		return false
	}
	for i := range this.Field2 {
		if !this.Field2[i].Equal(that1.Field2[i]) {
			return false
		}
	}
	if len(this.Field3) != len(that1.Field3) {
		return false
	}
	for i := range this.Field3 {
		if !this.Field3[i].Equal(that1.Field3[i]) {
			return false
		}
	}
	return true
}
func (this *NonNullableExternalStruct) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NonNullableExternalStruct)
	if !ok {
		that2, ok := that.(NonNullableExternalStruct)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Field1.Equal(&that1.Field1) {
		return false
	}
	if !this.Field2.Equal(&that1.Field2) {
		return false
	}
	if !this.Field3.Equal(&that1.Field3) {
		return false
	}
	return true
}
func (this *RepeatedNonNullableExternalStruct) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RepeatedNonNullableExternalStruct)
	if !ok {
		that2, ok := that.(RepeatedNonNullableExternalStruct)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Field1) != len(that1.Field1) {
		return false
	}
	for i := range this.Field1 {
		if !this.Field1[i].Equal(&that1.Field1[i]) {
			return false
		}
	}
	if len(this.Field2) != len(that1.Field2) {
		return false
	}
	for i := range this.Field2 {
		if !this.Field2[i].Equal(&that1.Field2[i]) {
			return false
		}
	}
	if len(this.Field3) != len(that1.Field3) {
		return false
	}
	for i := range this.Field3 {
		if !this.Field3[i].Equal(&that1.Field3[i]) {
			return false
		}
	}
	return true
}
func (this *MapStruct) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MapStruct)
	if !ok {
		that2, ok := that.(MapStruct)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NullableMap) != len(that1.NullableMap) {
		return false
	}
	for i := range this.NullableMap {
		if !this.NullableMap[i].Equal(that1.NullableMap[i]) {
			return false
		}
	}
	if len(this.NonnullableMap) != len(that1.NonnullableMap) {
		return false
	}
	for i := range this.NonnullableMap {
		a := this.NonnullableMap[i]
		b := that1.NonnullableMap[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	return true
}
func (this *OneOf) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

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

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

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

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

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

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

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

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

	that1, ok := that.(*OneOf_Field11)
	if !ok {
		that2, ok := that.(OneOf_Field11)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Field11.Equal(that1.Field11) {
		return false
	}
	return true
}
func NewPopulatedBasicScalar(r randyDeepcopy, easy bool) *BasicScalar {
	this := &BasicScalar{}
	this.Field1 = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.Field1 *= -1
	}
	this.Field2 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Field2 *= -1
	}
	this.Field3 = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Field3 *= -1
	}
	this.Field4 = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Field4 *= -1
	}
	this.Field5 = uint32(r.Uint32())
	this.Field6 = uint64(uint64(r.Uint32()))
	this.Field7 = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Field7 *= -1
	}
	this.Field8 = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Field8 *= -1
	}
	this.Field9 = uint32(r.Uint32())
	this.Field10 = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Field10 *= -1
	}
	this.Field11 = uint64(uint64(r.Uint32()))
	this.Field12 = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Field12 *= -1
	}
	this.Field13 = bool(bool(r.Intn(2) == 0))
	this.Field14 = string(randStringDeepcopy(r))
	v1 := r.Intn(100)
	this.Field15 = make([]byte, v1)
	for i := 0; i < v1; i++ {
		this.Field15[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRepeatedScalar(r randyDeepcopy, easy bool) *RepeatedScalar {
	this := &RepeatedScalar{}
	v2 := r.Intn(10)
	this.Field1 = make([]float64, v2)
	for i := 0; i < v2; i++ {
		this.Field1[i] = float64(r.Float64())
		if r.Intn(2) == 0 {
			this.Field1[i] *= -1
		}
	}
	v3 := r.Intn(10)
	this.Field2 = make([]float32, v3)
	for i := 0; i < v3; i++ {
		this.Field2[i] = float32(r.Float32())
		if r.Intn(2) == 0 {
			this.Field2[i] *= -1
		}
	}
	v4 := r.Intn(10)
	this.Field3 = make([]int32, v4)
	for i := 0; i < v4; i++ {
		this.Field3[i] = int32(r.Int31())
		if r.Intn(2) == 0 {
			this.Field3[i] *= -1
		}
	}
	v5 := r.Intn(10)
	this.Field4 = make([]int64, v5)
	for i := 0; i < v5; i++ {
		this.Field4[i] = int64(r.Int63())
		if r.Intn(2) == 0 {
			this.Field4[i] *= -1
		}
	}
	v6 := r.Intn(10)
	this.Field5 = make([]uint32, v6)
	for i := 0; i < v6; i++ {
		this.Field5[i] = uint32(r.Uint32())
	}
	v7 := r.Intn(10)
	this.Field6 = make([]uint64, v7)
	for i := 0; i < v7; i++ {
		this.Field6[i] = uint64(uint64(r.Uint32()))
	}
	v8 := r.Intn(10)
	this.Field7 = make([]int32, v8)
	for i := 0; i < v8; i++ {
		this.Field7[i] = int32(r.Int31())
		if r.Intn(2) == 0 {
			this.Field7[i] *= -1
		}
	}
	v9 := r.Intn(10)
	this.Field8 = make([]int64, v9)
	for i := 0; i < v9; i++ {
		this.Field8[i] = int64(r.Int63())
		if r.Intn(2) == 0 {
			this.Field8[i] *= -1
		}
	}
	v10 := r.Intn(10)
	this.Field9 = make([]uint32, v10)
	for i := 0; i < v10; i++ {
		this.Field9[i] = uint32(r.Uint32())
	}
	v11 := r.Intn(10)
	this.Field10 = make([]int32, v11)
	for i := 0; i < v11; i++ {
		this.Field10[i] = int32(r.Int31())
		if r.Intn(2) == 0 {
			this.Field10[i] *= -1
		}
	}
	v12 := r.Intn(10)
	this.Field11 = make([]uint64, v12)
	for i := 0; i < v12; i++ {
		this.Field11[i] = uint64(uint64(r.Uint32()))
	}
	v13 := r.Intn(10)
	this.Field12 = make([]int64, v13)
	for i := 0; i < v13; i++ {
		this.Field12[i] = int64(r.Int63())
		if r.Intn(2) == 0 {
			this.Field12[i] *= -1
		}
	}
	v14 := r.Intn(10)
	this.Field13 = make([]bool, v14)
	for i := 0; i < v14; i++ {
		this.Field13[i] = bool(bool(r.Intn(2) == 0))
	}
	v15 := r.Intn(10)
	this.Field14 = make([]string, v15)
	for i := 0; i < v15; i++ {
		this.Field14[i] = string(randStringDeepcopy(r))
	}
	v16 := r.Intn(10)
	this.Field15 = make([][]byte, v16)
	for i := 0; i < v16; i++ {
		v17 := r.Intn(100)
		this.Field15[i] = make([]byte, v17)
		for j := 0; j < v17; j++ {
			this.Field15[i][j] = byte(r.Intn(256))
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRepeatedScalarPacked(r randyDeepcopy, easy bool) *RepeatedScalarPacked {
	this := &RepeatedScalarPacked{}
	v18 := r.Intn(10)
	this.Field1 = make([]float64, v18)
	for i := 0; i < v18; i++ {
		this.Field1[i] = float64(r.Float64())
		if r.Intn(2) == 0 {
			this.Field1[i] *= -1
		}
	}
	v19 := r.Intn(10)
	this.Field2 = make([]float32, v19)
	for i := 0; i < v19; i++ {
		this.Field2[i] = float32(r.Float32())
		if r.Intn(2) == 0 {
			this.Field2[i] *= -1
		}
	}
	v20 := r.Intn(10)
	this.Field3 = make([]int32, v20)
	for i := 0; i < v20; i++ {
		this.Field3[i] = int32(r.Int31())
		if r.Intn(2) == 0 {
			this.Field3[i] *= -1
		}
	}
	v21 := r.Intn(10)
	this.Field4 = make([]int64, v21)
	for i := 0; i < v21; i++ {
		this.Field4[i] = int64(r.Int63())
		if r.Intn(2) == 0 {
			this.Field4[i] *= -1
		}
	}
	v22 := r.Intn(10)
	this.Field5 = make([]uint32, v22)
	for i := 0; i < v22; i++ {
		this.Field5[i] = uint32(r.Uint32())
	}
	v23 := r.Intn(10)
	this.Field6 = make([]uint64, v23)
	for i := 0; i < v23; i++ {
		this.Field6[i] = uint64(uint64(r.Uint32()))
	}
	v24 := r.Intn(10)
	this.Field7 = make([]int32, v24)
	for i := 0; i < v24; i++ {
		this.Field7[i] = int32(r.Int31())
		if r.Intn(2) == 0 {
			this.Field7[i] *= -1
		}
	}
	v25 := r.Intn(10)
	this.Field8 = make([]int64, v25)
	for i := 0; i < v25; i++ {
		this.Field8[i] = int64(r.Int63())
		if r.Intn(2) == 0 {
			this.Field8[i] *= -1
		}
	}
	v26 := r.Intn(10)
	this.Field9 = make([]uint32, v26)
	for i := 0; i < v26; i++ {
		this.Field9[i] = uint32(r.Uint32())
	}
	v27 := r.Intn(10)
	this.Field10 = make([]int32, v27)
	for i := 0; i < v27; i++ {
		this.Field10[i] = int32(r.Int31())
		if r.Intn(2) == 0 {
			this.Field10[i] *= -1
		}
	}
	v28 := r.Intn(10)
	this.Field11 = make([]uint64, v28)
	for i := 0; i < v28; i++ {
		this.Field11[i] = uint64(uint64(r.Uint32()))
	}
	v29 := r.Intn(10)
	this.Field12 = make([]int64, v29)
	for i := 0; i < v29; i++ {
		this.Field12[i] = int64(r.Int63())
		if r.Intn(2) == 0 {
			this.Field12[i] *= -1
		}
	}
	v30 := r.Intn(10)
	this.Field13 = make([]bool, v30)
	for i := 0; i < v30; i++ {
		this.Field13[i] = bool(bool(r.Intn(2) == 0))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedExternalStruct(r randyDeepcopy, easy bool) *ExternalStruct {
	this := &ExternalStruct{}
	if r.Intn(10) != 0 {
		this.Field1 = NewPopulatedBasicScalar(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Field2 = NewPopulatedRepeatedScalar(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Field3 = NewPopulatedRepeatedScalarPacked(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRepeatedExternalStruct(r randyDeepcopy, easy bool) *RepeatedExternalStruct {
	this := &RepeatedExternalStruct{}
	if r.Intn(10) != 0 {
		v31 := r.Intn(5)
		this.Field1 = make([]*BasicScalar, v31)
		for i := 0; i < v31; i++ {
			this.Field1[i] = NewPopulatedBasicScalar(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v32 := r.Intn(5)
		this.Field2 = make([]*RepeatedScalar, v32)
		for i := 0; i < v32; i++ {
			this.Field2[i] = NewPopulatedRepeatedScalar(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v33 := r.Intn(5)
		this.Field3 = make([]*RepeatedScalarPacked, v33)
		for i := 0; i < v33; i++ {
			this.Field3[i] = NewPopulatedRepeatedScalarPacked(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedNonNullableExternalStruct(r randyDeepcopy, easy bool) *NonNullableExternalStruct {
	this := &NonNullableExternalStruct{}
	v34 := NewPopulatedBasicScalar(r, easy)
	this.Field1 = *v34
	v35 := NewPopulatedRepeatedScalar(r, easy)
	this.Field2 = *v35
	v36 := NewPopulatedRepeatedScalarPacked(r, easy)
	this.Field3 = *v36
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRepeatedNonNullableExternalStruct(r randyDeepcopy, easy bool) *RepeatedNonNullableExternalStruct {
	this := &RepeatedNonNullableExternalStruct{}
	if r.Intn(10) != 0 {
		v37 := r.Intn(5)
		this.Field1 = make([]BasicScalar, v37)
		for i := 0; i < v37; i++ {
			v38 := NewPopulatedBasicScalar(r, easy)
			this.Field1[i] = *v38
		}
	}
	if r.Intn(10) != 0 {
		v39 := r.Intn(5)
		this.Field2 = make([]RepeatedScalar, v39)
		for i := 0; i < v39; i++ {
			v40 := NewPopulatedRepeatedScalar(r, easy)
			this.Field2[i] = *v40
		}
	}
	if r.Intn(10) != 0 {
		v41 := r.Intn(5)
		this.Field3 = make([]RepeatedScalarPacked, v41)
		for i := 0; i < v41; i++ {
			v42 := NewPopulatedRepeatedScalarPacked(r, easy)
			this.Field3[i] = *v42
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedMapStruct(r randyDeepcopy, easy bool) *MapStruct {
	this := &MapStruct{}
	if r.Intn(10) != 0 {
		v43 := r.Intn(10)
		this.NullableMap = make(map[string]*BasicScalar)
		for i := 0; i < v43; i++ {
			this.NullableMap[randStringDeepcopy(r)] = NewPopulatedBasicScalar(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v44 := r.Intn(10)
		this.NonnullableMap = make(map[string]BasicScalar)
		for i := 0; i < v44; i++ {
			this.NonnullableMap[randStringDeepcopy(r)] = *NewPopulatedBasicScalar(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedOneOf(r randyDeepcopy, easy bool) *OneOf {
	this := &OneOf{}
	oneofNumber_Fields := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9}[r.Intn(9)]
	switch oneofNumber_Fields {
	case 1:
		this.Fields = NewPopulatedOneOf_Field1(r, easy)
	case 2:
		this.Fields = NewPopulatedOneOf_Field2(r, easy)
	case 3:
		this.Fields = NewPopulatedOneOf_Field3(r, easy)
	case 4:
		this.Fields = NewPopulatedOneOf_Field4(r, easy)
	case 5:
		this.Fields = NewPopulatedOneOf_Field5(r, easy)
	case 6:
		this.Fields = NewPopulatedOneOf_Field6(r, easy)
	case 7:
		this.Fields = NewPopulatedOneOf_Field7(r, easy)
	case 8:
		this.Fields = NewPopulatedOneOf_Field8(r, easy)
	case 9:
		this.Fields = NewPopulatedOneOf_Field9(r, easy)
	}
	oneofNumber_FieldsTwo := []int32{10, 11}[r.Intn(2)]
	switch oneofNumber_FieldsTwo {
	case 10:
		this.FieldsTwo = NewPopulatedOneOf_Field10(r, easy)
	case 11:
		this.FieldsTwo = NewPopulatedOneOf_Field11(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedOneOf_Field1(r randyDeepcopy, easy bool) *OneOf_Field1 {
	this := &OneOf_Field1{}
	this.Field1 = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.Field1 *= -1
	}
	return this
}
func NewPopulatedOneOf_Field2(r randyDeepcopy, easy bool) *OneOf_Field2 {
	this := &OneOf_Field2{}
	this.Field2 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Field2 *= -1
	}
	return this
}
func NewPopulatedOneOf_Field3(r randyDeepcopy, easy bool) *OneOf_Field3 {
	this := &OneOf_Field3{}
	this.Field3 = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Field3 *= -1
	}
	return this
}
func NewPopulatedOneOf_Field4(r randyDeepcopy, easy bool) *OneOf_Field4 {
	this := &OneOf_Field4{}
	this.Field4 = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Field4 *= -1
	}
	return this
}
func NewPopulatedOneOf_Field5(r randyDeepcopy, easy bool) *OneOf_Field5 {
	this := &OneOf_Field5{}
	this.Field5 = uint32(r.Uint32())
	return this
}
func NewPopulatedOneOf_Field6(r randyDeepcopy, easy bool) *OneOf_Field6 {
	this := &OneOf_Field6{}
	this.Field6 = string(randStringDeepcopy(r))
	return this
}
func NewPopulatedOneOf_Field7(r randyDeepcopy, easy bool) *OneOf_Field7 {
	this := &OneOf_Field7{}
	v45 := r.Intn(100)
	this.Field7 = make([]byte, v45)
	for i := 0; i < v45; i++ {
		this.Field7[i] = byte(r.Intn(256))
	}
	return this
}
func NewPopulatedOneOf_Field8(r randyDeepcopy, easy bool) *OneOf_Field8 {
	this := &OneOf_Field8{}
	this.Field8 = NewPopulatedMapStruct(r, easy)
	return this
}
func NewPopulatedOneOf_Field9(r randyDeepcopy, easy bool) *OneOf_Field9 {
	this := &OneOf_Field9{}
	this.Field9 = NewPopulatedRepeatedNonNullableExternalStruct(r, easy)
	return this
}
func NewPopulatedOneOf_Field10(r randyDeepcopy, easy bool) *OneOf_Field10 {
	this := &OneOf_Field10{}
	this.Field10 = NewPopulatedNonNullableExternalStruct(r, easy)
	return this
}
func NewPopulatedOneOf_Field11(r randyDeepcopy, easy bool) *OneOf_Field11 {
	this := &OneOf_Field11{}
	this.Field11 = NewPopulatedRepeatedExternalStruct(r, easy)
	return this
}

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

func randUTF8RuneDeepcopy(r randyDeepcopy) 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 randStringDeepcopy(r randyDeepcopy) string {
	v46 := r.Intn(100)
	tmps := make([]rune, v46)
	for i := 0; i < v46; i++ {
		tmps[i] = randUTF8RuneDeepcopy(r)
	}
	return string(tmps)
}
func randUnrecognizedDeepcopy(r randyDeepcopy, 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 = randFieldDeepcopy(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldDeepcopy(dAtA []byte, r randyDeepcopy, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateDeepcopy(dAtA, uint64(key))
		v47 := r.Int63()
		if r.Intn(2) == 0 {
			v47 *= -1
		}
		dAtA = encodeVarintPopulateDeepcopy(dAtA, uint64(v47))
	case 1:
		dAtA = encodeVarintPopulateDeepcopy(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 = encodeVarintPopulateDeepcopy(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateDeepcopy(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateDeepcopy(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 encodeVarintPopulateDeepcopy(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 (this *BasicScalar) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BasicScalar{`,
		`Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
		`Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
		`Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
		`Field4:` + fmt.Sprintf("%v", this.Field4) + `,`,
		`Field5:` + fmt.Sprintf("%v", this.Field5) + `,`,
		`Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
		`Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
		`Field8:` + fmt.Sprintf("%v", this.Field8) + `,`,
		`Field9:` + fmt.Sprintf("%v", this.Field9) + `,`,
		`Field10:` + fmt.Sprintf("%v", this.Field10) + `,`,
		`Field11:` + fmt.Sprintf("%v", this.Field11) + `,`,
		`Field12:` + fmt.Sprintf("%v", this.Field12) + `,`,
		`Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
		`Field14:` + fmt.Sprintf("%v", this.Field14) + `,`,
		`Field15:` + fmt.Sprintf("%v", this.Field15) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RepeatedScalar) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RepeatedScalar{`,
		`Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
		`Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
		`Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
		`Field4:` + fmt.Sprintf("%v", this.Field4) + `,`,
		`Field5:` + fmt.Sprintf("%v", this.Field5) + `,`,
		`Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
		`Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
		`Field8:` + fmt.Sprintf("%v", this.Field8) + `,`,
		`Field9:` + fmt.Sprintf("%v", this.Field9) + `,`,
		`Field10:` + fmt.Sprintf("%v", this.Field10) + `,`,
		`Field11:` + fmt.Sprintf("%v", this.Field11) + `,`,
		`Field12:` + fmt.Sprintf("%v", this.Field12) + `,`,
		`Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
		`Field14:` + fmt.Sprintf("%v", this.Field14) + `,`,
		`Field15:` + fmt.Sprintf("%v", this.Field15) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RepeatedScalarPacked) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RepeatedScalarPacked{`,
		`Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
		`Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
		`Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
		`Field4:` + fmt.Sprintf("%v", this.Field4) + `,`,
		`Field5:` + fmt.Sprintf("%v", this.Field5) + `,`,
		`Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
		`Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
		`Field8:` + fmt.Sprintf("%v", this.Field8) + `,`,
		`Field9:` + fmt.Sprintf("%v", this.Field9) + `,`,
		`Field10:` + fmt.Sprintf("%v", this.Field10) + `,`,
		`Field11:` + fmt.Sprintf("%v", this.Field11) + `,`,
		`Field12:` + fmt.Sprintf("%v", this.Field12) + `,`,
		`Field13:` + fmt.Sprintf("%v", this.Field13) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExternalStruct) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExternalStruct{`,
		`Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "BasicScalar", "BasicScalar", 1) + `,`,
		`Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "RepeatedScalar", "RepeatedScalar", 1) + `,`,
		`Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "RepeatedScalarPacked", "RepeatedScalarPacked", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RepeatedExternalStruct) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RepeatedExternalStruct{`,
		`Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "BasicScalar", "BasicScalar", 1) + `,`,
		`Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "RepeatedScalar", "RepeatedScalar", 1) + `,`,
		`Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "RepeatedScalarPacked", "RepeatedScalarPacked", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NonNullableExternalStruct) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NonNullableExternalStruct{`,
		`Field1:` + strings.Replace(strings.Replace(this.Field1.String(), "BasicScalar", "BasicScalar", 1), `&`, ``, 1) + `,`,
		`Field2:` + strings.Replace(strings.Replace(this.Field2.String(), "RepeatedScalar", "RepeatedScalar", 1), `&`, ``, 1) + `,`,
		`Field3:` + strings.Replace(strings.Replace(this.Field3.String(), "RepeatedScalarPacked", "RepeatedScalarPacked", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RepeatedNonNullableExternalStruct) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RepeatedNonNullableExternalStruct{`,
		`Field1:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field1), "BasicScalar", "BasicScalar", 1), `&`, ``, 1) + `,`,
		`Field2:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field2), "RepeatedScalar", "RepeatedScalar", 1), `&`, ``, 1) + `,`,
		`Field3:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field3), "RepeatedScalarPacked", "RepeatedScalarPacked", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MapStruct) String() string {
	if this == nil {
		return "nil"
	}
	keysForNullableMap := make([]string, 0, len(this.NullableMap))
	for k, _ := range this.NullableMap {
		keysForNullableMap = append(keysForNullableMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForNullableMap)
	mapStringForNullableMap := "map[string]*BasicScalar{"
	for _, k := range keysForNullableMap {
		mapStringForNullableMap += fmt.Sprintf("%v: %v,", k, this.NullableMap[k])
	}
	mapStringForNullableMap += "}"
	keysForNonnullableMap := make([]string, 0, len(this.NonnullableMap))
	for k, _ := range this.NonnullableMap {
		keysForNonnullableMap = append(keysForNonnullableMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForNonnullableMap)
	mapStringForNonnullableMap := "map[string]BasicScalar{"
	for _, k := range keysForNonnullableMap {
		mapStringForNonnullableMap += fmt.Sprintf("%v: %v,", k, this.NonnullableMap[k])
	}
	mapStringForNonnullableMap += "}"
	s := strings.Join([]string{`&MapStruct{`,
		`NullableMap:` + mapStringForNullableMap + `,`,
		`NonnullableMap:` + mapStringForNonnullableMap + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf{`,
		`Fields:` + fmt.Sprintf("%v", this.Fields) + `,`,
		`FieldsTwo:` + fmt.Sprintf("%v", this.FieldsTwo) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field1) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field1{`,
		`Field1:` + fmt.Sprintf("%v", this.Field1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field2) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field2{`,
		`Field2:` + fmt.Sprintf("%v", this.Field2) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field3) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field3{`,
		`Field3:` + fmt.Sprintf("%v", this.Field3) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field4) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field4{`,
		`Field4:` + fmt.Sprintf("%v", this.Field4) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field5) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field5{`,
		`Field5:` + fmt.Sprintf("%v", this.Field5) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field6) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field6{`,
		`Field6:` + fmt.Sprintf("%v", this.Field6) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field7) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field7{`,
		`Field7:` + fmt.Sprintf("%v", this.Field7) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field8) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field8{`,
		`Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "MapStruct", "MapStruct", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field9) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field9{`,
		`Field9:` + strings.Replace(fmt.Sprintf("%v", this.Field9), "RepeatedNonNullableExternalStruct", "RepeatedNonNullableExternalStruct", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field10) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field10{`,
		`Field10:` + strings.Replace(fmt.Sprintf("%v", this.Field10), "NonNullableExternalStruct", "NonNullableExternalStruct", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OneOf_Field11) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OneOf_Field11{`,
		`Field11:` + strings.Replace(fmt.Sprintf("%v", this.Field11), "RepeatedExternalStruct", "RepeatedExternalStruct", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringDeepcopy(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}