From 8a6285d844439b3bd9e089f59435a42999670b85 Mon Sep 17 00:00:00 2001
From: Yu-Ju Hong <yjhong@google.com>
Date: Tue, 1 Nov 2016 12:58:04 -0700
Subject: [PATCH] CRI: Rename container/sandbox states

The enum constants are not namespaced. The shorter, unspecifc names are likely
to cause naming conflicts in the future.

Also replace "SandBox" with "Sandbox" in the API.
---
 .../api/testing/fake_runtime_service.go       |  10 +-
 pkg/kubelet/api/v1alpha1/runtime/api.pb.go    | 482 +++++++++---------
 pkg/kubelet/api/v1alpha1/runtime/api.proto    |  24 +-
 pkg/kubelet/container/helpers.go              |   6 +-
 pkg/kubelet/dockershim/convert.go             |  22 +-
 pkg/kubelet/dockershim/convert_test.go        |   8 +-
 pkg/kubelet/dockershim/docker_container.go    |   8 +-
 .../dockershim/docker_container_test.go       |   8 +-
 pkg/kubelet/dockershim/docker_sandbox.go      |  10 +-
 pkg/kubelet/dockershim/docker_sandbox_test.go |   6 +-
 pkg/kubelet/kuberuntime/helpers.go            |   8 +-
 .../kuberuntime/kuberuntime_container.go      |   4 +-
 pkg/kubelet/kuberuntime/kuberuntime_gc.go     |   4 +-
 .../kuberuntime/kuberuntime_gc_test.go        | 128 ++---
 .../kuberuntime/kuberuntime_manager.go        |   6 +-
 .../kuberuntime/kuberuntime_manager_test.go   |  24 +-
 .../kuberuntime/kuberuntime_sandbox.go        |   4 +-
 pkg/kubelet/rktshim/fake-app-interface.go     |  18 +-
 18 files changed, 391 insertions(+), 389 deletions(-)

diff --git a/pkg/kubelet/api/testing/fake_runtime_service.go b/pkg/kubelet/api/testing/fake_runtime_service.go
index 51a0d1c04c7..239c27b35df 100644
--- a/pkg/kubelet/api/testing/fake_runtime_service.go
+++ b/pkg/kubelet/api/testing/fake_runtime_service.go
@@ -119,7 +119,7 @@ func (r *FakeRuntimeService) RunPodSandbox(config *runtimeApi.PodSandboxConfig)
 	// fixed name from BuildSandboxName() for easily making fake sandboxes.
 	podSandboxID := BuildSandboxName(config.Metadata)
 	createdAt := time.Now().Unix()
