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

// StartID=1000;

package protomsg

import (
	driver "database/sql/driver"
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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 DataType int32

const (
	DataType_Type_None     DataType = 0
	DataType_Type_int8     DataType = 1
	DataType_Type_int16    DataType = 2
	DataType_Type_int32    DataType = 3
	DataType_Type_int64    DataType = 4
	DataType_Type_uint8    DataType = 5
	DataType_Type_uint16   DataType = 6
	DataType_Type_uint32   DataType = 7
	DataType_Type_uint64   DataType = 8
	DataType_Type_float32  DataType = 9
	DataType_Type_float64  DataType = 10
	DataType_Type_bool     DataType = 11
	DataType_Type_string   DataType = 12
	DataType_Type_protoMsg DataType = 13
)

var DataType_name = map[int32]string{
	0:  "Type_None",
	1:  "Type_int8",
	2:  "Type_int16",
	3:  "Type_int32",
	4:  "Type_int64",
	5:  "Type_uint8",
	6:  "Type_uint16",
	7:  "Type_uint32",
	8:  "Type_uint64",
	9:  "Type_float32",
	10: "Type_float64",
	11: "Type_bool",
	12: "Type_string",
	13: "Type_protoMsg",
}

var DataType_value = map[string]int32{
	"Type_None":     0,
	"Type_int8":     1,
	"Type_int16":    2,
	"Type_int32":    3,
	"Type_int64":    4,
	"Type_uint8":    5,
	"Type_uint16":   6,
	"Type_uint32":   7,
	"Type_uint64":   8,
	"Type_float32":  9,
	"Type_float64":  10,
	"Type_bool":     11,
	"Type_string":   12,
	"Type_protoMsg": 13,
}

func (x DataType) String() string {
	return proto.EnumName(DataType_name, int32(x))
}

func (DataType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_db1b6b0986796150, []int{0}
}

// 坐标三唯
type Vector3 struct {
	// 长
	X float64 `protobuf:"fixed64,1,opt,name=x,proto3" json:"x,omitempty"`
	// 高
	Y float64 `protobuf:"fixed64,2,opt,name=y,proto3" json:"y,omitempty"`
	// 宽
	Z float64 `protobuf:"fixed64,3,opt,name=z,proto3" json:"z,omitempty"`
}

func (m *Vector3) Reset() {
	*m = Vector3{}
}
func (m *Vector3) String() string { return proto.CompactTextString(m) }
func (*Vector3) ProtoMessage()    {}
func (*Vector3) Descriptor() ([]byte, []int) {
	return fileDescriptor_db1b6b0986796150, []int{0}
}
func (m *Vector3) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Vector3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Vector3.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 *Vector3) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Vector3.Merge(m, src)
}
func (m *Vector3) XXX_Size() int {
	return m.Size()
}
func (m *Vector3) XXX_DiscardUnknown() {
	xxx_messageInfo_Vector3.DiscardUnknown(m)
}

var xxx_messageInfo_Vector3 proto.InternalMessageInfo

func (m *Vector3) GetX() float64 {
	if m != nil {
		return m.X
	}
	return 0
}

func (m *Vector3) GetY() float64 {
	if m != nil {
		return m.Y
	}
	return 0
}

func (m *Vector3) GetZ() float64 {
	if m != nil {
		return m.Z
	}
	return 0
}

func (*Vector3) XXX_MessageName() string {
	return "protomsg.Vector3"
}
func (*Vector3) Name() string {
	return "Vector3"
}
func (m *Vector3) Scan(value interface{}) error {
	m.Reset()
	if value == nil {
		return nil
	} else if bli, ok := value.([]byte); ok {
		return m.Unmarshal(bli)
	}
	return io.ErrUnexpectedEOF
}
func (m Vector3) Value() (driver.Value, error) {
	return m.Marshal()
}

// 坐标二唯
type Vector2 struct {
	// 长
	X float64 `protobuf:"fixed64,1,opt,name=x,proto3" json:"x,omitempty"`
	// 宽
	Y float64 `protobuf:"fixed64,2,opt,name=y,proto3" json:"y,omitempty"`
}

