evacuation.pb.go

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

package models

import (
	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 EvacuationResponse struct {
	Error         *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	KeepContainer bool   `protobuf:"varint,2,opt,name=keep_container,json=keepContainer,proto3" json:"keep_container"`
}

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

var xxx_messageInfo_EvacuationResponse proto.InternalMessageInfo

func (m *EvacuationResponse) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *EvacuationResponse) GetKeepContainer() bool {
	if m != nil {
		return m.KeepContainer
	}
	return false
}

type EvacuateClaimedActualLRPRequest struct {
	ActualLrpKey         *ActualLRPKey         `protobuf:"bytes,1,opt,name=actual_lrp_key,json=actualLrpKey,proto3" json:"actual_lrp_key,omitempty"`
	ActualLrpInstanceKey *ActualLRPInstanceKey `protobuf:"bytes,2,opt,name=actual_lrp_instance_key,json=actualLrpInstanceKey,proto3" json:"actual_lrp_instance_key,omitempty"`
}

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

var xxx_messageInfo_EvacuateClaimedActualLRPRequest proto.InternalMessageInfo

func (m *EvacuateClaimedActualLRPRequest) GetActualLrpKey() *ActualLRPKey {
	if m != nil {
		return m.ActualLrpKey
	}
	return nil
}

func (m *EvacuateClaimedActualLRPRequest) GetActualLrpInstanceKey() *ActualLRPInstanceKey {
	if m != nil {
		return m.ActualLrpInstanceKey
	}
	return nil
}

type EvacuateRunningActualLRPRequest struct {
	ActualLrpKey            *ActualLRPKey             `protobuf:"bytes,1,opt,name=actual_lrp_key,json=actualLrpKey,proto3" json:"actual_lrp_key,omitempty"`
	ActualLrpInstanceKey    *ActualLRPInstanceKey     `protobuf:"bytes,2,opt,name=actual_lrp_instance_key,json=actualLrpInstanceKey,proto3" json:"actual_lrp_instance_key,omitempty"`
	ActualLrpNetInfo        *ActualLRPNetInfo         `protobuf:"bytes,3,opt,name=actual_lrp_net_info,json=actualLrpNetInfo,proto3" json:"actual_lrp_net_info,omitempty"`
	ActualLrpInternalRoutes []*ActualLRPInternalRoute `protobuf:"bytes,5,rep,name=actual_lrp_internal_routes,json=actualLrpInternalRoutes,proto3" json:"actual_lrp_internal_routes,omitempty"`
	MetricTags              map[string]string         `protobuf:"bytes,6,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"`
	// Types that are valid to be assigned to OptionalRoutable:
	//	*EvacuateRunningActualLRPRequest_Routable
	OptionalRoutable isEvacuateRunningActualLRPRequest_OptionalRoutable `protobuf_oneof:"optional_routable"`
	AvailabilityZone string                                             `protobuf:"bytes,8,opt,name=availability_zone,json=availabilityZone,proto3" json:"availability_zone"`
}

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

var xxx_messageInfo_EvacuateRunningActualLRPRequest proto.InternalMessageInfo

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

type EvacuateRunningActualLRPRequest_Routable struct {
	Routable bool `protobuf:"varint,7,opt,name=Routable,proto3,oneof" json:"Routable,omitempty"`
}

func (*EvacuateRunningActualLRPRequest_Routable) isEvacuateRunningActualLRPRequest_OptionalRoutable() {
}

func (m *EvacuateRunningActualLRPRequest) GetOptionalRoutable() isEvacuateRunningActualLRPRequest_OptionalRoutable {
	if m != nil {
		return m.OptionalRoutable
	}
	return nil
}

func (m *EvacuateRunningActualLRPRequest) GetActualLrpKey() *ActualLRPKey {
	if m != nil {
		return m.ActualLrpKey
	}
	return nil
}

func (m *EvacuateRunningActualLRPRequest) GetActualLrpInstanceKey() *ActualLRPInstanceKey {
	if m != nil {
		return m.ActualLrpInstanceKey
	}
	return nil
}

