@@ -2680,7 +2680,13 @@ definitions:

                     ConfigName is the name of the config that this references, but this is just provided for

                     lookup/display purposes. The config in the reference will be identified by its ID.

                   type: "string"

-

+          Isolation:

+            type: "string"

+            description: "Isolation technology of the containers running the service. (Windows only)"

+            enum:

+              - "default"

+              - "process"

+              - "hyperv"

       Resources:

         description: "Resource requirements which apply to each individual container created as part of the service."

         type: "object"

@@ -20,6 +20,27 @@ func (i Isolation) IsDefault() bool {

 	return strings.ToLower(string(i)) == "default" || string(i) == ""

 }

+// IsHyperV indicates the use of a Hyper-V partition for isolation

+func (i Isolation) IsHyperV() bool {

+	return strings.ToLower(string(i)) == "hyperv"

+}

+

+// IsProcess indicates the use of process isolation

+func (i Isolation) IsProcess() bool {

+	return strings.ToLower(string(i)) == "process"

+}

+

+const (

+	// IsolationEmpty is unspecified (same behavior as default)

+	IsolationEmpty = Isolation("")

+	// IsolationDefault is the default isolation mode on current daemon

+	IsolationDefault = Isolation("default")

+	// IsolationProcess is process isolation mode

+	IsolationProcess = Isolation("process")

+	// IsolationHyperV is HyperV isolation mode

+	IsolationHyperV = Isolation("hyperv")

+)

+

 // IpcMode represents the container ipc stack.

 type IpcMode string

@@ -1,9 +1,5 @@

 package container

-import (

-	"strings"

-)