func (m *Vector2) Reset() {
	*m = Vector2{}
}
func (m *Vector2) String() string { return proto.CompactTextString(m) }
func (*Vector2) ProtoMessage()    {}
func (*Vector2) Descriptor() ([]byte, []int) {
	return fileDescriptor_db1b6b0986796150, []int{1}
}
func (m *Vector2) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Vector2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Vector2.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 *Vector2) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Vector2.Merge(m, src)
}
func (m *Vector2) XXX_Size() int {
	return m.Size()
}
func (m *Vector2) XXX_DiscardUnknown() {
	xxx_messageInfo_Vector2.DiscardUnknown(m)
}

var xxx_messageInfo_Vector2 proto.InternalMessageInfo

func (m *Vector2) GetX() float64 {
	if m != nil {
		return m.X
	}
	return 0
}

func (m *Vector2) GetY() float64 {
	if m != nil {
		return m.Y
	}
	return 0
}

func (*Vector2) XXX_MessageName() string {
	return "protomsg.Vector2"
}
func (*Vector2) Name() string {
	return "Vector2"
}

// 同步基础结构
type SyncProp struct {
	// 属性索引ID
	Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	// 属性值
	//
	// Types that are valid to be assigned to PropValue:
	//
	//	*SyncProp_Int32Value
	//	*SyncProp_Uint32Value
	//	*SyncProp_Int64Value
	//	*SyncProp_Uint64Value
	//	*SyncProp_FloatValue
	//	*SyncProp_DoubleValue
	//	*SyncProp_StringValue
	//	*SyncProp_BoolValue
	//	*SyncProp_Msg_Value
	PropValue isSyncProp_PropValue `protobuf_oneof:"PropValue"`
}

func (m *SyncProp) Reset() {
	*m = SyncProp{}
}
func (m *SyncProp) String() string { return proto.CompactTextString(m) }
func (*SyncProp) ProtoMessage()    {}
func (*SyncProp) Descriptor() ([]byte, []int) {
	return fileDescriptor_db1b6b0986796150, []int{2}
}
func (m *SyncProp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SyncProp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SyncProp.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 *SyncProp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SyncProp.Merge(m, src)
}
func (m *SyncProp) XXX_Size() int {
	return m.Size()
}
func (m *SyncProp) XXX_DiscardUnknown() {
	xxx_messageInfo_SyncProp.DiscardUnknown(m)
}

var xxx_messageInfo_SyncProp proto.InternalMessageInfo

type isSyncProp_PropValue interface {
	isSyncProp_PropValue()
	MarshalTo([]byte) (int, error)
	Size() int
}

type SyncProp_Int32Value struct {
	Int32Value int32 `protobuf:"varint,2,opt,name=int32_value,json=int32Value,proto3,oneof" json:"int32_value,omitempty"`
}
type SyncProp_Uint32Value struct {
	Uint32Value uint32 `protobuf:"varint,3,opt,name=uint32_value,json=uint32Value,proto3,oneof" json:"uint32_value,omitempty"`
}
type SyncProp_Int64Value struct {
	Int64Value int64 `protobuf:"varint,4,opt,name=int64_value,json=int64Value,proto3,oneof" json:"int64_value,omitempty"`
}
type SyncProp_Uint64Value struct {
	Uint64Value uint64 `protobuf:"varint,5,opt,name=uint64_value,json=uint64Value,proto3,oneof" json:"uint64_value,omitempty"`
}
type SyncProp_FloatValue struct {
	FloatValue float32 `protobuf:"fixed32,6,opt,name=float_value,json=floatValue,proto3,oneof" json:"float_value,omitempty"`
}
type SyncProp_DoubleValue struct {
	DoubleValue float64 `protobuf:"fixed64,7,opt,name=double_value,json=doubleValue,proto3,oneof" json:"double_value,omitempty"`
}
type SyncProp_StringValue struct {
	StringValue string `protobuf:"bytes,8,opt,name=string_value,json=stringValue,proto3,oneof" json:"string_value,omitempty"`
}
type SyncProp_BoolValue struct {
	BoolValue bool `protobuf:"varint,9,opt,name=bool_value,json=boolValue,proto3,oneof" json:"bool_value,omitempty"`
}
type SyncProp_Msg_Value struct {
	Msg_Value []byte `protobuf:"bytes,10,opt,name=Msg_Value,json=MsgValue,proto3,oneof" json:"Msg_Value,omitempty"`
}

