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

package proto

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	math "math"
)

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

// Message to store bundle/config.json bytes
type ExtraData struct {
	JsonSpec             []byte     `protobuf:"bytes,1,opt,name=JsonSpec,proto3" json:"JsonSpec,omitempty"`
	RuncOptions          *types.Any `protobuf:"bytes,2,opt,name=RuncOptions,proto3" json:"RuncOptions,omitempty"`
	StdinPort            uint32     `protobuf:"varint,3,opt,name=StdinPort,proto3" json:"StdinPort,omitempty"`
	StdoutPort           uint32     `protobuf:"varint,4,opt,name=StdoutPort,proto3" json:"StdoutPort,omitempty"`
	StderrPort           uint32     `protobuf:"varint,5,opt,name=StderrPort,proto3" json:"StderrPort,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ExtraData) Reset()         { *m = ExtraData{} }
func (m *ExtraData) String() string { return proto.CompactTextString(m) }
func (*ExtraData) ProtoMessage()    {}
func (*ExtraData) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{0}
}
func (m *ExtraData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExtraData.Unmarshal(m, b)
}
func (m *ExtraData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExtraData.Marshal(b, m, deterministic)
}
func (m *ExtraData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExtraData.Merge(m, src)
}
func (m *ExtraData) XXX_Size() int {
	return xxx_messageInfo_ExtraData.Size(m)
}
func (m *ExtraData) XXX_DiscardUnknown() {
	xxx_messageInfo_ExtraData.DiscardUnknown(m)
}

var xxx_messageInfo_ExtraData proto.InternalMessageInfo

func (m *ExtraData) GetJsonSpec() []byte {
	if m != nil {
		return m.JsonSpec
	}
	return nil
}

func (m *ExtraData) GetRuncOptions() *types.Any {
	if m != nil {
		return m.RuncOptions
	}
	return nil
}

func (m *ExtraData) GetStdinPort() uint32 {
	if m != nil {
		return m.StdinPort
	}
	return 0
}

func (m *ExtraData) GetStdoutPort() uint32 {
	if m != nil {
		return m.StdoutPort
	}
	return 0
}

func (m *ExtraData) GetStderrPort() uint32 {
	if m != nil {
		return m.StderrPort
	}
	return 0
}

// Message to specify network config for a Firecracker VM
type FirecrackerNetworkInterface struct {
	AllowMMDS      bool                    `protobuf:"varint,1,opt,name=AllowMMDS,proto3" json:"AllowMMDS,omitempty"`
	InRateLimiter  *FirecrackerRateLimiter `protobuf:"bytes,2,opt,name=InRateLimiter,proto3" json:"InRateLimiter,omitempty"`
	OutRateLimiter *FirecrackerRateLimiter `protobuf:"bytes,3,opt,name=OutRateLimiter,proto3" json:"OutRateLimiter,omitempty"`
	// CNIConfiguration specifies CNI configuration that will be used to generate
	// a network interface for a Firecracker VM.
	CNIConfig *CNIConfiguration `protobuf:"bytes,4,opt,name=CNIConfig,proto3" json:"CNIConfig,omitempty"`
	// StaticNetworkConfiguration specifies static configuration parameters for a
	// Firecracker VM's network interface
	StaticConfig         *StaticNetworkConfiguration `protobuf:"bytes,5,opt,name=StaticConfig,proto3" json:"StaticConfig,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *FirecrackerNetworkInterface) Reset()         { *m = FirecrackerNetworkInterface{} }
func (m *FirecrackerNetworkInterface) String() string { return proto.CompactTextString(m) }
func (*FirecrackerNetworkInterface) ProtoMessage()    {}
func (*FirecrackerNetworkInterface) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{1}
}
func (m *FirecrackerNetworkInterface) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirecrackerNetworkInterface.Unmarshal(m, b)
}
func (m *FirecrackerNetworkInterface) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirecrackerNetworkInterface.Marshal(b, m, deterministic)
}
func (m *FirecrackerNetworkInterface) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirecrackerNetworkInterface.Merge(m, src)
}
func (m *FirecrackerNetworkInterface) XXX_Size() int {
	return xxx_messageInfo_FirecrackerNetworkInterface.Size(m)
}
func (m *FirecrackerNetworkInterface) XXX_DiscardUnknown() {
	xxx_messageInfo_FirecrackerNetworkInterface.DiscardUnknown(m)
}

