schedulerobjects.pb.go

// 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"
	time "time"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "github.com/gogo/protobuf/types"
	github_com_gogo_protobuf_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
var _ = time.Kitchen

// 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"`
	// Minimum resources which a job must request in order to be considered for scheduling on this executor.
	MinimumJobSize ResourceList `protobuf:"bytes,4,opt,name=minimumJobSize,proto3" json:"minimumJobSize"`
	// Last time the executor provided a heartbeat to say it was still accepting job.
	LastUpdateTime time.Time `protobuf:"bytes,5,opt,name=lastUpdateTime,proto3,stdtime" json:"lastUpdateTime"`
	// 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) GetMinimumJobSize() ResourceList {
	if m != nil {
		return m.MinimumJobSize
	}
	return ResourceList{}
}

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

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"`
	// Keys by which nodes are sorted in the nodeDb.
	NodeDbKeys [][]byte `protobuf:"bytes,18,rep,name=nodeDbKeys,proto3" json:"nodeDbKeys,omitempty"`
	// Time at which this node was last updated.
	// Used to garbage collect nodes that have been removed.
	LastSeen time.Time `protobuf:"bytes,2,opt,name=last_seen,json=lastSeen,proto3,stdtime" json:"lastSeen"`
	// The node type captures scheduling requirements of the node;
	// it's computed from the taints and labels associated with the node.
	// This field is set automatically by the NodeDb on inserting the node.
	NodeType *NodeType `protobuf:"bytes,3,opt,name=node_type,json=nodeType,proto3" json:"nodeType,omitempty"`
	// We store NodeType.id here to simplify indexing.
	// This field is set automatically by the NodeDb on inserting the node.
	NodeTypeId uint64 `protobuf:"varint,4,opt,name=node_type_id,json=nodeTypeId,proto3" json:"nodeTypeId,omitempty"`
	// Kubernetes taints.
	Taints []v1.Taint `protobuf:"bytes,5,rep,name=taints,proto3" json:"taints"`
	// 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"`
	// Resources available for jobs of a given priority.
	// E.g., AvailableResources[5]["cpu"] is the amount of CPU available to jobs with priority 5,
	// where available resources = unused resources + resources assigned to lower-priority jobs.
	AllocatableByPriorityAndResource map[int32]ResourceList `protobuf:"bytes,8,rep,name=allocatable_by_priority_and_resource,json=allocatableByPriorityAndResource,proto3" json:"allocatableByPriorityAndResource" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// 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" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=schedulerobjects.JobRunState"`
	// Resource allocated to jobs on this node.
	AllocatedByJobId map[string]ResourceList `protobuf:"bytes,10,rep,name=allocated_by_job_id,json=allocatedByJobId,proto3" json:"allocatedByJobId" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Resource allocated to queues on this node.
	AllocatedByQueue map[string]ResourceList `protobuf:"bytes,11,rep,name=allocated_by_queue,json=allocatedByQueue,proto3" json:"allocatedByQueue" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Ids of all runs evicted on this node.
	EvictedJobRunIds map[string]bool `protobuf:"bytes,14,rep,name=evicted_job_run_ids,json=evictedJobRunIds,proto3" json:"evictedJobRunIds" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	// Resource allocated to non-Armada pods on this node.
	NonArmadaAllocatedResources map[int32]ResourceList `protobuf:"bytes,13,rep,name=non_armada_allocated_resources,json=nonArmadaAllocatedResources,proto3" json:"nonArmadaAllocatedResources" 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
	// An aggregated real usage of jobs by queue
	ResourceUsageByQueue map[string]*ResourceList `protobuf:"bytes,16,rep,name=resource_usage_by_queue,json=resourceUsageByQueue,proto3" json:"resourceUsageByQueue,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// This should only be used for metrics
	// This is the type the node should be reported as. It is simple 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"`
}

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) GetNodeDbKeys() [][]byte {
	if m != nil {
		return m.NodeDbKeys
	}
	return nil
}

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

func (m *Node) GetNodeType() *NodeType {
	if m != nil {
		return m.NodeType
	}
	return nil
}