-

 // IsBridge indicates whether container uses the bridge network stack

 // in windows it is given the name NAT

 func (n NetworkMode) IsBridge() bool {

@@ -21,16 +17,6 @@ func (n NetworkMode) IsUserDefined() bool {

 	return !n.IsDefault() && !n.IsNone() && !n.IsBridge() && !n.IsContainer()

 }

-// IsHyperV indicates the use of a Hyper-V partition for isolation

-func (i Isolation) IsHyperV() bool {

-	return strings.ToLower(string(i)) == "hyperv"

-}

-

-// IsProcess indicates the use of process isolation

-func (i Isolation) IsProcess() bool {

-	return strings.ToLower(string(i)) == "process"

-}

-

 // IsValid indicates if an isolation technology is valid

 func (i Isolation) IsValid() bool {

 	return i.IsDefault() || i.IsHyperV() || i.IsProcess()

@@ -65,8 +65,9 @@ type ContainerSpec struct {

 	// The format of extra hosts on swarmkit is specified in:

 	// http://man7.org/linux/man-pages/man5/hosts.5.html

 	//    IP_address canonical_hostname [aliases...]

-	Hosts     []string           `json:",omitempty"`

-	DNSConfig *DNSConfig         `json:",omitempty"`

-	Secrets   []*SecretReference `json:",omitempty"`

-	Configs   []*ConfigReference `json:",omitempty"`

+	Hosts     []string            `json:",omitempty"`

+	DNSConfig *DNSConfig          `json:",omitempty"`

+	Secrets   []*SecretReference  `json:",omitempty"`

+	Configs   []*ConfigReference  `json:",omitempty"`

+	Isolation container.Isolation `json:",omitempty"`

 }

@@ -34,6 +34,7 @@ func containerSpecFromGRPC(c *swarmapi.ContainerSpec) *types.ContainerSpec {

 		Hosts:      c.Hosts,

 		Secrets:    secretReferencesFromGRPC(c.Secrets),

 		Configs:    configReferencesFromGRPC(c.Configs),

+		Isolation:  IsolationFromGRPC(c.Isolation),

 	}

 	if c.DNSConfig != nil {

@@ -232,6 +233,7 @@ func containerToGRPC(c *types.ContainerSpec) (*swarmapi.ContainerSpec, error) {

 		Hosts:      c.Hosts,

 		Secrets:    secretReferencesToGRPC(c.Secrets),

 		Configs:    configReferencesToGRPC(c.Configs),

+		Isolation:  isolationToGRPC(c.Isolation),

 	}

 	if c.DNSConfig != nil {

@@ -354,3 +356,26 @@ func healthConfigToGRPC(h *container.HealthConfig) *swarmapi.HealthConfig {

 		StartPeriod: gogotypes.DurationProto(h.StartPeriod),

 	}

 }

+

+// IsolationFromGRPC converts a swarm api container isolation to a moby isolation representation

+func IsolationFromGRPC(i swarmapi.ContainerSpec_Isolation) container.Isolation {

+	switch i {

+	case swarmapi.ContainerIsolationHyperV:

+		return container.IsolationHyperV

+	case swarmapi.ContainerIsolationProcess:

+		return container.IsolationProcess

+	case swarmapi.ContainerIsolationDefault:

+		return container.IsolationDefault

+	}

+	return container.IsolationEmpty

+}

+

+func isolationToGRPC(i container.Isolation) swarmapi.ContainerSpec_Isolation {

+	if i.IsHyperV() {

+		return swarmapi.ContainerIsolationHyperV

+	}

+	if i.IsProcess() {

+		return swarmapi.ContainerIsolationProcess

+	}

+	return swarmapi.ContainerIsolationDefault

+}

@@ -3,10 +3,12 @@ package convert

 import (

 	"testing"

+	containertypes "github.com/docker/docker/api/types/container"

 	swarmtypes "github.com/docker/docker/api/types/swarm"

 	"github.com/docker/docker/api/types/swarm/runtime"

 	swarmapi "github.com/docker/swarmkit/api"

 	google_protobuf3 "github.com/gogo/protobuf/types"

+	"github.com/stretchr/testify/require"

 )

 func TestServiceConvertFromGRPCRuntimeContainer(t *testing.T) {

@@ -148,3 +150,85 @@ func TestServiceConvertToGRPCGenericRuntimeCustom(t *testing.T) {

 		t.Fatal(err)

 	}

 }

+

+func TestServiceConvertToGRPCIsolation(t *testing.T) {

+	cases := []struct {

+		name string

+		from containertypes.Isolation

+		to   swarmapi.ContainerSpec_Isolation

+	}{

+		{name: "empty", from: containertypes.IsolationEmpty, to: swarmapi.ContainerIsolationDefault},

+		{name: "default", from: containertypes.IsolationDefault, to: swarmapi.ContainerIsolationDefault},

+		{name: "process", from: containertypes.IsolationProcess, to: swarmapi.ContainerIsolationProcess},

+		{name: "hyperv", from: containertypes.IsolationHyperV, to: swarmapi.ContainerIsolationHyperV},

+		{name: "proCess", from: containertypes.Isolation("proCess"), to: swarmapi.ContainerIsolationProcess},

+		{name: "hypErv", from: containertypes.Isolation("hypErv"), to: swarmapi.ContainerIsolationHyperV},

+	}

+	for _, c := range cases {

+		t.Run(c.name, func(t *testing.T) {

+			s := swarmtypes.ServiceSpec{

+				TaskTemplate: swarmtypes.TaskSpec{

+					ContainerSpec: &swarmtypes.ContainerSpec{

+						Image:     "alpine:latest",

+						Isolation: c.from,

+					},

+				},

+				Mode: swarmtypes.ServiceMode{

+					Global: &swarmtypes.GlobalService{},

+				},

+			}

+			res, err := ServiceSpecToGRPC(s)

+			require.NoError(t, err)

+			v, ok := res.Task.Runtime.(*swarmapi.TaskSpec_Container)

+			if !ok {

+				t.Fatal("expected type swarmapi.TaskSpec_Container")

+			}

+			require.Equal(t, c.to, v.Container.Isolation)

+		})

+	}

+}

+

+func TestServiceConvertFromGRPCIsolation(t *testing.T) {

+	cases := []struct {

+		name string

+		from swarmapi.ContainerSpec_Isolation

+		to   containertypes.Isolation

+	}{

+		{name: "default", to: containertypes.IsolationDefault, from: swarmapi.ContainerIsolationDefault},

+		{name: "process", to: containertypes.IsolationProcess, from: swarmapi.ContainerIsolationProcess},

+		{name: "hyperv", to: containertypes.IsolationHyperV, from: swarmapi.ContainerIsolationHyperV},

+	}

+	for _, c := range cases {

+		t.Run(c.name, func(t *testing.T) {

+			gs := swarmapi.Service{

+				Meta: swarmapi.Meta{

+					Version: swarmapi.Version{

+						Index: 1,

+					},

+					CreatedAt: nil,

+					UpdatedAt: nil,

+				},

+				SpecVersion: &swarmapi.Version{

+					Index: 1,

+				},

+				Spec: swarmapi.ServiceSpec{

+					Task: swarmapi.TaskSpec{

+						Runtime: &swarmapi.TaskSpec_Container{

+							Container: &swarmapi.ContainerSpec{

+								Image:     "alpine:latest",

+								Isolation: c.from,

+							},

+						},

+					},

+				},

+			}

+

+			svc, err := ServiceFromGRPC(gs)

+			if err != nil {

+				t.Fatal(err)

+			}

+

+			require.Equal(t, c.to, svc.Spec.TaskTemplate.ContainerSpec.Isolation)

+		})

+	}

+}

@@ -168,6 +168,10 @@ func (c *containerConfig) portBindings() nat.PortMap {

 	return portBindings

 }

+func (c *containerConfig) isolation() enginecontainer.Isolation {

+	return convert.IsolationFromGRPC(c.spec().Isolation)

+}

+

 func (c *containerConfig) exposedPorts() map[nat.Port]struct{} {

 	exposedPorts := make(map[nat.Port]struct{})

 	if c.task.Endpoint == nil {

@@ -350,6 +354,7 @@ func (c *containerConfig) hostConfig() *enginecontainer.HostConfig {

 		PortBindings:   c.portBindings(),

 		Mounts:         c.mounts(),

 		ReadonlyRootfs: c.spec().ReadOnly,

+		Isolation:      c.isolation(),

 	}

 	if c.spec().DNSConfig != nil {

new file mode 100644

@@ -0,0 +1,37 @@

+package container

+

+import (

+	"testing"

+

+	container "github.com/docker/docker/api/types/container"

+	swarmapi "github.com/docker/swarmkit/api"

+	"github.com/stretchr/testify/require"

+)

+

+func TestIsolationConversion(t *testing.T) {

+	cases := []struct {

+		name string

+		from swarmapi.ContainerSpec_Isolation

+		to   container.Isolation

+	}{

+		{name: "default", from: swarmapi.ContainerIsolationDefault, to: container.IsolationDefault},

+		{name: "process", from: swarmapi.ContainerIsolationProcess, to: container.IsolationProcess},

+		{name: "hyperv", from: swarmapi.ContainerIsolationHyperV, to: container.IsolationHyperV},

+	}

+	for _, c := range cases {

+		t.Run(c.name, func(t *testing.T) {

+			task := swarmapi.Task{

+				Spec: swarmapi.TaskSpec{

+					Runtime: &swarmapi.TaskSpec_Container{

+						Container: &swarmapi.ContainerSpec{

+							Image:     "alpine:latest",

+							Isolation: c.from,

+						},

+					},

+				},

+			}

+			config := containerConfig{task: &task}

+			require.Equal(t, c.to, config.hostConfig().Isolation)

+		})

+	}

+}

@@ -23,6 +23,7 @@ keywords: "API, Docker, rcli, REST, documentation"

   If `Error` is `null`, container removal has succeeded, otherwise

   the test of an error message indicating why container removal has failed

   is available from `Error.Message` field.

+* `POST /services/create` and `POST /services/(id)/update` now accept an `Isolation` field on container spec

 ## v1.33 API changes

@@ -198,6 +198,23 @@ func (d *Swarm) CheckServiceTasksInState(service string, state swarm.TaskState,

 	}

 }

+// CheckServiceTasksInStateWithError returns the number of tasks with a matching state,

+// and optional message substring.

+func (d *Swarm) CheckServiceTasksInStateWithError(service string, state swarm.TaskState, errorMessage string) func(*check.C) (interface{}, check.CommentInterface) {

+	return func(c *check.C) (interface{}, check.CommentInterface) {

+		tasks := d.GetServiceTasks(c, service)

+		var count int

+		for _, task := range tasks {

+			if task.Status.State == state {

+				if errorMessage == "" || strings.Contains(task.Status.Err, errorMessage) {

+					count++

+				}

+			}

+		}

+		return count, nil

+	}

+}

+

 // CheckServiceRunningTasks returns the number of running tasks for the specified service

 func (d *Swarm) CheckServiceRunningTasks(service string) func(*check.C) (interface{}, check.CommentInterface) {

 	return d.CheckServiceTasksInState(service, swarm.TaskStateRunning, "")

@@ -19,7 +19,7 @@ func (s *DockerSwarmSuite) TestSwarmVolumePlugin(c *check.C) {

 	c.Assert(err, checker.IsNil, check.Commentf(out))

 	// Make sure task stays pending before plugin is available

-	waitAndAssert(c, defaultReconciliationTimeout, d.CheckServiceTasksInState("top", swarm.TaskStatePending, "missing plugin on 1 node"), checker.Equals, 1)

+	waitAndAssert(c, defaultReconciliationTimeout, d.CheckServiceTasksInStateWithError("top", swarm.TaskStatePending, "missing plugin on 1 node"), checker.Equals, 1)

 	plugin := newVolumePlugin(c, "customvolumedriver")

 	defer plugin.Close()

@@ -6,6 +6,7 @@ import (

 	"time"

 	"github.com/docker/docker/api/types"

+	"github.com/docker/docker/api/types/container"

 	"github.com/docker/docker/api/types/filters"

 	"github.com/docker/docker/api/types/swarm"

 	"github.com/docker/docker/client"

@@ -76,6 +77,7 @@ func fullSwarmServiceSpec(name string, replicas uint64) swarm.ServiceSpec {

 					Nameservers: []string{"8.8.8.8"},

 					Search:      []string{"somedomain"},

 				},

+				Isolation: container.IsolationDefault,

 			},

 			RestartPolicy: &swarm.RestartPolicy{

 				Delay:       &restartDelay,

@@ -103,7 +103,6 @@ github.com/googleapis/gax-go da06d194a00e19ce00d9011a13931c3f6f6887c7

 google.golang.org/genproto d80a6e20e776b0b17a324d0ba1ab50a39c8e8944

 # containerd

-github.com/stevvooe/continuity cd7a8e21e2b6f84799f5dd4b65faf49c8d3ee02d

 github.com/containerd/containerd 992280e8e265f491f7a624ab82f3e238be086e49

 github.com/containerd/fifo fbfb6a11ec671efbe94ad1c12c2e98773f19e1e6

 github.com/containerd/continuity 35d55c5e8dd23b32037d56cf97174aff3efdfa83

@@ -114,7 +113,7 @@ github.com/containerd/typeurl f6943554a7e7e88b3c14aad190bf05932da84788

 github.com/dmcgowan/go-tar 2e2c51242e8993c50445dab7c03c8e7febddd0cf

 # cluster

-github.com/docker/swarmkit 872861d2ae46958af7ead1d5fffb092c73afbaf0

+github.com/docker/swarmkit 28f91d87bd3f75fd039dbb9be49bfd2381019261

 github.com/gogo/protobuf v0.4

 github.com/cloudflare/cfssl 7fb22c8cba7ecaf98e4082d22d65800cf45e042a

 github.com/google/certificate-transparency d90e65c3a07988180c5b1ece71791c0b6506826e

@@ -119,6 +119,7 @@ func Resolve(ctx context.Context, task *api.Task, executor Executor) (Controller

 		// we always want to proceed to accepted when we resolve the controller

 		status.Message = "accepted"

 		status.State = api.TaskStateAccepted

+		status.Err = ""

 	}

 	return ctlr, status, err

@@ -158,6 +159,7 @@ func Do(ctx context.Context, task *api.Task, ctlr Controller) (*api.TaskStatus,

 		current := status.State

 		status.State = state

 		status.Message = msg

+		status.Err = ""

 		if current > state {

 			panic("invalid state transition")

@@ -10,6 +10,7 @@ import math "math"

 import _ "github.com/gogo/protobuf/gogoproto"

 import google_protobuf1 "github.com/gogo/protobuf/types"

 import google_protobuf3 "github.com/gogo/protobuf/types"

+import google_protobuf4 "github.com/gogo/protobuf/types"

 import github_com_docker_swarmkit_api_deepcopy "github.com/docker/swarmkit/api/deepcopy"

@@ -74,6 +75,35 @@ func (x NodeSpec_Availability) String() string {

 }

 func (NodeSpec_Availability) EnumDescriptor() ([]byte, []int) { return fileDescriptorSpecs, []int{0, 1} }

+type ContainerSpec_Isolation int32

+

+const (

+	// ISOLATION_DEFAULT uses whatever default value from the container runtime

+	ContainerIsolationDefault ContainerSpec_Isolation = 0

+	// ISOLATION_PROCESS forces windows container isolation

+	ContainerIsolationProcess ContainerSpec_Isolation = 1

+	// ISOLATION_HYPERV forces Hyper-V isolation

+	ContainerIsolationHyperV ContainerSpec_Isolation = 2

+)

+

+var ContainerSpec_Isolation_name = map[int32]string{

+	0: "ISOLATION_DEFAULT",

+	1: "ISOLATION_PROCESS",

+	2: "ISOLATION_HYPERV",

+}

+var ContainerSpec_Isolation_value = map[string]int32{

+	"ISOLATION_DEFAULT": 0,

+	"ISOLATION_PROCESS": 1,

+	"ISOLATION_HYPERV":  2,

+}

+

+func (x ContainerSpec_Isolation) String() string {

+	return proto.EnumName(ContainerSpec_Isolation_name, int32(x))

+}

+func (ContainerSpec_Isolation) EnumDescriptor() ([]byte, []int) {

+	return fileDescriptorSpecs, []int{8, 0}

+}

+

 // ResolutionMode specifies the mode of resolution to use for

 // internal loadbalancing between tasks which are all within

 // the cluster. This is sometimes calls east-west data path.

@@ -542,6 +572,8 @@ type ContainerSpec struct {

 	Groups []string `protobuf:"bytes,11,rep,name=groups" json:"groups,omitempty"`

 	// Privileges specifies security configuration/permissions.

 	Privileges *Privileges `protobuf:"bytes,22,opt,name=privileges" json:"privileges,omitempty"`

+	// Init declares that a custom init will be running inside the container, if null, use the daemon's configured settings

+	Init *google_protobuf4.BoolValue `protobuf:"bytes,23,opt,name=init" json:"init,omitempty"`

 	// TTY declares that a TTY should be attached to the standard streams,

 	// including stdin if it is still open.

 	TTY bool `protobuf:"varint,13,opt,name=tty,proto3" json:"tty,omitempty"`

@@ -585,6 +617,9 @@ type ContainerSpec struct {

 	// task will exit and a new task will be rescheduled elsewhere. A container

 	// is considered unhealthy after `Retries` number of consecutive failures.

 	Healthcheck *HealthConfig `protobuf:"bytes,16,opt,name=healthcheck" json:"healthcheck,omitempty"`

+	// Isolation defines the isolation level for windows containers (default, process, hyperv).

+	// Runtimes that don't support it ignore that field

+	Isolation ContainerSpec_Isolation `protobuf:"varint,24,opt,name=isolation,proto3,enum=docker.swarmkit.v1.ContainerSpec_Isolation" json:"isolation,omitempty"`

 }

 func (m *ContainerSpec) Reset()                    { *m = ContainerSpec{} }

@@ -830,6 +865,7 @@ func init() {

 	proto.RegisterType((*ConfigSpec)(nil), "docker.swarmkit.v1.ConfigSpec")

 	proto.RegisterEnum("docker.swarmkit.v1.NodeSpec_Membership", NodeSpec_Membership_name, NodeSpec_Membership_value)

 	proto.RegisterEnum("docker.swarmkit.v1.NodeSpec_Availability", NodeSpec_Availability_name, NodeSpec_Availability_value)

+	proto.RegisterEnum("docker.swarmkit.v1.ContainerSpec_Isolation", ContainerSpec_Isolation_name, ContainerSpec_Isolation_value)

 	proto.RegisterEnum("docker.swarmkit.v1.EndpointSpec_ResolutionMode", EndpointSpec_ResolutionMode_name, EndpointSpec_ResolutionMode_value)

 }

@@ -1090,6 +1126,10 @@ func (m *ContainerSpec) CopyFrom(src interface{}) {

 		m.Privileges = &Privileges{}

 		github_com_docker_swarmkit_api_deepcopy.Copy(m.Privileges, o.Privileges)

 	}

+	if o.Init != nil {

+		m.Init = &google_protobuf4.BoolValue{}

+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Init, o.Init)

+	}

 	if o.Mounts != nil {

 		m.Mounts = make([]Mount, len(o.Mounts))

 		for i := range m.Mounts {

@@ -1996,6 +2036,25 @@ func (m *ContainerSpec) MarshalTo(dAtA []byte) (int, error) {

 		}

 		i += n23

 	}

+	if m.Init != nil {

+		dAtA[i] = 0xba

+		i++

+		dAtA[i] = 0x1

+		i++

+		i = encodeVarintSpecs(dAtA, i, uint64(m.Init.Size()))

+		n24, err := m.Init.MarshalTo(dAtA[i:])

+		if err != nil {

+			return 0, err

+		}

+		i += n24

+	}

+	if m.Isolation != 0 {

+		dAtA[i] = 0xc0

+		i++

+		dAtA[i] = 0x1

+		i++

+		i = encodeVarintSpecs(dAtA, i, uint64(m.Isolation))

+	}

 	return i, nil

 }

@@ -2141,20 +2200,20 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) {

 	dAtA[i] = 0xa

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))

-	n24, err := m.Annotations.MarshalTo(dAtA[i:])

+	n25, err := m.Annotations.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n24

+	i += n25

 	if m.DriverConfig != nil {

 		dAtA[i] = 0x12

 		i++

 		i = encodeVarintSpecs(dAtA, i, uint64(m.DriverConfig.Size()))

-		n25, err := m.DriverConfig.MarshalTo(dAtA[i:])

+		n26, err := m.DriverConfig.MarshalTo(dAtA[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n25

+		i += n26

 	}

 	if m.Ipv6Enabled {

 		dAtA[i] = 0x18

@@ -2180,11 +2239,11 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) {

 		dAtA[i] = 0x2a

 		i++

 		i = encodeVarintSpecs(dAtA, i, uint64(m.IPAM.Size()))

-		n26, err := m.IPAM.MarshalTo(dAtA[i:])

+		n27, err := m.IPAM.MarshalTo(dAtA[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n26

+		i += n27

 	}

 	if m.Attachable {

 		dAtA[i] = 0x30

@@ -2207,11 +2266,11 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) {

 		i++

 	}

 	if m.ConfigFrom != nil {

-		nn27, err := m.ConfigFrom.MarshalTo(dAtA[i:])

+		nn28, err := m.ConfigFrom.MarshalTo(dAtA[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += nn27

+		i += nn28

 	}

 	return i, nil

 }

@@ -2242,67 +2301,67 @@ func (m *ClusterSpec) MarshalTo(dAtA []byte) (int, error) {

 	dAtA[i] = 0xa

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))

-	n28, err := m.Annotations.MarshalTo(dAtA[i:])

+	n29, err := m.Annotations.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n28

+	i += n29

 	dAtA[i] = 0x12

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.AcceptancePolicy.Size()))

-	n29, err := m.AcceptancePolicy.MarshalTo(dAtA[i:])

+	n30, err := m.AcceptancePolicy.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n29

+	i += n30

 	dAtA[i] = 0x1a

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.Orchestration.Size()))

-	n30, err := m.Orchestration.MarshalTo(dAtA[i:])

+	n31, err := m.Orchestration.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n30

+	i += n31

 	dAtA[i] = 0x22

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.Raft.Size()))

-	n31, err := m.Raft.MarshalTo(dAtA[i:])

+	n32, err := m.Raft.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n31

+	i += n32

 	dAtA[i] = 0x2a

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.Dispatcher.Size()))

-	n32, err := m.Dispatcher.MarshalTo(dAtA[i:])

+	n33, err := m.Dispatcher.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n32

+	i += n33

 	dAtA[i] = 0x32

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.CAConfig.Size()))

-	n33, err := m.CAConfig.MarshalTo(dAtA[i:])

+	n34, err := m.CAConfig.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n33

+	i += n34

 	dAtA[i] = 0x3a

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.TaskDefaults.Size()))

