// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/Microsoft/hcsshim/internal/vmservice/vmservice.proto

package vmservice

import (
	context "context"
	fmt "fmt"
	github_com_containerd_ttrpc "github.com/containerd/ttrpc"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	types "github.com/gogo/protobuf/types"
	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 ModifyType int32

const (
	ModifyType_ADD    ModifyType = 0
	ModifyType_REMOVE ModifyType = 1
	ModifyType_UPDATE ModifyType = 2
)

var ModifyType_name = map[int32]string{
	0: "ADD",
	1: "REMOVE",
	2: "UPDATE",
}

var ModifyType_value = map[string]int32{
	"ADD":    0,
	"REMOVE": 1,
	"UPDATE": 2,
}

func (x ModifyType) String() string {
	return proto.EnumName(ModifyType_name, int32(x))
}

func (ModifyType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_272f12cfdaa6c7c8, []int{0}
}

type DiskType int32

const (
	DiskType_SCSI_DISK_TYPE_VHD1     DiskType = 0
	DiskType_SCSI_DISK_TYPE_VHDX     DiskType = 1
	DiskType_SCSI_DISK_TYPE_PHYSICAL DiskType = 2
)

var DiskType_name = map[int32]string{
	0: "SCSI_DISK_TYPE_VHD1",
	1: "SCSI_DISK_TYPE_VHDX",
	2: "SCSI_DISK_TYPE_PHYSICAL",
}

var DiskType_value = map[string]int32{
	"SCSI_DISK_TYPE_VHD1":     0,
	"SCSI_DISK_TYPE_VHDX":     1,
	"SCSI_DISK_TYPE_PHYSICAL": 2,
}

func (x DiskType) String() string {
	return proto.EnumName(DiskType_name, int32(x))
}

func (DiskType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_272f12cfdaa6c7c8, []int{1}
}

type PropertiesVMRequest_PropertiesType int32

const (
	PropertiesVMRequest_Memory    PropertiesVMRequest_PropertiesType = 0
	PropertiesVMRequest_Processor PropertiesVMRequest_PropertiesType = 1
)

var PropertiesVMRequest_PropertiesType_name = map[int32]string{
	0: "Memory",
	1: "Processor",
}

var PropertiesVMRequest_PropertiesType_value = map[string]int32{
	"Memory":    0,
	"Processor": 1,
}

func (x PropertiesVMRequest_PropertiesType) String() string {
	return proto.EnumName(PropertiesVMRequest_PropertiesType_name, int32(x))
}

func (PropertiesVMRequest_PropertiesType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_272f12cfdaa6c7c8, []int{13, 0}
}

type CapabilitiesVMResponse_Resource int32

const (
	CapabilitiesVMResponse_Vpmem     CapabilitiesVMResponse_Resource = 0
	CapabilitiesVMResponse_Scsi      CapabilitiesVMResponse_Resource = 1
	CapabilitiesVMResponse_Vpci      CapabilitiesVMResponse_Resource = 2
	CapabilitiesVMResponse_Plan9     CapabilitiesVMResponse_Resource = 3
	CapabilitiesVMResponse_VMNic     CapabilitiesVMResponse_Resource = 4
	CapabilitiesVMResponse_Memory    CapabilitiesVMResponse_Resource = 5
	CapabilitiesVMResponse_Processor CapabilitiesVMResponse_Resource = 6
)

var CapabilitiesVMResponse_Resource_name = map[int32]string{
	0: "Vpmem",
	1: "Scsi",
	2: "Vpci",
	3: "Plan9",
	4: "VMNic",
	5: "Memory",
	6: "Processor",
}

var CapabilitiesVMResponse_Resource_value = map[string]int32{
	"Vpmem":     0,
	"Scsi":      1,
	"Vpci":      2,
	"Plan9":     3,
	"VMNic":     4,
	"Memory":    5,
	"Processor": 6,
}

func (x CapabilitiesVMResponse_Resource) String() string {
	return proto.EnumName(CapabilitiesVMResponse_Resource_name, int32(x))
}

func (CapabilitiesVMResponse_Resource) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_272f12cfdaa6c7c8, []int{15, 0}
}

type CapabilitiesVMResponse_SupportedGuestOS int32

const (
	CapabilitiesVMResponse_Windows CapabilitiesVMResponse_SupportedGuestOS = 0
	CapabilitiesVMResponse_Linux   CapabilitiesVMResponse_SupportedGuestOS = 1
)

var CapabilitiesVMResponse_SupportedGuestOS_name = map[int32]string{
	0: "Windows",
	1: "Linux",
}

var CapabilitiesVMResponse_SupportedGuestOS_value = map[string]int32{
	"Windows": 0,
	"Linux":   1,
}

func (x CapabilitiesVMResponse_SupportedGuestOS) String() string {
	return proto.EnumName(CapabilitiesVMResponse_SupportedGuestOS_name, int32(x))
}

func (CapabilitiesVMResponse_SupportedGuestOS) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_272f12cfdaa6c7c8, []int{15, 1}
}