var xxx_messageInfo_FirecrackerNetworkInterface proto.InternalMessageInfo

func (m *FirecrackerNetworkInterface) GetAllowMMDS() bool {
	if m != nil {
		return m.AllowMMDS
	}
	return false
}

func (m *FirecrackerNetworkInterface) GetInRateLimiter() *FirecrackerRateLimiter {
	if m != nil {
		return m.InRateLimiter
	}
	return nil
}

func (m *FirecrackerNetworkInterface) GetOutRateLimiter() *FirecrackerRateLimiter {
	if m != nil {
		return m.OutRateLimiter
	}
	return nil
}

func (m *FirecrackerNetworkInterface) GetCNIConfig() *CNIConfiguration {
	if m != nil {
		return m.CNIConfig
	}
	return nil
}

func (m *FirecrackerNetworkInterface) GetStaticConfig() *StaticNetworkConfiguration {
	if m != nil {
		return m.StaticConfig
	}
	return nil
}

// Message to specify CNI configuration that will be used to
// generate a network interface for a Firecracker VM
type CNIConfiguration struct {
	// NetworkName is the name of a CNI network (as found in CNI
	// configuration files) that will be used to generate the
	// network interface.
	NetworkName string `protobuf:"bytes,1,opt,name=NetworkName,proto3" json:"NetworkName,omitempty"`
	// InterfaceName corresponds to the CNI_IFNAME parameter that will be
	// provided to CNI plugins during invocation.
	InterfaceName string `protobuf:"bytes,2,opt,name=InterfaceName,proto3" json:"InterfaceName,omitempty"`
	// BinPath is a list of directories that will be searched when
	// looking for CNI plugin binaries. Defaults to just "/opt/cni/bin"
	BinPath []string `protobuf:"bytes,3,rep,name=BinPath,proto3" json:"BinPath,omitempty"`
	// ConfDir is the directory in which CNI configuration will be sought.
	// If not specified, will default to "/etc/cni/conf.d".
	ConfDir string `protobuf:"bytes,4,opt,name=ConfDir,proto3" json:"ConfDir,omitempty"`
	// CacheDir is the directory in which CNI results will be temporarily
	// cached by the runtime. If not specified, it will default to
	// "/var/lib/cni"
	CacheDir string `protobuf:"bytes,5,opt,name=CacheDir,proto3" json:"CacheDir,omitempty"`
	// Args corresponds to the CNI_ARGS parameter that will be provided to
	// CNI plugins on invocation.
	Args                 []*CNIConfiguration_CNIArg `protobuf:"bytes,6,rep,name=Args,proto3" json:"Args,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *CNIConfiguration) Reset()         { *m = CNIConfiguration{} }
func (m *CNIConfiguration) String() string { return proto.CompactTextString(m) }
func (*CNIConfiguration) ProtoMessage()    {}
func (*CNIConfiguration) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{2}
}
func (m *CNIConfiguration) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CNIConfiguration.Unmarshal(m, b)
}
func (m *CNIConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CNIConfiguration.Marshal(b, m, deterministic)
}
func (m *CNIConfiguration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CNIConfiguration.Merge(m, src)
}
func (m *CNIConfiguration) XXX_Size() int {
	return xxx_messageInfo_CNIConfiguration.Size(m)
}
func (m *CNIConfiguration) XXX_DiscardUnknown() {
	xxx_messageInfo_CNIConfiguration.DiscardUnknown(m)
}

var xxx_messageInfo_CNIConfiguration proto.InternalMessageInfo

func (m *CNIConfiguration) GetNetworkName() string {
	if m != nil {
		return m.NetworkName
	}
	return ""
}

func (m *CNIConfiguration) GetInterfaceName() string {
	if m != nil {
		return m.InterfaceName
	}
	return ""
}

func (m *CNIConfiguration) GetBinPath() []string {
	if m != nil {
		return m.BinPath
	}
	return nil
}

func (m *CNIConfiguration) GetConfDir() string {
	if m != nil {
		return m.ConfDir
	}
	return ""
}

func (m *CNIConfiguration) GetCacheDir() string {
	if m != nil {
		return m.CacheDir
	}
	return ""
}

func (m *CNIConfiguration) GetArgs() []*CNIConfiguration_CNIArg {
	if m != nil {
		return m.Args
	}
	return nil
}

type CNIConfiguration_CNIArg struct {
	Key                  string   `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=Value,proto3" json:"Value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CNIConfiguration_CNIArg) Reset()         { *m = CNIConfiguration_CNIArg{} }