-	readyState := runtimeApi.PodSandBoxState_READY
+	readyState := runtimeApi.PodSandboxState_SANDBOX_READY
 	r.Sandboxes[podSandboxID] = &FakePodSandbox{
 		PodSandboxStatus: runtimeApi.PodSandboxStatus{
 			Id:        &podSandboxID,
@@ -143,7 +143,7 @@ func (r *FakeRuntimeService) StopPodSandbox(podSandboxID string) error {
 
 	r.Called = append(r.Called, "StopPodSandbox")
 
-	notReadyState := runtimeApi.PodSandBoxState_NOTREADY
+	notReadyState := runtimeApi.PodSandboxState_SANDBOX_NOTREADY
 	if s, ok := r.Sandboxes[podSandboxID]; ok {
 		s.State = &notReadyState
 	} else {
@@ -231,7 +231,7 @@ func (r *FakeRuntimeService) CreateContainer(podSandboxID string, config *runtim
 	// fixed BuildContainerName() for easily making fake containers.
 	containerID := BuildContainerName(config.Metadata, podSandboxID)
 	createdAt := time.Now().Unix()
-	createdState := runtimeApi.ContainerState_CREATED
+	createdState := runtimeApi.ContainerState_CONTAINER_CREATED
 	imageRef := config.Image.GetImage()
 	r.Containers[containerID] = &FakeContainer{
 		ContainerStatus: runtimeApi.ContainerStatus{
@@ -263,7 +263,7 @@ func (r *FakeRuntimeService) StartContainer(containerID string) error {
 
 	// Set container to running.
 	startedAt := time.Now().Unix()
-	runningState := runtimeApi.ContainerState_RUNNING
+	runningState := runtimeApi.ContainerState_CONTAINER_RUNNING
 	c.State = &runningState
 	c.StartedAt = &startedAt
 
@@ -283,7 +283,7 @@ func (r *FakeRuntimeService) StopContainer(containerID string, timeout int64) er
 
 	// Set container to exited state.
 	finishedAt := time.Now().Unix()
-	exitedState := runtimeApi.ContainerState_EXITED
+	exitedState := runtimeApi.ContainerState_CONTAINER_EXITED
 	c.State = &exitedState
 	c.FinishedAt = &finishedAt
 
diff --git a/pkg/kubelet/api/v1alpha1/runtime/api.pb.go b/pkg/kubelet/api/v1alpha1/runtime/api.pb.go
index cf62200f2be..e7dc8e79243 100644
--- a/pkg/kubelet/api/v1alpha1/runtime/api.pb.go
+++ b/pkg/kubelet/api/v1alpha1/runtime/api.pb.go
@@ -152,60 +152,60 @@ func (x *Protocol) UnmarshalJSON(data []byte) error {
 }
 func (Protocol) EnumDescriptor() ([]byte, []int) { return fileDescriptorApi, []int{0} }
 
-type PodSandBoxState int32
+type PodSandboxState int32
 
 const (
-	PodSandBoxState_READY    PodSandBoxState = 0
-	PodSandBoxState_NOTREADY PodSandBoxState = 1
+	PodSandboxState_SANDBOX_READY    PodSandboxState = 0
+	PodSandboxState_SANDBOX_NOTREADY PodSandboxState = 1
 )
 
-var PodSandBoxState_name = map[int32]string{
-	0: "READY",
-	1: "NOTREADY",
+var PodSandboxState_name = map[int32]string{
+	0: "SANDBOX_READY",
+	1: "SANDBOX_NOTREADY",
 }
-var PodSandBoxState_value = map[string]int32{
-	"READY":    0,
-	"NOTREADY": 1,
+var PodSandboxState_value = map[string]int32{
+	"SANDBOX_READY":    0,
+	"SANDBOX_NOTREADY": 1,
 }
 
-func (x PodSandBoxState) Enum() *PodSandBoxState {
-	p := new(PodSandBoxState)
+func (x PodSandboxState) Enum() *PodSandboxState {
+	p := new(PodSandboxState)
 	*p = x
 	return p
 }
-func (x PodSandBoxState) String() string {
-	return proto.EnumName(PodSandBoxState_name, int32(x))
+func (x PodSandboxState) String() string {
+	return proto.EnumName(PodSandboxState_name, int32(x))
 }
-func (x *PodSandBoxState) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(PodSandBoxState_value, data, "PodSandBoxState")
+func (x *PodSandboxState) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(PodSandboxState_value, data, "PodSandboxState")
 	if err != nil {
 		return err
 	}
-	*x = PodSandBoxState(value)
+	*x = PodSandboxState(value)
 	return nil
 }
-func (PodSandBoxState) EnumDescriptor() ([]byte, []int) { return fileDescriptorApi, []int{1} }
+func (PodSandboxState) EnumDescriptor() ([]byte, []int) { return fileDescriptorApi, []int{1} }
 
 type ContainerState int32
 
 const (
-	ContainerState_CREATED ContainerState = 0
-	ContainerState_RUNNING ContainerState = 1
-	ContainerState_EXITED  ContainerState = 2
-	ContainerState_UNKNOWN ContainerState = 3
+	ContainerState_CONTAINER_CREATED ContainerState = 0
+	ContainerState_CONTAINER_RUNNING ContainerState = 1
+	ContainerState_CONTAINER_EXITED  ContainerState = 2
+	ContainerState_CONTAINER_UNKNOWN ContainerState = 3
 )
 
 var ContainerState_name = map[int32]string{
-	0: "CREATED",
-	1: "RUNNING",
-	2: "EXITED",
-	3: "UNKNOWN",
+	0: "CONTAINER_CREATED",
+	1: "CONTAINER_RUNNING",
+	2: "CONTAINER_EXITED",
+	3: "CONTAINER_UNKNOWN",
 }
 var ContainerState_value = map[string]int32{
-	"CREATED": 0,
-	"RUNNING": 1,
-	"EXITED":  2,
-	"UNKNOWN": 3,
+	"CONTAINER_CREATED": 0,
+	"CONTAINER_RUNNING": 1,
+	"CONTAINER_EXITED":  2,
+	"CONTAINER_UNKNOWN": 3,
 }
 
 func (x ContainerState) Enum() *ContainerState {
@@ -823,7 +823,7 @@ func (m *Namespace) GetOptions() *NamespaceOption {
 	return nil
 }
 
-// LinuxSandBoxStatus contains status specific to Linux sandboxes.
+// LinuxSandboxStatus contains status specific to Linux sandboxes.
 type LinuxPodSandboxStatus struct {
 	// Namespaces contains paths to the sandbox's namespaces.
 	Namespaces       *Namespace `protobuf:"bytes,1,opt,name=namespaces" json:"namespaces,omitempty"`
@@ -849,7 +849,7 @@ type PodSandboxStatus struct {
 	// Metadata of the sandbox.
 	Metadata *PodSandboxMetadata `protobuf:"bytes,2,opt,name=metadata" json:"metadata,omitempty"`
 	// State of the sandbox.
-	State *PodSandBoxState `protobuf:"varint,3,opt,name=state,enum=runtime.PodSandBoxState" json:"state,omitempty"`
+	State *PodSandboxState `protobuf:"varint,3,opt,name=state,enum=runtime.PodSandboxState" json:"state,omitempty"`
 	// Creation timestamp of the sandbox in nanoseconds.
 	CreatedAt *int64 `protobuf:"varint,4,opt,name=created_at,json=createdAt" json:"created_at,omitempty"`
 	// Network contains network status if network is handled by the runtime.
@@ -883,11 +883,11 @@ func (m *PodSandboxStatus) GetMetadata() *PodSandboxMetadata {
 	return nil
 }
 
-func (m *PodSandboxStatus) GetState() PodSandBoxState {
+func (m *PodSandboxStatus) GetState() PodSandboxState {
 	if m != nil && m.State != nil {
 		return *m.State
 	}
-	return PodSandBoxState_READY
+	return PodSandboxState_SANDBOX_READY
 }
 
 func (m *PodSandboxStatus) GetCreatedAt() int64 {
@@ -949,7 +949,7 @@ type PodSandboxFilter struct {
 	// ID of the sandbox.
 	Id *string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
 	// State of the sandbox.
-	State *PodSandBoxState `protobuf:"varint,2,opt,name=state,enum=runtime.PodSandBoxState" json:"state,omitempty"`
+	State *PodSandboxState `protobuf:"varint,2,opt,name=state,enum=runtime.PodSandboxState" json:"state,omitempty"`
 	// LabelSelector to select matches.
 	// Only api.MatchLabels is supported for now and the requirements
 	// are ANDed. MatchExpressions is not supported yet.
@@ -969,11 +969,11 @@ func (m *PodSandboxFilter) GetId() string {
 	return ""
 }
 
-func (m *PodSandboxFilter) GetState() PodSandBoxState {
+func (m *PodSandboxFilter) GetState() PodSandboxState {
 	if m != nil && m.State != nil {
 		return *m.State
 	}
-	return PodSandBoxState_READY
+	return PodSandboxState_SANDBOX_READY
 }
 
 func (m *PodSandboxFilter) GetLabelSelector() map[string]string {
@@ -1008,7 +1008,7 @@ type PodSandbox struct {
 	// Metadata of the sandbox
 	Metadata *PodSandboxMetadata `protobuf:"bytes,2,opt,name=metadata" json:"metadata,omitempty"`
 	// The state of the PodSandbox
-	State *PodSandBoxState `protobuf:"varint,3,opt,name=state,enum=runtime.PodSandBoxState" json:"state,omitempty"`
+	State *PodSandboxState `protobuf:"varint,3,opt,name=state,enum=runtime.PodSandboxState" json:"state,omitempty"`
 	// Creation timestamps of the sandbox in nanoseconds
 	CreatedAt *int64 `protobuf:"varint,4,opt,name=created_at,json=createdAt" json:"created_at,omitempty"`
 	// The labels of the PodSandbox
@@ -1038,11 +1038,11 @@ func (m *PodSandbox) GetMetadata() *PodSandboxMetadata {
 	return nil
 }
 
-func (m *PodSandbox) GetState() PodSandBoxState {
+func (m *PodSandbox) GetState() PodSandboxState {
 	if m != nil && m.State != nil {
 		return *m.State
 	}
-	return PodSandBoxState_READY
+	return PodSandboxState_SANDBOX_READY
 }
 
 func (m *PodSandbox) GetCreatedAt() int64 {
@@ -1727,7 +1727,7 @@ func (m *ContainerFilter) GetState() ContainerState {
 	if m != nil && m.State != nil {
 		return *m.State
 	}
-	return ContainerState_CREATED
+	return ContainerState_CONTAINER_CREATED
 }
 
 func (m *ContainerFilter) GetPodSandboxId() string {
@@ -1832,7 +1832,7 @@ func (m *Container) GetState() ContainerState {
 	if m != nil && m.State != nil {
 		return *m.State
 	}
-	return ContainerState_CREATED
+	return ContainerState_CONTAINER_CREATED
 }
 
 func (m *Container) GetCreatedAt() int64 {
@@ -1950,7 +1950,7 @@ func (m *ContainerStatus) GetState() ContainerState {
 	if m != nil && m.State != nil {
 		return *m.State
 	}
-	return ContainerState_CREATED
+	return ContainerState_CONTAINER_CREATED
 }
 
 func (m *ContainerStatus) GetCreatedAt() int64 {
@@ -2677,7 +2677,7 @@ func init() {
 	proto.RegisterType((*UpdateRuntimeConfigRequest)(nil), "runtime.UpdateRuntimeConfigRequest")
 	proto.RegisterType((*UpdateRuntimeConfigResponse)(nil), "runtime.UpdateRuntimeConfigResponse")
 	proto.RegisterEnum("runtime.Protocol", Protocol_name, Protocol_value)
-	proto.RegisterEnum("runtime.PodSandBoxState", PodSandBoxState_name, PodSandBoxState_value)
+	proto.RegisterEnum("runtime.PodSandboxState", PodSandboxState_name, PodSandboxState_value)
 	proto.RegisterEnum("runtime.ContainerState", ContainerState_name, ContainerState_value)
 }
 
@@ -2706,7 +2706,7 @@ type RuntimeServiceClient interface {
 	RemovePodSandbox(ctx context.Context, in *RemovePodSandboxRequest, opts ...grpc.CallOption) (*RemovePodSandboxResponse, error)
 	// PodSandboxStatus returns the status of the PodSandbox.
 	PodSandboxStatus(ctx context.Context, in *PodSandboxStatusRequest, opts ...grpc.CallOption) (*PodSandboxStatusResponse, error)
-	// ListPodSandbox returns a list of SandBox.
+	// ListPodSandbox returns a list of Sandbox.
 	ListPodSandbox(ctx context.Context, in *ListPodSandboxRequest, opts ...grpc.CallOption) (*ListPodSandboxResponse, error)
 	// CreateContainer creates a new container in specified PodSandbox
 	CreateContainer(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error)
@@ -2912,7 +2912,7 @@ type RuntimeServiceServer interface {
 	RemovePodSandbox(context.Context, *RemovePodSandboxRequest) (*RemovePodSandboxResponse, error)
 	// PodSandboxStatus returns the status of the PodSandbox.
 	PodSandboxStatus(context.Context, *PodSandboxStatusRequest) (*PodSandboxStatusResponse, error)
-	// ListPodSandbox returns a list of SandBox.
+	// ListPodSandbox returns a list of Sandbox.
 	ListPodSandbox(context.Context, *ListPodSandboxRequest) (*ListPodSandboxResponse, error)
 	// CreateContainer creates a new container in specified PodSandbox
 	CreateContainer(context.Context, *CreateContainerRequest) (*CreateContainerResponse, error)
@@ -3503,199 +3503,201 @@ var _ImageService_serviceDesc = grpc.ServiceDesc{
 }
 
 var fileDescriptorApi = []byte{
-	// 3101 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x1a, 0x4d, 0x77, 0xdb, 0xc6,
-	0x31, 0x24, 0x45, 0x8a, 0x1c, 0x8a, 0x14, 0xbd, 0x92, 0x25, 0x9a, 0x8e, 0x6d, 0x19, 0x49, 0x9a,
-	0x44, 0x49, 0xfc, 0x12, 0xb6, 0x4d, 0x9a, 0x2f, 0x27, 0x8a, 0xa4, 0xa4, 0x8a, 0x6d, 0x5a, 0x05,
-	0xed, 0x34, 0x79, 0x39, 0xa0, 0x30, 0x01, 0x4b, 0xb0, 0x49, 0x00, 0x01, 0x40, 0xc5, 0xec, 0xb5,
-	0x97, 0x1e, 0x7a, 0xe8, 0xb5, 0xb7, 0x1e, 0xfa, 0x5e, 0x0f, 0xbd, 0xf5, 0xbd, 0xbe, 0xd7, 0xff,
-	0xd0, 0xd7, 0x1f, 0xd2, 0x43, 0xcf, 0xed, 0xb1, 0xb3, 0x1f, 0x58, 0x2c, 0xbe, 0x14, 0xc9, 0x79,
-	0xaf, 0xf1, 0x0d, 0x3b, 0x3b, 0x3b, 0x33, 0x3b, 0x33, 0x3b, 0x3b, 0x33, 0x0b, 0x68, 0x99, 0xbe,
-	0x73, 0xc3, 0x0f, 0xbc, 0xc8, 0x23, 0xcb, 0xc1, 0xdc, 0x8d, 0x9c, 0x99, 0xad, 0x6d, 0x43, 0xf7,
-	0x0b, 0x3b, 0x08, 0x1d, 0xcf, 0xd5, 0xed, 0x6f, 0xe6, 0x76, 0x18, 0x91, 0x3e, 0x2c, 0x9f, 0x70,
-	0x48, 0xbf, 0xb2, 0x55, 0x79, 0xa5, 0xa5, 0xc7, 0x43, 0xed, 0xcf, 0x15, 0x58, 0x95, 0xc8, 0xa1,
-	0xef, 0xb9, 0xa1, 0x5d, 0x8e, 0x4d, 0xae, 0xc3, 0x8a, 0x60, 0x62, 0xb8, 0xe6, 0xcc, 0xee, 0x57,
-	0xd9, 0x74, 0x5b, 0xc0, 0x46, 0x08, 0x22, 0x2f, 0xc3, 0x6a, 0x8c, 0x12, 0x13, 0xa9, 0x31, 0xac,
-	0xae, 0x00, 0x0b, 0x6e, 0xe4, 0x06, 0xac, 0xc5, 0x88, 0xb8, 0x07, 0x89, 0xbc, 0xc4, 0x90, 0x2f,
-	0x88, 0xa9, 0x1d, 0xdf, 0x11, 0xf8, 0xda, 0xd7, 0xd0, 0xda, 0x1b, 0x8d, 0x77, 0x3d, 0xf7, 0xa1,
-	0x73, 0x44, 0x45, 0x0c, 0xed, 0x80, 0xae, 0x41, 0x11, 0x6b, 0x54, 0x44, 0x31, 0x24, 0x03, 0x68,
-	0x86, 0xb6, 0x19, 0x4c, 0x8e, 0xed, 0x10, 0xc5, 0xa3, 0x53, 0x72, 0x4c, 0x57, 0x79, 0x7e, 0x84,
-	0xc4, 0x42, 0x94, 0x89, 0xad, 0x12, 0x43, 0xed, 0x0f, 0x15, 0x68, 0x1f, 0x7a, 0x41, 0x74, 0xc7,
-	0xf4, 0x7d, 0xc7, 0x3d, 0x22, 0x6f, 0x40, 0x93, 0x29, 0x75, 0xe2, 0x4d, 0x99, 0x0e, 0xba, 0xc3,
-	0x0b, 0x37, 0x84, 0x48, 0x37, 0x0e, 0xc5, 0x84, 0x2e, 0x51, 0xc8, 0x4b, 0xd0, 0x9d, 0x78, 0x6e,
-	0x64, 0x3a, 0xae, 0x1d, 0x18, 0x3e, 0xd2, 0x61, 0x9a, 0xa9, 0xeb, 0x1d, 0x09, 0xa5, 0xc4, 0xc9,
-	0x65, 0x68, 0x1d, 0x7b, 0x61, 0xc4, 0x31, 0x6a, 0x0c, 0xa3, 0x49, 0x01, 0x6c, 0x72, 0x13, 0x96,
-	0xd9, 0xa4, 0xe3, 0x0b, 0x1d, 0x34, 0xe8, 0xf0, 0xc0, 0xd7, 0x7e, 0x5f, 0x81, 0xfa, 0x1d, 0x0f,
-	0x99, 0x67, 0xd8, 0x98, 0xd1, 0xb1, 0xb0, 0x8f, 0xc2, 0x06, 0x81, 0x09, 0x1b, 0x8a, 0xc1, 0x4d,
-	0xc4, 0xd9, 0xd0, 0x49, 0xd4, 0x4f, 0x60, 0x9b, 0x96, 0xe7, 0x4e, 0x17, 0x4c, 0x84, 0xa6, 0x2e,
-	0xc7, 0xd4, 0x76, 0xa1, 0x3d, 0x75, 0xdc, 0xf9, 0x13, 0x23, 0xb0, 0xa7, 0xe6, 0x03, 0x7b, 0xca,
-	0x44, 0x69, 0xea, 0x5d, 0x01, 0xd6, 0x39, 0x54, 0x7b, 0x04, 0xab, 0xd4, 0xd8, 0xa1, 0x6f, 0x4e,
-	0xec, 0xbb, 0x4c, 0x85, 0xd4, 0x35, 0x18, 0x53, 0xd7, 0x8e, 0xbe, 0xf5, 0x82, 0xc7, 0x4c, 0xb2,
-	0xa6, 0xde, 0xa6, 0xb0, 0x11, 0x07, 0x91, 0x4b, 0xd0, 0xe4, 0x72, 0x39, 0x16, 0x13, 0xab, 0xa9,
-	0xb3, 0x1d, 0x1f, 0x3a, 0x96, 0x9c, 0x72, 0xfc, 0x89, 0x90, 0x6a, 0x99, 0xef, 0x7e, 0xa2, 0xfd,
-	0xa6, 0x02, 0x17, 0x6f, 0x53, 0xe6, 0x87, 0x9e, 0x35, 0x36, 0x5d, 0xeb, 0x81, 0xf7, 0x44, 0x38,
-	0xc1, 0x0b, 0xd0, 0x99, 0x1c, 0x05, 0xde, 0xdc, 0xc7, 0x9d, 0x06, 0xb6, 0x1b, 0x09, 0x6d, 0xac,
-	0x70, 0xe0, 0x21, 0x83, 0x91, 0x7d, 0xb8, 0xe0, 0xc6, 0xa2, 0x1a, 0xb1, 0xf5, 0x29, 0xf7, 0xf6,
-	0xb0, 0x2f, 0x4d, 0x9a, 0xd9, 0x8c, 0xde, 0x73, 0xd3, 0x80, 0x50, 0x0b, 0x80, 0x24, 0xfc, 0xef,
-	0xd8, 0x91, 0x69, 0x99, 0x91, 0x49, 0x08, 0x2c, 0xb1, 0x73, 0xc0, 0x19, 0xb3, 0x6f, 0xd2, 0x83,
-	0xda, 0x5c, 0x6c, 0xb0, 0xa5, 0xd3, 0x4f, 0xf2, 0x3c, 0xb4, 0x24, 0x3d, 0x71, 0x18, 0x12, 0x00,
-	0x75, 0x4a, 0x33, 0x8a, 0xec, 0x99, 0x1f, 0x31, 0x65, 0x77, 0xf4, 0x78, 0xa8, 0xfd, 0x7d, 0x09,
-	0x7a, 0xb9, 0x4d, 0xbf, 0x03, 0xcd, 0x99, 0x60, 0xcf, 0xd8, 0xb6, 0x87, 0x97, 0x13, 0xcf, 0xcc,
-	0x49, 0xa8, 0x4b, 0x64, 0x6a, 0x78, 0xaa, 0x52, 0xe5, 0xdc, 0xca, 0x31, 0xd5, 0xe4, 0xd4, 0x3b,
-	0x32, 0x2c, 0x27, 0xb0, 0x27, 0x91, 0x17, 0x2c, 0x84, 0x94, 0x2b, 0x08, 0xdc, 0x8b, 0x61, 0xe4,
-	0x2d, 0x00, 0xcb, 0x0d, 0x8d, 0x09, 0x93, 0x83, 0xc9, 0xda, 0x1e, 0x12, 0xc9, 0x5b, 0x9e, 0x4d,
-	0xbd, 0x85, 0x58, 0x42, 0xd8, 0x77, 0xa1, 0x43, 0x7d, 0xdd, 0x98, 0xf1, 0x63, 0x15, 0xf6, 0xeb,
-	0x78, 0xec, 0xda, 0xc3, 0x75, 0x45, 0x62, 0x79, 0xe6, 0xf4, 0x15, 0x3f, 0x19, 0x84, 0xe4, 0x43,
-	0x68, 0x30, 0x5f, 0x0b, 0xfb, 0x0d, 0xb6, 0xe6, 0xa5, 0x82, 0x5d, 0x72, 0x2e, 0x37, 0x6e, 0x33,
-	0xbc, 0x7d, 0x37, 0x0a, 0x16, 0xba, 0x58, 0x44, 0x6e, 0x43, 0xdb, 0x74, 0x5d, 0x2f, 0x32, 0xb9,
-	0xc1, 0x97, 0x19, 0x8d, 0xed, 0x72, 0x1a, 0x3b, 0x09, 0x32, 0x27, 0xa4, 0x2e, 0x27, 0x3f, 0x81,
-	0x3a, 0xf3, 0xff, 0x7e, 0x93, 0xed, 0xfa, 0xaa, 0xa4, 0x53, 0xe8, 0x98, 0x3a, 0x47, 0x1e, 0xbc,
-	0x0b, 0x6d, 0x45, 0x34, 0xea, 0x18, 0x8f, 0xed, 0x85, 0xf0, 0x15, 0xfa, 0x49, 0xd6, 0xa1, 0x7e,
-	0x62, 0x4e, 0xe7, 0xb1, 0x3d, 0xf8, 0xe0, 0xbd, 0xea, 0xcf, 0x2a, 0x83, 0x9b, 0xd0, 0xcb, 0x4a,
-	0x74, 0x9e, 0xf5, 0xda, 0x01, 0xac, 0xeb, 0x73, 0x37, 0x11, 0x2c, 0xbe, 0x08, 0xde, 0x82, 0x86,
-	0xb0, 0x1f, 0xf7, 0x9d, 0x4b, 0xa5, 0x1a, 0xd1, 0x05, 0xa2, 0xf6, 0x21, 0x5c, 0xcc, 0x90, 0x12,
-	0xd7, 0xc4, 0x8b, 0xd0, 0xf5, 0x3d, 0xcb, 0x08, 0x39, 0xd8, 0x40, 0x9f, 0x17, 0xe7, 0xcf, 0x97,
-	0xb8, 0x07, 0x16, 0x5d, 0x3e, 0x8e, 0x3c, 0x3f, 0x2f, 0xca, 0xd9, 0x96, 0xf7, 0x61, 0x23, 0xbb,
-	0x9c, 0xb3, 0xd7, 0x3e, 0x82, 0x4d, 0xdd, 0x9e, 0x79, 0x27, 0xf6, 0xd3, 0x92, 0x1e, 0x40, 0x3f,
-	0x4f, 0x20, 0x21, 0x9e, 0x40, 0xc7, 0x68, 0x86, 0x79, 0x78, 0x3e, 0xe2, 0xaf, 0xaa, 0x04, 0x44,
-	0x00, 0xe4, 0x74, 0x48, 0x17, 0xaa, 0x18, 0xe3, 0xf9, 0x22, 0xfc, 0xd2, 0xbe, 0x82, 0xd6, 0x48,
-	0x8d, 0x06, 0x6a, 0x04, 0xc5, 0x2b, 0x4a, 0x0c, 0xc9, 0x30, 0xb9, 0xbc, 0xbe, 0x2b, 0x7c, 0xc9,
-	0x6b, 0xed, 0x56, 0x2e, 0x74, 0x0a, 0x19, 0x86, 0x00, 0x32, 0x02, 0x85, 0xc2, 0x17, 0x48, 0x9e,
-	0x9e, 0xae, 0x60, 0x69, 0x7f, 0x4a, 0x85, 0x23, 0x65, 0x33, 0x96, 0xdc, 0x8c, 0x95, 0x0a, 0x4f,
-	0xd5, 0xf3, 0x84, 0xa7, 0x1b, 0x50, 0x0f, 0x91, 0x24, 0x0f, 0x90, 0x5d, 0x65, 0x73, 0x62, 0xd5,
-	0x27, 0x9c, 0xa5, 0xad, 0x73, 0x34, 0x72, 0x05, 0x60, 0x82, 0x17, 0x57, 0x64, 0x5b, 0x86, 0xc9,
-	0x23, 0x67, 0x4d, 0x6f, 0x09, 0xc8, 0x4e, 0x44, 0xde, 0x4b, 0xf4, 0x58, 0x67, 0x62, 0x6c, 0x15,
-	0x88, 0x91, 0xb2, 0x4b, 0xa2, 0x69, 0x79, 0xda, 0x1b, 0xa7, 0x9f, 0x76, 0xb1, 0x8e, 0x23, 0x2b,
-	0x01, 0x6b, 0xb9, 0x34, 0x60, 0xf1, 0x15, 0x67, 0x09, 0x58, 0xcd, 0xd2, 0x80, 0x25, 0x68, 0x9c,
-	0x1a, 0xb0, 0x7e, 0xc8, 0xd0, 0x73, 0x07, 0xfa, 0xf9, 0xa3, 0x23, 0x42, 0x06, 0x86, 0x9f, 0x90,
-	0x41, 0x4e, 0x09, 0x3f, 0x62, 0x89, 0x40, 0xd4, 0xfe, 0x55, 0x51, 0xbd, 0xee, 0x53, 0x67, 0x1a,
-	0xd9, 0x41, 0xce, 0xeb, 0xa4, 0xf3, 0x54, 0xcf, 0xe6, 0x3c, 0x63, 0xe8, 0x32, 0xb5, 0x1b, 0x98,
-	0xd7, 0xb0, 0xdb, 0x8d, 0xe5, 0x83, 0xed, 0xe1, 0xeb, 0x05, 0xf2, 0x70, 0x96, 0xdc, 0x66, 0x63,
-	0x81, 0xce, 0x35, 0xde, 0x99, 0xaa, 0xb0, 0xc1, 0xc7, 0x40, 0xf2, 0x48, 0xe7, 0x52, 0xdd, 0xe7,
-	0xf4, 0xb8, 0xd2, 0x74, 0xb0, 0x20, 0x6c, 0x3f, 0x64, 0x62, 0x9c, 0xa2, 0x37, 0x2e, 0xa7, 0x2e,
-	0x10, 0xb5, 0x3f, 0xd6, 0x00, 0x92, 0xc9, 0x67, 0xf6, 0x9c, 0xbe, 0x23, 0x4f, 0x0d, 0x4f, 0x0d,
-	0xae, 0x15, 0x48, 0x51, 0x78, 0x5e, 0x3e, 0x4d, 0x9f, 0x17, 0x9e, 0x24, 0xbc, 0x58, 0xb4, 0xfa,
-	0x99, 0x3d, 0x29, 0xbb, 0xb0, 0x91, 0x35, 0xb7, 0x38, 0x27, 0xaf, 0x42, 0xdd, 0xc1, 0x1c, 0x90,
-	0x17, 0x37, 0xed, 0xe1, 0x5a, 0xc1, 0xb6, 0x74, 0x8e, 0xa1, 0x5d, 0x87, 0xd6, 0xc1, 0xcc, 0x3c,
-	0xb2, 0xc7, 0xbe, 0x3d, 0xa1, 0xbc, 0x1c, 0x3a, 0x10, 0xfc, 0xf9, 0x40, 0x1b, 0x42, 0xf3, 0x96,
-	0xbd, 0xf8, 0x82, 0xf2, 0x3d, 0xab, 0x7c, 0xda, 0x3f, 0x2a, 0xb0, 0xc9, 0xc2, 0xdd, 0x6e, 0x5c,
-	0x5a, 0xa0, 0x70, 0xde, 0x3c, 0xc0, 0x8b, 0x80, 0x99, 0xd4, 0x9f, 0x1b, 0xbe, 0x1d, 0x38, 0x1e,
-	0xf7, 0x29, 0x6a, 0x52, 0x7f, 0x7e, 0xc8, 0x00, 0xb4, 0xfc, 0xa0, 0xd3, 0xdf, 0xcc, 0x3d, 0xe1,
-	0x5b, 0x35, 0xbd, 0x89, 0x80, 0x5f, 0xd0, 0x71, 0xbc, 0x36, 0x3c, 0xc6, 0xec, 0x3c, 0x64, 0x3e,
-	0xc4, 0xd7, 0x8e, 0x19, 0x00, 0x1d, 0xfd, 0xe2, 0x0c, 0xef, 0xe4, 0x60, 0x61, 0x4c, 0x9d, 0x99,
-	0x83, 0xf5, 0x80, 0x6b, 0x3c, 0x58, 0x44, 0x88, 0xc9, 0x1d, 0x87, 0xf0, 0xc9, 0xdb, 0x74, 0xee,
-	0xc0, 0xfd, 0x84, 0xce, 0x10, 0x0d, 0x3a, 0x9e, 0x37, 0x33, 0xc2, 0x89, 0x17, 0x60, 0x25, 0x69,
-	0x3d, 0x62, 0xf1, 0xbe, 0xa6, 0xb7, 0x11, 0x38, 0xa6, 0xb0, 0x1d, 0xeb, 0x91, 0x66, 0x42, 0x67,
-	0xbc, 0xcf, 0xb6, 0x23, 0xaa, 0x15, 0x4c, 0xdc, 0xe7, 0xa1, 0x38, 0x4e, 0x98, 0xb8, 0xd3, 0x6f,
-	0x0a, 0x0b, 0xbc, 0x69, 0xac, 0x07, 0xf6, 0x4d, 0x61, 0xd1, 0xc2, 0x8f, 0xb3, 0x76, 0xf6, 0x4d,
-	0x15, 0x36, 0xb5, 0x4f, 0x44, 0x6d, 0x84, 0x0a, 0x63, 0x03, 0xcd, 0x02, 0xd8, 0x35, 0x7d, 0xf3,
-	0x81, 0x33, 0x75, 0xa2, 0x05, 0x1a, 0xb0, 0x67, 0x5a, 0x96, 0x31, 0x89, 0x21, 0x8e, 0x1d, 0x17,
-	0xaa, 0xab, 0x08, 0xdf, 0x55, 0xc0, 0xe4, 0x35, 0xb8, 0x60, 0x05, 0x9e, 0x9f, 0xc6, 0xe5, 0x95,
-	0x6b, 0x8f, 0x4e, 0xa8, 0xc8, 0xda, 0x7f, 0x2b, 0xb0, 0x9e, 0x36, 0x8b, 0xc8, 0xb4, 0x6f, 0x42,
-	0x2b, 0x88, 0x0d, 0x24, 0x82, 0xc4, 0x56, 0xfa, 0xde, 0xca, 0x1b, 0x52, 0x4f, 0x96, 0xe0, 0x39,
-	0x5c, 0xc9, 0x08, 0x50, 0x49, 0x39, 0x5e, 0xb2, 0x37, 0x3d, 0x85, 0x48, 0x3e, 0x4a, 0x6a, 0xc6,
-	0xa4, 0xb6, 0xa6, 0x6b, 0x37, 0xe4, 0xda, 0x94, 0xea, 0x65, 0x2d, 0x29, 0x2a, 0x2b, 0xf2, 0x23,
-	0x61, 0x8a, 0x6c, 0x41, 0xc1, 0xd6, 0xdc, 0xc7, 0x19, 0x6e, 0x1e, 0xed, 0x4b, 0x68, 0x49, 0x50,
-	0x5c, 0x64, 0x71, 0xdf, 0x63, 0x45, 0x16, 0x42, 0x8e, 0x44, 0xd9, 0x85, 0x10, 0xfc, 0xa4, 0xd5,
-	0x2c, 0xea, 0xda, 0xa1, 0x5c, 0xcc, 0xa9, 0x81, 0x10, 0x5e, 0xf5, 0xd7, 0xf4, 0x6e, 0x02, 0xfe,
-	0x0c, 0xa1, 0xda, 0x0e, 0x5c, 0x90, 0xca, 0x39, 0xb5, 0xb4, 0x53, 0x4a, 0xb5, 0x6a, 0xba, 0x54,
-	0xfb, 0x4f, 0x1d, 0x56, 0xb3, 0x26, 0x79, 0x3b, 0x57, 0xa9, 0x0d, 0x12, 0x75, 0x66, 0xf9, 0x29,
-	0x11, 0xf6, 0x95, 0xf8, 0x10, 0x57, 0x33, 0x1a, 0x91, 0xe7, 0x5c, 0x1c, 0x6c, 0x2a, 0xcf, 0xc4,
-	0x9b, 0xcd, 0x30, 0x20, 0xc4, 0xfd, 0x0c, 0x31, 0xa4, 0xd2, 0x9b, 0xc1, 0x11, 0x3d, 0x36, 0x14,
-	0xcc, 0xbe, 0xc9, 0x35, 0x68, 0xd3, 0xf4, 0x06, 0xab, 0x2b, 0x5a, 0xe8, 0xb1, 0x63, 0xd2, 0xd2,
-	0x41, 0x80, 0xb0, 0xcc, 0x23, 0x2f, 0xc1, 0x92, 0xed, 0x9e, 0xc4, 0xb1, 0x34, 0x69, 0x78, 0xc4,
-	0xc1, 0x43, 0x67, 0xd3, 0x68, 0xb0, 0xc6, 0x8c, 0xb6, 0x23, 0xe2, 0x44, 0xa7, 0x2b, 0x11, 0x59,
-	0x97, 0x42, 0x17, 0xb3, 0xe4, 0x03, 0x19, 0xda, 0x9b, 0x99, 0xe0, 0x9c, 0xd1, 0x54, 0x61, 0x7c,
-	0xbf, 0x95, 0x8e, 0xef, 0x2d, 0x46, 0xe2, 0xd5, 0x52, 0x12, 0xa7, 0xd7, 0x6f, 0x57, 0x01, 0xfc,
-	0xc0, 0x39, 0x71, 0xa6, 0xf6, 0x91, 0x6d, 0xf5, 0x81, 0x35, 0x18, 0x14, 0x08, 0x6b, 0x5a, 0x89,
-	0x26, 0x88, 0x11, 0x78, 0x5e, 0xf4, 0x30, 0xec, 0xb7, 0x79, 0xe3, 0x23, 0x06, 0xeb, 0x0c, 0x4a,
-	0xfb, 0x14, 0xb4, 0x50, 0x66, 0x9d, 0x95, 0x15, 0x9e, 0x9f, 0xe3, 0x98, 0x35, 0x56, 0xd6, 0xe9,
-	0xc5, 0x68, 0x39, 0x6e, 0xbf, 0xc3, 0x56, 0xf2, 0x01, 0x8d, 0x77, 0xec, 0xc3, 0xf0, 0x5c, 0x2c,
-	0xfe, 0xbb, 0x6c, 0xaa, 0xc5, 0x20, 0x77, 0x11, 0x40, 0xbd, 0x36, 0x8a, 0x16, 0xfd, 0x55, 0x06,
-	0xa7, 0x9f, 0xe4, 0xc7, 0x71, 0xf2, 0xd9, 0x63, 0xd6, 0xbf, 0x52, 0x72, 0x88, 0x9f, 0x99, 0x4a,
-	0xf3, 0xaf, 0x15, 0xd8, 0xd8, 0x65, 0xd7, 0xb9, 0x12, 0x60, 0xce, 0x51, 0x29, 0x91, 0x37, 0x65,
-	0x49, 0x9a, 0x2d, 0x6b, 0xb2, 0x9b, 0x15, 0x78, 0xe4, 0x63, 0xe8, 0xc6, 0x34, 0xc5, 0xca, 0xda,
-	0x77, 0x15, 0xb3, 0x9d, 0x50, 0x1d, 0x6a, 0x1f, 0xc0, 0x66, 0x4e, 0x66, 0x71, 0xf5, 0x5e, 0xc7,
-	0x40, 0x28, 0x7b, 0x6c, 0x52, 0xe4, 0xb6, 0x84, 0x61, 0x6d, 0xf7, 0x1e, 0x2d, 0x69, 0xcd, 0x20,
-	0xca, 0x6d, 0xf8, 0x0c, 0x6b, 0x59, 0x3d, 0x9b, 0x5e, 0x2b, 0x4a, 0xce, 0x31, 0xac, 0xd3, 0x4a,
-	0xf7, 0x29, 0x88, 0xd2, 0x38, 0x40, 0xb7, 0xed, 0xcd, 0x23, 0x11, 0xff, 0xe2, 0xa1, 0xb6, 0xc9,
-	0xab, 0xef, 0x3c, 0xb7, 0xf7, 0x61, 0x83, 0x17, 0xbf, 0x4f, 0xb3, 0x89, 0x4b, 0x71, 0xe9, 0x9d,
-	0xa7, 0xfb, 0xbb, 0xaa, 0x12, 0x08, 0x4b, 0xb2, 0xf5, 0x37, 0xd2, 0xd9, 0xfa, 0x66, 0xde, 0xe0,
-	0xa9, 0x0c, 0x32, 0xef, 0x46, 0xb5, 0x02, 0x37, 0xd2, 0x73, 0x29, 0xfd, 0x12, 0x0b, 0x19, 0xaf,
-	0xe5, 0xa9, 0xff, 0x1f, 0x33, 0xfa, 0x03, 0x9e, 0xd1, 0x4b, 0xd6, 0xb2, 0x8b, 0xf0, 0x66, 0x26,
-	0xa3, 0xef, 0x97, 0x89, 0x29, 0x13, 0xfa, 0xdf, 0x2e, 0x41, 0x4b, 0xce, 0xe5, 0x74, 0x9a, 0x57,
-	0x52, 0xb5, 0x40, 0x49, 0xea, 0x95, 0x54, 0x7b, 0x9a, 0x2b, 0x69, 0xe9, 0xbb, 0xae, 0x24, 0x4c,
-	0xfe, 0xd8, 0x87, 0x11, 0xd8, 0x0f, 0xc5, 0x15, 0xd3, 0x64, 0x00, 0xdd, 0x7e, 0x98, 0x18, 0xbe,
-	0x71, 0x26, 0xc3, 0xa7, 0x4b, 0x87, 0xe5, 0x6c, 0xe9, 0xf0, 0x76, 0xe6, 0x7e, 0xb9, 0x9a, 0x27,
-	0x57, 0x78, 0xb3, 0xec, 0x17, 0xdd, 0x2c, 0x2f, 0x14, 0x2c, 0x7e, 0x66, 0x0b, 0x87, 0xdb, 0xbc,
-	0x70, 0x50, 0xbd, 0x4a, 0x44, 0xaf, 0x21, 0xaa, 0x4c, 0x42, 0x45, 0xf5, 0x40, 0xf2, 0x5b, 0xd3,
-	0x15, 0x2c, 0x1a, 0x0a, 0x52, 0xfa, 0x4f, 0x5a, 0x5d, 0x67, 0x08, 0x05, 0x7f, 0x51, 0x13, 0x9f,
-	0x92, 0x9e, 0xd0, 0xdb, 0xb9, 0x5a, 0xf3, 0x6c, 0x5e, 0xf7, 0x46, 0xba, 0xd4, 0x3c, 0x9f, 0xbb,
-	0xe4, 0x2a, 0x4d, 0x76, 0x13, 0x63, 0xe4, 0xe5, 0xd3, 0xbc, 0x48, 0x68, 0x09, 0x08, 0x4e, 0x63,
-	0x76, 0xf4, 0xd0, 0x71, 0x9d, 0xf0, 0x98, 0xcf, 0x37, 0xd8, 0x3c, 0xc4, 0xa0, 0x1d, 0xf6, 0x78,
-	0x63, 0x3f, 0xc1, 0x92, 0x64, 0xe2, 0x59, 0x36, 0x73, 0xc6, 0xba, 0xde, 0xa4, 0x80, 0x5d, 0x1c,
-	0x27, 0x07, 0xa4, 0x79, 0xae, 0x03, 0xd2, 0xca, 0x1c, 0x90, 0x0d, 0x68, 0xa0, 0xbc, 0xa1, 0xe7,
-	0xb2, 0x1c, 0xa5, 0xa5, 0x8b, 0x11, 0x0d, 0xf0, 0x33, 0x3b, 0x0c, 0x29, 0x83, 0x36, 0xcf, 0x3a,
-	0xc4, 0x50, 0x49, 0xb2, 0x56, 0xca, 0x92, 0xac, 0x53, 0x9a, 0x4e, 0x99, 0x24, 0xab, 0x53, 0x96,
-	0x64, 0x9d, 0xa5, 0xe7, 0xa4, 0xe4, 0x85, 0xdd, 0xd3, 0xf2, 0xc2, 0x1f, 0xf2, 0xe0, 0xdc, 0xc2,
-	0x7b, 0x3f, 0xeb, 0xea, 0xe2, 0xe4, 0xbc, 0x99, 0x69, 0x4d, 0xf5, 0xcb, 0xb4, 0x20, 0x3b, 0x53,
-	0xbf, 0x82, 0xd5, 0xfd, 0x27, 0xf6, 0x64, 0xbc, 0x70, 0x27, 0xe7, 0xb8, 0xab, 0x51, 0xdc, 0xc9,
-	0xcc, 0x12, 0x05, 0x1e, 0xfd, 0x54, 0x6f, 0xef, 0x5a, 0xfa, 0xf6, 0x36, 0xa0, 0x97, 0x70, 0x10,
-	0x72, 0x6e, 0x50, 0x39, 0x2d, 0x8a, 0x4c, 0x89, 0xaf, 0xe8, 0x62, 0x24, 0xe0, 0x76, 0x10, 0xb0,
-	0x5d, 0x73, 0x38, 0x8e, 0xd2, 0x6e, 0x5b, 0x4b, 0xbb, 0xad, 0xf6, 0x08, 0xda, 0x94, 0xc1, 0xf7,
-	0x12, 0x5f, 0xa4, 0xb0, 0xb5, 0x24, 0x85, 0x95, 0x99, 0xf0, 0x92, 0x92, 0x09, 0x6b, 0x5b, 0xb0,
-	0xc2, 0x79, 0x89, 0x8d, 0xd0, 0x12, 0x2e, 0x98, 0xc6, 0x76, 0xc3, 0x4f, 0xed, 0xe7, 0xd0, 0xd9,
-	0x89, 0x22, 0x73, 0x72, 0x7c, 0x0e, 0x79, 0x24, 0xaf, 0xaa, 0xca, 0x4b, 0x83, 0x6e, 0x4c, 0xa9,
-	0x94, 0xdb, 0x88, 0xbe, 0xe8, 0x05, 0xd1, 0xa7, 0x5e, 0xf0, 0xad, 0x19, 0x58, 0xe7, 0xcb, 0x59,
-	0xb1, 0xbc, 0x12, 0xaf, 0xbc, 0x35, 0xd4, 0x27, 0xfb, 0xd6, 0x5e, 0x86, 0xb5, 0x14, 0xbd, 0x52,
-	0xc6, 0xef, 0x40, 0x9b, 0x45, 0x05, 0x91, 0x1d, 0xbd, 0xa2, 0xf6, 0x6c, 0x4e, 0x0b, 0x1d, 0xb4,
-	0x4e, 0xa5, 0x61, 0x9f, 0xc1, 0x65, 0x8c, 0x7e, 0x3d, 0x93, 0x48, 0xac, 0xa7, 0xd7, 0x67, 0x92,
-	0x88, 0xc7, 0x50, 0x67, 0xe0, 0x5c, 0x8c, 0xbe, 0x4c, 0xfb, 0x07, 0xbe, 0x67, 0x44, 0xe6, 0x91,
-	0x7c, 0x37, 0xa7, 0x80, 0x7b, 0x38, 0x66, 0xcf, 0xfe, 0x74, 0xd2, 0x72, 0x90, 0x71, 0x14, 0x3f,
-	0x9e, 0xb7, 0x29, 0x6c, 0x8f, 0x83, 0xa8, 0x46, 0x42, 0xe7, 0xd7, 0x3c, 0x41, 0x58, 0xd2, 0xd9,
-	0x37, 0x66, 0xd9, 0x44, 0x95, 0x57, 0x28, 0x04, 0xc3, 0x04, 0xdb, 0x4e, 0x7c, 0x3d, 0x75, 0xd3,
-	0x02, 0xeb, 0x62, 0x56, 0xbb, 0x09, 0x84, 0x6b, 0x20, 0x75, 0x25, 0x9d, 0x5d, 0x5b, 0xef, 0xc3,
-	0x5a, 0x6a, 0xbd, 0x7c, 0xb5, 0x4a, 0x11, 0xc8, 0x72, 0x17, 0x8b, 0xff, 0x59, 0x01, 0xd8, 0x99,
-	0x47, 0xc7, 0xa2, 0x94, 0x1f, 0x40, 0x93, 0xf6, 0x20, 0x94, 0x86, 0x80, 0x1c, 0xd3, 0x39, 0xdf,
-	0x0c, 0x43, 0xac, 0xa3, 0xe3, 0x9c, 0x4b, 0x8e, 0x59, 0x19, 0x8e, 0x54, 0xe2, 0xf6, 0x11, 0xfd,
-	0xa6, 0x8f, 0xf8, 0xfc, 0x5f, 0x05, 0xc3, 0xb4, 0xac, 0x00, 0xc3, 0xb8, 0xe8, 0x23, 0x75, 0x38,
-	0x74, 0x87, 0x03, 0x29, 0x9a, 0x63, 0xd9, 0x28, 0x5a, 0xb4, 0x30, 0x22, 0xef, 0xb1, 0xed, 0x8a,
-	0x6c, 0xaa, 0x13, 0x43, 0xef, 0x51, 0x20, 0x45, 0x0b, 0xec, 0x23, 0xd4, 0x72, 0x10, 0xa3, 0x35,
-	0x38, 0x5a, 0x0c, 0x65, 0x68, 0xf4, 0x37, 0x8f, 0xde, 0xe1, 0x7c, 0x3a, 0xe5, 0x9b, 0x3c, 0xaf,
-	0x2e, 0xb1, 0x3e, 0xe6, 0xfb, 0xc8, 0x76, 0x85, 0x12, 0x15, 0x89, 0xcd, 0x7d, 0xff, 0xd2, 0x6c,
-	0x0d, 0x2e, 0x28, 0x82, 0x8a, 0xaa, 0x02, 0x7d, 0x81, 0x17, 0x1c, 0x4f, 0x27, 0xbf, 0x76, 0x11,
-	0xd6, 0x52, 0xeb, 0x05, 0xd9, 0x6d, 0xe8, 0x88, 0x27, 0x20, 0x61, 0x67, 0x2c, 0xef, 0xe9, 0xe9,
-	0x9f, 0x38, 0x56, 0xdc, 0x1a, 0x5c, 0xc6, 0xf1, 0x2e, 0x0e, 0x31, 0x5c, 0x74, 0x74, 0x4e, 0x5e,
-	0xe0, 0x7e, 0x08, 0x5d, 0xf1, 0x60, 0x64, 0xa4, 0x9e, 0x54, 0x93, 0xbe, 0x57, 0x8a, 0xb6, 0xde,
-	0x71, 0xd5, 0xa1, 0xf6, 0x35, 0x0c, 0xee, 0xfb, 0x16, 0x4d, 0x5f, 0x54, 0xaa, 0xf1, 0xd6, 0x90,
-	0x78, 0xfc, 0x73, 0x4c, 0x09, 0xf1, 0xf4, 0xb2, 0x4e, 0xa0, 0x0e, 0xb5, 0x2b, 0x70, 0xb9, 0x90,
-	0x38, 0xdf, 0xf7, 0xf6, 0xf3, 0xd0, 0x8c, 0x7f, 0x62, 0x21, 0xcb, 0x50, 0xbb, 0xb7, 0x7b, 0xd8,
-	0x7b, 0x8e, 0x7e, 0xdc, 0xdf, 0x3b, 0xec, 0x55, 0xb6, 0xb7, 0x61, 0x35, 0xd3, 0xcb, 0x27, 0x2d,
-	0xa8, 0xeb, 0xfb, 0x3b, 0x7b, 0x5f, 0x21, 0xda, 0x0a, 0x34, 0x47, 0x77, 0xef, 0xf1, 0x51, 0x65,
-	0x7b, 0x17, 0xba, 0xe9, 0x64, 0x8c, 0xb4, 0x61, 0x79, 0x17, 0x67, 0xef, 0xed, 0xef, 0x21, 0x32,
-	0x0e, 0xf4, 0xfb, 0xa3, 0xd1, 0xc1, 0xe8, 0xb3, 0x5e, 0x85, 0x00, 0x34, 0xf6, 0xbf, 0x3c, 0xa0,
-	0x13, 0x55, 0x3a, 0x71, 0x7f, 0x74, 0x6b, 0x74, 0xf7, 0x97, 0xa3, 0x5e, 0x6d, 0xf8, 0x6f, 0x80,
-	0xae, 0x10, 0x74, 0x8c, 0x67, 0xc0, 0x99, 0xd8, 0xe4, 0x26, 0x2c, 0xc7, 0xff, 0x09, 0x25, 0x69,
-	0x5f, 0xfa, 0xa7, 0xa6, 0x41, 0x3f, 0x3f, 0x21, 0xec, 0xfa, 0x1c, 0x39, 0x64, 0xd6, 0x52, 0xde,
-	0x3f, 0xae, 0xa8, 0x8a, 0xcb, 0x3d, 0xb0, 0x0c, 0xae, 0x96, 0x4d, 0x4b, 0x8a, 0x63, 0xe8, 0xa6,
-	0x1f, 0xa2, 0x49, 0xb2, 0xa6, 0xf0, 0x81, 0x7b, 0x70, 0xad, 0x74, 0x5e, 0x12, 0xfd, 0x0a, 0x7a,
-	0xd9, 0x27, 0x68, 0x92, 0xb4, 0x6d, 0x4b, 0x9e, 0xb7, 0x07, 0xd7, 0x4f, 0xc1, 0x50, 0x49, 0xe7,
-	0x1e, 0x6b, 0xb7, 0xca, 0x9f, 0xdb, 0x72, 0xa4, 0xcb, 0xde, 0xf0, 0xb8, 0x2a, 0xd2, 0xef, 0x16,
-	0x44, 0x7d, 0x22, 0x2d, 0x78, 0xbf, 0x52, 0x54, 0x51, 0xfc, 0xe0, 0x81, 0x44, 0xbf, 0xc0, 0x3a,
-	0x22, 0xdd, 0x92, 0x21, 0xc9, 0xaa, 0xe2, 0x06, 0xd3, 0x60, 0xab, 0x1c, 0x21, 0x6d, 0x37, 0xb5,
-	0xe1, 0x92, 0xb2, 0x5b, 0x41, 0x17, 0x27, 0x65, 0xb7, 0xc2, 0x4e, 0x0d, 0x73, 0xaf, 0x54, 0x5b,
-	0x45, 0x71, 0xaf, 0xa2, 0x1e, 0xce, 0xe0, 0x6a, 0xd9, 0xb4, 0xba, 0xfd, 0x4c, 0x4b, 0x45, 0xd9,
-	0x7e, 0x71, 0xa7, 0x66, 0xb0, 0x55, 0x8e, 0x90, 0xb5, 0x55, 0x52, 0x2a, 0x66, 0x6c, 0x95, 0xeb,
-	0x4c, 0x64, 0x6c, 0x95, 0xaf, 0x31, 0x85, 0xad, 0x32, 0x35, 0xdf, 0xb5, 0xd2, 0x74, 0x39, 0x6f,
-	0xab, 0xe2, 0x0c, 0x1c, 0xe9, 0xee, 0x40, 0x33, 0xce, 0x77, 0x49, 0x72, 0xba, 0x33, 0x49, 0xf6,
-	0xe0, 0x52, 0xc1, 0x8c, 0x24, 0xf1, 0x53, 0x58, 0xa2, 0x50, 0xb2, 0x9e, 0x42, 0x8a, 0x97, 0x5e,
-	0xcc, 0x40, 0xe5, 0xb2, 0xf7, 0xa1, 0xc1, 0x13, 0x46, 0x92, 0x44, 0xd8, 0x54, 0x2e, 0x3a, 0xd8,
-	0xcc, 0xc1, 0xe5, 0xe2, 0xcf, 0xf9, 0xbf, 0x83, 0x22, 0xf3, 0x23, 0x97, 0x53, 0x7f, 0x37, 0xa5,
-	0xf3, 0xcb, 0xc1, 0xf3, 0xc5, 0x93, 0x92, 0xd6, 0x03, 0x58, 0x2b, 0x88, 0xdc, 0x24, 0x69, 0x4f,
-	0x94, 0x5f, 0x1a, 0x83, 0x17, 0x4f, 0x47, 0x8a, 0x79, 0x0c, 0xff, 0x56, 0x85, 0x15, 0x7e, 0x45,
-	0x8a, 0x68, 0xfb, 0x19, 0x40, 0x92, 0xa8, 0x91, 0x41, 0xca, 0x01, 0x52, 0xd9, 0xe6, 0xe0, 0x72,
-	0xe1, 0x9c, 0xaa, 0x09, 0x25, 0xe7, 0x52, 0x34, 0x91, 0xcf, 0xe4, 0x14, 0x4d, 0x14, 0xa4, 0x69,
-	0x48, 0x6b, 0x0f, 0x5a, 0x32, 0x11, 0x20, 0x4a, 0xfe, 0x90, 0xc9, 0x62, 0x06, 0x83, 0xa2, 0x29,
-	0x55, 0x22, 0xe5, 0xe6, 0x57, 0x24, 0xca, 0xe7, 0x13, 0x8a, 0x44, 0x45, 0xc9, 0xc2, 0x73, 0xff,
-	0x0b, 0x00, 0x00, 0xff, 0xff, 0x27, 0xd9, 0x1b, 0x77, 0x6c, 0x2b, 0x00, 0x00,
+	// 3133 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x3a, 0x4d, 0x73, 0x1b, 0xc7,
+	0xb1, 0x04, 0xc0, 0x0f, 0xa0, 0x41, 0x80, 0xe0, 0x90, 0x22, 0x21, 0xd0, 0x92, 0xa8, 0xb5, 0x65,
+	0x4b, 0xb2, 0xad, 0xb2, 0xf0, 0xde, 0xb3, 0x9e, 0x65, 0x4b, 0x36, 0x4c, 0xd2, 0x0e, 0x2d, 0x09,
+	0x62, 0x06, 0x92, 0x63, 0x97, 0x0f, 0x9b, 0x15, 0x76, 0x04, 0xae, 0x04, 0xec, 0xae, 0x67, 0x07,
+	0xb4, 0x98, 0x6b, 0x2e, 0x39, 0xe4, 0x90, 0x6b, 0x6e, 0x39, 0xa4, 0xca, 0x87, 0xdc, 0x52, 0x95,
+	0xaa, 0xfc, 0x87, 0x54, 0x7e, 0x48, 0x0e, 0x39, 0x27, 0xc7, 0xd4, 0x7c, 0xec, 0xec, 0xec, 0x07,
+	0x68, 0x52, 0xae, 0x8a, 0x75, 0xdb, 0xe9, 0xe9, 0xee, 0xe9, 0xe9, 0xee, 0xe9, 0xe9, 0xee, 0x59,
+	0xa8, 0x39, 0xa1, 0x77, 0x23, 0xa4, 0x01, 0x0b, 0xd0, 0x12, 0x9d, 0xfa, 0xcc, 0x9b, 0x10, 0xeb,
+	0x3a, 0x34, 0xbf, 0x24, 0x34, 0xf2, 0x02, 0x1f, 0x93, 0x6f, 0xa7, 0x24, 0x62, 0xa8, 0x0d, 0x4b,
+	0x47, 0x12, 0xd2, 0x2e, 0x6d, 0x97, 0xae, 0xd6, 0x70, 0x3c, 0xb4, 0xbe, 0x2f, 0xc1, 0x8a, 0x46,
+	0x8e, 0xc2, 0xc0, 0x8f, 0xc8, 0x6c, 0x6c, 0x74, 0x19, 0x96, 0xd5, 0x22, 0xb6, 0xef, 0x4c, 0x48,
+	0xbb, 0x2c, 0xa6, 0xeb, 0x0a, 0xd6, 0x77, 0x26, 0x04, 0xbd, 0x05, 0x2b, 0x31, 0x4a, 0xcc, 0xa4,
+	0x22, 0xb0, 0x9a, 0x0a, 0xac, 0x56, 0x43, 0x37, 0x60, 0x2d, 0x46, 0x74, 0x42, 0x4f, 0x23, 0xcf,
+	0x0b, 0xe4, 0x55, 0x35, 0xd5, 0x0b, 0x3d, 0x85, 0x6f, 0x7d, 0x03, 0xb5, 0xdd, 0xfe, 0x60, 0x27,
+	0xf0, 0x9f, 0x7a, 0x23, 0x2e, 0x62, 0x44, 0x28, 0xa7, 0x69, 0x97, 0xb6, 0x2b, 0x5c, 0x44, 0x35,
+	0x44, 0x1d, 0xa8, 0x46, 0xc4, 0xa1, 0xc3, 0x43, 0x12, 0xb5, 0xcb, 0x62, 0x4a, 0x8f, 0x39, 0x55,
+	0x10, 0x32, 0x2f, 0xf0, 0xa3, 0x76, 0x45, 0x52, 0xa9, 0xa1, 0xf5, 0xfb, 0x12, 0xd4, 0x0f, 0x02,
+	0xca, 0x1e, 0x38, 0x61, 0xe8, 0xf9, 0x23, 0xf4, 0x2e, 0x54, 0x85, 0x52, 0x87, 0xc1, 0x58, 0xe8,
+	0xa0, 0xd9, 0x5d, 0xbd, 0xa1, 0x44, 0xba, 0x71, 0xa0, 0x26, 0xb0, 0x46, 0x41, 0x57, 0xa0, 0x39,
+	0x0c, 0x7c, 0xe6, 0x78, 0x3e, 0xa1, 0x76, 0x18, 0x50, 0x26, 0x34, 0xb3, 0x80, 0x1b, 0x1a, 0xca,
+	0x99, 0xa3, 0x2d, 0xa8, 0x1d, 0x06, 0x11, 0x93, 0x18, 0x15, 0x81, 0x51, 0xe5, 0x00, 0x31, 0xb9,
+	0x09, 0x4b, 0x62, 0xd2, 0x0b, 0x95, 0x0e, 0x16, 0xf9, 0x70, 0x3f, 0xb4, 0x7e, 0x57, 0x82, 0x85,
+	0x07, 0xc1, 0xd4, 0x67, 0x99, 0x65, 0x1c, 0x76, 0xa8, 0xec, 0x63, 0x2c, 0xe3, 0xb0, 0xc3, 0x64,
+	0x19, 0x8e, 0x21, 0x4d, 0x24, 0x97, 0xe1, 0x93, 0x1d, 0xa8, 0x52, 0xe2, 0xb8, 0x81, 0x3f, 0x3e,
+	0x16, 0x22, 0x54, 0xb1, 0x1e, 0x73, 0xdb, 0x45, 0x64, 0xec, 0xf9, 0xd3, 0x17, 0x36, 0x25, 0x63,
+	0xe7, 0x09, 0x19, 0x0b, 0x51, 0xaa, 0xb8, 0xa9, 0xc0, 0x58, 0x42, 0xad, 0x67, 0xb0, 0xc2, 0x8d,
+	0x1d, 0x85, 0xce, 0x90, 0x3c, 0x14, 0x2a, 0xe4, 0xae, 0x21, 0x16, 0xf5, 0x09, 0xfb, 0x2e, 0xa0,
+	0xcf, 0x85, 0x64, 0x55, 0x5c, 0xe7, 0xb0, 0xbe, 0x04, 0xa1, 0xf3, 0x50, 0x95, 0x72, 0x79, 0xae,
+	0x10, 0xab, 0x8a, 0xc5, 0x8e, 0x0f, 0x3c, 0x57, 0x4f, 0x79, 0xe1, 0x50, 0x49, 0xb5, 0x24, 0x77,
+	0x3f, 0xb4, 0x7e, 0x5d, 0x82, 0x73, 0xf7, 0xf9, 0xe2, 0x07, 0x81, 0x3b, 0x70, 0x7c, 0xf7, 0x49,
+	0xf0, 0x42, 0x39, 0xc1, 0xeb, 0xd0, 0x18, 0x8e, 0x68, 0x30, 0x0d, 0xed, 0xd0, 0xa1, 0xc4, 0x67,
+	0x4a, 0x1b, 0xcb, 0x12, 0x78, 0x20, 0x60, 0x68, 0x0f, 0x56, 0xfd, 0x58, 0x54, 0x3b, 0xb6, 0x3e,
+	0x5f, 0xbd, 0xde, 0x6d, 0x6b, 0x93, 0x66, 0x36, 0x83, 0x5b, 0x7e, 0x1a, 0x10, 0x59, 0x14, 0x50,
+	0xb2, 0xfe, 0x03, 0xc2, 0x1c, 0xd7, 0x61, 0x0e, 0x42, 0x30, 0x2f, 0xce, 0x81, 0x5c, 0x58, 0x7c,
+	0xa3, 0x16, 0x54, 0xa6, 0x6a, 0x83, 0x35, 0xcc, 0x3f, 0xd1, 0x6b, 0x50, 0xd3, 0xfc, 0xd4, 0x61,
+	0x48, 0x00, 0xdc, 0x29, 0x1d, 0xc6, 0xc8, 0x24, 0x64, 0x42, 0xd9, 0x0d, 0x1c, 0x0f, 0xad, 0xbf,
+	0xce, 0x43, 0x2b, 0xb7, 0xe9, 0x5b, 0x50, 0x9d, 0xa8, 0xe5, 0xc5, 0xb2, 0xf5, 0xee, 0x56, 0xe2,
+	0x99, 0x39, 0x09, 0xb1, 0x46, 0xe6, 0x86, 0xe7, 0x2a, 0x35, 0xce, 0xad, 0x1e, 0x73, 0x4d, 0x8e,
+	0x83, 0x91, 0xed, 0x7a, 0x94, 0x0c, 0x59, 0x40, 0x8f, 0x95, 0x94, 0xcb, 0xe3, 0x60, 0xb4, 0x1b,
+	0xc3, 0xd0, 0x4d, 0x00, 0xd7, 0x8f, 0xec, 0xa1, 0x90, 0x43, 0xc8, 0x5a, 0xef, 0x22, 0xbd, 0xb6,
+	0x3e, 0x9b, 0xb8, 0xe6, 0xfa, 0x91, 0x12, 0xf6, 0x03, 0x68, 0x70, 0x5f, 0xb7, 0x27, 0xf2, 0x58,
+	0x45, 0xed, 0x85, 0xed, 0xca, 0xd5, 0x7a, 0x77, 0xdd, 0x90, 0x58, 0x9f, 0x39, 0xbc, 0x1c, 0x26,
+	0x83, 0x08, 0xdd, 0x81, 0x45, 0xe1, 0x6b, 0x51, 0x7b, 0x51, 0xd0, 0x5c, 0x29, 0xd8, 0xa5, 0x5c,
+	0xe5, 0xc6, 0x7d, 0x81, 0xb7, 0xe7, 0x33, 0x7a, 0x8c, 0x15, 0x11, 0xba, 0x0f, 0x75, 0xc7, 0xf7,
+	0x03, 0xe6, 0x48, 0x83, 0x2f, 0x09, 0x1e, 0xd7, 0x67, 0xf3, 0xe8, 0x25, 0xc8, 0x92, 0x91, 0x49,
+	0x8e, 0xfe, 0x17, 0x16, 0x84, 0xff, 0xb7, 0xab, 0x62, 0xd7, 0x17, 0x35, 0x9f, 0x42, 0xc7, 0xc4,
+	0x12, 0xb9, 0xf3, 0x01, 0xd4, 0x0d, 0xd1, 0xb8, 0x63, 0x3c, 0x27, 0xc7, 0xca, 0x57, 0xf8, 0x27,
+	0x5a, 0x87, 0x85, 0x23, 0x67, 0x3c, 0x8d, 0xed, 0x21, 0x07, 0xb7, 0xcb, 0xff, 0x5f, 0xea, 0xdc,
+	0x85, 0x56, 0x56, 0xa2, 0xb3, 0xd0, 0x5b, 0xfb, 0xb0, 0x8e, 0xa7, 0x7e, 0x22, 0x58, 0x7c, 0x11,
+	0xdc, 0x84, 0x45, 0x65, 0x3f, 0xe9, 0x3b, 0xe7, 0x67, 0x6a, 0x04, 0x2b, 0x44, 0xeb, 0x0e, 0x9c,
+	0xcb, 0xb0, 0x52, 0xd7, 0xc4, 0x1b, 0xd0, 0x0c, 0x03, 0xd7, 0x8e, 0x24, 0xd8, 0xf6, 0xdc, 0xf8,
+	0xfc, 0x85, 0x1a, 0x77, 0xdf, 0xe5, 0xe4, 0x03, 0x16, 0x84, 0x79, 0x51, 0x4e, 0x47, 0xde, 0x86,
+	0x8d, 0x2c, 0xb9, 0x5c, 0xde, 0xfa, 0x18, 0x36, 0x31, 0x99, 0x04, 0x47, 0xe4, 0x65, 0x59, 0x77,
+	0xa0, 0x9d, 0x67, 0x90, 0x30, 0x4f, 0xa0, 0x03, 0xe6, 0xb0, 0x69, 0x74, 0x36, 0xe6, 0xd7, 0x4c,
+	0x06, 0x2a, 0x00, 0x4a, 0x3e, 0xa8, 0x09, 0x65, 0x2f, 0x54, 0x44, 0x65, 0x2f, 0xb4, 0xbe, 0x86,
+	0x5a, 0xdf, 0x8c, 0x06, 0x66, 0x04, 0xad, 0xe1, 0x78, 0x88, 0xba, 0xc9, 0xe5, 0xf5, 0x43, 0xe1,
+	0x4b, 0x5f, 0x6b, 0xf7, 0x72, 0xa1, 0x53, 0xc9, 0xd0, 0x05, 0xd0, 0x11, 0x28, 0x52, 0xbe, 0x80,
+	0xf2, 0xfc, 0xb0, 0x81, 0x65, 0xfd, 0x31, 0x15, 0x8e, 0x8c, 0xcd, 0xb8, 0x7a, 0x33, 0x6e, 0x2a,
+	0x3c, 0x95, 0xcf, 0x12, 0x9e, 0x6e, 0xc0, 0x42, 0xc4, 0x1c, 0x26, 0x03, 0x64, 0xd3, 0xd8, 0x5c,
+	0x7a, 0x49, 0x82, 0x25, 0x1a, 0xba, 0x00, 0x30, 0xa4, 0xc4, 0x61, 0xc4, 0xb5, 0x1d, 0x19, 0x39,
+	0x2b, 0xb8, 0xa6, 0x20, 0x3d, 0x86, 0x6e, 0x27, 0x7a, 0x5c, 0x10, 0x62, 0x6c, 0x17, 0x30, 0x4c,
+	0xd9, 0x25, 0xd1, 0xb4, 0x3e, 0xed, 0x8b, 0x27, 0x9f, 0x76, 0x45, 0x27, 0x91, 0x8d, 0x80, 0xb5,
+	0x34, 0x33, 0x60, 0x49, 0x8a, 0xd3, 0x04, 0xac, 0xea, 0xcc, 0x80, 0xa5, 0x78, 0x9c, 0x18, 0xb0,
+	0x7e, 0xca, 0xd0, 0xf3, 0x00, 0xda, 0xf9, 0xa3, 0xa3, 0x42, 0xc6, 0x4d, 0x58, 0x8c, 0x04, 0xe4,
+	0x84, 0xf0, 0xa3, 0x48, 0x14, 0xa2, 0xf5, 0x8f, 0x92, 0xe9, 0x75, 0x9f, 0x79, 0x63, 0x46, 0x68,
+	0xce, 0xeb, 0xb4, 0xf3, 0x94, 0x4f, 0xe7, 0x3c, 0x03, 0x68, 0x0a, 0xb5, 0xdb, 0x11, 0x19, 0x8b,
+	0xdb, 0x4d, 0xe4, 0x83, 0xf5, 0xee, 0x3b, 0x05, 0x84, 0x72, 0x49, 0x69, 0xb3, 0x81, 0x42, 0x97,
+	0x1a, 0x6f, 0x8c, 0x4d, 0x58, 0xe7, 0x13, 0x40, 0x79, 0xa4, 0x33, 0xa9, 0xee, 0x0b, 0x7e, 0x5c,
+	0x79, 0x3a, 0x58, 0x10, 0xb6, 0x9f, 0x0a, 0x31, 0x4e, 0xd0, 0x9b, 0x94, 0x13, 0x2b, 0x44, 0xeb,
+	0x0f, 0x15, 0x80, 0x64, 0xf2, 0x95, 0x3d, 0xa7, 0xb7, 0xf4, 0xa9, 0x91, 0xa9, 0xc1, 0xa5, 0x02,
+	0x7e, 0x85, 0xe7, 0xe5, 0xb3, 0xf4, 0x79, 0x91, 0x49, 0xc2, 0x1b, 0x45, 0xd4, 0xaf, 0xec, 0x49,
+	0xd9, 0x81, 0x8d, 0xac, 0xb9, 0xd5, 0x39, 0xb9, 0x06, 0x0b, 0x1e, 0x23, 0x13, 0x59, 0xdc, 0xd4,
+	0xbb, 0x6b, 0x05, 0xdb, 0xc2, 0x12, 0xc3, 0xba, 0x0c, 0xb5, 0xfd, 0x89, 0x33, 0x22, 0x83, 0x90,
+	0x0c, 0xf9, 0x5a, 0x1e, 0x1f, 0xa8, 0xf5, 0xe5, 0xc0, 0xea, 0x42, 0xf5, 0x1e, 0x39, 0xfe, 0x92,
+	0xaf, 0x7b, 0x5a, 0xf9, 0xac, 0xbf, 0x95, 0x60, 0x53, 0x84, 0xbb, 0x9d, 0xb8, 0xb4, 0xc0, 0x24,
+	0x0a, 0xa6, 0x74, 0x48, 0x22, 0x61, 0xd2, 0x70, 0x6a, 0x87, 0x84, 0x7a, 0x81, 0xf4, 0x29, 0x6e,
+	0xd2, 0x70, 0x7a, 0x20, 0x00, 0xbc, 0xfc, 0xe0, 0xd3, 0xdf, 0x4e, 0x03, 0xe5, 0x5b, 0x15, 0x5c,
+	0x1d, 0x86, 0xd3, 0x9f, 0xf3, 0x71, 0x4c, 0x1b, 0x1d, 0x3a, 0x94, 0x44, 0xc2, 0x87, 0x24, 0xed,
+	0x40, 0x00, 0xd0, 0x4d, 0x38, 0x37, 0x21, 0x93, 0x80, 0x1e, 0xdb, 0x63, 0x6f, 0xe2, 0x31, 0xdb,
+	0xf3, 0xed, 0x27, 0xc7, 0x8c, 0x44, 0xca, 0x71, 0x90, 0x9c, 0xbc, 0xcf, 0xe7, 0xf6, 0xfd, 0x4f,
+	0xf9, 0x0c, 0xb2, 0xa0, 0x11, 0x04, 0x13, 0x3b, 0x1a, 0x06, 0x94, 0xd8, 0x8e, 0xfb, 0x4c, 0xc4,
+	0xfb, 0x0a, 0xae, 0x07, 0xc1, 0x64, 0xc0, 0x61, 0x3d, 0xf7, 0x99, 0xe5, 0x40, 0x63, 0xb0, 0x27,
+	0xb6, 0xa3, 0xaa, 0x15, 0x04, 0xf3, 0xd3, 0x48, 0x1d, 0xa7, 0x1a, 0x16, 0xdf, 0x1c, 0x46, 0x83,
+	0x71, 0xac, 0x07, 0xf1, 0xcd, 0x61, 0xec, 0x38, 0x8c, 0xb3, 0x76, 0xf1, 0xcd, 0x15, 0x36, 0x26,
+	0x47, 0xaa, 0x36, 0xaa, 0x61, 0x39, 0xb0, 0x5c, 0x80, 0x1d, 0x27, 0x74, 0x9e, 0x78, 0x63, 0x8f,
+	0x1d, 0xa3, 0x6b, 0xd0, 0x72, 0x5c, 0xd7, 0x1e, 0xc6, 0x10, 0x8f, 0xc4, 0x85, 0xea, 0x8a, 0xe3,
+	0xba, 0x3b, 0x06, 0x18, 0xbd, 0x0d, 0xab, 0x2e, 0x0d, 0xc2, 0x34, 0xae, 0xac, 0x5c, 0x5b, 0x7c,
+	0xc2, 0x44, 0xb6, 0xfe, 0x5d, 0x82, 0xf5, 0xb4, 0x59, 0x54, 0xa6, 0x7d, 0x17, 0x6a, 0x34, 0x36,
+	0x90, 0x0a, 0x12, 0xdb, 0xe9, 0x7b, 0x2b, 0x6f, 0x48, 0x9c, 0x90, 0xa0, 0x5b, 0xb0, 0x9c, 0x11,
+	0xa0, 0x94, 0x72, 0xbc, 0x64, 0x6f, 0x38, 0x85, 0x88, 0x3e, 0x4e, 0x6a, 0xc6, 0xa4, 0xb6, 0xe6,
+	0xb4, 0x1b, 0x9a, 0x36, 0xa5, 0x7a, 0x5d, 0x4b, 0xaa, 0xca, 0x0a, 0xbd, 0xa9, 0x4c, 0x91, 0x2d,
+	0x28, 0x04, 0xcd, 0xe3, 0x88, 0x50, 0x69, 0x1e, 0xeb, 0x2b, 0xa8, 0x69, 0x50, 0x5c, 0x64, 0x49,
+	0xdf, 0x13, 0x45, 0x56, 0x0b, 0x2a, 0x23, 0x55, 0x76, 0x55, 0x30, 0xff, 0xe4, 0xd5, 0xac, 0xe3,
+	0xba, 0x1e, 0x5f, 0xc5, 0x19, 0xdb, 0x23, 0xcf, 0x95, 0x55, 0x7f, 0x05, 0x37, 0x13, 0xf0, 0xe7,
+	0x9e, 0x1b, 0x59, 0x3d, 0x58, 0xd5, 0xca, 0x39, 0xb1, 0xb4, 0x33, 0x4a, 0xb5, 0x72, 0xba, 0x54,
+	0xfb, 0xd7, 0x02, 0xac, 0x64, 0x4d, 0xf2, 0x7e, 0xae, 0x52, 0xeb, 0x24, 0xea, 0xcc, 0xae, 0x67,
+	0x44, 0xd8, 0xab, 0xf1, 0x21, 0x2e, 0x67, 0x34, 0xa2, 0xcf, 0xb9, 0x3a, 0xd8, 0x5c, 0x9e, 0x61,
+	0x30, 0x99, 0x38, 0xbe, 0x1b, 0xf7, 0x33, 0xd4, 0x90, 0x4b, 0xef, 0xd0, 0x11, 0x3f, 0x36, 0x1c,
+	0x2c, 0xbe, 0xd1, 0x25, 0xa8, 0xf3, 0xf4, 0xc6, 0xf3, 0x45, 0xa1, 0x27, 0x8e, 0x49, 0x0d, 0x83,
+	0x02, 0xed, 0x7a, 0x14, 0x5d, 0x81, 0x79, 0xe2, 0x1f, 0xc5, 0xb1, 0x34, 0x69, 0x78, 0xc4, 0xc1,
+	0x03, 0x8b, 0x69, 0xf4, 0x26, 0x2c, 0x4e, 0x82, 0xa9, 0xcf, 0xe2, 0x44, 0xa7, 0xa9, 0x11, 0x45,
+	0x97, 0x02, 0xab, 0x59, 0xf4, 0x91, 0x0e, 0xed, 0xd5, 0x4c, 0x70, 0xce, 0x68, 0xaa, 0x30, 0xbe,
+	0xdf, 0x4b, 0xc7, 0xf7, 0x9a, 0x60, 0x71, 0x6d, 0x26, 0x8b, 0x93, 0xeb, 0xb7, 0x8b, 0x00, 0x21,
+	0xf5, 0x8e, 0xbc, 0x31, 0x19, 0x11, 0xb7, 0x0d, 0xa2, 0xc1, 0x60, 0x40, 0x44, 0xd3, 0x4a, 0x35,
+	0x41, 0x6c, 0x1a, 0x04, 0xec, 0x69, 0xd4, 0xae, 0xcb, 0xc6, 0x47, 0x0c, 0xc6, 0x02, 0x8a, 0xce,
+	0x43, 0x95, 0x17, 0xca, 0xa2, 0xb3, 0xb2, 0x2c, 0xf3, 0xf3, 0x71, 0x30, 0x12, 0x8d, 0x95, 0x75,
+	0x7e, 0x31, 0xba, 0x9e, 0xdf, 0x6e, 0x08, 0x4a, 0x39, 0xe0, 0xf1, 0x4e, 0x7c, 0xd8, 0x81, 0x3f,
+	0x24, 0xed, 0xa6, 0x98, 0xaa, 0x09, 0xc8, 0x43, 0x7f, 0x28, 0xc2, 0x31, 0x63, 0xc7, 0xed, 0x15,
+	0x01, 0xe7, 0x9f, 0xe8, 0x7f, 0xe2, 0xe4, 0xb3, 0x25, 0xac, 0x7f, 0x61, 0xc6, 0x21, 0x7e, 0x65,
+	0x2a, 0xcd, 0x3f, 0x97, 0x60, 0x63, 0x47, 0x5c, 0xe7, 0x46, 0x80, 0x39, 0x43, 0xa5, 0x84, 0xde,
+	0xd3, 0x25, 0x69, 0xb6, 0xac, 0xc9, 0x6e, 0x56, 0xe1, 0xa1, 0x4f, 0xa0, 0x19, 0xf3, 0x54, 0x94,
+	0x95, 0x1f, 0x2a, 0x66, 0x1b, 0x91, 0x39, 0xb4, 0x3e, 0x82, 0xcd, 0x9c, 0xcc, 0xea, 0xea, 0xbd,
+	0x0c, 0xcb, 0x49, 0x8f, 0x4d, 0x8b, 0x5c, 0xd7, 0xb0, 0x7d, 0xd7, 0xba, 0xcd, 0x4b, 0x5a, 0x87,
+	0xb2, 0xdc, 0x86, 0x4f, 0x41, 0x2b, 0xea, 0xd9, 0x34, 0xad, 0x2a, 0x39, 0x07, 0xb0, 0xce, 0x2b,
+	0xdd, 0x97, 0x60, 0xca, 0xe3, 0x00, 0xdf, 0x76, 0x30, 0x65, 0x2a, 0xfe, 0xc5, 0x43, 0x6b, 0x53,
+	0x56, 0xdf, 0xf9, 0xd5, 0x3e, 0x84, 0x0d, 0x59, 0xfc, 0xbe, 0xcc, 0x26, 0xce, 0xc7, 0xa5, 0x77,
+	0x9e, 0xef, 0x6f, 0xcb, 0x46, 0x20, 0x9c, 0x91, 0xad, 0xbf, 0x9b, 0xce, 0xd6, 0x37, 0xf3, 0x06,
+	0x4f, 0x65, 0x90, 0x79, 0x37, 0xaa, 0x14, 0xb8, 0x11, 0xce, 0xa5, 0xf4, 0xf3, 0x22, 0x64, 0xbc,
+	0x9d, 0xe7, 0xfe, 0x5f, 0xcc, 0xe8, 0xf7, 0x65, 0x46, 0xaf, 0x97, 0xd6, 0x5d, 0x84, 0xf7, 0x32,
+	0x19, 0x7d, 0x7b, 0x96, 0x98, 0x3a, 0xa1, 0xff, 0xcd, 0x3c, 0xd4, 0xf4, 0x5c, 0x4e, 0xa7, 0x79,
+	0x25, 0x95, 0x0b, 0x94, 0x64, 0x5e, 0x49, 0x95, 0x97, 0xb9, 0x92, 0xe6, 0x7f, 0xe8, 0x4a, 0xda,
+	0x82, 0x9a, 0xf8, 0xb0, 0x29, 0x79, 0xaa, 0xae, 0x98, 0xaa, 0x00, 0x60, 0xf2, 0x34, 0x31, 0xfc,
+	0xe2, 0xa9, 0x0c, 0x9f, 0x2e, 0x1d, 0x96, 0xb2, 0xa5, 0xc3, 0xfb, 0x99, 0xfb, 0xe5, 0x62, 0x9e,
+	0x5d, 0xe1, 0xcd, 0xb2, 0x57, 0x74, 0xb3, 0xbc, 0x5e, 0x40, 0xfc, 0xca, 0x16, 0x0e, 0xf7, 0x65,
+	0xe1, 0x60, 0x7a, 0x95, 0x8a, 0x5e, 0x5d, 0x00, 0x7d, 0x50, 0xe3, 0xea, 0x01, 0xe5, 0xb7, 0x86,
+	0x0d, 0x2c, 0x1e, 0x0a, 0x52, 0xfa, 0x4f, 0x5a, 0x5d, 0xa7, 0x08, 0x05, 0x7f, 0x32, 0x13, 0x9f,
+	0x19, 0x3d, 0xa1, 0xf7, 0x73, 0xb5, 0xe6, 0xe9, 0xbc, 0xee, 0xdd, 0x74, 0xa9, 0x79, 0x36, 0x77,
+	0xc9, 0x55, 0x9a, 0xe2, 0x26, 0x76, 0xa8, 0x9a, 0x96, 0x45, 0x42, 0x4d, 0x41, 0x7a, 0x8c, 0x67,
+	0x47, 0x4f, 0x3d, 0xdf, 0x8b, 0x0e, 0xe5, 0xfc, 0xa2, 0x98, 0x87, 0x18, 0xd4, 0x13, 0x8f, 0x37,
+	0xe4, 0x85, 0xc7, 0xec, 0x61, 0xe0, 0x12, 0xe1, 0x8c, 0x0b, 0xb8, 0xca, 0x01, 0x3b, 0x81, 0x4b,
+	0x92, 0x03, 0x52, 0x3d, 0xd3, 0x01, 0xa9, 0x65, 0x0e, 0xc8, 0x06, 0x2c, 0x52, 0xe2, 0x44, 0x81,
+	0x2f, 0x72, 0x94, 0x1a, 0x56, 0x23, 0x1e, 0xe0, 0x27, 0x24, 0x8a, 0xf8, 0x02, 0x75, 0x99, 0x75,
+	0xa8, 0xa1, 0x91, 0x64, 0x2d, 0xcf, 0x4a, 0xb2, 0x4e, 0x68, 0x3a, 0x65, 0x92, 0xac, 0xc6, 0xac,
+	0x24, 0xeb, 0x34, 0x3d, 0x27, 0x23, 0x2f, 0x6c, 0x9e, 0x94, 0x17, 0xfe, 0x94, 0x07, 0xe7, 0x1e,
+	0x6c, 0xe6, 0x5c, 0x5d, 0x9d, 0x9c, 0xf7, 0x32, 0xad, 0xa9, 0xf6, 0x2c, 0x2d, 0xe8, 0xce, 0xd4,
+	0x2f, 0x61, 0x65, 0xef, 0x05, 0x19, 0x0e, 0x8e, 0xfd, 0xe1, 0x19, 0xee, 0xea, 0x16, 0x54, 0x86,
+	0x13, 0x57, 0x15, 0x78, 0xfc, 0xd3, 0xbc, 0xbd, 0x2b, 0xe9, 0xdb, 0xdb, 0x86, 0x56, 0xb2, 0x82,
+	0x92, 0x73, 0x83, 0xcb, 0xe9, 0x72, 0x64, 0xce, 0x7c, 0x19, 0xab, 0x91, 0x82, 0x13, 0x4a, 0xc5,
+	0xae, 0x25, 0x9c, 0x50, 0x9a, 0x76, 0xdb, 0x4a, 0xda, 0x6d, 0xad, 0x67, 0x50, 0xe7, 0x0b, 0xfc,
+	0x28, 0xf1, 0x55, 0x0a, 0x5b, 0x49, 0x52, 0x58, 0x9d, 0x09, 0xcf, 0x1b, 0x99, 0xb0, 0xb5, 0x0d,
+	0xcb, 0x72, 0x2d, 0xb5, 0x11, 0x5e, 0xc2, 0xd1, 0x71, 0x6c, 0xb7, 0x29, 0x1d, 0x5b, 0x3f, 0x83,
+	0x46, 0x8f, 0x31, 0x67, 0x78, 0x78, 0x06, 0x79, 0xf4, 0x5a, 0x65, 0x73, 0x2d, 0x0b, 0x9a, 0x31,
+	0xa7, 0x99, 0xab, 0xf5, 0x01, 0x1d, 0x04, 0x94, 0x7d, 0x16, 0xd0, 0xef, 0x1c, 0xea, 0x9e, 0x2d,
+	0x67, 0x45, 0x30, 0xaf, 0x5e, 0x79, 0x2b, 0x57, 0x17, 0xb0, 0xf8, 0xb6, 0xde, 0x82, 0xb5, 0x14,
+	0xbf, 0x99, 0x0b, 0xdf, 0x82, 0xba, 0x88, 0x0a, 0x2a, 0x3b, 0xba, 0x6a, 0xf6, 0x6c, 0x4e, 0x0a,
+	0x1d, 0xbc, 0x4e, 0xe5, 0x61, 0x5f, 0xc0, 0x75, 0x8c, 0x7e, 0x27, 0x93, 0x48, 0xac, 0xa7, 0xe9,
+	0x33, 0x49, 0xc4, 0x73, 0x58, 0x10, 0xe0, 0x5c, 0x8c, 0xde, 0x82, 0x1a, 0x25, 0x61, 0x60, 0x33,
+	0x67, 0xa4, 0xdf, 0xcd, 0x39, 0xe0, 0x91, 0x33, 0x8a, 0xc4, 0xb3, 0x3f, 0x9f, 0x74, 0xbd, 0x11,
+	0x89, 0x58, 0xfc, 0x78, 0x5e, 0xe7, 0xb0, 0x5d, 0x09, 0xe2, 0x1a, 0x89, 0xbc, 0x5f, 0xc9, 0x04,
+	0x61, 0x1e, 0x8b, 0x6f, 0xeb, 0x23, 0x40, 0xa6, 0xbc, 0x4a, 0x21, 0x6f, 0xc2, 0xa2, 0xd8, 0x4e,
+	0x7c, 0x3d, 0x35, 0xd3, 0x02, 0x63, 0x35, 0x6b, 0xdd, 0x05, 0x24, 0x35, 0x90, 0xba, 0x92, 0x4e,
+	0xaf, 0xad, 0x0f, 0x61, 0x2d, 0x45, 0xaf, 0x5f, 0xad, 0x52, 0x0c, 0xb2, 0xab, 0x2b, 0xe2, 0xbf,
+	0x97, 0x00, 0x7a, 0x53, 0x76, 0xa8, 0x4a, 0xf9, 0x0e, 0x54, 0xa7, 0x11, 0xa1, 0x46, 0x43, 0x40,
+	0x8f, 0xf9, 0x5c, 0xe8, 0x44, 0xd1, 0x77, 0x01, 0x8d, 0x73, 0x2e, 0x3d, 0x16, 0x65, 0xf8, 0x94,
+	0x1d, 0xc6, 0xed, 0x23, 0xfe, 0x8d, 0xae, 0x40, 0x53, 0xfe, 0xab, 0x60, 0x3b, 0xae, 0x4b, 0x49,
+	0x14, 0xa9, 0x3e, 0x52, 0x43, 0x42, 0x7b, 0x12, 0xc8, 0xd1, 0x3c, 0x97, 0xf8, 0xcc, 0x63, 0xc7,
+	0x36, 0x0b, 0x9e, 0x13, 0x5f, 0x65, 0x53, 0x8d, 0x18, 0xfa, 0x88, 0x03, 0x39, 0x1a, 0x25, 0x23,
+	0x2f, 0x62, 0x34, 0x46, 0x5b, 0x94, 0x68, 0x31, 0x54, 0xa0, 0x59, 0xdf, 0x97, 0xa0, 0x75, 0x30,
+	0x1d, 0x8f, 0xe5, 0x26, 0xcf, 0xaa, 0x4b, 0xf4, 0x96, 0xda, 0x47, 0xb6, 0x2b, 0x94, 0xa8, 0x48,
+	0x6d, 0xee, 0xc7, 0x97, 0x66, 0x6b, 0xb0, 0x6a, 0x08, 0xaa, 0xaa, 0x8a, 0xbb, 0x80, 0x64, 0xc1,
+	0xf1, 0x72, 0xf2, 0x5b, 0xe7, 0x60, 0x2d, 0x45, 0xaf, 0xd8, 0x5e, 0x87, 0x86, 0x7a, 0x02, 0x52,
+	0x76, 0x3e, 0x0f, 0x55, 0x7e, 0xfa, 0x87, 0x9e, 0x1b, 0xb7, 0x06, 0x97, 0xc2, 0xc0, 0xdd, 0xf1,
+	0x5c, 0x6a, 0xf5, 0xa1, 0x81, 0x25, 0x7b, 0x85, 0x7b, 0x07, 0x9a, 0xea, 0xc1, 0xc8, 0x4e, 0x3d,
+	0xa9, 0x26, 0x7d, 0xaf, 0x14, 0x6f, 0xdc, 0xf0, 0xcd, 0xa1, 0xf5, 0x0d, 0x74, 0x1e, 0x87, 0x2e,
+	0x4f, 0x5f, 0x4c, 0xae, 0xf1, 0xd6, 0xee, 0x40, 0xfc, 0xbb, 0xcc, 0x2c, 0xe6, 0x69, 0xb2, 0x06,
+	0x35, 0x87, 0xd6, 0x05, 0xd8, 0x2a, 0x64, 0x2e, 0xf7, 0x7d, 0xfd, 0x35, 0xa8, 0xc6, 0x3f, 0xb1,
+	0xa0, 0x25, 0xa8, 0x3c, 0xda, 0x39, 0x68, 0xcd, 0xf1, 0x8f, 0xc7, 0xbb, 0x07, 0xad, 0xd2, 0xf5,
+	0xdb, 0xb0, 0x92, 0xe9, 0xe5, 0xa3, 0x55, 0x68, 0x0c, 0x7a, 0xfd, 0xdd, 0x4f, 0x1f, 0x7e, 0x65,
+	0xe3, 0xbd, 0xde, 0xee, 0xd7, 0xad, 0x39, 0xb4, 0x0e, 0xad, 0x18, 0xd4, 0x7f, 0xf8, 0x48, 0x42,
+	0x4b, 0xd7, 0x9f, 0x43, 0x33, 0x9d, 0x9c, 0xa1, 0x73, 0xb0, 0xba, 0xf3, 0xb0, 0xff, 0xa8, 0xb7,
+	0xdf, 0xdf, 0xc3, 0xf6, 0x0e, 0xde, 0xeb, 0x3d, 0xda, 0xdb, 0x6d, 0xcd, 0xa5, 0xc1, 0xf8, 0x71,
+	0xbf, 0xbf, 0xdf, 0xff, 0xbc, 0x55, 0xe2, 0x5c, 0x13, 0xf0, 0xde, 0x57, 0xfb, 0x1c, 0xb9, 0x9c,
+	0x46, 0x7e, 0xdc, 0xbf, 0xd7, 0x7f, 0xf8, 0x8b, 0x7e, 0xab, 0xd2, 0xfd, 0x27, 0x40, 0x53, 0x6d,
+	0x70, 0x40, 0xe8, 0x91, 0x37, 0x24, 0xe8, 0x2e, 0x2c, 0xc5, 0xff, 0x17, 0x25, 0xe9, 0x62, 0xfa,
+	0x67, 0xa8, 0x4e, 0x3b, 0x3f, 0xa1, 0xfc, 0x61, 0x0e, 0x1d, 0x08, 0x2b, 0x1b, 0xef, 0x26, 0x17,
+	0x4c, 0x85, 0xe7, 0x1e, 0x66, 0x3a, 0x17, 0x67, 0x4d, 0x6b, 0x8e, 0x03, 0x68, 0xa6, 0x1f, 0xb0,
+	0x51, 0x42, 0x53, 0xf8, 0x30, 0xde, 0xb9, 0x34, 0x73, 0x5e, 0x33, 0xfd, 0x1a, 0x5a, 0xd9, 0xa7,
+	0x6b, 0x94, 0xb4, 0x7b, 0x67, 0x3c, 0x8b, 0x77, 0x2e, 0x9f, 0x80, 0x61, 0xb2, 0xce, 0x3d, 0xf2,
+	0x6e, 0xcf, 0x7e, 0xa6, 0xcb, 0xb1, 0x9e, 0xf5, 0xf6, 0x27, 0x55, 0x91, 0x7e, 0xef, 0x40, 0xe6,
+	0xd3, 0x6a, 0xc1, 0xbb, 0x97, 0xa1, 0x8a, 0xe2, 0x87, 0x12, 0x6b, 0x0e, 0x7d, 0x09, 0x2b, 0x99,
+	0x56, 0x0e, 0x4a, 0xa8, 0x8a, 0x1b, 0x53, 0x9d, 0xed, 0xd9, 0x08, 0x69, 0xbb, 0x99, 0x8d, 0x9a,
+	0x94, 0xdd, 0x0a, 0xba, 0x3f, 0x29, 0xbb, 0x15, 0x76, 0x78, 0x84, 0x7b, 0xa5, 0xda, 0x31, 0x86,
+	0x7b, 0x15, 0xf5, 0x7e, 0x3a, 0x17, 0x67, 0x4d, 0x9b, 0xdb, 0xcf, 0xb4, 0x62, 0x8c, 0xed, 0x17,
+	0x77, 0x78, 0x3a, 0xdb, 0xb3, 0x11, 0xb2, 0xb6, 0x4a, 0x4a, 0xcc, 0x8c, 0xad, 0x72, 0x1d, 0x8d,
+	0x8c, 0xad, 0xf2, 0xb5, 0xa9, 0xb2, 0x55, 0xa6, 0x56, 0xbc, 0x34, 0x33, 0xcd, 0xce, 0xdb, 0xaa,
+	0x38, 0x73, 0xb7, 0xe6, 0x50, 0x0f, 0xaa, 0x71, 0x9e, 0x8c, 0x92, 0xd3, 0x9d, 0x49, 0xce, 0x3b,
+	0xe7, 0x0b, 0x66, 0x34, 0x8b, 0xff, 0x83, 0x79, 0x0e, 0x45, 0xeb, 0x29, 0xa4, 0x98, 0xf4, 0x5c,
+	0x06, 0xaa, 0xc9, 0x3e, 0x84, 0x45, 0x99, 0x68, 0xa2, 0x24, 0x32, 0xa7, 0x72, 0xd8, 0xce, 0x66,
+	0x0e, 0xae, 0x89, 0xbf, 0x90, 0xff, 0x1c, 0xaa, 0x8c, 0x11, 0x6d, 0xa5, 0xfe, 0x8a, 0x4a, 0xe7,
+	0xa5, 0x9d, 0xd7, 0x8a, 0x27, 0x35, 0xaf, 0x27, 0xb0, 0x56, 0x10, 0xf1, 0x51, 0xd2, 0xd6, 0x98,
+	0x7d, 0xd9, 0x74, 0xde, 0x38, 0x19, 0x29, 0x5e, 0xa3, 0xfb, 0x97, 0x32, 0x2c, 0xcb, 0xab, 0x55,
+	0x45, 0xdb, 0xcf, 0x01, 0x92, 0x04, 0x0f, 0x75, 0x52, 0x0e, 0x90, 0xca, 0x52, 0x3b, 0x5b, 0x85,
+	0x73, 0xa6, 0x26, 0x8c, 0x5c, 0xcd, 0xd0, 0x44, 0x3e, 0x03, 0x34, 0x34, 0x51, 0x90, 0xde, 0x59,
+	0x73, 0x68, 0x17, 0x6a, 0x3a, 0x81, 0x40, 0x46, 0xde, 0x91, 0xc9, 0x7e, 0x3a, 0x9d, 0xa2, 0x29,
+	0x53, 0x22, 0x23, 0x63, 0x30, 0x24, 0xca, 0xe7, 0x21, 0x86, 0x44, 0x45, 0x49, 0xc6, 0xdc, 0x7f,
+	0x02, 0x00, 0x00, 0xff, 0xff, 0x45, 0x43, 0x5d, 0x1f, 0xa4, 0x2b, 0x00, 0x00,
 }
diff --git a/pkg/kubelet/api/v1alpha1/runtime/api.proto b/pkg/kubelet/api/v1alpha1/runtime/api.proto
index b100c1f6d88..14d32388acf 100644
--- a/pkg/kubelet/api/v1alpha1/runtime/api.proto
+++ b/pkg/kubelet/api/v1alpha1/runtime/api.proto
@@ -20,7 +20,7 @@ service RuntimeService {
     rpc RemovePodSandbox(RemovePodSandboxRequest) returns (RemovePodSandboxResponse) {}
     // PodSandboxStatus returns the status of the PodSandbox.
     rpc PodSandboxStatus(PodSandboxStatusRequest) returns (PodSandboxStatusResponse) {}
-    // ListPodSandbox returns a list of SandBox.
+    // ListPodSandbox returns a list of Sandbox.
     rpc ListPodSandbox(ListPodSandboxRequest) returns (ListPodSandboxResponse) {}
 
     // CreateContainer creates a new container in specified PodSandbox
@@ -270,15 +270,15 @@ message Namespace {
     optional NamespaceOption options = 2;
 }
 
-// LinuxSandBoxStatus contains status specific to Linux sandboxes.
+// LinuxSandboxStatus contains status specific to Linux sandboxes.
 message LinuxPodSandboxStatus {
     // Namespaces contains paths to the sandbox's namespaces.
     optional Namespace namespaces = 1;
 }
 
-enum PodSandBoxState {
-    READY = 0;
-    NOTREADY = 1;
+enum PodSandboxState {
+    SANDBOX_READY = 0;
+    SANDBOX_NOTREADY = 1;
 }
 
 // PodSandboxStatus contains the status of the PodSandbox.
@@ -288,7 +288,7 @@ message PodSandboxStatus {
     // Metadata of the sandbox.
     optional PodSandboxMetadata metadata = 2;
     // State of the sandbox.
-    optional PodSandBoxState state = 3;
+    optional PodSandboxState state = 3;
     // Creation timestamp of the sandbox in nanoseconds.
     optional int64 created_at = 4;
     // Network contains network status if network is handled by the runtime.
@@ -313,7 +313,7 @@ message PodSandboxFilter {
     // ID of the sandbox.
     optional string id = 1;
     // State of the sandbox.
-    optional PodSandBoxState state = 2;
+    optional PodSandboxState state = 2;
     // LabelSelector to select matches.
     // Only api.MatchLabels is supported for now and the requirements
     // are ANDed. MatchExpressions is not supported yet.
@@ -333,7 +333,7 @@ message PodSandbox {
     // Metadata of the sandbox
     optional PodSandboxMetadata metadata = 2;
     // The state of the PodSandbox
-    optional PodSandBoxState state = 3;
+    optional PodSandboxState state = 3;
     // Creation timestamps of the sandbox in nanoseconds
     optional int64 created_at = 4;
     // The labels of the PodSandbox
@@ -529,10 +529,10 @@ message RemoveContainerRequest {
 message RemoveContainerResponse {}
 
 enum ContainerState {
-    CREATED = 0;
-    RUNNING = 1;
-    EXITED  = 2;
-    UNKNOWN = 3;
+    CONTAINER_CREATED = 0;
+    CONTAINER_RUNNING = 1;
+    CONTAINER_EXITED  = 2;
+    CONTAINER_UNKNOWN = 3;
 }
 
 // ContainerFilter is used to filter containers.
diff --git a/pkg/kubelet/container/helpers.go b/pkg/kubelet/container/helpers.go
index 59d94d77dc0..4b06a92d093 100644
--- a/pkg/kubelet/container/helpers.go
+++ b/pkg/kubelet/container/helpers.go
@@ -206,11 +206,11 @@ func ConvertPodStatusToRunningPod(runtimeName string, podStatus *PodStatus) Pod
 // This is only needed because we need to return sandboxes as if they were
 // kubecontainer.Containers to avoid substantial changes to PLEG.
 // TODO: Remove this once it becomes obsolete.
-func SandboxToContainerState(state runtimeApi.PodSandBoxState) ContainerState {
+func SandboxToContainerState(state runtimeApi.PodSandboxState) ContainerState {
 	switch state {
-	case runtimeApi.PodSandBoxState_READY:
+	case runtimeApi.PodSandboxState_SANDBOX_READY:
 		return ContainerStateRunning
-	case runtimeApi.PodSandBoxState_NOTREADY:
+	case runtimeApi.PodSandboxState_SANDBOX_NOTREADY:
 		return ContainerStateExited
 	}
 	return ContainerStateUnknown
diff --git a/pkg/kubelet/dockershim/convert.go b/pkg/kubelet/dockershim/convert.go
index 09872982953..0b6a9c9c754 100644
--- a/pkg/kubelet/dockershim/convert.go
+++ b/pkg/kubelet/dockershim/convert.go
@@ -100,13 +100,13 @@ func toRuntimeAPIContainer(c *dockertypes.Container) (*runtimeApi.Container, err
 
 func toDockerContainerStatus(state runtimeApi.ContainerState) string {
 	switch state {
-	case runtimeApi.ContainerState_CREATED:
+	case runtimeApi.ContainerState_CONTAINER_CREATED:
 		return "created"
-	case runtimeApi.ContainerState_RUNNING:
+	case runtimeApi.ContainerState_CONTAINER_RUNNING:
 		return "running"
-	case runtimeApi.ContainerState_EXITED:
+	case runtimeApi.ContainerState_CONTAINER_EXITED:
 		return "exited"
-	case runtimeApi.ContainerState_UNKNOWN:
+	case runtimeApi.ContainerState_CONTAINER_UNKNOWN:
 		fallthrough
 	default:
 		return "unknown"
@@ -118,24 +118,24 @@ func toRuntimeAPIContainerState(state string) runtimeApi.ContainerState {
 	// we upgrade docker.
 	switch {
 	case strings.HasPrefix(state, statusRunningPrefix):
-		return runtimeApi.ContainerState_RUNNING
+		return runtimeApi.ContainerState_CONTAINER_RUNNING
 	case strings.HasPrefix(state, statusExitedPrefix):
-		return runtimeApi.ContainerState_EXITED
+		return runtimeApi.ContainerState_CONTAINER_EXITED
 	case strings.HasPrefix(state, statusCreatedPrefix):
-		return runtimeApi.ContainerState_CREATED
+		return runtimeApi.ContainerState_CONTAINER_CREATED
 	default:
-		return runtimeApi.ContainerState_UNKNOWN
+		return runtimeApi.ContainerState_CONTAINER_UNKNOWN
 	}
 }
 
-func toRuntimeAPISandboxState(state string) runtimeApi.PodSandBoxState {
+func toRuntimeAPISandboxState(state string) runtimeApi.PodSandboxState {
 	// Parse the state string in dockertypes.Container. This could break when
 	// we upgrade docker.
 	switch {
 	case strings.HasPrefix(state, statusRunningPrefix):
-		return runtimeApi.PodSandBoxState_READY
+		return runtimeApi.PodSandboxState_SANDBOX_READY
 	default:
-		return runtimeApi.PodSandBoxState_NOTREADY
+		return runtimeApi.PodSandboxState_SANDBOX_NOTREADY
 	}
 }
 
diff --git a/pkg/kubelet/dockershim/convert_test.go b/pkg/kubelet/dockershim/convert_test.go
index 993dffb2451..73bdffcb843 100644
--- a/pkg/kubelet/dockershim/convert_test.go
+++ b/pkg/kubelet/dockershim/convert_test.go
@@ -30,10 +30,10 @@ func TestConvertDockerStatusToRuntimeAPIState(t *testing.T) {
 		input    string
 		expected runtimeApi.ContainerState
 	}{
-		{input: "Up 5 hours", expected: runtimeApi.ContainerState_RUNNING},
-		{input: "Exited (0) 2 hours ago", expected: runtimeApi.ContainerState_EXITED},
-		{input: "Created", expected: runtimeApi.ContainerState_CREATED},
-		{input: "Random string", expected: runtimeApi.ContainerState_UNKNOWN},
+		{input: "Up 5 hours", expected: runtimeApi.ContainerState_CONTAINER_RUNNING},
+		{input: "Exited (0) 2 hours ago", expected: runtimeApi.ContainerState_CONTAINER_EXITED},
+		{input: "Created", expected: runtimeApi.ContainerState_CONTAINER_CREATED},
+		{input: "Random string", expected: runtimeApi.ContainerState_CONTAINER_UNKNOWN},
 	}
 
 	for _, test := range testCases {
diff --git a/pkg/kubelet/dockershim/docker_container.go b/pkg/kubelet/dockershim/docker_container.go
index 74d3abf4a12..5fe8ab3482c 100644
--- a/pkg/kubelet/dockershim/docker_container.go
+++ b/pkg/kubelet/dockershim/docker_container.go
@@ -327,7 +327,7 @@ func (ds *dockerService) ContainerStatus(containerID string) (*runtimeApi.Contai
 	var reason, message string
 	if r.State.Running {
 		// Container is running.
-		state = runtimeApi.ContainerState_RUNNING
+		state = runtimeApi.ContainerState_CONTAINER_RUNNING
 	} else {
 		// Container is *not* running. We need to get more details.
 		//    * Case 1: container has run and exited with non-zero finishedAt
@@ -336,7 +336,7 @@ func (ds *dockerService) ContainerStatus(containerID string) (*runtimeApi.Contai
 		//              time, but a non-zero exit code.
 		//    * Case 3: container has been created, but not started (yet).
 		if !finishedAt.IsZero() { // Case 1
-			state = runtimeApi.ContainerState_EXITED
+			state = runtimeApi.ContainerState_CONTAINER_EXITED
 			switch {
 			case r.State.OOMKilled:
 				// TODO: consider exposing OOMKilled via the runtimeAPI.
@@ -349,13 +349,13 @@ func (ds *dockerService) ContainerStatus(containerID string) (*runtimeApi.Contai
 				reason = "Error"
 			}
 		} else if r.State.ExitCode != 0 { // Case 2
-			state = runtimeApi.ContainerState_EXITED
+			state = runtimeApi.ContainerState_CONTAINER_EXITED
 			// Adjust finshedAt and startedAt time to createdAt time to avoid
 			// the confusion.
 			finishedAt, startedAt = createdAt, createdAt
 			reason = "ContainerCannotRun"
 		} else { // Case 3
-			state = runtimeApi.ContainerState_CREATED
+			state = runtimeApi.ContainerState_CONTAINER_CREATED
 		}
 		message = r.State.Error
 	}
diff --git a/pkg/kubelet/dockershim/docker_container_test.go b/pkg/kubelet/dockershim/docker_container_test.go
index 6f672dd7453..4bf61c2fcf2 100644
--- a/pkg/kubelet/dockershim/docker_container_test.go
+++ b/pkg/kubelet/dockershim/docker_container_test.go
@@ -62,7 +62,7 @@ func TestListContainers(t *testing.T) {
 	}
 
 	expected := []*runtimeApi.Container{}
-	state := runtimeApi.ContainerState_RUNNING
+	state := runtimeApi.ContainerState_CONTAINER_RUNNING
 	var createdAt int64 = 0
 	for i := range configs {
 		// We don't care about the sandbox id; pass a bogus one.
@@ -105,7 +105,7 @@ func TestContainerStatus(t *testing.T) {
 	var defaultTime time.Time
 	dt := defaultTime.UnixNano()
 	ct, st, ft := dt, dt, dt
-	state := runtimeApi.ContainerState_CREATED
+	state := runtimeApi.ContainerState_CONTAINER_CREATED
 	// The following variables are not set in FakeDockerClient.
 	imageRef := DockerImageIDPrefix + ""
 	exitCode := int32(0)
@@ -149,7 +149,7 @@ func TestContainerStatus(t *testing.T) {
 	// Advance the clock and start the container.
 	fClock.SetTime(time.Now())
 	*expected.StartedAt = fClock.Now().UnixNano()
-	*expected.State = runtimeApi.ContainerState_RUNNING
+	*expected.State = runtimeApi.ContainerState_CONTAINER_RUNNING
 
 	err = ds.StartContainer(id)
 	assert.NoError(t, err)
@@ -159,7 +159,7 @@ func TestContainerStatus(t *testing.T) {
 	// Advance the clock and stop the container.
 	fClock.SetTime(time.Now().Add(1 * time.Hour))
 	*expected.FinishedAt = fClock.Now().UnixNano()
-	*expected.State = runtimeApi.ContainerState_EXITED
+	*expected.State = runtimeApi.ContainerState_CONTAINER_EXITED
 	*expected.Reason = "Completed"
 
 	err = ds.StopContainer(id, 0)
diff --git a/pkg/kubelet/dockershim/docker_sandbox.go b/pkg/kubelet/dockershim/docker_sandbox.go
index 8586068a342..457aae42ade 100644
--- a/pkg/kubelet/dockershim/docker_sandbox.go
+++ b/pkg/kubelet/dockershim/docker_sandbox.go
@@ -192,9 +192,9 @@ func (ds *dockerService) PodSandboxStatus(podSandboxID string) (*runtimeApi.PodS
 	ct := createdAt.UnixNano()
 
 	// Translate container to sandbox state.
-	state := runtimeApi.PodSandBoxState_NOTREADY
+	state := runtimeApi.PodSandboxState_SANDBOX_NOTREADY
 	if r.State.Running {
-		state = runtimeApi.PodSandBoxState_READY
+		state = runtimeApi.PodSandboxState_SANDBOX_READY
 	}
 	IP, err := ds.getIP(r)
 	if err != nil {
@@ -244,11 +244,11 @@ func (ds *dockerService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter) ([]
 			f.Add("id", filter.GetId())
 		}
 		if filter.State != nil {
-			if filter.GetState() == runtimeApi.PodSandBoxState_READY {
+			if filter.GetState() == runtimeApi.PodSandboxState_SANDBOX_READY {
 				// Only list running containers.
 				opts.All = false
 			} else {
-				// runtimeApi.PodSandBoxState_NOTREADY can mean the
+				// runtimeApi.PodSandboxState_SANDBOX_NOTREADY can mean the
 				// container is in any of the non-running state (e.g., created,
 				// exited). We can't tell docker to filter out running
 				// containers directly, so we'll need to filter them out
@@ -277,7 +277,7 @@ func (ds *dockerService) ListPodSandbox(filter *runtimeApi.PodSandboxFilter) ([]
 			glog.V(5).Infof("Unable to convert docker to runtime API sandbox: %v", err)
 			continue
 		}
-		if filterOutReadySandboxes && converted.GetState() == runtimeApi.PodSandBoxState_READY {
+		if filterOutReadySandboxes && converted.GetState() == runtimeApi.PodSandboxState_SANDBOX_READY {
 			continue
 		}
 
diff --git a/pkg/kubelet/dockershim/docker_sandbox_test.go b/pkg/kubelet/dockershim/docker_sandbox_test.go
index baaadcd86bb..bf49c25628a 100644
--- a/pkg/kubelet/dockershim/docker_sandbox_test.go
+++ b/pkg/kubelet/dockershim/docker_sandbox_test.go
@@ -63,7 +63,7 @@ func TestListSandboxes(t *testing.T) {
 	}
 
 	expected := []*runtimeApi.PodSandbox{}
-	state := runtimeApi.PodSandBoxState_READY
+	state := runtimeApi.PodSandboxState_SANDBOX_READY
 	var createdAt int64 = 0
 	for i := range configs {
 		id, err := ds.RunPodSandbox(configs[i])
@@ -98,7 +98,7 @@ func TestSandboxStatus(t *testing.T) {
 	fakeIP := "2.3.4.5"
 	fakeNS := fmt.Sprintf("/proc/%d/ns/net", os.Getpid())
 
-	state := runtimeApi.PodSandBoxState_READY
+	state := runtimeApi.PodSandboxState_SANDBOX_READY
 	ct := int64(0)
 	hostNetwork := false
 	expected := &runtimeApi.PodSandboxStatus{
@@ -128,7 +128,7 @@ func TestSandboxStatus(t *testing.T) {
 	assert.Equal(t, expected, status)
 
 	// Stop the sandbox.
-	*expected.State = runtimeApi.PodSandBoxState_NOTREADY
+	*expected.State = runtimeApi.PodSandboxState_SANDBOX_NOTREADY
 	err = ds.StopPodSandbox(id)
 	assert.NoError(t, err)
 	status, err = ds.PodSandboxStatus(id)
diff --git a/pkg/kubelet/kuberuntime/helpers.go b/pkg/kubelet/kuberuntime/helpers.go
index 34cb93f45c7..c4584447b37 100644
--- a/pkg/kubelet/kuberuntime/helpers.go
+++ b/pkg/kubelet/kuberuntime/helpers.go
@@ -72,13 +72,13 @@ func (c containerStatusByCreated) Less(i, j int) bool { return c[i].CreatedAt.Af
 // toKubeContainerState converts runtimeApi.ContainerState to kubecontainer.ContainerState.
 func toKubeContainerState(state runtimeApi.ContainerState) kubecontainer.ContainerState {
 	switch state {
-	case runtimeApi.ContainerState_CREATED:
+	case runtimeApi.ContainerState_CONTAINER_CREATED:
 		return kubecontainer.ContainerStateCreated
-	case runtimeApi.ContainerState_RUNNING:
+	case runtimeApi.ContainerState_CONTAINER_RUNNING:
 		return kubecontainer.ContainerStateRunning
-	case runtimeApi.ContainerState_EXITED:
+	case runtimeApi.ContainerState_CONTAINER_EXITED:
 		return kubecontainer.ContainerStateExited
-	case runtimeApi.ContainerState_UNKNOWN:
+	case runtimeApi.ContainerState_CONTAINER_UNKNOWN:
 		return kubecontainer.ContainerStateUnknown
 	}
 
diff --git a/pkg/kubelet/kuberuntime/kuberuntime_container.go b/pkg/kubelet/kuberuntime/kuberuntime_container.go
index 0b4c4eee019..0fff29c0977 100644
--- a/pkg/kubelet/kuberuntime/kuberuntime_container.go
+++ b/pkg/kubelet/kuberuntime/kuberuntime_container.go
@@ -301,7 +301,7 @@ func (m *kubeGenericRuntimeManager) getKubeletContainers(allContainers bool) ([]
 		LabelSelector: map[string]string{kubernetesManagedLabel: "true"},
 	}
 	if !allContainers {
-		runningState := runtimeApi.ContainerState_RUNNING
+		runningState := runtimeApi.ContainerState_CONTAINER_RUNNING
 		filter.State = &runningState
 	}
 
@@ -390,7 +390,7 @@ func (m *kubeGenericRuntimeManager) getPodContainerStatuses(uid kubetypes.UID, n
 			CreatedAt:    time.Unix(0, status.GetCreatedAt()),
 		}
 
-		if c.GetState() == runtimeApi.ContainerState_RUNNING {
+		if c.GetState() == runtimeApi.ContainerState_CONTAINER_RUNNING {
 			cStatus.StartedAt = time.Unix(0, status.GetStartedAt())
 		} else {
 			cStatus.Reason = status.GetReason()
diff --git a/pkg/kubelet/kuberuntime/kuberuntime_gc.go b/pkg/kubelet/kuberuntime/kuberuntime_gc.go
index 7696e6dd355..7e7ab9a4152 100644
--- a/pkg/kubelet/kuberuntime/kuberuntime_gc.go
+++ b/pkg/kubelet/kuberuntime/kuberuntime_gc.go
@@ -154,7 +154,7 @@ func (cgc *containerGC) evictableContainers(minAge time.Duration) (containersByE
 	newestGCTime := time.Now().Add(-minAge)
 	for _, container := range containers {
 		// Prune out running containers.
-		if container.GetState() == runtimeApi.ContainerState_RUNNING {
+		if container.GetState() == runtimeApi.ContainerState_CONTAINER_RUNNING {
 			continue
 		}
 
@@ -249,7 +249,7 @@ func (cgc *containerGC) evictSandboxes(minAge time.Duration) error {
 	newestGCTime := time.Now().Add(-minAge)
 	for _, sandbox := range sandboxes {
 		// Prune out ready sandboxes.
-		if sandbox.GetState() == runtimeApi.PodSandBoxState_READY {
+		if sandbox.GetState() == runtimeApi.PodSandboxState_SANDBOX_READY {
 			continue
 		}
 
diff --git a/pkg/kubelet/kuberuntime/kuberuntime_gc_test.go b/pkg/kubelet/kuberuntime/kuberuntime_gc_test.go
index 6c62f3fe513..8ba08c31af0 100644
--- a/pkg/kubelet/kuberuntime/kuberuntime_gc_test.go
+++ b/pkg/kubelet/kuberuntime/kuberuntime_gc_test.go
@@ -54,7 +54,7 @@ func TestSandboxGC(t *testing.T) {
 		{
 			description: "sandbox with no containers should be garbage collected.",
 			sandboxes: []sandboxTemplate{
-				{pod: pods[0], state: runtimeApi.PodSandBoxState_NOTREADY},
+				{pod: pods[0], state: runtimeApi.PodSandboxState_SANDBOX_NOTREADY},
 			},
 			containers: []containerTemplate{},
 			remain:     []int{},
@@ -62,7 +62,7 @@ func TestSandboxGC(t *testing.T) {
 		{
 			description: "running sandbox should not be garbage collected.",
 			sandboxes: []sandboxTemplate{
-				{pod: pods[0], state: runtimeApi.PodSandBoxState_READY},
+				{pod: pods[0], state: runtimeApi.PodSandboxState_SANDBOX_READY},
 			},
 			containers: []containerTemplate{},
 			remain:     []int{0},
@@ -70,18 +70,18 @@ func TestSandboxGC(t *testing.T) {
 		{
 			description: "sandbox with containers should not be garbage collected.",
 			sandboxes: []sandboxTemplate{
-				{pod: pods[0], state: runtimeApi.PodSandBoxState_NOTREADY},
+				{pod: pods[0], state: runtimeApi.PodSandboxState_SANDBOX_NOTREADY},
 			},
 			containers: []containerTemplate{
-				{pod: pods[0], container: &pods[0].Spec.Containers[0], state: runtimeApi.ContainerState_EXITED},
+				{pod: pods[0], container: &pods[0].Spec.Containers[0], state: runtimeApi.ContainerState_CONTAINER_EXITED},
 			},
 			remain: []int{0},
 		},
 		{
 			description: "sandbox within min age should not be garbage collected.",
 			sandboxes: []sandboxTemplate{
-				{pod: pods[0], createdAt: time.Now().UnixNano(), state: runtimeApi.PodSandBoxState_NOTREADY},
-				{pod: pods[1], createdAt: time.Now().Add(-2 * time.Hour).UnixNano(), state: runtimeApi.PodSandBoxState_NOTREADY},
+				{pod: pods[0], createdAt: time.Now().UnixNano(), state: runtimeApi.PodSandboxState_SANDBOX_NOTREADY},
+				{pod: pods[1], createdAt: time.Now().Add(-2 * time.Hour).UnixNano(), state: runtimeApi.PodSandboxState_SANDBOX_NOTREADY},
 			},
 			containers: []containerTemplate{},
 			minAge:     time.Hour, // assume the test won't take an hour
@@ -91,14 +91,14 @@ func TestSandboxGC(t *testing.T) {
 			description: "multiple sandboxes should be handled properly.",
 			sandboxes: []sandboxTemplate{
 				// running sandbox.
-				{pod: pods[0], attempt: 1, state: runtimeApi.PodSandBoxState_READY},
+				{pod: pods[0], attempt: 1, state: runtimeApi.PodSandboxState_SANDBOX_READY},
 				// exited sandbox with containers.
-				{pod: pods[1], attempt: 1, state: runtimeApi.PodSandBoxState_NOTREADY},
+				{pod: pods[1], attempt: 1, state: runtimeApi.PodSandboxState_SANDBOX_NOTREADY},
 				// exited sandbox without containers.
-				{pod: pods[1], attempt: 0, state: runtimeApi.PodSandBoxState_NOTREADY},
+				{pod: pods[1], attempt: 0, state: runtimeApi.PodSandboxState_SANDBOX_NOTREADY},
 			},
 			containers: []containerTemplate{
-				{pod: pods[1], container: &pods[1].Spec.Containers[0], sandboxAttempt: 1, state: runtimeApi.ContainerState_EXITED},
+				{pod: pods[1], container: &pods[1].Spec.Containers[0], sandboxAttempt: 1, state: runtimeApi.ContainerState_CONTAINER_EXITED},
 			},
 			remain: []int{0, 1},
 		},
@@ -153,7 +153,7 @@ func TestContainerGC(t *testing.T) {
 		{
 			description: "all containers should be removed when max container limit is 0",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_EXITED),
+				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
 			},
 			policy: &kubecontainer.ContainerGCPolicy{MinAge: time.Minute, MaxPerPodContainer: 1, MaxContainers: 0},
 			remain: []int{},
@@ -161,11 +161,11 @@ func TestContainerGC(t *testing.T) {
 		{
 			description: "max containers should be complied when no max per pod container limit is set",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 4, 4, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 3, 3, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_EXITED),
+				makeGCContainer("foo", "bar", 4, 4, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 3, 3, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
 			},
 			policy: &kubecontainer.ContainerGCPolicy{MinAge: time.Minute, MaxPerPodContainer: -1, MaxContainers: 4},
 			remain: []int{0, 1, 2, 3},
@@ -173,9 +173,9 @@ func TestContainerGC(t *testing.T) {
 		{
 			description: "no containers should be removed if both max container and per pod container limits are not set",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_EXITED),
+				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
 			},
 			policy: &kubecontainer.ContainerGCPolicy{MinAge: time.Minute, MaxPerPodContainer: -1, MaxContainers: -1},
 			remain: []int{0, 1, 2},
@@ -183,94 +183,94 @@ func TestContainerGC(t *testing.T) {
 		{
 			description: "recently started containers should not be removed",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 2, time.Now().UnixNano(), runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 1, time.Now().UnixNano(), runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 0, time.Now().UnixNano(), runtimeApi.ContainerState_EXITED),
+				makeGCContainer("foo", "bar", 2, time.Now().UnixNano(), runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 1, time.Now().UnixNano(), runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 0, time.Now().UnixNano(), runtimeApi.ContainerState_CONTAINER_EXITED),
 			},
 			remain: []int{0, 1, 2},
 		},
 		{
 			description: "oldest containers should be removed when per pod container limit exceeded",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_EXITED),
+				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
 			},
 			remain: []int{0, 1},
 		},
 		{
 			description: "running containers should not be removed",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_RUNNING),
+				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_CONTAINER_RUNNING),
 			},
 			remain: []int{0, 1, 2},
 		},
 		{
 			description: "no containers should be removed when limits are not exceeded",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_EXITED),
+				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
 			},
 			remain: []int{0, 1},
 		},
 		{
 			description: "max container count should apply per (UID, container) pair",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo1", "baz", 2, 2, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo1", "baz", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo1", "baz", 0, 0, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo2", "bar", 2, 2, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo2", "bar", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo2", "bar", 0, 0, runtimeApi.ContainerState_EXITED),
+				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo1", "baz", 2, 2, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo1", "baz", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo1", "baz", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo2", "bar", 2, 2, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo2", "bar", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo2", "bar", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
 			},
 			remain: []int{0, 1, 3, 4, 6, 7},
 		},
 		{
 			description: "max limit should apply and try to keep from every pod",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo1", "bar1", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo1", "bar1", 0, 0, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo2", "bar2", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo2", "bar2", 0, 0, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo3", "bar3", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo3", "bar3", 0, 0, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo4", "bar4", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo4", "bar4", 0, 0, runtimeApi.ContainerState_EXITED),
+				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo1", "bar1", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo1", "bar1", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo2", "bar2", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo2", "bar2", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo3", "bar3", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo3", "bar3", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo4", "bar4", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo4", "bar4", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
 			},
 			remain: []int{0, 2, 4, 6, 8},
 		},
 		{
 			description: "oldest pods should be removed if limit exceeded",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo1", "bar1", 2, 2, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo1", "bar1", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo2", "bar2", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo3", "bar3", 0, 0, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo4", "bar4", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo5", "bar5", 0, 0, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo6", "bar6", 2, 2, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo7", "bar7", 1, 1, runtimeApi.ContainerState_EXITED),
+				makeGCContainer("foo", "bar", 2, 2, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo1", "bar1", 2, 2, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo1", "bar1", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo2", "bar2", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo3", "bar3", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo4", "bar4", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo5", "bar5", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo6", "bar6", 2, 2, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo7", "bar7", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
 			},
 			remain: []int{0, 2, 4, 6, 8, 9},
 		},
 		{
 			description: "containers for deleted pods should be removed",
 			containers: []containerTemplate{
-				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_EXITED),
+				makeGCContainer("foo", "bar", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("foo", "bar", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
 				// deleted pods still respect MinAge.
-				makeGCContainer("deleted", "bar1", 2, time.Now().UnixNano(), runtimeApi.ContainerState_EXITED),
-				makeGCContainer("deleted", "bar1", 1, 1, runtimeApi.ContainerState_EXITED),
-				makeGCContainer("deleted", "bar1", 0, 0, runtimeApi.ContainerState_EXITED),
+				makeGCContainer("deleted", "bar1", 2, time.Now().UnixNano(), runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("deleted", "bar1", 1, 1, runtimeApi.ContainerState_CONTAINER_EXITED),
+				makeGCContainer("deleted", "bar1", 0, 0, runtimeApi.ContainerState_CONTAINER_EXITED),
 			},
 			remain: []int{0, 1, 2},
 		},
diff --git a/pkg/kubelet/kuberuntime/kuberuntime_manager.go b/pkg/kubelet/kuberuntime/kuberuntime_manager.go
index b0f4378cc4a..0d4b6dddd86 100644
--- a/pkg/kubelet/kuberuntime/kuberuntime_manager.go
+++ b/pkg/kubelet/kuberuntime/kuberuntime_manager.go
@@ -393,14 +393,14 @@ func (m *kubeGenericRuntimeManager) podSandboxChanged(pod *api.Pod, podStatus *k
 
 	readySandboxCount := 0
 	for _, s := range podStatus.SandboxStatuses {
-		if s.GetState() == runtimeApi.PodSandBoxState_READY {
+		if s.GetState() == runtimeApi.PodSandboxState_SANDBOX_READY {
 			readySandboxCount++
 		}
 	}
 
 	// Needs to create a new sandbox when readySandboxCount > 1 or the ready sandbox is not the latest one.
 	sandboxStatus := podStatus.SandboxStatuses[0]
-	if readySandboxCount > 1 || sandboxStatus.GetState() != runtimeApi.PodSandBoxState_READY {
+	if readySandboxCount > 1 || sandboxStatus.GetState() != runtimeApi.PodSandboxState_SANDBOX_READY {
 		glog.V(2).Infof("No ready sandbox for pod %q can be found. Need to start a new one", format.Pod(pod))
 		return true, sandboxStatus.Metadata.GetAttempt() + 1, sandboxStatus.GetId()
 	}
@@ -865,7 +865,7 @@ func (m *kubeGenericRuntimeManager) GetPodStatus(uid kubetypes.UID, name, namesp
 		sandboxStatuses[idx] = podSandboxStatus
 
 		// Only get pod IP from latest sandbox
-		if idx == 0 && podSandboxStatus.GetState() == runtimeApi.PodSandBoxState_READY {
+		if idx == 0 && podSandboxStatus.GetState() == runtimeApi.PodSandboxState_SANDBOX_READY {
 			podIP = m.determinePodSandboxIP(namespace, name, podSandboxStatus)
 		}
 	}
diff --git a/pkg/kubelet/kuberuntime/kuberuntime_manager_test.go b/pkg/kubelet/kuberuntime/kuberuntime_manager_test.go
index 1e549284a7d..07610e1b92d 100644
--- a/pkg/kubelet/kuberuntime/kuberuntime_manager_test.go
+++ b/pkg/kubelet/kuberuntime/kuberuntime_manager_test.go
@@ -66,7 +66,7 @@ type sandboxTemplate struct {
 	pod       *api.Pod
 	attempt   uint32
 	createdAt int64
-	state     runtimeApi.PodSandBoxState
+	state     runtimeApi.PodSandboxState
 }
 
 // containerTemplate is a container template to create fake container.
@@ -86,7 +86,7 @@ func makeAndSetFakePod(t *testing.T, m *kubeGenericRuntimeManager, fakeRuntime *
 	sandbox := makeFakePodSandbox(t, m, sandboxTemplate{
 		pod:       pod,
 		createdAt: fakeCreatedAt,
-		state:     runtimeApi.PodSandBoxState_READY,
+		state:     runtimeApi.PodSandboxState_SANDBOX_READY,
 	})
 
 	var containers []*apitest.FakeContainer
@@ -95,7 +95,7 @@ func makeAndSetFakePod(t *testing.T, m *kubeGenericRuntimeManager, fakeRuntime *
 			pod:       pod,
 			container: c,
 			createdAt: fakeCreatedAt,
-			state:     runtimeApi.ContainerState_RUNNING,
+			state:     runtimeApi.ContainerState_CONTAINER_RUNNING,
 		}
 	}
 	for i := range pod.Spec.Containers {
@@ -509,10 +509,10 @@ func TestKillPod(t *testing.T) {
 	assert.Equal(t, 2, len(fakeRuntime.Containers))
 	assert.Equal(t, 1, len(fakeRuntime.Sandboxes))
 	for _, sandbox := range fakeRuntime.Sandboxes {
-		assert.Equal(t, runtimeApi.PodSandBoxState_NOTREADY, sandbox.GetState())
+		assert.Equal(t, runtimeApi.PodSandboxState_SANDBOX_NOTREADY, sandbox.GetState())
 	}
 	for _, c := range fakeRuntime.Containers {
-		assert.Equal(t, runtimeApi.ContainerState_EXITED, c.GetState())
+		assert.Equal(t, runtimeApi.ContainerState_CONTAINER_EXITED, c.GetState())
 	}
 }
 
@@ -550,10 +550,10 @@ func TestSyncPod(t *testing.T) {
 	assert.Equal(t, 2, len(fakeImage.Images))
 	assert.Equal(t, 1, len(fakeRuntime.Sandboxes))
 	for _, sandbox := range fakeRuntime.Sandboxes {
-		assert.Equal(t, runtimeApi.PodSandBoxState_READY, sandbox.GetState())
+		assert.Equal(t, runtimeApi.PodSandboxState_SANDBOX_READY, sandbox.GetState())
 	}
 	for _, c := range fakeRuntime.Containers {
-		assert.Equal(t, runtimeApi.ContainerState_RUNNING, c.GetState())
+		assert.Equal(t, runtimeApi.ContainerState_CONTAINER_RUNNING, c.GetState())
 	}
 }
 
@@ -575,11 +575,11 @@ func TestPruneInitContainers(t *testing.T) {
 	}
 
 	templates := []containerTemplate{
-		{pod: pod, container: &init1, attempt: 2, createdAt: 2, state: runtimeApi.ContainerState_EXITED},
-		{pod: pod, container: &init1, attempt: 1, createdAt: 1, state: runtimeApi.ContainerState_EXITED},
-		{pod: pod, container: &init2, attempt: 1, createdAt: 1, state: runtimeApi.ContainerState_EXITED},
-		{pod: pod, container: &init2, attempt: 0, createdAt: 0, state: runtimeApi.ContainerState_EXITED},
-		{pod: pod, container: &init1, attempt: 0, createdAt: 0, state: runtimeApi.ContainerState_EXITED},
+		{pod: pod, container: &init1, attempt: 2, createdAt: 2, state: runtimeApi.ContainerState_CONTAINER_EXITED},
+		{pod: pod, container: &init1, attempt: 1, createdAt: 1, state: runtimeApi.ContainerState_CONTAINER_EXITED},
+		{pod: pod, container: &init2, attempt: 1, createdAt: 1, state: runtimeApi.ContainerState_CONTAINER_EXITED},
+		{pod: pod, container: &init2, attempt: 0, createdAt: 0, state: runtimeApi.ContainerState_CONTAINER_EXITED},
+		{pod: pod, container: &init1, attempt: 0, createdAt: 0, state: runtimeApi.ContainerState_CONTAINER_EXITED},
 	}
 	fakes := makeFakeContainers(t, m, templates)
 	fakeRuntime.SetFakeContainers(fakes)
diff --git a/pkg/kubelet/kuberuntime/kuberuntime_sandbox.go b/pkg/kubelet/kuberuntime/kuberuntime_sandbox.go
index a2d5232025e..f42e8f13a9e 100644
--- a/pkg/kubelet/kuberuntime/kuberuntime_sandbox.go
+++ b/pkg/kubelet/kuberuntime/kuberuntime_sandbox.go
@@ -153,7 +153,7 @@ func generatePodSandboxLinuxConfig(pod *api.Pod, cgroupParent string) *runtimeAp
 func (m *kubeGenericRuntimeManager) getKubeletSandboxes(all bool) ([]*runtimeApi.PodSandbox, error) {
 	var filter *runtimeApi.PodSandboxFilter
 	if !all {
-		readyState := runtimeApi.PodSandBoxState_READY
+		readyState := runtimeApi.PodSandboxState_SANDBOX_READY
 		filter = &runtimeApi.PodSandboxFilter{
 			State: &readyState,
 		}
@@ -195,7 +195,7 @@ func (m *kubeGenericRuntimeManager) determinePodSandboxIP(podNamespace, podName
 
 // getPodSandboxID gets the sandbox id by podUID and returns ([]sandboxID, error).
 // Param state could be nil in order to get all sandboxes belonging to same pod.
-func (m *kubeGenericRuntimeManager) getSandboxIDByPodUID(podUID string, state *runtimeApi.PodSandBoxState) ([]string, error) {
+func (m *kubeGenericRuntimeManager) getSandboxIDByPodUID(podUID string, state *runtimeApi.PodSandboxState) ([]string, error) {
 	filter := &runtimeApi.PodSandboxFilter{
 		State:         state,
 		LabelSelector: map[string]string{types.KubernetesPodUIDLabel: podUID},
diff --git a/pkg/kubelet/rktshim/fake-app-interface.go b/pkg/kubelet/rktshim/fake-app-interface.go
index 433f52e9c8f..01349206f93 100644
--- a/pkg/kubelet/rktshim/fake-app-interface.go
+++ b/pkg/kubelet/rktshim/fake-app-interface.go
@@ -88,13 +88,13 @@ type fakeContainer struct {
 }
 
 func (c *fakeContainer) Start() {
-	c.State = runtimeApi.ContainerState_RUNNING
+	c.State = runtimeApi.ContainerState_CONTAINER_RUNNING
 
 	c.Status.State = &c.State
 }
 
 func (c *fakeContainer) Stop() {
-	c.State = runtimeApi.ContainerState_EXITED
+	c.State = runtimeApi.ContainerState_CONTAINER_EXITED
 
 	c.Status.State = &c.State
 
@@ -135,11 +135,11 @@ func (r *FakeRuntime) StartContainer(id string) error {
 		return ErrContainerNotFound
 	}
 	switch c.State {
-	case runtimeApi.ContainerState_EXITED:
+	case runtimeApi.ContainerState_CONTAINER_EXITED:
 		fallthrough
-	case runtimeApi.ContainerState_CREATED:
+	case runtimeApi.ContainerState_CONTAINER_CREATED:
 		c.Start()
-	case runtimeApi.ContainerState_UNKNOWN:
+	case runtimeApi.ContainerState_CONTAINER_UNKNOWN:
 		// TODO(tmrts): add timeout to Start API or generalize timeout somehow
 		//<-time.After(time.Duration(timeout) * time.Second)
 		fallthrough
@@ -157,9 +157,9 @@ func (r *FakeRuntime) StopContainer(id string, timeout int64) error {
 	}
 
 	switch c.State {
-	case runtimeApi.ContainerState_RUNNING:
-		c.State = runtimeApi.ContainerState_EXITED // This state might not be the best one
-	case runtimeApi.ContainerState_UNKNOWN:
+	case runtimeApi.ContainerState_CONTAINER_RUNNING:
+		c.State = runtimeApi.ContainerState_CONTAINER_EXITED // This state might not be the best one
+	case runtimeApi.ContainerState_CONTAINER_UNKNOWN:
 		<-time.After(time.Duration(timeout) * time.Second)
 		fallthrough
 	default:
@@ -214,7 +214,7 @@ func (r *FakeRuntime) ExecSync(containerID string, cmd []string, timeout time.Du
 	}
 
 	// TODO(tmrts): Validate the assumption that container has to be running for exec to work.
-	if c.State != runtimeApi.ContainerState_RUNNING {
+	if c.State != runtimeApi.ContainerState_CONTAINER_RUNNING {
 		return nil, nil, ErrInvalidContainerStateTransition
 	}