shim: Add PullImage support

Add a new PullImage endpoint to the shim API.
Add new PullImage functions to the virtcontainers files, which allows
the PullImage endpoint on the agent to be called.
Update the containerd vendor files to support new PullImage API changes.

Fixes #2651

Signed-off-by: Dave Hay <david_hay@uk.ibm.com>
Co-authored-by: ashleyrobertson <ashleyro@uk.ibm.com>
Co-authored-by: stevenhorsman <steven@uk.ibm.com>

src/runtime/go.mod

@@ -58,7 +58,7 @@ require (
 )
 
 replace (
-	github.com/containerd/containerd => github.com/containerd/containerd v1.5.7
+	github.com/containerd/containerd => github.com/confidential-containers/containerd v1.5.8-0.20211026205748-ba7b469fa4d7
 	github.com/opencontainers/runc => github.com/opencontainers/runc v1.0.1
 	github.com/uber-go/atomic => go.uber.org/atomic v1.5.1
 	google.golang.org/genproto => google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8

src/runtime/go.sum

@@ -98,6 +98,8 @@ github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDk
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
+github.com/confidential-containers/containerd v1.5.8-0.20211026205748-ba7b469fa4d7 h1:pCf9B/MN4QsbgisCkJBZtrIuv9JJXmHjXSdqvAmwlTc=
+github.com/confidential-containers/containerd v1.5.8-0.20211026205748-ba7b469fa4d7/go.mod h1:gyvv6+ugqY25TiXxcZC3L5yOeYgEw0QMhscqVp1AR9c=
 github.com/containerd/aufs v1.0.0/go.mod h1:kL5kd6KM5TzQjR79jljyi4olc1Vrx6XBlcyj3gNv2PU=
 github.com/containerd/btrfs v1.0.0/go.mod h1:zMcX3qkXTAi9GI50+0HOeuV8LU2ryCE/V2vG/ZBiTss=
 github.com/containerd/cgroups v0.0.0-20210114181951-8a68de567b68/go.mod h1:ZJeTFisyysqgcCdecO57Dj79RfL0LNeGiFUqLYQRYLE=
@@ -106,8 +108,6 @@ github.com/containerd/cgroups v1.0.1/go.mod h1:0SJrPIenamHDcZhEcJMNBB85rHcUsw4f2
 github.com/containerd/console v1.0.1/go.mod h1:XUsP6YE/mKtz6bxc+I8UiKKTP04qjQL4qcS3XoQ5xkw=
 github.com/containerd/console v1.0.2 h1:Pi6D+aZXM+oUw1czuKgH5IJ+y0jhYcwBJfx5/Ghn9dE=
 github.com/containerd/console v1.0.2/go.mod h1:ytZPjGgY2oeTkAONYafi2kSj0aYggsf8acV1PGKCbzQ=
-github.com/containerd/containerd v1.5.7 h1:rQyoYtj4KddB3bxG6SAqd4+08gePNyJjRqvOIfV3rkM=
-github.com/containerd/containerd v1.5.7/go.mod h1:gyvv6+ugqY25TiXxcZC3L5yOeYgEw0QMhscqVp1AR9c=
 github.com/containerd/continuity v0.0.0-20210208174643-50096c924a4e/go.mod h1:EXlVlkqNba9rJe3j7w3Xa924itAMLgZH4UD/Q4PExuQ=
 github.com/containerd/continuity v0.1.0 h1:UFRRY5JemiAhPZrr/uE0n8fMTLcZsUvySPr1+D7pgr8=
 github.com/containerd/continuity v0.1.0/go.mod h1:ICJu0PwR54nI0yPEnJ6jcS+J7CZAUXrLh8lPo2knzsM=

src/runtime/pkg/containerd-shim-v2/service.go

@@ -751,6 +751,32 @@ func (s *service) Resume(ctx context.Context, r *taskAPI.ResumeRequest) (_ *ptyp
 	return empty, err
 }
 
+// Pull image and unbundle ready for container creation
+func (s *service) PullImage(ctx context.Context, r *taskAPI.PullImageRequest) (_ *ptypes.Empty, err error) {
+	shimLog.WithField("id", r.ID).Debug("PullImage() start")
+	defer shimLog.WithField("id", r.ID).Debug("PullImage() end")
+	span, spanCtx := katatrace.Trace(s.rootCtx, shimLog, "PullImage", shimTracingTags)
+	defer span.End()
+
+	start := time.Now()
+	defer func() {
+		err = toGRPC(err)
+		rpcDurationsHistogram.WithLabelValues("pullimage").Observe(float64(time.Since(start).Nanoseconds() / int64(time.Millisecond)))
+	}()
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	shimLog.WithFields(logrus.Fields{
+		"image":            r.Image,
+		"new_container_id": r.NewContainerID,
+	}).Debug("Making image pull request")
+
+	err = s.sandbox.PullImage(spanCtx, r.Image, r.NewContainerID)
+
+	return empty, err
+}
+
 // Kill a process with the provided signal
 func (s *service) Kill(ctx context.Context, r *taskAPI.KillRequest) (_ *ptypes.Empty, err error) {
 	shimLog.WithField("container", r.ID).Debug("Kill() start")

src/runtime/vendor/github.com/containerd/containerd/runtime/v2/task/shim.pb.go

@@ -326,6 +326,47 @@ func (m *ResizePtyRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ResizePtyRequest proto.InternalMessageInfo
 
+type PullImageRequest struct {
+	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	Image                string   `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
+	NewContainerID       string   `protobuf:"bytes,3,opt,name=new_container_id,json=newContainerId,proto3" json:"new_container_id,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PullImageRequest) Reset()      { *m = PullImageRequest{} }
+func (*PullImageRequest) ProtoMessage() {}
+func (*PullImageRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9202ee34bc3ad8ca, []int{7}
+}
+func (m *PullImageRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *PullImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_PullImageRequest.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 *PullImageRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PullImageRequest.Merge(m, src)
+}
+func (m *PullImageRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *PullImageRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_PullImageRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PullImageRequest proto.InternalMessageInfo
+
 type StateRequest struct {
 	ID                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
 	ExecID               string   `protobuf:"bytes,2,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"`
@@ -337,7 +378,7 @@ type StateRequest struct {
 func (m *StateRequest) Reset()      { *m = StateRequest{} }
 func (*StateRequest) ProtoMessage() {}
 func (*StateRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{7}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{8}
 }
 func (m *StateRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -386,7 +427,7 @@ type StateResponse struct {
 func (m *StateResponse) Reset()      { *m = StateResponse{} }
 func (*StateResponse) ProtoMessage() {}
 func (*StateResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{8}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{9}
 }
 func (m *StateResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -428,7 +469,7 @@ type KillRequest struct {
 func (m *KillRequest) Reset()      { *m = KillRequest{} }
 func (*KillRequest) ProtoMessage() {}
 func (*KillRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{9}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{10}
 }
 func (m *KillRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -469,7 +510,7 @@ type CloseIORequest struct {
 func (m *CloseIORequest) Reset()      { *m = CloseIORequest{} }
 func (*CloseIORequest) ProtoMessage() {}
 func (*CloseIORequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{10}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{11}
 }
 func (m *CloseIORequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -508,7 +549,7 @@ type PidsRequest struct {
 func (m *PidsRequest) Reset()      { *m = PidsRequest{} }
 func (*PidsRequest) ProtoMessage() {}
 func (*PidsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{11}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{12}
 }
 func (m *PidsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -547,7 +588,7 @@ type PidsResponse struct {
 func (m *PidsResponse) Reset()      { *m = PidsResponse{} }
 func (*PidsResponse) ProtoMessage() {}
 func (*PidsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{12}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{13}
 }
 func (m *PidsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -588,7 +629,7 @@ type CheckpointTaskRequest struct {
 func (m *CheckpointTaskRequest) Reset()      { *m = CheckpointTaskRequest{} }
 func (*CheckpointTaskRequest) ProtoMessage() {}
 func (*CheckpointTaskRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{13}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{14}
 }
 func (m *CheckpointTaskRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -629,7 +670,7 @@ type UpdateTaskRequest struct {
 func (m *UpdateTaskRequest) Reset()      { *m = UpdateTaskRequest{} }
 func (*UpdateTaskRequest) ProtoMessage() {}
 func (*UpdateTaskRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{14}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{15}
 }
 func (m *UpdateTaskRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -669,7 +710,7 @@ type StartRequest struct {
 func (m *StartRequest) Reset()      { *m = StartRequest{} }
 func (*StartRequest) ProtoMessage() {}
 func (*StartRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{15}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{16}
 }
 func (m *StartRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -708,7 +749,7 @@ type StartResponse struct {
 func (m *StartResponse) Reset()      { *m = StartResponse{} }
 func (*StartResponse) ProtoMessage() {}
 func (*StartResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{16}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{17}
 }
 func (m *StartResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -748,7 +789,7 @@ type WaitRequest struct {
 func (m *WaitRequest) Reset()      { *m = WaitRequest{} }
 func (*WaitRequest) ProtoMessage() {}
 func (*WaitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{17}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{18}
 }
 func (m *WaitRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -788,7 +829,7 @@ type WaitResponse struct {
 func (m *WaitResponse) Reset()      { *m = WaitResponse{} }
 func (*WaitResponse) ProtoMessage() {}
 func (*WaitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{18}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{19}
 }
 func (m *WaitResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -827,7 +868,7 @@ type StatsRequest struct {
 func (m *StatsRequest) Reset()      { *m = StatsRequest{} }
 func (*StatsRequest) ProtoMessage() {}
 func (*StatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{19}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{20}
 }
 func (m *StatsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -866,7 +907,7 @@ type StatsResponse struct {
 func (m *StatsResponse) Reset()      { *m = StatsResponse{} }
 func (*StatsResponse) ProtoMessage() {}
 func (*StatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{20}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{21}
 }
 func (m *StatsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -905,7 +946,7 @@ type ConnectRequest struct {
 func (m *ConnectRequest) Reset()      { *m = ConnectRequest{} }
 func (*ConnectRequest) ProtoMessage() {}
 func (*ConnectRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{21}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{22}
 }
 func (m *ConnectRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -946,7 +987,7 @@ type ConnectResponse struct {
 func (m *ConnectResponse) Reset()      { *m = ConnectResponse{} }
 func (*ConnectResponse) ProtoMessage() {}
 func (*ConnectResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{22}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{23}
 }
 func (m *ConnectResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -986,7 +1027,7 @@ type ShutdownRequest struct {
 func (m *ShutdownRequest) Reset()      { *m = ShutdownRequest{} }
 func (*ShutdownRequest) ProtoMessage() {}
 func (*ShutdownRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{23}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{24}
 }
 func (m *ShutdownRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1025,7 +1066,7 @@ type PauseRequest struct {
 func (m *PauseRequest) Reset()      { *m = PauseRequest{} }
 func (*PauseRequest) ProtoMessage() {}
 func (*PauseRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{24}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{25}
 }
 func (m *PauseRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1064,7 +1105,7 @@ type ResumeRequest struct {
 func (m *ResumeRequest) Reset()      { *m = ResumeRequest{} }
 func (*ResumeRequest) ProtoMessage() {}
 func (*ResumeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9202ee34bc3ad8ca, []int{25}
+	return fileDescriptor_9202ee34bc3ad8ca, []int{26}
 }
 func (m *ResumeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1101,6 +1142,7 @@ func init() {
 	proto.RegisterType((*ExecProcessRequest)(nil), "containerd.task.v2.ExecProcessRequest")
 	proto.RegisterType((*ExecProcessResponse)(nil), "containerd.task.v2.ExecProcessResponse")
 	proto.RegisterType((*ResizePtyRequest)(nil), "containerd.task.v2.ResizePtyRequest")
+	proto.RegisterType((*PullImageRequest)(nil), "containerd.task.v2.PullImageRequest")
 	proto.RegisterType((*StateRequest)(nil), "containerd.task.v2.StateRequest")
 	proto.RegisterType((*StateResponse)(nil), "containerd.task.v2.StateResponse")
 	proto.RegisterType((*KillRequest)(nil), "containerd.task.v2.KillRequest")
@@ -1128,89 +1170,93 @@ func init() {
 }
 
 var fileDescriptor_9202ee34bc3ad8ca = []byte{
-	// 1306 bytes of a gzipped FileDescriptorProto
+	// 1365 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x4d, 0x6f, 0xdb, 0x46,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcd, 0x6f, 0x1b, 0x45,
-	0x13, 0x0e, 0xf5, 0x41, 0x49, 0xa3, 0xc8, 0x71, 0xf6, 0x75, 0xf2, 0x32, 0x0a, 0x20, 0x29, 0x4c,
+	0x14, 0xef, 0xfa, 0xdb, 0xcf, 0x75, 0xea, 0x0e, 0x69, 0xd9, 0xba, 0x92, 0xed, 0x6e, 0x69, 0x09,
-	0x93, 0xaa, 0x2d, 0x40, 0xa1, 0x0a, 0x1a, 0x14, 0x31, 0x90, 0xc2, 0x76, 0xdc, 0x40, 0x4d, 0x5a,
+	0x20, 0xad, 0x85, 0x2b, 0x2a, 0xd4, 0xa0, 0xa2, 0x7c, 0x51, 0x99, 0x96, 0x26, 0xda, 0x16, 0xb5,
-	0x1b, 0x4c, 0x8a, 0x04, 0xbd, 0x18, 0xb4, 0xb8, 0x91, 0x08, 0x4b, 0x5c, 0x96, 0xbb, 0x74, 0xa2,
+	0xe2, 0x12, 0x6d, 0xbc, 0x53, 0x7b, 0x15, 0x7b, 0x67, 0xd9, 0x99, 0x4d, 0x1a, 0x24, 0x10, 0x27,
-	0x02, 0x05, 0x7a, 0xea, 0xa1, 0xa7, 0xfe, 0xac, 0x1c, 0x0b, 0xf4, 0xd2, 0x4b, 0xd3, 0x46, 0xff,
+	0xce, 0xfc, 0x59, 0x3d, 0x22, 0x21, 0x24, 0x2e, 0x04, 0xea, 0xff, 0x80, 0x23, 0x37, 0x34, 0x1f,
-	0xa0, 0xc7, 0xde, 0x8a, 0xfd, 0x90, 0x45, 0x49, 0xa4, 0x14, 0x07, 0xba, 0x18, 0x3b, 0xdc, 0x67,
+	0xb6, 0xd7, 0xf6, 0xae, 0xdd, 0x56, 0xbe, 0x44, 0xf3, 0x76, 0x7e, 0xf3, 0x66, 0xe6, 0xcd, 0xef,
-	0x67, 0x67, 0x67, 0x9f, 0x79, 0x66, 0x65, 0xd8, 0xee, 0x79, 0xac, 0x1f, 0x1d, 0x5b, 0x5d, 0x32,
+	0xfd, 0xde, 0x73, 0x60, 0xb3, 0xeb, 0xb2, 0x5e, 0x78, 0x64, 0x76, 0xc8, 0xa0, 0xd9, 0x21, 0x1e,
-	0x6c, 0x75, 0x89, 0xcf, 0x1c, 0xcf, 0xc7, 0xa1, 0x1b, 0x1f, 0x86, 0x91, 0xcf, 0xbc, 0x21, 0x6e,
+	0xb3, 0x5d, 0x0f, 0x07, 0x4e, 0x74, 0x18, 0x84, 0x1e, 0x73, 0x07, 0xb8, 0x79, 0xd2, 0x6a, 0x32,
-	0x9d, 0xb6, 0x5b, 0xcc, 0xa1, 0x27, 0x2d, 0xda, 0xf7, 0x86, 0x56, 0x10, 0x12, 0x46, 0x10, 0x9a,
+	0x9b, 0x1e, 0x37, 0x69, 0xcf, 0x1d, 0x98, 0x7e, 0x40, 0x18, 0x41, 0x68, 0x02, 0x33, 0xf9, 0x9c,
-	0xc2, 0x2c, 0x3e, 0x67, 0x9d, 0xb6, 0xab, 0xd7, 0x7a, 0x84, 0xf4, 0x06, 0xb8, 0x25, 0x10, 0xc7,
+	0x79, 0xd2, 0xaa, 0x5e, 0xeb, 0x12, 0xd2, 0xed, 0xe3, 0xa6, 0x40, 0x1c, 0x85, 0x2f, 0x9a, 0xb6,
-	0xd1, 0x8b, 0x96, 0xe3, 0x8f, 0x24, 0xbc, 0x7a, 0x7d, 0x7e, 0x0a, 0x0f, 0x03, 0x36, 0x99, 0xdc,
+	0x77, 0x26, 0xe1, 0xd5, 0xeb, 0xb3, 0x53, 0x78, 0xe0, 0xb3, 0xd1, 0xe4, 0x7a, 0x97, 0x74, 0x89,
-	0xea, 0x91, 0x1e, 0x11, 0xc3, 0x16, 0x1f, 0xa9, 0xaf, 0xf5, 0xf9, 0x25, 0x3c, 0x14, 0xca, 0x9c,
+	0x18, 0x36, 0xf9, 0x48, 0x7d, 0xad, 0xcf, 0x2e, 0xe1, 0x47, 0xa1, 0xcc, 0x1e, 0xf8, 0x0a, 0x70,
-	0x61, 0xa0, 0x00, 0x77, 0x57, 0xc6, 0xef, 0x04, 0x5e, 0x8b, 0x8d, 0x02, 0x4c, 0x5b, 0x43, 0x12,
+	0x77, 0xe9, 0xf9, 0x6d, 0xdf, 0x6d, 0xb2, 0x33, 0x1f, 0xd3, 0xe6, 0x80, 0x84, 0x1e, 0x53, 0xeb,
-	0xf9, 0x4c, 0xad, 0xbb, 0x77, 0x8e, 0x75, 0xe2, 0xd8, 0xe2, 0x7c, 0x62, 0xad, 0xf9, 0x7b, 0x06,
+	0xee, 0xbd, 0xc5, 0x3a, 0x71, 0x6d, 0x71, 0x3f, 0xb1, 0xd6, 0xf8, 0x3d, 0x05, 0x97, 0x77, 0x02,
-	0x2e, 0xef, 0x85, 0xd8, 0x61, 0xf8, 0xa9, 0x43, 0x4f, 0x6c, 0xfc, 0x7d, 0x84, 0x29, 0x43, 0x57,
+	0x6c, 0x33, 0xfc, 0xd4, 0xa6, 0xc7, 0x16, 0xfe, 0x3e, 0xc4, 0x94, 0xa1, 0xab, 0x90, 0x72, 0x1d,
-	0x21, 0xe3, 0xb9, 0x86, 0xd6, 0xd0, 0x9a, 0xa5, 0x5d, 0x7d, 0xfc, 0xa6, 0x9e, 0xe9, 0x3c, 0xb0,
+	0x5d, 0x6b, 0x68, 0x1b, 0xc5, 0xed, 0xdc, 0xf0, 0xbc, 0x9e, 0x6a, 0xef, 0x5a, 0x29, 0xd7, 0x41,
-	0x33, 0x9e, 0x8b, 0xae, 0x82, 0x7e, 0x1c, 0xf9, 0xee, 0x00, 0x1b, 0x19, 0x3e, 0x67, 0x2b, 0x0b,
+	0x57, 0x21, 0x77, 0x14, 0x7a, 0x4e, 0x1f, 0xeb, 0x29, 0x3e, 0x67, 0x29, 0x0b, 0x35, 0x21, 0x17,
-	0xb5, 0x40, 0x0f, 0x09, 0x61, 0x2f, 0xa8, 0x91, 0x6d, 0x64, 0x9b, 0xe5, 0xf6, 0xff, 0xad, 0x78,
+	0x10, 0xc2, 0x5e, 0x50, 0x3d, 0xdd, 0x48, 0x6f, 0x94, 0x5a, 0xef, 0x9b, 0xd1, 0x68, 0xf2, 0x8d,
-	0x36, 0xf9, 0xc6, 0xd6, 0xd7, 0x3c, 0x60, 0x5b, 0xc1, 0x50, 0x15, 0x8a, 0x0c, 0x87, 0x43, 0xcf,
+	0xcd, 0x6f, 0xf8, 0x81, 0x2d, 0x05, 0x43, 0x55, 0x28, 0x30, 0x1c, 0x0c, 0x5c, 0xcf, 0xee, 0xeb,
-	0x77, 0x06, 0x46, 0xae, 0xa1, 0x35, 0x8b, 0xf6, 0x99, 0x8d, 0xb6, 0x20, 0x4f, 0x99, 0xeb, 0xf9,
+	0x99, 0x86, 0xb6, 0x51, 0xb0, 0xc6, 0x36, 0x5a, 0x87, 0x2c, 0x65, 0x8e, 0xeb, 0xe9, 0x59, 0xb1,
-	0x46, 0x5e, 0xec, 0x21, 0x0d, 0xbe, 0x35, 0x65, 0x2e, 0x89, 0x98, 0xa1, 0xcb, 0xad, 0xa5, 0xa5,
+	0x87, 0x34, 0xf8, 0xd6, 0x94, 0x39, 0x24, 0x64, 0x7a, 0x4e, 0x6e, 0x2d, 0x2d, 0xf5, 0x1d, 0x07,
-	0xbe, 0xe3, 0x30, 0x34, 0x0a, 0x67, 0xdf, 0x71, 0x18, 0xa2, 0x1a, 0x40, 0xb7, 0x8f, 0xbb, 0x27,
+	0x81, 0x9e, 0x1f, 0x7f, 0xc7, 0x41, 0x80, 0x6a, 0x00, 0x9d, 0x1e, 0xee, 0x1c, 0xfb, 0xc4, 0xf5,
-	0x01, 0xf1, 0x7c, 0x66, 0x14, 0xc5, 0x5c, 0xec, 0x0b, 0xfa, 0x04, 0x2e, 0x07, 0x4e, 0x88, 0x7d,
+	0x98, 0x5e, 0x10, 0x73, 0x91, 0x2f, 0xe8, 0x13, 0xb8, 0xec, 0xdb, 0x01, 0xf6, 0xd8, 0x61, 0x04,
-	0x76, 0x14, 0x83, 0x95, 0x04, 0x6c, 0x53, 0x4e, 0xec, 0x4d, 0xc1, 0x16, 0x14, 0x48, 0xc0, 0x3c,
+	0x56, 0x14, 0xb0, 0x8a, 0x9c, 0xd8, 0x99, 0x80, 0x4d, 0xc8, 0x13, 0x9f, 0xb9, 0xc4, 0xa3, 0x3a,
-	0xe2, 0x53, 0x03, 0x1a, 0x5a, 0xb3, 0xdc, 0xde, 0xb2, 0xe4, 0x65, 0x5a, 0x93, 0xcb, 0xb4, 0x76,
+	0x34, 0xb4, 0x8d, 0x52, 0x6b, 0xdd, 0x94, 0x8f, 0x69, 0x8e, 0x1e, 0xd3, 0xdc, 0xf2, 0xce, 0xac,
-	0xfc, 0x91, 0x3d, 0x01, 0x99, 0xb7, 0x01, 0xc5, 0x93, 0x4a, 0x03, 0xe2, 0x53, 0x8c, 0x36, 0x21,
+	0x11, 0xc8, 0xb8, 0x0d, 0x28, 0x1a, 0x54, 0xea, 0x13, 0x8f, 0x62, 0x54, 0x81, 0xb4, 0xaf, 0xc2,
-	0x1b, 0xa8, 0xb4, 0x56, 0x6c, 0x3e, 0x34, 0x1f, 0x43, 0xe5, 0x01, 0x1e, 0x60, 0x86, 0x57, 0x25,
+	0x5a, 0xb6, 0xf8, 0xd0, 0x78, 0x04, 0xe5, 0x5d, 0xdc, 0xc7, 0x0c, 0x2f, 0x0b, 0xfc, 0x4d, 0xc8,
-	0xfe, 0x26, 0x14, 0xf0, 0x2b, 0xdc, 0x3d, 0xf2, 0x5c, 0x99, 0xf9, 0x5d, 0x18, 0xbf, 0xa9, 0xeb,
+	0xe3, 0x97, 0xb8, 0x73, 0xe8, 0x3a, 0x32, 0xf2, 0xdb, 0x30, 0x3c, 0xaf, 0xe7, 0xf6, 0x5e, 0xe2,
-	0xfb, 0xaf, 0x70, 0xb7, 0xf3, 0xc0, 0xd6, 0xf9, 0x54, 0xc7, 0x35, 0x7f, 0xd6, 0x60, 0x63, 0xe2,
+	0x4e, 0x7b, 0xd7, 0xca, 0xf1, 0xa9, 0xb6, 0x63, 0xfc, 0xa2, 0xc1, 0xda, 0xc8, 0x5d, 0xd2, 0x96,
-	0x2e, 0x6d, 0x4b, 0x54, 0x87, 0x32, 0x7e, 0xe5, 0xb1, 0x23, 0xca, 0x1c, 0x16, 0x51, 0xe1, 0xad,
+	0xa8, 0x0e, 0x25, 0xfc, 0xd2, 0x65, 0x87, 0x94, 0xd9, 0x2c, 0xa4, 0xc2, 0x5b, 0xd9, 0x02, 0xfe,
-	0x62, 0x03, 0xff, 0xf4, 0x44, 0x7c, 0x41, 0x3b, 0x50, 0xe2, 0x16, 0x76, 0x8f, 0x1c, 0x66, 0x64,
+	0xe9, 0x89, 0xf8, 0x82, 0xb6, 0xa0, 0xc8, 0x2d, 0xec, 0x1c, 0xda, 0x4c, 0x4f, 0x8b, 0xdb, 0x56,
-	0xc5, 0x69, 0xab, 0x0b, 0xa7, 0x7d, 0x3a, 0xa1, 0xee, 0x6e, 0xf1, 0xf5, 0x9b, 0xfa, 0x85, 0x5f,
+	0xe7, 0x6e, 0xfb, 0x74, 0x44, 0xdd, 0xed, 0xc2, 0xab, 0xf3, 0xfa, 0x85, 0x5f, 0xff, 0xae, 0x6b,
-	0xff, 0xaa, 0x6b, 0x76, 0x51, 0x2e, 0xdb, 0x61, 0xe6, 0x9f, 0x1a, 0x20, 0x1e, 0xdb, 0x61, 0x48,
+	0x56, 0x41, 0x2e, 0xdb, 0x62, 0xc6, 0x5f, 0x1a, 0x20, 0x7e, 0xb6, 0x83, 0x80, 0x74, 0x30, 0xa5,
-	0xba, 0x98, 0xd2, 0x75, 0x1c, 0x6e, 0x86, 0x31, 0xd9, 0x34, 0xc6, 0xe4, 0x92, 0x19, 0x93, 0x4f,
+	0xab, 0xb8, 0xdc, 0x14, 0x63, 0xd2, 0x49, 0x8c, 0xc9, 0xc4, 0x33, 0x26, 0x9b, 0xc0, 0x98, 0xdc,
-	0x61, 0x8c, 0x3e, 0xc3, 0x98, 0x26, 0xe4, 0x68, 0x80, 0xbb, 0x82, 0x47, 0x69, 0x37, 0x2c, 0x10,
+	0x14, 0x63, 0x36, 0x20, 0x43, 0x7d, 0xdc, 0x11, 0x3c, 0x4a, 0x7a, 0x61, 0x81, 0x30, 0xae, 0xc0,
-	0xe6, 0x15, 0xf8, 0xdf, 0xcc, 0xf1, 0x64, 0xb2, 0xcd, 0x1f, 0x61, 0xd3, 0xc6, 0xd4, 0xfb, 0x01,
+	0x7b, 0x53, 0xd7, 0x93, 0xc1, 0x36, 0x7e, 0x84, 0x8a, 0x85, 0xa9, 0xfb, 0x03, 0x3e, 0x60, 0x67,
-	0x1f, 0xb2, 0xd1, 0x5a, 0xce, 0xbc, 0x05, 0xf9, 0x97, 0x9e, 0xcb, 0xfa, 0xe2, 0xc0, 0x15, 0x5b,
+	0x2b, 0xb9, 0xf3, 0x3a, 0x64, 0x4f, 0x5d, 0x87, 0xf5, 0xc4, 0x85, 0xcb, 0x96, 0x34, 0xf8, 0xf9,
-	0x1a, 0x3c, 0xfe, 0x3e, 0xf6, 0x7a, 0x7d, 0x26, 0x8e, 0x5b, 0xb1, 0x95, 0x65, 0x3e, 0x82, 0x8b,
+	0x7b, 0xd8, 0xed, 0xf6, 0x98, 0xb8, 0x6e, 0xd9, 0x52, 0x96, 0xf1, 0x13, 0x54, 0x0e, 0xc2, 0x7e,
-	0xfc, 0x0a, 0xd7, 0xc3, 0xa5, 0x7f, 0x32, 0x50, 0x51, 0xde, 0x14, 0x95, 0xce, 0xab, 0x09, 0x8a,
+	0xbf, 0x3d, 0xb0, 0xbb, 0x4b, 0xf9, 0xb4, 0x0e, 0x59, 0x97, 0xe3, 0x54, 0x1e, 0x4b, 0x03, 0x7d,
-	0x7a, 0xd9, 0x29, 0xf5, 0xee, 0xf0, 0xc4, 0x0b, 0xd6, 0xf1, 0xc0, 0x37, 0xda, 0xd7, 0xe3, 0x2a,
+	0x01, 0x15, 0x0f, 0x9f, 0x1e, 0x8e, 0x73, 0x97, 0x9f, 0x2e, 0x2d, 0xd6, 0xa2, 0xe1, 0x79, 0x7d,
-	0x71, 0xfa, 0xa9, 0x12, 0x0a, 0x49, 0x43, 0x5b, 0x41, 0xd7, 0xa4, 0x06, 0x71, 0xf6, 0x14, 0xe7,
+	0xed, 0x31, 0x3e, 0xdd, 0x19, 0x4d, 0xb5, 0x77, 0xad, 0x35, 0x2f, 0x6a, 0x3b, 0xc6, 0x43, 0xb8,
-	0xd8, 0x33, 0x57, 0x11, 0xa5, 0xe5, 0x15, 0x01, 0xef, 0x53, 0x11, 0xf1, 0x9c, 0x97, 0x53, 0x73,
+	0xc8, 0x29, 0xb4, 0x1a, 0x2e, 0xff, 0x9b, 0x82, 0xb2, 0xf2, 0xa6, 0xa8, 0xfc, 0xb6, 0x9a, 0xa4,
-	0xce, 0xa0, 0xfc, 0xc8, 0x1b, 0x0c, 0xd6, 0x42, 0x1d, 0x9e, 0x08, 0xaf, 0x37, 0x29, 0x96, 0x8a,
+	0xa8, 0x9f, 0x9e, 0x50, 0xff, 0x0e, 0x7f, 0x78, 0xc1, 0x7a, 0x1e, 0xb8, 0xb5, 0xd6, 0xf5, 0xa8,
-	0xad, 0x2c, 0x7e, 0x2b, 0xce, 0x60, 0xa2, 0xb9, 0x7c, 0x68, 0x76, 0x61, 0x63, 0x6f, 0x40, 0x28,
+	0x4a, 0x9d, 0x7c, 0xaa, 0x84, 0x4a, 0xa6, 0x81, 0xa5, 0xa0, 0x2b, 0x52, 0xa3, 0x28, 0x7b, 0x0b,
-	0xee, 0x1c, 0xac, 0x8b, 0xb3, 0xf2, 0xbe, 0x64, 0x91, 0x4a, 0xc3, 0xbc, 0x05, 0xe5, 0x43, 0xcf,
+	0x33, 0xec, 0x9d, 0xc9, 0xc8, 0xe2, 0xe2, 0x8c, 0x84, 0x77, 0xc9, 0xc8, 0x68, 0xcc, 0x4b, 0x89,
-	0x5d, 0xa5, 0x04, 0xe6, 0x37, 0x70, 0x51, 0xc2, 0x14, 0xe7, 0xee, 0x43, 0x29, 0x90, 0x45, 0x86,
+	0x31, 0x67, 0x50, 0x7a, 0xe8, 0xf6, 0xfb, 0x2b, 0xa1, 0x2e, 0x0f, 0x84, 0xdb, 0x1d, 0x25, 0x6b,
-	0xa9, 0xa1, 0x89, 0xd6, 0xd2, 0x48, 0x24, 0x8d, 0x2a, 0xc5, 0x8e, 0xff, 0x82, 0xd8, 0xd3, 0x25,
+	0xd9, 0x52, 0x16, 0x7f, 0x15, 0xbb, 0x3f, 0xd2, 0x7c, 0x3e, 0x34, 0x3a, 0xb0, 0xb6, 0xd3, 0x27,
-	0x26, 0x85, 0x2b, 0x53, 0x15, 0x7f, 0x97, 0x06, 0x87, 0x20, 0x17, 0x38, 0xac, 0xaf, 0xa8, 0x2c,
+	0x14, 0xb7, 0xf7, 0x57, 0x95, 0x33, 0xf2, 0xbd, 0xa4, 0x48, 0x48, 0xc3, 0xb8, 0x05, 0xa5, 0x03,
-	0xc6, 0x71, 0xf1, 0xcf, 0xbe, 0x8b, 0xf8, 0xff, 0xab, 0xc1, 0xe5, 0x6f, 0x03, 0xf7, 0x1d, 0x5b,
+	0xd7, 0x59, 0xa6, 0x44, 0xc6, 0x63, 0xb8, 0x28, 0x61, 0x8a, 0x73, 0xf7, 0xa1, 0xe8, 0xcb, 0x24,
-	0x6a, 0x1b, 0x4a, 0x21, 0xa6, 0x24, 0x0a, 0xbb, 0x58, 0xaa, 0x71, 0x9a, 0xff, 0x29, 0x0c, 0x3d,
+	0xc7, 0x54, 0xd7, 0x44, 0x69, 0x6b, 0xc4, 0x92, 0x46, 0x49, 0x41, 0xdb, 0x7b, 0x41, 0xac, 0xc9,
-	0x87, 0xb2, 0xe3, 0xfb, 0x84, 0x39, 0x93, 0xa8, 0x78, 0x62, 0xee, 0x5a, 0x8b, 0x2f, 0x18, 0x6b,
+	0x12, 0x83, 0xc2, 0x95, 0x49, 0x15, 0x79, 0x93, 0x02, 0x8b, 0x20, 0xe3, 0xdb, 0xac, 0xa7, 0xa8,
-	0x21, 0x0e, 0x6b, 0x67, 0xba, 0x70, 0xdf, 0x67, 0xe1, 0xc8, 0x8e, 0xbb, 0xaa, 0xde, 0x87, 0xcd,
+	0x2c, 0xc6, 0xd1, 0xe2, 0x93, 0x7e, 0x93, 0xe2, 0xf3, 0x9f, 0x06, 0x97, 0xbf, 0xf5, 0x9d, 0x37,
-	0x79, 0x00, 0xa7, 0xcc, 0x09, 0x1e, 0xc9, 0xd0, 0x6d, 0x3e, 0xe4, 0x77, 0x7c, 0xea, 0x0c, 0xa2,
+	0x2c, 0xe9, 0x2d, 0x28, 0x06, 0x98, 0x92, 0x30, 0xe8, 0x60, 0x59, 0x0d, 0x92, 0xfc, 0x4f, 0x60,
-	0x49, 0xc5, 0x4b, 0xe3, 0x5e, 0xe6, 0x73, 0x4d, 0x69, 0x50, 0xc8, 0xd6, 0xa2, 0x41, 0x37, 0x84,
+	0xe8, 0x39, 0x94, 0x6c, 0xcf, 0x23, 0xcc, 0x1e, 0x9d, 0x8a, 0x07, 0xe6, 0xae, 0x39, 0xdf, 0x41,
-	0x04, 0x71, 0x67, 0xa9, 0x0d, 0xf4, 0x2b, 0x28, 0x3f, 0x73, 0xbc, 0xf5, 0x6c, 0x17, 0xc2, 0x45,
+	0x99, 0x73, 0xe7, 0x30, 0xb7, 0x26, 0x0b, 0xf7, 0x3c, 0x16, 0x9c, 0x59, 0x51, 0x57, 0xd5, 0xfb,
-	0xe9, 0x4b, 0xed, 0x36, 0xa7, 0x0b, 0xda, 0x72, 0x5d, 0xc8, 0xbc, 0x57, 0xa7, 0xbc, 0x2d, 0x35,
+	0x50, 0x99, 0x05, 0x70, 0xca, 0x1c, 0xe3, 0x33, 0x79, 0x74, 0x8b, 0x0f, 0xf9, 0x1b, 0x9f, 0xd8,
-	0x7b, 0x65, 0x61, 0x6c, 0x4b, 0x35, 0x9e, 0x56, 0xc6, 0xc7, 0xbc, 0xcc, 0x1c, 0x26, 0xc3, 0x4a,
+	0xfd, 0x70, 0xac, 0x5e, 0xc2, 0xb8, 0x97, 0xfa, 0x5c, 0x53, 0x1a, 0x14, 0xb0, 0x95, 0x68, 0xd0,
-	0xa3, 0x8c, 0x84, 0x98, 0x4d, 0xd8, 0xd8, 0x23, 0xbe, 0x8f, 0xbb, 0xab, 0xf2, 0x64, 0x3a, 0x70,
+	0x0d, 0x21, 0x41, 0xdc, 0x59, 0x62, 0x01, 0xff, 0x1a, 0x4a, 0xcf, 0x6c, 0x77, 0x35, 0xdb, 0x05,
-	0xe9, 0x0c, 0xa9, 0x36, 0xba, 0x06, 0x45, 0xfe, 0x4a, 0x3e, 0x9a, 0x26, 0xbe, 0xc0, 0xed, 0x43,
+	0x70, 0x51, 0xfa, 0x52, 0xbb, 0xcd, 0xe8, 0x82, 0xb6, 0x58, 0x17, 0x52, 0xef, 0x54, 0xa9, 0x6f,
-	0xcf, 0xe5, 0x53, 0x9c, 0x67, 0x62, 0x4a, 0xbe, 0x23, 0x0a, 0xdc, 0xe6, 0x53, 0x06, 0x14, 0x4e,
+	0x4b, 0xcd, 0x5e, 0x9a, 0x18, 0x9b, 0x52, 0x8d, 0x27, 0x99, 0xf1, 0x31, 0x4f, 0x33, 0x9b, 0xc9,
-	0x71, 0x48, 0x3d, 0x22, 0x75, 0xa0, 0x64, 0x4f, 0x4c, 0x73, 0x1b, 0x2e, 0x3d, 0xe9, 0x47, 0xcc,
+	0x63, 0x25, 0x51, 0x46, 0x42, 0x8c, 0x0d, 0x58, 0xdb, 0x21, 0x9e, 0x87, 0x3b, 0xcb, 0xe2, 0x64,
-	0x25, 0x2f, 0xfd, 0x55, 0xb7, 0xb6, 0x09, 0x59, 0x9f, 0xbc, 0x14, 0xae, 0x8b, 0x36, 0x1f, 0xf2,
+	0xd8, 0x70, 0x69, 0x8c, 0x54, 0x1b, 0x5d, 0x83, 0x02, 0xef, 0xd2, 0x0f, 0x27, 0x81, 0xcf, 0x73,
-	0x74, 0x1d, 0x3a, 0x11, 0x5d, 0xd5, 0xe2, 0xcc, 0x0f, 0xa1, 0x62, 0x63, 0x1a, 0x0d, 0x57, 0x01,
+	0xfb, 0xc0, 0x75, 0xf8, 0x14, 0xe7, 0x99, 0x98, 0x92, 0x7d, 0x4c, 0x9e, 0xdb, 0x7c, 0x4a, 0x87,
-	0xdb, 0xbf, 0x00, 0xe4, 0x78, 0x75, 0xa0, 0xc7, 0x90, 0x17, 0xed, 0x0e, 0x35, 0x92, 0xca, 0x28,
+	0xfc, 0x09, 0x0e, 0xa8, 0x4b, 0xa4, 0x0e, 0x14, 0xad, 0x91, 0x69, 0x6c, 0xc2, 0xa5, 0x27, 0xbd,
-	0xde, 0x57, 0xab, 0x37, 0x96, 0x20, 0x54, 0xd2, 0x9e, 0x81, 0x2e, 0xdf, 0x7f, 0xe8, 0x56, 0x12,
+	0x90, 0x39, 0xe4, 0xd4, 0x5b, 0xf6, 0x6a, 0x15, 0x48, 0x7b, 0xe4, 0x54, 0xb8, 0x2e, 0x58, 0x7c,
-	0x78, 0xe1, 0xc1, 0x5d, 0xbd, 0xbd, 0x0a, 0xa6, 0x1c, 0xcb, 0x30, 0x43, 0x96, 0x1a, 0xe6, 0x59,
+	0xc8, 0xc3, 0x75, 0x60, 0x87, 0x74, 0x59, 0x89, 0x33, 0x3e, 0x84, 0xb2, 0x85, 0x69, 0x38, 0x58,
-	0xe9, 0xa5, 0x86, 0x19, 0xab, 0xa7, 0x03, 0xd0, 0xe5, 0x7b, 0x11, 0x25, 0x82, 0x67, 0x9e, 0xa6,
+	0x06, 0x6c, 0xfd, 0x01, 0x90, 0xe1, 0xd9, 0x81, 0x1e, 0x41, 0x56, 0x94, 0x3b, 0xd4, 0x88, 0x4b,
-	0x55, 0x73, 0x19, 0x44, 0x39, 0xec, 0x40, 0x8e, 0xeb, 0x37, 0xaa, 0x27, 0x61, 0x63, 0x0d, 0xa0,
+	0xa3, 0x68, 0x5d, 0xad, 0xde, 0x58, 0x80, 0x50, 0x41, 0x7b, 0x06, 0x39, 0xd9, 0x7f, 0xa2, 0x5b,
-	0xda, 0x48, 0x07, 0x28, 0x57, 0x3b, 0x90, 0x17, 0x57, 0x9d, 0x7c, 0xd2, 0x38, 0x0b, 0xaa, 0x57,
+	0x71, 0xe0, 0xb9, 0x86, 0xbf, 0x7a, 0x7b, 0x19, 0x4c, 0x39, 0x96, 0xc7, 0x0c, 0x58, 0xe2, 0x31,
-	0x17, 0xc8, 0xbf, 0xcf, 0x7f, 0x8c, 0xa1, 0x3d, 0xd0, 0x25, 0x0b, 0x92, 0x8f, 0x37, 0xc3, 0x90,
+	0xc7, 0xa9, 0x97, 0x78, 0xcc, 0x48, 0x3e, 0xed, 0x43, 0x4e, 0xf6, 0xab, 0x28, 0x16, 0x3c, 0xd5,
-	0x54, 0x27, 0x07, 0x00, 0xb1, 0x1f, 0x02, 0x1f, 0x25, 0xde, 0x53, 0x52, 0x8b, 0x49, 0x75, 0xf8,
+	0x1a, 0x57, 0x8d, 0x45, 0x10, 0xe5, 0xb0, 0x0d, 0x19, 0xae, 0xdf, 0xa8, 0x1e, 0x87, 0x8d, 0x14,
-	0x05, 0xe4, 0x78, 0x97, 0x4f, 0xce, 0x51, 0xac, 0xff, 0xa7, 0x3a, 0xf8, 0x12, 0x72, 0x5c, 0xb9,
+	0x80, 0x6a, 0x23, 0x19, 0xa0, 0x5c, 0x6d, 0x41, 0x56, 0x3c, 0x75, 0xfc, 0x4d, 0xa3, 0x2c, 0xa8,
-	0x50, 0x22, 0x67, 0x16, 0x9f, 0xdd, 0xa9, 0x7e, 0x3a, 0x50, 0x3a, 0x7b, 0xae, 0xa2, 0x0f, 0x52,
+	0x5e, 0x9d, 0x23, 0xff, 0x1e, 0xff, 0x31, 0x88, 0x76, 0x20, 0x27, 0x59, 0x10, 0x7f, 0xbd, 0x29,
-	0x32, 0x34, 0xf3, 0x9a, 0x4d, 0x75, 0xb5, 0x0f, 0x05, 0xf5, 0x86, 0x40, 0x89, 0x34, 0x99, 0x7d,
+	0x86, 0x24, 0x3a, 0xd9, 0x07, 0x88, 0xfc, 0x10, 0xf9, 0x28, 0xf6, 0x9d, 0xe2, 0x4a, 0x4c, 0xa2,
-	0x60, 0xa4, 0xba, 0x79, 0x08, 0xba, 0x6c, 0x58, 0xc9, 0x65, 0xb3, 0xd0, 0xcc, 0x96, 0x1c, 0x2d,
+	0xc3, 0x2f, 0x21, 0xc3, 0xab, 0x7c, 0x7c, 0x8c, 0x22, 0xf5, 0x3f, 0xd1, 0xc1, 0x57, 0x90, 0xe1,
-	0xc7, 0xa5, 0x3c, 0x39, 0xc7, 0xb1, 0x86, 0x91, 0xcc, 0xc3, 0x99, 0x2e, 0xa0, 0x84, 0x81, 0xa6,
+	0xca, 0x85, 0x62, 0x39, 0x33, 0xdf, 0xf6, 0x27, 0xfa, 0x69, 0x43, 0x71, 0xdc, 0x2e, 0xa3, 0x0f,
-	0x0b, 0x03, 0x5d, 0x29, 0x0c, 0x53, 0x56, 0xdb, 0x50, 0x50, 0x02, 0x9b, 0x92, 0xa8, 0x19, 0x9d,
+	0x12, 0x22, 0x34, 0xd5, 0x4d, 0x2f, 0x72, 0x35, 0x6e, 0x7d, 0xe3, 0x5d, 0xcd, 0x76, 0xc6, 0x89,
-	0xae, 0xde, 0x5c, 0x8a, 0x51, 0x3e, 0x1f, 0x42, 0x71, 0xa2, 0xa8, 0x28, 0x71, 0xc1, 0x9c, 0xde,
+	0xae, 0xf6, 0x20, 0xaf, 0xda, 0x11, 0x14, 0xcb, 0xb8, 0xe9, 0x5e, 0x25, 0xd1, 0xcd, 0x03, 0xc8,
-	0xa6, 0x65, 0x6d, 0xf7, 0xe0, 0xf5, 0xdb, 0xda, 0x85, 0x3f, 0xde, 0xd6, 0x2e, 0xfc, 0x34, 0xae,
+	0xc9, 0xda, 0x17, 0x9f, 0x81, 0x73, 0x75, 0x71, 0xc1, 0xd5, 0x32, 0xbc, 0x2a, 0xc4, 0x3f, 0x57,
-	0x69, 0xaf, 0xc7, 0x35, 0xed, 0xb7, 0x71, 0x4d, 0xfb, 0x7b, 0x5c, 0xd3, 0xbe, 0xfb, 0xec, 0xbc,
+	0xa4, 0xf6, 0xc4, 0x53, 0x7a, 0xaa, 0xa0, 0x28, 0x8d, 0xa1, 0xc9, 0x1a, 0x43, 0x97, 0x6a, 0xcc,
-	0xff, 0x59, 0xd9, 0xe6, 0x7f, 0x9e, 0x67, 0x8e, 0x75, 0xb1, 0xc5, 0x9d, 0xff, 0x02, 0x00, 0x00,
+	0x24, 0x41, 0x2c, 0xc8, 0x2b, 0xad, 0x4e, 0x08, 0xd4, 0x94, 0xe4, 0x57, 0x6f, 0x2e, 0xc4, 0x28,
-	0xff, 0xff, 0xd3, 0xbf, 0xc3, 0xa9, 0x9b, 0x11, 0x00, 0x00,
+	0x9f, 0x0f, 0xa0, 0x30, 0x12, 0x67, 0x14, 0xbb, 0x60, 0x46, 0xba, 0x93, 0xa2, 0xb6, 0xbd, 0xff,
+	0xea, 0x75, 0xed, 0xc2, 0x9f, 0xaf, 0x6b, 0x17, 0x7e, 0x1e, 0xd6, 0xb4, 0x57, 0xc3, 0x9a, 0xf6,
+	0xdb, 0xb0, 0xa6, 0xfd, 0x33, 0xac, 0x69, 0xdf, 0x7d, 0xf6, 0xb6, 0xff, 0x24, 0xda, 0xe4, 0x7f,
+	0x9e, 0xa7, 0x8e, 0x72, 0x62, 0x8b, 0x3b, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0x7b, 0xba, 0x42,
+	0xb9, 0x66, 0x12, 0x00, 0x00,
 }
 
 func (m *CreateTaskRequest) Marshal() (dAtA []byte, err error) {
@@ -1605,6 +1651,54 @@ func (m *ResizePtyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *PullImageRequest) 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 *PullImageRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PullImageRequest) 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.NewContainerID) > 0 {
+		i -= len(m.NewContainerID)
+		copy(dAtA[i:], m.NewContainerID)
+		i = encodeVarintShim(dAtA, i, uint64(len(m.NewContainerID)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Image) > 0 {
+		i -= len(m.Image)
+		copy(dAtA[i:], m.Image)
+		i = encodeVarintShim(dAtA, i, uint64(len(m.Image)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.ID) > 0 {
+		i -= len(m.ID)
+		copy(dAtA[i:], m.ID)
+		i = encodeVarintShim(dAtA, i, uint64(len(m.ID)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *StateRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2661,6 +2755,30 @@ func (m *ResizePtyRequest) Size() (n int) {
 	return n
 }
 
+func (m *PullImageRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.ID)
+	if l > 0 {
+		n += 1 + l + sovShim(uint64(l))
+	}
+	l = len(m.Image)
+	if l > 0 {
+		n += 1 + l + sovShim(uint64(l))
+	}
+	l = len(m.NewContainerID)
+	if l > 0 {
+		n += 1 + l + sovShim(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func (m *StateRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -3167,6 +3285,19 @@ func (this *ResizePtyRequest) String() string {
 	}, "")
 	return s
 }
+func (this *PullImageRequest) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&PullImageRequest{`,
+		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
+		`Image:` + fmt.Sprintf("%v", this.Image) + `,`,
+		`NewContainerID:` + fmt.Sprintf("%v", this.NewContainerID) + `,`,
+		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func (this *StateRequest) String() string {
 	if this == nil {
 		return "nil"
@@ -3438,6 +3569,7 @@ type TaskService interface {
 	Kill(ctx context.Context, req *KillRequest) (*types1.Empty, error)
 	Exec(ctx context.Context, req *ExecProcessRequest) (*types1.Empty, error)
 	ResizePty(ctx context.Context, req *ResizePtyRequest) (*types1.Empty, error)
+	PullImage(ctx context.Context, req *PullImageRequest) (*types1.Empty, error)
 	CloseIO(ctx context.Context, req *CloseIORequest) (*types1.Empty, error)
 	Update(ctx context.Context, req *UpdateTaskRequest) (*types1.Empty, error)
 	Wait(ctx context.Context, req *WaitRequest) (*WaitResponse, error)
@@ -3525,6 +3657,13 @@ func RegisterTaskService(srv *github_com_containerd_ttrpc.Server, svc TaskServic
 			}
 			return svc.ResizePty(ctx, &req)
 		},
+		"PullImage": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+			var req PullImageRequest
+			if err := unmarshal(&req); err != nil {
+				return nil, err
+			}
+			return svc.PullImage(ctx, &req)
+		},
 		"CloseIO": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
 			var req CloseIORequest
 			if err := unmarshal(&req); err != nil {
@@ -3668,6 +3807,14 @@ func (c *taskClient) ResizePty(ctx context.Context, req *ResizePtyRequest) (*typ
 	return &resp, nil
 }
 
+func (c *taskClient) PullImage(ctx context.Context, req *PullImageRequest) (*types1.Empty, error) {
+	var resp types1.Empty
+	if err := c.client.Call(ctx, "containerd.task.v2.Task", "PullImage", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
 func (c *taskClient) CloseIO(ctx context.Context, req *CloseIORequest) (*types1.Empty, error) {
 	var resp types1.Empty
 	if err := c.client.Call(ctx, "containerd.task.v2.Task", "CloseIO", req, &resp); err != nil {
@@ -4858,6 +5005,153 @@ func (m *ResizePtyRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *PullImageRequest) 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 ErrIntOverflowShim
+			}
+			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: PullImageRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PullImageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthShim
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthShim
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthShim
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthShim
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Image = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NewContainerID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthShim
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthShim
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.NewContainerID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipShim(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthShim
+			}
+			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 *StateRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

src/runtime/vendor/github.com/containerd/containerd/runtime/v2/task/shim.proto

@@ -43,6 +43,7 @@ service Task {
 	rpc Kill(KillRequest) returns (google.protobuf.Empty);
 	rpc Exec(ExecProcessRequest) returns (google.protobuf.Empty);
 	rpc ResizePty(ResizePtyRequest) returns (google.protobuf.Empty);
+	rpc PullImage(PullImageRequest) returns (google.protobuf.Empty);
 	rpc CloseIO(CloseIORequest) returns (google.protobuf.Empty);
 	rpc Update(UpdateTaskRequest) returns (google.protobuf.Empty);
 	rpc Wait(WaitRequest) returns (WaitResponse);
@@ -99,6 +100,12 @@ message ResizePtyRequest {
 	uint32 height = 4;
 }
 
+message PullImageRequest {
+	string id = 1; // Unique image identifier, used to avoid duplication when unpacking the image layers.
+	string image = 2; // Image name (e.g. docker.io/library/busybox:latest).
+	string new_container_id = 3; // The id of the container that will run from this image.
+}
+
 message StateRequest {
 	string id = 1;
 	string exec_id = 2;

src/runtime/vendor/modules.txt

@@ -52,7 +52,7 @@ github.com/containerd/cgroups/stats/v1
 # github.com/containerd/console v1.0.2
 ## explicit
 github.com/containerd/console
-# github.com/containerd/containerd v1.5.7 => github.com/containerd/containerd v1.5.7
+# github.com/containerd/containerd v1.5.7 => github.com/confidential-containers/containerd v1.5.8-0.20211026205748-ba7b469fa4d7
 ## explicit
 github.com/containerd/containerd/api/events
 github.com/containerd/containerd/api/services/ttrpc/events/v1
@@ -420,7 +420,7 @@ k8s.io/apimachinery/pkg/api/resource
 # k8s.io/cri-api v0.20.6
 ## explicit
 k8s.io/cri-api/pkg/apis/runtime/v1alpha2
-# github.com/containerd/containerd => github.com/containerd/containerd v1.5.7
+# github.com/containerd/containerd => github.com/confidential-containers/containerd v1.5.8-0.20211026205748-ba7b469fa4d7
 # github.com/opencontainers/runc => github.com/opencontainers/runc v1.0.1
 # github.com/uber-go/atomic => go.uber.org/atomic v1.5.1
 # google.golang.org/genproto => google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8

src/runtime/virtcontainers/agent.go

@@ -139,6 +139,9 @@ type agent interface {
 	// resumeContainer will resume a paused container
 	resumeContainer(ctx context.Context, sandbox *Sandbox, c Container) error
 
+	// pullImage will tell the agent to pull an image inside the Pod Sandbox
+	pullImage(ctx context.Context, sandbox *Sandbox, image string, containerID string) error
+
 	// configure will update agent settings based on provided arguments
 	configure(ctx context.Context, h Hypervisor, id, sharePath string, config KataAgentConfig) error
 

src/runtime/virtcontainers/interfaces.go

@@ -55,6 +55,7 @@ type VCSandbox interface {
 	StatsContainer(ctx context.Context, containerID string) (ContainerStats, error)
 	PauseContainer(ctx context.Context, containerID string) error
 	ResumeContainer(ctx context.Context, containerID string) error
+	PullImage(ctx context.Context, image string, newContainerID string) error
 	EnterContainer(ctx context.Context, containerID string, cmd types.Cmd) (VCContainer, *Process, error)
 	UpdateContainer(ctx context.Context, containerID string, resources specs.LinuxResources) error
 	WaitProcess(ctx context.Context, containerID, processID string) (int32, error)

src/runtime/virtcontainers/kata_agent.go

@@ -129,6 +129,7 @@ const (
 	grpcStatsContainerRequest    = "grpc.StatsContainerRequest"
 	grpcPauseContainerRequest    = "grpc.PauseContainerRequest"
 	grpcResumeContainerRequest   = "grpc.ResumeContainerRequest"
+	grpcPullImageRequest         = "grpc.PullImageRequest"
 	grpcReseedRandomDevRequest   = "grpc.ReseedRandomDevRequest"
 	grpcGuestDetailsRequest      = "grpc.GuestDetailsRequest"
 	grpcMemHotplugByProbeRequest = "grpc.MemHotplugByProbeRequest"
@@ -1766,6 +1767,15 @@ func (k *kataAgent) resumeContainer(ctx context.Context, sandbox *Sandbox, c Con
 	return err
 }
 
+func (k *kataAgent) pullImage(ctx context.Context, sandbox *Sandbox, image string, containerID string) error {
+	req := &grpc.PullImageRequest{
+		Image:       image,
+		ContainerId: containerID,
+	}
+	_, err := k.sendReq(ctx, req)
+	return err
+}
+
 func (k *kataAgent) memHotplugByProbe(ctx context.Context, addr uint64, sizeMB uint32, memorySectionSizeMB uint32) error {
 	if memorySectionSizeMB == uint32(0) {
 		return fmt.Errorf("memorySectionSizeMB couldn't be zero")
@@ -2011,6 +2021,9 @@ func (k *kataAgent) installReqFunc(c *kataclient.AgentClient) {
 	k.reqHandlers[grpcResumeContainerRequest] = func(ctx context.Context, req interface{}) (interface{}, error) {
 		return k.client.AgentServiceClient.ResumeContainer(ctx, req.(*grpc.ResumeContainerRequest))
 	}
+	k.reqHandlers[grpcPullImageRequest] = func(ctx context.Context, req interface{}) (interface{}, error) {
+		return k.client.AgentServiceClient.PullImage(ctx, req.(*grpc.PullImageRequest))
+	}
 	k.reqHandlers[grpcReseedRandomDevRequest] = func(ctx context.Context, req interface{}) (interface{}, error) {
 		return k.client.AgentServiceClient.ReseedRandomDev(ctx, req.(*grpc.ReseedRandomDevRequest))
 	}

src/runtime/virtcontainers/mock_agent.go

@@ -172,6 +172,11 @@ func (n *mockAgent) resumeContainer(ctx context.Context, sandbox *Sandbox, c Con
 	return nil
 }
 
+// pullImage is the Noop agent pull image implementation. It does nothing.
+func (n *mockAgent) pullImage(ctx context.Context, sandbox *Sandbox, image string, containerID string) error {
+	return nil
+}
+
 // configure is the Noop agent configuration implementation. It does nothing.
 func (n *mockAgent) configure(ctx context.Context, h Hypervisor, id, sharePath string, config KataAgentConfig) error {
 	return nil

src/runtime/virtcontainers/pkg/agent/protocols/grpc/agent.pb.go

@@ -2491,6 +2491,47 @@ func (m *Metrics) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Metrics proto.InternalMessageInfo
 
+type PullImageRequest struct {
+	Image                string   `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
+	ContainerId          string   `protobuf:"bytes,2,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
+	SourceCreds          string   `protobuf:"bytes,3,opt,name=source_creds,json=sourceCreds,proto3" json:"source_creds,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PullImageRequest) Reset()      { *m = PullImageRequest{} }
+func (*PullImageRequest) ProtoMessage() {}
+func (*PullImageRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_c1460208c38ccf5e, []int{58}
+}
+func (m *PullImageRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *PullImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_PullImageRequest.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 *PullImageRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PullImageRequest.Merge(m, src)
+}
+func (m *PullImageRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *PullImageRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_PullImageRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PullImageRequest proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*CreateContainerRequest)(nil), "grpc.CreateContainerRequest")
 	proto.RegisterType((*StartContainerRequest)(nil), "grpc.StartContainerRequest")
@@ -2552,6 +2593,7 @@ func init() {
 	proto.RegisterType((*AddSwapRequest)(nil), "grpc.AddSwapRequest")
 	proto.RegisterType((*GetMetricsRequest)(nil), "grpc.GetMetricsRequest")
 	proto.RegisterType((*Metrics)(nil), "grpc.Metrics")
+	proto.RegisterType((*PullImageRequest)(nil), "grpc.PullImageRequest")
 }
 
 func init() {
@@ -2559,196 +2601,199 @@ func init() {
 }
 
 var fileDescriptor_c1460208c38ccf5e = []byte{
-	// 3011 bytes of a gzipped FileDescriptorProto
+	// 3071 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x3a, 0x4b, 0x6f, 0x23, 0xc7,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x3a, 0x4b, 0x73, 0x1b, 0xc7,
-	0xd1, 0xe6, 0x43, 0x22, 0x59, 0x7c, 0x89, 0x23, 0xad, 0x96, 0x4b, 0xdb, 0xfa, 0xd6, 0xb3, 0xf6,
+	0xd1, 0xc6, 0x83, 0x04, 0xd0, 0x78, 0x11, 0x4b, 0x8a, 0x82, 0x60, 0x9b, 0x9f, 0xbc, 0xb2, 0x65,
-	0x7a, 0x6d, 0x7f, 0xe6, 0xda, 0x6b, 0x23, 0xeb, 0x07, 0x9c, 0xc5, 0x4a, 0x2b, 0x4b, 0xb2, 0x2d,
+	0xd9, 0xfe, 0x0c, 0xd9, 0xb2, 0xeb, 0x93, 0x6d, 0x95, 0x3f, 0x95, 0x48, 0xd1, 0x24, 0x6d, 0xd3,
-	0x2f, 0x3d, 0x5c, 0xc1, 0x41, 0x82, 0x64, 0x30, 0x9a, 0x69, 0x91, 0x6d, 0x71, 0xa6, 0xc7, 0x3d,
+	0x82, 0x17, 0x62, 0xf9, 0xab, 0x2f, 0x95, 0x6c, 0x2d, 0x77, 0x87, 0xc0, 0x98, 0xd8, 0x9d, 0xf5,
-	0x3d, 0x5a, 0xd1, 0x01, 0x82, 0x9c, 0x92, 0x5b, 0x8e, 0xb9, 0xe5, 0x0f, 0x04, 0xb9, 0xe5, 0x96,
+	0xec, 0x2c, 0x45, 0x38, 0x55, 0xa9, 0x9c, 0x92, 0x5b, 0x8e, 0xb9, 0xe5, 0x0f, 0xa4, 0x72, 0xcb,
-	0x5c, 0x73, 0x30, 0x72, 0xca, 0x31, 0xa7, 0x20, 0xde, 0x9f, 0x90, 0x5f, 0x10, 0xf4, 0x6b, 0x1e,
+	0x31, 0xd7, 0x1c, 0x5c, 0x39, 0xe5, 0x98, 0x53, 0x2a, 0xd6, 0x4f, 0xc8, 0x25, 0xd7, 0xd4, 0xbc,
-	0x7c, 0xc8, 0x89, 0x20, 0x20, 0x17, 0x62, 0xaa, 0xba, 0xba, 0x5e, 0xdd, 0x55, 0x5d, 0xd5, 0x4d,
+	0xf6, 0x81, 0x07, 0x9d, 0xb0, 0x58, 0x95, 0x0b, 0x6a, 0xbb, 0xa7, 0xa7, 0x5f, 0x33, 0xdd, 0xd3,
-	0xf8, 0x62, 0x84, 0xd9, 0x38, 0x3e, 0xee, 0xbb, 0xc4, 0xbf, 0x7b, 0xea, 0x30, 0xe7, 0x4d, 0x97,
+	0x3d, 0x03, 0xf8, 0x72, 0x84, 0xd9, 0x38, 0x3e, 0xee, 0xbb, 0xc4, 0xbf, 0x7b, 0xea, 0x30, 0xe7,
-	0x04, 0xcc, 0xc1, 0x01, 0xa2, 0xd1, 0x1c, 0x1c, 0x51, 0xf7, 0xae, 0x33, 0x42, 0x01, 0xbb, 0x1b,
+	0x6d, 0x97, 0x04, 0xcc, 0xc1, 0x01, 0xa2, 0xd1, 0x1c, 0x1c, 0x51, 0xf7, 0xae, 0x33, 0x42, 0x01,
-	0x52, 0xc2, 0x88, 0x4b, 0x26, 0x91, 0xfc, 0x8a, 0x24, 0xba, 0x2f, 0x00, 0xa3, 0x3c, 0xa2, 0xa1,
+	0xbb, 0x1b, 0x52, 0xc2, 0x88, 0x4b, 0x26, 0x91, 0xfc, 0x8a, 0x24, 0xba, 0x2f, 0x00, 0xa3, 0x3c,
-	0xdb, 0xab, 0x11, 0x17, 0x4b, 0x44, 0xaf, 0xce, 0xa6, 0x21, 0x8a, 0x14, 0xf0, 0xfc, 0x88, 0x90,
+	0xa2, 0xa1, 0xdb, 0xab, 0x11, 0x17, 0x4b, 0x44, 0xaf, 0xce, 0xa6, 0x21, 0x8a, 0x14, 0xf0, 0xe2,
-	0xd1, 0x04, 0xc9, 0x89, 0xc7, 0xf1, 0xc9, 0x5d, 0xe4, 0x87, 0x6c, 0x2a, 0x07, 0xcd, 0xdf, 0x15,
+	0x88, 0x90, 0xd1, 0x04, 0xc9, 0x89, 0xc7, 0xf1, 0xc9, 0x5d, 0xe4, 0x87, 0x6c, 0x2a, 0x07, 0xcd,
-	0x61, 0x73, 0x87, 0x22, 0x87, 0xa1, 0x1d, 0x2d, 0xd6, 0x42, 0x5f, 0xc7, 0x28, 0x62, 0xc6, 0x4b,
+	0xdf, 0x14, 0x61, 0x73, 0x87, 0x22, 0x87, 0xa1, 0x1d, 0x2d, 0xd6, 0x42, 0xdf, 0xc4, 0x28, 0x62,
-	0xd0, 0x48, 0x54, 0xb1, 0xb1, 0xd7, 0x2d, 0xdc, 0x2c, 0xdc, 0xa9, 0x59, 0xf5, 0x04, 0x77, 0xe0,
+	0xc6, 0x2b, 0xd0, 0x48, 0x54, 0xb1, 0xb1, 0xd7, 0x2d, 0xdc, 0x2c, 0xdc, 0xa9, 0x59, 0xf5, 0x04,
-	0x19, 0xd7, 0xa1, 0x82, 0xce, 0x91, 0xcb, 0x47, 0x8b, 0x62, 0x74, 0x95, 0x83, 0x07, 0x9e, 0xf1,
+	0x77, 0xe0, 0x19, 0xd7, 0xa1, 0x82, 0xce, 0x91, 0xcb, 0x47, 0x8b, 0x62, 0x74, 0x95, 0x83, 0x07,
-	0x36, 0xd4, 0x23, 0x46, 0x71, 0x30, 0xb2, 0xe3, 0x08, 0xd1, 0x6e, 0xe9, 0x66, 0xe1, 0x4e, 0xfd,
+	0x9e, 0xf1, 0x2e, 0xd4, 0x23, 0x46, 0x71, 0x30, 0xb2, 0xe3, 0x08, 0xd1, 0x6e, 0xe9, 0x66, 0xe1,
-	0xde, 0x5a, 0x9f, 0xeb, 0xd9, 0x1f, 0x8a, 0x81, 0xa3, 0x08, 0x51, 0x0b, 0xa2, 0xe4, 0xdb, 0xb8,
+	0x4e, 0xfd, 0xde, 0x5a, 0x9f, 0xeb, 0xd9, 0x1f, 0x8a, 0x81, 0xa3, 0x08, 0x51, 0x0b, 0xa2, 0xe4,
-	0x0d, 0x15, 0x0f, 0x9d, 0x61, 0x17, 0x45, 0xdd, 0xf2, 0xcd, 0xd2, 0x9d, 0xfa, 0xbd, 0x86, 0x24,
+	0xdb, 0xb8, 0x0d, 0x15, 0x0f, 0x9d, 0x61, 0x17, 0x45, 0xdd, 0xf2, 0xcd, 0xd2, 0x9d, 0xfa, 0xbd,
-	0x7f, 0x24, 0x90, 0x96, 0x1e, 0x34, 0x5e, 0x83, 0x6a, 0xc4, 0x08, 0x75, 0x46, 0x28, 0xea, 0xae,
+	0x86, 0x24, 0x7f, 0x2c, 0x90, 0x96, 0x1e, 0x34, 0xde, 0x80, 0x6a, 0xc4, 0x08, 0x75, 0x46, 0x28,
-	0x08, 0xc2, 0xa6, 0xe6, 0x2b, 0xb0, 0x56, 0x32, 0x6c, 0xbc, 0x00, 0xa5, 0xc7, 0x3b, 0x07, 0xdd,
+	0xea, 0xae, 0x08, 0xc2, 0xa6, 0xe6, 0x2b, 0xb0, 0x56, 0x32, 0x6c, 0xbc, 0x04, 0xa5, 0x27, 0x3b,
-	0x55, 0x21, 0x1d, 0x14, 0x55, 0x88, 0x5c, 0x8b, 0xa3, 0x8d, 0x5b, 0xd0, 0x8c, 0x9c, 0xc0, 0x3b,
+	0x07, 0xdd, 0x55, 0x21, 0x1d, 0x14, 0x55, 0x88, 0x5c, 0x8b, 0xa3, 0x8d, 0x5b, 0xd0, 0x8c, 0x9c,
-	0x26, 0xe7, 0x76, 0x88, 0xbd, 0x20, 0xea, 0x56, 0x6e, 0x16, 0xee, 0x54, 0xad, 0x86, 0x42, 0x0e,
+	0xc0, 0x3b, 0x26, 0xe7, 0x76, 0x88, 0xbd, 0x20, 0xea, 0x56, 0x6e, 0x16, 0xee, 0x54, 0xad, 0x86,
-	0x38, 0xce, 0xfc, 0x00, 0xae, 0x0d, 0x99, 0x43, 0xd9, 0x25, 0xbc, 0x63, 0x1e, 0xc1, 0xa6, 0x85,
+	0x42, 0x0e, 0x38, 0xce, 0xfc, 0x08, 0xae, 0x0d, 0x99, 0x43, 0xd9, 0x25, 0xbc, 0x63, 0x1e, 0xc1,
-	0x7c, 0x72, 0x76, 0x29, 0xd7, 0x76, 0xa1, 0xc2, 0xb0, 0x8f, 0x48, 0xcc, 0x84, 0x6b, 0x9b, 0x96,
+	0xa6, 0x85, 0x7c, 0x72, 0x76, 0x29, 0xd7, 0x76, 0xa1, 0xc2, 0xb0, 0x8f, 0x48, 0xcc, 0x84, 0x6b,
-	0x06, 0xcd, 0x3f, 0x14, 0xc0, 0xd8, 0x3d, 0x47, 0xee, 0x80, 0x12, 0x17, 0x45, 0xd1, 0xff, 0x68,
+	0x9b, 0x96, 0x06, 0xcd, 0xdf, 0x15, 0xc0, 0xd8, 0x3d, 0x47, 0xee, 0x80, 0x12, 0x17, 0x45, 0xd1,
-	0xb9, 0x5e, 0x85, 0x4a, 0x28, 0x15, 0xe8, 0x96, 0x05, 0xb9, 0x5a, 0x05, 0xad, 0x95, 0x1e, 0x35,
+	0x7f, 0x68, 0xb9, 0x5e, 0x87, 0x4a, 0x28, 0x15, 0xe8, 0x96, 0x05, 0xb9, 0x5a, 0x05, 0xad, 0x95,
-	0xbf, 0x82, 0x8d, 0x21, 0x1e, 0x05, 0xce, 0xe4, 0x0a, 0xf5, 0xdd, 0x84, 0xd5, 0x48, 0xf0, 0x14,
+	0x1e, 0x35, 0xbf, 0x86, 0x8d, 0x21, 0x1e, 0x05, 0xce, 0xe4, 0x0a, 0xf5, 0xdd, 0x84, 0xd5, 0x48,
-	0xaa, 0x36, 0x2d, 0x05, 0x99, 0x03, 0x30, 0xbe, 0x74, 0x30, 0xbb, 0x3a, 0x49, 0xe6, 0x9b, 0xb0,
+	0xf0, 0x14, 0xaa, 0x36, 0x2d, 0x05, 0x99, 0x03, 0x30, 0xbe, 0x72, 0x30, 0xbb, 0x3a, 0x49, 0xe6,
-	0x9e, 0xe3, 0x18, 0x85, 0x24, 0x88, 0x90, 0x50, 0x80, 0x39, 0x2c, 0x8e, 0x04, 0xb3, 0x15, 0x4b,
+	0xdb, 0xb0, 0x9e, 0xe3, 0x18, 0x85, 0x24, 0x88, 0x90, 0x50, 0x80, 0x39, 0x2c, 0x8e, 0x04, 0xb3,
-	0x41, 0x26, 0x81, 0xcd, 0xa3, 0xd0, 0xbb, 0x64, 0x34, 0xdd, 0x83, 0x1a, 0x45, 0x11, 0x89, 0x29,
+	0x15, 0x4b, 0x41, 0x26, 0x81, 0xcd, 0xa3, 0xd0, 0xbb, 0x64, 0x34, 0xdd, 0x83, 0x1a, 0x45, 0x11,
-	0x8f, 0x81, 0xa2, 0x70, 0xea, 0x86, 0x74, 0xea, 0x67, 0x38, 0x88, 0xcf, 0x2d, 0x3d, 0x66, 0xa5,
+	0x89, 0x29, 0x8f, 0x81, 0xa2, 0x70, 0xea, 0x86, 0x74, 0xea, 0xe7, 0x38, 0x88, 0xcf, 0x2d, 0x3d,
-	0x64, 0x6a, 0x7f, 0xb2, 0xe8, 0x32, 0xfb, 0xf3, 0x03, 0xb8, 0x36, 0x70, 0xe2, 0xe8, 0x32, 0xba,
+	0x66, 0xa5, 0x64, 0x6a, 0x7f, 0xb2, 0xe8, 0x32, 0xfb, 0xf3, 0x23, 0xb8, 0x36, 0x70, 0xe2, 0xe8,
-	0x9a, 0x1f, 0xf2, 0xbd, 0x1d, 0xc5, 0xfe, 0xa5, 0x26, 0xff, 0xbe, 0x00, 0xd5, 0x9d, 0x30, 0x3e,
+	0x32, 0xba, 0x9a, 0x0f, 0xf8, 0xde, 0x8e, 0x62, 0xff, 0x52, 0x93, 0x7f, 0x5b, 0x80, 0xea, 0x4e,
-	0x8a, 0x9c, 0x11, 0x32, 0xfe, 0x0f, 0xea, 0x8c, 0x30, 0x67, 0x62, 0xc7, 0x1c, 0x14, 0xe4, 0x65,
+	0x18, 0x1f, 0x45, 0xce, 0x08, 0x19, 0xff, 0x05, 0x75, 0x46, 0x98, 0x33, 0xb1, 0x63, 0x0e, 0x0a,
-	0x0b, 0x04, 0x4a, 0x12, 0xbc, 0x04, 0x8d, 0x10, 0x51, 0x37, 0x8c, 0x15, 0x45, 0xf1, 0x66, 0xe9,
+	0xf2, 0xb2, 0x05, 0x02, 0x25, 0x09, 0x5e, 0x81, 0x46, 0x88, 0xa8, 0x1b, 0xc6, 0x8a, 0xa2, 0x78,
-	0x4e, 0xd9, 0xaa, 0x4b, 0x9c, 0x24, 0xe9, 0xc3, 0xba, 0x18, 0xb3, 0x71, 0x60, 0x9f, 0x22, 0x1a,
+	0xb3, 0x74, 0xa7, 0x6c, 0xd5, 0x25, 0x4e, 0x92, 0xf4, 0x61, 0x5d, 0x8c, 0xd9, 0x38, 0xb0, 0x4f,
-	0xa0, 0x89, 0x4f, 0x3c, 0x24, 0x36, 0x47, 0xd9, 0xea, 0x88, 0xa1, 0x83, 0xe0, 0xd3, 0x64, 0xc0,
+	0x11, 0x0d, 0xd0, 0xc4, 0x27, 0x1e, 0x12, 0x9b, 0xa3, 0x6c, 0x75, 0xc4, 0xd0, 0x41, 0xf0, 0x59,
-	0x78, 0x1d, 0x3a, 0x09, 0x3d, 0xdf, 0xf1, 0x82, 0xba, 0x2c, 0xa8, 0xdb, 0x8a, 0xfa, 0x48, 0xa1,
+	0x32, 0x60, 0xbc, 0x09, 0x9d, 0x84, 0x9e, 0xef, 0x78, 0x41, 0x5d, 0x16, 0xd4, 0x6d, 0x45, 0x7d,
-	0xcd, 0x5f, 0x40, 0xeb, 0xc9, 0x98, 0x12, 0xc6, 0x26, 0x38, 0x18, 0x3d, 0x72, 0x98, 0xc3, 0x43,
+	0xa4, 0xd0, 0xe6, 0xcf, 0xa0, 0xf5, 0x74, 0x4c, 0x09, 0x63, 0x13, 0x1c, 0x8c, 0x1e, 0x3b, 0xcc,
-	0x33, 0x44, 0x14, 0x13, 0x2f, 0x52, 0xda, 0x6a, 0xd0, 0x78, 0x03, 0x3a, 0x4c, 0xd2, 0x22, 0xcf,
+	0xe1, 0xa1, 0x19, 0x22, 0x8a, 0x89, 0x17, 0x29, 0x6d, 0x35, 0x68, 0xbc, 0x05, 0x1d, 0x26, 0x69,
-	0xd6, 0x34, 0x45, 0x41, 0xb3, 0x96, 0x0c, 0x0c, 0x14, 0xf1, 0x2b, 0xd0, 0x4a, 0x89, 0x79, 0x70,
+	0x91, 0x67, 0x6b, 0x9a, 0xa2, 0xa0, 0x59, 0x4b, 0x06, 0x06, 0x8a, 0xf8, 0x35, 0x68, 0xa5, 0xc4,
-	0x2b, 0x7d, 0x9b, 0x09, 0xf6, 0x09, 0xf6, 0x91, 0x79, 0x26, 0x7c, 0x25, 0x16, 0xd9, 0x78, 0x03,
+	0x3c, 0xb8, 0x95, 0xbe, 0xcd, 0x04, 0xfb, 0x14, 0xfb, 0xc8, 0x3c, 0x13, 0xbe, 0x12, 0x8b, 0x6c,
-	0x6a, 0xa9, 0x1f, 0x0a, 0x62, 0x87, 0xb4, 0xe4, 0x0e, 0xd1, 0xee, 0xb4, 0xaa, 0x89, 0x53, 0x3e,
+	0xbc, 0x05, 0xb5, 0xd4, 0x0f, 0x05, 0xb1, 0x43, 0x5a, 0x72, 0x87, 0x68, 0x77, 0x5a, 0xd5, 0xc4,
-	0x82, 0x36, 0x4b, 0x14, 0xb7, 0x3d, 0x87, 0x39, 0xf9, 0x4d, 0x95, 0xb7, 0xca, 0x6a, 0xb1, 0x1c,
+	0x29, 0x1f, 0x43, 0x9b, 0x25, 0x8a, 0xdb, 0x9e, 0xc3, 0x9c, 0xfc, 0xa6, 0xca, 0x5b, 0x65, 0xb5,
-	0x6c, 0x7e, 0x08, 0xb5, 0x01, 0xf6, 0x22, 0x29, 0xb8, 0x0b, 0x15, 0x37, 0xa6, 0x14, 0x05, 0x4c,
+	0x58, 0x0e, 0x36, 0x1f, 0x40, 0x6d, 0x80, 0xbd, 0x48, 0x0a, 0xee, 0x42, 0xc5, 0x8d, 0x29, 0x45,
-	0x9b, 0xac, 0x40, 0x63, 0x03, 0x56, 0x26, 0xd8, 0xc7, 0x4c, 0x99, 0x29, 0x01, 0x93, 0x00, 0x1c,
+	0x01, 0xd3, 0x26, 0x2b, 0xd0, 0xd8, 0x80, 0x95, 0x09, 0xf6, 0x31, 0x53, 0x66, 0x4a, 0xc0, 0x24,
-	0x22, 0x9f, 0xd0, 0xa9, 0x70, 0xd8, 0x06, 0xac, 0x64, 0x17, 0x57, 0x02, 0xc6, 0xf3, 0x50, 0xf3,
+	0x00, 0x87, 0xc8, 0x27, 0x74, 0x2a, 0x1c, 0xb6, 0x01, 0x2b, 0xd9, 0xc5, 0x95, 0x80, 0xf1, 0x22,
-	0x9d, 0xf3, 0x64, 0x51, 0xf9, 0x48, 0xd5, 0x77, 0xce, 0xa5, 0xf2, 0x5d, 0xa8, 0x9c, 0x38, 0x78,
+	0xd4, 0x7c, 0xe7, 0x3c, 0x59, 0x54, 0x3e, 0x52, 0xf5, 0x9d, 0x73, 0xa9, 0x7c, 0x17, 0x2a, 0x27,
-	0xe2, 0x06, 0x4c, 0x79, 0x45, 0x83, 0xa9, 0xc0, 0x72, 0x56, 0xe0, 0x5f, 0x8a, 0x50, 0x97, 0x12,
+	0x0e, 0x9e, 0xb8, 0x01, 0x53, 0x5e, 0xd1, 0x60, 0x2a, 0xb0, 0x9c, 0x15, 0xf8, 0xc7, 0x22, 0xd4,
-	0xa5, 0xc2, 0x1b, 0xb0, 0xe2, 0x3a, 0xee, 0x38, 0x11, 0x29, 0x00, 0xe3, 0xb6, 0x56, 0xa4, 0x98,
+	0xa5, 0x44, 0xa9, 0xf0, 0x06, 0xac, 0xb8, 0x8e, 0x3b, 0x4e, 0x44, 0x0a, 0xc0, 0xb8, 0xad, 0x15,
-	0xcd, 0x70, 0xa9, 0xa6, 0x5a, 0xb5, 0xbb, 0x00, 0xd1, 0x53, 0x27, 0x54, 0xba, 0x95, 0x96, 0x10,
+	0x29, 0x66, 0x33, 0x5c, 0xaa, 0xa9, 0x56, 0xed, 0x2e, 0x40, 0xf4, 0xcc, 0x09, 0x95, 0x6e, 0xa5,
-	0xd7, 0x38, 0x8d, 0x54, 0xf7, 0x1d, 0x68, 0xc8, 0x7d, 0xa7, 0xa6, 0x94, 0x97, 0x4c, 0xa9, 0x4b,
+	0x25, 0xc4, 0x35, 0x4e, 0x23, 0xd5, 0x7d, 0x0f, 0x1a, 0x72, 0xdf, 0xa9, 0x29, 0xe5, 0x25, 0x53,
-	0x2a, 0x39, 0xe9, 0x16, 0x34, 0xe3, 0x08, 0xd9, 0x63, 0x8c, 0xa8, 0x43, 0xdd, 0xf1, 0xb4, 0xbb,
+	0xea, 0x92, 0x4a, 0x4e, 0xba, 0x05, 0xcd, 0x38, 0x42, 0xf6, 0x18, 0x23, 0xea, 0x50, 0x77, 0x3c,
-	0x22, 0x0f, 0xa0, 0x38, 0x42, 0xfb, 0x1a, 0x67, 0xdc, 0x83, 0x15, 0x9e, 0x5b, 0xa2, 0xee, 0xaa,
+	0xed, 0xae, 0xc8, 0x03, 0x28, 0x8e, 0xd0, 0xbe, 0xc6, 0x19, 0xf7, 0x60, 0x85, 0xe7, 0x96, 0xa8,
-	0x38, 0xeb, 0x5e, 0xc8, 0xb2, 0x14, 0xa6, 0xf6, 0xc5, 0xef, 0x6e, 0xc0, 0xe8, 0xd4, 0x92, 0xa4,
+	0xbb, 0x2a, 0xce, 0xba, 0x97, 0xb2, 0x2c, 0x85, 0xa9, 0x7d, 0xf1, 0xbb, 0x1b, 0x30, 0x3a, 0xb5,
-	0xbd, 0xf7, 0x00, 0x52, 0xa4, 0xb1, 0x06, 0xa5, 0x53, 0x34, 0x55, 0x71, 0xc8, 0x3f, 0xb9, 0x73,
+	0x24, 0x69, 0xef, 0x03, 0x80, 0x14, 0x69, 0xac, 0x41, 0xe9, 0x14, 0x4d, 0x55, 0x1c, 0xf2, 0x4f,
-	0xce, 0x9c, 0x49, 0xac, 0xbd, 0x2e, 0x81, 0x0f, 0x8a, 0xef, 0x15, 0x4c, 0x17, 0xda, 0xdb, 0x93,
+	0xee, 0x9c, 0x33, 0x67, 0x12, 0x6b, 0xaf, 0x4b, 0xe0, 0xa3, 0xe2, 0x07, 0x05, 0xd3, 0x85, 0xf6,
-	0x53, 0x4c, 0x32, 0xd3, 0x37, 0x60, 0xc5, 0x77, 0xbe, 0x22, 0x54, 0x7b, 0x52, 0x00, 0x02, 0x8b,
+	0xf6, 0xe4, 0x14, 0x93, 0xcc, 0xf4, 0x0d, 0x58, 0xf1, 0x9d, 0xaf, 0x09, 0xd5, 0x9e, 0x14, 0x80,
-	0x03, 0x42, 0x35, 0x0b, 0x01, 0x18, 0x2d, 0x28, 0x92, 0x50, 0xf8, 0xab, 0x66, 0x15, 0x49, 0x98,
+	0xc0, 0xe2, 0x80, 0x50, 0xcd, 0x42, 0x00, 0x46, 0x0b, 0x8a, 0x24, 0x14, 0xfe, 0xaa, 0x59, 0x45,
-	0x0a, 0x2a, 0x67, 0x04, 0x99, 0xff, 0x28, 0x03, 0xa4, 0x52, 0x0c, 0x0b, 0x7a, 0x98, 0xd8, 0x11,
+	0x12, 0xa6, 0x82, 0xca, 0x19, 0x41, 0xe6, 0x5f, 0xcb, 0x00, 0xa9, 0x14, 0xc3, 0x82, 0x1e, 0x26,
-	0xa2, 0xfc, 0x7c, 0xb7, 0x8f, 0xa7, 0x0c, 0x45, 0x36, 0x45, 0x6e, 0x4c, 0x23, 0x7c, 0xc6, 0xd7,
+	0x76, 0x84, 0x28, 0x3f, 0xdf, 0xed, 0xe3, 0x29, 0x43, 0x91, 0x4d, 0x91, 0x1b, 0xd3, 0x08, 0x9f,
-	0x8f, 0x9b, 0x7d, 0x4d, 0x9a, 0x3d, 0xa3, 0x9b, 0x75, 0x1d, 0x93, 0xa1, 0x9c, 0xb7, 0xcd, 0xa7,
+	0xf1, 0xf5, 0xe3, 0x66, 0x5f, 0x93, 0x66, 0xcf, 0xe8, 0x66, 0x5d, 0xc7, 0x64, 0x28, 0xe7, 0x6d,
-	0x59, 0x7a, 0x96, 0x71, 0x00, 0xd7, 0x52, 0x9e, 0x5e, 0x86, 0x5d, 0xf1, 0x22, 0x76, 0xeb, 0x09,
+	0xf3, 0x69, 0x96, 0x9e, 0x65, 0x1c, 0xc0, 0xb5, 0x94, 0xa7, 0x97, 0x61, 0x57, 0xbc, 0x88, 0xdd,
-	0x3b, 0x2f, 0x65, 0xb5, 0x0b, 0xeb, 0x98, 0xd8, 0x5f, 0xc7, 0x28, 0xce, 0x31, 0x2a, 0x5d, 0xc4,
+	0x7a, 0xc2, 0xce, 0x4b, 0x59, 0xed, 0xc2, 0x3a, 0x26, 0xf6, 0x37, 0x31, 0x8a, 0x73, 0x8c, 0x4a,
-	0xa8, 0x83, 0xc9, 0x17, 0x62, 0x42, 0xca, 0x66, 0x00, 0x37, 0x32, 0x56, 0xf2, 0x70, 0xcf, 0x30,
+	0x17, 0x31, 0xea, 0x60, 0xf2, 0xa5, 0x98, 0x90, 0xb2, 0x19, 0xc0, 0x8d, 0x8c, 0x95, 0x3c, 0xdc,
-	0x2b, 0x5f, 0xc4, 0x6c, 0x33, 0xd1, 0x8a, 0xe7, 0x83, 0x94, 0xe3, 0x27, 0xb0, 0x89, 0x89, 0xfd,
+	0x33, 0xcc, 0xca, 0x17, 0x31, 0xdb, 0x4c, 0xb4, 0xe2, 0xf9, 0x20, 0xe5, 0xf8, 0x29, 0x6c, 0x62,
-	0xd4, 0xc1, 0x6c, 0x96, 0xdd, 0xca, 0xf7, 0x18, 0xc9, 0x4f, 0xb4, 0x3c, 0x2f, 0x69, 0xa4, 0x8f,
+	0x62, 0x3f, 0x73, 0x30, 0x9b, 0x65, 0xb7, 0xf2, 0x03, 0x46, 0xf2, 0x13, 0x2d, 0xcf, 0x4b, 0x1a,
-	0xe8, 0x28, 0x67, 0xe4, 0xea, 0xf7, 0x18, 0x79, 0x28, 0x26, 0xa4, 0x6c, 0x1e, 0x42, 0x07, 0x93,
+	0xe9, 0x23, 0x3a, 0xca, 0x19, 0xb9, 0xfa, 0x03, 0x46, 0x1e, 0x8a, 0x09, 0x29, 0x9b, 0x47, 0xd0,
-	0x59, 0x6d, 0x2a, 0x17, 0x31, 0x69, 0x63, 0x92, 0xd7, 0x64, 0x1b, 0x3a, 0x11, 0x72, 0x19, 0xa1,
+	0xc1, 0x64, 0x56, 0x9b, 0xca, 0x45, 0x4c, 0xda, 0x98, 0xe4, 0x35, 0xd9, 0x86, 0x4e, 0x84, 0x5c,
-	0xd9, 0x4d, 0x50, 0xbd, 0x88, 0xc5, 0x9a, 0xa2, 0x4f, 0x78, 0x98, 0x3f, 0x81, 0xc6, 0x7e, 0x3c,
+	0x46, 0x68, 0x76, 0x13, 0x54, 0x2f, 0x62, 0xb1, 0xa6, 0xe8, 0x13, 0x1e, 0xe6, 0x8f, 0xa0, 0xb1,
-	0x42, 0x6c, 0x72, 0x9c, 0x24, 0x83, 0x2b, 0xcb, 0x3f, 0xe6, 0xbf, 0x8a, 0x50, 0xdf, 0x19, 0x51,
+	0x1f, 0x8f, 0x10, 0x9b, 0x1c, 0x27, 0xc9, 0xe0, 0xca, 0xf2, 0x8f, 0xf9, 0xf7, 0x22, 0xd4, 0x77,
-	0x12, 0x87, 0xb9, 0x9c, 0x2c, 0x83, 0x74, 0x36, 0x27, 0x0b, 0x12, 0x91, 0x93, 0x25, 0xf1, 0xbb,
+	0x46, 0x94, 0xc4, 0x61, 0x2e, 0x27, 0xcb, 0x20, 0x9d, 0xcd, 0xc9, 0x82, 0x44, 0xe4, 0x64, 0x49,
-	0xd0, 0xf0, 0x45, 0xe8, 0x2a, 0x7a, 0x99, 0x87, 0x3a, 0x73, 0x41, 0x6d, 0xd5, 0xfd, 0x4c, 0x32,
+	0xfc, 0x3e, 0x34, 0x7c, 0x11, 0xba, 0x8a, 0x5e, 0xe6, 0xa1, 0xce, 0x5c, 0x50, 0x5b, 0x75, 0x3f,
-	0xeb, 0x03, 0x84, 0xd8, 0x8b, 0xd4, 0x1c, 0x99, 0x8e, 0xda, 0xaa, 0xdc, 0xd2, 0x29, 0xda, 0xaa,
+	0x93, 0xcc, 0xfa, 0x00, 0x21, 0xf6, 0x22, 0x35, 0x47, 0xa6, 0xa3, 0xb6, 0x2a, 0xb7, 0x74, 0x8a,
-	0x85, 0x49, 0xb6, 0x7e, 0x1b, 0xea, 0xc7, 0xdc, 0x49, 0x6a, 0x42, 0x2e, 0x19, 0xa5, 0xde, 0xb3,
+	0xb6, 0x6a, 0x61, 0x92, 0xad, 0xdf, 0x85, 0xfa, 0x31, 0x77, 0x92, 0x9a, 0x90, 0x4b, 0x46, 0xa9,
-	0xe0, 0x38, 0x0d, 0xc2, 0x7d, 0x68, 0x8e, 0xa5, 0xcb, 0xd4, 0x24, 0xb9, 0x87, 0x6e, 0x29, 0x4b,
+	0xf7, 0x2c, 0x38, 0x4e, 0x83, 0x70, 0x1f, 0x9a, 0x63, 0xe9, 0x32, 0x35, 0x49, 0xee, 0xa1, 0x5b,
-	0x52, 0x7b, 0xfb, 0x59, 0xcf, 0xca, 0x05, 0x68, 0x8c, 0x33, 0xa8, 0xde, 0x10, 0x3a, 0x73, 0x24,
+	0xca, 0x92, 0xd4, 0xde, 0x7e, 0xd6, 0xb3, 0x72, 0x01, 0x1a, 0xe3, 0x0c, 0xaa, 0x37, 0x84, 0xce,
-	0x0b, 0x72, 0xd0, 0x9d, 0x6c, 0x0e, 0xaa, 0xdf, 0x33, 0xa4, 0xa0, 0xec, 0xcc, 0x6c, 0x5e, 0xfa,
+	0x1c, 0xc9, 0x82, 0x1c, 0x74, 0x27, 0x9b, 0x83, 0xea, 0xf7, 0x0c, 0x29, 0x28, 0x3b, 0x33, 0x9b,
-	0x4d, 0x11, 0x1a, 0x9f, 0x23, 0xf6, 0x94, 0xd0, 0x53, 0xa9, 0xaf, 0x01, 0xe5, 0xc0, 0xf1, 0x91,
+	0x97, 0x7e, 0x55, 0x84, 0xc6, 0x17, 0x88, 0x3d, 0x23, 0xf4, 0x54, 0xea, 0x6b, 0x40, 0x39, 0x70,
-	0xe2, 0x28, 0xbe, 0x8d, 0x1b, 0x50, 0xa5, 0xe7, 0x32, 0x81, 0xa8, 0xf5, 0xac, 0xd0, 0x73, 0x91,
+	0x7c, 0xa4, 0x38, 0x8a, 0x6f, 0xe3, 0x06, 0x54, 0xe9, 0xb9, 0x4c, 0x20, 0x6a, 0x3d, 0x2b, 0xf4,
-	0x18, 0x8c, 0x17, 0x01, 0xe8, 0xb9, 0x1d, 0x3a, 0xee, 0x29, 0x52, 0x1e, 0x2c, 0x5b, 0x35, 0x7a,
+	0x5c, 0x24, 0x06, 0xe3, 0x65, 0x00, 0x7a, 0x6e, 0x87, 0x8e, 0x7b, 0x8a, 0x94, 0x07, 0xcb, 0x56,
-	0x3e, 0x90, 0x08, 0xbe, 0x15, 0xe8, 0xb9, 0x8d, 0x28, 0x25, 0x34, 0x52, 0xb9, 0xaa, 0x4a, 0xcf,
+	0x8d, 0x9e, 0x0f, 0x24, 0x82, 0x6f, 0x05, 0x7a, 0x6e, 0x23, 0x4a, 0x09, 0x8d, 0x54, 0xae, 0xaa,
-	0x77, 0x05, 0xac, 0xe6, 0x7a, 0x94, 0x84, 0x21, 0xf2, 0x44, 0x8e, 0x16, 0x73, 0x1f, 0x49, 0x04,
+	0xd2, 0xf3, 0x5d, 0x01, 0xab, 0xb9, 0x1e, 0x25, 0x61, 0x88, 0x3c, 0x91, 0xa3, 0xc5, 0xdc, 0xc7,
-	0x97, 0xca, 0xb4, 0xd4, 0x55, 0x29, 0x95, 0xa5, 0x52, 0x59, 0x2a, 0xb5, 0x22, 0x67, 0xb2, 0xac,
+	0x12, 0xc1, 0xa5, 0x32, 0x2d, 0x75, 0x55, 0x4a, 0x65, 0xa9, 0x54, 0x96, 0x4a, 0xad, 0xc8, 0x99,
-	0x54, 0x96, 0x48, 0xad, 0x4a, 0xa9, 0x2c, 0x23, 0x95, 0xa5, 0x52, 0x6b, 0x7a, 0xae, 0x92, 0x6a,
+	0x2c, 0x2b, 0x95, 0x25, 0x52, 0xab, 0x52, 0x2a, 0xcb, 0x48, 0x65, 0xa9, 0xd4, 0x9a, 0x9e, 0xab,
-	0xfe, 0xba, 0x00, 0x9b, 0xb3, 0x85, 0x9f, 0xaa, 0x4d, 0xdf, 0x85, 0x86, 0x2b, 0xd6, 0x2b, 0xb7,
+	0xa4, 0x9a, 0xbf, 0x2c, 0xc0, 0xe6, 0x6c, 0xe1, 0xa7, 0x6a, 0xd3, 0xf7, 0xa1, 0xe1, 0x8a, 0xf5,
-	0x27, 0x3b, 0x73, 0x2b, 0x69, 0xd5, 0xdd, 0xcc, 0x36, 0xbe, 0x0f, 0xcd, 0x40, 0x3a, 0x38, 0xd9,
+	0xca, 0xed, 0xc9, 0xce, 0xdc, 0x4a, 0x5a, 0x75, 0x37, 0xb3, 0x8d, 0xef, 0x43, 0x33, 0x90, 0x0e,
-	0x9a, 0xa5, 0x74, 0x5d, 0xb2, 0xbe, 0xb7, 0x1a, 0x41, 0x06, 0x32, 0x3d, 0x30, 0xbe, 0xa4, 0x98,
+	0x4e, 0xb6, 0x66, 0x29, 0x5d, 0x97, 0xac, 0xef, 0xad, 0x46, 0x90, 0x81, 0x4c, 0x0f, 0x8c, 0xaf,
-	0xa1, 0x21, 0xa3, 0xc8, 0xf1, 0xaf, 0xa2, 0xba, 0x37, 0xa0, 0x2c, 0xaa, 0x15, 0xbe, 0x4c, 0x0d,
+	0x28, 0x66, 0x68, 0xc8, 0x28, 0x72, 0xfc, 0xab, 0xa8, 0xee, 0x0d, 0x28, 0x8b, 0x6a, 0x85, 0x2f,
-	0x4b, 0x7c, 0x9b, 0xaf, 0xc2, 0x7a, 0x4e, 0x8a, 0xb2, 0x75, 0x0d, 0x4a, 0x13, 0x14, 0x08, 0xee,
+	0x53, 0xc3, 0x12, 0xdf, 0xe6, 0xeb, 0xb0, 0x9e, 0x93, 0xa2, 0x6c, 0x5d, 0x83, 0xd2, 0x04, 0x05,
-	0x4d, 0x8b, 0x7f, 0x9a, 0x0e, 0x74, 0x2c, 0xe4, 0x78, 0x57, 0xa7, 0x8d, 0x12, 0x51, 0x4a, 0x45,
+	0x82, 0x7b, 0xd3, 0xe2, 0x9f, 0xa6, 0x03, 0x1d, 0x0b, 0x39, 0xde, 0xd5, 0x69, 0xa3, 0x44, 0x94,
-	0xdc, 0x01, 0x23, 0x2b, 0x42, 0xa9, 0xa2, 0xb5, 0x2e, 0x64, 0xb4, 0x7e, 0x0c, 0x9d, 0x9d, 0x09,
+	0x52, 0x11, 0x77, 0xc0, 0xc8, 0x8a, 0x50, 0xaa, 0x68, 0xad, 0x0b, 0x19, 0xad, 0x9f, 0x40, 0x67,
-	0x89, 0xd0, 0x90, 0x79, 0x38, 0xb8, 0x8a, 0x76, 0xe4, 0xe7, 0xb0, 0xfe, 0x84, 0x4d, 0xbf, 0xe4,
+	0x67, 0x42, 0x22, 0x34, 0x64, 0x1e, 0x0e, 0xae, 0xa2, 0x1d, 0xf9, 0x29, 0xac, 0x3f, 0x65, 0xd3,
-	0xcc, 0x22, 0xfc, 0x0d, 0xba, 0x22, 0xfb, 0x28, 0x79, 0xaa, 0xed, 0xa3, 0xe4, 0x29, 0x6f, 0x6e,
+	0xaf, 0x38, 0xb3, 0x08, 0x7f, 0x8b, 0xae, 0xc8, 0x3e, 0x4a, 0x9e, 0x69, 0xfb, 0x28, 0x79, 0xc6,
-	0x5c, 0x32, 0x89, 0xfd, 0x40, 0x84, 0x42, 0xd3, 0x52, 0x90, 0xb9, 0x0d, 0x0d, 0x59, 0x43, 0x1f,
+	0x9b, 0x1b, 0x97, 0x4c, 0x62, 0x3f, 0x10, 0xa1, 0xd0, 0xb4, 0x14, 0x64, 0x6e, 0x43, 0x43, 0xd6,
-	0x12, 0x2f, 0x9e, 0xa0, 0x85, 0x31, 0xb8, 0x05, 0x10, 0x3a, 0xd4, 0xf1, 0x11, 0x43, 0x54, 0xee,
+	0xd0, 0x87, 0xc4, 0x8b, 0x27, 0x68, 0x61, 0x0c, 0x6e, 0x01, 0x84, 0x0e, 0x75, 0x7c, 0xc4, 0x10,
-	0xa1, 0x9a, 0x95, 0xc1, 0x98, 0xbf, 0x2d, 0xc2, 0x86, 0xbc, 0x6f, 0x18, 0xca, 0x36, 0x5b, 0x9b,
+	0x95, 0x7b, 0xa8, 0x66, 0x65, 0x30, 0xe6, 0xaf, 0x8b, 0xb0, 0x21, 0xef, 0x1b, 0x86, 0xb2, 0xcd,
-	0xd0, 0x83, 0xea, 0x98, 0x44, 0x2c, 0xc3, 0x30, 0x81, 0xb9, 0x8a, 0xbc, 0x3f, 0x97, 0xdc, 0xf8,
+	0xd6, 0x26, 0xf4, 0xa0, 0x3a, 0x26, 0x11, 0xcb, 0x30, 0x4c, 0x60, 0xae, 0x22, 0xef, 0xcf, 0x25,
-	0x67, 0xee, 0x12, 0xa0, 0x74, 0xf1, 0x25, 0xc0, 0x5c, 0x9b, 0x5f, 0x9e, 0x6f, 0xf3, 0x79, 0xb4,
+	0x37, 0xfe, 0x99, 0xbb, 0x04, 0x28, 0x5d, 0x7c, 0x09, 0x30, 0xd7, 0xe6, 0x97, 0xe7, 0xdb, 0x7c,
-	0x69, 0x22, 0x2c, 0x63, 0xbc, 0x66, 0xd5, 0x14, 0xe6, 0xc0, 0x33, 0x6e, 0x43, 0x7b, 0xc4, 0xb5,
+	0x1e, 0x6d, 0x9a, 0x08, 0xcb, 0x18, 0xaf, 0x59, 0x35, 0x85, 0x39, 0xf0, 0x8c, 0xdb, 0xd0, 0x1e,
-	0xb4, 0xc7, 0x84, 0x9c, 0xda, 0xa1, 0xc3, 0xc6, 0x22, 0xd4, 0x6b, 0x56, 0x53, 0xa0, 0xf7, 0x09,
+	0x71, 0x2d, 0xed, 0x31, 0x21, 0xa7, 0x76, 0xe8, 0xb0, 0xb1, 0x08, 0xf5, 0x9a, 0xd5, 0x14, 0xe8,
-	0x39, 0x1d, 0x38, 0x6c, 0x6c, 0xbc, 0x0f, 0x2d, 0x55, 0x06, 0xfa, 0xc2, 0x45, 0x91, 0x3a, 0xfc,
+	0x7d, 0x42, 0x4e, 0x07, 0x0e, 0x1b, 0x1b, 0x1f, 0x42, 0x4b, 0x95, 0x81, 0xbe, 0x70, 0x51, 0xa4,
-	0x54, 0x14, 0x65, 0xbd, 0x67, 0x35, 0x4f, 0x33, 0x50, 0x64, 0x5e, 0x87, 0x6b, 0x8f, 0x50, 0xc4,
+	0x0e, 0x3f, 0x15, 0x45, 0x59, 0xef, 0x59, 0xcd, 0xd3, 0x0c, 0x14, 0x99, 0xd7, 0xe1, 0xda, 0x63,
-	0x28, 0x99, 0xe6, 0x1d, 0x63, 0xfe, 0x10, 0xe0, 0x20, 0x60, 0x88, 0x9e, 0x38, 0x2e, 0x8a, 0x8c,
+	0x14, 0x31, 0x4a, 0xa6, 0x79, 0xc7, 0x98, 0xff, 0x0b, 0x70, 0x10, 0x30, 0x44, 0x4f, 0x1c, 0x17,
-	0xb7, 0xb2, 0x90, 0x2a, 0x8e, 0xd6, 0xfa, 0xf2, 0xba, 0x27, 0x19, 0xb0, 0x32, 0x34, 0x66, 0x1f,
+	0x45, 0xc6, 0x3b, 0x59, 0x48, 0x15, 0x47, 0x6b, 0x7d, 0x79, 0xdd, 0x93, 0x0c, 0x58, 0x19, 0x1a,
-	0x56, 0x2d, 0x12, 0xf3, 0x74, 0xf4, 0xb2, 0xfe, 0x52, 0xf3, 0x1a, 0x6a, 0x9e, 0x40, 0x5a, 0x6a,
+	0xb3, 0x0f, 0xab, 0x16, 0x89, 0x79, 0x3a, 0x7a, 0x55, 0x7f, 0xa9, 0x79, 0x0d, 0x35, 0x4f, 0x20,
-	0xcc, 0xdc, 0xd7, 0x2d, 0x6c, 0xca, 0x4e, 0x2d, 0x51, 0x1f, 0x6a, 0x58, 0xe3, 0x54, 0x56, 0x99,
+	0x2d, 0x35, 0x66, 0xee, 0xeb, 0x16, 0x36, 0x65, 0xa7, 0x96, 0xa8, 0x0f, 0x35, 0xac, 0x71, 0x2a,
-	0x17, 0x9d, 0x92, 0x98, 0x1f, 0xc2, 0xba, 0xe4, 0x24, 0x39, 0x6b, 0x36, 0x2f, 0xc3, 0x2a, 0xd5,
+	0xab, 0xcc, 0x8b, 0x4e, 0x49, 0xcc, 0x07, 0xb0, 0x2e, 0x39, 0x49, 0xce, 0x9a, 0xcd, 0xab, 0xb0,
-	0x6a, 0x14, 0xd2, 0x7b, 0x1e, 0x45, 0xa4, 0xc6, 0xb8, 0x3f, 0x3e, 0xc3, 0x11, 0x4b, 0x0d, 0xd1,
+	0x4a, 0xb5, 0x1a, 0x85, 0xf4, 0x9e, 0x47, 0x11, 0xa9, 0x31, 0xee, 0x8f, 0xcf, 0x71, 0xc4, 0x52,
-	0xfe, 0x58, 0x87, 0x0e, 0x1f, 0xc8, 0xf1, 0x34, 0x3f, 0x86, 0xc6, 0x43, 0x6b, 0xf0, 0x39, 0xc2,
+	0x43, 0xb4, 0x3f, 0xd6, 0xa1, 0xc3, 0x07, 0x72, 0x3c, 0xcd, 0x4f, 0xa0, 0xf1, 0xc8, 0x1a, 0x7c,
-	0xa3, 0xf1, 0x31, 0xcf, 0x9e, 0x3f, 0xc8, 0xc3, 0xca, 0x60, 0x43, 0x69, 0x9b, 0x19, 0xb2, 0x72,
+	0x81, 0xf0, 0x68, 0x7c, 0xcc, 0xb3, 0xe7, 0xff, 0xe4, 0x61, 0x65, 0xb0, 0xa1, 0xb4, 0xcd, 0x0c,
-	0x74, 0xe6, 0x27, 0xb0, 0xf9, 0xd0, 0xf3, 0xb2, 0x28, 0xad, 0xf5, 0x5b, 0x50, 0x0b, 0x32, 0xec,
+	0x59, 0x39, 0x3a, 0xf3, 0x53, 0xd8, 0x7c, 0xe4, 0x79, 0x59, 0x94, 0xd6, 0xfa, 0x1d, 0xa8, 0x05,
-	0x32, 0x67, 0x56, 0x8e, 0x3a, 0x25, 0x32, 0x7f, 0x0a, 0xeb, 0x8f, 0x83, 0x09, 0x0e, 0xd0, 0xce,
+	0x19, 0x76, 0x99, 0x33, 0x2b, 0x47, 0x9d, 0x12, 0x99, 0x3f, 0x86, 0xf5, 0x27, 0xc1, 0x04, 0x07,
-	0xe0, 0xe8, 0x10, 0x25, 0xb9, 0xc8, 0x80, 0x32, 0xaf, 0xd9, 0x04, 0x8f, 0xaa, 0x25, 0xbe, 0x79,
+	0x68, 0x67, 0x70, 0x74, 0x88, 0x92, 0x5c, 0x64, 0x40, 0x99, 0xd7, 0x6c, 0x82, 0x47, 0xd5, 0x12,
-	0x70, 0x06, 0xc7, 0xb6, 0x1b, 0xc6, 0x91, 0xba, 0xec, 0x59, 0x0d, 0x8e, 0x77, 0xc2, 0x38, 0xe2,
+	0xdf, 0x3c, 0x38, 0x83, 0x63, 0xdb, 0x0d, 0xe3, 0x48, 0x5d, 0xf6, 0xac, 0x06, 0xc7, 0x3b, 0x61,
-	0x87, 0x0b, 0x2f, 0x2e, 0x48, 0x30, 0x99, 0x8a, 0x08, 0xad, 0x5a, 0x15, 0x37, 0x8c, 0x1f, 0x07,
+	0x1c, 0xf1, 0xc3, 0x85, 0x17, 0x17, 0x24, 0x98, 0x4c, 0x45, 0x84, 0x56, 0xad, 0x8a, 0x1b, 0xc6,
-	0x93, 0xa9, 0xf9, 0xff, 0xa2, 0x03, 0x47, 0xc8, 0xb3, 0x9c, 0xc0, 0x23, 0xfe, 0x23, 0x74, 0x96,
+	0x4f, 0x82, 0xc9, 0xd4, 0xfc, 0x6f, 0xd1, 0x81, 0x23, 0xe4, 0x59, 0x4e, 0xe0, 0x11, 0xff, 0x31,
-	0x91, 0x90, 0x74, 0x7b, 0x3a, 0x13, 0x7d, 0x5b, 0x80, 0xc6, 0xc3, 0x11, 0x0a, 0xd8, 0x23, 0xc4,
+	0x3a, 0xcb, 0x48, 0x48, 0xba, 0x3d, 0x9d, 0x89, 0xbe, 0x2b, 0x40, 0xe3, 0xd1, 0x08, 0x05, 0xec,
-	0x1c, 0x3c, 0x11, 0x1d, 0xdd, 0x19, 0xa2, 0x11, 0x26, 0x81, 0x0a, 0x37, 0x0d, 0xf2, 0x86, 0x1c,
+	0x31, 0x62, 0x0e, 0x9e, 0x88, 0x8e, 0xee, 0x0c, 0xd1, 0x08, 0x93, 0x40, 0x85, 0x9b, 0x06, 0x79,
-	0x07, 0x98, 0xd9, 0x9e, 0x83, 0x7c, 0x12, 0x08, 0x2e, 0x55, 0x0b, 0x38, 0xea, 0x91, 0xc0, 0x18,
+	0x43, 0x8e, 0x03, 0xcc, 0x6c, 0xcf, 0x41, 0x3e, 0x09, 0x04, 0x97, 0xaa, 0x05, 0x1c, 0xf5, 0x58,
-	0xaf, 0x42, 0x5b, 0x5e, 0xc6, 0xd9, 0x63, 0x27, 0xf0, 0x26, 0x3c, 0xd0, 0x4b, 0x22, 0x34, 0x5b,
+	0x60, 0x8c, 0xd7, 0xa1, 0x2d, 0x2f, 0xe3, 0xec, 0xb1, 0x13, 0x78, 0x13, 0x1e, 0xe8, 0x25, 0x11,
-	0x12, 0xbd, 0xaf, 0xb0, 0xc6, 0x6b, 0xb0, 0xa6, 0xc2, 0x30, 0xa5, 0x2c, 0x0b, 0xca, 0xb6, 0xc2,
+	0x9a, 0x2d, 0x89, 0xde, 0x57, 0x58, 0xe3, 0x0d, 0x58, 0x53, 0x61, 0x98, 0x52, 0x96, 0x05, 0x65,
-	0xe7, 0x48, 0xe3, 0x30, 0x24, 0x94, 0x45, 0x76, 0x84, 0x5c, 0x97, 0xf8, 0xa1, 0x6a, 0x87, 0xda,
+	0x5b, 0xe1, 0x73, 0xa4, 0x71, 0x18, 0x12, 0xca, 0x22, 0x3b, 0x42, 0xae, 0x4b, 0xfc, 0x50, 0xb5,
-	0x1a, 0x3f, 0x94, 0x68, 0x73, 0x04, 0xeb, 0x7b, 0xdc, 0x4e, 0x65, 0x49, 0xba, 0xad, 0x5a, 0x3e,
+	0x43, 0x6d, 0x8d, 0x1f, 0x4a, 0xb4, 0x39, 0x82, 0xf5, 0x3d, 0x6e, 0xa7, 0xb2, 0x24, 0xdd, 0x56,
-	0xf2, 0xed, 0xe3, 0x09, 0x71, 0x4f, 0x6d, 0x9e, 0x1c, 0x95, 0x87, 0x79, 0xc1, 0xb5, 0xcd, 0x91,
+	0x2d, 0x1f, 0xf9, 0xf6, 0xf1, 0x84, 0xb8, 0xa7, 0x36, 0x4f, 0x8e, 0xca, 0xc3, 0xbc, 0xe0, 0xda,
-	0x43, 0xfc, 0x8d, 0xe8, 0xfc, 0x39, 0xd5, 0x98, 0xb0, 0x70, 0x12, 0x8f, 0xec, 0x90, 0x92, 0x63,
+	0xe6, 0xc8, 0x21, 0xfe, 0x56, 0x74, 0xfe, 0x9c, 0x6a, 0x4c, 0x58, 0x38, 0x89, 0x47, 0x76, 0x48,
-	0xa4, 0x4c, 0x6c, 0xfb, 0xc8, 0xdf, 0x97, 0xf8, 0x01, 0x47, 0x9b, 0x7f, 0x2e, 0xc0, 0x46, 0x5e,
+	0xc9, 0x31, 0x52, 0x26, 0xb6, 0x7d, 0xe4, 0xef, 0x4b, 0xfc, 0x80, 0xa3, 0xcd, 0x3f, 0x14, 0x60,
-	0x92, 0x4a, 0xf5, 0x77, 0x61, 0x23, 0x2f, 0x4a, 0x1d, 0xff, 0xb2, 0xbc, 0xec, 0x64, 0x05, 0xca,
+	0x23, 0x2f, 0x49, 0xa5, 0xfa, 0xbb, 0xb0, 0x91, 0x17, 0xa5, 0x8e, 0x7f, 0x59, 0x5e, 0x76, 0xb2,
-	0x42, 0xe0, 0x3e, 0x34, 0xc5, 0x7d, 0xad, 0xed, 0x49, 0x4e, 0xf9, 0xa2, 0x27, 0xbb, 0x2e, 0x56,
+	0x02, 0x65, 0x21, 0x70, 0x1f, 0x9a, 0xe2, 0xbe, 0xd6, 0xf6, 0x24, 0xa7, 0x7c, 0xd1, 0x93, 0x5d,
-	0xc3, 0xc9, 0xae, 0xd2, 0xfb, 0x70, 0x43, 0x99, 0x6f, 0xcf, 0xab, 0x2d, 0x37, 0xc4, 0xa6, 0x22,
+	0x17, 0xab, 0xe1, 0x64, 0x57, 0xe9, 0x43, 0xb8, 0xa1, 0xcc, 0xb7, 0xe7, 0xd5, 0x96, 0x1b, 0x62,
-	0x38, 0x9c, 0xd1, 0xfe, 0x33, 0xe8, 0xa6, 0xa8, 0xed, 0xa9, 0x40, 0xa6, 0x9b, 0x79, 0x7d, 0xc6,
+	0x53, 0x11, 0x1c, 0xce, 0x68, 0xff, 0x39, 0x74, 0x53, 0xd4, 0xf6, 0x54, 0x20, 0xd3, 0xcd, 0xbc,
-	0xd8, 0x87, 0x9e, 0x47, 0x45, 0x94, 0x94, 0xad, 0x45, 0x43, 0xe6, 0x03, 0xb8, 0x3e, 0x44, 0x4c,
+	0x3e, 0x63, 0xec, 0x23, 0xcf, 0xa3, 0x22, 0x4a, 0xca, 0xd6, 0xa2, 0x21, 0xf3, 0x21, 0x5c, 0x1f,
-	0x7a, 0xc3, 0x61, 0xaa, 0x13, 0x91, 0xcc, 0xd6, 0xa0, 0x34, 0x44, 0xae, 0x30, 0xbe, 0x64, 0xf1,
+	0x22, 0x26, 0xbd, 0xe1, 0x30, 0xd5, 0x89, 0x48, 0x66, 0x6b, 0x50, 0x1a, 0x22, 0x57, 0x18, 0x5f,
-	0x4f, 0xbe, 0x01, 0x8f, 0x22, 0xe4, 0x0a, 0x2b, 0x4b, 0x96, 0xf8, 0x36, 0xff, 0x58, 0x80, 0x8a,
+	0xb2, 0xf8, 0x27, 0xdf, 0x80, 0x47, 0x11, 0x72, 0x85, 0x95, 0x25, 0x4b, 0x7c, 0x9b, 0xbf, 0x2f,
-	0x4a, 0xce, 0xfc, 0x80, 0xf1, 0x28, 0x3e, 0x43, 0x54, 0x6d, 0x3d, 0x05, 0x19, 0xaf, 0x40, 0x4b,
+	0x40, 0x45, 0x25, 0x67, 0x7e, 0xc0, 0x78, 0x14, 0x9f, 0x21, 0xaa, 0xb6, 0x9e, 0x82, 0x8c, 0xd7,
-	0x7e, 0xd9, 0x24, 0x64, 0x98, 0x24, 0x29, 0xbf, 0x29, 0xb1, 0x8f, 0x25, 0x52, 0x5c, 0xbe, 0x89,
+	0xa0, 0x25, 0xbf, 0x6c, 0x12, 0x32, 0x4c, 0x92, 0x94, 0xdf, 0x94, 0xd8, 0x27, 0x12, 0x29, 0x2e,
-	0xeb, 0x2f, 0xd5, 0x69, 0x2a, 0x88, 0xe3, 0x4f, 0x22, 0x1e, 0xe1, 0x22, 0xc5, 0xd7, 0x2c, 0x05,
+	0xdf, 0xc4, 0xf5, 0x97, 0xea, 0x34, 0x15, 0xc4, 0xf1, 0x27, 0x11, 0x8f, 0x70, 0x91, 0xe2, 0x6b,
-	0xf1, 0xad, 0xae, 0xf9, 0xad, 0x08, 0x7e, 0x1a, 0xe4, 0x5b, 0xdd, 0x27, 0x71, 0xc0, 0xec, 0x90,
+	0x96, 0x82, 0xf8, 0x56, 0xd7, 0xfc, 0x56, 0x04, 0x3f, 0x0d, 0xf2, 0xad, 0xee, 0x93, 0x38, 0x60,
-	0xe0, 0x80, 0xa9, 0x9c, 0x0e, 0x02, 0x35, 0xe0, 0x18, 0xf3, 0x57, 0x05, 0x58, 0x95, 0x17, 0xd0,
+	0x76, 0x48, 0x70, 0xc0, 0x54, 0x4e, 0x07, 0x81, 0x1a, 0x70, 0x8c, 0xf9, 0x8b, 0x02, 0xac, 0xca,
-	0xbc, 0xb7, 0x4d, 0x4e, 0xd6, 0x22, 0x16, 0x55, 0x8a, 0x90, 0x25, 0x4f, 0x53, 0xf1, 0xcd, 0xe3,
+	0x0b, 0x68, 0xde, 0xdb, 0x26, 0x27, 0x6b, 0x11, 0x8b, 0x2a, 0x45, 0xc8, 0x92, 0xa7, 0xa9, 0xf8,
-	0xf8, 0xcc, 0x97, 0xe7, 0x83, 0x52, 0xed, 0xcc, 0x17, 0x07, 0xc3, 0x2b, 0xd0, 0x4a, 0x0f, 0x68,
+	0xe6, 0x71, 0x7c, 0xe6, 0xcb, 0xf3, 0x41, 0xa9, 0x76, 0xe6, 0x8b, 0x83, 0xe1, 0x35, 0x68, 0xa5,
-	0x31, 0x2e, 0x55, 0x6c, 0x26, 0x58, 0x41, 0xb6, 0x54, 0x53, 0xf3, 0x47, 0xbc, 0xa5, 0x4f, 0x2e,
+	0x07, 0xb4, 0x18, 0x97, 0x2a, 0x36, 0x13, 0xac, 0x20, 0x5b, 0xaa, 0xa9, 0xf9, 0x7f, 0xbc, 0xa5,
-	0x5f, 0xd7, 0xa0, 0x14, 0x27, 0xca, 0xf0, 0x4f, 0x8e, 0x19, 0x25, 0x47, 0x3b, 0xff, 0x34, 0x6e,
+	0x4f, 0x2e, 0x5f, 0xd7, 0xa0, 0x14, 0x27, 0xca, 0xf0, 0x4f, 0x8e, 0x19, 0x25, 0x47, 0x3b, 0xff,
-	0x43, 0xcb, 0xf1, 0x3c, 0xcc, 0xa7, 0x3b, 0x93, 0x3d, 0xec, 0x25, 0x41, 0x9a, 0xc7, 0x9a, 0x7f,
+	0x34, 0x6e, 0x43, 0xcb, 0xf1, 0x3c, 0xcc, 0xa7, 0x3b, 0x93, 0x3d, 0xec, 0x25, 0x41, 0x9a, 0xc7,
-	0x2d, 0x40, 0x7b, 0x87, 0x84, 0xd3, 0x8f, 0xf1, 0x04, 0x65, 0x32, 0x88, 0x50, 0x52, 0x9d, 0xec,
+	0x9a, 0x7f, 0x2a, 0x40, 0x7b, 0x87, 0x84, 0xd3, 0x4f, 0xf0, 0x04, 0x65, 0x32, 0x88, 0x50, 0x52,
-	0xfc, 0x9b, 0x57, 0xab, 0x27, 0x78, 0x82, 0x64, 0x68, 0xc9, 0x95, 0xad, 0x72, 0x84, 0x08, 0x2b,
+	0x9d, 0xec, 0xfc, 0x9b, 0x57, 0xab, 0x27, 0x78, 0x82, 0x64, 0x68, 0xc9, 0x95, 0xad, 0x72, 0x84,
-	0x3d, 0x98, 0x5c, 0xbb, 0x35, 0xe5, 0xe0, 0x21, 0xf1, 0x44, 0x5d, 0xee, 0x61, 0x6a, 0x27, 0x97,
+	0x08, 0x2b, 0x3d, 0x98, 0x5c, 0xbb, 0x35, 0xe5, 0xe0, 0x21, 0xf1, 0x44, 0x5d, 0xee, 0x61, 0x6a,
-	0x6c, 0x4d, 0xab, 0xe2, 0x61, 0x2a, 0x86, 0x94, 0x21, 0x2b, 0xe2, 0x12, 0x35, 0x6b, 0xc8, 0xaa,
+	0x27, 0x97, 0x6c, 0x4d, 0xab, 0xe2, 0x61, 0x2a, 0x86, 0x94, 0x21, 0x2b, 0xe2, 0x12, 0x35, 0x6b,
-	0xc4, 0x70, 0x43, 0x36, 0x61, 0x95, 0x9c, 0x9c, 0x44, 0x88, 0x89, 0x0a, 0xba, 0x64, 0x29, 0x28,
+	0xc8, 0xaa, 0xc4, 0x70, 0x43, 0x36, 0x61, 0x95, 0x9c, 0x9c, 0x44, 0x88, 0x89, 0x0a, 0xba, 0x64,
-	0x49, 0x73, 0xd5, 0x4c, 0x9a, 0xbb, 0x06, 0xeb, 0xe2, 0xba, 0xfe, 0x09, 0x75, 0x5c, 0x1c, 0x8c,
+	0x29, 0x28, 0x49, 0x73, 0xd5, 0x4c, 0x9a, 0xbb, 0x06, 0xeb, 0xe2, 0xba, 0xfe, 0x29, 0x75, 0x5c,
-	0xf4, 0xf1, 0xb0, 0x01, 0xc6, 0x90, 0x91, 0x70, 0x1e, 0xbb, 0x87, 0xd8, 0xe3, 0xc7, 0x87, 0xbb,
+	0x1c, 0x8c, 0xf4, 0xf1, 0xb0, 0x01, 0xc6, 0x90, 0x91, 0x70, 0x1e, 0xbb, 0x87, 0xd8, 0x93, 0x27,
-	0x67, 0x28, 0x60, 0x1a, 0xfb, 0x26, 0x54, 0x35, 0xea, 0x3f, 0xb9, 0xcb, 0x7c, 0x1d, 0x5a, 0x0f,
+	0x87, 0xbb, 0x67, 0x28, 0x60, 0x1a, 0xfb, 0x36, 0x54, 0x35, 0xea, 0x5f, 0xb9, 0xcb, 0x7c, 0x13,
-	0x3d, 0x6f, 0xf8, 0xd4, 0x09, 0xb5, 0xf3, 0xba, 0x50, 0x19, 0xec, 0x1c, 0x0c, 0xa4, 0xff, 0x4a,
+	0x5a, 0x8f, 0x3c, 0x6f, 0xf8, 0xcc, 0x09, 0xb5, 0xf3, 0xba, 0x50, 0x19, 0xec, 0x1c, 0x0c, 0xa4,
-	0xdc, 0x5a, 0x05, 0xf2, 0xa3, 0x6b, 0x0f, 0xb1, 0x43, 0xc4, 0x28, 0x76, 0x93, 0xa3, 0xeb, 0x16,
+	0xff, 0x4a, 0xdc, 0x5a, 0x05, 0xf2, 0xa3, 0x6b, 0x0f, 0xb1, 0x43, 0xc4, 0x28, 0x76, 0x93, 0xa3,
-	0x54, 0x14, 0x86, 0xcf, 0xf4, 0xe5, 0xa7, 0xce, 0xc9, 0x0a, 0xbc, 0xf7, 0xa7, 0x8e, 0x4a, 0xdf,
+	0xeb, 0x16, 0x54, 0x14, 0x86, 0xcf, 0xf4, 0xe5, 0xa7, 0xce, 0xc9, 0x0a, 0x34, 0x03, 0x58, 0x1b,
-	0xea, 0x26, 0xc0, 0xd8, 0x83, 0xf6, 0xcc, 0xb3, 0x8d, 0xa1, 0xae, 0x86, 0x16, 0xbf, 0xe6, 0xf4,
+	0xc4, 0x93, 0xc9, 0x81, 0xcf, 0x6b, 0x1b, 0x25, 0x67, 0x03, 0x56, 0xb0, 0xaf, 0xbb, 0xda, 0x9a,
-	0x36, 0xfb, 0xf2, 0x19, 0xa8, 0xaf, 0x9f, 0x81, 0xfa, 0xbb, 0x7e, 0xc8, 0xa6, 0xc6, 0x2e, 0xb4,
+	0x25, 0x81, 0x39, 0x95, 0x8b, 0xf3, 0xa5, 0xe0, 0x2b, 0xd0, 0x90, 0x11, 0x63, 0xbb, 0x14, 0x79,
-	0xf2, 0x0f, 0x1c, 0xc6, 0xf3, 0xba, 0x92, 0x5a, 0xf0, 0xec, 0xb1, 0x94, 0xcd, 0x1e, 0xb4, 0x67,
+	0x91, 0xda, 0xaa, 0x75, 0x89, 0xdb, 0xe1, 0xa8, 0x7b, 0xff, 0xe8, 0xa8, 0xe3, 0x42, 0xdd, 0x3c,
-	0xde, 0x3a, 0xb4, 0x3e, 0x8b, 0x9f, 0x40, 0x96, 0x32, 0x7a, 0x00, 0xf5, 0xcc, 0xe3, 0x86, 0xd1,
+	0x18, 0x7b, 0xd0, 0x9e, 0x79, 0x26, 0x32, 0xd4, 0x55, 0xd4, 0xe2, 0xd7, 0xa3, 0xde, 0x66, 0x5f,
-	0x95, 0x4c, 0xe6, 0xdf, 0x3b, 0x96, 0x32, 0xd8, 0x81, 0x66, 0xee, 0xbd, 0xc1, 0xe8, 0x29, 0x7b,
+	0x3e, 0x3b, 0xf5, 0xf5, 0xb3, 0x53, 0x7f, 0xd7, 0x0f, 0xd9, 0xd4, 0xd8, 0x85, 0x56, 0xfe, 0x41,
-	0x16, 0x3c, 0x42, 0x2c, 0x65, 0xb2, 0x0d, 0xf5, 0xcc, 0xb5, 0xbf, 0xd6, 0x62, 0xfe, 0x6d, 0xa1,
+	0xc5, 0x78, 0x51, 0x57, 0x6e, 0x0b, 0x9e, 0x59, 0x96, 0xb2, 0xd9, 0x83, 0xf6, 0xcc, 0xdb, 0x8a,
-	0x77, 0x63, 0xc1, 0x88, 0x3a, 0x25, 0xf6, 0xa0, 0x3d, 0xf3, 0x16, 0xa0, 0x5d, 0xb2, 0xf8, 0x89,
+	0xd6, 0x67, 0xf1, 0x93, 0xcb, 0x52, 0x46, 0x0f, 0xa1, 0x9e, 0x79, 0x4c, 0x31, 0xba, 0x92, 0xc9,
-	0x60, 0xa9, 0x32, 0x9f, 0x8a, 0x25, 0xca, 0xb4, 0x7a, 0x99, 0x25, 0x9a, 0xbf, 0xf9, 0xef, 0xbd,
+	0xfc, 0xfb, 0xca, 0x52, 0x06, 0x3b, 0xd0, 0xcc, 0xbd, 0x6f, 0x18, 0x3d, 0x65, 0xcf, 0x82, 0x47,
-	0xb0, 0x78, 0x50, 0x69, 0xb5, 0x0b, 0xad, 0xfc, 0xa5, 0xbf, 0x66, 0xb6, 0xf0, 0x29, 0xe0, 0xe2,
+	0x8f, 0xa5, 0x4c, 0xb6, 0xa1, 0x9e, 0x79, 0x66, 0xd0, 0x5a, 0xcc, 0xbf, 0x65, 0xf4, 0x6e, 0x2c,
-	0xf5, 0xce, 0xdd, 0xff, 0xa7, 0xeb, 0xbd, 0xe8, 0x59, 0x60, 0x29, 0xa3, 0x87, 0x00, 0xaa, 0xb1,
+	0x18, 0x51, 0xa7, 0xd2, 0x1e, 0xb4, 0x67, 0xde, 0x1e, 0xb4, 0x4b, 0x16, 0x3f, 0x49, 0x2c, 0x55,
-	0xf3, 0x70, 0x90, 0x38, 0x7a, 0xae, 0xa1, 0x4c, 0x1c, 0xbd, 0xa0, 0x09, 0x7c, 0x00, 0x20, 0xfb,
+	0xe6, 0x33, 0xb1, 0x44, 0x99, 0xd6, 0x32, 0xb3, 0x44, 0xf3, 0x2f, 0x0d, 0xbd, 0x97, 0x16, 0x0f,
-	0x31, 0x8f, 0xc4, 0xcc, 0xb8, 0xae, 0xd5, 0x98, 0x69, 0x02, 0x7b, 0xdd, 0xf9, 0x81, 0x39, 0x06,
+	0x2a, 0xad, 0x76, 0xa1, 0x95, 0x7f, 0x64, 0xd0, 0xcc, 0x16, 0x3e, 0x3d, 0x5c, 0xbc, 0xde, 0xb9,
-	0x88, 0xd2, 0xcb, 0x30, 0xf8, 0x08, 0x20, 0xed, 0xf3, 0x34, 0x83, 0xb9, 0xce, 0xef, 0x02, 0x1f,
+	0xf7, 0x86, 0x74, 0xbd, 0x17, 0x3d, 0x43, 0x2c, 0x65, 0xf4, 0x08, 0x40, 0x35, 0x92, 0x1e, 0x0e,
-	0x34, 0xb2, 0x5d, 0x9d, 0xa1, 0x6c, 0x5d, 0xd0, 0xe9, 0x5d, 0xc0, 0xa2, 0x3d, 0x53, 0xb5, 0xe7,
+	0x12, 0x47, 0xcf, 0x35, 0xb0, 0x89, 0xa3, 0x17, 0x34, 0x9d, 0x0f, 0x01, 0x64, 0xff, 0xe7, 0x91,
-	0x37, 0xdb, 0x6c, 0x31, 0xdf, 0x9b, 0xab, 0xdc, 0x8d, 0xfb, 0xd0, 0xc8, 0x96, 0xeb, 0x5a, 0x8b,
+	0x98, 0x19, 0xd7, 0xb5, 0x1a, 0x33, 0x4d, 0x67, 0xaf, 0x3b, 0x3f, 0x30, 0xc7, 0x00, 0x51, 0x7a,
-	0x05, 0x25, 0x7c, 0x2f, 0x57, 0xb2, 0x1b, 0x0f, 0xa0, 0x95, 0x2f, 0xd5, 0xf5, 0x96, 0x5a, 0x58,
+	0x19, 0x06, 0x1f, 0x03, 0xa4, 0x7d, 0xa5, 0x66, 0x30, 0xd7, 0x69, 0x5e, 0xe0, 0x83, 0x46, 0xb6,
-	0xc0, 0xf7, 0xd4, 0x45, 0x54, 0x86, 0xfc, 0x1d, 0x80, 0xb4, 0xa4, 0xd7, 0xee, 0x9b, 0x2b, 0xf2,
+	0x8b, 0x34, 0x94, 0xad, 0x0b, 0x3a, 0xcb, 0x0b, 0x58, 0xb4, 0x67, 0xba, 0x84, 0xfc, 0x66, 0x9b,
-	0x67, 0xa4, 0xee, 0x41, 0x7b, 0xa6, 0x54, 0xd7, 0x16, 0x2f, 0xae, 0xe0, 0x2f, 0xf2, 0x7e, 0xf6,
+	0x6d, 0x1e, 0x7a, 0x73, 0x9d, 0x82, 0x71, 0x1f, 0x1a, 0xd9, 0xf6, 0x40, 0x6b, 0xb1, 0xa0, 0x65,
-	0xcc, 0xd0, 0x76, 0x2f, 0x38, 0x47, 0x2e, 0x4a, 0x5a, 0x99, 0xf3, 0x45, 0xef, 0xe2, 0xf9, 0x23,
+	0xe8, 0xe5, 0x5a, 0x04, 0xe3, 0x21, 0xb4, 0xf2, 0xad, 0x81, 0xde, 0x52, 0x0b, 0x1b, 0x86, 0x9e,
-	0x67, 0x29, 0x83, 0x77, 0x01, 0xd2, 0x93, 0x41, 0x7b, 0x60, 0xee, 0xac, 0xe8, 0x35, 0xf5, 0x45,
+	0xba, 0xf8, 0xca, 0x90, 0xbf, 0x07, 0x90, 0xb6, 0x10, 0xda, 0x7d, 0x73, 0x4d, 0xc5, 0x8c, 0xd4,
-	0xa1, 0xa4, 0xdb, 0x81, 0x66, 0xae, 0x97, 0xd6, 0xa9, 0x6e, 0x51, 0x83, 0x7d, 0xd1, 0x01, 0x90,
+	0x3d, 0x68, 0xcf, 0xb4, 0x06, 0xda, 0xe2, 0xc5, 0x1d, 0xc3, 0x45, 0xde, 0xcf, 0x9e, 0x51, 0xda,
-	0x6f, 0x3c, 0xf5, 0xea, 0x2d, 0x6c, 0x47, 0x2f, 0xf2, 0x62, 0xb6, 0xdb, 0xd1, 0x5e, 0x5c, 0xd0,
+	0xee, 0x05, 0xe7, 0xd6, 0x45, 0x49, 0x2b, 0x73, 0x9e, 0xe9, 0x5d, 0x3c, 0x7f, 0xc4, 0x2d, 0x65,
-	0x01, 0x7d, 0x4f, 0x4e, 0xc9, 0x76, 0x34, 0x99, 0x9c, 0xb2, 0xa0, 0xd1, 0x59, 0xca, 0x68, 0x1f,
+	0xf0, 0x3e, 0x40, 0x7a, 0x12, 0x69, 0x0f, 0xcc, 0x9d, 0x4d, 0xbd, 0xa6, 0xbe, 0x98, 0x94, 0x74,
-	0xda, 0x7b, 0xba, 0x58, 0x55, 0x85, 0xb4, 0x52, 0x67, 0x41, 0xe3, 0xd0, 0xeb, 0x2d, 0x1a, 0x52,
+	0x3b, 0xd0, 0xcc, 0xf5, 0xee, 0x3a, 0xd5, 0x2d, 0x6a, 0xe8, 0x2f, 0x3a, 0x00, 0xf2, 0x8d, 0xae,
-	0x81, 0xfd, 0x29, 0x74, 0xe6, 0x8a, 0x68, 0x63, 0x2b, 0xb9, 0xae, 0x5d, 0x58, 0x5d, 0x2f, 0x55,
+	0x5e, 0xbd, 0x85, 0xed, 0xef, 0x45, 0x5e, 0xcc, 0x76, 0x57, 0xda, 0x8b, 0x0b, 0x3a, 0xae, 0x1f,
-	0xeb, 0x00, 0xd6, 0x66, 0x6b, 0x68, 0xe3, 0x45, 0xb5, 0x55, 0x16, 0xd7, 0xd6, 0x4b, 0x59, 0xbd,
+	0xc8, 0x29, 0xd9, 0x0e, 0x2a, 0x93, 0x53, 0x16, 0x34, 0x56, 0x4b, 0x19, 0xed, 0x43, 0x7b, 0x4f,
-	0x0f, 0x55, 0x5d, 0xb3, 0x19, 0xea, 0x5a, 0x7c, 0xa6, 0x86, 0x5b, 0x3a, 0xf5, 0x3e, 0xd4, 0x33,
+	0x17, 0xc7, 0xaa, 0x70, 0x57, 0xea, 0x2c, 0x68, 0x54, 0x7a, 0xbd, 0x45, 0x43, 0x2a, 0xb0, 0x3f,
-	0x55, 0x8f, 0xde, 0xab, 0xf3, 0x85, 0x50, 0x4f, 0xdd, 0x62, 0x27, 0x94, 0xf7, 0xa1, 0xa2, 0x2a,
+	0x83, 0xce, 0x5c, 0xd1, 0x6e, 0x6c, 0x25, 0xd7, 0xc3, 0x0b, 0xab, 0xf9, 0xa5, 0x6a, 0x1d, 0xc0,
-	0x1d, 0x63, 0x23, 0x09, 0xb4, 0x4c, 0xe1, 0xb3, 0x4c, 0xe2, 0xf6, 0xf9, 0xb7, 0xdf, 0x6d, 0x3d,
+	0xda, 0x6c, 0xcd, 0x6e, 0xbc, 0xac, 0xb6, 0xca, 0xe2, 0x5a, 0x7e, 0x29, 0xab, 0x0f, 0xa1, 0xaa,
-	0xf7, 0xf7, 0xef, 0xb6, 0x9e, 0xfb, 0xe5, 0xb3, 0xad, 0xc2, 0xb7, 0xcf, 0xb6, 0x0a, 0x7f, 0x7b,
+	0x6b, 0x44, 0x43, 0x5d, 0xc3, 0xcf, 0xd4, 0x8c, 0x4b, 0xa7, 0xde, 0x87, 0x7a, 0xa6, 0xca, 0xd2,
-	0xb6, 0x55, 0xf8, 0xe7, 0xb3, 0xad, 0xc2, 0x8f, 0x7f, 0xf6, 0x5f, 0xfe, 0x17, 0x86, 0xc6, 0x01,
+	0x7b, 0x75, 0xbe, 0xf0, 0xea, 0xa9, 0x5b, 0xf3, 0x84, 0xf2, 0x3e, 0x54, 0x54, 0x65, 0x65, 0x6c,
-	0xc3, 0x3e, 0xba, 0x7b, 0x86, 0x29, 0xcb, 0x0c, 0x85, 0xa7, 0xa3, 0xb9, 0xbf, 0xc9, 0x70, 0x05,
+	0x24, 0x81, 0x96, 0x29, 0xb4, 0x96, 0x4a, 0x7c, 0x00, 0xb5, 0xa4, 0x58, 0x32, 0x36, 0xd5, 0x69,
-	0x8f, 0x57, 0x05, 0xfc, 0xce, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x43, 0x46, 0x6b, 0x3b, 0x74,
+	0x33, 0x53, 0x3d, 0x2d, 0x9b, 0xbc, 0x7d, 0xfe, 0xdd, 0xf7, 0x5b, 0x2f, 0xfc, 0xe5, 0xfb, 0xad,
-	0x23, 0x00, 0x00,
+	0x17, 0x7e, 0xfe, 0x7c, 0xab, 0xf0, 0xdd, 0xf3, 0xad, 0xc2, 0x9f, 0x9f, 0x6f, 0x15, 0xfe, 0xf6,
+	0x7c, 0xab, 0xf0, 0xff, 0x3f, 0xf9, 0x37, 0xff, 0xb8, 0x43, 0xe3, 0x80, 0x61, 0x1f, 0xdd, 0x3d,
+	0xc3, 0x94, 0x65, 0x86, 0xc2, 0xd3, 0xd1, 0xdc, 0x7f, 0x7a, 0xb8, 0x8a, 0xc7, 0xab, 0x02, 0x7e,
+	0xef, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf4, 0x8c, 0xe7, 0x3d, 0x21, 0x24, 0x00, 0x00,
 }
 
 func (m *CreateContainerRequest) Marshal() (dAtA []byte, err error) {
@@ -5580,6 +5625,54 @@ func (m *Metrics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *PullImageRequest) 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 *PullImageRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PullImageRequest) 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.SourceCreds) > 0 {
+		i -= len(m.SourceCreds)
+		copy(dAtA[i:], m.SourceCreds)
+		i = encodeVarintAgent(dAtA, i, uint64(len(m.SourceCreds)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.ContainerId) > 0 {
+		i -= len(m.ContainerId)
+		copy(dAtA[i:], m.ContainerId)
+		i = encodeVarintAgent(dAtA, i, uint64(len(m.ContainerId)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Image) > 0 {
+		i -= len(m.Image)
+		copy(dAtA[i:], m.Image)
+		i = encodeVarintAgent(dAtA, i, uint64(len(m.Image)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintAgent(dAtA []byte, offset int, v uint64) int {
 	offset -= sovAgent(v)
 	base := offset
@@ -6895,6 +6988,30 @@ func (m *Metrics) Size() (n int) {
 	return n
 }
 
+func (m *PullImageRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Image)
+	if l > 0 {
+		n += 1 + l + sovAgent(uint64(l))
+	}
+	l = len(m.ContainerId)
+	if l > 0 {
+		n += 1 + l + sovAgent(uint64(l))
+	}
+	l = len(m.SourceCreds)
+	if l > 0 {
+		n += 1 + l + sovAgent(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func sovAgent(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -7729,6 +7846,19 @@ func (this *Metrics) String() string {
 	}, "")
 	return s
 }
+func (this *PullImageRequest) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&PullImageRequest{`,
+		`Image:` + fmt.Sprintf("%v", this.Image) + `,`,
+		`ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`,
+		`SourceCreds:` + fmt.Sprintf("%v", this.SourceCreds) + `,`,
+		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func valueToStringAgent(v interface{}) string {
 	rv := reflect.ValueOf(v)
 	if rv.IsNil() {
@@ -7772,6 +7902,7 @@ type AgentServiceService interface {
 	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)
+	PullImage(ctx context.Context, req *PullImageRequest) (*types.Empty, error)
 }
 
 func RegisterAgentServiceService(srv *github_com_containerd_ttrpc.Server, svc AgentServiceService) {
@@ -8007,6 +8138,13 @@ func RegisterAgentServiceService(srv *github_com_containerd_ttrpc.Server, svc Ag
 			}
 			return svc.AddSwap(ctx, &req)
 		},
+		"PullImage": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
+			var req PullImageRequest
+			if err := unmarshal(&req); err != nil {
+				return nil, err
+			}
+			return svc.PullImage(ctx, &req)
+		},
 	})
 }
 
@@ -8283,6 +8421,14 @@ func (c *agentServiceClient) AddSwap(ctx context.Context, req *AddSwapRequest) (
 	}
 	return &resp, nil
 }
+
+func (c *agentServiceClient) PullImage(ctx context.Context, req *PullImageRequest) (*types.Empty, error) {
+	var resp types.Empty
+	if err := c.client.Call(ctx, "grpc.AgentService", "PullImage", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
 func (m *CreateContainerRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -15711,6 +15857,153 @@ func (m *Metrics) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *PullImageRequest) 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: PullImageRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PullImageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAgent
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthAgent
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthAgent
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Image = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAgent
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthAgent
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthAgent
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ContainerId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SourceCreds", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAgent
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthAgent
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthAgent
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SourceCreds = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		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 skipAgent(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

src/runtime/virtcontainers/pkg/agent/protocols/grpc/health.pb.go

@@ -732,10 +732,7 @@ func (m *CheckRequest) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthHealth
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthHealth
 			}
 			if (iNdEx + skippy) > l {
@@ -805,10 +802,7 @@ func (m *HealthCheckResponse) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthHealth
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthHealth
 			}
 			if (iNdEx + skippy) > l {
@@ -923,10 +917,7 @@ func (m *VersionCheckResponse) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthHealth
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthHealth
 			}
 			if (iNdEx + skippy) > l {

src/runtime/virtcontainers/pkg/agent/protocols/grpc/oci.pb.go

@@ -7717,7 +7717,7 @@ func (m *Spec) Unmarshal(dAtA []byte) error {
 					if err != nil {
 						return err
 					}
-					if skippy < 0 {
+					if (skippy < 0) || (iNdEx+skippy) < 0 {
 						return ErrInvalidLengthOci
 					}
 					if (iNdEx + skippy) > postIndex {
@@ -7842,10 +7842,7 @@ func (m *Spec) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -8254,10 +8251,7 @@ func (m *Process) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -8346,10 +8340,7 @@ func (m *Box) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -8546,10 +8537,7 @@ func (m *User) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -8760,10 +8748,7 @@ func (m *LinuxCapabilities) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -8884,10 +8869,7 @@ func (m *POSIXRlimit) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -9066,10 +9048,7 @@ func (m *Mount) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -9172,10 +9151,7 @@ func (m *Root) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -9328,10 +9304,7 @@ func (m *Hooks) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -9497,10 +9470,7 @@ func (m *Hook) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -9729,7 +9699,7 @@ func (m *Linux) Unmarshal(dAtA []byte) error {
 					if err != nil {
 						return err
 					}
-					if skippy < 0 {
+					if (skippy < 0) || (iNdEx+skippy) < 0 {
 						return ErrInvalidLengthOci
 					}
 					if (iNdEx + skippy) > postIndex {
@@ -10082,10 +10052,7 @@ func (m *Linux) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -10168,10 +10135,7 @@ func (m *Windows) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -10254,10 +10218,7 @@ func (m *Solaris) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -10365,10 +10326,7 @@ func (m *LinuxIDMapping) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -10483,10 +10441,7 @@ func (m *LinuxNamespace) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -10696,10 +10651,7 @@ func (m *LinuxDevice) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -10998,10 +10950,7 @@ func (m *LinuxResources) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -11186,10 +11135,7 @@ func (m *LinuxMemory) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -11399,10 +11345,7 @@ func (m *LinuxCPU) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -11529,10 +11472,7 @@ func (m *LinuxWeightDevice) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -11640,10 +11580,7 @@ func (m *LinuxThrottleDevice) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -11902,10 +11839,7 @@ func (m *LinuxBlockIO) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -11975,10 +11909,7 @@ func (m *LinuxPids) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -12151,10 +12082,7 @@ func (m *LinuxDeviceCgroup) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -12258,10 +12186,7 @@ func (m *LinuxNetwork) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -12363,10 +12288,7 @@ func (m *LinuxHugepageLimit) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -12468,10 +12390,7 @@ func (m *LinuxInterfacePriority) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -12652,10 +12571,7 @@ func (m *LinuxSeccomp) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -12795,10 +12711,7 @@ func (m *LinuxSeccompArg) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -12967,10 +12880,7 @@ func (m *LinuxSyscall) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {
@@ -13053,10 +12963,7 @@ func (m *LinuxIntelRdt) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthOci
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthOci
 			}
 			if (iNdEx + skippy) > l {

src/runtime/virtcontainers/pkg/agent/protocols/types.pb.go

@@ -875,10 +875,7 @@ func (m *IPAddress) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthTypes
 			}
 			if (iNdEx + skippy) > l {
@@ -1161,10 +1158,7 @@ func (m *Interface) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthTypes
 			}
 			if (iNdEx + skippy) > l {
@@ -1381,10 +1375,7 @@ func (m *Route) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthTypes
 			}
 			if (iNdEx + skippy) > l {
@@ -1573,10 +1564,7 @@ func (m *ARPNeighbor) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if skippy < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthTypes
 			}
 			if (iNdEx + skippy) > l {

src/runtime/virtcontainers/pkg/mock/mock.go

@@ -226,3 +226,7 @@ func (p *HybridVSockTTRPCMockImp) GetMetrics(ctx context.Context, req *pb.GetMet
 func (p *HybridVSockTTRPCMockImp) AddSwap(ctx context.Context, req *pb.AddSwapRequest) (*gpb.Empty, error) {
 	return &gpb.Empty{}, nil
 }
+
+func (p *HybridVSockTTRPCMockImp) PullImage(ctx context.Context, req *pb.PullImageRequest) (*gpb.Empty, error) {
+	return &gpb.Empty{}, nil
+}

src/runtime/virtcontainers/pkg/vcmock/sandbox.go

@@ -254,3 +254,7 @@ func (s *Sandbox) GetAgentURL() (string, error) {
 func (s *Sandbox) GetHypervisorPid() (int, error) {
 	return 0, nil
 }
+
+func (s *Sandbox) PullImage(ctx context.Context, image string, newContainerID string) error {
+	return nil
+}

src/runtime/virtcontainers/sandbox.go

@@ -1587,6 +1587,14 @@ func (s *Sandbox) ResumeContainer(ctx context.Context, containerID string) error
 	return nil
 }
 
+// PullImage pulls an image on a sandbox.
+func (s *Sandbox) PullImage(ctx context.Context, image string, containerID string) error {
+	if err := s.agent.pullImage(ctx, s, image, containerID); err != nil {
+		return err
+	}
+	return nil
+}
+
 // createContainers registers all containers, create the
 // containers in the guest and starts one shim per container.
 func (s *Sandbox) createContainers(ctx context.Context) error {