github.com/gogo/protobuf@v1.3.2/test/casttype/combos/both/casttype.pb.go

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

package casttype

import (
	bytes "bytes"
	compress_gzip "compress/gzip"
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	github_com_gogo_protobuf_test_casttype "github.com/gogo/protobuf/test/casttype"
	io "io"
	io_ioutil "io/ioutil"
	math "math"
	math_bits "math/bits"
	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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type Castaway struct {
	Int32Ptr             *int32                                                                                                      `protobuf:"varint,1,opt,name=Int32Ptr,casttype=int32" json:"Int32Ptr,omitempty"`
	Int32                int32                                                                                                       `protobuf:"varint,2,opt,name=Int32,casttype=int32" json:"Int32"`
	MyUint64Ptr          *github_com_gogo_protobuf_test_casttype.MyUint64Type                                                        `protobuf:"varint,3,opt,name=MyUint64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64Ptr,omitempty"`
	MyUint64             github_com_gogo_protobuf_test_casttype.MyUint64Type                                                         `protobuf:"varint,4,opt,name=MyUint64,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64"`
	MyFloat32Ptr         *github_com_gogo_protobuf_test_casttype.MyFloat32Type                                                       `protobuf:"fixed32,5,opt,name=MyFloat32Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyFloat32Type" json:"MyFloat32Ptr,omitempty"`
	MyFloat32            github_com_gogo_protobuf_test_casttype.MyFloat32Type                                                        `protobuf:"fixed32,6,opt,name=MyFloat32,casttype=github.com/gogo/protobuf/test/casttype.MyFloat32Type" json:"MyFloat32"`
	MyFloat64Ptr         *github_com_gogo_protobuf_test_casttype.MyFloat64Type                                                       `protobuf:"fixed64,7,opt,name=MyFloat64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyFloat64Type" json:"MyFloat64Ptr,omitempty"`
	MyFloat64            github_com_gogo_protobuf_test_casttype.MyFloat64Type                                                        `protobuf:"fixed64,8,opt,name=MyFloat64,casttype=github.com/gogo/protobuf/test/casttype.MyFloat64Type" json:"MyFloat64"`
	MyBytes              github_com_gogo_protobuf_test_casttype.Bytes                                                                `protobuf:"bytes,9,opt,name=MyBytes,casttype=github.com/gogo/protobuf/test/casttype.Bytes" json:"MyBytes,omitempty"`
	NormalBytes          []byte                                                                                                      `protobuf:"bytes,10,opt,name=NormalBytes" json:"NormalBytes,omitempty"`
	MyUint64S            []github_com_gogo_protobuf_test_casttype.MyUint64Type                                                       `protobuf:"varint,11,rep,name=MyUint64s,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64s,omitempty"`
	MyMap                github_com_gogo_protobuf_test_casttype.MyMapType                                                            `protobuf:"bytes,12,rep,name=MyMap,casttype=github.com/gogo/protobuf/test/casttype.MyMapType" json:"MyMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	MyCustomMap          map[github_com_gogo_protobuf_test_casttype.MyStringType]github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"bytes,13,rep,name=MyCustomMap,castkey=github.com/gogo/protobuf/test/casttype.MyStringType,castvalue=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyCustomMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	MyNullableMap        map[github_com_gogo_protobuf_test_casttype.MyInt32Type]*Wilson                                              `protobuf:"bytes,14,rep,name=MyNullableMap,castkey=github.com/gogo/protobuf/test/casttype.MyInt32Type" json:"MyNullableMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	MyEmbeddedMap        map[github_com_gogo_protobuf_test_casttype.MyInt32Type]Wilson                                               `protobuf:"bytes,15,rep,name=MyEmbeddedMap,castkey=github.com/gogo/protobuf/test/casttype.MyInt32Type" json:"MyEmbeddedMap" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	String_              *github_com_gogo_protobuf_test_casttype.MyStringType                                                        `protobuf:"bytes,16,opt,name=String,casttype=github.com/gogo/protobuf/test/casttype.MyStringType" json:"String,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                                                                                    `json:"-"`
	XXX_unrecognized     []byte                                                                                                      `json:"-"`
	XXX_sizecache        int32                                                                                                       `json:"-"`
}

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

var xxx_messageInfo_Castaway proto.InternalMessageInfo

type Wilson struct {
	Int64                *int64   `protobuf:"varint,1,opt,name=Int64" json:"Int64,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Wilson proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Castaway)(nil), "casttype.Castaway")
	proto.RegisterMapType((map[github_com_gogo_protobuf_test_casttype.MyStringType]github_com_gogo_protobuf_test_casttype.MyUint64Type)(nil), "casttype.Castaway.MyCustomMapEntry")
	proto.RegisterMapType((map[github_com_gogo_protobuf_test_casttype.MyInt32Type]Wilson)(nil), "casttype.Castaway.MyEmbeddedMapEntry")
	proto.RegisterMapType((github_com_gogo_protobuf_test_casttype.MyMapType)(nil), "casttype.Castaway.MyMapEntry")
	proto.RegisterMapType((map[github_com_gogo_protobuf_test_casttype.MyInt32Type]*Wilson)(nil), "casttype.Castaway.MyNullableMapEntry")
	proto.RegisterType((*Wilson)(nil), "casttype.Wilson")
}

func init() { proto.RegisterFile("combos/both/casttype.proto", fileDescriptor_e62bd869da1a4b71) }

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

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

	that1, ok := that.(*Castaway)
	if !ok {
		that2, ok := that.(Castaway)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Castaway")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Castaway but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Castaway but is not nil && this == nil")
	}
	if this.Int32Ptr != nil && that1.Int32Ptr != nil {
		if *this.Int32Ptr != *that1.Int32Ptr {
			return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", *this.Int32Ptr, *that1.Int32Ptr)
		}
	} else if this.Int32Ptr != nil {
		return fmt.Errorf("this.Int32Ptr == nil && that.Int32Ptr != nil")
	} else if that1.Int32Ptr != nil {
		return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", this.Int32Ptr, that1.Int32Ptr)
	}
	if this.Int32 != that1.Int32 {
		return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32)
	}
	if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil {
		if *this.MyUint64Ptr != *that1.MyUint64Ptr {
			return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", *this.MyUint64Ptr, *that1.MyUint64Ptr)
		}
	} else if this.MyUint64Ptr != nil {
		return fmt.Errorf("this.MyUint64Ptr == nil && that.MyUint64Ptr != nil")
	} else if that1.MyUint64Ptr != nil {
		return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", this.MyUint64Ptr, that1.MyUint64Ptr)
	}
	if this.MyUint64 != that1.MyUint64 {
		return fmt.Errorf("MyUint64 this(%v) Not Equal that(%v)", this.MyUint64, that1.MyUint64)
	}
	if this.MyFloat32Ptr != nil && that1.MyFloat32Ptr != nil {
		if *this.MyFloat32Ptr != *that1.MyFloat32Ptr {
			return fmt.Errorf("MyFloat32Ptr this(%v) Not Equal that(%v)", *this.MyFloat32Ptr, *that1.MyFloat32Ptr)
		}
	} else if this.MyFloat32Ptr != nil {
		return fmt.Errorf("this.MyFloat32Ptr == nil && that.MyFloat32Ptr != nil")
	} else if that1.MyFloat32Ptr != nil {
		return fmt.Errorf("MyFloat32Ptr this(%v) Not Equal that(%v)", this.MyFloat32Ptr, that1.MyFloat32Ptr)
	}
	if this.MyFloat32 != that1.MyFloat32 {
		return fmt.Errorf("MyFloat32 this(%v) Not Equal that(%v)", this.MyFloat32, that1.MyFloat32)
	}
	if this.MyFloat64Ptr != nil && that1.MyFloat64Ptr != nil {
		if *this.MyFloat64Ptr != *that1.MyFloat64Ptr {
			return fmt.Errorf("MyFloat64Ptr this(%v) Not Equal that(%v)", *this.MyFloat64Ptr, *that1.MyFloat64Ptr)
		}
	} else if this.MyFloat64Ptr != nil {
		return fmt.Errorf("this.MyFloat64Ptr == nil && that.MyFloat64Ptr != nil")
	} else if that1.MyFloat64Ptr != nil {
		return fmt.Errorf("MyFloat64Ptr this(%v) Not Equal that(%v)", this.MyFloat64Ptr, that1.MyFloat64Ptr)
	}
	if this.MyFloat64 != that1.MyFloat64 {
		return fmt.Errorf("MyFloat64 this(%v) Not Equal that(%v)", this.MyFloat64, that1.MyFloat64)
	}
	if !bytes.Equal(this.MyBytes, that1.MyBytes) {
		return fmt.Errorf("MyBytes this(%v) Not Equal that(%v)", this.MyBytes, that1.MyBytes)
	}
	if !bytes.Equal(this.NormalBytes, that1.NormalBytes) {
		return fmt.Errorf("NormalBytes this(%v) Not Equal that(%v)", this.NormalBytes, that1.NormalBytes)
	}
	if len(this.MyUint64S) != len(that1.MyUint64S) {
		return fmt.Errorf("MyUint64S this(%v) Not Equal that(%v)", len(this.MyUint64S), len(that1.MyUint64S))
	}
	for i := range this.MyUint64S {
		if this.MyUint64S[i] != that1.MyUint64S[i] {
			return fmt.Errorf("MyUint64S this[%v](%v) Not Equal that[%v](%v)", i, this.MyUint64S[i], i, that1.MyUint64S[i])
		}
	}
	if len(this.MyMap) != len(that1.MyMap) {
		return fmt.Errorf("MyMap this(%v) Not Equal that(%v)", len(this.MyMap), len(that1.MyMap))
	}
	for i := range this.MyMap {
		if this.MyMap[i] != that1.MyMap[i] {
			return fmt.Errorf("MyMap this[%v](%v) Not Equal that[%v](%v)", i, this.MyMap[i], i, that1.MyMap[i])
		}
	}
	if len(this.MyCustomMap) != len(that1.MyCustomMap) {
		return fmt.Errorf("MyCustomMap this(%v) Not Equal that(%v)", len(this.MyCustomMap), len(that1.MyCustomMap))
	}
	for i := range this.MyCustomMap {
		if this.MyCustomMap[i] != that1.MyCustomMap[i] {
			return fmt.Errorf("MyCustomMap this[%v](%v) Not Equal that[%v](%v)", i, this.MyCustomMap[i], i, that1.MyCustomMap[i])
		}
	}
	if len(this.MyNullableMap) != len(that1.MyNullableMap) {
		return fmt.Errorf("MyNullableMap this(%v) Not Equal that(%v)", len(this.MyNullableMap), len(that1.MyNullableMap))
	}
	for i := range this.MyNullableMap {
		if !this.MyNullableMap[i].Equal(that1.MyNullableMap[i]) {
			return fmt.Errorf("MyNullableMap this[%v](%v) Not Equal that[%v](%v)", i, this.MyNullableMap[i], i, that1.MyNullableMap[i])
		}
	}
	if len(this.MyEmbeddedMap) != len(that1.MyEmbeddedMap) {
		return fmt.Errorf("MyEmbeddedMap this(%v) Not Equal that(%v)", len(this.MyEmbeddedMap), len(that1.MyEmbeddedMap))
	}
	for i := range this.MyEmbeddedMap {
		a := this.MyEmbeddedMap[i]
		b := that1.MyEmbeddedMap[i]
		if !(&a).Equal(&b) {
			return fmt.Errorf("MyEmbeddedMap this[%v](%v) Not Equal that[%v](%v)", i, this.MyEmbeddedMap[i], i, that1.MyEmbeddedMap[i])
		}
	}
	if this.String_ != nil && that1.String_ != nil {
		if *this.String_ != *that1.String_ {
			return fmt.Errorf("String_ this(%v) Not Equal that(%v)", *this.String_, *that1.String_)
		}
	} else if this.String_ != nil {
		return fmt.Errorf("this.String_ == nil && that.String_ != nil")
	} else if that1.String_ != nil {
		return fmt.Errorf("String_ this(%v) Not Equal that(%v)", this.String_, that1.String_)
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *Castaway) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Castaway)
	if !ok {
		that2, ok := that.(Castaway)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Int32Ptr != nil && that1.Int32Ptr != nil {
		if *this.Int32Ptr != *that1.Int32Ptr {
			return false
		}
	} else if this.Int32Ptr != nil {
		return false
	} else if that1.Int32Ptr != nil {
		return false
	}
	if this.Int32 != that1.Int32 {
		return false
	}
	if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil {
		if *this.MyUint64Ptr != *that1.MyUint64Ptr {
			return false
		}
	} else if this.MyUint64Ptr != nil {
		return false
	} else if that1.MyUint64Ptr != nil {
		return false
	}
	if this.MyUint64 != that1.MyUint64 {
		return false
	}
	if this.MyFloat32Ptr != nil && that1.MyFloat32Ptr != nil {
		if *this.MyFloat32Ptr != *that1.MyFloat32Ptr {
			return false
		}
	} else if this.MyFloat32Ptr != nil {
		return false
	} else if that1.MyFloat32Ptr != nil {
		return false
	}
	if this.MyFloat32 != that1.MyFloat32 {
		return false
	}
	if this.MyFloat64Ptr != nil && that1.MyFloat64Ptr != nil {
		if *this.MyFloat64Ptr != *that1.MyFloat64Ptr {
			return false
		}
	} else if this.MyFloat64Ptr != nil {
		return false
	} else if that1.MyFloat64Ptr != nil {
		return false
	}
	if this.MyFloat64 != that1.MyFloat64 {
		return false
	}
	if !bytes.Equal(this.MyBytes, that1.MyBytes) {
		return false
	}
	if !bytes.Equal(this.NormalBytes, that1.NormalBytes) {
		return false
	}
	if len(this.MyUint64S) != len(that1.MyUint64S) {
		return false
	}
	for i := range this.MyUint64S {
		if this.MyUint64S[i] != that1.MyUint64S[i] {
			return false
		}
	}
	if len(this.MyMap) != len(that1.MyMap) {
		return false
	}
	for i := range this.MyMap {
		if this.MyMap[i] != that1.MyMap[i] {
			return false
		}
	}
	if len(this.MyCustomMap) != len(that1.MyCustomMap) {
		return false
	}
	for i := range this.MyCustomMap {
		if this.MyCustomMap[i] != that1.MyCustomMap[i] {
			return false
		}
	}
	if len(this.MyNullableMap) != len(that1.MyNullableMap) {
		return false
	}
	for i := range this.MyNullableMap {
		if !this.MyNullableMap[i].Equal(that1.MyNullableMap[i]) {
			return false
		}
	}
	if len(this.MyEmbeddedMap) != len(that1.MyEmbeddedMap) {
		return false
	}
	for i := range this.MyEmbeddedMap {
		a := this.MyEmbeddedMap[i]
		b := that1.MyEmbeddedMap[i]
		if !(&a).Equal(&b) {
			return false
		}
	}
	if this.String_ != nil && that1.String_ != nil {
		if *this.String_ != *that1.String_ {
			return false
		}
	} else if this.String_ != nil {
		return false
	} else if that1.String_ != nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Wilson) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

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

	that1, ok := that.(*Wilson)
	if !ok {
		that2, ok := that.(Wilson)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Int64 != nil && that1.Int64 != nil {
		if *this.Int64 != *that1.Int64 {
			return false
		}
	} else if this.Int64 != nil {
		return false
	} else if that1.Int64 != nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}

type CastawayFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetInt32Ptr() *int32
	GetInt32() int32
	GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type
	GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type
	GetMyFloat32Ptr() *github_com_gogo_protobuf_test_casttype.MyFloat32Type
	GetMyFloat32() github_com_gogo_protobuf_test_casttype.MyFloat32Type
	GetMyFloat64Ptr() *github_com_gogo_protobuf_test_casttype.MyFloat64Type
	GetMyFloat64() github_com_gogo_protobuf_test_casttype.MyFloat64Type
	GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes
	GetNormalBytes() []byte
	GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type
	GetMyMap() github_com_gogo_protobuf_test_casttype.MyMapType
	GetMyCustomMap() map[github_com_gogo_protobuf_test_casttype.MyStringType]github_com_gogo_protobuf_test_casttype.MyUint64Type
	GetMyNullableMap() map[github_com_gogo_protobuf_test_casttype.MyInt32Type]*Wilson
	GetMyEmbeddedMap() map[github_com_gogo_protobuf_test_casttype.MyInt32Type]Wilson
	GetString_() *github_com_gogo_protobuf_test_casttype.MyStringType
}

func (this *Castaway) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *Castaway) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewCastawayFromFace(this)
}

func (this *Castaway) GetInt32Ptr() *int32 {
	return this.Int32Ptr
}

func (this *Castaway) GetInt32() int32 {
	return this.Int32
}

func (this *Castaway) GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type {
	return this.MyUint64Ptr
}

func (this *Castaway) GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type {
	return this.MyUint64
}

func (this *Castaway) GetMyFloat32Ptr() *github_com_gogo_protobuf_test_casttype.MyFloat32Type {
	return this.MyFloat32Ptr
}

func (this *Castaway) GetMyFloat32() github_com_gogo_protobuf_test_casttype.MyFloat32Type {
	return this.MyFloat32
}

func (this *Castaway) GetMyFloat64Ptr() *github_com_gogo_protobuf_test_casttype.MyFloat64Type {
	return this.MyFloat64Ptr
}

func (this *Castaway) GetMyFloat64() github_com_gogo_protobuf_test_casttype.MyFloat64Type {
	return this.MyFloat64
}

func (this *Castaway) GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes {
	return this.MyBytes
}

func (this *Castaway) GetNormalBytes() []byte {
	return this.NormalBytes
}

func (this *Castaway) GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type {
	return this.MyUint64S
}

func (this *Castaway) GetMyMap() github_com_gogo_protobuf_test_casttype.MyMapType {
	return this.MyMap
}

func (this *Castaway) GetMyCustomMap() map[github_com_gogo_protobuf_test_casttype.MyStringType]github_com_gogo_protobuf_test_casttype.MyUint64Type {
	return this.MyCustomMap
}

func (this *Castaway) GetMyNullableMap() map[github_com_gogo_protobuf_test_casttype.MyInt32Type]*Wilson {
	return this.MyNullableMap
}

func (this *Castaway) GetMyEmbeddedMap() map[github_com_gogo_protobuf_test_casttype.MyInt32Type]Wilson {
	return this.MyEmbeddedMap
}

func (this *Castaway) GetString_() *github_com_gogo_protobuf_test_casttype.MyStringType {
	return this.String_
}

func NewCastawayFromFace(that CastawayFace) *Castaway {
	this := &Castaway{}
	this.Int32Ptr = that.GetInt32Ptr()
	this.Int32 = that.GetInt32()
	this.MyUint64Ptr = that.GetMyUint64Ptr()
	this.MyUint64 = that.GetMyUint64()
	this.MyFloat32Ptr = that.GetMyFloat32Ptr()
	this.MyFloat32 = that.GetMyFloat32()
	this.MyFloat64Ptr = that.GetMyFloat64Ptr()
	this.MyFloat64 = that.GetMyFloat64()
	this.MyBytes = that.GetMyBytes()
	this.NormalBytes = that.GetNormalBytes()
	this.MyUint64S = that.GetMyUint64S()
	this.MyMap = that.GetMyMap()
	this.MyCustomMap = that.GetMyCustomMap()
	this.MyNullableMap = that.GetMyNullableMap()
	this.MyEmbeddedMap = that.GetMyEmbeddedMap()
	this.String_ = that.GetString_()
	return this
}

type WilsonFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetInt64() *int64
}

func (this *Wilson) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *Wilson) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewWilsonFromFace(this)
}

func (this *Wilson) GetInt64() *int64 {
	return this.Int64
}

func NewWilsonFromFace(that WilsonFace) *Wilson {
	this := &Wilson{}
	this.Int64 = that.GetInt64()
	return this
}

func (this *Castaway) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 20)
	s = append(s, "&casttype.Castaway{")
	if this.Int32Ptr != nil {
		s = append(s, "Int32Ptr: "+valueToGoStringCasttype(this.Int32Ptr, "int32")+",\n")
	}
	s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n")
	if this.MyUint64Ptr != nil {
		s = append(s, "MyUint64Ptr: "+valueToGoStringCasttype(this.MyUint64Ptr, "github_com_gogo_protobuf_test_casttype.MyUint64Type")+",\n")
	}
	s = append(s, "MyUint64: "+fmt.Sprintf("%#v", this.MyUint64)+",\n")
	if this.MyFloat32Ptr != nil {
		s = append(s, "MyFloat32Ptr: "+valueToGoStringCasttype(this.MyFloat32Ptr, "github_com_gogo_protobuf_test_casttype.MyFloat32Type")+",\n")
	}
	s = append(s, "MyFloat32: "+fmt.Sprintf("%#v", this.MyFloat32)+",\n")
	if this.MyFloat64Ptr != nil {
		s = append(s, "MyFloat64Ptr: "+valueToGoStringCasttype(this.MyFloat64Ptr, "github_com_gogo_protobuf_test_casttype.MyFloat64Type")+",\n")
	}
	s = append(s, "MyFloat64: "+fmt.Sprintf("%#v", this.MyFloat64)+",\n")
	if this.MyBytes != nil {
		s = append(s, "MyBytes: "+valueToGoStringCasttype(this.MyBytes, "github_com_gogo_protobuf_test_casttype.Bytes")+",\n")
	}
	if this.NormalBytes != nil {
		s = append(s, "NormalBytes: "+valueToGoStringCasttype(this.NormalBytes, "byte")+",\n")
	}
	if this.MyUint64S != nil {
		s = append(s, "MyUint64S: "+fmt.Sprintf("%#v", this.MyUint64S)+",\n")
	}
	keysForMyMap := make([]string, 0, len(this.MyMap))
	for k := range this.MyMap {
		keysForMyMap = append(keysForMyMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMyMap)
	mapStringForMyMap := "github_com_gogo_protobuf_test_casttype.MyMapType{"
	for _, k := range keysForMyMap {
		mapStringForMyMap += fmt.Sprintf("%#v: %#v,", k, this.MyMap[k])
	}
	mapStringForMyMap += "}"
	if this.MyMap != nil {
		s = append(s, "MyMap: "+mapStringForMyMap+",\n")
	}
	keysForMyCustomMap := make([]string, 0, len(this.MyCustomMap))
	for k := range this.MyCustomMap {
		keysForMyCustomMap = append(keysForMyCustomMap, string(k))
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMyCustomMap)
	mapStringForMyCustomMap := "map[github_com_gogo_protobuf_test_casttype.MyStringType]github_com_gogo_protobuf_test_casttype.MyUint64Type{"
	for _, k := range keysForMyCustomMap {
		mapStringForMyCustomMap += fmt.Sprintf("%#v: %#v,", k, this.MyCustomMap[github_com_gogo_protobuf_test_casttype.MyStringType(k)])
	}
	mapStringForMyCustomMap += "}"
	if this.MyCustomMap != nil {
		s = append(s, "MyCustomMap: "+mapStringForMyCustomMap+",\n")
	}
	keysForMyNullableMap := make([]int32, 0, len(this.MyNullableMap))
	for k := range this.MyNullableMap {
		keysForMyNullableMap = append(keysForMyNullableMap, int32(k))
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForMyNullableMap)
	mapStringForMyNullableMap := "map[github_com_gogo_protobuf_test_casttype.MyInt32Type]*Wilson{"
	for _, k := range keysForMyNullableMap {
		mapStringForMyNullableMap += fmt.Sprintf("%#v: %#v,", k, this.MyNullableMap[github_com_gogo_protobuf_test_casttype.MyInt32Type(k)])
	}
	mapStringForMyNullableMap += "}"
	if this.MyNullableMap != nil {
		s = append(s, "MyNullableMap: "+mapStringForMyNullableMap+",\n")
	}
	keysForMyEmbeddedMap := make([]int32, 0, len(this.MyEmbeddedMap))
	for k := range this.MyEmbeddedMap {
		keysForMyEmbeddedMap = append(keysForMyEmbeddedMap, int32(k))
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForMyEmbeddedMap)
	mapStringForMyEmbeddedMap := "map[github_com_gogo_protobuf_test_casttype.MyInt32Type]Wilson{"
	for _, k := range keysForMyEmbeddedMap {
		mapStringForMyEmbeddedMap += fmt.Sprintf("%#v: %#v,", k, this.MyEmbeddedMap[github_com_gogo_protobuf_test_casttype.MyInt32Type(k)])
	}
	mapStringForMyEmbeddedMap += "}"
	if this.MyEmbeddedMap != nil {
		s = append(s, "MyEmbeddedMap: "+mapStringForMyEmbeddedMap+",\n")
	}
	if this.String_ != nil {
		s = append(s, "String_: "+valueToGoStringCasttype(this.String_, "github_com_gogo_protobuf_test_casttype.MyStringType")+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Wilson) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&casttype.Wilson{")
	if this.Int64 != nil {
		s = append(s, "Int64: "+valueToGoStringCasttype(this.Int64, "int64")+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringCasttype(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Castaway) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *Castaway) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.String_ != nil {
		i -= len(*m.String_)
		copy(dAtA[i:], *m.String_)
		i = encodeVarintCasttype(dAtA, i, uint64(len(*m.String_)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if len(m.MyEmbeddedMap) > 0 {
		for k := range m.MyEmbeddedMap {
			v := m.MyEmbeddedMap[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCasttype(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintCasttype(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintCasttype(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.MyNullableMap) > 0 {
		for k := range m.MyNullableMap {
			v := m.MyNullableMap[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintCasttype(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintCasttype(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintCasttype(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.MyCustomMap) > 0 {
		for k := range m.MyCustomMap {
			v := m.MyCustomMap[k]
			baseI := i
			i = encodeVarintCasttype(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintCasttype(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintCasttype(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.MyMap) > 0 {
		for k := range m.MyMap {
			v := m.MyMap[k]
			baseI := i
			i = encodeVarintCasttype(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintCasttype(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintCasttype(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.MyUint64S) > 0 {
		for iNdEx := len(m.MyUint64S) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintCasttype(dAtA, i, uint64(m.MyUint64S[iNdEx]))
			i--
			dAtA[i] = 0x58
		}
	}
	if m.NormalBytes != nil {
		i -= len(m.NormalBytes)
		copy(dAtA[i:], m.NormalBytes)
		i = encodeVarintCasttype(dAtA, i, uint64(len(m.NormalBytes)))
		i--
		dAtA[i] = 0x52
	}
	if m.MyBytes != nil {
		i -= len(m.MyBytes)
		copy(dAtA[i:], m.MyBytes)
		i = encodeVarintCasttype(dAtA, i, uint64(len(m.MyBytes)))
		i--
		dAtA[i] = 0x4a
	}
	i -= 8
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.MyFloat64))))
	i--
	dAtA[i] = 0x41
	if m.MyFloat64Ptr != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.MyFloat64Ptr))))
		i--
		dAtA[i] = 0x39
	}
	i -= 4
	encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.MyFloat32))))
	i--
	dAtA[i] = 0x35
	if m.MyFloat32Ptr != nil {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.MyFloat32Ptr))))
		i--
		dAtA[i] = 0x2d
	}
	i = encodeVarintCasttype(dAtA, i, uint64(m.MyUint64))
	i--
	dAtA[i] = 0x20
	if m.MyUint64Ptr != nil {
		i = encodeVarintCasttype(dAtA, i, uint64(*m.MyUint64Ptr))
		i--
		dAtA[i] = 0x18
	}
	i = encodeVarintCasttype(dAtA, i, uint64(m.Int32))
	i--
	dAtA[i] = 0x10
	if m.Int32Ptr != nil {
		i = encodeVarintCasttype(dAtA, i, uint64(*m.Int32Ptr))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Wilson) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Int64 != nil {
		i = encodeVarintCasttype(dAtA, i, uint64(*m.Int64))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintCasttype(dAtA []byte, offset int, v uint64) int {
	offset -= sovCasttype(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedCastaway(r randyCasttype, easy bool) *Castaway {
	this := &Castaway{}
	if r.Intn(5) != 0 {
		v1 := int32(r.Int63())
		if r.Intn(2) == 0 {
			v1 *= -1
		}
		this.Int32Ptr = &v1
	}
	this.Int32 = int32(r.Int63())
	if r.Intn(2) == 0 {
		this.Int32 *= -1
	}
	if r.Intn(5) != 0 {
		v2 := github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32()))
		this.MyUint64Ptr = &v2
	}
	this.MyUint64 = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32()))
	if r.Intn(5) != 0 {
		v3 := github_com_gogo_protobuf_test_casttype.MyFloat32Type(r.Float32())
		if r.Intn(2) == 0 {
			v3 *= -1
		}
		this.MyFloat32Ptr = &v3
	}
	this.MyFloat32 = github_com_gogo_protobuf_test_casttype.MyFloat32Type(r.Float32())
	if r.Intn(2) == 0 {
		this.MyFloat32 *= -1
	}
	if r.Intn(5) != 0 {
		v4 := github_com_gogo_protobuf_test_casttype.MyFloat64Type(r.Float64())
		if r.Intn(2) == 0 {
			v4 *= -1
		}
		this.MyFloat64Ptr = &v4
	}
	this.MyFloat64 = github_com_gogo_protobuf_test_casttype.MyFloat64Type(r.Float64())
	if r.Intn(2) == 0 {
		this.MyFloat64 *= -1
	}
	if r.Intn(5) != 0 {
		v5 := r.Intn(100)
		this.MyBytes = make(github_com_gogo_protobuf_test_casttype.Bytes, v5)
		for i := 0; i < v5; i++ {
			this.MyBytes[i] = byte(r.Intn(256))
		}
	}
	if r.Intn(5) != 0 {
		v6 := r.Intn(100)
		this.NormalBytes = make([]byte, v6)
		for i := 0; i < v6; i++ {
			this.NormalBytes[i] = byte(r.Intn(256))
		}
	}
	if r.Intn(5) != 0 {
		v7 := r.Intn(10)
		this.MyUint64S = make([]github_com_gogo_protobuf_test_casttype.MyUint64Type, v7)
		for i := 0; i < v7; i++ {
			this.MyUint64S[i] = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32()))
		}
	}
	if r.Intn(5) != 0 {
		v8 := r.Intn(10)
		this.MyMap = make(github_com_gogo_protobuf_test_casttype.MyMapType)
		for i := 0; i < v8; i++ {
			v9 := randStringCasttype(r)
			this.MyMap[v9] = uint64(uint64(r.Uint32()))
		}
	}
	if r.Intn(5) != 0 {
		v10 := r.Intn(10)
		this.MyCustomMap = make(map[github_com_gogo_protobuf_test_casttype.MyStringType]github_com_gogo_protobuf_test_casttype.MyUint64Type)
		for i := 0; i < v10; i++ {
			v11 := github_com_gogo_protobuf_test_casttype.MyStringType(randStringCasttype(r))
			this.MyCustomMap[v11] = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32()))
		}
	}
	if r.Intn(5) != 0 {
		v12 := r.Intn(10)
		this.MyNullableMap = make(map[github_com_gogo_protobuf_test_casttype.MyInt32Type]*Wilson)
		for i := 0; i < v12; i++ {
			this.MyNullableMap[github_com_gogo_protobuf_test_casttype.MyInt32Type(int32(r.Int31()))] = NewPopulatedWilson(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v13 := r.Intn(10)
		this.MyEmbeddedMap = make(map[github_com_gogo_protobuf_test_casttype.MyInt32Type]Wilson)
		for i := 0; i < v13; i++ {
			this.MyEmbeddedMap[github_com_gogo_protobuf_test_casttype.MyInt32Type(int32(r.Int31()))] = *NewPopulatedWilson(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v14 := github_com_gogo_protobuf_test_casttype.MyStringType(randStringCasttype(r))
		this.String_ = &v14
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedCasttype(r, 17)
	}
	return this
}

func NewPopulatedWilson(r randyCasttype, easy bool) *Wilson {
	this := &Wilson{}
	if r.Intn(5) != 0 {
		v15 := int64(r.Int63())
		if r.Intn(2) == 0 {
			v15 *= -1
		}
		this.Int64 = &v15
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedCasttype(r, 2)
	}
	return this
}

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

func randUTF8RuneCasttype(r randyCasttype) 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 randStringCasttype(r randyCasttype) string {
	v16 := r.Intn(100)
	tmps := make([]rune, v16)
	for i := 0; i < v16; i++ {
		tmps[i] = randUTF8RuneCasttype(r)
	}
	return string(tmps)
}
func randUnrecognizedCasttype(r randyCasttype, 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 = randFieldCasttype(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldCasttype(dAtA []byte, r randyCasttype, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateCasttype(dAtA, uint64(key))
		v17 := r.Int63()
		if r.Intn(2) == 0 {
			v17 *= -1
		}
		dAtA = encodeVarintPopulateCasttype(dAtA, uint64(v17))
	case 1:
		dAtA = encodeVarintPopulateCasttype(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 = encodeVarintPopulateCasttype(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateCasttype(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateCasttype(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 encodeVarintPopulateCasttype(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Castaway) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Int32Ptr != nil {
		n += 1 + sovCasttype(uint64(*m.Int32Ptr))
	}
	n += 1 + sovCasttype(uint64(m.Int32))
	if m.MyUint64Ptr != nil {
		n += 1 + sovCasttype(uint64(*m.MyUint64Ptr))
	}
	n += 1 + sovCasttype(uint64(m.MyUint64))
	if m.MyFloat32Ptr != nil {
		n += 5
	}
	n += 5
	if m.MyFloat64Ptr != nil {
		n += 9
	}
	n += 9
	if m.MyBytes != nil {
		l = len(m.MyBytes)
		n += 1 + l + sovCasttype(uint64(l))
	}
	if m.NormalBytes != nil {
		l = len(m.NormalBytes)
		n += 1 + l + sovCasttype(uint64(l))
	}
	if len(m.MyUint64S) > 0 {
		for _, e := range m.MyUint64S {
			n += 1 + sovCasttype(uint64(e))
		}
	}
	if len(m.MyMap) > 0 {
		for k, v := range m.MyMap {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovCasttype(uint64(len(k))) + 1 + sovCasttype(uint64(v))
			n += mapEntrySize + 1 + sovCasttype(uint64(mapEntrySize))
		}
	}
	if len(m.MyCustomMap) > 0 {
		for k, v := range m.MyCustomMap {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovCasttype(uint64(len(k))) + 1 + sovCasttype(uint64(v))
			n += mapEntrySize + 1 + sovCasttype(uint64(mapEntrySize))
		}
	}
	if len(m.MyNullableMap) > 0 {
		for k, v := range m.MyNullableMap {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovCasttype(uint64(l))
			}
			mapEntrySize := 1 + sovCasttype(uint64(k)) + l
			n += mapEntrySize + 1 + sovCasttype(uint64(mapEntrySize))
		}
	}
	if len(m.MyEmbeddedMap) > 0 {
		for k, v := range m.MyEmbeddedMap {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovCasttype(uint64(k)) + 1 + l + sovCasttype(uint64(l))
			n += mapEntrySize + 1 + sovCasttype(uint64(mapEntrySize))
		}
	}
	if m.String_ != nil {
		l = len(*m.String_)
		n += 2 + l + sovCasttype(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Wilson) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Int64 != nil {
		n += 1 + sovCasttype(uint64(*m.Int64))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovCasttype(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCasttype(x uint64) (n int) {
	return sovCasttype(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Castaway) String() string {
	if this == nil {
		return "nil"
	}
	keysForMyMap := make([]string, 0, len(this.MyMap))
	for k := range this.MyMap {
		keysForMyMap = append(keysForMyMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMyMap)
	mapStringForMyMap := "github_com_gogo_protobuf_test_casttype.MyMapType{"
	for _, k := range keysForMyMap {
		mapStringForMyMap += fmt.Sprintf("%v: %v,", k, this.MyMap[k])
	}
	mapStringForMyMap += "}"
	keysForMyCustomMap := make([]string, 0, len(this.MyCustomMap))
	for k := range this.MyCustomMap {
		keysForMyCustomMap = append(keysForMyCustomMap, string(k))
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMyCustomMap)
	mapStringForMyCustomMap := "map[github_com_gogo_protobuf_test_casttype.MyStringType]github_com_gogo_protobuf_test_casttype.MyUint64Type{"
	for _, k := range keysForMyCustomMap {
		mapStringForMyCustomMap += fmt.Sprintf("%v: %v,", k, this.MyCustomMap[github_com_gogo_protobuf_test_casttype.MyStringType(k)])
	}
	mapStringForMyCustomMap += "}"
	keysForMyNullableMap := make([]int32, 0, len(this.MyNullableMap))
	for k := range this.MyNullableMap {
		keysForMyNullableMap = append(keysForMyNullableMap, int32(k))
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForMyNullableMap)
	mapStringForMyNullableMap := "map[github_com_gogo_protobuf_test_casttype.MyInt32Type]*Wilson{"
	for _, k := range keysForMyNullableMap {
		mapStringForMyNullableMap += fmt.Sprintf("%v: %v,", k, this.MyNullableMap[github_com_gogo_protobuf_test_casttype.MyInt32Type(k)])
	}
	mapStringForMyNullableMap += "}"
	keysForMyEmbeddedMap := make([]int32, 0, len(this.MyEmbeddedMap))
	for k := range this.MyEmbeddedMap {
		keysForMyEmbeddedMap = append(keysForMyEmbeddedMap, int32(k))
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForMyEmbeddedMap)
	mapStringForMyEmbeddedMap := "map[github_com_gogo_protobuf_test_casttype.MyInt32Type]Wilson{"
	for _, k := range keysForMyEmbeddedMap {
		mapStringForMyEmbeddedMap += fmt.Sprintf("%v: %v,", k, this.MyEmbeddedMap[github_com_gogo_protobuf_test_casttype.MyInt32Type(k)])
	}
	mapStringForMyEmbeddedMap += "}"
	s := strings.Join([]string{`&Castaway{`,
		`Int32Ptr:` + valueToStringCasttype(this.Int32Ptr) + `,`,
		`Int32:` + fmt.Sprintf("%v", this.Int32) + `,`,
		`MyUint64Ptr:` + valueToStringCasttype(this.MyUint64Ptr) + `,`,
		`MyUint64:` + fmt.Sprintf("%v", this.MyUint64) + `,`,
		`MyFloat32Ptr:` + valueToStringCasttype(this.MyFloat32Ptr) + `,`,
		`MyFloat32:` + fmt.Sprintf("%v", this.MyFloat32) + `,`,
		`MyFloat64Ptr:` + valueToStringCasttype(this.MyFloat64Ptr) + `,`,
		`MyFloat64:` + fmt.Sprintf("%v", this.MyFloat64) + `,`,
		`MyBytes:` + valueToStringCasttype(this.MyBytes) + `,`,
		`NormalBytes:` + valueToStringCasttype(this.NormalBytes) + `,`,
		`MyUint64S:` + fmt.Sprintf("%v", this.MyUint64S) + `,`,
		`MyMap:` + mapStringForMyMap + `,`,
		`MyCustomMap:` + mapStringForMyCustomMap + `,`,
		`MyNullableMap:` + mapStringForMyNullableMap + `,`,
		`MyEmbeddedMap:` + mapStringForMyEmbeddedMap + `,`,
		`String_:` + valueToStringCasttype(this.String_) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Wilson) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Wilson{`,
		`Int64:` + valueToStringCasttype(this.Int64) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringCasttype(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Castaway) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCasttype
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Castaway: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Castaway: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int32Ptr", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Int32Ptr = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType)
			}
			m.Int32 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Int32 |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyUint64Ptr", wireType)
			}
			var v github_com_gogo_protobuf_test_casttype.MyUint64Type
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= github_com_gogo_protobuf_test_casttype.MyUint64Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MyUint64Ptr = &v
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyUint64", wireType)
			}
			m.MyUint64 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MyUint64 |= github_com_gogo_protobuf_test_casttype.MyUint64Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyFloat32Ptr", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			v2 := github_com_gogo_protobuf_test_casttype.MyFloat32Type(math.Float32frombits(v))
			m.MyFloat32Ptr = &v2
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyFloat32", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.MyFloat32 = github_com_gogo_protobuf_test_casttype.MyFloat32Type(math.Float32frombits(v))
		case 7:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyFloat64Ptr", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := github_com_gogo_protobuf_test_casttype.MyFloat64Type(math.Float64frombits(v))
			m.MyFloat64Ptr = &v2
		case 8:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyFloat64", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.MyFloat64 = github_com_gogo_protobuf_test_casttype.MyFloat64Type(math.Float64frombits(v))
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyBytes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCasttype
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCasttype
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MyBytes = append(m.MyBytes[:0], dAtA[iNdEx:postIndex]...)
			if m.MyBytes == nil {
				m.MyBytes = []byte{}
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NormalBytes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCasttype
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCasttype
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NormalBytes = append(m.NormalBytes[:0], dAtA[iNdEx:postIndex]...)
			if m.NormalBytes == nil {
				m.NormalBytes = []byte{}
			}
			iNdEx = postIndex
		case 11:
			if wireType == 0 {
				var v github_com_gogo_protobuf_test_casttype.MyUint64Type
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowCasttype
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= github_com_gogo_protobuf_test_casttype.MyUint64Type(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MyUint64S = append(m.MyUint64S, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowCasttype
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthCasttype
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthCasttype
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.MyUint64S) == 0 {
					m.MyUint64S = make([]github_com_gogo_protobuf_test_casttype.MyUint64Type, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v github_com_gogo_protobuf_test_casttype.MyUint64Type
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCasttype
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= github_com_gogo_protobuf_test_casttype.MyUint64Type(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MyUint64S = append(m.MyUint64S, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MyUint64S", wireType)
			}
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCasttype
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCasttype
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MyMap == nil {
				m.MyMap = make(github_com_gogo_protobuf_test_casttype.MyMapType)
			}
			var mapkey string
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowCasttype
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCasttype
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthCasttype
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthCasttype
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCasttype
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipCasttype(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthCasttype
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MyMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyCustomMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCasttype
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCasttype
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MyCustomMap == nil {
				m.MyCustomMap = make(map[github_com_gogo_protobuf_test_casttype.MyStringType]github_com_gogo_protobuf_test_casttype.MyUint64Type)
			}
			var mapkey github_com_gogo_protobuf_test_casttype.MyStringType
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowCasttype
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCasttype
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthCasttype
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthCasttype
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = github_com_gogo_protobuf_test_casttype.MyStringType(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCasttype
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipCasttype(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthCasttype
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MyCustomMap[github_com_gogo_protobuf_test_casttype.MyStringType(mapkey)] = ((github_com_gogo_protobuf_test_casttype.MyUint64Type)(mapvalue))
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyNullableMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCasttype
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCasttype
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MyNullableMap == nil {
				m.MyNullableMap = make(map[github_com_gogo_protobuf_test_casttype.MyInt32Type]*Wilson)
			}
			var mapkey int32
			var mapvalue *Wilson
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowCasttype
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCasttype
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCasttype
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthCasttype
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthCasttype
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &Wilson{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipCasttype(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthCasttype
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MyNullableMap[github_com_gogo_protobuf_test_casttype.MyInt32Type(mapkey)] = mapvalue
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyEmbeddedMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCasttype
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCasttype
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MyEmbeddedMap == nil {
				m.MyEmbeddedMap = make(map[github_com_gogo_protobuf_test_casttype.MyInt32Type]Wilson)
			}
			var mapkey int32
			mapvalue := &Wilson{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowCasttype
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCasttype
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCasttype
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthCasttype
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthCasttype
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &Wilson{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipCasttype(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthCasttype
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MyEmbeddedMap[github_com_gogo_protobuf_test_casttype.MyInt32Type(mapkey)] = *mapvalue
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field String_", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthCasttype
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCasttype
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := github_com_gogo_protobuf_test_casttype.MyStringType(dAtA[iNdEx:postIndex])
			m.String_ = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCasttype(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCasttype
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Wilson) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCasttype
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Wilson: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Wilson: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCasttype
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Int64 = &v
		default:
			iNdEx = preIndex
			skippy, err := skipCasttype(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCasttype
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthCasttype        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCasttype          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupCasttype = fmt.Errorf("proto: unexpected end of group")
)