func (m *EvacuateRunningActualLRPRequest) GetActualLrpNetInfo() *ActualLRPNetInfo {
	if m != nil {
		return m.ActualLrpNetInfo
	}
	return nil
}

func (m *EvacuateRunningActualLRPRequest) GetActualLrpInternalRoutes() []*ActualLRPInternalRoute {
	if m != nil {
		return m.ActualLrpInternalRoutes
	}
	return nil
}

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

func (m *EvacuateRunningActualLRPRequest) GetRoutable() bool {
	if x, ok := m.GetOptionalRoutable().(*EvacuateRunningActualLRPRequest_Routable); ok {
		return x.Routable
	}
	return false
}

func (m *EvacuateRunningActualLRPRequest) GetAvailabilityZone() string {
	if m != nil {
		return m.AvailabilityZone
	}
	return ""
}

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

type EvacuateStoppedActualLRPRequest struct {
	ActualLrpKey         *ActualLRPKey         `protobuf:"bytes,1,opt,name=actual_lrp_key,json=actualLrpKey,proto3" json:"actual_lrp_key,omitempty"`
	ActualLrpInstanceKey *ActualLRPInstanceKey `protobuf:"bytes,2,opt,name=actual_lrp_instance_key,json=actualLrpInstanceKey,proto3" json:"actual_lrp_instance_key,omitempty"`
}

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

var xxx_messageInfo_EvacuateStoppedActualLRPRequest proto.InternalMessageInfo

func (m *EvacuateStoppedActualLRPRequest) GetActualLrpKey() *ActualLRPKey {
	if m != nil {
		return m.ActualLrpKey
	}
	return nil
}

func (m *EvacuateStoppedActualLRPRequest) GetActualLrpInstanceKey() *ActualLRPInstanceKey {
	if m != nil {
		return m.ActualLrpInstanceKey
	}
	return nil
}

type EvacuateCrashedActualLRPRequest struct {
	ActualLrpKey         *ActualLRPKey         `protobuf:"bytes,1,opt,name=actual_lrp_key,json=actualLrpKey,proto3" json:"actual_lrp_key,omitempty"`
	ActualLrpInstanceKey *ActualLRPInstanceKey `protobuf:"bytes,2,opt,name=actual_lrp_instance_key,json=actualLrpInstanceKey,proto3" json:"actual_lrp_instance_key,omitempty"`
	ErrorMessage         string                `protobuf:"bytes,3,opt,name=error_message,json=errorMessage,proto3" json:"error_message"`
}

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

var xxx_messageInfo_EvacuateCrashedActualLRPRequest proto.InternalMessageInfo

func (m *EvacuateCrashedActualLRPRequest) GetActualLrpKey() *ActualLRPKey {
	if m != nil {
		return m.ActualLrpKey
	}
	return nil
}

func (m *EvacuateCrashedActualLRPRequest) GetActualLrpInstanceKey() *ActualLRPInstanceKey {
	if m != nil {
		return m.ActualLrpInstanceKey
	}
	return nil
}

func (m *EvacuateCrashedActualLRPRequest) GetErrorMessage() string {
	if m != nil {
		return m.ErrorMessage
	}
	return ""
}

type RemoveEvacuatingActualLRPRequest struct {
	ActualLrpKey         *ActualLRPKey         `protobuf:"bytes,1,opt,name=actual_lrp_key,json=actualLrpKey,proto3" json:"actual_lrp_key,omitempty"`
	ActualLrpInstanceKey *ActualLRPInstanceKey `protobuf:"bytes,2,opt,name=actual_lrp_instance_key,json=actualLrpInstanceKey,proto3" json:"actual_lrp_instance_key,omitempty"`
}

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

var xxx_messageInfo_RemoveEvacuatingActualLRPRequest proto.InternalMessageInfo

func (m *RemoveEvacuatingActualLRPRequest) GetActualLrpKey() *ActualLRPKey {
	if m != nil {
		return m.ActualLrpKey
	}
	return nil
}

