diff --git a/src/agent/protocols/protos/agent.proto b/src/agent/protocols/protos/agent.proto
index 6cbf5a28c..c29ef7ebc 100644
--- a/src/agent/protocols/protos/agent.proto
+++ b/src/agent/protocols/protos/agent.proto
@@ -66,6 +66,7 @@ service AgentService {
 	rpc SetGuestDateTime(SetGuestDateTimeRequest) returns (google.protobuf.Empty);
 	rpc CopyFile(CopyFileRequest) returns (google.protobuf.Empty);
 	rpc GetOOMEvent(GetOOMEventRequest) returns (OOMEvent);
+	rpc AddSwap(AddSwapRequest) returns (google.protobuf.Empty);
 }
 
 message CreateContainerRequest {
@@ -503,6 +504,10 @@ message OOMEvent {
 	string container_id = 1;
 }
 
+message AddSwapRequest {
+	repeated uint32 PCIPath = 1;
+}
+
 message GetMetricsRequest {}
 
 message Metrics {
diff --git a/src/agent/src/device.rs b/src/agent/src/device.rs
index 60a02147a..5fd85d4bb 100644
--- a/src/agent/src/device.rs
+++ b/src/agent/src/device.rs
@@ -62,7 +62,7 @@ pub fn online_device(path: &str) -> Result<()> {
 // the sysfs path for the PCI host bridge, based on the PCI path
 // provided.
 #[instrument]
-fn pcipath_to_sysfs(root_bus_sysfs: &str, pcipath: &pci::Path) -> Result<String> {
+pub fn pcipath_to_sysfs(root_bus_sysfs: &str, pcipath: &pci::Path) -> Result<String> {
     let mut bus = "0000:00".to_string();
     let mut relpath = String::new();
 
diff --git a/src/agent/src/rpc.rs b/src/agent/src/rpc.rs
index 518597f5c..ba08c8cf5 100644
--- a/src/agent/src/rpc.rs
+++ b/src/agent/src/rpc.rs
@@ -3,11 +3,14 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+use crate::pci;
 use async_trait::async_trait;
 use rustjail::{pipestream::PipeStream, process::StreamType};
 use tokio::io::{AsyncReadExt, AsyncWriteExt, ReadHalf};
 use tokio::sync::Mutex;
 
+use std::ffi::CString;
+use std::io;
 use std::path::Path;
 use std::sync::Arc;
 use ttrpc::{
@@ -20,8 +23,9 @@ use anyhow::{anyhow, Context, Result};
 use oci::{LinuxNamespace, Root, Spec};
 use protobuf::{RepeatedField, SingularPtrField};
 use protocols::agent::{
-    AgentDetails, CopyFileRequest, GuestDetailsResponse, Interfaces, Metrics, OOMEvent,
-    ReadStreamResponse, Routes, StatsContainerResponse, WaitProcessResponse, WriteStreamResponse,
+    AddSwapRequest, AgentDetails, CopyFileRequest, GuestDetailsResponse, Interfaces, Metrics,
+    OOMEvent, ReadStreamResponse, Routes, StatsContainerResponse, WaitProcessResponse,
+    WriteStreamResponse,
 };
 use protocols::empty::Empty;
 use protocols::health::{
@@ -40,7 +44,7 @@ use nix::sys::stat;
 use nix::unistd::{self, Pid};
 use rustjail::process::ProcessOperations;
 
-use crate::device::{add_devices, rescan_pci_bus, update_device_cgroup};
+use crate::device::{add_devices, pcipath_to_sysfs, rescan_pci_bus, update_device_cgroup};
 use crate::linux_abi::*;
 use crate::metrics::get_metrics;
 use crate::mount::{add_storages, remove_mounts, BareMount, STORAGE_HANDLER_LIST};
@@ -59,7 +63,7 @@ use tracing_opentelemetry::OpenTelemetrySpanExt;
 
 use tracing::instrument;
 
-use libc::{self, c_ushort, pid_t, winsize, TIOCSWINSZ};
+use libc::{self, c_char, c_ushort, pid_t, winsize, TIOCSWINSZ};
 use std::convert::TryFrom;
 use std::fs;
 use std::os::unix::prelude::PermissionsExt;
@@ -1192,6 +1196,18 @@ impl protocols::agent_ttrpc::AgentService for AgentService {
 
         Err(ttrpc_error(ttrpc::Code::INTERNAL, ""))
     }
+
+    async fn add_swap(
+        &self,
+        ctx: &TtrpcContext,
+        req: protocols::agent::AddSwapRequest,
+    ) -> ttrpc::Result<Empty> {
+        trace_rpc_call!(ctx, "add_swap", req);
+
+        do_add_swap(&req).map_err(|e| ttrpc_error(ttrpc::Code::INTERNAL, e.to_string()))?;
+
+        Ok(Empty::new())
+    }
 }
 
 #[derive(Clone)]
@@ -1541,6 +1557,56 @@ fn do_copy_file(req: &CopyFileRequest) -> Result<()> {
     Ok(())
 }
 
+pub fn path_name_lookup<P: std::clone::Clone + AsRef<Path> + std::fmt::Debug>(
+    path: P,
+    lookup: &str,
+) -> Result<(PathBuf, String)> {
+    for entry in fs::read_dir(path.clone())? {
+        let entry = entry?;
+        if let Some(name) = entry.path().file_name() {
+            if let Some(name) = name.to_str() {
+                if Some(0) == name.find(lookup) {
+                    return Ok((entry.path(), name.to_string()));
+                }
+            }
+        }
+    }
+    Err(anyhow!("cannot get {} dir in {:?}", lookup, path))
+}
+
+fn do_add_swap(req: &AddSwapRequest) -> Result<()> {
+    // re-scan PCI bus
+    // looking for hidden devices
+    rescan_pci_bus().context("Could not rescan PCI bus")?;
+
+    let mut slots = Vec::new();
+    for slot in &req.PCIPath {
+        slots.push(pci::Slot::new(*slot as u8)?);
+    }
+    let pcipath = pci::Path::new(slots)?;
+    let root_bus_sysfs = format!("{}{}", SYSFS_DIR, create_pci_root_bus_path());
+    let sysfs_rel_path = format!(
+        "{}{}",
+        root_bus_sysfs,
+        pcipath_to_sysfs(&root_bus_sysfs, &pcipath)?
+    );
+    let (mut virtio_path, _) = path_name_lookup(sysfs_rel_path, "virtio")?;
+    virtio_path.push("block");
+    let (_, dev_name) = path_name_lookup(virtio_path, "vd")?;
+    let dev_name = format!("/dev/{}", dev_name);
+
+    let c_str = CString::new(dev_name)?;
+    let ret = unsafe { libc::swapon(c_str.as_ptr() as *const c_char, 0) };
+    if ret != 0 {
+        return Err(anyhow!(
+            "libc::swapon get error {}",
+            io::Error::last_os_error()
+        ));
+    }
+
+    Ok(())
+}
+
 // Setup container bundle under CONTAINER_BASE, which is cleaned up
 // before removing a container.
 // - bundle path is /<CONTAINER_BASE>/<cid>/
diff --git a/src/runtime/cli/config/configuration-qemu.toml.in b/src/runtime/cli/config/configuration-qemu.toml.in
index 19fa2b3b6..2113a527e 100644
--- a/src/runtime/cli/config/configuration-qemu.toml.in
+++ b/src/runtime/cli/config/configuration-qemu.toml.in
@@ -356,6 +356,17 @@ valid_entropy_sources = @DEFVALIDENTROPYSOURCES@
 # See: https://www.qemu.org/docs/master/qemu-qmp-ref.html#Dump-guest-memory for details
 #guest_memory_dump_paging=false
 
+# Enable swap in the guest. Default false.
+# When enable_guest_swap is enabled, insert a raw file to the guest as the swap device
+# if the swappiness of a container (set by annotation "io.katacontainers.container.resource.swappiness")
+# is bigger than 0.
+# The size of the swap device should be 
+# swap_in_bytes (set by annotation "io.katacontainers.container.resource.swap_in_bytes") - memory_limit_in_bytes.
+# If swap_in_bytes is not set, the size should be memory_limit_in_bytes.
+# If swap_in_bytes and memory_limit_in_bytes is not set, the size should
+# be default_memory.
+#enable_guest_swap = true
+
 [factory]
 # VM templating support. Once enabled, new VMs are created from template
 # using vm cloning. They will share the same initial kernel, initramfs and
diff --git a/src/runtime/pkg/katautils/config-settings.go.in b/src/runtime/pkg/katautils/config-settings.go.in
index e92d8741c..6231ddd39 100644
--- a/src/runtime/pkg/katautils/config-settings.go.in
+++ b/src/runtime/pkg/katautils/config-settings.go.in
@@ -55,6 +55,7 @@ const defaultVhostUserStorePath string = "/var/run/kata-containers/vhost-user/"
 const defaultRxRateLimiterMaxRate = uint64(0)
 const defaultTxRateLimiterMaxRate = uint64(0)
 const defaultConfidentialGuest = false
+const defaultGuestSwap = false
 
 var defaultSGXEPCSize = int64(0)
 
diff --git a/src/runtime/pkg/katautils/config.go b/src/runtime/pkg/katautils/config.go
index fc9e5a013..41ff6c3bd 100644
--- a/src/runtime/pkg/katautils/config.go
+++ b/src/runtime/pkg/katautils/config.go
@@ -133,6 +133,7 @@ type hypervisor struct {
 	DisableVhostNet         bool     `toml:"disable_vhost_net"`
 	GuestMemoryDumpPaging   bool     `toml:"guest_memory_dump_paging"`
 	ConfidentialGuest       bool     `toml:"confidential_guest"`
+	GuestSwap               bool     `toml:"enable_guest_swap"`
 }
 
 type runtime struct {
@@ -711,6 +712,7 @@ func newQemuHypervisorConfig(h hypervisor) (vc.HypervisorConfig, error) {
 		GuestMemoryDumpPath:     h.GuestMemoryDumpPath,
 		GuestMemoryDumpPaging:   h.GuestMemoryDumpPaging,
 		ConfidentialGuest:       h.ConfidentialGuest,
+		GuestSwap:               h.GuestSwap,
 	}, nil
 }
 
@@ -1066,6 +1068,7 @@ func GetDefaultHypervisorConfig() vc.HypervisorConfig {
 		TxRateLimiterMaxRate:    defaultTxRateLimiterMaxRate,
 		SGXEPCSize:              defaultSGXEPCSize,
 		ConfidentialGuest:       defaultConfidentialGuest,
+		GuestSwap:               defaultGuestSwap,
 	}
 }
 
diff --git a/src/runtime/virtcontainers/acrn.go b/src/runtime/virtcontainers/acrn.go
index dd2d59954..07eb92c8c 100644
--- a/src/runtime/virtcontainers/acrn.go
+++ b/src/runtime/virtcontainers/acrn.go
@@ -517,6 +517,10 @@ func (a *Acrn) stopSandbox(ctx context.Context, waitOnly bool) (err error) {
 }
 
 func (a *Acrn) updateBlockDevice(drive *config.BlockDrive) error {
+	if drive.Swap {
+		return fmt.Errorf("Acrn doesn't support swap")
+	}
+
 	var err error
 	if drive.File == "" || drive.Index >= AcrnBlkDevPoolSz {
 		return fmt.Errorf("Empty filepath or invalid drive index, Dive ID:%s, Drive Index:%d",
diff --git a/src/runtime/virtcontainers/agent.go b/src/runtime/virtcontainers/agent.go
index 51fdf67dc..bf709b1ad 100644
--- a/src/runtime/virtcontainers/agent.go
+++ b/src/runtime/virtcontainers/agent.go
@@ -12,6 +12,7 @@ import (
 	persistapi "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/persist/api"
 	pbTypes "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/agent/protocols"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/agent/protocols/grpc"
+	vcTypes "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/types"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/types"
 	specs "github.com/opencontainers/runtime-spec/specs-go"
 	"golang.org/x/net/context"
@@ -189,6 +190,9 @@ type agent interface {
 	// copyFile copies file from host to container's rootfs
 	copyFile(ctx context.Context, src, dst string) error
 
+	// Tell the agent to setup the swapfile in the guest
+	addSwap(ctx context.Context, PCIPath vcTypes.PciPath) error
+
 	// markDead tell agent that the guest is dead
 	markDead(ctx context.Context)
 
diff --git a/src/runtime/virtcontainers/clh.go b/src/runtime/virtcontainers/clh.go
index 053d60b75..5cf2a5de9 100644
--- a/src/runtime/virtcontainers/clh.go
+++ b/src/runtime/virtcontainers/clh.go
@@ -416,6 +416,10 @@ func clhPciInfoToPath(pciInfo chclient.PciDeviceInfo) (vcTypes.PciPath, error) {
 }
 
 func (clh *cloudHypervisor) hotplugAddBlockDevice(drive *config.BlockDrive) error {
+	if drive.Swap {
+		return fmt.Errorf("cloudHypervisor doesn't support swap")
+	}
+
 	if clh.config.BlockDeviceDriver != config.VirtioBlock {
 		return fmt.Errorf("incorrect hypervisor configuration on 'block_device_driver':"+
 			" using '%v' but only support '%v'", clh.config.BlockDeviceDriver, config.VirtioBlock)
diff --git a/src/runtime/virtcontainers/container.go b/src/runtime/virtcontainers/container.go
index b98c4f7eb..6440bd7fb 100644
--- a/src/runtime/virtcontainers/container.go
+++ b/src/runtime/virtcontainers/container.go
@@ -13,6 +13,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strconv"
 	"syscall"
 	"time"
 
@@ -20,6 +21,7 @@ import (
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/device/config"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/device/manager"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/agent/protocols/grpc"
+	vcAnnotations "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/annotations"
 	vccgroups "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/cgroups"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/rootless"
 	vcTypes "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/types"
@@ -767,6 +769,26 @@ func newContainer(ctx context.Context, sandbox *Sandbox, contConfig *ContainerCo
 		ctx:           sandbox.ctx,
 	}
 
+	// Set the Annotations of SWAP to Resources
+	if resourceSwappinessStr, ok := c.config.Annotations[vcAnnotations.ContainerResourcesSwappiness]; ok {
+		resourceSwappiness, err := strconv.ParseUint(resourceSwappinessStr, 0, 64)
+		if err == nil && resourceSwappiness > 200 {
+			err = fmt.Errorf("swapiness should not bigger than 200")
+		}
+		if err != nil {
+			return &Container{}, fmt.Errorf("Invalid container configuration Annotations %s %v", vcAnnotations.ContainerResourcesSwappiness, err)
+		}
+		c.config.Resources.Memory.Swappiness = &resourceSwappiness
+	}
+	if resourceSwapInBytesStr, ok := c.config.Annotations[vcAnnotations.ContainerResourcesSwapInBytes]; ok {
+		resourceSwapInBytesInUint, err := strconv.ParseUint(resourceSwapInBytesStr, 0, 64)
+		if err != nil {
+			return &Container{}, fmt.Errorf("Invalid container configuration Annotations %s %v", vcAnnotations.ContainerResourcesSwapInBytes, err)
+		}
+		resourceSwapInBytes := int64(resourceSwapInBytesInUint)
+		c.config.Resources.Memory.Swap = &resourceSwapInBytes
+	}
+
 	// experimental runtime use "persist.json" instead of legacy "state.json" as storage
 	err := c.Restore()
 	if err == nil {
diff --git a/src/runtime/virtcontainers/device/config/config.go b/src/runtime/virtcontainers/device/config/config.go
index 5c866623d..8ad8c6266 100644
--- a/src/runtime/virtcontainers/device/config/config.go
+++ b/src/runtime/virtcontainers/device/config/config.go
@@ -182,6 +182,9 @@ type BlockDrive struct {
 	// Pmem enables persistent memory. Use File as backing file
 	// for a nvdimm device in the guest
 	Pmem bool
+
+	// This block device is for swap
+	Swap bool
 }
 
 // VFIODeviceType indicates VFIO device type
diff --git a/src/runtime/virtcontainers/fc.go b/src/runtime/virtcontainers/fc.go
index f7775117d..9b4ffa782 100644
--- a/src/runtime/virtcontainers/fc.go
+++ b/src/runtime/virtcontainers/fc.go
@@ -1036,6 +1036,10 @@ func (fc *firecracker) addDevice(ctx context.Context, devInfo interface{}, devTy
 // hotplugBlockDevice supported in Firecracker VMM
 // hot add or remove a block device.
 func (fc *firecracker) hotplugBlockDevice(ctx context.Context, drive config.BlockDrive, op operation) (interface{}, error) {
+	if drive.Swap {
+		return nil, fmt.Errorf("firecracker doesn't support swap")
+	}
+
 	var path string
 	var err error
 	driveID := fcDriveIndexToID(drive.Index)
diff --git a/src/runtime/virtcontainers/hypervisor.go b/src/runtime/virtcontainers/hypervisor.go
index 2c75d7f4a..525d77ceb 100644
--- a/src/runtime/virtcontainers/hypervisor.go
+++ b/src/runtime/virtcontainers/hypervisor.go
@@ -458,6 +458,9 @@ type HypervisorConfig struct {
 
 	// MemOffset specifies memory space for nvdimm device
 	MemOffset uint64
+
+	// GuestSwap Used to enable/disable swap in the guest
+	GuestSwap bool
 }
 
 // vcpu mapping from vcpu number to thread number
diff --git a/src/runtime/virtcontainers/kata_agent.go b/src/runtime/virtcontainers/kata_agent.go
index 2edb295f7..a8b62127a 100644
--- a/src/runtime/virtcontainers/kata_agent.go
+++ b/src/runtime/virtcontainers/kata_agent.go
@@ -143,6 +143,7 @@ const (
 	grpcStopTracingRequest       = "grpc.StopTracingRequest"
 	grpcGetOOMEventRequest       = "grpc.GetOOMEventRequest"
 	grpcGetMetricsRequest        = "grpc.GetMetricsRequest"
+	grpcAddSwapRequest           = "grpc.AddSwapRequest"
 )
 
 // newKataAgent returns an agent from an agent type.
@@ -2024,6 +2025,9 @@ func (k *kataAgent) installReqFunc(c *kataclient.AgentClient) {
 	k.reqHandlers[grpcGetMetricsRequest] = func(ctx context.Context, req interface{}) (interface{}, error) {
 		return k.client.AgentServiceClient.GetMetrics(ctx, req.(*grpc.GetMetricsRequest))
 	}
+	k.reqHandlers[grpcAddSwapRequest] = func(ctx context.Context, req interface{}) (interface{}, error) {
+		return k.client.AgentServiceClient.AddSwap(ctx, req.(*grpc.AddSwapRequest))
+	}
 }
 
 func (k *kataAgent) getReqContext(ctx context.Context, reqName string) (newCtx context.Context, cancel context.CancelFunc) {
@@ -2184,6 +2188,14 @@ func (k *kataAgent) copyFile(ctx context.Context, src, dst string) error {
 	return nil
 }
 
+func (k *kataAgent) addSwap(ctx context.Context, PCIPath vcTypes.PciPath) error {
+	span, ctx := katatrace.Trace(ctx, k.Logger(), "addSwap", kataAgentTracingTags)
+	defer span.End()
+
+	_, err := k.sendReq(ctx, &grpc.AddSwapRequest{PCIPath: PCIPath.ToArray()})
+	return err
+}
+
 func (k *kataAgent) markDead(ctx context.Context) {
 	k.Logger().Infof("mark agent dead")
 	k.dead = true
diff --git a/src/runtime/virtcontainers/mock_agent.go b/src/runtime/virtcontainers/mock_agent.go
index 17bd03d54..5be0b4a2f 100644
--- a/src/runtime/virtcontainers/mock_agent.go
+++ b/src/runtime/virtcontainers/mock_agent.go
@@ -12,6 +12,7 @@ import (
 	persistapi "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/persist/api"
 	pbTypes "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/agent/protocols"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/agent/protocols/grpc"
+	vcTypes "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/types"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/types"
 	specs "github.com/opencontainers/runtime-spec/specs-go"
 	"golang.org/x/net/context"
@@ -215,6 +216,11 @@ func (n *mockAgent) copyFile(ctx context.Context, src, dst string) error {
 	return nil
 }
 
+// addSwap is the Noop agent setup swap. It does nothing.
+func (n *mockAgent) addSwap(ctx context.Context, PCIPath vcTypes.PciPath) error {
+	return nil
+}
+
 func (n *mockAgent) markDead(ctx context.Context) {
 }
 
diff --git a/src/runtime/virtcontainers/pkg/agent/protocols/grpc/agent.pb.go b/src/runtime/virtcontainers/pkg/agent/protocols/grpc/agent.pb.go
index 417ed5760..2d60f94c7 100644
--- a/src/runtime/virtcontainers/pkg/agent/protocols/grpc/agent.pb.go
+++ b/src/runtime/virtcontainers/pkg/agent/protocols/grpc/agent.pb.go
@@ -35,7 +35,7 @@ type CreateContainerRequest struct {
 	StringUser  *StringUser `protobuf:"bytes,3,opt,name=string_user,json=stringUser,proto3" json:"string_user,omitempty"`
 	Devices     []*Device   `protobuf:"bytes,4,rep,name=devices,proto3" json:"devices,omitempty"`
 	Storages    []*Storage  `protobuf:"bytes,5,rep,name=storages,proto3" json:"storages,omitempty"`
-	OCI         *Spec       `protobuf:"bytes,6,opt,name=OCI,json=oCI,proto3" json:"OCI,omitempty"`
+	OCI         *Spec       `protobuf:"bytes,6,opt,name=OCI,proto3" json:"OCI,omitempty"`
 	// This field is used to indicate if the container needs to join
 	// sandbox shared pid ns or create a new namespace. This field is
 	// meant to override the NEWPID config settings in the OCI spec.
@@ -1372,7 +1372,7 @@ func (m *DestroySandboxRequest) XXX_DiscardUnknown() {
 var xxx_messageInfo_DestroySandboxRequest proto.InternalMessageInfo
 
 type Interfaces struct {
-	Interfaces           []*protocols.Interface `protobuf:"bytes,1,rep,name=Interfaces,json=interfaces,proto3" json:"Interfaces,omitempty"`
+	Interfaces           []*protocols.Interface `protobuf:"bytes,1,rep,name=Interfaces,proto3" json:"Interfaces,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
 	XXX_unrecognized     []byte                 `json:"-"`
 	XXX_sizecache        int32                  `json:"-"`
@@ -1411,7 +1411,7 @@ func (m *Interfaces) XXX_DiscardUnknown() {
 var xxx_messageInfo_Interfaces proto.InternalMessageInfo
 
 type Routes struct {
-	Routes               []*protocols.Route `protobuf:"bytes,1,rep,name=Routes,json=routes,proto3" json:"Routes,omitempty"`
+	Routes               []*protocols.Route `protobuf:"bytes,1,rep,name=Routes,proto3" json:"Routes,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
 	XXX_unrecognized     []byte             `json:"-"`
 	XXX_sizecache        int32              `json:"-"`
@@ -1604,7 +1604,7 @@ func (m *ListRoutesRequest) XXX_DiscardUnknown() {
 var xxx_messageInfo_ListRoutesRequest proto.InternalMessageInfo
 
 type ARPNeighbors struct {
-	ARPNeighbors         []*protocols.ARPNeighbor `protobuf:"bytes,1,rep,name=ARPNeighbors,json=aRPNeighbors,proto3" json:"ARPNeighbors,omitempty"`
+	ARPNeighbors         []*protocols.ARPNeighbor `protobuf:"bytes,1,rep,name=ARPNeighbors,proto3" json:"ARPNeighbors,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
 	XXX_unrecognized     []byte                   `json:"-"`
 	XXX_sizecache        int32                    `json:"-"`
@@ -1948,9 +1948,9 @@ var xxx_messageInfo_MemHotplugByProbeRequest proto.InternalMessageInfo
 
 type SetGuestDateTimeRequest struct {
 	// Sec the second since the Epoch.
-	Sec int64 `protobuf:"varint,1,opt,name=Sec,json=sec,proto3" json:"Sec,omitempty"`
+	Sec int64 `protobuf:"varint,1,opt,name=Sec,proto3" json:"Sec,omitempty"`
 	// Usec the microseconds portion of time since the Epoch.
-	Usec                 int64    `protobuf:"varint,2,opt,name=Usec,json=usec,proto3" json:"Usec,omitempty"`
+	Usec                 int64    `protobuf:"varint,2,opt,name=Usec,proto3" json:"Usec,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -2375,6 +2375,45 @@ func (m *OOMEvent) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_OOMEvent proto.InternalMessageInfo
 
+type AddSwapRequest struct {
+	PCIPath              []uint32 `protobuf:"varint,1,rep,packed,name=PCIPath,proto3" json:"PCIPath,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AddSwapRequest) Reset()      { *m = AddSwapRequest{} }
+func (*AddSwapRequest) ProtoMessage() {}
+func (*AddSwapRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_c1460208c38ccf5e, []int{55}
+}
+func (m *AddSwapRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *AddSwapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_AddSwapRequest.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 *AddSwapRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AddSwapRequest.Merge(m, src)
+}
+func (m *AddSwapRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *AddSwapRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_AddSwapRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AddSwapRequest proto.InternalMessageInfo
+
 type GetMetricsRequest struct {
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -2384,7 +2423,7 @@ type GetMetricsRequest struct {
 func (m *GetMetricsRequest) Reset()      { *m = GetMetricsRequest{} }
 func (*GetMetricsRequest) ProtoMessage() {}
 func (*GetMetricsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_c1460208c38ccf5e, []int{55}
+	return fileDescriptor_c1460208c38ccf5e, []int{56}
 }
 func (m *GetMetricsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2423,7 +2462,7 @@ type Metrics struct {
 func (m *Metrics) Reset()      { *m = Metrics{} }
 func (*Metrics) ProtoMessage() {}
 func (*Metrics) Descriptor() ([]byte, []int) {
-	return fileDescriptor_c1460208c38ccf5e, []int{56}
+	return fileDescriptor_c1460208c38ccf5e, []int{57}
 }
 func (m *Metrics) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2510,6 +2549,7 @@ func init() {
 	proto.RegisterType((*StopTracingRequest)(nil), "grpc.StopTracingRequest")
 	proto.RegisterType((*GetOOMEventRequest)(nil), "grpc.GetOOMEventRequest")
 	proto.RegisterType((*OOMEvent)(nil), "grpc.OOMEvent")
+	proto.RegisterType((*AddSwapRequest)(nil), "grpc.AddSwapRequest")
 	proto.RegisterType((*GetMetricsRequest)(nil), "grpc.GetMetricsRequest")
 	proto.RegisterType((*Metrics)(nil), "grpc.Metrics")
 }
@@ -2519,194 +2559,196 @@ func init() {
 }
 
 var fileDescriptor_c1460208c38ccf5e = []byte{
-	// 2982 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x1a, 0xcb, 0x6e, 0x1c, 0xc7,
-	0xd1, 0xfb, 0x20, 0x77, 0xb7, 0xf6, 0xc5, 0x1d, 0x52, 0xd4, 0x6a, 0x6d, 0x33, 0xf2, 0xc8, 0x96,
-	0xe5, 0x38, 0x5e, 0xd9, 0xb2, 0x11, 0xf9, 0x01, 0x47, 0x10, 0x29, 0x9a, 0xa4, 0x6d, 0x5a, 0xf4,
-	0x50, 0x82, 0x83, 0x04, 0xc9, 0x60, 0x38, 0xd3, 0xda, 0x6d, 0x73, 0x67, 0x7a, 0xdc, 0xdd, 0x43,
-	0x71, 0x1d, 0x20, 0x48, 0x2e, 0xc9, 0x2d, 0xc7, 0xdc, 0xf2, 0x03, 0x41, 0x6e, 0x39, 0xe6, 0x9a,
-	0x83, 0x91, 0x53, 0x8e, 0x39, 0x05, 0xb1, 0x3e, 0x21, 0x5f, 0x10, 0xf4, 0x6b, 0x1e, 0xfb, 0xa0,
-	0x13, 0x41, 0x40, 0x2e, 0x8b, 0xae, 0xea, 0xea, 0x7a, 0x75, 0x77, 0x75, 0x55, 0xcd, 0xc2, 0xe7,
-	0x23, 0xcc, 0xc7, 0xc9, 0xc9, 0xd0, 0x27, 0xe1, 0xcd, 0x53, 0x8f, 0x7b, 0x6f, 0xf8, 0x24, 0xe2,
-	0x1e, 0x8e, 0x10, 0x65, 0x73, 0x30, 0xa3, 0xfe, 0x4d, 0x6f, 0x84, 0x22, 0x7e, 0x33, 0xa6, 0x84,
-	0x13, 0x9f, 0x4c, 0x98, 0x1a, 0x31, 0x85, 0x1e, 0x4a, 0xc0, 0xaa, 0x8e, 0x68, 0xec, 0x0f, 0x1a,
-	0xc4, 0xc7, 0x0a, 0x31, 0x68, 0xf2, 0x69, 0x8c, 0x98, 0x06, 0x9e, 0x1f, 0x11, 0x32, 0x9a, 0x20,
-	0xb5, 0xf0, 0x24, 0x79, 0x74, 0x13, 0x85, 0x31, 0x9f, 0xaa, 0x49, 0xfb, 0x0f, 0x65, 0xd8, 0xdc,
-	0xa1, 0xc8, 0xe3, 0x68, 0xc7, 0x88, 0x75, 0xd0, 0x57, 0x09, 0x62, 0xdc, 0x7a, 0x09, 0x5a, 0xa9,
-	0x2a, 0x2e, 0x0e, 0xfa, 0xa5, 0xab, 0xa5, 0x1b, 0x0d, 0xa7, 0x99, 0xe2, 0x0e, 0x02, 0xeb, 0x32,
-	0xd4, 0xd0, 0x39, 0xf2, 0xc5, 0x6c, 0x59, 0xce, 0xae, 0x0a, 0xf0, 0x20, 0xb0, 0xde, 0x82, 0x26,
-	0xe3, 0x14, 0x47, 0x23, 0x37, 0x61, 0x88, 0xf6, 0x2b, 0x57, 0x4b, 0x37, 0x9a, 0xb7, 0xd6, 0x86,
-	0x42, 0xcf, 0xe1, 0xb1, 0x9c, 0x78, 0xc8, 0x10, 0x75, 0x80, 0xa5, 0x63, 0xeb, 0x3a, 0xd4, 0x02,
-	0x74, 0x86, 0x7d, 0xc4, 0xfa, 0xd5, 0xab, 0x95, 0x1b, 0xcd, 0x5b, 0x2d, 0x45, 0x7e, 0x4f, 0x22,
-	0x1d, 0x33, 0x69, 0xbd, 0x06, 0x75, 0xc6, 0x09, 0xf5, 0x46, 0x88, 0xf5, 0x57, 0x24, 0x61, 0xdb,
-	0xf0, 0x95, 0x58, 0x27, 0x9d, 0xb6, 0x5e, 0x80, 0xca, 0xfd, 0x9d, 0x83, 0xfe, 0xaa, 0x94, 0x0e,
-	0x9a, 0x2a, 0x46, 0xbe, 0x53, 0x21, 0x3b, 0x07, 0xd6, 0x35, 0x68, 0x33, 0x2f, 0x0a, 0x4e, 0xc8,
-	0xb9, 0x1b, 0xe3, 0x20, 0x62, 0xfd, 0xda, 0xd5, 0xd2, 0x8d, 0xba, 0xd3, 0xd2, 0xc8, 0x23, 0x81,
-	0xb3, 0xdf, 0x87, 0x4b, 0xc7, 0xdc, 0xa3, 0xfc, 0x29, 0xbc, 0x63, 0x3f, 0x84, 0x4d, 0x07, 0x85,
-	0xe4, 0xec, 0xa9, 0x5c, 0xdb, 0x87, 0x1a, 0xc7, 0x21, 0x22, 0x09, 0x97, 0xae, 0x6d, 0x3b, 0x06,
-	0xb4, 0xff, 0x54, 0x02, 0x6b, 0xf7, 0x1c, 0xf9, 0x47, 0x94, 0xf8, 0x88, 0xb1, 0xff, 0xd3, 0x76,
-	0xbd, 0x0a, 0xb5, 0x58, 0x29, 0xd0, 0xaf, 0x4a, 0x72, 0xbd, 0x0b, 0x46, 0x2b, 0x33, 0x6b, 0x7f,
-	0x09, 0x1b, 0xc7, 0x78, 0x14, 0x79, 0x93, 0x67, 0xa8, 0xef, 0x26, 0xac, 0x32, 0xc9, 0x53, 0xaa,
-	0xda, 0x76, 0x34, 0x64, 0x1f, 0x81, 0xf5, 0x85, 0x87, 0xf9, 0xb3, 0x93, 0x64, 0xbf, 0x01, 0xeb,
-	0x05, 0x8e, 0x2c, 0x26, 0x11, 0x43, 0x52, 0x01, 0xee, 0xf1, 0x84, 0x49, 0x66, 0x2b, 0x8e, 0x86,
-	0x6c, 0x02, 0x9b, 0x0f, 0xe3, 0xe0, 0x29, 0x6f, 0xd3, 0x2d, 0x68, 0x50, 0xc4, 0x48, 0x42, 0xc5,
-	0x1d, 0x28, 0x4b, 0xa7, 0x6e, 0x28, 0xa7, 0x7e, 0x8a, 0xa3, 0xe4, 0xdc, 0x31, 0x73, 0x4e, 0x46,
-	0xa6, 0xcf, 0x27, 0x67, 0x4f, 0x73, 0x3e, 0xdf, 0x87, 0x4b, 0x47, 0x5e, 0xc2, 0x9e, 0x46, 0x57,
-	0xfb, 0x03, 0x71, 0xb6, 0x59, 0x12, 0x3e, 0xd5, 0xe2, 0x3f, 0x96, 0xa0, 0xbe, 0x13, 0x27, 0x0f,
-	0x99, 0x37, 0x42, 0xd6, 0xf7, 0xa0, 0xc9, 0x09, 0xf7, 0x26, 0x6e, 0x22, 0x40, 0x49, 0x5e, 0x75,
-	0x40, 0xa2, 0x14, 0xc1, 0x4b, 0xd0, 0x8a, 0x11, 0xf5, 0xe3, 0x44, 0x53, 0x94, 0xaf, 0x56, 0x6e,
-	0x54, 0x9d, 0xa6, 0xc2, 0x29, 0x92, 0x21, 0xac, 0xcb, 0x39, 0x17, 0x47, 0xee, 0x29, 0xa2, 0x11,
-	0x9a, 0x84, 0x24, 0x40, 0xf2, 0x70, 0x54, 0x9d, 0x9e, 0x9c, 0x3a, 0x88, 0x3e, 0x49, 0x27, 0xac,
-	0xef, 0x43, 0x2f, 0xa5, 0x17, 0x27, 0x5e, 0x52, 0x57, 0x25, 0x75, 0x57, 0x53, 0x3f, 0xd4, 0x68,
-	0xfb, 0x97, 0xd0, 0x79, 0x30, 0xa6, 0x84, 0xf3, 0x09, 0x8e, 0x46, 0xf7, 0x3c, 0xee, 0x89, 0xab,
-	0x19, 0x23, 0x8a, 0x49, 0xc0, 0xb4, 0xb6, 0x06, 0xb4, 0x5e, 0x87, 0x1e, 0x57, 0xb4, 0x28, 0x70,
-	0x0d, 0x4d, 0x59, 0xd2, 0xac, 0xa5, 0x13, 0x47, 0x9a, 0xf8, 0x15, 0xe8, 0x64, 0xc4, 0xe2, 0x72,
-	0x6b, 0x7d, 0xdb, 0x29, 0xf6, 0x01, 0x0e, 0x91, 0x7d, 0x26, 0x7d, 0x25, 0x37, 0xd9, 0x7a, 0x1d,
-	0x1a, 0x99, 0x1f, 0x4a, 0xf2, 0x84, 0x74, 0xd4, 0x09, 0x31, 0xee, 0x74, 0xea, 0xa9, 0x53, 0x3e,
-	0x84, 0x2e, 0x4f, 0x15, 0x77, 0x03, 0x8f, 0x7b, 0xc5, 0x43, 0x55, 0xb4, 0xca, 0xe9, 0xf0, 0x02,
-	0x6c, 0x7f, 0x00, 0x8d, 0x23, 0x1c, 0x30, 0x25, 0xb8, 0x0f, 0x35, 0x3f, 0xa1, 0x14, 0x45, 0xdc,
-	0x98, 0xac, 0x41, 0x6b, 0x03, 0x56, 0x26, 0x38, 0xc4, 0x5c, 0x9b, 0xa9, 0x00, 0x9b, 0x00, 0x1c,
-	0xa2, 0x90, 0xd0, 0xa9, 0x74, 0xd8, 0x06, 0xac, 0xe4, 0x37, 0x57, 0x01, 0xd6, 0xf3, 0xd0, 0x08,
-	0xbd, 0xf3, 0x74, 0x53, 0xc5, 0x4c, 0x3d, 0xf4, 0xce, 0x95, 0xf2, 0x7d, 0xa8, 0x3d, 0xf2, 0xf0,
-	0xc4, 0x8f, 0xb8, 0xf6, 0x8a, 0x01, 0x33, 0x81, 0xd5, 0xbc, 0xc0, 0xbf, 0x96, 0xa1, 0xa9, 0x24,
-	0x2a, 0x85, 0x37, 0x60, 0xc5, 0xf7, 0xfc, 0x71, 0x2a, 0x52, 0x02, 0xd6, 0x75, 0xa3, 0x48, 0x39,
-	0x1f, 0xe1, 0x32, 0x4d, 0x8d, 0x6a, 0x37, 0x01, 0xd8, 0x63, 0x2f, 0xd6, 0xba, 0x55, 0x96, 0x10,
-	0x37, 0x04, 0x8d, 0x52, 0xf7, 0x6d, 0x68, 0xa9, 0x73, 0xa7, 0x97, 0x54, 0x97, 0x2c, 0x69, 0x2a,
-	0x2a, 0xb5, 0xe8, 0x1a, 0xb4, 0x13, 0x86, 0xdc, 0x31, 0x46, 0xd4, 0xa3, 0xfe, 0x78, 0xda, 0x5f,
-	0x51, 0x0f, 0x50, 0xc2, 0xd0, 0xbe, 0xc1, 0x59, 0xb7, 0x60, 0x45, 0xc4, 0x16, 0xd6, 0x5f, 0x95,
-	0x6f, 0xdd, 0x0b, 0x79, 0x96, 0xd2, 0xd4, 0xa1, 0xfc, 0xdd, 0x8d, 0x38, 0x9d, 0x3a, 0x8a, 0x74,
-	0xf0, 0x2e, 0x40, 0x86, 0xb4, 0xd6, 0xa0, 0x72, 0x8a, 0xa6, 0xfa, 0x1e, 0x8a, 0xa1, 0x70, 0xce,
-	0x99, 0x37, 0x49, 0x8c, 0xd7, 0x15, 0xf0, 0x7e, 0xf9, 0xdd, 0x92, 0xed, 0x43, 0x77, 0x7b, 0x72,
-	0x8a, 0x49, 0x6e, 0xf9, 0x06, 0xac, 0x84, 0xde, 0x97, 0x84, 0x1a, 0x4f, 0x4a, 0x40, 0x62, 0x71,
-	0x44, 0xa8, 0x61, 0x21, 0x01, 0xab, 0x03, 0x65, 0x12, 0x4b, 0x7f, 0x35, 0x9c, 0x32, 0x89, 0x33,
-	0x41, 0xd5, 0x9c, 0x20, 0xfb, 0x9f, 0x55, 0x80, 0x4c, 0x8a, 0xe5, 0xc0, 0x00, 0x13, 0x97, 0x21,
-	0x2a, 0xde, 0x77, 0xf7, 0x64, 0xca, 0x11, 0x73, 0x29, 0xf2, 0x13, 0xca, 0xf0, 0x99, 0xd8, 0x3f,
-	0x61, 0xf6, 0x25, 0x65, 0xf6, 0x8c, 0x6e, 0xce, 0x65, 0x4c, 0x8e, 0xd5, 0xba, 0x6d, 0xb1, 0xcc,
-	0x31, 0xab, 0xac, 0x03, 0xb8, 0x94, 0xf1, 0x0c, 0x72, 0xec, 0xca, 0x17, 0xb1, 0x5b, 0x4f, 0xd9,
-	0x05, 0x19, 0xab, 0x5d, 0x58, 0xc7, 0xc4, 0xfd, 0x2a, 0x41, 0x49, 0x81, 0x51, 0xe5, 0x22, 0x46,
-	0x3d, 0x4c, 0x3e, 0x97, 0x0b, 0x32, 0x36, 0x47, 0x70, 0x25, 0x67, 0xa5, 0xb8, 0xee, 0x39, 0x66,
-	0xd5, 0x8b, 0x98, 0x6d, 0xa6, 0x5a, 0x89, 0x78, 0x90, 0x71, 0xfc, 0x18, 0x36, 0x31, 0x71, 0x1f,
-	0x7b, 0x98, 0xcf, 0xb2, 0x5b, 0xf9, 0x0e, 0x23, 0xc5, 0x8b, 0x56, 0xe4, 0xa5, 0x8c, 0x0c, 0x11,
-	0x1d, 0x15, 0x8c, 0x5c, 0xfd, 0x0e, 0x23, 0x0f, 0xe5, 0x82, 0x8c, 0xcd, 0x5d, 0xe8, 0x61, 0x32,
-	0xab, 0x4d, 0xed, 0x22, 0x26, 0x5d, 0x4c, 0x8a, 0x9a, 0x6c, 0x43, 0x8f, 0x21, 0x9f, 0x13, 0x9a,
-	0x3f, 0x04, 0xf5, 0x8b, 0x58, 0xac, 0x69, 0xfa, 0x94, 0x87, 0xfd, 0x53, 0x68, 0xed, 0x27, 0x23,
-	0xc4, 0x27, 0x27, 0x69, 0x30, 0x78, 0x66, 0xf1, 0xc7, 0xfe, 0x77, 0x19, 0x9a, 0x3b, 0x23, 0x4a,
-	0x92, 0xb8, 0x10, 0x93, 0xd5, 0x25, 0x9d, 0x8d, 0xc9, 0x92, 0x44, 0xc6, 0x64, 0x45, 0xfc, 0x0e,
-	0xb4, 0x42, 0x79, 0x75, 0x35, 0xbd, 0x8a, 0x43, 0xbd, 0xb9, 0x4b, 0xed, 0x34, 0xc3, 0x5c, 0x30,
-	0x1b, 0x02, 0xc4, 0x38, 0x60, 0x7a, 0x8d, 0x0a, 0x47, 0x5d, 0x9d, 0x6e, 0x99, 0x10, 0xed, 0x34,
-	0xe2, 0x34, 0x5a, 0xbf, 0x05, 0xcd, 0x13, 0xe1, 0x24, 0xbd, 0xa0, 0x10, 0x8c, 0x32, 0xef, 0x39,
-	0x70, 0x92, 0x5d, 0xc2, 0x7d, 0x68, 0x8f, 0x95, 0xcb, 0xf4, 0x22, 0x75, 0x86, 0xae, 0x69, 0x4b,
-	0x32, 0x7b, 0x87, 0x79, 0xcf, 0xaa, 0x0d, 0x68, 0x8d, 0x73, 0xa8, 0xc1, 0x31, 0xf4, 0xe6, 0x48,
-	0x16, 0xc4, 0xa0, 0x1b, 0xf9, 0x18, 0xd4, 0xbc, 0x65, 0x29, 0x41, 0xf9, 0x95, 0xf9, 0xb8, 0xf4,
-	0xbb, 0x32, 0xb4, 0x3e, 0x43, 0xfc, 0x31, 0xa1, 0xa7, 0x4a, 0x5f, 0x0b, 0xaa, 0x91, 0x17, 0x22,
-	0xcd, 0x51, 0x8e, 0xad, 0x2b, 0x50, 0xa7, 0xe7, 0x2a, 0x80, 0xe8, 0xfd, 0xac, 0xd1, 0x73, 0x19,
-	0x18, 0xac, 0x17, 0x01, 0xe8, 0xb9, 0x1b, 0x7b, 0xfe, 0x29, 0xd2, 0x1e, 0xac, 0x3a, 0x0d, 0x7a,
-	0x7e, 0xa4, 0x10, 0xe2, 0x28, 0xd0, 0x73, 0x17, 0x51, 0x4a, 0x28, 0xd3, 0xb1, 0xaa, 0x4e, 0xcf,
-	0x77, 0x25, 0xac, 0xd7, 0x06, 0x94, 0xc4, 0x31, 0x0a, 0x64, 0x8c, 0x96, 0x6b, 0xef, 0x29, 0x84,
-	0x90, 0xca, 0x8d, 0xd4, 0x55, 0x25, 0x95, 0x67, 0x52, 0x79, 0x26, 0xb5, 0xa6, 0x56, 0xf2, 0xbc,
-	0x54, 0x9e, 0x4a, 0xad, 0x2b, 0xa9, 0x3c, 0x27, 0x95, 0x67, 0x52, 0x1b, 0x66, 0xad, 0x96, 0x6a,
-	0xff, 0xb6, 0x04, 0x9b, 0xb3, 0x89, 0x9f, 0xce, 0x4d, 0xdf, 0x81, 0x96, 0x2f, 0xf7, 0xab, 0x70,
-	0x26, 0x7b, 0x73, 0x3b, 0xe9, 0x34, 0xfd, 0xdc, 0x31, 0xbe, 0x0d, 0xed, 0x48, 0x39, 0x38, 0x3d,
-	0x9a, 0x95, 0x6c, 0x5f, 0xf2, 0xbe, 0x77, 0x5a, 0x51, 0x0e, 0xb2, 0x03, 0xb0, 0xbe, 0xa0, 0x98,
-	0xa3, 0x63, 0x4e, 0x91, 0x17, 0x3e, 0x8b, 0xec, 0xde, 0x82, 0xaa, 0xcc, 0x56, 0xc4, 0x36, 0xb5,
-	0x1c, 0x39, 0xb6, 0x5f, 0x85, 0xf5, 0x82, 0x14, 0x6d, 0xeb, 0x1a, 0x54, 0x26, 0x28, 0x92, 0xdc,
-	0xdb, 0x8e, 0x18, 0xda, 0x1e, 0xf4, 0x1c, 0xe4, 0x05, 0xcf, 0x4e, 0x1b, 0x2d, 0xa2, 0x92, 0x89,
-	0xb8, 0x01, 0x56, 0x5e, 0x84, 0x56, 0xc5, 0x68, 0x5d, 0xca, 0x69, 0x7d, 0x1f, 0x7a, 0x3b, 0x13,
-	0xc2, 0xd0, 0x31, 0x0f, 0x70, 0xf4, 0x2c, 0xca, 0x91, 0x5f, 0xc0, 0xfa, 0x03, 0x3e, 0xfd, 0x42,
-	0x30, 0x63, 0xf8, 0x6b, 0xf4, 0x8c, 0xec, 0xa3, 0xe4, 0xb1, 0xb1, 0x8f, 0x92, 0xc7, 0xa2, 0xb8,
-	0xf1, 0xc9, 0x24, 0x09, 0x23, 0x79, 0x15, 0xda, 0x8e, 0x86, 0xec, 0x6d, 0x68, 0xa9, 0x1c, 0xfa,
-	0x90, 0x04, 0xc9, 0x04, 0x2d, 0xbc, 0x83, 0x5b, 0x00, 0xb1, 0x47, 0xbd, 0x10, 0x71, 0x44, 0xd5,
-	0x19, 0x6a, 0x38, 0x39, 0x8c, 0xfd, 0xfb, 0x32, 0x6c, 0xa8, 0x7e, 0xc3, 0xb1, 0x2a, 0xb3, 0x8d,
-	0x09, 0x03, 0xa8, 0x8f, 0x09, 0xe3, 0x39, 0x86, 0x29, 0x2c, 0x54, 0x14, 0xf5, 0xb9, 0xe2, 0x26,
-	0x86, 0x85, 0x26, 0x40, 0xe5, 0xe2, 0x26, 0xc0, 0x5c, 0x99, 0x5f, 0x9d, 0x2f, 0xf3, 0xc5, 0x6d,
-	0x33, 0x44, 0x58, 0xdd, 0xf1, 0x86, 0xd3, 0xd0, 0x98, 0x83, 0xc0, 0xba, 0x0e, 0xdd, 0x91, 0xd0,
-	0xd2, 0x1d, 0x13, 0x72, 0xea, 0xc6, 0x1e, 0x1f, 0xcb, 0xab, 0xde, 0x70, 0xda, 0x12, 0xbd, 0x4f,
-	0xc8, 0xe9, 0x91, 0xc7, 0xc7, 0xd6, 0x7b, 0xd0, 0xd1, 0x69, 0x60, 0x28, 0x5d, 0xc4, 0xf4, 0xe3,
-	0xa7, 0x6f, 0x51, 0xde, 0x7b, 0x4e, 0xfb, 0x34, 0x07, 0x31, 0xfb, 0x32, 0x5c, 0xba, 0x87, 0x18,
-	0xa7, 0x64, 0x5a, 0x74, 0x8c, 0xfd, 0x23, 0x80, 0x83, 0x88, 0x23, 0xfa, 0xc8, 0xf3, 0x11, 0xb3,
-	0xde, 0xcc, 0x43, 0x3a, 0x39, 0x5a, 0x1b, 0xaa, 0x76, 0x4f, 0x3a, 0xe1, 0x00, 0x4e, 0x69, 0xec,
-	0x21, 0xac, 0x3a, 0x24, 0x11, 0xe1, 0xe8, 0x65, 0x33, 0xd2, 0xeb, 0x5a, 0x7a, 0x9d, 0x44, 0x3a,
-	0xab, 0x54, 0xce, 0xd9, 0xfb, 0xa6, 0x84, 0xcd, 0xd8, 0xe9, 0x2d, 0x1a, 0x42, 0x23, 0xe5, 0xab,
-	0xa3, 0xca, 0xbc, 0xe8, 0x8c, 0xc4, 0xfe, 0x00, 0xd6, 0x15, 0x27, 0x25, 0xd5, 0xb0, 0x79, 0x19,
-	0xb4, 0x28, 0xcd, 0x43, 0xf7, 0x79, 0x34, 0x91, 0x51, 0xe3, 0x32, 0x5c, 0xfa, 0x14, 0x33, 0x9e,
-	0x19, 0x6b, 0xfc, 0xb1, 0x0e, 0x3d, 0x31, 0x51, 0xe0, 0x69, 0x7f, 0x04, 0xad, 0xbb, 0xce, 0xd1,
-	0x67, 0x08, 0x8f, 0xc6, 0x27, 0x22, 0x7a, 0xfe, 0xb0, 0x08, 0x6b, 0x83, 0x2d, 0xad, 0x6d, 0x6e,
-	0xca, 0x69, 0x79, 0x39, 0x3a, 0xfb, 0x63, 0xd8, 0xbc, 0x1b, 0x04, 0xf9, 0xa5, 0x46, 0xeb, 0x37,
-	0xa1, 0x11, 0xe5, 0xd8, 0xe5, 0xde, 0xac, 0x02, 0x75, 0x46, 0x64, 0xff, 0x0c, 0xd6, 0xef, 0x47,
-	0x13, 0x1c, 0xa1, 0x9d, 0xa3, 0x87, 0x87, 0x28, 0x8d, 0x45, 0x16, 0x54, 0x45, 0xce, 0x26, 0x79,
-	0xd4, 0x1d, 0x39, 0x16, 0x97, 0x33, 0x3a, 0x71, 0xfd, 0x38, 0x61, 0xba, 0xd9, 0xb3, 0x1a, 0x9d,
-	0xec, 0xc4, 0x09, 0x13, 0x8f, 0x8b, 0x48, 0x2e, 0x48, 0x34, 0x99, 0xca, 0x1b, 0x5a, 0x77, 0x6a,
-	0x7e, 0x9c, 0xdc, 0x8f, 0x26, 0x53, 0xfb, 0x07, 0xb2, 0x02, 0x47, 0x28, 0x70, 0xbc, 0x28, 0x20,
-	0xe1, 0x3d, 0x74, 0x96, 0x93, 0x90, 0x56, 0x7b, 0x26, 0x12, 0x7d, 0x53, 0x82, 0xd6, 0xdd, 0x11,
-	0x8a, 0xf8, 0x3d, 0xc4, 0x3d, 0x3c, 0x91, 0x15, 0xdd, 0x19, 0xa2, 0x0c, 0x93, 0x48, 0x5f, 0x37,
-	0x03, 0x8a, 0x82, 0x1c, 0x47, 0x98, 0xbb, 0x81, 0x87, 0x42, 0x12, 0x49, 0x2e, 0x75, 0x71, 0xa2,
-	0x30, 0xbf, 0x27, 0x31, 0xd6, 0xab, 0xd0, 0x55, 0xcd, 0x38, 0x77, 0xec, 0x45, 0xc1, 0x44, 0x5c,
-	0xf4, 0x8a, 0xbc, 0x9a, 0x1d, 0x85, 0xde, 0xd7, 0x58, 0xeb, 0x35, 0x58, 0xd3, 0xd7, 0x30, 0xa3,
-	0xac, 0x4a, 0xca, 0xae, 0xc6, 0x17, 0x48, 0x93, 0x38, 0x26, 0x94, 0x33, 0x97, 0x21, 0xdf, 0x27,
-	0x61, 0xac, 0xcb, 0xa1, 0xae, 0xc1, 0x1f, 0x2b, 0xb4, 0x3d, 0x82, 0xf5, 0x3d, 0x61, 0xa7, 0xb6,
-	0x24, 0x3b, 0x56, 0x9d, 0x10, 0x85, 0xee, 0xc9, 0x84, 0xf8, 0xa7, 0xae, 0x08, 0x8e, 0xda, 0xc3,
-	0x22, 0xe1, 0xda, 0x16, 0xc8, 0x63, 0xfc, 0xb5, 0xac, 0xfc, 0x05, 0xd5, 0x98, 0xf0, 0x78, 0x92,
-	0x8c, 0xdc, 0x98, 0x92, 0x13, 0xa4, 0x4d, 0xec, 0x86, 0x28, 0xdc, 0x57, 0xf8, 0x23, 0x81, 0xb6,
-	0xff, 0x52, 0x82, 0x8d, 0xa2, 0x24, 0x1d, 0xea, 0x6f, 0xc2, 0x46, 0x51, 0x94, 0x7e, 0xfe, 0x55,
-	0x7a, 0xd9, 0xcb, 0x0b, 0x54, 0x89, 0xc0, 0x6d, 0x68, 0xcb, 0x7e, 0xad, 0x1b, 0x28, 0x4e, 0xc5,
-	0xa4, 0x27, 0xbf, 0x2f, 0x4e, 0xcb, 0xcb, 0xef, 0xd2, 0x7b, 0x70, 0x45, 0x9b, 0xef, 0xce, 0xab,
-	0xad, 0x0e, 0xc4, 0xa6, 0x26, 0x38, 0x9c, 0xd1, 0xfe, 0x53, 0xe8, 0x67, 0xa8, 0xed, 0xa9, 0x44,
-	0x66, 0x87, 0x79, 0x7d, 0xc6, 0xd8, 0xbb, 0x41, 0x40, 0xe5, 0x2d, 0xa9, 0x3a, 0x8b, 0xa6, 0xec,
-	0x3b, 0x70, 0xf9, 0x18, 0x71, 0xe5, 0x0d, 0x8f, 0xeb, 0x4a, 0x44, 0x31, 0x5b, 0x83, 0xca, 0x31,
-	0xf2, 0xa5, 0xf1, 0x15, 0xa7, 0xc2, 0x90, 0x2f, 0x0e, 0xe0, 0x43, 0x86, 0x7c, 0x69, 0x65, 0xc5,
-	0xa9, 0x26, 0x0c, 0xf9, 0xf6, 0x9f, 0x4b, 0x50, 0xd3, 0xc1, 0x59, 0x3c, 0x30, 0x01, 0xc5, 0x67,
-	0x88, 0xea, 0xa3, 0xa7, 0x21, 0xeb, 0x15, 0xe8, 0xa8, 0x91, 0x4b, 0x62, 0x8e, 0x49, 0x1a, 0xf2,
-	0xdb, 0x0a, 0x7b, 0x5f, 0x21, 0x65, 0xf3, 0x4d, 0xb6, 0xbf, 0x74, 0xa5, 0xa9, 0x21, 0x81, 0x7f,
-	0xc4, 0xc4, 0x0d, 0x97, 0x21, 0xbe, 0xe1, 0x68, 0x48, 0x1c, 0x75, 0xc3, 0x6f, 0x45, 0xf2, 0x33,
-	0xa0, 0x38, 0xea, 0x21, 0x49, 0x22, 0xee, 0xc6, 0x04, 0x47, 0x5c, 0xc7, 0x74, 0x90, 0xa8, 0x23,
-	0x81, 0xb1, 0x7f, 0x53, 0x82, 0x55, 0xd5, 0x80, 0x16, 0xb5, 0x6d, 0xfa, 0xb2, 0x96, 0xb1, 0xcc,
-	0x52, 0xa4, 0x2c, 0xf5, 0x9a, 0xca, 0xb1, 0xb8, 0xc7, 0x67, 0xa1, 0x7a, 0x1f, 0xb4, 0x6a, 0x67,
-	0xa1, 0x7c, 0x18, 0x5e, 0x81, 0x4e, 0xf6, 0x40, 0xcb, 0x79, 0xa5, 0x62, 0x3b, 0xc5, 0x4a, 0xb2,
-	0xa5, 0x9a, 0xda, 0x3f, 0x16, 0x25, 0x7d, 0xda, 0x7c, 0x5d, 0x83, 0x4a, 0x92, 0x2a, 0x23, 0x86,
-	0x02, 0x33, 0x4a, 0x9f, 0x76, 0x31, 0xb4, 0xae, 0x43, 0xc7, 0x0b, 0x02, 0x2c, 0x96, 0x7b, 0x93,
-	0x3d, 0x1c, 0xa4, 0x97, 0xb4, 0x88, 0xb5, 0xff, 0x56, 0x82, 0xee, 0x0e, 0x89, 0xa7, 0x1f, 0xe1,
-	0x09, 0xca, 0x45, 0x10, 0xa9, 0xa4, 0x7e, 0xd9, 0xc5, 0x58, 0x64, 0xab, 0x8f, 0xf0, 0x04, 0xa9,
-	0xab, 0xa5, 0x76, 0xb6, 0x2e, 0x10, 0xf2, 0x5a, 0x99, 0xc9, 0xb4, 0xed, 0xd6, 0x56, 0x93, 0x87,
-	0x24, 0x90, 0x79, 0x79, 0x80, 0xa9, 0x9b, 0x36, 0xd9, 0xda, 0x4e, 0x2d, 0xc0, 0x54, 0x4e, 0x69,
-	0x43, 0x56, 0x64, 0x13, 0x35, 0x6f, 0xc8, 0xaa, 0xc2, 0x08, 0x43, 0x36, 0x61, 0x95, 0x3c, 0x7a,
-	0xc4, 0x10, 0x97, 0x19, 0x74, 0xc5, 0xd1, 0x50, 0x1a, 0xe6, 0xea, 0xb9, 0x30, 0x77, 0x09, 0xd6,
-	0x65, 0xbb, 0xfe, 0x01, 0xf5, 0x7c, 0x1c, 0x8d, 0xcc, 0xf3, 0xb0, 0x01, 0xd6, 0x31, 0x27, 0xf1,
-	0x3c, 0x76, 0x0f, 0xf1, 0xfb, 0xf7, 0x0f, 0x77, 0xcf, 0x50, 0xc4, 0x0d, 0xf6, 0x0d, 0xa8, 0x1b,
-	0xd4, 0x7f, 0xd3, 0xcb, 0x5c, 0x87, 0xde, 0x1e, 0xe2, 0x87, 0x88, 0x53, 0xec, 0xa7, 0xcf, 0xd1,
-	0x35, 0xa8, 0x69, 0x8c, 0xd8, 0xd2, 0x50, 0x0d, 0x4d, 0x9c, 0xd5, 0xe0, 0xad, 0x5f, 0xf7, 0x74,
-	0x48, 0xd6, 0xd5, 0xbd, 0xb5, 0x07, 0xdd, 0x99, 0x4f, 0x31, 0x96, 0x6e, 0xf7, 0x2c, 0xfe, 0x42,
-	0x33, 0xd8, 0x1c, 0xaa, 0x4f, 0x3b, 0x43, 0xf3, 0x69, 0x67, 0xb8, 0x1b, 0xc6, 0x7c, 0x6a, 0xed,
-	0x42, 0xa7, 0xf8, 0xd1, 0xc2, 0x7a, 0xde, 0x64, 0x47, 0x0b, 0x3e, 0x65, 0x2c, 0x65, 0xb3, 0x07,
-	0xdd, 0x99, 0xef, 0x17, 0x46, 0x9f, 0xc5, 0x9f, 0x35, 0x96, 0x32, 0xba, 0x03, 0xcd, 0xdc, 0x07,
-	0x0b, 0xab, 0xaf, 0x98, 0xcc, 0x7f, 0xc3, 0x58, 0xca, 0x60, 0x07, 0xda, 0x85, 0x6f, 0x08, 0xd6,
-	0x40, 0xdb, 0xb3, 0xe0, 0xc3, 0xc2, 0x52, 0x26, 0xdb, 0xd0, 0xcc, 0xb5, 0xf2, 0x8d, 0x16, 0xf3,
-	0xdf, 0x0b, 0x06, 0x57, 0x16, 0xcc, 0xe8, 0xc8, 0xbf, 0x07, 0xdd, 0x99, 0xfe, 0xbe, 0x71, 0xc9,
-	0xe2, 0xb6, 0xff, 0x52, 0x65, 0x3e, 0x91, 0x5b, 0x94, 0x2b, 0xdf, 0x72, 0x5b, 0x34, 0xdf, 0xcd,
-	0x1f, 0xbc, 0xb0, 0x78, 0x52, 0x6b, 0xb5, 0x0b, 0x9d, 0x62, 0x23, 0xdf, 0x30, 0x5b, 0xd8, 0xde,
-	0xbf, 0x78, 0xbf, 0x0b, 0x3d, 0xfd, 0x6c, 0xbf, 0x17, 0xb5, 0xfa, 0x97, 0x32, 0xba, 0x0b, 0xa0,
-	0x8b, 0xb5, 0x00, 0x47, 0xa9, 0xa3, 0xe7, 0x8a, 0xc4, 0xd4, 0xd1, 0x0b, 0x0a, 0xbb, 0x3b, 0x00,
-	0xaa, 0xc6, 0x0a, 0x48, 0xc2, 0xad, 0xcb, 0x46, 0x8d, 0x99, 0xc2, 0x6e, 0xd0, 0x9f, 0x9f, 0x98,
-	0x63, 0x80, 0x28, 0x7d, 0x1a, 0x06, 0x1f, 0x02, 0x64, 0xb5, 0x9b, 0x61, 0x30, 0x57, 0xcd, 0x5d,
-	0xe0, 0x83, 0x56, 0xbe, 0x52, 0xb3, 0xb4, 0xad, 0x0b, 0xaa, 0xb7, 0x0b, 0x58, 0x74, 0x67, 0x32,
-	0xf1, 0xe2, 0x61, 0x9b, 0x4d, 0xd0, 0x07, 0x73, 0xd9, 0xb8, 0x75, 0x1b, 0x5a, 0xf9, 0x14, 0xdc,
-	0x68, 0xb1, 0x20, 0x2d, 0x1f, 0x14, 0xd2, 0x70, 0xeb, 0x0e, 0x74, 0x8a, 0xe9, 0xb7, 0x39, 0x52,
-	0x0b, 0x93, 0xf2, 0x81, 0x6e, 0x2e, 0xe5, 0xc8, 0xdf, 0x06, 0xc8, 0xd2, 0x74, 0xe3, 0xbe, 0xb9,
-	0xc4, 0x7d, 0x46, 0xea, 0x1e, 0x74, 0x67, 0xd2, 0x6f, 0x63, 0xf1, 0xe2, 0xac, 0xfc, 0x22, 0xef,
-	0xe7, 0xdf, 0x01, 0x63, 0xf7, 0x82, 0xb7, 0xe1, 0xa2, 0xa0, 0x95, 0x7b, 0x33, 0xcc, 0x29, 0x9e,
-	0x7f, 0x46, 0x96, 0x32, 0x78, 0x07, 0x20, 0x7b, 0x19, 0x8c, 0x07, 0xe6, 0xde, 0x8a, 0x41, 0xdb,
-	0x34, 0xff, 0x14, 0xdd, 0x0e, 0xb4, 0x0b, 0xf5, 0xb1, 0x09, 0x75, 0x8b, 0x8a, 0xe6, 0x8b, 0x1e,
-	0x80, 0x62, 0x31, 0x69, 0x76, 0x6f, 0x61, 0x89, 0x79, 0x91, 0x17, 0xf3, 0x15, 0x8c, 0xf1, 0xe2,
-	0x82, 0xaa, 0xe6, 0x3b, 0x62, 0x4a, 0xbe, 0x4a, 0xc9, 0xc5, 0x94, 0x05, 0xc5, 0xcb, 0x52, 0x46,
-	0xfb, 0xd0, 0xdd, 0x33, 0x09, 0xa8, 0x4e, 0x8e, 0xb5, 0x3a, 0x0b, 0x8a, 0x81, 0xc1, 0x60, 0xd1,
-	0x94, 0xbe, 0xd8, 0x9f, 0x40, 0x6f, 0x2e, 0x31, 0xb6, 0xb6, 0xd2, 0x16, 0xec, 0xc2, 0x8c, 0x79,
-	0xa9, 0x5a, 0x07, 0xb0, 0x36, 0x9b, 0x17, 0x5b, 0x2f, 0xea, 0xa3, 0xb2, 0x38, 0x5f, 0x5e, 0xca,
-	0xea, 0x3d, 0xa8, 0x9b, 0x3c, 0xcc, 0xd2, 0xad, 0xee, 0x99, 0xbc, 0x6c, 0xe9, 0xd2, 0xdb, 0xd0,
-	0xcc, 0x65, 0x32, 0xe6, 0xac, 0xce, 0x27, 0x37, 0x03, 0xdd, 0x99, 0x36, 0xe8, 0xed, 0xf3, 0x6f,
-	0xbe, 0xdd, 0x7a, 0xee, 0x1f, 0xdf, 0x6e, 0x3d, 0xf7, 0xab, 0x27, 0x5b, 0xa5, 0x6f, 0x9e, 0x6c,
-	0x95, 0xfe, 0xfe, 0x64, 0xab, 0xf4, 0xaf, 0x27, 0x5b, 0xa5, 0x9f, 0xfc, 0xfc, 0x7f, 0xfc, 0x9b,
-	0x0a, 0x4d, 0x22, 0x8e, 0x43, 0x74, 0xf3, 0x0c, 0x53, 0x9e, 0x9b, 0x8a, 0x4f, 0x47, 0x73, 0xff,
-	0x60, 0x11, 0x2a, 0x9c, 0xac, 0x4a, 0xf8, 0xed, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x22, 0x03,
-	0xd8, 0x19, 0x0f, 0x23, 0x00, 0x00,
+	// 3011 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x3a, 0x4b, 0x6f, 0x23, 0xc7,
+	0xd1, 0xe6, 0x43, 0x22, 0x59, 0x7c, 0x89, 0x23, 0xad, 0x96, 0x4b, 0xdb, 0xfa, 0xd6, 0xb3, 0xf6,
+	0x7a, 0x6d, 0x7f, 0xe6, 0xda, 0x6b, 0x23, 0xeb, 0x07, 0x9c, 0xc5, 0x4a, 0x2b, 0x4b, 0xb2, 0x2d,
+	0x2f, 0x3d, 0x5c, 0xc1, 0x41, 0x82, 0x64, 0x30, 0x9a, 0x69, 0x91, 0x6d, 0x71, 0xa6, 0xc7, 0x3d,
+	0x3d, 0x5a, 0xd1, 0x01, 0x82, 0x9c, 0x92, 0x5b, 0x8e, 0xb9, 0xe5, 0x0f, 0x04, 0xb9, 0xe5, 0x96,
+	0x5c, 0x73, 0x30, 0x72, 0xca, 0x31, 0xa7, 0x20, 0xde, 0x9f, 0x90, 0x5f, 0x10, 0xf4, 0x6b, 0x1e,
+	0x7c, 0xc8, 0x89, 0x20, 0x20, 0x17, 0x62, 0xaa, 0xba, 0xba, 0x5e, 0xdd, 0x55, 0x5d, 0xd5, 0x4d,
+	0xf8, 0x62, 0x84, 0xd9, 0x38, 0x3e, 0xee, 0xbb, 0xc4, 0xbf, 0x7b, 0xea, 0x30, 0xe7, 0x4d, 0x97,
+	0x04, 0xcc, 0xc1, 0x01, 0xa2, 0xd1, 0x1c, 0x1c, 0x51, 0xf7, 0xae, 0x33, 0x42, 0x01, 0xbb, 0x1b,
+	0x52, 0xc2, 0x88, 0x4b, 0x26, 0x91, 0xfc, 0x8a, 0x24, 0xba, 0x2f, 0x00, 0xa3, 0x3c, 0xa2, 0xa1,
+	0xdb, 0xab, 0x11, 0x17, 0x4b, 0x44, 0xaf, 0xce, 0xa6, 0x21, 0x8a, 0x14, 0xf0, 0xfc, 0x88, 0x90,
+	0xd1, 0x04, 0xc9, 0x89, 0xc7, 0xf1, 0xc9, 0x5d, 0xe4, 0x87, 0x6c, 0x2a, 0x07, 0xcd, 0xdf, 0x15,
+	0x61, 0x73, 0x87, 0x22, 0x87, 0xa1, 0x1d, 0x2d, 0xd6, 0x42, 0x5f, 0xc7, 0x28, 0x62, 0xc6, 0x4b,
+	0xd0, 0x48, 0x54, 0xb1, 0xb1, 0xd7, 0x2d, 0xdc, 0x2c, 0xdc, 0xa9, 0x59, 0xf5, 0x04, 0x77, 0xe0,
+	0x19, 0xd7, 0xa1, 0x82, 0xce, 0x91, 0xcb, 0x47, 0x8b, 0x62, 0x74, 0x95, 0x83, 0x07, 0x9e, 0xf1,
+	0x36, 0xd4, 0x23, 0x46, 0x71, 0x30, 0xb2, 0xe3, 0x08, 0xd1, 0x6e, 0xe9, 0x66, 0xe1, 0x4e, 0xfd,
+	0xde, 0x5a, 0x9f, 0xeb, 0xd9, 0x1f, 0x8a, 0x81, 0xa3, 0x08, 0x51, 0x0b, 0xa2, 0xe4, 0xdb, 0xb8,
+	0x0d, 0x15, 0x0f, 0x9d, 0x61, 0x17, 0x45, 0xdd, 0xf2, 0xcd, 0xd2, 0x9d, 0xfa, 0xbd, 0x86, 0x24,
+	0x7f, 0x24, 0x90, 0x96, 0x1e, 0x34, 0x5e, 0x83, 0x6a, 0xc4, 0x08, 0x75, 0x46, 0x28, 0xea, 0xae,
+	0x08, 0xc2, 0xa6, 0xe6, 0x2b, 0xb0, 0x56, 0x32, 0x6c, 0xbc, 0x00, 0xa5, 0xc7, 0x3b, 0x07, 0xdd,
+	0x55, 0x21, 0x1d, 0x14, 0x55, 0x88, 0x5c, 0x8b, 0xa3, 0x8d, 0x5b, 0xd0, 0x8c, 0x9c, 0xc0, 0x3b,
+	0x26, 0xe7, 0x76, 0x88, 0xbd, 0x20, 0xea, 0x56, 0x6e, 0x16, 0xee, 0x54, 0xad, 0x86, 0x42, 0x0e,
+	0x38, 0xce, 0xfc, 0x00, 0xae, 0x0d, 0x99, 0x43, 0xd9, 0x25, 0xbc, 0x63, 0x1e, 0xc1, 0xa6, 0x85,
+	0x7c, 0x72, 0x76, 0x29, 0xd7, 0x76, 0xa1, 0xc2, 0xb0, 0x8f, 0x48, 0xcc, 0x84, 0x6b, 0x9b, 0x96,
+	0x06, 0xcd, 0x3f, 0x14, 0xc0, 0xd8, 0x3d, 0x47, 0xee, 0x80, 0x12, 0x17, 0x45, 0xd1, 0xff, 0x68,
+	0xb9, 0x5e, 0x85, 0x4a, 0x28, 0x15, 0xe8, 0x96, 0x05, 0xb9, 0x5a, 0x05, 0xad, 0x95, 0x1e, 0x35,
+	0xbf, 0x82, 0x8d, 0x21, 0x1e, 0x05, 0xce, 0xe4, 0x0a, 0xf5, 0xdd, 0x84, 0xd5, 0x48, 0xf0, 0x14,
+	0xaa, 0x36, 0x2d, 0x05, 0x99, 0x03, 0x30, 0xbe, 0x74, 0x30, 0xbb, 0x3a, 0x49, 0xe6, 0x9b, 0xb0,
+	0x9e, 0xe3, 0x18, 0x85, 0x24, 0x88, 0x90, 0x50, 0x80, 0x39, 0x2c, 0x8e, 0x04, 0xb3, 0x15, 0x4b,
+	0x41, 0x26, 0x81, 0xcd, 0xa3, 0xd0, 0xbb, 0x64, 0x34, 0xdd, 0x83, 0x1a, 0x45, 0x11, 0x89, 0x29,
+	0x8f, 0x81, 0xa2, 0x70, 0xea, 0x86, 0x74, 0xea, 0x67, 0x38, 0x88, 0xcf, 0x2d, 0x3d, 0x66, 0xa5,
+	0x64, 0x6a, 0x7f, 0xb2, 0xe8, 0x32, 0xfb, 0xf3, 0x03, 0xb8, 0x36, 0x70, 0xe2, 0xe8, 0x32, 0xba,
+	0x9a, 0x1f, 0xf2, 0xbd, 0x1d, 0xc5, 0xfe, 0xa5, 0x26, 0xff, 0xbe, 0x00, 0xd5, 0x9d, 0x30, 0x3e,
+	0x8a, 0x9c, 0x11, 0x32, 0xfe, 0x0f, 0xea, 0x8c, 0x30, 0x67, 0x62, 0xc7, 0x1c, 0x14, 0xe4, 0x65,
+	0x0b, 0x04, 0x4a, 0x12, 0xbc, 0x04, 0x8d, 0x10, 0x51, 0x37, 0x8c, 0x15, 0x45, 0xf1, 0x66, 0xe9,
+	0x4e, 0xd9, 0xaa, 0x4b, 0x9c, 0x24, 0xe9, 0xc3, 0xba, 0x18, 0xb3, 0x71, 0x60, 0x9f, 0x22, 0x1a,
+	0xa0, 0x89, 0x4f, 0x3c, 0x24, 0x36, 0x47, 0xd9, 0xea, 0x88, 0xa1, 0x83, 0xe0, 0xd3, 0x64, 0xc0,
+	0x78, 0x1d, 0x3a, 0x09, 0x3d, 0xdf, 0xf1, 0x82, 0xba, 0x2c, 0xa8, 0xdb, 0x8a, 0xfa, 0x48, 0xa1,
+	0xcd, 0x5f, 0x40, 0xeb, 0xc9, 0x98, 0x12, 0xc6, 0x26, 0x38, 0x18, 0x3d, 0x72, 0x98, 0xc3, 0x43,
+	0x33, 0x44, 0x14, 0x13, 0x2f, 0x52, 0xda, 0x6a, 0xd0, 0x78, 0x03, 0x3a, 0x4c, 0xd2, 0x22, 0xcf,
+	0xd6, 0x34, 0x45, 0x41, 0xb3, 0x96, 0x0c, 0x0c, 0x14, 0xf1, 0x2b, 0xd0, 0x4a, 0x89, 0x79, 0x70,
+	0x2b, 0x7d, 0x9b, 0x09, 0xf6, 0x09, 0xf6, 0x91, 0x79, 0x26, 0x7c, 0x25, 0x16, 0xd9, 0x78, 0x03,
+	0x6a, 0xa9, 0x1f, 0x0a, 0x62, 0x87, 0xb4, 0xe4, 0x0e, 0xd1, 0xee, 0xb4, 0xaa, 0x89, 0x53, 0x3e,
+	0x82, 0x36, 0x4b, 0x14, 0xb7, 0x3d, 0x87, 0x39, 0xf9, 0x4d, 0x95, 0xb7, 0xca, 0x6a, 0xb1, 0x1c,
+	0x6c, 0x7e, 0x08, 0xb5, 0x01, 0xf6, 0x22, 0x29, 0xb8, 0x0b, 0x15, 0x37, 0xa6, 0x14, 0x05, 0x4c,
+	0x9b, 0xac, 0x40, 0x63, 0x03, 0x56, 0x26, 0xd8, 0xc7, 0x4c, 0x99, 0x29, 0x01, 0x93, 0x00, 0x1c,
+	0x22, 0x9f, 0xd0, 0xa9, 0x70, 0xd8, 0x06, 0xac, 0x64, 0x17, 0x57, 0x02, 0xc6, 0xf3, 0x50, 0xf3,
+	0x9d, 0xf3, 0x64, 0x51, 0xf9, 0x48, 0xd5, 0x77, 0xce, 0xa5, 0xf2, 0x5d, 0xa8, 0x9c, 0x38, 0x78,
+	0xe2, 0x06, 0x4c, 0x79, 0x45, 0x83, 0xa9, 0xc0, 0x72, 0x56, 0xe0, 0x5f, 0x8a, 0x50, 0x97, 0x12,
+	0xa5, 0xc2, 0x1b, 0xb0, 0xe2, 0x3a, 0xee, 0x38, 0x11, 0x29, 0x00, 0xe3, 0xb6, 0x56, 0xa4, 0x98,
+	0xcd, 0x70, 0xa9, 0xa6, 0x5a, 0xb5, 0xbb, 0x00, 0xd1, 0x53, 0x27, 0x54, 0xba, 0x95, 0x96, 0x10,
+	0xd7, 0x38, 0x8d, 0x54, 0xf7, 0x1d, 0x68, 0xc8, 0x7d, 0xa7, 0xa6, 0x94, 0x97, 0x4c, 0xa9, 0x4b,
+	0x2a, 0x39, 0xe9, 0x16, 0x34, 0xe3, 0x08, 0xd9, 0x63, 0x8c, 0xa8, 0x43, 0xdd, 0xf1, 0xb4, 0xbb,
+	0x22, 0x0f, 0xa0, 0x38, 0x42, 0xfb, 0x1a, 0x67, 0xdc, 0x83, 0x15, 0x9e, 0x5b, 0xa2, 0xee, 0xaa,
+	0x38, 0xeb, 0x5e, 0xc8, 0xb2, 0x14, 0xa6, 0xf6, 0xc5, 0xef, 0x6e, 0xc0, 0xe8, 0xd4, 0x92, 0xa4,
+	0xbd, 0xf7, 0x00, 0x52, 0xa4, 0xb1, 0x06, 0xa5, 0x53, 0x34, 0x55, 0x71, 0xc8, 0x3f, 0xb9, 0x73,
+	0xce, 0x9c, 0x49, 0xac, 0xbd, 0x2e, 0x81, 0x0f, 0x8a, 0xef, 0x15, 0x4c, 0x17, 0xda, 0xdb, 0x93,
+	0x53, 0x4c, 0x32, 0xd3, 0x37, 0x60, 0xc5, 0x77, 0xbe, 0x22, 0x54, 0x7b, 0x52, 0x00, 0x02, 0x8b,
+	0x03, 0x42, 0x35, 0x0b, 0x01, 0x18, 0x2d, 0x28, 0x92, 0x50, 0xf8, 0xab, 0x66, 0x15, 0x49, 0x98,
+	0x0a, 0x2a, 0x67, 0x04, 0x99, 0xff, 0x28, 0x03, 0xa4, 0x52, 0x0c, 0x0b, 0x7a, 0x98, 0xd8, 0x11,
+	0xa2, 0xfc, 0x7c, 0xb7, 0x8f, 0xa7, 0x0c, 0x45, 0x36, 0x45, 0x6e, 0x4c, 0x23, 0x7c, 0xc6, 0xd7,
+	0x8f, 0x9b, 0x7d, 0x4d, 0x9a, 0x3d, 0xa3, 0x9b, 0x75, 0x1d, 0x93, 0xa1, 0x9c, 0xb7, 0xcd, 0xa7,
+	0x59, 0x7a, 0x96, 0x71, 0x00, 0xd7, 0x52, 0x9e, 0x5e, 0x86, 0x5d, 0xf1, 0x22, 0x76, 0xeb, 0x09,
+	0x3b, 0x2f, 0x65, 0xb5, 0x0b, 0xeb, 0x98, 0xd8, 0x5f, 0xc7, 0x28, 0xce, 0x31, 0x2a, 0x5d, 0xc4,
+	0xa8, 0x83, 0xc9, 0x17, 0x62, 0x42, 0xca, 0x66, 0x00, 0x37, 0x32, 0x56, 0xf2, 0x70, 0xcf, 0x30,
+	0x2b, 0x5f, 0xc4, 0x6c, 0x33, 0xd1, 0x8a, 0xe7, 0x83, 0x94, 0xe3, 0x27, 0xb0, 0x89, 0x89, 0xfd,
+	0xd4, 0xc1, 0x6c, 0x96, 0xdd, 0xca, 0xf7, 0x18, 0xc9, 0x4f, 0xb4, 0x3c, 0x2f, 0x69, 0xa4, 0x8f,
+	0xe8, 0x28, 0x67, 0xe4, 0xea, 0xf7, 0x18, 0x79, 0x28, 0x26, 0xa4, 0x6c, 0x1e, 0x42, 0x07, 0x93,
+	0x59, 0x6d, 0x2a, 0x17, 0x31, 0x69, 0x63, 0x92, 0xd7, 0x64, 0x1b, 0x3a, 0x11, 0x72, 0x19, 0xa1,
+	0xd9, 0x4d, 0x50, 0xbd, 0x88, 0xc5, 0x9a, 0xa2, 0x4f, 0x78, 0x98, 0x3f, 0x81, 0xc6, 0x7e, 0x3c,
+	0x42, 0x6c, 0x72, 0x9c, 0x24, 0x83, 0x2b, 0xcb, 0x3f, 0xe6, 0xbf, 0x8a, 0x50, 0xdf, 0x19, 0x51,
+	0x12, 0x87, 0xb9, 0x9c, 0x2c, 0x83, 0x74, 0x36, 0x27, 0x0b, 0x12, 0x91, 0x93, 0x25, 0xf1, 0xbb,
+	0xd0, 0xf0, 0x45, 0xe8, 0x2a, 0x7a, 0x99, 0x87, 0x3a, 0x73, 0x41, 0x6d, 0xd5, 0xfd, 0x4c, 0x32,
+	0xeb, 0x03, 0x84, 0xd8, 0x8b, 0xd4, 0x1c, 0x99, 0x8e, 0xda, 0xaa, 0xdc, 0xd2, 0x29, 0xda, 0xaa,
+	0x85, 0x49, 0xb6, 0x7e, 0x1b, 0xea, 0xc7, 0xdc, 0x49, 0x6a, 0x42, 0x2e, 0x19, 0xa5, 0xde, 0xb3,
+	0xe0, 0x38, 0x0d, 0xc2, 0x7d, 0x68, 0x8e, 0xa5, 0xcb, 0xd4, 0x24, 0xb9, 0x87, 0x6e, 0x29, 0x4b,
+	0x52, 0x7b, 0xfb, 0x59, 0xcf, 0xca, 0x05, 0x68, 0x8c, 0x33, 0xa8, 0xde, 0x10, 0x3a, 0x73, 0x24,
+	0x0b, 0x72, 0xd0, 0x9d, 0x6c, 0x0e, 0xaa, 0xdf, 0x33, 0xa4, 0xa0, 0xec, 0xcc, 0x6c, 0x5e, 0xfa,
+	0x4d, 0x11, 0x1a, 0x9f, 0x23, 0xf6, 0x94, 0xd0, 0x53, 0xa9, 0xaf, 0x01, 0xe5, 0xc0, 0xf1, 0x91,
+	0xe2, 0x28, 0xbe, 0x8d, 0x1b, 0x50, 0xa5, 0xe7, 0x32, 0x81, 0xa8, 0xf5, 0xac, 0xd0, 0x73, 0x91,
+	0x18, 0x8c, 0x17, 0x01, 0xe8, 0xb9, 0x1d, 0x3a, 0xee, 0x29, 0x52, 0x1e, 0x2c, 0x5b, 0x35, 0x7a,
+	0x3e, 0x90, 0x08, 0xbe, 0x15, 0xe8, 0xb9, 0x8d, 0x28, 0x25, 0x34, 0x52, 0xb9, 0xaa, 0x4a, 0xcf,
+	0x77, 0x05, 0xac, 0xe6, 0x7a, 0x94, 0x84, 0x21, 0xf2, 0x44, 0x8e, 0x16, 0x73, 0x1f, 0x49, 0x04,
+	0x97, 0xca, 0xb4, 0xd4, 0x55, 0x29, 0x95, 0xa5, 0x52, 0x59, 0x2a, 0xb5, 0x22, 0x67, 0xb2, 0xac,
+	0x54, 0x96, 0x48, 0xad, 0x4a, 0xa9, 0x2c, 0x23, 0x95, 0xa5, 0x52, 0x6b, 0x7a, 0xae, 0x92, 0x6a,
+	0xfe, 0xba, 0x00, 0x9b, 0xb3, 0x85, 0x9f, 0xaa, 0x4d, 0xdf, 0x85, 0x86, 0x2b, 0xd6, 0x2b, 0xb7,
+	0x27, 0x3b, 0x73, 0x2b, 0x69, 0xd5, 0xdd, 0xcc, 0x36, 0xbe, 0x0f, 0xcd, 0x40, 0x3a, 0x38, 0xd9,
+	0x9a, 0xa5, 0x74, 0x5d, 0xb2, 0xbe, 0xb7, 0x1a, 0x41, 0x06, 0x32, 0x3d, 0x30, 0xbe, 0xa4, 0x98,
+	0xa1, 0x21, 0xa3, 0xc8, 0xf1, 0xaf, 0xa2, 0xba, 0x37, 0xa0, 0x2c, 0xaa, 0x15, 0xbe, 0x4c, 0x0d,
+	0x4b, 0x7c, 0x9b, 0xaf, 0xc2, 0x7a, 0x4e, 0x8a, 0xb2, 0x75, 0x0d, 0x4a, 0x13, 0x14, 0x08, 0xee,
+	0x4d, 0x8b, 0x7f, 0x9a, 0x0e, 0x74, 0x2c, 0xe4, 0x78, 0x57, 0xa7, 0x8d, 0x12, 0x51, 0x4a, 0x45,
+	0xdc, 0x01, 0x23, 0x2b, 0x42, 0xa9, 0xa2, 0xb5, 0x2e, 0x64, 0xb4, 0x7e, 0x0c, 0x9d, 0x9d, 0x09,
+	0x89, 0xd0, 0x90, 0x79, 0x38, 0xb8, 0x8a, 0x76, 0xe4, 0xe7, 0xb0, 0xfe, 0x84, 0x4d, 0xbf, 0xe4,
+	0xcc, 0x22, 0xfc, 0x0d, 0xba, 0x22, 0xfb, 0x28, 0x79, 0xaa, 0xed, 0xa3, 0xe4, 0x29, 0x6f, 0x6e,
+	0x5c, 0x32, 0x89, 0xfd, 0x40, 0x84, 0x42, 0xd3, 0x52, 0x90, 0xb9, 0x0d, 0x0d, 0x59, 0x43, 0x1f,
+	0x12, 0x2f, 0x9e, 0xa0, 0x85, 0x31, 0xb8, 0x05, 0x10, 0x3a, 0xd4, 0xf1, 0x11, 0x43, 0x54, 0xee,
+	0xa1, 0x9a, 0x95, 0xc1, 0x98, 0xbf, 0x2d, 0xc2, 0x86, 0xbc, 0x6f, 0x18, 0xca, 0x36, 0x5b, 0x9b,
+	0xd0, 0x83, 0xea, 0x98, 0x44, 0x2c, 0xc3, 0x30, 0x81, 0xb9, 0x8a, 0xbc, 0x3f, 0x97, 0xdc, 0xf8,
+	0x67, 0xee, 0x12, 0xa0, 0x74, 0xf1, 0x25, 0xc0, 0x5c, 0x9b, 0x5f, 0x9e, 0x6f, 0xf3, 0x79, 0xb4,
+	0x69, 0x22, 0x2c, 0x63, 0xbc, 0x66, 0xd5, 0x14, 0xe6, 0xc0, 0x33, 0x6e, 0x43, 0x7b, 0xc4, 0xb5,
+	0xb4, 0xc7, 0x84, 0x9c, 0xda, 0xa1, 0xc3, 0xc6, 0x22, 0xd4, 0x6b, 0x56, 0x53, 0xa0, 0xf7, 0x09,
+	0x39, 0x1d, 0x38, 0x6c, 0x6c, 0xbc, 0x0f, 0x2d, 0x55, 0x06, 0xfa, 0xc2, 0x45, 0x91, 0x3a, 0xfc,
+	0x54, 0x14, 0x65, 0xbd, 0x67, 0x35, 0x4f, 0x33, 0x50, 0x64, 0x5e, 0x87, 0x6b, 0x8f, 0x50, 0xc4,
+	0x28, 0x99, 0xe6, 0x1d, 0x63, 0xfe, 0x10, 0xe0, 0x20, 0x60, 0x88, 0x9e, 0x38, 0x2e, 0x8a, 0x8c,
+	0xb7, 0xb2, 0x90, 0x2a, 0x8e, 0xd6, 0xfa, 0xf2, 0xba, 0x27, 0x19, 0xb0, 0x32, 0x34, 0x66, 0x1f,
+	0x56, 0x2d, 0x12, 0xf3, 0x74, 0xf4, 0xb2, 0xfe, 0x52, 0xf3, 0x1a, 0x6a, 0x9e, 0x40, 0x5a, 0x6a,
+	0xcc, 0xdc, 0xd7, 0x2d, 0x6c, 0xca, 0x4e, 0x2d, 0x51, 0x1f, 0x6a, 0x58, 0xe3, 0x54, 0x56, 0x99,
+	0x17, 0x9d, 0x92, 0x98, 0x1f, 0xc2, 0xba, 0xe4, 0x24, 0x39, 0x6b, 0x36, 0x2f, 0xc3, 0x2a, 0xd5,
+	0x6a, 0x14, 0xd2, 0x7b, 0x1e, 0x45, 0xa4, 0xc6, 0xb8, 0x3f, 0x3e, 0xc3, 0x11, 0x4b, 0x0d, 0xd1,
+	0xfe, 0x58, 0x87, 0x0e, 0x1f, 0xc8, 0xf1, 0x34, 0x3f, 0x86, 0xc6, 0x43, 0x6b, 0xf0, 0x39, 0xc2,
+	0xa3, 0xf1, 0x31, 0xcf, 0x9e, 0x3f, 0xc8, 0xc3, 0xca, 0x60, 0x43, 0x69, 0x9b, 0x19, 0xb2, 0x72,
+	0x74, 0xe6, 0x27, 0xb0, 0xf9, 0xd0, 0xf3, 0xb2, 0x28, 0xad, 0xf5, 0x5b, 0x50, 0x0b, 0x32, 0xec,
+	0x32, 0x67, 0x56, 0x8e, 0x3a, 0x25, 0x32, 0x7f, 0x0a, 0xeb, 0x8f, 0x83, 0x09, 0x0e, 0xd0, 0xce,
+	0xe0, 0xe8, 0x10, 0x25, 0xb9, 0xc8, 0x80, 0x32, 0xaf, 0xd9, 0x04, 0x8f, 0xaa, 0x25, 0xbe, 0x79,
+	0x70, 0x06, 0xc7, 0xb6, 0x1b, 0xc6, 0x91, 0xba, 0xec, 0x59, 0x0d, 0x8e, 0x77, 0xc2, 0x38, 0xe2,
+	0x87, 0x0b, 0x2f, 0x2e, 0x48, 0x30, 0x99, 0x8a, 0x08, 0xad, 0x5a, 0x15, 0x37, 0x8c, 0x1f, 0x07,
+	0x93, 0xa9, 0xf9, 0xff, 0xa2, 0x03, 0x47, 0xc8, 0xb3, 0x9c, 0xc0, 0x23, 0xfe, 0x23, 0x74, 0x96,
+	0x91, 0x90, 0x74, 0x7b, 0x3a, 0x13, 0x7d, 0x5b, 0x80, 0xc6, 0xc3, 0x11, 0x0a, 0xd8, 0x23, 0xc4,
+	0x1c, 0x3c, 0x11, 0x1d, 0xdd, 0x19, 0xa2, 0x11, 0x26, 0x81, 0x0a, 0x37, 0x0d, 0xf2, 0x86, 0x1c,
+	0x07, 0x98, 0xd9, 0x9e, 0x83, 0x7c, 0x12, 0x08, 0x2e, 0x55, 0x0b, 0x38, 0xea, 0x91, 0xc0, 0x18,
+	0xaf, 0x42, 0x5b, 0x5e, 0xc6, 0xd9, 0x63, 0x27, 0xf0, 0x26, 0x3c, 0xd0, 0x4b, 0x22, 0x34, 0x5b,
+	0x12, 0xbd, 0xaf, 0xb0, 0xc6, 0x6b, 0xb0, 0xa6, 0xc2, 0x30, 0xa5, 0x2c, 0x0b, 0xca, 0xb6, 0xc2,
+	0xe7, 0x48, 0xe3, 0x30, 0x24, 0x94, 0x45, 0x76, 0x84, 0x5c, 0x97, 0xf8, 0xa1, 0x6a, 0x87, 0xda,
+	0x1a, 0x3f, 0x94, 0x68, 0x73, 0x04, 0xeb, 0x7b, 0xdc, 0x4e, 0x65, 0x49, 0xba, 0xad, 0x5a, 0x3e,
+	0xf2, 0xed, 0xe3, 0x09, 0x71, 0x4f, 0x6d, 0x9e, 0x1c, 0x95, 0x87, 0x79, 0xc1, 0xb5, 0xcd, 0x91,
+	0x43, 0xfc, 0x8d, 0xe8, 0xfc, 0x39, 0xd5, 0x98, 0xb0, 0x70, 0x12, 0x8f, 0xec, 0x90, 0x92, 0x63,
+	0xa4, 0x4c, 0x6c, 0xfb, 0xc8, 0xdf, 0x97, 0xf8, 0x01, 0x47, 0x9b, 0x7f, 0x2e, 0xc0, 0x46, 0x5e,
+	0x92, 0x4a, 0xf5, 0x77, 0x61, 0x23, 0x2f, 0x4a, 0x1d, 0xff, 0xb2, 0xbc, 0xec, 0x64, 0x05, 0xca,
+	0x42, 0xe0, 0x3e, 0x34, 0xc5, 0x7d, 0xad, 0xed, 0x49, 0x4e, 0xf9, 0xa2, 0x27, 0xbb, 0x2e, 0x56,
+	0xc3, 0xc9, 0xae, 0xd2, 0xfb, 0x70, 0x43, 0x99, 0x6f, 0xcf, 0xab, 0x2d, 0x37, 0xc4, 0xa6, 0x22,
+	0x38, 0x9c, 0xd1, 0xfe, 0x33, 0xe8, 0xa6, 0xa8, 0xed, 0xa9, 0x40, 0xa6, 0x9b, 0x79, 0x7d, 0xc6,
+	0xd8, 0x87, 0x9e, 0x47, 0x45, 0x94, 0x94, 0xad, 0x45, 0x43, 0xe6, 0x03, 0xb8, 0x3e, 0x44, 0x4c,
+	0x7a, 0xc3, 0x61, 0xaa, 0x13, 0x91, 0xcc, 0xd6, 0xa0, 0x34, 0x44, 0xae, 0x30, 0xbe, 0x64, 0xf1,
+	0x4f, 0xbe, 0x01, 0x8f, 0x22, 0xe4, 0x0a, 0x2b, 0x4b, 0x96, 0xf8, 0x36, 0xff, 0x58, 0x80, 0x8a,
+	0x4a, 0xce, 0xfc, 0x80, 0xf1, 0x28, 0x3e, 0x43, 0x54, 0x6d, 0x3d, 0x05, 0x19, 0xaf, 0x40, 0x4b,
+	0x7e, 0xd9, 0x24, 0x64, 0x98, 0x24, 0x29, 0xbf, 0x29, 0xb1, 0x8f, 0x25, 0x52, 0x5c, 0xbe, 0x89,
+	0xeb, 0x2f, 0xd5, 0x69, 0x2a, 0x88, 0xe3, 0x4f, 0x22, 0x1e, 0xe1, 0x22, 0xc5, 0xd7, 0x2c, 0x05,
+	0xf1, 0xad, 0xae, 0xf9, 0xad, 0x08, 0x7e, 0x1a, 0xe4, 0x5b, 0xdd, 0x27, 0x71, 0xc0, 0xec, 0x90,
+	0xe0, 0x80, 0xa9, 0x9c, 0x0e, 0x02, 0x35, 0xe0, 0x18, 0xf3, 0x57, 0x05, 0x58, 0x95, 0x17, 0xd0,
+	0xbc, 0xb7, 0x4d, 0x4e, 0xd6, 0x22, 0x16, 0x55, 0x8a, 0x90, 0x25, 0x4f, 0x53, 0xf1, 0xcd, 0xe3,
+	0xf8, 0xcc, 0x97, 0xe7, 0x83, 0x52, 0xed, 0xcc, 0x17, 0x07, 0xc3, 0x2b, 0xd0, 0x4a, 0x0f, 0x68,
+	0x31, 0x2e, 0x55, 0x6c, 0x26, 0x58, 0x41, 0xb6, 0x54, 0x53, 0xf3, 0x47, 0xbc, 0xa5, 0x4f, 0x2e,
+	0x5f, 0xd7, 0xa0, 0x14, 0x27, 0xca, 0xf0, 0x4f, 0x8e, 0x19, 0x25, 0x47, 0x3b, 0xff, 0x34, 0x6e,
+	0x43, 0xcb, 0xf1, 0x3c, 0xcc, 0xa7, 0x3b, 0x93, 0x3d, 0xec, 0x25, 0x41, 0x9a, 0xc7, 0x9a, 0x7f,
+	0x2d, 0x40, 0x7b, 0x87, 0x84, 0xd3, 0x8f, 0xf1, 0x04, 0x65, 0x32, 0x88, 0x50, 0x52, 0x9d, 0xec,
+	0xfc, 0x9b, 0x57, 0xab, 0x27, 0x78, 0x82, 0x64, 0x68, 0xc9, 0x95, 0xad, 0x72, 0x84, 0x08, 0x2b,
+	0x3d, 0x98, 0x5c, 0xbb, 0x35, 0xe5, 0xe0, 0x21, 0xf1, 0x44, 0x5d, 0xee, 0x61, 0x6a, 0x27, 0x97,
+	0x6c, 0x4d, 0xab, 0xe2, 0x61, 0x2a, 0x86, 0x94, 0x21, 0x2b, 0xe2, 0x12, 0x35, 0x6b, 0xc8, 0xaa,
+	0xc4, 0x70, 0x43, 0x36, 0x61, 0x95, 0x9c, 0x9c, 0x44, 0x88, 0x89, 0x0a, 0xba, 0x64, 0x29, 0x28,
+	0x49, 0x73, 0xd5, 0x4c, 0x9a, 0xbb, 0x06, 0xeb, 0xe2, 0xba, 0xfe, 0x09, 0x75, 0x5c, 0x1c, 0x8c,
+	0xf4, 0xf1, 0xb0, 0x01, 0xc6, 0x90, 0x91, 0x70, 0x1e, 0xbb, 0x87, 0xd8, 0xe3, 0xc7, 0x87, 0xbb,
+	0x67, 0x28, 0x60, 0x1a, 0xfb, 0x26, 0x54, 0x35, 0xea, 0x3f, 0xb9, 0xcb, 0x7c, 0x1d, 0x5a, 0x0f,
+	0x3d, 0x6f, 0xf8, 0xd4, 0x09, 0xb5, 0xf3, 0xba, 0x50, 0x19, 0xec, 0x1c, 0x0c, 0xa4, 0xff, 0x4a,
+	0xdc, 0x5a, 0x05, 0xf2, 0xa3, 0x6b, 0x0f, 0xb1, 0x43, 0xc4, 0x28, 0x76, 0x93, 0xa3, 0xeb, 0x16,
+	0x54, 0x14, 0x86, 0xcf, 0xf4, 0xe5, 0xa7, 0xce, 0xc9, 0x0a, 0xbc, 0xf7, 0xa7, 0x8e, 0x4a, 0xdf,
+	0xea, 0x26, 0xc0, 0xd8, 0x83, 0xf6, 0xcc, 0xb3, 0x8d, 0xa1, 0xae, 0x86, 0x16, 0xbf, 0xe6, 0xf4,
+	0x36, 0xfb, 0xf2, 0x19, 0xa8, 0xaf, 0x9f, 0x81, 0xfa, 0xbb, 0x7e, 0xc8, 0xa6, 0xc6, 0x2e, 0xb4,
+	0xf2, 0x0f, 0x1c, 0xc6, 0xf3, 0xba, 0x92, 0x5a, 0xf0, 0xec, 0xb1, 0x94, 0xcd, 0x1e, 0xb4, 0x67,
+	0xde, 0x3a, 0xb4, 0x3e, 0x8b, 0x9f, 0x40, 0x96, 0x32, 0x7a, 0x00, 0xf5, 0xcc, 0xe3, 0x86, 0xd1,
+	0x95, 0x4c, 0xe6, 0xdf, 0x3b, 0x96, 0x32, 0xd8, 0x81, 0x66, 0xee, 0xbd, 0xc1, 0xe8, 0x29, 0x7b,
+	0x16, 0x3c, 0x42, 0x2c, 0x65, 0xb2, 0x0d, 0xf5, 0xcc, 0xb5, 0xbf, 0xd6, 0x62, 0xfe, 0x6d, 0xa1,
+	0x77, 0x63, 0xc1, 0x88, 0x3a, 0x25, 0xf6, 0xa0, 0x3d, 0xf3, 0x16, 0xa0, 0x5d, 0xb2, 0xf8, 0x89,
+	0x60, 0xa9, 0x32, 0x9f, 0x8a, 0x25, 0xca, 0xb4, 0x7a, 0x99, 0x25, 0x9a, 0xbf, 0xf9, 0xef, 0xbd,
+	0xb0, 0x78, 0x50, 0x69, 0xb5, 0x0b, 0xad, 0xfc, 0xa5, 0xbf, 0x66, 0xb6, 0xf0, 0x29, 0xe0, 0xe2,
+	0xf5, 0xce, 0xdd, 0xff, 0xa7, 0xeb, 0xbd, 0xe8, 0x59, 0x60, 0x29, 0xa3, 0x87, 0x00, 0xaa, 0xb1,
+	0xf3, 0x70, 0x90, 0x38, 0x7a, 0xae, 0xa1, 0x4c, 0x1c, 0xbd, 0xa0, 0x09, 0x7c, 0x00, 0x20, 0xfb,
+	0x31, 0x8f, 0xc4, 0xcc, 0xb8, 0xae, 0xd5, 0x98, 0x69, 0x02, 0x7b, 0xdd, 0xf9, 0x81, 0x39, 0x06,
+	0x88, 0xd2, 0xcb, 0x30, 0xf8, 0x08, 0x20, 0xed, 0xf3, 0x34, 0x83, 0xb9, 0xce, 0xef, 0x02, 0x1f,
+	0x34, 0xb2, 0x5d, 0x9d, 0xa1, 0x6c, 0x5d, 0xd0, 0xe9, 0x5d, 0xc0, 0xa2, 0x3d, 0x53, 0xb5, 0xe7,
+	0x37, 0xdb, 0x6c, 0x31, 0xdf, 0x9b, 0xab, 0xdc, 0x8d, 0xfb, 0xd0, 0xc8, 0x96, 0xeb, 0x5a, 0x8b,
+	0x05, 0x25, 0x7c, 0x2f, 0x57, 0xb2, 0x1b, 0x0f, 0xa0, 0x95, 0x2f, 0xd5, 0xf5, 0x96, 0x5a, 0x58,
+	0xc0, 0xf7, 0xd4, 0x45, 0x54, 0x86, 0xfc, 0x1d, 0x80, 0xb4, 0xa4, 0xd7, 0xee, 0x9b, 0x2b, 0xf2,
+	0x67, 0xa4, 0xee, 0x41, 0x7b, 0xa6, 0x54, 0xd7, 0x16, 0x2f, 0xae, 0xe0, 0x2f, 0xf2, 0x7e, 0xf6,
+	0xcc, 0xd0, 0x76, 0x2f, 0x38, 0x47, 0x2e, 0x4a, 0x5a, 0x99, 0xf3, 0x45, 0xef, 0xe2, 0xf9, 0x23,
+	0x67, 0x29, 0x83, 0x77, 0x01, 0xd2, 0x93, 0x41, 0x7b, 0x60, 0xee, 0xac, 0xe8, 0x35, 0xf5, 0x45,
+	0xa1, 0xa4, 0xdb, 0x81, 0x66, 0xae, 0x97, 0xd6, 0xa9, 0x6e, 0x51, 0x83, 0x7d, 0xd1, 0x01, 0x90,
+	0x6f, 0x3c, 0xf5, 0xea, 0x2d, 0x6c, 0x47, 0x2f, 0xf2, 0x62, 0xb6, 0xdb, 0xd1, 0x5e, 0x5c, 0xd0,
+	0x01, 0x7d, 0x4f, 0x4e, 0xc9, 0x76, 0x34, 0x99, 0x9c, 0xb2, 0xa0, 0xd1, 0x59, 0xca, 0x68, 0x1f,
+	0xda, 0x7b, 0xba, 0x58, 0x55, 0x85, 0xb4, 0x52, 0x67, 0x41, 0xe3, 0xd0, 0xeb, 0x2d, 0x1a, 0x52,
+	0x81, 0xfd, 0x29, 0x74, 0xe6, 0x8a, 0x68, 0x63, 0x2b, 0xb9, 0xae, 0x5d, 0x58, 0x5d, 0x2f, 0x55,
+	0xeb, 0x00, 0xd6, 0x66, 0x6b, 0x68, 0xe3, 0x45, 0xb5, 0x55, 0x16, 0xd7, 0xd6, 0x4b, 0x59, 0xbd,
+	0x0f, 0x55, 0x5d, 0xb3, 0x19, 0xea, 0x5a, 0x7c, 0xa6, 0x86, 0x5b, 0x3a, 0xf5, 0x3e, 0xd4, 0x33,
+	0x55, 0x8f, 0xde, 0xab, 0xf3, 0x85, 0x50, 0x4f, 0xdd, 0x62, 0x27, 0x94, 0xf7, 0xa1, 0xa2, 0x2a,
+	0x1d, 0x63, 0x23, 0x09, 0xb4, 0x4c, 0xe1, 0xb3, 0x4c, 0xe2, 0xf6, 0xf9, 0xb7, 0xdf, 0x6d, 0x3d,
+	0xf7, 0xf7, 0xef, 0xb6, 0x9e, 0xfb, 0xe5, 0xb3, 0xad, 0xc2, 0xb7, 0xcf, 0xb6, 0x0a, 0x7f, 0x7b,
+	0xb6, 0x55, 0xf8, 0xe7, 0xb3, 0xad, 0xc2, 0x8f, 0x7f, 0xf6, 0x5f, 0xfe, 0x17, 0x86, 0xc6, 0x01,
+	0xc3, 0x3e, 0xba, 0x7b, 0x86, 0x29, 0xcb, 0x0c, 0x85, 0xa7, 0xa3, 0xb9, 0xbf, 0xc9, 0x70, 0x05,
+	0x8f, 0x57, 0x05, 0xfc, 0xce, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x43, 0x46, 0x6b, 0x3b, 0x74,
+	0x23, 0x00, 0x00,
 }
 
 func (m *CreateContainerRequest) Marshal() (dAtA []byte, err error) {
@@ -5432,6 +5474,51 @@ func (m *OOMEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *AddSwapRequest) 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 *AddSwapRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AddSwapRequest) 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.PCIPath) > 0 {
+		dAtA26 := make([]byte, len(m.PCIPath)*10)
+		var j25 int
+		for _, num := range m.PCIPath {
+			for num >= 1<<7 {
+				dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80)
+				num >>= 7
+				j25++
+			}
+			dAtA26[j25] = uint8(num)
+			j25++
+		}
+		i -= j25
+		copy(dAtA[i:], dAtA26[:j25])
+		i = encodeVarintAgent(dAtA, i, uint64(j25))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *GetMetricsRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -6761,6 +6848,25 @@ func (m *OOMEvent) Size() (n int) {
 	return n
 }
 
+func (m *AddSwapRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.PCIPath) > 0 {
+		l = 0
+		for _, e := range m.PCIPath {
+			l += sovAgent(uint64(e))
+		}
+		n += 1 + sovAgent(uint64(l)) + l
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func (m *GetMetricsRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -7591,6 +7697,17 @@ func (this *OOMEvent) String() string {
 	}, "")
 	return s
 }
+func (this *AddSwapRequest) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&AddSwapRequest{`,
+		`PCIPath:` + fmt.Sprintf("%v", this.PCIPath) + `,`,
+		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func (this *GetMetricsRequest) String() string {
 	if this == nil {
 		return "nil"
@@ -7654,6 +7771,7 @@ type AgentServiceService interface {
 	SetGuestDateTime(ctx context.Context, req *SetGuestDateTimeRequest) (*types.Empty, error)
 	CopyFile(ctx context.Context, req *CopyFileRequest) (*types.Empty, error)
 	GetOOMEvent(ctx context.Context, req *GetOOMEventRequest) (*OOMEvent, error)
+	AddSwap(ctx context.Context, req *AddSwapRequest) (*types.Empty, error)
 }
 
 func RegisterAgentServiceService(srv *github_com_containerd_ttrpc.Server, svc AgentServiceService) {
@@ -7882,6 +8000,13 @@ func RegisterAgentServiceService(srv *github_com_containerd_ttrpc.Server, svc Ag
 			}
 			return svc.GetOOMEvent(ctx, &req)
 		},
+		"AddSwap": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+			var req AddSwapRequest
+			if err := unmarshal(&req); err != nil {
+				return nil, err
+			}
+			return svc.AddSwap(ctx, &req)
+		},
 	})
 }
 
@@ -8150,6 +8275,14 @@ func (c *agentServiceClient) GetOOMEvent(ctx context.Context, req *GetOOMEventRe
 	}
 	return &resp, nil
 }
+
+func (c *agentServiceClient) AddSwap(ctx context.Context, req *AddSwapRequest) (*types.Empty, error) {
+	var resp types.Empty
+	if err := c.client.Call(ctx, "grpc.AgentService", "AddSwap", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
 func (m *CreateContainerRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -15317,6 +15450,133 @@ func (m *OOMEvent) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *AddSwapRequest) 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 ErrIntOverflowAgent
+			}
+			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: AddSwapRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AddSwapRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType == 0 {
+				var v uint32
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowAgent
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= uint32(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.PCIPath = append(m.PCIPath, v)
+			} else if wireType == 2 {
+				var packedLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowAgent
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					packedLen |= int(b&0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if packedLen < 0 {
+					return ErrInvalidLengthAgent
+				}
+				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthAgent
+				}
+				if postIndex > l {
+					return io.ErrUnexpectedEOF
+				}
+				var elementCount int
+				var count int
+				for _, integer := range dAtA[iNdEx:postIndex] {
+					if integer < 128 {
+						count++
+					}
+				}
+				elementCount = count
+				if elementCount != 0 && len(m.PCIPath) == 0 {
+					m.PCIPath = make([]uint32, 0, elementCount)
+				}
+				for iNdEx < postIndex {
+					var v uint32
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowAgent
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= uint32(b&0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					m.PCIPath = append(m.PCIPath, v)
+				}
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field PCIPath", wireType)
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipAgent(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthAgent
+			}
+			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 *GetMetricsRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/src/runtime/virtcontainers/pkg/agent/protocols/grpc/oci.pb.go b/src/runtime/virtcontainers/pkg/agent/protocols/grpc/oci.pb.go
index 6b5ca0fe4..2dc8fd757 100644
--- a/src/runtime/virtcontainers/pkg/agent/protocols/grpc/oci.pb.go
+++ b/src/runtime/virtcontainers/pkg/agent/protocols/grpc/oci.pb.go
@@ -29,25 +29,25 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type Spec struct {
 	// Version of the Open Container Initiative Runtime Specification with which the bundle complies.
-	Version string `protobuf:"bytes,1,opt,name=Version,json=version,proto3" json:"Version,omitempty"`
+	Version string `protobuf:"bytes,1,opt,name=Version,proto3" json:"Version,omitempty"`
 	// Process configures the container process.
-	Process *Process `protobuf:"bytes,2,opt,name=Process,json=process,proto3" json:"Process,omitempty"`
+	Process *Process `protobuf:"bytes,2,opt,name=Process,proto3" json:"Process,omitempty"`
 	// Root configures the container's root filesystem.
-	Root *Root `protobuf:"bytes,3,opt,name=Root,json=root,proto3" json:"Root,omitempty"`
+	Root *Root `protobuf:"bytes,3,opt,name=Root,proto3" json:"Root,omitempty"`
 	// Hostname configures the container's hostname.
-	Hostname string `protobuf:"bytes,4,opt,name=Hostname,json=hostname,proto3" json:"Hostname,omitempty"`
+	Hostname string `protobuf:"bytes,4,opt,name=Hostname,proto3" json:"Hostname,omitempty"`
 	// Mounts configures additional mounts (on top of Root).
-	Mounts []Mount `protobuf:"bytes,5,rep,name=Mounts,json=mounts,proto3" json:"Mounts"`
+	Mounts []Mount `protobuf:"bytes,5,rep,name=Mounts,proto3" json:"Mounts"`
 	// Hooks configures callbacks for container lifecycle events.
-	Hooks *Hooks `protobuf:"bytes,6,opt,name=Hooks,json=hooks,proto3" json:"Hooks,omitempty"`
+	Hooks *Hooks `protobuf:"bytes,6,opt,name=Hooks,proto3" json:"Hooks,omitempty"`
 	// Annotations contains arbitrary metadata for the container.
-	Annotations map[string]string `protobuf:"bytes,7,rep,name=Annotations,json=annotations,proto3" json:"Annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Annotations map[string]string `protobuf:"bytes,7,rep,name=Annotations,proto3" json:"Annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	// Linux is platform-specific configuration for Linux based containers.
-	Linux *Linux `protobuf:"bytes,8,opt,name=Linux,json=linux,proto3" json:"Linux,omitempty"`
+	Linux *Linux `protobuf:"bytes,8,opt,name=Linux,proto3" json:"Linux,omitempty"`
 	// Solaris is platform-specific configuration for Solaris based containers.
-	Solaris *Solaris `protobuf:"bytes,9,opt,name=Solaris,json=solaris,proto3" json:"Solaris,omitempty"`
+	Solaris *Solaris `protobuf:"bytes,9,opt,name=Solaris,proto3" json:"Solaris,omitempty"`
 	// Windows is platform-specific configuration for Windows based containers.
-	Windows              *Windows `protobuf:"bytes,10,opt,name=Windows,json=windows,proto3" json:"Windows,omitempty"`
+	Windows              *Windows `protobuf:"bytes,10,opt,name=Windows,proto3" json:"Windows,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -87,30 +87,30 @@ var xxx_messageInfo_Spec proto.InternalMessageInfo
 
 type Process struct {
 	// Terminal creates an interactive terminal for the container.
-	Terminal bool `protobuf:"varint,1,opt,name=Terminal,json=terminal,proto3" json:"Terminal,omitempty"`
+	Terminal bool `protobuf:"varint,1,opt,name=Terminal,proto3" json:"Terminal,omitempty"`
 	// ConsoleSize specifies the size of the console.
-	ConsoleSize *Box `protobuf:"bytes,2,opt,name=ConsoleSize,json=consoleSize,proto3" json:"ConsoleSize,omitempty"`
+	ConsoleSize *Box `protobuf:"bytes,2,opt,name=ConsoleSize,proto3" json:"ConsoleSize,omitempty"`
 	// User specifies user information for the process.
-	User User `protobuf:"bytes,3,opt,name=User,json=user,proto3" json:"User"`
+	User User `protobuf:"bytes,3,opt,name=User,proto3" json:"User"`
 	// Args specifies the binary and arguments for the application to execute.
-	Args []string `protobuf:"bytes,4,rep,name=Args,json=args,proto3" json:"Args,omitempty"`
+	Args []string `protobuf:"bytes,4,rep,name=Args,proto3" json:"Args,omitempty"`
 	// Env populates the process environment for the process.
-	Env []string `protobuf:"bytes,5,rep,name=Env,json=env,proto3" json:"Env,omitempty"`
+	Env []string `protobuf:"bytes,5,rep,name=Env,proto3" json:"Env,omitempty"`
 	// Cwd is the current working directory for the process and must be
 	// relative to the container's root.
-	Cwd string `protobuf:"bytes,6,opt,name=Cwd,json=cwd,proto3" json:"Cwd,omitempty"`
+	Cwd string `protobuf:"bytes,6,opt,name=Cwd,proto3" json:"Cwd,omitempty"`
 	// Capabilities are Linux capabilities that are kept for the process.
-	Capabilities *LinuxCapabilities `protobuf:"bytes,7,opt,name=Capabilities,json=capabilities,proto3" json:"Capabilities,omitempty"`
+	Capabilities *LinuxCapabilities `protobuf:"bytes,7,opt,name=Capabilities,proto3" json:"Capabilities,omitempty"`
 	// Rlimits specifies rlimit options to apply to the process.
-	Rlimits []POSIXRlimit `protobuf:"bytes,8,rep,name=Rlimits,json=rlimits,proto3" json:"Rlimits"`
+	Rlimits []POSIXRlimit `protobuf:"bytes,8,rep,name=Rlimits,proto3" json:"Rlimits"`
 	// NoNewPrivileges controls whether additional privileges could be gained by processes in the container.
-	NoNewPrivileges bool `protobuf:"varint,9,opt,name=NoNewPrivileges,json=noNewPrivileges,proto3" json:"NoNewPrivileges,omitempty"`
+	NoNewPrivileges bool `protobuf:"varint,9,opt,name=NoNewPrivileges,proto3" json:"NoNewPrivileges,omitempty"`
 	// ApparmorProfile specifies the apparmor profile for the container.
-	ApparmorProfile string `protobuf:"bytes,10,opt,name=ApparmorProfile,json=apparmorProfile,proto3" json:"ApparmorProfile,omitempty"`
+	ApparmorProfile string `protobuf:"bytes,10,opt,name=ApparmorProfile,proto3" json:"ApparmorProfile,omitempty"`
 	// Specify an oom_score_adj for the container.
-	OOMScoreAdj int64 `protobuf:"varint,11,opt,name=OOMScoreAdj,json=oOMScoreAdj,proto3" json:"OOMScoreAdj,omitempty"`
+	OOMScoreAdj int64 `protobuf:"varint,11,opt,name=OOMScoreAdj,proto3" json:"OOMScoreAdj,omitempty"`
 	// SelinuxLabel specifies the selinux context that the container process is run as.
-	SelinuxLabel         string   `protobuf:"bytes,12,opt,name=SelinuxLabel,json=selinuxLabel,proto3" json:"SelinuxLabel,omitempty"`
+	SelinuxLabel         string   `protobuf:"bytes,12,opt,name=SelinuxLabel,proto3" json:"SelinuxLabel,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -150,9 +150,9 @@ var xxx_messageInfo_Process proto.InternalMessageInfo
 
 type Box struct {
 	// Height is the vertical dimension of a box.
-	Height uint32 `protobuf:"varint,1,opt,name=Height,json=height,proto3" json:"Height,omitempty"`
+	Height uint32 `protobuf:"varint,1,opt,name=Height,proto3" json:"Height,omitempty"`
 	// Width is the horizontal dimension of a box.
-	Width                uint32   `protobuf:"varint,2,opt,name=Width,json=width,proto3" json:"Width,omitempty"`
+	Width                uint32   `protobuf:"varint,2,opt,name=Width,proto3" json:"Width,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -192,13 +192,13 @@ var xxx_messageInfo_Box proto.InternalMessageInfo
 
 type User struct {
 	// UID is the user id.
-	UID uint32 `protobuf:"varint,1,opt,name=UID,json=uID,proto3" json:"UID,omitempty"`
+	UID uint32 `protobuf:"varint,1,opt,name=UID,proto3" json:"UID,omitempty"`
 	// GID is the group id.
-	GID uint32 `protobuf:"varint,2,opt,name=GID,json=gID,proto3" json:"GID,omitempty"`
+	GID uint32 `protobuf:"varint,2,opt,name=GID,proto3" json:"GID,omitempty"`
 	// AdditionalGids are additional group ids set for the container's process.
-	AdditionalGids []uint32 `protobuf:"varint,3,rep,packed,name=AdditionalGids,json=additionalGids,proto3" json:"AdditionalGids,omitempty"`
+	AdditionalGids []uint32 `protobuf:"varint,3,rep,packed,name=AdditionalGids,proto3" json:"AdditionalGids,omitempty"`
 	// Username is the user name.
-	Username             string   `protobuf:"bytes,4,opt,name=Username,json=username,proto3" json:"Username,omitempty"`
+	Username             string   `protobuf:"bytes,4,opt,name=Username,proto3" json:"Username,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -238,15 +238,15 @@ var xxx_messageInfo_User proto.InternalMessageInfo
 
 type LinuxCapabilities struct {
 	// Bounding is the set of capabilities checked by the kernel.
-	Bounding []string `protobuf:"bytes,1,rep,name=Bounding,json=bounding,proto3" json:"Bounding,omitempty"`
+	Bounding []string `protobuf:"bytes,1,rep,name=Bounding,proto3" json:"Bounding,omitempty"`
 	// Effective is the set of capabilities checked by the kernel.
-	Effective []string `protobuf:"bytes,2,rep,name=Effective,json=effective,proto3" json:"Effective,omitempty"`
+	Effective []string `protobuf:"bytes,2,rep,name=Effective,proto3" json:"Effective,omitempty"`
 	// Inheritable is the capabilities preserved across execve.
-	Inheritable []string `protobuf:"bytes,3,rep,name=Inheritable,json=inheritable,proto3" json:"Inheritable,omitempty"`
+	Inheritable []string `protobuf:"bytes,3,rep,name=Inheritable,proto3" json:"Inheritable,omitempty"`
 	// Permitted is the limiting superset for effective capabilities.
-	Permitted []string `protobuf:"bytes,4,rep,name=Permitted,json=permitted,proto3" json:"Permitted,omitempty"`
+	Permitted []string `protobuf:"bytes,4,rep,name=Permitted,proto3" json:"Permitted,omitempty"`
 	// Ambient is the ambient set of capabilities that are kept.
-	Ambient              []string `protobuf:"bytes,5,rep,name=Ambient,json=ambient,proto3" json:"Ambient,omitempty"`
+	Ambient              []string `protobuf:"bytes,5,rep,name=Ambient,proto3" json:"Ambient,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -286,11 +286,11 @@ var xxx_messageInfo_LinuxCapabilities proto.InternalMessageInfo
 
 type POSIXRlimit struct {
 	// Type of the rlimit to set
-	Type string `protobuf:"bytes,1,opt,name=Type,json=type,proto3" json:"Type,omitempty"`
+	Type string `protobuf:"bytes,1,opt,name=Type,proto3" json:"Type,omitempty"`
 	// Hard is the hard limit for the specified type
-	Hard uint64 `protobuf:"varint,2,opt,name=Hard,json=hard,proto3" json:"Hard,omitempty"`
+	Hard uint64 `protobuf:"varint,2,opt,name=Hard,proto3" json:"Hard,omitempty"`
 	// Soft is the soft limit for the specified type
-	Soft                 uint64   `protobuf:"varint,3,opt,name=Soft,json=soft,proto3" json:"Soft,omitempty"`
+	Soft                 uint64   `protobuf:"varint,3,opt,name=Soft,proto3" json:"Soft,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -377,9 +377,9 @@ var xxx_messageInfo_Mount proto.InternalMessageInfo
 
 type Root struct {
 	// Path is the absolute path to the container's root filesystem.
-	Path string `protobuf:"bytes,1,opt,name=Path,json=path,proto3" json:"Path,omitempty"`
+	Path string `protobuf:"bytes,1,opt,name=Path,proto3" json:"Path,omitempty"`
 	// Readonly makes the root filesystem for the container readonly before the process is executed.
-	Readonly             bool     `protobuf:"varint,2,opt,name=Readonly,json=readonly,proto3" json:"Readonly,omitempty"`
+	Readonly             bool     `protobuf:"varint,2,opt,name=Readonly,proto3" json:"Readonly,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -419,11 +419,11 @@ var xxx_messageInfo_Root proto.InternalMessageInfo
 
 type Hooks struct {
 	// Prestart is a list of hooks to be run before the container process is executed.
-	Prestart []Hook `protobuf:"bytes,1,rep,name=Prestart,json=prestart,proto3" json:"Prestart"`
+	Prestart []Hook `protobuf:"bytes,1,rep,name=Prestart,proto3" json:"Prestart"`
 	// Poststart is a list of hooks to be run after the container process is started.
-	Poststart []Hook `protobuf:"bytes,2,rep,name=Poststart,json=poststart,proto3" json:"Poststart"`
+	Poststart []Hook `protobuf:"bytes,2,rep,name=Poststart,proto3" json:"Poststart"`
 	// Poststop is a list of hooks to be run after the container process exits.
-	Poststop             []Hook   `protobuf:"bytes,3,rep,name=Poststop,json=poststop,proto3" json:"Poststop"`
+	Poststop             []Hook   `protobuf:"bytes,3,rep,name=Poststop,proto3" json:"Poststop"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -462,10 +462,10 @@ func (m *Hooks) XXX_DiscardUnknown() {
 var xxx_messageInfo_Hooks proto.InternalMessageInfo
 
 type Hook struct {
-	Path                 string   `protobuf:"bytes,1,opt,name=Path,json=path,proto3" json:"Path,omitempty"`
-	Args                 []string `protobuf:"bytes,2,rep,name=Args,json=args,proto3" json:"Args,omitempty"`
-	Env                  []string `protobuf:"bytes,3,rep,name=Env,json=env,proto3" json:"Env,omitempty"`
-	Timeout              int64    `protobuf:"varint,4,opt,name=Timeout,json=timeout,proto3" json:"Timeout,omitempty"`
+	Path                 string   `protobuf:"bytes,1,opt,name=Path,proto3" json:"Path,omitempty"`
+	Args                 []string `protobuf:"bytes,2,rep,name=Args,proto3" json:"Args,omitempty"`
+	Env                  []string `protobuf:"bytes,3,rep,name=Env,proto3" json:"Env,omitempty"`
+	Timeout              int64    `protobuf:"varint,4,opt,name=Timeout,proto3" json:"Timeout,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -505,35 +505,35 @@ var xxx_messageInfo_Hook proto.InternalMessageInfo
 
 type Linux struct {
 	// UIDMapping specifies user mappings for supporting user namespaces.
-	UIDMappings []LinuxIDMapping `protobuf:"bytes,1,rep,name=UIDMappings,json=uIDMappings,proto3" json:"UIDMappings"`
+	UIDMappings []LinuxIDMapping `protobuf:"bytes,1,rep,name=UIDMappings,proto3" json:"UIDMappings"`
 	// GIDMapping specifies group mappings for supporting user namespaces.
-	GIDMappings []LinuxIDMapping `protobuf:"bytes,2,rep,name=GIDMappings,json=gIDMappings,proto3" json:"GIDMappings"`
+	GIDMappings []LinuxIDMapping `protobuf:"bytes,2,rep,name=GIDMappings,proto3" json:"GIDMappings"`
 	// Sysctl are a set of key value pairs that are set for the container on start
-	Sysctl map[string]string `protobuf:"bytes,3,rep,name=Sysctl,json=sysctl,proto3" json:"Sysctl,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Sysctl map[string]string `protobuf:"bytes,3,rep,name=Sysctl,proto3" json:"Sysctl,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	// Resources contain cgroup information for handling resource constraints
 	// for the container
-	Resources *LinuxResources `protobuf:"bytes,4,opt,name=Resources,json=resources,proto3" json:"Resources,omitempty"`
+	Resources *LinuxResources `protobuf:"bytes,4,opt,name=Resources,proto3" json:"Resources,omitempty"`
 	// CgroupsPath specifies the path to cgroups that are created and/or joined by the container.
 	// The path is expected to be relative to the cgroups mountpoint.
 	// If resources are specified, the cgroups at CgroupsPath will be updated based on resources.
-	CgroupsPath string `protobuf:"bytes,5,opt,name=CgroupsPath,json=cgroupsPath,proto3" json:"CgroupsPath,omitempty"`
+	CgroupsPath string `protobuf:"bytes,5,opt,name=CgroupsPath,proto3" json:"CgroupsPath,omitempty"`
 	// Namespaces contains the namespaces that are created and/or joined by the container
-	Namespaces []LinuxNamespace `protobuf:"bytes,6,rep,name=Namespaces,json=namespaces,proto3" json:"Namespaces"`
+	Namespaces []LinuxNamespace `protobuf:"bytes,6,rep,name=Namespaces,proto3" json:"Namespaces"`
 	// Devices are a list of device nodes that are created for the container
-	Devices []LinuxDevice `protobuf:"bytes,7,rep,name=Devices,json=devices,proto3" json:"Devices"`
+	Devices []LinuxDevice `protobuf:"bytes,7,rep,name=Devices,proto3" json:"Devices"`
 	// Seccomp specifies the seccomp security settings for the container.
-	Seccomp *LinuxSeccomp `protobuf:"bytes,8,opt,name=Seccomp,json=seccomp,proto3" json:"Seccomp,omitempty"`
+	Seccomp *LinuxSeccomp `protobuf:"bytes,8,opt,name=Seccomp,proto3" json:"Seccomp,omitempty"`
 	// RootfsPropagation is the rootfs mount propagation mode for the container.
-	RootfsPropagation string `protobuf:"bytes,9,opt,name=RootfsPropagation,json=rootfsPropagation,proto3" json:"RootfsPropagation,omitempty"`
+	RootfsPropagation string `protobuf:"bytes,9,opt,name=RootfsPropagation,proto3" json:"RootfsPropagation,omitempty"`
 	// MaskedPaths masks over the provided paths inside the container.
-	MaskedPaths []string `protobuf:"bytes,10,rep,name=MaskedPaths,json=maskedPaths,proto3" json:"MaskedPaths,omitempty"`
+	MaskedPaths []string `protobuf:"bytes,10,rep,name=MaskedPaths,proto3" json:"MaskedPaths,omitempty"`
 	// ReadonlyPaths sets the provided paths as RO inside the container.
-	ReadonlyPaths []string `protobuf:"bytes,11,rep,name=ReadonlyPaths,json=readonlyPaths,proto3" json:"ReadonlyPaths,omitempty"`
+	ReadonlyPaths []string `protobuf:"bytes,11,rep,name=ReadonlyPaths,proto3" json:"ReadonlyPaths,omitempty"`
 	// MountLabel specifies the selinux context for the mounts in the container.
-	MountLabel string `protobuf:"bytes,12,opt,name=MountLabel,json=mountLabel,proto3" json:"MountLabel,omitempty"`
+	MountLabel string `protobuf:"bytes,12,opt,name=MountLabel,proto3" json:"MountLabel,omitempty"`
 	// IntelRdt contains Intel Resource Director Technology (RDT) information
 	// for handling resource constraints (e.g., L3 cache) for the container
-	IntelRdt             *LinuxIntelRdt `protobuf:"bytes,13,opt,name=IntelRdt,json=intelRdt,proto3" json:"IntelRdt,omitempty"`
+	IntelRdt             *LinuxIntelRdt `protobuf:"bytes,13,opt,name=IntelRdt,proto3" json:"IntelRdt,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
 	XXX_unrecognized     []byte         `json:"-"`
 	XXX_sizecache        int32          `json:"-"`
@@ -653,11 +653,11 @@ var xxx_messageInfo_Solaris proto.InternalMessageInfo
 
 type LinuxIDMapping struct {
 	// HostID is the starting UID/GID on the host to be mapped to 'ContainerID'
-	HostID uint32 `protobuf:"varint,1,opt,name=HostID,json=hostID,proto3" json:"HostID,omitempty"`
+	HostID uint32 `protobuf:"varint,1,opt,name=HostID,proto3" json:"HostID,omitempty"`
 	// ContainerID is the starting UID/GID in the container
-	ContainerID uint32 `protobuf:"varint,2,opt,name=ContainerID,json=containerID,proto3" json:"ContainerID,omitempty"`
+	ContainerID uint32 `protobuf:"varint,2,opt,name=ContainerID,proto3" json:"ContainerID,omitempty"`
 	// Size is the number of IDs to be mapped
-	Size_                uint32   `protobuf:"varint,3,opt,name=Size,json=size,proto3" json:"Size,omitempty"`
+	Size_                uint32   `protobuf:"varint,3,opt,name=Size,proto3" json:"Size,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -697,10 +697,10 @@ var xxx_messageInfo_LinuxIDMapping proto.InternalMessageInfo
 
 type LinuxNamespace struct {
 	// Type is the type of namespace
-	Type string `protobuf:"bytes,1,opt,name=Type,json=type,proto3" json:"Type,omitempty"`
+	Type string `protobuf:"bytes,1,opt,name=Type,proto3" json:"Type,omitempty"`
 	// Path is a path to an existing namespace persisted on disk that can be joined
 	// and is of the same type
-	Path                 string   `protobuf:"bytes,2,opt,name=Path,json=path,proto3" json:"Path,omitempty"`
+	Path                 string   `protobuf:"bytes,2,opt,name=Path,proto3" json:"Path,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -740,19 +740,19 @@ var xxx_messageInfo_LinuxNamespace proto.InternalMessageInfo
 
 type LinuxDevice struct {
 	// Path to the device.
-	Path string `protobuf:"bytes,1,opt,name=Path,json=path,proto3" json:"Path,omitempty"`
+	Path string `protobuf:"bytes,1,opt,name=Path,proto3" json:"Path,omitempty"`
 	// Device type, block, char, etc.
-	Type string `protobuf:"bytes,2,opt,name=Type,json=type,proto3" json:"Type,omitempty"`
+	Type string `protobuf:"bytes,2,opt,name=Type,proto3" json:"Type,omitempty"`
 	// Major is the device's major number.
-	Major int64 `protobuf:"varint,3,opt,name=Major,json=major,proto3" json:"Major,omitempty"`
+	Major int64 `protobuf:"varint,3,opt,name=Major,proto3" json:"Major,omitempty"`
 	// Minor is the device's minor number.
-	Minor int64 `protobuf:"varint,4,opt,name=Minor,json=minor,proto3" json:"Minor,omitempty"`
+	Minor int64 `protobuf:"varint,4,opt,name=Minor,proto3" json:"Minor,omitempty"`
 	// FileMode permission bits for the device.
-	FileMode uint32 `protobuf:"varint,5,opt,name=FileMode,json=fileMode,proto3" json:"FileMode,omitempty"`
+	FileMode uint32 `protobuf:"varint,5,opt,name=FileMode,proto3" json:"FileMode,omitempty"`
 	// UID of the device.
-	UID uint32 `protobuf:"varint,6,opt,name=UID,json=uID,proto3" json:"UID,omitempty"`
+	UID uint32 `protobuf:"varint,6,opt,name=UID,proto3" json:"UID,omitempty"`
 	// Gid of the device.
-	GID                  uint32   `protobuf:"varint,7,opt,name=GID,json=gID,proto3" json:"GID,omitempty"`
+	GID                  uint32   `protobuf:"varint,7,opt,name=GID,proto3" json:"GID,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -792,19 +792,19 @@ var xxx_messageInfo_LinuxDevice proto.InternalMessageInfo
 
 type LinuxResources struct {
 	// Devices configures the device whitelist.
-	Devices []LinuxDeviceCgroup `protobuf:"bytes,1,rep,name=Devices,json=devices,proto3" json:"Devices"`
+	Devices []LinuxDeviceCgroup `protobuf:"bytes,1,rep,name=Devices,proto3" json:"Devices"`
 	// Memory restriction configuration
-	Memory *LinuxMemory `protobuf:"bytes,2,opt,name=Memory,json=memory,proto3" json:"Memory,omitempty"`
+	Memory *LinuxMemory `protobuf:"bytes,2,opt,name=Memory,proto3" json:"Memory,omitempty"`
 	// CPU resource restriction configuration
-	CPU *LinuxCPU `protobuf:"bytes,3,opt,name=CPU,json=cPU,proto3" json:"CPU,omitempty"`
+	CPU *LinuxCPU `protobuf:"bytes,3,opt,name=CPU,proto3" json:"CPU,omitempty"`
 	// Task resource restriction configuration.
-	Pids *LinuxPids `protobuf:"bytes,4,opt,name=Pids,json=pids,proto3" json:"Pids,omitempty"`
+	Pids *LinuxPids `protobuf:"bytes,4,opt,name=Pids,proto3" json:"Pids,omitempty"`
 	// BlockIO restriction configuration
-	BlockIO *LinuxBlockIO `protobuf:"bytes,5,opt,name=BlockIO,json=blockIO,proto3" json:"BlockIO,omitempty"`
+	BlockIO *LinuxBlockIO `protobuf:"bytes,5,opt,name=BlockIO,proto3" json:"BlockIO,omitempty"`
 	// Hugetlb limit (in bytes)
-	HugepageLimits []LinuxHugepageLimit `protobuf:"bytes,6,rep,name=HugepageLimits,json=hugepageLimits,proto3" json:"HugepageLimits"`
+	HugepageLimits []LinuxHugepageLimit `protobuf:"bytes,6,rep,name=HugepageLimits,proto3" json:"HugepageLimits"`
 	// Network restriction configuration
-	Network              *LinuxNetwork `protobuf:"bytes,7,opt,name=Network,json=network,proto3" json:"Network,omitempty"`
+	Network              *LinuxNetwork `protobuf:"bytes,7,opt,name=Network,proto3" json:"Network,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
 	XXX_unrecognized     []byte        `json:"-"`
 	XXX_sizecache        int32         `json:"-"`
@@ -844,19 +844,19 @@ var xxx_messageInfo_LinuxResources proto.InternalMessageInfo
 
 type LinuxMemory struct {
 	// Memory limit (in bytes).
-	Limit int64 `protobuf:"varint,1,opt,name=Limit,json=limit,proto3" json:"Limit,omitempty"`
+	Limit int64 `protobuf:"varint,1,opt,name=Limit,proto3" json:"Limit,omitempty"`
 	// Memory reservation or soft_limit (in bytes).
-	Reservation int64 `protobuf:"varint,2,opt,name=Reservation,json=reservation,proto3" json:"Reservation,omitempty"`
+	Reservation int64 `protobuf:"varint,2,opt,name=Reservation,proto3" json:"Reservation,omitempty"`
 	// Total memory limit (memory + swap).
-	Swap int64 `protobuf:"varint,3,opt,name=Swap,json=swap,proto3" json:"Swap,omitempty"`
+	Swap int64 `protobuf:"varint,3,opt,name=Swap,proto3" json:"Swap,omitempty"`
 	// Kernel memory limit (in bytes).
-	Kernel int64 `protobuf:"varint,4,opt,name=Kernel,json=kernel,proto3" json:"Kernel,omitempty"`
+	Kernel int64 `protobuf:"varint,4,opt,name=Kernel,proto3" json:"Kernel,omitempty"`
 	// Kernel memory limit for tcp (in bytes)
-	KernelTCP int64 `protobuf:"varint,5,opt,name=KernelTCP,json=kernelTCP,proto3" json:"KernelTCP,omitempty"`
+	KernelTCP int64 `protobuf:"varint,5,opt,name=KernelTCP,proto3" json:"KernelTCP,omitempty"`
 	// How aggressive the kernel will swap memory pages.
-	Swappiness uint64 `protobuf:"varint,6,opt,name=Swappiness,json=swappiness,proto3" json:"Swappiness,omitempty"`
+	Swappiness uint64 `protobuf:"varint,6,opt,name=Swappiness,proto3" json:"Swappiness,omitempty"`
 	// DisableOOMKiller disables the OOM killer for out of memory conditions
-	DisableOOMKiller     bool     `protobuf:"varint,7,opt,name=DisableOOMKiller,json=disableOOMKiller,proto3" json:"DisableOOMKiller,omitempty"`
+	DisableOOMKiller     bool     `protobuf:"varint,7,opt,name=DisableOOMKiller,proto3" json:"DisableOOMKiller,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -896,19 +896,19 @@ var xxx_messageInfo_LinuxMemory proto.InternalMessageInfo
 
 type LinuxCPU struct {
 	// CPU shares (relative weight (ratio) vs. other cgroups with cpu shares).
-	Shares uint64 `protobuf:"varint,1,opt,name=Shares,json=shares,proto3" json:"Shares,omitempty"`
+	Shares uint64 `protobuf:"varint,1,opt,name=Shares,proto3" json:"Shares,omitempty"`
 	// CPU hardcap limit (in usecs). Allowed cpu time in a given period.
-	Quota int64 `protobuf:"varint,2,opt,name=Quota,json=quota,proto3" json:"Quota,omitempty"`
+	Quota int64 `protobuf:"varint,2,opt,name=Quota,proto3" json:"Quota,omitempty"`
 	// CPU period to be used for hardcapping (in usecs).
-	Period uint64 `protobuf:"varint,3,opt,name=Period,json=period,proto3" json:"Period,omitempty"`
+	Period uint64 `protobuf:"varint,3,opt,name=Period,proto3" json:"Period,omitempty"`
 	// How much time realtime scheduling may use (in usecs).
-	RealtimeRuntime int64 `protobuf:"varint,4,opt,name=RealtimeRuntime,json=realtimeRuntime,proto3" json:"RealtimeRuntime,omitempty"`
+	RealtimeRuntime int64 `protobuf:"varint,4,opt,name=RealtimeRuntime,proto3" json:"RealtimeRuntime,omitempty"`
 	// CPU period to be used for realtime scheduling (in usecs).
-	RealtimePeriod uint64 `protobuf:"varint,5,opt,name=RealtimePeriod,json=realtimePeriod,proto3" json:"RealtimePeriod,omitempty"`
+	RealtimePeriod uint64 `protobuf:"varint,5,opt,name=RealtimePeriod,proto3" json:"RealtimePeriod,omitempty"`
 	// CPUs to use within the cpuset. Default is to use any CPU available.
-	Cpus string `protobuf:"bytes,6,opt,name=Cpus,json=cpus,proto3" json:"Cpus,omitempty"`
+	Cpus string `protobuf:"bytes,6,opt,name=Cpus,proto3" json:"Cpus,omitempty"`
 	// List of memory nodes in the cpuset. Default is to use any available memory node.
-	Mems                 string   `protobuf:"bytes,7,opt,name=Mems,json=mems,proto3" json:"Mems,omitempty"`
+	Mems                 string   `protobuf:"bytes,7,opt,name=Mems,proto3" json:"Mems,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -948,13 +948,13 @@ var xxx_messageInfo_LinuxCPU proto.InternalMessageInfo
 
 type LinuxWeightDevice struct {
 	// Major is the device's major number.
-	Major int64 `protobuf:"varint,1,opt,name=Major,json=major,proto3" json:"Major,omitempty"`
+	Major int64 `protobuf:"varint,1,opt,name=Major,proto3" json:"Major,omitempty"`
 	// Minor is the device's minor number.
-	Minor int64 `protobuf:"varint,2,opt,name=Minor,json=minor,proto3" json:"Minor,omitempty"`
+	Minor int64 `protobuf:"varint,2,opt,name=Minor,proto3" json:"Minor,omitempty"`
 	// Weight is the bandwidth rate for the device.
-	Weight uint32 `protobuf:"varint,3,opt,name=Weight,json=weight,proto3" json:"Weight,omitempty"`
+	Weight uint32 `protobuf:"varint,3,opt,name=Weight,proto3" json:"Weight,omitempty"`
 	// LeafWeight is the bandwidth rate for the device while competing with the cgroup's child cgroups, CFQ scheduler only
-	LeafWeight           uint32   `protobuf:"varint,4,opt,name=LeafWeight,json=leafWeight,proto3" json:"LeafWeight,omitempty"`
+	LeafWeight           uint32   `protobuf:"varint,4,opt,name=LeafWeight,proto3" json:"LeafWeight,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -994,11 +994,11 @@ var xxx_messageInfo_LinuxWeightDevice proto.InternalMessageInfo
 
 type LinuxThrottleDevice struct {
 	// Major is the device's major number.
-	Major int64 `protobuf:"varint,1,opt,name=Major,json=major,proto3" json:"Major,omitempty"`
+	Major int64 `protobuf:"varint,1,opt,name=Major,proto3" json:"Major,omitempty"`
 	// Minor is the device's minor number.
-	Minor int64 `protobuf:"varint,2,opt,name=Minor,json=minor,proto3" json:"Minor,omitempty"`
+	Minor int64 `protobuf:"varint,2,opt,name=Minor,proto3" json:"Minor,omitempty"`
 	// Rate is the IO rate limit per cgroup per device
-	Rate                 uint64   `protobuf:"varint,3,opt,name=Rate,json=rate,proto3" json:"Rate,omitempty"`
+	Rate                 uint64   `protobuf:"varint,3,opt,name=Rate,proto3" json:"Rate,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1038,19 +1038,19 @@ var xxx_messageInfo_LinuxThrottleDevice proto.InternalMessageInfo
 
 type LinuxBlockIO struct {
 	// Specifies per cgroup weight
-	Weight uint32 `protobuf:"varint,1,opt,name=Weight,json=weight,proto3" json:"Weight,omitempty"`
+	Weight uint32 `protobuf:"varint,1,opt,name=Weight,proto3" json:"Weight,omitempty"`
 	// Specifies tasks' weight in the given cgroup while competing with the cgroup's child cgroups, CFQ scheduler only
-	LeafWeight uint32 `protobuf:"varint,2,opt,name=LeafWeight,json=leafWeight,proto3" json:"LeafWeight,omitempty"`
+	LeafWeight uint32 `protobuf:"varint,2,opt,name=LeafWeight,proto3" json:"LeafWeight,omitempty"`
 	// Weight per cgroup per device, can override BlkioWeight
-	WeightDevice []LinuxWeightDevice `protobuf:"bytes,3,rep,name=WeightDevice,json=weightDevice,proto3" json:"WeightDevice"`
+	WeightDevice []LinuxWeightDevice `protobuf:"bytes,3,rep,name=WeightDevice,proto3" json:"WeightDevice"`
 	// IO read rate limit per cgroup per device, bytes per second
-	ThrottleReadBpsDevice []LinuxThrottleDevice `protobuf:"bytes,4,rep,name=ThrottleReadBpsDevice,json=throttleReadBpsDevice,proto3" json:"ThrottleReadBpsDevice"`
+	ThrottleReadBpsDevice []LinuxThrottleDevice `protobuf:"bytes,4,rep,name=ThrottleReadBpsDevice,proto3" json:"ThrottleReadBpsDevice"`
 	// IO write rate limit per cgroup per device, bytes per second
-	ThrottleWriteBpsDevice []LinuxThrottleDevice `protobuf:"bytes,5,rep,name=ThrottleWriteBpsDevice,json=throttleWriteBpsDevice,proto3" json:"ThrottleWriteBpsDevice"`
+	ThrottleWriteBpsDevice []LinuxThrottleDevice `protobuf:"bytes,5,rep,name=ThrottleWriteBpsDevice,proto3" json:"ThrottleWriteBpsDevice"`
 	// IO read rate limit per cgroup per device, IO per second
-	ThrottleReadIOPSDevice []LinuxThrottleDevice `protobuf:"bytes,6,rep,name=ThrottleReadIOPSDevice,json=throttleReadIOPSDevice,proto3" json:"ThrottleReadIOPSDevice"`
+	ThrottleReadIOPSDevice []LinuxThrottleDevice `protobuf:"bytes,6,rep,name=ThrottleReadIOPSDevice,proto3" json:"ThrottleReadIOPSDevice"`
 	// IO write rate limit per cgroup per device, IO per second
-	ThrottleWriteIOPSDevice []LinuxThrottleDevice `protobuf:"bytes,7,rep,name=ThrottleWriteIOPSDevice,json=throttleWriteIOPSDevice,proto3" json:"ThrottleWriteIOPSDevice"`
+	ThrottleWriteIOPSDevice []LinuxThrottleDevice `protobuf:"bytes,7,rep,name=ThrottleWriteIOPSDevice,proto3" json:"ThrottleWriteIOPSDevice"`
 	XXX_NoUnkeyedLiteral    struct{}              `json:"-"`
 	XXX_unrecognized        []byte                `json:"-"`
 	XXX_sizecache           int32                 `json:"-"`
@@ -1090,7 +1090,7 @@ var xxx_messageInfo_LinuxBlockIO proto.InternalMessageInfo
 
 type LinuxPids struct {
 	// Maximum number of PIDs. Default is "no limit".
-	Limit                int64    `protobuf:"varint,1,opt,name=Limit,json=limit,proto3" json:"Limit,omitempty"`
+	Limit                int64    `protobuf:"varint,1,opt,name=Limit,proto3" json:"Limit,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1130,15 +1130,15 @@ var xxx_messageInfo_LinuxPids proto.InternalMessageInfo
 
 type LinuxDeviceCgroup struct {
 	// Allow or deny
-	Allow bool `protobuf:"varint,1,opt,name=Allow,json=allow,proto3" json:"Allow,omitempty"`
+	Allow bool `protobuf:"varint,1,opt,name=Allow,proto3" json:"Allow,omitempty"`
 	// Device type, block, char, etc.
-	Type string `protobuf:"bytes,2,opt,name=Type,json=type,proto3" json:"Type,omitempty"`
+	Type string `protobuf:"bytes,2,opt,name=Type,proto3" json:"Type,omitempty"`
 	// Major is the device's major number.
-	Major int64 `protobuf:"varint,3,opt,name=Major,json=major,proto3" json:"Major,omitempty"`
+	Major int64 `protobuf:"varint,3,opt,name=Major,proto3" json:"Major,omitempty"`
 	// Minor is the device's minor number.
-	Minor int64 `protobuf:"varint,4,opt,name=Minor,json=minor,proto3" json:"Minor,omitempty"`
+	Minor int64 `protobuf:"varint,4,opt,name=Minor,proto3" json:"Minor,omitempty"`
 	// Cgroup access permissions format, rwm.
-	Access               string   `protobuf:"bytes,5,opt,name=Access,json=access,proto3" json:"Access,omitempty"`
+	Access               string   `protobuf:"bytes,5,opt,name=Access,proto3" json:"Access,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1178,9 +1178,9 @@ var xxx_messageInfo_LinuxDeviceCgroup proto.InternalMessageInfo
 
 type LinuxNetwork struct {
 	// Set class identifier for container's network packets
-	ClassID uint32 `protobuf:"varint,1,opt,name=ClassID,json=classID,proto3" json:"ClassID,omitempty"`
+	ClassID uint32 `protobuf:"varint,1,opt,name=ClassID,proto3" json:"ClassID,omitempty"`
 	// Set priority of network traffic for container
-	Priorities           []LinuxInterfacePriority `protobuf:"bytes,2,rep,name=Priorities,json=priorities,proto3" json:"Priorities"`
+	Priorities           []LinuxInterfacePriority `protobuf:"bytes,2,rep,name=Priorities,proto3" json:"Priorities"`
 	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
 	XXX_unrecognized     []byte                   `json:"-"`
 	XXX_sizecache        int32                    `json:"-"`
@@ -1220,9 +1220,9 @@ var xxx_messageInfo_LinuxNetwork proto.InternalMessageInfo
 
 type LinuxHugepageLimit struct {
 	// Pagesize is the hugepage size
-	Pagesize string `protobuf:"bytes,1,opt,name=Pagesize,json=pagesize,proto3" json:"Pagesize,omitempty"`
+	Pagesize string `protobuf:"bytes,1,opt,name=Pagesize,proto3" json:"Pagesize,omitempty"`
 	// Limit is the limit of "hugepagesize" hugetlb usage
-	Limit                uint64   `protobuf:"varint,2,opt,name=Limit,json=limit,proto3" json:"Limit,omitempty"`
+	Limit                uint64   `protobuf:"varint,2,opt,name=Limit,proto3" json:"Limit,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1262,9 +1262,9 @@ var xxx_messageInfo_LinuxHugepageLimit proto.InternalMessageInfo
 
 type LinuxInterfacePriority struct {
 	// Name is the name of the network interface
-	Name string `protobuf:"bytes,1,opt,name=Name,json=name,proto3" json:"Name,omitempty"`
+	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
 	// Priority for the interface
-	Priority             uint32   `protobuf:"varint,2,opt,name=Priority,json=priority,proto3" json:"Priority,omitempty"`
+	Priority             uint32   `protobuf:"varint,2,opt,name=Priority,proto3" json:"Priority,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1303,10 +1303,10 @@ func (m *LinuxInterfacePriority) XXX_DiscardUnknown() {
 var xxx_messageInfo_LinuxInterfacePriority proto.InternalMessageInfo
 
 type LinuxSeccomp struct {
-	DefaultAction        string         `protobuf:"bytes,1,opt,name=DefaultAction,json=defaultAction,proto3" json:"DefaultAction,omitempty"`
-	Architectures        []string       `protobuf:"bytes,2,rep,name=Architectures,json=architectures,proto3" json:"Architectures,omitempty"`
-	Flags                []string       `protobuf:"bytes,3,rep,name=Flags,json=flags,proto3" json:"Flags,omitempty"`
-	Syscalls             []LinuxSyscall `protobuf:"bytes,4,rep,name=Syscalls,json=syscalls,proto3" json:"Syscalls"`
+	DefaultAction        string         `protobuf:"bytes,1,opt,name=DefaultAction,proto3" json:"DefaultAction,omitempty"`
+	Architectures        []string       `protobuf:"bytes,2,rep,name=Architectures,proto3" json:"Architectures,omitempty"`
+	Flags                []string       `protobuf:"bytes,3,rep,name=Flags,proto3" json:"Flags,omitempty"`
+	Syscalls             []LinuxSyscall `protobuf:"bytes,4,rep,name=Syscalls,proto3" json:"Syscalls"`
 	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
 	XXX_unrecognized     []byte         `json:"-"`
 	XXX_sizecache        int32          `json:"-"`
@@ -1345,10 +1345,10 @@ func (m *LinuxSeccomp) XXX_DiscardUnknown() {
 var xxx_messageInfo_LinuxSeccomp proto.InternalMessageInfo
 
 type LinuxSeccompArg struct {
-	Index                uint64   `protobuf:"varint,1,opt,name=Index,json=index,proto3" json:"Index,omitempty"`
-	Value                uint64   `protobuf:"varint,2,opt,name=Value,json=value,proto3" json:"Value,omitempty"`
-	ValueTwo             uint64   `protobuf:"varint,3,opt,name=ValueTwo,json=valueTwo,proto3" json:"ValueTwo,omitempty"`
-	Op                   string   `protobuf:"bytes,4,opt,name=Op,json=op,proto3" json:"Op,omitempty"`
+	Index                uint64   `protobuf:"varint,1,opt,name=Index,proto3" json:"Index,omitempty"`
+	Value                uint64   `protobuf:"varint,2,opt,name=Value,proto3" json:"Value,omitempty"`
+	ValueTwo             uint64   `protobuf:"varint,3,opt,name=ValueTwo,proto3" json:"ValueTwo,omitempty"`
+	Op                   string   `protobuf:"bytes,4,opt,name=Op,proto3" json:"Op,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1387,12 +1387,12 @@ func (m *LinuxSeccompArg) XXX_DiscardUnknown() {
 var xxx_messageInfo_LinuxSeccompArg proto.InternalMessageInfo
 
 type LinuxSyscall struct {
-	Names  []string `protobuf:"bytes,1,rep,name=Names,json=names,proto3" json:"Names,omitempty"`
-	Action string   `protobuf:"bytes,2,opt,name=Action,json=action,proto3" json:"Action,omitempty"`
+	Names  []string `protobuf:"bytes,1,rep,name=Names,proto3" json:"Names,omitempty"`
+	Action string   `protobuf:"bytes,2,opt,name=Action,proto3" json:"Action,omitempty"`
 	// Types that are valid to be assigned to ErrnoRet:
 	//	*LinuxSyscall_Errnoret
 	ErrnoRet             isLinuxSyscall_ErrnoRet `protobuf_oneof:"ErrnoRet"`
-	Args                 []LinuxSeccompArg       `protobuf:"bytes,4,rep,name=Args,json=args,proto3" json:"Args"`
+	Args                 []LinuxSeccompArg       `protobuf:"bytes,4,rep,name=Args,proto3" json:"Args"`
 	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
 	XXX_unrecognized     []byte                  `json:"-"`
 	XXX_sizecache        int32                   `json:"-"`
@@ -1467,7 +1467,7 @@ func (*LinuxSyscall) XXX_OneofWrappers() []interface{} {
 type LinuxIntelRdt struct {
 	// The schema for L3 cache id and capacity bitmask (CBM)
 	// Format: "L3:<cache_id0>=<cbm0>;<cache_id1>=<cbm1>;..."
-	L3CacheSchema        string   `protobuf:"bytes,1,opt,name=L3CacheSchema,json=l3CacheSchema,proto3" json:"L3CacheSchema,omitempty"`
+	L3CacheSchema        string   `protobuf:"bytes,1,opt,name=L3CacheSchema,proto3" json:"L3CacheSchema,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1546,150 +1546,140 @@ func init() {
 }
 
 var fileDescriptor_e42fef2823778fc8 = []byte{
-	// 2282 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xcd, 0x73, 0x23, 0x47,
-	0xd9, 0xdf, 0xd1, 0x8c, 0xa4, 0x51, 0xcb, 0x1f, 0xbb, 0x9d, 0xc4, 0xd1, 0xbb, 0x6f, 0x4a, 0x71,
-	0x86, 0x14, 0x18, 0x58, 0xec, 0x62, 0xc3, 0x47, 0x08, 0x1f, 0x55, 0xb2, 0xbd, 0x1b, 0xab, 0xb2,
-	0x5e, 0x8b, 0x96, 0x9d, 0x85, 0x1c, 0x52, 0xd5, 0x9e, 0x69, 0x49, 0x13, 0x8f, 0xa6, 0x87, 0xee,
-	0x96, 0xb5, 0xce, 0x09, 0x6e, 0xdc, 0x39, 0x70, 0xe6, 0xc2, 0xc7, 0x7f, 0x40, 0x71, 0xe2, 0xc6,
-	0x16, 0x27, 0x8e, 0x54, 0x51, 0x05, 0xac, 0xef, 0xdc, 0x39, 0x52, 0x4f, 0x77, 0xcf, 0xa8, 0x65,
-	0x7b, 0x21, 0x0b, 0x27, 0xcd, 0xf3, 0x7b, 0x9e, 0x7e, 0xba, 0xfb, 0xf9, 0x6e, 0xa1, 0xa3, 0x71,
-	0xaa, 0x26, 0xb3, 0xd3, 0xed, 0x98, 0x4f, 0x77, 0xce, 0xa8, 0xa2, 0x5f, 0x89, 0x79, 0xae, 0x68,
-	0x9a, 0x33, 0x21, 0xaf, 0xd1, 0x52, 0xc4, 0x3b, 0x74, 0xcc, 0x72, 0xb5, 0x53, 0x08, 0xae, 0x78,
-	0xcc, 0x33, 0x69, 0xbe, 0xe4, 0x0e, 0x8f, 0xd3, 0x6d, 0xfd, 0x89, 0x83, 0xb1, 0x28, 0xe2, 0xbb,
-	0xd1, 0x98, 0x8f, 0xb9, 0x61, 0x9e, 0xce, 0x46, 0x3b, 0x40, 0x69, 0x42, 0x7f, 0x19, 0xc9, 0xe8,
-	0x0f, 0x3e, 0x0a, 0x86, 0x05, 0x8b, 0x71, 0x07, 0x35, 0x3f, 0x64, 0x42, 0xa6, 0x3c, 0xef, 0x78,
-	0x9b, 0xde, 0x56, 0x8b, 0x34, 0xcf, 0x0d, 0x89, 0xbf, 0x80, 0x9a, 0x03, 0xc1, 0x63, 0x26, 0x65,
-	0xa7, 0xb6, 0xe9, 0x6d, 0xb5, 0xef, 0xaf, 0x6e, 0x83, 0xfa, 0x6d, 0x0b, 0x92, 0x66, 0x61, 0x3e,
-	0x70, 0x17, 0x05, 0x84, 0x73, 0xd5, 0xf1, 0xb5, 0x14, 0x32, 0x52, 0x80, 0x90, 0x40, 0x70, 0xae,
-	0xf0, 0x5d, 0x14, 0x1e, 0x70, 0xa9, 0x72, 0x3a, 0x65, 0x9d, 0x40, 0xef, 0x11, 0x4e, 0x2c, 0x8d,
-	0xbf, 0x88, 0x1a, 0x87, 0x7c, 0x96, 0x2b, 0xd9, 0xa9, 0x6f, 0xfa, 0x5b, 0xed, 0xfb, 0x6d, 0xb3,
-	0x5a, 0x63, 0xbb, 0xc1, 0xb3, 0xbf, 0xbe, 0x79, 0x8b, 0x34, 0xa6, 0x5a, 0x00, 0xbf, 0x85, 0xea,
-	0x07, 0x9c, 0x9f, 0xc9, 0x4e, 0x43, 0xef, 0x63, 0x25, 0x35, 0x44, 0xea, 0x13, 0xf8, 0xc1, 0xdf,
-	0x45, 0xed, 0x5e, 0x9e, 0x73, 0x45, 0x55, 0xca, 0x73, 0xd9, 0x69, 0x6a, 0x95, 0xff, 0x6f, 0x04,
-	0xe1, 0xb6, 0xdb, 0x0e, 0xf7, 0x41, 0xae, 0xc4, 0x05, 0x69, 0xd3, 0x05, 0x02, 0x3b, 0x3c, 0x4a,
-	0xf3, 0xd9, 0xd3, 0x4e, 0xe8, 0xee, 0xa0, 0x21, 0x52, 0xcf, 0xe0, 0x07, 0x8c, 0x32, 0xe4, 0x19,
-	0x15, 0xa9, 0xec, 0xb4, 0x5c, 0xa3, 0x58, 0x90, 0x34, 0xa5, 0xf9, 0x00, 0xc1, 0x27, 0x69, 0x9e,
-	0xf0, 0xb9, 0xec, 0x20, 0x57, 0xd0, 0x82, 0xa4, 0x39, 0x37, 0x1f, 0x77, 0xbf, 0x87, 0x6e, 0x5f,
-	0x3d, 0x15, 0xbe, 0x8d, 0xfc, 0x33, 0x76, 0x61, 0x1d, 0x02, 0x9f, 0xf8, 0x55, 0x54, 0x3f, 0xa7,
-	0xd9, 0x8c, 0x69, 0x57, 0xb4, 0x88, 0x21, 0xde, 0xab, 0xbd, 0xeb, 0x45, 0xbf, 0xf3, 0x2b, 0x3f,
-	0x81, 0xa5, 0x8f, 0x99, 0x98, 0xa6, 0x39, 0xcd, 0xf4, 0xe2, 0x90, 0x84, 0xca, 0xd2, 0xf8, 0xcb,
-	0xa8, 0xbd, 0xc7, 0x73, 0xc9, 0x33, 0x36, 0x4c, 0x3f, 0x65, 0xd6, 0xa5, 0x2d, 0x73, 0xa8, 0x5d,
-	0xfe, 0x94, 0xb4, 0xe3, 0x05, 0x17, 0xbf, 0x8d, 0x82, 0x13, 0xc9, 0xc4, 0xb2, 0x4b, 0x01, 0xb1,
-	0x3e, 0x09, 0x66, 0x92, 0x09, 0x8c, 0x51, 0xd0, 0x13, 0x63, 0xd9, 0x09, 0x36, 0xfd, 0xad, 0x16,
-	0x09, 0xa8, 0x18, 0x4b, 0x38, 0xfa, 0x83, 0xfc, 0x5c, 0x7b, 0xb3, 0x45, 0x7c, 0x96, 0x9f, 0x03,
-	0xb2, 0x37, 0x4f, 0xb4, 0xd7, 0x5a, 0xc4, 0x8f, 0xe7, 0x09, 0xfe, 0x36, 0x5a, 0xd9, 0xa3, 0x05,
-	0x3d, 0x4d, 0xb3, 0x54, 0xa5, 0x0c, 0xfc, 0x04, 0xbb, 0xbc, 0xee, 0x98, 0xdb, 0x65, 0x93, 0x95,
-	0xd8, 0xa1, 0xf0, 0x57, 0x51, 0x93, 0x64, 0xe9, 0x34, 0x55, 0xb2, 0x13, 0x6a, 0xff, 0xde, 0xb1,
-	0x61, 0x79, 0x34, 0xec, 0xff, 0xc0, 0x70, 0xec, 0x21, 0x9b, 0xc2, 0xc8, 0xe1, 0x2d, 0xb4, 0xfe,
-	0x98, 0x3f, 0x66, 0xf3, 0x81, 0x48, 0xcf, 0xd3, 0x8c, 0x8d, 0x99, 0x71, 0x5e, 0x48, 0xd6, 0xf3,
-	0x65, 0x18, 0x24, 0x7b, 0x45, 0x41, 0xc5, 0x94, 0x8b, 0x81, 0xe0, 0xa3, 0x34, 0x63, 0xda, 0x7b,
-	0x2d, 0xb2, 0x4e, 0x97, 0x61, 0xbc, 0x89, 0xda, 0x47, 0x47, 0x87, 0xc3, 0x98, 0x0b, 0xd6, 0x4b,
-	0x3e, 0xe9, 0xb4, 0x37, 0xbd, 0x2d, 0x9f, 0xb4, 0xf9, 0x02, 0xc2, 0x11, 0x5a, 0x19, 0x32, 0x1d,
-	0x35, 0x8f, 0xe8, 0x29, 0xcb, 0x3a, 0x2b, 0x5a, 0xd1, 0x8a, 0x74, 0xb0, 0xe8, 0x1d, 0xe4, 0xef,
-	0xf2, 0xa7, 0x78, 0x03, 0x35, 0x0e, 0x58, 0x3a, 0x9e, 0x28, 0xed, 0xb5, 0x55, 0xd2, 0x98, 0x68,
-	0x0a, 0xbc, 0xfe, 0x24, 0x4d, 0xd4, 0x44, 0x7b, 0x6b, 0x95, 0xd4, 0xe7, 0x40, 0x44, 0xb9, 0x71,
-	0x0e, 0x18, 0xf6, 0xa4, 0xbf, 0x6f, 0x97, 0xf8, 0xb3, 0xfe, 0x3e, 0x20, 0xef, 0xf7, 0xf7, 0xad,
-	0xb4, 0x3f, 0xee, 0xef, 0xe3, 0xcf, 0xa3, 0xb5, 0x5e, 0x92, 0xa4, 0x10, 0x5b, 0x34, 0x7b, 0x3f,
-	0x4d, 0x64, 0xc7, 0xdf, 0xf4, 0xb7, 0x56, 0xc9, 0x1a, 0x5d, 0x42, 0x21, 0x72, 0x40, 0xa7, 0x9b,
-	0xa3, 0x33, 0x4b, 0x47, 0xbf, 0xf2, 0xd0, 0x9d, 0x6b, 0x5e, 0x81, 0x15, 0xbb, 0x7c, 0x96, 0x27,
-	0x69, 0x3e, 0xee, 0x78, 0xda, 0xdb, 0xe1, 0xa9, 0xa5, 0xf1, 0x1b, 0xa8, 0xf5, 0x60, 0x34, 0x62,
-	0xb1, 0x4a, 0xcf, 0x21, 0xd2, 0x80, 0xd9, 0x62, 0x25, 0x00, 0xa6, 0xeb, 0xe7, 0x13, 0x26, 0x52,
-	0x45, 0x4f, 0x33, 0xa6, 0x0f, 0xd4, 0x22, 0xed, 0x74, 0x01, 0xc1, 0xfa, 0x01, 0xc4, 0xad, 0x52,
-	0x2c, 0xb1, 0xd1, 0xd5, 0x2a, 0x4a, 0x00, 0x4a, 0x56, 0x6f, 0x7a, 0x9a, 0xb2, 0x5c, 0xd9, 0x30,
-	0x6b, 0x52, 0x43, 0x46, 0x7d, 0xd4, 0x76, 0xc2, 0x00, 0xe2, 0xf3, 0xf8, 0xa2, 0x60, 0x36, 0x8f,
-	0x02, 0x75, 0x51, 0x30, 0xc0, 0x0e, 0xa8, 0x48, 0xb4, 0x8d, 0x02, 0x12, 0x4c, 0xa8, 0x48, 0x00,
-	0x1b, 0xf2, 0x91, 0x29, 0x60, 0x01, 0x09, 0x24, 0x1f, 0xa9, 0x88, 0xa3, 0xba, 0x2e, 0x42, 0x70,
-	0xda, 0x84, 0x49, 0x95, 0xe6, 0x3a, 0x41, 0xad, 0x2e, 0x17, 0x02, 0xef, 0x49, 0x3e, 0x13, 0x71,
-	0x99, 0x9c, 0x96, 0x02, 0xb5, 0xb0, 0xa5, 0x56, 0x5b, 0x6e, 0xdf, 0x41, 0x4d, 0x5e, 0x98, 0xea,
-	0x64, 0xee, 0x55, 0x92, 0xd1, 0x37, 0x4c, 0x15, 0x85, 0x55, 0x03, 0xaa, 0x26, 0xe5, 0xa1, 0x0b,
-	0xaa, 0x26, 0x60, 0x6b, 0xc2, 0x68, 0xc2, 0xf3, 0xec, 0x42, 0xef, 0x11, 0x92, 0x50, 0x58, 0x3a,
-	0xfa, 0x99, 0x67, 0xeb, 0x22, 0xbe, 0x87, 0xc2, 0x81, 0x60, 0x52, 0x51, 0xa1, 0xb4, 0x47, 0xaa,
-	0xc4, 0x05, 0xb6, 0xcd, 0x89, 0xb0, 0xb0, 0x12, 0x78, 0x1b, 0xb5, 0x06, 0x5c, 0x2a, 0x23, 0x5e,
-	0x7b, 0x81, 0x78, 0xab, 0x28, 0x45, 0xb4, 0x76, 0x4d, 0xf0, 0x42, 0xbb, 0xec, 0x66, 0xed, 0x56,
-	0x22, 0xfa, 0x08, 0x05, 0x80, 0xdf, 0x78, 0x9b, 0xb2, 0x6c, 0xd4, 0xae, 0x97, 0x0d, 0x7f, 0x51,
-	0x36, 0x3a, 0xa8, 0x79, 0x9c, 0x4e, 0x19, 0x9f, 0x29, 0x1d, 0x90, 0x3e, 0x69, 0x2a, 0x43, 0x46,
-	0xbf, 0xa9, 0xdb, 0x3a, 0x8d, 0xbf, 0x83, 0xda, 0x27, 0xfd, 0xfd, 0x43, 0x5a, 0x14, 0x69, 0x3e,
-	0x96, 0xf6, 0xd2, 0xaf, 0x3a, 0x75, 0xa4, 0x62, 0xda, 0x03, 0xb6, 0x67, 0x0b, 0x71, 0x58, 0xfd,
-	0xbe, 0xb3, 0xba, 0xf6, 0x9f, 0x57, 0x8f, 0x9d, 0xd5, 0x3b, 0xa8, 0x31, 0xbc, 0x90, 0xb1, 0xca,
-	0xac, 0x35, 0xdc, 0xf2, 0xb5, 0x6d, 0x38, 0xa6, 0xc5, 0x34, 0xa4, 0x26, 0xf0, 0x7d, 0xd4, 0x22,
-	0xcc, 0x84, 0x86, 0xd4, 0x57, 0x5a, 0xde, 0xac, 0xe2, 0x91, 0x96, 0x28, 0x3f, 0x21, 0xf8, 0xf6,
-	0xc6, 0x82, 0xcf, 0x0a, 0xa9, 0xad, 0x58, 0x37, 0xc1, 0x17, 0x2f, 0x20, 0xfc, 0x1e, 0x42, 0x8f,
-	0xe9, 0x94, 0xc9, 0x82, 0x82, 0xda, 0xc6, 0xb5, 0x3b, 0x54, 0x4c, 0x7b, 0x07, 0x94, 0x57, 0xd2,
-	0x50, 0x4a, 0xf7, 0xd9, 0x79, 0x1a, 0xb3, 0xb2, 0x55, 0xde, 0x71, 0x16, 0x1a, 0x4e, 0x59, 0x4a,
-	0x13, 0x23, 0x87, 0xef, 0xa1, 0xe6, 0x90, 0xc5, 0x31, 0x9f, 0x16, 0xb6, 0x49, 0x62, 0x67, 0x89,
-	0xe5, 0x90, 0xa6, 0x34, 0x1f, 0xf8, 0x1e, 0xba, 0x03, 0x31, 0x3d, 0x92, 0x03, 0xc1, 0x0b, 0x3a,
-	0x36, 0x19, 0xd4, 0xd2, 0x97, 0xb8, 0x23, 0xae, 0x32, 0xe0, 0xb2, 0x87, 0x54, 0x9e, 0xb1, 0x04,
-	0x2e, 0x06, 0x6d, 0x53, 0xd7, 0x85, 0xe9, 0x02, 0xc2, 0x6f, 0xa3, 0xd5, 0x32, 0x0f, 0x8c, 0x4c,
-	0x5b, 0xcb, 0xac, 0x0a, 0x17, 0xc4, 0x5d, 0x84, 0x74, 0xea, 0xba, 0x65, 0x17, 0x4d, 0x2b, 0x04,
-	0xef, 0xa0, 0xb0, 0x9f, 0x2b, 0x96, 0x91, 0x44, 0x75, 0x56, 0xf5, 0x25, 0x5e, 0x71, 0x9d, 0x6e,
-	0x59, 0x24, 0x4c, 0xed, 0xd7, 0xdd, 0x6f, 0xa1, 0xb6, 0xe3, 0xd0, 0x97, 0xea, 0xce, 0x6f, 0x56,
-	0x63, 0x00, 0x08, 0x25, 0xb3, 0xe9, 0xb4, 0x5c, 0x68, 0x08, 0x10, 0xb0, 0xb3, 0xc3, 0x0b, 0x04,
-	0x3e, 0x46, 0x6b, 0xcb, 0xc1, 0xa8, 0xbb, 0x05, 0x97, 0xaa, 0x2a, 0xfd, 0x8d, 0x89, 0xa6, 0x74,
-	0xb0, 0x94, 0x03, 0x63, 0xd5, 0x05, 0xda, 0xf1, 0x02, 0xd2, 0x85, 0x0e, 0x9a, 0xbf, 0xaf, 0x59,
-	0x81, 0x4c, 0x3f, 0x65, 0xd1, 0xbb, 0x56, 0x7f, 0x15, 0x28, 0x2f, 0x2a, 0x9b, 0x3a, 0x02, 0x6b,
-	0x8b, 0x3c, 0x8e, 0x7e, 0xe1, 0xa1, 0xb6, 0x13, 0x2a, 0x2f, 0xca, 0x75, 0xad, 0xab, 0xe6, 0xe8,
-	0x7a, 0x15, 0xd5, 0x0f, 0xe9, 0x27, 0xdc, 0x4c, 0x17, 0x3e, 0xa9, 0x4f, 0x81, 0xd0, 0x68, 0x9a,
-	0x73, 0x61, 0xb3, 0xbd, 0x3e, 0x05, 0x02, 0x2a, 0xdf, 0xc3, 0x34, 0x63, 0x87, 0x3c, 0x61, 0x3a,
-	0xfa, 0x57, 0x49, 0x38, 0xb2, 0x74, 0xd9, 0xff, 0x1a, 0xd7, 0xfa, 0x5f, 0xb3, 0xea, 0x7f, 0xd1,
-	0xdf, 0x6a, 0xf6, 0x7a, 0x55, 0x7a, 0xe1, 0x6f, 0x2e, 0xa2, 0xde, 0xbb, 0x96, 0xb9, 0x86, 0x63,
-	0x72, 0xee, 0x6a, 0xec, 0xc3, 0xac, 0xca, 0xa6, 0x5c, 0x5c, 0xd8, 0xe1, 0xc9, 0xcd, 0x16, 0xc3,
-	0x20, 0x8d, 0xa9, 0xfe, 0xc5, 0x9b, 0xc8, 0xdf, 0x1b, 0x9c, 0xd8, 0xf1, 0x69, 0xcd, 0x1d, 0x6c,
-	0x06, 0x27, 0xc4, 0x8f, 0x07, 0x27, 0xf8, 0x73, 0x28, 0x18, 0x40, 0x3b, 0x36, 0x85, 0x60, 0xdd,
-	0x11, 0x01, 0x98, 0x04, 0x05, 0x74, 0xe5, 0x7b, 0xa8, 0xb9, 0x9b, 0xf1, 0xf8, 0xac, 0x7f, 0xa4,
-	0x2f, 0xbf, 0x9c, 0x6d, 0x96, 0x43, 0x9a, 0xa7, 0xe6, 0x03, 0x3f, 0x44, 0x6b, 0x07, 0xb3, 0x31,
-	0x2b, 0xe8, 0x98, 0x3d, 0x32, 0x03, 0x92, 0x29, 0x07, 0x1d, 0x67, 0xd1, 0x92, 0x80, 0xbd, 0xe0,
-	0xda, 0x64, 0x69, 0x15, 0xec, 0xfa, 0x98, 0xa9, 0x39, 0x17, 0x67, 0x76, 0x32, 0x73, 0x77, 0xb5,
-	0x1c, 0xd2, 0xcc, 0xcd, 0x47, 0xf4, 0x97, 0x32, 0x0a, 0x8c, 0x09, 0xc0, 0x8f, 0x5a, 0x8f, 0x0e,
-	0x03, 0x1f, 0xe6, 0x66, 0x68, 0xc5, 0x9b, 0xa8, 0x4d, 0x98, 0x64, 0xe2, 0xdc, 0xd4, 0x80, 0x9a,
-	0x19, 0x97, 0xc4, 0x02, 0xd2, 0xb1, 0x39, 0xa7, 0x85, 0x0d, 0x8a, 0x40, 0xce, 0x69, 0x01, 0x91,
-	0xfe, 0x01, 0x13, 0x39, 0xcb, 0x6c, 0x50, 0x34, 0xce, 0x34, 0x05, 0xf3, 0x81, 0xc1, 0x8f, 0xf7,
-	0x06, 0xda, 0x32, 0x3e, 0x69, 0x9d, 0x95, 0x00, 0xe4, 0x3f, 0x68, 0x2a, 0xd2, 0x1c, 0xde, 0x2e,
-	0x0d, 0xdd, 0xd4, 0x91, 0xac, 0x10, 0xfc, 0x25, 0x74, 0x7b, 0x3f, 0x95, 0x30, 0x68, 0x1c, 0x1d,
-	0x1d, 0x7e, 0x90, 0x66, 0x19, 0x13, 0xfa, 0xa2, 0x21, 0xb9, 0x9d, 0x5c, 0xc1, 0xa3, 0x3f, 0x7a,
-	0x28, 0x2c, 0x1d, 0x07, 0xc7, 0x19, 0x4e, 0xa8, 0xd0, 0x81, 0x03, 0x4a, 0x1b, 0x52, 0x53, 0x70,
-	0xe5, 0xef, 0xcf, 0xb8, 0xa2, 0xf6, 0x5a, 0xf5, 0x1f, 0x01, 0x01, 0xd2, 0x03, 0x26, 0x52, 0x9e,
-	0xd8, 0xb9, 0xa2, 0x51, 0x68, 0x0a, 0x66, 0x4c, 0xc2, 0x68, 0x06, 0xdd, 0x8c, 0xcc, 0x72, 0xf8,
-	0xb1, 0xb7, 0x5b, 0x17, 0xcb, 0x30, 0x0c, 0x6f, 0xa5, 0xa4, 0xd5, 0x54, 0xd7, 0x9a, 0xd6, 0xc4,
-	0x12, 0x0a, 0xa6, 0xdb, 0x2b, 0x66, 0xd2, 0x8e, 0xd8, 0x41, 0x5c, 0xcc, 0x24, 0x60, 0x87, 0x6c,
-	0x6a, 0x66, 0xeb, 0x16, 0x09, 0xa6, 0x6c, 0x2a, 0xa3, 0xb9, 0x9d, 0xe3, 0x9e, 0xe8, 0xe9, 0xd2,
-	0x66, 0x6d, 0x95, 0x8d, 0xde, 0x8d, 0xd9, 0x58, 0x73, 0xb3, 0x71, 0x03, 0x35, 0xcc, 0x5a, 0x5b,
-	0x41, 0x1a, 0x73, 0x33, 0xa7, 0x76, 0x11, 0x7a, 0xc4, 0xe8, 0xc8, 0xf2, 0x02, 0xcd, 0x43, 0x59,
-	0x85, 0x44, 0x27, 0xe8, 0x15, 0xbd, 0xf1, 0xf1, 0x44, 0x70, 0xa5, 0x32, 0xf6, 0x5f, 0x6c, 0x8d,
-	0x51, 0x40, 0xa8, 0x62, 0xe5, 0x8c, 0x26, 0xa8, 0x62, 0xd1, 0x3f, 0x7c, 0xb4, 0xe2, 0xa6, 0x82,
-	0x73, 0x3e, 0xef, 0xdf, 0x9c, 0xaf, 0x76, 0xf5, 0x7c, 0xb8, 0x87, 0x56, 0x5c, 0x9b, 0xdc, 0xd0,
-	0xd1, 0x5d, 0xb6, 0x4d, 0x9b, 0x95, 0xb9, 0x6b, 0xc6, 0x13, 0xf4, 0x5a, 0x79, 0x3b, 0x68, 0x51,
-	0xbb, 0x85, 0xb4, 0xba, 0x02, 0xad, 0xeb, 0xff, 0x1c, 0x5d, 0xcb, 0x56, 0xb0, 0xda, 0x5e, 0x53,
-	0x37, 0xad, 0xc6, 0x4f, 0xd0, 0x46, 0x29, 0xfe, 0x44, 0xa4, 0x8a, 0x2d, 0xf4, 0xd6, 0x3f, 0x9b,
-	0xde, 0x0d, 0x75, 0xe3, 0x72, 0x57, 0x31, 0xec, 0xd8, 0x3f, 0x1a, 0x0c, 0xad, 0xe2, 0xc6, 0x4b,
-	0x2a, 0x5e, 0x5e, 0x8e, 0x7f, 0x88, 0x5e, 0x5f, 0x3a, 0xb1, 0xa3, 0xb9, 0xf9, 0xd9, 0x34, 0xbf,
-	0xae, 0x6e, 0x5e, 0x1f, 0xbd, 0x85, 0x5a, 0x55, 0x85, 0xbc, 0xb9, 0xce, 0x44, 0x3f, 0x29, 0xdf,
-	0x2a, 0x6e, 0x21, 0x07, 0xd9, 0x5e, 0x96, 0xf1, 0xb9, 0x7d, 0x14, 0xd7, 0x29, 0x10, 0xff, 0x73,
-	0x6f, 0xda, 0x40, 0x8d, 0x5e, 0xac, 0xff, 0x1f, 0x31, 0x73, 0x59, 0x83, 0x6a, 0x2a, 0xca, 0x6c,
-	0x54, 0xda, 0x52, 0x09, 0x93, 0xec, 0x5e, 0x46, 0xa5, 0xac, 0x1a, 0x76, 0x33, 0x36, 0x24, 0xde,
-	0x45, 0x68, 0x20, 0x52, 0x2e, 0xcc, 0x33, 0xd8, 0x0c, 0xa0, 0x6f, 0x5c, 0x99, 0x45, 0xc4, 0x88,
-	0xc6, 0xcc, 0x4a, 0x5d, 0x94, 0x43, 0x5c, 0x51, 0xad, 0x8a, 0x1e, 0x22, 0x7c, 0xbd, 0xb2, 0x43,
-	0xdf, 0x1c, 0xd0, 0x31, 0x83, 0x0e, 0x6f, 0xfb, 0x71, 0x58, 0x58, 0x7a, 0x61, 0x39, 0xf3, 0x06,
-	0xb2, 0x96, 0x3b, 0x40, 0x1b, 0x37, 0xef, 0x09, 0x76, 0x82, 0xe1, 0xa0, 0xec, 0xeb, 0xfa, 0x7f,
-	0x1b, 0xd0, 0x6f, 0xf9, 0x36, 0x9f, 0x42, 0x7b, 0xa6, 0x8b, 0xe8, 0x97, 0x9e, 0x35, 0x80, 0x9d,
-	0x07, 0x61, 0x6c, 0xdb, 0x67, 0x23, 0x3a, 0xcb, 0x54, 0x2f, 0x76, 0x1e, 0x51, 0xab, 0x89, 0x0b,
-	0x82, 0x54, 0x4f, 0xc4, 0x93, 0x54, 0xb1, 0x58, 0xcd, 0x04, 0x2b, 0xdf, 0x07, 0xab, 0xd4, 0x05,
-	0xe1, 0xf0, 0x0f, 0x33, 0x3a, 0x96, 0xf6, 0xa9, 0x50, 0x1f, 0x01, 0x81, 0xbf, 0x86, 0x42, 0x98,
-	0xd0, 0x68, 0x96, 0x49, 0x9b, 0x70, 0x4b, 0x73, 0xa9, 0x61, 0x95, 0x8f, 0x14, 0x69, 0x25, 0xa3,
-	0x14, 0xad, 0xbb, 0xe7, 0xec, 0x89, 0x31, 0xa8, 0xef, 0xe7, 0x09, 0x7b, 0x6a, 0x2b, 0x7c, 0x3d,
-	0x05, 0x02, 0xd0, 0x0f, 0xab, 0xf9, 0x2e, 0xb0, 0xf3, 0x1d, 0xd8, 0x40, 0xa3, 0xc7, 0x73, 0x6e,
-	0xcb, 0x52, 0x78, 0x6e, 0x69, 0xbc, 0x86, 0x6a, 0x47, 0x85, 0x7d, 0x49, 0xd7, 0x78, 0x11, 0xfd,
-	0xbc, 0xb2, 0x89, 0xd9, 0x1c, 0x54, 0xea, 0x89, 0xcb, 0xbe, 0x9d, 0xeb, 0x7a, 0x2c, 0x37, 0x21,
-	0x55, 0x75, 0x48, 0x1d, 0x52, 0xda, 0x36, 0x6f, 0xa0, 0x90, 0x09, 0x91, 0x73, 0xc1, 0x6c, 0xe9,
-	0x3d, 0xb8, 0x45, 0x2a, 0x04, 0xef, 0x38, 0xff, 0xc3, 0xb4, 0xef, 0xbf, 0x76, 0x7d, 0x22, 0xef,
-	0x89, 0xf2, 0x09, 0xa3, 0x5f, 0x5b, 0xbb, 0x08, 0x85, 0x0f, 0x60, 0x31, 0x61, 0x2a, 0xfa, 0x3a,
-	0x5a, 0x5d, 0x9a, 0x7b, 0xc1, 0x0f, 0x8f, 0xde, 0xd9, 0xa3, 0xf1, 0x84, 0x0d, 0xe3, 0x09, 0x9b,
-	0xd2, 0xd2, 0x5b, 0x99, 0x0b, 0xee, 0xfe, 0xd4, 0x7b, 0xf6, 0xbc, 0x7b, 0xeb, 0xcf, 0xcf, 0xbb,
-	0xb7, 0xfe, 0xf9, 0xbc, 0xeb, 0xfd, 0xf8, 0xb2, 0xeb, 0xfd, 0xfa, 0xb2, 0xeb, 0xfd, 0xf6, 0xb2,
-	0xeb, 0xfd, 0xfe, 0xb2, 0xeb, 0x3d, 0xbb, 0xec, 0x7a, 0x7f, 0xba, 0xec, 0x7a, 0x7f, 0xbf, 0xec,
-	0x7a, 0x1f, 0x7d, 0xfc, 0x92, 0x7f, 0x73, 0x0a, 0xd3, 0xfe, 0x76, 0xce, 0x53, 0xa1, 0x1c, 0x56,
-	0x71, 0x36, 0xbe, 0xf6, 0x0f, 0x28, 0xdc, 0xf4, 0xb4, 0xa1, 0xe9, 0x77, 0xfe, 0x15, 0x00, 0x00,
-	0xff, 0xff, 0x63, 0x45, 0x7b, 0x17, 0x4f, 0x15, 0x00, 0x00,
+	// 2118 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xcb, 0x73, 0x5b, 0x49,
+	0xd5, 0xcf, 0x95, 0x64, 0x59, 0x6a, 0xc5, 0x79, 0xf4, 0x64, 0x32, 0xf7, 0xcb, 0x97, 0xd2, 0x78,
+	0x2e, 0x29, 0x30, 0x10, 0xec, 0x22, 0xe1, 0x31, 0x0c, 0x8f, 0x2a, 0xd9, 0x4e, 0x62, 0xd5, 0xc4,
+	0x91, 0x68, 0xd9, 0x13, 0x98, 0xc5, 0x54, 0xb5, 0xaf, 0xda, 0x52, 0x8f, 0xaf, 0x6e, 0xdf, 0xea,
+	0xdb, 0xb2, 0x63, 0x56, 0xb0, 0x63, 0xcf, 0x82, 0x35, 0x1b, 0x1e, 0xff, 0x01, 0xc5, 0x8a, 0x1d,
+	0x29, 0x56, 0x2c, 0xa9, 0xa2, 0x0a, 0x88, 0xf7, 0xec, 0x59, 0x52, 0xa7, 0xfb, 0xdc, 0xab, 0x96,
+	0xe4, 0xc0, 0x04, 0x56, 0xea, 0xf3, 0x3b, 0x8f, 0x7e, 0x9c, 0xe7, 0x15, 0xe9, 0x8d, 0xa4, 0x19,
+	0x4f, 0x8f, 0x36, 0x63, 0x35, 0xd9, 0x3a, 0xe1, 0x86, 0x7f, 0x25, 0x56, 0xa9, 0xe1, 0x32, 0x15,
+	0x3a, 0x5f, 0xa2, 0x73, 0x1d, 0x6f, 0xf1, 0x91, 0x48, 0xcd, 0x56, 0xa6, 0x95, 0x51, 0xb1, 0x4a,
+	0x72, 0xb7, 0xca, 0xb7, 0x54, 0x2c, 0x37, 0xed, 0x92, 0xd6, 0x46, 0x3a, 0x8b, 0xef, 0x44, 0x23,
+	0x35, 0x52, 0x8e, 0x79, 0x34, 0x3d, 0xde, 0x02, 0xca, 0x12, 0x76, 0xe5, 0x24, 0xa3, 0x3f, 0x54,
+	0x49, 0x6d, 0x90, 0x89, 0x98, 0x86, 0x64, 0xf5, 0x23, 0xa1, 0x73, 0xa9, 0xd2, 0x30, 0x58, 0x0f,
+	0x36, 0x9a, 0xac, 0x20, 0xe9, 0x17, 0xc8, 0x6a, 0x5f, 0xab, 0x58, 0xe4, 0x79, 0x58, 0x59, 0x0f,
+	0x36, 0x5a, 0x0f, 0xd6, 0x36, 0xc1, 0xfc, 0x26, 0x82, 0xac, 0xe0, 0xd2, 0x36, 0xa9, 0x31, 0xa5,
+	0x4c, 0x58, 0xb5, 0x52, 0xc4, 0x49, 0x01, 0xc2, 0x2c, 0x4e, 0xef, 0x90, 0xc6, 0x9e, 0xca, 0x4d,
+	0xca, 0x27, 0x22, 0xac, 0xd9, 0x3d, 0x4a, 0x9a, 0x7e, 0x91, 0xd4, 0xf7, 0xd5, 0x34, 0x35, 0x79,
+	0xb8, 0xb2, 0x5e, 0xdd, 0x68, 0x3d, 0x68, 0x39, 0x6d, 0x8b, 0x6d, 0xd7, 0x5e, 0xfe, 0xf5, 0xdd,
+	0x2b, 0x0c, 0x05, 0xe8, 0x7b, 0x64, 0x65, 0x4f, 0xa9, 0x93, 0x3c, 0xac, 0xdb, 0x7d, 0x50, 0xd2,
+	0x42, 0xcc, 0x71, 0xe8, 0x77, 0x49, 0xab, 0x93, 0xa6, 0xca, 0x70, 0x23, 0x55, 0x9a, 0x87, 0xab,
+	0xd6, 0xe4, 0xff, 0x3b, 0x41, 0xb8, 0xed, 0xa6, 0xc7, 0x7d, 0x94, 0x1a, 0x7d, 0xce, 0x7c, 0x79,
+	0xd8, 0xe1, 0xa9, 0x4c, 0xa7, 0x2f, 0xc2, 0x86, 0xbf, 0x83, 0x85, 0x98, 0xe3, 0xc0, 0xa3, 0x0c,
+	0x54, 0xc2, 0xb5, 0xcc, 0xc3, 0xa6, 0xff, 0x28, 0x08, 0xb2, 0x82, 0x0b, 0x82, 0xcf, 0x65, 0x3a,
+	0x54, 0x67, 0x79, 0x48, 0x7c, 0x41, 0x04, 0x59, 0xc1, 0xbd, 0xf3, 0x3d, 0x72, 0x63, 0xf1, 0x54,
+	0xf4, 0x06, 0xa9, 0x9e, 0x88, 0x73, 0x74, 0x08, 0x2c, 0xe9, 0x2d, 0xb2, 0x72, 0xca, 0x93, 0xa9,
+	0xb0, 0xae, 0x68, 0x32, 0x47, 0x7c, 0x50, 0x79, 0x3f, 0x88, 0x7e, 0x57, 0x2d, 0xfd, 0x04, 0x2f,
+	0x7d, 0x20, 0xf4, 0x44, 0xa6, 0x3c, 0xb1, 0xca, 0x0d, 0x56, 0xd2, 0xf4, 0xcb, 0xa4, 0xb5, 0xa3,
+	0xd2, 0x5c, 0x25, 0x62, 0x20, 0x7f, 0x24, 0xd0, 0xa5, 0x4d, 0x77, 0xa8, 0x6d, 0xf5, 0x82, 0xf9,
+	0x5c, 0x7a, 0x8f, 0xd4, 0x0e, 0x73, 0xa1, 0xe7, 0x5d, 0x0a, 0x08, 0xfa, 0xc4, 0x72, 0x29, 0x25,
+	0xb5, 0x8e, 0x1e, 0xe5, 0x61, 0x6d, 0xbd, 0xba, 0xd1, 0x64, 0x76, 0x0d, 0x47, 0x7f, 0x94, 0x9e,
+	0x5a, 0x6f, 0x36, 0x19, 0x2c, 0x01, 0xd9, 0x39, 0x1b, 0x5a, 0xaf, 0x35, 0x19, 0x2c, 0xe9, 0xb7,
+	0xc9, 0xd5, 0x1d, 0x9e, 0xf1, 0x23, 0x99, 0x48, 0x23, 0x05, 0xf8, 0x09, 0x76, 0x79, 0xc7, 0x7b,
+	0x6e, 0x9f, 0xcd, 0xe6, 0x84, 0xe9, 0x57, 0xc9, 0x2a, 0x4b, 0xe4, 0x44, 0x9a, 0x3c, 0x6c, 0x58,
+	0xff, 0xde, 0xc4, 0xb0, 0xec, 0x0d, 0xba, 0x3f, 0x70, 0x1c, 0x3c, 0x64, 0x21, 0x47, 0x37, 0xc8,
+	0xf5, 0x67, 0xea, 0x99, 0x38, 0xeb, 0x6b, 0x79, 0x2a, 0x13, 0x31, 0x12, 0xce, 0x79, 0x0d, 0xb6,
+	0x08, 0x83, 0x64, 0x27, 0xcb, 0xb8, 0x9e, 0x28, 0xdd, 0xd7, 0xea, 0x58, 0x26, 0xc2, 0x7a, 0xaf,
+	0xc9, 0x16, 0x61, 0xba, 0x4e, 0x5a, 0xbd, 0xde, 0xfe, 0x20, 0x56, 0x5a, 0x74, 0x86, 0x9f, 0x86,
+	0xad, 0xf5, 0x60, 0xa3, 0xca, 0x7c, 0x88, 0x46, 0xe4, 0xea, 0x40, 0x24, 0x70, 0x9b, 0xa7, 0xfc,
+	0x48, 0x24, 0xe1, 0x55, 0x6b, 0x68, 0x0e, 0x8b, 0x1e, 0x92, 0xea, 0xb6, 0x7a, 0x41, 0x6f, 0x93,
+	0xfa, 0x9e, 0x90, 0xa3, 0xb1, 0xb1, 0x5e, 0x5b, 0x63, 0x48, 0x81, 0xd7, 0x9f, 0xcb, 0xa1, 0x19,
+	0x5b, 0x6f, 0xad, 0x31, 0x47, 0x44, 0xa9, 0x73, 0x0e, 0x3c, 0xec, 0x61, 0x77, 0x17, 0x55, 0x60,
+	0x09, 0xc8, 0x93, 0xee, 0x2e, 0x4a, 0xc3, 0x92, 0x7e, 0x9e, 0x5c, 0xeb, 0x0c, 0x87, 0x12, 0x62,
+	0x8b, 0x27, 0x4f, 0xe4, 0x30, 0x0f, 0xab, 0xeb, 0xd5, 0x8d, 0x35, 0xb6, 0x80, 0x42, 0xe4, 0x80,
+	0x4d, 0x3f, 0x47, 0x0b, 0x3a, 0xfa, 0x55, 0x40, 0x6e, 0x2e, 0x79, 0x05, 0x34, 0xb6, 0xd5, 0x34,
+	0x1d, 0xca, 0x74, 0x14, 0x06, 0xd6, 0xdb, 0x25, 0x4d, 0xef, 0x92, 0xe6, 0xa3, 0xe3, 0x63, 0x11,
+	0x1b, 0x79, 0x0a, 0x91, 0x06, 0xcc, 0x19, 0x00, 0x4f, 0xd7, 0x4d, 0xc7, 0x42, 0x4b, 0xc3, 0x8f,
+	0x12, 0x61, 0x0f, 0xd4, 0x64, 0x3e, 0x04, 0xfa, 0x7d, 0x88, 0x5b, 0x63, 0xc4, 0x10, 0xa3, 0x6b,
+	0x06, 0x40, 0xc9, 0xea, 0x4c, 0x8e, 0xa4, 0x48, 0x0d, 0x86, 0x59, 0x41, 0x46, 0x5d, 0xd2, 0xf2,
+	0xc2, 0x00, 0xe2, 0xf3, 0xe0, 0x3c, 0x13, 0x98, 0x47, 0x76, 0x0d, 0xd8, 0x1e, 0xd7, 0x43, 0xfb,
+	0x46, 0x35, 0x66, 0xd7, 0x80, 0x0d, 0xd4, 0xb1, 0x2b, 0x60, 0x35, 0x66, 0xd7, 0x91, 0x22, 0x2b,
+	0xb6, 0xee, 0xc0, 0x69, 0x87, 0x22, 0x37, 0x32, 0xb5, 0x09, 0x8a, 0xb6, 0x7c, 0x08, 0xbc, 0x97,
+	0xab, 0xa9, 0x8e, 0x8b, 0xe4, 0x44, 0x0a, 0xcc, 0x1a, 0xd8, 0xbe, 0xea, 0xb6, 0x87, 0x35, 0x9c,
+	0x5d, 0x65, 0xae, 0x3a, 0xb9, 0x7b, 0x15, 0x64, 0xf4, 0x0d, 0x57, 0x45, 0x41, 0xab, 0xcf, 0xcd,
+	0xb8, 0x38, 0x34, 0xac, 0xe1, 0xad, 0x99, 0xe0, 0x43, 0x95, 0x26, 0xe7, 0x76, 0x8f, 0x06, 0x2b,
+	0xe9, 0xe8, 0x67, 0x01, 0xd6, 0x45, 0x7a, 0x9f, 0x34, 0xfa, 0x5a, 0xe4, 0x86, 0x6b, 0x63, 0x3d,
+	0x52, 0x26, 0x2e, 0xb0, 0x31, 0x27, 0x4a, 0x09, 0xba, 0x49, 0x9a, 0x7d, 0x95, 0x1b, 0x27, 0x5e,
+	0x79, 0x8d, 0xf8, 0x4c, 0xc4, 0x5a, 0xb7, 0x84, 0xca, 0xac, 0xcb, 0x2e, 0xb7, 0x8e, 0x12, 0xd1,
+	0xc7, 0xa4, 0x06, 0xf8, 0xa5, 0xb7, 0x29, 0xca, 0x46, 0x65, 0xb9, 0x6c, 0x54, 0x67, 0x65, 0x23,
+	0x24, 0xab, 0x07, 0x72, 0x22, 0xd4, 0xd4, 0xd8, 0x80, 0xac, 0xb2, 0x82, 0x8c, 0x7e, 0xb3, 0x82,
+	0x75, 0x9a, 0x7e, 0x87, 0xb4, 0x0e, 0xbb, 0xbb, 0xfb, 0x3c, 0xcb, 0x64, 0x3a, 0xca, 0xf1, 0xd2,
+	0xb7, 0xbc, 0x3a, 0x52, 0x32, 0xf1, 0x80, 0xbe, 0x38, 0x68, 0x3f, 0xf1, 0xb4, 0x2b, 0xff, 0x59,
+	0xdb, 0x13, 0xa7, 0x5b, 0xa4, 0x3e, 0x38, 0xcf, 0x63, 0x93, 0xe0, 0x6b, 0xf8, 0xe5, 0x6b, 0xd3,
+	0x71, 0x5c, 0x8b, 0x41, 0x31, 0xfa, 0x80, 0x34, 0x99, 0x70, 0xa1, 0x91, 0xdb, 0x2b, 0xcd, 0x6f,
+	0x56, 0xf2, 0xd8, 0x4c, 0x0c, 0x82, 0x6f, 0x67, 0xa4, 0xd5, 0x34, 0xcb, 0xed, 0x2b, 0xae, 0xb8,
+	0xe0, 0xf3, 0x20, 0xfa, 0x01, 0x21, 0xcf, 0xf8, 0x44, 0xe4, 0x19, 0x07, 0xb3, 0xf5, 0xa5, 0x3b,
+	0x94, 0x4c, 0xbc, 0x83, 0x27, 0x0d, 0xa5, 0x74, 0x57, 0x9c, 0xca, 0x58, 0x14, 0xad, 0xf2, 0xa6,
+	0xa7, 0xe8, 0x38, 0x45, 0x29, 0x45, 0x39, 0x7a, 0x9f, 0xac, 0x0e, 0x44, 0x1c, 0xab, 0x49, 0x86,
+	0x4d, 0x92, 0x7a, 0x2a, 0xc8, 0x61, 0x85, 0x08, 0xbd, 0x4f, 0x6e, 0x42, 0x4c, 0x1f, 0xe7, 0x7d,
+	0xad, 0x32, 0x3e, 0x72, 0x19, 0xd4, 0xb4, 0x97, 0x58, 0x66, 0xc0, 0x65, 0xf7, 0x79, 0x7e, 0x22,
+	0x86, 0x70, 0x31, 0x68, 0x9b, 0xb6, 0x2e, 0x78, 0x10, 0xbd, 0x47, 0xd6, 0x8a, 0xb8, 0x77, 0x32,
+	0x2d, 0x2b, 0x33, 0x0f, 0xd2, 0x36, 0x21, 0x36, 0x75, 0xfd, 0xb2, 0xeb, 0x21, 0x74, 0x8b, 0x34,
+	0xba, 0xa9, 0x11, 0x09, 0x1b, 0x9a, 0x70, 0xcd, 0x5e, 0xe2, 0x2d, 0xdf, 0xe9, 0xc8, 0x62, 0xa5,
+	0xd0, 0x9d, 0x6f, 0x91, 0x96, 0xe7, 0xd0, 0x37, 0xea, 0xce, 0xef, 0x96, 0x63, 0x00, 0x08, 0x0d,
+	0xa7, 0x93, 0x49, 0xa1, 0xe8, 0x08, 0x10, 0x28, 0x46, 0x86, 0xcb, 0x05, 0x3e, 0x21, 0xd7, 0xe6,
+	0x83, 0xd1, 0x76, 0x0b, 0x95, 0x9b, 0xb2, 0xf4, 0x23, 0x65, 0x83, 0xa5, 0x18, 0x18, 0xcb, 0x2e,
+	0xe0, 0x43, 0xb6, 0xd0, 0x41, 0xf3, 0xaf, 0x5a, 0x96, 0x5d, 0x47, 0xef, 0xa3, 0xfd, 0x32, 0x2e,
+	0x5e, 0x57, 0x36, 0x6d, 0x04, 0x56, 0x66, 0x79, 0x1c, 0xfd, 0x22, 0x20, 0x2d, 0x2f, 0x54, 0x5e,
+	0x97, 0xeb, 0xd6, 0x56, 0xc5, 0xb3, 0x75, 0x8b, 0xac, 0xec, 0xf3, 0x4f, 0x95, 0x9b, 0x2e, 0xaa,
+	0xcc, 0x11, 0x16, 0x95, 0xa9, 0xd2, 0x98, 0xed, 0x8e, 0x80, 0xca, 0xf7, 0x58, 0x26, 0x62, 0x5f,
+	0x0d, 0x85, 0x8d, 0xfe, 0x35, 0x56, 0xd2, 0x45, 0xff, 0xab, 0x2f, 0xf5, 0xbf, 0xd5, 0xb2, 0xff,
+	0x45, 0x7f, 0xab, 0xe0, 0xf5, 0x66, 0x39, 0xf5, 0xcd, 0x59, 0xd4, 0x07, 0x4b, 0x99, 0xeb, 0x38,
+	0x2e, 0xc1, 0x16, 0x63, 0x1f, 0x66, 0x55, 0x31, 0x51, 0xfa, 0x1c, 0x87, 0x27, 0x3f, 0x5b, 0x1c,
+	0x83, 0xa1, 0x00, 0x5d, 0x27, 0xd5, 0x9d, 0xfe, 0x21, 0x8e, 0x4f, 0xd7, 0xfc, 0xc1, 0xa6, 0x7f,
+	0xc8, 0x80, 0x45, 0x3f, 0x47, 0x6a, 0x7d, 0x68, 0xc7, 0xae, 0x10, 0x5c, 0xf7, 0x44, 0x00, 0x66,
+	0x96, 0x09, 0xd9, 0xb6, 0x9d, 0xa8, 0xf8, 0xa4, 0xdb, 0xb3, 0x97, 0x9f, 0xcf, 0x36, 0xe4, 0xb0,
+	0x42, 0x84, 0x3e, 0x26, 0xd7, 0xf6, 0xa6, 0x23, 0x91, 0xf1, 0x91, 0x78, 0xea, 0x06, 0x24, 0x57,
+	0x0e, 0x42, 0x4f, 0x69, 0x4e, 0x00, 0x2f, 0xb8, 0xa0, 0x05, 0xbb, 0x3e, 0x13, 0xe6, 0x4c, 0xe9,
+	0x13, 0x9c, 0xcc, 0xfc, 0x5d, 0x91, 0xc3, 0x0a, 0x91, 0xe8, 0x2f, 0x45, 0x14, 0xe0, 0xd5, 0x6f,
+	0x41, 0x71, 0x9e, 0x48, 0x37, 0xca, 0x54, 0x99, 0x23, 0x20, 0x36, 0x99, 0xc8, 0x85, 0x3e, 0x75,
+	0x35, 0xa0, 0xe2, 0xc6, 0x25, 0x0f, 0xb2, 0xb1, 0x79, 0xc6, 0x33, 0x0c, 0x0a, 0xbb, 0x86, 0x48,
+	0xff, 0x50, 0xe8, 0x54, 0x24, 0x18, 0x14, 0x48, 0xc1, 0x7c, 0xe0, 0x56, 0x07, 0x3b, 0x7d, 0xfb,
+	0x32, 0x55, 0x36, 0x03, 0x20, 0xff, 0x41, 0x3b, 0x93, 0x29, 0x7c, 0xbb, 0xd4, 0x6d, 0x53, 0xf7,
+	0x10, 0xfa, 0x25, 0x72, 0x63, 0x57, 0xe6, 0x30, 0x68, 0xf4, 0x7a, 0xfb, 0x1f, 0xca, 0x24, 0x11,
+	0xda, 0x5e, 0xb4, 0xc1, 0x96, 0xf0, 0xe8, 0x8f, 0x01, 0x69, 0x14, 0x8e, 0x83, 0xe3, 0x0c, 0xc6,
+	0x5c, 0xdb, 0xc0, 0x01, 0xa3, 0x48, 0xc1, 0x95, 0xbf, 0x3f, 0x55, 0x86, 0xe3, 0xb5, 0x1c, 0x01,
+	0xd2, 0x7d, 0xa1, 0xa5, 0x1a, 0xe2, 0x5c, 0x81, 0x14, 0xcc, 0x98, 0x4c, 0xf0, 0xc4, 0xc8, 0x89,
+	0x60, 0xd3, 0x14, 0x7e, 0xf0, 0x76, 0x8b, 0x30, 0x0c, 0x6f, 0x05, 0x84, 0x96, 0x56, 0xac, 0xa5,
+	0x05, 0x14, 0x9e, 0x6e, 0x27, 0x9b, 0xe6, 0x38, 0x62, 0xdb, 0x35, 0x60, 0xfb, 0x62, 0xe2, 0x66,
+	0xeb, 0x26, 0xb3, 0xeb, 0xe8, 0x0c, 0xe7, 0xb8, 0xe7, 0x76, 0xba, 0xc4, 0xac, 0x2d, 0xb3, 0x31,
+	0xb8, 0x34, 0x1b, 0x2b, 0x7e, 0x36, 0xde, 0x26, 0x75, 0xa7, 0x8b, 0x15, 0x04, 0x29, 0x78, 0xf1,
+	0xa7, 0x82, 0x1f, 0x23, 0xaf, 0x66, 0x79, 0x1e, 0x12, 0x1d, 0x92, 0xb7, 0xec, 0xc6, 0x07, 0x63,
+	0xad, 0x8c, 0x49, 0xc4, 0x7f, 0xb1, 0x35, 0x25, 0x35, 0xc6, 0x8d, 0x28, 0x66, 0x34, 0x58, 0x47,
+	0xff, 0xa8, 0x92, 0xab, 0x7e, 0x2a, 0x78, 0xe7, 0x0b, 0xfe, 0xcd, 0xf9, 0x2a, 0x8b, 0xe7, 0xa3,
+	0x1d, 0x72, 0xd5, 0x7f, 0x93, 0x4b, 0x3a, 0xba, 0xcf, 0xc6, 0xb4, 0x99, 0x53, 0xa1, 0x87, 0xe4,
+	0xed, 0xe2, 0x76, 0xd0, 0x8d, 0xb6, 0xb3, 0x1c, 0x6d, 0xd5, 0xac, 0xad, 0xff, 0xf3, 0x6c, 0xcd,
+	0xbf, 0x02, 0x5a, 0xbb, 0x5c, 0x9b, 0x3e, 0x27, 0xb7, 0x0b, 0xc6, 0x73, 0x2d, 0x8d, 0x98, 0xd9,
+	0x5d, 0xf9, 0x6c, 0x76, 0x5f, 0xa3, 0xee, 0x1b, 0x86, 0x1d, 0xbb, 0xbd, 0xfe, 0x00, 0x0d, 0xd7,
+	0xdf, 0xd0, 0xf0, 0xbc, 0x3a, 0xfd, 0x21, 0x79, 0x67, 0x6e, 0x4b, 0xcf, 0xf2, 0xea, 0x67, 0xb3,
+	0xfc, 0x3a, 0xfd, 0xe8, 0x3d, 0xd2, 0x2c, 0x2b, 0xe4, 0xe5, 0x75, 0x26, 0xfa, 0x49, 0xf1, 0xad,
+	0xe2, 0x17, 0x72, 0x90, 0xed, 0x24, 0x89, 0x3a, 0xc3, 0x8f, 0x62, 0x47, 0xfc, 0xcf, 0xbd, 0xe9,
+	0x36, 0xa9, 0x77, 0x62, 0xfb, 0xff, 0x88, 0x9b, 0xcb, 0x90, 0x8a, 0x12, 0x8c, 0x4a, 0xac, 0x90,
+	0x30, 0xc9, 0xee, 0x24, 0x3c, 0xcf, 0xcb, 0x86, 0x5d, 0x90, 0x74, 0x9b, 0x90, 0xbe, 0x96, 0x4a,
+	0xbb, 0xcf, 0x60, 0x37, 0x80, 0xde, 0x5d, 0x98, 0x45, 0xf4, 0x31, 0x8f, 0x05, 0x4a, 0x9d, 0x17,
+	0x43, 0xdc, 0x4c, 0x2b, 0x7a, 0x4c, 0xe8, 0x72, 0x65, 0x87, 0xbe, 0xd9, 0xe7, 0x23, 0x91, 0x43,
+	0xb7, 0x77, 0xfd, 0xb8, 0xa4, 0x67, 0x2f, 0xe7, 0xbe, 0x81, 0xf0, 0xe5, 0xf6, 0xc8, 0xed, 0xcb,
+	0xf7, 0x84, 0x77, 0x82, 0xe1, 0xa0, 0xe8, 0xeb, 0xb0, 0xb6, 0xf6, 0x91, 0x8f, 0xf9, 0x54, 0xd2,
+	0xd1, 0x2f, 0x03, 0x7c, 0x80, 0x62, 0x0c, 0xbc, 0x47, 0xd6, 0x76, 0xc5, 0x31, 0x9f, 0x26, 0xa6,
+	0x13, 0x7b, 0x1f, 0x51, 0xf3, 0x20, 0x48, 0x75, 0x74, 0x3c, 0x96, 0x46, 0xc4, 0x66, 0xaa, 0x45,
+	0xf1, 0x7d, 0x30, 0x0f, 0xc2, 0xe1, 0x1f, 0x27, 0x7c, 0x94, 0xe3, 0xa7, 0x82, 0x23, 0xe8, 0xd7,
+	0x48, 0x03, 0x26, 0x34, 0x9e, 0x24, 0x39, 0x26, 0xdc, 0xdc, 0x5c, 0xea, 0x58, 0xc5, 0x47, 0x4a,
+	0x21, 0x19, 0x49, 0x72, 0xdd, 0x3f, 0x67, 0x47, 0x8f, 0xc0, 0x7c, 0x37, 0x1d, 0x8a, 0x17, 0x58,
+	0xe1, 0x1d, 0x01, 0xe8, 0x47, 0xe5, 0x7c, 0x57, 0x63, 0x8e, 0x80, 0x37, 0xb0, 0x8b, 0x83, 0x33,
+	0x85, 0x65, 0xa9, 0xa4, 0xe9, 0x35, 0x52, 0xe9, 0x65, 0xf8, 0x25, 0x5d, 0xe9, 0x65, 0xd1, 0xcf,
+	0xcb, 0x37, 0x71, 0x9b, 0x83, 0x49, 0x3b, 0x71, 0xe1, 0xb7, 0xb3, 0x23, 0x5c, 0x48, 0x95, 0x1d,
+	0xd2, 0x86, 0x94, 0x7d, 0x9b, 0xbb, 0xa4, 0x21, 0xb4, 0x4e, 0x95, 0x16, 0x58, 0x7a, 0xf7, 0xae,
+	0xb0, 0x12, 0xa1, 0x5b, 0xde, 0xff, 0x30, 0xad, 0x07, 0x6f, 0x2f, 0x4f, 0xe4, 0x1d, 0x5d, 0x7c,
+	0xc2, 0x58, 0xc1, 0x6d, 0x42, 0x1a, 0x8f, 0x40, 0x99, 0x09, 0x13, 0x7d, 0x9d, 0xac, 0xcd, 0xcd,
+	0xbd, 0xe0, 0x87, 0xa7, 0x0f, 0x77, 0x78, 0x3c, 0x16, 0x83, 0x78, 0x2c, 0x26, 0xbc, 0xf0, 0xd6,
+	0x1c, 0xb8, 0xfd, 0xd3, 0xe0, 0xe5, 0xab, 0xf6, 0x95, 0x3f, 0xbf, 0x6a, 0x5f, 0xf9, 0xe7, 0xab,
+	0x76, 0xf0, 0xe3, 0x8b, 0x76, 0xf0, 0xeb, 0x8b, 0x76, 0xf0, 0xdb, 0x8b, 0x76, 0xf0, 0xfb, 0x8b,
+	0x76, 0xf0, 0xf2, 0xa2, 0x1d, 0xfc, 0xe9, 0xa2, 0x1d, 0xfc, 0xfd, 0xa2, 0x1d, 0x7c, 0xfc, 0xc9,
+	0x1b, 0xfe, 0xcd, 0xa9, 0x5d, 0xfb, 0xdb, 0x3a, 0x95, 0xda, 0x78, 0xac, 0xec, 0x64, 0xb4, 0xf4,
+	0x0f, 0x28, 0xdc, 0xf4, 0xa8, 0x6e, 0xe9, 0x87, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xfb, 0x3e,
+	0xc9, 0x10, 0x4f, 0x15, 0x00, 0x00,
 }
 
 func (this *Spec) Equal(that interface{}) bool {
diff --git a/src/runtime/virtcontainers/pkg/agent/protocols/types.pb.go b/src/runtime/virtcontainers/pkg/agent/protocols/types.pb.go
index 74a86f03f..263afa8f1 100644
--- a/src/runtime/virtcontainers/pkg/agent/protocols/types.pb.go
+++ b/src/runtime/virtcontainers/pkg/agent/protocols/types.pb.go
@@ -93,7 +93,7 @@ var xxx_messageInfo_IPAddress proto.InternalMessageInfo
 type Interface struct {
 	Device      string       `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
 	Name        string       `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
-	IPAddresses []*IPAddress `protobuf:"bytes,3,rep,name=IPAddresses,json=iPAddresses,proto3" json:"IPAddresses,omitempty"`
+	IPAddresses []*IPAddress `protobuf:"bytes,3,rep,name=IPAddresses,proto3" json:"IPAddresses,omitempty"`
 	Mtu         uint64       `protobuf:"varint,4,opt,name=mtu,proto3" json:"mtu,omitempty"`
 	HwAddr      string       `protobuf:"bytes,5,opt,name=hwAddr,proto3" json:"hwAddr,omitempty"`
 	// PCI path for the device (see the pci::Path (Rust) or types.PciPath (Go) type for format details)
@@ -240,37 +240,37 @@ func init() {
 }
 
 var fileDescriptor_b0c68e5b9fabcd81 = []byte{
-	// 474 bytes of a gzipped FileDescriptorProto
+	// 472 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0x31, 0x8f, 0xd3, 0x30,
-	0x18, 0x86, 0xcf, 0x4d, 0x93, 0x6b, 0x5c, 0x1d, 0x54, 0x16, 0x3a, 0x59, 0x20, 0x45, 0x51, 0x17,
-	0x22, 0x24, 0x1a, 0xa9, 0x20, 0xf6, 0x63, 0x38, 0xa9, 0x0b, 0x2a, 0xde, 0x60, 0x41, 0xae, 0xeb,
-	0xa6, 0x56, 0x93, 0x38, 0xb2, 0x9d, 0x56, 0x15, 0x0b, 0x7f, 0x84, 0xff, 0x73, 0x23, 0x23, 0xe3,
-	0x5d, 0x7f, 0x09, 0xb2, 0x9d, 0x96, 0x72, 0xb0, 0x30, 0xe5, 0x7d, 0x3e, 0xdb, 0xf9, 0xde, 0xef,
-	0x8d, 0x03, 0x3f, 0x16, 0xc2, 0xac, 0xdb, 0xc5, 0x84, 0xc9, 0x2a, 0xdf, 0x50, 0x43, 0x5f, 0x33,
-	0x59, 0x1b, 0x2a, 0x6a, 0xae, 0xf4, 0x5f, 0xac, 0x15, 0xcb, 0x69, 0xc1, 0x6b, 0x93, 0x37, 0x4a,
-	0x1a, 0xc9, 0x64, 0xa9, 0xbd, 0xd2, 0xb9, 0xd9, 0x37, 0x5c, 0x4f, 0x1c, 0xa0, 0xd0, 0xc1, 0x78,
-	0x01, 0xe3, 0xd9, 0xfc, 0x66, 0xb9, 0x54, 0x5c, 0x6b, 0xf4, 0x12, 0x46, 0x2b, 0x5a, 0x89, 0x72,
-	0x8f, 0x41, 0x0a, 0xb2, 0x27, 0xd3, 0xa7, 0x13, 0x7f, 0x62, 0x36, 0xbf, 0x75, 0x65, 0xd2, 0x2d,
-	0x23, 0x0c, 0x2f, 0xa9, 0x3f, 0x83, 0x7b, 0x29, 0xc8, 0x62, 0x72, 0x44, 0x84, 0x60, 0xbf, 0xa2,
-	0x7a, 0x83, 0x03, 0x57, 0x76, 0x7a, 0x7c, 0x0f, 0x60, 0x3c, 0xab, 0x0d, 0x57, 0x2b, 0xca, 0x38,
-	0xba, 0x86, 0xd1, 0x92, 0x6f, 0x05, 0xe3, 0xae, 0x49, 0x4c, 0x3a, 0xb2, 0x27, 0x6b, 0x5a, 0xf1,
-	0xee, 0x85, 0x4e, 0xa3, 0x29, 0x1c, 0x9e, 0xdc, 0x71, 0x8d, 0x83, 0x34, 0xc8, 0x86, 0xd3, 0xd1,
-	0xc9, 0x55, 0xb7, 0x42, 0x86, 0xe2, 0xf7, 0x26, 0x34, 0x82, 0x41, 0x65, 0x5a, 0xdc, 0x4f, 0x41,
-	0xd6, 0x27, 0x56, 0xda, 0x8e, 0xeb, 0x9d, 0xdd, 0x80, 0x43, 0xdf, 0xd1, 0x93, 0x9d, 0xa2, 0x61,
-	0x62, 0x4e, 0xcd, 0x1a, 0x47, 0x7e, 0x8a, 0x0e, 0xad, 0x17, 0xdb, 0x03, 0x5f, 0x7a, 0x2f, 0x56,
-	0xa3, 0x17, 0x30, 0x56, 0x74, 0xf7, 0x65, 0x55, 0xd2, 0x42, 0xe3, 0x41, 0x0a, 0xb2, 0x2b, 0x32,
-	0x50, 0x74, 0x77, 0x6b, 0x79, 0xfc, 0x15, 0x86, 0x44, 0xb6, 0xc6, 0x4d, 0xb1, 0xe4, 0xda, 0x74,
-	0xb3, 0x39, 0x6d, 0xfb, 0x14, 0xd4, 0xf0, 0x1d, 0xdd, 0x1f, 0xd3, 0xea, 0xf0, 0x2c, 0x8b, 0xe0,
-	0x8f, 0x2c, 0xae, 0x61, 0xa4, 0x65, 0xab, 0x18, 0x77, 0x63, 0xc4, 0xa4, 0x23, 0xf4, 0x0c, 0x86,
-	0x9a, 0xc9, 0x86, 0xbb, 0x41, 0xae, 0x88, 0x87, 0xf1, 0x77, 0x00, 0x87, 0x37, 0x64, 0xfe, 0x81,
-	0x8b, 0x62, 0xbd, 0x90, 0xca, 0xa6, 0x66, 0xe4, 0x29, 0x1d, 0x67, 0xe5, 0x9f, 0xa9, 0x9d, 0x6d,
-	0x3a, 0x73, 0xd2, 0x7b, 0xec, 0xa4, 0x2c, 0xed, 0xc7, 0x3d, 0x3a, 0xf4, 0xe4, 0x9c, 0x18, 0x6a,
-	0xbc, 0xc1, 0x90, 0x78, 0xb0, 0x55, 0x9f, 0x4f, 0xe8, 0xab, 0x0e, 0x5e, 0x3d, 0x87, 0x83, 0xe3,
-	0x0d, 0x42, 0x11, 0xec, 0x6d, 0xdf, 0x8e, 0x2e, 0xdc, 0xf3, 0xdd, 0x08, 0xbc, 0xd7, 0x77, 0x0f,
-	0xc9, 0xc5, 0xcf, 0x87, 0xe4, 0xe2, 0xdb, 0x21, 0x01, 0x77, 0x87, 0x04, 0xfc, 0x38, 0x24, 0xe0,
-	0xfe, 0x90, 0x80, 0xcf, 0x9f, 0xfe, 0xf3, 0xce, 0xab, 0xb6, 0x36, 0xa2, 0xe2, 0xf9, 0x56, 0x28,
-	0x73, 0xb6, 0xd4, 0x6c, 0x8a, 0xc7, 0xbf, 0xc3, 0x22, 0x72, 0xf2, 0xcd, 0xaf, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xf8, 0xd7, 0x14, 0x95, 0x57, 0x03, 0x00, 0x00,
+	0x18, 0x86, 0xeb, 0xa6, 0xc9, 0x35, 0xae, 0x0e, 0x2a, 0x0b, 0x9d, 0x2c, 0x90, 0xa2, 0xa8, 0x0b,
+	0x11, 0x12, 0x8d, 0x54, 0x10, 0xfb, 0x31, 0x9c, 0xd4, 0x05, 0x15, 0x6f, 0xb0, 0x20, 0xd7, 0x75,
+	0xd3, 0xa8, 0x49, 0x1c, 0xd9, 0x4e, 0xab, 0x8a, 0x85, 0x3f, 0xc2, 0xff, 0xb9, 0x91, 0x91, 0xf1,
+	0xae, 0xbf, 0x04, 0xd9, 0x4e, 0xab, 0x50, 0x58, 0x6e, 0xca, 0xfb, 0x7c, 0xb6, 0xf3, 0xbd, 0xdf,
+	0x1b, 0x07, 0x7e, 0xce, 0x72, 0xbd, 0x69, 0x96, 0x53, 0x26, 0xca, 0x74, 0x4b, 0x35, 0x7d, 0xcb,
+	0x44, 0xa5, 0x69, 0x5e, 0x71, 0xa9, 0xfe, 0x61, 0x25, 0x59, 0x4a, 0x33, 0x5e, 0xe9, 0xb4, 0x96,
+	0x42, 0x0b, 0x26, 0x0a, 0xe5, 0x94, 0x4a, 0xf5, 0xa1, 0xe6, 0x6a, 0x6a, 0x01, 0xf9, 0x16, 0x26,
+	0x4b, 0x18, 0xce, 0x17, 0xb7, 0xab, 0x95, 0xe4, 0x4a, 0xa1, 0xd7, 0x30, 0x58, 0xd3, 0x32, 0x2f,
+	0x0e, 0x18, 0xc4, 0x20, 0x79, 0x36, 0x7b, 0x3e, 0x75, 0x27, 0xe6, 0x8b, 0x3b, 0x5b, 0x26, 0xed,
+	0x32, 0xc2, 0xf0, 0x8a, 0xba, 0x33, 0xb8, 0x1f, 0x83, 0x24, 0x24, 0x27, 0x44, 0x08, 0x0e, 0x4a,
+	0xaa, 0xb6, 0xd8, 0xb3, 0x65, 0xab, 0x27, 0x0f, 0x00, 0x86, 0xf3, 0x4a, 0x73, 0xb9, 0xa6, 0x8c,
+	0xa3, 0x1b, 0x18, 0xac, 0xf8, 0x2e, 0x67, 0xdc, 0x36, 0x09, 0x49, 0x4b, 0xe6, 0x64, 0x45, 0x4b,
+	0xde, 0xbe, 0xd0, 0x6a, 0x34, 0x83, 0xa3, 0xb3, 0x3b, 0xae, 0xb0, 0x17, 0x7b, 0xc9, 0x68, 0x36,
+	0x3e, 0xbb, 0x6a, 0x57, 0x48, 0x77, 0x13, 0x1a, 0x43, 0xaf, 0xd4, 0x0d, 0x1e, 0xc4, 0x20, 0x19,
+	0x10, 0x23, 0x4d, 0xc7, 0xcd, 0xde, 0x6c, 0xc0, 0xbe, 0xeb, 0xe8, 0xc8, 0x4c, 0x51, 0xb3, 0x7c,
+	0x41, 0xf5, 0x06, 0x07, 0x6e, 0x8a, 0x16, 0x8d, 0x17, 0xd3, 0x03, 0x5f, 0x39, 0x2f, 0x46, 0xa3,
+	0x57, 0x30, 0x94, 0x74, 0xff, 0x6d, 0x5d, 0xd0, 0x4c, 0xe1, 0x61, 0x0c, 0x92, 0x6b, 0x32, 0x94,
+	0x74, 0x7f, 0x67, 0x78, 0xf2, 0x1d, 0xfa, 0x44, 0x34, 0xda, 0x4e, 0xb1, 0xe2, 0x4a, 0xb7, 0xb3,
+	0x59, 0x6d, 0xfa, 0x64, 0x54, 0xf3, 0x3d, 0x3d, 0x9c, 0xd2, 0x6a, 0xb1, 0x93, 0x85, 0xf7, 0x57,
+	0x16, 0x37, 0x30, 0x50, 0xa2, 0x91, 0x8c, 0xdb, 0x31, 0x42, 0xd2, 0x12, 0x7a, 0x01, 0x7d, 0xc5,
+	0x44, 0xcd, 0xed, 0x20, 0xd7, 0xc4, 0xc1, 0xe4, 0x27, 0x80, 0xa3, 0x5b, 0xb2, 0xf8, 0xc4, 0xf3,
+	0x6c, 0xb3, 0x14, 0xd2, 0xa4, 0xa6, 0xc5, 0x39, 0x12, 0x6b, 0xe5, 0xbf, 0xa9, 0x75, 0x36, 0x75,
+	0x9c, 0xf4, 0x2f, 0x9d, 0x14, 0x85, 0xf9, 0xb8, 0x27, 0x87, 0x8e, 0xac, 0x13, 0x4d, 0xb5, 0x33,
+	0xe8, 0x13, 0x07, 0xa6, 0xea, 0xf2, 0xf1, 0x5d, 0xd5, 0xc2, 0x9b, 0x97, 0x70, 0x78, 0xba, 0x41,
+	0x28, 0x80, 0xfd, 0xdd, 0xfb, 0x71, 0xcf, 0x3e, 0x3f, 0x8c, 0xc1, 0x47, 0x75, 0xff, 0x18, 0xf5,
+	0x7e, 0x3f, 0x46, 0xbd, 0x1f, 0xc7, 0x08, 0xdc, 0x1f, 0x23, 0xf0, 0xeb, 0x18, 0x81, 0x87, 0x63,
+	0x04, 0xbe, 0x7e, 0x79, 0xe2, 0x9d, 0x97, 0x4d, 0xa5, 0xf3, 0x92, 0xa7, 0xbb, 0x5c, 0xea, 0xce,
+	0x52, 0xbd, 0xcd, 0x2e, 0x7f, 0x87, 0x65, 0x60, 0xe5, 0xbb, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff,
+	0xed, 0x3e, 0x9a, 0x58, 0x57, 0x03, 0x00, 0x00,
 }
 
 func (m *IPAddress) Marshal() (dAtA []byte, err error) {
diff --git a/src/runtime/virtcontainers/pkg/annotations/annotations.go b/src/runtime/virtcontainers/pkg/annotations/annotations.go
index 8e4306aef..838b2994f 100644
--- a/src/runtime/virtcontainers/pkg/annotations/annotations.go
+++ b/src/runtime/virtcontainers/pkg/annotations/annotations.go
@@ -9,6 +9,7 @@ const (
 	kataAnnotationsPrefix     = "io.katacontainers."
 	kataConfAnnotationsPrefix = kataAnnotationsPrefix + "config."
 	kataAnnotHypervisorPrefix = kataConfAnnotationsPrefix + "hypervisor."
+	kataAnnotContainerPrefix  = kataAnnotationsPrefix + "container."
 
 	//
 	// OCI
@@ -219,6 +220,9 @@ const (
 
 	// TxRateLimiter is a sandbox annotation that specifies max rate on network I/O outbound bandwidth
 	TxRateLimiterMaxRate = kataAnnotHypervisorPrefix + "tx_rate_limiter_max_rate"
+
+	// EnableGuestSwap is a sandbox annotation to enable swap in the guest.
+	EnableGuestSwap = kataAnnotHypervisorPrefix + "enable_guest_swap"
 )
 
 // Runtime related annotations
@@ -277,6 +281,17 @@ const (
 	ContainerPipeSizeKernelParam = "agent." + ContainerPipeSizeOption
 )
 
+// Container resource related annotations
+const (
+	kataAnnotContainerResourcePrefix = kataAnnotContainerPrefix + "resource."
+
+	// ContainerResourcesSwappiness is a container annotation to specify the Resources.Memory.Swappiness
+	ContainerResourcesSwappiness = kataAnnotContainerResourcePrefix + "swappiness"
+
+	// ContainerResourcesSwapInBytes is a container annotation to specify the Resources.Memory.Swap
+	ContainerResourcesSwapInBytes = kataAnnotContainerResourcePrefix + "swap_in_bytes"
+)
+
 const (
 	// SHA512 is the SHA-512 (64) hash algorithm
 	SHA512 string = "sha512"
diff --git a/src/runtime/virtcontainers/pkg/mock/mock.go b/src/runtime/virtcontainers/pkg/mock/mock.go
index bec736d6e..0c95e36d4 100644
--- a/src/runtime/virtcontainers/pkg/mock/mock.go
+++ b/src/runtime/virtcontainers/pkg/mock/mock.go
@@ -222,3 +222,7 @@ func (p *HybridVSockTTRPCMockImp) GetOOMEvent(ctx context.Context, req *pb.GetOO
 func (p *HybridVSockTTRPCMockImp) GetMetrics(ctx context.Context, req *pb.GetMetricsRequest) (*pb.Metrics, error) {
 	return &pb.Metrics{}, nil
 }
+
+func (p *HybridVSockTTRPCMockImp) AddSwap(ctx context.Context, req *pb.AddSwapRequest) (*gpb.Empty, error) {
+	return &gpb.Empty{}, nil
+}
diff --git a/src/runtime/virtcontainers/pkg/oci/utils.go b/src/runtime/virtcontainers/pkg/oci/utils.go
index 9eecd02b4..bbdd5dcae 100644
--- a/src/runtime/virtcontainers/pkg/oci/utils.go
+++ b/src/runtime/virtcontainers/pkg/oci/utils.go
@@ -539,6 +539,7 @@ func addHypervisorPathOverrides(ocispec specs.Spec, config *vc.SandboxConfig, ru
 			}
 		}
 	}
+
 	return nil
 }
 
@@ -616,6 +617,12 @@ func addHypervisorMemoryOverrides(ocispec specs.Spec, sbConfig *vc.SandboxConfig
 		return err
 	}
 
+	if err := newAnnotationConfiguration(ocispec, vcAnnotations.EnableGuestSwap).setBool(func(enableGuestSwap bool) {
+		sbConfig.HypervisorConfig.GuestSwap = enableGuestSwap
+	}); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -950,17 +957,22 @@ func ContainerConfig(ocispec specs.Spec, bundlePath, cid, console string, detach
 		RootFs:         rootfs,
 		ReadonlyRootfs: ocispec.Root.Readonly,
 		Cmd:            cmd,
-		Annotations: map[string]string{
-			vcAnnotations.BundlePathKey: bundlePath,
-		},
-		Mounts:      containerMounts(ocispec),
-		DeviceInfos: deviceInfos,
-		Resources:   *ocispec.Linux.Resources,
+		Annotations:    ocispec.Annotations,
+		Mounts:         containerMounts(ocispec),
+		DeviceInfos:    deviceInfos,
+		Resources:      *ocispec.Linux.Resources,
 
 		// This is a custom OCI spec modified at SetEphemeralStorageType()
 		// to support ephemeral storage and k8s empty dir.
 		CustomSpec: &ocispec,
 	}
+	if containerConfig.Annotations == nil {
+		containerConfig.Annotations = map[string]string{
+			vcAnnotations.BundlePathKey: bundlePath,
+		}
+	} else {
+		containerConfig.Annotations[vcAnnotations.BundlePathKey] = bundlePath
+	}
 
 	cType, err := ContainerType(ocispec)
 	if err != nil {
diff --git a/src/runtime/virtcontainers/pkg/types/pcipath.go b/src/runtime/virtcontainers/pkg/types/pcipath.go
index 786ab67a3..5b7b3db91 100644
--- a/src/runtime/virtcontainers/pkg/types/pcipath.go
+++ b/src/runtime/virtcontainers/pkg/types/pcipath.go
@@ -75,6 +75,14 @@ func (p PciPath) IsNil() bool {
 	return p.slots == nil
 }
 
+func (p PciPath) ToArray() []uint32 {
+	var slots []uint32
+	for _, slot := range p.slots {
+		slots = append(slots, uint32(slot.slot))
+	}
+	return slots
+}
+
 func PciPathFromString(s string) (PciPath, error) {
 	if s == "" {
 		return PciPath{}, nil
diff --git a/src/runtime/virtcontainers/qemu.go b/src/runtime/virtcontainers/qemu.go
index f340e36e4..8bdc0439f 100644
--- a/src/runtime/virtcontainers/qemu.go
+++ b/src/runtime/virtcontainers/qemu.go
@@ -1232,7 +1232,9 @@ func (q *qemu) hotplugAddBlockDevice(ctx context.Context, drive *config.BlockDri
 		return nil
 	}
 
-	if q.config.BlockDeviceCacheSet {
+	if drive.Swap {
+		err = q.qmpMonitorCh.qmp.ExecuteBlockdevAddWithCache(q.qmpMonitorCh.ctx, drive.File, drive.ID, false, false, false)
+	} else if q.config.BlockDeviceCacheSet {
 		err = q.qmpMonitorCh.qmp.ExecuteBlockdevAddWithCache(q.qmpMonitorCh.ctx, drive.File, drive.ID, q.config.BlockDeviceCacheDirect, q.config.BlockDeviceCacheNoflush, drive.ReadOnly)
 	} else {
 		err = q.qmpMonitorCh.qmp.ExecuteBlockdevAdd(q.qmpMonitorCh.ctx, drive.File, drive.ID, drive.ReadOnly)
@@ -1248,25 +1250,8 @@ func (q *qemu) hotplugAddBlockDevice(ctx context.Context, drive *config.BlockDri
 	}()
 
 	switch {
-	case q.config.BlockDeviceDriver == config.VirtioBlockCCW:
-		driver := "virtio-blk-ccw"
-
-		addr, bridge, err := q.arch.addDeviceToBridge(ctx, drive.ID, types.CCW)
-		if err != nil {
-			return err
-		}
-		var devNoHotplug string
-		devNoHotplug, err = bridge.AddressFormatCCW(addr)
-		if err != nil {
-			return err
-		}
-		drive.DevNo, err = bridge.AddressFormatCCWForVirtServer(addr)
-		if err != nil {
-			return err
-		}
-		if err = q.qmpMonitorCh.qmp.ExecuteDeviceAdd(q.qmpMonitorCh.ctx, drive.ID, devID, driver, devNoHotplug, "", true, false); err != nil {
-			return err
-		}
+	case drive.Swap:
+		fallthrough
 	case q.config.BlockDeviceDriver == config.VirtioBlock:
 		driver := "virtio-blk-pci"
 		addr, bridge, err := q.arch.addDeviceToBridge(ctx, drive.ID, types.PCI)
@@ -1296,6 +1281,25 @@ func (q *qemu) hotplugAddBlockDevice(ctx context.Context, drive *config.BlockDri
 		if err = q.qmpMonitorCh.qmp.ExecutePCIDeviceAdd(q.qmpMonitorCh.ctx, drive.ID, devID, driver, addr, bridge.ID, romFile, 0, true, defaultDisableModern); err != nil {
 			return err
 		}
+	case q.config.BlockDeviceDriver == config.VirtioBlockCCW:
+		driver := "virtio-blk-ccw"
+
+		addr, bridge, err := q.arch.addDeviceToBridge(ctx, drive.ID, types.CCW)
+		if err != nil {
+			return err
+		}
+		var devNoHotplug string
+		devNoHotplug, err = bridge.AddressFormatCCW(addr)
+		if err != nil {
+			return err
+		}
+		drive.DevNo, err = bridge.AddressFormatCCWForVirtServer(addr)
+		if err != nil {
+			return err
+		}
+		if err = q.qmpMonitorCh.qmp.ExecuteDeviceAdd(q.qmpMonitorCh.ctx, drive.ID, devID, driver, devNoHotplug, "", true, false); err != nil {
+			return err
+		}
 	case q.config.BlockDeviceDriver == config.VirtioSCSI:
 		driver := "scsi-hd"
 
@@ -1369,7 +1373,7 @@ func (q *qemu) hotplugBlockDevice(ctx context.Context, drive *config.BlockDrive,
 	if op == addDevice {
 		return q.hotplugAddBlockDevice(ctx, drive, op, devID)
 	}
-	if q.config.BlockDeviceDriver == config.VirtioBlock {
+	if !drive.Swap && q.config.BlockDeviceDriver == config.VirtioBlock {
 		if err := q.arch.removeDeviceFromBridge(drive.ID); err != nil {
 			return err
 		}
diff --git a/src/runtime/virtcontainers/sandbox.go b/src/runtime/virtcontainers/sandbox.go
index 2a41a1b4b..7784a66b8 100644
--- a/src/runtime/virtcontainers/sandbox.go
+++ b/src/runtime/virtcontainers/sandbox.go
@@ -8,12 +8,15 @@ package virtcontainers
 
 import (
 	"bufio"
+	"bytes"
 	"context"
 	"fmt"
 	"io"
 	"math"
 	"net"
 	"os"
+	"os/exec"
+	"path/filepath"
 	"strings"
 	"sync"
 	"syscall"
@@ -63,6 +66,8 @@ const (
 
 	// DirMode is the permission bits used for creating a directory
 	DirMode = os.FileMode(0750) | os.ModeDir
+
+	mkswapPath = "/sbin/mkswap"
 )
 
 var (
@@ -198,6 +203,10 @@ type Sandbox struct {
 	ctx context.Context
 
 	cw *consoleWatcher
+
+	swapDeviceNum uint
+	swapSizeBytes int64
+	swapDevices   []*config.BlockDrive
 }
 
 // ID returns the sandbox identifier string.
@@ -517,6 +526,9 @@ func newSandbox(ctx context.Context, sandboxConfig SandboxConfig, factory Factor
 		sharePidNs:      sandboxConfig.SharePidNs,
 		networkNS:       NetworkNamespace{NetNsPath: sandboxConfig.NetworkConfig.NetNSPath},
 		ctx:             ctx,
+		swapDeviceNum:   0,
+		swapSizeBytes:   0,
+		swapDevices:     []*config.BlockDrive{},
 	}
 
 	hypervisor.setSandbox(s)
@@ -996,6 +1008,115 @@ func (cw *consoleWatcher) stop() {
 	}
 }
 
+func (s *Sandbox) addSwap(ctx context.Context, swapID string, size int64) (*config.BlockDrive, error) {
+	swapFile := filepath.Join(getSandboxPath(s.id), swapID)
+
+	swapFD, err := os.OpenFile(swapFile, os.O_CREATE, 0600)
+	if err != nil {
+		err = fmt.Errorf("creat swapfile %s fail %s", swapFile, err.Error())
+		s.Logger().WithError(err).Error("addSwap")
+		return nil, err
+	}
+	swapFD.Close()
+	defer func() {
+		if err != nil {
+			os.Remove(swapFile)
+		}
+	}()
+
+	// Check the size
+	pagesize := os.Getpagesize()
+	// mkswap refuses areas smaller than 10 pages.
+	size = int64(math.Max(float64(size), float64(pagesize*10)))
+	// Swapfile need a page to store the metadata
+	size += int64(pagesize)
+
+	err = os.Truncate(swapFile, size)
+	if err != nil {
+		err = fmt.Errorf("truncate swapfile %s fail %s", swapFile, err.Error())
+		s.Logger().WithError(err).Error("addSwap")
+		return nil, err
+	}
+
+	var outbuf, errbuf bytes.Buffer
+	cmd := exec.CommandContext(ctx, mkswapPath, swapFile)
+	cmd.Stdout = &outbuf
+	cmd.Stderr = &errbuf
+	err = cmd.Run()
+	if err != nil {
+		err = fmt.Errorf("mkswap swapfile %s fail %s stdout %s stderr %s", swapFile, err.Error(), outbuf.String(), errbuf.String())
+		s.Logger().WithError(err).Error("addSwap")
+		return nil, err
+	}
+
+	blockDevice := &config.BlockDrive{
+		File:   swapFile,
+		Format: "raw",
+		ID:     swapID,
+		Swap:   true,
+	}
+	_, err = s.hypervisor.hotplugAddDevice(ctx, blockDevice, blockDev)
+	if err != nil {
+		err = fmt.Errorf("add swapfile %s device to VM fail %s", swapFile, err.Error())
+		s.Logger().WithError(err).Error("addSwap")
+		return nil, err
+	}
+	defer func() {
+		if err != nil {
+			_, e := s.hypervisor.hotplugRemoveDevice(ctx, blockDevice, blockDev)
+			if e != nil {
+				s.Logger().Errorf("remove swapfile %s to VM fail %s", swapFile, e.Error())
+			}
+		}
+	}()
+
+	err = s.agent.addSwap(ctx, blockDevice.PCIPath)
+	if err != nil {
+		err = fmt.Errorf("agent add swapfile %s PCIPath %+v to VM fail %s", swapFile, blockDevice.PCIPath, err.Error())
+		s.Logger().WithError(err).Error("addSwap")
+		return nil, err
+	}
+
+	s.Logger().Infof("add swapfile %s size %d PCIPath %+v to VM success", swapFile, size, blockDevice.PCIPath)
+
+	return blockDevice, nil
+}
+
+func (s *Sandbox) removeSwap(ctx context.Context, blockDevice *config.BlockDrive) error {
+	err := os.Remove(blockDevice.File)
+	if err != nil {
+		err = fmt.Errorf("remove swapfile %s fail %s", blockDevice.File, err.Error())
+		s.Logger().WithError(err).Error("removeSwap")
+	} else {
+		s.Logger().Infof("remove swapfile %s success", blockDevice.File)
+	}
+	return err
+}
+
+func (s *Sandbox) setupSwap(ctx context.Context, sizeBytes int64) error {
+	if sizeBytes > s.swapSizeBytes {
+		dev, err := s.addSwap(ctx, fmt.Sprintf("swap%d", s.swapDeviceNum), sizeBytes-s.swapSizeBytes)
+		if err != nil {
+			return err
+		}
+
+		s.swapDeviceNum += 1
+		s.swapSizeBytes = sizeBytes
+		s.swapDevices = append(s.swapDevices, dev)
+	}
+
+	return nil
+}
+
+func (s *Sandbox) cleanSwap(ctx context.Context) {
+	for _, dev := range s.swapDevices {
+		err := s.removeSwap(ctx, dev)
+		if err != nil {
+			s.Logger().Warnf("remove swap device %+v got error %s", dev, err)
+		}
+	}
+}
+
 // startVM starts the VM.
 func (s *Sandbox) startVM(ctx context.Context) (err error) {
 	span, ctx := katatrace.Trace(ctx, s.Logger(), "startVM", s.tracingTags())
@@ -1074,6 +1195,14 @@ func (s *Sandbox) startVM(ctx context.Context) (err error) {
 
 	s.Logger().Info("Agent started in the sandbox")
 
+	defer func() {
+		if err != nil {
+			if e := s.agent.stopSandbox(ctx, s); e != nil {
+				s.Logger().WithError(e).WithField("sandboxid", s.id).Warning("Agent did not stop sandbox")
+			}
+		}
+	}()
+
 	return nil
 }
 
@@ -1550,6 +1679,8 @@ func (s *Sandbox) Stop(ctx context.Context, force bool) error {
 		return err
 	}
 
+	s.cleanSwap(ctx)
+
 	return nil
 }
 
@@ -1803,9 +1934,21 @@ func (s *Sandbox) updateResources(ctx context.Context) error {
 	// Add default vcpus for sandbox
 	sandboxVCPUs += s.hypervisor.hypervisorConfig().NumVCPUs
 
-	sandboxMemoryByte := s.calculateSandboxMemory()
+	sandboxMemoryByte, sandboxneedPodSwap, sandboxSwapByte := s.calculateSandboxMemory()
 	// Add default / rsvd memory for sandbox.
-	sandboxMemoryByte += int64(s.hypervisor.hypervisorConfig().MemorySize) << utils.MibToBytesShift
+	hypervisorMemoryByte := int64(s.hypervisor.hypervisorConfig().MemorySize) << utils.MibToBytesShift
+	sandboxMemoryByte += hypervisorMemoryByte
+	if sandboxneedPodSwap {
+		sandboxSwapByte += hypervisorMemoryByte
+	}
+
+	// Setup the SWAP in the guest
+	if sandboxSwapByte > 0 {
+		err = s.setupSwap(ctx, sandboxSwapByte)
+		if err != nil {
+			return err
+		}
+	}
 
 	// Update VCPUs
 	s.Logger().WithField("cpus-sandbox", sandboxVCPUs).Debugf("Request to hypervisor to update vCPUs")
@@ -1846,11 +1989,14 @@ func (s *Sandbox) updateResources(ctx context.Context) error {
 	if err := s.agent.onlineCPUMem(ctx, 0, false); err != nil {
 		return err
 	}
+
 	return nil
 }
 
-func (s *Sandbox) calculateSandboxMemory() int64 {
+func (s *Sandbox) calculateSandboxMemory() (int64, bool, int64) {
 	memorySandbox := int64(0)
+	needPodSwap := false
+	swapSandbox := int64(0)
 	for _, c := range s.config.Containers {
 		// Do not hot add again non-running containers resources
 		if cont, ok := s.containers[c.ID]; ok && cont.state.State == types.StateStopped {
@@ -1858,11 +2004,30 @@ func (s *Sandbox) calculateSandboxMemory() int64 {
 			continue
 		}
 
-		if m := c.Resources.Memory; m != nil && m.Limit != nil {
-			memorySandbox += *m.Limit
+		if m := c.Resources.Memory; m != nil {
+			currentLimit := int64(0)
+			if m.Limit != nil {
+				currentLimit = *m.Limit
+				memorySandbox += currentLimit
+			}
+			if s.config.HypervisorConfig.GuestSwap && m.Swappiness != nil && *m.Swappiness > 0 {
+				currentSwap := int64(0)
+				if m.Swap != nil {
+					currentSwap = *m.Swap
+				}
+				if currentSwap == 0 {
+					if currentLimit == 0 {
+						needPodSwap = true
+					} else {
+						swapSandbox += currentLimit
+					}
+				} else if currentSwap > currentLimit {
+					swapSandbox = currentSwap - currentLimit
+				}
+			}
 		}
 	}
-	return memorySandbox
+	return memorySandbox, needPodSwap, swapSandbox
 }
 
 func (s *Sandbox) calculateSandboxCPUs() (uint32, error) {
diff --git a/src/runtime/virtcontainers/sandbox_test.go b/src/runtime/virtcontainers/sandbox_test.go
index 27df559d3..77475be96 100644
--- a/src/runtime/virtcontainers/sandbox_test.go
+++ b/src/runtime/virtcontainers/sandbox_test.go
@@ -168,8 +168,10 @@ func TestCalculateSandboxMem(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			sandbox.config.Containers = tt.containers
-			got := sandbox.calculateSandboxMemory()
-			assert.Equal(t, got, tt.want)
+			mem, needSwap, swap := sandbox.calculateSandboxMemory()
+			assert.Equal(t, mem, tt.want)
+			assert.Equal(t, needSwap, false)
+			assert.Equal(t, swap, int64(0))
 		})
 	}
 }