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

package simulator

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	schedulerobjects "github.com/armadaproject/armada/internal/scheduler/schedulerobjects"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	v1 "k8s.io/api/core/v1"
	math "math"
	math_bits "math/bits"
)

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

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

type ClusterSpec struct {
	Name                             string              `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Clusters                         []*Cluster          `protobuf:"bytes,2,rep,name=clusters,proto3" json:"clusters,omitempty"`
	WorkflowManagerDelayDistribution *ShiftedExponential `protobuf:"bytes,3,opt,name=workflow_manager_delay_distribution,json=workflowManagerDelayDistribution,proto3" json:"workflowManagerDelayDistribution,omitempty"`
	PendingDelayDistribution         *ShiftedExponential `protobuf:"bytes,4,opt,name=pending_delay_distribution,json=pendingDelayDistribution,proto3" json:"pendingDelayDistribution,omitempty"`
}

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

var xxx_messageInfo_ClusterSpec proto.InternalMessageInfo

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

func (m *ClusterSpec) GetClusters() []*Cluster {
	if m != nil {
		return m.Clusters
	}
	return nil
}

func (m *ClusterSpec) GetWorkflowManagerDelayDistribution() *ShiftedExponential {
	if m != nil {
		return m.WorkflowManagerDelayDistribution
	}
	return nil
}

func (m *ClusterSpec) GetPendingDelayDistribution() *ShiftedExponential {
	if m != nil {
		return m.PendingDelayDistribution
	}
	return nil
}

type Cluster struct {
	Name          string          `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Pool          string          `protobuf:"bytes,3,opt,name=pool,proto3" json:"pool,omitempty"`
	NodeTemplates []*NodeTemplate `protobuf:"bytes,2,rep,name=node_templates,json=nodeTemplates,proto3" json:"nodeTemplates,omitempty"`
}

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

var xxx_messageInfo_Cluster proto.InternalMessageInfo

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

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

func (m *Cluster) GetNodeTemplates() []*NodeTemplate {
	if m != nil {
		return m.NodeTemplates
	}
	return nil
}

type WorkloadSpec struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Random seed used in simulations; use to ensure simulations are reproducible.
	// If not provided, or explicitly set to 0, the current time is used.
	RandomSeed int64    `protobuf:"varint,2,opt,name=random_seed,json=randomSeed,proto3" json:"randomSeed,omitempty"`
	Queues     []*Queue `protobuf:"bytes,3,rep,name=queues,proto3" json:"queues,omitempty"`
}

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

var xxx_messageInfo_WorkloadSpec proto.InternalMessageInfo

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

func (m *WorkloadSpec) GetRandomSeed() int64 {
	if m != nil {
		return m.RandomSeed
	}
	return 0
}

func (m *WorkloadSpec) GetQueues() []*Queue {
	if m != nil {
		return m.Queues
	}
	return nil
}

type NodeTemplate struct {
	Number         int64                          `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"`
	Taints         []*v1.Taint                    `protobuf:"bytes,2,rep,name=taints,proto3" json:"taints,omitempty"`
	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"`
	TotalResources *schedulerobjects.ResourceList `protobuf:"bytes,4,opt,name=total_resources,json=totalResources,proto3" json:"totalResources,omitempty"`
}

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

var xxx_messageInfo_NodeTemplate proto.InternalMessageInfo

func (m *NodeTemplate) GetNumber() int64 {
	if m != nil {
		return m.Number
	}
	return 0
}

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

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

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

type Queue struct {
	Name         string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Weight       float64        `protobuf:"fixed64,2,opt,name=weight,proto3" json:"weight,omitempty"`
	JobTemplates []*JobTemplate `protobuf:"bytes,3,rep,name=job_templates,json=jobTemplates,proto3" json:"jobTemplates,omitempty"`
}

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

var xxx_messageInfo_Queue proto.InternalMessageInfo

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

func (m *Queue) GetWeight() float64 {
	if m != nil {
		return m.Weight
	}
	return 0
}

func (m *Queue) GetJobTemplates() []*JobTemplate {
	if m != nil {
		return m.JobTemplates
	}
	return nil
}