func (m *CNIConfiguration_CNIArg) String() string { return proto.CompactTextString(m) }
func (*CNIConfiguration_CNIArg) ProtoMessage()    {}
func (*CNIConfiguration_CNIArg) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{2, 0}
}
func (m *CNIConfiguration_CNIArg) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CNIConfiguration_CNIArg.Unmarshal(m, b)
}
func (m *CNIConfiguration_CNIArg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CNIConfiguration_CNIArg.Marshal(b, m, deterministic)
}
func (m *CNIConfiguration_CNIArg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CNIConfiguration_CNIArg.Merge(m, src)
}
func (m *CNIConfiguration_CNIArg) XXX_Size() int {
	return xxx_messageInfo_CNIConfiguration_CNIArg.Size(m)
}
func (m *CNIConfiguration_CNIArg) XXX_DiscardUnknown() {
	xxx_messageInfo_CNIConfiguration_CNIArg.DiscardUnknown(m)
}

var xxx_messageInfo_CNIConfiguration_CNIArg proto.InternalMessageInfo

func (m *CNIConfiguration_CNIArg) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *CNIConfiguration_CNIArg) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

// Message to specify static configuration parameters for a
// Firecracker VM's network interface
type StaticNetworkConfiguration struct {
	MacAddress  string `protobuf:"bytes,1,opt,name=MacAddress,proto3" json:"MacAddress,omitempty"`
	HostDevName string `protobuf:"bytes,2,opt,name=HostDevName,proto3" json:"HostDevName,omitempty"`
	// IPConfig optionally provides static IP configuration that will be configured
	// on the VM's internal networking interface. If not specified, no IP
	// configuration will be applied to the VM's internal nic automatically.
	IPConfig             *IPConfiguration `protobuf:"bytes,3,opt,name=IPConfig,proto3" json:"IPConfig,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *StaticNetworkConfiguration) Reset()         { *m = StaticNetworkConfiguration{} }
func (m *StaticNetworkConfiguration) String() string { return proto.CompactTextString(m) }
func (*StaticNetworkConfiguration) ProtoMessage()    {}
func (*StaticNetworkConfiguration) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{3}
}
func (m *StaticNetworkConfiguration) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StaticNetworkConfiguration.Unmarshal(m, b)
}
func (m *StaticNetworkConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StaticNetworkConfiguration.Marshal(b, m, deterministic)
}
func (m *StaticNetworkConfiguration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StaticNetworkConfiguration.Merge(m, src)
}
func (m *StaticNetworkConfiguration) XXX_Size() int {
	return xxx_messageInfo_StaticNetworkConfiguration.Size(m)
}
func (m *StaticNetworkConfiguration) XXX_DiscardUnknown() {
	xxx_messageInfo_StaticNetworkConfiguration.DiscardUnknown(m)
}

var xxx_messageInfo_StaticNetworkConfiguration proto.InternalMessageInfo

func (m *StaticNetworkConfiguration) GetMacAddress() string {
	if m != nil {
		return m.MacAddress
	}
	return ""
}

func (m *StaticNetworkConfiguration) GetHostDevName() string {
	if m != nil {
		return m.HostDevName
	}
	return ""
}

func (m *StaticNetworkConfiguration) GetIPConfig() *IPConfiguration {
	if m != nil {
		return m.IPConfig
	}
	return nil
}

// Message to specify static IP configuration that will be
// applied to a Firecracker VM's network interface internally
type IPConfiguration struct {
	// PrimaryAddr specifies, in CIDR notation, the primary address
	// and subnet that a network interface will be assigned inside
	// the VM.
	PrimaryAddr string `protobuf:"bytes,1,opt,name=PrimaryAddr,proto3" json:"PrimaryAddr,omitempty"`
	// GatewayAddr specifies the default gateway that a network interface
	// should use inside the VM.
	GatewayAddr string `protobuf:"bytes,3,opt,name=GatewayAddr,proto3" json:"GatewayAddr,omitempty"`
	// Nameservers is a list of nameservers that the VM will be configured
	// to use internally. Currently only up to 2 nameservers can be specified
	// (any more in the list will be ignored) and configuration is provided
	// to the VM via /proc/net/pnp.
	Nameservers          []string `protobuf:"bytes,4,rep,name=Nameservers,proto3" json:"Nameservers,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IPConfiguration) Reset()         { *m = IPConfiguration{} }
func (m *IPConfiguration) String() string { return proto.CompactTextString(m) }
func (*IPConfiguration) ProtoMessage()    {}
func (*IPConfiguration) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{4}
}
func (m *IPConfiguration) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IPConfiguration.Unmarshal(m, b)
}
func (m *IPConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IPConfiguration.Marshal(b, m, deterministic)
}
func (m *IPConfiguration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IPConfiguration.Merge(m, src)
}
func (m *IPConfiguration) XXX_Size() int {
	return xxx_messageInfo_IPConfiguration.Size(m)
}
func (m *IPConfiguration) XXX_DiscardUnknown() {
	xxx_messageInfo_IPConfiguration.DiscardUnknown(m)
}

