Slave.pb.go

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

package hippo

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type MemPolicy int32

const (
	MemPolicy_MEM_UNDEFINE   MemPolicy = -1
	MemPolicy_MEM_DEFAULT    MemPolicy = 0
	MemPolicy_MEM_PREFERRED  MemPolicy = 1
	MemPolicy_MEM_BIND       MemPolicy = 2
	MemPolicy_MEM_INTERLEAVE MemPolicy = 3
)

var MemPolicy_name = map[int32]string{
	-1: "MEM_UNDEFINE",
	0:  "MEM_DEFAULT",
	1:  "MEM_PREFERRED",
	2:  "MEM_BIND",
	3:  "MEM_INTERLEAVE",
}

var MemPolicy_value = map[string]int32{
	"MEM_UNDEFINE":   -1,
	"MEM_DEFAULT":    0,
	"MEM_PREFERRED":  1,
	"MEM_BIND":       2,
	"MEM_INTERLEAVE": 3,
}

func (x MemPolicy) Enum() *MemPolicy {
	p := new(MemPolicy)
	*p = x
	return p
}

func (x MemPolicy) String() string {
	return proto.EnumName(MemPolicy_name, int32(x))
}

func (x *MemPolicy) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(MemPolicy_value, data, "MemPolicy")
	if err != nil {
		return err
	}
	*x = MemPolicy(value)
	return nil
}

func (MemPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5e466cc5b3932b09, []int{0}
}

type SlotState int32

const (
	SlotState_SS_NORMAL   SlotState = 0
	SlotState_SS_RESERVE  SlotState = 1
	SlotState_SS_STOPPING SlotState = 2
)

var SlotState_name = map[int32]string{
	0: "SS_NORMAL",
	1: "SS_RESERVE",
	2: "SS_STOPPING",
}

var SlotState_value = map[string]int32{
	"SS_NORMAL":   0,
	"SS_RESERVE":  1,
	"SS_STOPPING": 2,
}

func (x SlotState) Enum() *SlotState {
	p := new(SlotState)
	*p = x
	return p
}

func (x SlotState) String() string {
	return proto.EnumName(SlotState_name, int32(x))
}

func (x *SlotState) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SlotState_value, data, "SlotState")
	if err != nil {
		return err
	}
	*x = SlotState(value)
	return nil
}

func (SlotState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5e466cc5b3932b09, []int{1}
}

type ExecutionType int32

const (
	ExecutionType_ET_GUARANTEED    ExecutionType = 0
	ExecutionType_ET_OPPORTUNISTIC ExecutionType = 1
)

var ExecutionType_name = map[int32]string{
	0: "ET_GUARANTEED",
	1: "ET_OPPORTUNISTIC",
}

var ExecutionType_value = map[string]int32{
	"ET_GUARANTEED":    0,
	"ET_OPPORTUNISTIC": 1,
}

func (x ExecutionType) Enum() *ExecutionType {
	p := new(ExecutionType)
	*p = x
	return p
}

func (x ExecutionType) String() string {
	return proto.EnumName(ExecutionType_name, int32(x))
}

func (x *ExecutionType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ExecutionType_value, data, "ExecutionType")
	if err != nil {
		return err
	}
	*x = ExecutionType(value)
	return nil
}

func (ExecutionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5e466cc5b3932b09, []int{2}
}

type ProcessLaunchResponse_ProcessLaunchStatus int32

const (
	ProcessLaunchResponse_SLOT_ACCEPTED  ProcessLaunchResponse_ProcessLaunchStatus = 1
	ProcessLaunchResponse_SLOT_DENIED    ProcessLaunchResponse_ProcessLaunchStatus = 2
	ProcessLaunchResponse_SLOT_DESTROYED ProcessLaunchResponse_ProcessLaunchStatus = 3
)

var ProcessLaunchResponse_ProcessLaunchStatus_name = map[int32]string{
	1: "SLOT_ACCEPTED",
	2: "SLOT_DENIED",
	3: "SLOT_DESTROYED",
}

var ProcessLaunchResponse_ProcessLaunchStatus_value = map[string]int32{
	"SLOT_ACCEPTED":  1,
	"SLOT_DENIED":    2,
	"SLOT_DESTROYED": 3,
}

func (x ProcessLaunchResponse_ProcessLaunchStatus) Enum() *ProcessLaunchResponse_ProcessLaunchStatus {
	p := new(ProcessLaunchResponse_ProcessLaunchStatus)
	*p = x
	return p
}

func (x ProcessLaunchResponse_ProcessLaunchStatus) String() string {
	return proto.EnumName(ProcessLaunchResponse_ProcessLaunchStatus_name, int32(x))
}

func (x *ProcessLaunchResponse_ProcessLaunchStatus) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ProcessLaunchResponse_ProcessLaunchStatus_value, data, "ProcessLaunchResponse_ProcessLaunchStatus")
	if err != nil {
		return err
	}
	*x = ProcessLaunchResponse_ProcessLaunchStatus(value)
	return nil
}

func (ProcessLaunchResponse_ProcessLaunchStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5e466cc5b3932b09, []int{13, 0}
}