func (m *RemoveEvacuatingActualLRPRequest) GetActualLrpInstanceKey() *ActualLRPInstanceKey {
	if m != nil {
		return m.ActualLrpInstanceKey
	}
	return nil
}

type RemoveEvacuatingActualLRPResponse struct {
	Error *Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
}

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

var xxx_messageInfo_RemoveEvacuatingActualLRPResponse proto.InternalMessageInfo

func (m *RemoveEvacuatingActualLRPResponse) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func init() {
	proto.RegisterType((*EvacuationResponse)(nil), "models.EvacuationResponse")
	proto.RegisterType((*EvacuateClaimedActualLRPRequest)(nil), "models.EvacuateClaimedActualLRPRequest")
	proto.RegisterType((*EvacuateRunningActualLRPRequest)(nil), "models.EvacuateRunningActualLRPRequest")
	proto.RegisterMapType((map[string]string)(nil), "models.EvacuateRunningActualLRPRequest.MetricTagsEntry")
	proto.RegisterType((*EvacuateStoppedActualLRPRequest)(nil), "models.EvacuateStoppedActualLRPRequest")
	proto.RegisterType((*EvacuateCrashedActualLRPRequest)(nil), "models.EvacuateCrashedActualLRPRequest")
	proto.RegisterType((*RemoveEvacuatingActualLRPRequest)(nil), "models.RemoveEvacuatingActualLRPRequest")
	proto.RegisterType((*RemoveEvacuatingActualLRPResponse)(nil), "models.RemoveEvacuatingActualLRPResponse")
}

func init() { proto.RegisterFile("evacuation.proto", fileDescriptor_5cec7f656fd69c9d) }

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

