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

package models

import (
	bytes "bytes"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

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

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

type DesiredLRPSchedulingInfo struct {
	DesiredLRPKey      `protobuf:"bytes,1,opt,name=desired_lrp_key,json=desiredLrpKey,proto3,embedded=desired_lrp_key" json:""`
	Annotation         string `protobuf:"bytes,2,opt,name=annotation,proto3" json:"annotation"`
	Instances          int32  `protobuf:"varint,3,opt,name=instances,proto3" json:"instances"`
	DesiredLRPResource `protobuf:"bytes,4,opt,name=desired_lrp_resource,json=desiredLrpResource,proto3,embedded=desired_lrp_resource" json:""`
	Routes             Routes `protobuf:"bytes,5,opt,name=routes,proto3,customtype=Routes" json:"routes"`
	ModificationTag    `protobuf:"bytes,6,opt,name=modification_tag,json=modificationTag,proto3,embedded=modification_tag" json:""`
	VolumePlacement    *VolumePlacement `protobuf:"bytes,7,opt,name=volume_placement,json=volumePlacement,proto3" json:"volume_placement,omitempty"`
	PlacementTags      []string         `protobuf:"bytes,8,rep,name=PlacementTags,proto3" json:"placement_tags,omitempty"`
}

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

var xxx_messageInfo_DesiredLRPSchedulingInfo proto.InternalMessageInfo

func (m *DesiredLRPSchedulingInfo) GetAnnotation() string {
	if m != nil {
		return m.Annotation
	}
	return ""
}

func (m *DesiredLRPSchedulingInfo) GetInstances() int32 {
	if m != nil {
		return m.Instances
	}
	return 0
}

func (m *DesiredLRPSchedulingInfo) GetVolumePlacement() *VolumePlacement {
	if m != nil {
		return m.VolumePlacement
	}
	return nil
}

func (m *DesiredLRPSchedulingInfo) GetPlacementTags() []string {
	if m != nil {
		return m.PlacementTags
	}
	return nil
}

type DesiredLRPRunInfo struct {
	DesiredLRPKey                 `protobuf:"bytes,1,opt,name=desired_lrp_key,json=desiredLrpKey,proto3,embedded=desired_lrp_key" json:""`
	EnvironmentVariables          []EnvironmentVariable      `protobuf:"bytes,2,rep,name=environment_variables,json=environmentVariables,proto3" json:"env"`
	Setup                         *Action                    `protobuf:"bytes,3,opt,name=setup,proto3" json:"setup,omitempty"`
	Action                        *Action                    `protobuf:"bytes,4,opt,name=action,proto3" json:"action,omitempty"`
	Monitor                       *Action                    `protobuf:"bytes,5,opt,name=monitor,proto3" json:"monitor,omitempty"`
	DeprecatedStartTimeoutS       uint32                     `protobuf:"varint,6,opt,name=deprecated_start_timeout_s,json=deprecatedStartTimeoutS,proto3" json:"start_timeout,omitempty"` // Deprecated: Do not use.
	Privileged                    bool                       `protobuf:"varint,7,opt,name=privileged,proto3" json:"privileged"`
	CpuWeight                     uint32                     `protobuf:"varint,8,opt,name=cpu_weight,json=cpuWeight,proto3" json:"cpu_weight"`
	Ports                         []uint32                   `protobuf:"varint,9,rep,name=ports,proto3" json:"ports,omitempty"`
	EgressRules                   []SecurityGroupRule        `protobuf:"bytes,10,rep,name=egress_rules,json=egressRules,proto3" json:"egress_rules"`
	LogSource                     string                     `protobuf:"bytes,11,opt,name=log_source,json=logSource,proto3" json:"log_source"`
	MetricsGuid                   string                     `protobuf:"bytes,12,opt,name=metrics_guid,json=metricsGuid,proto3" json:"metrics_guid"` // Deprecated: Do not use.
	CreatedAt                     int64                      `protobuf:"varint,13,opt,name=created_at,json=createdAt,proto3" json:"created_at"`
	CachedDependencies            []*CachedDependency        `protobuf:"bytes,14,rep,name=cached_dependencies,json=cachedDependencies,proto3" json:"cached_dependencies,omitempty"`
	LegacyDownloadUser            string                     `protobuf:"bytes,15,opt,name=legacy_download_user,json=legacyDownloadUser,proto3" json:"legacy_download_user,omitempty"` // Deprecated: Do not use.
	TrustedSystemCertificatesPath string                     `protobuf:"bytes,16,opt,name=trusted_system_certificates_path,json=trustedSystemCertificatesPath,proto3" json:"trusted_system_certificates_path,omitempty"`
	VolumeMounts                  []*VolumeMount             `protobuf:"bytes,17,rep,name=volume_mounts,json=volumeMounts,proto3" json:"volume_mounts,omitempty"`
	Network                       *Network                   `protobuf:"bytes,18,opt,name=network,proto3" json:"network,omitempty"`
	StartTimeoutMs                int64                      `protobuf:"varint,19,opt,name=start_timeout_ms,json=startTimeoutMs,proto3" json:"start_timeout_ms"`
	CertificateProperties         *CertificateProperties     `protobuf:"bytes,20,opt,name=certificate_properties,json=certificateProperties,proto3" json:"certificate_properties,omitempty"`
	ImageUsername                 string                     `protobuf:"bytes,21,opt,name=image_username,json=imageUsername,proto3" json:"image_username,omitempty"`
	ImagePassword                 string                     `protobuf:"bytes,22,opt,name=image_password,json=imagePassword,proto3" json:"image_password,omitempty"`
	CheckDefinition               *CheckDefinition           `protobuf:"bytes,23,opt,name=check_definition,json=checkDefinition,proto3" json:"check_definition,omitempty"`
	ImageLayers                   []*ImageLayer              `protobuf:"bytes,24,rep,name=image_layers,json=imageLayers,proto3" json:"image_layers,omitempty"`
	MetricTags                    map[string]*MetricTagValue `protobuf:"bytes,25,rep,name=metric_tags,json=metricTags,proto3" json:"metric_tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Deprecated: Do not use.
	Sidecars                      []*Sidecar                 `protobuf:"bytes,26,rep,name=sidecars,proto3" json:"sidecars,omitempty"`
	LogRateLimit                  *LogRateLimit              `protobuf:"bytes,27,opt,name=log_rate_limit,json=logRateLimit,proto3" json:"log_rate_limit,omitempty"`
}

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

var xxx_messageInfo_DesiredLRPRunInfo proto.InternalMessageInfo

func (m *DesiredLRPRunInfo) GetEnvironmentVariables() []EnvironmentVariable {
	if m != nil {
		return m.EnvironmentVariables
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetSetup() *Action {
	if m != nil {
		return m.Setup
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetAction() *Action {
	if m != nil {
		return m.Action
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetMonitor() *Action {
	if m != nil {
		return m.Monitor
	}
	return nil
}

// Deprecated: Do not use.
func (m *DesiredLRPRunInfo) GetDeprecatedStartTimeoutS() uint32 {
	if m != nil {
		return m.DeprecatedStartTimeoutS
	}
	return 0
}

func (m *DesiredLRPRunInfo) GetPrivileged() bool {
	if m != nil {
		return m.Privileged
	}
	return false
}

func (m *DesiredLRPRunInfo) GetCpuWeight() uint32 {
	if m != nil {
		return m.CpuWeight
	}
	return 0
}

func (m *DesiredLRPRunInfo) GetPorts() []uint32 {
	if m != nil {
		return m.Ports
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetEgressRules() []SecurityGroupRule {
	if m != nil {
		return m.EgressRules
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetLogSource() string {
	if m != nil {
		return m.LogSource
	}
	return ""
}

// Deprecated: Do not use.
func (m *DesiredLRPRunInfo) GetMetricsGuid() string {
	if m != nil {
		return m.MetricsGuid
	}
	return ""
}

func (m *DesiredLRPRunInfo) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

func (m *DesiredLRPRunInfo) GetCachedDependencies() []*CachedDependency {
	if m != nil {
		return m.CachedDependencies
	}
	return nil
}

// Deprecated: Do not use.
func (m *DesiredLRPRunInfo) GetLegacyDownloadUser() string {
	if m != nil {
		return m.LegacyDownloadUser
	}
	return ""
}

func (m *DesiredLRPRunInfo) GetTrustedSystemCertificatesPath() string {
	if m != nil {
		return m.TrustedSystemCertificatesPath
	}
	return ""
}

func (m *DesiredLRPRunInfo) GetVolumeMounts() []*VolumeMount {
	if m != nil {
		return m.VolumeMounts
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetNetwork() *Network {
	if m != nil {
		return m.Network
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetStartTimeoutMs() int64 {
	if m != nil {
		return m.StartTimeoutMs
	}
	return 0
}

func (m *DesiredLRPRunInfo) GetCertificateProperties() *CertificateProperties {
	if m != nil {
		return m.CertificateProperties
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetImageUsername() string {
	if m != nil {
		return m.ImageUsername
	}
	return ""
}

func (m *DesiredLRPRunInfo) GetImagePassword() string {
	if m != nil {
		return m.ImagePassword
	}
	return ""
}

func (m *DesiredLRPRunInfo) GetCheckDefinition() *CheckDefinition {
	if m != nil {
		return m.CheckDefinition
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetImageLayers() []*ImageLayer {
	if m != nil {
		return m.ImageLayers
	}
	return nil
}

// Deprecated: Do not use.
func (m *DesiredLRPRunInfo) GetMetricTags() map[string]*MetricTagValue {
	if m != nil {
		return m.MetricTags
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetSidecars() []*Sidecar {
	if m != nil {
		return m.Sidecars
	}
	return nil
}

func (m *DesiredLRPRunInfo) GetLogRateLimit() *LogRateLimit {
	if m != nil {
		return m.LogRateLimit
	}
	return nil
}

// helper message for marshalling routes
type ProtoRoutes struct {
	Routes map[string][]byte `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_ProtoRoutes proto.InternalMessageInfo

func (m *ProtoRoutes) GetRoutes() map[string][]byte {
	if m != nil {
		return m.Routes
	}
	return nil
}

type DesiredLRPUpdate struct {
	// Types that are valid to be assigned to OptionalInstances:
	//
	//	*DesiredLRPUpdate_Instances
	OptionalInstances isDesiredLRPUpdate_OptionalInstances `protobuf_oneof:"optional_instances"`
	Routes            *Routes                              `protobuf:"bytes,2,opt,name=routes,proto3,customtype=Routes" json:"routes,omitempty"`
	// Types that are valid to be assigned to OptionalAnnotation:
	//
	//	*DesiredLRPUpdate_Annotation
	OptionalAnnotation isDesiredLRPUpdate_OptionalAnnotation `protobuf_oneof:"optional_annotation"`
	MetricTags         map[string]*MetricTagValue            `protobuf:"bytes,4,rep,name=metric_tags,json=metricTags,proto3" json:"metric_tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_DesiredLRPUpdate proto.InternalMessageInfo

type isDesiredLRPUpdate_OptionalInstances interface {
	isDesiredLRPUpdate_OptionalInstances()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}
type isDesiredLRPUpdate_OptionalAnnotation interface {
	isDesiredLRPUpdate_OptionalAnnotation()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type DesiredLRPUpdate_Instances struct {
	Instances int32 `protobuf:"varint,1,opt,name=instances,proto3,oneof" json:"instances,omitempty"`
}
type DesiredLRPUpdate_Annotation struct {
	Annotation string `protobuf:"bytes,3,opt,name=annotation,proto3,oneof" json:"annotation,omitempty"`
}

func (*DesiredLRPUpdate_Instances) isDesiredLRPUpdate_OptionalInstances()   {}
func (*DesiredLRPUpdate_Annotation) isDesiredLRPUpdate_OptionalAnnotation() {}

func (m *DesiredLRPUpdate) GetOptionalInstances() isDesiredLRPUpdate_OptionalInstances {
	if m != nil {
		return m.OptionalInstances
	}
	return nil
}
func (m *DesiredLRPUpdate) GetOptionalAnnotation() isDesiredLRPUpdate_OptionalAnnotation {
	if m != nil {
		return m.OptionalAnnotation
	}
	return nil
}

func (m *DesiredLRPUpdate) GetInstances() int32 {
	if x, ok := m.GetOptionalInstances().(*DesiredLRPUpdate_Instances); ok {
		return x.Instances
	}
	return 0
}

func (m *DesiredLRPUpdate) GetAnnotation() string {
	if x, ok := m.GetOptionalAnnotation().(*DesiredLRPUpdate_Annotation); ok {
		return x.Annotation
	}
	return ""
}

func (m *DesiredLRPUpdate) GetMetricTags() map[string]*MetricTagValue {
	if m != nil {
		return m.MetricTags
	}
	return nil
}

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

type DesiredLRPKey struct {
	ProcessGuid string `protobuf:"bytes,1,opt,name=process_guid,json=processGuid,proto3" json:"process_guid"`
	Domain      string `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain"`
	LogGuid     string `protobuf:"bytes,3,opt,name=log_guid,json=logGuid,proto3" json:"log_guid"`
}

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

var xxx_messageInfo_DesiredLRPKey proto.InternalMessageInfo

func (m *DesiredLRPKey) GetProcessGuid() string {
	if m != nil {
		return m.ProcessGuid
	}
	return ""
}

func (m *DesiredLRPKey) GetDomain() string {
	if m != nil {
		return m.Domain
	}
	return ""
}

func (m *DesiredLRPKey) GetLogGuid() string {
	if m != nil {
		return m.LogGuid
	}
	return ""
}

type DesiredLRPResource struct {
	MemoryMb int32  `protobuf:"varint,1,opt,name=memory_mb,json=memoryMb,proto3" json:"memory_mb"`
	DiskMb   int32  `protobuf:"varint,2,opt,name=disk_mb,json=diskMb,proto3" json:"disk_mb"`
	RootFs   string `protobuf:"bytes,3,opt,name=root_fs,json=rootFs,proto3" json:"rootfs"`
	MaxPids  int32  `protobuf:"varint,4,opt,name=max_pids,json=maxPids,proto3" json:"max_pids"`
}

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

var xxx_messageInfo_DesiredLRPResource proto.InternalMessageInfo

func (m *DesiredLRPResource) GetMemoryMb() int32 {
	if m != nil {
		return m.MemoryMb
	}
	return 0
}

func (m *DesiredLRPResource) GetDiskMb() int32 {
	if m != nil {
		return m.DiskMb
	}
	return 0
}

func (m *DesiredLRPResource) GetRootFs() string {
	if m != nil {
		return m.RootFs
	}
	return ""
}

func (m *DesiredLRPResource) GetMaxPids() int32 {
	if m != nil {
		return m.MaxPids
	}
	return 0
}

type DesiredLRP struct {
	ProcessGuid                   string                     `protobuf:"bytes,1,opt,name=process_guid,json=processGuid,proto3" json:"process_guid"`
	Domain                        string                     `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain"`
	RootFs                        string                     `protobuf:"bytes,3,opt,name=root_fs,json=rootFs,proto3" json:"rootfs"`
	Instances                     int32                      `protobuf:"varint,4,opt,name=instances,proto3" json:"instances"`
	EnvironmentVariables          []*EnvironmentVariable     `protobuf:"bytes,5,rep,name=environment_variables,json=environmentVariables,proto3" json:"env"`
	Setup                         *Action                    `protobuf:"bytes,6,opt,name=setup,proto3" json:"setup,omitempty"`
	Action                        *Action                    `protobuf:"bytes,7,opt,name=action,proto3" json:"action,omitempty"`
	StartTimeoutMs                int64                      `protobuf:"varint,27,opt,name=start_timeout_ms,json=startTimeoutMs,proto3" json:"start_timeout_ms"`
	DeprecatedStartTimeoutS       uint32                     `protobuf:"varint,8,opt,name=deprecated_start_timeout_s,json=deprecatedStartTimeoutS,proto3" json:"deprecated_timeout_ns,omitempty"` // Deprecated: Do not use.
	Monitor                       *Action                    `protobuf:"bytes,9,opt,name=monitor,proto3" json:"monitor,omitempty"`
	DiskMb                        int32                      `protobuf:"varint,10,opt,name=disk_mb,json=diskMb,proto3" json:"disk_mb"`
	MemoryMb                      int32                      `protobuf:"varint,11,opt,name=memory_mb,json=memoryMb,proto3" json:"memory_mb"`
	CpuWeight                     uint32                     `protobuf:"varint,12,opt,name=cpu_weight,json=cpuWeight,proto3" json:"cpu_weight"`
	Privileged                    bool                       `protobuf:"varint,13,opt,name=privileged,proto3" json:"privileged"`
	Ports                         []uint32                   `protobuf:"varint,14,rep,name=ports,proto3" json:"ports,omitempty"`
	Routes                        *Routes                    `protobuf:"bytes,15,opt,name=routes,proto3,customtype=Routes" json:"routes,omitempty"`
	LogSource                     string                     `protobuf:"bytes,16,opt,name=log_source,json=logSource,proto3" json:"log_source"`
	LogGuid                       string                     `protobuf:"bytes,17,opt,name=log_guid,json=logGuid,proto3" json:"log_guid"`
	MetricsGuid                   string                     `protobuf:"bytes,18,opt,name=metrics_guid,json=metricsGuid,proto3" json:"metrics_guid"` // Deprecated: Do not use.
	Annotation                    string                     `protobuf:"bytes,19,opt,name=annotation,proto3" json:"annotation"`
	EgressRules                   []*SecurityGroupRule       `protobuf:"bytes,20,rep,name=egress_rules,json=egressRules,proto3" json:"egress_rules,omitempty"`
	ModificationTag               *ModificationTag           `protobuf:"bytes,21,opt,name=modification_tag,json=modificationTag,proto3" json:"modification_tag,omitempty"`
	CachedDependencies            []*CachedDependency        `protobuf:"bytes,22,rep,name=cached_dependencies,json=cachedDependencies,proto3" json:"cached_dependencies,omitempty"`
	LegacyDownloadUser            string                     `protobuf:"bytes,23,opt,name=legacy_download_user,json=legacyDownloadUser,proto3" json:"legacy_download_user,omitempty"` // Deprecated: Do not use.
	TrustedSystemCertificatesPath string                     `protobuf:"bytes,24,opt,name=trusted_system_certificates_path,json=trustedSystemCertificatesPath,proto3" json:"trusted_system_certificates_path,omitempty"`
	VolumeMounts                  []*VolumeMount             `protobuf:"bytes,25,rep,name=volume_mounts,json=volumeMounts,proto3" json:"volume_mounts,omitempty"`
	Network                       *Network                   `protobuf:"bytes,26,opt,name=network,proto3" json:"network,omitempty"`
	PlacementTags                 []string                   `protobuf:"bytes,28,rep,name=PlacementTags,proto3" json:"placement_tags,omitempty"`
	MaxPids                       int32                      `protobuf:"varint,29,opt,name=max_pids,json=maxPids,proto3" json:"max_pids"`
	CertificateProperties         *CertificateProperties     `protobuf:"bytes,30,opt,name=certificate_properties,json=certificateProperties,proto3" json:"certificate_properties,omitempty"`
	ImageUsername                 string                     `protobuf:"bytes,31,opt,name=image_username,json=imageUsername,proto3" json:"image_username,omitempty"`
	ImagePassword                 string                     `protobuf:"bytes,32,opt,name=image_password,json=imagePassword,proto3" json:"image_password,omitempty"`
	CheckDefinition               *CheckDefinition           `protobuf:"bytes,33,opt,name=check_definition,json=checkDefinition,proto3" json:"check_definition,omitempty"`
	ImageLayers                   []*ImageLayer              `protobuf:"bytes,34,rep,name=image_layers,json=imageLayers,proto3" json:"image_layers,omitempty"`
	MetricTags                    map[string]*MetricTagValue `protobuf:"bytes,35,rep,name=metric_tags,json=metricTags,proto3" json:"metric_tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Sidecars                      []*Sidecar                 `protobuf:"bytes,36,rep,name=sidecars,proto3" json:"sidecars,omitempty"`
	LogRateLimit                  *LogRateLimit              `protobuf:"bytes,37,opt,name=log_rate_limit,json=logRateLimit,proto3" json:"log_rate_limit,omitempty"`
}

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

var xxx_messageInfo_DesiredLRP proto.InternalMessageInfo

func (m *DesiredLRP) GetProcessGuid() string {
	if m != nil {
		return m.ProcessGuid
	}
	return ""
}

func (m *DesiredLRP) GetDomain() string {
	if m != nil {
		return m.Domain
	}
	return ""
}

func (m *DesiredLRP) GetRootFs() string {
	if m != nil {
		return m.RootFs
	}
	return ""
}

func (m *DesiredLRP) GetInstances() int32 {
	if m != nil {
		return m.Instances
	}
	return 0
}

func (m *DesiredLRP) GetEnvironmentVariables() []*EnvironmentVariable {
	if m != nil {
		return m.EnvironmentVariables
	}
	return nil
}

func (m *DesiredLRP) GetSetup() *Action {
	if m != nil {
		return m.Setup
	}
	return nil
}

func (m *DesiredLRP) GetAction() *Action {
	if m != nil {
		return m.Action
	}
	return nil
}

func (m *DesiredLRP) GetStartTimeoutMs() int64 {
	if m != nil {
		return m.StartTimeoutMs
	}
	return 0
}

// Deprecated: Do not use.
func (m *DesiredLRP) GetDeprecatedStartTimeoutS() uint32 {
	if m != nil {
		return m.DeprecatedStartTimeoutS
	}
	return 0
}

func (m *DesiredLRP) GetMonitor() *Action {
	if m != nil {
		return m.Monitor
	}
	return nil
}

func (m *DesiredLRP) GetDiskMb() int32 {
	if m != nil {
		return m.DiskMb
	}
	return 0
}

func (m *DesiredLRP) GetMemoryMb() int32 {
	if m != nil {
		return m.MemoryMb
	}
	return 0
}

func (m *DesiredLRP) GetCpuWeight() uint32 {
	if m != nil {
		return m.CpuWeight
	}
	return 0
}

func (m *DesiredLRP) GetPrivileged() bool {
	if m != nil {
		return m.Privileged
	}
	return false
}

func (m *DesiredLRP) GetPorts() []uint32 {
	if m != nil {
		return m.Ports
	}
	return nil
}

func (m *DesiredLRP) GetLogSource() string {
	if m != nil {
		return m.LogSource
	}
	return ""
}

func (m *DesiredLRP) GetLogGuid() string {
	if m != nil {
		return m.LogGuid
	}
	return ""
}

// Deprecated: Do not use.
func (m *DesiredLRP) GetMetricsGuid() string {
	if m != nil {
		return m.MetricsGuid
	}
	return ""
}

func (m *DesiredLRP) GetAnnotation() string {
	if m != nil {
		return m.Annotation
	}
	return ""
}

func (m *DesiredLRP) GetEgressRules() []*SecurityGroupRule {
	if m != nil {
		return m.EgressRules
	}
	return nil
}

func (m *DesiredLRP) GetModificationTag() *ModificationTag {
	if m != nil {
		return m.ModificationTag
	}
	return nil
}

func (m *DesiredLRP) GetCachedDependencies() []*CachedDependency {
	if m != nil {
		return m.CachedDependencies
	}
	return nil
}

// Deprecated: Do not use.
func (m *DesiredLRP) GetLegacyDownloadUser() string {
	if m != nil {
		return m.LegacyDownloadUser
	}
	return ""
}

func (m *DesiredLRP) GetTrustedSystemCertificatesPath() string {
	if m != nil {
		return m.TrustedSystemCertificatesPath
	}
	return ""
}

func (m *DesiredLRP) GetVolumeMounts() []*VolumeMount {
	if m != nil {
		return m.VolumeMounts
	}
	return nil
}

func (m *DesiredLRP) GetNetwork() *Network {
	if m != nil {
		return m.Network
	}
	return nil
}

func (m *DesiredLRP) GetPlacementTags() []string {
	if m != nil {
		return m.PlacementTags
	}
	return nil
}

func (m *DesiredLRP) GetMaxPids() int32 {
	if m != nil {
		return m.MaxPids
	}
	return 0
}

func (m *DesiredLRP) GetCertificateProperties() *CertificateProperties {
	if m != nil {
		return m.CertificateProperties
	}
	return nil
}

func (m *DesiredLRP) GetImageUsername() string {
	if m != nil {
		return m.ImageUsername
	}
	return ""
}

func (m *DesiredLRP) GetImagePassword() string {
	if m != nil {
		return m.ImagePassword
	}
	return ""
}

func (m *DesiredLRP) GetCheckDefinition() *CheckDefinition {
	if m != nil {
		return m.CheckDefinition
	}
	return nil
}

func (m *DesiredLRP) GetImageLayers() []*ImageLayer {
	if m != nil {
		return m.ImageLayers
	}
	return nil
}

func (m *DesiredLRP) GetMetricTags() map[string]*MetricTagValue {
	if m != nil {
		return m.MetricTags
	}
	return nil
}

func (m *DesiredLRP) GetSidecars() []*Sidecar {
	if m != nil {
		return m.Sidecars
	}
	return nil
}

func (m *DesiredLRP) GetLogRateLimit() *LogRateLimit {
	if m != nil {
		return m.LogRateLimit
	}
	return nil
}

func init() {
	proto.RegisterType((*DesiredLRPSchedulingInfo)(nil), "models.DesiredLRPSchedulingInfo")
	proto.RegisterType((*DesiredLRPRunInfo)(nil), "models.DesiredLRPRunInfo")
	proto.RegisterMapType((map[string]*MetricTagValue)(nil), "models.DesiredLRPRunInfo.MetricTagsEntry")
	proto.RegisterType((*ProtoRoutes)(nil), "models.ProtoRoutes")
	proto.RegisterMapType((map[string][]byte)(nil), "models.ProtoRoutes.RoutesEntry")
	proto.RegisterType((*DesiredLRPUpdate)(nil), "models.DesiredLRPUpdate")
	proto.RegisterMapType((map[string]*MetricTagValue)(nil), "models.DesiredLRPUpdate.MetricTagsEntry")
	proto.RegisterType((*DesiredLRPKey)(nil), "models.DesiredLRPKey")
	proto.RegisterType((*DesiredLRPResource)(nil), "models.DesiredLRPResource")
	proto.RegisterType((*DesiredLRP)(nil), "models.DesiredLRP")
	proto.RegisterMapType((map[string]*MetricTagValue)(nil), "models.DesiredLRP.MetricTagsEntry")
}

func init() { proto.RegisterFile("desired_lrp.proto", fileDescriptor_f592e9299b63d68c) }

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

func (this *DesiredLRPSchedulingInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DesiredLRPSchedulingInfo)
	if !ok {
		that2, ok := that.(DesiredLRPSchedulingInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.DesiredLRPKey.Equal(&that1.DesiredLRPKey) {
		return false
	}
	if this.Annotation != that1.Annotation {
		return false
	}
	if this.Instances != that1.Instances {
		return false
	}
	if !this.DesiredLRPResource.Equal(&that1.DesiredLRPResource) {
		return false
	}
	if !this.Routes.Equal(that1.Routes) {
		return false
	}
	if !this.ModificationTag.Equal(&that1.ModificationTag) {
		return false
	}
	if !this.VolumePlacement.Equal(that1.VolumePlacement) {
		return false
	}
	if len(this.PlacementTags) != len(that1.PlacementTags) {
		return false
	}
	for i := range this.PlacementTags {
		if this.PlacementTags[i] != that1.PlacementTags[i] {
			return false
		}
	}
	return true
}
func (this *DesiredLRPRunInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DesiredLRPRunInfo)
	if !ok {
		that2, ok := that.(DesiredLRPRunInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.DesiredLRPKey.Equal(&that1.DesiredLRPKey) {
		return false
	}
	if len(this.EnvironmentVariables) != len(that1.EnvironmentVariables) {
		return false
	}
	for i := range this.EnvironmentVariables {
		if !this.EnvironmentVariables[i].Equal(&that1.EnvironmentVariables[i]) {
			return false
		}
	}
	if !this.Setup.Equal(that1.Setup) {
		return false
	}
	if !this.Action.Equal(that1.Action) {
		return false
	}
	if !this.Monitor.Equal(that1.Monitor) {
		return false
	}
	if this.DeprecatedStartTimeoutS != that1.DeprecatedStartTimeoutS {
		return false
	}
	if this.Privileged != that1.Privileged {
		return false
	}
	if this.CpuWeight != that1.CpuWeight {
		return false
	}
	if len(this.Ports) != len(that1.Ports) {
		return false
	}
	for i := range this.Ports {
		if this.Ports[i] != that1.Ports[i] {
			return false
		}
	}
	if len(this.EgressRules) != len(that1.EgressRules) {
		return false
	}
	for i := range this.EgressRules {
		if !this.EgressRules[i].Equal(&that1.EgressRules[i]) {
			return false
		}
	}
	if this.LogSource != that1.LogSource {
		return false
	}
	if this.MetricsGuid != that1.MetricsGuid {
		return false
	}
	if this.CreatedAt != that1.CreatedAt {
		return false
	}
	if len(this.CachedDependencies) != len(that1.CachedDependencies) {
		return false
	}
	for i := range this.CachedDependencies {
		if !this.CachedDependencies[i].Equal(that1.CachedDependencies[i]) {
			return false
		}
	}
	if this.LegacyDownloadUser != that1.LegacyDownloadUser {
		return false
	}
	if this.TrustedSystemCertificatesPath != that1.TrustedSystemCertificatesPath {
		return false
	}
	if len(this.VolumeMounts) != len(that1.VolumeMounts) {
		return false
	}
	for i := range this.VolumeMounts {
		if !this.VolumeMounts[i].Equal(that1.VolumeMounts[i]) {
			return false
		}
	}
	if !this.Network.Equal(that1.Network) {
		return false
	}
	if this.StartTimeoutMs != that1.StartTimeoutMs {
		return false
	}
	if !this.CertificateProperties.Equal(that1.CertificateProperties) {
		return false
	}
	if this.ImageUsername != that1.ImageUsername {
		return false
	}
	if this.ImagePassword != that1.ImagePassword {
		return false
	}
	if !this.CheckDefinition.Equal(that1.CheckDefinition) {
		return false
	}
	if len(this.ImageLayers) != len(that1.ImageLayers) {
		return false
	}
	for i := range this.ImageLayers {
		if !this.ImageLayers[i].Equal(that1.ImageLayers[i]) {
			return false
		}
	}
	if len(this.MetricTags) != len(that1.MetricTags) {
		return false
	}
	for i := range this.MetricTags {
		if !this.MetricTags[i].Equal(that1.MetricTags[i]) {
			return false
		}
	}
	if len(this.Sidecars) != len(that1.Sidecars) {
		return false
	}
	for i := range this.Sidecars {
		if !this.Sidecars[i].Equal(that1.Sidecars[i]) {
			return false
		}
	}
	if !this.LogRateLimit.Equal(that1.LogRateLimit) {
		return false
	}
	return true
}
func (this *ProtoRoutes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*DesiredLRPUpdate)
	if !ok {
		that2, ok := that.(DesiredLRPUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.OptionalInstances == nil {
		if this.OptionalInstances != nil {
			return false
		}
	} else if this.OptionalInstances == nil {
		return false
	} else if !this.OptionalInstances.Equal(that1.OptionalInstances) {
		return false
	}
	if that1.Routes == nil {
		if this.Routes != nil {
			return false
		}
	} else if !this.Routes.Equal(*that1.Routes) {
		return false
	}
	if that1.OptionalAnnotation == nil {
		if this.OptionalAnnotation != nil {
			return false
		}
	} else if this.OptionalAnnotation == nil {
		return false
	} else if !this.OptionalAnnotation.Equal(that1.OptionalAnnotation) {
		return false
	}
	if len(this.MetricTags) != len(that1.MetricTags) {
		return false
	}
	for i := range this.MetricTags {
		if !this.MetricTags[i].Equal(that1.MetricTags[i]) {
			return false
		}
	}
	return true
}
func (this *DesiredLRPUpdate_Instances) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

	that1, ok := that.(*DesiredLRPKey)
	if !ok {
		that2, ok := that.(DesiredLRPKey)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ProcessGuid != that1.ProcessGuid {
		return false
	}
	if this.Domain != that1.Domain {
		return false
	}
	if this.LogGuid != that1.LogGuid {
		return false
	}
	return true
}
func (this *DesiredLRPResource) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DesiredLRPResource)
	if !ok {
		that2, ok := that.(DesiredLRPResource)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MemoryMb != that1.MemoryMb {
		return false
	}
	if this.DiskMb != that1.DiskMb {
		return false
	}
	if this.RootFs != that1.RootFs {
		return false
	}
	if this.MaxPids != that1.MaxPids {
		return false
	}
	return true
}
func (this *DesiredLRP) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DesiredLRP)
	if !ok {
		that2, ok := that.(DesiredLRP)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ProcessGuid != that1.ProcessGuid {
		return false
	}
	if this.Domain != that1.Domain {
		return false
	}
	if this.RootFs != that1.RootFs {
		return false
	}
	if this.Instances != that1.Instances {
		return false
	}
	if len(this.EnvironmentVariables) != len(that1.EnvironmentVariables) {
		return false
	}
	for i := range this.EnvironmentVariables {
		if !this.EnvironmentVariables[i].Equal(that1.EnvironmentVariables[i]) {
			return false
		}
	}
	if !this.Setup.Equal(that1.Setup) {
		return false
	}
	if !this.Action.Equal(that1.Action) {
		return false
	}
	if this.StartTimeoutMs != that1.StartTimeoutMs {
		return false
	}
	if this.DeprecatedStartTimeoutS != that1.DeprecatedStartTimeoutS {
		return false
	}
	if !this.Monitor.Equal(that1.Monitor) {
		return false
	}
	if this.DiskMb != that1.DiskMb {
		return false
	}
	if this.MemoryMb != that1.MemoryMb {
		return false
	}
	if this.CpuWeight != that1.CpuWeight {
		return false
	}
	if this.Privileged != that1.Privileged {
		return false
	}
	if len(this.Ports) != len(that1.Ports) {
		return false
	}
	for i := range this.Ports {
		if this.Ports[i] != that1.Ports[i] {
			return false
		}
	}
	if that1.Routes == nil {
		if this.Routes != nil {
			return false
		}
	} else if !this.Routes.Equal(*that1.Routes) {
		return false
	}
	if this.LogSource != that1.LogSource {
		return false
	}
	if this.LogGuid != that1.LogGuid {
		return false
	}
	if this.MetricsGuid != that1.MetricsGuid {
		return false
	}
	if this.Annotation != that1.Annotation {
		return false
	}
	if len(this.EgressRules) != len(that1.EgressRules) {
		return false
	}
	for i := range this.EgressRules {
		if !this.EgressRules[i].Equal(that1.EgressRules[i]) {
			return false
		}
	}
	if !this.ModificationTag.Equal(that1.ModificationTag) {
		return false
	}
	if len(this.CachedDependencies) != len(that1.CachedDependencies) {
		return false
	}
	for i := range this.CachedDependencies {
		if !this.CachedDependencies[i].Equal(that1.CachedDependencies[i]) {
			return false
		}
	}
	if this.LegacyDownloadUser != that1.LegacyDownloadUser {
		return false
	}
	if this.TrustedSystemCertificatesPath != that1.TrustedSystemCertificatesPath {
		return false
	}
	if len(this.VolumeMounts) != len(that1.VolumeMounts) {
		return false
	}
	for i := range this.VolumeMounts {
		if !this.VolumeMounts[i].Equal(that1.VolumeMounts[i]) {
			return false
		}
	}
	if !this.Network.Equal(that1.Network) {
		return false
	}
	if len(this.PlacementTags) != len(that1.PlacementTags) {
		return false
	}
	for i := range this.PlacementTags {
		if this.PlacementTags[i] != that1.PlacementTags[i] {
			return false
		}
	}
	if this.MaxPids != that1.MaxPids {
		return false
	}
	if !this.CertificateProperties.Equal(that1.CertificateProperties) {
		return false
	}
	if this.ImageUsername != that1.ImageUsername {
		return false
	}
	if this.ImagePassword != that1.ImagePassword {
		return false
	}
	if !this.CheckDefinition.Equal(that1.CheckDefinition) {
		return false
	}
	if len(this.ImageLayers) != len(that1.ImageLayers) {
		return false
	}
	for i := range this.ImageLayers {
		if !this.ImageLayers[i].Equal(that1.ImageLayers[i]) {
			return false
		}
	}
	if len(this.MetricTags) != len(that1.MetricTags) {
		return false
	}
	for i := range this.MetricTags {
		if !this.MetricTags[i].Equal(that1.MetricTags[i]) {
			return false
		}
	}
	if len(this.Sidecars) != len(that1.Sidecars) {
		return false
	}
	for i := range this.Sidecars {
		if !this.Sidecars[i].Equal(that1.Sidecars[i]) {
			return false
		}
	}
	if !this.LogRateLimit.Equal(that1.LogRateLimit) {
		return false
	}
	return true
}
func (this *DesiredLRPSchedulingInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&models.DesiredLRPSchedulingInfo{")
	s = append(s, "DesiredLRPKey: "+strings.Replace(this.DesiredLRPKey.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "Annotation: "+fmt.Sprintf("%#v", this.Annotation)+",\n")
	s = append(s, "Instances: "+fmt.Sprintf("%#v", this.Instances)+",\n")
	s = append(s, "DesiredLRPResource: "+strings.Replace(this.DesiredLRPResource.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "Routes: "+fmt.Sprintf("%#v", this.Routes)+",\n")
	s = append(s, "ModificationTag: "+strings.Replace(this.ModificationTag.GoString(), `&`, ``, 1)+",\n")
	if this.VolumePlacement != nil {
		s = append(s, "VolumePlacement: "+fmt.Sprintf("%#v", this.VolumePlacement)+",\n")
	}
	s = append(s, "PlacementTags: "+fmt.Sprintf("%#v", this.PlacementTags)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DesiredLRPRunInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 31)
	s = append(s, "&models.DesiredLRPRunInfo{")
	s = append(s, "DesiredLRPKey: "+strings.Replace(this.DesiredLRPKey.GoString(), `&`, ``, 1)+",\n")
	if this.EnvironmentVariables != nil {
		vs := make([]EnvironmentVariable, len(this.EnvironmentVariables))
		for i := range vs {
			vs[i] = this.EnvironmentVariables[i]
		}
		s = append(s, "EnvironmentVariables: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	if this.Setup != nil {
		s = append(s, "Setup: "+fmt.Sprintf("%#v", this.Setup)+",\n")
	}
	if this.Action != nil {
		s = append(s, "Action: "+fmt.Sprintf("%#v", this.Action)+",\n")
	}
	if this.Monitor != nil {
		s = append(s, "Monitor: "+fmt.Sprintf("%#v", this.Monitor)+",\n")
	}
	s = append(s, "DeprecatedStartTimeoutS: "+fmt.Sprintf("%#v", this.DeprecatedStartTimeoutS)+",\n")
	s = append(s, "Privileged: "+fmt.Sprintf("%#v", this.Privileged)+",\n")
	s = append(s, "CpuWeight: "+fmt.Sprintf("%#v", this.CpuWeight)+",\n")
	s = append(s, "Ports: "+fmt.Sprintf("%#v", this.Ports)+",\n")
	if this.EgressRules != nil {
		vs := make([]SecurityGroupRule, len(this.EgressRules))
		for i := range vs {
			vs[i] = this.EgressRules[i]
		}
		s = append(s, "EgressRules: "+fmt.Sprintf("%#v", vs)+",\n")
	}
	s = append(s, "LogSource: "+fmt.Sprintf("%#v", this.LogSource)+",\n")
	s = append(s, "MetricsGuid: "+fmt.Sprintf("%#v", this.MetricsGuid)+",\n")
	s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	if this.CachedDependencies != nil {
		s = append(s, "CachedDependencies: "+fmt.Sprintf("%#v", this.CachedDependencies)+",\n")
	}
	s = append(s, "LegacyDownloadUser: "+fmt.Sprintf("%#v", this.LegacyDownloadUser)+",\n")
	s = append(s, "TrustedSystemCertificatesPath: "+fmt.Sprintf("%#v", this.TrustedSystemCertificatesPath)+",\n")
	if this.VolumeMounts != nil {
		s = append(s, "VolumeMounts: "+fmt.Sprintf("%#v", this.VolumeMounts)+",\n")
	}
	if this.Network != nil {
		s = append(s, "Network: "+fmt.Sprintf("%#v", this.Network)+",\n")
	}
	s = append(s, "StartTimeoutMs: "+fmt.Sprintf("%#v", this.StartTimeoutMs)+",\n")
	if this.CertificateProperties != nil {
		s = append(s, "CertificateProperties: "+fmt.Sprintf("%#v", this.CertificateProperties)+",\n")
	}
	s = append(s, "ImageUsername: "+fmt.Sprintf("%#v", this.ImageUsername)+",\n")
	s = append(s, "ImagePassword: "+fmt.Sprintf("%#v", this.ImagePassword)+",\n")
	if this.CheckDefinition != nil {
		s = append(s, "CheckDefinition: "+fmt.Sprintf("%#v", this.CheckDefinition)+",\n")
	}
	if this.ImageLayers != nil {
		s = append(s, "ImageLayers: "+fmt.Sprintf("%#v", this.ImageLayers)+",\n")
	}
	keysForMetricTags := make([]string, 0, len(this.MetricTags))
	for k, _ := range this.MetricTags {
		keysForMetricTags = append(keysForMetricTags, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetricTags)
	mapStringForMetricTags := "map[string]*MetricTagValue{"
	for _, k := range keysForMetricTags {
		mapStringForMetricTags += fmt.Sprintf("%#v: %#v,", k, this.MetricTags[k])
	}
	mapStringForMetricTags += "}"
	if this.MetricTags != nil {
		s = append(s, "MetricTags: "+mapStringForMetricTags+",\n")
	}
	if this.Sidecars != nil {
		s = append(s, "Sidecars: "+fmt.Sprintf("%#v", this.Sidecars)+",\n")
	}
	if this.LogRateLimit != nil {
		s = append(s, "LogRateLimit: "+fmt.Sprintf("%#v", this.LogRateLimit)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ProtoRoutes) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&models.ProtoRoutes{")
	keysForRoutes := make([]string, 0, len(this.Routes))
	for k, _ := range this.Routes {
		keysForRoutes = append(keysForRoutes, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForRoutes)
	mapStringForRoutes := "map[string][]byte{"
	for _, k := range keysForRoutes {
		mapStringForRoutes += fmt.Sprintf("%#v: %#v,", k, this.Routes[k])
	}
	mapStringForRoutes += "}"
	if this.Routes != nil {
		s = append(s, "Routes: "+mapStringForRoutes+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DesiredLRPUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&models.DesiredLRPUpdate{")
	if this.OptionalInstances != nil {
		s = append(s, "OptionalInstances: "+fmt.Sprintf("%#v", this.OptionalInstances)+",\n")
	}
	s = append(s, "Routes: "+fmt.Sprintf("%#v", this.Routes)+",\n")
	if this.OptionalAnnotation != nil {
		s = append(s, "OptionalAnnotation: "+fmt.Sprintf("%#v", this.OptionalAnnotation)+",\n")
	}
	keysForMetricTags := make([]string, 0, len(this.MetricTags))
	for k, _ := range this.MetricTags {
		keysForMetricTags = append(keysForMetricTags, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetricTags)
	mapStringForMetricTags := "map[string]*MetricTagValue{"
	for _, k := range keysForMetricTags {
		mapStringForMetricTags += fmt.Sprintf("%#v: %#v,", k, this.MetricTags[k])
	}
	mapStringForMetricTags += "}"
	if this.MetricTags != nil {
		s = append(s, "MetricTags: "+mapStringForMetricTags+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DesiredLRPUpdate_Instances) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&models.DesiredLRPUpdate_Instances{` +
		`Instances:` + fmt.Sprintf("%#v", this.Instances) + `}`}, ", ")
	return s
}
func (this *DesiredLRPUpdate_Annotation) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&models.DesiredLRPUpdate_Annotation{` +
		`Annotation:` + fmt.Sprintf("%#v", this.Annotation) + `}`}, ", ")
	return s
}
func (this *DesiredLRPKey) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&models.DesiredLRPKey{")
	s = append(s, "ProcessGuid: "+fmt.Sprintf("%#v", this.ProcessGuid)+",\n")
	s = append(s, "Domain: "+fmt.Sprintf("%#v", this.Domain)+",\n")
	s = append(s, "LogGuid: "+fmt.Sprintf("%#v", this.LogGuid)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DesiredLRPResource) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&models.DesiredLRPResource{")
	s = append(s, "MemoryMb: "+fmt.Sprintf("%#v", this.MemoryMb)+",\n")
	s = append(s, "DiskMb: "+fmt.Sprintf("%#v", this.DiskMb)+",\n")
	s = append(s, "RootFs: "+fmt.Sprintf("%#v", this.RootFs)+",\n")
	s = append(s, "MaxPids: "+fmt.Sprintf("%#v", this.MaxPids)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DesiredLRP) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 41)
	s = append(s, "&models.DesiredLRP{")
	s = append(s, "ProcessGuid: "+fmt.Sprintf("%#v", this.ProcessGuid)+",\n")
	s = append(s, "Domain: "+fmt.Sprintf("%#v", this.Domain)+",\n")
	s = append(s, "RootFs: "+fmt.Sprintf("%#v", this.RootFs)+",\n")
	s = append(s, "Instances: "+fmt.Sprintf("%#v", this.Instances)+",\n")
	if this.EnvironmentVariables != nil {
		s = append(s, "EnvironmentVariables: "+fmt.Sprintf("%#v", this.EnvironmentVariables)+",\n")
	}
	if this.Setup != nil {
		s = append(s, "Setup: "+fmt.Sprintf("%#v", this.Setup)+",\n")
	}
	if this.Action != nil {
		s = append(s, "Action: "+fmt.Sprintf("%#v", this.Action)+",\n")
	}
	s = append(s, "StartTimeoutMs: "+fmt.Sprintf("%#v", this.StartTimeoutMs)+",\n")
	s = append(s, "DeprecatedStartTimeoutS: "+fmt.Sprintf("%#v", this.DeprecatedStartTimeoutS)+",\n")
	if this.Monitor != nil {
		s = append(s, "Monitor: "+fmt.Sprintf("%#v", this.Monitor)+",\n")
	}
	s = append(s, "DiskMb: "+fmt.Sprintf("%#v", this.DiskMb)+",\n")
	s = append(s, "MemoryMb: "+fmt.Sprintf("%#v", this.MemoryMb)+",\n")
	s = append(s, "CpuWeight: "+fmt.Sprintf("%#v", this.CpuWeight)+",\n")
	s = append(s, "Privileged: "+fmt.Sprintf("%#v", this.Privileged)+",\n")
	s = append(s, "Ports: "+fmt.Sprintf("%#v", this.Ports)+",\n")
	s = append(s, "Routes: "+fmt.Sprintf("%#v", this.Routes)+",\n")
	s = append(s, "LogSource: "+fmt.Sprintf("%#v", this.LogSource)+",\n")
	s = append(s, "LogGuid: "+fmt.Sprintf("%#v", this.LogGuid)+",\n")
	s = append(s, "MetricsGuid: "+fmt.Sprintf("%#v", this.MetricsGuid)+",\n")
	s = append(s, "Annotation: "+fmt.Sprintf("%#v", this.Annotation)+",\n")
	if this.EgressRules != nil {
		s = append(s, "EgressRules: "+fmt.Sprintf("%#v", this.EgressRules)+",\n")
	}
	if this.ModificationTag != nil {
		s = append(s, "ModificationTag: "+fmt.Sprintf("%#v", this.ModificationTag)+",\n")
	}
	if this.CachedDependencies != nil {
		s = append(s, "CachedDependencies: "+fmt.Sprintf("%#v", this.CachedDependencies)+",\n")
	}
	s = append(s, "LegacyDownloadUser: "+fmt.Sprintf("%#v", this.LegacyDownloadUser)+",\n")
	s = append(s, "TrustedSystemCertificatesPath: "+fmt.Sprintf("%#v", this.TrustedSystemCertificatesPath)+",\n")
	if this.VolumeMounts != nil {
		s = append(s, "VolumeMounts: "+fmt.Sprintf("%#v", this.VolumeMounts)+",\n")
	}
	if this.Network != nil {
		s = append(s, "Network: "+fmt.Sprintf("%#v", this.Network)+",\n")
	}
	s = append(s, "PlacementTags: "+fmt.Sprintf("%#v", this.PlacementTags)+",\n")
	s = append(s, "MaxPids: "+fmt.Sprintf("%#v", this.MaxPids)+",\n")
	if this.CertificateProperties != nil {
		s = append(s, "CertificateProperties: "+fmt.Sprintf("%#v", this.CertificateProperties)+",\n")
	}
	s = append(s, "ImageUsername: "+fmt.Sprintf("%#v", this.ImageUsername)+",\n")
	s = append(s, "ImagePassword: "+fmt.Sprintf("%#v", this.ImagePassword)+",\n")
	if this.CheckDefinition != nil {
		s = append(s, "CheckDefinition: "+fmt.Sprintf("%#v", this.CheckDefinition)+",\n")
	}
	if this.ImageLayers != nil {
		s = append(s, "ImageLayers: "+fmt.Sprintf("%#v", this.ImageLayers)+",\n")
	}
	keysForMetricTags := make([]string, 0, len(this.MetricTags))
	for k, _ := range this.MetricTags {
		keysForMetricTags = append(keysForMetricTags, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetricTags)
	mapStringForMetricTags := "map[string]*MetricTagValue{"
	for _, k := range keysForMetricTags {
		mapStringForMetricTags += fmt.Sprintf("%#v: %#v,", k, this.MetricTags[k])
	}
	mapStringForMetricTags += "}"
	if this.MetricTags != nil {
		s = append(s, "MetricTags: "+mapStringForMetricTags+",\n")
	}
	if this.Sidecars != nil {
		s = append(s, "Sidecars: "+fmt.Sprintf("%#v", this.Sidecars)+",\n")
	}
	if this.LogRateLimit != nil {
		s = append(s, "LogRateLimit: "+fmt.Sprintf("%#v", this.LogRateLimit)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringDesiredLrp(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *DesiredLRPSchedulingInfo) 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 *DesiredLRPSchedulingInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DesiredLRPSchedulingInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PlacementTags) > 0 {
		for iNdEx := len(m.PlacementTags) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PlacementTags[iNdEx])
			copy(dAtA[i:], m.PlacementTags[iNdEx])
			i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.PlacementTags[iNdEx])))
			i--
			dAtA[i] = 0x42
		}
	}
	if m.VolumePlacement != nil {
		{
			size, err := m.VolumePlacement.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	{
		size, err := m.ModificationTag.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.Routes.Size()
		i -= size
		if _, err := m.Routes.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.DesiredLRPResource.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Instances != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.Instances))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Annotation) > 0 {
		i -= len(m.Annotation)
		copy(dAtA[i:], m.Annotation)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.Annotation)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.DesiredLRPKey.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *DesiredLRPRunInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LogRateLimit != nil {
		{
			size, err := m.LogRateLimit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xda
	}
	if len(m.Sidecars) > 0 {
		for iNdEx := len(m.Sidecars) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Sidecars[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xd2
		}
	}
	if len(m.MetricTags) > 0 {
		for k := range m.MetricTags {
			v := m.MetricTags[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDesiredLrp(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDesiredLrp(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	if len(m.ImageLayers) > 0 {
		for iNdEx := len(m.ImageLayers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ImageLayers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	if m.CheckDefinition != nil {
		{
			size, err := m.CheckDefinition.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xba
	}
	if len(m.ImagePassword) > 0 {
		i -= len(m.ImagePassword)
		copy(dAtA[i:], m.ImagePassword)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.ImagePassword)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb2
	}
	if len(m.ImageUsername) > 0 {
		i -= len(m.ImageUsername)
		copy(dAtA[i:], m.ImageUsername)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.ImageUsername)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if m.CertificateProperties != nil {
		{
			size, err := m.CertificateProperties.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if m.StartTimeoutMs != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.StartTimeoutMs))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if m.Network != nil {
		{
			size, err := m.Network.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if len(m.VolumeMounts) > 0 {
		for iNdEx := len(m.VolumeMounts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.VolumeMounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.TrustedSystemCertificatesPath) > 0 {
		i -= len(m.TrustedSystemCertificatesPath)
		copy(dAtA[i:], m.TrustedSystemCertificatesPath)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.TrustedSystemCertificatesPath)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if len(m.LegacyDownloadUser) > 0 {
		i -= len(m.LegacyDownloadUser)
		copy(dAtA[i:], m.LegacyDownloadUser)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.LegacyDownloadUser)))
		i--
		dAtA[i] = 0x7a
	}
	if len(m.CachedDependencies) > 0 {
		for iNdEx := len(m.CachedDependencies) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CachedDependencies[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x72
		}
	}
	if m.CreatedAt != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x68
	}
	if len(m.MetricsGuid) > 0 {
		i -= len(m.MetricsGuid)
		copy(dAtA[i:], m.MetricsGuid)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.MetricsGuid)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.LogSource) > 0 {
		i -= len(m.LogSource)
		copy(dAtA[i:], m.LogSource)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.LogSource)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.EgressRules) > 0 {
		for iNdEx := len(m.EgressRules) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EgressRules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.Ports) > 0 {
		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintDesiredLrp(dAtA, i, uint64(m.Ports[iNdEx]))
			i--
			dAtA[i] = 0x48
		}
	}
	if m.CpuWeight != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.CpuWeight))
		i--
		dAtA[i] = 0x40
	}
	if m.Privileged {
		i--
		if m.Privileged {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.DeprecatedStartTimeoutS != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.DeprecatedStartTimeoutS))
		i--
		dAtA[i] = 0x30
	}
	if m.Monitor != nil {
		{
			size, err := m.Monitor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Action != nil {
		{
			size, err := m.Action.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Setup != nil {
		{
			size, err := m.Setup.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.EnvironmentVariables) > 0 {
		for iNdEx := len(m.EnvironmentVariables) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EnvironmentVariables[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.DesiredLRPKey.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *DesiredLRPUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MetricTags) > 0 {
		for k := range m.MetricTags {
			v := m.MetricTags[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDesiredLrp(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDesiredLrp(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.OptionalAnnotation != nil {
		{
			size := m.OptionalAnnotation.Size()
			i -= size
			if _, err := m.OptionalAnnotation.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Routes != nil {
		{
			size := m.Routes.Size()
			i -= size
			if _, err := m.Routes.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.OptionalInstances != nil {
		{
			size := m.OptionalInstances.Size()
			i -= size
			if _, err := m.OptionalInstances.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *DesiredLRPUpdate_Instances) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintDesiredLrp(dAtA, i, uint64(m.Instances))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}
func (m *DesiredLRPUpdate_Annotation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DesiredLRPUpdate_Annotation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.Annotation)
	copy(dAtA[i:], m.Annotation)
	i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.Annotation)))
	i--
	dAtA[i] = 0x1a
	return len(dAtA) - i, nil
}
func (m *DesiredLRPKey) 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 *DesiredLRPKey) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DesiredLRPKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LogGuid) > 0 {
		i -= len(m.LogGuid)
		copy(dAtA[i:], m.LogGuid)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.LogGuid)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Domain) > 0 {
		i -= len(m.Domain)
		copy(dAtA[i:], m.Domain)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.Domain)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ProcessGuid) > 0 {
		i -= len(m.ProcessGuid)
		copy(dAtA[i:], m.ProcessGuid)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.ProcessGuid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DesiredLRPResource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MaxPids != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.MaxPids))
		i--
		dAtA[i] = 0x20
	}
	if len(m.RootFs) > 0 {
		i -= len(m.RootFs)
		copy(dAtA[i:], m.RootFs)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.RootFs)))
		i--
		dAtA[i] = 0x1a
	}
	if m.DiskMb != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.DiskMb))
		i--
		dAtA[i] = 0x10
	}
	if m.MemoryMb != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.MemoryMb))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *DesiredLRP) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LogRateLimit != nil {
		{
			size, err := m.LogRateLimit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xaa
	}
	if len(m.Sidecars) > 0 {
		for iNdEx := len(m.Sidecars) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Sidecars[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.MetricTags) > 0 {
		for k := range m.MetricTags {
			v := m.MetricTags[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDesiredLrp(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDesiredLrp(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.ImageLayers) > 0 {
		for iNdEx := len(m.ImageLayers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ImageLayers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x92
		}
	}
	if m.CheckDefinition != nil {
		{
			size, err := m.CheckDefinition.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x8a
	}
	if len(m.ImagePassword) > 0 {
		i -= len(m.ImagePassword)
		copy(dAtA[i:], m.ImagePassword)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.ImagePassword)))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x82
	}
	if len(m.ImageUsername) > 0 {
		i -= len(m.ImageUsername)
		copy(dAtA[i:], m.ImageUsername)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.ImageUsername)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xfa
	}
	if m.CertificateProperties != nil {
		{
			size, err := m.CertificateProperties.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf2
	}
	if m.MaxPids != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.MaxPids))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe8
	}
	if len(m.PlacementTags) > 0 {
		for iNdEx := len(m.PlacementTags) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PlacementTags[iNdEx])
			copy(dAtA[i:], m.PlacementTags[iNdEx])
			i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.PlacementTags[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xe2
		}
	}
	if m.StartTimeoutMs != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.StartTimeoutMs))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd8
	}
	if m.Network != nil {
		{
			size, err := m.Network.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd2
	}
	if len(m.VolumeMounts) > 0 {
		for iNdEx := len(m.VolumeMounts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.VolumeMounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	if len(m.TrustedSystemCertificatesPath) > 0 {
		i -= len(m.TrustedSystemCertificatesPath)
		copy(dAtA[i:], m.TrustedSystemCertificatesPath)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.TrustedSystemCertificatesPath)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc2
	}
	if len(m.LegacyDownloadUser) > 0 {
		i -= len(m.LegacyDownloadUser)
		copy(dAtA[i:], m.LegacyDownloadUser)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.LegacyDownloadUser)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xba
	}
	if len(m.CachedDependencies) > 0 {
		for iNdEx := len(m.CachedDependencies) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CachedDependencies[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xb2
		}
	}
	if m.ModificationTag != nil {
		{
			size, err := m.ModificationTag.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if len(m.EgressRules) > 0 {
		for iNdEx := len(m.EgressRules) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EgressRules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.Annotation) > 0 {
		i -= len(m.Annotation)
		copy(dAtA[i:], m.Annotation)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.Annotation)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if len(m.MetricsGuid) > 0 {
		i -= len(m.MetricsGuid)
		copy(dAtA[i:], m.MetricsGuid)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.MetricsGuid)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if len(m.LogGuid) > 0 {
		i -= len(m.LogGuid)
		copy(dAtA[i:], m.LogGuid)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.LogGuid)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if len(m.LogSource) > 0 {
		i -= len(m.LogSource)
		copy(dAtA[i:], m.LogSource)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.LogSource)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if m.Routes != nil {
		{
			size := m.Routes.Size()
			i -= size
			if _, err := m.Routes.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	if len(m.Ports) > 0 {
		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintDesiredLrp(dAtA, i, uint64(m.Ports[iNdEx]))
			i--
			dAtA[i] = 0x70
		}
	}
	if m.Privileged {
		i--
		if m.Privileged {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if m.CpuWeight != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.CpuWeight))
		i--
		dAtA[i] = 0x60
	}
	if m.MemoryMb != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.MemoryMb))
		i--
		dAtA[i] = 0x58
	}
	if m.DiskMb != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.DiskMb))
		i--
		dAtA[i] = 0x50
	}
	if m.Monitor != nil {
		{
			size, err := m.Monitor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.DeprecatedStartTimeoutS != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.DeprecatedStartTimeoutS))
		i--
		dAtA[i] = 0x40
	}
	if m.Action != nil {
		{
			size, err := m.Action.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Setup != nil {
		{
			size, err := m.Setup.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.EnvironmentVariables) > 0 {
		for iNdEx := len(m.EnvironmentVariables) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EnvironmentVariables[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDesiredLrp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Instances != 0 {
		i = encodeVarintDesiredLrp(dAtA, i, uint64(m.Instances))
		i--
		dAtA[i] = 0x20
	}
	if len(m.RootFs) > 0 {
		i -= len(m.RootFs)
		copy(dAtA[i:], m.RootFs)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.RootFs)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Domain) > 0 {
		i -= len(m.Domain)
		copy(dAtA[i:], m.Domain)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.Domain)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ProcessGuid) > 0 {
		i -= len(m.ProcessGuid)
		copy(dAtA[i:], m.ProcessGuid)
		i = encodeVarintDesiredLrp(dAtA, i, uint64(len(m.ProcessGuid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintDesiredLrp(dAtA []byte, offset int, v uint64) int {
	offset -= sovDesiredLrp(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *DesiredLRPSchedulingInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.DesiredLRPKey.Size()
	n += 1 + l + sovDesiredLrp(uint64(l))
	l = len(m.Annotation)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.Instances != 0 {
		n += 1 + sovDesiredLrp(uint64(m.Instances))
	}
	l = m.DesiredLRPResource.Size()
	n += 1 + l + sovDesiredLrp(uint64(l))
	l = m.Routes.Size()
	n += 1 + l + sovDesiredLrp(uint64(l))
	l = m.ModificationTag.Size()
	n += 1 + l + sovDesiredLrp(uint64(l))
	if m.VolumePlacement != nil {
		l = m.VolumePlacement.Size()
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if len(m.PlacementTags) > 0 {
		for _, s := range m.PlacementTags {
			l = len(s)
			n += 1 + l + sovDesiredLrp(uint64(l))
		}
	}
	return n
}

func (m *DesiredLRPRunInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.DesiredLRPKey.Size()
	n += 1 + l + sovDesiredLrp(uint64(l))
	if len(m.EnvironmentVariables) > 0 {
		for _, e := range m.EnvironmentVariables {
			l = e.Size()
			n += 1 + l + sovDesiredLrp(uint64(l))
		}
	}
	if m.Setup != nil {
		l = m.Setup.Size()
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.Action != nil {
		l = m.Action.Size()
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.Monitor != nil {
		l = m.Monitor.Size()
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.DeprecatedStartTimeoutS != 0 {
		n += 1 + sovDesiredLrp(uint64(m.DeprecatedStartTimeoutS))
	}
	if m.Privileged {
		n += 2
	}
	if m.CpuWeight != 0 {
		n += 1 + sovDesiredLrp(uint64(m.CpuWeight))
	}
	if len(m.Ports) > 0 {
		for _, e := range m.Ports {
			n += 1 + sovDesiredLrp(uint64(e))
		}
	}
	if len(m.EgressRules) > 0 {
		for _, e := range m.EgressRules {
			l = e.Size()
			n += 1 + l + sovDesiredLrp(uint64(l))
		}
	}
	l = len(m.LogSource)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.MetricsGuid)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovDesiredLrp(uint64(m.CreatedAt))
	}
	if len(m.CachedDependencies) > 0 {
		for _, e := range m.CachedDependencies {
			l = e.Size()
			n += 1 + l + sovDesiredLrp(uint64(l))
		}
	}
	l = len(m.LegacyDownloadUser)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.TrustedSystemCertificatesPath)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	if len(m.VolumeMounts) > 0 {
		for _, e := range m.VolumeMounts {
			l = e.Size()
			n += 2 + l + sovDesiredLrp(uint64(l))
		}
	}
	if m.Network != nil {
		l = m.Network.Size()
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	if m.StartTimeoutMs != 0 {
		n += 2 + sovDesiredLrp(uint64(m.StartTimeoutMs))
	}
	if m.CertificateProperties != nil {
		l = m.CertificateProperties.Size()
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.ImageUsername)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.ImagePassword)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	if m.CheckDefinition != nil {
		l = m.CheckDefinition.Size()
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	if len(m.ImageLayers) > 0 {
		for _, e := range m.ImageLayers {
			l = e.Size()
			n += 2 + l + sovDesiredLrp(uint64(l))
		}
	}
	if len(m.MetricTags) > 0 {
		for k, v := range m.MetricTags {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovDesiredLrp(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovDesiredLrp(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovDesiredLrp(uint64(mapEntrySize))
		}
	}
	if len(m.Sidecars) > 0 {
		for _, e := range m.Sidecars {
			l = e.Size()
			n += 2 + l + sovDesiredLrp(uint64(l))
		}
	}
	if m.LogRateLimit != nil {
		l = m.LogRateLimit.Size()
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	return n
}

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

func (m *DesiredLRPUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OptionalInstances != nil {
		n += m.OptionalInstances.Size()
	}
	if m.Routes != nil {
		l = m.Routes.Size()
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.OptionalAnnotation != nil {
		n += m.OptionalAnnotation.Size()
	}
	if len(m.MetricTags) > 0 {
		for k, v := range m.MetricTags {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovDesiredLrp(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovDesiredLrp(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovDesiredLrp(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *DesiredLRPUpdate_Instances) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovDesiredLrp(uint64(m.Instances))
	return n
}
func (m *DesiredLRPUpdate_Annotation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Annotation)
	n += 1 + l + sovDesiredLrp(uint64(l))
	return n
}
func (m *DesiredLRPKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProcessGuid)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.Domain)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.LogGuid)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	return n
}

func (m *DesiredLRPResource) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MemoryMb != 0 {
		n += 1 + sovDesiredLrp(uint64(m.MemoryMb))
	}
	if m.DiskMb != 0 {
		n += 1 + sovDesiredLrp(uint64(m.DiskMb))
	}
	l = len(m.RootFs)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.MaxPids != 0 {
		n += 1 + sovDesiredLrp(uint64(m.MaxPids))
	}
	return n
}

func (m *DesiredLRP) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProcessGuid)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.Domain)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.RootFs)
	if l > 0 {
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.Instances != 0 {
		n += 1 + sovDesiredLrp(uint64(m.Instances))
	}
	if len(m.EnvironmentVariables) > 0 {
		for _, e := range m.EnvironmentVariables {
			l = e.Size()
			n += 1 + l + sovDesiredLrp(uint64(l))
		}
	}
	if m.Setup != nil {
		l = m.Setup.Size()
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.Action != nil {
		l = m.Action.Size()
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.DeprecatedStartTimeoutS != 0 {
		n += 1 + sovDesiredLrp(uint64(m.DeprecatedStartTimeoutS))
	}
	if m.Monitor != nil {
		l = m.Monitor.Size()
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	if m.DiskMb != 0 {
		n += 1 + sovDesiredLrp(uint64(m.DiskMb))
	}
	if m.MemoryMb != 0 {
		n += 1 + sovDesiredLrp(uint64(m.MemoryMb))
	}
	if m.CpuWeight != 0 {
		n += 1 + sovDesiredLrp(uint64(m.CpuWeight))
	}
	if m.Privileged {
		n += 2
	}
	if len(m.Ports) > 0 {
		for _, e := range m.Ports {
			n += 1 + sovDesiredLrp(uint64(e))
		}
	}
	if m.Routes != nil {
		l = m.Routes.Size()
		n += 1 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.LogSource)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.LogGuid)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.MetricsGuid)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.Annotation)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	if len(m.EgressRules) > 0 {
		for _, e := range m.EgressRules {
			l = e.Size()
			n += 2 + l + sovDesiredLrp(uint64(l))
		}
	}
	if m.ModificationTag != nil {
		l = m.ModificationTag.Size()
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	if len(m.CachedDependencies) > 0 {
		for _, e := range m.CachedDependencies {
			l = e.Size()
			n += 2 + l + sovDesiredLrp(uint64(l))
		}
	}
	l = len(m.LegacyDownloadUser)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.TrustedSystemCertificatesPath)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	if len(m.VolumeMounts) > 0 {
		for _, e := range m.VolumeMounts {
			l = e.Size()
			n += 2 + l + sovDesiredLrp(uint64(l))
		}
	}
	if m.Network != nil {
		l = m.Network.Size()
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	if m.StartTimeoutMs != 0 {
		n += 2 + sovDesiredLrp(uint64(m.StartTimeoutMs))
	}
	if len(m.PlacementTags) > 0 {
		for _, s := range m.PlacementTags {
			l = len(s)
			n += 2 + l + sovDesiredLrp(uint64(l))
		}
	}
	if m.MaxPids != 0 {
		n += 2 + sovDesiredLrp(uint64(m.MaxPids))
	}
	if m.CertificateProperties != nil {
		l = m.CertificateProperties.Size()
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.ImageUsername)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	l = len(m.ImagePassword)
	if l > 0 {
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	if m.CheckDefinition != nil {
		l = m.CheckDefinition.Size()
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	if len(m.ImageLayers) > 0 {
		for _, e := range m.ImageLayers {
			l = e.Size()
			n += 2 + l + sovDesiredLrp(uint64(l))
		}
	}
	if len(m.MetricTags) > 0 {
		for k, v := range m.MetricTags {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovDesiredLrp(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovDesiredLrp(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovDesiredLrp(uint64(mapEntrySize))
		}
	}
	if len(m.Sidecars) > 0 {
		for _, e := range m.Sidecars {
			l = e.Size()
			n += 2 + l + sovDesiredLrp(uint64(l))
		}
	}
	if m.LogRateLimit != nil {
		l = m.LogRateLimit.Size()
		n += 2 + l + sovDesiredLrp(uint64(l))
	}
	return n
}

func sovDesiredLrp(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozDesiredLrp(x uint64) (n int) {
	return sovDesiredLrp(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *DesiredLRPSchedulingInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DesiredLRPSchedulingInfo{`,
		`DesiredLRPKey:` + strings.Replace(strings.Replace(this.DesiredLRPKey.String(), "DesiredLRPKey", "DesiredLRPKey", 1), `&`, ``, 1) + `,`,
		`Annotation:` + fmt.Sprintf("%v", this.Annotation) + `,`,
		`Instances:` + fmt.Sprintf("%v", this.Instances) + `,`,
		`DesiredLRPResource:` + strings.Replace(strings.Replace(this.DesiredLRPResource.String(), "DesiredLRPResource", "DesiredLRPResource", 1), `&`, ``, 1) + `,`,
		`Routes:` + fmt.Sprintf("%v", this.Routes) + `,`,
		`ModificationTag:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ModificationTag), "ModificationTag", "ModificationTag", 1), `&`, ``, 1) + `,`,
		`VolumePlacement:` + strings.Replace(fmt.Sprintf("%v", this.VolumePlacement), "VolumePlacement", "VolumePlacement", 1) + `,`,
		`PlacementTags:` + fmt.Sprintf("%v", this.PlacementTags) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DesiredLRPRunInfo) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForEnvironmentVariables := "[]EnvironmentVariable{"
	for _, f := range this.EnvironmentVariables {
		repeatedStringForEnvironmentVariables += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForEnvironmentVariables += "}"
	repeatedStringForEgressRules := "[]SecurityGroupRule{"
	for _, f := range this.EgressRules {
		repeatedStringForEgressRules += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForEgressRules += "}"
	repeatedStringForCachedDependencies := "[]*CachedDependency{"
	for _, f := range this.CachedDependencies {
		repeatedStringForCachedDependencies += strings.Replace(fmt.Sprintf("%v", f), "CachedDependency", "CachedDependency", 1) + ","
	}
	repeatedStringForCachedDependencies += "}"
	repeatedStringForVolumeMounts := "[]*VolumeMount{"
	for _, f := range this.VolumeMounts {
		repeatedStringForVolumeMounts += strings.Replace(fmt.Sprintf("%v", f), "VolumeMount", "VolumeMount", 1) + ","
	}
	repeatedStringForVolumeMounts += "}"
	repeatedStringForImageLayers := "[]*ImageLayer{"
	for _, f := range this.ImageLayers {
		repeatedStringForImageLayers += strings.Replace(fmt.Sprintf("%v", f), "ImageLayer", "ImageLayer", 1) + ","
	}
	repeatedStringForImageLayers += "}"
	repeatedStringForSidecars := "[]*Sidecar{"
	for _, f := range this.Sidecars {
		repeatedStringForSidecars += strings.Replace(fmt.Sprintf("%v", f), "Sidecar", "Sidecar", 1) + ","
	}
	repeatedStringForSidecars += "}"
	keysForMetricTags := make([]string, 0, len(this.MetricTags))
	for k, _ := range this.MetricTags {
		keysForMetricTags = append(keysForMetricTags, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetricTags)
	mapStringForMetricTags := "map[string]*MetricTagValue{"
	for _, k := range keysForMetricTags {
		mapStringForMetricTags += fmt.Sprintf("%v: %v,", k, this.MetricTags[k])
	}
	mapStringForMetricTags += "}"
	s := strings.Join([]string{`&DesiredLRPRunInfo{`,
		`DesiredLRPKey:` + strings.Replace(strings.Replace(this.DesiredLRPKey.String(), "DesiredLRPKey", "DesiredLRPKey", 1), `&`, ``, 1) + `,`,
		`EnvironmentVariables:` + repeatedStringForEnvironmentVariables + `,`,
		`Setup:` + strings.Replace(fmt.Sprintf("%v", this.Setup), "Action", "Action", 1) + `,`,
		`Action:` + strings.Replace(fmt.Sprintf("%v", this.Action), "Action", "Action", 1) + `,`,
		`Monitor:` + strings.Replace(fmt.Sprintf("%v", this.Monitor), "Action", "Action", 1) + `,`,
		`DeprecatedStartTimeoutS:` + fmt.Sprintf("%v", this.DeprecatedStartTimeoutS) + `,`,
		`Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`,
		`CpuWeight:` + fmt.Sprintf("%v", this.CpuWeight) + `,`,
		`Ports:` + fmt.Sprintf("%v", this.Ports) + `,`,
		`EgressRules:` + repeatedStringForEgressRules + `,`,
		`LogSource:` + fmt.Sprintf("%v", this.LogSource) + `,`,
		`MetricsGuid:` + fmt.Sprintf("%v", this.MetricsGuid) + `,`,
		`CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`,
		`CachedDependencies:` + repeatedStringForCachedDependencies + `,`,
		`LegacyDownloadUser:` + fmt.Sprintf("%v", this.LegacyDownloadUser) + `,`,
		`TrustedSystemCertificatesPath:` + fmt.Sprintf("%v", this.TrustedSystemCertificatesPath) + `,`,
		`VolumeMounts:` + repeatedStringForVolumeMounts + `,`,
		`Network:` + strings.Replace(fmt.Sprintf("%v", this.Network), "Network", "Network", 1) + `,`,
		`StartTimeoutMs:` + fmt.Sprintf("%v", this.StartTimeoutMs) + `,`,
		`CertificateProperties:` + strings.Replace(fmt.Sprintf("%v", this.CertificateProperties), "CertificateProperties", "CertificateProperties", 1) + `,`,
		`ImageUsername:` + fmt.Sprintf("%v", this.ImageUsername) + `,`,
		`ImagePassword:` + fmt.Sprintf("%v", this.ImagePassword) + `,`,
		`CheckDefinition:` + strings.Replace(fmt.Sprintf("%v", this.CheckDefinition), "CheckDefinition", "CheckDefinition", 1) + `,`,
		`ImageLayers:` + repeatedStringForImageLayers + `,`,
		`MetricTags:` + mapStringForMetricTags + `,`,
		`Sidecars:` + repeatedStringForSidecars + `,`,
		`LogRateLimit:` + strings.Replace(fmt.Sprintf("%v", this.LogRateLimit), "LogRateLimit", "LogRateLimit", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProtoRoutes) String() string {
	if this == nil {
		return "nil"
	}
	keysForRoutes := make([]string, 0, len(this.Routes))
	for k, _ := range this.Routes {
		keysForRoutes = append(keysForRoutes, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForRoutes)
	mapStringForRoutes := "map[string][]byte{"
	for _, k := range keysForRoutes {
		mapStringForRoutes += fmt.Sprintf("%v: %v,", k, this.Routes[k])
	}
	mapStringForRoutes += "}"
	s := strings.Join([]string{`&ProtoRoutes{`,
		`Routes:` + mapStringForRoutes + `,`,
		`}`,
	}, "")
	return s
}
func (this *DesiredLRPUpdate) String() string {
	if this == nil {
		return "nil"
	}
	keysForMetricTags := make([]string, 0, len(this.MetricTags))
	for k, _ := range this.MetricTags {
		keysForMetricTags = append(keysForMetricTags, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetricTags)
	mapStringForMetricTags := "map[string]*MetricTagValue{"
	for _, k := range keysForMetricTags {
		mapStringForMetricTags += fmt.Sprintf("%v: %v,", k, this.MetricTags[k])
	}
	mapStringForMetricTags += "}"
	s := strings.Join([]string{`&DesiredLRPUpdate{`,
		`OptionalInstances:` + fmt.Sprintf("%v", this.OptionalInstances) + `,`,
		`Routes:` + fmt.Sprintf("%v", this.Routes) + `,`,
		`OptionalAnnotation:` + fmt.Sprintf("%v", this.OptionalAnnotation) + `,`,
		`MetricTags:` + mapStringForMetricTags + `,`,
		`}`,
	}, "")
	return s
}
func (this *DesiredLRPUpdate_Instances) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DesiredLRPUpdate_Instances{`,
		`Instances:` + fmt.Sprintf("%v", this.Instances) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DesiredLRPUpdate_Annotation) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DesiredLRPUpdate_Annotation{`,
		`Annotation:` + fmt.Sprintf("%v", this.Annotation) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DesiredLRPKey) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DesiredLRPKey{`,
		`ProcessGuid:` + fmt.Sprintf("%v", this.ProcessGuid) + `,`,
		`Domain:` + fmt.Sprintf("%v", this.Domain) + `,`,
		`LogGuid:` + fmt.Sprintf("%v", this.LogGuid) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DesiredLRPResource) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DesiredLRPResource{`,
		`MemoryMb:` + fmt.Sprintf("%v", this.MemoryMb) + `,`,
		`DiskMb:` + fmt.Sprintf("%v", this.DiskMb) + `,`,
		`RootFs:` + fmt.Sprintf("%v", this.RootFs) + `,`,
		`MaxPids:` + fmt.Sprintf("%v", this.MaxPids) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DesiredLRP) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForEnvironmentVariables := "[]*EnvironmentVariable{"
	for _, f := range this.EnvironmentVariables {
		repeatedStringForEnvironmentVariables += strings.Replace(fmt.Sprintf("%v", f), "EnvironmentVariable", "EnvironmentVariable", 1) + ","
	}
	repeatedStringForEnvironmentVariables += "}"
	repeatedStringForEgressRules := "[]*SecurityGroupRule{"
	for _, f := range this.EgressRules {
		repeatedStringForEgressRules += strings.Replace(fmt.Sprintf("%v", f), "SecurityGroupRule", "SecurityGroupRule", 1) + ","
	}
	repeatedStringForEgressRules += "}"
	repeatedStringForCachedDependencies := "[]*CachedDependency{"
	for _, f := range this.CachedDependencies {
		repeatedStringForCachedDependencies += strings.Replace(fmt.Sprintf("%v", f), "CachedDependency", "CachedDependency", 1) + ","
	}
	repeatedStringForCachedDependencies += "}"
	repeatedStringForVolumeMounts := "[]*VolumeMount{"
	for _, f := range this.VolumeMounts {
		repeatedStringForVolumeMounts += strings.Replace(fmt.Sprintf("%v", f), "VolumeMount", "VolumeMount", 1) + ","
	}
	repeatedStringForVolumeMounts += "}"
	repeatedStringForImageLayers := "[]*ImageLayer{"
	for _, f := range this.ImageLayers {
		repeatedStringForImageLayers += strings.Replace(fmt.Sprintf("%v", f), "ImageLayer", "ImageLayer", 1) + ","
	}
	repeatedStringForImageLayers += "}"
	repeatedStringForSidecars := "[]*Sidecar{"
	for _, f := range this.Sidecars {
		repeatedStringForSidecars += strings.Replace(fmt.Sprintf("%v", f), "Sidecar", "Sidecar", 1) + ","
	}
	repeatedStringForSidecars += "}"
	keysForMetricTags := make([]string, 0, len(this.MetricTags))
	for k, _ := range this.MetricTags {
		keysForMetricTags = append(keysForMetricTags, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetricTags)
	mapStringForMetricTags := "map[string]*MetricTagValue{"
	for _, k := range keysForMetricTags {
		mapStringForMetricTags += fmt.Sprintf("%v: %v,", k, this.MetricTags[k])
	}
	mapStringForMetricTags += "}"
	s := strings.Join([]string{`&DesiredLRP{`,
		`ProcessGuid:` + fmt.Sprintf("%v", this.ProcessGuid) + `,`,
		`Domain:` + fmt.Sprintf("%v", this.Domain) + `,`,
		`RootFs:` + fmt.Sprintf("%v", this.RootFs) + `,`,
		`Instances:` + fmt.Sprintf("%v", this.Instances) + `,`,
		`EnvironmentVariables:` + repeatedStringForEnvironmentVariables + `,`,
		`Setup:` + strings.Replace(fmt.Sprintf("%v", this.Setup), "Action", "Action", 1) + `,`,
		`Action:` + strings.Replace(fmt.Sprintf("%v", this.Action), "Action", "Action", 1) + `,`,
		`DeprecatedStartTimeoutS:` + fmt.Sprintf("%v", this.DeprecatedStartTimeoutS) + `,`,
		`Monitor:` + strings.Replace(fmt.Sprintf("%v", this.Monitor), "Action", "Action", 1) + `,`,
		`DiskMb:` + fmt.Sprintf("%v", this.DiskMb) + `,`,
		`MemoryMb:` + fmt.Sprintf("%v", this.MemoryMb) + `,`,
		`CpuWeight:` + fmt.Sprintf("%v", this.CpuWeight) + `,`,
		`Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`,
		`Ports:` + fmt.Sprintf("%v", this.Ports) + `,`,
		`Routes:` + fmt.Sprintf("%v", this.Routes) + `,`,
		`LogSource:` + fmt.Sprintf("%v", this.LogSource) + `,`,
		`LogGuid:` + fmt.Sprintf("%v", this.LogGuid) + `,`,
		`MetricsGuid:` + fmt.Sprintf("%v", this.MetricsGuid) + `,`,
		`Annotation:` + fmt.Sprintf("%v", this.Annotation) + `,`,
		`EgressRules:` + repeatedStringForEgressRules + `,`,
		`ModificationTag:` + strings.Replace(fmt.Sprintf("%v", this.ModificationTag), "ModificationTag", "ModificationTag", 1) + `,`,
		`CachedDependencies:` + repeatedStringForCachedDependencies + `,`,
		`LegacyDownloadUser:` + fmt.Sprintf("%v", this.LegacyDownloadUser) + `,`,
		`TrustedSystemCertificatesPath:` + fmt.Sprintf("%v", this.TrustedSystemCertificatesPath) + `,`,
		`VolumeMounts:` + repeatedStringForVolumeMounts + `,`,
		`Network:` + strings.Replace(fmt.Sprintf("%v", this.Network), "Network", "Network", 1) + `,`,
		`StartTimeoutMs:` + fmt.Sprintf("%v", this.StartTimeoutMs) + `,`,
		`PlacementTags:` + fmt.Sprintf("%v", this.PlacementTags) + `,`,
		`MaxPids:` + fmt.Sprintf("%v", this.MaxPids) + `,`,
		`CertificateProperties:` + strings.Replace(fmt.Sprintf("%v", this.CertificateProperties), "CertificateProperties", "CertificateProperties", 1) + `,`,
		`ImageUsername:` + fmt.Sprintf("%v", this.ImageUsername) + `,`,
		`ImagePassword:` + fmt.Sprintf("%v", this.ImagePassword) + `,`,
		`CheckDefinition:` + strings.Replace(fmt.Sprintf("%v", this.CheckDefinition), "CheckDefinition", "CheckDefinition", 1) + `,`,
		`ImageLayers:` + repeatedStringForImageLayers + `,`,
		`MetricTags:` + mapStringForMetricTags + `,`,
		`Sidecars:` + repeatedStringForSidecars + `,`,
		`LogRateLimit:` + strings.Replace(fmt.Sprintf("%v", this.LogRateLimit), "LogRateLimit", "LogRateLimit", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringDesiredLrp(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *DesiredLRPSchedulingInfo) 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 ErrIntOverflowDesiredLrp
			}
			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: DesiredLRPSchedulingInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DesiredLRPSchedulingInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DesiredLRPKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DesiredLRPKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotation", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Annotation = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Instances", wireType)
			}
			m.Instances = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Instances |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DesiredLRPResource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DesiredLRPResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Routes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Routes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModificationTag", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ModificationTag.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VolumePlacement", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VolumePlacement == nil {
				m.VolumePlacement = &VolumePlacement{}
			}
			if err := m.VolumePlacement.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlacementTags", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PlacementTags = append(m.PlacementTags, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDesiredLrp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DesiredLRPRunInfo) 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 ErrIntOverflowDesiredLrp
			}
			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: DesiredLRPRunInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DesiredLRPRunInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DesiredLRPKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DesiredLRPKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnvironmentVariables", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EnvironmentVariables = append(m.EnvironmentVariables, EnvironmentVariable{})
			if err := m.EnvironmentVariables[len(m.EnvironmentVariables)-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 Setup", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Setup == nil {
				m.Setup = &Action{}
			}
			if err := m.Setup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Action == nil {
				m.Action = &Action{}
			}
			if err := m.Action.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Monitor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Monitor == nil {
				m.Monitor = &Action{}
			}
			if err := m.Monitor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedStartTimeoutS", wireType)
			}
			m.DeprecatedStartTimeoutS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DeprecatedStartTimeoutS |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Privileged = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuWeight", wireType)
			}
			m.CpuWeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CpuWeight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDesiredLrp
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Ports = append(m.Ports, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDesiredLrp
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthDesiredLrp
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthDesiredLrp
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Ports) == 0 {
					m.Ports = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDesiredLrp
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Ports = append(m.Ports, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EgressRules", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EgressRules = append(m.EgressRules, SecurityGroupRule{})
			if err := m.EgressRules[len(m.EgressRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogSource", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LogSource = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricsGuid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricsGuid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CachedDependencies", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CachedDependencies = append(m.CachedDependencies, &CachedDependency{})
			if err := m.CachedDependencies[len(m.CachedDependencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LegacyDownloadUser", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LegacyDownloadUser = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustedSystemCertificatesPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TrustedSystemCertificatesPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VolumeMounts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VolumeMounts = append(m.VolumeMounts, &VolumeMount{})
			if err := m.VolumeMounts[len(m.VolumeMounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Network == nil {
				m.Network = &Network{}
			}
			if err := m.Network.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimeoutMs", wireType)
			}
			m.StartTimeoutMs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimeoutMs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CertificateProperties", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CertificateProperties == nil {
				m.CertificateProperties = &CertificateProperties{}
			}
			if err := m.CertificateProperties.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageUsername", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImageUsername = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImagePassword", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImagePassword = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckDefinition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CheckDefinition == nil {
				m.CheckDefinition = &CheckDefinition{}
			}
			if err := m.CheckDefinition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageLayers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImageLayers = append(m.ImageLayers, &ImageLayer{})
			if err := m.ImageLayers[len(m.ImageLayers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricTags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MetricTags == nil {
				m.MetricTags = make(map[string]*MetricTagValue)
			}
			var mapkey string
			var mapvalue *MetricTagValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDesiredLrp
					}
					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 ErrIntOverflowDesiredLrp
						}
						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 ErrInvalidLengthDesiredLrp
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					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 ErrIntOverflowDesiredLrp
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &MetricTagValue{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDesiredLrp(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MetricTags[mapkey] = mapvalue
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sidecars", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sidecars = append(m.Sidecars, &Sidecar{})
			if err := m.Sidecars[len(m.Sidecars)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogRateLimit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LogRateLimit == nil {
				m.LogRateLimit = &LogRateLimit{}
			}
			if err := m.LogRateLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDesiredLrp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProtoRoutes) 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 ErrIntOverflowDesiredLrp
			}
			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: ProtoRoutes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProtoRoutes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Routes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Routes == nil {
				m.Routes = make(map[string][]byte)
			}
			var mapkey string
			mapvalue := []byte{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDesiredLrp
					}
					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 ErrIntOverflowDesiredLrp
						}
						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 ErrInvalidLengthDesiredLrp
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapbyteLen uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDesiredLrp
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapbyteLen |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intMapbyteLen := int(mapbyteLen)
					if intMapbyteLen < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					postbytesIndex := iNdEx + intMapbyteLen
					if postbytesIndex < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					if postbytesIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = make([]byte, mapbyteLen)
					copy(mapvalue, dAtA[iNdEx:postbytesIndex])
					iNdEx = postbytesIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDesiredLrp(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Routes[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDesiredLrp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DesiredLRPUpdate) 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 ErrIntOverflowDesiredLrp
			}
			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: DesiredLRPUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DesiredLRPUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Instances", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalInstances = &DesiredLRPUpdate_Instances{v}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Routes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Routes == nil {
				m.Routes = &Routes{}
			}
			if err := m.Routes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotation", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OptionalAnnotation = &DesiredLRPUpdate_Annotation{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricTags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MetricTags == nil {
				m.MetricTags = make(map[string]*MetricTagValue)
			}
			var mapkey string
			var mapvalue *MetricTagValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDesiredLrp
					}
					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 ErrIntOverflowDesiredLrp
						}
						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 ErrInvalidLengthDesiredLrp
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					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 ErrIntOverflowDesiredLrp
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &MetricTagValue{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDesiredLrp(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MetricTags[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDesiredLrp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DesiredLRP) 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 ErrIntOverflowDesiredLrp
			}
			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: DesiredLRP: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DesiredLRP: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessGuid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProcessGuid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Domain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootFs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootFs = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Instances", wireType)
			}
			m.Instances = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Instances |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnvironmentVariables", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EnvironmentVariables = append(m.EnvironmentVariables, &EnvironmentVariable{})
			if err := m.EnvironmentVariables[len(m.EnvironmentVariables)-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 Setup", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Setup == nil {
				m.Setup = &Action{}
			}
			if err := m.Setup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Action == nil {
				m.Action = &Action{}
			}
			if err := m.Action.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedStartTimeoutS", wireType)
			}
			m.DeprecatedStartTimeoutS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DeprecatedStartTimeoutS |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Monitor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Monitor == nil {
				m.Monitor = &Action{}
			}
			if err := m.Monitor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DiskMb", wireType)
			}
			m.DiskMb = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DiskMb |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemoryMb", wireType)
			}
			m.MemoryMb = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MemoryMb |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuWeight", wireType)
			}
			m.CpuWeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CpuWeight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Privileged = bool(v != 0)
		case 14:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDesiredLrp
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Ports = append(m.Ports, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDesiredLrp
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthDesiredLrp
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthDesiredLrp
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Ports) == 0 {
					m.Ports = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDesiredLrp
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Ports = append(m.Ports, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Routes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Routes == nil {
				m.Routes = &Routes{}
			}
			if err := m.Routes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogSource", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LogSource = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogGuid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LogGuid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricsGuid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricsGuid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotation", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Annotation = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EgressRules", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EgressRules = append(m.EgressRules, &SecurityGroupRule{})
			if err := m.EgressRules[len(m.EgressRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModificationTag", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ModificationTag == nil {
				m.ModificationTag = &ModificationTag{}
			}
			if err := m.ModificationTag.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CachedDependencies", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CachedDependencies = append(m.CachedDependencies, &CachedDependency{})
			if err := m.CachedDependencies[len(m.CachedDependencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LegacyDownloadUser", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LegacyDownloadUser = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustedSystemCertificatesPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TrustedSystemCertificatesPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VolumeMounts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VolumeMounts = append(m.VolumeMounts, &VolumeMount{})
			if err := m.VolumeMounts[len(m.VolumeMounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Network == nil {
				m.Network = &Network{}
			}
			if err := m.Network.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 27:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimeoutMs", wireType)
			}
			m.StartTimeoutMs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimeoutMs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlacementTags", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PlacementTags = append(m.PlacementTags, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 29:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxPids", wireType)
			}
			m.MaxPids = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxPids |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CertificateProperties", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CertificateProperties == nil {
				m.CertificateProperties = &CertificateProperties{}
			}
			if err := m.CertificateProperties.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageUsername", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImageUsername = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 32:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImagePassword", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				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 ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImagePassword = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckDefinition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CheckDefinition == nil {
				m.CheckDefinition = &CheckDefinition{}
			}
			if err := m.CheckDefinition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 34:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageLayers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImageLayers = append(m.ImageLayers, &ImageLayer{})
			if err := m.ImageLayers[len(m.ImageLayers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 35:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricTags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MetricTags == nil {
				m.MetricTags = make(map[string]*MetricTagValue)
			}
			var mapkey string
			var mapvalue *MetricTagValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDesiredLrp
					}
					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 ErrIntOverflowDesiredLrp
						}
						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 ErrInvalidLengthDesiredLrp
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					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 ErrIntOverflowDesiredLrp
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &MetricTagValue{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDesiredLrp(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthDesiredLrp
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MetricTags[mapkey] = mapvalue
			iNdEx = postIndex
		case 36:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sidecars", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sidecars = append(m.Sidecars, &Sidecar{})
			if err := m.Sidecars[len(m.Sidecars)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 37:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogRateLimit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDesiredLrp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LogRateLimit == nil {
				m.LogRateLimit = &LogRateLimit{}
			}
			if err := m.LogRateLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDesiredLrp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDesiredLrp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthDesiredLrp        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDesiredLrp          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupDesiredLrp = fmt.Errorf("proto: unexpected end of group")
)