var xxx_messageInfo_IPConfiguration proto.InternalMessageInfo

func (m *IPConfiguration) GetPrimaryAddr() string {
	if m != nil {
		return m.PrimaryAddr
	}
	return ""
}

func (m *IPConfiguration) GetGatewayAddr() string {
	if m != nil {
		return m.GatewayAddr
	}
	return ""
}

func (m *IPConfiguration) GetNameservers() []string {
	if m != nil {
		return m.Nameservers
	}
	return nil
}

// Message to set the machine config for a Firecracker VM
type FirecrackerMachineConfiguration struct {
	CPUTemplate string `protobuf:"bytes,1,opt,name=CPUTemplate,proto3" json:"CPUTemplate,omitempty"`
	HtEnabled   bool   `protobuf:"varint,2,opt,name=HtEnabled,proto3" json:"HtEnabled,omitempty"`
	// Specifies the memory size of VM
	// This lets us create a Firecracker VM of up to 4096 TiB, which
	// for a microVM should be large enough
	MemSizeMib           uint32   `protobuf:"varint,3,opt,name=MemSizeMib,proto3" json:"MemSizeMib,omitempty"`
	VcpuCount            uint32   `protobuf:"varint,4,opt,name=VcpuCount,proto3" json:"VcpuCount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FirecrackerMachineConfiguration) Reset()         { *m = FirecrackerMachineConfiguration{} }
func (m *FirecrackerMachineConfiguration) String() string { return proto.CompactTextString(m) }
func (*FirecrackerMachineConfiguration) ProtoMessage()    {}
func (*FirecrackerMachineConfiguration) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{5}
}
func (m *FirecrackerMachineConfiguration) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirecrackerMachineConfiguration.Unmarshal(m, b)
}
func (m *FirecrackerMachineConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirecrackerMachineConfiguration.Marshal(b, m, deterministic)
}
func (m *FirecrackerMachineConfiguration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirecrackerMachineConfiguration.Merge(m, src)
}
func (m *FirecrackerMachineConfiguration) XXX_Size() int {
	return xxx_messageInfo_FirecrackerMachineConfiguration.Size(m)
}
func (m *FirecrackerMachineConfiguration) XXX_DiscardUnknown() {
	xxx_messageInfo_FirecrackerMachineConfiguration.DiscardUnknown(m)
}

var xxx_messageInfo_FirecrackerMachineConfiguration proto.InternalMessageInfo

func (m *FirecrackerMachineConfiguration) GetCPUTemplate() string {
	if m != nil {
		return m.CPUTemplate
	}
	return ""
}

func (m *FirecrackerMachineConfiguration) GetHtEnabled() bool {
	if m != nil {
		return m.HtEnabled
	}
	return false
}

func (m *FirecrackerMachineConfiguration) GetMemSizeMib() uint32 {
	if m != nil {
		return m.MemSizeMib
	}
	return 0
}

func (m *FirecrackerMachineConfiguration) GetVcpuCount() uint32 {
	if m != nil {
		return m.VcpuCount
	}
	return 0
}

// Message to specify the block device config for a Firecracker VM
type FirecrackerRootDrive struct {
	// (Required) HostPath is the path on the host to the filesystem image or device
	// that will supply the rootfs of the VM.
	HostPath string `protobuf:"bytes,1,opt,name=HostPath,proto3" json:"HostPath,omitempty"`
	// (Optional) If the HostPath points to a drive or image with multiple
	// partitions, Partuuid specifies which partition will be used to boot
	// the VM
	Partuuid string `protobuf:"bytes,2,opt,name=Partuuid,proto3" json:"Partuuid,omitempty"`
	// (Optional) If set to true, IsWritable results in the VM Guest's rootfs
	// being mounted as read-write. Defaults to false, in which case the
	// rootfs is mounted as read-only.
	IsWritable bool `protobuf:"varint,3,opt,name=IsWritable,proto3" json:"IsWritable,omitempty"`
	// (Optional) RateLimiter configuration that will be applied to the
	// backing-drive for the VM's rootfs
	RateLimiter *FirecrackerRateLimiter `protobuf:"bytes,4,opt,name=RateLimiter,proto3" json:"RateLimiter,omitempty"`
	// (Optional) CacheType specifies the caching strategy for the block device.
	// The supported caching strategies are: "Unsafe"(default) and "Writeback".
	CacheType            string   `protobuf:"bytes,5,opt,name=CacheType,proto3" json:"CacheType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FirecrackerRootDrive) Reset()         { *m = FirecrackerRootDrive{} }
func (m *FirecrackerRootDrive) String() string { return proto.CompactTextString(m) }
func (*FirecrackerRootDrive) ProtoMessage()    {}
func (*FirecrackerRootDrive) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{6}
}
func (m *FirecrackerRootDrive) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirecrackerRootDrive.Unmarshal(m, b)
}
func (m *FirecrackerRootDrive) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirecrackerRootDrive.Marshal(b, m, deterministic)
}
func (m *FirecrackerRootDrive) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirecrackerRootDrive.Merge(m, src)
}
func (m *FirecrackerRootDrive) XXX_Size() int {
	return xxx_messageInfo_FirecrackerRootDrive.Size(m)
}
func (m *FirecrackerRootDrive) XXX_DiscardUnknown() {
	xxx_messageInfo_FirecrackerRootDrive.DiscardUnknown(m)
}

