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

package cluster

import (
	bytes "bytes"
	fmt "fmt"
	actor "github.com/AsynkronIT/protoactor-go/actor"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

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

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

type ErrorCode int32

const (
	EC_Success                     ErrorCode = 0
	EC_Fail                        ErrorCode = 1
	EC_ServiceGroupNotExist        ErrorCode = 2
	EC_ServiceInfoNotExist         ErrorCode = 3
	EC_MarshalInstanceFail         ErrorCode = 4
	EC_PutInstanceToEtcdFail       ErrorCode = 5
	EC_ServiceInstanceAlreadyExist ErrorCode = 6
	EC_PutPayloadToEtcdFail        ErrorCode = 7
)

var ErrorCode_name = map[int32]string{
	0: "EC_Success",
	1: "EC_Fail",
	2: "EC_ServiceGroupNotExist",
	3: "EC_ServiceInfoNotExist",
	4: "EC_MarshalInstanceFail",
	5: "EC_PutInstanceToEtcdFail",
	6: "EC_ServiceInstanceAlreadyExist",
	7: "EC_PutPayloadToEtcdFail",
}

var ErrorCode_value = map[string]int32{
	"EC_Success":                     0,
	"EC_Fail":                        1,
	"EC_ServiceGroupNotExist":        2,
	"EC_ServiceInfoNotExist":         3,
	"EC_MarshalInstanceFail":         4,
	"EC_PutInstanceToEtcdFail":       5,
	"EC_ServiceInstanceAlreadyExist": 6,
	"EC_PutPayloadToEtcdFail":        7,
}

func (ErrorCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5da3cbeb884d181c, []int{0}
}

type Error struct {
	Code    ErrorCode `protobuf:"varint,1,opt,name=Code,proto3,enum=cluster.ErrorCode" json:"Code,omitempty"`
	Message string    `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
}

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

var xxx_messageInfo_Error proto.InternalMessageInfo

func (m *Error) GetCode() ErrorCode {
	if m != nil {
		return m.Code
	}
	return EC_Success
}

func (m *Error) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

// 请求全局配置
//@response=S2C_GlobalConfig
type C2S_GlobalConfig struct {
}

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

var xxx_messageInfo_C2S_GlobalConfig proto.InternalMessageInfo

// 请求全局配置回复
type S2C_GlobalConfig struct {
	ConfigData []byte `protobuf:"bytes,1,opt,name=ConfigData,proto3" json:"ConfigData,omitempty"`
}

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

var xxx_messageInfo_S2C_GlobalConfig proto.InternalMessageInfo

func (m *S2C_GlobalConfig) GetConfigData() []byte {
	if m != nil {
		return m.ConfigData
	}
	return nil
}

// 请求服务全局配置
type C2S_ServiceGlobalConfig struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
}

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

var xxx_messageInfo_C2S_ServiceGlobalConfig proto.InternalMessageInfo

func (m *C2S_ServiceGlobalConfig) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// 请求服务全局配置回复
type S2C_ServiceGlobalConfig struct {
	Err        *Error `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	ConfigData []byte `protobuf:"bytes,2,opt,name=ConfigData,proto3" json:"ConfigData,omitempty"`
}

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

var xxx_messageInfo_S2C_ServiceGlobalConfig proto.InternalMessageInfo

func (m *S2C_ServiceGlobalConfig) GetErr() *Error {
	if m != nil {
		return m.Err
	}
	return nil
}

func (m *S2C_ServiceGlobalConfig) GetConfigData() []byte {
	if m != nil {
		return m.ConfigData
	}
	return nil
}

type ServiceInstance struct {
	PID       *actor.PID `protobuf:"bytes,1,opt,name=PID,proto3" json:"PID,omitempty"`
	PprofAddr string     `protobuf:"bytes,2,opt,name=PprofAddr,proto3" json:"PprofAddr,omitempty"`
	Extra     []byte     `protobuf:"bytes,3,opt,name=Extra,proto3" json:"Extra,omitempty"`
}

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

var xxx_messageInfo_ServiceInstance proto.InternalMessageInfo

func (m *ServiceInstance) GetPID() *actor.PID {
	if m != nil {
		return m.PID
	}
	return nil
}

func (m *ServiceInstance) GetPprofAddr() string {
	if m != nil {
		return m.PprofAddr
	}
	return ""
}

func (m *ServiceInstance) GetExtra() []byte {
	if m != nil {
		return m.Extra
	}
	return nil
}

type ServiceInfo struct {
	ID         int32            `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
	ConfigData []byte           `protobuf:"bytes,2,opt,name=ConfigData,proto3" json:"ConfigData,omitempty"`
	Instance   *ServiceInstance `protobuf:"bytes,3,opt,name=Instance,proto3" json:"Instance,omitempty"`
	Payload    int32            `protobuf:"varint,4,opt,name=Payload,proto3" json:"Payload,omitempty"`
}

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

var xxx_messageInfo_ServiceInfo proto.InternalMessageInfo

func (m *ServiceInfo) GetID() int32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *ServiceInfo) GetConfigData() []byte {
	if m != nil {
		return m.ConfigData
	}
	return nil
}

func (m *ServiceInfo) GetInstance() *ServiceInstance {
	if m != nil {
		return m.Instance
	}
	return nil
}

func (m *ServiceInfo) GetPayload() int32 {
	if m != nil {
		return m.Payload
	}
	return 0
}

// 请求服务信息
type C2S_ServiceInfo struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID   int32  `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
}

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

var xxx_messageInfo_C2S_ServiceInfo proto.InternalMessageInfo

func (m *C2S_ServiceInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *C2S_ServiceInfo) GetID() int32 {
	if m != nil {
		return m.ID
	}
	return 0
}

// 请求服务信息回复
type S2C_ServiceInfo struct {
	Err  *Error       `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Info *ServiceInfo `protobuf:"bytes,2,opt,name=Info,proto3" json:"Info,omitempty"`
}

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

var xxx_messageInfo_S2C_ServiceInfo proto.InternalMessageInfo

func (m *S2C_ServiceInfo) GetErr() *Error {
	if m != nil {
		return m.Err
	}
	return nil
}

func (m *S2C_ServiceInfo) GetInfo() *ServiceInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

// 请求服务实例
type C2S_ServiceInstance struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID   int32  `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
}

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

var xxx_messageInfo_C2S_ServiceInstance proto.InternalMessageInfo

func (m *C2S_ServiceInstance) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *C2S_ServiceInstance) GetID() int32 {
	if m != nil {
		return m.ID
	}
	return 0
}

