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

/*
Package test is a generated protocol buffer package.

It is generated from these files:
	github.com/docker/swarmkit/protobuf/plugin/deepcopy/test/deepcopy.proto

It has these top-level messages:
	BasicScalar
	RepeatedScalar
	RepeatedScalarPacked
	ExternalStruct
	RepeatedExternalStruct
	NonNullableExternalStruct
	RepeatedNonNullableExternalStruct
	MapStruct
	OneOf
*/
package test

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import deepcopy "github.com/docker/swarmkit/api/deepcopy"

import bytes "bytes"

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

// 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 fileDescriptorDeepcopy, []int{0} }

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

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

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

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

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

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

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

func (m *RepeatedExternalStruct) Reset()                    { *m = RepeatedExternalStruct{} }
func (*RepeatedExternalStruct) ProtoMessage()               {}
func (*RepeatedExternalStruct) Descriptor() ([]byte, []int) { return fileDescriptorDeepcopy, []int{4} }

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

func (m *NonNullableExternalStruct) Reset()      { *m = NonNullableExternalStruct{} }
func (*NonNullableExternalStruct) ProtoMessage() {}
func (*NonNullableExternalStruct) Descriptor() ([]byte, []int) {
	return fileDescriptorDeepcopy, []int{5}
}

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

func (m *RepeatedNonNullableExternalStruct) Reset()      { *m = RepeatedNonNullableExternalStruct{} }
func (*RepeatedNonNullableExternalStruct) ProtoMessage() {}
func (*RepeatedNonNullableExternalStruct) Descriptor() ([]byte, []int) {
	return fileDescriptorDeepcopy, []int{6}
}

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

func (m *MapStruct) Reset()                    { *m = MapStruct{} }
func (*MapStruct) ProtoMessage()               {}
func (*MapStruct) Descriptor() ([]byte, []int) { return fileDescriptorDeepcopy, []int{7} }

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 fileDescriptorDeepcopy, []int{8} }

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,oneof"`
}
type OneOf_Field9 struct {
	Field9 *RepeatedNonNullableExternalStruct `protobuf:"bytes,9,opt,name=Field9,oneof"`
}
type OneOf_Field10 struct {
	Field10 *NonNullableExternalStruct `protobuf:"bytes,10,opt,name=Field10,oneof"`
}
type OneOf_Field11 struct {
	Field11 *RepeatedExternalStruct `protobuf:"bytes,11,opt,name=Field11,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 += proto.SizeVarint(1<<3 | proto.WireFixed64)
		n += 8
	case *OneOf_Field2:
		n += proto.SizeVarint(2<<3 | proto.WireFixed32)
		n += 4
	case *OneOf_Field3:
		n += proto.SizeVarint(3<<3 | proto.WireVarint)
		n += proto.SizeVarint(uint64(x.Field3))
	case *OneOf_Field4:
		n += proto.SizeVarint(4<<3 | proto.WireVarint)
		n += proto.SizeVarint(uint64(x.Field4))
	case *OneOf_Field5:
		n += proto.SizeVarint(5<<3 | proto.WireVarint)
		n += proto.SizeVarint(uint64(x.Field5))
	case *OneOf_Field6:
		n += proto.SizeVarint(6<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(len(x.Field6)))
		n += len(x.Field6)
	case *OneOf_Field7:
		n += proto.SizeVarint(7<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(len(x.Field7)))
		n += len(x.Field7)
	case *OneOf_Field8:
		s := proto.Size(x.Field8)
		n += proto.SizeVarint(8<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneOf_Field9:
		s := proto.Size(x.Field9)
		n += proto.SizeVarint(9<<3 | proto.WireBytes)
		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 += proto.SizeVarint(10<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *OneOf_Field11:
		s := proto.Size(x.Field11)
		n += proto.SizeVarint(11<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

func init() {
	proto.RegisterType((*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.RegisterType((*OneOf)(nil), "test.OneOf")
}

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{}
		deepcopy.Copy(m.Field1, o.Field1)
	}
	if o.Field2 != nil {
		m.Field2 = &RepeatedScalar{}
		deepcopy.Copy(m.Field2, o.Field2)
	}
	if o.Field3 != nil {
		m.Field3 = &RepeatedScalarPacked{}
		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{}
			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{}
			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{}
			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
	deepcopy.Copy(&m.Field1, &o.Field1)
	deepcopy.Copy(&m.Field2, &o.Field2)
	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 {
			deepcopy.Copy(&m.Field1[i], &o.Field1[i])
		}
	}

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

	if o.Field3 != nil {
		m.Field3 = make([]RepeatedScalarPacked, len(o.Field3))
		for i := range m.Field3 {
			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{}
			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{}
			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{},
			}
			deepcopy.Copy(v.Field8, o.GetField8())
			m.Fields = &v
		case *OneOf_Field9:
			v := OneOf_Field9{
				Field9: &RepeatedNonNullableExternalStruct{},
			}
			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{},
			}
			deepcopy.Copy(v.Field10, o.GetField10())
			m.FieldsTwo = &v
		case *OneOf_Field11:
			v := OneOf_Field11{
				Field11: &RepeatedExternalStruct{},
			}
			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)
	}
	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)
	}
	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)
}

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

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