var xxx_messageInfo_FirecrackerRootDrive proto.InternalMessageInfo

func (m *FirecrackerRootDrive) GetHostPath() string {
	if m != nil {
		return m.HostPath
	}
	return ""
}

func (m *FirecrackerRootDrive) GetPartuuid() string {
	if m != nil {
		return m.Partuuid
	}
	return ""
}

func (m *FirecrackerRootDrive) GetIsWritable() bool {
	if m != nil {
		return m.IsWritable
	}
	return false
}

func (m *FirecrackerRootDrive) GetRateLimiter() *FirecrackerRateLimiter {
	if m != nil {
		return m.RateLimiter
	}
	return nil
}

func (m *FirecrackerRootDrive) GetCacheType() string {
	if m != nil {
		return m.CacheType
	}
	return ""
}

type FirecrackerDriveMount struct {
	// (Required) HostPath is the path on the host to the filesystem image or device
	// that will be mounted inside the VM.
	HostPath string `protobuf:"bytes,1,opt,name=HostPath,proto3" json:"HostPath,omitempty"`
	// (Required) VMPath is the path inside the VM guest at which the filesystem
	// image or device will be mounted.
	VMPath string `protobuf:"bytes,2,opt,name=VMPath,proto3" json:"VMPath,omitempty"`
	// (Required) FilesystemType is the filesystem type (i.e. ext4, xfs, etc.), as
	// used when mounting the filesystem image inside the VM. The VM guest kernel
	// is expected to have support for this filesystem.
	FilesystemType string `protobuf:"bytes,3,opt,name=FilesystemType,proto3" json:"FilesystemType,omitempty"`
	// (Optional) Options are fstab-style options that the mount will be performed
	// within the VM (i.e. ["rw", "noatime"]). Defaults to none if not specified.
	Options []string `protobuf:"bytes,4,rep,name=Options,proto3" json:"Options,omitempty"`
	// (Optional) RateLimiter configuration that will be applied to the
	// backing-drive for the VM's rootfs
	RateLimiter *FirecrackerRateLimiter `protobuf:"bytes,5,opt,name=RateLimiter,proto3" json:"RateLimiter,omitempty"`
	// (Optional) If set to true, IsWritable results in the backing file for the
	// drive being opened as read-write by the Firecracker VMM on the host, allowing
	// writes to the image from within the guest. Defaults to false, in which case
	// the block device in the VM will be read-only.
	IsWritable bool `protobuf:"varint,6,opt,name=IsWritable,proto3" json:"IsWritable,omitempty"`
	// (Optional) CacheType specifies the caching strategy for the block device.
	// The supported caching strategies are: "Unsafe"(default) and "Writeback".
	CacheType            string   `protobuf:"bytes,7,opt,name=CacheType,proto3" json:"CacheType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FirecrackerDriveMount) Reset()         { *m = FirecrackerDriveMount{} }
func (m *FirecrackerDriveMount) String() string { return proto.CompactTextString(m) }
func (*FirecrackerDriveMount) ProtoMessage()    {}
func (*FirecrackerDriveMount) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{7}
}
func (m *FirecrackerDriveMount) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirecrackerDriveMount.Unmarshal(m, b)
}
func (m *FirecrackerDriveMount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirecrackerDriveMount.Marshal(b, m, deterministic)
}
func (m *FirecrackerDriveMount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirecrackerDriveMount.Merge(m, src)
}
func (m *FirecrackerDriveMount) XXX_Size() int {
	return xxx_messageInfo_FirecrackerDriveMount.Size(m)
}
func (m *FirecrackerDriveMount) XXX_DiscardUnknown() {
	xxx_messageInfo_FirecrackerDriveMount.DiscardUnknown(m)
}

var xxx_messageInfo_FirecrackerDriveMount proto.InternalMessageInfo

func (m *FirecrackerDriveMount) GetHostPath() string {
	if m != nil {
		return m.HostPath
	}
	return ""
}

func (m *FirecrackerDriveMount) GetVMPath() string {
	if m != nil {
		return m.VMPath
	}
	return ""
}

func (m *FirecrackerDriveMount) GetFilesystemType() string {
	if m != nil {
		return m.FilesystemType
	}
	return ""
}

func (m *FirecrackerDriveMount) GetOptions() []string {
	if m != nil {
		return m.Options
	}
	return nil
}

func (m *FirecrackerDriveMount) GetRateLimiter() *FirecrackerRateLimiter {
	if m != nil {
		return m.RateLimiter
	}
	return nil
}

func (m *FirecrackerDriveMount) GetIsWritable() bool {
	if m != nil {
		return m.IsWritable
	}
	return false
}

func (m *FirecrackerDriveMount) GetCacheType() string {
	if m != nil {
		return m.CacheType
	}
	return ""
}

// Message to specify an IO rate limiter with bytes/s and ops/s limits
type FirecrackerRateLimiter struct {
	Bandwidth            *FirecrackerTokenBucket `protobuf:"bytes,1,opt,name=Bandwidth,proto3" json:"Bandwidth,omitempty"`
	Ops                  *FirecrackerTokenBucket `protobuf:"bytes,2,opt,name=Ops,proto3" json:"Ops,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *FirecrackerRateLimiter) Reset()         { *m = FirecrackerRateLimiter{} }
func (m *FirecrackerRateLimiter) String() string { return proto.CompactTextString(m) }
func (*FirecrackerRateLimiter) ProtoMessage()    {}
func (*FirecrackerRateLimiter) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{8}
}
func (m *FirecrackerRateLimiter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirecrackerRateLimiter.Unmarshal(m, b)
}
func (m *FirecrackerRateLimiter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirecrackerRateLimiter.Marshal(b, m, deterministic)
}
func (m *FirecrackerRateLimiter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirecrackerRateLimiter.Merge(m, src)
}
func (m *FirecrackerRateLimiter) XXX_Size() int {
	return xxx_messageInfo_FirecrackerRateLimiter.Size(m)
}
func (m *FirecrackerRateLimiter) XXX_DiscardUnknown() {
	xxx_messageInfo_FirecrackerRateLimiter.DiscardUnknown(m)
}