type JobTemplate struct {
	// Number of jobs to create from this template.
	Number int64 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"`
	// Number of jobs created from this template that have succeeded.
	// Maintained by the simulator.
	NumberSuccessful int64 `protobuf:"varint,2,opt,name=numberSuccessful,proto3" json:"numberSuccessful,omitempty"`
	// Queue to which this template belongs. Populated automatically.
	Queue string `protobuf:"bytes,3,opt,name=queue,proto3" json:"queue,omitempty"`
	// Unique id for this template. An id is generated if empty.
	Id                string `protobuf:"bytes,4,opt,name=id,proto3" json:"id,omitempty"`
	JobSet            string `protobuf:"bytes,5,opt,name=job_set,json=jobSet,proto3" json:"jobSet,omitempty"`
	QueuePriority     uint32 `protobuf:"varint,6,opt,name=queue_priority,json=queuePriority,proto3" json:"queuePriority,omitempty"`
	PriorityClassName string `protobuf:"bytes,7,opt,name=priority_class_name,json=priorityClassName,proto3" json:"priorityClassName,omitempty"`
	// Scheduling requirements for the pod embedded in the job.
	Requirements *schedulerobjects.PodRequirements `protobuf:"bytes,8,opt,name=requirements,proto3" json:"requirements,omitempty"`
	// List of template ids that must be completed before this template is submitted.
	Dependencies []string `protobuf:"bytes,9,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
	// Earliest time at which jobs from this template are submitted.
	// Measured from the start of the simulation.
	EarliestSubmitTime *types.Duration `protobuf:"bytes,10,opt,name=earliest_submit_time,json=earliestSubmitTime,proto3" json:"earliestSubmitTime,omitempty"`
	// Earliest time job can be submitted from when all its dependencies have completed.
	// This option is meant to model thinking or processing time, where some fixed amount of time
	// needs to be spent between dependencies completing and the next batch of jobs being ready to submit.
	EarliestSubmitTimeFromDependencyCompletion *types.Duration `protobuf:"bytes,11,opt,name=earliest_submit_time_from_dependency_completion,json=earliestSubmitTimeFromDependencyCompletion,proto3" json:"earliestSubmitTimeFromDependencyCompletion,omitempty"`
	// Job runtimes are assumed to follow a shifted exponential distribution
	// i.e., to be a fixed constant (runtime_minimum) plus a random amount of time
	// drawn from an exponential distribution with known mean (runtime_tail_mean).
	//
	// The shifted-exponential distribution strikes a good balance between simplicity and accuracy;
	// see https://bora.uib.no/bora-xmlui/bitstream/handle/11250/3014726/drthesis_2022_severinson.pdf?sequence=2
	// for a discussion on the topic.
	RuntimeDistribution *ShiftedExponential `protobuf:"bytes,12,opt,name=runtime_distribution,json=runtimeDistribution,proto3" json:"runtimeDistribution,omitempty"`
	// If set, jobs will be assigned to gangs with the given size. In this case `number` must be exactly divisible by the gang size
	GangCardinality uint32 `protobuf:"varint,13,opt,name=gang_cardinality,json=gangCardinality,proto3" json:"gangCardinality,omitempty"`
	// Node Uniformity label when scheduling gangs.  Only applies if gang_cardinality is non-zero.  If unset it defaults to armadaproject.io/clusterName
	GangNodeUniformityLabel string `protobuf:"bytes,14,opt,name=gang_node_uniformity_label,json=gangNodeUniformityLabel,proto3" json:"gangNodeUniformityLabel,omitempty"`
	// If set then the template will be repeated at some frequency. If null then the template will be submitted a single time.
	Repeat *RepeatDetails `protobuf:"bytes,15,opt,name=repeat,proto3" json:"repeat,omitempty"`
}

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

var xxx_messageInfo_JobTemplate proto.InternalMessageInfo

func (m *JobTemplate) GetNumber() int64 {
	if m != nil {
		return m.Number
	}
	return 0
}

func (m *JobTemplate) GetNumberSuccessful() int64 {
	if m != nil {
		return m.NumberSuccessful
	}
	return 0
}

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

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

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

func (m *JobTemplate) GetQueuePriority() uint32 {
	if m != nil {
		return m.QueuePriority
	}
	return 0
}

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

func (m *JobTemplate) GetRequirements() *schedulerobjects.PodRequirements {
	if m != nil {
		return m.Requirements
	}
	return nil
}

func (m *JobTemplate) GetDependencies() []string {
	if m != nil {
		return m.Dependencies
	}
	return nil
}

func (m *JobTemplate) GetEarliestSubmitTime() *types.Duration {
	if m != nil {
		return m.EarliestSubmitTime
	}
	return nil
}

func (m *JobTemplate) GetEarliestSubmitTimeFromDependencyCompletion() *types.Duration {
	if m != nil {
		return m.EarliestSubmitTimeFromDependencyCompletion
	}
	return nil
}

func (m *JobTemplate) GetRuntimeDistribution() *ShiftedExponential {
	if m != nil {
		return m.RuntimeDistribution
	}
	return nil
}

func (m *JobTemplate) GetGangCardinality() uint32 {
	if m != nil {
		return m.GangCardinality
	}
	return 0
}

func (m *JobTemplate) GetGangNodeUniformityLabel() string {
	if m != nil {
		return m.GangNodeUniformityLabel
	}
	return ""
}

func (m *JobTemplate) GetRepeat() *RepeatDetails {
	if m != nil {
		return m.Repeat
	}
	return nil
}

type RepeatDetails struct {
	// The number of times that template should be repeated. Must be > 0
	NumTimes uint32 `protobuf:"varint,1,opt,name=num_times,json=numTimes,proto3" json:"numTimes,omitempty"`
	// The period between template submissions.  May not be null
	Period *types.Duration `protobuf:"bytes,2,opt,name=period,proto3" json:"period,omitempty"`
}

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

var xxx_messageInfo_RepeatDetails proto.InternalMessageInfo

func (m *RepeatDetails) GetNumTimes() uint32 {
	if m != nil {
		return m.NumTimes
	}
	return 0
}

func (m *RepeatDetails) GetPeriod() *types.Duration {
	if m != nil {
		return m.Period
	}
	return nil
}

type ShiftedExponential struct {
	Minimum  *types.Duration `protobuf:"bytes,1,opt,name=minimum,proto3" json:"minimum,omitempty"`
	TailMean *types.Duration `protobuf:"bytes,2,opt,name=tail_mean,json=tailMean,proto3" json:"tailMean,omitempty"`
}

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

var xxx_messageInfo_ShiftedExponential proto.InternalMessageInfo

func (m *ShiftedExponential) GetMinimum() *types.Duration {
	if m != nil {
		return m.Minimum
	}
	return nil
}

func (m *ShiftedExponential) GetTailMean() *types.Duration {
	if m != nil {
		return m.TailMean
	}
	return nil
}

func init() {
	proto.RegisterType((*ClusterSpec)(nil), "simulator.ClusterSpec")
	proto.RegisterType((*Cluster)(nil), "simulator.Cluster")
	proto.RegisterType((*WorkloadSpec)(nil), "simulator.WorkloadSpec")
	proto.RegisterType((*NodeTemplate)(nil), "simulator.NodeTemplate")
	proto.RegisterMapType((map[string]string)(nil), "simulator.NodeTemplate.LabelsEntry")
	proto.RegisterType((*Queue)(nil), "simulator.Queue")
	proto.RegisterType((*JobTemplate)(nil), "simulator.JobTemplate")
	proto.RegisterType((*RepeatDetails)(nil), "simulator.RepeatDetails")
	proto.RegisterType((*ShiftedExponential)(nil), "simulator.ShiftedExponential")
}

func init() {
	proto.RegisterFile("internal/scheduler/simulator/simulator.proto", fileDescriptor_63baccdfe9127510)
}

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

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

func (m *ClusterSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PendingDelayDistribution != nil {
		{
			size, err := m.PendingDelayDistribution.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.WorkflowManagerDelayDistribution != nil {
		{
			size, err := m.WorkflowManagerDelayDistribution.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Clusters) > 0 {
		for iNdEx := len(m.Clusters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Clusters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSimulator(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSimulator(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Cluster) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Pool) > 0 {
		i -= len(m.Pool)
		copy(dAtA[i:], m.Pool)
		i = encodeVarintSimulator(dAtA, i, uint64(len(m.Pool)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.NodeTemplates) > 0 {
		for iNdEx := len(m.NodeTemplates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NodeTemplates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSimulator(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSimulator(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *WorkloadSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Queues) > 0 {
		for iNdEx := len(m.Queues) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Queues[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSimulator(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.RandomSeed != 0 {
		i = encodeVarintSimulator(dAtA, i, uint64(m.RandomSeed))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSimulator(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NodeTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TotalResources != nil {
		{
			size, err := m.TotalResources.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		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 = encodeVarintSimulator(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintSimulator(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintSimulator(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 = encodeVarintSimulator(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Number != 0 {
		i = encodeVarintSimulator(dAtA, i, uint64(m.Number))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Queue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.JobTemplates) > 0 {
		for iNdEx := len(m.JobTemplates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.JobTemplates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSimulator(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Weight != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Weight))))
		i--
		dAtA[i] = 0x11
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSimulator(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *JobTemplate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Repeat != nil {
		{
			size, err := m.Repeat.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if len(m.GangNodeUniformityLabel) > 0 {
		i -= len(m.GangNodeUniformityLabel)
		copy(dAtA[i:], m.GangNodeUniformityLabel)
		i = encodeVarintSimulator(dAtA, i, uint64(len(m.GangNodeUniformityLabel)))
		i--
		dAtA[i] = 0x72
	}
	if m.GangCardinality != 0 {
		i = encodeVarintSimulator(dAtA, i, uint64(m.GangCardinality))
		i--
		dAtA[i] = 0x68
	}
	if m.RuntimeDistribution != nil {
		{
			size, err := m.RuntimeDistribution.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.EarliestSubmitTimeFromDependencyCompletion != nil {
		{
			size, err := m.EarliestSubmitTimeFromDependencyCompletion.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if m.EarliestSubmitTime != nil {
		{
			size, err := m.EarliestSubmitTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if len(m.Dependencies) > 0 {
		for iNdEx := len(m.Dependencies) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Dependencies[iNdEx])
			copy(dAtA[i:], m.Dependencies[iNdEx])
			i = encodeVarintSimulator(dAtA, i, uint64(len(m.Dependencies[iNdEx])))
			i--
			dAtA[i] = 0x4a
		}
	}
	if m.Requirements != nil {
		{
			size, err := m.Requirements.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.PriorityClassName) > 0 {
		i -= len(m.PriorityClassName)
		copy(dAtA[i:], m.PriorityClassName)
		i = encodeVarintSimulator(dAtA, i, uint64(len(m.PriorityClassName)))
		i--
		dAtA[i] = 0x3a
	}
	if m.QueuePriority != 0 {
		i = encodeVarintSimulator(dAtA, i, uint64(m.QueuePriority))
		i--
		dAtA[i] = 0x30
	}
	if len(m.JobSet) > 0 {
		i -= len(m.JobSet)
		copy(dAtA[i:], m.JobSet)
		i = encodeVarintSimulator(dAtA, i, uint64(len(m.JobSet)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintSimulator(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Queue) > 0 {
		i -= len(m.Queue)
		copy(dAtA[i:], m.Queue)
		i = encodeVarintSimulator(dAtA, i, uint64(len(m.Queue)))
		i--
		dAtA[i] = 0x1a
	}
	if m.NumberSuccessful != 0 {
		i = encodeVarintSimulator(dAtA, i, uint64(m.NumberSuccessful))
		i--
		dAtA[i] = 0x10
	}
	if m.Number != 0 {
		i = encodeVarintSimulator(dAtA, i, uint64(m.Number))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *RepeatDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Period != nil {
		{
			size, err := m.Period.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.NumTimes != 0 {
		i = encodeVarintSimulator(dAtA, i, uint64(m.NumTimes))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ShiftedExponential) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TailMean != nil {
		{
			size, err := m.TailMean.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Minimum != nil {
		{
			size, err := m.Minimum.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSimulator(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintSimulator(dAtA []byte, offset int, v uint64) int {
	offset -= sovSimulator(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ClusterSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSimulator(uint64(l))
	}
	if len(m.Clusters) > 0 {
		for _, e := range m.Clusters {
			l = e.Size()
			n += 1 + l + sovSimulator(uint64(l))
		}
	}
	if m.WorkflowManagerDelayDistribution != nil {
		l = m.WorkflowManagerDelayDistribution.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	if m.PendingDelayDistribution != nil {
		l = m.PendingDelayDistribution.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	return n
}

func (m *Cluster) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSimulator(uint64(l))
	}
	if len(m.NodeTemplates) > 0 {
		for _, e := range m.NodeTemplates {
			l = e.Size()
			n += 1 + l + sovSimulator(uint64(l))
		}
	}
	l = len(m.Pool)
	if l > 0 {
		n += 1 + l + sovSimulator(uint64(l))
	}
	return n
}

func (m *WorkloadSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSimulator(uint64(l))
	}
	if m.RandomSeed != 0 {
		n += 1 + sovSimulator(uint64(m.RandomSeed))
	}
	if len(m.Queues) > 0 {
		for _, e := range m.Queues {
			l = e.Size()
			n += 1 + l + sovSimulator(uint64(l))
		}
	}
	return n
}

func (m *NodeTemplate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Number != 0 {
		n += 1 + sovSimulator(uint64(m.Number))
	}
	if len(m.Taints) > 0 {
		for _, e := range m.Taints {
			l = e.Size()
			n += 1 + l + sovSimulator(uint64(l))
		}
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovSimulator(uint64(len(k))) + 1 + len(v) + sovSimulator(uint64(len(v)))
			n += mapEntrySize + 1 + sovSimulator(uint64(mapEntrySize))
		}
	}
	if m.TotalResources != nil {
		l = m.TotalResources.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	return n
}

func (m *Queue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSimulator(uint64(l))
	}
	if m.Weight != 0 {
		n += 9
	}
	if len(m.JobTemplates) > 0 {
		for _, e := range m.JobTemplates {
			l = e.Size()
			n += 1 + l + sovSimulator(uint64(l))
		}
	}
	return n
}

func (m *JobTemplate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Number != 0 {
		n += 1 + sovSimulator(uint64(m.Number))
	}
	if m.NumberSuccessful != 0 {
		n += 1 + sovSimulator(uint64(m.NumberSuccessful))
	}
	l = len(m.Queue)
	if l > 0 {
		n += 1 + l + sovSimulator(uint64(l))
	}
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovSimulator(uint64(l))
	}
	l = len(m.JobSet)
	if l > 0 {
		n += 1 + l + sovSimulator(uint64(l))
	}
	if m.QueuePriority != 0 {
		n += 1 + sovSimulator(uint64(m.QueuePriority))
	}
	l = len(m.PriorityClassName)
	if l > 0 {
		n += 1 + l + sovSimulator(uint64(l))
	}
	if m.Requirements != nil {
		l = m.Requirements.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	if len(m.Dependencies) > 0 {
		for _, s := range m.Dependencies {
			l = len(s)
			n += 1 + l + sovSimulator(uint64(l))
		}
	}
	if m.EarliestSubmitTime != nil {
		l = m.EarliestSubmitTime.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	if m.EarliestSubmitTimeFromDependencyCompletion != nil {
		l = m.EarliestSubmitTimeFromDependencyCompletion.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	if m.RuntimeDistribution != nil {
		l = m.RuntimeDistribution.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	if m.GangCardinality != 0 {
		n += 1 + sovSimulator(uint64(m.GangCardinality))
	}
	l = len(m.GangNodeUniformityLabel)
	if l > 0 {
		n += 1 + l + sovSimulator(uint64(l))
	}
	if m.Repeat != nil {
		l = m.Repeat.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	return n
}

func (m *RepeatDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NumTimes != 0 {
		n += 1 + sovSimulator(uint64(m.NumTimes))
	}
	if m.Period != nil {
		l = m.Period.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	return n
}

func (m *ShiftedExponential) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Minimum != nil {
		l = m.Minimum.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	if m.TailMean != nil {
		l = m.TailMean.Size()
		n += 1 + l + sovSimulator(uint64(l))
	}
	return n
}

func sovSimulator(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSimulator(x uint64) (n int) {
	return sovSimulator(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ClusterSpec) 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 ErrIntOverflowSimulator
			}
			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: ClusterSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				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 ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Clusters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Clusters = append(m.Clusters, &Cluster{})
			if err := m.Clusters[len(m.Clusters)-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 WorkflowManagerDelayDistribution", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.WorkflowManagerDelayDistribution == nil {
				m.WorkflowManagerDelayDistribution = &ShiftedExponential{}
			}
			if err := m.WorkflowManagerDelayDistribution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PendingDelayDistribution", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PendingDelayDistribution == nil {
				m.PendingDelayDistribution = &ShiftedExponential{}
			}
			if err := m.PendingDelayDistribution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSimulator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSimulator
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeTemplate) 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 ErrIntOverflowSimulator
			}
			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: NodeTemplate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeTemplate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType)
			}
			m.Number = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Number |= int64(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 ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			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 ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			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 ErrIntOverflowSimulator
					}
					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 ErrIntOverflowSimulator
						}
						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 ErrInvalidLengthSimulator
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthSimulator
					}
					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 ErrIntOverflowSimulator
						}
						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 ErrInvalidLengthSimulator
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthSimulator
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipSimulator(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthSimulator
					}
					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 TotalResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TotalResources == nil {
				m.TotalResources = &schedulerobjects.ResourceList{}
			}
			if err := m.TotalResources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSimulator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSimulator
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Queue) 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 ErrIntOverflowSimulator
			}
			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: Queue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Queue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				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 ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Weight = float64(math.Float64frombits(v))
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobTemplates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobTemplates = append(m.JobTemplates, &JobTemplate{})
			if err := m.JobTemplates[len(m.JobTemplates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSimulator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSimulator
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobTemplate) 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 ErrIntOverflowSimulator
			}
			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: JobTemplate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobTemplate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType)
			}
			m.Number = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Number |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumberSuccessful", wireType)
			}
			m.NumberSuccessful = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumberSuccessful |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowSimulator
				}
				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 ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Queue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowSimulator
				}
				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 ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowSimulator
				}
				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 ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobSet = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueuePriority", wireType)
			}
			m.QueuePriority = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QueuePriority |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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 ErrIntOverflowSimulator
				}
				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 ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PriorityClassName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requirements", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Requirements == nil {
				m.Requirements = &schedulerobjects.PodRequirements{}
			}
			if err := m.Requirements.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dependencies", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				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 ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dependencies = append(m.Dependencies, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EarliestSubmitTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EarliestSubmitTime == nil {
				m.EarliestSubmitTime = &types.Duration{}
			}
			if err := m.EarliestSubmitTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EarliestSubmitTimeFromDependencyCompletion", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EarliestSubmitTimeFromDependencyCompletion == nil {
				m.EarliestSubmitTimeFromDependencyCompletion = &types.Duration{}
			}
			if err := m.EarliestSubmitTimeFromDependencyCompletion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RuntimeDistribution", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RuntimeDistribution == nil {
				m.RuntimeDistribution = &ShiftedExponential{}
			}
			if err := m.RuntimeDistribution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GangCardinality", wireType)
			}
			m.GangCardinality = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GangCardinality |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GangNodeUniformityLabel", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				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 ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GangNodeUniformityLabel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Repeat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSimulator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSimulator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSimulator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Repeat == nil {
				m.Repeat = &RepeatDetails{}
			}
			if err := m.Repeat.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSimulator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSimulator
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

var (
	ErrInvalidLengthSimulator        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSimulator          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSimulator = fmt.Errorf("proto: unexpected end of group")
)