// 请求服务实例回复
type S2C_ServiceInstance struct {
	Err      *Error           `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Instance *ServiceInstance `protobuf:"bytes,2,opt,name=Instance,proto3" json:"Instance,omitempty"`
}

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

var xxx_messageInfo_S2C_ServiceInstance proto.InternalMessageInfo

func (m *S2C_ServiceInstance) GetErr() *Error {
	if m != nil {
		return m.Err
	}
	return nil
}

func (m *S2C_ServiceInstance) GetInstance() *ServiceInstance {
	if m != nil {
		return m.Instance
	}
	return nil
}

// 请求上传服务实例
type C2S_PutServiceInstance struct {
	Name     string           `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID       int32            `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
	Instance *ServiceInstance `protobuf:"bytes,3,opt,name=Instance,proto3" json:"Instance,omitempty"`
}

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

var xxx_messageInfo_C2S_PutServiceInstance proto.InternalMessageInfo

func (m *C2S_PutServiceInstance) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *C2S_PutServiceInstance) GetID() int32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *C2S_PutServiceInstance) GetInstance() *ServiceInstance {
	if m != nil {
		return m.Instance
	}
	return nil
}

// 请求上传服务实例回复
type S2C_PutServiceInstance struct {
	Err *Error `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
}

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

var xxx_messageInfo_S2C_PutServiceInstance proto.InternalMessageInfo

func (m *S2C_PutServiceInstance) GetErr() *Error {
	if m != nil {
		return m.Err
	}
	return nil
}

// 请求锁定服务坑位
type C2S_TryLockServicePosition struct {
	Name     string           `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID       int32            `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
	Instance *ServiceInstance `protobuf:"bytes,3,opt,name=Instance,proto3" json:"Instance,omitempty"`
}

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

var xxx_messageInfo_C2S_TryLockServicePosition proto.InternalMessageInfo

func (m *C2S_TryLockServicePosition) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *C2S_TryLockServicePosition) GetID() int32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *C2S_TryLockServicePosition) GetInstance() *ServiceInstance {
	if m != nil {
		return m.Instance
	}
	return nil
}

// 请求锁定服务坑位回复
type S2C_TryLockServicePosition struct {
	Err *Error `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
}

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

var xxx_messageInfo_S2C_TryLockServicePosition proto.InternalMessageInfo

func (m *S2C_TryLockServicePosition) GetErr() *Error {
	if m != nil {
		return m.Err
	}
	return nil
}

// 请求服务负载
type C2S_ServicePayload struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID   int32  `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
}

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

var xxx_messageInfo_C2S_ServicePayload proto.InternalMessageInfo

func (m *C2S_ServicePayload) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *C2S_ServicePayload) GetID() int32 {
	if m != nil {
		return m.ID
	}
	return 0
}

