// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: internal/scheduler/schedulerobjects/schedulerobjects.proto

package schedulerobjects

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	v1 "k8s.io/api/core/v1"
	resource "k8s.io/apimachinery/pkg/api/resource"
)

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

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

type JobRunState int32

const (
	JobRunState_UNKNOWN   JobRunState = 0
	JobRunState_PENDING   JobRunState = 1
	JobRunState_RUNNING   JobRunState = 2
	JobRunState_SUCCEEDED JobRunState = 3
	JobRunState_FAILED    JobRunState = 4
)

var JobRunState_name = map[int32]string{
	0: "UNKNOWN",
	1: "PENDING",
	2: "RUNNING",
	3: "SUCCEEDED",
	4: "FAILED",
}

var JobRunState_value = map[string]int32{
	"UNKNOWN":   0,
	"PENDING":   1,
	"RUNNING":   2,
	"SUCCEEDED": 3,
	"FAILED":    4,
}

func (x JobRunState) String() string {
	return proto.EnumName(JobRunState_name, int32(x))
}

func (JobRunState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_97dadc5fbd620721, []int{0}
}

// Executor represents an executor running on a worker cluster
type Executor struct {
	// Name of the executor.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Pool that the executor belongs to.
	Pool string `protobuf:"bytes,2,opt,name=pool,proto3" json:"pool,omitempty"`
	// The nodes available for scheduling via this executor.
	Nodes []*Node `protobuf:"bytes,3,rep,name=nodes,proto3" json:"nodes,omitempty"`
	// Last time the executor provided a heartbeat to say it was still accepting job.
	LastUpdateTime *types.Timestamp `protobuf:"bytes,5,opt,name=lastUpdateTime,proto3" json:"lastUpdateTime,omitempty"`
	// Jobs that are owned by the cluster but are not assigned to any node.
	UnassignedJobRuns []string `protobuf:"bytes,9,rep,name=unassigned_job_runs,json=unassignedJobRuns,proto3" json:"unassignedJobRuns,omitempty"`
}

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

var xxx_messageInfo_Executor proto.InternalMessageInfo

func (m *Executor) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Executor) GetPool() string {
	if m != nil {
		return m.Pool
	}
	return ""
}

func (m *Executor) GetNodes() []*Node {
	if m != nil {
		return m.Nodes
	}
	return nil
}

func (m *Executor) GetLastUpdateTime() *types.Timestamp {
	if m != nil {
		return m.LastUpdateTime
	}
	return nil
}

func (m *Executor) GetUnassignedJobRuns() []string {
	if m != nil {
		return m.UnassignedJobRuns
	}
	return nil
}