func (*SyncProp_Int32Value) isSyncProp_PropValue()  {}
func (*SyncProp_Uint32Value) isSyncProp_PropValue() {}
func (*SyncProp_Int64Value) isSyncProp_PropValue()  {}
func (*SyncProp_Uint64Value) isSyncProp_PropValue() {}
func (*SyncProp_FloatValue) isSyncProp_PropValue()  {}
func (*SyncProp_DoubleValue) isSyncProp_PropValue() {}
func (*SyncProp_StringValue) isSyncProp_PropValue() {}
func (*SyncProp_BoolValue) isSyncProp_PropValue()   {}
func (*SyncProp_Msg_Value) isSyncProp_PropValue()   {}

func (m *SyncProp) GetPropValue() isSyncProp_PropValue {
	if m != nil {
		return m.PropValue
	}
	return nil
}

func (m *SyncProp) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *SyncProp) GetInt32Value() int32 {
	if x, ok := m.GetPropValue().(*SyncProp_Int32Value); ok {
		return x.Int32Value
	}
	return 0
}

func (m *SyncProp) GetUint32Value() uint32 {
	if x, ok := m.GetPropValue().(*SyncProp_Uint32Value); ok {
		return x.Uint32Value
	}
	return 0
}

func (m *SyncProp) GetInt64Value() int64 {
	if x, ok := m.GetPropValue().(*SyncProp_Int64Value); ok {
		return x.Int64Value
	}
	return 0
}

func (m *SyncProp) GetUint64Value() uint64 {
	if x, ok := m.GetPropValue().(*SyncProp_Uint64Value); ok {
		return x.Uint64Value
	}
	return 0
}

func (m *SyncProp) GetFloatValue() float32 {
	if x, ok := m.GetPropValue().(*SyncProp_FloatValue); ok {
		return x.FloatValue
	}
	return 0
}

func (m *SyncProp) GetDoubleValue() float64 {
	if x, ok := m.GetPropValue().(*SyncProp_DoubleValue); ok {
		return x.DoubleValue
	}
	return 0
}

func (m *SyncProp) GetStringValue() string {
	if x, ok := m.GetPropValue().(*SyncProp_StringValue); ok {
		return x.StringValue
	}
	return ""
}

func (m *SyncProp) GetBoolValue() bool {
	if x, ok := m.GetPropValue().(*SyncProp_BoolValue); ok {
		return x.BoolValue
	}
	return false
}

func (m *SyncProp) GetMsg_Value() []byte {
	if x, ok := m.GetPropValue().(*SyncProp_Msg_Value); ok {
		return x.Msg_Value
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SyncProp) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SyncProp_Int32Value)(nil),
		(*SyncProp_Uint32Value)(nil),
		(*SyncProp_Int64Value)(nil),
		(*SyncProp_Uint64Value)(nil),
		(*SyncProp_FloatValue)(nil),
		(*SyncProp_DoubleValue)(nil),
		(*SyncProp_StringValue)(nil),
		(*SyncProp_BoolValue)(nil),
		(*SyncProp_Msg_Value)(nil),
	}
}

func (*SyncProp) XXX_MessageName() string {
	return "protomsg.SyncProp"
}
func (*SyncProp) Name() string {
	return "SyncProp"
}

// 同步属性列表通过RPCEntityRet发给客户端，客户端就知道是谁的属性变化
type SyncEntityProps struct {
	// 对象UID
	EntityID uint64 `protobuf:"varint,1,opt,name=entityID,proto3" json:"entityID,omitempty"`
	// 对象类型
	EntityType string `protobuf:"bytes,2,opt,name=entityType,proto3" json:"entityType,omitempty"`
	// 需要同步的属性列表
	Props []*SyncProp `protobuf:"bytes,3,rep,name=Props,proto3" json:"Props,omitempty"`
}