type Metric struct {
	Name                 *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Value                *float64 `protobuf:"fixed64,2,opt,name=value" json:"value,omitempty"`
	Time                 *int64   `protobuf:"varint,3,opt,name=time" json:"time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Metric proto.InternalMessageInfo

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

func (m *Metric) GetValue() float64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

func (m *Metric) GetTime() int64 {
	if m != nil && m.Time != nil {
		return *m.Time
	}
	return 0
}

type SocketInfo struct {
	SocketIdx            *int32   `protobuf:"varint,1,opt,name=socketIdx" json:"socketIdx,omitempty"`
	CpuNum               *uint32  `protobuf:"varint,2,opt,name=cpuNum,def=0" json:"cpuNum,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SocketInfo proto.InternalMessageInfo

const Default_SocketInfo_CpuNum uint32 = 0

func (m *SocketInfo) GetSocketIdx() int32 {
	if m != nil && m.SocketIdx != nil {
		return *m.SocketIdx
	}
	return 0
}

func (m *SocketInfo) GetCpuNum() uint32 {
	if m != nil && m.CpuNum != nil {
		return *m.CpuNum
	}
	return Default_SocketInfo_CpuNum
}

type SocketNodePolicy struct {
	MemPolicy            *MemPolicy    `protobuf:"varint,1,opt,name=memPolicy,enum=hippo.MemPolicy,def=-1" json:"memPolicy,omitempty"`
	Sockets              []*SocketInfo `protobuf:"bytes,2,rep,name=sockets" json:"sockets,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_SocketNodePolicy proto.InternalMessageInfo

const Default_SocketNodePolicy_MemPolicy MemPolicy = MemPolicy_MEM_UNDEFINE

func (m *SocketNodePolicy) GetMemPolicy() MemPolicy {
	if m != nil && m.MemPolicy != nil {
		return *m.MemPolicy
	}
	return Default_SocketNodePolicy_MemPolicy
}

func (m *SocketNodePolicy) GetSockets() []*SocketInfo {
	if m != nil {
		return m.Sockets
	}
	return nil
}

type SlotInfo struct {
	SlotId                   *int32                      `protobuf:"varint,1,opt,name=slotId" json:"slotId,omitempty"`
	ApplicationId            *string                     `protobuf:"bytes,2,opt,name=applicationId" json:"applicationId,omitempty"`
	AppChecksum              *int64                      `protobuf:"varint,3,opt,name=appChecksum" json:"appChecksum,omitempty"`
	ProcessStatus            []*ProcessStatus            `protobuf:"bytes,4,rep,name=processStatus" json:"processStatus,omitempty"`
	DataStatus               []*DataStatus               `protobuf:"bytes,5,rep,name=dataStatus" json:"dataStatus,omitempty"`
	LaunchSignature          *int64                      `protobuf:"varint,6,opt,name=launchSignature" json:"launchSignature,omitempty"`
	PackageChecksum          *string                     `protobuf:"bytes,7,opt,name=packageChecksum" json:"packageChecksum,omitempty"`
	PackageStatus            *PackageStatus              `protobuf:"bytes,8,opt,name=packageStatus" json:"packageStatus,omitempty"`
	SlotResource             *SlotResource               `protobuf:"bytes,9,opt,name=slotResource" json:"slotResource,omitempty"`
	ResourceTag              *string                     `protobuf:"bytes,10,opt,name=resourceTag" json:"resourceTag,omitempty"`
	UseCpuset                *bool                       `protobuf:"varint,11,opt,name=useCpuset" json:"useCpuset,omitempty"`
	CpusetMode               *ResourceRequest_CpusetMode `protobuf:"varint,12,opt,name=cpusetMode,enum=hippo.ResourceRequest_CpusetMode" json:"cpusetMode,omitempty"`
	Cpusets                  *string                     `protobuf:"bytes,13,opt,name=cpusets" json:"cpusets,omitempty"`
	PreDeployPackageChecksum *string                     `protobuf:"bytes,14,opt,name=preDeployPackageChecksum" json:"preDeployPackageChecksum,omitempty"`
	PreDeployPackageStatus   *PackageStatus              `protobuf:"bytes,15,opt,name=preDeployPackageStatus" json:"preDeployPackageStatus,omitempty"`
	Priority                 *Priority                   `protobuf:"bytes,16,opt,name=priority" json:"priority,omitempty"`
	WorkDirTag               *string                     `protobuf:"bytes,17,opt,name=workDirTag" json:"workDirTag,omitempty"`
	Metrics                  []*Metric                   `protobuf:"bytes,18,rep,name=metrics" json:"metrics,omitempty"`
	PackageDetails           []*PackageDetail            `protobuf:"bytes,19,rep,name=packageDetails" json:"packageDetails,omitempty"`
	Status                   []*Parameter                `protobuf:"bytes,20,rep,name=status" json:"status,omitempty"`
	SocketPolicy             *SocketNodePolicy           `protobuf:"bytes,21,opt,name=socketPolicy" json:"socketPolicy,omitempty"`
	XXX_NoUnkeyedLiteral     struct{}                    `json:"-"`
	XXX_unrecognized         []byte                      `json:"-"`
	XXX_sizecache            int32                       `json:"-"`
}

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

var xxx_messageInfo_SlotInfo proto.InternalMessageInfo

func (m *SlotInfo) GetSlotId() int32 {
	if m != nil && m.SlotId != nil {
		return *m.SlotId
	}
	return 0
}

func (m *SlotInfo) GetApplicationId() string {
	if m != nil && m.ApplicationId != nil {
		return *m.ApplicationId
	}
	return ""
}

func (m *SlotInfo) GetAppChecksum() int64 {
	if m != nil && m.AppChecksum != nil {
		return *m.AppChecksum
	}
	return 0
}

func (m *SlotInfo) GetProcessStatus() []*ProcessStatus {
	if m != nil {
		return m.ProcessStatus
	}
	return nil
}

func (m *SlotInfo) GetDataStatus() []*DataStatus {
	if m != nil {
		return m.DataStatus
	}
	return nil
}

func (m *SlotInfo) GetLaunchSignature() int64 {
	if m != nil && m.LaunchSignature != nil {
		return *m.LaunchSignature
	}
	return 0
}

func (m *SlotInfo) GetPackageChecksum() string {
	if m != nil && m.PackageChecksum != nil {
		return *m.PackageChecksum
	}
	return ""
}

func (m *SlotInfo) GetPackageStatus() *PackageStatus {
	if m != nil {
		return m.PackageStatus
	}
	return nil
}

func (m *SlotInfo) GetSlotResource() *SlotResource {
	if m != nil {
		return m.SlotResource
	}
	return nil
}

func (m *SlotInfo) GetResourceTag() string {
	if m != nil && m.ResourceTag != nil {
		return *m.ResourceTag
	}
	return ""
}

func (m *SlotInfo) GetUseCpuset() bool {
	if m != nil && m.UseCpuset != nil {
		return *m.UseCpuset
	}
	return false
}

func (m *SlotInfo) GetCpusetMode() ResourceRequest_CpusetMode {
	if m != nil && m.CpusetMode != nil {
		return *m.CpusetMode
	}
	return ResourceRequest_NONE
}

func (m *SlotInfo) GetCpusets() string {
	if m != nil && m.Cpusets != nil {
		return *m.Cpusets
	}
	return ""
}

func (m *SlotInfo) GetPreDeployPackageChecksum() string {
	if m != nil && m.PreDeployPackageChecksum != nil {
		return *m.PreDeployPackageChecksum
	}
	return ""
}

func (m *SlotInfo) GetPreDeployPackageStatus() *PackageStatus {
	if m != nil {
		return m.PreDeployPackageStatus
	}
	return nil
}

func (m *SlotInfo) GetPriority() *Priority {
	if m != nil {
		return m.Priority
	}
	return nil
}

func (m *SlotInfo) GetWorkDirTag() string {
	if m != nil && m.WorkDirTag != nil {
		return *m.WorkDirTag
	}
	return ""
}

func (m *SlotInfo) GetMetrics() []*Metric {
	if m != nil {
		return m.Metrics
	}
	return nil
}

func (m *SlotInfo) GetPackageDetails() []*PackageDetail {
	if m != nil {
		return m.PackageDetails
	}
	return nil
}

func (m *SlotInfo) GetStatus() []*Parameter {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *SlotInfo) GetSocketPolicy() *SocketNodePolicy {
	if m != nil {
		return m.SocketPolicy
	}
	return nil
}

type SlaveInfo struct {
	Address              *string        `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
	Resource             *SlaveResource `protobuf:"bytes,2,opt,name=resource" json:"resource,omitempty"`
	Slots                []*SlotInfo    `protobuf:"bytes,3,rep,name=slots" json:"slots,omitempty"`
	BinaryVersion        *string        `protobuf:"bytes,4,opt,name=binaryVersion" json:"binaryVersion,omitempty"`
	Attributes           []*Parameter   `protobuf:"bytes,5,rep,name=attributes" json:"attributes,omitempty"`
	RestfulHttpPort      *int32         `protobuf:"varint,6,opt,name=restfulHttpPort" json:"restfulHttpPort,omitempty"`
	Labels               []*Parameter   `protobuf:"bytes,7,rep,name=labels" json:"labels,omitempty"`
	Metrics              []*Metric      `protobuf:"bytes,8,rep,name=metrics" json:"metrics,omitempty"`
	SlaveHttpPort        *int32         `protobuf:"varint,9,opt,name=slaveHttpPort" json:"slaveHttpPort,omitempty"`
	SlaveHealth          *SlaveHealth   `protobuf:"bytes,10,opt,name=slaveHealth" json:"slaveHealth,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_SlaveInfo proto.InternalMessageInfo

func (m *SlaveInfo) GetAddress() string {
	if m != nil && m.Address != nil {
		return *m.Address
	}
	return ""
}

func (m *SlaveInfo) GetResource() *SlaveResource {
	if m != nil {
		return m.Resource
	}
	return nil
}

func (m *SlaveInfo) GetSlots() []*SlotInfo {
	if m != nil {
		return m.Slots
	}
	return nil
}

func (m *SlaveInfo) GetBinaryVersion() string {
	if m != nil && m.BinaryVersion != nil {
		return *m.BinaryVersion
	}
	return ""
}

func (m *SlaveInfo) GetAttributes() []*Parameter {
	if m != nil {
		return m.Attributes
	}
	return nil
}

func (m *SlaveInfo) GetRestfulHttpPort() int32 {
	if m != nil && m.RestfulHttpPort != nil {
		return *m.RestfulHttpPort
	}
	return 0
}

func (m *SlaveInfo) GetLabels() []*Parameter {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *SlaveInfo) GetMetrics() []*Metric {
	if m != nil {
		return m.Metrics
	}
	return nil
}

func (m *SlaveInfo) GetSlaveHttpPort() int32 {
	if m != nil && m.SlaveHttpPort != nil {
		return *m.SlaveHttpPort
	}
	return 0
}

func (m *SlaveInfo) GetSlaveHealth() *SlaveHealth {
	if m != nil {
		return m.SlaveHealth
	}
	return nil
}

type SlotDetail struct {
	Info                 *SlotInfo    `protobuf:"bytes,1,opt,name=info" json:"info,omitempty"`
	WorkDir              *string      `protobuf:"bytes,2,opt,name=workDir" json:"workDir,omitempty"`
	ContainerConfigs     []string     `protobuf:"bytes,3,rep,name=containerConfigs" json:"containerConfigs,omitempty"`
	GroupId              *string      `protobuf:"bytes,4,opt,name=groupId" json:"groupId,omitempty"`
	Labels               []*Parameter `protobuf:"bytes,5,rep,name=labels" json:"labels,omitempty"`
	Envs                 []*Parameter `protobuf:"bytes,6,rep,name=envs" json:"envs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_SlotDetail proto.InternalMessageInfo

func (m *SlotDetail) GetInfo() *SlotInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

func (m *SlotDetail) GetWorkDir() string {
	if m != nil && m.WorkDir != nil {
		return *m.WorkDir
	}
	return ""
}

func (m *SlotDetail) GetContainerConfigs() []string {
	if m != nil {
		return m.ContainerConfigs
	}
	return nil
}

func (m *SlotDetail) GetGroupId() string {
	if m != nil && m.GroupId != nil {
		return *m.GroupId
	}
	return ""
}

func (m *SlotDetail) GetLabels() []*Parameter {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *SlotDetail) GetEnvs() []*Parameter {
	if m != nil {
		return m.Envs
	}
	return nil
}

type SlaveDetail struct {
	Address              *string          `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
	Resource             *SlaveResource   `protobuf:"bytes,2,opt,name=resource" json:"resource,omitempty"`
	Slots                []*SlotDetail    `protobuf:"bytes,3,rep,name=slots" json:"slots,omitempty"`
	BinaryVersion        *string          `protobuf:"bytes,4,opt,name=binaryVersion" json:"binaryVersion,omitempty"`
	GrantedQueue         *string          `protobuf:"bytes,5,opt,name=grantedQueue" json:"grantedQueue,omitempty"`
	GrantedResource      *GrantedResource `protobuf:"bytes,6,opt,name=grantedResource" json:"grantedResource,omitempty"`
	IsOffline            *bool            `protobuf:"varint,7,opt,name=isOffline" json:"isOffline,omitempty"`
	CpuShareNum          *int32           `protobuf:"varint,8,opt,name=cpuShareNum" json:"cpuShareNum,omitempty"`
	Labels               []*Parameter     `protobuf:"bytes,9,rep,name=labels" json:"labels,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_SlaveDetail proto.InternalMessageInfo

func (m *SlaveDetail) GetAddress() string {
	if m != nil && m.Address != nil {
		return *m.Address
	}
	return ""
}

func (m *SlaveDetail) GetResource() *SlaveResource {
	if m != nil {
		return m.Resource
	}
	return nil
}

func (m *SlaveDetail) GetSlots() []*SlotDetail {
	if m != nil {
		return m.Slots
	}
	return nil
}

func (m *SlaveDetail) GetBinaryVersion() string {
	if m != nil && m.BinaryVersion != nil {
		return *m.BinaryVersion
	}
	return ""
}

func (m *SlaveDetail) GetGrantedQueue() string {
	if m != nil && m.GrantedQueue != nil {
		return *m.GrantedQueue
	}
	return ""
}

func (m *SlaveDetail) GetGrantedResource() *GrantedResource {
	if m != nil {
		return m.GrantedResource
	}
	return nil
}

func (m *SlaveDetail) GetIsOffline() bool {
	if m != nil && m.IsOffline != nil {
		return *m.IsOffline
	}
	return false
}

func (m *SlaveDetail) GetCpuShareNum() int32 {
	if m != nil && m.CpuShareNum != nil {
		return *m.CpuShareNum
	}
	return 0
}

func (m *SlaveDetail) GetLabels() []*Parameter {
	if m != nil {
		return m.Labels
	}
	return nil
}

type NameAmount struct {
	Name                 *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Amount               *int32   `protobuf:"varint,2,opt,name=amount" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NameAmount proto.InternalMessageInfo

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

func (m *NameAmount) GetAmount() int32 {
	if m != nil && m.Amount != nil {
		return *m.Amount
	}
	return 0
}

type SlotAssignment struct {
	SlotId           *int32                      `protobuf:"varint,1,opt,name=slotId" json:"slotId,omitempty"`
	ApplicationId    *string                     `protobuf:"bytes,2,opt,name=applicationId" json:"applicationId,omitempty"`
	AppChecksum      *int64                      `protobuf:"varint,3,opt,name=appChecksum" json:"appChecksum,omitempty"`
	ResourceTag      *string                     `protobuf:"bytes,4,opt,name=resourceTag" json:"resourceTag,omitempty"`
	SlotConfig       *ApplicationSlotConfig      `protobuf:"bytes,5,opt,name=slotConfig" json:"slotConfig,omitempty"`
	SlotResource     *SlotResource               `protobuf:"bytes,6,opt,name=slotResource" json:"slotResource,omitempty"`
	ConstraintPolicy *uint64                     `protobuf:"varint,7,opt,name=constraintPolicy" json:"constraintPolicy,omitempty"`
	SystemSlot       *bool                       `protobuf:"varint,8,opt,name=systemSlot" json:"systemSlot,omitempty"`
	WorkDirTag       *string                     `protobuf:"bytes,9,opt,name=workDirTag" json:"workDirTag,omitempty"`
	UseCpuset        *bool                       `protobuf:"varint,10,opt,name=useCpuset" json:"useCpuset,omitempty"`
	UseHostWorkdir   *bool                       `protobuf:"varint,11,opt,name=useHostWorkdir,def=1" json:"useHostWorkdir,omitempty"`
	CpusetMode       *ResourceRequest_CpusetMode `protobuf:"varint,12,opt,name=cpusetMode,enum=hippo.ResourceRequest_CpusetMode" json:"cpusetMode,omitempty"`
	ContainerConfigs []string                    `protobuf:"bytes,13,rep,name=containerConfigs" json:"containerConfigs,omitempty"`
	DeclareTime      *int64                      `protobuf:"varint,14,opt,name=declareTime" json:"declareTime,omitempty"`
	Priority         *Priority                   `protobuf:"bytes,15,opt,name=priority" json:"priority,omitempty"`
	SlotState        *SlotState                  `protobuf:"varint,16,opt,name=slotState,enum=hippo.SlotState" json:"slotState,omitempty"`
	RequirementId    *string                     `protobuf:"bytes,17,opt,name=requirementId" json:"requirementId,omitempty"`
	// don't use
	Container            *string      `protobuf:"bytes,18,opt,name=container" json:"container,omitempty"`
	GroupId              *string      `protobuf:"bytes,19,opt,name=groupId" json:"groupId,omitempty"`
	Spec                 []*Parameter `protobuf:"bytes,20,rep,name=spec" json:"spec,omitempty"`
	Mempolicy            *MemPolicy   `protobuf:"varint,21,opt,name=mempolicy,enum=hippo.MemPolicy" json:"mempolicy,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_SlotAssignment proto.InternalMessageInfo

const Default_SlotAssignment_UseHostWorkdir bool = true

func (m *SlotAssignment) GetSlotId() int32 {
	if m != nil && m.SlotId != nil {
		return *m.SlotId
	}
	return 0
}

func (m *SlotAssignment) GetApplicationId() string {
	if m != nil && m.ApplicationId != nil {
		return *m.ApplicationId
	}
	return ""
}

func (m *SlotAssignment) GetAppChecksum() int64 {
	if m != nil && m.AppChecksum != nil {
		return *m.AppChecksum
	}
	return 0
}

func (m *SlotAssignment) GetResourceTag() string {
	if m != nil && m.ResourceTag != nil {
		return *m.ResourceTag
	}
	return ""
}

func (m *SlotAssignment) GetSlotConfig() *ApplicationSlotConfig {
	if m != nil {
		return m.SlotConfig
	}
	return nil
}

func (m *SlotAssignment) GetSlotResource() *SlotResource {
	if m != nil {
		return m.SlotResource
	}
	return nil
}

func (m *SlotAssignment) GetConstraintPolicy() uint64 {
	if m != nil && m.ConstraintPolicy != nil {
		return *m.ConstraintPolicy
	}
	return 0
}

func (m *SlotAssignment) GetSystemSlot() bool {
	if m != nil && m.SystemSlot != nil {
		return *m.SystemSlot
	}
	return false
}

func (m *SlotAssignment) GetWorkDirTag() string {
	if m != nil && m.WorkDirTag != nil {
		return *m.WorkDirTag
	}
	return ""
}

func (m *SlotAssignment) GetUseCpuset() bool {
	if m != nil && m.UseCpuset != nil {
		return *m.UseCpuset
	}
	return false
}

func (m *SlotAssignment) GetUseHostWorkdir() bool {
	if m != nil && m.UseHostWorkdir != nil {
		return *m.UseHostWorkdir
	}
	return Default_SlotAssignment_UseHostWorkdir
}

func (m *SlotAssignment) GetCpusetMode() ResourceRequest_CpusetMode {
	if m != nil && m.CpusetMode != nil {
		return *m.CpusetMode
	}
	return ResourceRequest_NONE
}

func (m *SlotAssignment) GetContainerConfigs() []string {
	if m != nil {
		return m.ContainerConfigs
	}
	return nil
}

func (m *SlotAssignment) GetDeclareTime() int64 {
	if m != nil && m.DeclareTime != nil {
		return *m.DeclareTime
	}
	return 0
}

func (m *SlotAssignment) GetPriority() *Priority {
	if m != nil {
		return m.Priority
	}
	return nil
}

func (m *SlotAssignment) GetSlotState() SlotState {
	if m != nil && m.SlotState != nil {
		return *m.SlotState
	}
	return SlotState_SS_NORMAL
}

func (m *SlotAssignment) GetRequirementId() string {
	if m != nil && m.RequirementId != nil {
		return *m.RequirementId
	}
	return ""
}

func (m *SlotAssignment) GetContainer() string {
	if m != nil && m.Container != nil {
		return *m.Container
	}
	return ""
}

func (m *SlotAssignment) GetGroupId() string {
	if m != nil && m.GroupId != nil {
		return *m.GroupId
	}
	return ""
}

func (m *SlotAssignment) GetSpec() []*Parameter {
	if m != nil {
		return m.Spec
	}
	return nil
}

func (m *SlotAssignment) GetMempolicy() MemPolicy {
	if m != nil && m.Mempolicy != nil {
		return *m.Mempolicy
	}
	return MemPolicy_MEM_UNDEFINE
}

type SlaveAssignment struct {
	SlotAssignments      []*SlotAssignment `protobuf:"bytes,1,rep,name=slotAssignments" json:"slotAssignments,omitempty"`
	GrantedResource      *GrantedResource  `protobuf:"bytes,2,opt,name=grantedResource" json:"grantedResource,omitempty"`
	GrantedQueue         *string           `protobuf:"bytes,3,opt,name=grantedQueue" json:"grantedQueue,omitempty"`
	Labels               []*Parameter      `protobuf:"bytes,4,rep,name=labels" json:"labels,omitempty"`
	IsOffline            *bool             `protobuf:"varint,5,opt,name=isOffline,def=0" json:"isOffline,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_SlaveAssignment proto.InternalMessageInfo

const Default_SlaveAssignment_IsOffline bool = false

func (m *SlaveAssignment) GetSlotAssignments() []*SlotAssignment {
	if m != nil {
		return m.SlotAssignments
	}
	return nil
}

func (m *SlaveAssignment) GetGrantedResource() *GrantedResource {
	if m != nil {
		return m.GrantedResource
	}
	return nil
}

func (m *SlaveAssignment) GetGrantedQueue() string {
	if m != nil && m.GrantedQueue != nil {
		return *m.GrantedQueue
	}
	return ""
}

func (m *SlaveAssignment) GetLabels() []*Parameter {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *SlaveAssignment) GetIsOffline() bool {
	if m != nil && m.IsOffline != nil {
		return *m.IsOffline
	}
	return Default_SlaveAssignment_IsOffline
}

type SystemConfig struct {
	Configs              []*Parameter `protobuf:"bytes,1,rep,name=configs" json:"configs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_SystemConfig proto.InternalMessageInfo

func (m *SystemConfig) GetConfigs() []*Parameter {
	if m != nil {
		return m.Configs
	}
	return nil
}

type SystemInfo struct {
	SystemConfig         *SystemConfig       `protobuf:"bytes,1,opt,name=systemConfig" json:"systemConfig,omitempty"`
	SystemStatus         *SystemStatus       `protobuf:"bytes,2,opt,name=systemStatus" json:"systemStatus,omitempty"`
	RuntimeConfig        *SlaveRuntimeConfig `protobuf:"bytes,3,opt,name=runtimeConfig" json:"runtimeConfig,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_SystemInfo proto.InternalMessageInfo

func (m *SystemInfo) GetSystemConfig() *SystemConfig {
	if m != nil {
		return m.SystemConfig
	}
	return nil
}

func (m *SystemInfo) GetSystemStatus() *SystemStatus {
	if m != nil {
		return m.SystemStatus
	}
	return nil
}

func (m *SystemInfo) GetRuntimeConfig() *SlaveRuntimeConfig {
	if m != nil {
		return m.RuntimeConfig
	}
	return nil
}

type ProcessLaunchRequest struct {
	ApplicationId        *string               `protobuf:"bytes,1,opt,name=applicationId" json:"applicationId,omitempty"`
	AppChecksum          *int64                `protobuf:"varint,2,opt,name=appChecksum" json:"appChecksum,omitempty"`
	SlotId               *int32                `protobuf:"varint,3,opt,name=slotId" json:"slotId,omitempty"`
	ProcessContext       *ProcessLaunchContext `protobuf:"bytes,4,opt,name=processContext" json:"processContext,omitempty"`
	DeclareTime          *int64                `protobuf:"varint,5,opt,name=declareTime" json:"declareTime,omitempty"`
	RequirementId        *string               `protobuf:"bytes,6,opt,name=requirementId" json:"requirementId,omitempty"`
	FillExtraInfo        *bool                 `protobuf:"varint,7,opt,name=fillExtraInfo,def=0" json:"fillExtraInfo,omitempty"`
	K8SPodUID            *string               `protobuf:"bytes,8,opt,name=k8sPodUID" json:"k8sPodUID,omitempty"`
	K8SPodName           *string               `protobuf:"bytes,9,opt,name=k8sPodName" json:"k8sPodName,omitempty"`
	K8SNamespace         *string               `protobuf:"bytes,10,opt,name=k8sNamespace" json:"k8sNamespace,omitempty"`
	LaunchSignature      *int64                `protobuf:"varint,11,opt,name=launchSignature" json:"launchSignature,omitempty"`
	PackageChecksum      *string               `protobuf:"bytes,12,opt,name=packageChecksum" json:"packageChecksum,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

var xxx_messageInfo_ProcessLaunchRequest proto.InternalMessageInfo

const Default_ProcessLaunchRequest_FillExtraInfo bool = false

func (m *ProcessLaunchRequest) GetApplicationId() string {
	if m != nil && m.ApplicationId != nil {
		return *m.ApplicationId
	}
	return ""
}

func (m *ProcessLaunchRequest) GetAppChecksum() int64 {
	if m != nil && m.AppChecksum != nil {
		return *m.AppChecksum
	}
	return 0
}

func (m *ProcessLaunchRequest) GetSlotId() int32 {
	if m != nil && m.SlotId != nil {
		return *m.SlotId
	}
	return 0
}

func (m *ProcessLaunchRequest) GetProcessContext() *ProcessLaunchContext {
	if m != nil {
		return m.ProcessContext
	}
	return nil
}

func (m *ProcessLaunchRequest) GetDeclareTime() int64 {
	if m != nil && m.DeclareTime != nil {
		return *m.DeclareTime
	}
	return 0
}

func (m *ProcessLaunchRequest) GetRequirementId() string {
	if m != nil && m.RequirementId != nil {
		return *m.RequirementId
	}
	return ""
}

func (m *ProcessLaunchRequest) GetFillExtraInfo() bool {
	if m != nil && m.FillExtraInfo != nil {
		return *m.FillExtraInfo
	}
	return Default_ProcessLaunchRequest_FillExtraInfo
}

func (m *ProcessLaunchRequest) GetK8SPodUID() string {
	if m != nil && m.K8SPodUID != nil {
		return *m.K8SPodUID
	}
	return ""
}

func (m *ProcessLaunchRequest) GetK8SPodName() string {
	if m != nil && m.K8SPodName != nil {
		return *m.K8SPodName
	}
	return ""
}

func (m *ProcessLaunchRequest) GetK8SNamespace() string {
	if m != nil && m.K8SNamespace != nil {
		return *m.K8SNamespace
	}
	return ""
}

func (m *ProcessLaunchRequest) GetLaunchSignature() int64 {
	if m != nil && m.LaunchSignature != nil {
		return *m.LaunchSignature
	}
	return 0
}

func (m *ProcessLaunchRequest) GetPackageChecksum() string {
	if m != nil && m.PackageChecksum != nil {
		return *m.PackageChecksum
	}
	return ""
}

type ProcessLaunchResponse struct {
	LaunchStatus         *ProcessLaunchResponse_ProcessLaunchStatus `protobuf:"varint,1,opt,name=launchStatus,enum=hippo.ProcessLaunchResponse_ProcessLaunchStatus" json:"launchStatus,omitempty"`
	Diagnostic           *string                                    `protobuf:"bytes,2,opt,name=diagnostic" json:"diagnostic,omitempty"`
	ExtraInfo            *ProcessLaunchExtraInfo                    `protobuf:"bytes,3,opt,name=extraInfo" json:"extraInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                   `json:"-"`
	XXX_unrecognized     []byte                                     `json:"-"`
	XXX_sizecache        int32                                      `json:"-"`
}

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

var xxx_messageInfo_ProcessLaunchResponse proto.InternalMessageInfo

func (m *ProcessLaunchResponse) GetLaunchStatus() ProcessLaunchResponse_ProcessLaunchStatus {
	if m != nil && m.LaunchStatus != nil {
		return *m.LaunchStatus
	}
	return ProcessLaunchResponse_SLOT_ACCEPTED
}

func (m *ProcessLaunchResponse) GetDiagnostic() string {
	if m != nil && m.Diagnostic != nil {
		return *m.Diagnostic
	}
	return ""
}

func (m *ProcessLaunchResponse) GetExtraInfo() *ProcessLaunchExtraInfo {
	if m != nil {
		return m.ExtraInfo
	}
	return nil
}

type ProcessTerminateRequest struct {
	SlotId               *int32   `protobuf:"varint,1,opt,name=slotId" json:"slotId,omitempty"`
	ApplicationId        *string  `protobuf:"bytes,2,opt,name=applicationId" json:"applicationId,omitempty"`
	AppChecksum          *int64   `protobuf:"varint,3,opt,name=appChecksum" json:"appChecksum,omitempty"`
	All                  *bool    `protobuf:"varint,4,opt,name=all" json:"all,omitempty"`
	ProcessName          []string `protobuf:"bytes,5,rep,name=processName" json:"processName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ProcessTerminateRequest proto.InternalMessageInfo

func (m *ProcessTerminateRequest) GetSlotId() int32 {
	if m != nil && m.SlotId != nil {
		return *m.SlotId
	}
	return 0
}

func (m *ProcessTerminateRequest) GetApplicationId() string {
	if m != nil && m.ApplicationId != nil {
		return *m.ApplicationId
	}
	return ""
}

func (m *ProcessTerminateRequest) GetAppChecksum() int64 {
	if m != nil && m.AppChecksum != nil {
		return *m.AppChecksum
	}
	return 0
}

func (m *ProcessTerminateRequest) GetAll() bool {
	if m != nil && m.All != nil {
		return *m.All
	}
	return false
}

func (m *ProcessTerminateRequest) GetProcessName() []string {
	if m != nil {
		return m.ProcessName
	}
	return nil
}

type ProcessTerminateResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ProcessTerminateResponse proto.InternalMessageInfo

type StopRequest struct {
	CleanUp              *bool    `protobuf:"varint,1,opt,name=cleanUp,def=0" json:"cleanUp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StopRequest proto.InternalMessageInfo

const Default_StopRequest_CleanUp bool = false

func (m *StopRequest) GetCleanUp() bool {
	if m != nil && m.CleanUp != nil {
		return *m.CleanUp
	}
	return Default_StopRequest_CleanUp
}

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

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

var xxx_messageInfo_ResetSlotRequest proto.InternalMessageInfo

func (m *ResetSlotRequest) GetSlotId() int32 {
	if m != nil && m.SlotId != nil {
		return *m.SlotId
	}
	return 0
}

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

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

var xxx_messageInfo_KillSlotRequest proto.InternalMessageInfo

func (m *KillSlotRequest) GetSlotId() int32 {
	if m != nil && m.SlotId != nil {
		return *m.SlotId
	}
	return 0
}

type GetSlotDetailsRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetSlotDetailsRequest proto.InternalMessageInfo

type GetSlotDetailsResponse struct {
	SlaveDetail          *SlaveDetail `protobuf:"bytes,1,opt,name=slaveDetail" json:"slaveDetail,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_GetSlotDetailsResponse proto.InternalMessageInfo

func (m *GetSlotDetailsResponse) GetSlaveDetail() *SlaveDetail {
	if m != nil {
		return m.SlaveDetail
	}
	return nil
}

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

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

var xxx_messageInfo_GetSlotDetailRequest proto.InternalMessageInfo

func (m *GetSlotDetailRequest) GetSlotId() int32 {
	if m != nil && m.SlotId != nil {
		return *m.SlotId
	}
	return 0
}

type GetSlotDetailResponse struct {
	SlotDetail           *SlotDetail `protobuf:"bytes,1,opt,name=slotDetail" json:"slotDetail,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_GetSlotDetailResponse proto.InternalMessageInfo

func (m *GetSlotDetailResponse) GetSlotDetail() *SlotDetail {
	if m != nil {
		return m.SlotDetail
	}
	return nil
}

type RebindAllSlotCpusetRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RebindAllSlotCpusetRequest proto.InternalMessageInfo

type RebindAllSlotCpusetResponse struct {
	ErrorInfo            *ErrorInfo `protobuf:"bytes,1,opt,name=errorInfo" json:"errorInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_RebindAllSlotCpusetResponse proto.InternalMessageInfo

func (m *RebindAllSlotCpusetResponse) GetErrorInfo() *ErrorInfo {
	if m != nil {
		return m.ErrorInfo
	}
	return nil
}

type SlaveNodeLoadInfoRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SlaveNodeLoadInfoRequest proto.InternalMessageInfo

type SlaveNodeLoadInfoResponse struct {
	SlaveNodeLoadInfo    *SlaveNodeLoadInfo `protobuf:"bytes,1,opt,name=slaveNodeLoadInfo" json:"slaveNodeLoadInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_SlaveNodeLoadInfoResponse proto.InternalMessageInfo

func (m *SlaveNodeLoadInfoResponse) GetSlaveNodeLoadInfo() *SlaveNodeLoadInfo {
	if m != nil {
		return m.SlaveNodeLoadInfo
	}
	return nil
}

type SlaveHealthInfoRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SlaveHealthInfoRequest proto.InternalMessageInfo

type SlaveHealthInfoResponse struct {
	SlaveHealth          *SlaveHealth `protobuf:"bytes,1,opt,name=slaveHealth" json:"slaveHealth,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_SlaveHealthInfoResponse proto.InternalMessageInfo

func (m *SlaveHealthInfoResponse) GetSlaveHealth() *SlaveHealth {
	if m != nil {
		return m.SlaveHealth
	}
	return nil
}

type HeartbeatRequest struct {
	SlaveAssignment      *SlaveAssignment `protobuf:"bytes,1,opt,name=slaveAssignment" json:"slaveAssignment,omitempty"`
	SystemInfo           *SystemInfo      `protobuf:"bytes,2,opt,name=systemInfo" json:"systemInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_HeartbeatRequest proto.InternalMessageInfo

func (m *HeartbeatRequest) GetSlaveAssignment() *SlaveAssignment {
	if m != nil {
		return m.SlaveAssignment
	}
	return nil
}

func (m *HeartbeatRequest) GetSystemInfo() *SystemInfo {
	if m != nil {
		return m.SystemInfo
	}
	return nil
}

type HeartbeatResponse struct {
	SlaveInfo            *SlaveInfo `protobuf:"bytes,1,opt,name=slaveInfo" json:"slaveInfo,omitempty"`
	NeedReport           *bool      `protobuf:"varint,2,opt,name=needReport,def=1" json:"needReport,omitempty"`
	ErrorInfo            *ErrorInfo `protobuf:"bytes,3,opt,name=errorInfo" json:"errorInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_HeartbeatResponse proto.InternalMessageInfo

const Default_HeartbeatResponse_NeedReport bool = true

func (m *HeartbeatResponse) GetSlaveInfo() *SlaveInfo {
	if m != nil {
		return m.SlaveInfo
	}
	return nil
}

func (m *HeartbeatResponse) GetNeedReport() bool {
	if m != nil && m.NeedReport != nil {
		return *m.NeedReport
	}
	return Default_HeartbeatResponse_NeedReport
}

func (m *HeartbeatResponse) GetErrorInfo() *ErrorInfo {
	if m != nil {
		return m.ErrorInfo
	}
	return nil
}

type UpdatePackageVersionRequest struct {
	PackageURI           []string `protobuf:"bytes,1,rep,name=packageURI" json:"packageURI,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UpdatePackageVersionRequest proto.InternalMessageInfo

func (m *UpdatePackageVersionRequest) GetPackageURI() []string {
	if m != nil {
		return m.PackageURI
	}
	return nil
}

type UpdatePackageVersionResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UpdatePackageVersionResponse proto.InternalMessageInfo

type CpuAllocatorDebugInfo struct {
	Id                   *int32   `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
	CpuWmark             *int32   `protobuf:"varint,2,opt,name=cpuWmark,def=0" json:"cpuWmark,omitempty"`
	MinCpuNumFactor      *float64 `protobuf:"fixed64,3,opt,name=minCpuNumFactor,def=0" json:"minCpuNumFactor,omitempty"`
	MaxCpuNumFactor      *float64 `protobuf:"fixed64,4,opt,name=maxCpuNumFactor,def=0" json:"maxCpuNumFactor,omitempty"`
	Exclusive            *bool    `protobuf:"varint,5,opt,name=exclusive,def=0" json:"exclusive,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CpuAllocatorDebugInfo proto.InternalMessageInfo

const Default_CpuAllocatorDebugInfo_CpuWmark int32 = 0
const Default_CpuAllocatorDebugInfo_MinCpuNumFactor float64 = 0
const Default_CpuAllocatorDebugInfo_MaxCpuNumFactor float64 = 0
const Default_CpuAllocatorDebugInfo_Exclusive bool = false

func (m *CpuAllocatorDebugInfo) GetId() int32 {
	if m != nil && m.Id != nil {
		return *m.Id
	}
	return 0
}

func (m *CpuAllocatorDebugInfo) GetCpuWmark() int32 {
	if m != nil && m.CpuWmark != nil {
		return *m.CpuWmark
	}
	return Default_CpuAllocatorDebugInfo_CpuWmark
}

func (m *CpuAllocatorDebugInfo) GetMinCpuNumFactor() float64 {
	if m != nil && m.MinCpuNumFactor != nil {
		return *m.MinCpuNumFactor
	}
	return Default_CpuAllocatorDebugInfo_MinCpuNumFactor
}

func (m *CpuAllocatorDebugInfo) GetMaxCpuNumFactor() float64 {
	if m != nil && m.MaxCpuNumFactor != nil {
		return *m.MaxCpuNumFactor
	}
	return Default_CpuAllocatorDebugInfo_MaxCpuNumFactor
}

func (m *CpuAllocatorDebugInfo) GetExclusive() bool {
	if m != nil && m.Exclusive != nil {
		return *m.Exclusive
	}
	return Default_CpuAllocatorDebugInfo_Exclusive
}

type CpuAllocatorDetail struct {
	Id                   *int32   `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
	AppId                *string  `protobuf:"bytes,2,opt,name=appId" json:"appId,omitempty"`
	Role                 *string  `protobuf:"bytes,3,opt,name=role" json:"role,omitempty"`
	GrantedCpusets       *string  `protobuf:"bytes,4,opt,name=grantedCpusets" json:"grantedCpusets,omitempty"`
	ElasticCpusets       *string  `protobuf:"bytes,5,opt,name=elasticCpusets" json:"elasticCpusets,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CpuAllocatorDetail proto.InternalMessageInfo

func (m *CpuAllocatorDetail) GetId() int32 {
	if m != nil && m.Id != nil {
		return *m.Id
	}
	return 0
}

func (m *CpuAllocatorDetail) GetAppId() string {
	if m != nil && m.AppId != nil {
		return *m.AppId
	}
	return ""
}

func (m *CpuAllocatorDetail) GetRole() string {
	if m != nil && m.Role != nil {
		return *m.Role
	}
	return ""
}

func (m *CpuAllocatorDetail) GetGrantedCpusets() string {
	if m != nil && m.GrantedCpusets != nil {
		return *m.GrantedCpusets
	}
	return ""
}

func (m *CpuAllocatorDetail) GetElasticCpusets() string {
	if m != nil && m.ElasticCpusets != nil {
		return *m.ElasticCpusets
	}
	return ""
}

type CpuAllocatorDebugInfoRequest struct {
	Op                   *Operator                `protobuf:"varint,1,opt,name=op,enum=hippo.Operator,def=3" json:"op,omitempty"`
	Allocator            *string                  `protobuf:"bytes,2,opt,name=allocator" json:"allocator,omitempty"`
	Debugs               []*CpuAllocatorDebugInfo `protobuf:"bytes,3,rep,name=debugs" json:"debugs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

var xxx_messageInfo_CpuAllocatorDebugInfoRequest proto.InternalMessageInfo

const Default_CpuAllocatorDebugInfoRequest_Op Operator = Operator_GET

func (m *CpuAllocatorDebugInfoRequest) GetOp() Operator {
	if m != nil && m.Op != nil {
		return *m.Op
	}
	return Default_CpuAllocatorDebugInfoRequest_Op
}

func (m *CpuAllocatorDebugInfoRequest) GetAllocator() string {
	if m != nil && m.Allocator != nil {
		return *m.Allocator
	}
	return ""
}

func (m *CpuAllocatorDebugInfoRequest) GetDebugs() []*CpuAllocatorDebugInfo {
	if m != nil {
		return m.Debugs
	}
	return nil
}

type CpuAllocatorDebugInfoResponse struct {
	Allocator            *string                  `protobuf:"bytes,1,opt,name=allocator" json:"allocator,omitempty"`
	Details              []*CpuAllocatorDetail    `protobuf:"bytes,2,rep,name=details" json:"details,omitempty"`
	Debugs               []*CpuAllocatorDebugInfo `protobuf:"bytes,3,rep,name=debugs" json:"debugs,omitempty"`
	ErrorInfo            *ErrorInfo               `protobuf:"bytes,4,opt,name=errorInfo" json:"errorInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

var xxx_messageInfo_CpuAllocatorDebugInfoResponse proto.InternalMessageInfo

func (m *CpuAllocatorDebugInfoResponse) GetAllocator() string {
	if m != nil && m.Allocator != nil {
		return *m.Allocator
	}
	return ""
}

func (m *CpuAllocatorDebugInfoResponse) GetDetails() []*CpuAllocatorDetail {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *CpuAllocatorDebugInfoResponse) GetDebugs() []*CpuAllocatorDebugInfo {
	if m != nil {
		return m.Debugs
	}
	return nil
}

func (m *CpuAllocatorDebugInfoResponse) GetErrorInfo() *ErrorInfo {
	if m != nil {
		return m.ErrorInfo
	}
	return nil
}

type SlotResourceTunning struct {
	Id                   *int32   `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
	CpuQuota             *int64   `protobuf:"varint,2,opt,name=cpuQuota" json:"cpuQuota,omitempty"`
	CpuShare             *int64   `protobuf:"varint,3,opt,name=cpuShare" json:"cpuShare,omitempty"`
	Memory               *int64   `protobuf:"varint,4,opt,name=memory" json:"memory,omitempty"`
	ColdMemThreshold     *int64   `protobuf:"varint,5,opt,name=coldMemThreshold" json:"coldMemThreshold,omitempty"`
	MemoryWmark          *int64   `protobuf:"varint,6,opt,name=memoryWmark" json:"memoryWmark,omitempty"`
	DiskWriteBps         *int64   `protobuf:"varint,7,opt,name=diskWriteBps" json:"diskWriteBps,omitempty"`
	DiskReadBps          *int64   `protobuf:"varint,8,opt,name=diskReadBps" json:"diskReadBps,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SlotResourceTunning proto.InternalMessageInfo

func (m *SlotResourceTunning) GetId() int32 {
	if m != nil && m.Id != nil {
		return *m.Id
	}
	return 0
}

func (m *SlotResourceTunning) GetCpuQuota() int64 {
	if m != nil && m.CpuQuota != nil {
		return *m.CpuQuota
	}
	return 0
}

func (m *SlotResourceTunning) GetCpuShare() int64 {
	if m != nil && m.CpuShare != nil {
		return *m.CpuShare
	}
	return 0
}

func (m *SlotResourceTunning) GetMemory() int64 {
	if m != nil && m.Memory != nil {
		return *m.Memory
	}
	return 0
}

func (m *SlotResourceTunning) GetColdMemThreshold() int64 {
	if m != nil && m.ColdMemThreshold != nil {
		return *m.ColdMemThreshold
	}
	return 0
}

func (m *SlotResourceTunning) GetMemoryWmark() int64 {
	if m != nil && m.MemoryWmark != nil {
		return *m.MemoryWmark
	}
	return 0
}

func (m *SlotResourceTunning) GetDiskWriteBps() int64 {
	if m != nil && m.DiskWriteBps != nil {
		return *m.DiskWriteBps
	}
	return 0
}

func (m *SlotResourceTunning) GetDiskReadBps() int64 {
	if m != nil && m.DiskReadBps != nil {
		return *m.DiskReadBps
	}
	return 0
}

type SlotResourceTunningRequest struct {
	Op                   *Operator              `protobuf:"varint,1,opt,name=op,enum=hippo.Operator,def=3" json:"op,omitempty"`
	Tunnings             []*SlotResourceTunning `protobuf:"bytes,2,rep,name=tunnings" json:"tunnings,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_SlotResourceTunningRequest proto.InternalMessageInfo

const Default_SlotResourceTunningRequest_Op Operator = Operator_GET

func (m *SlotResourceTunningRequest) GetOp() Operator {
	if m != nil && m.Op != nil {
		return *m.Op
	}
	return Default_SlotResourceTunningRequest_Op
}

func (m *SlotResourceTunningRequest) GetTunnings() []*SlotResourceTunning {
	if m != nil {
		return m.Tunnings
	}
	return nil
}

type SlotResourceTunningResponse struct {
	Tunnings             []*SlotResourceTunning `protobuf:"bytes,1,rep,name=tunnings" json:"tunnings,omitempty"`
	ErrorInfo            *ErrorInfo             `protobuf:"bytes,2,opt,name=errorInfo" json:"errorInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_SlotResourceTunningResponse proto.InternalMessageInfo

func (m *SlotResourceTunningResponse) GetTunnings() []*SlotResourceTunning {
	if m != nil {
		return m.Tunnings
	}
	return nil
}

func (m *SlotResourceTunningResponse) GetErrorInfo() *ErrorInfo {
	if m != nil {
		return m.ErrorInfo
	}
	return nil
}

type OutlierEvent struct {
	Metric               *string  `protobuf:"bytes,1,opt,name=metric" json:"metric,omitempty"`
	AppId                *string  `protobuf:"bytes,2,opt,name=appId" json:"appId,omitempty"`
	Role                 *string  `protobuf:"bytes,3,opt,name=role" json:"role,omitempty"`
	SlotId               *int32   `protobuf:"varint,4,opt,name=slotId" json:"slotId,omitempty"`
	Type                 *string  `protobuf:"bytes,5,opt,name=type" json:"type,omitempty"`
	Outlier              *float64 `protobuf:"fixed64,6,opt,name=outlier" json:"outlier,omitempty"`
	Median               *float64 `protobuf:"fixed64,7,opt,name=median" json:"median,omitempty"`
	Suspects             []int32  `protobuf:"varint,8,rep,name=suspects" json:"suspects,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_OutlierEvent proto.InternalMessageInfo

func (m *OutlierEvent) GetMetric() string {
	if m != nil && m.Metric != nil {
		return *m.Metric
	}
	return ""
}

func (m *OutlierEvent) GetAppId() string {
	if m != nil && m.AppId != nil {
		return *m.AppId
	}
	return ""
}

func (m *OutlierEvent) GetRole() string {
	if m != nil && m.Role != nil {
		return *m.Role
	}
	return ""
}

func (m *OutlierEvent) GetSlotId() int32 {
	if m != nil && m.SlotId != nil {
		return *m.SlotId
	}
	return 0
}

func (m *OutlierEvent) GetType() string {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return ""
}

func (m *OutlierEvent) GetOutlier() float64 {
	if m != nil && m.Outlier != nil {
		return *m.Outlier
	}
	return 0
}

func (m *OutlierEvent) GetMedian() float64 {
	if m != nil && m.Median != nil {
		return *m.Median
	}
	return 0
}

func (m *OutlierEvent) GetSuspects() []int32 {
	if m != nil {
		return m.Suspects
	}
	return nil
}

type OutlierEventRequest struct {
	Op                   *Operator       `protobuf:"varint,1,opt,name=op,enum=hippo.Operator,def=0" json:"op,omitempty"`
	Events               []*OutlierEvent `protobuf:"bytes,2,rep,name=events" json:"events,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_OutlierEventRequest proto.InternalMessageInfo

const Default_OutlierEventRequest_Op Operator = Operator_ADD

func (m *OutlierEventRequest) GetOp() Operator {
	if m != nil && m.Op != nil {
		return *m.Op
	}
	return Default_OutlierEventRequest_Op
}

func (m *OutlierEventRequest) GetEvents() []*OutlierEvent {
	if m != nil {
		return m.Events
	}
	return nil
}

type OutlierEventResponse struct {
	Events               []string   `protobuf:"bytes,1,rep,name=events" json:"events,omitempty"`
	ErrorInfo            *ErrorInfo `protobuf:"bytes,10,opt,name=errorInfo" json:"errorInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_OutlierEventResponse proto.InternalMessageInfo

func (m *OutlierEventResponse) GetEvents() []string {
	if m != nil {
		return m.Events
	}
	return nil
}

func (m *OutlierEventResponse) GetErrorInfo() *ErrorInfo {
	if m != nil {
		return m.ErrorInfo
	}
	return nil
}

func init() {
	proto.RegisterEnum("hippo.MemPolicy", MemPolicy_name, MemPolicy_value)
	proto.RegisterEnum("hippo.SlotState", SlotState_name, SlotState_value)
	proto.RegisterEnum("hippo.ExecutionType", ExecutionType_name, ExecutionType_value)
	proto.RegisterEnum("hippo.ProcessLaunchResponse_ProcessLaunchStatus", ProcessLaunchResponse_ProcessLaunchStatus_name, ProcessLaunchResponse_ProcessLaunchStatus_value)
	proto.RegisterType((*Metric)(nil), "hippo.Metric")
	proto.RegisterType((*SocketInfo)(nil), "hippo.SocketInfo")
	proto.RegisterType((*SocketNodePolicy)(nil), "hippo.SocketNodePolicy")
	proto.RegisterType((*SlotInfo)(nil), "hippo.SlotInfo")
	proto.RegisterType((*SlaveInfo)(nil), "hippo.SlaveInfo")
	proto.RegisterType((*SlotDetail)(nil), "hippo.SlotDetail")
	proto.RegisterType((*SlaveDetail)(nil), "hippo.SlaveDetail")
	proto.RegisterType((*NameAmount)(nil), "hippo.NameAmount")
	proto.RegisterType((*SlotAssignment)(nil), "hippo.SlotAssignment")
	proto.RegisterType((*SlaveAssignment)(nil), "hippo.SlaveAssignment")
	proto.RegisterType((*SystemConfig)(nil), "hippo.SystemConfig")
	proto.RegisterType((*SystemInfo)(nil), "hippo.SystemInfo")
	proto.RegisterType((*ProcessLaunchRequest)(nil), "hippo.ProcessLaunchRequest")
	proto.RegisterType((*ProcessLaunchResponse)(nil), "hippo.ProcessLaunchResponse")
	proto.RegisterType((*ProcessTerminateRequest)(nil), "hippo.ProcessTerminateRequest")
	proto.RegisterType((*ProcessTerminateResponse)(nil), "hippo.ProcessTerminateResponse")
	proto.RegisterType((*StopRequest)(nil), "hippo.StopRequest")
	proto.RegisterType((*ResetSlotRequest)(nil), "hippo.ResetSlotRequest")
	proto.RegisterType((*KillSlotRequest)(nil), "hippo.KillSlotRequest")
	proto.RegisterType((*GetSlotDetailsRequest)(nil), "hippo.GetSlotDetailsRequest")
	proto.RegisterType((*GetSlotDetailsResponse)(nil), "hippo.GetSlotDetailsResponse")
	proto.RegisterType((*GetSlotDetailRequest)(nil), "hippo.GetSlotDetailRequest")
	proto.RegisterType((*GetSlotDetailResponse)(nil), "hippo.GetSlotDetailResponse")
	proto.RegisterType((*RebindAllSlotCpusetRequest)(nil), "hippo.RebindAllSlotCpusetRequest")
	proto.RegisterType((*RebindAllSlotCpusetResponse)(nil), "hippo.RebindAllSlotCpusetResponse")
	proto.RegisterType((*SlaveNodeLoadInfoRequest)(nil), "hippo.SlaveNodeLoadInfoRequest")
	proto.RegisterType((*SlaveNodeLoadInfoResponse)(nil), "hippo.SlaveNodeLoadInfoResponse")
	proto.RegisterType((*SlaveHealthInfoRequest)(nil), "hippo.SlaveHealthInfoRequest")
	proto.RegisterType((*SlaveHealthInfoResponse)(nil), "hippo.SlaveHealthInfoResponse")
	proto.RegisterType((*HeartbeatRequest)(nil), "hippo.HeartbeatRequest")
	proto.RegisterType((*HeartbeatResponse)(nil), "hippo.HeartbeatResponse")
	proto.RegisterType((*UpdatePackageVersionRequest)(nil), "hippo.UpdatePackageVersionRequest")
	proto.RegisterType((*UpdatePackageVersionResponse)(nil), "hippo.UpdatePackageVersionResponse")
	proto.RegisterType((*CpuAllocatorDebugInfo)(nil), "hippo.CpuAllocatorDebugInfo")
	proto.RegisterType((*CpuAllocatorDetail)(nil), "hippo.CpuAllocatorDetail")
	proto.RegisterType((*CpuAllocatorDebugInfoRequest)(nil), "hippo.CpuAllocatorDebugInfoRequest")
	proto.RegisterType((*CpuAllocatorDebugInfoResponse)(nil), "hippo.CpuAllocatorDebugInfoResponse")
	proto.RegisterType((*SlotResourceTunning)(nil), "hippo.SlotResourceTunning")
	proto.RegisterType((*SlotResourceTunningRequest)(nil), "hippo.SlotResourceTunningRequest")
	proto.RegisterType((*SlotResourceTunningResponse)(nil), "hippo.SlotResourceTunningResponse")
	proto.RegisterType((*OutlierEvent)(nil), "hippo.OutlierEvent")
	proto.RegisterType((*OutlierEventRequest)(nil), "hippo.OutlierEventRequest")
	proto.RegisterType((*OutlierEventResponse)(nil), "hippo.OutlierEventResponse")
}

func init() { proto.RegisterFile("Slave.proto", fileDescriptor_5e466cc5b3932b09) }

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

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

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

func (m *Metric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Time != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.Time))
		i--
		dAtA[i] = 0x18
	}
	if m.Value != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Value))))
		i--
		dAtA[i] = 0x11
	}
	if m.Name != nil {
		i -= len(*m.Name)
		copy(dAtA[i:], *m.Name)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *SocketNodePolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Sockets) > 0 {
		for iNdEx := len(m.Sockets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Sockets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.MemPolicy != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.MemPolicy))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SlotInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SocketPolicy != nil {
		{
			size, err := m.SocketPolicy.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if len(m.Status) > 0 {
		for iNdEx := len(m.Status) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Status[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.PackageDetails) > 0 {
		for iNdEx := len(m.PackageDetails) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PackageDetails[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.Metrics) > 0 {
		for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Metrics[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if m.WorkDirTag != nil {
		i -= len(*m.WorkDirTag)
		copy(dAtA[i:], *m.WorkDirTag)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.WorkDirTag)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if m.Priority != nil {
		{
			size, err := m.Priority.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if m.PreDeployPackageStatus != nil {
		{
			size, err := m.PreDeployPackageStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if m.PreDeployPackageChecksum != nil {
		i -= len(*m.PreDeployPackageChecksum)
		copy(dAtA[i:], *m.PreDeployPackageChecksum)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.PreDeployPackageChecksum)))
		i--
		dAtA[i] = 0x72
	}
	if m.Cpusets != nil {
		i -= len(*m.Cpusets)
		copy(dAtA[i:], *m.Cpusets)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Cpusets)))
		i--
		dAtA[i] = 0x6a
	}
	if m.CpusetMode != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.CpusetMode))
		i--
		dAtA[i] = 0x60
	}
	if m.UseCpuset != nil {
		i--
		if *m.UseCpuset {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x58
	}
	if m.ResourceTag != nil {
		i -= len(*m.ResourceTag)
		copy(dAtA[i:], *m.ResourceTag)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.ResourceTag)))
		i--
		dAtA[i] = 0x52
	}
	if m.SlotResource != nil {
		{
			size, err := m.SlotResource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.PackageStatus != nil {
		{
			size, err := m.PackageStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.PackageChecksum != nil {
		i -= len(*m.PackageChecksum)
		copy(dAtA[i:], *m.PackageChecksum)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.PackageChecksum)))
		i--
		dAtA[i] = 0x3a
	}
	if m.LaunchSignature != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.LaunchSignature))
		i--
		dAtA[i] = 0x30
	}
	if len(m.DataStatus) > 0 {
		for iNdEx := len(m.DataStatus) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DataStatus[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.ProcessStatus) > 0 {
		for iNdEx := len(m.ProcessStatus) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ProcessStatus[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.AppChecksum != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.AppChecksum))
		i--
		dAtA[i] = 0x18
	}
	if m.ApplicationId != nil {
		i -= len(*m.ApplicationId)
		copy(dAtA[i:], *m.ApplicationId)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.ApplicationId)))
		i--
		dAtA[i] = 0x12
	}
	if m.SlotId != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.SlotId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SlaveInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SlaveHealth != nil {
		{
			size, err := m.SlaveHealth.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.SlaveHttpPort != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.SlaveHttpPort))
		i--
		dAtA[i] = 0x48
	}
	if len(m.Metrics) > 0 {
		for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Metrics[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.Labels) > 0 {
		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.RestfulHttpPort != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.RestfulHttpPort))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Attributes) > 0 {
		for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.BinaryVersion != nil {
		i -= len(*m.BinaryVersion)
		copy(dAtA[i:], *m.BinaryVersion)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.BinaryVersion)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Slots) > 0 {
		for iNdEx := len(m.Slots) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Slots[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Resource != nil {
		{
			size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Address != nil {
		i -= len(*m.Address)
		copy(dAtA[i:], *m.Address)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SlotDetail) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Envs) > 0 {
		for iNdEx := len(m.Envs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Envs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Labels) > 0 {
		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.GroupId != nil {
		i -= len(*m.GroupId)
		copy(dAtA[i:], *m.GroupId)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.GroupId)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ContainerConfigs) > 0 {
		for iNdEx := len(m.ContainerConfigs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ContainerConfigs[iNdEx])
			copy(dAtA[i:], m.ContainerConfigs[iNdEx])
			i = encodeVarintSlave(dAtA, i, uint64(len(m.ContainerConfigs[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.WorkDir != nil {
		i -= len(*m.WorkDir)
		copy(dAtA[i:], *m.WorkDir)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.WorkDir)))
		i--
		dAtA[i] = 0x12
	}
	if m.Info != nil {
		{
			size, err := m.Info.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SlaveDetail) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Labels) > 0 {
		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if m.CpuShareNum != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.CpuShareNum))
		i--
		dAtA[i] = 0x40
	}
	if m.IsOffline != nil {
		i--
		if *m.IsOffline {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.GrantedResource != nil {
		{
			size, err := m.GrantedResource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.GrantedQueue != nil {
		i -= len(*m.GrantedQueue)
		copy(dAtA[i:], *m.GrantedQueue)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.GrantedQueue)))
		i--
		dAtA[i] = 0x2a
	}
	if m.BinaryVersion != nil {
		i -= len(*m.BinaryVersion)
		copy(dAtA[i:], *m.BinaryVersion)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.BinaryVersion)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Slots) > 0 {
		for iNdEx := len(m.Slots) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Slots[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Resource != nil {
		{
			size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Address != nil {
		i -= len(*m.Address)
		copy(dAtA[i:], *m.Address)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *NameAmount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Amount != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.Amount))
		i--
		dAtA[i] = 0x10
	}
	if m.Name != nil {
		i -= len(*m.Name)
		copy(dAtA[i:], *m.Name)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SlotAssignment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Mempolicy != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.Mempolicy))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa8
	}
	if len(m.Spec) > 0 {
		for iNdEx := len(m.Spec) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Spec[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if m.GroupId != nil {
		i -= len(*m.GroupId)
		copy(dAtA[i:], *m.GroupId)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.GroupId)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if m.Container != nil {
		i -= len(*m.Container)
		copy(dAtA[i:], *m.Container)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Container)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if m.RequirementId != nil {
		i -= len(*m.RequirementId)
		copy(dAtA[i:], *m.RequirementId)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.RequirementId)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if m.SlotState != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.SlotState))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.Priority != nil {
		{
			size, err := m.Priority.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if m.DeclareTime != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.DeclareTime))
		i--
		dAtA[i] = 0x70
	}
	if len(m.ContainerConfigs) > 0 {
		for iNdEx := len(m.ContainerConfigs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ContainerConfigs[iNdEx])
			copy(dAtA[i:], m.ContainerConfigs[iNdEx])
			i = encodeVarintSlave(dAtA, i, uint64(len(m.ContainerConfigs[iNdEx])))
			i--
			dAtA[i] = 0x6a
		}
	}
	if m.CpusetMode != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.CpusetMode))
		i--
		dAtA[i] = 0x60
	}
	if m.UseHostWorkdir != nil {
		i--
		if *m.UseHostWorkdir {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x58
	}
	if m.UseCpuset != nil {
		i--
		if *m.UseCpuset {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.WorkDirTag != nil {
		i -= len(*m.WorkDirTag)
		copy(dAtA[i:], *m.WorkDirTag)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.WorkDirTag)))
		i--
		dAtA[i] = 0x4a
	}
	if m.SystemSlot != nil {
		i--
		if *m.SystemSlot {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.ConstraintPolicy != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.ConstraintPolicy))
		i--
		dAtA[i] = 0x38
	}
	if m.SlotResource != nil {
		{
			size, err := m.SlotResource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.SlotConfig != nil {
		{
			size, err := m.SlotConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.ResourceTag != nil {
		i -= len(*m.ResourceTag)
		copy(dAtA[i:], *m.ResourceTag)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.ResourceTag)))
		i--
		dAtA[i] = 0x22
	}
	if m.AppChecksum != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.AppChecksum))
		i--
		dAtA[i] = 0x18
	}
	if m.ApplicationId != nil {
		i -= len(*m.ApplicationId)
		copy(dAtA[i:], *m.ApplicationId)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.ApplicationId)))
		i--
		dAtA[i] = 0x12
	}
	if m.SlotId != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.SlotId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SlaveAssignment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.IsOffline != nil {
		i--
		if *m.IsOffline {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.Labels) > 0 {
		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.GrantedQueue != nil {
		i -= len(*m.GrantedQueue)
		copy(dAtA[i:], *m.GrantedQueue)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.GrantedQueue)))
		i--
		dAtA[i] = 0x1a
	}
	if m.GrantedResource != nil {
		{
			size, err := m.GrantedResource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.SlotAssignments) > 0 {
		for iNdEx := len(m.SlotAssignments) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SlotAssignments[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SystemConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Configs) > 0 {
		for iNdEx := len(m.Configs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Configs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SystemInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.RuntimeConfig != nil {
		{
			size, err := m.RuntimeConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.SystemStatus != nil {
		{
			size, err := m.SystemStatus.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.SystemConfig != nil {
		{
			size, err := m.SystemConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ProcessLaunchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.PackageChecksum != nil {
		i -= len(*m.PackageChecksum)
		copy(dAtA[i:], *m.PackageChecksum)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.PackageChecksum)))
		i--
		dAtA[i] = 0x62
	}
	if m.LaunchSignature != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.LaunchSignature))
		i--
		dAtA[i] = 0x58
	}
	if m.K8SNamespace != nil {
		i -= len(*m.K8SNamespace)
		copy(dAtA[i:], *m.K8SNamespace)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.K8SNamespace)))
		i--
		dAtA[i] = 0x52
	}
	if m.K8SPodName != nil {
		i -= len(*m.K8SPodName)
		copy(dAtA[i:], *m.K8SPodName)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.K8SPodName)))
		i--
		dAtA[i] = 0x4a
	}
	if m.K8SPodUID != nil {
		i -= len(*m.K8SPodUID)
		copy(dAtA[i:], *m.K8SPodUID)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.K8SPodUID)))
		i--
		dAtA[i] = 0x42
	}
	if m.FillExtraInfo != nil {
		i--
		if *m.FillExtraInfo {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.RequirementId != nil {
		i -= len(*m.RequirementId)
		copy(dAtA[i:], *m.RequirementId)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.RequirementId)))
		i--
		dAtA[i] = 0x32
	}
	if m.DeclareTime != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.DeclareTime))
		i--
		dAtA[i] = 0x28
	}
	if m.ProcessContext != nil {
		{
			size, err := m.ProcessContext.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.SlotId != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.SlotId))
		i--
		dAtA[i] = 0x18
	}
	if m.AppChecksum != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.AppChecksum))
		i--
		dAtA[i] = 0x10
	}
	if m.ApplicationId != nil {
		i -= len(*m.ApplicationId)
		copy(dAtA[i:], *m.ApplicationId)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.ApplicationId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ProcessLaunchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ExtraInfo != nil {
		{
			size, err := m.ExtraInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Diagnostic != nil {
		i -= len(*m.Diagnostic)
		copy(dAtA[i:], *m.Diagnostic)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Diagnostic)))
		i--
		dAtA[i] = 0x12
	}
	if m.LaunchStatus != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.LaunchStatus))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ProcessTerminateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ProcessName) > 0 {
		for iNdEx := len(m.ProcessName) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ProcessName[iNdEx])
			copy(dAtA[i:], m.ProcessName[iNdEx])
			i = encodeVarintSlave(dAtA, i, uint64(len(m.ProcessName[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.All != nil {
		i--
		if *m.All {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.AppChecksum != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.AppChecksum))
		i--
		dAtA[i] = 0x18
	}
	if m.ApplicationId != nil {
		i -= len(*m.ApplicationId)
		copy(dAtA[i:], *m.ApplicationId)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.ApplicationId)))
		i--
		dAtA[i] = 0x12
	}
	if m.SlotId != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.SlotId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *GetSlotDetailsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SlaveDetail != nil {
		{
			size, err := m.SlaveDetail.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *GetSlotDetailResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SlotDetail != nil {
		{
			size, err := m.SlotDetail.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *RebindAllSlotCpusetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ErrorInfo != nil {
		{
			size, err := m.ErrorInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *SlaveNodeLoadInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SlaveNodeLoadInfo != nil {
		{
			size, err := m.SlaveNodeLoadInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *SlaveHealthInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SlaveHealth != nil {
		{
			size, err := m.SlaveHealth.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *HeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.SystemInfo != nil {
		{
			size, err := m.SystemInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.SlaveAssignment != nil {
		{
			size, err := m.SlaveAssignment.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *HeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ErrorInfo != nil {
		{
			size, err := m.ErrorInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.NeedReport != nil {
		i--
		if *m.NeedReport {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.SlaveInfo != nil {
		{
			size, err := m.SlaveInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *UpdatePackageVersionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.PackageURI) > 0 {
		for iNdEx := len(m.PackageURI) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PackageURI[iNdEx])
			copy(dAtA[i:], m.PackageURI[iNdEx])
			i = encodeVarintSlave(dAtA, i, uint64(len(m.PackageURI[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *CpuAllocatorDebugInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Exclusive != nil {
		i--
		if *m.Exclusive {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.MaxCpuNumFactor != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.MaxCpuNumFactor))))
		i--
		dAtA[i] = 0x21
	}
	if m.MinCpuNumFactor != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.MinCpuNumFactor))))
		i--
		dAtA[i] = 0x19
	}
	if m.CpuWmark != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.CpuWmark))
		i--
		dAtA[i] = 0x10
	}
	if m.Id != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CpuAllocatorDetail) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ElasticCpusets != nil {
		i -= len(*m.ElasticCpusets)
		copy(dAtA[i:], *m.ElasticCpusets)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.ElasticCpusets)))
		i--
		dAtA[i] = 0x2a
	}
	if m.GrantedCpusets != nil {
		i -= len(*m.GrantedCpusets)
		copy(dAtA[i:], *m.GrantedCpusets)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.GrantedCpusets)))
		i--
		dAtA[i] = 0x22
	}
	if m.Role != nil {
		i -= len(*m.Role)
		copy(dAtA[i:], *m.Role)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Role)))
		i--
		dAtA[i] = 0x1a
	}
	if m.AppId != nil {
		i -= len(*m.AppId)
		copy(dAtA[i:], *m.AppId)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.AppId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CpuAllocatorDebugInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Debugs) > 0 {
		for iNdEx := len(m.Debugs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Debugs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Allocator != nil {
		i -= len(*m.Allocator)
		copy(dAtA[i:], *m.Allocator)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Allocator)))
		i--
		dAtA[i] = 0x12
	}
	if m.Op != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.Op))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *CpuAllocatorDebugInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ErrorInfo != nil {
		{
			size, err := m.ErrorInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Debugs) > 0 {
		for iNdEx := len(m.Debugs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Debugs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Details) > 0 {
		for iNdEx := len(m.Details) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Details[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Allocator != nil {
		i -= len(*m.Allocator)
		copy(dAtA[i:], *m.Allocator)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Allocator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SlotResourceTunning) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.DiskReadBps != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.DiskReadBps))
		i--
		dAtA[i] = 0x40
	}
	if m.DiskWriteBps != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.DiskWriteBps))
		i--
		dAtA[i] = 0x38
	}
	if m.MemoryWmark != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.MemoryWmark))
		i--
		dAtA[i] = 0x30
	}
	if m.ColdMemThreshold != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.ColdMemThreshold))
		i--
		dAtA[i] = 0x28
	}
	if m.Memory != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.Memory))
		i--
		dAtA[i] = 0x20
	}
	if m.CpuShare != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.CpuShare))
		i--
		dAtA[i] = 0x18
	}
	if m.CpuQuota != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.CpuQuota))
		i--
		dAtA[i] = 0x10
	}
	if m.Id != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SlotResourceTunningRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Tunnings) > 0 {
		for iNdEx := len(m.Tunnings) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tunnings[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Op != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.Op))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SlotResourceTunningResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ErrorInfo != nil {
		{
			size, err := m.ErrorInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Tunnings) > 0 {
		for iNdEx := len(m.Tunnings) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tunnings[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *OutlierEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Suspects) > 0 {
		for iNdEx := len(m.Suspects) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintSlave(dAtA, i, uint64(m.Suspects[iNdEx]))
			i--
			dAtA[i] = 0x40
		}
	}
	if m.Median != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Median))))
		i--
		dAtA[i] = 0x39
	}
	if m.Outlier != nil {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.Outlier))))
		i--
		dAtA[i] = 0x31
	}
	if m.Type != nil {
		i -= len(*m.Type)
		copy(dAtA[i:], *m.Type)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Type)))
		i--
		dAtA[i] = 0x2a
	}
	if m.SlotId != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.SlotId))
		i--
		dAtA[i] = 0x20
	}
	if m.Role != nil {
		i -= len(*m.Role)
		copy(dAtA[i:], *m.Role)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Role)))
		i--
		dAtA[i] = 0x1a
	}
	if m.AppId != nil {
		i -= len(*m.AppId)
		copy(dAtA[i:], *m.AppId)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.AppId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Metric != nil {
		i -= len(*m.Metric)
		copy(dAtA[i:], *m.Metric)
		i = encodeVarintSlave(dAtA, i, uint64(len(*m.Metric)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *OutlierEventRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Events) > 0 {
		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSlave(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Op != nil {
		i = encodeVarintSlave(dAtA, i, uint64(*m.Op))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *OutlierEventResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ErrorInfo != nil {
		{
			size, err := m.ErrorInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSlave(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if len(m.Events) > 0 {
		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Events[iNdEx])
			copy(dAtA[i:], m.Events[iNdEx])
			i = encodeVarintSlave(dAtA, i, uint64(len(m.Events[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintSlave(dAtA []byte, offset int, v uint64) int {
	offset -= sovSlave(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Metric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Name != nil {
		l = len(*m.Name)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.Value != nil {
		n += 9
	}
	if m.Time != nil {
		n += 1 + sovSlave(uint64(*m.Time))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SocketInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SocketIdx != nil {
		n += 1 + sovSlave(uint64(*m.SocketIdx))
	}
	if m.CpuNum != nil {
		n += 1 + sovSlave(uint64(*m.CpuNum))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SocketNodePolicy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MemPolicy != nil {
		n += 1 + sovSlave(uint64(*m.MemPolicy))
	}
	if len(m.Sockets) > 0 {
		for _, e := range m.Sockets {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SlotInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SlotId != nil {
		n += 1 + sovSlave(uint64(*m.SlotId))
	}
	if m.ApplicationId != nil {
		l = len(*m.ApplicationId)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.AppChecksum != nil {
		n += 1 + sovSlave(uint64(*m.AppChecksum))
	}
	if len(m.ProcessStatus) > 0 {
		for _, e := range m.ProcessStatus {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if len(m.DataStatus) > 0 {
		for _, e := range m.DataStatus {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.LaunchSignature != nil {
		n += 1 + sovSlave(uint64(*m.LaunchSignature))
	}
	if m.PackageChecksum != nil {
		l = len(*m.PackageChecksum)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.PackageStatus != nil {
		l = m.PackageStatus.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.SlotResource != nil {
		l = m.SlotResource.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.ResourceTag != nil {
		l = len(*m.ResourceTag)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.UseCpuset != nil {
		n += 2
	}
	if m.CpusetMode != nil {
		n += 1 + sovSlave(uint64(*m.CpusetMode))
	}
	if m.Cpusets != nil {
		l = len(*m.Cpusets)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.PreDeployPackageChecksum != nil {
		l = len(*m.PreDeployPackageChecksum)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.PreDeployPackageStatus != nil {
		l = m.PreDeployPackageStatus.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.Priority != nil {
		l = m.Priority.Size()
		n += 2 + l + sovSlave(uint64(l))
	}
	if m.WorkDirTag != nil {
		l = len(*m.WorkDirTag)
		n += 2 + l + sovSlave(uint64(l))
	}
	if len(m.Metrics) > 0 {
		for _, e := range m.Metrics {
			l = e.Size()
			n += 2 + l + sovSlave(uint64(l))
		}
	}
	if len(m.PackageDetails) > 0 {
		for _, e := range m.PackageDetails {
			l = e.Size()
			n += 2 + l + sovSlave(uint64(l))
		}
	}
	if len(m.Status) > 0 {
		for _, e := range m.Status {
			l = e.Size()
			n += 2 + l + sovSlave(uint64(l))
		}
	}
	if m.SocketPolicy != nil {
		l = m.SocketPolicy.Size()
		n += 2 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SlaveInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Address != nil {
		l = len(*m.Address)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.Resource != nil {
		l = m.Resource.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if len(m.Slots) > 0 {
		for _, e := range m.Slots {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.BinaryVersion != nil {
		l = len(*m.BinaryVersion)
		n += 1 + l + sovSlave(uint64(l))
	}
	if len(m.Attributes) > 0 {
		for _, e := range m.Attributes {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.RestfulHttpPort != nil {
		n += 1 + sovSlave(uint64(*m.RestfulHttpPort))
	}
	if len(m.Labels) > 0 {
		for _, e := range m.Labels {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if len(m.Metrics) > 0 {
		for _, e := range m.Metrics {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.SlaveHttpPort != nil {
		n += 1 + sovSlave(uint64(*m.SlaveHttpPort))
	}
	if m.SlaveHealth != nil {
		l = m.SlaveHealth.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SlotDetail) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Info != nil {
		l = m.Info.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.WorkDir != nil {
		l = len(*m.WorkDir)
		n += 1 + l + sovSlave(uint64(l))
	}
	if len(m.ContainerConfigs) > 0 {
		for _, s := range m.ContainerConfigs {
			l = len(s)
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.GroupId != nil {
		l = len(*m.GroupId)
		n += 1 + l + sovSlave(uint64(l))
	}
	if len(m.Labels) > 0 {
		for _, e := range m.Labels {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if len(m.Envs) > 0 {
		for _, e := range m.Envs {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SlaveDetail) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Address != nil {
		l = len(*m.Address)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.Resource != nil {
		l = m.Resource.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if len(m.Slots) > 0 {
		for _, e := range m.Slots {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.BinaryVersion != nil {
		l = len(*m.BinaryVersion)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.GrantedQueue != nil {
		l = len(*m.GrantedQueue)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.GrantedResource != nil {
		l = m.GrantedResource.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.IsOffline != nil {
		n += 2
	}
	if m.CpuShareNum != nil {
		n += 1 + sovSlave(uint64(*m.CpuShareNum))
	}
	if len(m.Labels) > 0 {
		for _, e := range m.Labels {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NameAmount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Name != nil {
		l = len(*m.Name)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.Amount != nil {
		n += 1 + sovSlave(uint64(*m.Amount))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SlotAssignment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SlotId != nil {
		n += 1 + sovSlave(uint64(*m.SlotId))
	}
	if m.ApplicationId != nil {
		l = len(*m.ApplicationId)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.AppChecksum != nil {
		n += 1 + sovSlave(uint64(*m.AppChecksum))
	}
	if m.ResourceTag != nil {
		l = len(*m.ResourceTag)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.SlotConfig != nil {
		l = m.SlotConfig.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.SlotResource != nil {
		l = m.SlotResource.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.ConstraintPolicy != nil {
		n += 1 + sovSlave(uint64(*m.ConstraintPolicy))
	}
	if m.SystemSlot != nil {
		n += 2
	}
	if m.WorkDirTag != nil {
		l = len(*m.WorkDirTag)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.UseCpuset != nil {
		n += 2
	}
	if m.UseHostWorkdir != nil {
		n += 2
	}
	if m.CpusetMode != nil {
		n += 1 + sovSlave(uint64(*m.CpusetMode))
	}
	if len(m.ContainerConfigs) > 0 {
		for _, s := range m.ContainerConfigs {
			l = len(s)
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.DeclareTime != nil {
		n += 1 + sovSlave(uint64(*m.DeclareTime))
	}
	if m.Priority != nil {
		l = m.Priority.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.SlotState != nil {
		n += 2 + sovSlave(uint64(*m.SlotState))
	}
	if m.RequirementId != nil {
		l = len(*m.RequirementId)
		n += 2 + l + sovSlave(uint64(l))
	}
	if m.Container != nil {
		l = len(*m.Container)
		n += 2 + l + sovSlave(uint64(l))
	}
	if m.GroupId != nil {
		l = len(*m.GroupId)
		n += 2 + l + sovSlave(uint64(l))
	}
	if len(m.Spec) > 0 {
		for _, e := range m.Spec {
			l = e.Size()
			n += 2 + l + sovSlave(uint64(l))
		}
	}
	if m.Mempolicy != nil {
		n += 2 + sovSlave(uint64(*m.Mempolicy))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SlaveAssignment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SlotAssignments) > 0 {
		for _, e := range m.SlotAssignments {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.GrantedResource != nil {
		l = m.GrantedResource.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.GrantedQueue != nil {
		l = len(*m.GrantedQueue)
		n += 1 + l + sovSlave(uint64(l))
	}
	if len(m.Labels) > 0 {
		for _, e := range m.Labels {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.IsOffline != nil {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SystemConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Configs) > 0 {
		for _, e := range m.Configs {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SystemInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SystemConfig != nil {
		l = m.SystemConfig.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.SystemStatus != nil {
		l = m.SystemStatus.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.RuntimeConfig != nil {
		l = m.RuntimeConfig.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ProcessLaunchRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ApplicationId != nil {
		l = len(*m.ApplicationId)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.AppChecksum != nil {
		n += 1 + sovSlave(uint64(*m.AppChecksum))
	}
	if m.SlotId != nil {
		n += 1 + sovSlave(uint64(*m.SlotId))
	}
	if m.ProcessContext != nil {
		l = m.ProcessContext.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.DeclareTime != nil {
		n += 1 + sovSlave(uint64(*m.DeclareTime))
	}
	if m.RequirementId != nil {
		l = len(*m.RequirementId)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.FillExtraInfo != nil {
		n += 2
	}
	if m.K8SPodUID != nil {
		l = len(*m.K8SPodUID)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.K8SPodName != nil {
		l = len(*m.K8SPodName)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.K8SNamespace != nil {
		l = len(*m.K8SNamespace)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.LaunchSignature != nil {
		n += 1 + sovSlave(uint64(*m.LaunchSignature))
	}
	if m.PackageChecksum != nil {
		l = len(*m.PackageChecksum)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ProcessLaunchResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LaunchStatus != nil {
		n += 1 + sovSlave(uint64(*m.LaunchStatus))
	}
	if m.Diagnostic != nil {
		l = len(*m.Diagnostic)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.ExtraInfo != nil {
		l = m.ExtraInfo.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ProcessTerminateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SlotId != nil {
		n += 1 + sovSlave(uint64(*m.SlotId))
	}
	if m.ApplicationId != nil {
		l = len(*m.ApplicationId)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.AppChecksum != nil {
		n += 1 + sovSlave(uint64(*m.AppChecksum))
	}
	if m.All != nil {
		n += 2
	}
	if len(m.ProcessName) > 0 {
		for _, s := range m.ProcessName {
			l = len(s)
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ProcessTerminateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StopRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CleanUp != nil {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *GetSlotDetailsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

func (m *RebindAllSlotCpusetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *SlaveNodeLoadInfoRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *SlaveHealthInfoRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *HeartbeatRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SlaveAssignment != nil {
		l = m.SlaveAssignment.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.SystemInfo != nil {
		l = m.SystemInfo.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HeartbeatResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SlaveInfo != nil {
		l = m.SlaveInfo.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.NeedReport != nil {
		n += 2
	}
	if m.ErrorInfo != nil {
		l = m.ErrorInfo.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdatePackageVersionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PackageURI) > 0 {
		for _, s := range m.PackageURI {
			l = len(s)
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdatePackageVersionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CpuAllocatorDebugInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != nil {
		n += 1 + sovSlave(uint64(*m.Id))
	}
	if m.CpuWmark != nil {
		n += 1 + sovSlave(uint64(*m.CpuWmark))
	}
	if m.MinCpuNumFactor != nil {
		n += 9
	}
	if m.MaxCpuNumFactor != nil {
		n += 9
	}
	if m.Exclusive != nil {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CpuAllocatorDetail) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != nil {
		n += 1 + sovSlave(uint64(*m.Id))
	}
	if m.AppId != nil {
		l = len(*m.AppId)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.Role != nil {
		l = len(*m.Role)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.GrantedCpusets != nil {
		l = len(*m.GrantedCpusets)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.ElasticCpusets != nil {
		l = len(*m.ElasticCpusets)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CpuAllocatorDebugInfoRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != nil {
		n += 1 + sovSlave(uint64(*m.Op))
	}
	if m.Allocator != nil {
		l = len(*m.Allocator)
		n += 1 + l + sovSlave(uint64(l))
	}
	if len(m.Debugs) > 0 {
		for _, e := range m.Debugs {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CpuAllocatorDebugInfoResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Allocator != nil {
		l = len(*m.Allocator)
		n += 1 + l + sovSlave(uint64(l))
	}
	if len(m.Details) > 0 {
		for _, e := range m.Details {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if len(m.Debugs) > 0 {
		for _, e := range m.Debugs {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.ErrorInfo != nil {
		l = m.ErrorInfo.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SlotResourceTunning) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != nil {
		n += 1 + sovSlave(uint64(*m.Id))
	}
	if m.CpuQuota != nil {
		n += 1 + sovSlave(uint64(*m.CpuQuota))
	}
	if m.CpuShare != nil {
		n += 1 + sovSlave(uint64(*m.CpuShare))
	}
	if m.Memory != nil {
		n += 1 + sovSlave(uint64(*m.Memory))
	}
	if m.ColdMemThreshold != nil {
		n += 1 + sovSlave(uint64(*m.ColdMemThreshold))
	}
	if m.MemoryWmark != nil {
		n += 1 + sovSlave(uint64(*m.MemoryWmark))
	}
	if m.DiskWriteBps != nil {
		n += 1 + sovSlave(uint64(*m.DiskWriteBps))
	}
	if m.DiskReadBps != nil {
		n += 1 + sovSlave(uint64(*m.DiskReadBps))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SlotResourceTunningRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != nil {
		n += 1 + sovSlave(uint64(*m.Op))
	}
	if len(m.Tunnings) > 0 {
		for _, e := range m.Tunnings {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SlotResourceTunningResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Tunnings) > 0 {
		for _, e := range m.Tunnings {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.ErrorInfo != nil {
		l = m.ErrorInfo.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OutlierEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metric != nil {
		l = len(*m.Metric)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.AppId != nil {
		l = len(*m.AppId)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.Role != nil {
		l = len(*m.Role)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.SlotId != nil {
		n += 1 + sovSlave(uint64(*m.SlotId))
	}
	if m.Type != nil {
		l = len(*m.Type)
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.Outlier != nil {
		n += 9
	}
	if m.Median != nil {
		n += 9
	}
	if len(m.Suspects) > 0 {
		for _, e := range m.Suspects {
			n += 1 + sovSlave(uint64(e))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OutlierEventRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != nil {
		n += 1 + sovSlave(uint64(*m.Op))
	}
	if len(m.Events) > 0 {
		for _, e := range m.Events {
			l = e.Size()
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OutlierEventResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Events) > 0 {
		for _, s := range m.Events {
			l = len(s)
			n += 1 + l + sovSlave(uint64(l))
		}
	}
	if m.ErrorInfo != nil {
		l = m.ErrorInfo.Size()
		n += 1 + l + sovSlave(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovSlave(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSlave(x uint64) (n int) {
	return sovSlave(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Metric) 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 ErrIntOverflowSlave
			}
			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: Metric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Metric: 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 ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Name = &s
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.Value = &v2
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Time = &v
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SocketInfo) 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 ErrIntOverflowSlave
			}
			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: SocketInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SocketInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SocketIdx", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SocketIdx = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuNum", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CpuNum = &v
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SlotInfo) 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 ErrIntOverflowSlave
			}
			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: SlotInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SlotInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotId", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SlotId = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ApplicationId = &s
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppChecksum", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AppChecksum = &v
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProcessStatus = append(m.ProcessStatus, &ProcessStatus{})
			if err := m.ProcessStatus[len(m.ProcessStatus)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DataStatus = append(m.DataStatus, &DataStatus{})
			if err := m.DataStatus[len(m.DataStatus)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LaunchSignature", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.LaunchSignature = &v
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PackageChecksum", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.PackageChecksum = &s
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PackageStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PackageStatus == nil {
				m.PackageStatus = &PackageStatus{}
			}
			if err := m.PackageStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotResource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SlotResource == nil {
				m.SlotResource = &SlotResource{}
			}
			if err := m.SlotResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceTag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ResourceTag = &s
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseCpuset", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.UseCpuset = &b
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpusetMode", wireType)
			}
			var v ResourceRequest_CpusetMode
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= ResourceRequest_CpusetMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CpusetMode = &v
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cpusets", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Cpusets = &s
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreDeployPackageChecksum", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.PreDeployPackageChecksum = &s
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreDeployPackageStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PreDeployPackageStatus == nil {
				m.PreDeployPackageStatus = &PackageStatus{}
			}
			if err := m.PreDeployPackageStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Priority == nil {
				m.Priority = &Priority{}
			}
			if err := m.Priority.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkDirTag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.WorkDirTag = &s
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metrics = append(m.Metrics, &Metric{})
			if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PackageDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PackageDetails = append(m.PackageDetails, &PackageDetail{})
			if err := m.PackageDetails[len(m.PackageDetails)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = append(m.Status, &Parameter{})
			if err := m.Status[len(m.Status)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SocketPolicy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SocketPolicy == nil {
				m.SocketPolicy = &SocketNodePolicy{}
			}
			if err := m.SocketPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SlaveInfo) 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 ErrIntOverflowSlave
			}
			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: SlaveInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SlaveInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Address = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Resource == nil {
				m.Resource = &SlaveResource{}
			}
			if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Slots", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Slots = append(m.Slots, &SlotInfo{})
			if err := m.Slots[len(m.Slots)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinaryVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.BinaryVersion = &s
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Attributes = append(m.Attributes, &Parameter{})
			if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestfulHttpPort", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RestfulHttpPort = &v
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = append(m.Labels, &Parameter{})
			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metrics = append(m.Metrics, &Metric{})
			if err := m.Metrics[len(m.Metrics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlaveHttpPort", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SlaveHttpPort = &v
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlaveHealth", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SlaveHealth == nil {
				m.SlaveHealth = &SlaveHealth{}
			}
			if err := m.SlaveHealth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SlotDetail) 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 ErrIntOverflowSlave
			}
			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: SlotDetail: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SlotDetail: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Info == nil {
				m.Info = &SlotInfo{}
			}
			if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkDir", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.WorkDir = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerConfigs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerConfigs = append(m.ContainerConfigs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.GroupId = &s
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = append(m.Labels, &Parameter{})
			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Envs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Envs = append(m.Envs, &Parameter{})
			if err := m.Envs[len(m.Envs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SlaveDetail) 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 ErrIntOverflowSlave
			}
			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: SlaveDetail: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SlaveDetail: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Address = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Resource == nil {
				m.Resource = &SlaveResource{}
			}
			if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Slots", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Slots = append(m.Slots, &SlotDetail{})
			if err := m.Slots[len(m.Slots)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinaryVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.BinaryVersion = &s
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GrantedQueue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.GrantedQueue = &s
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GrantedResource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GrantedResource == nil {
				m.GrantedResource = &GrantedResource{}
			}
			if err := m.GrantedResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsOffline", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.IsOffline = &b
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuShareNum", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CpuShareNum = &v
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = append(m.Labels, &Parameter{})
			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NameAmount) 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 ErrIntOverflowSlave
			}
			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: NameAmount: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NameAmount: 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 ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Name = &s
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Amount = &v
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SlotAssignment) 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 ErrIntOverflowSlave
			}
			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: SlotAssignment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SlotAssignment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotId", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SlotId = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ApplicationId = &s
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppChecksum", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AppChecksum = &v
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceTag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ResourceTag = &s
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SlotConfig == nil {
				m.SlotConfig = &ApplicationSlotConfig{}
			}
			if err := m.SlotConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotResource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SlotResource == nil {
				m.SlotResource = &SlotResource{}
			}
			if err := m.SlotResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConstraintPolicy", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ConstraintPolicy = &v
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SystemSlot", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.SystemSlot = &b
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkDirTag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.WorkDirTag = &s
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseCpuset", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.UseCpuset = &b
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseHostWorkdir", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.UseHostWorkdir = &b
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpusetMode", wireType)
			}
			var v ResourceRequest_CpusetMode
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= ResourceRequest_CpusetMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CpusetMode = &v
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerConfigs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerConfigs = append(m.ContainerConfigs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeclareTime", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DeclareTime = &v
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Priority == nil {
				m.Priority = &Priority{}
			}
			if err := m.Priority.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotState", wireType)
			}
			var v SlotState
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= SlotState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SlotState = &v
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequirementId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.RequirementId = &s
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Container = &s
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.GroupId = &s
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Spec = append(m.Spec, &Parameter{})
			if err := m.Spec[len(m.Spec)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mempolicy", wireType)
			}
			var v MemPolicy
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= MemPolicy(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Mempolicy = &v
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SlaveAssignment) 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 ErrIntOverflowSlave
			}
			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: SlaveAssignment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SlaveAssignment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotAssignments", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SlotAssignments = append(m.SlotAssignments, &SlotAssignment{})
			if err := m.SlotAssignments[len(m.SlotAssignments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GrantedResource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GrantedResource == nil {
				m.GrantedResource = &GrantedResource{}
			}
			if err := m.GrantedResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GrantedQueue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.GrantedQueue = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = append(m.Labels, &Parameter{})
			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsOffline", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.IsOffline = &b
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessLaunchRequest) 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 ErrIntOverflowSlave
			}
			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: ProcessLaunchRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessLaunchRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ApplicationId = &s
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppChecksum", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AppChecksum = &v
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotId", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SlotId = &v
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessContext", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProcessContext == nil {
				m.ProcessContext = &ProcessLaunchContext{}
			}
			if err := m.ProcessContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeclareTime", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DeclareTime = &v
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequirementId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.RequirementId = &s
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FillExtraInfo", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.FillExtraInfo = &b
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field K8SPodUID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.K8SPodUID = &s
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field K8SPodName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.K8SPodName = &s
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field K8SNamespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.K8SNamespace = &s
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LaunchSignature", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.LaunchSignature = &v
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PackageChecksum", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.PackageChecksum = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessLaunchResponse) 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 ErrIntOverflowSlave
			}
			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: ProcessLaunchResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessLaunchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LaunchStatus", wireType)
			}
			var v ProcessLaunchResponse_ProcessLaunchStatus
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= ProcessLaunchResponse_ProcessLaunchStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.LaunchStatus = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Diagnostic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Diagnostic = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExtraInfo == nil {
				m.ExtraInfo = &ProcessLaunchExtraInfo{}
			}
			if err := m.ExtraInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessTerminateRequest) 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 ErrIntOverflowSlave
			}
			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: ProcessTerminateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessTerminateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotId", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SlotId = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ApplicationId = &s
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppChecksum", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AppChecksum = &v
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field All", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.All = &b
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProcessName = append(m.ProcessName, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResetSlotRequest) 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 ErrIntOverflowSlave
			}
			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: ResetSlotRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResetSlotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotId", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SlotId = &v
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KillSlotRequest) 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 ErrIntOverflowSlave
			}
			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: KillSlotRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KillSlotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotId", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SlotId = &v
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetSlotDetailRequest) 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 ErrIntOverflowSlave
			}
			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: GetSlotDetailRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetSlotDetailRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotId", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SlotId = &v
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CpuAllocatorDebugInfo) 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 ErrIntOverflowSlave
			}
			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: CpuAllocatorDebugInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CpuAllocatorDebugInfo: 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)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Id = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuWmark", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CpuWmark = &v
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinCpuNumFactor", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.MinCpuNumFactor = &v2
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxCpuNumFactor", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.MaxCpuNumFactor = &v2
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exclusive", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Exclusive = &b
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CpuAllocatorDetail) 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 ErrIntOverflowSlave
			}
			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: CpuAllocatorDetail: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CpuAllocatorDetail: 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)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Id = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.AppId = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Role = &s
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GrantedCpusets", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.GrantedCpusets = &s
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ElasticCpusets", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ElasticCpusets = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CpuAllocatorDebugInfoResponse) 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 ErrIntOverflowSlave
			}
			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: CpuAllocatorDebugInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CpuAllocatorDebugInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Allocator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Allocator = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Details = append(m.Details, &CpuAllocatorDetail{})
			if err := m.Details[len(m.Details)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Debugs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Debugs = append(m.Debugs, &CpuAllocatorDebugInfo{})
			if err := m.Debugs[len(m.Debugs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSlave
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ErrorInfo == nil {
				m.ErrorInfo = &ErrorInfo{}
			}
			if err := m.ErrorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SlotResourceTunning) 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 ErrIntOverflowSlave
			}
			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: SlotResourceTunning: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SlotResourceTunning: 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)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Id = &v
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuQuota", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CpuQuota = &v
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuShare", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CpuShare = &v
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Memory = &v
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColdMemThreshold", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ColdMemThreshold = &v
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemoryWmark", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MemoryWmark = &v
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DiskWriteBps", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DiskWriteBps = &v
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DiskReadBps", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DiskReadBps = &v
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutlierEvent) 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 ErrIntOverflowSlave
			}
			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: OutlierEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutlierEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metric", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Metric = &s
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.AppId = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Role = &s
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotId", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SlotId = &v
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSlave
				}
				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 ErrInvalidLengthSlave
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSlave
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.Type = &s
			iNdEx = postIndex
		case 6:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Outlier", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.Outlier = &v2
		case 7:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Median", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.Median = &v2
		case 8:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSlave
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Suspects = append(m.Suspects, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSlave
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthSlave
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthSlave
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Suspects) == 0 {
					m.Suspects = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSlave
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Suspects = append(m.Suspects, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Suspects", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSlave(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSlave
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipSlave(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowSlave
			}
			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, ErrIntOverflowSlave
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowSlave
				}
				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, ErrInvalidLengthSlave
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupSlave
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthSlave
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthSlave        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSlave          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSlave = fmt.Errorf("proto: unexpected end of group")
)