var xxx_messageInfo_FirecrackerRateLimiter proto.InternalMessageInfo

func (m *FirecrackerRateLimiter) GetBandwidth() *FirecrackerTokenBucket {
	if m != nil {
		return m.Bandwidth
	}
	return nil
}

func (m *FirecrackerRateLimiter) GetOps() *FirecrackerTokenBucket {
	if m != nil {
		return m.Ops
	}
	return nil
}

// Message to specify a token buicket used to rate limit disk and network IO for a Firecracker VM
type FirecrackerTokenBucket struct {
	OneTimeBurst         int64    `protobuf:"varint,1,opt,name=OneTimeBurst,proto3" json:"OneTimeBurst,omitempty"`
	RefillTime           int64    `protobuf:"varint,2,opt,name=RefillTime,proto3" json:"RefillTime,omitempty"`
	Capacity             int64    `protobuf:"varint,3,opt,name=Capacity,proto3" json:"Capacity,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FirecrackerTokenBucket) Reset()         { *m = FirecrackerTokenBucket{} }
func (m *FirecrackerTokenBucket) String() string { return proto.CompactTextString(m) }
func (*FirecrackerTokenBucket) ProtoMessage()    {}
func (*FirecrackerTokenBucket) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{9}
}
func (m *FirecrackerTokenBucket) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirecrackerTokenBucket.Unmarshal(m, b)
}
func (m *FirecrackerTokenBucket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirecrackerTokenBucket.Marshal(b, m, deterministic)
}
func (m *FirecrackerTokenBucket) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirecrackerTokenBucket.Merge(m, src)
}
func (m *FirecrackerTokenBucket) XXX_Size() int {
	return xxx_messageInfo_FirecrackerTokenBucket.Size(m)
}
func (m *FirecrackerTokenBucket) XXX_DiscardUnknown() {
	xxx_messageInfo_FirecrackerTokenBucket.DiscardUnknown(m)
}

var xxx_messageInfo_FirecrackerTokenBucket proto.InternalMessageInfo

func (m *FirecrackerTokenBucket) GetOneTimeBurst() int64 {
	if m != nil {
		return m.OneTimeBurst
	}
	return 0
}

func (m *FirecrackerTokenBucket) GetRefillTime() int64 {
	if m != nil {
		return m.RefillTime
	}
	return 0
}

func (m *FirecrackerTokenBucket) GetCapacity() int64 {
	if m != nil {
		return m.Capacity
	}
	return 0
}

type FirecrackerBalloonDevice struct {
	AmountMib             int64    `protobuf:"varint,1,opt,name=AmountMib,proto3" json:"AmountMib,omitempty"`
	DeflateOnOom          bool     `protobuf:"varint,2,opt,name=DeflateOnOom,proto3" json:"DeflateOnOom,omitempty"`
	StatsPollingIntervals int64    `protobuf:"varint,3,opt,name=StatsPollingIntervals,proto3" json:"StatsPollingIntervals,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

func (m *FirecrackerBalloonDevice) Reset()         { *m = FirecrackerBalloonDevice{} }
func (m *FirecrackerBalloonDevice) String() string { return proto.CompactTextString(m) }
func (*FirecrackerBalloonDevice) ProtoMessage()    {}
func (*FirecrackerBalloonDevice) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{10}
}
func (m *FirecrackerBalloonDevice) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FirecrackerBalloonDevice.Unmarshal(m, b)
}
func (m *FirecrackerBalloonDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FirecrackerBalloonDevice.Marshal(b, m, deterministic)
}
func (m *FirecrackerBalloonDevice) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FirecrackerBalloonDevice.Merge(m, src)
}
func (m *FirecrackerBalloonDevice) XXX_Size() int {
	return xxx_messageInfo_FirecrackerBalloonDevice.Size(m)
}
func (m *FirecrackerBalloonDevice) XXX_DiscardUnknown() {
	xxx_messageInfo_FirecrackerBalloonDevice.DiscardUnknown(m)
}