func (m *SyncEntityProps) Reset() {
	*m = SyncEntityProps{}
	m.Props = make([]*SyncProp, 0, 10)
}
func (m *SyncEntityProps) String() string { return proto.CompactTextString(m) }
func (*SyncEntityProps) ProtoMessage()    {}
func (*SyncEntityProps) Descriptor() ([]byte, []int) {
	return fileDescriptor_db1b6b0986796150, []int{3}
}
func (m *SyncEntityProps) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SyncEntityProps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SyncEntityProps.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 *SyncEntityProps) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SyncEntityProps.Merge(m, src)
}
func (m *SyncEntityProps) XXX_Size() int {
	return m.Size()
}
func (m *SyncEntityProps) XXX_DiscardUnknown() {
	xxx_messageInfo_SyncEntityProps.DiscardUnknown(m)
}

var xxx_messageInfo_SyncEntityProps proto.InternalMessageInfo

func (m *SyncEntityProps) GetEntityID() uint64 {
	if m != nil {
		return m.EntityID
	}
	return 0
}

func (m *SyncEntityProps) GetEntityType() string {
	if m != nil {
		return m.EntityType
	}
	return ""
}

func (m *SyncEntityProps) GetProps() []*SyncProp {
	if m != nil {
		return m.Props
	}
	return nil
}

func (*SyncEntityProps) XXX_MessageName() string {
	return "protomsg.SyncEntityProps"
}
func (*SyncEntityProps) Name() string {
	return "SyncEntityProps"
}

// CodeRet 回复信息
type CodeRet struct {
	// 错误码 0表示没有错
	Code int64 `protobuf:"varint,1,opt,name=Code,proto3" json:"Code,omitempty"`
	// 错误对应的提示文本
	CodeMessage string `protobuf:"bytes,2,opt,name=CodeMessage,proto3" json:"CodeMessage,omitempty"`
}

func (m *CodeRet) Reset() {
	*m = CodeRet{}
}
func (m *CodeRet) String() string { return proto.CompactTextString(m) }
func (*CodeRet) ProtoMessage()    {}
func (*CodeRet) Descriptor() ([]byte, []int) {
	return fileDescriptor_db1b6b0986796150, []int{4}
}
func (m *CodeRet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CodeRet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CodeRet.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 *CodeRet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CodeRet.Merge(m, src)
}
func (m *CodeRet) XXX_Size() int {
	return m.Size()
}
func (m *CodeRet) XXX_DiscardUnknown() {
	xxx_messageInfo_CodeRet.DiscardUnknown(m)
}

var xxx_messageInfo_CodeRet proto.InternalMessageInfo

func (m *CodeRet) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *CodeRet) GetCodeMessage() string {
	if m != nil {
		return m.CodeMessage
	}
	return ""
}

func (*CodeRet) XXX_MessageName() string {
	return "protomsg.CodeRet"
}
func (*CodeRet) Name() string {
	return "CodeRet"
}