-	n34, err := m.TaskDefaults.MarshalTo(dAtA[i:])

+	n35, err := m.TaskDefaults.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n34

+	i += n35

 	dAtA[i] = 0x42

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.EncryptionConfig.Size()))

-	n35, err := m.EncryptionConfig.MarshalTo(dAtA[i:])

+	n36, err := m.EncryptionConfig.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n35

+	i += n36

 	return i, nil

 }

@@ -2324,11 +2383,11 @@ func (m *SecretSpec) MarshalTo(dAtA []byte) (int, error) {

 	dAtA[i] = 0xa

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))

-	n36, err := m.Annotations.MarshalTo(dAtA[i:])

+	n37, err := m.Annotations.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n36

+	i += n37

 	if len(m.Data) > 0 {

 		dAtA[i] = 0x12

 		i++

@@ -2339,21 +2398,21 @@ func (m *SecretSpec) MarshalTo(dAtA []byte) (int, error) {

 		dAtA[i] = 0x1a

 		i++

 		i = encodeVarintSpecs(dAtA, i, uint64(m.Templating.Size()))

-		n37, err := m.Templating.MarshalTo(dAtA[i:])

+		n38, err := m.Templating.MarshalTo(dAtA[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n37

+		i += n38

 	}

 	if m.Driver != nil {

 		dAtA[i] = 0x22

 		i++

 		i = encodeVarintSpecs(dAtA, i, uint64(m.Driver.Size()))

-		n38, err := m.Driver.MarshalTo(dAtA[i:])

+		n39, err := m.Driver.MarshalTo(dAtA[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n38

+		i += n39

 	}

 	return i, nil

 }

@@ -2376,11 +2435,11 @@ func (m *ConfigSpec) MarshalTo(dAtA []byte) (int, error) {

 	dAtA[i] = 0xa

 	i++

 	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))

-	n39, err := m.Annotations.MarshalTo(dAtA[i:])

+	n40, err := m.Annotations.MarshalTo(dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n39

+	i += n40

 	if len(m.Data) > 0 {

 		dAtA[i] = 0x12

 		i++

@@ -2391,11 +2450,11 @@ func (m *ConfigSpec) MarshalTo(dAtA []byte) (int, error) {

 		dAtA[i] = 0x1a

 		i++

 		i = encodeVarintSpecs(dAtA, i, uint64(m.Templating.Size()))

-		n40, err := m.Templating.MarshalTo(dAtA[i:])

+		n41, err := m.Templating.MarshalTo(dAtA[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n40

+		i += n41

 	}

 	return i, nil

 }

@@ -2721,6 +2780,13 @@ func (m *ContainerSpec) Size() (n int) {

 		l = m.Privileges.Size()

 		n += 2 + l + sovSpecs(uint64(l))

 	}

+	if m.Init != nil {

+		l = m.Init.Size()

+		n += 2 + l + sovSpecs(uint64(l))

+	}

+	if m.Isolation != 0 {

+		n += 2 + sovSpecs(uint64(m.Isolation))

+	}

 	return n

 }

@@ -3066,6 +3132,8 @@ func (this *ContainerSpec) String() string {

 		`StopSignal:` + fmt.Sprintf("%v", this.StopSignal) + `,`,

 		`Configs:` + strings.Replace(fmt.Sprintf("%v", this.Configs), "ConfigReference", "ConfigReference", 1) + `,`,

 		`Privileges:` + strings.Replace(fmt.Sprintf("%v", this.Privileges), "Privileges", "Privileges", 1) + `,`,

+		`Init:` + strings.Replace(fmt.Sprintf("%v", this.Init), "BoolValue", "google_protobuf4.BoolValue", 1) + `,`,

+		`Isolation:` + fmt.Sprintf("%v", this.Isolation) + `,`,

 		`}`,

 	}, "")

 	return s

@@ -5141,6 +5209,58 @@ func (m *ContainerSpec) Unmarshal(dAtA []byte) error {

 				return err

 			}

 			iNdEx = postIndex

+		case 23:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Init", wireType)

+			}

+			var msglen int

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowSpecs

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				msglen |= (int(b) & 0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			if msglen < 0 {

+				return ErrInvalidLengthSpecs

+			}

+			postIndex := iNdEx + msglen

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			if m.Init == nil {

+				m.Init = &google_protobuf4.BoolValue{}

+			}

+			if err := m.Init.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {

+				return err

+			}

+			iNdEx = postIndex

+		case 24:

+			if wireType != 0 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Isolation", wireType)

+			}

+			m.Isolation = 0

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowSpecs

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				m.Isolation |= (ContainerSpec_Isolation(b) & 0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

 		default:

 			iNdEx = preIndex

 			skippy, err := skipSpecs(dAtA[iNdEx:])

@@ -6452,129 +6572,138 @@ var (

 func init() { proto.RegisterFile("github.com/docker/swarmkit/api/specs.proto", fileDescriptorSpecs) }

 var fileDescriptorSpecs = []byte{

-	// 1975 bytes of a gzipped FileDescriptorProto

-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xcf, 0x6f, 0x1b, 0xb9,

-	0x15, 0xb6, 0x6c, 0x59, 0x3f, 0xde, 0xc8, 0x89, 0xc2, 0xcd, 0xa6, 0x13, 0xa5, 0x6b, 0x2b, 0xda,

-	0x6c, 0xea, 0xdd, 0x45, 0x25, 0xd4, 0x2d, 0xb6, 0xd9, 0x4d, 0xb7, 0xad, 0x64, 0xa9, 0x8e, 0x9b,

-	0xc6, 0x11, 0x68, 0x6f, 0xda, 0x00, 0x05, 0x04, 0x6a, 0x86, 0x1e, 0x0d, 0x3c, 0x1a, 0x4e, 0x39,

-	0x1c, 0x2d, 0x74, 0xeb, 0x71, 0x91, 0x1e, 0x7b, 0x0e, 0x7a, 0x28, 0x7a, 0xef, 0x9f, 0x91, 0x63,

-	0x8f, 0xed, 0xc5, 0xe8, 0xea, 0x5f, 0xe8, 0xad, 0x97, 0x16, 0xe4, 0x70, 0x46, 0xa3, 0x64, 0x6c,

-	0x07, 0x68, 0x0e, 0xbd, 0x91, 0x8f, 0xdf, 0xf7, 0x48, 0x3e, 0x7e, 0x8f, 0x7c, 0x84, 0x4f, 0x1c,

-	0x57, 0x4c, 0xa2, 0x71, 0xdb, 0x62, 0xd3, 0x8e, 0xcd, 0xac, 0x33, 0xca, 0x3b, 0xe1, 0xd7, 0x84,

-	0x4f, 0xcf, 0x5c, 0xd1, 0x21, 0x81, 0xdb, 0x09, 0x03, 0x6a, 0x85, 0xed, 0x80, 0x33, 0xc1, 0x10,

-	0x8a, 0x01, 0xed, 0x04, 0xd0, 0x9e, 0xfd, 0xa0, 0x71, 0x15, 0x5f, 0xcc, 0x03, 0xaa, 0xf9, 0x8d,

-	0x9b, 0x0e, 0x73, 0x98, 0x6a, 0x76, 0x64, 0x4b, 0x5b, 0xb7, 0x1d, 0xc6, 0x1c, 0x8f, 0x76, 0x54,

-	0x6f, 0x1c, 0x9d, 0x76, 0xec, 0x88, 0x13, 0xe1, 0x32, 0x5f, 0x8f, 0xdf, 0x7e, 0x7d, 0x9c, 0xf8,

-	0xf3, 0x78, 0xa8, 0xf5, 0xb2, 0x08, 0x95, 0x23, 0x66, 0xd3, 0xe3, 0x80, 0x5a, 0xe8, 0x00, 0x0c,

-	0xe2, 0xfb, 0x4c, 0x28, 0x6e, 0x68, 0x16, 0x9a, 0x85, 0x5d, 0x63, 0x6f, 0xa7, 0xfd, 0xe6, 0x9a,

-	0xdb, 0xdd, 0x25, 0xac, 0x57, 0x7c, 0x75, 0xbe, 0xb3, 0x86, 0xb3, 0x4c, 0xf4, 0x33, 0xa8, 0xd9,

-	0x34, 0x74, 0x39, 0xb5, 0x47, 0x9c, 0x79, 0xd4, 0x5c, 0x6f, 0x16, 0x76, 0xaf, 0xed, 0x7d, 0x37,

-	0xcf, 0x93, 0x9c, 0x1c, 0x33, 0x8f, 0x62, 0x43, 0x33, 0x64, 0x07, 0x1d, 0x00, 0x4c, 0xe9, 0x74,

-	0x4c, 0x79, 0x38, 0x71, 0x03, 0x73, 0x43, 0xd1, 0xbf, 0x77, 0x11, 0x5d, 0xae, 0xbd, 0xfd, 0x24,

-	0x85, 0xe3, 0x0c, 0x15, 0x3d, 0x81, 0x1a, 0x99, 0x11, 0xd7, 0x23, 0x63, 0xd7, 0x73, 0xc5, 0xdc,

-	0x2c, 0x2a, 0x57, 0x1f, 0x5f, 0xea, 0xaa, 0x9b, 0x21, 0xe0, 0x15, 0x7a, 0xcb, 0x06, 0x58, 0x4e,

-	0x84, 0xee, 0x43, 0x79, 0x38, 0x38, 0xea, 0x1f, 0x1e, 0x1d, 0xd4, 0xd7, 0x1a, 0xb7, 0x5f, 0xbc,

-	0x6c, 0xbe, 0x2f, 0x7d, 0x2c, 0x01, 0x43, 0xea, 0xdb, 0xae, 0xef, 0xa0, 0x5d, 0xa8, 0x74, 0xf7,

-	0xf7, 0x07, 0xc3, 0x93, 0x41, 0xbf, 0x5e, 0x68, 0x34, 0x5e, 0xbc, 0x6c, 0xde, 0x5a, 0x05, 0x76,

-	0x2d, 0x8b, 0x06, 0x82, 0xda, 0x8d, 0xe2, 0x37, 0x7f, 0xde, 0x5e, 0x6b, 0x7d, 0x53, 0x80, 0x5a,

-	0x76, 0x11, 0xe8, 0x3e, 0x94, 0xba, 0xfb, 0x27, 0x87, 0xcf, 0x06, 0xf5, 0xb5, 0x25, 0x3d, 0x8b,

-	0xe8, 0x5a, 0xc2, 0x9d, 0x51, 0x74, 0x0f, 0x36, 0x87, 0xdd, 0xaf, 0x8e, 0x07, 0xf5, 0xc2, 0x72,

-	0x39, 0x59, 0xd8, 0x90, 0x44, 0xa1, 0x42, 0xf5, 0x71, 0xf7, 0xf0, 0xa8, 0xbe, 0x9e, 0x8f, 0xea,

-	0x73, 0xe2, 0xfa, 0x7a, 0x29, 0x7f, 0x2a, 0x82, 0x71, 0x4c, 0xf9, 0xcc, 0xb5, 0xde, 0xb1, 0x44,

-	0x3e, 0x83, 0xa2, 0x20, 0xe1, 0x99, 0x92, 0x86, 0x91, 0x2f, 0x8d, 0x13, 0x12, 0x9e, 0xc9, 0x49,

-	0x35, 0x5d, 0xe1, 0xa5, 0x32, 0x38, 0x0d, 0x3c, 0xd7, 0x22, 0x82, 0xda, 0x4a, 0x19, 0xc6, 0xde,

-	0x47, 0x79, 0x6c, 0x9c, 0xa2, 0xf4, 0xfa, 0x1f, 0xad, 0xe1, 0x0c, 0x15, 0x3d, 0x84, 0x92, 0xe3,

-	0xb1, 0x31, 0xf1, 0x94, 0x26, 0x8c, 0xbd, 0xbb, 0x79, 0x4e, 0x0e, 0x14, 0x62, 0xe9, 0x40, 0x53,

-	0xd0, 0x03, 0x28, 0x45, 0x81, 0x4d, 0x04, 0x35, 0x4b, 0x8a, 0xdc, 0xcc, 0x23, 0x7f, 0xa5, 0x10,

-	0xfb, 0xcc, 0x3f, 0x75, 0x1d, 0xac, 0xf1, 0xe8, 0x31, 0x54, 0x7c, 0x2a, 0xbe, 0x66, 0xfc, 0x2c,

-	0x34, 0xcb, 0xcd, 0x8d, 0x5d, 0x63, 0xef, 0xd3, 0x5c, 0x31, 0xc6, 0x98, 0xae, 0x10, 0xc4, 0x9a,

-	0x4c, 0xa9, 0x2f, 0x62, 0x37, 0xbd, 0x75, 0xb3, 0x80, 0x53, 0x07, 0xe8, 0x27, 0x50, 0xa1, 0xbe,

-	0x1d, 0x30, 0xd7, 0x17, 0x66, 0xe5, 0xe2, 0x85, 0x0c, 0x34, 0x46, 0x06, 0x13, 0xa7, 0x0c, 0xc9,

-	0xe6, 0xcc, 0xf3, 0xc6, 0xc4, 0x3a, 0x33, 0xab, 0x6f, 0xb9, 0x8d, 0x94, 0xd1, 0x2b, 0x41, 0x71,

-	0xca, 0x6c, 0xda, 0xea, 0xc0, 0x8d, 0x37, 0x42, 0x8d, 0x1a, 0x50, 0xd1, 0xa1, 0x8e, 0x35, 0x52,

-	0xc4, 0x69, 0xbf, 0x75, 0x1d, 0xb6, 0x56, 0xc2, 0xda, 0xfa, 0xeb, 0x26, 0x54, 0x92, 0xb3, 0x46,

-	0x5d, 0xa8, 0x5a, 0xcc, 0x17, 0xc4, 0xf5, 0x29, 0xd7, 0xf2, 0xca, 0x3d, 0x99, 0xfd, 0x04, 0x24,

-	0x59, 0x8f, 0xd6, 0xf0, 0x92, 0x85, 0x7e, 0x01, 0x55, 0x4e, 0x43, 0x16, 0x71, 0x8b, 0x86, 0x5a,

-	0x5f, 0xbb, 0xf9, 0x0a, 0x89, 0x41, 0x98, 0xfe, 0x2e, 0x72, 0x39, 0x95, 0x51, 0x0e, 0xf1, 0x92,

-	0x8a, 0x1e, 0x42, 0x99, 0xd3, 0x50, 0x10, 0x2e, 0x2e, 0x93, 0x08, 0x8e, 0x21, 0x43, 0xe6, 0xb9,

-	0xd6, 0x1c, 0x27, 0x0c, 0xf4, 0x10, 0xaa, 0x81, 0x47, 0x2c, 0xe5, 0xd5, 0xdc, 0x54, 0xf4, 0x0f,

-	0xf2, 0xe8, 0xc3, 0x04, 0x84, 0x97, 0x78, 0xf4, 0x39, 0x80, 0xc7, 0x9c, 0x91, 0xcd, 0xdd, 0x19,

-	0xe5, 0x5a, 0x62, 0x8d, 0x3c, 0x76, 0x5f, 0x21, 0x70, 0xd5, 0x63, 0x4e, 0xdc, 0x44, 0x07, 0xff,

-	0x93, 0xbe, 0x32, 0xda, 0x7a, 0x0c, 0x40, 0xd2, 0x51, 0xad, 0xae, 0x8f, 0xdf, 0xca, 0x95, 0x3e,

-	0x91, 0x0c, 0x1d, 0xdd, 0x85, 0xda, 0x29, 0xe3, 0x16, 0x1d, 0xe9, 0xac, 0xa9, 0x2a, 0x4d, 0x18,

-	0xca, 0x16, 0xeb, 0x0b, 0xf5, 0xa0, 0xec, 0x50, 0x9f, 0x72, 0xd7, 0x32, 0x41, 0x4d, 0x76, 0x3f,

-	0x37, 0x21, 0x63, 0x08, 0x8e, 0x7c, 0xe1, 0x4e, 0xa9, 0x9e, 0x29, 0x21, 0xa2, 0xdf, 0xc2, 0x7b,

-	0xc9, 0xf1, 0x8d, 0x38, 0x3d, 0xa5, 0x9c, 0xfa, 0x52, 0x03, 0x86, 0x8a, 0xc3, 0x47, 0x97, 0x6b,

-	0x40, 0xa3, 0xf5, 0x65, 0x83, 0xf8, 0xeb, 0x03, 0x61, 0xaf, 0x0a, 0x65, 0x1e, 0xcf, 0xdb, 0xfa,

-	0x43, 0x41, 0xaa, 0xfe, 0x35, 0x04, 0xea, 0x80, 0x91, 0x4e, 0xef, 0xda, 0x4a, 0xbd, 0xd5, 0xde,

-	0xb5, 0xc5, 0xf9, 0x0e, 0x24, 0xd8, 0xc3, 0xbe, 0xbc, 0x83, 0x74, 0xdb, 0x46, 0x03, 0xd8, 0x4a,

-	0x09, 0xf2, 0x99, 0xd7, 0x0f, 0x65, 0xf3, 0xb2, 0x95, 0x9e, 0xcc, 0x03, 0x8a, 0x6b, 0x3c, 0xd3,

-	0x6b, 0xfd, 0x06, 0xd0, 0x9b, 0x71, 0x41, 0x08, 0x8a, 0x67, 0xae, 0xaf, 0x97, 0x81, 0x55, 0x1b,

-	0xb5, 0xa1, 0x1c, 0x90, 0xb9, 0xc7, 0x88, 0xad, 0x13, 0xe3, 0x66, 0x3b, 0xae, 0x0d, 0xda, 0x49,

-	0x6d, 0xd0, 0xee, 0xfa, 0x73, 0x9c, 0x80, 0x5a, 0x8f, 0xe1, 0xfd, 0xdc, 0xe3, 0x45, 0x7b, 0x50,

-	0x4b, 0x13, 0x6e, 0xb9, 0xd7, 0xeb, 0x8b, 0xf3, 0x1d, 0x23, 0xcd, 0xcc, 0xc3, 0x3e, 0x36, 0x52,

-	0xd0, 0xa1, 0xdd, 0xfa, 0x63, 0x15, 0xb6, 0x56, 0xd2, 0x16, 0xdd, 0x84, 0x4d, 0x77, 0x4a, 0x1c,

-	0xaa, 0xd7, 0x18, 0x77, 0xd0, 0x00, 0x4a, 0x1e, 0x19, 0x53, 0x4f, 0x26, 0xaf, 0x3c, 0xb8, 0xef,

-	0x5f, 0x99, 0xff, 0xed, 0x5f, 0x29, 0xfc, 0xc0, 0x17, 0x7c, 0x8e, 0x35, 0x19, 0x99, 0x50, 0xb6,

-	0xd8, 0x74, 0x4a, 0x7c, 0xf9, 0x4c, 0x6c, 0xec, 0x56, 0x71, 0xd2, 0x95, 0x91, 0x21, 0xdc, 0x09,

-	0xcd, 0xa2, 0x32, 0xab, 0x36, 0xaa, 0xc3, 0x06, 0xf5, 0x67, 0xe6, 0xa6, 0x32, 0xc9, 0xa6, 0xb4,

-	0xd8, 0x6e, 0x9c, 0x7d, 0x55, 0x2c, 0x9b, 0x92, 0x17, 0x85, 0x94, 0x9b, 0xe5, 0x38, 0xa2, 0xb2,

-	0x8d, 0x7e, 0x0c, 0xa5, 0x29, 0x8b, 0x7c, 0x11, 0x9a, 0x15, 0xb5, 0xd8, 0xdb, 0x79, 0x8b, 0x7d,

-	0x22, 0x11, 0x5a, 0x59, 0x1a, 0x8e, 0x06, 0x70, 0x23, 0x14, 0x2c, 0x18, 0x39, 0x9c, 0x58, 0x74,

-	0x14, 0x50, 0xee, 0x32, 0x5b, 0x5f, 0xc3, 0xb7, 0xdf, 0x38, 0x94, 0xbe, 0x2e, 0xe8, 0xf0, 0x75,

-	0xc9, 0x39, 0x90, 0x94, 0xa1, 0x62, 0xa0, 0x21, 0xd4, 0x82, 0xc8, 0xf3, 0x46, 0x2c, 0x88, 0x5f,

-	0xe4, 0x38, 0x77, 0xde, 0x22, 0x64, 0xc3, 0xc8, 0xf3, 0x9e, 0xc6, 0x24, 0x6c, 0x04, 0xcb, 0x0e,

-	0xba, 0x05, 0x25, 0x87, 0xb3, 0x28, 0x88, 0xf3, 0xa6, 0x8a, 0x75, 0x0f, 0x7d, 0x09, 0xe5, 0x90,

-	0x5a, 0x9c, 0x8a, 0xd0, 0xac, 0xa9, 0xad, 0x7e, 0x98, 0x37, 0xc9, 0xb1, 0x82, 0xa4, 0x39, 0x81,

-	0x13, 0x0e, 0xba, 0x0d, 0x1b, 0x42, 0xcc, 0xcd, 0xad, 0x66, 0x61, 0xb7, 0xd2, 0x2b, 0x2f, 0xce,

-	0x77, 0x36, 0x4e, 0x4e, 0x9e, 0x63, 0x69, 0x93, 0xaf, 0xc5, 0x84, 0x85, 0xc2, 0x27, 0x53, 0x6a,

-	0x5e, 0x53, 0xb1, 0x4d, 0xfb, 0xe8, 0x39, 0x80, 0xed, 0x87, 0x23, 0x4b, 0x5d, 0x4f, 0xe6, 0x75,

-	0xb5, 0xbb, 0x4f, 0xaf, 0xde, 0x5d, 0xff, 0xe8, 0x58, 0xbf, 0x98, 0x5b, 0x8b, 0xf3, 0x9d, 0x6a,

-	0xda, 0xc5, 0x55, 0xdb, 0x0f, 0xe3, 0x26, 0xea, 0x81, 0x31, 0xa1, 0xc4, 0x13, 0x13, 0x6b, 0x42,

-	0xad, 0x33, 0xb3, 0x7e, 0xf1, 0x13, 0xf8, 0x48, 0xc1, 0xb4, 0x87, 0x2c, 0x49, 0x2a, 0x58, 0x2e,

-	0x35, 0x34, 0x6f, 0xa8, 0x58, 0xc5, 0x1d, 0xf4, 0x01, 0x00, 0x0b, 0xa8, 0x3f, 0x0a, 0x85, 0xed,

-	0xfa, 0x26, 0x92, 0x5b, 0xc6, 0x55, 0x69, 0x39, 0x96, 0x06, 0x74, 0x47, 0x3e, 0x50, 0xc4, 0x1e,

-	0x31, 0xdf, 0x9b, 0x9b, 0xef, 0xa9, 0xd1, 0x8a, 0x34, 0x3c, 0xf5, 0xbd, 0x39, 0xda, 0x01, 0x43,

-	0xe9, 0x22, 0x74, 0x1d, 0x9f, 0x78, 0xe6, 0x4d, 0x15, 0x0f, 0x90, 0xa6, 0x63, 0x65, 0x91, 0xe7,

-	0x10, 0x47, 0x23, 0x34, 0xdf, 0xbf, 0xf8, 0x1c, 0xf4, 0x62, 0x97, 0xe7, 0xa0, 0x39, 0xe8, 0xa7,

-	0x00, 0x01, 0x77, 0x67, 0xae, 0x47, 0x1d, 0x1a, 0x9a, 0xb7, 0xd4, 0xa6, 0xb7, 0x73, 0x5f, 0xa6,

-	0x14, 0x85, 0x33, 0x8c, 0xc6, 0xe7, 0x60, 0x64, 0xb2, 0x4d, 0x66, 0xc9, 0x19, 0x9d, 0xeb, 0x04,

-	0x96, 0x4d, 0x19, 0x92, 0x19, 0xf1, 0xa2, 0xf8, 0x32, 0xab, 0xe2, 0xb8, 0xf3, 0xc5, 0xfa, 0x83,

-	0x42, 0x63, 0x0f, 0x8c, 0x8c, 0xea, 0xd0, 0x87, 0xf2, 0xf6, 0x73, 0xdc, 0x50, 0xf0, 0xf9, 0x88,

-	0x44, 0x62, 0x62, 0xfe, 0x5c, 0x11, 0x6a, 0x89, 0xb1, 0x1b, 0x89, 0x49, 0x63, 0x04, 0xcb, 0xc3,

-	0x43, 0x4d, 0x30, 0xa4, 0x28, 0x42, 0xca, 0x67, 0x94, 0xcb, 0xca, 0x42, 0xc6, 0x3c, 0x6b, 0x92,

-	0xe2, 0x0d, 0x29, 0xe1, 0xd6, 0x44, 0xdd, 0x1d, 0x55, 0xac, 0x7b, 0xf2, 0x32, 0x48, 0x32, 0x44,

-	0x5f, 0x06, 0xba, 0xdb, 0xfa, 0x57, 0x01, 0x6a, 0xd9, 0x02, 0x09, 0xed, 0xc7, 0x85, 0x8d, 0xda,

-	0xd2, 0xb5, 0xbd, 0xce, 0x55, 0x05, 0x95, 0xba, 0x98, 0xbd, 0x48, 0x3a, 0x7b, 0x22, 0xff, 0x32,

-	0x8a, 0x8c, 0x7e, 0x04, 0x9b, 0x01, 0xe3, 0x22, 0xb9, 0xc2, 0xf2, 0x03, 0xcc, 0x78, 0xf2, 0xec,

-	0xc6, 0xe0, 0xd6, 0x04, 0xae, 0xad, 0x7a, 0x43, 0xf7, 0x60, 0xe3, 0xd9, 0xe1, 0xb0, 0xbe, 0xd6,