var xxx_messageInfo_FirecrackerBalloonDevice proto.InternalMessageInfo

func (m *FirecrackerBalloonDevice) GetAmountMib() int64 {
	if m != nil {
		return m.AmountMib
	}
	return 0
}

func (m *FirecrackerBalloonDevice) GetDeflateOnOom() bool {
	if m != nil {
		return m.DeflateOnOom
	}
	return false
}

func (m *FirecrackerBalloonDevice) GetStatsPollingIntervals() int64 {
	if m != nil {
		return m.StatsPollingIntervals
	}
	return 0
}

func init() {
	proto.RegisterType((*ExtraData)(nil), "ExtraData")
	proto.RegisterType((*FirecrackerNetworkInterface)(nil), "FirecrackerNetworkInterface")
	proto.RegisterType((*CNIConfiguration)(nil), "CNIConfiguration")
	proto.RegisterType((*CNIConfiguration_CNIArg)(nil), "CNIConfiguration.CNIArg")
	proto.RegisterType((*StaticNetworkConfiguration)(nil), "StaticNetworkConfiguration")
	proto.RegisterType((*IPConfiguration)(nil), "IPConfiguration")
	proto.RegisterType((*FirecrackerMachineConfiguration)(nil), "FirecrackerMachineConfiguration")
	proto.RegisterType((*FirecrackerRootDrive)(nil), "FirecrackerRootDrive")
	proto.RegisterType((*FirecrackerDriveMount)(nil), "FirecrackerDriveMount")
	proto.RegisterType((*FirecrackerRateLimiter)(nil), "FirecrackerRateLimiter")
	proto.RegisterType((*FirecrackerTokenBucket)(nil), "FirecrackerTokenBucket")
	proto.RegisterType((*FirecrackerBalloonDevice)(nil), "FirecrackerBalloonDevice")
}

func init() { proto.RegisterFile("types.proto", fileDescriptor_d938547f84707355) }

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