Update swarmkit to 25572005f

Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com>

hack/vendor.sh

@@ -139,7 +139,7 @@ clone git github.com/docker/docker-credential-helpers v0.3.0
 clone git github.com/docker/containerd 860f3a94940894ac0a106eff4bd1616a67407ee2
 
 # cluster
-clone git github.com/docker/swarmkit 45094b473cbdb2d45e4d8f703fb615989399ae29
+clone git github.com/docker/swarmkit 25572005febb76c2cc5f7e37d878615e6fe330f9
 clone git github.com/golang/mock bd3c8e81be01eef76d4b503f5e687d2d1354d2d9
 clone git github.com/gogo/protobuf 43a2e0b1c32252bfbbdf81f7faa7a88fb3fa4028
 clone git github.com/cloudflare/cfssl 92f037e39eb103fb30f9151be40d9ed267fc4ae2

vendor/src/github.com/docker/swarmkit/agent/node.go

@@ -622,15 +622,18 @@ func (n *Node) runManager(ctx context.Context, securityConfig *ca.SecurityConfig
 
 			select {
 			case <-ctx.Done():
+				m.Stop(context.Background()) // todo: this should be sync like other components
 			case <-n.waitRole(ctx, ca.AgentRole):
 			}
 
-			m.Stop(context.Background()) // todo: this should be sync like other components
 			<-done
 
 			ready = nil // ready event happens once, even on multiple starts
 			n.Lock()
 			n.manager = nil
+			if n.conn != nil {
+				n.conn.Close()
+			}
 			n.Unlock()
 
 			if ctx.Err() != nil {

vendor/src/github.com/docker/swarmkit/api/control.pb.go

@@ -349,20 +349,13 @@ func (m *ListNetworksResponse) Reset()                    { *m = ListNetworksRes
 func (*ListNetworksResponse) ProtoMessage()               {}
 func (*ListNetworksResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{31} }
 
-type RemoveManagerResponse struct {
-}
-
-func (m *RemoveManagerResponse) Reset()                    { *m = RemoveManagerResponse{} }
-func (*RemoveManagerResponse) ProtoMessage()               {}
-func (*RemoveManagerResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{32} }
-
 type GetClusterRequest struct {
 	ClusterID string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
 }
 
 func (m *GetClusterRequest) Reset()                    { *m = GetClusterRequest{} }
 func (*GetClusterRequest) ProtoMessage()               {}
-func (*GetClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{33} }
+func (*GetClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{32} }
 
 type GetClusterResponse struct {
 	Cluster *Cluster `protobuf:"bytes,1,opt,name=cluster" json:"cluster,omitempty"`
@@ -370,7 +363,7 @@ type GetClusterResponse struct {
 
 func (m *GetClusterResponse) Reset()                    { *m = GetClusterResponse{} }
 func (*GetClusterResponse) ProtoMessage()               {}
-func (*GetClusterResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{34} }
+func (*GetClusterResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{33} }
 
 type ListClustersRequest struct {
 	Filters *ListClustersRequest_Filters `protobuf:"bytes,1,opt,name=filters" json:"filters,omitempty"`
@@ -378,7 +371,7 @@ type ListClustersRequest struct {
 
 func (m *ListClustersRequest) Reset()                    { *m = ListClustersRequest{} }
 func (*ListClustersRequest) ProtoMessage()               {}
-func (*ListClustersRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{35} }
+func (*ListClustersRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{34} }
 
 type ListClustersRequest_Filters struct {
 	Names      []string          `protobuf:"bytes,1,rep,name=names" json:"names,omitempty"`
@@ -389,7 +382,7 @@ type ListClustersRequest_Filters struct {
 func (m *ListClustersRequest_Filters) Reset()      { *m = ListClustersRequest_Filters{} }
 func (*ListClustersRequest_Filters) ProtoMessage() {}
 func (*ListClustersRequest_Filters) Descriptor() ([]byte, []int) {
-	return fileDescriptorControl, []int{35, 0}
+	return fileDescriptorControl, []int{34, 0}
 }
 
 type ListClustersResponse struct {
@@ -398,7 +391,7 @@ type ListClustersResponse struct {
 
 func (m *ListClustersResponse) Reset()                    { *m = ListClustersResponse{} }
 func (*ListClustersResponse) ProtoMessage()               {}
-func (*ListClustersResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{36} }
+func (*ListClustersResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{35} }
 
 type UpdateClusterRequest struct {
 	// ClusterID is the cluster ID to update.
@@ -411,7 +404,7 @@ type UpdateClusterRequest struct {
 
 func (m *UpdateClusterRequest) Reset()                    { *m = UpdateClusterRequest{} }
 func (*UpdateClusterRequest) ProtoMessage()               {}
-func (*UpdateClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{37} }
+func (*UpdateClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{36} }
 
 type UpdateClusterResponse struct {
 	Cluster *Cluster `protobuf:"bytes,1,opt,name=cluster" json:"cluster,omitempty"`
@@ -419,7 +412,7 @@ type UpdateClusterResponse struct {
 
 func (m *UpdateClusterResponse) Reset()                    { *m = UpdateClusterResponse{} }
 func (*UpdateClusterResponse) ProtoMessage()               {}
-func (*UpdateClusterResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{38} }
+func (*UpdateClusterResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{37} }
 
 func init() {
 	proto.RegisterType((*GetNodeRequest)(nil), "docker.swarmkit.v1.GetNodeRequest")
@@ -458,7 +451,6 @@ func init() {
 	proto.RegisterType((*ListNetworksRequest)(nil), "docker.swarmkit.v1.ListNetworksRequest")
 	proto.RegisterType((*ListNetworksRequest_Filters)(nil), "docker.swarmkit.v1.ListNetworksRequest.Filters")
 	proto.RegisterType((*ListNetworksResponse)(nil), "docker.swarmkit.v1.ListNetworksResponse")
-	proto.RegisterType((*RemoveManagerResponse)(nil), "docker.swarmkit.v1.RemoveManagerResponse")
 	proto.RegisterType((*GetClusterRequest)(nil), "docker.swarmkit.v1.GetClusterRequest")
 	proto.RegisterType((*GetClusterResponse)(nil), "docker.swarmkit.v1.GetClusterResponse")
 	proto.RegisterType((*ListClustersRequest)(nil), "docker.swarmkit.v1.ListClustersRequest")
@@ -1193,16 +1185,6 @@ func (m *ListNetworksResponse) Copy() *ListNetworksResponse {
 	return o
 }
 
-func (m *RemoveManagerResponse) Copy() *RemoveManagerResponse {
-	if m == nil {
-		return nil
-	}
-
-	o := &RemoveManagerResponse{}
-
-	return o
-}
-
 func (m *GetClusterRequest) Copy() *GetClusterRequest {
 	if m == nil {
 		return nil
@@ -1780,15 +1762,6 @@ func (this *ListNetworksResponse) GoString() string {
 	s = append(s, "}")
 	return strings.Join(s, "")
 }
-func (this *RemoveManagerResponse) GoString() string {
-	if this == nil {
-		return "nil"
-	}
-	s := make([]string, 0, 4)
-	s = append(s, "&api.RemoveManagerResponse{")
-	s = append(s, "}")
-	return strings.Join(s, "")
-}
 func (this *GetClusterRequest) GoString() string {
 	if this == nil {
 		return "nil"
@@ -3765,24 +3738,6 @@ func (m *ListNetworksResponse) MarshalTo(data []byte) (int, error) {
 	return i, nil
 }
 
-func (m *RemoveManagerResponse) Marshal() (data []byte, err error) {
-	size := m.Size()
-	data = make([]byte, size)
-	n, err := m.MarshalTo(data)
-	if err != nil {
-		return nil, err
-	}
-	return data[:n], nil
-}
-
-func (m *RemoveManagerResponse) MarshalTo(data []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	return i, nil
-}
-
 func (m *GetClusterRequest) Marshal() (data []byte, err error) {
 	size := m.Size()
 	data = make([]byte, size)
@@ -4874,12 +4829,6 @@ func (m *ListNetworksResponse) Size() (n int) {
 	return n
 }
 
-func (m *RemoveManagerResponse) Size() (n int) {
-	var l int
-	_ = l
-	return n
-}
-
 func (m *GetClusterRequest) Size() (n int) {
 	var l int
 	_ = l
@@ -5404,15 +5353,6 @@ func (this *ListNetworksResponse) String() string {
 	}, "")
 	return s
 }
-func (this *RemoveManagerResponse) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&RemoveManagerResponse{`,
-		`}`,
-	}, "")
-	return s
-}
 func (this *GetClusterRequest) String() string {
 	if this == nil {
 		return "nil"
@@ -9165,56 +9105,6 @@ func (m *ListNetworksResponse) Unmarshal(data []byte) error {
 	}
 	return nil
 }
-func (m *RemoveManagerResponse) Unmarshal(data []byte) error {
-	l := len(data)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowControl
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := data[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: RemoveManagerResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RemoveManagerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		default:
-			iNdEx = preIndex
-			skippy, err := skipControl(data[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthControl
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *GetClusterRequest) Unmarshal(data []byte) error {
 	l := len(data)
 	iNdEx := 0
@@ -10094,92 +9984,92 @@ var (
 )
 
 var fileDescriptorControl = []byte{
-	// 1391 bytes of a gzipped FileDescriptorProto
+	// 1384 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x59, 0x4f, 0x6f, 0x1b, 0x45,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x59, 0xcf, 0x6f, 0x1b, 0xc5,
-	0x14, 0xc7, 0x4e, 0x1b, 0xd7, 0xcf, 0x75, 0xd2, 0x4c, 0x1d, 0x11, 0xb9, 0x21, 0x45, 0x5b, 0x48,
+	0x17, 0xff, 0xda, 0x69, 0xe2, 0xfa, 0xb9, 0x4e, 0x9a, 0xa9, 0xa3, 0x6f, 0xe4, 0x86, 0x14, 0x6d,
-	0x13, 0x29, 0x38, 0xe0, 0xa8, 0x22, 0x80, 0x04, 0x22, 0x09, 0x45, 0x16, 0x6d, 0xa8, 0x36, 0x14,
+	0x21, 0x4d, 0xa4, 0xe0, 0x80, 0xa3, 0x8a, 0x00, 0x12, 0x88, 0x24, 0x14, 0x59, 0x94, 0x50, 0x6d,
-	0x71, 0x8b, 0x1c, 0x7b, 0x1a, 0x96, 0xd8, 0x5e, 0xb3, 0xbb, 0x49, 0x1b, 0x71, 0xe1, 0x63, 0xf0,
+	0x28, 0xe2, 0x16, 0x39, 0xf6, 0x34, 0x2c, 0xb1, 0xbd, 0x66, 0x77, 0x93, 0x36, 0xe2, 0xc2, 0x9f,
-	0x19, 0x38, 0x70, 0xe7, 0xc4, 0x81, 0x4b, 0xc5, 0x89, 0x0b, 0x12, 0x48, 0x08, 0xb5, 0xfd, 0x00,
+	0xc1, 0xdf, 0xc0, 0x81, 0x3b, 0x27, 0x0e, 0x5c, 0x2a, 0x4e, 0x5c, 0x90, 0x40, 0x42, 0xa8, 0xed,
-	0x88, 0x0f, 0xc0, 0x81, 0x99, 0x9d, 0x37, 0xbb, 0xeb, 0xf1, 0xec, 0xac, 0x1d, 0xa7, 0xa2, 0x07,
+	0x1f, 0x80, 0xf8, 0x03, 0x38, 0x30, 0xb3, 0xf3, 0x66, 0x77, 0x3d, 0x9e, 0x9d, 0xb5, 0xe3, 0x54,
-	0xab, 0xde, 0xd9, 0xdf, 0xfb, 0x37, 0xef, 0xf7, 0x5e, 0xde, 0x73, 0xa1, 0xdc, 0x72, 0x7b, 0x81,
+	0xf4, 0x60, 0xd5, 0x3b, 0xfb, 0x79, 0xbf, 0xe6, 0x7d, 0xde, 0xcb, 0x7b, 0x2e, 0x94, 0x5b, 0x6e,
-	0xe7, 0x76, 0x6a, 0x7d, 0xcf, 0x0d, 0x5c, 0x42, 0xda, 0x6e, 0xeb, 0x88, 0x7a, 0x35, 0xff, 0x61,
+	0x2f, 0xf0, 0xdc, 0x4e, 0xad, 0xef, 0xb9, 0x81, 0x4b, 0x48, 0xdb, 0x6d, 0x1d, 0x53, 0xaf, 0xe6,
-	0xd3, 0xeb, 0x1e, 0x39, 0x41, 0xed, 0xe4, 0xad, 0x6a, 0xc9, 0xef, 0xd3, 0x96, 0x2f, 0x00, 0xd5,
+	0x3f, 0x6c, 0x7a, 0xdd, 0x63, 0x27, 0xa8, 0x9d, 0xbe, 0x51, 0x2d, 0xf9, 0x7d, 0xda, 0xf2, 0x05,
-	0xb2, 0x7b, 0xf0, 0x15, 0x6d, 0x05, 0xf2, 0xb1, 0x14, 0x9c, 0xf6, 0xa9, 0x7c, 0xa8, 0x1c, 0xba,
+	0xa0, 0x5a, 0x76, 0x0f, 0xbf, 0xa4, 0xad, 0x40, 0x3e, 0x96, 0x82, 0xb3, 0x3e, 0x95, 0x0f, 0x95,
-	0x87, 0x6e, 0xf8, 0x75, 0x9d, 0x7f, 0xc3, 0xd3, 0xab, 0xfd, 0xce, 0xf1, 0xa1, 0xd3, 0x5b, 0x17,
+	0x23, 0xf7, 0xc8, 0x0d, 0xbf, 0x6e, 0xf0, 0x6f, 0x78, 0x7a, 0xad, 0xdf, 0x39, 0x39, 0x72, 0x7a,
-	0xff, 0x88, 0x43, 0xeb, 0x16, 0xcc, 0x7c, 0x4c, 0x83, 0x5d, 0xb7, 0x4d, 0x6d, 0xfa, 0xf5, 0x31,
+	0x1b, 0xe2, 0x1f, 0x71, 0x68, 0xdd, 0x86, 0xd9, 0x0f, 0x69, 0xb0, 0xe7, 0xb6, 0xa9, 0x4d, 0xbf,
-	0xf5, 0x03, 0x72, 0x03, 0x0a, 0x3d, 0xf6, 0xb8, 0xef, 0xb4, 0x17, 0x72, 0xaf, 0xe6, 0x56, 0x8a,
+	0x3a, 0xa1, 0x7e, 0x40, 0x6e, 0x42, 0xa1, 0xc7, 0x1e, 0x0f, 0x9c, 0xf6, 0x62, 0xee, 0xe5, 0xdc,
-	0x5b, 0xf0, 0xec, 0xaf, 0xeb, 0xd3, 0x1c, 0xd1, 0xd8, 0xb1, 0xa7, 0xf9, 0xab, 0x46, 0xdb, 0xfa,
+	0x6a, 0x71, 0x1b, 0x9e, 0xfd, 0x79, 0x63, 0x86, 0x23, 0x1a, 0xbb, 0xf6, 0x0c, 0x7f, 0xd5, 0x68,
-	0x00, 0x66, 0x23, 0x31, 0xbf, 0xef, 0xf6, 0x7c, 0x4a, 0xd6, 0xe0, 0x02, 0x7f, 0x19, 0x0a, 0x95,
+	0x5b, 0xef, 0xc1, 0x5c, 0x24, 0xe6, 0xf7, 0xdd, 0x9e, 0x4f, 0xc9, 0x3a, 0x5c, 0xe2, 0x2f, 0x43,
-	0xea, 0x0b, 0xb5, 0xe1, 0x00, 0x6a, 0x21, 0x3e, 0x44, 0x59, 0x3f, 0x4e, 0xc1, 0x95, 0x3b, 0x8e,
+	0xa1, 0x52, 0x7d, 0xb1, 0x36, 0x1c, 0x40, 0x2d, 0xc4, 0x87, 0x28, 0xeb, 0x87, 0x29, 0xb8, 0x7a,
-	0x1f, 0xaa, 0xf0, 0xa5, 0xe9, 0xdb, 0x50, 0x78, 0xe0, 0x74, 0x02, 0xea, 0xf9, 0xa8, 0x65, 0x4d,
+	0xd7, 0xf1, 0x43, 0x15, 0xbe, 0x34, 0x7d, 0x07, 0x0a, 0x0f, 0x9c, 0x4e, 0x40, 0x3d, 0x1f, 0xb5,
-	0xa7, 0x45, 0x15, 0xab, 0xdd, 0x16, 0x32, 0xb6, 0x14, 0xae, 0xfe, 0x99, 0x87, 0x02, 0x1e, 0x92,
+	0xac, 0xeb, 0xb4, 0xa8, 0x62, 0xb5, 0x3b, 0x42, 0xc6, 0x96, 0xc2, 0xd5, 0x3f, 0xf2, 0x50, 0xc0,
-	0x0a, 0x5c, 0xec, 0x35, 0xbb, 0x94, 0x6b, 0x9c, 0x5a, 0x29, 0xda, 0xe2, 0x81, 0xac, 0x43, 0xc9,
+	0x43, 0x52, 0x81, 0xe9, 0x5e, 0xb3, 0x4b, 0xb9, 0xc6, 0xa9, 0xd5, 0xa2, 0x2d, 0x1e, 0xc8, 0x06,
-	0x69, 0xef, 0xf7, 0x3d, 0xfa, 0xc0, 0x79, 0xc4, 0xde, 0xe5, 0xf9, 0xbb, 0xad, 0x19, 0x16, 0x28,
+	0x94, 0x9c, 0xf6, 0x41, 0xdf, 0xa3, 0x0f, 0x9c, 0x47, 0xec, 0x5d, 0x9e, 0xbf, 0xdb, 0x9e, 0x65,
-	0x34, 0x76, 0xee, 0xe1, 0xa9, 0x0d, 0x4e, 0x5b, 0x7e, 0x27, 0xf7, 0x60, 0xba, 0xd3, 0x3c, 0xa0,
+	0x81, 0x42, 0x63, 0xf7, 0x1e, 0x9e, 0xda, 0xe0, 0xb4, 0xe5, 0x77, 0x72, 0x0f, 0x66, 0x3a, 0xcd,
-	0x1d, 0x7f, 0x61, 0x8a, 0x61, 0x4b, 0xf5, 0xcd, 0x71, 0x3c, 0xab, 0xdd, 0x09, 0x45, 0x3f, 0x62,
+	0x43, 0xda, 0xf1, 0x17, 0xa7, 0x18, 0xb6, 0x54, 0xdf, 0x1a, 0xc7, 0xb3, 0xda, 0xdd, 0x50, 0xf4,
-	0x09, 0x3e, 0xb5, 0x51, 0x0f, 0x69, 0x40, 0xa9, 0x4b, 0xbb, 0x07, 0xec, 0xf5, 0x97, 0x4e, 0xdf,
+	0x03, 0x96, 0xe0, 0x33, 0x1b, 0xf5, 0x90, 0x06, 0x94, 0xba, 0xb4, 0x7b, 0xc8, 0x5e, 0x7f, 0xe1,
-	0x5f, 0xb8, 0xc0, 0xd4, 0xce, 0xd4, 0x6f, 0xa6, 0x5d, 0xdb, 0x1e, 0x4b, 0x7d, 0xed, 0x6e, 0x84,
+	0xf4, 0xfd, 0xc5, 0x4b, 0x4c, 0xed, 0x6c, 0xfd, 0x56, 0xda, 0xb5, 0xed, 0xb3, 0xd4, 0xd7, 0x3e,
-	0xb7, 0x93, 0xb2, 0xa4, 0x0e, 0x17, 0x19, 0x73, 0x58, 0x1c, 0x17, 0x43, 0x25, 0x8b, 0xa9, 0x77,
+	0x8e, 0xf0, 0x76, 0x52, 0x96, 0xd4, 0x61, 0x9a, 0x31, 0x87, 0xc5, 0x31, 0x1d, 0x2a, 0x59, 0x4a,
-	0xcf, 0x40, 0xb6, 0x80, 0x56, 0xdf, 0x81, 0x52, 0xc2, 0x2b, 0x72, 0x05, 0xa6, 0x8e, 0xe8, 0xa9,
+	0xbd, 0x7b, 0x06, 0xb2, 0x05, 0xb4, 0xfa, 0x16, 0x94, 0x12, 0x5e, 0x91, 0xab, 0x30, 0x75, 0x4c,
-	0xc8, 0xb8, 0xcd, 0xbf, 0xf2, 0x8b, 0x3b, 0x69, 0x76, 0x8e, 0x29, 0xbb, 0x1c, 0x7e, 0x26, 0x1e,
+	0xcf, 0x44, 0xc6, 0x6d, 0xfe, 0x95, 0x5f, 0xdc, 0x69, 0xb3, 0x73, 0x42, 0xd9, 0xe5, 0xf0, 0x33,
-	0xde, 0xcd, 0x6f, 0xe6, 0xac, 0x6d, 0x98, 0x4b, 0x44, 0x8a, 0xe9, 0xaf, 0xb1, 0x7b, 0xe6, 0x07,
+	0xf1, 0xf0, 0x76, 0x7e, 0x2b, 0x67, 0xed, 0xc0, 0x7c, 0x22, 0x52, 0x4c, 0x7f, 0x8d, 0xdd, 0x33,
-	0xe1, 0x3d, 0x9b, 0xf2, 0x2f, 0x60, 0xd6, 0xf7, 0x39, 0x98, 0xbb, 0xdf, 0x6f, 0x37, 0x03, 0x3a,
+	0x3f, 0x08, 0xef, 0xd9, 0x94, 0x7f, 0x01, 0xb3, 0xbe, 0xcb, 0xc1, 0xfc, 0xfd, 0x7e, 0xbb, 0x19,
-	0x2e, 0xf9, 0xc8, 0xfb, 0x70, 0x39, 0x04, 0x9d, 0xb0, 0xf8, 0x1d, 0xb7, 0x17, 0x3a, 0x58, 0xaa,
+	0xd0, 0x71, 0xc9, 0x47, 0xde, 0x85, 0x2b, 0x21, 0xe8, 0x94, 0xc5, 0xef, 0xb8, 0xbd, 0xd0, 0xc1,
-	0x5f, 0xd3, 0x59, 0xfc, 0x5c, 0x40, 0xec, 0x12, 0x17, 0xc0, 0x07, 0xf2, 0x26, 0x5c, 0xe0, 0x95,
+	0x52, 0xfd, 0xba, 0xce, 0xe2, 0x67, 0x02, 0x62, 0x97, 0xb8, 0x00, 0x3e, 0x90, 0xd7, 0xe1, 0x12,
-	0xc4, 0x32, 0xc9, 0xe5, 0x16, 0x4d, 0x57, 0x6e, 0x87, 0x48, 0x6b, 0x0b, 0x48, 0xd2, 0xd7, 0x33,
+	0xaf, 0x24, 0x96, 0x49, 0x2e, 0xb7, 0x64, 0xba, 0x72, 0x3b, 0x44, 0x5a, 0xdb, 0x40, 0x92, 0xbe,
-	0x31, 0x7e, 0x13, 0xe6, 0x6c, 0xda, 0x75, 0x4f, 0xc6, 0x8e, 0xd7, 0xaa, 0x00, 0x49, 0x4a, 0x0a,
+	0x9e, 0x8b, 0xf1, 0x5b, 0x30, 0x6f, 0xd3, 0xae, 0x7b, 0x3a, 0x76, 0xbc, 0x56, 0x05, 0x48, 0x52,
-	0xeb, 0x58, 0xb9, 0x9f, 0x35, 0xfd, 0xa3, 0x84, 0xb2, 0x80, 0x3d, 0x2a, 0xca, 0x38, 0x82, 0x2b,
+	0x52, 0x58, 0xc7, 0xca, 0xfd, 0xb4, 0xe9, 0x1f, 0x27, 0x94, 0x05, 0xec, 0x51, 0x51, 0xc6, 0x11,
-	0xe3, 0xaf, 0xa2, 0xca, 0x15, 0x62, 0x71, 0x1c, 0xfc, 0xa5, 0x29, 0x8e, 0x10, 0x1f, 0xa2, 0xe2,
+	0x5c, 0x19, 0x7f, 0x15, 0x55, 0xae, 0x10, 0x8b, 0xe3, 0xe0, 0x2f, 0x4d, 0x71, 0x84, 0xf8, 0x10,
-	0x38, 0xc6, 0x36, 0x1d, 0xc5, 0x91, 0xb4, 0x6e, 0xfd, 0x81, 0x9d, 0x80, 0x1f, 0x9e, 0xa1, 0x13,
+	0x15, 0xc7, 0x31, 0xb6, 0xe9, 0x28, 0x8e, 0xa4, 0x75, 0xeb, 0x77, 0xec, 0x04, 0xfc, 0xf0, 0x1c,
-	0x24, 0xc5, 0x86, 0x3b, 0xc1, 0xbf, 0xff, 0x63, 0x27, 0xd0, 0x79, 0xa6, 0xed, 0x04, 0xcc, 0x05,
+	0x9d, 0x20, 0x29, 0x36, 0xdc, 0x09, 0xfe, 0xf9, 0x0f, 0x3b, 0x81, 0xce, 0x33, 0x6d, 0x27, 0x60,
-	0x9f, 0x7a, 0x27, 0x4e, 0x8b, 0xf3, 0x40, 0x74, 0x02, 0x74, 0x61, 0x4f, 0x1c, 0x37, 0x76, 0x98,
+	0x2e, 0xf8, 0xd4, 0x3b, 0x75, 0x5a, 0x9c, 0x07, 0xa2, 0x13, 0xa0, 0x0b, 0xfb, 0xe2, 0xb8, 0xb1,
-	0x0b, 0x08, 0x69, 0xb4, 0x7d, 0xb2, 0x0c, 0x97, 0x90, 0x35, 0xa2, 0xe4, 0x8b, 0x5b, 0x25, 0x86,
+	0xcb, 0x5c, 0x40, 0x48, 0xa3, 0xed, 0x93, 0x15, 0xb8, 0x8c, 0xac, 0x11, 0x25, 0x5f, 0xdc, 0x2e,
-	0x2e, 0x08, 0xda, 0xb0, 0xe8, 0x05, 0x6f, 0x7c, 0xb2, 0x03, 0x33, 0xac, 0xd4, 0x1c, 0x8f, 0xb6,
+	0x31, 0x74, 0x41, 0xd0, 0x86, 0x45, 0x2f, 0x78, 0xe3, 0x93, 0x5d, 0x98, 0x65, 0xa5, 0xe6, 0x78,
-	0xf7, 0xfd, 0x80, 0xb1, 0xd7, 0x5f, 0x98, 0x0e, 0x1b, 0xc4, 0x2b, 0x69, 0x29, 0xde, 0xe3, 0x28,
+	0xb4, 0x7d, 0xe0, 0x07, 0x8c, 0xbd, 0xfe, 0xe2, 0x4c, 0xd8, 0x20, 0x5e, 0x4a, 0x4b, 0xf1, 0x3e,
-	0xbb, 0x8c, 0x42, 0xe1, 0xd3, 0x79, 0x74, 0x0a, 0xbc, 0x89, 0xb8, 0x53, 0x70, 0x42, 0x18, 0x3b,
+	0x47, 0xd9, 0x65, 0x14, 0x0a, 0x9f, 0x2e, 0xa2, 0x53, 0xe0, 0x4d, 0xc4, 0x9d, 0x82, 0x13, 0xc2,
-	0x45, 0xc8, 0x10, 0x01, 0xb3, 0x3e, 0x81, 0xca, 0xb6, 0x47, 0x99, 0x2b, 0x78, 0x1b, 0x92, 0x23,
+	0xd8, 0x29, 0x42, 0x86, 0x08, 0x98, 0xf5, 0x11, 0x54, 0x76, 0x3c, 0xca, 0x5c, 0xc1, 0xdb, 0x90,
-	0x1b, 0x58, 0xc6, 0x82, 0x20, 0xd7, 0x75, 0x6a, 0x50, 0x22, 0x51, 0xc9, 0xbb, 0x30, 0xaf, 0x28,
+	0x1c, 0xd9, 0xc4, 0x32, 0x16, 0x04, 0xb9, 0xa1, 0x53, 0x83, 0x12, 0x89, 0x4a, 0xde, 0x83, 0x05,
-	0x43, 0xaf, 0x6e, 0x41, 0x01, 0x6f, 0x18, 0x15, 0x5e, 0x33, 0x28, 0xb4, 0x25, 0xd6, 0xfa, 0x10,
+	0x45, 0x19, 0x7a, 0x75, 0x1b, 0x0a, 0x78, 0xc3, 0xa8, 0xf0, 0xba, 0x41, 0xa1, 0x2d, 0xb1, 0xd6,
-	0xe6, 0x58, 0x39, 0x29, 0x9e, 0xad, 0x01, 0xc4, 0x09, 0xc5, 0x82, 0x28, 0xb3, 0x0c, 0x15, 0xa3,
+	0xfb, 0x30, 0xcf, 0xca, 0x49, 0xf1, 0x6c, 0x1d, 0x20, 0x4e, 0x28, 0x16, 0x44, 0x99, 0x65, 0xa8,
-	0x7c, 0xda, 0xc5, 0x28, 0x9d, 0x2c, 0x3e, 0x92, 0x54, 0x31, 0x99, 0x3f, 0x3f, 0xe5, 0xa0, 0x22,
+	0x18, 0xe5, 0xd3, 0x2e, 0x46, 0xe9, 0x64, 0xf1, 0x91, 0xa4, 0x8a, 0xc9, 0xfc, 0xf9, 0x31, 0x07,
-	0x5a, 0xd5, 0x24, 0x3e, 0x31, 0xe6, 0xcc, 0x4a, 0xf4, 0x18, 0x5d, 0x76, 0x06, 0x65, 0x64, 0xa3,
+	0x15, 0xd1, 0xaa, 0x26, 0xf1, 0x89, 0x31, 0x67, 0x4e, 0xa2, 0xc7, 0xe8, 0xb2, 0xb3, 0x28, 0x23,
-	0xdd, 0x18, 0x68, 0xb4, 0xa3, 0x67, 0x48, 0x09, 0x60, 0xb2, 0x1b, 0xd9, 0x81, 0x8a, 0xe8, 0x3a,
+	0x1b, 0xed, 0xe6, 0x40, 0xa3, 0x1d, 0x3d, 0x43, 0x4a, 0x00, 0x93, 0xdd, 0xc8, 0x2e, 0x54, 0x44,
-	0x13, 0x25, 0xe9, 0x65, 0x98, 0x57, 0xb4, 0x60, 0xfb, 0xfa, 0x39, 0x0f, 0x57, 0x39, 0xc7, 0xf1,
+	0xd7, 0x99, 0x28, 0x49, 0xff, 0x87, 0x05, 0x45, 0x0b, 0xb6, 0xaf, 0x9f, 0xf2, 0x70, 0x8d, 0x73,
-	0x3c, 0xea, 0x60, 0x0d, 0xb5, 0x83, 0xad, 0xa7, 0xf5, 0x09, 0x45, 0x72, 0xb8, 0x89, 0x3d, 0xc9,
+	0x1c, 0xcf, 0xa3, 0x0e, 0xd6, 0x50, 0x3b, 0xd8, 0x46, 0x5a, 0x9f, 0x50, 0x24, 0x87, 0x9b, 0xd8,
-	0x9d, 0x7b, 0x13, 0xdb, 0x53, 0x9a, 0xd8, 0x7b, 0x63, 0x3a, 0xa7, 0xeb, 0x63, 0x93, 0x34, 0x8a,
+	0x93, 0xdc, 0x85, 0x37, 0xb1, 0x7d, 0xa5, 0x89, 0xbd, 0x33, 0xa6, 0x73, 0xba, 0x3e, 0x36, 0x49,
-	0x4f, 0xa1, 0x32, 0x68, 0x0d, 0x73, 0xfe, 0x36, 0x5c, 0xc2, 0x1c, 0xc8, 0x76, 0x61, 0x4c, 0x7a,
+	0xa3, 0xf8, 0x04, 0x2a, 0x83, 0xd6, 0x30, 0xe7, 0x6f, 0xc2, 0x65, 0xcc, 0x81, 0x6c, 0x17, 0xc6,
-	0x04, 0x8e, 0x9b, 0xc6, 0x2e, 0x0d, 0x1e, 0xba, 0xde, 0xd1, 0x18, 0x4d, 0x03, 0x25, 0x74, 0x4d,
+	0xa4, 0x47, 0xe0, 0xb8, 0x69, 0xec, 0xd1, 0xe0, 0xa1, 0xeb, 0x1d, 0x8f, 0xd1, 0x34, 0x50, 0x42,
-	0x23, 0x52, 0x16, 0x53, 0xb2, 0x27, 0x8e, 0x4c, 0x94, 0x94, 0x52, 0x12, 0x6b, 0xdd, 0x0f, 0x9b,
+	0xd7, 0x34, 0x22, 0x65, 0x31, 0x25, 0x7b, 0xe2, 0xc8, 0x44, 0x49, 0x29, 0x25, 0xb1, 0xd6, 0xfd,
-	0x86, 0xe2, 0x19, 0x61, 0xd3, 0x04, 0x4b, 0x26, 0xde, 0x57, 0xf8, 0x9d, 0x73, 0x14, 0x65, 0x38,
+	0xb0, 0x69, 0x28, 0x9e, 0x11, 0x36, 0x4d, 0xb0, 0x64, 0xe2, 0x7d, 0x85, 0xdf, 0x39, 0x47, 0x51,
-	0x47, 0xf3, 0x31, 0x47, 0x51, 0x96, 0x73, 0x14, 0x01, 0x51, 0x23, 0x39, 0x27, 0x1f, 0xbf, 0x90,
+	0x86, 0x73, 0x34, 0x1f, 0x73, 0x14, 0x65, 0x39, 0x47, 0x11, 0x10, 0x35, 0x92, 0x0b, 0xf2, 0xf1,
-	0x65, 0x73, 0xee, 0x6e, 0x46, 0xa5, 0xa4, 0x78, 0x1a, 0x95, 0x12, 0x9e, 0x9f, 0xa1, 0x94, 0x14,
+	0x73, 0x59, 0x36, 0x17, 0xee, 0x66, 0x54, 0x4a, 0x8a, 0xa7, 0x51, 0x29, 0xe1, 0xf9, 0x39, 0x4a,
-	0xc9, 0x17, 0xab, 0x94, 0x52, 0x9c, 0x7b, 0x4e, 0xa5, 0x14, 0x5b, 0x8b, 0x4b, 0x09, 0x73, 0x60,
+	0x49, 0x91, 0x7c, 0xb1, 0x4a, 0x29, 0xc5, 0xb9, 0xe7, 0x54, 0x4a, 0xb1, 0xb5, 0xb8, 0x94, 0x30,
-	0x2c, 0x25, 0x99, 0x94, 0x08, 0x1c, 0xe7, 0xeb, 0x6e, 0xb3, 0xd7, 0x3c, 0xa4, 0x5e, 0x94, 0x2f,
+	0x07, 0xc6, 0x52, 0x92, 0x49, 0x89, 0xc0, 0xf8, 0x27, 0x6e, 0xa7, 0x73, 0xe2, 0x33, 0x77, 0x13,
-	0xf1, 0xb7, 0x6f, 0xbb, 0x73, 0xec, 0x07, 0xfc, 0x34, 0x6a, 0xab, 0x2d, 0x71, 0xa2, 0xb4, 0x55,
+	0xdd, 0xb3, 0x25, 0x4e, 0x94, 0xee, 0x89, 0x38, 0x9e, 0x72, 0x04, 0x44, 0xcc, 0x8c, 0x54, 0xc4,
-	0xc4, 0x71, 0x2e, 0x20, 0x20, 0xa2, 0x6c, 0xa4, 0x22, 0xa6, 0x2c, 0x42, 0x4c, 0x94, 0x95, 0x52,
+	0xcc, 0x44, 0x88, 0x89, 0x99, 0x52, 0x4a, 0x62, 0x23, 0x9a, 0xe0, 0x8b, 0x73, 0xd0, 0x44, 0x91,
-	0x12, 0x1b, 0xf1, 0x07, 0x5f, 0x9c, 0x81, 0x3f, 0x8a, 0xe4, 0x8b, 0xc5, 0x9f, 0x14, 0xe7, 0x9e,
+	0x7c, 0xb1, 0x68, 0x92, 0xe2, 0xdc, 0x73, 0xa2, 0x49, 0x6c, 0x2d, 0xa6, 0x09, 0x5e, 0xb4, 0x91,
-	0x13, 0x7f, 0x62, 0x6b, 0x31, 0x7f, 0xf0, 0xa2, 0x8d, 0xfc, 0x91, 0x59, 0x89, 0xc0, 0x89, 0x91,
+	0x26, 0x32, 0x2b, 0x11, 0x38, 0x31, 0x79, 0x4c, 0x42, 0x15, 0x3e, 0x79, 0x48, 0xf4, 0x38, 0x93,
-	0x64, 0x12, 0xaa, 0xf0, 0x91, 0x44, 0xa2, 0xc7, 0x19, 0x49, 0x50, 0x66, 0x8c, 0x91, 0x04, 0xad,
+	0x07, 0xca, 0x8c, 0x31, 0x79, 0xa0, 0x75, 0xdd, 0xe4, 0x71, 0x31, 0x44, 0xad, 0xff, 0x3a, 0x0f,
-	0xeb, 0x46, 0x92, 0xf3, 0x21, 0x6a, 0xfd, 0xb7, 0x39, 0x28, 0x6c, 0x8b, 0x9f, 0x7b, 0x88, 0x03,
+	0x85, 0x1d, 0xf1, 0xab, 0x0e, 0x71, 0xa0, 0x80, 0x3f, 0x98, 0x10, 0x4b, 0x27, 0x3c, 0xf8, 0x23,
-	0x05, 0xfc, 0x25, 0x85, 0x58, 0x3a, 0xe1, 0xc1, 0x5f, 0x67, 0xaa, 0x37, 0x8c, 0x18, 0x2c, 0xcc,
+	0x4c, 0xf5, 0xa6, 0x11, 0x83, 0xfd, 0x72, 0xe1, 0xe7, 0xef, 0xff, 0xfa, 0x36, 0x3f, 0x07, 0xe5,
-	0xf9, 0x5f, 0x7e, 0xf8, 0xfb, 0xbb, 0xfc, 0x2c, 0x94, 0x43, 0xd0, 0x1b, 0x5d, 0x51, 0xb7, 0xc4,
+	0x10, 0xf4, 0x5a, 0xb7, 0xd9, 0x6b, 0x1e, 0x51, 0x8f, 0xb8, 0x50, 0x8c, 0xd6, 0x73, 0xf2, 0xca,
-	0x85, 0x62, 0xb4, 0xb7, 0x93, 0xd7, 0x46, 0xf9, 0x01, 0xa3, 0xfa, 0x7a, 0x06, 0xca, 0x6c, 0xd0,
+	0x28, 0xbf, 0x53, 0x54, 0x5f, 0xcd, 0x40, 0x99, 0x0d, 0x7a, 0x00, 0xf1, 0x76, 0x4c, 0xb4, 0xba,
-	0x03, 0x88, 0xd7, 0x66, 0xa2, 0xd5, 0x35, 0xf4, 0x13, 0x40, 0x75, 0x39, 0x0b, 0x96, 0x69, 0x33,
+	0x86, 0x36, 0xfd, 0xea, 0x4a, 0x16, 0x2c, 0xd3, 0x66, 0xbc, 0x13, 0xeb, 0x6d, 0x0e, 0x6d, 0xdb,
-	0x5e, 0x96, 0xf5, 0x36, 0x87, 0xd6, 0x70, 0xbd, 0x4d, 0xcd, 0xce, 0x9d, 0x62, 0x53, 0xe4, 0x90,
+	0x7a, 0x9b, 0x9a, 0xd5, 0x3a, 0xc5, 0xa6, 0xc8, 0x21, 0x5f, 0x4d, 0x52, 0x73, 0x98, 0xd8, 0x89,
-	0xef, 0x2c, 0xa9, 0x39, 0x4c, 0x2c, 0xcb, 0xa9, 0x39, 0x1c, 0x58, 0x8b, 0xcd, 0x39, 0x0c, 0x37,
+	0x53, 0x73, 0x38, 0xb0, 0xfd, 0x9a, 0x73, 0x18, 0x2e, 0x4e, 0xe9, 0x39, 0x4c, 0x6e, 0x98, 0xe9,
-	0xaa, 0xf4, 0x1c, 0x26, 0x57, 0xcf, 0xf4, 0x1c, 0x0e, 0xac, 0x65, 0x99, 0xf7, 0x19, 0x86, 0x67,
+	0x39, 0x1c, 0xd8, 0xbe, 0x32, 0xef, 0x33, 0x0c, 0xcf, 0x70, 0x9f, 0xc9, 0x08, 0x57, 0xb2, 0x60,
-	0xb8, 0xcf, 0x64, 0x84, 0xcb, 0x59, 0xb0, 0x4c, 0x9b, 0xf1, 0x46, 0xa4, 0xb7, 0x39, 0xb4, 0x74,
+	0x99, 0x36, 0xe3, 0xc5, 0x47, 0x6f, 0x73, 0x68, 0xb7, 0xd2, 0xdb, 0x1c, 0xde, 0x9f, 0xd2, 0x6c,
-	0xe9, 0x6d, 0x0e, 0x2f, 0x56, 0x69, 0x36, 0x1f, 0xc1, 0xe5, 0xe4, 0x04, 0x4a, 0x6e, 0x8e, 0x38,
+	0x3e, 0x82, 0x2b, 0xc9, 0x41, 0x93, 0xdc, 0x1a, 0x71, 0xf0, 0xad, 0xae, 0x66, 0x03, 0xcd, 0x96,
-	0x11, 0x57, 0x57, 0xb2, 0x81, 0x66, 0xcb, 0xdf, 0x40, 0x79, 0x60, 0x25, 0x25, 0x5a, 0x8d, 0xba,
+	0xbf, 0x86, 0xf2, 0xc0, 0xe6, 0x49, 0xb4, 0x1a, 0x75, 0x9b, 0x6e, 0x75, 0x6d, 0x04, 0x64, 0xa6,
-	0x15, 0xb8, 0xba, 0x3a, 0x02, 0x32, 0xd3, 0xf8, 0xc0, 0xb6, 0xa5, 0x37, 0xae, 0xdb, 0x28, 0xf5,
+	0xf1, 0x81, 0xa5, 0x4a, 0x6f, 0x5c, 0xb7, 0x38, 0xea, 0x8d, 0x6b, 0x37, 0x34, 0x83, 0xf1, 0x81,
-	0xc6, 0xb5, 0xab, 0x9b, 0xc1, 0xf8, 0xc0, 0x52, 0xa5, 0x37, 0xae, 0xdb, 0xde, 0xf4, 0xc6, 0xf5,
+	0xdd, 0x49, 0x6f, 0x5c, 0xb7, 0xa4, 0xe9, 0x8d, 0xeb, 0x17, 0x31, 0x23, 0xc9, 0x70, 0xaa, 0x49,
-	0x1b, 0x9a, 0x91, 0x64, 0x38, 0xee, 0xa4, 0x92, 0x6c, 0x70, 0xfa, 0x4d, 0x25, 0x99, 0x3a, 0xca,
+	0x25, 0xd9, 0xe0, 0x90, 0x9b, 0x4a, 0x32, 0x75, 0x62, 0x35, 0x93, 0x4c, 0x8e, 0x60, 0xe9, 0x24,
-	0x9a, 0x49, 0x26, 0x67, 0xb3, 0x74, 0x92, 0x29, 0xb3, 0x62, 0x3a, 0xc9, 0xd4, 0x31, 0x2f, 0x93,
+	0x53, 0x46, 0xc2, 0x74, 0x92, 0xa9, 0xd3, 0x5c, 0x26, 0xc9, 0x64, 0xc0, 0x06, 0x92, 0x29, 0x31,
-	0x64, 0x32, 0x60, 0x03, 0xc9, 0x94, 0x98, 0x57, 0x47, 0x40, 0x8e, 0x98, 0x67, 0xa3, 0x71, 0xdd,
+	0xaf, 0x8d, 0x80, 0x1c, 0x31, 0xcf, 0x46, 0xe3, 0xba, 0xad, 0xc2, 0x94, 0xe7, 0x11, 0x8d, 0x8b,
-	0xba, 0x61, 0xca, 0xf3, 0x88, 0xc6, 0x45, 0x9e, 0xf1, 0x6f, 0x70, 0x6a, 0x9e, 0x07, 0x47, 0x93,
+	0x3c, 0xe3, 0xdf, 0xe0, 0xd4, 0x3c, 0x0f, 0x8e, 0x26, 0xa9, 0x79, 0x56, 0x06, 0x80, 0x8c, 0x3c,
-	0xd4, 0x3c, 0x2b, 0x03, 0x40, 0x46, 0x9e, 0xe5, 0x0c, 0x95, 0x9e, 0x67, 0x65, 0xa6, 0x4b, 0xcf,
+	0xcb, 0x19, 0x2a, 0x3d, 0xcf, 0xca, 0x4c, 0x97, 0x9e, 0x67, 0x75, 0x1c, 0xcb, 0xac, 0x67, 0x19,
-	0xb3, 0x3a, 0x8e, 0x65, 0xd6, 0xb3, 0x0c, 0xd8, 0x50, 0xcf, 0x4a, 0xcc, 0xab, 0x23, 0x20, 0x8d,
+	0xb0, 0xa1, 0x9e, 0x95, 0x98, 0xd7, 0x46, 0x40, 0x1a, 0x8d, 0x6f, 0x2f, 0x3d, 0x7e, 0xba, 0xfc,
-	0xc6, 0xb7, 0x16, 0x1f, 0x3f, 0x5d, 0x7a, 0xe9, 0x77, 0xf6, 0xf9, 0xe7, 0xe9, 0x52, 0xee, 0xdb,
+	0xbf, 0xdf, 0xd8, 0xe7, 0xef, 0xa7, 0xcb, 0xb9, 0x6f, 0x9e, 0x2d, 0xe7, 0x1e, 0xb3, 0xcf, 0x2f,
-	0x67, 0x4b, 0xb9, 0xc7, 0xec, 0xf3, 0x2b, 0xfb, 0x3c, 0x61, 0x9f, 0x83, 0xe9, 0xf0, 0x7f, 0x9c,
+	0xec, 0xf3, 0x84, 0x7d, 0x0e, 0x67, 0xc2, 0xff, 0x58, 0xda, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff,
-	0x36, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x43, 0x84, 0x5f, 0x00, 0xea, 0x1a, 0x00, 0x00,
+	0x35, 0x0f, 0xc7, 0x5a, 0xd1, 0x1a, 0x00, 0x00,
 }

vendor/src/github.com/docker/swarmkit/api/control.proto

@@ -235,8 +235,6 @@ message ListNetworksResponse {
 	repeated Network networks = 1;
 }
 
-message RemoveManagerResponse {}
-
 message GetClusterRequest {
 	string cluster_id = 1 [(gogoproto.customname) = "ClusterID"];
 }

vendor/src/github.com/docker/swarmkit/api/objects.pb.go

@@ -49,8 +49,8 @@ type Node struct {
 	Description *NodeDescription `protobuf:"bytes,4,opt,name=description" json:"description,omitempty"`
 	// Status provides the current status of the node, as seen by the manager.
 	Status NodeStatus `protobuf:"bytes,5,opt,name=status" json:"status"`
-	// Status of the manager. If the node is not a manager, this field will not
+	// ManagerStatus provides the current status of the node's manager
-	// be set.
+	// component, if the node is a manager.
 	ManagerStatus *ManagerStatus `protobuf:"bytes,6,opt,name=manager_status,json=managerStatus" json:"manager_status,omitempty"`
 	// The node attachment to the ingress network.
 	Attachment *NetworkAttachment `protobuf:"bytes,7,opt,name=attachment" json:"attachment,omitempty"`

vendor/src/github.com/docker/swarmkit/api/objects.proto

@@ -39,8 +39,8 @@ message Node {
 	// Status provides the current status of the node, as seen by the manager.
 	NodeStatus status = 5 [(gogoproto.nullable) = false];
 
-	// Status of the manager. If the node is not a manager, this field will not
+	// ManagerStatus provides the current status of the node's manager
-	// be set.
+	// component, if the node is a manager.
 	ManagerStatus manager_status = 6;
 
 	// The node attachment to the ingress network.

vendor/src/github.com/docker/swarmkit/api/raft.proto

@@ -10,16 +10,6 @@ import weak "plugin/plugin.proto";
 
 // Raft defines the RPC communication between raft nodes.
 service Raft {
-	// Join adds a RaftMember to the raft cluster.
-	rpc Join(JoinRequest) returns (JoinResponse) {
-		option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-manager" };
-	};
-
-	// Leave removes a RaftMember from the raft cluster.
-	rpc Leave(LeaveRequest) returns (LeaveResponse) {
-		option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-manager" };
-	};
-
 	// ProcessRaftMessage sends a raft message to be processed on a raft member, it is
 	// called from the RaftMember willing to send a message to its destination ('To' field)
 	rpc ProcessRaftMessage(ProcessRaftMessageRequest) returns (ProcessRaftMessageResponse) {
@@ -32,13 +22,44 @@ service Raft {
 	};
 }
 
+// RaftMembership defines RPCs for adding and removing members from the
+// cluster. These RPCs must always run on the leader, so they are in a separate
+// service to support the raft proxy.
+service RaftMembership {
+	// Join adds a RaftMember to the raft cluster.
+	rpc Join(JoinRequest) returns (JoinResponse) {
+		option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-manager" };
+	};
+
+	// Leave removes a RaftMember from the raft cluster.
+	rpc Leave(LeaveRequest) returns (LeaveResponse) {
+		option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-manager" };
+	};
+}
+
+message RaftMember {
+	// RaftID specifies the internal ID used by the manager in a raft context, it can never be modified
+	// and is used only for information purposes
+	uint64 raft_id = 1 [(gogoproto.customname) = "RaftID"];
+
+	// NodeID is the node's ID.
+	string node_id = 2 [(gogoproto.customname) = "NodeID"];
+
+	// Addr specifies the address of the member
+	string addr = 3;
+
+	// Status provides the current status of the manager from the perspective of another manager.
+	RaftMemberStatus status = 4 [(gogoproto.nullable) = false];
+}
+
 message JoinRequest {
 	// Addr specifies the address of the member
 	string addr = 1;
 }
 
 message JoinResponse {
-	repeated RaftMember members = 1;
+	uint64 raft_id = 1 [(gogoproto.customname) = "RaftID"];
+	repeated RaftMember members = 2;
 }
 
 message LeaveRequest {

vendor/src/github.com/docker/swarmkit/api/snapshot.pb.go

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

vendor/src/github.com/docker/swarmkit/api/snapshot.proto

@@ -3,7 +3,7 @@ syntax = "proto3";
 package docker.swarmkit.v1;
 
 import "objects.proto";
-import "types.proto";
+import "raft.proto";
 import weak "gogoproto/gogo.proto";
 
 // StoreSnapshot is used to store snapshots of the store.

vendor/src/github.com/docker/swarmkit/api/specs.pb.go

@@ -405,6 +405,10 @@ type ContainerSpec struct {
 	// service definitions will used immutable references, either through tags
 	// that don't change or verifiable digests.
 	Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
+	// RegistryAuth is the registry auth token obtained from the client, required
+	// to pull private images
+	// TODO(nishanttotla): This field will later be deprecated
+	RegistryAuth string `protobuf:"bytes,64,opt,name=registry_auth,json=registryAuth,proto3" json:"registry_auth,omitempty"`
 	// Labels defines labels to be added to the container at creation time. If
 	// collisions with system labels occur, these labels will be overridden.
 	//
@@ -625,6 +629,7 @@ func (m *ContainerSpec) Copy() *ContainerSpec {
 
 	o := &ContainerSpec{
 		Image:           m.Image,
+		RegistryAuth:    m.RegistryAuth,
 		Dir:             m.Dir,
 		User:            m.User,
 		StopGracePeriod: m.StopGracePeriod.Copy(),
@@ -835,9 +840,10 @@ func (this *ContainerSpec) GoString() string {
 	if this == nil {
 		return "nil"
 	}
-	s := make([]string, 0, 13)
+	s := make([]string, 0, 14)
 	s = append(s, "&api.ContainerSpec{")
 	s = append(s, "Image: "+fmt.Sprintf("%#v", this.Image)+",\n")
+	s = append(s, "RegistryAuth: "+fmt.Sprintf("%#v", this.RegistryAuth)+",\n")
 	keysForLabels := make([]string, 0, len(this.Labels))
 	for k, _ := range this.Labels {
 		keysForLabels = append(keysForLabels, k)
@@ -1344,6 +1350,14 @@ func (m *ContainerSpec) MarshalTo(data []byte) (int, error) {
 		}
 		i += n14
 	}
+	if len(m.RegistryAuth) > 0 {
+		data[i] = 0x82
+		i++
+		data[i] = 0x4
+		i++
+		i = encodeVarintSpecs(data, i, uint64(len(m.RegistryAuth)))
+		i += copy(data[i:], m.RegistryAuth)
+	}
 	return i, nil
 }
 
@@ -1716,6 +1730,10 @@ func (m *ContainerSpec) Size() (n int) {
 		l = m.StopGracePeriod.Size()
 		n += 1 + l + sovSpecs(uint64(l))
 	}
+	l = len(m.RegistryAuth)
+	if l > 0 {
+		n += 2 + l + sovSpecs(uint64(l))
+	}
 	return n
 }
 
@@ -1912,6 +1930,7 @@ func (this *ContainerSpec) String() string {
 		`User:` + fmt.Sprintf("%v", this.User) + `,`,
 		`Mounts:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Mounts), "Mount", "Mount", 1), `&`, ``, 1) + `,`,
 		`StopGracePeriod:` + strings.Replace(fmt.Sprintf("%v", this.StopGracePeriod), "Duration", "docker_swarmkit_v11.Duration", 1) + `,`,
+		`RegistryAuth:` + fmt.Sprintf("%v", this.RegistryAuth) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -3158,6 +3177,35 @@ func (m *ContainerSpec) Unmarshal(data []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 64:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RegistryAuth", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSpecs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RegistryAuth = string(data[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipSpecs(data[iNdEx:])
@@ -3801,82 +3849,84 @@ var (
 )
 
 var fileDescriptorSpecs = []byte{
-	// 1224 bytes of a gzipped FileDescriptorProto
+	// 1249 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x56, 0x4d, 0x6f, 0x1b, 0x45,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x56, 0x4f, 0x73, 0x1b, 0x35,
-	0x18, 0x8e, 0xe3, 0x8d, 0xb3, 0x9e, 0x4d, 0x5a, 0x77, 0x54, 0x5a, 0xd7, 0x2d, 0x49, 0x6a, 0x15,
+	0x14, 0x8f, 0xe3, 0x8d, 0xb3, 0xd6, 0x26, 0xad, 0xab, 0x29, 0xad, 0xeb, 0x96, 0x24, 0x35, 0x05,
-	0x28, 0x48, 0x38, 0x60, 0x50, 0x5b, 0xbe, 0x84, 0xb6, 0xb6, 0x49, 0x4d, 0x89, 0x6b, 0x4d, 0xda,
+	0x0a, 0x33, 0x38, 0x60, 0x98, 0xb6, 0xfc, 0x1b, 0xd8, 0xda, 0x26, 0x35, 0x25, 0xae, 0x47, 0x69,
-	0x70, 0x8c, 0xc6, 0xbb, 0x53, 0x67, 0x95, 0xf5, 0xce, 0x32, 0x3b, 0x76, 0x95, 0x1b, 0xc7, 0x8a,
+	0xcb, 0x31, 0x23, 0xef, 0xaa, 0x8e, 0x26, 0xeb, 0xdd, 0x45, 0x2b, 0xbb, 0x93, 0x1b, 0xc7, 0x0e,
-	0x03, 0xe2, 0xc2, 0x05, 0x89, 0x13, 0xff, 0x81, 0xdf, 0x90, 0x23, 0x37, 0x38, 0x55, 0xb4, 0xbf,
+	0x07, 0x6e, 0x5c, 0x98, 0xe1, 0xc4, 0x67, 0x80, 0xcf, 0x90, 0x23, 0x37, 0x38, 0x75, 0x68, 0x3f,
-	0x00, 0x89, 0x3f, 0xc0, 0x3b, 0xb3, 0x63, 0x7b, 0x4d, 0x37, 0xed, 0x25, 0x87, 0x95, 0xe6, 0xe3,
+	0x01, 0x33, 0x7c, 0x01, 0x9e, 0xb4, 0xb2, 0xbd, 0xa6, 0x9b, 0xf6, 0x92, 0xc3, 0xce, 0x48, 0x4f,
-	0x79, 0x9e, 0x99, 0x79, 0x3f, 0x17, 0x39, 0x49, 0xcc, 0xbc, 0xa4, 0x11, 0x0b, 0x2e, 0x39, 0xc6,
+	0xbf, 0xdf, 0x4f, 0xd2, 0x7b, 0x4f, 0xef, 0x2d, 0x72, 0x92, 0x98, 0x79, 0x49, 0x23, 0x16, 0x91,
-	0x3e, 0xf7, 0x8e, 0x98, 0x68, 0x24, 0x4f, 0xa8, 0x18, 0x1d, 0x05, 0xb2, 0x31, 0xf9, 0xb0, 0xe6,
+	0x8c, 0x30, 0xf6, 0x23, 0xef, 0x90, 0x89, 0x46, 0xf2, 0x98, 0x8a, 0xd1, 0x21, 0x97, 0x8d, 0xc9,
-	0xc8, 0xe3, 0x98, 0x19, 0x40, 0xed, 0xe2, 0x90, 0x0f, 0xb9, 0x1e, 0x6e, 0xab, 0x91, 0x59, 0xbd,
+	0x07, 0x35, 0x47, 0x1e, 0xc5, 0xcc, 0x00, 0x6a, 0xe7, 0x87, 0xd1, 0x30, 0xd2, 0xc3, 0x6d, 0x35,
-	0xec, 0x8f, 0x05, 0x95, 0x01, 0x8f, 0xb6, 0xa7, 0x83, 0x74, 0xa3, 0xfe, 0xa3, 0x85, 0xec, 0x1e,
+	0x32, 0xd6, 0x8b, 0xfe, 0x58, 0x50, 0xc9, 0xa3, 0x70, 0x7b, 0x3a, 0x48, 0x17, 0xea, 0x3f, 0x5a,
-	0xf7, 0xd9, 0x1e, 0x9c, 0x81, 0x77, 0x90, 0x43, 0xa3, 0x88, 0x4b, 0x0d, 0x48, 0xaa, 0x85, 0xad,
+	0xc8, 0xee, 0x45, 0x3e, 0xdb, 0x83, 0x3d, 0xf0, 0x0e, 0x72, 0x68, 0x18, 0x46, 0x52, 0x03, 0x92,
-	0xc2, 0x4d, 0xa7, 0xb9, 0xd9, 0x78, 0xf9, 0xc8, 0x86, 0x3b, 0x87, 0xdd, 0xb5, 0x4e, 0x9e, 0x6d,
+	0x6a, 0x61, 0xab, 0x70, 0xdd, 0x69, 0x6e, 0x36, 0x5e, 0xdc, 0xb2, 0xe1, 0xce, 0x61, 0xb7, 0xad,
-	0x2e, 0x91, 0x2c, 0x13, 0x7f, 0x80, 0x2c, 0xc1, 0x43, 0x56, 0x5d, 0x06, 0x85, 0x73, 0xcd, 0x6b,
+	0xe3, 0xa7, 0x9b, 0x4b, 0x24, 0xcb, 0xc4, 0xef, 0x23, 0x4b, 0x44, 0x01, 0xab, 0x2e, 0x83, 0xc2,
-	0x79, 0x0a, 0xea, 0x50, 0x02, 0x18, 0xa2, 0x91, 0x70, 0x34, 0x1a, 0xb1, 0xd1, 0x80, 0x89, 0xe4,
+	0x99, 0xe6, 0x95, 0x3c, 0x05, 0xb5, 0x29, 0x01, 0x0c, 0xd1, 0x48, 0xd8, 0x1a, 0x8d, 0xd8, 0x68,
-	0x30, 0x88, 0xab, 0x45, 0xcd, 0x7b, 0xe7, 0x34, 0x9e, 0xba, 0x6c, 0x63, 0x77, 0x06, 0x27, 0x19,
+	0xc0, 0x44, 0x72, 0xc0, 0xe3, 0x6a, 0x51, 0xf3, 0xde, 0x3e, 0x89, 0xa7, 0x0e, 0xdb, 0xd8, 0x9d,
-	0x2a, 0xde, 0x45, 0x6b, 0x74, 0x42, 0x83, 0x90, 0x0e, 0x82, 0x30, 0x90, 0xc7, 0x55, 0x4b, 0x4b,
+	0xc1, 0x49, 0x86, 0x8a, 0x77, 0xd1, 0x1a, 0x9d, 0x50, 0x1e, 0xd0, 0x01, 0x0f, 0xb8, 0x3c, 0xaa,
-	0xbd, 0xfb, 0x4a, 0x29, 0x37, 0x43, 0x20, 0x0b, 0xf4, 0xba, 0x8f, 0xd0, 0xfc, 0x20, 0xfc, 0x36,
+	0x5a, 0x5a, 0xea, 0x9d, 0x97, 0x4a, 0xb9, 0x19, 0x02, 0x59, 0xa0, 0xd7, 0x7d, 0x84, 0xe6, 0x1b,
-	0x5a, 0xed, 0x77, 0x7a, 0xed, 0x6e, 0x6f, 0xa7, 0xb2, 0x54, 0xbb, 0xf2, 0xc3, 0xaf, 0x5b, 0x6f,
+	0xe1, 0xb7, 0xd0, 0x6a, 0xbf, 0xd3, 0x6b, 0x77, 0x7b, 0x3b, 0x95, 0xa5, 0xda, 0xa5, 0x1f, 0x7e,
-	0x28, 0x8d, 0x39, 0xa0, 0xcf, 0x22, 0x3f, 0x88, 0x86, 0xf8, 0x26, 0xb2, 0xdd, 0x56, 0xab, 0xd3,
+	0xd9, 0x7a, 0x4d, 0x69, 0xcc, 0x01, 0x7d, 0x16, 0xfa, 0x3c, 0x1c, 0xe2, 0xeb, 0xc8, 0x76, 0x5b,
-	0x7f, 0xd8, 0x69, 0x57, 0x0a, 0xb5, 0x1a, 0x00, 0x2f, 0x2d, 0x02, 0x5d, 0xcf, 0x63, 0xb1, 0x64,
+	0xad, 0x4e, 0xff, 0x7e, 0xa7, 0x5d, 0x29, 0xd4, 0x6a, 0x00, 0xbc, 0xb0, 0x08, 0x74, 0x3d, 0x8f,
-	0x7e, 0xcd, 0x7a, 0xfa, 0xdb, 0xc6, 0x52, 0xfd, 0x69, 0x01, 0xad, 0x65, 0x2f, 0x01, 0x07, 0x95,
+	0xc5, 0x92, 0xf9, 0x35, 0xeb, 0xc9, 0xaf, 0x1b, 0x4b, 0xf5, 0x27, 0x05, 0xb4, 0x96, 0x3d, 0x04,
-	0xdc, 0xd6, 0xc3, 0xee, 0x7e, 0x07, 0xce, 0x99, 0xd1, 0xb3, 0x08, 0xd7, 0x93, 0xc1, 0x84, 0xe1,
+	0x6c, 0x54, 0x72, 0x5b, 0xf7, 0xbb, 0x0f, 0x3b, 0xb0, 0xcf, 0x8c, 0x9e, 0x45, 0xb8, 0x9e, 0xe4,
-	0x1b, 0x68, 0xa5, 0xef, 0x3e, 0xda, 0xeb, 0xc0, 0x29, 0xb3, 0xeb, 0x64, 0x61, 0x7d, 0x3a, 0x4e,
+	0x13, 0x86, 0xaf, 0xa1, 0x95, 0xbe, 0xfb, 0x60, 0xaf, 0x03, 0xbb, 0xcc, 0x8e, 0x93, 0x85, 0xf5,
-	0x34, 0xaa, 0x4d, 0xdc, 0x6e, 0xaf, 0xb2, 0x9c, 0x8f, 0x6a, 0x0b, 0x1a, 0x44, 0xe6, 0x2a, 0xbf,
+	0xe9, 0x38, 0xd1, 0xa8, 0x36, 0x71, 0xbb, 0xbd, 0xca, 0x72, 0x3e, 0xaa, 0x2d, 0x28, 0x0f, 0xcd,
-	0x5b, 0xc8, 0xd9, 0x63, 0x62, 0x12, 0x78, 0x67, 0x1c, 0x13, 0xb7, 0x90, 0x25, 0x69, 0x72, 0xa4,
+	0x51, 0x7e, 0xb7, 0x90, 0xb3, 0xc7, 0xc4, 0x84, 0x7b, 0xa7, 0x9c, 0x13, 0x37, 0x90, 0x25, 0x69,
-	0x63, 0xc2, 0xc9, 0x8f, 0x89, 0x87, 0xb0, 0xaf, 0x0e, 0x35, 0x74, 0x8d, 0x57, 0x91, 0x21, 0x58,
+	0x72, 0xa8, 0x73, 0xc2, 0xc9, 0xcf, 0x89, 0xfb, 0xb0, 0xae, 0x36, 0x35, 0x74, 0x8d, 0x57, 0x99,
-	0x1c, 0x06, 0x1e, 0x05, 0x7b, 0xe9, 0xc8, 0x70, 0x9a, 0x6f, 0xe5, 0xb1, 0xc9, 0x0c, 0x65, 0xee,
+	0x21, 0x58, 0x1c, 0x70, 0x8f, 0x82, 0xbf, 0x74, 0x66, 0x38, 0xcd, 0x37, 0xf3, 0xd8, 0x64, 0x86,
-	0x7f, 0x6f, 0x89, 0x64, 0xa8, 0xf8, 0x33, 0x54, 0x1a, 0x86, 0x7c, 0x40, 0x43, 0x1d, 0x13, 0x4e,
+	0x32, 0xe7, 0xbf, 0xb3, 0x44, 0x32, 0x54, 0xfc, 0x29, 0x2a, 0x0d, 0x83, 0x68, 0x40, 0x03, 0x9d,
-	0xf3, 0x7a, 0x9e, 0xc8, 0x8e, 0x46, 0xcc, 0x05, 0x0c, 0x05, 0xdf, 0x41, 0xa5, 0x71, 0xec, 0x83,
+	0x13, 0x4e, 0xf3, 0x6a, 0x9e, 0xc8, 0x8e, 0x46, 0xcc, 0x05, 0x0c, 0x05, 0xdf, 0x42, 0xa5, 0x71,
-	0x4e, 0xb5, 0xa4, 0xc9, 0x5b, 0x79, 0xe4, 0x47, 0x1a, 0xd1, 0xe2, 0xd1, 0xe3, 0x60, 0x48, 0x0c,
+	0xec, 0x83, 0x4e, 0xb5, 0xa4, 0xc9, 0x5b, 0x79, 0xe4, 0x07, 0x1a, 0xd1, 0x8a, 0xc2, 0x47, 0x7c,
-	0x1e, 0xef, 0x21, 0x3b, 0x62, 0xf2, 0x09, 0x17, 0x47, 0x49, 0x75, 0x75, 0xab, 0x08, 0xdc, 0xdb,
+	0x48, 0x0c, 0x1e, 0xef, 0x21, 0x3b, 0x64, 0xf2, 0x71, 0x24, 0x0e, 0x93, 0xea, 0xea, 0x56, 0x11,
-	0x79, 0xdc, 0x8c, 0xcd, 0x1b, 0xbd, 0x14, 0xef, 0x4a, 0x49, 0xbd, 0xc3, 0x11, 0x8b, 0xa4, 0x91,
+	0xb8, 0x37, 0xf3, 0xb8, 0x19, 0x9f, 0x37, 0x7a, 0x29, 0xde, 0x95, 0x92, 0x7a, 0x07, 0x23, 0x16,
-	0x9c, 0x09, 0xe1, 0xcf, 0x91, 0x0d, 0xa1, 0x16, 0xf3, 0x20, 0x92, 0x55, 0xfb, 0xf4, 0x0b, 0x75,
+	0x4a, 0x23, 0x39, 0x13, 0xc2, 0x9f, 0x21, 0x1b, 0x52, 0x2d, 0x8e, 0x78, 0x28, 0xab, 0xf6, 0xc9,
-	0x0c, 0x46, 0xa9, 0x92, 0x19, 0xa3, 0x76, 0x1f, 0x5d, 0x3e, 0xe5, 0x08, 0x7c, 0x09, 0x95, 0x24,
+	0x07, 0xea, 0x18, 0x8c, 0x52, 0x25, 0x33, 0x46, 0xed, 0x2e, 0xba, 0x78, 0xc2, 0x16, 0xf8, 0x02,
-	0x15, 0x43, 0x26, 0xb5, 0xa7, 0xcb, 0xc4, 0xcc, 0x70, 0x15, 0xad, 0xd2, 0x30, 0xa0, 0x09, 0x4b,
+	0x2a, 0x49, 0x2a, 0x86, 0x4c, 0xea, 0x48, 0x97, 0x89, 0x99, 0xe1, 0x2a, 0x5a, 0xa5, 0x01, 0xa7,
-	0xc0, 0x81, 0x45, 0xd8, 0x98, 0x4e, 0xef, 0x96, 0x90, 0x35, 0x82, 0x78, 0xaa, 0x6f, 0xa3, 0x0b,
+	0x09, 0x4b, 0x20, 0x80, 0x45, 0x58, 0x98, 0x4e, 0x6f, 0x97, 0x90, 0x35, 0x82, 0x7c, 0xaa, 0x6f,
-	0x2f, 0x79, 0x00, 0xd7, 0x90, 0x6d, 0x3c, 0x90, 0x86, 0x8e, 0x45, 0x66, 0xf3, 0xfa, 0x79, 0xb4,
+	0xa3, 0x73, 0x2f, 0x44, 0x00, 0xd7, 0x90, 0x6d, 0x22, 0x90, 0xa6, 0x8e, 0x45, 0x66, 0xf3, 0xfa,
-	0xbe, 0x60, 0xed, 0xfa, 0x2f, 0xcb, 0xc8, 0x9e, 0x86, 0x00, 0x76, 0x51, 0xd9, 0xe3, 0x91, 0x84,
+	0x59, 0xb4, 0xbe, 0xe0, 0xed, 0xfa, 0xcf, 0xcb, 0xc8, 0x9e, 0xa6, 0x00, 0x76, 0x51, 0xd9, 0x8b,
-	0xc0, 0x64, 0xc2, 0x44, 0x5d, 0xae, 0xc3, 0x5a, 0x53, 0x90, 0x62, 0x81, 0xc3, 0xe6, 0x2c, 0xfc,
+	0x42, 0x09, 0x89, 0xc9, 0x84, 0xc9, 0xba, 0xdc, 0x80, 0xb5, 0xa6, 0x20, 0xc5, 0x82, 0x80, 0xcd,
-	0x15, 0x2a, 0x0b, 0x96, 0xf0, 0xb1, 0xf0, 0xf4, 0xad, 0x95, 0xc4, 0xcd, 0xfc, 0xc0, 0x49, 0x41,
+	0x59, 0xf8, 0x2b, 0x54, 0x16, 0x2c, 0x89, 0xc6, 0xc2, 0xd3, 0xa7, 0x56, 0x12, 0xd7, 0xf3, 0x13,
-	0x84, 0x7d, 0x37, 0x0e, 0x04, 0x53, 0xd6, 0x48, 0xc8, 0x9c, 0x0a, 0x81, 0xb3, 0x0a, 0x13, 0x30,
+	0x27, 0x05, 0x11, 0xf6, 0xdd, 0x98, 0x0b, 0xa6, 0xbc, 0x91, 0x90, 0x39, 0x15, 0x12, 0x67, 0x15,
-	0x84, 0x7c, 0x55, 0xe4, 0x90, 0x14, 0xd2, 0xe7, 0xf0, 0xba, 0x63, 0x32, 0x65, 0x00, 0xb9, 0x1c,
+	0x26, 0xe0, 0x08, 0xf9, 0xb2, 0xcc, 0x21, 0x29, 0xa4, 0x1f, 0xc1, 0xed, 0x8e, 0xc8, 0x94, 0x01,
-	0x87, 0xd4, 0xd3, 0xaa, 0xd5, 0x15, 0x4d, 0x7f, 0x33, 0x8f, 0xde, 0x9f, 0x82, 0xc8, 0x1c, 0x7f,
+	0xe4, 0x72, 0x1c, 0x50, 0x4f, 0xab, 0x56, 0x57, 0x34, 0xfd, 0xf5, 0x3c, 0x7a, 0x7f, 0x0a, 0x22,
-	0xb7, 0x0c, 0x27, 0x8f, 0x23, 0x19, 0x8c, 0x58, 0xfd, 0xa7, 0x22, 0x5a, 0x5f, 0x78, 0x2b, 0xbe,
+	0x73, 0xfc, 0xed, 0x32, 0xec, 0x3c, 0x0e, 0x25, 0x1f, 0xb1, 0xfa, 0x6f, 0x45, 0xb4, 0xbe, 0x70,
-	0x88, 0x56, 0x82, 0x11, 0x1d, 0x32, 0xe3, 0xa9, 0x74, 0x82, 0x3b, 0xa8, 0x04, 0x69, 0xcd, 0xc2,
+	0x57, 0x7c, 0x1e, 0xad, 0xf0, 0x11, 0x1d, 0x32, 0x13, 0xa9, 0x74, 0x82, 0x3b, 0xa8, 0x04, 0xcf,
-	0xd4, 0x4f, 0x4e, 0xf3, 0xfd, 0xd7, 0x1a, 0xad, 0xf1, 0x8d, 0xc6, 0x77, 0x22, 0x29, 0x8e, 0x89,
+	0x9a, 0x05, 0x69, 0x9c, 0x9c, 0xe6, 0x7b, 0xaf, 0x74, 0x5a, 0xe3, 0x1b, 0x8d, 0xef, 0x84, 0x52,
-	0x21, 0x2b, 0x7f, 0x7b, 0x7c, 0x34, 0xa2, 0x91, 0x4a, 0x39, 0xed, 0x6f, 0x33, 0xc5, 0x18, 0x59,
+	0x1c, 0x11, 0x43, 0x56, 0xf1, 0xf6, 0xa2, 0xd1, 0x88, 0x86, 0xea, 0xc9, 0xe9, 0x78, 0x9b, 0x29,
-	0x10, 0x12, 0x09, 0x98, 0x42, 0x2d, 0xeb, 0x31, 0xae, 0xa0, 0x22, 0x8b, 0x26, 0xf0, 0x3c, 0xb5,
+	0xc6, 0xc8, 0x82, 0x94, 0x48, 0xc0, 0x15, 0xca, 0xac, 0xc7, 0xb8, 0x82, 0x8a, 0x2c, 0x9c, 0xc0,
-	0xa4, 0x86, 0x6a, 0xc5, 0x0f, 0x84, 0x4e, 0x16, 0x58, 0x81, 0xa1, 0xe2, 0x41, 0x2d, 0x12, 0x90,
+	0xf5, 0x94, 0x49, 0x0d, 0x95, 0xc5, 0xe7, 0x42, 0x3f, 0x16, 0xb0, 0xc0, 0x50, 0xf1, 0xa0, 0x16,
-	0x03, 0x6a, 0x49, 0x8f, 0xf1, 0x6d, 0x54, 0x1a, 0x71, 0x78, 0x60, 0x02, 0x41, 0xac, 0x2e, 0x7b,
+	0x09, 0x78, 0x03, 0xca, 0xa4, 0xc7, 0xf8, 0x26, 0x2a, 0x8d, 0x22, 0xb8, 0x60, 0x02, 0x49, 0xac,
-	0x25, 0xef, 0xb2, 0xbb, 0x0a, 0x61, 0x4a, 0x82, 0x81, 0xe3, 0x7b, 0xe8, 0x42, 0x22, 0x79, 0x7c,
+	0x0e, 0x7b, 0x29, 0xef, 0xb0, 0xbb, 0x0a, 0x61, 0x4a, 0x82, 0x81, 0xe3, 0x3b, 0xe8, 0x5c, 0x22,
-	0x30, 0x14, 0x60, 0xaa, 0x83, 0x98, 0x89, 0x80, 0xfb, 0xd5, 0xf2, 0xe9, 0x95, 0xa5, 0x6d, 0xba,
+	0xa3, 0x78, 0x7f, 0x28, 0xc0, 0x55, 0xfb, 0x31, 0x13, 0x3c, 0xf2, 0xab, 0xe5, 0x93, 0x2b, 0x4b,
-	0x1e, 0x39, 0xaf, 0x68, 0x3b, 0x8a, 0xd5, 0xd7, 0xa4, 0xda, 0x27, 0xc8, 0xc9, 0xbc, 0x5f, 0xdd,
+	0xdb, 0x74, 0x3d, 0x72, 0x56, 0xd1, 0x76, 0x14, 0xab, 0xaf, 0x49, 0xf8, 0x0d, 0xb4, 0x2e, 0xd8,
-	0xfb, 0x88, 0x1d, 0x1b, 0x93, 0xaa, 0xa1, 0x32, 0xf3, 0x84, 0x86, 0xe3, 0xb4, 0x99, 0x81, 0x99,
+	0x90, 0x27, 0x70, 0xf9, 0x7d, 0x3a, 0x96, 0x07, 0xd5, 0x2f, 0xf5, 0xf9, 0xd6, 0xa6, 0x46, 0x17,
-	0xf5, 0xe4, 0xd3, 0xe5, 0x3b, 0x85, 0xfa, 0xbf, 0x50, 0xb5, 0xb3, 0x19, 0x86, 0x5b, 0x69, 0x2a,
+	0x6c, 0xb5, 0x8f, 0x91, 0x93, 0x71, 0x92, 0xba, 0xdc, 0x21, 0x3b, 0x32, 0x7e, 0x57, 0x43, 0x15,
-	0x68, 0xf6, 0xb9, 0xe6, 0xf6, 0xeb, 0x32, 0x52, 0x07, 0x5e, 0x38, 0x56, 0xf7, 0xda, 0x55, 0xdd,
+	0x8b, 0x09, 0x0d, 0xc6, 0x69, 0xc7, 0x83, 0x58, 0xe8, 0xc9, 0x27, 0xcb, 0xb7, 0x0a, 0xf5, 0x7f,
-	0x50, 0x93, 0xf1, 0xc7, 0x68, 0x25, 0xe6, 0x42, 0x4e, 0xfd, 0xb7, 0x91, 0x1b, 0x2c, 0x00, 0x30,
+	0xa1, 0xb4, 0x67, 0x9f, 0x21, 0x6e, 0xa5, 0xef, 0x45, 0xb3, 0xcf, 0x34, 0xb7, 0x5f, 0xf5, 0x6c,
-	0x35, 0x21, 0x05, 0xd7, 0x0f, 0xd1, 0xb9, 0x45, 0x35, 0x28, 0xfa, 0xc5, 0xfd, 0x6e, 0x1f, 0xfa,
+	0x75, 0x76, 0x06, 0x63, 0x75, 0xf8, 0x5d, 0xd5, 0x32, 0x35, 0x19, 0x7f, 0x84, 0x56, 0xe2, 0x48,
-	0xc7, 0x55, 0x28, 0xf9, 0x97, 0x17, 0x37, 0xf7, 0x03, 0x21, 0xc7, 0x34, 0xec, 0xf6, 0xf1, 0x7b,
+	0xc8, 0x69, 0x90, 0x37, 0x72, 0x33, 0x0a, 0x00, 0xa6, 0x70, 0xa4, 0xe0, 0xfa, 0x01, 0x3a, 0xb3,
-	0xd0, 0x1a, 0x7a, 0x7b, 0x84, 0x40, 0x03, 0xd9, 0x04, 0xdc, 0xd5, 0x45, 0x9c, 0xda, 0x02, 0x83,
+	0xa8, 0x06, 0x9d, 0xa1, 0xf8, 0xb0, 0xdb, 0x87, 0x26, 0x73, 0x19, 0xfa, 0xc2, 0xc5, 0xc5, 0xc5,
-	0xfb, 0x84, 0x0f, 0x66, 0x0d, 0xe2, 0xe7, 0x65, 0xe4, 0x98, 0xea, 0x71, 0xb6, 0x0d, 0xe2, 0x4b,
+	0x87, 0x5c, 0xc8, 0x31, 0x0d, 0xba, 0x7d, 0xfc, 0x2e, 0xf4, 0x8f, 0xde, 0x1e, 0x21, 0xd0, 0x65,
-	0xb4, 0xee, 0x0b, 0x68, 0x6a, 0xe2, 0xc0, 0xd3, 0x4f, 0x33, 0x29, 0x5b, 0xcb, 0xf5, 0xa7, 0x06,
+	0x36, 0x01, 0x77, 0x79, 0x11, 0xa7, 0x96, 0x20, 0x2a, 0x3e, 0x89, 0x06, 0xb3, 0x2e, 0xf2, 0xd3,
-	0x92, 0xb5, 0x94, 0x60, 0x6a, 0xd7, 0x75, 0xb4, 0x16, 0xc4, 0x93, 0x5b, 0x07, 0x2c, 0xa2, 0x83,
+	0x32, 0x72, 0x4c, 0x89, 0x39, 0xdd, 0x2e, 0xf2, 0x05, 0x5a, 0xf7, 0x05, 0x74, 0x3e, 0xb1, 0xef,
-	0xd0, 0xf4, 0x0a, 0x9b, 0x38, 0x6a, 0xad, 0x93, 0x2e, 0xa9, 0x7a, 0x04, 0xc6, 0x67, 0x22, 0x32,
+	0xe9, 0xab, 0x99, 0x77, 0x5d, 0xcb, 0x0d, 0xba, 0x06, 0x92, 0xb5, 0x94, 0x60, 0x0a, 0xdc, 0x55,
-	0x5d, 0xc0, 0x26, 0xb3, 0x39, 0xfe, 0x02, 0x59, 0x41, 0x4c, 0x47, 0x26, 0x49, 0x73, 0x5f, 0xd0,
+	0xb4, 0xc6, 0xe3, 0xc9, 0x8d, 0x7d, 0x16, 0xd2, 0x41, 0x60, 0x1a, 0x8a, 0x4d, 0x1c, 0x65, 0xeb,
-	0xed, 0xbb, 0xbb, 0x0f, 0xe2, 0xf4, 0x05, 0xf6, 0x8b, 0x67, 0x9b, 0x96, 0x5a, 0x20, 0x9a, 0x56,
+	0xa4, 0x26, 0x55, 0xb4, 0xc0, 0xf9, 0x4c, 0x84, 0xa6, 0x55, 0xd8, 0x64, 0x36, 0xc7, 0x9f, 0x23,
-	0xff, 0xb3, 0x88, 0x9c, 0x56, 0x38, 0x4e, 0xa4, 0x49, 0xcf, 0x33, 0xb3, 0xcb, 0xb7, 0xe8, 0x02,
+	0x8b, 0xc7, 0x74, 0x64, 0x5e, 0x72, 0xee, 0x0d, 0xba, 0x7d, 0x77, 0xf7, 0x5e, 0x9c, 0xde, 0xc0,
-	0xd5, 0xbf, 0x0b, 0x34, 0x52, 0xb1, 0xae, 0xeb, 0x8b, 0xb1, 0xcd, 0x8d, 0x5c, 0xb9, 0x19, 0x38,
+	0x7e, 0xfe, 0x74, 0xd3, 0x52, 0x06, 0xa2, 0x69, 0xf5, 0x3f, 0x8b, 0xc8, 0x69, 0x05, 0xe3, 0x44,
-	0xad, 0x45, 0x46, 0xb3, 0x42, 0xff, 0xb7, 0x0e, 0x9d, 0x69, 0x9d, 0x0b, 0xef, 0x10, 0x0a, 0x55,
+	0x9a, 0x37, 0x7c, 0x6a, 0x7e, 0xf9, 0x16, 0x9d, 0xa3, 0xfa, 0x9f, 0x82, 0x86, 0xea, 0x41, 0xe8,
-	0x9a, 0x1c, 0xa6, 0xb9, 0xe6, 0xfe, 0x76, 0x3d, 0xc8, 0x02, 0x53, 0x7b, 0x1b, 0xdd, 0x45, 0x0d,
+	0x22, 0x64, 0x7c, 0x73, 0x2d, 0x57, 0x6e, 0x06, 0x4e, 0x0b, 0x96, 0xd1, 0xac, 0xd0, 0xff, 0xd9,
-	0x68, 0x94, 0x96, 0xa0, 0x8f, 0xa7, 0x95, 0x32, 0x37, 0x7a, 0x09, 0xec, 0x2f, 0x48, 0x68, 0x06,
+	0xa1, 0x7d, 0xad, 0x47, 0xc2, 0x3b, 0x80, 0x6a, 0x96, 0xbe, 0x20, 0xd3, 0x81, 0x73, 0xff, 0xcd,
-	0xfe, 0x1a, 0x21, 0x3f, 0x48, 0x62, 0x2a, 0x41, 0x4e, 0x18, 0x2f, 0xe4, 0x3e, 0xb0, 0x3d, 0x43,
+	0xee, 0x65, 0x81, 0xa9, 0xbf, 0x8d, 0xee, 0xa2, 0x06, 0x74, 0x53, 0x4b, 0xd0, 0x47, 0xd3, 0x72,
-	0x2d, 0xa8, 0x64, 0xd8, 0xf8, 0x3e, 0x74, 0x0f, 0x3a, 0x8d, 0xa3, 0xd2, 0xe9, 0x75, 0xa1, 0xe5,
+	0x9a, 0x9b, 0xbd, 0x04, 0xd6, 0x17, 0x24, 0x34, 0x03, 0x7f, 0x8d, 0x90, 0xcf, 0x93, 0x98, 0x4a,
-	0x1a, 0x89, 0x8a, 0x92, 0x00, 0x8f, 0xda, 0xd3, 0x15, 0x62, 0x7b, 0xd4, 0xec, 0x5d, 0x3b, 0x79,
+	0x90, 0x13, 0x26, 0x0a, 0xb9, 0x17, 0x6c, 0xcf, 0x50, 0x0b, 0x2a, 0x19, 0x36, 0xbe, 0x0b, 0x2d,
-	0xbe, 0xb1, 0xf4, 0x17, 0x7c, 0xff, 0x3c, 0xdf, 0x28, 0x7c, 0xff, 0x62, 0xa3, 0x70, 0x02, 0xdf,
+	0x86, 0x4e, 0xf3, 0xa8, 0x74, 0x72, 0xf1, 0x68, 0xb9, 0x46, 0xa2, 0xa2, 0x24, 0x20, 0xa2, 0xf6,
-	0x1f, 0xf0, 0xfd, 0x0d, 0xdf, 0xa0, 0xa4, 0x7f, 0xa4, 0x3f, 0xfa, 0x2f, 0x00, 0x00, 0xff, 0xff,
+	0xd4, 0x42, 0x6c, 0x8f, 0x9a, 0xb5, 0x2b, 0xc7, 0xcf, 0x36, 0x96, 0xfe, 0x82, 0xef, 0x9f, 0x67,
-	0x4e, 0xfb, 0xdd, 0xf6, 0xa7, 0x0b, 0x00, 0x00,
+	0x1b, 0x85, 0xef, 0x9f, 0x6f, 0x14, 0x8e, 0xe1, 0xfb, 0x03, 0xbe, 0xbf, 0xe1, 0x1b, 0x94, 0xf4,
+	0xdf, 0xf6, 0x87, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x6e, 0x60, 0xc5, 0xcc, 0x0b, 0x00,
+	0x00,
 }

vendor/src/github.com/docker/swarmkit/api/specs.proto

@@ -127,6 +127,11 @@ message ContainerSpec {
 	// that don't change or verifiable digests.
 	string image = 1;
 
+	// RegistryAuth is the registry auth token obtained from the client, required
+	// to pull private images
+	// TODO(nishanttotla): This field will later be deprecated
+	string registry_auth = 64;
+
 	// Labels defines labels to be added to the container at creation time. If
 	// collisions with system labels occur, these labels will be overridden.
 	//

vendor/src/github.com/docker/swarmkit/api/types.pb.go

@@ -44,7 +44,6 @@
 		OrchestrationConfig
 		DispatcherConfig
 		RaftConfig
-		RaftMember
 		Placement
 		RootCA
 		Certificate
@@ -99,7 +98,6 @@
 		RemoveNetworkResponse
 		ListNetworksRequest
 		ListNetworksResponse
-		RemoveManagerResponse
 		GetClusterRequest
 		GetClusterResponse
 		ListClustersRequest
@@ -123,6 +121,7 @@
 		StoreSnapshot
 		ClusterSnapshot
 		Snapshot
+		RaftMember
 		JoinRequest
 		JoinResponse
 		LeaveRequest
@@ -481,7 +480,7 @@ func (x EncryptionKey_Algorithm) String() string {
 	return proto.EnumName(EncryptionKey_Algorithm_name, int32(x))
 }
 func (EncryptionKey_Algorithm) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptorTypes, []int{32, 0}
+	return fileDescriptorTypes, []int{31, 0}
 }
 
 // Version tracks the last time an object in the store was updated.
@@ -1009,20 +1008,6 @@ func (m *RaftConfig) Reset()                    { *m = RaftConfig{} }
 func (*RaftConfig) ProtoMessage()               {}
 func (*RaftConfig) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{27} }
 
-type RaftMember struct {
-	// RaftID specifies the internal ID used by the manager in a raft context, it can never be modified
-	// and is used only for information purposes
-	RaftID uint64 `protobuf:"varint,1,opt,name=raft_id,json=raftId,proto3" json:"raft_id,omitempty"`
-	// Addr specifies the address of the member
-	Addr string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
-	// Status provides the current status of the manager from the perspective of another manager.
-	Status RaftMemberStatus `protobuf:"bytes,3,opt,name=status" json:"status"`
-}
-
-func (m *RaftMember) Reset()                    { *m = RaftMember{} }
-func (*RaftMember) ProtoMessage()               {}
-func (*RaftMember) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{28} }
-
 // Placement specifies task distribution constraints.
 type Placement struct {
 	// constraints specifies a set of requirements a node should meet for a task.
@@ -1031,7 +1016,7 @@ type Placement struct {
 
 func (m *Placement) Reset()                    { *m = Placement{} }
 func (*Placement) ProtoMessage()               {}
-func (*Placement) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{29} }
+func (*Placement) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{28} }
 
 type RootCA struct {
 	// CAKey is the root CA private key.
@@ -1044,7 +1029,7 @@ type RootCA struct {
 
 func (m *RootCA) Reset()                    { *m = RootCA{} }
 func (*RootCA) ProtoMessage()               {}
-func (*RootCA) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{30} }
+func (*RootCA) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{29} }
 
 type Certificate struct {
 	Role        NodeRole       `protobuf:"varint,1,opt,name=role,proto3,enum=docker.swarmkit.v1.NodeRole" json:"role,omitempty"`
@@ -1057,7 +1042,7 @@ type Certificate struct {
 
 func (m *Certificate) Reset()                    { *m = Certificate{} }
 func (*Certificate) ProtoMessage()               {}
-func (*Certificate) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{31} }
+func (*Certificate) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{30} }
 
 // Symmetric keys to encrypt inter-agent communication.
 type EncryptionKey struct {
@@ -1073,16 +1058,24 @@ type EncryptionKey struct {
 
 func (m *EncryptionKey) Reset()                    { *m = EncryptionKey{} }
 func (*EncryptionKey) ProtoMessage()               {}
-func (*EncryptionKey) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{32} }
+func (*EncryptionKey) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{31} }
 
-// ManagerStatus provides information about the status of a manager in the cluster.
+// ManagerStatus provides informations about the state of a manager in the cluster.
 type ManagerStatus struct {
-	Raft RaftMember `protobuf:"bytes,1,opt,name=raft" json:"raft"`
+	// RaftID specifies the internal ID used by the manager in a raft context, it can never be modified
+	// and is used only for information purposes
+	RaftID uint64 `protobuf:"varint,1,opt,name=raft_id,json=raftId,proto3" json:"raft_id,omitempty"`
+	// Addr is the address advertised to raft.
+	Addr string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
+	// Leader is set to true if this node is the raft leader.
+	Leader bool `protobuf:"varint,3,opt,name=leader,proto3" json:"leader,omitempty"`
+	// Reachability specifies whether this node is reachable.
+	Reachability RaftMemberStatus_Reachability `protobuf:"varint,4,opt,name=reachability,proto3,enum=docker.swarmkit.v1.RaftMemberStatus_Reachability" json:"reachability,omitempty"`
 }
 
 func (m *ManagerStatus) Reset()                    { *m = ManagerStatus{} }
 func (*ManagerStatus) ProtoMessage()               {}
-func (*ManagerStatus) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{33} }
+func (*ManagerStatus) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{32} }
 
 func init() {
 	proto.RegisterType((*Version)(nil), "docker.swarmkit.v1.Version")
@@ -1117,7 +1110,6 @@ func init() {
 	proto.RegisterType((*OrchestrationConfig)(nil), "docker.swarmkit.v1.OrchestrationConfig")
 	proto.RegisterType((*DispatcherConfig)(nil), "docker.swarmkit.v1.DispatcherConfig")
 	proto.RegisterType((*RaftConfig)(nil), "docker.swarmkit.v1.RaftConfig")
-	proto.RegisterType((*RaftMember)(nil), "docker.swarmkit.v1.RaftMember")
 	proto.RegisterType((*Placement)(nil), "docker.swarmkit.v1.Placement")
 	proto.RegisterType((*RootCA)(nil), "docker.swarmkit.v1.RootCA")
 	proto.RegisterType((*Certificate)(nil), "docker.swarmkit.v1.Certificate")
@@ -1624,20 +1616,6 @@ func (m *RaftConfig) Copy() *RaftConfig {
 	return o
 }
 
-func (m *RaftMember) Copy() *RaftMember {
-	if m == nil {
-		return nil
-	}
-
-	o := &RaftMember{
-		RaftID: m.RaftID,
-		Addr:   m.Addr,
-		Status: *m.Status.Copy(),
-	}
-
-	return o
-}
-
 func (m *Placement) Copy() *Placement {
 	if m == nil {
 		return nil
@@ -1706,7 +1684,10 @@ func (m *ManagerStatus) Copy() *ManagerStatus {
 	}
 
 	o := &ManagerStatus{
-		Raft: *m.Raft.Copy(),
+		RaftID:       m.RaftID,
+		Addr:         m.Addr,
+		Leader:       m.Leader,
+		Reachability: m.Reachability,
 	}
 
 	return o
@@ -2187,18 +2168,6 @@ func (this *RaftConfig) GoString() string {
 	s = append(s, "}")
 	return strings.Join(s, "")
 }
-func (this *RaftMember) GoString() string {
-	if this == nil {
-		return "nil"
-	}
-	s := make([]string, 0, 7)
-	s = append(s, "&api.RaftMember{")
-	s = append(s, "RaftID: "+fmt.Sprintf("%#v", this.RaftID)+",\n")
-	s = append(s, "Addr: "+fmt.Sprintf("%#v", this.Addr)+",\n")
-	s = append(s, "Status: "+strings.Replace(this.Status.GoString(), `&`, ``, 1)+",\n")
-	s = append(s, "}")
-	return strings.Join(s, "")
-}
 func (this *Placement) GoString() string {
 	if this == nil {
 		return "nil"
@@ -2252,9 +2221,12 @@ func (this *ManagerStatus) GoString() string {
 	if this == nil {
 		return "nil"
 	}
-	s := make([]string, 0, 5)
+	s := make([]string, 0, 8)
 	s = append(s, "&api.ManagerStatus{")
-	s = append(s, "Raft: "+strings.Replace(this.Raft.GoString(), `&`, ``, 1)+",\n")
+	s = append(s, "RaftID: "+fmt.Sprintf("%#v", this.RaftID)+",\n")
+	s = append(s, "Addr: "+fmt.Sprintf("%#v", this.Addr)+",\n")
+	s = append(s, "Leader: "+fmt.Sprintf("%#v", this.Leader)+",\n")
+	s = append(s, "Reachability: "+fmt.Sprintf("%#v", this.Reachability)+",\n")
 	s = append(s, "}")
 	return strings.Join(s, "")
 }
@@ -3484,43 +3456,6 @@ func (m *RaftConfig) MarshalTo(data []byte) (int, error) {
 	return i, nil
 }
 
-func (m *RaftMember) Marshal() (data []byte, err error) {
-	size := m.Size()
-	data = make([]byte, size)
-	n, err := m.MarshalTo(data)
-	if err != nil {
-		return nil, err
-	}
-	return data[:n], nil
-}
-
-func (m *RaftMember) MarshalTo(data []byte) (int, error) {
-	var i int
-	_ = i
-	var l int
-	_ = l
-	if m.RaftID != 0 {
-		data[i] = 0x8
-		i++
-		i = encodeVarintTypes(data, i, uint64(m.RaftID))
-	}
-	if len(m.Addr) > 0 {
-		data[i] = 0x12
-		i++
-		i = encodeVarintTypes(data, i, uint64(len(m.Addr)))
-		i += copy(data[i:], m.Addr)
-	}
-	data[i] = 0x1a
-	i++
-	i = encodeVarintTypes(data, i, uint64(m.Status.Size()))
-	n19, err := m.Status.MarshalTo(data[i:])
-	if err != nil {
-		return 0, err
-	}
-	i += n19
-	return i, nil
-}
-
 func (m *Placement) Marshal() (data []byte, err error) {
 	size := m.Size()
 	data = make([]byte, size)
@@ -3619,11 +3554,11 @@ func (m *Certificate) MarshalTo(data []byte) (int, error) {
 	data[i] = 0x1a
 	i++
 	i = encodeVarintTypes(data, i, uint64(m.Status.Size()))
-	n20, err := m.Status.MarshalTo(data[i:])
+	n19, err := m.Status.MarshalTo(data[i:])
 	if err != nil {
 		return 0, err
 	}
-	i += n20
+	i += n19
 	if len(m.Certificate) > 0 {
 		data[i] = 0x22
 		i++
@@ -3694,14 +3629,32 @@ func (m *ManagerStatus) MarshalTo(data []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	data[i] = 0xa
+	if m.RaftID != 0 {
-	i++
+		data[i] = 0x8
-	i = encodeVarintTypes(data, i, uint64(m.Raft.Size()))
+		i++
-	n21, err := m.Raft.MarshalTo(data[i:])
+		i = encodeVarintTypes(data, i, uint64(m.RaftID))
-	if err != nil {
+	}
-		return 0, err
+	if len(m.Addr) > 0 {
+		data[i] = 0x12
+		i++
+		i = encodeVarintTypes(data, i, uint64(len(m.Addr)))
+		i += copy(data[i:], m.Addr)
+	}
+	if m.Leader {
+		data[i] = 0x18
+		i++
+		if m.Leader {
+			data[i] = 1
+		} else {
+			data[i] = 0
+		}
+		i++
+	}
+	if m.Reachability != 0 {
+		data[i] = 0x20
+		i++
+		i = encodeVarintTypes(data, i, uint64(m.Reachability))
 	}
-	i += n21
 	return i, nil
 }
 
@@ -4250,21 +4203,6 @@ func (m *RaftConfig) Size() (n int) {
 	return n
 }
 
-func (m *RaftMember) Size() (n int) {
-	var l int
-	_ = l
-	if m.RaftID != 0 {
-		n += 1 + sovTypes(uint64(m.RaftID))
-	}
-	l = len(m.Addr)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	l = m.Status.Size()
-	n += 1 + l + sovTypes(uint64(l))
-	return n
-}
-
 func (m *Placement) Size() (n int) {
 	var l int
 	_ = l
@@ -4341,8 +4279,19 @@ func (m *EncryptionKey) Size() (n int) {
 func (m *ManagerStatus) Size() (n int) {
 	var l int
 	_ = l
-	l = m.Raft.Size()
+	if m.RaftID != 0 {
-	n += 1 + l + sovTypes(uint64(l))
+		n += 1 + sovTypes(uint64(m.RaftID))
+	}
+	l = len(m.Addr)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.Leader {
+		n += 2
+	}
+	if m.Reachability != 0 {
+		n += 1 + sovTypes(uint64(m.Reachability))
+	}
 	return n
 }
 
@@ -4788,18 +4737,6 @@ func (this *RaftConfig) String() string {
 	}, "")
 	return s
 }
-func (this *RaftMember) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&RaftMember{`,
-		`RaftID:` + fmt.Sprintf("%v", this.RaftID) + `,`,
-		`Addr:` + fmt.Sprintf("%v", this.Addr) + `,`,
-		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "RaftMemberStatus", "RaftMemberStatus", 1), `&`, ``, 1) + `,`,
-		`}`,
-	}, "")
-	return s
-}
 func (this *Placement) String() string {
 	if this == nil {
 		return "nil"
@@ -4854,7 +4791,10 @@ func (this *ManagerStatus) String() string {
 		return "nil"
 	}
 	s := strings.Join([]string{`&ManagerStatus{`,
-		`Raft:` + strings.Replace(strings.Replace(this.Raft.String(), "RaftMember", "RaftMember", 1), `&`, ``, 1) + `,`,
+		`RaftID:` + fmt.Sprintf("%v", this.RaftID) + `,`,
+		`Addr:` + fmt.Sprintf("%v", this.Addr) + `,`,
+		`Leader:` + fmt.Sprintf("%v", this.Leader) + `,`,
+		`Reachability:` + fmt.Sprintf("%v", this.Reachability) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -8992,134 +8932,6 @@ func (m *RaftConfig) Unmarshal(data []byte) error {
 	}
 	return nil
 }
-func (m *RaftMember) Unmarshal(data []byte) error {
-	l := len(data)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := data[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: RaftMember: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RaftMember: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RaftID", wireType)
-			}
-			m.RaftID = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := data[iNdEx]
-				iNdEx++
-				m.RaftID |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := data[iNdEx]
-				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Addr = string(data[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := data[iNdEx]
-				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(data[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *Placement) Unmarshal(data []byte) error {
 	l := len(data)
 	iNdEx := 0
@@ -9708,10 +9520,10 @@ func (m *ManagerStatus) Unmarshal(data []byte) error {
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
+			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Raft", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RaftID", wireType)
 			}
-			var msglen int
+			m.RaftID = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -9721,22 +9533,79 @@ func (m *ManagerStatus) Unmarshal(data []byte) error {
 				}
 				b := data[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				m.RaftID |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthTypes
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.Raft.Unmarshal(data[iNdEx:postIndex]); err != nil {
+			m.Addr = string(data[iNdEx:postIndex])
-				return err
-			}
 			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Leader = bool(v != 0)
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Reachability", wireType)
+			}
+			m.Reachability = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				m.Reachability |= (RaftMemberStatus_Reachability(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTypes(data[iNdEx:])
@@ -9864,189 +9733,188 @@ var (
 )
 
 var fileDescriptorTypes = []byte{
-	// 2940 bytes of a gzipped FileDescriptorProto
+	// 2920 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x58, 0xcb, 0x73, 0x1b, 0xc7,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x58, 0x4d, 0x6c, 0x1b, 0xc7,
-	0xd1, 0x27, 0x9e, 0x04, 0x06, 0x20, 0x09, 0xad, 0x64, 0x99, 0x82, 0xf9, 0x51, 0xfa, 0xd6, 0x52,
+	0x15, 0x16, 0x7f, 0x45, 0x0e, 0x29, 0x89, 0x5e, 0x3b, 0x8e, 0xcc, 0xa8, 0xb2, 0xbb, 0x89, 0x1b,
-	0x2c, 0x3f, 0x02, 0x5b, 0xb4, 0x93, 0x52, 0xec, 0x72, 0xec, 0xc5, 0x83, 0x22, 0x22, 0x12, 0x44,
+	0xe7, 0xa7, 0x4c, 0xac, 0xa4, 0x85, 0x9b, 0x20, 0x4d, 0x96, 0x3f, 0xb2, 0x58, 0x4b, 0x14, 0x31,
-	0x0d, 0x48, 0xaa, 0x7c, 0x48, 0x50, 0xcb, 0xc5, 0x90, 0x58, 0x73, 0xb1, 0x8b, 0xec, 0x2e, 0x48,
+	0x94, 0x64, 0xe4, 0xd0, 0x12, 0xab, 0xe5, 0x48, 0xdc, 0x68, 0xb9, 0xcb, 0xee, 0x2e, 0x25, 0x13,
-	0xa1, 0x52, 0xa9, 0x92, 0x73, 0x49, 0xe2, 0x53, 0xee, 0x29, 0x57, 0x2a, 0x95, 0x5c, 0xf3, 0x0f,
+	0x45, 0x01, 0xa7, 0x97, 0x16, 0x39, 0xf5, 0x5e, 0x04, 0x45, 0xd1, 0x5e, 0x7b, 0x2e, 0xd0, 0x93,
-	0xe4, 0xa4, 0xa3, 0x8e, 0x49, 0xa5, 0x2a, 0xe5, 0x93, 0x2b, 0x76, 0x0e, 0xb9, 0xa6, 0x2a, 0xa9,
+	0x8f, 0x3e, 0xb6, 0x28, 0x50, 0xe4, 0x14, 0x34, 0xe9, 0xa1, 0xd7, 0x02, 0x2d, 0x9a, 0x43, 0x7b,
-	0xf8, 0x90, 0x1c, 0xd2, 0x3d, 0x8f, 0xc5, 0x43, 0x2b, 0x5a, 0x8a, 0x0f, 0x28, 0xec, 0xf4, 0xfc,
+	0xe8, 0x7b, 0xf3, 0xb3, 0xfc, 0xf1, 0x5a, 0xb1, 0x9b, 0x1e, 0x08, 0xee, 0xbc, 0xf9, 0xde, 0x9b,
-	0xba, 0xa7, 0xbb, 0xa7, 0xa7, 0xbb, 0x67, 0x48, 0x21, 0x1c, 0x0f, 0x59, 0x50, 0x19, 0xfa, 0x5e,
+	0x79, 0x6f, 0xde, 0xdf, 0x0c, 0x29, 0x84, 0xe3, 0x21, 0x0b, 0x2a, 0x43, 0xdf, 0x0b, 0x3d, 0x4d,
-	0xe8, 0x69, 0x5a, 0xcf, 0xb3, 0x4e, 0x98, 0x5f, 0x09, 0xce, 0x4c, 0x7f, 0x70, 0x62, 0x87, 0x95,
+	0xeb, 0x79, 0xd6, 0x09, 0xf3, 0x2b, 0xc1, 0x99, 0xe9, 0x0f, 0x4e, 0xec, 0xb0, 0x72, 0x7a, 0xb3,
-	0xd3, 0x5b, 0xe5, 0x2b, 0xa1, 0x3d, 0x60, 0x41, 0x68, 0x0e, 0x86, 0xaf, 0x47, 0x5f, 0x02, 0x5e,
+	0x7c, 0x25, 0xb4, 0x07, 0x2c, 0x08, 0xcd, 0xc1, 0xf0, 0xb5, 0xe8, 0x4b, 0xc0, 0xcb, 0xcf, 0xf6,
-	0x7e, 0xbe, 0x37, 0xf2, 0xcd, 0xd0, 0xf6, 0xdc, 0xd7, 0xd5, 0x87, 0x9c, 0xb8, 0x74, 0xec, 0x1d,
+	0x46, 0xbe, 0x19, 0xda, 0x9e, 0xfb, 0x9a, 0xfa, 0x90, 0x13, 0x97, 0x8e, 0xbd, 0x63, 0x8f, 0x7f,
-	0x7b, 0xfc, 0xf3, 0x75, 0xfc, 0x12, 0x54, 0xfd, 0x2a, 0x59, 0x3c, 0x60, 0x7e, 0x00, 0x30, 0xed,
+	0xbe, 0x86, 0x5f, 0x82, 0xaa, 0x5f, 0x25, 0x8b, 0x07, 0xcc, 0x0f, 0x00, 0xa6, 0x5d, 0x22, 0x19,
-	0x12, 0xc9, 0xd8, 0x6e, 0x8f, 0xdd, 0x5f, 0x4d, 0x5c, 0x4b, 0xdc, 0x4c, 0x53, 0x31, 0xd0, 0x7f,
+	0xdb, 0xed, 0xb1, 0x7b, 0xab, 0x89, 0x6b, 0x89, 0x1b, 0x69, 0x2a, 0x06, 0xfa, 0xaf, 0x12, 0xa4,
-	0x9d, 0x20, 0x05, 0xc3, 0x75, 0xbd, 0x90, 0xcb, 0x0a, 0x34, 0x8d, 0xa4, 0x5d, 0x73, 0xc0, 0x38,
+	0x60, 0xb8, 0xae, 0x17, 0x72, 0x59, 0x81, 0xa6, 0x91, 0xb4, 0x6b, 0x0e, 0x18, 0x07, 0xe5, 0x29,
-	0x28, 0x4f, 0xf9, 0xb7, 0x56, 0x23, 0x59, 0xc7, 0x3c, 0x64, 0x4e, 0xb0, 0x9a, 0xbc, 0x96, 0xba,
+	0xff, 0xd6, 0x6a, 0x24, 0xeb, 0x98, 0x87, 0xcc, 0x09, 0x56, 0x93, 0xd7, 0x52, 0x37, 0x0a, 0x1b,
-	0x59, 0xd8, 0x78, 0xb5, 0xf2, 0xb8, 0xce, 0x95, 0x29, 0x21, 0x95, 0x6d, 0x8e, 0x6e, 0xb8, 0xa1,
+	0xaf, 0x54, 0x1e, 0xdd, 0x73, 0x65, 0x4a, 0x48, 0x65, 0x9b, 0xa3, 0x1b, 0x6e, 0xe8, 0x8f, 0xa9,
-	0x3f, 0xa6, 0x92, 0xb5, 0xfc, 0x1d, 0x52, 0x98, 0x22, 0x6b, 0x25, 0x92, 0x3a, 0x61, 0x63, 0xb9,
+	0x64, 0x2d, 0x7f, 0x87, 0x14, 0xa6, 0xc8, 0x5a, 0x89, 0xa4, 0x4e, 0xd8, 0x58, 0x2e, 0x83, 0x9f,
-	0x0c, 0x7e, 0xa2, 0x7e, 0xa7, 0xa6, 0x33, 0x62, 0xb0, 0x08, 0xd2, 0xc4, 0xe0, 0xed, 0xe4, 0xed,
+	0xb8, 0xbf, 0x53, 0xd3, 0x19, 0x31, 0x58, 0x04, 0x69, 0x62, 0xf0, 0x56, 0xf2, 0x56, 0x42, 0x7f,
-	0x84, 0xfe, 0x01, 0xc9, 0x53, 0x16, 0x78, 0x23, 0xdf, 0x62, 0x81, 0xf6, 0x32, 0xc9, 0xbb, 0xa6,
+	0x9f, 0xe4, 0x29, 0x0b, 0xbc, 0x91, 0x6f, 0xb1, 0x40, 0x7b, 0x89, 0xe4, 0x5d, 0xd3, 0xf5, 0xba,
-	0xeb, 0x75, 0xad, 0xe1, 0x28, 0xe0, 0xec, 0xa9, 0x6a, 0xf1, 0x8b, 0xcf, 0xae, 0xe6, 0x5a, 0x40,
+	0xd6, 0x70, 0x14, 0x70, 0xf6, 0x54, 0xb5, 0xf8, 0xf9, 0xa7, 0x57, 0x73, 0x2d, 0x20, 0xd6, 0xda,
-	0xac, 0xb5, 0xf7, 0x03, 0x9a, 0xc3, 0xe9, 0x1a, 0xcc, 0x6a, 0xff, 0x4f, 0x8a, 0x03, 0x36, 0xf0,
+	0xfb, 0x01, 0xcd, 0xe1, 0x74, 0x0d, 0x66, 0xb5, 0xaf, 0x93, 0xe2, 0x80, 0x0d, 0x3c, 0x7f, 0xdc,
-	0xfc, 0x71, 0xf7, 0x70, 0x1c, 0xb2, 0x80, 0x0b, 0x4e, 0xd1, 0x82, 0xa0, 0x55, 0x91, 0xa4, 0xff,
+	0x3d, 0x1c, 0x87, 0x2c, 0xe0, 0x82, 0x53, 0xb4, 0x20, 0x68, 0x55, 0x24, 0xe9, 0x3f, 0x4f, 0x90,
-	0x22, 0x41, 0x2e, 0x29, 0xd9, 0x94, 0xfd, 0x70, 0x64, 0xfb, 0x6c, 0xc0, 0xdc, 0x30, 0xd0, 0xbe,
+	0x4b, 0x4a, 0x36, 0x65, 0x3f, 0x1c, 0xd9, 0x3e, 0x1b, 0x30, 0x37, 0x0c, 0xb4, 0x6f, 0x81, 0xce,
-	0x05, 0x36, 0xdb, 0x03, 0x3b, 0x14, 0x6b, 0x14, 0x36, 0xfe, 0x2f, 0xce, 0xe6, 0x48, 0x2b, 0x2a,
+	0xf6, 0xc0, 0x0e, 0xc5, 0x1a, 0x85, 0x8d, 0xaf, 0xc5, 0xe9, 0x1c, 0xed, 0x8a, 0x4a, 0xb0, 0x66,
-	0xc1, 0x9a, 0x41, 0x8a, 0x3e, 0x0b, 0x98, 0x7f, 0x2a, 0x3c, 0xc1, 0x97, 0xfc, 0x4a, 0xe6, 0x19,
+	0x90, 0xa2, 0xcf, 0x02, 0xe6, 0x9f, 0x0a, 0x4b, 0xf0, 0x25, 0xbf, 0x94, 0x79, 0x86, 0x45, 0xdf,
-	0x16, 0x7d, 0x93, 0xe4, 0xda, 0x8e, 0x19, 0x1e, 0x79, 0xfe, 0x40, 0xd3, 0x49, 0xd1, 0xf4, 0xad,
+	0x24, 0xb9, 0xb6, 0x63, 0x86, 0x47, 0x9e, 0x3f, 0xd0, 0x74, 0x52, 0x34, 0x7d, 0xab, 0x6f, 0x87,
-	0xbe, 0x1d, 0x32, 0x2b, 0x1c, 0xf9, 0x6a, 0x57, 0x66, 0x68, 0xda, 0x65, 0x92, 0xf4, 0xc4, 0x42,
+	0xcc, 0x0a, 0x47, 0xbe, 0x3a, 0x95, 0x19, 0x9a, 0x76, 0x99, 0x24, 0x3d, 0xb1, 0x50, 0xbe, 0x9a,
-	0xf9, 0x6a, 0x16, 0x3c, 0x91, 0xdc, 0xed, 0x50, 0xa0, 0xe8, 0xef, 0x90, 0x0b, 0x6d, 0x67, 0x74,
+	0x05, 0x4b, 0x24, 0x77, 0x3b, 0x14, 0x28, 0xfa, 0xdb, 0xe4, 0x42, 0xdb, 0x19, 0x1d, 0xdb, 0x6e,
-	0x6c, 0xbb, 0x75, 0x16, 0x58, 0xbe, 0x3d, 0x44, 0xe9, 0xb8, 0xbd, 0x18, 0x7c, 0x6a, 0x7b, 0xf1,
+	0x9d, 0x05, 0x96, 0x6f, 0x0f, 0x51, 0x3a, 0x1e, 0x2f, 0x3a, 0x9f, 0x3a, 0x5e, 0xfc, 0x8e, 0x8e,
-	0x3b, 0xda, 0xf2, 0xe4, 0x64, 0xcb, 0xf5, 0x9f, 0x26, 0xc9, 0x85, 0x86, 0x0b, 0xcc, 0x6c, 0x9a,
+	0x3c, 0x39, 0x39, 0x72, 0xfd, 0xa7, 0x49, 0x72, 0xa1, 0xe1, 0x02, 0x33, 0x9b, 0xe6, 0xbe, 0x4e,
-	0xfb, 0x06, 0x59, 0x66, 0x9c, 0xd8, 0x3d, 0x15, 0x41, 0x25, 0xe5, 0x2c, 0x09, 0xaa, 0x8a, 0xb4,
+	0x96, 0x19, 0x27, 0x76, 0x4f, 0x85, 0x53, 0x49, 0x39, 0x4b, 0x82, 0xaa, 0x3c, 0xad, 0x39, 0xe7,
-	0xe6, 0x5c, 0xbc, 0xdc, 0x8a, 0x33, 0xff, 0x31, 0xe9, 0x71, 0x51, 0xa3, 0x35, 0xc8, 0xe2, 0x90,
+	0x2f, 0x37, 0xe3, 0xd4, 0x7f, 0x44, 0x7a, 0x9c, 0xd7, 0x68, 0x0d, 0xb2, 0x38, 0xe4, 0x4a, 0x04,
-	0x1b, 0x11, 0xac, 0xa6, 0xb8, 0xac, 0x1b, 0x71, 0xb2, 0x1e, 0xb3, 0xb3, 0x9a, 0x7e, 0xf4, 0xd9,
+	0xab, 0x29, 0x2e, 0xeb, 0x7a, 0x9c, 0xac, 0x47, 0xf4, 0xac, 0xa6, 0x1f, 0x7e, 0x7a, 0x75, 0x81,
-	0xd5, 0x05, 0xaa, 0x78, 0xbf, 0x4e, 0xf0, 0xfd, 0x35, 0x41, 0x56, 0x5a, 0x5e, 0x6f, 0xc6, 0x0f,
+	0x2a, 0xde, 0xaf, 0xe2, 0x7c, 0x7f, 0x4d, 0x90, 0x95, 0x96, 0xd7, 0x9b, 0xb1, 0x43, 0x99, 0xe4,
-	0x65, 0x92, 0xeb, 0x7b, 0x41, 0x38, 0x75, 0x50, 0xa2, 0xb1, 0x76, 0x9b, 0xe4, 0x86, 0x72, 0xfb,
+	0xfa, 0x5e, 0x10, 0x4e, 0x05, 0x4a, 0x34, 0xd6, 0x6e, 0x91, 0xdc, 0x50, 0x1e, 0x9f, 0x3c, 0xfd,
-	0xe4, 0xee, 0xaf, 0xc5, 0xab, 0x2c, 0x30, 0x34, 0x42, 0x6b, 0xef, 0x90, 0xbc, 0xaf, 0x62, 0x02,
+	0xb5, 0xf8, 0x2d, 0x0b, 0x0c, 0x8d, 0xd0, 0xda, 0xdb, 0x24, 0xef, 0x2b, 0x9f, 0x00, 0x6d, 0x9f,
-	0xac, 0x7d, 0x8a, 0xc0, 0x99, 0xe0, 0xb5, 0x77, 0x49, 0x56, 0x6c, 0xc2, 0x6a, 0x9a, 0x73, 0xde,
+	0xc0, 0x71, 0x26, 0x78, 0xed, 0x1d, 0x92, 0x15, 0x87, 0xb0, 0x9a, 0xe6, 0x9c, 0xd7, 0x9f, 0xc8,
-	0x78, 0x2a, 0x9f, 0x53, 0xc9, 0xa4, 0x7f, 0x9a, 0x20, 0x25, 0x6a, 0x1e, 0x85, 0x3b, 0x6c, 0x70,
+	0xe6, 0x54, 0x32, 0xe9, 0x9f, 0x24, 0x48, 0x89, 0x9a, 0x47, 0xe1, 0x0e, 0x1b, 0x1c, 0x32, 0xbf,
-	0xc8, 0xfc, 0x0e, 0x1c, 0x64, 0x38, 0x3f, 0x97, 0x61, 0x1f, 0x99, 0xd9, 0x63, 0x3e, 0x37, 0x32,
+	0x03, 0x81, 0x0c, 0xf1, 0x73, 0x19, 0xce, 0x91, 0x99, 0x3d, 0xe6, 0x73, 0x25, 0x73, 0x54, 0x8e,
-	0x47, 0xe5, 0x48, 0xdb, 0xc7, 0x20, 0x37, 0xad, 0xbe, 0x79, 0x68, 0x3b, 0x76, 0x38, 0xe6, 0x66,
+	0xb4, 0x7d, 0x74, 0x72, 0xd3, 0xea, 0x9b, 0x87, 0xb6, 0x63, 0x87, 0x63, 0xae, 0xe6, 0x72, 0xfc,
-	0x2e, 0xc7, 0xef, 0xf2, 0xbc, 0x4c, 0x50, 0x7e, 0xc2, 0x48, 0x67, 0xc4, 0x68, 0xab, 0x64, 0x11,
+	0x29, 0xcf, 0xcb, 0x84, 0xcd, 0x4f, 0x18, 0xe9, 0x8c, 0x18, 0x6d, 0x95, 0x2c, 0x42, 0xae, 0x0b,
-	0x72, 0x5d, 0x60, 0x1e, 0x33, 0x6e, 0x7d, 0x9e, 0xaa, 0x21, 0x84, 0x72, 0x71, 0x9a, 0x4f, 0x2b,
+	0xcc, 0x63, 0xc6, 0xb5, 0xcf, 0x53, 0x35, 0x04, 0x57, 0x2e, 0x4e, 0xf3, 0x69, 0x05, 0xb2, 0xb8,
-	0x90, 0xc5, 0xfd, 0xd6, 0xdd, 0xd6, 0xee, 0xbd, 0x56, 0x69, 0x41, 0x5b, 0x21, 0x85, 0xfd, 0x16,
+	0xdf, 0xba, 0xd3, 0xda, 0xbd, 0xdb, 0x2a, 0x2d, 0x68, 0x2b, 0xa4, 0xb0, 0xdf, 0xa2, 0x0d, 0xa3,
-	0x6d, 0x18, 0xb5, 0x2d, 0xa3, 0xba, 0xdd, 0x28, 0x25, 0xb4, 0x25, 0x48, 0x17, 0xd1, 0x30, 0xa9,
+	0xb6, 0x65, 0x54, 0xb7, 0x1b, 0xa5, 0x84, 0xb6, 0x04, 0xe9, 0x22, 0x1a, 0x26, 0xf5, 0x5f, 0x26,
-	0xff, 0x2a, 0x41, 0x08, 0x6e, 0xa0, 0x34, 0xea, 0x6d, 0x92, 0x81, 0x7c, 0x1a, 0x8a, 0x8d, 0x5b,
+	0x08, 0xc1, 0x03, 0x94, 0x4a, 0xbd, 0x45, 0x32, 0x90, 0x4f, 0x43, 0x71, 0x70, 0xcb, 0x1b, 0x2f,
-	0xde, 0xb8, 0x1e, 0xa7, 0xf5, 0x04, 0x5e, 0xc1, 0x3f, 0x46, 0x05, 0xcb, 0xb4, 0x86, 0xc9, 0x79,
+	0xc4, 0xed, 0x7a, 0x02, 0xaf, 0xe0, 0x1f, 0xa3, 0x82, 0x65, 0x7a, 0x87, 0xc9, 0xf9, 0x1d, 0x66,
-	0x0d, 0x33, 0x1c, 0x39, 0xab, 0x5a, 0x8e, 0xa4, 0xeb, 0xf8, 0x95, 0xd0, 0xf2, 0x24, 0x03, 0x3a,
+	0x38, 0x72, 0x76, 0x6b, 0x39, 0x92, 0xae, 0xe3, 0x57, 0x42, 0xcb, 0x93, 0x0c, 0xec, 0xa9, 0xfe,
-	0xd5, 0x3f, 0x28, 0x25, 0x21, 0xf8, 0x8a, 0xf5, 0x66, 0xa7, 0xb6, 0xdb, 0x6a, 0x35, 0x6a, 0x7b,
+	0x7e, 0x29, 0x09, 0xce, 0x57, 0xac, 0x37, 0x3b, 0xb5, 0xdd, 0x56, 0xab, 0x51, 0xdb, 0x6b, 0xd4,
-	0x8d, 0x7a, 0x29, 0xa5, 0xdf, 0x20, 0x99, 0xe6, 0x00, 0xa4, 0x68, 0x6b, 0x18, 0x01, 0x47, 0xcc,
+	0x4b, 0x29, 0xfd, 0x3a, 0xc9, 0x34, 0x07, 0x20, 0x45, 0x5b, 0x43, 0x0f, 0x38, 0x62, 0x3e, 0x73,
-	0x67, 0xae, 0xa5, 0x02, 0x6b, 0x42, 0xd0, 0xff, 0xb5, 0x48, 0x32, 0x3b, 0xde, 0xc8, 0x0d, 0xb5,
+	0x2d, 0xe5, 0x58, 0x13, 0x82, 0xfe, 0xaf, 0x45, 0x92, 0xd9, 0xf1, 0x46, 0x6e, 0xa8, 0x6d, 0x4c,
-	0x8d, 0xa9, 0x53, 0xbc, 0xbc, 0xb1, 0x1e, 0x67, 0x02, 0x07, 0x56, 0xf6, 0x00, 0x25, 0x4f, 0x39,
+	0x45, 0xf1, 0xf2, 0xc6, 0x7a, 0x9c, 0x0a, 0x1c, 0x58, 0xd9, 0x03, 0x94, 0x8c, 0x72, 0x38, 0x4c,
-	0x6c, 0xa6, 0x88, 0x15, 0xa9, 0xba, 0x1c, 0x21, 0x3d, 0x34, 0xfd, 0x63, 0x16, 0x4a, 0xa7, 0xcb,
+	0xe1, 0x2b, 0x72, 0xeb, 0x72, 0x84, 0xf4, 0xd0, 0xf4, 0x8f, 0x59, 0x28, 0x8d, 0x2e, 0x47, 0xe8,
-	0x11, 0xc6, 0xf8, 0x99, 0x6f, 0x87, 0xe6, 0xa1, 0x23, 0x42, 0x2a, 0x47, 0xa3, 0xb1, 0xb6, 0x45,
+	0xe3, 0x67, 0xbe, 0x1d, 0x9a, 0x87, 0x8e, 0x70, 0xa9, 0x1c, 0x8d, 0xc6, 0xda, 0x16, 0x29, 0x1e,
-	0x8a, 0x87, 0x50, 0x3e, 0xba, 0xde, 0x50, 0x64, 0xb9, 0xcc, 0x93, 0x43, 0x4e, 0xe8, 0x51, 0x05,
+	0x42, 0xf9, 0xe8, 0x7a, 0x43, 0x91, 0xe5, 0x32, 0x8f, 0x77, 0x39, 0xb1, 0x8f, 0x2a, 0xa0, 0x77,
-	0xf4, 0xae, 0x00, 0xd3, 0xc2, 0xe1, 0x64, 0xa0, 0xb5, 0xc8, 0xf2, 0xa9, 0xe7, 0x8c, 0x06, 0x2c,
+	0x05, 0x98, 0x16, 0x0e, 0x27, 0x03, 0xad, 0x45, 0x96, 0x4f, 0x3d, 0x67, 0x34, 0x60, 0x91, 0xac,
-	0x92, 0x95, 0xe5, 0xb2, 0x5e, 0x7a, 0xb2, 0xac, 0x03, 0x8e, 0x57, 0xd2, 0x96, 0x4e, 0xa7, 0x87,
+	0x2c, 0x97, 0xf5, 0xe2, 0xe3, 0x65, 0x1d, 0x70, 0xbc, 0x92, 0xb6, 0x74, 0x3a, 0x3d, 0x2c, 0xff,
-	0xe5, 0x9f, 0xa4, 0x48, 0x61, 0x6a, 0x31, 0xad, 0x43, 0x0a, 0x50, 0x08, 0x87, 0xe6, 0x31, 0x4f,
+	0x24, 0x45, 0x0a, 0x53, 0x8b, 0x69, 0x1d, 0x52, 0x80, 0x42, 0x38, 0x34, 0x8f, 0x79, 0x72, 0x95,
-	0xae, 0xd2, 0x61, 0xb7, 0x9e, 0x4a, 0xd1, 0x4a, 0x7b, 0xc2, 0x48, 0xa7, 0xa5, 0xe8, 0x9f, 0x24,
+	0x06, 0xbb, 0xf9, 0x44, 0x1b, 0xad, 0xb4, 0x27, 0x8c, 0x74, 0x5a, 0x8a, 0xfe, 0x71, 0x92, 0x14,
-	0x49, 0x61, 0x6a, 0x52, 0x7b, 0x85, 0xe4, 0x68, 0x9b, 0x36, 0x0f, 0x8c, 0xbd, 0x46, 0x69, 0xa1,
+	0xa6, 0x26, 0xb5, 0x97, 0x49, 0x8e, 0xb6, 0x69, 0xf3, 0xc0, 0xd8, 0x6b, 0x94, 0x16, 0xca, 0x6b,
-	0xbc, 0xf6, 0xf1, 0x27, 0xd7, 0x56, 0xb9, 0xb4, 0x69, 0x01, 0x6d, 0xdf, 0x3e, 0xc5, 0xf8, 0xb8,
+	0x1f, 0x7d, 0x7c, 0x6d, 0x95, 0x4b, 0x9b, 0x16, 0xd0, 0xf6, 0xed, 0x53, 0xf4, 0x8f, 0x1b, 0x64,
-	0x49, 0x16, 0x15, 0x34, 0x51, 0x7e, 0x01, 0xa0, 0xcf, 0xcf, 0x43, 0xa7, 0x90, 0xb4, 0xb3, 0x65,
+	0x51, 0x41, 0x13, 0xe5, 0xe7, 0x00, 0xfa, 0xec, 0x3c, 0x74, 0x0a, 0x49, 0x3b, 0x5b, 0x06, 0x05,
-	0x50, 0x08, 0x91, 0x64, 0x3c, 0x92, 0x76, 0xfa, 0xa6, 0xcf, 0x7a, 0xda, 0x37, 0x48, 0x56, 0x02,
+	0x17, 0x49, 0xc6, 0x23, 0x69, 0xa7, 0x6f, 0xfa, 0xac, 0xa7, 0x7d, 0x83, 0x64, 0x25, 0x30, 0x55,
-	0x53, 0xe5, 0x32, 0x00, 0x2f, 0xcf, 0x03, 0x27, 0x38, 0xda, 0xd9, 0x36, 0x0e, 0x1a, 0xa5, 0x74,
+	0x2e, 0x03, 0xf0, 0xf2, 0x3c, 0x70, 0x82, 0xa3, 0x9d, 0x6d, 0xe3, 0xa0, 0x51, 0x4a, 0xc7, 0xe3,
-	0x3c, 0x8e, 0x76, 0x1c, 0xf3, 0x94, 0x69, 0xd7, 0x21, 0x98, 0x39, 0x2c, 0x53, 0xbe, 0x02, 0xb0,
+	0x68, 0xc7, 0x31, 0x4f, 0x99, 0xf6, 0x02, 0x38, 0x33, 0x87, 0x65, 0xca, 0x57, 0x00, 0xf6, 0xcc,
-	0xe7, 0x1e, 0x13, 0x87, 0xa8, 0xf2, 0xea, 0xcf, 0x7e, 0xb3, 0xbe, 0xf0, 0xfb, 0xdf, 0xae, 0x97,
+	0x23, 0xe2, 0x10, 0x55, 0x5e, 0xfd, 0xd9, 0xaf, 0xd7, 0x17, 0x7e, 0xff, 0x9b, 0xf5, 0xd2, 0xfc,
-	0xe6, 0xa7, 0xcb, 0xff, 0x4c, 0x90, 0xa5, 0x99, 0x5d, 0xc2, 0x60, 0x1a, 0x7a, 0xc3, 0x91, 0xa3,
+	0x74, 0xf9, 0x9f, 0x09, 0xb2, 0x34, 0x73, 0x4a, 0xe8, 0x4c, 0x43, 0x6f, 0x38, 0x72, 0x54, 0xdc,
-	0xce, 0x1d, 0x04, 0x93, 0x1a, 0x6b, 0x77, 0xe7, 0xaa, 0xc5, 0x9b, 0x4f, 0xb9, 0xf5, 0xb1, 0xf5,
+	0x81, 0x33, 0xa9, 0xb1, 0x76, 0x67, 0xae, 0x5a, 0xbc, 0xf1, 0x84, 0x47, 0x1f, 0x5b, 0x2f, 0xde,
-	0xe2, 0x3d, 0xb2, 0xd4, 0x03, 0xff, 0x31, 0xbf, 0x6b, 0x79, 0xee, 0x91, 0x7d, 0x2c, 0xf3, 0x68,
+	0x25, 0x4b, 0x3d, 0xb0, 0x1f, 0xf3, 0xbb, 0x96, 0xe7, 0x1e, 0xd9, 0xc7, 0x32, 0x8f, 0x96, 0xe3,
-	0x39, 0x4e, 0x66, 0x9d, 0x03, 0x69, 0x51, 0x30, 0xd4, 0x38, 0xfe, 0xeb, 0x54, 0x8a, 0x7b, 0x24,
+	0x64, 0xd6, 0x39, 0x90, 0x16, 0x05, 0x43, 0x8d, 0xe3, 0xbf, 0x4a, 0xa5, 0xb8, 0x4b, 0xd2, 0x18,
-	0x8d, 0xe7, 0x4d, 0x7b, 0x81, 0xa4, 0xab, 0xcd, 0x56, 0x1d, 0x42, 0xe1, 0x02, 0x78, 0x6f, 0x89,
+	0x6f, 0xda, 0x73, 0x24, 0x5d, 0x6d, 0xb6, 0xea, 0xe0, 0x0a, 0x17, 0xc0, 0x7a, 0x4b, 0x7c, 0xeb,
-	0xab, 0x8e, 0x13, 0x18, 0x5b, 0xda, 0x55, 0x92, 0x3d, 0xd8, 0xdd, 0xde, 0xdf, 0xc1, 0xed, 0xbf,
+	0x38, 0x81, 0xbe, 0xa5, 0x5d, 0x25, 0xd9, 0x83, 0xdd, 0xed, 0xfd, 0x1d, 0x3c, 0xfe, 0x8b, 0x30,
-	0x08, 0xd3, 0x2b, 0xd1, 0xb4, 0x30, 0xae, 0x7c, 0x41, 0xba, 0x35, 0x1f, 0x4d, 0xe8, 0xff, 0x4e,
+	0xbd, 0x12, 0x4d, 0x0b, 0xe5, 0xca, 0x17, 0xa4, 0x59, 0xf3, 0xd1, 0x84, 0xfe, 0xef, 0x24, 0x59,
-	0x92, 0x25, 0x8a, 0x5d, 0xa0, 0x1f, 0xb6, 0x3d, 0xc7, 0xb6, 0xc6, 0x5a, 0x9b, 0xe4, 0xc1, 0xbe,
+	0xa2, 0xd8, 0x05, 0xfa, 0x61, 0xdb, 0x73, 0x6c, 0x6b, 0xac, 0xb5, 0x49, 0x1e, 0xf4, 0xeb, 0xd9,
-	0x9e, 0x3d, 0x15, 0xd4, 0x1b, 0x4f, 0x28, 0x15, 0x13, 0x2e, 0x35, 0xaa, 0x29, 0x4e, 0x3a, 0x11,
+	0x53, 0x4e, 0xbd, 0xf1, 0x98, 0x52, 0x31, 0xe1, 0x52, 0xa3, 0x9a, 0xe2, 0xa4, 0x13, 0x21, 0x90,
-	0x02, 0x29, 0x25, 0xd3, 0x63, 0x8e, 0x39, 0x3e, 0xaf, 0x66, 0xd5, 0x65, 0xc7, 0x49, 0x05, 0x94,
+	0x52, 0x32, 0x3d, 0xe6, 0x98, 0xe3, 0xf3, 0x6a, 0x56, 0x5d, 0x76, 0x9c, 0x54, 0x40, 0x79, 0x7f,
-	0xf7, 0x57, 0xe6, 0xfd, 0xae, 0x19, 0x86, 0x6c, 0x30, 0x0c, 0x45, 0xcd, 0x4a, 0x43, 0x7f, 0x65,
+	0x65, 0xde, 0xeb, 0x9a, 0x61, 0xc8, 0x06, 0xc3, 0x50, 0xd4, 0xac, 0x34, 0xf4, 0x57, 0xe6, 0x3d,
-	0xde, 0x37, 0x24, 0x49, 0x7b, 0x8b, 0x64, 0xcf, 0xc0, 0x6c, 0xef, 0x4c, 0x96, 0xa5, 0xf3, 0xe5,
+	0x43, 0x92, 0xb4, 0x37, 0x49, 0xf6, 0x0c, 0xd4, 0xf6, 0xce, 0x64, 0x59, 0x3a, 0x5f, 0xae, 0xc4,
-	0x4a, 0xac, 0xfe, 0x31, 0x56, 0xa3, 0x39, 0x65, 0xd1, 0xad, 0xad, 0xdd, 0x56, 0x43, 0xb9, 0x55,
+	0xea, 0x1f, 0x61, 0x35, 0x9a, 0xdb, 0x2c, 0x9a, 0xb5, 0xb5, 0xdb, 0x6a, 0x28, 0xb3, 0xca, 0xf9,
-	0xce, 0xef, 0xba, 0x2d, 0xcf, 0xc5, 0x90, 0x25, 0xbb, 0xad, 0xee, 0xa6, 0xd1, 0xdc, 0xde, 0xa7,
+	0x5d, 0xb7, 0xe5, 0xb9, 0xe8, 0xb2, 0x64, 0xb7, 0xd5, 0xdd, 0x34, 0x9a, 0xdb, 0xfb, 0x14, 0x4d,
-	0xe8, 0xda, 0x4b, 0x00, 0x29, 0x45, 0x90, 0x4d, 0xd3, 0x76, 0xb0, 0x55, 0xba, 0x42, 0x52, 0x46,
+	0x7b, 0x09, 0x20, 0xa5, 0x08, 0xb2, 0x69, 0xda, 0x0e, 0xb6, 0x4a, 0x57, 0x48, 0xca, 0x68, 0x41,
-	0x0b, 0x72, 0x70, 0xb9, 0x04, 0xd3, 0xc5, 0x68, 0xda, 0x70, 0xc7, 0x93, 0x68, 0x9e, 0x5f, 0x57,
+	0x0e, 0x2e, 0x97, 0x60, 0xba, 0x18, 0x4d, 0x1b, 0xee, 0x78, 0xe2, 0xcd, 0xf3, 0xeb, 0xea, 0x1f,
-	0xff, 0x90, 0x14, 0xf7, 0x87, 0x3d, 0x88, 0x54, 0x11, 0x21, 0xda, 0x35, 0x48, 0x29, 0xa6, 0x6f,
+	0x90, 0xe2, 0xfe, 0xb0, 0x07, 0x9e, 0x2a, 0x3c, 0x44, 0xbb, 0x06, 0x29, 0xc5, 0xf4, 0x4d, 0xc7,
-	0x3a, 0x0e, 0x73, 0xec, 0x60, 0x20, 0xbb, 0xe9, 0x69, 0x12, 0xb4, 0x00, 0x4f, 0xef, 0x4b, 0xd9,
+	0x61, 0x8e, 0x1d, 0x0c, 0x64, 0x37, 0x3d, 0x4d, 0x82, 0x16, 0xe0, 0xc9, 0x6d, 0x29, 0x3b, 0x15,
-	0xa9, 0x08, 0x06, 0xfd, 0xc7, 0x64, 0x05, 0x56, 0x09, 0x4d, 0x28, 0xc9, 0xaa, 0x08, 0x6f, 0x90,
+	0xc1, 0xa0, 0xff, 0x98, 0xac, 0xc0, 0x2a, 0xa1, 0x09, 0x25, 0x59, 0x15, 0xe1, 0x0d, 0x52, 0xb4,
-	0xa2, 0xa5, 0x48, 0x5d, 0xbb, 0x27, 0x42, 0xb1, 0xba, 0x02, 0x8d, 0x5e, 0x21, 0x82, 0x36, 0xeb,
+	0x14, 0xa9, 0x6b, 0xf7, 0x84, 0x2b, 0x56, 0x57, 0xa0, 0xd1, 0x2b, 0x44, 0xd0, 0x66, 0x9d, 0x16,
-	0xb4, 0x10, 0x81, 0x9a, 0x3d, 0xb4, 0x73, 0x08, 0x50, 0x5c, 0x3e, 0x53, 0x5d, 0x04, 0x68, 0xaa,
+	0x22, 0x50, 0xb3, 0x87, 0x7a, 0x0e, 0x01, 0x8a, 0xcb, 0x67, 0xaa, 0x8b, 0x00, 0x4d, 0xb5, 0x01,
-	0x0d, 0x10, 0xa4, 0x81, 0x17, 0xf3, 0xec, 0xbe, 0x1d, 0xc2, 0xf1, 0xe8, 0x89, 0x32, 0x9b, 0xa1,
+	0x82, 0x34, 0xb0, 0x62, 0x9e, 0xdd, 0xb3, 0x43, 0x08, 0x8f, 0x9e, 0x28, 0xb3, 0x19, 0x9a, 0x43,
-	0x39, 0x24, 0xd4, 0x60, 0xac, 0x7f, 0x94, 0x24, 0x64, 0xcf, 0x0c, 0x4e, 0xe4, 0xd2, 0xd0, 0x90,
+	0x42, 0x0d, 0xc6, 0xfa, 0x87, 0x49, 0x42, 0xf6, 0xcc, 0xe0, 0x44, 0x2e, 0x0d, 0x0d, 0x49, 0x74,
-	0x44, 0xd7, 0x8f, 0xf3, 0xda, 0xe0, 0x3d, 0x05, 0xa2, 0x13, 0xbc, 0xf6, 0xa6, 0xaa, 0xb3, 0xa2,
+	0xfd, 0x38, 0xaf, 0x0d, 0xde, 0x53, 0x20, 0x3a, 0xc1, 0x6b, 0x6f, 0xa8, 0x3a, 0x2b, 0xba, 0x83,
-	0x3b, 0x88, 0x67, 0x94, 0x6b, 0xc5, 0x15, 0xd8, 0xd9, 0x16, 0x00, 0x0f, 0x22, 0xf3, 0x7d, 0x1e,
+	0x78, 0x46, 0xb9, 0x56, 0x5c, 0x81, 0x9d, 0x6d, 0x01, 0x30, 0x10, 0x99, 0xef, 0x73, 0x2f, 0x82,
-	0x45, 0x70, 0x10, 0xe1, 0x13, 0x6e, 0x25, 0xf9, 0xc8, 0x66, 0x59, 0x81, 0x5e, 0x8c, 0x5b, 0x64,
+	0x40, 0x84, 0x4f, 0xb8, 0x95, 0xe4, 0x23, 0x9d, 0x65, 0x05, 0x7a, 0x3e, 0x6e, 0x91, 0x39, 0x83,
-	0xce, 0xa1, 0x5b, 0x0b, 0x74, 0xc2, 0x57, 0x2d, 0x91, 0x65, 0x1f, 0x8e, 0x19, 0x68, 0xdd, 0x0d,
+	0x6e, 0x2d, 0xd0, 0x09, 0x5f, 0xb5, 0x44, 0x96, 0x7d, 0x08, 0x33, 0xd8, 0x75, 0x37, 0xe0, 0xd3,
-	0xf8, 0xb4, 0xfe, 0x27, 0xf0, 0x41, 0xb3, 0x6d, 0xec, 0xc8, 0xdd, 0xae, 0x93, 0xec, 0x91, 0x39,
+	0xfa, 0x9f, 0xc0, 0x06, 0xcd, 0xb6, 0xb1, 0x23, 0x4f, 0xbb, 0x4e, 0xb2, 0x47, 0xe6, 0xc0, 0x76,
-	0xb0, 0x9d, 0xb1, 0x3c, 0x66, 0xaf, 0xc5, 0x2d, 0x31, 0xc1, 0x57, 0x8c, 0x5e, 0x0f, 0x9a, 0xb2,
+	0xc6, 0x32, 0xcc, 0x5e, 0x8d, 0x5b, 0x62, 0x82, 0xaf, 0x18, 0xbd, 0x1e, 0x34, 0x65, 0xc1, 0x26,
-	0x60, 0x93, 0xf3, 0x50, 0xc9, 0xcb, 0x8b, 0xef, 0xe8, 0xd0, 0x85, 0x22, 0xab, 0x8a, 0x2f, 0x1f,
+	0xe7, 0xa1, 0x92, 0x97, 0x17, 0xdf, 0xd1, 0xa1, 0x0b, 0x45, 0x56, 0x15, 0x5f, 0x3e, 0xc2, 0x64,
-	0x61, 0x32, 0xf1, 0x4d, 0x37, 0xb2, 0x56, 0x0c, 0xd0, 0x0b, 0x90, 0x49, 0xd9, 0x19, 0x44, 0x90,
+	0xe2, 0x9b, 0x6e, 0xa4, 0xad, 0x18, 0xa0, 0x15, 0x20, 0x93, 0xb2, 0x33, 0xf0, 0x20, 0xa1, 0xaf,
-	0xb0, 0x57, 0x0d, 0xa1, 0xf0, 0xe6, 0xc4, 0x5d, 0x81, 0xf5, 0xc0, 0x64, 0xcc, 0x96, 0x5f, 0xa5,
+	0x1a, 0x42, 0xe1, 0xcd, 0x89, 0xbb, 0x02, 0xeb, 0x81, 0xca, 0x98, 0x2d, 0xbf, 0x6c, 0x3f, 0x54,
-	0x0f, 0x95, 0x70, 0x91, 0x26, 0x23, 0xee, 0xf2, 0x3b, 0x3c, 0xa5, 0x4c, 0xa6, 0x9e, 0x29, 0xd3,
+	0xc2, 0x45, 0x9a, 0x8c, 0xb8, 0xcb, 0x6f, 0xf3, 0x94, 0x32, 0x99, 0x7a, 0xaa, 0x4c, 0xf7, 0x3a,
-	0xbd, 0x41, 0x96, 0x66, 0xec, 0x7c, 0xac, 0xeb, 0x69, 0xb6, 0x0f, 0xde, 0x2a, 0xa5, 0xe5, 0xd7,
+	0x59, 0x9a, 0xd1, 0xf3, 0x91, 0xae, 0xa7, 0xd9, 0x3e, 0x78, 0xb3, 0x94, 0x96, 0x5f, 0xdf, 0x2e,
-	0xb7, 0x4b, 0x59, 0xfd, 0x1f, 0xd0, 0x84, 0xb5, 0x3d, 0x7e, 0xac, 0xd0, 0xab, 0xf1, 0xb7, 0xcc,
+	0x65, 0xf5, 0x7f, 0x40, 0x13, 0xd6, 0xf6, 0x78, 0x58, 0xa1, 0x55, 0xe3, 0x6f, 0x99, 0x39, 0x7e,
-	0x1c, 0xbf, 0xb3, 0x5a, 0x9e, 0x23, 0x63, 0x26, 0xb6, 0x09, 0x98, 0x48, 0xc1, 0x02, 0xcd, 0xe1,
+	0x67, 0xb5, 0x3c, 0x47, 0xfa, 0x4c, 0x6c, 0x13, 0x30, 0x91, 0x82, 0x05, 0x9a, 0xc3, 0x69, 0xc4,
-	0x34, 0x62, 0x84, 0xf4, 0x5a, 0x10, 0xfd, 0x4b, 0x77, 0x08, 0x38, 0xee, 0xd6, 0x25, 0x4a, 0x04,
+	0x08, 0xe9, 0xb5, 0x20, 0xfa, 0x97, 0xee, 0x10, 0x70, 0xdc, 0xac, 0x4b, 0x94, 0x08, 0x12, 0x72,
-	0x09, 0x39, 0xf1, 0x0a, 0x33, 0x1c, 0x1d, 0xc2, 0x31, 0xed, 0xb3, 0x9e, 0xc0, 0xa4, 0x39, 0x66,
+	0xe2, 0x15, 0x66, 0x38, 0x3a, 0x84, 0x30, 0xed, 0xb3, 0x9e, 0xc0, 0xa4, 0x39, 0x66, 0x29, 0xa2,
-	0x29, 0xa2, 0x22, 0x4c, 0xaf, 0xc3, 0x25, 0x4c, 0xc9, 0x5c, 0x25, 0xa9, 0xbd, 0x5a, 0x1b, 0xf2,
+	0x22, 0x4c, 0xaf, 0xc3, 0x25, 0x4c, 0xc9, 0x5c, 0x25, 0xa9, 0xbd, 0x5a, 0x1b, 0xf2, 0xce, 0x0a,
-	0xce, 0x0a, 0x64, 0x8d, 0x82, 0x22, 0x03, 0x09, 0x67, 0xf6, 0xeb, 0x6d, 0x48, 0x37, 0x33, 0x33,
+	0x64, 0x8d, 0x82, 0x22, 0x03, 0x09, 0x67, 0xf6, 0xeb, 0x6d, 0x48, 0x37, 0x33, 0x33, 0x40, 0x2a,
-	0x40, 0x2a, 0xa7, 0x31, 0x9d, 0xe8, 0xbf, 0x4c, 0x90, 0xac, 0xa8, 0x32, 0xb1, 0x16, 0x1b, 0x64,
+	0xa7, 0x31, 0x9d, 0xe8, 0xbf, 0x48, 0x90, 0xac, 0xa8, 0x32, 0xb1, 0x1a, 0x1b, 0x64, 0x51, 0x75,
-	0x51, 0x75, 0x3d, 0xa2, 0xf4, 0xbd, 0xf4, 0xe4, 0x32, 0x55, 0x91, 0x55, 0x4f, 0xec, 0xa3, 0xe2,
+	0x3d, 0xa2, 0xf4, 0xbd, 0xf8, 0xf8, 0x32, 0x55, 0x91, 0x55, 0x4f, 0x9c, 0xa3, 0xe2, 0x2b, 0xbf,
-	0x2b, 0xbf, 0x4d, 0x8a, 0xd3, 0x13, 0xcf, 0xb4, 0x8b, 0x3f, 0x22, 0x05, 0x0c, 0x14, 0x55, 0xa3,
+	0x45, 0x8a, 0xd3, 0x13, 0x4f, 0x75, 0x8a, 0x3f, 0x22, 0x05, 0x74, 0x14, 0x55, 0xa3, 0x37, 0x48,
-	0x37, 0x48, 0x56, 0x54, 0x42, 0x79, 0xd4, 0xcf, 0xab, 0x99, 0x12, 0x09, 0x99, 0x6e, 0x51, 0xd4,
+	0x56, 0x54, 0x42, 0x19, 0xea, 0xe7, 0xd5, 0x4c, 0x89, 0x84, 0x4c, 0xb7, 0x28, 0xea, 0xac, 0xba,
-	0x59, 0x75, 0x3d, 0x5b, 0x3f, 0x3f, 0x1c, 0xa9, 0x82, 0xeb, 0xef, 0x91, 0x74, 0x9b, 0x81, 0x84,
+	0x9e, 0xad, 0x9f, 0xef, 0x8e, 0x54, 0xc1, 0xf5, 0x77, 0x49, 0xba, 0xcd, 0x40, 0xc2, 0xf3, 0x64,
-	0x17, 0xc9, 0xa2, 0x0b, 0xa9, 0x67, 0x92, 0xd9, 0x08, 0xa4, 0xab, 0x2c, 0x36, 0xe0, 0x90, 0xb1,
+	0xd1, 0x85, 0xd4, 0x33, 0xc9, 0x6c, 0x04, 0xd2, 0x55, 0x16, 0x1b, 0x70, 0xc8, 0x58, 0x59, 0x9c,
-	0xb2, 0x38, 0x05, 0xf9, 0x0c, 0x9c, 0x67, 0x42, 0xbc, 0xa9, 0x1b, 0x2a, 0x7e, 0xeb, 0x7b, 0xa4,
+	0x82, 0x7c, 0x06, 0xc6, 0x33, 0xc1, 0xdf, 0xd4, 0x0d, 0x15, 0xbf, 0xf5, 0x3d, 0x52, 0xbc, 0xcb,
-	0x78, 0x8f, 0xd9, 0xc7, 0xfd, 0x10, 0x76, 0x0c, 0x05, 0xbd, 0x46, 0xd2, 0x43, 0x16, 0x29, 0xbf,
+	0xec, 0xe3, 0x7e, 0x08, 0x27, 0x86, 0x82, 0x5e, 0x25, 0xe9, 0x21, 0x8b, 0x36, 0xbf, 0x1a, 0xeb,
-	0x1a, 0x1b, 0x3a, 0x30, 0x4f, 0x39, 0x0a, 0x0f, 0xe4, 0x19, 0xe7, 0x96, 0x8f, 0x02, 0x72, 0xa4,
+	0x3a, 0x30, 0x4f, 0x39, 0x0a, 0x03, 0xf2, 0x8c, 0x73, 0xcb, 0x47, 0x01, 0x39, 0xd2, 0x7f, 0x9b,
-	0xff, 0x2e, 0x49, 0x96, 0x9b, 0x41, 0x30, 0x32, 0xa1, 0xe1, 0x96, 0x59, 0xf0, 0xbb, 0xb3, 0x17,
+	0x24, 0xcb, 0xcd, 0x20, 0x18, 0x99, 0xd0, 0x70, 0xcb, 0x2c, 0xf8, 0xdd, 0xd9, 0x0b, 0xc3, 0x8d,
-	0x86, 0x9b, 0xb1, 0x16, 0xce, 0xb0, 0xcc, 0x5e, 0x1a, 0x64, 0xe6, 0x4a, 0x46, 0x99, 0x4b, 0x7f,
+	0x58, 0x0d, 0x67, 0x58, 0x66, 0x2f, 0x0d, 0x32, 0x73, 0x25, 0xa3, 0xcc, 0xa5, 0x3f, 0x4c, 0xa8,
-	0x94, 0x50, 0xb7, 0x85, 0x1b, 0x53, 0xe7, 0xa6, 0xbc, 0x0a, 0x41, 0x74, 0x69, 0x5a, 0x12, 0xdb,
+	0xdb, 0xc2, 0xf5, 0xa9, 0xb8, 0x29, 0xaf, 0x82, 0x13, 0x5d, 0x9a, 0x96, 0xc4, 0xf6, 0xdd, 0x13,
-	0x77, 0x4f, 0x5c, 0xef, 0xcc, 0x85, 0x42, 0x0b, 0xb7, 0x87, 0x56, 0xe3, 0x1e, 0x44, 0xda, 0x65,
+	0xd7, 0x3b, 0x73, 0xa1, 0xd0, 0xc2, 0xed, 0xa1, 0xd5, 0xb8, 0x0b, 0x9e, 0x76, 0x19, 0x40, 0xda,
-	0x00, 0x69, 0x33, 0x20, 0xca, 0x5c, 0x76, 0x86, 0x92, 0xda, 0x8d, 0x56, 0xbd, 0xd9, 0xba, 0x03,
+	0x0c, 0x88, 0x32, 0x97, 0x9d, 0xa1, 0xa4, 0x76, 0xa3, 0x55, 0x6f, 0xb6, 0x6e, 0x43, 0x79, 0x7b,
-	0xe5, 0xed, 0x71, 0x49, 0x6d, 0x06, 0xe5, 0xcc, 0x3d, 0x06, 0x77, 0x67, 0x9b, 0x9d, 0xce, 0x3e,
+	0x54, 0x52, 0x9b, 0x41, 0x39, 0x73, 0x8f, 0xc1, 0xdc, 0xd9, 0x66, 0xa7, 0xb3, 0xcf, 0x5b, 0xc5,
-	0x6f, 0x15, 0x9f, 0x07, 0xd4, 0xc5, 0x19, 0x14, 0x0e, 0xa0, 0x4f, 0x04, 0x10, 0x56, 0x52, 0x00,
+	0x67, 0x01, 0x75, 0x71, 0x06, 0x85, 0x03, 0xe8, 0x13, 0x01, 0x84, 0x95, 0x14, 0x40, 0xe9, 0x18,
-	0xa5, 0x63, 0x40, 0x58, 0x4c, 0x21, 0x81, 0x88, 0x08, 0xff, 0x5b, 0x92, 0x94, 0x0c, 0xcb, 0x62,
+	0x10, 0x16, 0x53, 0x48, 0x20, 0xc2, 0xc3, 0xff, 0x96, 0x24, 0x25, 0xc3, 0xb2, 0xd8, 0x30, 0xc4,
-	0xc3, 0x10, 0xe7, 0x65, 0x77, 0xb2, 0x87, 0xdd, 0x1e, 0x7c, 0xd9, 0x0c, 0x5f, 0x4f, 0x30, 0x2c,
+	0x79, 0xd9, 0x9d, 0xec, 0x61, 0xb7, 0x07, 0x5f, 0x36, 0xc3, 0xd7, 0x13, 0x74, 0x8b, 0x5b, 0xb1,
-	0x6e, 0xc7, 0xbe, 0x18, 0xcd, 0xf1, 0x55, 0xa8, 0xe7, 0x30, 0xa3, 0x37, 0xb0, 0x03, 0x7c, 0x45,
+	0x2f, 0x46, 0x73, 0x7c, 0x15, 0xea, 0x39, 0xcc, 0xe8, 0x0d, 0xec, 0x00, 0x5f, 0x11, 0x04, 0x8d,
-	0x10, 0x34, 0x1a, 0x49, 0x2a, 0xff, 0x27, 0x41, 0x2e, 0xc6, 0x20, 0xb4, 0x37, 0x48, 0xda, 0x07,
+	0x46, 0x92, 0xca, 0xff, 0x49, 0x90, 0x8b, 0x31, 0x08, 0xed, 0x75, 0x92, 0xf6, 0x81, 0x2c, 0x8f,
-	0xb2, 0xdc, 0x9e, 0xb5, 0x27, 0xdd, 0xe7, 0x90, 0x95, 0x72, 0xa4, 0xb6, 0x4e, 0x88, 0x39, 0x0a,
+	0x67, 0xed, 0x71, 0xf7, 0x39, 0x64, 0xa5, 0x1c, 0xa9, 0xad, 0x13, 0x62, 0x8e, 0x42, 0xcf, 0xe4,
-	0x3d, 0x93, 0xaf, 0xcf, 0x37, 0x26, 0x47, 0xa7, 0x28, 0xda, 0xf7, 0x21, 0x5b, 0x33, 0xcb, 0x97,
+	0xeb, 0xf3, 0x83, 0xc9, 0xd1, 0x29, 0x8a, 0xf6, 0x7d, 0xc8, 0xd6, 0xcc, 0xf2, 0xe5, 0x95, 0xa8,
-	0x57, 0xa2, 0xc2, 0x46, 0xe3, 0x7f, 0xd5, 0xbe, 0xb2, 0x65, 0x62, 0x46, 0xe9, 0x70, 0x61, 0x54,
+	0xb0, 0xd1, 0xf8, 0x5f, 0x77, 0x5f, 0xd9, 0x32, 0x31, 0xa3, 0x74, 0xb8, 0x30, 0x2a, 0x85, 0x96,
-	0x0a, 0x2d, 0xbf, 0x45, 0x8a, 0xd3, 0x74, 0x8c, 0x6e, 0x68, 0x2f, 0x4c, 0x6e, 0x40, 0x91, 0xf2,
+	0xdf, 0x24, 0xc5, 0x69, 0x3a, 0x7a, 0x37, 0xb4, 0x17, 0x26, 0x57, 0xa0, 0x48, 0xf9, 0x37, 0x3a,
-	0x6f, 0x0c, 0x1a, 0xd3, 0x39, 0x56, 0x41, 0x03, 0x9f, 0x3a, 0x25, 0xb9, 0x9a, 0x21, 0xd3, 0xe7,
+	0x8d, 0xe9, 0x1c, 0x2b, 0xa7, 0x81, 0x4f, 0x9d, 0x92, 0x5c, 0xcd, 0x90, 0xe9, 0x73, 0x93, 0x94,
-	0x26, 0x29, 0xf1, 0x43, 0x63, 0x31, 0x3f, 0xec, 0xb2, 0xfb, 0x43, 0xdb, 0x1f, 0xcb, 0xb8, 0x3f,
+	0x78, 0xd0, 0x58, 0xcc, 0x0f, 0xbb, 0xec, 0xde, 0xd0, 0xf6, 0xc7, 0xd2, 0xef, 0xcf, 0xef, 0xaf,
-	0xbf, 0xbf, 0x5a, 0x46, 0xae, 0x1a, 0x30, 0x35, 0x38, 0x8f, 0x7e, 0x40, 0x2e, 0xee, 0xfa, 0x56,
+	0x96, 0x91, 0xab, 0x06, 0x4c, 0x0d, 0xce, 0xa3, 0x1f, 0x90, 0x8b, 0xbb, 0xbe, 0xd5, 0x87, 0x8a,
-	0x1f, 0x2a, 0xb6, 0x00, 0x48, 0xf1, 0xef, 0x91, 0xb5, 0x10, 0x2a, 0x73, 0xb7, 0x6f, 0x07, 0x21,
+	0x2d, 0x00, 0x52, 0xfc, 0xbb, 0x64, 0x2d, 0x84, 0xca, 0xdc, 0xed, 0xdb, 0x41, 0x88, 0xaf, 0x67,
-	0xbe, 0x9e, 0x81, 0x92, 0xcc, 0xc5, 0xf9, 0x2e, 0x7f, 0xe5, 0x12, 0xaf, 0x6e, 0xf4, 0x0a, 0x62,
+	0xb0, 0x49, 0xe6, 0xe2, 0x7c, 0x97, 0xbf, 0x72, 0x89, 0x57, 0x37, 0x7a, 0x05, 0x31, 0x5b, 0x02,
-	0xb6, 0x04, 0x84, 0x2a, 0xc4, 0x36, 0x02, 0xf4, 0x77, 0x49, 0xa9, 0x6e, 0x07, 0x43, 0x33, 0x04,
+	0x42, 0x15, 0x62, 0x1b, 0x01, 0xfa, 0x3b, 0xa4, 0x54, 0xb7, 0x83, 0xa1, 0x19, 0x82, 0x6c, 0xd9,
-	0xd9, 0xb2, 0xb1, 0xd6, 0x5e, 0x26, 0xa5, 0x3e, 0x83, 0xc6, 0xea, 0x90, 0x99, 0x90, 0x9c, 0x99,
+	0x58, 0x6b, 0x2f, 0x91, 0x52, 0x9f, 0x41, 0x63, 0x75, 0xc8, 0x4c, 0x48, 0xce, 0xcc, 0xb7, 0xbd,
-	0x6f, 0x7b, 0x3d, 0xd9, 0x3b, 0xad, 0x44, 0xf4, 0x36, 0x27, 0xeb, 0x5f, 0x42, 0xb1, 0xc0, 0x87,
+	0x9e, 0xec, 0x9d, 0x56, 0x22, 0x7a, 0x9b, 0x93, 0xf5, 0x2f, 0xa0, 0x58, 0xe0, 0xc3, 0x81, 0xe4,
-	0x03, 0xc9, 0xf9, 0x2a, 0xb9, 0x10, 0xb8, 0xe6, 0x30, 0xe8, 0x7b, 0x61, 0xd7, 0x76, 0x43, 0x7c,
+	0x7c, 0x85, 0x5c, 0x08, 0x5c, 0x73, 0x18, 0xf4, 0xbd, 0xb0, 0x6b, 0xbb, 0x21, 0xbe, 0x94, 0x39,
-	0x29, 0x73, 0x24, 0x6b, 0x49, 0x4d, 0x34, 0x25, 0x1d, 0xd2, 0x80, 0x76, 0xc2, 0xd8, 0xb0, 0xeb,
+	0x92, 0xb5, 0xa4, 0x26, 0x9a, 0x92, 0x0e, 0x69, 0x40, 0x3b, 0x61, 0x6c, 0xd8, 0xf5, 0x9c, 0x5e,
-	0x39, 0xbd, 0xae, 0x9a, 0x14, 0xaf, 0x63, 0x80, 0xc6, 0x99, 0x5d, 0xa7, 0xd7, 0x51, 0x74, 0xad,
+	0x57, 0x4d, 0x8a, 0xd7, 0x31, 0x40, 0xe3, 0xcc, 0xae, 0xd3, 0xeb, 0x28, 0xba, 0x56, 0x25, 0xeb,
-	0x4a, 0xd6, 0x1d, 0xef, 0xb8, 0x0b, 0xba, 0xfb, 0x10, 0x62, 0xdd, 0x23, 0xcf, 0xef, 0x06, 0x8e,
+	0x8e, 0x77, 0xdc, 0x85, 0xbd, 0xfb, 0xe0, 0x62, 0xdd, 0x23, 0xcf, 0xef, 0x06, 0x8e, 0x77, 0x06,
-	0x77, 0x06, 0x1f, 0x0e, 0xfc, 0x31, 0x5f, 0xf5, 0xb4, 0x65, 0x40, 0x35, 0x04, 0x68, 0xd3, 0xf3,
+	0x1f, 0x0e, 0xfc, 0x31, 0x5f, 0xf5, 0xb4, 0x65, 0x40, 0x35, 0x04, 0x68, 0xd3, 0xf3, 0x3b, 0x30,
-	0x3b, 0x30, 0xb7, 0xa9, 0x10, 0x58, 0x51, 0x26, 0x86, 0x85, 0xb6, 0x75, 0xa2, 0x2a, 0x4a, 0x44,
+	0xb7, 0xa9, 0x10, 0x58, 0x51, 0x26, 0x8a, 0x85, 0xb6, 0x75, 0xa2, 0x2a, 0x4a, 0x44, 0xdd, 0x03,
-	0xdd, 0x03, 0x22, 0x1c, 0xaa, 0x25, 0xe6, 0x30, 0x8b, 0xbb, 0x91, 0xa3, 0x32, 0x1c, 0x55, 0x54,
+	0x22, 0x04, 0xd5, 0x12, 0x73, 0x98, 0xc5, 0xcd, 0xc8, 0x51, 0x19, 0x8e, 0x2a, 0x2a, 0x22, 0x82,
-	0x44, 0x04, 0xe9, 0x3f, 0x97, 0x96, 0x8b, 0x27, 0x13, 0x4c, 0x8e, 0x3e, 0x8c, 0x54, 0x72, 0x4c,
+	0xf4, 0x6f, 0x92, 0x7c, 0xdb, 0x31, 0x2d, 0xfe, 0x06, 0x89, 0x8d, 0x26, 0x64, 0x4b, 0x3c, 0x1b,
-	0x8b, 0xe4, 0x88, 0x00, 0x4c, 0x8e, 0x38, 0x15, 0x9f, 0x1c, 0xc1, 0xae, 0xac, 0x68, 0x67, 0x64,
+	0xd0, 0x5a, 0x44, 0x52, 0x9e, 0x4e, 0x93, 0xf4, 0x0f, 0xa1, 0xbe, 0x50, 0xcf, 0x0b, 0x6b, 0x06,
-	0x04, 0x5f, 0x7f, 0x9a, 0xb7, 0x19, 0xd9, 0x8a, 0x4a, 0x4e, 0xfd, 0x9b, 0x24, 0xdf, 0x76, 0x4c,
+	0x80, 0xb3, 0x96, 0xd9, 0x55, 0xb9, 0xbf, 0x58, 0xcd, 0x43, 0x1a, 0xcd, 0xd4, 0x8c, 0x3b, 0x6c,
-	0x8b, 0xbf, 0x87, 0x62, 0xd3, 0x0b, 0x99, 0x1b, 0xe3, 0x04, 0x76, 0x40, 0x9c, 0xea, 0x3c, 0x9d,
+	0x4c, 0x33, 0x96, 0x09, 0x7f, 0x98, 0x69, 0x01, 0x81, 0x2e, 0xc3, 0xcd, 0x51, 0x14, 0x99, 0x16,
-	0x26, 0xe9, 0x1f, 0x41, 0xad, 0xa3, 0x9e, 0x17, 0xd6, 0x0c, 0x00, 0x67, 0x2d, 0xb3, 0xab, 0xea,
+	0x7c, 0x0a, 0x28, 0x14, 0x98, 0xf1, 0x1f, 0x82, 0xa9, 0x28, 0x41, 0xdd, 0x3e, 0xf8, 0xa8, 0xe8,
-	0x50, 0xb1, 0x9a, 0x07, 0xad, 0x33, 0x35, 0xe3, 0x2e, 0x1b, 0xd3, 0x8c, 0x65, 0xc2, 0x1f, 0x1a,
+	0x4b, 0xaa, 0xcb, 0x80, 0x24, 0x02, 0x89, 0x9e, 0x4b, 0x89, 0x40, 0xe3, 0xb7, 0xfe, 0xe7, 0x04,
-	0x06, 0x08, 0x0c, 0x5f, 0xae, 0x76, 0x51, 0x18, 0x06, 0xf1, 0x0d, 0x14, 0x0a, 0xcc, 0xf8, 0x0f,
+	0x29, 0xe0, 0xc0, 0x3e, 0xb2, 0x2d, 0x4c, 0x69, 0x4f, 0x1f, 0x8e, 0xd0, 0xad, 0x5a, 0x81, 0x2f,
-	0x07, 0xbb, 0x28, 0x41, 0xdd, 0x3e, 0x9c, 0x17, 0xd1, 0x23, 0x55, 0x97, 0x01, 0x49, 0x04, 0x12,
+	0x37, 0xc5, 0xbb, 0xd5, 0x5a, 0x87, 0x52, 0xa4, 0x69, 0xef, 0x41, 0x24, 0xf2, 0x94, 0x2a, 0x23,
-	0x4f, 0x11, 0x25, 0x02, 0x8d, 0xdf, 0xfa, 0x9f, 0x13, 0xa4, 0x80, 0x03, 0xfb, 0xc8, 0xb6, 0x30,
+	0x51, 0xff, 0xf2, 0xe4, 0x2b, 0x1b, 0x6a, 0xc9, 0xc7, 0x8d, 0x38, 0xd9, 0x1d, 0x3f, 0x9a, 0x22,
-	0xbd, 0x3e, 0x7b, 0x6a, 0x80, 0xce, 0xd9, 0x0a, 0x7c, 0xa9, 0x14, 0xef, 0x9c, 0x6b, 0x1d, 0x4a,
+	0x9d, 0x26, 0xe1, 0xfb, 0xa9, 0xe5, 0xf2, 0xd3, 0x90, 0xef, 0xa7, 0xb5, 0x16, 0x05, 0x8a, 0xfe,
-	0x91, 0xa6, 0xbd, 0x3f, 0xe7, 0x53, 0xfd, 0xab, 0x0b, 0xc1, 0xac, 0x47, 0xb9, 0x13, 0x27, 0xda,
+	0x47, 0xb8, 0xc5, 0x36, 0x5c, 0xcb, 0x1f, 0xf3, 0xfa, 0x88, 0x16, 0x5c, 0x23, 0x79, 0xe8, 0xdb,
-	0xf1, 0x30, 0x29, 0xd2, 0x69, 0x12, 0xbe, 0xe5, 0x5a, 0x2e, 0x8f, 0x0c, 0xf9, 0x96, 0x5b, 0x6b,
+	0x82, 0x71, 0x00, 0x97, 0x1b, 0xf5, 0x3c, 0x13, 0x11, 0xb4, 0x26, 0xc9, 0x43, 0x9c, 0x7a, 0xbe,
-	0x51, 0xa0, 0xe8, 0x7f, 0x84, 0x1b, 0x75, 0xc3, 0xb5, 0xfc, 0x31, 0xaf, 0xd5, 0xe8, 0xc1, 0x35,
+	0x1d, 0xf6, 0x07, 0xb2, 0x81, 0x79, 0x25, 0xfe, 0x11, 0x6e, 0x4a, 0x66, 0xc5, 0x50, 0x2c, 0x74,
-	0x92, 0x87, 0x1e, 0x32, 0x18, 0x07, 0x70, 0xd1, 0x52, 0x4f, 0x45, 0x11, 0x41, 0x6b, 0x92, 0x3c,
+	0xc2, 0xad, 0xaa, 0x78, 0x8a, 0x6f, 0x96, 0x57, 0x71, 0xb8, 0x6a, 0x39, 0xd0, 0x55, 0x43, 0x6b,
-	0xe4, 0x0c, 0xcf, 0xb7, 0xc3, 0xfe, 0x40, 0x36, 0x53, 0xaf, 0xc6, 0x3f, 0x08, 0x4e, 0xc9, 0xac,
+	0xd2, 0xc5, 0x66, 0x95, 0xeb, 0x01, 0xb7, 0x0e, 0x49, 0xc3, 0x06, 0x5c, 0xd7, 0x49, 0x3e, 0x12,
-	0x18, 0x8a, 0x85, 0x4e, 0xb8, 0x55, 0x47, 0x91, 0xe2, 0xca, 0xf2, 0x8e, 0x02, 0xae, 0x7d, 0x0e,
+	0x86, 0x8f, 0x62, 0x46, 0xa3, 0xd3, 0xbd, 0xb9, 0x71, 0xab, 0x7b, 0xbb, 0xb6, 0x03, 0xc5, 0x45,
-	0x74, 0xf8, 0xd0, 0x26, 0x75, 0xb1, 0x71, 0xe6, 0x76, 0xc0, 0x0d, 0x48, 0xd2, 0xf0, 0x32, 0xa0,
+	0xa4, 0xeb, 0xdf, 0x81, 0x4e, 0x3b, 0xa6, 0x0b, 0x0d, 0xb5, 0xba, 0x5e, 0x80, 0x57, 0xf8, 0x10,
-	0xeb, 0x24, 0x1f, 0x09, 0xc3, 0x07, 0x3a, 0xa3, 0xd1, 0xe9, 0xde, 0xda, 0xb8, 0xdd, 0xbd, 0x53,
+	0x6a, 0xaa, 0xfe, 0xa6, 0x85, 0x57, 0x60, 0xf4, 0x61, 0xfd, 0xc5, 0xa9, 0xf8, 0xfa, 0x3b, 0xf5,
-	0xdb, 0x81, 0x42, 0x27, 0x4a, 0x47, 0x93, 0x2c, 0xed, 0x98, 0x2e, 0xf4, 0xf6, 0xea, 0xa6, 0x73,
+	0x38, 0x98, 0x3a, 0xf7, 0x71, 0x30, 0xfd, 0x7f, 0x79, 0x1c, 0x7c, 0xf9, 0x8b, 0x14, 0xc9, 0x47,
-	0x1b, 0x76, 0x0b, 0x42, 0x52, 0x66, 0xb2, 0xf5, 0xf3, 0x43, 0x56, 0xba, 0x96, 0x73, 0xbc, 0xf2,
+	0xd7, 0x05, 0x74, 0x19, 0x2c, 0x87, 0x0b, 0xe2, 0x22, 0x17, 0xd1, 0x5b, 0xbc, 0x10, 0xe6, 0x8d,
-	0x65, 0x8a, 0xe4, 0xa3, 0xbb, 0x04, 0xee, 0x21, 0xd6, 0xca, 0x05, 0x71, 0xcb, 0x8b, 0xe8, 0x2d,
+	0xed, 0xed, 0xdd, 0x9a, 0x81, 0x6f, 0x6b, 0xef, 0x89, 0x7a, 0x19, 0x01, 0x0c, 0x08, 0x5a, 0x3c,
-	0x5e, 0x25, 0xf3, 0xc6, 0xf6, 0xf6, 0x6e, 0xcd, 0xc0, 0x87, 0xb7, 0xf7, 0x45, 0x31, 0x8d, 0x00,
+	0xf4, 0x9e, 0xa6, 0x4f, 0xea, 0xe5, 0x7d, 0x79, 0x5d, 0x8c, 0x50, 0xaa, 0x58, 0xbe, 0x40, 0x72,
-	0x06, 0x9c, 0x68, 0xdc, 0x85, 0x9e, 0xa6, 0x4f, 0x8a, 0xe9, 0x03, 0x79, 0x97, 0x8c, 0x50, 0xaa,
+	0x46, 0xa7, 0xd3, 0xbc, 0xdd, 0x02, 0x49, 0x0f, 0x12, 0xe5, 0x67, 0x00, 0x74, 0x61, 0x22, 0x0a,
-	0x92, 0x5e, 0x27, 0x39, 0xa3, 0xd3, 0x69, 0xde, 0x69, 0x81, 0xa4, 0x87, 0x89, 0xf2, 0x73, 0x00,
+	0xf2, 0xfc, 0xb1, 0x0b, 0x92, 0x10, 0x55, 0xab, 0x35, 0xda, 0xb8, 0xde, 0xfd, 0xe4, 0x3c, 0x8a,
-	0xba, 0x30, 0x11, 0x05, 0x45, 0xe0, 0xd8, 0x05, 0x49, 0x88, 0xaa, 0xd5, 0x1a, 0x6d, 0x5c, 0xef,
+	0x57, 0x09, 0xfe, 0xf6, 0x92, 0x6f, 0xd3, 0x46, 0xdb, 0xa0, 0xb8, 0xe2, 0x83, 0xe4, 0xdc, 0xbe,
-	0x41, 0x72, 0x1e, 0xc5, 0x4b, 0x08, 0x7f, 0x98, 0xc9, 0xb7, 0x69, 0xa3, 0x6d, 0x50, 0x5c, 0xf1,
+	0xda, 0x3e, 0x83, 0x0b, 0x24, 0xae, 0xb9, 0xae, 0x1e, 0x0a, 0xef, 0xa7, 0xca, 0x1a, 0x60, 0x96,
-	0x61, 0x72, 0x4e, 0xaf, 0xb6, 0xcf, 0xe0, 0x76, 0x89, 0x6b, 0xae, 0xab, 0x57, 0xc4, 0x07, 0xa9,
+	0x27, 0x77, 0x24, 0xb0, 0xef, 0x18, 0x57, 0xeb, 0xec, 0x19, 0x74, 0x8f, 0x8b, 0x49, 0xcd, 0xad,
-	0xb2, 0x06, 0x98, 0xe5, 0xc9, 0x05, 0x8a, 0x99, 0xbd, 0x31, 0xae, 0xd6, 0xd9, 0x33, 0xe8, 0x1e,
+	0xd6, 0xc1, 0x9b, 0x2b, 0x4a, 0x01, 0xed, 0xe8, 0x7e, 0xab, 0xc5, 0xb5, 0x4b, 0xcf, 0x69, 0x47,
-	0x17, 0x93, 0x9a, 0x5b, 0xad, 0x83, 0xd7, 0x5a, 0x94, 0x02, 0xd6, 0xd1, 0xfd, 0x56, 0x8b, 0x5b,
+	0x47, 0xae, 0x8b, 0x98, 0xeb, 0x50, 0x50, 0x76, 0x77, 0xda, 0xdb, 0x8d, 0xbd, 0x46, 0xe9, 0x41,
-	0x97, 0x9e, 0xb3, 0x8e, 0x8e, 0x5c, 0x17, 0x31, 0x37, 0xa0, 0xda, 0xec, 0xee, 0xb4, 0xb7, 0x1b,
+	0x7a, 0x6e, 0x43, 0x35, 0x6f, 0x30, 0x74, 0x58, 0x28, 0xd4, 0xeb, 0x6c, 0xed, 0xef, 0xf1, 0x77,
-	0x7b, 0x8d, 0xd2, 0xc3, 0xf4, 0x9c, 0x42, 0x35, 0x6f, 0x30, 0x74, 0x58, 0x28, 0xcc, 0xeb, 0x6c,
+	0xcc, 0xfb, 0x99, 0xf9, 0x05, 0xfb, 0xa3, 0xb0, 0x87, 0x1d, 0xca, 0xb5, 0xa8, 0x65, 0x78, 0x90,
-	0xed, 0xef, 0xf1, 0x47, 0xce, 0x07, 0x99, 0xf9, 0x05, 0xfb, 0xa3, 0xb0, 0x87, 0xed, 0xcb, 0xb5,
+	0x11, 0xef, 0x1a, 0x11, 0x46, 0xf4, 0x0b, 0x28, 0x87, 0x36, 0xbe, 0x27, 0x9e, 0x3c, 0xef, 0x67,
-	0xa8, 0x9f, 0x78, 0x98, 0x11, 0x8f, 0x1e, 0x11, 0x46, 0x34, 0x13, 0x28, 0x87, 0x36, 0xbe, 0x27,
+	0xe7, 0xe4, 0x50, 0xf6, 0x01, 0x64, 0x41, 0xe8, 0x2a, 0xa2, 0xd7, 0x8f, 0x68, 0xea, 0xe5, 0x1f,
-	0xde, 0x43, 0x1f, 0x64, 0xe7, 0xe4, 0x50, 0xf6, 0x21, 0xa4, 0x48, 0x68, 0x39, 0xa2, 0xa7, 0x91,
+	0x90, 0x9c, 0x4a, 0x18, 0x60, 0x9d, 0xec, 0xdd, 0x5d, 0x7a, 0xa7, 0x41, 0xe1, 0xe8, 0xb9, 0x75,
-	0x68, 0xea, 0x95, 0x1f, 0x90, 0x9c, 0x3a, 0xc1, 0xe0, 0x9d, 0xec, 0xbd, 0x5d, 0x7a, 0xb7, 0x41,
+	0xd4, 0xcc, 0x5d, 0xcf, 0x07, 0xef, 0x82, 0x6d, 0x2c, 0xee, 0x18, 0x2d, 0xe3, 0x36, 0x00, 0xe4,
-	0x61, 0xeb, 0xb9, 0x77, 0xd4, 0xcc, 0x3d, 0xcf, 0x87, 0x40, 0x02, 0x35, 0x16, 0x77, 0x8c, 0x96,
+	0xf3, 0x8a, 0x02, 0x48, 0xaf, 0x2f, 0x97, 0xe4, 0x02, 0x91, 0xcc, 0xea, 0xda, 0xc3, 0xcf, 0xd6,
-	0x71, 0x07, 0x00, 0xf2, 0xed, 0x45, 0x01, 0x64, 0x1c, 0x96, 0x4b, 0x72, 0x81, 0x48, 0x66, 0x75,
+	0x17, 0x3e, 0x81, 0xdf, 0xdf, 0x3f, 0x5b, 0x4f, 0xdc, 0xff, 0x7c, 0x3d, 0xf1, 0x10, 0x7e, 0x7f,
-	0xed, 0xd1, 0xe7, 0xeb, 0x0b, 0x9f, 0xc2, 0xef, 0xef, 0x9f, 0xaf, 0x27, 0x1e, 0x7c, 0xb1, 0x9e,
+	0x80, 0xdf, 0x5f, 0xe0, 0x77, 0x98, 0xe5, 0x57, 0x8b, 0x37, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff,
-	0x78, 0x04, 0xbf, 0x3f, 0xc0, 0xef, 0x2f, 0xf0, 0x3b, 0xcc, 0xf2, 0x7b, 0xc7, 0x9b, 0xff, 0x0d,
+	0xe7, 0xbe, 0x71, 0xe8, 0xb4, 0x1b, 0x00, 0x00,
-	0x00, 0x00, 0xff, 0xff, 0x6c, 0xaf, 0xb7, 0x57, 0xd1, 0x1b, 0x00, 0x00,
 }

vendor/src/github.com/docker/swarmkit/api/types.proto

@@ -484,18 +484,6 @@ message RaftConfig {
 	uint32 election_tick = 5;
 }
 
-message RaftMember {
-	// RaftID specifies the internal ID used by the manager in a raft context, it can never be modified
-	// and is used only for information purposes
-	uint64 raft_id = 1 [(gogoproto.customname) = "RaftID"];
-
-	// Addr specifies the address of the member
-	string addr = 2;
-
-	// Status provides the current status of the manager from the perspective of another manager.
-	RaftMemberStatus status = 3 [(gogoproto.nullable) = false];
-}
-
 // Placement specifies task distribution constraints.
 message Placement {
 	// constraints specifies a set of requirements a node should meet for a task.
@@ -558,7 +546,18 @@ message EncryptionKey {
 	uint64 lamport_time = 4;
 }
 
-// ManagerStatus provides information about the status of a manager in the cluster.
+// ManagerStatus provides informations about the state of a manager in the cluster.
 message ManagerStatus {
-	RaftMember raft = 1 [(gogoproto.nullable) = false];
+	// RaftID specifies the internal ID used by the manager in a raft context, it can never be modified
-}
+	// and is used only for information purposes
+	uint64 raft_id = 1 [(gogoproto.customname) = "RaftID"];
+
+	// Addr is the address advertised to raft.
+	string addr = 2;
+
+	// Leader is set to true if this node is the raft leader.
+	bool leader = 3;
+
+	// Reachability specifies whether this node is reachable.
+	RaftMemberStatus.Reachability reachability = 4;
+}

vendor/src/github.com/docker/swarmkit/ca/certificates.go

@@ -476,7 +476,7 @@ func BootstrapCluster(baseCertDir string) error {
 		return err
 	}
 
-	nodeID := identity.NewNodeID()
+	nodeID := identity.NewID()
 	newOrg := identity.NewID()
 	_, err = GenerateAndSignNewTLSCert(rootCA, nodeID, ManagerRole, newOrg, paths.Node)
 

vendor/src/github.com/docker/swarmkit/ca/config.go

@@ -194,7 +194,7 @@ func LoadOrCreateSecurityConfig(ctx context.Context, baseCertDir, caHash, secret
 
 		if rootCA.CanSign() {
 			// Create a new random ID for this certificate
-			cn := identity.NewNodeID()
+			cn := identity.NewID()
 			org := identity.NewID()
 
 			if nodeInfo != nil {

vendor/src/github.com/docker/swarmkit/ca/server.go

@@ -30,6 +30,10 @@ type Server struct {
 	store            *store.MemoryStore
 	securityConfig   *SecurityConfig
 	acceptancePolicy *api.AcceptancePolicy
+
+	// Started is a channel which gets closed once the server is running
+	// and able to service RPCs.
+	Started chan struct{}
 }
 
 // DefaultAcceptancePolicy returns the default acceptance policy.
@@ -60,6 +64,7 @@ func NewServer(store *store.MemoryStore, securityConfig *SecurityConfig) *Server
 	return &Server{
 		store:          store,
 		securityConfig: securityConfig,
+		Started:        make(chan struct{}),
 	}
 }
 
@@ -200,7 +205,7 @@ func (s *Server) IssueNodeCertificate(ctx context.Context, request *api.IssueNod
 	maxRetries := 3
 	// Generate a random ID for this new node
 	for i := 0; ; i++ {
-		nodeID = identity.NewNodeID()
+		nodeID = identity.NewID()
 
 		// Create a new node
 		err := s.store.Update(func(tx store.Tx) error {
@@ -353,6 +358,8 @@ func (s *Server) Run(ctx context.Context) error {
 	s.ctx, s.cancel = context.WithCancel(ctx)
 	s.mu.Unlock()
 
+	close(s.Started)
+
 	// Retrieve the channels to keep track of changes in the cluster
 	// Retrieve all the currently registered nodes
 	var nodes []*api.Node

vendor/src/github.com/docker/swarmkit/identity/randomid.go

@@ -2,12 +2,9 @@ package identity
 
 import (
 	"crypto/rand"
-	"encoding/binary"
-	"errors"
 	"fmt"
 	"io"
 	"math/big"
-	"strconv"
 )
 
 var (
@@ -53,31 +50,3 @@ func NewID() string {
 	nn.SetBytes(p[:])
 	return fmt.Sprintf("%0[1]*s", maxRandomIDLength, nn.Text(randomIDBase))
 }
-
-// NewNodeID generates a new identifier for identifying a node. These IDs
-// are shorter than the IDs returned by NewID, so they can be used directly
-// by Raft. Because they are short, they MUST be checked for collisions.
-func NewNodeID() string {
-	var p [randomNodeIDEntropyBytes]byte
-
-	if _, err := io.ReadFull(idReader, p[:]); err != nil {
-		panic(fmt.Errorf("failed to read random bytes: %v", err))
-	}
-
-	randomInt := binary.LittleEndian.Uint64(p[:])
-	return FormatNodeID(randomInt)
-}
-
-// FormatNodeID converts a node ID from uint64 to string format.
-// A string-formatted node ID looks like 1w8ynjwhcy4zd.
-func FormatNodeID(nodeID uint64) string {
-	return fmt.Sprintf("%0[1]*s", maxRandomNodeIDLength, strconv.FormatUint(nodeID, 36))
-}
-
-// ParseNodeID converts a node ID from string format to uint64.
-func ParseNodeID(nodeID string) (uint64, error) {
-	if len(nodeID) != maxRandomNodeIDLength {
-		return 0, errors.New("node ID has invalid length")
-	}
-	return strconv.ParseUint(nodeID, 36, 64)
-}

vendor/src/github.com/docker/swarmkit/manager/controlapi/cluster.go

@@ -169,6 +169,7 @@ func redactClusters(clusters []*api.Cluster) []*api.Cluster {
 	// Only add public fields to the new clusters
 	for _, cluster := range clusters {
 		// Copy all the mandatory fields
+		// Do not copy secret key
 		newCluster := &api.Cluster{
 			ID:   cluster.ID,
 			Meta: cluster.Meta,
@@ -179,17 +180,6 @@ func redactClusters(clusters []*api.Cluster) []*api.Cluster {
 			},
 		}
 
-		// Redact the acceptance policy secrets
-		if len(newCluster.Spec.AcceptancePolicy.Policies) > 0 {
-			for _, policy := range newCluster.Spec.AcceptancePolicy.Policies {
-				// Adding [REDACTED] to the api client so they know there is a
-				// a secret configured, but without telling them what it is.
-				if policy.Secret != nil {
-					policy.Secret.Data = []byte("[REDACTED]")
-				}
-
-			}
-		}
 		redactedClusters = append(redactedClusters, newCluster)
 	}
 

vendor/src/github.com/docker/swarmkit/manager/controlapi/node.go

@@ -2,7 +2,6 @@ package controlapi
 
 import (
 	"github.com/docker/swarmkit/api"
-	"github.com/docker/swarmkit/identity"
 	"github.com/docker/swarmkit/manager/state/store"
 	"golang.org/x/net/context"
 	"google.golang.org/grpc"
@@ -34,9 +33,16 @@ func (s *Server) GetNode(ctx context.Context, request *api.GetNodeRequest) (*api
 
 	if s.raft != nil {
 		memberlist := s.raft.GetMemberlist()
-		raftID, err := identity.ParseNodeID(request.NodeID)
+		for _, member := range memberlist {
-		if err == nil && memberlist[raftID] != nil {
+			if member.NodeID == node.ID {
-			node.ManagerStatus = &api.ManagerStatus{Raft: *memberlist[raftID]}
+				node.ManagerStatus = &api.ManagerStatus{
+					RaftID:       member.RaftID,
+					Addr:         member.Addr,
+					Leader:       member.Status.Leader,
+					Reachability: member.Status.Reachability,
+				}
+				break
+			}
 		}
 	}
 
@@ -148,10 +154,17 @@ func (s *Server) ListNodes(ctx context.Context, request *api.ListNodesRequest) (
 	if s.raft != nil {
 		memberlist := s.raft.GetMemberlist()
 
-		for _, n := range nodes {
+		for _, node := range nodes {
-			raftID, err := identity.ParseNodeID(n.ID)
+			for _, member := range memberlist {
-			if err == nil && memberlist[raftID] != nil {
+				if member.NodeID == node.ID {
-				n.ManagerStatus = &api.ManagerStatus{Raft: *memberlist[raftID]}
+					node.ManagerStatus = &api.ManagerStatus{
+						RaftID:       member.RaftID,
+						Addr:         member.Addr,
+						Leader:       member.Status.Leader,
+						Reachability: member.Status.Reachability,
+					}
+					break
+				}
 			}
 		}
 	}
@@ -173,7 +186,10 @@ func (s *Server) UpdateNode(ctx context.Context, request *api.UpdateNodeRequest)
 		return nil, err
 	}
 
-	var node *api.Node
+	var (
+		node   *api.Node
+		demote bool
+	)
 	err := s.store.Update(func(tx store.Tx) error {
 		node = store.GetNode(tx, request.NodeID)
 		if node == nil {
@@ -182,6 +198,7 @@ func (s *Server) UpdateNode(ctx context.Context, request *api.UpdateNodeRequest)
 
 		// Demotion sanity checks.
 		if node.Spec.Role == api.NodeRoleManager && request.Spec.Role == api.NodeRoleWorker {
+			demote = true
 			managers, err := store.FindNodes(tx, store.ByRole(api.NodeRoleManager))
 			if err != nil {
 				return grpc.Errorf(codes.Internal, "internal store error: %v", err)
@@ -201,6 +218,19 @@ func (s *Server) UpdateNode(ctx context.Context, request *api.UpdateNodeRequest)
 	if node == nil {
 		return nil, grpc.Errorf(codes.NotFound, "node %s not found", request.NodeID)
 	}
+
+	if demote && s.raft != nil {
+		memberlist := s.raft.GetMemberlist()
+		for raftID, member := range memberlist {
+			if member.NodeID == request.NodeID {
+				if err := s.raft.RemoveMember(ctx, raftID); err != nil {
+					return nil, err
+				}
+				break
+			}
+		}
+	}
+
 	return &api.UpdateNodeResponse{
 		Node: node,
 	}, nil
@@ -217,9 +247,11 @@ func (s *Server) RemoveNode(ctx context.Context, request *api.RemoveNodeRequest)
 	}
 	if s.raft != nil {
 		memberlist := s.raft.GetMemberlist()
-		raftID, err := identity.ParseNodeID(request.NodeID)
+
-		if err == nil && memberlist[raftID] != nil {
+		for _, member := range memberlist {
-			return nil, grpc.Errorf(codes.FailedPrecondition, "node %s is a cluster manager and is part of the quorum. It must be demoted to worker before removal", request.NodeID)
+			if member.NodeID == request.NodeID {
+				return nil, grpc.Errorf(codes.FailedPrecondition, "node %s is a cluster manager and is part of the quorum. It must be demoted to worker before removal", request.NodeID)
+			}
 		}
 	}
 

vendor/src/github.com/docker/swarmkit/manager/dispatcher/dispatcher.go

@@ -15,7 +15,6 @@ import (
 	"github.com/Sirupsen/logrus"
 	"github.com/docker/swarmkit/api"
 	"github.com/docker/swarmkit/ca"
-	"github.com/docker/swarmkit/identity"
 	"github.com/docker/swarmkit/log"
 	"github.com/docker/swarmkit/manager/state"
 	"github.com/docker/swarmkit/manager/state/store"
@@ -136,7 +135,7 @@ func getWeightedPeers(cluster Cluster) []*api.WeightedPeer {
 	for _, m := range members {
 		mgrs = append(mgrs, &api.WeightedPeer{
 			Peer: &api.Peer{
-				NodeID: identity.FormatNodeID(m.RaftID),
+				NodeID: m.NodeID,
 				Addr:   m.Addr,
 			},
 			Weight: 1,

vendor/src/github.com/docker/swarmkit/manager/manager.go

@@ -443,10 +443,12 @@ func (m *Manager) Run(parent context.Context) error {
 	authenticatedCAAPI := api.NewAuthenticatedWrapperCAServer(m.caserver, authorize)
 	authenticatedNodeCAAPI := api.NewAuthenticatedWrapperNodeCAServer(m.caserver, authorize)
 	authenticatedRaftAPI := api.NewAuthenticatedWrapperRaftServer(m.RaftNode, authorize)
+	authenticatedRaftMembershipAPI := api.NewAuthenticatedWrapperRaftMembershipServer(m.RaftNode, authorize)
 
 	proxyDispatcherAPI := api.NewRaftProxyDispatcherServer(authenticatedDispatcherAPI, cs, m.RaftNode, ca.WithMetadataForwardTLSInfo)
 	proxyCAAPI := api.NewRaftProxyCAServer(authenticatedCAAPI, cs, m.RaftNode, ca.WithMetadataForwardTLSInfo)
 	proxyNodeCAAPI := api.NewRaftProxyNodeCAServer(authenticatedNodeCAAPI, cs, m.RaftNode, ca.WithMetadataForwardTLSInfo)
+	proxyRaftMembershipAPI := api.NewRaftProxyRaftMembershipServer(authenticatedRaftMembershipAPI, cs, m.RaftNode, ca.WithMetadataForwardTLSInfo)
 
 	// localProxyControlAPI is a special kind of proxy. It is only wired up
 	// to receive requests from a trusted local socket, and these requests
@@ -462,6 +464,7 @@ func (m *Manager) Run(parent context.Context) error {
 	api.RegisterCAServer(m.server, proxyCAAPI)
 	api.RegisterNodeCAServer(m.server, proxyNodeCAAPI)
 	api.RegisterRaftServer(m.server, authenticatedRaftAPI)
+	api.RegisterRaftMembershipServer(m.server, proxyRaftMembershipAPI)
 	api.RegisterControlServer(m.localserver, localProxyControlAPI)
 	api.RegisterControlServer(m.server, authenticatedControlAPI)
 	api.RegisterDispatcherServer(m.server, proxyDispatcherAPI)
@@ -570,7 +573,7 @@ func (m *Manager) Stop(ctx context.Context) {
 	}
 
 	m.RaftNode.Shutdown()
-	// some time after this point, Run will recieve an error from one of these
+	// some time after this point, Run will receive an error from one of these
 	m.server.Stop()
 	m.localserver.Stop()
 

vendor/src/github.com/docker/swarmkit/manager/orchestrator/services.go

@@ -99,29 +99,34 @@ func (r *ReplicatedOrchestrator) reconcile(ctx context.Context, service *api.Ser
 
 	// TODO(aaronl): Add support for restart delays.
 
-	_, err = r.store.Batch(func(batch *store.Batch) error {
+	switch {
-		switch {
+	case specifiedInstances > numTasks:
-		case specifiedInstances > numTasks:
+		log.G(ctx).Debugf("Service %s was scaled up from %d to %d instances", service.ID, numTasks, specifiedInstances)
-			log.G(ctx).Debugf("Service %s was scaled up from %d to %d instances", service.ID, numTasks, specifiedInstances)
+		// Update all current tasks then add missing tasks
-			// Update all current tasks then add missing tasks
+		r.updater.Update(ctx, service, runningTasks)
-			r.updater.Update(ctx, service, runningTasks)
+		_, err = r.store.Batch(func(batch *store.Batch) error {
 			r.addTasks(ctx, batch, service, runningInstances, specifiedInstances-numTasks)
-
+			return nil
-		case specifiedInstances < numTasks:
+		})
-			// Update up to N tasks then remove the extra
+		if err != nil {
-			log.G(ctx).Debugf("Service %s was scaled down from %d to %d instances", service.ID, numTasks, specifiedInstances)
+			log.G(ctx).WithError(err).Errorf("reconcile batch failed")
-			r.updater.Update(ctx, service, runningTasks[:specifiedInstances])
-			r.removeTasks(ctx, batch, service, runningTasks[specifiedInstances:])
-
-		case specifiedInstances == numTasks:
-			// Simple update, no scaling - update all tasks.
-			r.updater.Update(ctx, service, runningTasks)
 		}
-		return nil
-	})
 
-	if err != nil {
+	case specifiedInstances < numTasks:
-		log.G(ctx).WithError(err).Errorf("reconcile batch failed")
+		// Update up to N tasks then remove the extra
+		log.G(ctx).Debugf("Service %s was scaled down from %d to %d instances", service.ID, numTasks, specifiedInstances)
+		r.updater.Update(ctx, service, runningTasks[:specifiedInstances])
+		_, err = r.store.Batch(func(batch *store.Batch) error {
+			r.removeTasks(ctx, batch, service, runningTasks[specifiedInstances:])
+			return nil
+		})
+		if err != nil {
+			log.G(ctx).WithError(err).Errorf("reconcile batch failed")
+		}
+
+	case specifiedInstances == numTasks:
+		// Simple update, no scaling - update all tasks.
+		r.updater.Update(ctx, service, runningTasks)
 	}
 }
 

vendor/src/github.com/docker/swarmkit/manager/scheduler/filter.go

@@ -53,6 +53,9 @@ func (f *ResourceFilter) SetTask(t *api.Task) bool {
 
 // Check returns true if the task can be scheduled into the given node.
 func (f *ResourceFilter) Check(n *NodeInfo) bool {
+	if n.AvailableResources == nil {
+		return false
+	}
 	if f.reservations.NanoCPUs > n.AvailableResources.NanoCPUs {
 		return false
 	}

vendor/src/github.com/docker/swarmkit/manager/scheduler/nodeinfo.go

@@ -6,10 +6,10 @@ import "github.com/docker/swarmkit/api"
 type NodeInfo struct {
 	*api.Node
 	Tasks              map[string]*api.Task
-	AvailableResources api.Resources
+	AvailableResources *api.Resources
 }
 
-func newNodeInfo(n *api.Node, tasks map[string]*api.Task, availableResources api.Resources) NodeInfo {
+func newNodeInfo(n *api.Node, tasks map[string]*api.Task, availableResources *api.Resources) NodeInfo {
 	nodeInfo := NodeInfo{
 		Node:               n,
 		Tasks:              make(map[string]*api.Task),
@@ -31,9 +31,11 @@ func (nodeInfo *NodeInfo) removeTask(t *api.Task) bool {
 	}
 
 	delete(nodeInfo.Tasks, t.ID)
-	reservations := taskReservations(t.Spec)
+	if nodeInfo.AvailableResources != nil {
-	nodeInfo.AvailableResources.MemoryBytes += reservations.MemoryBytes
+		reservations := taskReservations(t.Spec)
-	nodeInfo.AvailableResources.NanoCPUs += reservations.NanoCPUs
+		nodeInfo.AvailableResources.MemoryBytes += reservations.MemoryBytes
+		nodeInfo.AvailableResources.NanoCPUs += reservations.NanoCPUs
+	}
 
 	return true
 }
@@ -47,9 +49,11 @@ func (nodeInfo *NodeInfo) addTask(t *api.Task) bool {
 	}
 	if _, ok := nodeInfo.Tasks[t.ID]; !ok {
 		nodeInfo.Tasks[t.ID] = t
-		reservations := taskReservations(t.Spec)
+		if nodeInfo.AvailableResources != nil {
-		nodeInfo.AvailableResources.MemoryBytes -= reservations.MemoryBytes
+			reservations := taskReservations(t.Spec)
-		nodeInfo.AvailableResources.NanoCPUs -= reservations.NanoCPUs
+			nodeInfo.AvailableResources.MemoryBytes -= reservations.MemoryBytes
+			nodeInfo.AvailableResources.NanoCPUs -= reservations.NanoCPUs
+		}
 		return true
 	}
 

vendor/src/github.com/docker/swarmkit/manager/scheduler/scheduler.go

@@ -242,13 +242,17 @@ func (s *Scheduler) deleteTask(ctx context.Context, t *api.Task) {
 }
 
 func (s *Scheduler) createOrUpdateNode(n *api.Node) {
-	var resources api.Resources
-	if n.Description != nil && n.Description.Resources != nil {
-		resources = *n.Description.Resources
-	}
 	nodeInfo := s.nodeHeap.nodeInfo(n.ID)
+	if n.Description != nil && n.Description.Resources != nil {
+		if nodeInfo.AvailableResources == nil {
+			// if nodeInfo.AvailableResources hasn't been initialized
+			// we copy resources information from node description and
+			// pass it to nodeInfo
+			resources := *n.Description.Resources
+			nodeInfo.AvailableResources = &resources
+		}
+	}
 	nodeInfo.Node = n
-	nodeInfo.AvailableResources = resources
 	s.nodeHeap.addOrUpdateNode(nodeInfo)
 }
 
@@ -418,9 +422,10 @@ func (s *Scheduler) buildNodeHeap(tx store.ReadTx, tasksByNode map[string]map[st
 
 	i := 0
 	for _, n := range nodes {
-		var resources api.Resources
+		var resources *api.Resources
 		if n.Description != nil && n.Description.Resources != nil {
-			resources = *n.Description.Resources
+			resources = &api.Resources{NanoCPUs: n.Description.Resources.NanoCPUs,
+				MemoryBytes: n.Description.Resources.MemoryBytes}
 		}
 		s.nodeHeap.heap = append(s.nodeHeap.heap, newNodeInfo(n, tasksByNode[n.ID], resources))
 		s.nodeHeap.index[n.ID] = i

vendor/src/github.com/docker/swarmkit/manager/state/raft/raft.go

@@ -3,6 +3,7 @@ package raft
 import (
 	"errors"
 	"math"
+	"math/rand"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -22,7 +23,6 @@ import (
 	"github.com/docker/go-events"
 	"github.com/docker/swarmkit/api"
 	"github.com/docker/swarmkit/ca"
-	"github.com/docker/swarmkit/identity"
 	"github.com/docker/swarmkit/log"
 	"github.com/docker/swarmkit/manager/state/raft/membership"
 	"github.com/docker/swarmkit/manager/state/store"
@@ -109,6 +109,8 @@ type Node struct {
 
 	// used to coordinate shutdown
 	stopMu sync.RWMutex
+	// used for membership management checks
+	membershipLock sync.Mutex
 
 	snapshotInProgress chan uint64
 	asyncTasks         sync.WaitGroup
@@ -142,6 +144,10 @@ type NewNodeOptions struct {
 	TLSCredentials credentials.TransportAuthenticator
 }
 
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
 // NewNode generates a new Raft node
 func NewNode(ctx context.Context, opts NewNodeOptions) (*Node, error) {
 	cfg := opts.Config
@@ -152,11 +158,6 @@ func NewNode(ctx context.Context, opts NewNodeOptions) (*Node, error) {
 		opts.TickInterval = time.Second
 	}
 
-	raftID, err := identity.ParseNodeID(opts.ID)
-	if err != nil {
-		return nil, err
-	}
-
 	raftStore := raft.NewMemoryStorage()
 
 	ctx, cancel := context.WithCancel(ctx)
@@ -175,7 +176,6 @@ func NewNode(ctx context.Context, opts NewNodeOptions) (*Node, error) {
 			MaxSizePerMsg:   cfg.MaxSizePerMsg,
 			MaxInflightMsgs: cfg.MaxInflightMsgs,
 			Logger:          cfg.Logger,
-			ID:              raftID,
 		},
 		forceNewCluster:     opts.ForceNewCluster,
 		stopCh:              make(chan struct{}),
@@ -196,9 +196,10 @@ func NewNode(ctx context.Context, opts NewNodeOptions) (*Node, error) {
 		n.sendTimeout = opts.SendTimeout
 	}
 
-	if err := n.loadAndStart(ctx, opts.ForceNewCluster); err != nil {
+	loadAndStartErr := n.loadAndStart(ctx, opts.ForceNewCluster)
+	if loadAndStartErr != nil && loadAndStartErr != errNoWAL {
 		n.ticker.Stop()
-		return nil, err
+		return nil, loadAndStartErr
 	}
 
 	snapshot, err := raftStore.Snapshot()
@@ -213,32 +214,45 @@ func NewNode(ctx context.Context, opts NewNodeOptions) (*Node, error) {
 	n.reqIDGen = idutil.NewGenerator(uint16(n.Config.ID), time.Now())
 	n.wait = newWait()
 
-	if n.startNodePeers != nil {
+	if loadAndStartErr == errNoWAL {
 		if n.joinAddr != "" {
 			c, err := n.ConnectToMember(n.joinAddr, 10*time.Second)
 			if err != nil {
 				return nil, err
 			}
+			client := api.NewRaftMembershipClient(c.Conn)
 			defer func() {
 				_ = c.Conn.Close()
 			}()
 
 			ctx, cancel := context.WithTimeout(n.Ctx, 10*time.Second)
 			defer cancel()
-			resp, err := c.Join(ctx, &api.JoinRequest{
+			resp, err := client.Join(ctx, &api.JoinRequest{
 				Addr: n.Address,
 			})
 			if err != nil {
 				return nil, err
 			}
 
+			n.Config.ID = resp.RaftID
+
+			if _, err := n.createWAL(opts.ID); err != nil {
+				return nil, err
+			}
+
 			n.Node = raft.StartNode(n.Config, []raft.Peer{})
 
 			if err := n.registerNodes(resp.Members); err != nil {
 				return nil, err
 			}
 		} else {
-			n.Node = raft.StartNode(n.Config, n.startNodePeers)
+			// First member in the cluster, self-assign ID
+			n.Config.ID = uint64(rand.Int63()) + 1
+			peer, err := n.createWAL(opts.ID)
+			if err != nil {
+				return nil, err
+			}
+			n.Node = raft.StartNode(n.Config, []raft.Peer{peer})
 			if err := n.Campaign(n.Ctx); err != nil {
 				return nil, err
 			}
@@ -363,6 +377,14 @@ func (n *Node) Run(ctx context.Context) error {
 			// send back an error to the caller to start
 			// the shutdown process.
 			if n.mustStop() {
+				n.stop()
+
+				// Move WAL and snapshot out of the way, since
+				// they are no longer usable.
+				if err := n.moveWALAndSnap(); err != nil {
+					n.Config.Logger.Error(err)
+				}
+
 				return ErrMemberRemoved
 			}
 
@@ -387,7 +409,6 @@ func (n *Node) Run(ctx context.Context) error {
 func (n *Node) Shutdown() {
 	select {
 	case <-n.doneCh:
-		n.stop()
 	default:
 		close(n.stopCh)
 		<-n.doneCh
@@ -409,7 +430,7 @@ func (n *Node) stop() {
 	}
 	n.Stop()
 	if err := n.wal.Close(); err != nil {
-		n.Config.Logger.Error(err)
+		n.Config.Logger.Errorf("raft: error closing WAL: %v", err)
 	}
 	// TODO(stevvooe): Handle ctx.Done()
 }
@@ -446,45 +467,55 @@ func (n *Node) Join(ctx context.Context, req *api.JoinRequest) (*api.JoinRespons
 	}
 	log := log.G(ctx).WithFields(fields)
 
-	raftID, err := identity.ParseNodeID(nodeInfo.NodeID)
-	if err != nil {
-		return nil, err
-	}
-
 	// can't stop the raft node while an async RPC is in progress
 	n.stopMu.RLock()
 	defer n.stopMu.RUnlock()
 
+	n.membershipLock.Lock()
+	defer n.membershipLock.Unlock()
+
 	if n.Node == nil {
 		log.WithError(ErrStopped).Errorf(ErrStopped.Error())
 		return nil, ErrStopped
 	}
 
-	// We submit a configuration change only if the node was not registered yet
+	if !n.IsLeader() {
-	if n.cluster.GetMember(raftID) == nil {
+		return nil, ErrLostLeadership
-		err = n.addMember(ctx, req.Addr, raftID)
+	}
-		if err != nil {
+
-			log.WithError(err).Errorf("failed to add member")
+	// Find a unique ID for the joining member.
-			return nil, err
+	var raftID uint64
+	for {
+		raftID = uint64(rand.Int63()) + 1
+		if n.cluster.GetMember(raftID) == nil && !n.cluster.IsIDRemoved(raftID) {
+			break
 		}
 	}
 
+	err = n.addMember(ctx, req.Addr, raftID, nodeInfo.NodeID)
+	if err != nil {
+		log.WithError(err).Errorf("failed to add member")
+		return nil, err
+	}
+
 	var nodes []*api.RaftMember
 	for _, node := range n.cluster.Members() {
 		nodes = append(nodes, &api.RaftMember{
 			RaftID: node.RaftID,
+			NodeID: node.NodeID,
 			Addr:   node.Addr,
 		})
 	}
 	log.Debugf("node joined")
 
-	return &api.JoinResponse{Members: nodes}, nil
+	return &api.JoinResponse{Members: nodes, RaftID: raftID}, nil
 }
 
 // addMember submits a configuration change to add a new member on the raft cluster.
-func (n *Node) addMember(ctx context.Context, addr string, raftID uint64) error {
+func (n *Node) addMember(ctx context.Context, addr string, raftID uint64, nodeID string) error {
 	node := api.RaftMember{
 		RaftID: raftID,
+		NodeID: nodeID,
 		Addr:   addr,
 	}
 
@@ -531,6 +562,10 @@ func (n *Node) Leave(ctx context.Context, req *api.LeaveRequest) (*api.LeaveResp
 		return nil, ErrStopped
 	}
 
+	if !n.IsLeader() {
+		return nil, ErrLostLeadership
+	}
+
 	err = n.RemoveMember(ctx, req.Node.RaftID)
 	if err != nil {
 		return nil, err
@@ -541,8 +576,9 @@ func (n *Node) Leave(ctx context.Context, req *api.LeaveRequest) (*api.LeaveResp
 
 // RemoveMember submits a configuration change to remove a member from the raft cluster.
 func (n *Node) RemoveMember(ctx context.Context, id uint64) error {
-	// TODO(abronan): this can race if multiple removes are processed, we should
+	n.membershipLock.Lock()
-	// send all the requests to the Leader and track pending removals.
+	defer n.membershipLock.Unlock()
+
 	if n.cluster.CanRemoveMember(n.Config.ID, id) {
 		cc := raftpb.ConfChange{
 			ID:      id,
@@ -600,7 +636,7 @@ func (n *Node) ResolveAddress(ctx context.Context, msg *api.ResolveAddressReques
 
 	member := n.cluster.GetMember(msg.RaftID)
 	if member == nil {
-		return nil, grpc.Errorf(codes.NotFound, "member %s not found", identity.FormatNodeID(msg.RaftID))
+		return nil, grpc.Errorf(codes.NotFound, "member %x not found", msg.RaftID)
 	}
 	return &api.ResolveAddressResponse{Addr: member.Addr}, nil
 }
@@ -630,6 +666,11 @@ func (n *Node) LeaderAddr() (string, error) {
 func (n *Node) registerNode(node *api.RaftMember) error {
 	member := &membership.Member{}
 
+	if n.cluster.GetMember(node.RaftID) != nil {
+		// member already exists
+		return nil
+	}
+
 	// Avoid opening a connection to the local node
 	if node.RaftID != n.Config.ID {
 		// We don't want to impose a timeout on the grpc connection. It
@@ -702,6 +743,7 @@ func (n *Node) GetMemberlist() map[uint64]*api.RaftMember {
 
 		memberlist[id] = &api.RaftMember{
 			RaftID: member.RaftID,
+			NodeID: member.NodeID,
 			Addr:   member.Addr,
 			Status: api.RaftMemberStatus{
 				Leader:       leader,
@@ -787,7 +829,7 @@ func (n *Node) sendToMember(members map[uint64]*membership.Member, m raftpb.Mess
 		// If we are being asked to send to a member that's not in
 		// our member list, that could indicate that the current leader
 		// was added while we were offline. Try to resolve its address.
-		n.Config.Logger.Warningf("sending message to an unrecognized member ID %s", identity.FormatNodeID(m.To))
+		n.Config.Logger.Warningf("sending message to an unrecognized member ID %x", m.To)
 
 		// Choose a random member
 		var (
@@ -807,12 +849,12 @@ func (n *Node) sendToMember(members map[uint64]*membership.Member, m raftpb.Mess
 
 		resp, err := queryMember.ResolveAddress(ctx, &api.ResolveAddressRequest{RaftID: m.To})
 		if err != nil {
-			n.Config.Logger.Errorf("could not resolve address of member ID %s: %v", identity.FormatNodeID(m.To), err)
+			n.Config.Logger.Errorf("could not resolve address of member ID %x: %v", m.To, err)
 			return
 		}
 		conn, err = n.ConnectToMember(resp.Addr, n.sendTimeout)
 		if err != nil {
-			n.Config.Logger.Errorf("could connect to member ID %s at %s: %v", identity.FormatNodeID(m.To), resp.Addr, err)
+			n.Config.Logger.Errorf("could connect to member ID %x at %s: %v", m.To, resp.Addr, err)
 			return
 		}
 		// The temporary connection is only used for this message.

vendor/src/github.com/docker/swarmkit/manager/state/raft/storage.go

@@ -1,6 +1,7 @@
 package raft
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -21,6 +22,8 @@ import (
 	"golang.org/x/net/context"
 )
 
+var errNoWAL = errors.New("no WAL present")
+
 func (n *Node) walDir() string {
 	return filepath.Join(n.StateDir, "wal")
 }
@@ -41,23 +44,7 @@ func (n *Node) loadAndStart(ctx context.Context, forceNewCluster bool) error {
 	n.snapshotter = snap.New(snapDir)
 
 	if !wal.Exist(walDir) {
-		raftNode := &api.RaftMember{
+		return errNoWAL
-			RaftID: n.Config.ID,
-			Addr:   n.Address,
-		}
-		metadata, err := raftNode.Marshal()
-		if err != nil {
-			return fmt.Errorf("error marshalling raft node: %v", err)
-		}
-		n.wal, err = wal.Create(walDir, metadata)
-		if err != nil {
-			return fmt.Errorf("create wal error: %v", err)
-		}
-
-		n.cluster.AddMember(&membership.Member{RaftMember: raftNode})
-		n.startNodePeers = []raft.Peer{{ID: n.Config.ID, Context: metadata}}
-
-		return nil
 	}
 
 	// Load snapshot data
@@ -82,6 +69,49 @@ func (n *Node) loadAndStart(ctx context.Context, forceNewCluster bool) error {
 	return nil
 }
 
+func (n *Node) createWAL(nodeID string) (raft.Peer, error) {
+	raftNode := &api.RaftMember{
+		RaftID: n.Config.ID,
+		NodeID: nodeID,
+		Addr:   n.Address,
+	}
+	metadata, err := raftNode.Marshal()
+	if err != nil {
+		return raft.Peer{}, fmt.Errorf("error marshalling raft node: %v", err)
+	}
+	n.wal, err = wal.Create(n.walDir(), metadata)
+	if err != nil {
+		return raft.Peer{}, fmt.Errorf("create wal error: %v", err)
+	}
+
+	n.cluster.AddMember(&membership.Member{RaftMember: raftNode})
+	return raft.Peer{ID: n.Config.ID, Context: metadata}, nil
+}
+
+// moveWALAndSnap moves away the WAL and snapshot because we were removed
+// from the cluster and will need to recreate them if we are readded.
+func (n *Node) moveWALAndSnap() error {
+	newWALDir, err := ioutil.TempDir(n.StateDir, "wal.")
+	if err != nil {
+		return err
+	}
+	err = os.Rename(n.walDir(), newWALDir)
+	if err != nil {
+		return err
+	}
+
+	newSnapDir, err := ioutil.TempDir(n.StateDir, "snap.")
+	if err != nil {
+		return err
+	}
+	err = os.Rename(n.snapDir(), newSnapDir)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (n *Node) readWAL(ctx context.Context, snapshot *raftpb.Snapshot, forceNewCluster bool) (err error) {
 	var (
 		walsnap  walpb.Snapshot
@@ -238,6 +268,7 @@ func (n *Node) doSnapshot(raftConfig *api.RaftConfig) {
 	for _, member := range n.cluster.Members() {
 		snapshot.Membership.Members = append(snapshot.Membership.Members,
 			&api.RaftMember{
+				NodeID: member.NodeID,
 				RaftID: member.RaftID,
 				Addr:   member.Addr,
 			})
@@ -312,7 +343,7 @@ func (n *Node) restoreFromSnapshot(data []byte, forceNewCluster bool) error {
 
 	if !forceNewCluster {
 		for _, member := range snapshot.Membership.Members {
-			if err := n.registerNode(&api.RaftMember{RaftID: member.RaftID, Addr: member.Addr}); err != nil {
+			if err := n.registerNode(&api.RaftMember{RaftID: member.RaftID, NodeID: member.NodeID, Addr: member.Addr}); err != nil {
 				return err
 			}
 		}

vendor/src/github.com/docker/swarmkit/manager/state/raft/util.go

@@ -29,6 +29,7 @@ func dial(addr string, protocol string, creds credentials.TransportAuthenticator
 // Register registers the node raft server
 func Register(server *grpc.Server, node *Node) {
 	api.RegisterRaftServer(server, node)
+	api.RegisterRaftMembershipServer(server, node)
 }
 
 // WaitForLeader waits until node observe some leader in cluster. It returns