// Node represents a node in a worker cluster.
type Node struct {
	// Id associated with the node. Must be unique across all clusters.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Kubernetes node name. Not guaranteed to be unique across clusters.
	Name string `protobuf:"bytes,12,opt,name=name,proto3" json:"name,omitempty"`
	// Name of the executor to which this node belongs.
	Executor string `protobuf:"bytes,19,opt,name=executor,proto3" json:"executor,omitempty"`
	// Time at which this node was last updated.
	// Used to garbage collect nodes that have been removed.
	LastSeen *types.Timestamp `protobuf:"bytes,2,opt,name=last_seen,json=lastSeen,proto3" json:"lastSeen,omitempty"`
	// Kubernetes taints.
	Taints []*v1.Taint `protobuf:"bytes,5,rep,name=taints,proto3" json:"taints,omitempty"`
	// Kubernetes labels.
	Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Total resources on this node.
	TotalResources *ResourceList `protobuf:"bytes,7,opt,name=total_resources,json=totalResources,proto3" json:"totalResources,omitempty"`
	// Ids of the job runs currently assigned to this node and their current state.
	StateByJobRunId map[string]JobRunState `protobuf:"bytes,9,rep,name=state_by_job_run_id,json=stateByJobRunId,proto3" json:"stateByJobRunId,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=schedulerobjects.JobRunState"`
	// Resource allocated to non-Armada pods on this node.
	UnallocatableResources map[int32]*ResourceList `protobuf:"bytes,13,rep,name=unallocatable_resources,json=unallocatableResources,proto3" json:"unallocatableResources,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// If true, no new jobs should be scheduled onto this node, e.g., because the node has been cordoned.
	Unschedulable bool `protobuf:"varint,15,opt,name=unschedulable,proto3" json:"unschedulable,omitempty"`
	// This should only be used for metrics
	// This is the type the node should be reported as. It is simply a label to categorise the group the node belongs to
	ReportingNodeType string `protobuf:"bytes,17,opt,name=reporting_node_type,json=reportingNodeType,proto3" json:"reportingNodeType,omitempty"`
	// The pool that this node belongs to, this is used for scheduling purposes
	Pool                        string               `protobuf:"bytes,18,opt,name=pool,proto3" json:"pool,omitempty"`
	ResourceUsageByQueueAndPool []*PoolQueueResource `protobuf:"bytes,20,rep,name=resource_usage_by_queue_and_pool,json=resourceUsageByQueueAndPool,proto3" json:"resourceUsageByQueueAndPool,omitempty"`
}

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

var xxx_messageInfo_Node proto.InternalMessageInfo

func (m *Node) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

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

func (m *Node) GetExecutor() string {
	if m != nil {
		return m.Executor
	}
	return ""
}

func (m *Node) GetLastSeen() *types.Timestamp {
	if m != nil {
		return m.LastSeen
	}
	return nil
}

func (m *Node) GetTaints() []*v1.Taint {
	if m != nil {
		return m.Taints
	}
	return nil
}

func (m *Node) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *Node) GetTotalResources() *ResourceList {
	if m != nil {
		return m.TotalResources
	}
	return nil
}

func (m *Node) GetStateByJobRunId() map[string]JobRunState {
	if m != nil {
		return m.StateByJobRunId
	}
	return nil
}

func (m *Node) GetUnallocatableResources() map[int32]*ResourceList {
	if m != nil {
		return m.UnallocatableResources
	}
	return nil
}

func (m *Node) GetUnschedulable() bool {
	if m != nil {
		return m.Unschedulable
	}
	return false
}

func (m *Node) GetReportingNodeType() string {
	if m != nil {
		return m.ReportingNodeType
	}
	return ""
}

func (m *Node) GetPool() string {
	if m != nil {
		return m.Pool
	}
	return ""
}

func (m *Node) GetResourceUsageByQueueAndPool() []*PoolQueueResource {
	if m != nil {
		return m.ResourceUsageByQueueAndPool
	}
	return nil
}

type PoolQueueResource struct {
	Pool      string        `protobuf:"bytes,1,opt,name=pool,proto3" json:"pool,omitempty"`
	Queue     string        `protobuf:"bytes,2,opt,name=queue,proto3" json:"queue,omitempty"`
	Resources *ResourceList `protobuf:"bytes,3,opt,name=resources,proto3" json:"resources,omitempty"`
}

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

var xxx_messageInfo_PoolQueueResource proto.InternalMessageInfo

func (m *PoolQueueResource) GetPool() string {
	if m != nil {
		return m.Pool
	}
	return ""
}

func (m *PoolQueueResource) GetQueue() string {
	if m != nil {
		return m.Queue
	}
	return ""
}

func (m *PoolQueueResource) GetResources() *ResourceList {
	if m != nil {
		return m.Resources
	}
	return nil
}

type ResourceList struct {
	Resources map[string]*resource.Quantity `protobuf:"bytes,1,rep,name=resources,proto3" json:"resources,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_ResourceList proto.InternalMessageInfo

func (m *ResourceList) GetResources() map[string]*resource.Quantity {
	if m != nil {
		return m.Resources
	}
	return nil
}

// Minimal job representation used by the scheduler.
type JobSchedulingInfo struct {
	Lifetime          uint32           `protobuf:"varint,1,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
	AtMostOnce        bool             `protobuf:"varint,2,opt,name=at_most_once,json=atMostOnce,proto3" json:"atMostOnce,omitempty"`
	Preemptible       bool             `protobuf:"varint,3,opt,name=preemptible,proto3" json:"preemptible,omitempty"`
	ConcurrencySafe   bool             `protobuf:"varint,4,opt,name=concurrency_safe,json=concurrencySafe,proto3" json:"concurrencySafe,omitempty"`
	PriorityClassName string           `protobuf:"bytes,6,opt,name=priority_class_name,json=priorityClassName,proto3" json:"priorityClassName,omitempty"`
	SubmitTime        *types.Timestamp `protobuf:"bytes,7,opt,name=submit_time,json=submitTime,proto3" json:"submitTime,omitempty"`
	// In-queue priority. I.e., not the priority class priority.
	Priority uint32 `protobuf:"varint,8,opt,name=priority,proto3" json:"priority,omitempty"`
	// Kubernetes objects that make up this job and their respective scheduling requirements.
	ObjectRequirements []*ObjectRequirements `protobuf:"bytes,5,rep,name=object_requirements,json=objectRequirements,proto3" json:"objectRequirements,omitempty"`
	Version            uint32                `protobuf:"varint,9,opt,name=version,proto3" json:"version,omitempty"`
}

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

var xxx_messageInfo_JobSchedulingInfo proto.InternalMessageInfo

func (m *JobSchedulingInfo) GetLifetime() uint32 {
	if m != nil {
		return m.Lifetime
	}
	return 0
}

func (m *JobSchedulingInfo) GetAtMostOnce() bool {
	if m != nil {
		return m.AtMostOnce
	}
	return false
}

func (m *JobSchedulingInfo) GetPreemptible() bool {
	if m != nil {
		return m.Preemptible
	}
	return false
}

func (m *JobSchedulingInfo) GetConcurrencySafe() bool {
	if m != nil {
		return m.ConcurrencySafe
	}
	return false
}

func (m *JobSchedulingInfo) GetPriorityClassName() string {
	if m != nil {
		return m.PriorityClassName
	}
	return ""
}

func (m *JobSchedulingInfo) GetSubmitTime() *types.Timestamp {
	if m != nil {
		return m.SubmitTime
	}
	return nil
}

func (m *JobSchedulingInfo) GetPriority() uint32 {
	if m != nil {
		return m.Priority
	}
	return 0
}

func (m *JobSchedulingInfo) GetObjectRequirements() []*ObjectRequirements {
	if m != nil {
		return m.ObjectRequirements
	}
	return nil
}

func (m *JobSchedulingInfo) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

// Message capturing the scheduling requirements of a particular Kubernetes object.
type ObjectRequirements struct {
	// Types that are valid to be assigned to Requirements:
	//	*ObjectRequirements_PodRequirements
	Requirements isObjectRequirements_Requirements `protobuf_oneof:"requirements"`
}

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

var xxx_messageInfo_ObjectRequirements proto.InternalMessageInfo

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

type ObjectRequirements_PodRequirements struct {
	PodRequirements *PodRequirements `protobuf:"bytes,1,opt,name=podRequirements,proto3,oneof" json:"podRequirements,omitempty"`
}

func (*ObjectRequirements_PodRequirements) isObjectRequirements_Requirements() {}

func (m *ObjectRequirements) GetRequirements() isObjectRequirements_Requirements {
	if m != nil {
		return m.Requirements
	}
	return nil
}

func (m *ObjectRequirements) GetPodRequirements() *PodRequirements {
	if x, ok := m.GetRequirements().(*ObjectRequirements_PodRequirements); ok {
		return x.PodRequirements
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ObjectRequirements) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ObjectRequirements_PodRequirements)(nil),
	}
}

// Captures the scheduling requirements of a pod.
type PodRequirements struct {
	// Kubernetes node selector.
	NodeSelector map[string]string `protobuf:"bytes,1,rep,name=nodeSelector,proto3" json:"nodeSelector,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Kubernetes scheduling requirements.
	Affinity *v1.Affinity `protobuf:"bytes,2,opt,name=affinity,proto3" json:"affinity,omitempty"`
	// Kubernetes tolerations.
	Tolerations []*v1.Toleration `protobuf:"bytes,3,rep,name=tolerations,proto3" json:"tolerations,omitempty"`
	// Kubernetes annotations. Included here since we use annotations with special meaning.
	Annotations map[string]string `protobuf:"bytes,7,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// One of Never, PreemptLowerPriority.
	// Defaults to PreemptLowerPriority if unset.
	PreemptionPolicy string `protobuf:"bytes,5,opt,name=preemptionPolicy,proto3" json:"preemptionPolicy,omitempty"`
	// Sum of the resource requirements for all containers that make up this pod.
	ResourceRequirements *v1.ResourceRequirements `protobuf:"bytes,6,opt,name=resourceRequirements,proto3" json:"resourceRequirements,omitempty"`
}

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

var xxx_messageInfo_PodRequirements proto.InternalMessageInfo

func (m *PodRequirements) GetNodeSelector() map[string]string {
	if m != nil {
		return m.NodeSelector
	}
	return nil
}

func (m *PodRequirements) GetAffinity() *v1.Affinity {
	if m != nil {
		return m.Affinity
	}
	return nil
}

func (m *PodRequirements) GetTolerations() []*v1.Toleration {
	if m != nil {
		return m.Tolerations
	}
	return nil
}

func (m *PodRequirements) GetAnnotations() map[string]string {
	if m != nil {
		return m.Annotations
	}
	return nil
}

func (m *PodRequirements) GetPreemptionPolicy() string {
	if m != nil {
		return m.PreemptionPolicy
	}
	return ""
}

func (m *PodRequirements) GetResourceRequirements() *v1.ResourceRequirements {
	if m != nil {
		return m.ResourceRequirements
	}
	return nil
}

type ExecutorSettings struct {
	ExecutorId   string           `protobuf:"bytes,1,opt,name=executorId,proto3" json:"executorId,omitempty"`
	Cordoned     bool             `protobuf:"varint,2,opt,name=cordoned,proto3" json:"cordoned,omitempty"`
	CordonReason string           `protobuf:"bytes,3,opt,name=cordonReason,proto3" json:"cordonReason,omitempty"`
	SetByUser    string           `protobuf:"bytes,4,opt,name=setByUser,proto3" json:"setByUser,omitempty"`
	SetAtTime    *types.Timestamp `protobuf:"bytes,5,opt,name=setAtTime,proto3" json:"setAtTime,omitempty"`
}

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

var xxx_messageInfo_ExecutorSettings proto.InternalMessageInfo

func (m *ExecutorSettings) GetExecutorId() string {
	if m != nil {
		return m.ExecutorId
	}
	return ""
}

func (m *ExecutorSettings) GetCordoned() bool {
	if m != nil {
		return m.Cordoned
	}
	return false
}

func (m *ExecutorSettings) GetCordonReason() string {
	if m != nil {
		return m.CordonReason
	}
	return ""
}

func (m *ExecutorSettings) GetSetByUser() string {
	if m != nil {
		return m.SetByUser
	}
	return ""
}

func (m *ExecutorSettings) GetSetAtTime() *types.Timestamp {
	if m != nil {
		return m.SetAtTime
	}
	return nil
}

func init() {
	proto.RegisterEnum("schedulerobjects.JobRunState", JobRunState_name, JobRunState_value)
	proto.RegisterType((*Executor)(nil), "schedulerobjects.Executor")
	proto.RegisterType((*Node)(nil), "schedulerobjects.Node")
	proto.RegisterMapType((map[string]string)(nil), "schedulerobjects.Node.LabelsEntry")
	proto.RegisterMapType((map[string]JobRunState)(nil), "schedulerobjects.Node.StateByJobRunIdEntry")
	proto.RegisterMapType((map[int32]*ResourceList)(nil), "schedulerobjects.Node.UnallocatableResourcesEntry")
	proto.RegisterType((*PoolQueueResource)(nil), "schedulerobjects.PoolQueueResource")
	proto.RegisterType((*ResourceList)(nil), "schedulerobjects.ResourceList")
	proto.RegisterMapType((map[string]*resource.Quantity)(nil), "schedulerobjects.ResourceList.ResourcesEntry")
	proto.RegisterType((*JobSchedulingInfo)(nil), "schedulerobjects.JobSchedulingInfo")
	proto.RegisterType((*ObjectRequirements)(nil), "schedulerobjects.ObjectRequirements")
	proto.RegisterType((*PodRequirements)(nil), "schedulerobjects.PodRequirements")
	proto.RegisterMapType((map[string]string)(nil), "schedulerobjects.PodRequirements.AnnotationsEntry")
	proto.RegisterMapType((map[string]string)(nil), "schedulerobjects.PodRequirements.NodeSelectorEntry")
	proto.RegisterType((*ExecutorSettings)(nil), "schedulerobjects.ExecutorSettings")
}

func init() {
	proto.RegisterFile("internal/scheduler/schedulerobjects/schedulerobjects.proto", fileDescriptor_97dadc5fbd620721)
}

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

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

func (m *Executor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UnassignedJobRuns) > 0 {
		for iNdEx := len(m.UnassignedJobRuns) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.UnassignedJobRuns[iNdEx])
			copy(dAtA[i:], m.UnassignedJobRuns[iNdEx])
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.UnassignedJobRuns[iNdEx])))
			i--
			dAtA[i] = 0x4a
		}
	}
	if m.LastUpdateTime != nil {
		{
			size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Nodes) > 0 {
		for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Nodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Pool) > 0 {
		i -= len(m.Pool)
		copy(dAtA[i:], m.Pool)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.Pool)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ResourceUsageByQueueAndPool) > 0 {
		for iNdEx := len(m.ResourceUsageByQueueAndPool) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ResourceUsageByQueueAndPool[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.Executor) > 0 {
		i -= len(m.Executor)
		copy(dAtA[i:], m.Executor)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.Executor)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if len(m.Pool) > 0 {
		i -= len(m.Pool)
		copy(dAtA[i:], m.Pool)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.Pool)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if len(m.ReportingNodeType) > 0 {
		i -= len(m.ReportingNodeType)
		copy(dAtA[i:], m.ReportingNodeType)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.ReportingNodeType)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if m.Unschedulable {
		i--
		if m.Unschedulable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x78
	}
	if len(m.UnallocatableResources) > 0 {
		for k := range m.UnallocatableResources {
			v := m.UnallocatableResources[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.StateByJobRunId) > 0 {
		for k := range m.StateByJobRunId {
			v := m.StateByJobRunId[k]
			baseI := i
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4a
		}
	}
	if m.TotalResources != nil {
		{
			size, err := m.TotalResources.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Labels) > 0 {
		for k := range m.Labels {
			v := m.Labels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Taints) > 0 {
		for iNdEx := len(m.Taints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Taints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.LastSeen != nil {
		{
			size, err := m.LastSeen.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PoolQueueResource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Resources != nil {
		{
			size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Queue) > 0 {
		i -= len(m.Queue)
		copy(dAtA[i:], m.Queue)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.Queue)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Pool) > 0 {
		i -= len(m.Pool)
		copy(dAtA[i:], m.Pool)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.Pool)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ResourceList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Resources) > 0 {
		for k := range m.Resources {
			v := m.Resources[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *JobSchedulingInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Version != 0 {
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x48
	}
	if m.Priority != 0 {
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(m.Priority))
		i--
		dAtA[i] = 0x40
	}
	if m.SubmitTime != nil {
		{
			size, err := m.SubmitTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.PriorityClassName) > 0 {
		i -= len(m.PriorityClassName)
		copy(dAtA[i:], m.PriorityClassName)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.PriorityClassName)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.ObjectRequirements) > 0 {
		for iNdEx := len(m.ObjectRequirements) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ObjectRequirements[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.ConcurrencySafe {
		i--
		if m.ConcurrencySafe {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Preemptible {
		i--
		if m.Preemptible {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.AtMostOnce {
		i--
		if m.AtMostOnce {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Lifetime != 0 {
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(m.Lifetime))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *ObjectRequirements_PodRequirements) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PodRequirements != nil {
		{
			size, err := m.PodRequirements.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *PodRequirements) 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 *PodRequirements) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PodRequirements) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Annotations) > 0 {
		for k := range m.Annotations {
			v := m.Annotations[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.ResourceRequirements != nil {
		{
			size, err := m.ResourceRequirements.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.PreemptionPolicy) > 0 {
		i -= len(m.PreemptionPolicy)
		copy(dAtA[i:], m.PreemptionPolicy)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.PreemptionPolicy)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Tolerations) > 0 {
		for iNdEx := len(m.Tolerations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tolerations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Affinity != nil {
		{
			size, err := m.Affinity.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.NodeSelector) > 0 {
		for k := range m.NodeSelector {
			v := m.NodeSelector[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *ExecutorSettings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SetAtTime != nil {
		{
			size, err := m.SetAtTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchedulerobjects(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SetByUser) > 0 {
		i -= len(m.SetByUser)
		copy(dAtA[i:], m.SetByUser)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.SetByUser)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.CordonReason) > 0 {
		i -= len(m.CordonReason)
		copy(dAtA[i:], m.CordonReason)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.CordonReason)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Cordoned {
		i--
		if m.Cordoned {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.ExecutorId) > 0 {
		i -= len(m.ExecutorId)
		copy(dAtA[i:], m.ExecutorId)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.ExecutorId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintSchedulerobjects(dAtA []byte, offset int, v uint64) int {
	offset -= sovSchedulerobjects(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Executor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	l = len(m.Pool)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.Nodes) > 0 {
		for _, e := range m.Nodes {
			l = e.Size()
			n += 1 + l + sovSchedulerobjects(uint64(l))
		}
	}
	if m.LastUpdateTime != nil {
		l = m.LastUpdateTime.Size()
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.UnassignedJobRuns) > 0 {
		for _, s := range m.UnassignedJobRuns {
			l = len(s)
			n += 1 + l + sovSchedulerobjects(uint64(l))
		}
	}
	return n
}

func (m *Node) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if m.LastSeen != nil {
		l = m.LastSeen.Size()
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.Taints) > 0 {
		for _, e := range m.Taints {
			l = e.Size()
			n += 1 + l + sovSchedulerobjects(uint64(l))
		}
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovSchedulerobjects(uint64(len(k))) + 1 + len(v) + sovSchedulerobjects(uint64(len(v)))
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	if m.TotalResources != nil {
		l = m.TotalResources.Size()
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.StateByJobRunId) > 0 {
		for k, v := range m.StateByJobRunId {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovSchedulerobjects(uint64(len(k))) + 1 + sovSchedulerobjects(uint64(v))
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.UnallocatableResources) > 0 {
		for k, v := range m.UnallocatableResources {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovSchedulerobjects(uint64(l))
			}
			mapEntrySize := 1 + sovSchedulerobjects(uint64(k)) + l
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	if m.Unschedulable {
		n += 2
	}
	l = len(m.ReportingNodeType)
	if l > 0 {
		n += 2 + l + sovSchedulerobjects(uint64(l))
	}
	l = len(m.Pool)
	if l > 0 {
		n += 2 + l + sovSchedulerobjects(uint64(l))
	}
	l = len(m.Executor)
	if l > 0 {
		n += 2 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.ResourceUsageByQueueAndPool) > 0 {
		for _, e := range m.ResourceUsageByQueueAndPool {
			l = e.Size()
			n += 2 + l + sovSchedulerobjects(uint64(l))
		}
	}
	return n
}

func (m *PoolQueueResource) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Pool)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	l = len(m.Queue)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if m.Resources != nil {
		l = m.Resources.Size()
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	return n
}

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

func (m *JobSchedulingInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Lifetime != 0 {
		n += 1 + sovSchedulerobjects(uint64(m.Lifetime))
	}
	if m.AtMostOnce {
		n += 2
	}
	if m.Preemptible {
		n += 2
	}
	if m.ConcurrencySafe {
		n += 2
	}
	if len(m.ObjectRequirements) > 0 {
		for _, e := range m.ObjectRequirements {
			l = e.Size()
			n += 1 + l + sovSchedulerobjects(uint64(l))
		}
	}
	l = len(m.PriorityClassName)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if m.SubmitTime != nil {
		l = m.SubmitTime.Size()
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if m.Priority != 0 {
		n += 1 + sovSchedulerobjects(uint64(m.Priority))
	}
	if m.Version != 0 {
		n += 1 + sovSchedulerobjects(uint64(m.Version))
	}
	return n
}

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

func (m *ObjectRequirements_PodRequirements) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PodRequirements != nil {
		l = m.PodRequirements.Size()
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	return n
}
func (m *PodRequirements) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.NodeSelector) > 0 {
		for k, v := range m.NodeSelector {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovSchedulerobjects(uint64(len(k))) + 1 + len(v) + sovSchedulerobjects(uint64(len(v)))
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	if m.Affinity != nil {
		l = m.Affinity.Size()
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.Tolerations) > 0 {
		for _, e := range m.Tolerations {
			l = e.Size()
			n += 1 + l + sovSchedulerobjects(uint64(l))
		}
	}
	l = len(m.PreemptionPolicy)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if m.ResourceRequirements != nil {
		l = m.ResourceRequirements.Size()
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovSchedulerobjects(uint64(len(k))) + 1 + len(v) + sovSchedulerobjects(uint64(len(v)))
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ExecutorSettings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ExecutorId)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if m.Cordoned {
		n += 2
	}
	l = len(m.CordonReason)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	l = len(m.SetByUser)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if m.SetAtTime != nil {
		l = m.SetAtTime.Size()
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	return n
}

func sovSchedulerobjects(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSchedulerobjects(x uint64) (n int) {
	return sovSchedulerobjects(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Executor) 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 ErrIntOverflowSchedulerobjects
			}
			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: Executor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Executor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pool", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pool = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nodes = append(m.Nodes, &Node{})
			if err := m.Nodes[len(m.Nodes)-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 LastUpdateTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastUpdateTime == nil {
				m.LastUpdateTime = &types.Timestamp{}
			}
			if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnassignedJobRuns", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UnassignedJobRuns = append(m.UnassignedJobRuns, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Node) 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 ErrIntOverflowSchedulerobjects
			}
			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: Node: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastSeen", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastSeen == nil {
				m.LastSeen = &types.Timestamp{}
			}
			if err := m.LastSeen.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Taints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Taints = append(m.Taints, &v1.Taint{})
			if err := m.Taints[len(m.Taints)-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 Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchedulerobjects
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TotalResources == nil {
				m.TotalResources = &ResourceList{}
			}
			if err := m.TotalResources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StateByJobRunId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StateByJobRunId == nil {
				m.StateByJobRunId = make(map[string]JobRunState)
			}
			var mapkey string
			var mapvalue JobRunState
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchedulerobjects
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= JobRunState(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StateByJobRunId[mapkey] = mapvalue
			iNdEx = postIndex
		case 12:
			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 ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnallocatableResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UnallocatableResources == nil {
				m.UnallocatableResources = make(map[int32]*ResourceList)
			}
			var mapkey int32
			var mapvalue *ResourceList
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchedulerobjects
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ResourceList{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.UnallocatableResources[mapkey] = mapvalue
			iNdEx = postIndex
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unschedulable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Unschedulable = bool(v != 0)
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportingNodeType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReportingNodeType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pool", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pool = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Executor", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Executor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceUsageByQueueAndPool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ResourceUsageByQueueAndPool = append(m.ResourceUsageByQueueAndPool, &PoolQueueResource{})
			if err := m.ResourceUsageByQueueAndPool[len(m.ResourceUsageByQueueAndPool)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResourceList) 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 ErrIntOverflowSchedulerobjects
			}
			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: ResourceList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Resources == nil {
				m.Resources = make(map[string]*resource.Quantity)
			}
			var mapkey string
			var mapvalue *resource.Quantity
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchedulerobjects
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Resources[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobSchedulingInfo) 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 ErrIntOverflowSchedulerobjects
			}
			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: JobSchedulingInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobSchedulingInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lifetime", wireType)
			}
			m.Lifetime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Lifetime |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AtMostOnce", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AtMostOnce = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Preemptible", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Preemptible = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConcurrencySafe", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ConcurrencySafe = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectRequirements", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectRequirements = append(m.ObjectRequirements, &ObjectRequirements{})
			if err := m.ObjectRequirements[len(m.ObjectRequirements)-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 PriorityClassName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PriorityClassName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubmitTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SubmitTime == nil {
				m.SubmitTime = &types.Timestamp{}
			}
			if err := m.SubmitTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
			}
			m.Priority = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Priority |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PodRequirements) 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 ErrIntOverflowSchedulerobjects
			}
			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: PodRequirements: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodRequirements: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeSelector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NodeSelector == nil {
				m.NodeSelector = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchedulerobjects
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.NodeSelector[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Affinity", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Affinity == nil {
				m.Affinity = &v1.Affinity{}
			}
			if err := m.Affinity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tolerations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tolerations = append(m.Tolerations, &v1.Toleration{})
			if err := m.Tolerations[len(m.Tolerations)-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 PreemptionPolicy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreemptionPolicy = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceRequirements", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ResourceRequirements == nil {
				m.ResourceRequirements = &v1.ResourceRequirements{}
			}
			if err := m.ResourceRequirements.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Annotations == nil {
				m.Annotations = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchedulerobjects
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthSchedulerobjects
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Annotations[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecutorSettings) 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 ErrIntOverflowSchedulerobjects
			}
			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: ExecutorSettings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExecutorSettings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExecutorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cordoned", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Cordoned = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CordonReason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CordonReason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetByUser", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				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 ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SetByUser = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetAtTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SetAtTime == nil {
				m.SetAtTime = &types.Timestamp{}
			}
			if err := m.SetAtTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchedulerobjects(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthSchedulerobjects        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSchedulerobjects          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSchedulerobjects = fmt.Errorf("proto: unexpected end of group")
)