type DirectBoot struct {
	KernelPath           string   `protobuf:"bytes,1,opt,name=kernel_path,json=kernelPath,proto3" json:"kernel_path,omitempty"`
	InitrdPath           string   `protobuf:"bytes,2,opt,name=initrd_path,json=initrdPath,proto3" json:"initrd_path,omitempty"`
	KernelCmdline        string   `protobuf:"bytes,3,opt,name=kernel_cmdline,json=kernelCmdline,proto3" json:"kernel_cmdline,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DirectBoot proto.InternalMessageInfo

type UEFI struct {
	FirmwarePath string `protobuf:"bytes,1,opt,name=firmware_path,json=firmwarePath,proto3" json:"firmware_path,omitempty"`
	DevicePath   string `protobuf:"bytes,2,opt,name=device_path,json=devicePath,proto3" json:"device_path,omitempty"`
	// Optional data to include for uefi boot. For Linux this could be used as the kernel
	// commandline.
	OptionalData         string   `protobuf:"bytes,3,opt,name=optional_data,json=optionalData,proto3" json:"optional_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UEFI proto.InternalMessageInfo

type MemoryConfig struct {
	MemoryMb             uint64   `protobuf:"varint,1,opt,name=memory_mb,json=memoryMb,proto3" json:"memory_mb,omitempty"`
	AllowOvercommit      bool     `protobuf:"varint,2,opt,name=allow_overcommit,json=allowOvercommit,proto3" json:"allow_overcommit,omitempty"`
	DeferredCommit       bool     `protobuf:"varint,3,opt,name=deferred_commit,json=deferredCommit,proto3" json:"deferred_commit,omitempty"`
	HotHint              bool     `protobuf:"varint,4,opt,name=hot_hint,json=hotHint,proto3" json:"hot_hint,omitempty"`
	ColdHint             bool     `protobuf:"varint,5,opt,name=cold_hint,json=coldHint,proto3" json:"cold_hint,omitempty"`
	ColdDiscardHint      bool     `protobuf:"varint,6,opt,name=cold_discard_hint,json=coldDiscardHint,proto3" json:"cold_discard_hint,omitempty"`
	LowMmioGapInMb       uint64   `protobuf:"varint,7,opt,name=low_mmio_gap_in_mb,json=lowMmioGapInMb,proto3" json:"low_mmio_gap_in_mb,omitempty"`
	HighMmioBaseInMb     uint64   `protobuf:"varint,8,opt,name=high_mmio_base_in_mb,json=highMmioBaseInMb,proto3" json:"high_mmio_base_in_mb,omitempty"`
	HighMmioGapInMb      uint64   `protobuf:"varint,9,opt,name=high_mmio_gap_in_mb,json=highMmioGapInMb,proto3" json:"high_mmio_gap_in_mb,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MemoryConfig proto.InternalMessageInfo

type ProcessorConfig struct {
	ProcessorCount       uint32   `protobuf:"varint,1,opt,name=processor_count,json=processorCount,proto3" json:"processor_count,omitempty"`
	ProcessorWeight      uint32   `protobuf:"varint,2,opt,name=processor_weight,json=processorWeight,proto3" json:"processor_weight,omitempty"`
	ProcessorLimit       uint32   `protobuf:"varint,3,opt,name=processor_limit,json=processorLimit,proto3" json:"processor_limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ProcessorConfig proto.InternalMessageInfo

type DevicesConfig struct {
	ScsiDisks            []*SCSIDisk         `protobuf:"bytes,1,rep,name=scsi_disks,json=scsiDisks,proto3" json:"scsi_disks,omitempty"`
	VpmemDisks           []*VPMEMDisk        `protobuf:"bytes,2,rep,name=vpmem_disks,json=vpmemDisks,proto3" json:"vpmem_disks,omitempty"`
	NicConfig            []*NICConfig        `protobuf:"bytes,3,rep,name=nic_config,json=nicConfig,proto3" json:"nic_config,omitempty"`
	WindowsDevice        []*WindowsPCIDevice `protobuf:"bytes,4,rep,name=windows_device,json=windowsDevice,proto3" json:"windows_device,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_DevicesConfig proto.InternalMessageInfo

type VMConfig struct {
	MemoryConfig    *MemoryConfig    `protobuf:"bytes,1,opt,name=memory_config,json=memoryConfig,proto3" json:"memory_config,omitempty"`
	ProcessorConfig *ProcessorConfig `protobuf:"bytes,2,opt,name=processor_config,json=processorConfig,proto3" json:"processor_config,omitempty"`
	DevicesConfig   *DevicesConfig   `protobuf:"bytes,3,opt,name=devices_config,json=devicesConfig,proto3" json:"devices_config,omitempty"`
	SerialConfig    *SerialConfig    `protobuf:"bytes,4,opt,name=serial_config,json=serialConfig,proto3" json:"serial_config,omitempty"`
	// Types that are valid to be assigned to BootConfig:
	//	*VMConfig_DirectBoot
	//	*VMConfig_Uefi
	BootConfig     isVMConfig_BootConfig `protobuf_oneof:"BootConfig"`
	WindowsOptions *WindowsOptions       `protobuf:"bytes,7,opt,name=windows_options,json=windowsOptions,proto3" json:"windows_options,omitempty"`
	// Optional k:v extra data. Up to the virtstack for how to interpret this.
	ExtraData            map[string]string `protobuf:"bytes,8,rep,name=extra_data,json=extraData,proto3" json:"extra_data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_VMConfig proto.InternalMessageInfo

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

type VMConfig_DirectBoot struct {
	DirectBoot *DirectBoot `protobuf:"bytes,5,opt,name=direct_boot,json=directBoot,proto3,oneof" json:"direct_boot,omitempty"`
}
type VMConfig_Uefi struct {
	Uefi *UEFI `protobuf:"bytes,6,opt,name=uefi,proto3,oneof" json:"uefi,omitempty"`
}

func (*VMConfig_DirectBoot) isVMConfig_BootConfig() {}
func (*VMConfig_Uefi) isVMConfig_BootConfig()       {}

func (m *VMConfig) GetBootConfig() isVMConfig_BootConfig {
	if m != nil {
		return m.BootConfig
	}
	return nil
}

func (m *VMConfig) GetDirectBoot() *DirectBoot {
	if x, ok := m.GetBootConfig().(*VMConfig_DirectBoot); ok {
		return x.DirectBoot
	}
	return nil
}

func (m *VMConfig) GetUefi() *UEFI {
	if x, ok := m.GetBootConfig().(*VMConfig_Uefi); ok {
		return x.Uefi
	}
	return nil
}

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

// WindowsOptions contains virtual machine configurations that are only present on a Windows host.
type WindowsOptions struct {
	CpuGroupID           uint64   `protobuf:"varint,1,opt,name=cpu_group_id,json=cpuGroupId,proto3" json:"cpu_group_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_WindowsOptions proto.InternalMessageInfo

type SerialConfig struct {
	Ports                []*SerialConfig_Config `protobuf:"bytes,3,rep,name=ports,proto3" json:"ports,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_SerialConfig proto.InternalMessageInfo

type SerialConfig_Config struct {
	Port uint32 `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
	// Unix domain socket to relay serial console output to.
	SocketPath           string   `protobuf:"bytes,2,opt,name=socket_path,json=socketPath,proto3" json:"socket_path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SerialConfig_Config proto.InternalMessageInfo

type CreateVMRequest struct {
	Config *VMConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	// Optional ID to be used by the VM service in log messages. It's up to the
	// virtstack to make use of this field. Useful for debugging to be able to
	// correlate events for a given vm that the client launched.
	LogID                string   `protobuf:"bytes,2,opt,name=log_id,json=logId,proto3" json:"log_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CreateVMRequest proto.InternalMessageInfo

type InspectVMRequest struct {
	Query                string   `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
	RecursionLimit       uint32   `protobuf:"varint,2,opt,name=recursion_limit,json=recursionLimit,proto3" json:"recursion_limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_InspectVMRequest proto.InternalMessageInfo

type InspectVMResponse struct {
	Result               *types.Value `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_InspectVMResponse proto.InternalMessageInfo

type MemoryStats struct {
	WorkingSetBytes      uint64   `protobuf:"varint,1,opt,name=working_set_bytes,json=workingSetBytes,proto3" json:"working_set_bytes,omitempty"`
	AvailableMemory      uint64   `protobuf:"varint,2,opt,name=available_memory,json=availableMemory,proto3" json:"available_memory,omitempty"`
	ReservedMemory       uint64   `protobuf:"varint,3,opt,name=reserved_memory,json=reservedMemory,proto3" json:"reserved_memory,omitempty"`
	AssignedMemory       uint64   `protobuf:"varint,4,opt,name=assigned_memory,json=assignedMemory,proto3" json:"assigned_memory,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MemoryStats proto.InternalMessageInfo

type ProcessorStats struct {
	TotalRuntimeNs       uint64   `protobuf:"varint,1,opt,name=total_runtime_ns,json=totalRuntimeNs,proto3" json:"total_runtime_ns,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ProcessorStats proto.InternalMessageInfo

type PropertiesVMRequest struct {
	Types                []PropertiesVMRequest_PropertiesType `protobuf:"varint,1,rep,packed,name=types,proto3,enum=vmservice.PropertiesVMRequest_PropertiesType" json:"types,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
	XXX_unrecognized     []byte                               `json:"-"`
	XXX_sizecache        int32                                `json:"-"`
}

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

var xxx_messageInfo_PropertiesVMRequest proto.InternalMessageInfo

type PropertiesVMResponse struct {
	MemoryStats          *MemoryStats    `protobuf:"bytes,1,opt,name=memory_stats,json=memoryStats,proto3" json:"memory_stats,omitempty"`
	ProcessorStats       *ProcessorStats `protobuf:"bytes,2,opt,name=processor_stats,json=processorStats,proto3" json:"processor_stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_PropertiesVMResponse proto.InternalMessageInfo

type CapabilitiesVMResponse struct {
	SupportedResources   []*CapabilitiesVMResponse_SupportedResource `protobuf:"bytes,1,rep,name=supported_resources,json=supportedResources,proto3" json:"supported_resources,omitempty"`
	SupportedGuestOs     []CapabilitiesVMResponse_SupportedGuestOS   `protobuf:"varint,2,rep,packed,name=supported_guest_os,json=supportedGuestOs,proto3,enum=vmservice.CapabilitiesVMResponse_SupportedGuestOS" json:"supported_guest_os,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                    `json:"-"`
	XXX_unrecognized     []byte                                      `json:"-"`
	XXX_sizecache        int32                                       `json:"-"`
}

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

var xxx_messageInfo_CapabilitiesVMResponse proto.InternalMessageInfo

type CapabilitiesVMResponse_SupportedResource struct {
	Add                  bool                            `protobuf:"varint,1,opt,name=Add,proto3" json:"Add,omitempty"`
	Remove               bool                            `protobuf:"varint,2,opt,name=Remove,proto3" json:"Remove,omitempty"`
	Update               bool                            `protobuf:"varint,3,opt,name=Update,proto3" json:"Update,omitempty"`
	Resource             CapabilitiesVMResponse_Resource `protobuf:"varint,4,opt,name=resource,proto3,enum=vmservice.CapabilitiesVMResponse_Resource" json:"resource,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

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

var xxx_messageInfo_CapabilitiesVMResponse_SupportedResource proto.InternalMessageInfo

type HVSocketListen struct {
	ServiceID string `protobuf:"bytes,1,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
	// Expected that the listener is a unix domain socket. These
	// are supported on Windows as of 1809/RS5.
	ListenerPath         string   `protobuf:"bytes,2,opt,name=listener_path,json=listenerPath,proto3" json:"listener_path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_HVSocketListen proto.InternalMessageInfo

type VSockListen struct {
	Port                 uint32   `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
	ListenerPath         string   `protobuf:"bytes,2,opt,name=listener_path,json=listenerPath,proto3" json:"listener_path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_VSockListen proto.InternalMessageInfo

type VMSocketRequest struct {
	Type ModifyType `protobuf:"varint,1,opt,name=type,proto3,enum=vmservice.ModifyType" json:"type,omitempty"`
	// Types that are valid to be assigned to Config:
	//	*VMSocketRequest_HvsocketList
	//	*VMSocketRequest_VsockListen
	Config               isVMSocketRequest_Config `protobuf_oneof:"Config"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

var xxx_messageInfo_VMSocketRequest proto.InternalMessageInfo

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

type VMSocketRequest_HvsocketList struct {
	HvsocketList *HVSocketListen `protobuf:"bytes,2,opt,name=hvsocket_list,json=hvsocketList,proto3,oneof" json:"hvsocket_list,omitempty"`
}
type VMSocketRequest_VsockListen struct {
	VsockListen *VSockListen `protobuf:"bytes,3,opt,name=vsock_listen,json=vsockListen,proto3,oneof" json:"vsock_listen,omitempty"`
}

func (*VMSocketRequest_HvsocketList) isVMSocketRequest_Config() {}
func (*VMSocketRequest_VsockListen) isVMSocketRequest_Config()  {}

func (m *VMSocketRequest) GetConfig() isVMSocketRequest_Config {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *VMSocketRequest) GetHvsocketList() *HVSocketListen {
	if x, ok := m.GetConfig().(*VMSocketRequest_HvsocketList); ok {
		return x.HvsocketList
	}
	return nil
}

func (m *VMSocketRequest) GetVsockListen() *VSockListen {
	if x, ok := m.GetConfig().(*VMSocketRequest_VsockListen); ok {
		return x.VsockListen
	}
	return nil
}

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

type SCSIDisk struct {
	Controller           uint32   `protobuf:"varint,1,opt,name=controller,proto3" json:"controller,omitempty"`
	Lun                  uint32   `protobuf:"varint,2,opt,name=lun,proto3" json:"lun,omitempty"`
	HostPath             string   `protobuf:"bytes,3,opt,name=host_path,json=hostPath,proto3" json:"host_path,omitempty"`
	Type                 DiskType `protobuf:"varint,4,opt,name=type,proto3,enum=vmservice.DiskType" json:"type,omitempty"`
	ReadOnly             bool     `protobuf:"varint,5,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SCSIDisk proto.InternalMessageInfo

type VPMEMDisk struct {
	HostPath             string   `protobuf:"bytes,1,opt,name=host_path,json=hostPath,proto3" json:"host_path,omitempty"`
	Type                 DiskType `protobuf:"varint,2,opt,name=type,proto3,enum=vmservice.DiskType" json:"type,omitempty"`
	ReadOnly             bool     `protobuf:"varint,3,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_VPMEMDisk proto.InternalMessageInfo

type NICConfig struct {
	NicID      string `protobuf:"bytes,1,opt,name=nic_id,json=nicId,proto3" json:"nic_id,omitempty"`
	PortID     string `protobuf:"bytes,2,opt,name=port_id,json=portId,proto3" json:"port_id,omitempty"`
	MacAddress string `protobuf:"bytes,3,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"`
	SwitchID   string `protobuf:"bytes,4,opt,name=switch_id,json=switchId,proto3" json:"switch_id,omitempty"`
	// Optional friendly name for the adapter. Might be useful to show up in logs.
	NicName              string   `protobuf:"bytes,5,opt,name=nic_name,json=nicName,proto3" json:"nic_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NICConfig proto.InternalMessageInfo

type WindowsPCIDevice struct {
	// e.g. PCIP\\VEN_10DE&DEV_13F2&SUBSYS_115E10DE&REV_A1\\6&17F903&0&00400000
	InstanceID           string   `protobuf:"bytes,1,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_WindowsPCIDevice proto.InternalMessageInfo

type ModifyMemoryRequest struct {
	MemoryMb             uint64   `protobuf:"varint,1,opt,name=memory_mb,json=memoryMb,proto3" json:"memory_mb,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModifyMemoryRequest proto.InternalMessageInfo

type ModifyProcessorRequest struct {
	// Index of the processor to add/remove
	ProcessorIndex       uint32   `protobuf:"varint,1,opt,name=processor_index,json=processorIndex,proto3" json:"processor_index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModifyProcessorRequest proto.InternalMessageInfo

type ModifyProcessorConfigRequest struct {
	ProcessorWeight      uint32   `protobuf:"varint,1,opt,name=processor_weight,json=processorWeight,proto3" json:"processor_weight,omitempty"`
	ProcessorLimit       uint32   `protobuf:"varint,2,opt,name=processor_limit,json=processorLimit,proto3" json:"processor_limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModifyProcessorConfigRequest proto.InternalMessageInfo

type ModifyResourceRequest struct {
	Type ModifyType `protobuf:"varint,1,opt,name=type,proto3,enum=vmservice.ModifyType" json:"type,omitempty"`
	// Types that are valid to be assigned to Resource:
	//	*ModifyResourceRequest_Processor
	//	*ModifyResourceRequest_ProcessorConfig
	//	*ModifyResourceRequest_Memory
	//	*ModifyResourceRequest_ScsiDisk
	//	*ModifyResourceRequest_VpmemDisk
	//	*ModifyResourceRequest_NicConfig
	//	*ModifyResourceRequest_WindowsDevice
	Resource             isModifyResourceRequest_Resource `protobuf_oneof:"resource"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

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

var xxx_messageInfo_ModifyResourceRequest proto.InternalMessageInfo

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

type ModifyResourceRequest_Processor struct {
	Processor *ModifyProcessorRequest `protobuf:"bytes,2,opt,name=processor,proto3,oneof" json:"processor,omitempty"`
}
type ModifyResourceRequest_ProcessorConfig struct {
	ProcessorConfig *ModifyProcessorConfigRequest `protobuf:"bytes,3,opt,name=processor_config,json=processorConfig,proto3,oneof" json:"processor_config,omitempty"`
}
type ModifyResourceRequest_Memory struct {
	Memory *ModifyMemoryRequest `protobuf:"bytes,4,opt,name=memory,proto3,oneof" json:"memory,omitempty"`
}
type ModifyResourceRequest_ScsiDisk struct {
	ScsiDisk *SCSIDisk `protobuf:"bytes,5,opt,name=scsi_disk,json=scsiDisk,proto3,oneof" json:"scsi_disk,omitempty"`
}
type ModifyResourceRequest_VpmemDisk struct {
	VpmemDisk *VPMEMDisk `protobuf:"bytes,6,opt,name=vpmem_disk,json=vpmemDisk,proto3,oneof" json:"vpmem_disk,omitempty"`
}
type ModifyResourceRequest_NicConfig struct {
	NicConfig *NICConfig `protobuf:"bytes,7,opt,name=nic_config,json=nicConfig,proto3,oneof" json:"nic_config,omitempty"`
}
type ModifyResourceRequest_WindowsDevice struct {
	WindowsDevice *WindowsPCIDevice `protobuf:"bytes,8,opt,name=windows_device,json=windowsDevice,proto3,oneof" json:"windows_device,omitempty"`
}

func (*ModifyResourceRequest_Processor) isModifyResourceRequest_Resource()       {}
func (*ModifyResourceRequest_ProcessorConfig) isModifyResourceRequest_Resource() {}
func (*ModifyResourceRequest_Memory) isModifyResourceRequest_Resource()          {}
func (*ModifyResourceRequest_ScsiDisk) isModifyResourceRequest_Resource()        {}
func (*ModifyResourceRequest_VpmemDisk) isModifyResourceRequest_Resource()       {}
func (*ModifyResourceRequest_NicConfig) isModifyResourceRequest_Resource()       {}
func (*ModifyResourceRequest_WindowsDevice) isModifyResourceRequest_Resource()   {}

func (m *ModifyResourceRequest) GetResource() isModifyResourceRequest_Resource {
	if m != nil {
		return m.Resource
	}
	return nil
}

func (m *ModifyResourceRequest) GetProcessor() *ModifyProcessorRequest {
	if x, ok := m.GetResource().(*ModifyResourceRequest_Processor); ok {
		return x.Processor
	}
	return nil
}

func (m *ModifyResourceRequest) GetProcessorConfig() *ModifyProcessorConfigRequest {
	if x, ok := m.GetResource().(*ModifyResourceRequest_ProcessorConfig); ok {
		return x.ProcessorConfig
	}
	return nil
}

func (m *ModifyResourceRequest) GetMemory() *ModifyMemoryRequest {
	if x, ok := m.GetResource().(*ModifyResourceRequest_Memory); ok {
		return x.Memory
	}
	return nil
}

func (m *ModifyResourceRequest) GetScsiDisk() *SCSIDisk {
	if x, ok := m.GetResource().(*ModifyResourceRequest_ScsiDisk); ok {
		return x.ScsiDisk
	}
	return nil
}

func (m *ModifyResourceRequest) GetVpmemDisk() *VPMEMDisk {
	if x, ok := m.GetResource().(*ModifyResourceRequest_VpmemDisk); ok {
		return x.VpmemDisk
	}
	return nil
}

func (m *ModifyResourceRequest) GetNicConfig() *NICConfig {
	if x, ok := m.GetResource().(*ModifyResourceRequest_NicConfig); ok {
		return x.NicConfig
	}
	return nil
}

func (m *ModifyResourceRequest) GetWindowsDevice() *WindowsPCIDevice {
	if x, ok := m.GetResource().(*ModifyResourceRequest_WindowsDevice); ok {
		return x.WindowsDevice
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ModifyResourceRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ModifyResourceRequest_Processor)(nil),
		(*ModifyResourceRequest_ProcessorConfig)(nil),
		(*ModifyResourceRequest_Memory)(nil),
		(*ModifyResourceRequest_ScsiDisk)(nil),
		(*ModifyResourceRequest_VpmemDisk)(nil),
		(*ModifyResourceRequest_NicConfig)(nil),
		(*ModifyResourceRequest_WindowsDevice)(nil),
	}
}

func init() {
	proto.RegisterEnum("vmservice.ModifyType", ModifyType_name, ModifyType_value)
	proto.RegisterEnum("vmservice.DiskType", DiskType_name, DiskType_value)
	proto.RegisterEnum("vmservice.PropertiesVMRequest_PropertiesType", PropertiesVMRequest_PropertiesType_name, PropertiesVMRequest_PropertiesType_value)
	proto.RegisterEnum("vmservice.CapabilitiesVMResponse_Resource", CapabilitiesVMResponse_Resource_name, CapabilitiesVMResponse_Resource_value)
	proto.RegisterEnum("vmservice.CapabilitiesVMResponse_SupportedGuestOS", CapabilitiesVMResponse_SupportedGuestOS_name, CapabilitiesVMResponse_SupportedGuestOS_value)
	proto.RegisterType((*DirectBoot)(nil), "vmservice.DirectBoot")
	proto.RegisterType((*UEFI)(nil), "vmservice.UEFI")
	proto.RegisterType((*MemoryConfig)(nil), "vmservice.MemoryConfig")
	proto.RegisterType((*ProcessorConfig)(nil), "vmservice.ProcessorConfig")
	proto.RegisterType((*DevicesConfig)(nil), "vmservice.DevicesConfig")
	proto.RegisterType((*VMConfig)(nil), "vmservice.VMConfig")
	proto.RegisterMapType((map[string]string)(nil), "vmservice.VMConfig.ExtraDataEntry")
	proto.RegisterType((*WindowsOptions)(nil), "vmservice.WindowsOptions")
	proto.RegisterType((*SerialConfig)(nil), "vmservice.SerialConfig")
	proto.RegisterType((*SerialConfig_Config)(nil), "vmservice.SerialConfig.Config")
	proto.RegisterType((*CreateVMRequest)(nil), "vmservice.CreateVMRequest")
	proto.RegisterType((*InspectVMRequest)(nil), "vmservice.InspectVMRequest")
	proto.RegisterType((*InspectVMResponse)(nil), "vmservice.InspectVMResponse")
	proto.RegisterType((*MemoryStats)(nil), "vmservice.MemoryStats")
	proto.RegisterType((*ProcessorStats)(nil), "vmservice.ProcessorStats")
	proto.RegisterType((*PropertiesVMRequest)(nil), "vmservice.PropertiesVMRequest")
	proto.RegisterType((*PropertiesVMResponse)(nil), "vmservice.PropertiesVMResponse")
	proto.RegisterType((*CapabilitiesVMResponse)(nil), "vmservice.CapabilitiesVMResponse")
	proto.RegisterType((*CapabilitiesVMResponse_SupportedResource)(nil), "vmservice.CapabilitiesVMResponse.SupportedResource")
	proto.RegisterType((*HVSocketListen)(nil), "vmservice.HVSocketListen")
	proto.RegisterType((*VSockListen)(nil), "vmservice.VSockListen")
	proto.RegisterType((*VMSocketRequest)(nil), "vmservice.VMSocketRequest")
	proto.RegisterType((*SCSIDisk)(nil), "vmservice.SCSIDisk")
	proto.RegisterType((*VPMEMDisk)(nil), "vmservice.VPMEMDisk")
	proto.RegisterType((*NICConfig)(nil), "vmservice.NICConfig")
	proto.RegisterType((*WindowsPCIDevice)(nil), "vmservice.WindowsPCIDevice")
	proto.RegisterType((*ModifyMemoryRequest)(nil), "vmservice.ModifyMemoryRequest")
	proto.RegisterType((*ModifyProcessorRequest)(nil), "vmservice.ModifyProcessorRequest")
	proto.RegisterType((*ModifyProcessorConfigRequest)(nil), "vmservice.ModifyProcessorConfigRequest")
	proto.RegisterType((*ModifyResourceRequest)(nil), "vmservice.ModifyResourceRequest")
}

func init() {
	proto.RegisterFile("github.com/Microsoft/hcsshim/internal/vmservice/vmservice.proto", fileDescriptor_272f12cfdaa6c7c8)
}

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

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

func (m *DirectBoot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.KernelCmdline) > 0 {
		i -= len(m.KernelCmdline)
		copy(dAtA[i:], m.KernelCmdline)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.KernelCmdline)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.InitrdPath) > 0 {
		i -= len(m.InitrdPath)
		copy(dAtA[i:], m.InitrdPath)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.InitrdPath)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.KernelPath) > 0 {
		i -= len(m.KernelPath)
		copy(dAtA[i:], m.KernelPath)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.KernelPath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *UEFI) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.OptionalData) > 0 {
		i -= len(m.OptionalData)
		copy(dAtA[i:], m.OptionalData)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.OptionalData)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.DevicePath) > 0 {
		i -= len(m.DevicePath)
		copy(dAtA[i:], m.DevicePath)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.DevicePath)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.FirmwarePath) > 0 {
		i -= len(m.FirmwarePath)
		copy(dAtA[i:], m.FirmwarePath)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.FirmwarePath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MemoryConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.HighMmioGapInMb != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.HighMmioGapInMb))
		i--
		dAtA[i] = 0x48
	}
	if m.HighMmioBaseInMb != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.HighMmioBaseInMb))
		i--
		dAtA[i] = 0x40
	}
	if m.LowMmioGapInMb != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.LowMmioGapInMb))
		i--
		dAtA[i] = 0x38
	}
	if m.ColdDiscardHint {
		i--
		if m.ColdDiscardHint {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.ColdHint {
		i--
		if m.ColdHint {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.HotHint {
		i--
		if m.HotHint {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.DeferredCommit {
		i--
		if m.DeferredCommit {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.AllowOvercommit {
		i--
		if m.AllowOvercommit {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.MemoryMb != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.MemoryMb))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ProcessorConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ProcessorLimit != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorLimit))
		i--
		dAtA[i] = 0x18
	}
	if m.ProcessorWeight != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorWeight))
		i--
		dAtA[i] = 0x10
	}
	if m.ProcessorCount != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorCount))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *DevicesConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.WindowsDevice) > 0 {
		for iNdEx := len(m.WindowsDevice) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.WindowsDevice[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVmservice(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.NicConfig) > 0 {
		for iNdEx := len(m.NicConfig) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NicConfig[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVmservice(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.VpmemDisks) > 0 {
		for iNdEx := len(m.VpmemDisks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.VpmemDisks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVmservice(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ScsiDisks) > 0 {
		for iNdEx := len(m.ScsiDisks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ScsiDisks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVmservice(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *VMConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ExtraData) > 0 {
		for k := range m.ExtraData {
			v := m.ExtraData[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintVmservice(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintVmservice(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintVmservice(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x42
		}
	}
	if m.WindowsOptions != nil {
		{
			size, err := m.WindowsOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.BootConfig != nil {
		{
			size := m.BootConfig.Size()
			i -= size
			if _, err := m.BootConfig.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.SerialConfig != nil {
		{
			size, err := m.SerialConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.DevicesConfig != nil {
		{
			size, err := m.DevicesConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ProcessorConfig != nil {
		{
			size, err := m.ProcessorConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.MemoryConfig != nil {
		{
			size, err := m.MemoryConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VMConfig_DirectBoot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DirectBoot != nil {
		{
			size, err := m.DirectBoot.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *VMConfig_Uefi) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *WindowsOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.CpuGroupID != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.CpuGroupID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SerialConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Ports) > 0 {
		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVmservice(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SerialConfig_Config) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.SocketPath) > 0 {
		i -= len(m.SocketPath)
		copy(dAtA[i:], m.SocketPath)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.SocketPath)))
		i--
		dAtA[i] = 0x12
	}
	if m.Port != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *CreateVMRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.LogID) > 0 {
		i -= len(m.LogID)
		copy(dAtA[i:], m.LogID)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.LogID)))
		i--
		dAtA[i] = 0x12
	}
	if m.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *InspectVMRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.RecursionLimit != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.RecursionLimit))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Query) > 0 {
		i -= len(m.Query)
		copy(dAtA[i:], m.Query)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.Query)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MemoryStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.AssignedMemory != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.AssignedMemory))
		i--
		dAtA[i] = 0x20
	}
	if m.ReservedMemory != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.ReservedMemory))
		i--
		dAtA[i] = 0x18
	}
	if m.AvailableMemory != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.AvailableMemory))
		i--
		dAtA[i] = 0x10
	}
	if m.WorkingSetBytes != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.WorkingSetBytes))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ProcessorStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.TotalRuntimeNs != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.TotalRuntimeNs))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *PropertiesVMRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Types) > 0 {
		dAtA11 := make([]byte, len(m.Types)*10)
		var j10 int
		for _, num := range m.Types {
			for num >= 1<<7 {
				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j10++
			}
			dAtA11[j10] = uint8(num)
			j10++
		}
		i -= j10
		copy(dAtA[i:], dAtA11[:j10])
		i = encodeVarintVmservice(dAtA, i, uint64(j10))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PropertiesVMResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ProcessorStats != nil {
		{
			size, err := m.ProcessorStats.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.MemoryStats != nil {
		{
			size, err := m.MemoryStats.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CapabilitiesVMResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.SupportedGuestOs) > 0 {
		dAtA15 := make([]byte, len(m.SupportedGuestOs)*10)
		var j14 int
		for _, num := range m.SupportedGuestOs {
			for num >= 1<<7 {
				dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j14++
			}
			dAtA15[j14] = uint8(num)
			j14++
		}
		i -= j14
		copy(dAtA[i:], dAtA15[:j14])
		i = encodeVarintVmservice(dAtA, i, uint64(j14))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SupportedResources) > 0 {
		for iNdEx := len(m.SupportedResources) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SupportedResources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVmservice(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *CapabilitiesVMResponse_SupportedResource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Resource != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.Resource))
		i--
		dAtA[i] = 0x20
	}
	if m.Update {
		i--
		if m.Update {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Remove {
		i--
		if m.Remove {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Add {
		i--
		if m.Add {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *HVSocketListen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ListenerPath) > 0 {
		i -= len(m.ListenerPath)
		copy(dAtA[i:], m.ListenerPath)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.ListenerPath)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VSockListen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ListenerPath) > 0 {
		i -= len(m.ListenerPath)
		copy(dAtA[i:], m.ListenerPath)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.ListenerPath)))
		i--
		dAtA[i] = 0x12
	}
	if m.Port != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *VMSocketRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Config != nil {
		{
			size := m.Config.Size()
			i -= size
			if _, err := m.Config.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Type != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *VMSocketRequest_HvsocketList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.HvsocketList != nil {
		{
			size, err := m.HvsocketList.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *VMSocketRequest_VsockListen) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *SCSIDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ReadOnly {
		i--
		if m.ReadOnly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Type != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x20
	}
	if len(m.HostPath) > 0 {
		i -= len(m.HostPath)
		copy(dAtA[i:], m.HostPath)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.HostPath)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Lun != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.Lun))
		i--
		dAtA[i] = 0x10
	}
	if m.Controller != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.Controller))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *VPMEMDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ReadOnly {
		i--
		if m.ReadOnly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Type != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.HostPath) > 0 {
		i -= len(m.HostPath)
		copy(dAtA[i:], m.HostPath)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.HostPath)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NICConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.NicName) > 0 {
		i -= len(m.NicName)
		copy(dAtA[i:], m.NicName)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.NicName)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SwitchID) > 0 {
		i -= len(m.SwitchID)
		copy(dAtA[i:], m.SwitchID)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.SwitchID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.MacAddress) > 0 {
		i -= len(m.MacAddress)
		copy(dAtA[i:], m.MacAddress)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.MacAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.PortID) > 0 {
		i -= len(m.PortID)
		copy(dAtA[i:], m.PortID)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.PortID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.NicID) > 0 {
		i -= len(m.NicID)
		copy(dAtA[i:], m.NicID)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.NicID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *WindowsPCIDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.InstanceID) > 0 {
		i -= len(m.InstanceID)
		copy(dAtA[i:], m.InstanceID)
		i = encodeVarintVmservice(dAtA, i, uint64(len(m.InstanceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ModifyMemoryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.MemoryMb != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.MemoryMb))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ModifyProcessorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ProcessorIndex != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ModifyProcessorConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ProcessorLimit != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorLimit))
		i--
		dAtA[i] = 0x10
	}
	if m.ProcessorWeight != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.ProcessorWeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ModifyResourceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Resource != nil {
		{
			size := m.Resource.Size()
			i -= size
			if _, err := m.Resource.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Type != 0 {
		i = encodeVarintVmservice(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ModifyResourceRequest_Processor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Processor != nil {
		{
			size, err := m.Processor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *ModifyResourceRequest_ProcessorConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModifyResourceRequest_ProcessorConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ProcessorConfig != nil {
		{
			size, err := m.ProcessorConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *ModifyResourceRequest_Memory) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModifyResourceRequest_Memory) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Memory != nil {
		{
			size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *ModifyResourceRequest_ScsiDisk) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModifyResourceRequest_ScsiDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ScsiDisk != nil {
		{
			size, err := m.ScsiDisk.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *ModifyResourceRequest_VpmemDisk) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModifyResourceRequest_VpmemDisk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.VpmemDisk != nil {
		{
			size, err := m.VpmemDisk.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *ModifyResourceRequest_NicConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModifyResourceRequest_NicConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NicConfig != nil {
		{
			size, err := m.NicConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *ModifyResourceRequest_WindowsDevice) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ModifyResourceRequest_WindowsDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.WindowsDevice != nil {
		{
			size, err := m.WindowsDevice.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVmservice(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func encodeVarintVmservice(dAtA []byte, offset int, v uint64) int {
	offset -= sovVmservice(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *DirectBoot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.KernelPath)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	l = len(m.InitrdPath)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	l = len(m.KernelCmdline)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UEFI) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FirmwarePath)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	l = len(m.DevicePath)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	l = len(m.OptionalData)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MemoryConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MemoryMb != 0 {
		n += 1 + sovVmservice(uint64(m.MemoryMb))
	}
	if m.AllowOvercommit {
		n += 2
	}
	if m.DeferredCommit {
		n += 2
	}
	if m.HotHint {
		n += 2
	}
	if m.ColdHint {
		n += 2
	}
	if m.ColdDiscardHint {
		n += 2
	}
	if m.LowMmioGapInMb != 0 {
		n += 1 + sovVmservice(uint64(m.LowMmioGapInMb))
	}
	if m.HighMmioBaseInMb != 0 {
		n += 1 + sovVmservice(uint64(m.HighMmioBaseInMb))
	}
	if m.HighMmioGapInMb != 0 {
		n += 1 + sovVmservice(uint64(m.HighMmioGapInMb))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ProcessorConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProcessorCount != 0 {
		n += 1 + sovVmservice(uint64(m.ProcessorCount))
	}
	if m.ProcessorWeight != 0 {
		n += 1 + sovVmservice(uint64(m.ProcessorWeight))
	}
	if m.ProcessorLimit != 0 {
		n += 1 + sovVmservice(uint64(m.ProcessorLimit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DevicesConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ScsiDisks) > 0 {
		for _, e := range m.ScsiDisks {
			l = e.Size()
			n += 1 + l + sovVmservice(uint64(l))
		}
	}
	if len(m.VpmemDisks) > 0 {
		for _, e := range m.VpmemDisks {
			l = e.Size()
			n += 1 + l + sovVmservice(uint64(l))
		}
	}
	if len(m.NicConfig) > 0 {
		for _, e := range m.NicConfig {
			l = e.Size()
			n += 1 + l + sovVmservice(uint64(l))
		}
	}
	if len(m.WindowsDevice) > 0 {
		for _, e := range m.WindowsDevice {
			l = e.Size()
			n += 1 + l + sovVmservice(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *VMConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MemoryConfig != nil {
		l = m.MemoryConfig.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.ProcessorConfig != nil {
		l = m.ProcessorConfig.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.DevicesConfig != nil {
		l = m.DevicesConfig.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.SerialConfig != nil {
		l = m.SerialConfig.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.BootConfig != nil {
		n += m.BootConfig.Size()
	}
	if m.WindowsOptions != nil {
		l = m.WindowsOptions.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	if len(m.ExtraData) > 0 {
		for k, v := range m.ExtraData {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovVmservice(uint64(len(k))) + 1 + len(v) + sovVmservice(uint64(len(v)))
			n += mapEntrySize + 1 + sovVmservice(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *VMConfig_DirectBoot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DirectBoot != nil {
		l = m.DirectBoot.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}
func (m *VMConfig_Uefi) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uefi != nil {
		l = m.Uefi.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}
func (m *WindowsOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CpuGroupID != 0 {
		n += 1 + sovVmservice(uint64(m.CpuGroupID))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SerialConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ports) > 0 {
		for _, e := range m.Ports {
			l = e.Size()
			n += 1 + l + sovVmservice(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SerialConfig_Config) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Port != 0 {
		n += 1 + sovVmservice(uint64(m.Port))
	}
	l = len(m.SocketPath)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateVMRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	l = len(m.LogID)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *InspectVMRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Query)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.RecursionLimit != 0 {
		n += 1 + sovVmservice(uint64(m.RecursionLimit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *InspectVMResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MemoryStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.WorkingSetBytes != 0 {
		n += 1 + sovVmservice(uint64(m.WorkingSetBytes))
	}
	if m.AvailableMemory != 0 {
		n += 1 + sovVmservice(uint64(m.AvailableMemory))
	}
	if m.ReservedMemory != 0 {
		n += 1 + sovVmservice(uint64(m.ReservedMemory))
	}
	if m.AssignedMemory != 0 {
		n += 1 + sovVmservice(uint64(m.AssignedMemory))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ProcessorStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TotalRuntimeNs != 0 {
		n += 1 + sovVmservice(uint64(m.TotalRuntimeNs))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PropertiesVMRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Types) > 0 {
		l = 0
		for _, e := range m.Types {
			l += sovVmservice(uint64(e))
		}
		n += 1 + sovVmservice(uint64(l)) + l
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PropertiesVMResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MemoryStats != nil {
		l = m.MemoryStats.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.ProcessorStats != nil {
		l = m.ProcessorStats.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CapabilitiesVMResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SupportedResources) > 0 {
		for _, e := range m.SupportedResources {
			l = e.Size()
			n += 1 + l + sovVmservice(uint64(l))
		}
	}
	if len(m.SupportedGuestOs) > 0 {
		l = 0
		for _, e := range m.SupportedGuestOs {
			l += sovVmservice(uint64(e))
		}
		n += 1 + sovVmservice(uint64(l)) + l
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CapabilitiesVMResponse_SupportedResource) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Add {
		n += 2
	}
	if m.Remove {
		n += 2
	}
	if m.Update {
		n += 2
	}
	if m.Resource != 0 {
		n += 1 + sovVmservice(uint64(m.Resource))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HVSocketListen) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	l = len(m.ListenerPath)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *VSockListen) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Port != 0 {
		n += 1 + sovVmservice(uint64(m.Port))
	}
	l = len(m.ListenerPath)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *VMSocketRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovVmservice(uint64(m.Type))
	}
	if m.Config != nil {
		n += m.Config.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *VMSocketRequest_HvsocketList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HvsocketList != nil {
		l = m.HvsocketList.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}
func (m *VMSocketRequest_VsockListen) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VsockListen != nil {
		l = m.VsockListen.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}
func (m *SCSIDisk) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Controller != 0 {
		n += 1 + sovVmservice(uint64(m.Controller))
	}
	if m.Lun != 0 {
		n += 1 + sovVmservice(uint64(m.Lun))
	}
	l = len(m.HostPath)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovVmservice(uint64(m.Type))
	}
	if m.ReadOnly {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *VPMEMDisk) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.HostPath)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovVmservice(uint64(m.Type))
	}
	if m.ReadOnly {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NICConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NicID)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	l = len(m.PortID)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	l = len(m.MacAddress)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	l = len(m.SwitchID)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	l = len(m.NicName)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *WindowsPCIDevice) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.InstanceID)
	if l > 0 {
		n += 1 + l + sovVmservice(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModifyMemoryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MemoryMb != 0 {
		n += 1 + sovVmservice(uint64(m.MemoryMb))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModifyProcessorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProcessorIndex != 0 {
		n += 1 + sovVmservice(uint64(m.ProcessorIndex))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModifyProcessorConfigRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProcessorWeight != 0 {
		n += 1 + sovVmservice(uint64(m.ProcessorWeight))
	}
	if m.ProcessorLimit != 0 {
		n += 1 + sovVmservice(uint64(m.ProcessorLimit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModifyResourceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovVmservice(uint64(m.Type))
	}
	if m.Resource != nil {
		n += m.Resource.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModifyResourceRequest_Processor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Processor != nil {
		l = m.Processor.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}
func (m *ModifyResourceRequest_ProcessorConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProcessorConfig != nil {
		l = m.ProcessorConfig.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}
func (m *ModifyResourceRequest_Memory) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Memory != nil {
		l = m.Memory.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}
func (m *ModifyResourceRequest_ScsiDisk) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScsiDisk != nil {
		l = m.ScsiDisk.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}
func (m *ModifyResourceRequest_VpmemDisk) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VpmemDisk != nil {
		l = m.VpmemDisk.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}
func (m *ModifyResourceRequest_NicConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NicConfig != nil {
		l = m.NicConfig.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}
func (m *ModifyResourceRequest_WindowsDevice) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.WindowsDevice != nil {
		l = m.WindowsDevice.Size()
		n += 1 + l + sovVmservice(uint64(l))
	}
	return n
}

func sovVmservice(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozVmservice(x uint64) (n int) {
	return sovVmservice(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *DirectBoot) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DirectBoot{`,
		`KernelPath:` + fmt.Sprintf("%v", this.KernelPath) + `,`,
		`InitrdPath:` + fmt.Sprintf("%v", this.InitrdPath) + `,`,
		`KernelCmdline:` + fmt.Sprintf("%v", this.KernelCmdline) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UEFI) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UEFI{`,
		`FirmwarePath:` + fmt.Sprintf("%v", this.FirmwarePath) + `,`,
		`DevicePath:` + fmt.Sprintf("%v", this.DevicePath) + `,`,
		`OptionalData:` + fmt.Sprintf("%v", this.OptionalData) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MemoryConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MemoryConfig{`,
		`MemoryMb:` + fmt.Sprintf("%v", this.MemoryMb) + `,`,
		`AllowOvercommit:` + fmt.Sprintf("%v", this.AllowOvercommit) + `,`,
		`DeferredCommit:` + fmt.Sprintf("%v", this.DeferredCommit) + `,`,
		`HotHint:` + fmt.Sprintf("%v", this.HotHint) + `,`,
		`ColdHint:` + fmt.Sprintf("%v", this.ColdHint) + `,`,
		`ColdDiscardHint:` + fmt.Sprintf("%v", this.ColdDiscardHint) + `,`,
		`LowMmioGapInMb:` + fmt.Sprintf("%v", this.LowMmioGapInMb) + `,`,
		`HighMmioBaseInMb:` + fmt.Sprintf("%v", this.HighMmioBaseInMb) + `,`,
		`HighMmioGapInMb:` + fmt.Sprintf("%v", this.HighMmioGapInMb) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProcessorConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProcessorConfig{`,
		`ProcessorCount:` + fmt.Sprintf("%v", this.ProcessorCount) + `,`,
		`ProcessorWeight:` + fmt.Sprintf("%v", this.ProcessorWeight) + `,`,
		`ProcessorLimit:` + fmt.Sprintf("%v", this.ProcessorLimit) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DevicesConfig) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForScsiDisks := "[]*SCSIDisk{"
	for _, f := range this.ScsiDisks {
		repeatedStringForScsiDisks += strings.Replace(f.String(), "SCSIDisk", "SCSIDisk", 1) + ","
	}
	repeatedStringForScsiDisks += "}"
	repeatedStringForVpmemDisks := "[]*VPMEMDisk{"
	for _, f := range this.VpmemDisks {
		repeatedStringForVpmemDisks += strings.Replace(f.String(), "VPMEMDisk", "VPMEMDisk", 1) + ","
	}
	repeatedStringForVpmemDisks += "}"
	repeatedStringForNicConfig := "[]*NICConfig{"
	for _, f := range this.NicConfig {
		repeatedStringForNicConfig += strings.Replace(f.String(), "NICConfig", "NICConfig", 1) + ","
	}
	repeatedStringForNicConfig += "}"
	repeatedStringForWindowsDevice := "[]*WindowsPCIDevice{"
	for _, f := range this.WindowsDevice {
		repeatedStringForWindowsDevice += strings.Replace(f.String(), "WindowsPCIDevice", "WindowsPCIDevice", 1) + ","
	}
	repeatedStringForWindowsDevice += "}"
	s := strings.Join([]string{`&DevicesConfig{`,
		`ScsiDisks:` + repeatedStringForScsiDisks + `,`,
		`VpmemDisks:` + repeatedStringForVpmemDisks + `,`,
		`NicConfig:` + repeatedStringForNicConfig + `,`,
		`WindowsDevice:` + repeatedStringForWindowsDevice + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VMConfig) String() string {
	if this == nil {
		return "nil"
	}
	keysForExtraData := make([]string, 0, len(this.ExtraData))
	for k, _ := range this.ExtraData {
		keysForExtraData = append(keysForExtraData, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForExtraData)
	mapStringForExtraData := "map[string]string{"
	for _, k := range keysForExtraData {
		mapStringForExtraData += fmt.Sprintf("%v: %v,", k, this.ExtraData[k])
	}
	mapStringForExtraData += "}"
	s := strings.Join([]string{`&VMConfig{`,
		`MemoryConfig:` + strings.Replace(this.MemoryConfig.String(), "MemoryConfig", "MemoryConfig", 1) + `,`,
		`ProcessorConfig:` + strings.Replace(this.ProcessorConfig.String(), "ProcessorConfig", "ProcessorConfig", 1) + `,`,
		`DevicesConfig:` + strings.Replace(this.DevicesConfig.String(), "DevicesConfig", "DevicesConfig", 1) + `,`,
		`SerialConfig:` + strings.Replace(this.SerialConfig.String(), "SerialConfig", "SerialConfig", 1) + `,`,
		`BootConfig:` + fmt.Sprintf("%v", this.BootConfig) + `,`,
		`WindowsOptions:` + strings.Replace(this.WindowsOptions.String(), "WindowsOptions", "WindowsOptions", 1) + `,`,
		`ExtraData:` + mapStringForExtraData + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VMConfig_DirectBoot) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VMConfig_DirectBoot{`,
		`DirectBoot:` + strings.Replace(fmt.Sprintf("%v", this.DirectBoot), "DirectBoot", "DirectBoot", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VMConfig_Uefi) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VMConfig_Uefi{`,
		`Uefi:` + strings.Replace(fmt.Sprintf("%v", this.Uefi), "UEFI", "UEFI", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WindowsOptions) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&WindowsOptions{`,
		`CpuGroupID:` + fmt.Sprintf("%v", this.CpuGroupID) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SerialConfig) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForPorts := "[]*SerialConfig_Config{"
	for _, f := range this.Ports {
		repeatedStringForPorts += strings.Replace(fmt.Sprintf("%v", f), "SerialConfig_Config", "SerialConfig_Config", 1) + ","
	}
	repeatedStringForPorts += "}"
	s := strings.Join([]string{`&SerialConfig{`,
		`Ports:` + repeatedStringForPorts + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SerialConfig_Config) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SerialConfig_Config{`,
		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
		`SocketPath:` + fmt.Sprintf("%v", this.SocketPath) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CreateVMRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CreateVMRequest{`,
		`Config:` + strings.Replace(this.Config.String(), "VMConfig", "VMConfig", 1) + `,`,
		`LogID:` + fmt.Sprintf("%v", this.LogID) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *InspectVMRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&InspectVMRequest{`,
		`Query:` + fmt.Sprintf("%v", this.Query) + `,`,
		`RecursionLimit:` + fmt.Sprintf("%v", this.RecursionLimit) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *InspectVMResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&InspectVMResponse{`,
		`Result:` + strings.Replace(fmt.Sprintf("%v", this.Result), "Value", "types.Value", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MemoryStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MemoryStats{`,
		`WorkingSetBytes:` + fmt.Sprintf("%v", this.WorkingSetBytes) + `,`,
		`AvailableMemory:` + fmt.Sprintf("%v", this.AvailableMemory) + `,`,
		`ReservedMemory:` + fmt.Sprintf("%v", this.ReservedMemory) + `,`,
		`AssignedMemory:` + fmt.Sprintf("%v", this.AssignedMemory) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProcessorStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProcessorStats{`,
		`TotalRuntimeNs:` + fmt.Sprintf("%v", this.TotalRuntimeNs) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PropertiesVMRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PropertiesVMRequest{`,
		`Types:` + fmt.Sprintf("%v", this.Types) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PropertiesVMResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PropertiesVMResponse{`,
		`MemoryStats:` + strings.Replace(this.MemoryStats.String(), "MemoryStats", "MemoryStats", 1) + `,`,
		`ProcessorStats:` + strings.Replace(this.ProcessorStats.String(), "ProcessorStats", "ProcessorStats", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CapabilitiesVMResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSupportedResources := "[]*CapabilitiesVMResponse_SupportedResource{"
	for _, f := range this.SupportedResources {
		repeatedStringForSupportedResources += strings.Replace(fmt.Sprintf("%v", f), "CapabilitiesVMResponse_SupportedResource", "CapabilitiesVMResponse_SupportedResource", 1) + ","
	}
	repeatedStringForSupportedResources += "}"
	s := strings.Join([]string{`&CapabilitiesVMResponse{`,
		`SupportedResources:` + repeatedStringForSupportedResources + `,`,
		`SupportedGuestOs:` + fmt.Sprintf("%v", this.SupportedGuestOs) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CapabilitiesVMResponse_SupportedResource) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CapabilitiesVMResponse_SupportedResource{`,
		`Add:` + fmt.Sprintf("%v", this.Add) + `,`,
		`Remove:` + fmt.Sprintf("%v", this.Remove) + `,`,
		`Update:` + fmt.Sprintf("%v", this.Update) + `,`,
		`Resource:` + fmt.Sprintf("%v", this.Resource) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HVSocketListen) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HVSocketListen{`,
		`ServiceID:` + fmt.Sprintf("%v", this.ServiceID) + `,`,
		`ListenerPath:` + fmt.Sprintf("%v", this.ListenerPath) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VSockListen) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VSockListen{`,
		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
		`ListenerPath:` + fmt.Sprintf("%v", this.ListenerPath) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VMSocketRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VMSocketRequest{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Config:` + fmt.Sprintf("%v", this.Config) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VMSocketRequest_HvsocketList) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VMSocketRequest_HvsocketList{`,
		`HvsocketList:` + strings.Replace(fmt.Sprintf("%v", this.HvsocketList), "HVSocketListen", "HVSocketListen", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VMSocketRequest_VsockListen) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VMSocketRequest_VsockListen{`,
		`VsockListen:` + strings.Replace(fmt.Sprintf("%v", this.VsockListen), "VSockListen", "VSockListen", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SCSIDisk) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SCSIDisk{`,
		`Controller:` + fmt.Sprintf("%v", this.Controller) + `,`,
		`Lun:` + fmt.Sprintf("%v", this.Lun) + `,`,
		`HostPath:` + fmt.Sprintf("%v", this.HostPath) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VPMEMDisk) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VPMEMDisk{`,
		`HostPath:` + fmt.Sprintf("%v", this.HostPath) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NICConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NICConfig{`,
		`NicID:` + fmt.Sprintf("%v", this.NicID) + `,`,
		`PortID:` + fmt.Sprintf("%v", this.PortID) + `,`,
		`MacAddress:` + fmt.Sprintf("%v", this.MacAddress) + `,`,
		`SwitchID:` + fmt.Sprintf("%v", this.SwitchID) + `,`,
		`NicName:` + fmt.Sprintf("%v", this.NicName) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *WindowsPCIDevice) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&WindowsPCIDevice{`,
		`InstanceID:` + fmt.Sprintf("%v", this.InstanceID) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyMemoryRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyMemoryRequest{`,
		`MemoryMb:` + fmt.Sprintf("%v", this.MemoryMb) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyProcessorRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyProcessorRequest{`,
		`ProcessorIndex:` + fmt.Sprintf("%v", this.ProcessorIndex) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyProcessorConfigRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyProcessorConfigRequest{`,
		`ProcessorWeight:` + fmt.Sprintf("%v", this.ProcessorWeight) + `,`,
		`ProcessorLimit:` + fmt.Sprintf("%v", this.ProcessorLimit) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyResourceRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyResourceRequest{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Resource:` + fmt.Sprintf("%v", this.Resource) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyResourceRequest_Processor) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyResourceRequest_Processor{`,
		`Processor:` + strings.Replace(fmt.Sprintf("%v", this.Processor), "ModifyProcessorRequest", "ModifyProcessorRequest", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyResourceRequest_ProcessorConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyResourceRequest_ProcessorConfig{`,
		`ProcessorConfig:` + strings.Replace(fmt.Sprintf("%v", this.ProcessorConfig), "ModifyProcessorConfigRequest", "ModifyProcessorConfigRequest", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyResourceRequest_Memory) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyResourceRequest_Memory{`,
		`Memory:` + strings.Replace(fmt.Sprintf("%v", this.Memory), "ModifyMemoryRequest", "ModifyMemoryRequest", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyResourceRequest_ScsiDisk) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyResourceRequest_ScsiDisk{`,
		`ScsiDisk:` + strings.Replace(fmt.Sprintf("%v", this.ScsiDisk), "SCSIDisk", "SCSIDisk", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyResourceRequest_VpmemDisk) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyResourceRequest_VpmemDisk{`,
		`VpmemDisk:` + strings.Replace(fmt.Sprintf("%v", this.VpmemDisk), "VPMEMDisk", "VPMEMDisk", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyResourceRequest_NicConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyResourceRequest_NicConfig{`,
		`NicConfig:` + strings.Replace(fmt.Sprintf("%v", this.NicConfig), "NICConfig", "NICConfig", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ModifyResourceRequest_WindowsDevice) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ModifyResourceRequest_WindowsDevice{`,
		`WindowsDevice:` + strings.Replace(fmt.Sprintf("%v", this.WindowsDevice), "WindowsPCIDevice", "WindowsPCIDevice", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringVmservice(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}

type VMService interface {
	CreateVM(ctx context.Context, req *CreateVMRequest) (*types.Empty, error)
	TeardownVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
	PauseVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
	ResumeVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
	WaitVM(ctx context.Context, req *types.Empty) (*types.Empty, error)
	InspectVM(ctx context.Context, req *InspectVMRequest) (*InspectVMResponse, error)
	CapabilitiesVM(ctx context.Context, req *types.Empty) (*CapabilitiesVMResponse, error)
	PropertiesVM(ctx context.Context, req *PropertiesVMRequest) (*PropertiesVMResponse, error)
	ModifyResource(ctx context.Context, req *ModifyResourceRequest) (*types.Empty, error)
	VMSocket(ctx context.Context, req *VMSocketRequest) (*types.Empty, error)
	Quit(ctx context.Context, req *types.Empty) (*types.Empty, error)
}

func RegisterVMService(srv *github_com_containerd_ttrpc.Server, svc VMService) {
	srv.Register("vmservice.VM", map[string]github_com_containerd_ttrpc.Method{
		"CreateVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req CreateVMRequest
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.CreateVM(ctx, &req)
		},
		"TeardownVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req types.Empty
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.TeardownVM(ctx, &req)
		},
		"PauseVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req types.Empty
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.PauseVM(ctx, &req)
		},
		"ResumeVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req types.Empty
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.ResumeVM(ctx, &req)
		},
		"WaitVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req types.Empty
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.WaitVM(ctx, &req)
		},
		"InspectVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req InspectVMRequest
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.InspectVM(ctx, &req)
		},
		"CapabilitiesVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req types.Empty
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.CapabilitiesVM(ctx, &req)
		},
		"PropertiesVM": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req PropertiesVMRequest
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.PropertiesVM(ctx, &req)
		},
		"ModifyResource": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req ModifyResourceRequest
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.ModifyResource(ctx, &req)
		},
		"VMSocket": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req VMSocketRequest
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.VMSocket(ctx, &req)
		},
		"Quit": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req types.Empty
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.Quit(ctx, &req)
		},
	})
}

type vMClient struct {
	client *github_com_containerd_ttrpc.Client
}

func NewVMClient(client *github_com_containerd_ttrpc.Client) VMService {
	return &vMClient{
		client: client,
	}
}

func (c *vMClient) CreateVM(ctx context.Context, req *CreateVMRequest) (*types.Empty, error) {
	var resp types.Empty
	if err := c.client.Call(ctx, "vmservice.VM", "CreateVM", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *vMClient) TeardownVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
	var resp types.Empty
	if err := c.client.Call(ctx, "vmservice.VM", "TeardownVM", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *vMClient) PauseVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
	var resp types.Empty
	if err := c.client.Call(ctx, "vmservice.VM", "PauseVM", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *vMClient) ResumeVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
	var resp types.Empty
	if err := c.client.Call(ctx, "vmservice.VM", "ResumeVM", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *vMClient) WaitVM(ctx context.Context, req *types.Empty) (*types.Empty, error) {
	var resp types.Empty
	if err := c.client.Call(ctx, "vmservice.VM", "WaitVM", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *vMClient) InspectVM(ctx context.Context, req *InspectVMRequest) (*InspectVMResponse, error) {
	var resp InspectVMResponse
	if err := c.client.Call(ctx, "vmservice.VM", "InspectVM", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *vMClient) CapabilitiesVM(ctx context.Context, req *types.Empty) (*CapabilitiesVMResponse, error) {
	var resp CapabilitiesVMResponse
	if err := c.client.Call(ctx, "vmservice.VM", "CapabilitiesVM", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *vMClient) PropertiesVM(ctx context.Context, req *PropertiesVMRequest) (*PropertiesVMResponse, error) {
	var resp PropertiesVMResponse
	if err := c.client.Call(ctx, "vmservice.VM", "PropertiesVM", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *vMClient) ModifyResource(ctx context.Context, req *ModifyResourceRequest) (*types.Empty, error) {
	var resp types.Empty
	if err := c.client.Call(ctx, "vmservice.VM", "ModifyResource", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *vMClient) VMSocket(ctx context.Context, req *VMSocketRequest) (*types.Empty, error) {
	var resp types.Empty
	if err := c.client.Call(ctx, "vmservice.VM", "VMSocket", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *vMClient) Quit(ctx context.Context, req *types.Empty) (*types.Empty, error) {
	var resp types.Empty
	if err := c.client.Call(ctx, "vmservice.VM", "Quit", req, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}
func (m *DirectBoot) 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 ErrIntOverflowVmservice
			}
			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: DirectBoot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DirectBoot: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KernelPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KernelPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitrdPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InitrdPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KernelCmdline", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KernelCmdline = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MemoryConfig) 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 ErrIntOverflowVmservice
			}
			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: MemoryConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MemoryConfig: 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 ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MemoryMb |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowOvercommit", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllowOvercommit = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeferredCommit", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DeferredCommit = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HotHint", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HotHint = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColdHint", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ColdHint = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColdDiscardHint", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ColdDiscardHint = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LowMmioGapInMb", wireType)
			}
			m.LowMmioGapInMb = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LowMmioGapInMb |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HighMmioBaseInMb", wireType)
			}
			m.HighMmioBaseInMb = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HighMmioBaseInMb |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HighMmioGapInMb", wireType)
			}
			m.HighMmioGapInMb = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HighMmioGapInMb |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessorConfig) 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 ErrIntOverflowVmservice
			}
			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: ProcessorConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessorConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorCount", wireType)
			}
			m.ProcessorCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProcessorCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorWeight", wireType)
			}
			m.ProcessorWeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProcessorWeight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorLimit", wireType)
			}
			m.ProcessorLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProcessorLimit |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DevicesConfig) 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 ErrIntOverflowVmservice
			}
			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: DevicesConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DevicesConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScsiDisks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScsiDisks = append(m.ScsiDisks, &SCSIDisk{})
			if err := m.ScsiDisks[len(m.ScsiDisks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VpmemDisks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VpmemDisks = append(m.VpmemDisks, &VPMEMDisk{})
			if err := m.VpmemDisks[len(m.VpmemDisks)-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 NicConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NicConfig = append(m.NicConfig, &NICConfig{})
			if err := m.NicConfig[len(m.NicConfig)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WindowsDevice", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WindowsDevice = append(m.WindowsDevice, &WindowsPCIDevice{})
			if err := m.WindowsDevice[len(m.WindowsDevice)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VMConfig) 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 ErrIntOverflowVmservice
			}
			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: VMConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VMConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemoryConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MemoryConfig == nil {
				m.MemoryConfig = &MemoryConfig{}
			}
			if err := m.MemoryConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProcessorConfig == nil {
				m.ProcessorConfig = &ProcessorConfig{}
			}
			if err := m.ProcessorConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevicesConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DevicesConfig == nil {
				m.DevicesConfig = &DevicesConfig{}
			}
			if err := m.DevicesConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SerialConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SerialConfig == nil {
				m.SerialConfig = &SerialConfig{}
			}
			if err := m.SerialConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DirectBoot", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DirectBoot{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.BootConfig = &VMConfig_DirectBoot{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uefi", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UEFI{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.BootConfig = &VMConfig_Uefi{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WindowsOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.WindowsOptions == nil {
				m.WindowsOptions = &WindowsOptions{}
			}
			if err := m.WindowsOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExtraData == nil {
				m.ExtraData = 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 ErrIntOverflowVmservice
					}
					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 ErrIntOverflowVmservice
						}
						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 ErrInvalidLengthVmservice
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthVmservice
					}
					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 ErrIntOverflowVmservice
						}
						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 ErrInvalidLengthVmservice
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthVmservice
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipVmservice(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthVmservice
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ExtraData[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WindowsOptions) 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 ErrIntOverflowVmservice
			}
			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: WindowsOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WindowsOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuGroupID", wireType)
			}
			m.CpuGroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CpuGroupID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SerialConfig_Config) 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 ErrIntOverflowVmservice
			}
			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: Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SocketPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SocketPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InspectVMRequest) 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 ErrIntOverflowVmservice
			}
			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: InspectVMRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InspectVMRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Query = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecursionLimit", wireType)
			}
			m.RecursionLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RecursionLimit |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MemoryStats) 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 ErrIntOverflowVmservice
			}
			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: MemoryStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MemoryStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkingSetBytes", wireType)
			}
			m.WorkingSetBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WorkingSetBytes |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvailableMemory", wireType)
			}
			m.AvailableMemory = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AvailableMemory |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReservedMemory", wireType)
			}
			m.ReservedMemory = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReservedMemory |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AssignedMemory", wireType)
			}
			m.AssignedMemory = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AssignedMemory |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessorStats) 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 ErrIntOverflowVmservice
			}
			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: ProcessorStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessorStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalRuntimeNs", wireType)
			}
			m.TotalRuntimeNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalRuntimeNs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PropertiesVMRequest) 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 ErrIntOverflowVmservice
			}
			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: PropertiesVMRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PropertiesVMRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v PropertiesVMRequest_PropertiesType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVmservice
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= PropertiesVMRequest_PropertiesType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Types = append(m.Types, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVmservice
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthVmservice
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthVmservice
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Types) == 0 {
					m.Types = make([]PropertiesVMRequest_PropertiesType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v PropertiesVMRequest_PropertiesType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVmservice
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= PropertiesVMRequest_PropertiesType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Types = append(m.Types, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Types", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CapabilitiesVMResponse) 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 ErrIntOverflowVmservice
			}
			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: CapabilitiesVMResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CapabilitiesVMResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SupportedResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SupportedResources = append(m.SupportedResources, &CapabilitiesVMResponse_SupportedResource{})
			if err := m.SupportedResources[len(m.SupportedResources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v CapabilitiesVMResponse_SupportedGuestOS
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVmservice
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= CapabilitiesVMResponse_SupportedGuestOS(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.SupportedGuestOs = append(m.SupportedGuestOs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVmservice
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthVmservice
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthVmservice
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.SupportedGuestOs) == 0 {
					m.SupportedGuestOs = make([]CapabilitiesVMResponse_SupportedGuestOS, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v CapabilitiesVMResponse_SupportedGuestOS
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVmservice
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= CapabilitiesVMResponse_SupportedGuestOS(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.SupportedGuestOs = append(m.SupportedGuestOs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field SupportedGuestOs", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CapabilitiesVMResponse_SupportedResource) 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 ErrIntOverflowVmservice
			}
			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: SupportedResource: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SupportedResource: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Add", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Add = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Remove", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Remove = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Update", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Update = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
			}
			m.Resource = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Resource |= CapabilitiesVMResponse_Resource(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VSockListen) 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 ErrIntOverflowVmservice
			}
			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: VSockListen: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VSockListen: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListenerPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ListenerPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VMSocketRequest) 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 ErrIntOverflowVmservice
			}
			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: VMSocketRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VMSocketRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= ModifyType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HvsocketList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HVSocketListen{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Config = &VMSocketRequest_HvsocketList{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VsockListen", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &VSockListen{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Config = &VMSocketRequest_VsockListen{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SCSIDisk) 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 ErrIntOverflowVmservice
			}
			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: SCSIDisk: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SCSIDisk: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
			}
			m.Controller = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Controller |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lun", wireType)
			}
			m.Lun = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Lun |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= DiskType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ReadOnly = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VPMEMDisk) 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 ErrIntOverflowVmservice
			}
			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: VPMEMDisk: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VPMEMDisk: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= DiskType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ReadOnly = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NICConfig) 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 ErrIntOverflowVmservice
			}
			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: NICConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NICConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NicID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NicID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PortID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PortID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MacAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MacAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwitchID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SwitchID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NicName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				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 ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NicName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModifyMemoryRequest) 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 ErrIntOverflowVmservice
			}
			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: ModifyMemoryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModifyMemoryRequest: 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 ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MemoryMb |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModifyProcessorRequest) 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 ErrIntOverflowVmservice
			}
			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: ModifyProcessorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModifyProcessorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorIndex", wireType)
			}
			m.ProcessorIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProcessorIndex |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModifyProcessorConfigRequest) 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 ErrIntOverflowVmservice
			}
			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: ModifyProcessorConfigRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModifyProcessorConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorWeight", wireType)
			}
			m.ProcessorWeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProcessorWeight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorLimit", wireType)
			}
			m.ProcessorLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProcessorLimit |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ModifyResourceRequest) 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 ErrIntOverflowVmservice
			}
			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: ModifyResourceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModifyResourceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= ModifyType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Processor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ModifyProcessorRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Resource = &ModifyResourceRequest_Processor{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessorConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ModifyProcessorConfigRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Resource = &ModifyResourceRequest_ProcessorConfig{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ModifyMemoryRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Resource = &ModifyResourceRequest_Memory{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScsiDisk", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SCSIDisk{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Resource = &ModifyResourceRequest_ScsiDisk{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VpmemDisk", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &VPMEMDisk{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Resource = &ModifyResourceRequest_VpmemDisk{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NicConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NICConfig{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Resource = &ModifyResourceRequest_NicConfig{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WindowsDevice", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVmservice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVmservice
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVmservice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &WindowsPCIDevice{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Resource = &ModifyResourceRequest_WindowsDevice{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVmservice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVmservice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthVmservice        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowVmservice          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupVmservice = fmt.Errorf("proto: unexpected end of group")
)