func (this *EvacuationResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&models.EvacuationResponse{")
	if this.Error != nil {
		s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
	}
	s = append(s, "KeepContainer: "+fmt.Sprintf("%#v", this.KeepContainer)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvacuateClaimedActualLRPRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&models.EvacuateClaimedActualLRPRequest{")
	if this.ActualLrpKey != nil {
		s = append(s, "ActualLrpKey: "+fmt.Sprintf("%#v", this.ActualLrpKey)+",\n")
	}
	if this.ActualLrpInstanceKey != nil {
		s = append(s, "ActualLrpInstanceKey: "+fmt.Sprintf("%#v", this.ActualLrpInstanceKey)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvacuateRunningActualLRPRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&models.EvacuateRunningActualLRPRequest{")
	if this.ActualLrpKey != nil {
		s = append(s, "ActualLrpKey: "+fmt.Sprintf("%#v", this.ActualLrpKey)+",\n")
	}
	if this.ActualLrpInstanceKey != nil {
		s = append(s, "ActualLrpInstanceKey: "+fmt.Sprintf("%#v", this.ActualLrpInstanceKey)+",\n")
	}
	if this.ActualLrpNetInfo != nil {
		s = append(s, "ActualLrpNetInfo: "+fmt.Sprintf("%#v", this.ActualLrpNetInfo)+",\n")
	}
	if this.ActualLrpInternalRoutes != nil {
		s = append(s, "ActualLrpInternalRoutes: "+fmt.Sprintf("%#v", this.ActualLrpInternalRoutes)+",\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]string{"
	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.OptionalRoutable != nil {
		s = append(s, "OptionalRoutable: "+fmt.Sprintf("%#v", this.OptionalRoutable)+",\n")
	}
	s = append(s, "AvailabilityZone: "+fmt.Sprintf("%#v", this.AvailabilityZone)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvacuateRunningActualLRPRequest_Routable) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&models.EvacuateRunningActualLRPRequest_Routable{` +
		`Routable:` + fmt.Sprintf("%#v", this.Routable) + `}`}, ", ")
	return s
}
func (this *EvacuateStoppedActualLRPRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&models.EvacuateStoppedActualLRPRequest{")
	if this.ActualLrpKey != nil {
		s = append(s, "ActualLrpKey: "+fmt.Sprintf("%#v", this.ActualLrpKey)+",\n")
	}
	if this.ActualLrpInstanceKey != nil {
		s = append(s, "ActualLrpInstanceKey: "+fmt.Sprintf("%#v", this.ActualLrpInstanceKey)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EvacuateCrashedActualLRPRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&models.EvacuateCrashedActualLRPRequest{")
	if this.ActualLrpKey != nil {
		s = append(s, "ActualLrpKey: "+fmt.Sprintf("%#v", this.ActualLrpKey)+",\n")
	}
	if this.ActualLrpInstanceKey != nil {
		s = append(s, "ActualLrpInstanceKey: "+fmt.Sprintf("%#v", this.ActualLrpInstanceKey)+",\n")
	}
	s = append(s, "ErrorMessage: "+fmt.Sprintf("%#v", this.ErrorMessage)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RemoveEvacuatingActualLRPRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&models.RemoveEvacuatingActualLRPRequest{")
	if this.ActualLrpKey != nil {
		s = append(s, "ActualLrpKey: "+fmt.Sprintf("%#v", this.ActualLrpKey)+",\n")
	}
	if this.ActualLrpInstanceKey != nil {
		s = append(s, "ActualLrpInstanceKey: "+fmt.Sprintf("%#v", this.ActualLrpInstanceKey)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RemoveEvacuatingActualLRPResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&models.RemoveEvacuatingActualLRPResponse{")
	if this.Error != nil {
		s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringEvacuation(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 *EvacuationResponse) 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 *EvacuationResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EvacuationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.KeepContainer {
		i--
		if m.KeepContainer {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Error != nil {
		{
			size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvacuation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *EvacuateRunningActualLRPRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AvailabilityZone) > 0 {
		i -= len(m.AvailabilityZone)
		copy(dAtA[i:], m.AvailabilityZone)
		i = encodeVarintEvacuation(dAtA, i, uint64(len(m.AvailabilityZone)))
		i--
		dAtA[i] = 0x42
	}
	if m.OptionalRoutable != nil {
		{
			size := m.OptionalRoutable.Size()
			i -= size
			if _, err := m.OptionalRoutable.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.MetricTags) > 0 {
		for k := range m.MetricTags {
			v := m.MetricTags[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintEvacuation(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintEvacuation(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintEvacuation(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.ActualLrpInternalRoutes) > 0 {
		for iNdEx := len(m.ActualLrpInternalRoutes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ActualLrpInternalRoutes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEvacuation(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.ActualLrpNetInfo != nil {
		{
			size, err := m.ActualLrpNetInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvacuation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ActualLrpInstanceKey != nil {
		{
			size, err := m.ActualLrpInstanceKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvacuation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ActualLrpKey != nil {
		{
			size, err := m.ActualLrpKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvacuation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EvacuateRunningActualLRPRequest_Routable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.Routable {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x38
	return len(dAtA) - i, nil
}
func (m *EvacuateStoppedActualLRPRequest) 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 *EvacuateStoppedActualLRPRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *EvacuateCrashedActualLRPRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ErrorMessage) > 0 {
		i -= len(m.ErrorMessage)
		copy(dAtA[i:], m.ErrorMessage)
		i = encodeVarintEvacuation(dAtA, i, uint64(len(m.ErrorMessage)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ActualLrpInstanceKey != nil {
		{
			size, err := m.ActualLrpInstanceKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvacuation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ActualLrpKey != nil {
		{
			size, err := m.ActualLrpKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEvacuation(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

func encodeVarintEvacuation(dAtA []byte, offset int, v uint64) int {
	offset -= sovEvacuation(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *EvacuationResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	if m.KeepContainer {
		n += 2
	}
	return n
}

func (m *EvacuateClaimedActualLRPRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActualLrpKey != nil {
		l = m.ActualLrpKey.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	if m.ActualLrpInstanceKey != nil {
		l = m.ActualLrpInstanceKey.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	return n
}

func (m *EvacuateRunningActualLRPRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActualLrpKey != nil {
		l = m.ActualLrpKey.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	if m.ActualLrpInstanceKey != nil {
		l = m.ActualLrpInstanceKey.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	if m.ActualLrpNetInfo != nil {
		l = m.ActualLrpNetInfo.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	if len(m.ActualLrpInternalRoutes) > 0 {
		for _, e := range m.ActualLrpInternalRoutes {
			l = e.Size()
			n += 1 + l + sovEvacuation(uint64(l))
		}
	}
	if len(m.MetricTags) > 0 {
		for k, v := range m.MetricTags {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovEvacuation(uint64(len(k))) + 1 + len(v) + sovEvacuation(uint64(len(v)))
			n += mapEntrySize + 1 + sovEvacuation(uint64(mapEntrySize))
		}
	}
	if m.OptionalRoutable != nil {
		n += m.OptionalRoutable.Size()
	}
	l = len(m.AvailabilityZone)
	if l > 0 {
		n += 1 + l + sovEvacuation(uint64(l))
	}
	return n
}

func (m *EvacuateRunningActualLRPRequest_Routable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *EvacuateStoppedActualLRPRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActualLrpKey != nil {
		l = m.ActualLrpKey.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	if m.ActualLrpInstanceKey != nil {
		l = m.ActualLrpInstanceKey.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	return n
}

func (m *EvacuateCrashedActualLRPRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActualLrpKey != nil {
		l = m.ActualLrpKey.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	if m.ActualLrpInstanceKey != nil {
		l = m.ActualLrpInstanceKey.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	l = len(m.ErrorMessage)
	if l > 0 {
		n += 1 + l + sovEvacuation(uint64(l))
	}
	return n
}

func (m *RemoveEvacuatingActualLRPRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ActualLrpKey != nil {
		l = m.ActualLrpKey.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	if m.ActualLrpInstanceKey != nil {
		l = m.ActualLrpInstanceKey.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	return n
}

func (m *RemoveEvacuatingActualLRPResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovEvacuation(uint64(l))
	}
	return n
}

func sovEvacuation(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozEvacuation(x uint64) (n int) {
	return sovEvacuation(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *EvacuationResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvacuationResponse{`,
		`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Error", "Error", 1) + `,`,
		`KeepContainer:` + fmt.Sprintf("%v", this.KeepContainer) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvacuateClaimedActualLRPRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvacuateClaimedActualLRPRequest{`,
		`ActualLrpKey:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpKey), "ActualLRPKey", "ActualLRPKey", 1) + `,`,
		`ActualLrpInstanceKey:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpInstanceKey), "ActualLRPInstanceKey", "ActualLRPInstanceKey", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvacuateRunningActualLRPRequest) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForActualLrpInternalRoutes := "[]*ActualLRPInternalRoute{"
	for _, f := range this.ActualLrpInternalRoutes {
		repeatedStringForActualLrpInternalRoutes += strings.Replace(fmt.Sprintf("%v", f), "ActualLRPInternalRoute", "ActualLRPInternalRoute", 1) + ","
	}
	repeatedStringForActualLrpInternalRoutes += "}"
	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]string{"
	for _, k := range keysForMetricTags {
		mapStringForMetricTags += fmt.Sprintf("%v: %v,", k, this.MetricTags[k])
	}
	mapStringForMetricTags += "}"
	s := strings.Join([]string{`&EvacuateRunningActualLRPRequest{`,
		`ActualLrpKey:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpKey), "ActualLRPKey", "ActualLRPKey", 1) + `,`,
		`ActualLrpInstanceKey:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpInstanceKey), "ActualLRPInstanceKey", "ActualLRPInstanceKey", 1) + `,`,
		`ActualLrpNetInfo:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpNetInfo), "ActualLRPNetInfo", "ActualLRPNetInfo", 1) + `,`,
		`ActualLrpInternalRoutes:` + repeatedStringForActualLrpInternalRoutes + `,`,
		`MetricTags:` + mapStringForMetricTags + `,`,
		`OptionalRoutable:` + fmt.Sprintf("%v", this.OptionalRoutable) + `,`,
		`AvailabilityZone:` + fmt.Sprintf("%v", this.AvailabilityZone) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvacuateRunningActualLRPRequest_Routable) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvacuateRunningActualLRPRequest_Routable{`,
		`Routable:` + fmt.Sprintf("%v", this.Routable) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvacuateStoppedActualLRPRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvacuateStoppedActualLRPRequest{`,
		`ActualLrpKey:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpKey), "ActualLRPKey", "ActualLRPKey", 1) + `,`,
		`ActualLrpInstanceKey:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpInstanceKey), "ActualLRPInstanceKey", "ActualLRPInstanceKey", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EvacuateCrashedActualLRPRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EvacuateCrashedActualLRPRequest{`,
		`ActualLrpKey:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpKey), "ActualLRPKey", "ActualLRPKey", 1) + `,`,
		`ActualLrpInstanceKey:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpInstanceKey), "ActualLRPInstanceKey", "ActualLRPInstanceKey", 1) + `,`,
		`ErrorMessage:` + fmt.Sprintf("%v", this.ErrorMessage) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RemoveEvacuatingActualLRPRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RemoveEvacuatingActualLRPRequest{`,
		`ActualLrpKey:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpKey), "ActualLRPKey", "ActualLRPKey", 1) + `,`,
		`ActualLrpInstanceKey:` + strings.Replace(fmt.Sprintf("%v", this.ActualLrpInstanceKey), "ActualLRPInstanceKey", "ActualLRPInstanceKey", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RemoveEvacuatingActualLRPResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RemoveEvacuatingActualLRPResponse{`,
		`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Error", "Error", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringEvacuation(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *EvacuationResponse) 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 ErrIntOverflowEvacuation
			}
			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: EvacuationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EvacuationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvacuation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvacuation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvacuation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Error{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeepContainer", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvacuation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.KeepContainer = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipEvacuation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvacuation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EvacuateRunningActualLRPRequest) 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 ErrIntOverflowEvacuation
			}
			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: EvacuateRunningActualLRPRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EvacuateRunningActualLRPRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActualLrpKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvacuation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvacuation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvacuation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ActualLrpKey == nil {
				m.ActualLrpKey = &ActualLRPKey{}
			}
			if err := m.ActualLrpKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActualLrpInstanceKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvacuation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvacuation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvacuation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ActualLrpInstanceKey == nil {
				m.ActualLrpInstanceKey = &ActualLRPInstanceKey{}
			}
			if err := m.ActualLrpInstanceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActualLrpNetInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvacuation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvacuation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvacuation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ActualLrpNetInfo == nil {
				m.ActualLrpNetInfo = &ActualLRPNetInfo{}
			}
			if err := m.ActualLrpNetInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActualLrpInternalRoutes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvacuation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvacuation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvacuation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActualLrpInternalRoutes = append(m.ActualLrpInternalRoutes, &ActualLRPInternalRoute{})
			if err := m.ActualLrpInternalRoutes[len(m.ActualLrpInternalRoutes)-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 MetricTags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvacuation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvacuation
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEvacuation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MetricTags == nil {
				m.MetricTags = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEvacuation
					}
					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 ErrIntOverflowEvacuation
						}
						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 ErrInvalidLengthEvacuation
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthEvacuation
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowEvacuation
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthEvacuation
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthEvacuation
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipEvacuation(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthEvacuation
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MetricTags[mapkey] = mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Routable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvacuation
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.OptionalRoutable = &EvacuateRunningActualLRPRequest_Routable{b}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvailabilityZone", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvacuation
				}
				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 ErrInvalidLengthEvacuation
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvacuation
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AvailabilityZone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvacuation(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvacuation
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

var (
	ErrInvalidLengthEvacuation        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvacuation          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEvacuation = fmt.Errorf("proto: unexpected end of group")
)