// 请求服务负载回复
type S2C_ServicePayload struct {
	Err     *Error `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Payload int32  `protobuf:"varint,2,opt,name=Payload,proto3" json:"Payload,omitempty"`
}

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

var xxx_messageInfo_S2C_ServicePayload proto.InternalMessageInfo

func (m *S2C_ServicePayload) GetErr() *Error {
	if m != nil {
		return m.Err
	}
	return nil
}

func (m *S2C_ServicePayload) GetPayload() int32 {
	if m != nil {
		return m.Payload
	}
	return 0
}

// 请求上传服务负载
type C2S_PutServicePayload struct {
	Name    string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID      int32  `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
	Payload int32  `protobuf:"varint,3,opt,name=Payload,proto3" json:"Payload,omitempty"`
}

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

var xxx_messageInfo_C2S_PutServicePayload proto.InternalMessageInfo

func (m *C2S_PutServicePayload) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *C2S_PutServicePayload) GetID() int32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *C2S_PutServicePayload) GetPayload() int32 {
	if m != nil {
		return m.Payload
	}
	return 0
}

// 请求上传服务负载回复
type S2C_PutServicePayload struct {
	Err *Error `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
}

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

var xxx_messageInfo_S2C_PutServicePayload proto.InternalMessageInfo

func (m *S2C_PutServicePayload) GetErr() *Error {
	if m != nil {
		return m.Err
	}
	return nil
}

// 请求一组服务所有信息
type C2S_ServiceGroupAllInfo struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
}

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

var xxx_messageInfo_C2S_ServiceGroupAllInfo proto.InternalMessageInfo

func (m *C2S_ServiceGroupAllInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// 请求一组服务所有信息回复
type S2C_ServiceGroupAllInfo struct {
	Err   *Error         `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Infos []*ServiceInfo `protobuf:"bytes,2,rep,name=Infos,proto3" json:"Infos,omitempty"`
}

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

var xxx_messageInfo_S2C_ServiceGroupAllInfo proto.InternalMessageInfo

func (m *S2C_ServiceGroupAllInfo) GetErr() *Error {
	if m != nil {
		return m.Err
	}
	return nil
}

func (m *S2C_ServiceGroupAllInfo) GetInfos() []*ServiceInfo {
	if m != nil {
		return m.Infos
	}
	return nil
}

// 请求循环选取服务实例
type C2S_RoundRobinPickServiceInstance struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
}

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

var xxx_messageInfo_C2S_RoundRobinPickServiceInstance proto.InternalMessageInfo