func (m *Node) GetNodeTypeId() uint64 {
	if m != nil {
		return m.NodeTypeId
	}
	return 0
}

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 ResourceList{}
}

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

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

func (m *Node) GetAllocatedByJobId() map[string]ResourceList {
	if m != nil {
		return m.AllocatedByJobId
	}
	return nil
}

func (m *Node) GetAllocatedByQueue() map[string]ResourceList {
	if m != nil {
		return m.AllocatedByQueue
	}
	return nil
}

func (m *Node) GetEvictedJobRunIds() map[string]bool {
	if m != nil {
		return m.EvictedJobRunIds
	}
	return nil
}

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

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

func (m *Node) GetResourceUsageByQueue() map[string]*ResourceList {
	if m != nil {
		return m.ResourceUsageByQueue
	}
	return nil
}

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

// NodeType represents a particular combination of taints and labels.
// The scheduler groups nodes by node type. When assigning pods to nodes,
// the scheduler only considers nodes with a NodeType for which the taints and labels match.
type NodeType struct {
	// Unique identifier. Used for map lookup.
	Id uint64 `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// Kubernetes taints.
	// To reduce the number of distinct node types,
	// may contain only a subset of the taints of the node the node type is created from.
	Taints []v1.Taint `protobuf:"bytes,2,rep,name=taints,proto3" json:"taints"`
	// Kubernetes labels.
	// To reduce the number of distinct node types,
	// may contain only a subset of the labels of the node the node type is created from.
	Labels map[string]string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Well-known labels not set by this node type.
	// Used to filter out nodes when looking for nodes for a pod
	// that requires at least one well-known label to be set.
	UnsetIndexedLabels map[string]string `protobuf:"bytes,4,rep,name=unsetIndexedLabels,proto3" json:"unsetIndexedLabels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_NodeType proto.InternalMessageInfo

func (m *NodeType) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

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

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

func (m *NodeType) GetUnsetIndexedLabels() map[string]string {
	if m != nil {
		return m.UnsetIndexedLabels
	}
	return nil
}

// Captures the resource usage of a particular queue in a given cluster.
type QueueClusterResourceUsage struct {
	Created                      time.Time               `protobuf:"bytes,1,opt,name=created,proto3,stdtime" json:"created"`
	Queue                        string                  `protobuf:"bytes,2,opt,name=queue,proto3" json:"queue,omitempty"`
	ExecutorId                   string                  `protobuf:"bytes,3,opt,name=executorId,proto3" json:"executorId,omitempty"`
	ResourcesByPriority          map[int32]ResourceList  `protobuf:"bytes,4,rep,name=resourcesByPriority,proto3" json:"resourcesByPriority" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Deprecated: Do not use.
	ResourcesByPriorityClassName map[string]ResourceList `protobuf:"bytes,5,rep,name=resourcesByPriorityClassName,proto3" json:"resourcesByPriorityClassName" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_QueueClusterResourceUsage proto.InternalMessageInfo

func (m *QueueClusterResourceUsage) GetCreated() time.Time {
	if m != nil {
		return m.Created
	}
	return time.Time{}
}

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

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

// Deprecated: Do not use.
func (m *QueueClusterResourceUsage) GetResourcesByPriority() map[int32]ResourceList {
	if m != nil {
		return m.ResourcesByPriority
	}
	return nil
}

func (m *QueueClusterResourceUsage) GetResourcesByPriorityClassName() map[string]ResourceList {
	if m != nil {
		return m.ResourcesByPriorityClassName
	}
	return nil
}

// A collection of QueueClusterResourceUsage
// This is only needed to brige the gap between the redis based scheduler and the new scheduler.
type ClusterResourceUsageReport struct {
	Pool             string                                `protobuf:"bytes,1,opt,name=pool,proto3" json:"pool,omitempty"`
	Created          time.Time                             `protobuf:"bytes,2,opt,name=created,proto3,stdtime" json:"created"`
	ResourcesByQueue map[string]*QueueClusterResourceUsage `protobuf:"bytes,3,rep,name=resourcesByQueue,proto3" json:"resourcesByQueue,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_ClusterResourceUsageReport proto.InternalMessageInfo

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

func (m *ClusterResourceUsageReport) GetCreated() time.Time {
	if m != nil {
		return m.Created
	}
	return time.Time{}
}

func (m *ClusterResourceUsageReport) GetResourcesByQueue() map[string]*QueueClusterResourceUsage {
	if m != nil {
		return m.ResourcesByQueue
	}
	return nil
}

type ResourceList struct {
	Resources map[string]resource.Quantity `protobuf:"bytes,1,rep,name=resources,proto3" json:"resources" 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{5}
}
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        time.Time `protobuf:"bytes,7,opt,name=submit_time,json=submitTime,proto3,stdtime" json:"submitTime"`
	// 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"`
	// Queuing TTL for this job in seconds. If this job queues for more than this duration it will be cancelled. Zero indicates an infinite lifetime.
	QueueTtlSeconds int64 `protobuf:"varint,10,opt,name=queue_ttl_seconds,json=queueTtlSeconds,proto3" json:"queueTtlSeconds,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{6}
}
func (m *JobSchedulingInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobSchedulingInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	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() time.Time {
	if m != nil {
		return m.SubmitTime
	}
	return time.Time{}
}

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
}

func (m *JobSchedulingInfo) GetQueueTtlSeconds() int64 {
	if m != nil {
		return m.QueueTtlSeconds
	}
	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{7}
}
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"`
	// 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"`
	// Pod priority. Should be mapped from the priority class name of the submitted pod.
	Priority int32 `protobuf:"varint,4,opt,name=priority,proto3" json:"priority,omitempty"`
	// 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"`
	// This key is a hash of the scheduling requirements.
	// The hash is 20 bytes in size and is guaranteed to be the same for equivalent PodRequirements,
	// unless Affinity is used, in which case they may differ as a result of unordered map keys.
	CachedSchedulingKey []byte `protobuf:"bytes,8,opt,name=cachedSchedulingKey,proto3" json:"cachedSchedulingKey,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{8}
}
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) GetPriority() int32 {
	if m != nil {
		return m.Priority
	}
	return 0
}

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 v1.ResourceRequirements{}
}

func (m *PodRequirements) GetCachedSchedulingKey() []byte {
	if m != nil {
		return m.CachedSchedulingKey
	}
	return nil
}

// Used to store details about pulsar scheduler jobs in Redis
// Can be removed once we deprecate the legacy scheduler
type PulsarSchedulerJobDetails struct {
	JobId  string `protobuf:"bytes,1,opt,name=JobId,proto3" json:"JobId,omitempty"`
	Queue  string `protobuf:"bytes,2,opt,name=Queue,proto3" json:"Queue,omitempty"`
	JobSet string `protobuf:"bytes,3,opt,name=JobSet,proto3" json:"JobSet,omitempty"`
}

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

var xxx_messageInfo_PulsarSchedulerJobDetails proto.InternalMessageInfo

func (m *PulsarSchedulerJobDetails) GetJobId() string {
	if m != nil {
		return m.JobId
	}
	return ""
}

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

func (m *PulsarSchedulerJobDetails) GetJobSet() string {
	if m != nil {
		return m.JobSet
	}
	return ""
}

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[int32]ResourceList)(nil), "schedulerobjects.Node.AllocatableByPriorityAndResourceEntry")
	proto.RegisterMapType((map[string]ResourceList)(nil), "schedulerobjects.Node.AllocatedByJobIdEntry")
	proto.RegisterMapType((map[string]ResourceList)(nil), "schedulerobjects.Node.AllocatedByQueueEntry")
	proto.RegisterMapType((map[string]bool)(nil), "schedulerobjects.Node.EvictedJobRunIdsEntry")
	proto.RegisterMapType((map[string]string)(nil), "schedulerobjects.Node.LabelsEntry")
	proto.RegisterMapType((map[int32]ResourceList)(nil), "schedulerobjects.Node.NonArmadaAllocatedResourcesEntry")
	proto.RegisterMapType((map[string]*ResourceList)(nil), "schedulerobjects.Node.ResourceUsageByQueueEntry")
	proto.RegisterMapType((map[string]JobRunState)(nil), "schedulerobjects.Node.StateByJobRunIdEntry")
	proto.RegisterType((*NodeType)(nil), "schedulerobjects.NodeType")
	proto.RegisterMapType((map[string]string)(nil), "schedulerobjects.NodeType.LabelsEntry")
	proto.RegisterMapType((map[string]string)(nil), "schedulerobjects.NodeType.UnsetIndexedLabelsEntry")
	proto.RegisterType((*QueueClusterResourceUsage)(nil), "schedulerobjects.QueueClusterResourceUsage")
	proto.RegisterMapType((map[string]ResourceList)(nil), "schedulerobjects.QueueClusterResourceUsage.ResourcesByPriorityClassNameEntry")
	proto.RegisterMapType((map[int32]ResourceList)(nil), "schedulerobjects.QueueClusterResourceUsage.ResourcesByPriorityEntry")
	proto.RegisterType((*ClusterResourceUsageReport)(nil), "schedulerobjects.ClusterResourceUsageReport")
	proto.RegisterMapType((map[string]*QueueClusterResourceUsage)(nil), "schedulerobjects.ClusterResourceUsageReport.ResourcesByQueueEntry")
	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((*PulsarSchedulerJobDetails)(nil), "schedulerobjects.PulsarSchedulerJobDetails")
}

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

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

func (m *NodeType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UnsetIndexedLabels) > 0 {
		for k := range m.UnsetIndexedLabels {
			v := m.UnsetIndexedLabels[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] = 0x22
		}
	}
	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] = 0x1a
		}
	}
	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] = 0x12
		}
	}
	if m.Id != 0 {
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *QueueClusterResourceUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ResourcesByPriorityClassName) > 0 {
		for k := range m.ResourcesByPriorityClassName {
			v := m.ResourcesByPriorityClassName[k]
			baseI := i
			{
				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] = 0x2a
		}
	}
	if len(m.ResourcesByPriority) > 0 {
		for k := range m.ResourcesByPriority {
			v := m.ResourcesByPriority[k]
			baseI := i
			{
				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] = 0x22
		}
	}
	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] = 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
	}
	n13, err13 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Created, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Created):])
	if err13 != nil {
		return 0, err13
	}
	i -= n13
	i = encodeVarintSchedulerobjects(dAtA, i, uint64(n13))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *ClusterResourceUsageReport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ResourcesByQueue) > 0 {
		for k := range m.ResourcesByQueue {
			v := m.ResourcesByQueue[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] = 0x1a
		}
	}
	n15, err15 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Created, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Created):])
	if err15 != nil {
		return 0, err15
	}
	i -= n15
	i = encodeVarintSchedulerobjects(dAtA, i, uint64(n15))
	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
			{
				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.QueueTtlSeconds != 0 {
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(m.QueueTtlSeconds))
		i--
		dAtA[i] = 0x50
	}
	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
	}
	n17, err17 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.SubmitTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.SubmitTime):])
	if err17 != nil {
		return 0, err17
	}
	i -= n17
	i = encodeVarintSchedulerobjects(dAtA, i, uint64(n17))
	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.CachedSchedulingKey) > 0 {
		i -= len(m.CachedSchedulingKey)
		copy(dAtA[i:], m.CachedSchedulingKey)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.CachedSchedulingKey)))
		i--
		dAtA[i] = 0x42
	}
	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
		}
	}
	{
		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 m.Priority != 0 {
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(m.Priority))
		i--
		dAtA[i] = 0x20
	}
	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 *PulsarSchedulerJobDetails) 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 *PulsarSchedulerJobDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PulsarSchedulerJobDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.JobSet) > 0 {
		i -= len(m.JobSet)
		copy(dAtA[i:], m.JobSet)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.JobSet)))
		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.JobId) > 0 {
		i -= len(m.JobId)
		copy(dAtA[i:], m.JobId)
		i = encodeVarintSchedulerobjects(dAtA, i, uint64(len(m.JobId)))
		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))
		}
	}
	l = m.MinimumJobSize.Size()
	n += 1 + l + sovSchedulerobjects(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.LastUpdateTime)
	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))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.LastSeen)
	n += 1 + l + sovSchedulerobjects(uint64(l))
	if m.NodeType != nil {
		l = m.NodeType.Size()
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if m.NodeTypeId != 0 {
		n += 1 + sovSchedulerobjects(uint64(m.NodeTypeId))
	}
	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))
		}
	}
	l = m.TotalResources.Size()
	n += 1 + l + sovSchedulerobjects(uint64(l))
	if len(m.AllocatableByPriorityAndResource) > 0 {
		for k, v := range m.AllocatableByPriorityAndResource {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovSchedulerobjects(uint64(k)) + 1 + l + sovSchedulerobjects(uint64(l))
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	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))
		}
	}
	if len(m.AllocatedByJobId) > 0 {
		for k, v := range m.AllocatedByJobId {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovSchedulerobjects(uint64(len(k))) + 1 + l + sovSchedulerobjects(uint64(l))
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	if len(m.AllocatedByQueue) > 0 {
		for k, v := range m.AllocatedByQueue {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovSchedulerobjects(uint64(len(k))) + 1 + l + sovSchedulerobjects(uint64(l))
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.NonArmadaAllocatedResources) > 0 {
		for k, v := range m.NonArmadaAllocatedResources {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovSchedulerobjects(uint64(k)) + 1 + l + sovSchedulerobjects(uint64(l))
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	if len(m.EvictedJobRunIds) > 0 {
		for k, v := range m.EvictedJobRunIds {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovSchedulerobjects(uint64(len(k))) + 1 + 1
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	if m.Unschedulable {
		n += 2
	}
	if len(m.ResourceUsageByQueue) > 0 {
		for k, v := range m.ResourceUsageByQueue {
			_ = 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 + 2 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	l = len(m.ReportingNodeType)
	if l > 0 {
		n += 2 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.NodeDbKeys) > 0 {
		for _, b := range m.NodeDbKeys {
			l = len(b)
			n += 2 + l + sovSchedulerobjects(uint64(l))
		}
	}
	l = len(m.Executor)
	if l > 0 {
		n += 2 + l + sovSchedulerobjects(uint64(l))
	}
	return n
}

func (m *NodeType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovSchedulerobjects(uint64(m.Id))
	}
	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 len(m.UnsetIndexedLabels) > 0 {
		for k, v := range m.UnsetIndexedLabels {
			_ = 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 *QueueClusterResourceUsage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Created)
	n += 1 + l + sovSchedulerobjects(uint64(l))
	l = len(m.Queue)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	l = len(m.ExecutorId)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	if len(m.ResourcesByPriority) > 0 {
		for k, v := range m.ResourcesByPriority {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovSchedulerobjects(uint64(k)) + 1 + l + sovSchedulerobjects(uint64(l))
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	if len(m.ResourcesByPriorityClassName) > 0 {
		for k, v := range m.ResourcesByPriorityClassName {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovSchedulerobjects(uint64(len(k))) + 1 + l + sovSchedulerobjects(uint64(l))
			n += mapEntrySize + 1 + sovSchedulerobjects(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ClusterResourceUsageReport) 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 = github_com_gogo_protobuf_types.SizeOfStdTime(m.Created)
	n += 1 + l + sovSchedulerobjects(uint64(l))
	if len(m.ResourcesByQueue) > 0 {
		for k, v := range m.ResourcesByQueue {
			_ = 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 *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 = v.Size()
			mapEntrySize := 1 + len(k) + sovSchedulerobjects(uint64(len(k))) + 1 + l + sovSchedulerobjects(uint64(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))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.SubmitTime)
	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))
	}
	if m.QueueTtlSeconds != 0 {
		n += 1 + sovSchedulerobjects(uint64(m.QueueTtlSeconds))
	}
	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))
		}
	}
	if m.Priority != 0 {
		n += 1 + sovSchedulerobjects(uint64(m.Priority))
	}
	l = len(m.PreemptionPolicy)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	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))
		}
	}
	l = len(m.CachedSchedulingKey)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	return n
}

func (m *PulsarSchedulerJobDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.JobId)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	l = len(m.Queue)
	if l > 0 {
		n += 1 + l + sovSchedulerobjects(uint64(l))
	}
	l = len(m.JobSet)
	if l > 0 {
		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 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinimumJobSize", 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 err := m.MinimumJobSize.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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.LastUpdateTime, 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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.LastSeen, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeType", 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.NodeType == nil {
				m.NodeType = &NodeType{}
			}
			if err := m.NodeType.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeTypeId", wireType)
			}
			m.NodeTypeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeTypeId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 err := m.TotalResources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllocatableByPriorityAndResource", 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.AllocatableByPriorityAndResource == nil {
				m.AllocatableByPriorityAndResource = make(map[int32]ResourceList)
			}
			var mapkey int32
			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.AllocatableByPriorityAndResource[mapkey] = *mapvalue
			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 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllocatedByJobId", 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.AllocatedByJobId == nil {
				m.AllocatedByJobId = make(map[string]ResourceList)
			}
			var mapkey string
			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 {
					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 = &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.AllocatedByJobId[mapkey] = *mapvalue
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllocatedByQueue", 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.AllocatedByQueue == nil {
				m.AllocatedByQueue = make(map[string]ResourceList)
			}
			var mapkey string
			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 {
					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 = &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.AllocatedByQueue[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 NonArmadaAllocatedResources", 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.NonArmadaAllocatedResources == nil {
				m.NonArmadaAllocatedResources = make(map[int32]ResourceList)
			}
			var mapkey int32
			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.NonArmadaAllocatedResources[mapkey] = *mapvalue
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EvictedJobRunIds", 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.EvictedJobRunIds == nil {
				m.EvictedJobRunIds = make(map[string]bool)
			}
			var mapkey string
			var mapvalue bool
			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 mapvaluetemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchedulerobjects
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvalue = bool(mapvaluetemp != 0)
				} 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.EvictedJobRunIds[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 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceUsageByQueue", 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.ResourceUsageByQueue == nil {
				m.ResourceUsageByQueue = make(map[string]*ResourceList)
			}
			var mapkey string
			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 {
					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 = &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.ResourceUsageByQueue[mapkey] = mapvalue
			iNdEx = postIndex
		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 NodeDbKeys", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeDbKeys = append(m.NodeDbKeys, make([]byte, postIndex-iNdEx))
			copy(m.NodeDbKeys[len(m.NodeDbKeys)-1], 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
		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 *NodeType) 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: NodeType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 3:
			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 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnsetIndexedLabels", 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.UnsetIndexedLabels == nil {
				m.UnsetIndexedLabels = 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.UnsetIndexedLabels[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 *QueueClusterResourceUsage) 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: QueueClusterResourceUsage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueueClusterResourceUsage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Created", 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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Created, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 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 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourcesByPriority", 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.ResourcesByPriority == nil {
				m.ResourcesByPriority = make(map[int32]ResourceList)
			}
			var mapkey int32
			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.ResourcesByPriority[mapkey] = *mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourcesByPriorityClassName", 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.ResourcesByPriorityClassName == nil {
				m.ResourcesByPriorityClassName = make(map[string]ResourceList)
			}
			var mapkey string
			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 {
					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 = &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.ResourcesByPriorityClassName[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 *ClusterResourceUsageReport) 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: ClusterResourceUsageReport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterResourceUsageReport: 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 Created", 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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Created, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourcesByQueue", 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.ResourcesByQueue == nil {
				m.ResourcesByQueue = make(map[string]*QueueClusterResourceUsage)
			}
			var mapkey string
			var mapvalue *QueueClusterResourceUsage
			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 = &QueueClusterResourceUsage{}
					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.ResourcesByQueue[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 *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
			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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.SubmitTime, 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
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueTtlSeconds", wireType)
			}
			m.QueueTtlSeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QueueTtlSeconds |= int64(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 4:
			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 |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 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
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CachedSchedulingKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchedulerobjects
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSchedulerobjects
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CachedSchedulingKey = append(m.CachedSchedulingKey[:0], dAtA[iNdEx:postIndex]...)
			if m.CachedSchedulingKey == nil {
				m.CachedSchedulingKey = []byte{}
			}
			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 *PulsarSchedulerJobDetails) 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: PulsarSchedulerJobDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PulsarSchedulerJobDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobId", 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.JobId = 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 JobSet", 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.JobSet = 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 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")
)