// 基础仓库数据
type BaseData struct {
	// 数据
	Data map[int64]int64 `protobuf:"bytes,1,rep,name=Data,proto3" json:"Data,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
}

func (m *BaseData) Reset() {
	*m = BaseData{}
	m.Data = make(map[int64]int64)
}
func (m *BaseData) String() string { return proto.CompactTextString(m) }
func (*BaseData) ProtoMessage()    {}
func (*BaseData) Descriptor() ([]byte, []int) {
	return fileDescriptor_db1b6b0986796150, []int{5}
}
func (m *BaseData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BaseData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BaseData.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 *BaseData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BaseData.Merge(m, src)
}
func (m *BaseData) XXX_Size() int {
	return m.Size()
}
func (m *BaseData) XXX_DiscardUnknown() {
	xxx_messageInfo_BaseData.DiscardUnknown(m)
}

var xxx_messageInfo_BaseData proto.InternalMessageInfo

func (m *BaseData) GetData() map[int64]int64 {
	if m != nil {
		return m.Data
	}
	return nil
}

func (*BaseData) XXX_MessageName() string {
	return "protomsg.BaseData"
}
func (*BaseData) Name() string {
	return "BaseData"
}
func (m *BaseData) Scan(value interface{}) error {
	m.Reset()
	if value == nil {
		return nil
	} else if bli, ok := value.([]byte); ok {
		return m.Unmarshal(bli)
	}
	return io.ErrUnexpectedEOF
}
func (m BaseData) Value() (driver.Value, error) {
	return m.Marshal()
}

// 二进制数据
type BaseBinary struct {
	// 一个数据占多少个位，只能是1，2，4，8
	OneDataBitNum int32 `protobuf:"varint,1,opt,name=OneDataBitNum,proto3" json:"OneDataBitNum,omitempty"`
	// 数组的长度
	ArrayLen int32 `protobuf:"varint,2,opt,name=ArrayLen,proto3" json:"ArrayLen,omitempty"`
	// 放数据的数组
	Data []byte `protobuf:"bytes,3,opt,name=Data,proto3" json:"Data,omitempty"`
}

func (m *BaseBinary) Reset() {
	*m = BaseBinary{}
}
func (m *BaseBinary) String() string { return proto.CompactTextString(m) }
func (*BaseBinary) ProtoMessage()    {}
func (*BaseBinary) Descriptor() ([]byte, []int) {
	return fileDescriptor_db1b6b0986796150, []int{6}
}
func (m *BaseBinary) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BaseBinary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BaseBinary.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 *BaseBinary) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BaseBinary.Merge(m, src)
}
func (m *BaseBinary) XXX_Size() int {
	return m.Size()
}
func (m *BaseBinary) XXX_DiscardUnknown() {
	xxx_messageInfo_BaseBinary.DiscardUnknown(m)
}

var xxx_messageInfo_BaseBinary proto.InternalMessageInfo

func (m *BaseBinary) GetOneDataBitNum() int32 {
	if m != nil {
		return m.OneDataBitNum
	}
	return 0
}

func (m *BaseBinary) GetArrayLen() int32 {
	if m != nil {
		return m.ArrayLen
	}
	return 0
}

func (m *BaseBinary) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (*BaseBinary) XXX_MessageName() string {
	return "protomsg.BaseBinary"
}
func (*BaseBinary) Name() string {
	return "BaseBinary"
}
func (m *BaseBinary) Scan(value interface{}) error {
	m.Reset()
	if value == nil {
		return nil
	} else if bli, ok := value.([]byte); ok {
		return m.Unmarshal(bli)
	}
	return io.ErrUnexpectedEOF
}
func (m BaseBinary) Value() (driver.Value, error) {
	return m.Marshal()
}
func init() {
	proto.RegisterEnum("protomsg.DataType", DataType_name, DataType_value)
	proto.RegisterType((*Vector3)(nil), "protomsg.Vector3")
	proto.RegisterType((*Vector2)(nil), "protomsg.Vector2")
	proto.RegisterType((*SyncProp)(nil), "protomsg.SyncProp")
	proto.RegisterType((*SyncEntityProps)(nil), "protomsg.SyncEntityProps")
	proto.RegisterType((*CodeRet)(nil), "protomsg.CodeRet")
	proto.RegisterType((*BaseData)(nil), "protomsg.BaseData")
	proto.RegisterMapType((map[int64]int64)(nil), "protomsg.BaseData.DataEntry")
	proto.RegisterType((*BaseBinary)(nil), "protomsg.BaseBinary")
}

func init() { proto.RegisterFile("base.proto", fileDescriptor_db1b6b0986796150) }

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

func (m *Vector3) 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 *Vector3) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Vector3) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Z != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Z))))
		i--
		dAtA[i] = 0x19
	}
	if m.Y != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Y))))
		i--
		dAtA[i] = 0x11
	}
	if m.X != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.X))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *Vector2) 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 *Vector2) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Vector2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Y != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Y))))
		i--
		dAtA[i] = 0x11
	}
	if m.X != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.X))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *SyncProp) 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 *SyncProp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SyncProp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PropValue != nil {
		{
			size := m.PropValue.Size()
			i -= size
			if _, err := m.PropValue.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Index != 0 {
		i = encodeVarintBase(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SyncProp_Int32Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintBase(dAtA, i, uint64(m.Int32Value))
	i--
	dAtA[i] = 0x10
	return len(dAtA) - i, nil
}
func (m *SyncProp_Uint32Value) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SyncProp_Uint32Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintBase(dAtA, i, uint64(m.Uint32Value))
	i--
	dAtA[i] = 0x18
	return len(dAtA) - i, nil
}
func (m *SyncProp_Int64Value) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SyncProp_Int64Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintBase(dAtA, i, uint64(m.Int64Value))
	i--
	dAtA[i] = 0x20
	return len(dAtA) - i, nil
}
func (m *SyncProp_Uint64Value) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SyncProp_Uint64Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintBase(dAtA, i, uint64(m.Uint64Value))
	i--
	dAtA[i] = 0x28
	return len(dAtA) - i, nil
}
func (m *SyncProp_FloatValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SyncProp_FloatValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= 4
	encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FloatValue))))
	i--
	dAtA[i] = 0x35
	return len(dAtA) - i, nil
}
func (m *SyncProp_DoubleValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SyncProp_DoubleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= 8
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.DoubleValue))))
	i--
	dAtA[i] = 0x39
	return len(dAtA) - i, nil
}
func (m *SyncProp_StringValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SyncProp_StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.StringValue)
	copy(dAtA[i:], m.StringValue)
	i = encodeVarintBase(dAtA, i, uint64(len(m.StringValue)))
	i--
	dAtA[i] = 0x42
	return len(dAtA) - i, nil
}
func (m *SyncProp_BoolValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SyncProp_BoolValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.BoolValue {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x48
	return len(dAtA) - i, nil
}
func (m *SyncProp_Msg_Value) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SyncProp_Msg_Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Msg_Value != nil {
		i -= len(m.Msg_Value)
		copy(dAtA[i:], m.Msg_Value)
		i = encodeVarintBase(dAtA, i, uint64(len(m.Msg_Value)))
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *SyncEntityProps) 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 *SyncEntityProps) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SyncEntityProps) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Props) > 0 {
		for iNdEx := len(m.Props) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Props[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBase(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.EntityType) > 0 {
		i -= len(m.EntityType)
		copy(dAtA[i:], m.EntityType)
		i = encodeVarintBase(dAtA, i, uint64(len(m.EntityType)))
		i--
		dAtA[i] = 0x12
	}
	if m.EntityID != 0 {
		i = encodeVarintBase(dAtA, i, uint64(m.EntityID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CodeRet) 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 *CodeRet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CodeRet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CodeMessage) > 0 {
		i -= len(m.CodeMessage)
		copy(dAtA[i:], m.CodeMessage)
		i = encodeVarintBase(dAtA, i, uint64(len(m.CodeMessage)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintBase(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BaseData) 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 *BaseData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BaseData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for k := range m.Data {
			v := m.Data[k]
			baseI := i
			i = encodeVarintBase(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintBase(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintBase(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *BaseBinary) 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 *BaseBinary) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BaseBinary) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintBase(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ArrayLen != 0 {
		i = encodeVarintBase(dAtA, i, uint64(m.ArrayLen))
		i--
		dAtA[i] = 0x10
	}
	if m.OneDataBitNum != 0 {
		i = encodeVarintBase(dAtA, i, uint64(m.OneDataBitNum))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintBase(dAtA []byte, offset int, v uint64) int {
	offset -= sovBase(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Vector3) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.X != 0 {
		n += 9
	}
	if m.Y != 0 {
		n += 9
	}
	if m.Z != 0 {
		n += 9
	}
	return n
}

func (m *Vector2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.X != 0 {
		n += 9
	}
	if m.Y != 0 {
		n += 9
	}
	return n
}

func (m *SyncProp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovBase(uint64(m.Index))
	}
	if m.PropValue != nil {
		n += m.PropValue.Size()
	}
	return n
}

func (m *SyncProp_Int32Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovBase(uint64(m.Int32Value))
	return n
}
func (m *SyncProp_Uint32Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovBase(uint64(m.Uint32Value))
	return n
}
func (m *SyncProp_Int64Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovBase(uint64(m.Int64Value))
	return n
}
func (m *SyncProp_Uint64Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovBase(uint64(m.Uint64Value))
	return n
}
func (m *SyncProp_FloatValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 5
	return n
}
func (m *SyncProp_DoubleValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 9
	return n
}
func (m *SyncProp_StringValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StringValue)
	n += 1 + l + sovBase(uint64(l))
	return n
}
func (m *SyncProp_BoolValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *SyncProp_Msg_Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Msg_Value != nil {
		l = len(m.Msg_Value)
		n += 1 + l + sovBase(uint64(l))
	}
	return n
}
func (m *SyncEntityProps) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EntityID != 0 {
		n += 1 + sovBase(uint64(m.EntityID))
	}
	l = len(m.EntityType)
	if l > 0 {
		n += 1 + l + sovBase(uint64(l))
	}
	if len(m.Props) > 0 {
		for _, e := range m.Props {
			l = e.Size()
			n += 1 + l + sovBase(uint64(l))
		}
	}
	return n
}

func (m *CodeRet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovBase(uint64(m.Code))
	}
	l = len(m.CodeMessage)
	if l > 0 {
		n += 1 + l + sovBase(uint64(l))
	}
	return n
}

func (m *BaseData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		for k, v := range m.Data {
			_ = k
			_ = v
			mapEntrySize := 1 + sovBase(uint64(k)) + 1 + sovBase(uint64(v))
			n += mapEntrySize + 1 + sovBase(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *BaseBinary) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OneDataBitNum != 0 {
		n += 1 + sovBase(uint64(m.OneDataBitNum))
	}
	if m.ArrayLen != 0 {
		n += 1 + sovBase(uint64(m.ArrayLen))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovBase(uint64(l))
	}
	return n
}

func sovBase(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozBase(x uint64) (n int) {
	return sovBase(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Vector3) 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 ErrIntOverflowBase
			}
			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: Vector3: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Vector3: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.X = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Y", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Y = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Z", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Z = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipBase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Vector2) 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 ErrIntOverflowBase
			}
			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: Vector2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Vector2: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.X = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Y", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Y = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipBase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SyncProp) 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 ErrIntOverflowBase
			}
			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: SyncProp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SyncProp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int32Value", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PropValue = &SyncProp_Int32Value{v}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint32Value", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PropValue = &SyncProp_Uint32Value{v}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Value", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PropValue = &SyncProp_Int64Value{v}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint64Value", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PropValue = &SyncProp_Uint64Value{v}
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field FloatValue", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.PropValue = &SyncProp_FloatValue{float32(math.Float32frombits(v))}
		case 7:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field DoubleValue", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.PropValue = &SyncProp_DoubleValue{float64(math.Float64frombits(v))}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				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 ErrInvalidLengthBase
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PropValue = &SyncProp_StringValue{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoolValue", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.PropValue = &SyncProp_BoolValue{b}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg_Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBase
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := make([]byte, postIndex-iNdEx)
			copy(v, dAtA[iNdEx:postIndex])
			m.PropValue = &SyncProp_Msg_Value{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SyncEntityProps) 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 ErrIntOverflowBase
			}
			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: SyncEntityProps: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SyncEntityProps: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntityID", wireType)
			}
			m.EntityID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EntityID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntityType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				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 ErrInvalidLengthBase
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EntityType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Props", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBase
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Props = append(m.Props, &SyncProp{})
			if err := m.Props[len(m.Props)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CodeRet) 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 ErrIntOverflowBase
			}
			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: CodeRet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CodeRet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CodeMessage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				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 ErrInvalidLengthBase
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CodeMessage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BaseData) 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 ErrIntOverflowBase
			}
			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: BaseData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BaseData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBase
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = make(map[int64]int64)
			}
			var mapkey int64
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowBase
					}
					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 ErrIntOverflowBase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipBase(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthBase
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Data[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BaseBinary) 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 ErrIntOverflowBase
			}
			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: BaseBinary: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BaseBinary: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneDataBitNum", wireType)
			}
			m.OneDataBitNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OneDataBitNum |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArrayLen", wireType)
			}
			m.ArrayLen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ArrayLen |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBase
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipBase(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, ErrIntOverflowBase
			}
			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, ErrIntOverflowBase
				}
				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, ErrIntOverflowBase
				}
				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, ErrInvalidLengthBase
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupBase
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthBase
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthBase        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBase          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBase = fmt.Errorf("proto: unexpected end of group")
)