func (m *C2S_RoundRobinPickServiceInstance) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// 请求循环选取服务实例回复
type S2C_RoundRobinPickServiceInstance struct {
	Err  *Error       `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Info *ServiceInfo `protobuf:"bytes,2,opt,name=Info,proto3" json:"Info,omitempty"`
}

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

var xxx_messageInfo_S2C_RoundRobinPickServiceInstance proto.InternalMessageInfo

func (m *S2C_RoundRobinPickServiceInstance) GetErr() *Error {
	if m != nil {
		return m.Err
	}
	return nil
}

func (m *S2C_RoundRobinPickServiceInstance) GetInfo() *ServiceInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

func init() {
	proto.RegisterEnum("cluster.ErrorCode", ErrorCode_name, ErrorCode_value)
	proto.RegisterType((*Error)(nil), "cluster.Error")
	proto.RegisterType((*C2S_GlobalConfig)(nil), "cluster.C2S_GlobalConfig")
	proto.RegisterType((*S2C_GlobalConfig)(nil), "cluster.S2C_GlobalConfig")
	proto.RegisterType((*C2S_ServiceGlobalConfig)(nil), "cluster.C2S_ServiceGlobalConfig")
	proto.RegisterType((*S2C_ServiceGlobalConfig)(nil), "cluster.S2C_ServiceGlobalConfig")
	proto.RegisterType((*ServiceInstance)(nil), "cluster.ServiceInstance")
	proto.RegisterType((*ServiceInfo)(nil), "cluster.ServiceInfo")
	proto.RegisterType((*C2S_ServiceInfo)(nil), "cluster.C2S_ServiceInfo")
	proto.RegisterType((*S2C_ServiceInfo)(nil), "cluster.S2C_ServiceInfo")
	proto.RegisterType((*C2S_ServiceInstance)(nil), "cluster.C2S_ServiceInstance")
	proto.RegisterType((*S2C_ServiceInstance)(nil), "cluster.S2C_ServiceInstance")
	proto.RegisterType((*C2S_PutServiceInstance)(nil), "cluster.C2S_PutServiceInstance")
	proto.RegisterType((*S2C_PutServiceInstance)(nil), "cluster.S2C_PutServiceInstance")
	proto.RegisterType((*C2S_TryLockServicePosition)(nil), "cluster.C2S_TryLockServicePosition")
	proto.RegisterType((*S2C_TryLockServicePosition)(nil), "cluster.S2C_TryLockServicePosition")
	proto.RegisterType((*C2S_ServicePayload)(nil), "cluster.C2S_ServicePayload")
	proto.RegisterType((*S2C_ServicePayload)(nil), "cluster.S2C_ServicePayload")
	proto.RegisterType((*C2S_PutServicePayload)(nil), "cluster.C2S_PutServicePayload")
	proto.RegisterType((*S2C_PutServicePayload)(nil), "cluster.S2C_PutServicePayload")
	proto.RegisterType((*C2S_ServiceGroupAllInfo)(nil), "cluster.C2S_ServiceGroupAllInfo")
	proto.RegisterType((*S2C_ServiceGroupAllInfo)(nil), "cluster.S2C_ServiceGroupAllInfo")
	proto.RegisterType((*C2S_RoundRobinPickServiceInstance)(nil), "cluster.C2S_RoundRobinPickServiceInstance")
	proto.RegisterType((*S2C_RoundRobinPickServiceInstance)(nil), "cluster.S2C_RoundRobinPickServiceInstance")
}

func init() { proto.RegisterFile("protos.proto", fileDescriptor_5da3cbeb884d181c) }

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

func (x ErrorCode) String() string {
	s, ok := ErrorCode_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *Error) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Error)
	if !ok {
		that2, ok := that.(Error)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Code != that1.Code {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	return true
}
func (this *C2S_GlobalConfig) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

	that1, ok := that.(*S2C_ServiceGlobalConfig)
	if !ok {
		that2, ok := that.(S2C_ServiceGlobalConfig)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Err.Equal(that1.Err) {
		return false
	}
	if !bytes.Equal(this.ConfigData, that1.ConfigData) {
		return false
	}
	return true
}
func (this *ServiceInstance) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ServiceInstance)
	if !ok {
		that2, ok := that.(ServiceInstance)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.PID.Equal(that1.PID) {
		return false
	}
	if this.PprofAddr != that1.PprofAddr {
		return false
	}
	if !bytes.Equal(this.Extra, that1.Extra) {
		return false
	}
	return true
}
func (this *ServiceInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ServiceInfo)
	if !ok {
		that2, ok := that.(ServiceInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if !bytes.Equal(this.ConfigData, that1.ConfigData) {
		return false
	}
	if !this.Instance.Equal(that1.Instance) {
		return false
	}
	if this.Payload != that1.Payload {
		return false
	}
	return true
}
func (this *C2S_ServiceInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*C2S_ServiceInfo)
	if !ok {
		that2, ok := that.(C2S_ServiceInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	return true
}
func (this *S2C_ServiceInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*S2C_ServiceInfo)
	if !ok {
		that2, ok := that.(S2C_ServiceInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Err.Equal(that1.Err) {
		return false
	}
	if !this.Info.Equal(that1.Info) {
		return false
	}
	return true
}
func (this *C2S_ServiceInstance) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*C2S_ServiceInstance)
	if !ok {
		that2, ok := that.(C2S_ServiceInstance)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	return true
}
func (this *S2C_ServiceInstance) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*S2C_ServiceInstance)
	if !ok {
		that2, ok := that.(S2C_ServiceInstance)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Err.Equal(that1.Err) {
		return false
	}
	if !this.Instance.Equal(that1.Instance) {
		return false
	}
	return true
}
func (this *C2S_PutServiceInstance) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*C2S_PutServiceInstance)
	if !ok {
		that2, ok := that.(C2S_PutServiceInstance)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if !this.Instance.Equal(that1.Instance) {
		return false
	}
	return true
}
func (this *S2C_PutServiceInstance) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*C2S_TryLockServicePosition)
	if !ok {
		that2, ok := that.(C2S_TryLockServicePosition)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if !this.Instance.Equal(that1.Instance) {
		return false
	}
	return true
}
func (this *S2C_TryLockServicePosition) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*C2S_ServicePayload)
	if !ok {
		that2, ok := that.(C2S_ServicePayload)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	return true
}
func (this *S2C_ServicePayload) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*S2C_ServicePayload)
	if !ok {
		that2, ok := that.(S2C_ServicePayload)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Err.Equal(that1.Err) {
		return false
	}
	if this.Payload != that1.Payload {
		return false
	}
	return true
}
func (this *C2S_PutServicePayload) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*C2S_PutServicePayload)
	if !ok {
		that2, ok := that.(C2S_PutServicePayload)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.Payload != that1.Payload {
		return false
	}
	return true
}
func (this *S2C_PutServicePayload) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

	that1, ok := that.(*S2C_ServiceGroupAllInfo)
	if !ok {
		that2, ok := that.(S2C_ServiceGroupAllInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Err.Equal(that1.Err) {
		return false
	}
	if len(this.Infos) != len(that1.Infos) {
		return false
	}
	for i := range this.Infos {
		if !this.Infos[i].Equal(that1.Infos[i]) {
			return false
		}
	}
	return true
}
func (this *C2S_RoundRobinPickServiceInstance) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*S2C_RoundRobinPickServiceInstance)
	if !ok {
		that2, ok := that.(S2C_RoundRobinPickServiceInstance)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Err.Equal(that1.Err) {
		return false
	}
	if !this.Info.Equal(that1.Info) {
		return false
	}
	return true
}
func (this *Error) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cluster.Error{")
	s = append(s, "Code: "+fmt.Sprintf("%#v", this.Code)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *C2S_GlobalConfig) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&cluster.C2S_GlobalConfig{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *S2C_GlobalConfig) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cluster.S2C_GlobalConfig{")
	s = append(s, "ConfigData: "+fmt.Sprintf("%#v", this.ConfigData)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *C2S_ServiceGlobalConfig) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cluster.C2S_ServiceGlobalConfig{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *S2C_ServiceGlobalConfig) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cluster.S2C_ServiceGlobalConfig{")
	if this.Err != nil {
		s = append(s, "Err: "+fmt.Sprintf("%#v", this.Err)+",\n")
	}
	s = append(s, "ConfigData: "+fmt.Sprintf("%#v", this.ConfigData)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ServiceInstance) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&cluster.ServiceInstance{")
	if this.PID != nil {
		s = append(s, "PID: "+fmt.Sprintf("%#v", this.PID)+",\n")
	}
	s = append(s, "PprofAddr: "+fmt.Sprintf("%#v", this.PprofAddr)+",\n")
	s = append(s, "Extra: "+fmt.Sprintf("%#v", this.Extra)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ServiceInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&cluster.ServiceInfo{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "ConfigData: "+fmt.Sprintf("%#v", this.ConfigData)+",\n")
	if this.Instance != nil {
		s = append(s, "Instance: "+fmt.Sprintf("%#v", this.Instance)+",\n")
	}
	s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *C2S_ServiceInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cluster.C2S_ServiceInfo{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *S2C_ServiceInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cluster.S2C_ServiceInfo{")
	if this.Err != nil {
		s = append(s, "Err: "+fmt.Sprintf("%#v", this.Err)+",\n")
	}
	if this.Info != nil {
		s = append(s, "Info: "+fmt.Sprintf("%#v", this.Info)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *C2S_ServiceInstance) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cluster.C2S_ServiceInstance{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *S2C_ServiceInstance) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cluster.S2C_ServiceInstance{")
	if this.Err != nil {
		s = append(s, "Err: "+fmt.Sprintf("%#v", this.Err)+",\n")
	}
	if this.Instance != nil {
		s = append(s, "Instance: "+fmt.Sprintf("%#v", this.Instance)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *C2S_PutServiceInstance) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&cluster.C2S_PutServiceInstance{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	if this.Instance != nil {
		s = append(s, "Instance: "+fmt.Sprintf("%#v", this.Instance)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *S2C_PutServiceInstance) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cluster.S2C_PutServiceInstance{")
	if this.Err != nil {
		s = append(s, "Err: "+fmt.Sprintf("%#v", this.Err)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *C2S_TryLockServicePosition) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&cluster.C2S_TryLockServicePosition{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	if this.Instance != nil {
		s = append(s, "Instance: "+fmt.Sprintf("%#v", this.Instance)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *S2C_TryLockServicePosition) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cluster.S2C_TryLockServicePosition{")
	if this.Err != nil {
		s = append(s, "Err: "+fmt.Sprintf("%#v", this.Err)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *C2S_ServicePayload) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cluster.C2S_ServicePayload{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *S2C_ServicePayload) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cluster.S2C_ServicePayload{")
	if this.Err != nil {
		s = append(s, "Err: "+fmt.Sprintf("%#v", this.Err)+",\n")
	}
	s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *C2S_PutServicePayload) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&cluster.C2S_PutServicePayload{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *S2C_PutServicePayload) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cluster.S2C_PutServicePayload{")
	if this.Err != nil {
		s = append(s, "Err: "+fmt.Sprintf("%#v", this.Err)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *C2S_ServiceGroupAllInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cluster.C2S_ServiceGroupAllInfo{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *S2C_ServiceGroupAllInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cluster.S2C_ServiceGroupAllInfo{")
	if this.Err != nil {
		s = append(s, "Err: "+fmt.Sprintf("%#v", this.Err)+",\n")
	}
	if this.Infos != nil {
		s = append(s, "Infos: "+fmt.Sprintf("%#v", this.Infos)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *C2S_RoundRobinPickServiceInstance) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&cluster.C2S_RoundRobinPickServiceInstance{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *S2C_RoundRobinPickServiceInstance) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&cluster.S2C_RoundRobinPickServiceInstance{")
	if this.Err != nil {
		s = append(s, "Err: "+fmt.Sprintf("%#v", this.Err)+",\n")
	}
	if this.Info != nil {
		s = append(s, "Info: "+fmt.Sprintf("%#v", this.Info)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringProtos(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 *Error) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Error) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Code))
	}
	if len(m.Message) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	return i, nil
}

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

func (m *C2S_GlobalConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *S2C_GlobalConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ConfigData) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.ConfigData)))
		i += copy(dAtA[i:], m.ConfigData)
	}
	return i, nil
}

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

func (m *C2S_ServiceGlobalConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

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

func (m *S2C_ServiceGlobalConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Err.Size()))
		n1, err := m.Err.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.ConfigData) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.ConfigData)))
		i += copy(dAtA[i:], m.ConfigData)
	}
	return i, nil
}

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

func (m *ServiceInstance) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.PID != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.PID.Size()))
		n2, err := m.PID.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if len(m.PprofAddr) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.PprofAddr)))
		i += copy(dAtA[i:], m.PprofAddr)
	}
	if len(m.Extra) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Extra)))
		i += copy(dAtA[i:], m.Extra)
	}
	return i, nil
}

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

func (m *ServiceInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ID != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.ID))
	}
	if len(m.ConfigData) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.ConfigData)))
		i += copy(dAtA[i:], m.ConfigData)
	}
	if m.Instance != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Instance.Size()))
		n3, err := m.Instance.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Payload != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Payload))
	}
	return i, nil
}

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

func (m *C2S_ServiceInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.ID != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.ID))
	}
	return i, nil
}

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

func (m *S2C_ServiceInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Err.Size()))
		n4, err := m.Err.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.Info != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Info.Size()))
		n5, err := m.Info.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	return i, nil
}

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

func (m *C2S_ServiceInstance) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.ID != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.ID))
	}
	return i, nil
}

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

func (m *S2C_ServiceInstance) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Err.Size()))
		n6, err := m.Err.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.Instance != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Instance.Size()))
		n7, err := m.Instance.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	return i, nil
}

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

func (m *C2S_PutServiceInstance) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.ID != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.ID))
	}
	if m.Instance != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Instance.Size()))
		n8, err := m.Instance.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}

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

func (m *S2C_PutServiceInstance) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Err.Size()))
		n9, err := m.Err.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	return i, nil
}

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

func (m *C2S_TryLockServicePosition) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.ID != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.ID))
	}
	if m.Instance != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Instance.Size()))
		n10, err := m.Instance.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	return i, nil
}

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

func (m *S2C_TryLockServicePosition) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Err.Size()))
		n11, err := m.Err.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}

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

func (m *C2S_ServicePayload) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.ID != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.ID))
	}
	return i, nil
}

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

func (m *S2C_ServicePayload) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Err.Size()))
		n12, err := m.Err.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.Payload != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Payload))
	}
	return i, nil
}

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

func (m *C2S_PutServicePayload) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.ID != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.ID))
	}
	if m.Payload != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Payload))
	}
	return i, nil
}

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

func (m *S2C_PutServicePayload) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Err.Size()))
		n13, err := m.Err.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	return i, nil
}

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

func (m *C2S_ServiceGroupAllInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

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

func (m *S2C_ServiceGroupAllInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Err.Size()))
		n14, err := m.Err.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	if len(m.Infos) > 0 {
		for _, msg := range m.Infos {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtos(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *C2S_RoundRobinPickServiceInstance) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

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

func (m *S2C_RoundRobinPickServiceInstance) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Err.Size()))
		n15, err := m.Err.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	if m.Info != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtos(dAtA, i, uint64(m.Info.Size()))
		n16, err := m.Info.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	return i, nil
}

func encodeVarintProtos(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *Error) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovProtos(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *C2S_GlobalConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *S2C_GlobalConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ConfigData)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *C2S_ServiceGlobalConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *S2C_ServiceGlobalConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	l = len(m.ConfigData)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *ServiceInstance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PID != nil {
		l = m.PID.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	l = len(m.PprofAddr)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	l = len(m.Extra)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *ServiceInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovProtos(uint64(m.ID))
	}
	l = len(m.ConfigData)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.Instance != nil {
		l = m.Instance.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.Payload != 0 {
		n += 1 + sovProtos(uint64(m.Payload))
	}
	return n
}

func (m *C2S_ServiceInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.ID != 0 {
		n += 1 + sovProtos(uint64(m.ID))
	}
	return n
}

func (m *S2C_ServiceInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.Info != nil {
		l = m.Info.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *C2S_ServiceInstance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.ID != 0 {
		n += 1 + sovProtos(uint64(m.ID))
	}
	return n
}

func (m *S2C_ServiceInstance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.Instance != nil {
		l = m.Instance.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *C2S_PutServiceInstance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.ID != 0 {
		n += 1 + sovProtos(uint64(m.ID))
	}
	if m.Instance != nil {
		l = m.Instance.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *S2C_PutServiceInstance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *C2S_TryLockServicePosition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.ID != 0 {
		n += 1 + sovProtos(uint64(m.ID))
	}
	if m.Instance != nil {
		l = m.Instance.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *S2C_TryLockServicePosition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *C2S_ServicePayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.ID != 0 {
		n += 1 + sovProtos(uint64(m.ID))
	}
	return n
}

func (m *S2C_ServicePayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.Payload != 0 {
		n += 1 + sovProtos(uint64(m.Payload))
	}
	return n
}

func (m *C2S_PutServicePayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.ID != 0 {
		n += 1 + sovProtos(uint64(m.ID))
	}
	if m.Payload != 0 {
		n += 1 + sovProtos(uint64(m.Payload))
	}
	return n
}

func (m *S2C_PutServicePayload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *C2S_ServiceGroupAllInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *S2C_ServiceGroupAllInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	if len(m.Infos) > 0 {
		for _, e := range m.Infos {
			l = e.Size()
			n += 1 + l + sovProtos(uint64(l))
		}
	}
	return n
}

func (m *C2S_RoundRobinPickServiceInstance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func (m *S2C_RoundRobinPickServiceInstance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	if m.Info != nil {
		l = m.Info.Size()
		n += 1 + l + sovProtos(uint64(l))
	}
	return n
}

func sovProtos(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozProtos(x uint64) (n int) {
	return sovProtos(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Error) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Error{`,
		`Code:` + fmt.Sprintf("%v", this.Code) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *C2S_GlobalConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&C2S_GlobalConfig{`,
		`}`,
	}, "")
	return s
}
func (this *S2C_GlobalConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&S2C_GlobalConfig{`,
		`ConfigData:` + fmt.Sprintf("%v", this.ConfigData) + `,`,
		`}`,
	}, "")
	return s
}
func (this *C2S_ServiceGlobalConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&C2S_ServiceGlobalConfig{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *S2C_ServiceGlobalConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&S2C_ServiceGlobalConfig{`,
		`Err:` + strings.Replace(fmt.Sprintf("%v", this.Err), "Error", "Error", 1) + `,`,
		`ConfigData:` + fmt.Sprintf("%v", this.ConfigData) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ServiceInstance) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ServiceInstance{`,
		`PID:` + strings.Replace(fmt.Sprintf("%v", this.PID), "PID", "actor.PID", 1) + `,`,
		`PprofAddr:` + fmt.Sprintf("%v", this.PprofAddr) + `,`,
		`Extra:` + fmt.Sprintf("%v", this.Extra) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ServiceInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ServiceInfo{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`ConfigData:` + fmt.Sprintf("%v", this.ConfigData) + `,`,
		`Instance:` + strings.Replace(fmt.Sprintf("%v", this.Instance), "ServiceInstance", "ServiceInstance", 1) + `,`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`}`,
	}, "")
	return s
}
func (this *C2S_ServiceInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&C2S_ServiceInfo{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *S2C_ServiceInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&S2C_ServiceInfo{`,
		`Err:` + strings.Replace(fmt.Sprintf("%v", this.Err), "Error", "Error", 1) + `,`,
		`Info:` + strings.Replace(fmt.Sprintf("%v", this.Info), "ServiceInfo", "ServiceInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *C2S_ServiceInstance) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&C2S_ServiceInstance{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *S2C_ServiceInstance) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&S2C_ServiceInstance{`,
		`Err:` + strings.Replace(fmt.Sprintf("%v", this.Err), "Error", "Error", 1) + `,`,
		`Instance:` + strings.Replace(fmt.Sprintf("%v", this.Instance), "ServiceInstance", "ServiceInstance", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *C2S_PutServiceInstance) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&C2S_PutServiceInstance{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Instance:` + strings.Replace(fmt.Sprintf("%v", this.Instance), "ServiceInstance", "ServiceInstance", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *S2C_PutServiceInstance) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&S2C_PutServiceInstance{`,
		`Err:` + strings.Replace(fmt.Sprintf("%v", this.Err), "Error", "Error", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *C2S_TryLockServicePosition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&C2S_TryLockServicePosition{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Instance:` + strings.Replace(fmt.Sprintf("%v", this.Instance), "ServiceInstance", "ServiceInstance", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *S2C_TryLockServicePosition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&S2C_TryLockServicePosition{`,
		`Err:` + strings.Replace(fmt.Sprintf("%v", this.Err), "Error", "Error", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *C2S_ServicePayload) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&C2S_ServicePayload{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *S2C_ServicePayload) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&S2C_ServicePayload{`,
		`Err:` + strings.Replace(fmt.Sprintf("%v", this.Err), "Error", "Error", 1) + `,`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`}`,
	}, "")
	return s
}
func (this *C2S_PutServicePayload) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&C2S_PutServicePayload{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`}`,
	}, "")
	return s
}
func (this *S2C_PutServicePayload) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&S2C_PutServicePayload{`,
		`Err:` + strings.Replace(fmt.Sprintf("%v", this.Err), "Error", "Error", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *C2S_ServiceGroupAllInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&C2S_ServiceGroupAllInfo{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *S2C_ServiceGroupAllInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&S2C_ServiceGroupAllInfo{`,
		`Err:` + strings.Replace(fmt.Sprintf("%v", this.Err), "Error", "Error", 1) + `,`,
		`Infos:` + strings.Replace(fmt.Sprintf("%v", this.Infos), "ServiceInfo", "ServiceInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *C2S_RoundRobinPickServiceInstance) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&C2S_RoundRobinPickServiceInstance{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *S2C_RoundRobinPickServiceInstance) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&S2C_RoundRobinPickServiceInstance{`,
		`Err:` + strings.Replace(fmt.Sprintf("%v", this.Err), "Error", "Error", 1) + `,`,
		`Info:` + strings.Replace(fmt.Sprintf("%v", this.Info), "ServiceInfo", "ServiceInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringProtos(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Error) 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 ErrIntOverflowProtos
			}
			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: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: 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 ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= ErrorCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				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 ErrInvalidLengthProtos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *C2S_GlobalConfig) 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 ErrIntOverflowProtos
			}
			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: C2S_GlobalConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: C2S_GlobalConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipProtos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *S2C_ServiceInfo) 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 ErrIntOverflowProtos
			}
			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: S2C_ServiceInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: S2C_ServiceInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &Error{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Info == nil {
				m.Info = &ServiceInfo{}
			}
			if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *S2C_ServiceInstance) 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 ErrIntOverflowProtos
			}
			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: S2C_ServiceInstance: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: S2C_ServiceInstance: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &Error{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Instance", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Instance == nil {
				m.Instance = &ServiceInstance{}
			}
			if err := m.Instance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *S2C_PutServiceInstance) 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 ErrIntOverflowProtos
			}
			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: S2C_PutServiceInstance: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: S2C_PutServiceInstance: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &Error{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *S2C_TryLockServicePosition) 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 ErrIntOverflowProtos
			}
			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: S2C_TryLockServicePosition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: S2C_TryLockServicePosition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &Error{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *S2C_ServicePayload) 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 ErrIntOverflowProtos
			}
			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: S2C_ServicePayload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: S2C_ServicePayload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &Error{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			m.Payload = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Payload |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *S2C_PutServicePayload) 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 ErrIntOverflowProtos
			}
			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: S2C_PutServicePayload: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: S2C_PutServicePayload: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &Error{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *S2C_ServiceGroupAllInfo) 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 ErrIntOverflowProtos
			}
			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: S2C_ServiceGroupAllInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: S2C_ServiceGroupAllInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &Error{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Infos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Infos = append(m.Infos, &ServiceInfo{})
			if err := m.Infos[len(m.Infos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *S2C_RoundRobinPickServiceInstance) 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 ErrIntOverflowProtos
			}
			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: S2C_RoundRobinPickServiceInstance: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: S2C_RoundRobinPickServiceInstance: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &Error{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Info == nil {
				m.Info = &ServiceInfo{}
			}
			if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipProtos(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowProtos
			}
			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, ErrIntOverflowProtos
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowProtos
				}
				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, ErrInvalidLengthProtos
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthProtos
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowProtos
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipProtos(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthProtos
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthProtos = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProtos   = fmt.Errorf("proto: integer overflow")
)