diff --git a/dgraph/cmd/zero/http.go b/dgraph/cmd/zero/http.go
index a92045f39d3..530bb28f0c5 100644
--- a/dgraph/cmd/zero/http.go
+++ b/dgraph/cmd/zero/http.go
@@ -65,7 +65,7 @@ func (st *state) assign(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	num := &pb.Num{Val: uint64(val)}
+	num := &pb.Num{Val: val}
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
@@ -87,7 +87,7 @@ func (st *state) assign(w http.ResponseWriter, r *http.Request) {
 		ids, err = st.zero.AssignIds(ctx, num)
 	default:
 		x.SetStatus(w, x.Error,
-			fmt.Sprintf("Invalid what: [%s]. Must be one of uids or timestamps", what))
+			fmt.Sprintf("Invalid what: [%s]. Must be one of: [uids, timestamps, nsids]", what))
 		return
 	}
 	if err != nil {
@@ -124,7 +124,10 @@ func (st *state) removeNode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if err := st.zero.removeNode(context.Background(), nodeId, uint32(groupId)); err != nil {
+	if _, err := st.zero.RemoveNode(
+		context.Background(),
+		&pb.RemoveNodeRequest{NodeId: nodeId, GroupId: uint32(groupId)},
+	); err != nil {
 		x.SetStatus(w, x.Error, err.Error())
 		return
 	}
@@ -154,8 +157,6 @@ func (st *state) moveTablet(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	tablet := r.URL.Query().Get("tablet")
-
 	namespace := r.URL.Query().Get("namespace")
 	namespace = strings.TrimSpace(namespace)
 	ns := x.GalaxyNamespace
@@ -168,7 +169,7 @@ func (st *state) moveTablet(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	tablet = x.NamespaceAttr(ns, tablet)
+	tablet := r.URL.Query().Get("tablet")
 	if len(tablet) == 0 {
 		w.WriteHeader(http.StatusBadRequest)
 		x.SetStatus(w, x.ErrorInvalidRequest, "tablet is a mandatory query parameter")
@@ -178,50 +179,28 @@ func (st *state) moveTablet(w http.ResponseWriter, r *http.Request) {
 	groupId, ok := intFromQueryParam(w, r, "group")
 	if !ok {
 		w.WriteHeader(http.StatusBadRequest)
-		x.SetStatus(w, x.ErrorInvalidRequest, fmt.Sprintf(
-			"Query parameter 'group' should contain a valid integer."))
-		return
-	}
-	dstGroup := uint32(groupId)
-	knownGroups := st.zero.KnownGroups()
-	var isKnown bool
-	for _, grp := range knownGroups {
-		if grp == dstGroup {
-			isKnown = true
-			break
-		}
-	}
-	if !isKnown {
-		w.WriteHeader(http.StatusBadRequest)
-		x.SetStatus(w, x.ErrorInvalidRequest, fmt.Sprintf("Group: [%d] is not a known group.",
-			dstGroup))
-		return
-	}
-
-	tab := st.zero.ServingTablet(tablet)
-	if tab == nil {
-		w.WriteHeader(http.StatusBadRequest)
-		x.SetStatus(w, x.ErrorInvalidRequest, fmt.Sprintf("No tablet found for: %s", tablet))
-		return
-	}
-
-	srcGroup := tab.GroupId
-	if srcGroup == dstGroup {
-		w.WriteHeader(http.StatusInternalServerError)
 		x.SetStatus(w, x.ErrorInvalidRequest,
-			fmt.Sprintf("Tablet: [%s] is already being served by group: [%d]", tablet, srcGroup))
+			"Query parameter 'group' should contain a valid integer.")
 		return
 	}
+	dstGroup := uint32(groupId)
 
-	if err := st.zero.movePredicate(tablet, srcGroup, dstGroup); err != nil {
-		glog.Errorf("While moving predicate %s from %d -> %d. Error: %v",
-			tablet, srcGroup, dstGroup, err)
-		w.WriteHeader(http.StatusInternalServerError)
-		x.SetStatus(w, x.Error, err.Error())
+	var resp *pb.Status
+	var err error
+	if resp, err = st.zero.MoveTablet(
+		context.Background(),
+		&pb.MoveTabletRequest{Namespace: ns, Tablet: tablet, DstGroup: dstGroup},
+	); err != nil {
+		if resp.GetMsg() == x.ErrorInvalidRequest {
+			w.WriteHeader(http.StatusBadRequest)
+			x.SetStatus(w, x.ErrorInvalidRequest, err.Error())
+		} else {
+			w.WriteHeader(http.StatusInternalServerError)
+			x.SetStatus(w, x.Error, err.Error())
+		}
 		return
 	}
-	_, err := fmt.Fprintf(w, "Predicate: [%s] moved from group [%d] to [%d]",
-		tablet, srcGroup, dstGroup)
+	_, err = fmt.Fprint(w, resp.GetMsg())
 	if err != nil {
 		glog.Warningf("Error while writing response: %+v", err)
 	}
diff --git a/dgraph/cmd/zero/license_ee.go b/dgraph/cmd/zero/license_ee.go
index 4c7c2efddb6..748ae6ecfad 100644
--- a/dgraph/cmd/zero/license_ee.go
+++ b/dgraph/cmd/zero/license_ee.go
@@ -13,7 +13,6 @@
 package zero
 
 import (
-	"bytes"
 	"context"
 	"io/ioutil"
 	"math"
@@ -139,7 +138,7 @@ func (st *state) applyEnterpriseLicense(w http.ResponseWriter, r *http.Request)
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
 	defer cancel()
-	if err := st.zero.applyLicense(ctx, bytes.NewReader(b)); err != nil {
+	if _, err := st.zero.ApplyLicense(ctx, &pb.ApplyLicenseRequest{License: b}); err != nil {
 		w.WriteHeader(http.StatusBadRequest)
 		x.SetStatus(w, x.ErrorInvalidRequest, err.Error())
 		return
@@ -157,7 +156,7 @@ func (s *Server) applyLicenseFile(path string) {
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
 	defer cancel()
-	if err = s.applyLicense(ctx, bytes.NewReader(content)); err != nil {
+	if _, err = s.ApplyLicense(ctx, &pb.ApplyLicenseRequest{License: content}); err != nil {
 		glog.Infof("Unable to apply license at %v due to error %v", path, err)
 	}
 }
diff --git a/dgraph/cmd/zero/run.go b/dgraph/cmd/zero/run.go
index 3b50ba6c990..32bba03d088 100644
--- a/dgraph/cmd/zero/run.go
+++ b/dgraph/cmd/zero/run.go
@@ -99,6 +99,8 @@ instances to achieve high-availability.
 	flag.Duration("rebalance_interval", 8*time.Minute, "Interval for trying a predicate move.")
 	flag.String("enterprise_license", "", "Path to the enterprise license file.")
 	flag.String("cid", "", "Cluster ID")
+	flag.Bool("disable_admin_http", false,
+		"Turn on/off the administrative endpoints exposed over Zero's HTTP port.")
 
 	flag.String("raft", raftDefaults, z.NewSuperFlagHelp(raftDefaults).
 		Head("Raft options").
@@ -302,11 +304,14 @@ func run() {
 	http.Handle("/", audit.AuditRequestHttp(baseMux))
 
 	baseMux.HandleFunc("/health", st.pingResponse)
-	baseMux.HandleFunc("/state", st.getState)
-	baseMux.HandleFunc("/removeNode", st.removeNode)
-	baseMux.HandleFunc("/moveTablet", st.moveTablet)
-	baseMux.HandleFunc("/assign", st.assign)
-	baseMux.HandleFunc("/enterpriseLicense", st.applyEnterpriseLicense)
+	// the following endpoints are disabled only if the flag is explicitly set to true
+	if !Zero.Conf.GetBool("disable_admin_http") {
+		baseMux.HandleFunc("/state", st.getState)
+		baseMux.HandleFunc("/removeNode", st.removeNode)
+		baseMux.HandleFunc("/moveTablet", st.moveTablet)
+		baseMux.HandleFunc("/assign", st.assign)
+		baseMux.HandleFunc("/enterpriseLicense", st.applyEnterpriseLicense)
+	}
 	baseMux.HandleFunc("/debug/jemalloc", x.JemallocHandler)
 	zpages.Handle(baseMux, "/debug/z")
 
diff --git a/dgraph/cmd/zero/tablet.go b/dgraph/cmd/zero/tablet.go
index a6afd909d7d..9135914c35f 100644
--- a/dgraph/cmd/zero/tablet.go
+++ b/dgraph/cmd/zero/tablet.go
@@ -72,6 +72,52 @@ func (s *Server) rebalanceTablets() {
 	}
 }
 
+// MoveTablet can be used to move a tablet to a specific group.
+// It takes in tablet and destination group as argument.
+// It returns a *pb.Status to be used by the `/moveTablet` HTTP handler in Zero.
+func (s *Server) MoveTablet(ctx context.Context, req *pb.MoveTabletRequest) (*pb.Status, error) {
+	if !s.Node.AmLeader() {
+		return &pb.Status{Code: 1, Msg: x.Error}, errNotLeader
+	}
+
+	knownGroups := s.KnownGroups()
+	var isKnown bool
+	for _, grp := range knownGroups {
+		if grp == req.DstGroup {
+			isKnown = true
+			break
+		}
+	}
+	if !isKnown {
+		return &pb.Status{Code: 1, Msg: x.ErrorInvalidRequest},
+			fmt.Errorf("Group: [%d] is not a known group.", req.DstGroup)
+	}
+
+	tablet := x.NamespaceAttr(req.Namespace, req.Tablet)
+	tab := s.ServingTablet(tablet)
+	if tab == nil {
+		return &pb.Status{Code: 1, Msg: x.ErrorInvalidRequest},
+			fmt.Errorf("namespace: %d. No tablet found for: %s", req.Namespace, req.Tablet)
+	}
+
+	srcGroup := tab.GroupId
+	if srcGroup == req.DstGroup {
+		return &pb.Status{Code: 1, Msg: x.ErrorInvalidRequest},
+			fmt.Errorf("namespace: %d. Tablet: [%s] is already being served by group: [%d]",
+				req.Namespace, req.Tablet, srcGroup)
+	}
+
+	if err := s.movePredicate(tablet, srcGroup, req.DstGroup); err != nil {
+		glog.Errorf("namespace: %d. While moving predicate %s from %d -> %d. Error: %v",
+			req.Namespace, req.Tablet, srcGroup, req.DstGroup, err)
+		return &pb.Status{Code: 1, Msg: x.Error}, err
+	}
+
+	return &pb.Status{Code: 0, Msg: fmt.Sprintf("namespace: %d. "+
+		"Predicate: [%s] moved from group [%d] to [%d]", req.Namespace, req.Tablet, srcGroup,
+		req.DstGroup)}, nil
+}
+
 // movePredicate is the main entry point for move predicate logic. This Zero must remain the leader
 // for the entire duration of predicate move. If this Zero stops being the leader, the final
 // proposal of reassigning the tablet to the destination would fail automatically.
diff --git a/dgraph/cmd/zero/zero.go b/dgraph/cmd/zero/zero.go
index 477034ce627..be90f1e727c 100644
--- a/dgraph/cmd/zero/zero.go
+++ b/dgraph/cmd/zero/zero.go
@@ -17,9 +17,9 @@
 package zero
 
 import (
+	"bytes"
 	"context"
 	"crypto/tls"
-	"io"
 	"math"
 	"strings"
 	"sync"
@@ -402,26 +402,32 @@ func (s *Server) createProposals(dst *pb.Group) ([]*pb.ZeroProposal, error) {
 	return res, nil
 }
 
-// removeNode removes the given node from the given group.
+// RemoveNode removes the given node from the given group.
 // It's the user's responsibility to ensure that node doesn't come back again
 // before calling the api.
-func (s *Server) removeNode(ctx context.Context, nodeId uint64, groupId uint32) error {
-	if groupId == 0 {
-		return s.Node.ProposePeerRemoval(ctx, nodeId)
+func (s *Server) RemoveNode(ctx context.Context, req *pb.RemoveNodeRequest) (*pb.Status, error) {
+	if req.GroupId == 0 {
+		return nil, s.Node.ProposePeerRemoval(ctx, req.NodeId)
 	}
 	zp := &pb.ZeroProposal{}
-	zp.Member = &pb.Member{Id: nodeId, GroupId: groupId, AmDead: true}
-	if _, ok := s.state.Groups[groupId]; !ok {
-		return errors.Errorf("No group with groupId %d found", groupId)
+	zp.Member = &pb.Member{Id: req.NodeId, GroupId: req.GroupId, AmDead: true}
+	if _, ok := s.state.Groups[req.GroupId]; !ok {
+		return nil, errors.Errorf("No group with groupId %d found", req.GroupId)
 	}
-	if _, ok := s.state.Groups[groupId].Members[nodeId]; !ok {
-		return errors.Errorf("No node with nodeId %d found in group %d", nodeId, groupId)
+	if _, ok := s.state.Groups[req.GroupId].Members[req.NodeId]; !ok {
+		return nil, errors.Errorf("No node with nodeId %d found in group %d", req.NodeId,
+			req.GroupId)
 	}
-	if len(s.state.Groups[groupId].Members) == 1 && len(s.state.Groups[groupId].Tablets) > 0 {
-		return errors.Errorf("Move all tablets from group %d before removing the last node", groupId)
+	if len(s.state.Groups[req.GroupId].Members) == 1 && len(s.state.Groups[req.GroupId].
+		Tablets) > 0 {
+		return nil, errors.Errorf("Move all tablets from group %d before removing the last node",
+			req.GroupId)
+	}
+	if err := s.Node.proposeAndWait(ctx, zp); err != nil {
+		return nil, err
 	}
 
-	return s.Node.proposeAndWait(ctx, zp)
+	return &pb.Status{}, nil
 }
 
 // Connect is used by Alpha nodes to connect the very first time with group zero.
@@ -802,10 +808,12 @@ func (s *Server) latestMembershipState(ctx context.Context) (*pb.MembershipState
 	return ms, nil
 }
 
-func (s *Server) applyLicense(ctx context.Context, signedData io.Reader) error {
+func (s *Server) ApplyLicense(ctx context.Context, req *pb.ApplyLicenseRequest) (*pb.Status,
+	error) {
 	var l license
+	signedData := bytes.NewReader(req.License)
 	if err := verifySignature(signedData, strings.NewReader(publicKey), &l); err != nil {
-		return errors.Wrapf(err, "while extracting enterprise details from the license")
+		return nil, errors.Wrapf(err, "while extracting enterprise details from the license")
 	}
 
 	numNodes := len(s.state.GetZeros())
@@ -813,8 +821,8 @@ func (s *Server) applyLicense(ctx context.Context, signedData io.Reader) error {
 		numNodes += len(group.GetMembers())
 	}
 	if uint64(numNodes) > l.MaxNodes {
-		return errors.Errorf("Your license only allows [%v] (Alpha + Zero) nodes. You have: [%v].",
-			l.MaxNodes, numNodes)
+		return nil, errors.Errorf("Your license only allows [%v] (Alpha + Zero) nodes. "+
+			"You have: [%v].", l.MaxNodes, numNodes)
 	}
 
 	proposal := &pb.ZeroProposal{
@@ -827,8 +835,8 @@ func (s *Server) applyLicense(ctx context.Context, signedData io.Reader) error {
 
 	err := s.Node.proposeAndWait(ctx, proposal)
 	if err != nil {
-		return errors.Wrapf(err, "while proposing enterprise license state to cluster")
+		return nil, errors.Wrapf(err, "while proposing enterprise license state to cluster")
 	}
 	glog.Infof("Enterprise license proposed to the cluster %+v", proposal)
-	return nil
+	return &pb.Status{}, nil
 }
diff --git a/dgraph/cmd/zero/zero_test.go b/dgraph/cmd/zero/zero_test.go
index c3d88adc118..e6938a440ff 100644
--- a/dgraph/cmd/zero/zero_test.go
+++ b/dgraph/cmd/zero/zero_test.go
@@ -30,8 +30,8 @@ func TestRemoveNode(t *testing.T) {
 			Groups: map[uint32]*pb.Group{1: {Members: map[uint64]*pb.Member{}}},
 		},
 	}
-	err := server.removeNode(context.TODO(), 3, 1)
+	_, err := server.RemoveNode(context.TODO(), &pb.RemoveNodeRequest{NodeId: 3, GroupId: 1})
 	require.Error(t, err)
-	err = server.removeNode(context.TODO(), 1, 2)
+	_, err = server.RemoveNode(context.TODO(), &pb.RemoveNodeRequest{NodeId: 1, GroupId: 2})
 	require.Error(t, err)
 }
diff --git a/ee/acl/acl_test.go b/ee/acl/acl_test.go
index 687085b54f7..a81cece1a82 100644
--- a/ee/acl/acl_test.go
+++ b/ee/acl/acl_test.go
@@ -2736,6 +2736,70 @@ func TestGuardianOnlyAccessForAdminEndpoints(t *testing.T) {
 			guardianErr:        "The uri path: \"\" doesn't exist",
 			guardianData:       `{"restore": {"code": "Failure"}}`,
 		},
+		{
+			name: "removeNode has guardian auth",
+			query: `
+					mutation {
+					  removeNode(input: {nodeId: 1, groupId: 2147483640}) {
+						response {
+							code
+						}
+					  }
+					}`,
+			queryName:          "removeNode",
+			testGuardianAccess: true,
+			guardianErr:        "No group with groupId 2147483640 found",
+			guardianData:       `{"removeNode": null}`,
+		},
+		{
+			name: "moveTablet has guardian auth",
+			query: `
+					mutation {
+					  moveTablet(input: {tablet: "non_existent_pred", groupId: 2147483640}) {
+						response {
+							code
+							message
+						}
+					  }
+					}`,
+			queryName:          "moveTablet",
+			testGuardianAccess: true,
+			guardianErr:        "Group: [2147483640] is not a known group.",
+			guardianData:       `{"moveTablet": null}`,
+		},
+		{
+			name: "assign has guardian auth",
+			query: `
+					mutation {
+					  assign(input: {what: UID, num: 0}) {
+						response {
+							startId
+							endId
+							readOnly
+						}
+					  }
+					}`,
+			queryName:          "assign",
+			testGuardianAccess: true,
+			guardianErr:        "Nothing to be leased",
+			guardianData:       `{"assign": null}`,
+		},
+		{
+			name: "enterpriseLicense has guardian auth",
+			query: `
+					mutation {
+					  enterpriseLicense(input: {license: ""}) {
+						response {
+							code
+						}
+					  }
+					}`,
+			queryName:          "enterpriseLicense",
+			testGuardianAccess: true,
+			guardianErr: "while extracting enterprise details from the license: while decoding" +
+				" license file: EOF",
+			guardianData: `{"enterpriseLicense": null}`,
+		},
 		{
 			name: "getGQLSchema has guardian auth",
 			query: `
diff --git a/graphql/admin/admin.go b/graphql/admin/admin.go
index 1d808afd903..33ef7068491 100644
--- a/graphql/admin/admin.go
+++ b/graphql/admin/admin.go
@@ -53,7 +53,7 @@ const (
 	scalar Int64
 
     """
-	The UInt64 scalar type represents a unsigned 64‐bit numeric non‐fractional value.
+	The UInt64 scalar type represents an unsigned 64‐bit numeric non‐fractional value.
 	UInt64 can represent values in range [0,(2^64 - 1)].
 	""" 
     scalar UInt64
@@ -284,6 +284,82 @@ const (
 		cacheMb: Float
 	}
 
+	input RemoveNodeInput {
+		"""
+		ID of the node to be removed.
+		"""
+		nodeId: UInt64!
+
+		"""
+		ID of the group from which the node is to be removed.
+		"""
+		groupId: UInt64!
+	}
+
+	type RemoveNodePayload {
+		response: Response
+	}
+
+	input MoveTabletInput {
+		"""
+		Namespace in which the predicate exists.
+		"""
+		namespace: UInt64
+
+		"""
+		Name of the predicate to move.
+		"""
+		tablet: String!
+
+		"""
+		ID of the destination group where the predicate is to be moved.
+		"""
+		groupId: UInt64!
+	}
+
+	type MoveTabletPayload {
+		response: Response
+	}
+
+	enum AssignKind {
+		UID
+		TIMESTAMP
+		NAMESPACE_ID
+	}
+
+	input AssignInput {
+		"""
+		Choose what to assign: UID, TIMESTAMP or NAMESPACE_ID.
+		"""
+		what: AssignKind!
+
+		"""
+		How many to assign.
+		"""
+		num: UInt64!
+	}
+
+	type AssignedIds {
+		"""
+		The first UID, TIMESTAMP or NAMESPACE_ID assigned.
+		"""
+		startId: UInt64
+
+		"""
+		The last UID, TIMESTAMP or NAMESPACE_ID assigned.
+		"""
+		endId: UInt64
+
+		"""
+		TIMESTAMP for read-only transactions.
+		"""
+		readOnly: UInt64
+	}
+
+	type AssignPayload {
+		response: AssignedIds
+	}
+
 	` + adminTypes + `
 
 	type Query {
@@ -324,82 +400,113 @@ const (
 		"""
 		config(input: ConfigInput!): ConfigPayload
 
+		"""
+		Remove a node from the cluster.
+		"""
+		removeNode(input: RemoveNodeInput!): RemoveNodePayload
+
+		"""
+		Move a predicate from one group to another.
+		"""
+		moveTablet(input: MoveTabletInput!): MoveTabletPayload
+
+		"""
+		Lease UIDs, Timestamps or Namespace IDs in advance.
+		"""
+		assign(input: AssignInput!): AssignPayload
+
 		` + adminMutations + `
 	}
  `
 )
 
 var (
-	// guardianOfTheGalaxyQueryMWs are the middlewares which should be applied to queries served by
+	// gogQryMWs are the middlewares which should be applied to queries served by
 	// admin server for guardian of galaxy unless some exceptional behaviour is required
-	guardianOfTheGalaxyQueryMWs = resolve.QueryMiddlewares{
+	gogQryMWs = resolve.QueryMiddlewares{
 		resolve.IpWhitelistingMW4Query,
 		resolve.GuardianOfTheGalaxyAuthMW4Query,
 		resolve.LoggingMWQuery,
 	}
-	// guardianOfTheGalaxyMutationMWs are the middlewares which should be applied to mutations
+	// gogMutMWs are the middlewares which should be applied to mutations
 	// served by admin server for guardian of galaxy unless some exceptional behaviour is required
-	guardianOfTheGalaxyMutationMWs = resolve.MutationMiddlewares{
+	gogMutMWs = resolve.MutationMiddlewares{
 		resolve.IpWhitelistingMW4Mutation,
 		resolve.GuardianOfTheGalaxyAuthMW4Mutation,
 		resolve.LoggingMWMutation,
 	}
-	// guardianOfTheGalaxyMutaionWithAclMWs are the middlewares which should be applied to mutations
+	// gogAclMutMWs are the middlewares which should be applied to mutations
 	// served by the admin server for guardian of galaxy with ACL enabled.
-	guardianOfTheGalaxyMutaionWithAclMWs = resolve.MutationMiddlewares{
+	gogAclMutMWs = resolve.MutationMiddlewares{
 		resolve.IpWhitelistingMW4Mutation,
 		resolve.AclOnlyMW4Mutation,
 		resolve.GuardianOfTheGalaxyAuthMW4Mutation,
 		resolve.LoggingMWMutation,
 	}
-	// commonAdminQueryMWs are the middlewares which should be applied to queries served by admin
+	// stdAdminQryMWs are the middlewares which should be applied to queries served by admin
 	// server unless some exceptional behaviour is required
-	commonAdminQueryMWs = resolve.QueryMiddlewares{
+	stdAdminQryMWs = resolve.QueryMiddlewares{
 		resolve.IpWhitelistingMW4Query, // good to apply ip whitelisting before Guardian auth
 		resolve.GuardianAuthMW4Query,
 		resolve.LoggingMWQuery,
 	}
-	// commonAdminMutationMWs are the middlewares which should be applied to mutations served by
+	// stdAdminMutMWs are the middlewares which should be applied to mutations served by
 	// admin server unless some exceptional behaviour is required
-	commonAdminMutationMWs = resolve.MutationMiddlewares{
+	stdAdminMutMWs = resolve.MutationMiddlewares{
 		resolve.IpWhitelistingMW4Mutation, // good to apply ip whitelisting before Guardian auth
 		resolve.GuardianAuthMW4Mutation,
 		resolve.LoggingMWMutation,
 	}
+	// minimalAdminQryMWs is the minimal set of middlewares that should be applied to any query
+	// served by the admin server
+	minimalAdminQryMWs = resolve.QueryMiddlewares{
+		resolve.IpWhitelistingMW4Query,
+		resolve.LoggingMWQuery,
+	}
+	// minimalAdminMutMWs is the minimal set of middlewares that should be applied to any mutation
+	// served by the admin server
+	minimalAdminMutMWs = resolve.MutationMiddlewares{
+		resolve.IpWhitelistingMW4Mutation,
+		resolve.LoggingMWMutation,
+	}
 	adminQueryMWConfig = map[string]resolve.QueryMiddlewares{
-		"health":       {resolve.IpWhitelistingMW4Query, resolve.LoggingMWQuery}, // dgraph checks Guardian auth for health
-		"state":        {resolve.IpWhitelistingMW4Query, resolve.LoggingMWQuery}, // dgraph checks Guardian auth for state
-		"config":       commonAdminQueryMWs,
-		"listBackups":  guardianOfTheGalaxyQueryMWs,
-		"getGQLSchema": commonAdminQueryMWs,
+		"health":       minimalAdminQryMWs, // dgraph checks Guardian auth for health
+		"state":        minimalAdminQryMWs, // dgraph checks Guardian auth for state
+		"config":       stdAdminQryMWs,
+		"listBackups":  gogQryMWs,
+		"getGQLSchema": stdAdminQryMWs,
 		// for queries and mutations related to User/Group, dgraph handles Guardian auth,
 		// so no need to apply GuardianAuth Middleware
-		"queryUser":      {resolve.IpWhitelistingMW4Query, resolve.LoggingMWQuery},
-		"queryGroup":     {resolve.IpWhitelistingMW4Query, resolve.LoggingMWQuery},
-		"getUser":        {resolve.IpWhitelistingMW4Query, resolve.LoggingMWQuery},
-		"getCurrentUser": {resolve.IpWhitelistingMW4Query, resolve.LoggingMWQuery},
-		"getGroup":       {resolve.IpWhitelistingMW4Query, resolve.LoggingMWQuery},
+		"queryUser":      minimalAdminQryMWs,
+		"queryGroup":     minimalAdminQryMWs,
+		"getUser":        minimalAdminQryMWs,
+		"getCurrentUser": minimalAdminQryMWs,
+		"getGroup":       minimalAdminQryMWs,
 	}
 	adminMutationMWConfig = map[string]resolve.MutationMiddlewares{
-		"backup":          guardianOfTheGalaxyMutationMWs,
-		"config":          guardianOfTheGalaxyMutationMWs,
-		"draining":        guardianOfTheGalaxyMutationMWs,
-		"export":          commonAdminMutationMWs, // dgraph handles the export for other namespaces by guardian of galaxy
-		"login":           {resolve.IpWhitelistingMW4Mutation, resolve.LoggingMWMutation},
-		"restore":         guardianOfTheGalaxyMutationMWs,
-		"shutdown":        guardianOfTheGalaxyMutationMWs,
-		"updateGQLSchema": commonAdminMutationMWs,
-		"addNamespace":    guardianOfTheGalaxyMutaionWithAclMWs,
-		"deleteNamespace": guardianOfTheGalaxyMutaionWithAclMWs,
-		"resetPassword":   guardianOfTheGalaxyMutaionWithAclMWs,
+		"backup":            gogMutMWs,
+		"config":            gogMutMWs,
+		"draining":          gogMutMWs,
+		"export":            stdAdminMutMWs, // dgraph handles the export for other namespaces by guardian of galaxy
+		"login":             minimalAdminMutMWs,
+		"restore":           gogMutMWs,
+		"shutdown":          gogMutMWs,
+		"removeNode":        gogMutMWs,
+		"moveTablet":        gogMutMWs,
+		"assign":            gogMutMWs,
+		"enterpriseLicense": gogMutMWs,
+		"updateGQLSchema":   stdAdminMutMWs,
+		"addNamespace":      gogAclMutMWs,
+		"deleteNamespace":   gogAclMutMWs,
+		"resetPassword":     gogAclMutMWs,
 		// for queries and mutations related to User/Group, dgraph handles Guardian auth,
 		// so no need to apply GuardianAuth Middleware
-		"addUser":     {resolve.IpWhitelistingMW4Mutation, resolve.LoggingMWMutation},
-		"addGroup":    {resolve.IpWhitelistingMW4Mutation, resolve.LoggingMWMutation},
-		"updateUser":  {resolve.IpWhitelistingMW4Mutation, resolve.LoggingMWMutation},
-		"updateGroup": {resolve.IpWhitelistingMW4Mutation, resolve.LoggingMWMutation},
-		"deleteUser":  {resolve.IpWhitelistingMW4Mutation, resolve.LoggingMWMutation},
-		"deleteGroup": {resolve.IpWhitelistingMW4Mutation, resolve.LoggingMWMutation},
+		"addUser":     minimalAdminMutMWs,
+		"addGroup":    minimalAdminMutMWs,
+		"updateUser":  minimalAdminMutMWs,
+		"updateGroup": minimalAdminMutMWs,
+		"deleteUser":  minimalAdminMutMWs,
+		"deleteGroup": minimalAdminMutMWs,
 	}
 	// mainHealthStore stores the health of the main GraphQL server.
 	mainHealthStore = &GraphQLHealthStore{}
@@ -613,16 +720,20 @@ func newAdminResolver(
 func newAdminResolverFactory() resolve.ResolverFactory {
 
 	adminMutationResolvers := map[string]resolve.MutationResolverFunc{
-		"addNamespace":    resolveAddNamespace,
-		"backup":          resolveBackup,
-		"config":          resolveUpdateConfig,
-		"deleteNamespace": resolveDeleteNamespace,
-		"draining":        resolveDraining,
-		"export":          resolveExport,
-		"login":           resolveLogin,
-		"resetPassword":   resolveResetPassword,
-		"restore":         resolveRestore,
-		"shutdown":        resolveShutdown,
+		"addNamespace":      resolveAddNamespace,
+		"backup":            resolveBackup,
+		"config":            resolveUpdateConfig,
+		"deleteNamespace":   resolveDeleteNamespace,
+		"draining":          resolveDraining,
+		"export":            resolveExport,
+		"login":             resolveLogin,
+		"resetPassword":     resolveResetPassword,
+		"restore":           resolveRestore,
+		"shutdown":          resolveShutdown,
+		"removeNode":        resolveRemoveNode,
+		"moveTablet":        resolveMoveTablet,
+		"assign":            resolveAssign,
+		"enterpriseLicense": resolveEnterpriseLicense,
 	}
 
 	rf := resolverFactoryWithErrorMsg(errResolverNotFound).
@@ -919,6 +1030,10 @@ func LazyLoadSchema(namespace uint64) {
 	adminServerVar.lazyLoadSchema(namespace)
 }
 
+func inputArgError(err error) error {
+	return schema.GQLWrapf(err, "couldn't parse input argument")
+}
+
 func response(code, msg string) map[string]interface{} {
 	return map[string]interface{}{
 		"response": map[string]interface{}{"code": code, "message": msg}}
diff --git a/graphql/admin/assign.go b/graphql/admin/assign.go
new file mode 100644
index 00000000000..1d77c11d6c9
--- /dev/null
+++ b/graphql/admin/assign.go
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2020 Dgraph Labs, Inc. and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package admin
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+
+	"github.com/pkg/errors"
+
+	"github.com/dgraph-io/dgraph/graphql/resolve"
+	"github.com/dgraph-io/dgraph/graphql/schema"
+	"github.com/dgraph-io/dgraph/protos/pb"
+	"github.com/dgraph-io/dgraph/worker"
+)
+
+const (
+	uid         = "UID"
+	timestamp   = "TIMESTAMP"
+	namespaceId = "NAMESPACE_ID"
+)
+
+type assignInput struct {
+	What string
+	Num  uint64
+}
+
+func resolveAssign(ctx context.Context, m schema.Mutation) (*resolve.Resolved, bool) {
+	input, err := getAssignInput(m)
+	if err != nil {
+		return resolve.EmptyResult(m, err), false
+	}
+
+	var resp *pb.AssignedIds
+	num := &pb.Num{Val: input.Num}
+	switch input.What {
+	case uid:
+		resp, err = worker.AssignUidsOverNetwork(ctx, num)
+	case timestamp:
+		if num.Val == 0 {
+			num.ReadOnly = true
+		}
+		resp, err = worker.Timestamps(ctx, num)
+	case namespaceId:
+		resp, err = worker.AssignNsIdsOverNetwork(ctx, num)
+	}
+	if err != nil {
+		return resolve.EmptyResult(m, err), false
+	}
+
+	var startId, endId, readOnly interface{}
+	// if it was readonly TIMESTAMP request, then let other output fields be `null`,
+	// otherwise, let readOnly field remain `null`.
+	if input.What == timestamp && num.Val == 0 {
+		readOnly = json.Number(strconv.FormatUint(resp.GetReadOnly(), 10))
+	} else {
+		startId = json.Number(strconv.FormatUint(resp.GetStartId(), 10))
+		endId = json.Number(strconv.FormatUint(resp.GetEndId(), 10))
+	}
+
+	return resolve.DataResult(m,
+		map[string]interface{}{m.Name(): map[string]interface{}{
+			"response": map[string]interface{}{
+				"startId":  startId,
+				"endId":    endId,
+				"readOnly": readOnly,
+			},
+		}},
+		nil,
+	), true
+}
+
+func getAssignInput(m schema.Mutation) (*assignInput, error) {
+	inputArg, ok := m.ArgValue(schema.InputArgName).(map[string]interface{})
+	if !ok {
+		return nil, inputArgError(errors.Errorf("can't convert input to map"))
+	}
+
+	inputRef := &assignInput{}
+	inputRef.What, ok = inputArg["what"].(string)
+	if !ok {
+		return nil, inputArgError(errors.Errorf("can't convert input.what to string"))
+	}
+
+	num, err := parseAsUint64(inputArg["num"])
+	if err != nil {
+		return nil, inputArgError(schema.GQLWrapf(err, "can't convert input.num to uint64"))
+	}
+	inputRef.Num = num
+
+	return inputRef, nil
+}
diff --git a/graphql/admin/endpoints_ee.go b/graphql/admin/endpoints_ee.go
index a557e099a68..819caa93da4 100644
--- a/graphql/admin/endpoints_ee.go
+++ b/graphql/admin/endpoints_ee.go
@@ -432,6 +432,17 @@ const adminTypes = `
 		message: String
 		namespace: UInt64
 	}
+
+	input EnterpriseLicenseInput {
+		"""
+		The contents of license file as a String.
+		"""
+		license: String!
+	}
+
+	type EnterpriseLicensePayload {
+		response: Response
+	}
 	`
 
 const adminMutations = `
@@ -499,6 +510,11 @@ const adminMutations = `
 	any user in any namespace.
 	"""
 	resetPassword(input: ResetPasswordInput!): ResetPasswordPayload
+
+	"""
+	Apply enterprise license.
+	"""
+	enterpriseLicense(input: EnterpriseLicenseInput!): EnterpriseLicensePayload
 	`
 
 const adminQueries = `
diff --git a/graphql/admin/enterpriseLicense.go b/graphql/admin/enterpriseLicense.go
new file mode 100644
index 00000000000..6270287ebc6
--- /dev/null
+++ b/graphql/admin/enterpriseLicense.go
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2020 Dgraph Labs, Inc. and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package admin
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/dgraph-io/dgraph/graphql/resolve"
+	"github.com/dgraph-io/dgraph/graphql/schema"
+	"github.com/dgraph-io/dgraph/protos/pb"
+	"github.com/dgraph-io/dgraph/worker"
+)
+
+type enterpriseLicenseInput struct {
+	License string
+}
+
+func resolveEnterpriseLicense(ctx context.Context, m schema.Mutation) (*resolve.Resolved, bool) {
+	input, err := getEnterpriseLicenseInput(m)
+	if err != nil {
+		return resolve.EmptyResult(m, err), false
+	}
+
+	if _, err = worker.ApplyLicenseOverNetwork(
+		ctx,
+		&pb.ApplyLicenseRequest{License: []byte(input.License)},
+	); err != nil {
+		return resolve.EmptyResult(m, err), false
+	}
+
+	return resolve.DataResult(m,
+		map[string]interface{}{m.Name(): response("Success", "License applied.")},
+		nil,
+	), true
+}
+
+func getEnterpriseLicenseInput(m schema.Mutation) (*enterpriseLicenseInput, error) {
+	inputArg := m.ArgValue(schema.InputArgName)
+	inputBytes, err := json.Marshal(inputArg)
+	if err != nil {
+		return nil, inputArgError(err)
+	}
+
+	var input enterpriseLicenseInput
+	err = schema.Unmarshal(inputBytes, &input)
+	return &input, inputArgError(err)
+}
diff --git a/graphql/admin/moveTablet.go b/graphql/admin/moveTablet.go
new file mode 100644
index 00000000000..6665be1f968
--- /dev/null
+++ b/graphql/admin/moveTablet.go
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2020 Dgraph Labs, Inc. and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package admin
+
+import (
+	"context"
+
+	"github.com/dgraph-io/dgraph/x"
+
+	"github.com/pkg/errors"
+
+	"github.com/dgraph-io/dgraph/graphql/resolve"
+	"github.com/dgraph-io/dgraph/graphql/schema"
+	"github.com/dgraph-io/dgraph/protos/pb"
+	"github.com/dgraph-io/dgraph/worker"
+)
+
+type moveTabletInput struct {
+	Namespace uint64
+	Tablet    string
+	GroupId   uint32
+}
+
+func resolveMoveTablet(ctx context.Context, m schema.Mutation) (*resolve.Resolved, bool) {
+	input, err := getMoveTabletInput(m)
+	if err != nil {
+		return resolve.EmptyResult(m, err), false
+	}
+
+	// gRPC call returns a nil status if the error is non-nil
+	status, err := worker.MoveTabletOverNetwork(ctx, &pb.MoveTabletRequest{
+		Namespace: input.Namespace,
+		Tablet:    input.Tablet,
+		DstGroup:  input.GroupId,
+	})
+	if err != nil {
+		return resolve.EmptyResult(m, err), false
+	}
+
+	return resolve.DataResult(m,
+		map[string]interface{}{m.Name(): response("Success", status.GetMsg())},
+		nil,
+	), true
+}
+
+func getMoveTabletInput(m schema.Mutation) (*moveTabletInput, error) {
+	inputArg, ok := m.ArgValue(schema.InputArgName).(map[string]interface{})
+	if !ok {
+		return nil, inputArgError(errors.Errorf("can't convert input to map"))
+	}
+
+	inputRef := &moveTabletInput{}
+	// namespace is an optional parameter
+	if _, ok = inputArg["namespace"]; !ok {
+		inputRef.Namespace = x.GalaxyNamespace
+	} else {
+		ns, err := parseAsUint64(inputArg["namespace"])
+		if err != nil {
+			return nil, inputArgError(schema.GQLWrapf(err,
+				"can't convert input.namespace to uint64"))
+		}
+		inputRef.Namespace = ns
+	}
+
+	inputRef.Tablet, ok = inputArg["tablet"].(string)
+	if !ok {
+		return nil, inputArgError(errors.Errorf("can't convert input.tablet to string"))
+	}
+
+	gId, err := parseAsUint32(inputArg["groupId"])
+	if err != nil {
+		return nil, inputArgError(schema.GQLWrapf(err, "can't convert input.groupId to uint32"))
+	}
+	inputRef.GroupId = gId
+
+	return inputRef, nil
+}
diff --git a/graphql/admin/removeNode.go b/graphql/admin/removeNode.go
new file mode 100644
index 00000000000..d0146c7005c
--- /dev/null
+++ b/graphql/admin/removeNode.go
@@ -0,0 +1,101 @@
+/*
+ * Copyright 2020 Dgraph Labs, Inc. and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package admin
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+
+	"github.com/pkg/errors"
+
+	"github.com/dgraph-io/dgraph/graphql/resolve"
+	"github.com/dgraph-io/dgraph/graphql/schema"
+	"github.com/dgraph-io/dgraph/protos/pb"
+	"github.com/dgraph-io/dgraph/worker"
+)
+
+type removeNodeInput struct {
+	NodeId  uint64
+	GroupId uint32
+}
+
+func resolveRemoveNode(ctx context.Context, m schema.Mutation) (*resolve.Resolved, bool) {
+	input, err := getRemoveNodeInput(m)
+	if err != nil {
+		return resolve.EmptyResult(m, err), false
+	}
+
+	if _, err = worker.RemoveNodeOverNetwork(ctx, &pb.RemoveNodeRequest{NodeId: input.NodeId,
+		GroupId: input.GroupId}); err != nil {
+		return resolve.EmptyResult(m, err), false
+	}
+
+	return resolve.DataResult(m,
+		map[string]interface{}{m.Name(): response("Success",
+			fmt.Sprintf("Removed node with group: %v, idx: %v", input.GroupId, input.NodeId))},
+		nil,
+	), true
+}
+
+func getRemoveNodeInput(m schema.Mutation) (*removeNodeInput, error) {
+	inputArg, ok := m.ArgValue(schema.InputArgName).(map[string]interface{})
+	if !ok {
+		return nil, inputArgError(errors.Errorf("can't convert input to map"))
+	}
+
+	inputRef := &removeNodeInput{}
+	nodeId, err := parseAsUint64(inputArg["nodeId"])
+	if err != nil {
+		return nil, inputArgError(schema.GQLWrapf(err, "can't convert input.nodeId to uint64"))
+	}
+	inputRef.NodeId = nodeId
+
+	gId, err := parseAsUint32(inputArg["groupId"])
+	if err != nil {
+		return nil, inputArgError(schema.GQLWrapf(err, "can't convert input.groupId to uint32"))
+	}
+	inputRef.GroupId = gId
+
+	return inputRef, nil
+}
+
+func parseAsUint64(val interface{}) (uint64, error) {
+	return parseAsUint(val, 64)
+}
+
+func parseAsUint32(val interface{}) (uint32, error) {
+	ret, err := parseAsUint(val, 32)
+	return uint32(ret), err
+}
+
+func parseAsUint(val interface{}, bitSize int) (uint64, error) {
+	ret := uint64(0)
+	var err error
+
+	switch v := val.(type) {
+	case string:
+		ret, err = strconv.ParseUint(v, 10, bitSize)
+	case json.Number:
+		ret, err = strconv.ParseUint(v.String(), 10, bitSize)
+	default:
+		err = errors.Errorf("got unexpected value type")
+	}
+
+	return ret, err
+}
diff --git a/graphql/schema/completion.go b/graphql/schema/completion.go
index d5b323fc24c..de8119ee592 100644
--- a/graphql/schema/completion.go
+++ b/graphql/schema/completion.go
@@ -331,7 +331,7 @@ func mismatched(path []interface{}, field Field) ([]byte, x.GqlErrorList) {
 // defined in the GraphQL spec. If this is not possible, then it returns an error. The crux of
 // coercion rules defined in the spec is to not lose information during coercion.
 // Note that, admin server specifically uses these:
-//  * json.Number (Query.config.cacheMb)
+//  * json.Number
 //  * schema.Unmarshal() everywhere else
 // And, @custom(http: {...}) query/mutation would always use schema.Unmarshal().
 // Now, schema.Unmarshal() can only give one of the following types for scalars:
diff --git a/graphql/schema/validation_rules.go b/graphql/schema/validation_rules.go
index c17b5ff8da4..b3f197bd69a 100644
--- a/graphql/schema/validation_rules.go
+++ b/graphql/schema/validation_rules.go
@@ -175,6 +175,20 @@ func intRangeCheck(observers *validator.Events, addError validator.AddErrFunc) {
 				addError(validator.Message("Type mismatched for Value `%s`, expected: Int64, got: '%s'", value.Raw,
 					valueKindToString(value.Kind)), validator.At(value.Position))
 			}
+		case "UInt64":
+			// UInt64 exists only in admin schema
+			if value.Kind == ast.IntValue || value.Kind == ast.StringValue {
+				_, err := strconv.ParseUint(value.Raw, 10, 64)
+				if err != nil {
+					addError(validator.Message(err.Error()), validator.At(value.Position))
+				}
+				// UInt64 values parsed from query text would be propagated as strings internally
+				value.Kind = ast.StringValue
+			} else {
+				addError(validator.Message("Type mismatched for Value `%s`, expected: UInt64, "+
+					"got: '%s'", value.Raw,
+					valueKindToString(value.Kind)), validator.At(value.Position))
+			}
 		}
 	})
 }
diff --git a/protos/pb.proto b/protos/pb.proto
index 86e11f9bd57..06c58eafd97 100644
--- a/protos/pb.proto
+++ b/protos/pb.proto
@@ -535,6 +535,9 @@ service Zero {
 	rpc CommitOrAbort (api.TxnContext) returns (api.TxnContext) {}
 	rpc TryAbort (TxnTimestamps)       returns (OracleDelta) {}
 	rpc DeleteNamespace(DeleteNsRequest) returns (Status) {}
+	rpc RemoveNode (RemoveNodeRequest) returns (Status) {}
+	rpc MoveTablet (MoveTabletRequest) returns (Status) {}
+	rpc ApplyLicense (ApplyLicenseRequest) returns (Status) {}
 }
 
 service Worker {
@@ -583,6 +586,21 @@ message AssignedIds {
 	uint64 read_only = 5;
 }
 
+message RemoveNodeRequest {
+	uint64 nodeId = 1;
+	uint32 groupId = 2;
+}
+
+message MoveTabletRequest {
+	uint64 namespace = 1;
+	string tablet = 2;
+	uint32 dstGroup = 3;
+}
+
+message ApplyLicenseRequest {
+    bytes license = 1;
+}
+
 message SnapshotMeta {
 	uint64 client_ts = 1;
 	uint32 group_id = 2;
diff --git a/protos/pb/pb.pb.go b/protos/pb/pb.pb.go
index cf377e29f74..431f669971d 100644
--- a/protos/pb/pb.pb.go
+++ b/protos/pb/pb.pb.go
@@ -286,7 +286,7 @@ func (x DropOperation_DropOp) String() string {
 }
 
 func (DropOperation_DropOp) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{56, 0}
+	return fileDescriptor_f80abaa17e25ccc8, []int{59, 0}
 }
 
 type BackupKey_KeyType int32
@@ -329,7 +329,7 @@ func (x BackupKey_KeyType) String() string {
 }
 
 func (BackupKey_KeyType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{59, 0}
+	return fileDescriptor_f80abaa17e25ccc8, []int{62, 0}
 }
 
 type List struct {
@@ -4176,6 +4176,162 @@ func (m *AssignedIds) GetReadOnly() uint64 {
 	return 0
 }
 
+type RemoveNodeRequest struct {
+	NodeId  uint64 `protobuf:"varint,1,opt,name=nodeId,proto3" json:"nodeId,omitempty"`
+	GroupId uint32 `protobuf:"varint,2,opt,name=groupId,proto3" json:"groupId,omitempty"`
+}
+
+func (m *RemoveNodeRequest) Reset()         { *m = RemoveNodeRequest{} }
+func (m *RemoveNodeRequest) String() string { return proto.CompactTextString(m) }
+func (*RemoveNodeRequest) ProtoMessage()    {}
+func (*RemoveNodeRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f80abaa17e25ccc8, []int{52}
+}
+func (m *RemoveNodeRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *RemoveNodeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_RemoveNodeRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *RemoveNodeRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RemoveNodeRequest.Merge(m, src)
+}
+func (m *RemoveNodeRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *RemoveNodeRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_RemoveNodeRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RemoveNodeRequest proto.InternalMessageInfo
+
+func (m *RemoveNodeRequest) GetNodeId() uint64 {
+	if m != nil {
+		return m.NodeId
+	}
+	return 0
+}
+
+func (m *RemoveNodeRequest) GetGroupId() uint32 {
+	if m != nil {
+		return m.GroupId
+	}
+	return 0
+}
+
+type MoveTabletRequest struct {
+	Namespace uint64 `protobuf:"varint,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
+	Tablet    string `protobuf:"bytes,2,opt,name=tablet,proto3" json:"tablet,omitempty"`
+	DstGroup  uint32 `protobuf:"varint,3,opt,name=dstGroup,proto3" json:"dstGroup,omitempty"`
+}
+
+func (m *MoveTabletRequest) Reset()         { *m = MoveTabletRequest{} }
+func (m *MoveTabletRequest) String() string { return proto.CompactTextString(m) }
+func (*MoveTabletRequest) ProtoMessage()    {}
+func (*MoveTabletRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f80abaa17e25ccc8, []int{53}
+}
+func (m *MoveTabletRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MoveTabletRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MoveTabletRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MoveTabletRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MoveTabletRequest.Merge(m, src)
+}
+func (m *MoveTabletRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *MoveTabletRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_MoveTabletRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MoveTabletRequest proto.InternalMessageInfo
+
+func (m *MoveTabletRequest) GetNamespace() uint64 {
+	if m != nil {
+		return m.Namespace
+	}
+	return 0
+}
+
+func (m *MoveTabletRequest) GetTablet() string {
+	if m != nil {
+		return m.Tablet
+	}
+	return ""
+}
+
+func (m *MoveTabletRequest) GetDstGroup() uint32 {
+	if m != nil {
+		return m.DstGroup
+	}
+	return 0
+}
+
+type ApplyLicenseRequest struct {
+	License []byte `protobuf:"bytes,1,opt,name=license,proto3" json:"license,omitempty"`
+}
+
+func (m *ApplyLicenseRequest) Reset()         { *m = ApplyLicenseRequest{} }
+func (m *ApplyLicenseRequest) String() string { return proto.CompactTextString(m) }
+func (*ApplyLicenseRequest) ProtoMessage()    {}
+func (*ApplyLicenseRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f80abaa17e25ccc8, []int{54}
+}
+func (m *ApplyLicenseRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ApplyLicenseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ApplyLicenseRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ApplyLicenseRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ApplyLicenseRequest.Merge(m, src)
+}
+func (m *ApplyLicenseRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *ApplyLicenseRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ApplyLicenseRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ApplyLicenseRequest proto.InternalMessageInfo
+
+func (m *ApplyLicenseRequest) GetLicense() []byte {
+	if m != nil {
+		return m.License
+	}
+	return nil
+}
+
 type SnapshotMeta struct {
 	ClientTs uint64 `protobuf:"varint,1,opt,name=client_ts,json=clientTs,proto3" json:"client_ts,omitempty"`
 	GroupId  uint32 `protobuf:"varint,2,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
@@ -4185,7 +4341,7 @@ func (m *SnapshotMeta) Reset()         { *m = SnapshotMeta{} }
 func (m *SnapshotMeta) String() string { return proto.CompactTextString(m) }
 func (*SnapshotMeta) ProtoMessage()    {}
 func (*SnapshotMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{52}
+	return fileDescriptor_f80abaa17e25ccc8, []int{55}
 }
 func (m *SnapshotMeta) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4239,7 +4395,7 @@ func (m *Status) Reset()         { *m = Status{} }
 func (m *Status) String() string { return proto.CompactTextString(m) }
 func (*Status) ProtoMessage()    {}
 func (*Status) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{53}
+	return fileDescriptor_f80abaa17e25ccc8, []int{56}
 }
 func (m *Status) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4303,7 +4459,7 @@ func (m *BackupRequest) Reset()         { *m = BackupRequest{} }
 func (m *BackupRequest) String() string { return proto.CompactTextString(m) }
 func (*BackupRequest) ProtoMessage()    {}
 func (*BackupRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{54}
+	return fileDescriptor_f80abaa17e25ccc8, []int{57}
 }
 func (m *BackupRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4410,7 +4566,7 @@ func (m *BackupResponse) Reset()         { *m = BackupResponse{} }
 func (m *BackupResponse) String() string { return proto.CompactTextString(m) }
 func (*BackupResponse) ProtoMessage()    {}
 func (*BackupResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{55}
+	return fileDescriptor_f80abaa17e25ccc8, []int{58}
 }
 func (m *BackupResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4456,7 +4612,7 @@ func (m *DropOperation) Reset()         { *m = DropOperation{} }
 func (m *DropOperation) String() string { return proto.CompactTextString(m) }
 func (*DropOperation) ProtoMessage()    {}
 func (*DropOperation) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{56}
+	return fileDescriptor_f80abaa17e25ccc8, []int{59}
 }
 func (m *DropOperation) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4517,7 +4673,7 @@ func (m *ExportRequest) Reset()         { *m = ExportRequest{} }
 func (m *ExportRequest) String() string { return proto.CompactTextString(m) }
 func (*ExportRequest) ProtoMessage()    {}
 func (*ExportRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{57}
+	return fileDescriptor_f80abaa17e25ccc8, []int{60}
 }
 func (m *ExportRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4627,7 +4783,7 @@ func (m *ExportResponse) Reset()         { *m = ExportResponse{} }
 func (m *ExportResponse) String() string { return proto.CompactTextString(m) }
 func (*ExportResponse) ProtoMessage()    {}
 func (*ExportResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{58}
+	return fileDescriptor_f80abaa17e25ccc8, []int{61}
 }
 func (m *ExportResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4692,7 +4848,7 @@ func (m *BackupKey) Reset()         { *m = BackupKey{} }
 func (m *BackupKey) String() string { return proto.CompactTextString(m) }
 func (*BackupKey) ProtoMessage()    {}
 func (*BackupKey) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{59}
+	return fileDescriptor_f80abaa17e25ccc8, []int{62}
 }
 func (m *BackupKey) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4783,7 +4939,7 @@ func (m *BackupPostingList) Reset()         { *m = BackupPostingList{} }
 func (m *BackupPostingList) String() string { return proto.CompactTextString(m) }
 func (*BackupPostingList) ProtoMessage()    {}
 func (*BackupPostingList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{60}
+	return fileDescriptor_f80abaa17e25ccc8, []int{63}
 }
 func (m *BackupPostingList) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4858,7 +5014,7 @@ func (m *UpdateGraphQLSchemaRequest) Reset()         { *m = UpdateGraphQLSchemaR
 func (m *UpdateGraphQLSchemaRequest) String() string { return proto.CompactTextString(m) }
 func (*UpdateGraphQLSchemaRequest) ProtoMessage()    {}
 func (*UpdateGraphQLSchemaRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{61}
+	return fileDescriptor_f80abaa17e25ccc8, []int{64}
 }
 func (m *UpdateGraphQLSchemaRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4923,7 +5079,7 @@ func (m *UpdateGraphQLSchemaResponse) Reset()         { *m = UpdateGraphQLSchema
 func (m *UpdateGraphQLSchemaResponse) String() string { return proto.CompactTextString(m) }
 func (*UpdateGraphQLSchemaResponse) ProtoMessage()    {}
 func (*UpdateGraphQLSchemaResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{62}
+	return fileDescriptor_f80abaa17e25ccc8, []int{65}
 }
 func (m *UpdateGraphQLSchemaResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4969,7 +5125,7 @@ func (m *BulkMeta) Reset()         { *m = BulkMeta{} }
 func (m *BulkMeta) String() string { return proto.CompactTextString(m) }
 func (*BulkMeta) ProtoMessage()    {}
 func (*BulkMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{63}
+	return fileDescriptor_f80abaa17e25ccc8, []int{66}
 }
 func (m *BulkMeta) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5021,7 +5177,7 @@ func (m *DeleteNsRequest) Reset()         { *m = DeleteNsRequest{} }
 func (m *DeleteNsRequest) String() string { return proto.CompactTextString(m) }
 func (*DeleteNsRequest) ProtoMessage()    {}
 func (*DeleteNsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f80abaa17e25ccc8, []int{64}
+	return fileDescriptor_f80abaa17e25ccc8, []int{67}
 }
 func (m *DeleteNsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -5133,6 +5289,9 @@ func init() {
 	proto.RegisterType((*SubscriptionResponse)(nil), "pb.SubscriptionResponse")
 	proto.RegisterType((*Num)(nil), "pb.Num")
 	proto.RegisterType((*AssignedIds)(nil), "pb.AssignedIds")
+	proto.RegisterType((*RemoveNodeRequest)(nil), "pb.RemoveNodeRequest")
+	proto.RegisterType((*MoveTabletRequest)(nil), "pb.MoveTabletRequest")
+	proto.RegisterType((*ApplyLicenseRequest)(nil), "pb.ApplyLicenseRequest")
 	proto.RegisterType((*SnapshotMeta)(nil), "pb.SnapshotMeta")
 	proto.RegisterType((*Status)(nil), "pb.Status")
 	proto.RegisterType((*BackupRequest)(nil), "pb.BackupRequest")
@@ -5152,325 +5311,332 @@ func init() {
 func init() { proto.RegisterFile("pb.proto", fileDescriptor_f80abaa17e25ccc8) }
 
 var fileDescriptor_f80abaa17e25ccc8 = []byte{
-	// 5077 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3b, 0x4d, 0x6f, 0x1c, 0x57,
-	0x72, 0x9c, 0x9e, 0xaf, 0xee, 0x9a, 0x0f, 0x0e, 0x9f, 0xb4, 0xf2, 0x98, 0xb2, 0x45, 0xba, 0x65,
-	0xd9, 0xb4, 0x64, 0x51, 0x32, 0xe5, 0x20, 0x6b, 0x2d, 0x02, 0x84, 0x1f, 0x43, 0x99, 0x12, 0x39,
-	0xd4, 0xf6, 0x8c, 0x64, 0xaf, 0x81, 0x64, 0xd0, 0xec, 0x7e, 0x24, 0x7b, 0xd9, 0xd3, 0xdd, 0xdb,
-	0xdd, 0xc3, 0x25, 0xf7, 0x16, 0x04, 0xd8, 0x45, 0x6e, 0x0b, 0xe4, 0x92, 0x53, 0x02, 0xe4, 0x90,
-	0x4b, 0x0e, 0x41, 0x02, 0x2c, 0x10, 0x04, 0xc8, 0x2d, 0x08, 0x82, 0x5c, 0xb2, 0xc7, 0x1c, 0x12,
-	0x21, 0xb0, 0x17, 0x39, 0xe8, 0x16, 0xe4, 0x0f, 0x04, 0xaf, 0xea, 0xf5, 0xd7, 0x70, 0x28, 0xc9,
-	0x0e, 0x72, 0xc8, 0x69, 0x5e, 0x55, 0xbd, 0xcf, 0x7a, 0xf5, 0xea, 0xb3, 0x07, 0xd4, 0xe0, 0x60,
-	0x35, 0x08, 0xfd, 0xd8, 0x67, 0x4a, 0x70, 0xb0, 0xa8, 0x99, 0x81, 0x43, 0xe0, 0xe2, 0xed, 0x23,
-	0x27, 0x3e, 0x9e, 0x1c, 0xac, 0x5a, 0xfe, 0xf8, 0x9e, 0x7d, 0x14, 0x9a, 0xc1, 0xf1, 0x5d, 0xc7,
-	0xbf, 0x77, 0x60, 0xda, 0x47, 0x3c, 0xbc, 0x77, 0xfa, 0xe0, 0x5e, 0x70, 0x70, 0x2f, 0x19, 0xba,
-	0x78, 0x37, 0xd7, 0xf7, 0xc8, 0x3f, 0xf2, 0xef, 0x21, 0xfa, 0x60, 0x72, 0x88, 0x10, 0x02, 0xd8,
-	0xa2, 0xee, 0x7a, 0x0f, 0x2a, 0xbb, 0x4e, 0x14, 0x33, 0x06, 0x95, 0x89, 0x63, 0x47, 0xdd, 0xd2,
-	0x72, 0x79, 0xa5, 0x66, 0x60, 0x9b, 0x7d, 0x04, 0x0b, 0x07, 0x4e, 0x3c, 0x36, 0x83, 0x91, 0xed,
-	0x8f, 0x3c, 0x3f, 0x1e, 0x4d, 0x22, 0xde, 0x55, 0x96, 0x4b, 0x2b, 0x4d, 0xa3, 0x4d, 0x84, 0x2d,
-	0xbf, 0xef, 0xc7, 0xcf, 0x22, 0xae, 0xef, 0x81, 0x36, 0x34, 0xa3, 0x93, 0xe7, 0xa6, 0x3b, 0xe1,
-	0xac, 0x03, 0xe5, 0x53, 0xd3, 0xed, 0x96, 0xb0, 0xa7, 0x68, 0xb2, 0x55, 0x50, 0x4f, 0x4d, 0x77,
-	0x14, 0x9f, 0x07, 0x34, 0x41, 0x7b, 0xed, 0xca, 0x6a, 0x70, 0xb0, 0xfa, 0xd4, 0x8f, 0x62, 0xc7,
-	0x3b, 0x5a, 0x7d, 0x6e, 0xba, 0xc3, 0xf3, 0x80, 0x1b, 0xf5, 0x53, 0x6a, 0xe8, 0xfb, 0xd0, 0x18,
-	0x84, 0xd6, 0xf6, 0xc4, 0xb3, 0x62, 0xc7, 0xf7, 0xc4, 0xe6, 0x3c, 0x73, 0xcc, 0x71, 0x46, 0xcd,
-	0xc0, 0xb6, 0xc0, 0x99, 0xe1, 0x51, 0xd4, 0x2d, 0x2f, 0x97, 0x05, 0x4e, 0xb4, 0x59, 0x17, 0xea,
-	0x4e, 0xb4, 0xe9, 0x4f, 0xbc, 0xb8, 0x5b, 0x59, 0x2e, 0xad, 0xa8, 0x46, 0x02, 0xea, 0x7f, 0x56,
-	0x86, 0xea, 0x0f, 0x27, 0x3c, 0x3c, 0xc7, 0x71, 0x71, 0x1c, 0x26, 0x73, 0x89, 0x36, 0xbb, 0x0a,
-	0x55, 0xd7, 0xf4, 0x8e, 0xa2, 0xae, 0x82, 0x93, 0x11, 0xc0, 0xae, 0x83, 0x66, 0x1e, 0xc6, 0x3c,
-	0x1c, 0x4d, 0x1c, 0xbb, 0x5b, 0x5e, 0x2e, 0xad, 0xd4, 0x0c, 0x15, 0x11, 0xcf, 0x1c, 0x9b, 0xbd,
-	0x0d, 0xaa, 0xed, 0x8f, 0xac, 0xfc, 0x5a, 0xb6, 0x8f, 0x6b, 0xb1, 0x9b, 0xa0, 0x4e, 0x1c, 0x7b,
-	0xe4, 0x3a, 0x51, 0xdc, 0xad, 0x2e, 0x97, 0x56, 0x1a, 0x6b, 0xaa, 0x38, 0xac, 0x60, 0xb3, 0x51,
-	0x9f, 0x38, 0x36, 0xf2, 0xfb, 0x36, 0xa8, 0x51, 0x68, 0x8d, 0x0e, 0x27, 0x9e, 0xd5, 0xad, 0x61,
-	0xa7, 0x79, 0xd1, 0x29, 0x77, 0x6a, 0xa3, 0x1e, 0x11, 0x20, 0x8e, 0x15, 0xf2, 0x53, 0x1e, 0x46,
-	0xbc, 0x5b, 0xa7, 0xa5, 0x24, 0xc8, 0xee, 0x43, 0xe3, 0xd0, 0xb4, 0x78, 0x3c, 0x0a, 0xcc, 0xd0,
-	0x1c, 0x77, 0xd5, 0x6c, 0xa2, 0x6d, 0x81, 0x7e, 0x2a, 0xb0, 0x91, 0x01, 0x87, 0x29, 0xc0, 0x1e,
-	0x40, 0x0b, 0xa1, 0x68, 0x74, 0xe8, 0xb8, 0x31, 0x0f, 0xbb, 0x1a, 0x8e, 0x69, 0xe3, 0x18, 0xc4,
-	0x0c, 0x43, 0xce, 0x8d, 0x26, 0x75, 0x22, 0x0c, 0x7b, 0x17, 0x80, 0x9f, 0x05, 0xa6, 0x67, 0x8f,
-	0x4c, 0xd7, 0xed, 0x02, 0xee, 0x41, 0x23, 0xcc, 0xba, 0xeb, 0xb2, 0xb7, 0xc4, 0xfe, 0x4c, 0x7b,
-	0x14, 0x47, 0xdd, 0xd6, 0x72, 0x69, 0xa5, 0x62, 0xd4, 0x04, 0x38, 0x8c, 0x04, 0x5f, 0x2d, 0xd3,
-	0x3a, 0xe6, 0xdd, 0xf6, 0x72, 0x69, 0xa5, 0x6a, 0x10, 0x20, 0xb0, 0x87, 0x4e, 0x18, 0xc5, 0xdd,
-	0x79, 0xc2, 0x22, 0xa0, 0xaf, 0x81, 0x86, 0xd2, 0x83, 0xdc, 0xb9, 0x05, 0xb5, 0x53, 0x01, 0x90,
-	0x3c, 0x36, 0xd6, 0x5a, 0x62, 0x7b, 0xa9, 0x80, 0x19, 0x92, 0xa8, 0xdf, 0x00, 0x75, 0xd7, 0xf4,
-	0x8e, 0x12, 0x01, 0x16, 0xd7, 0x86, 0x03, 0x34, 0x03, 0xdb, 0xfa, 0x9f, 0x28, 0x50, 0x33, 0x78,
-	0x34, 0x71, 0x63, 0xf6, 0x21, 0x80, 0xb8, 0x94, 0xb1, 0x19, 0x87, 0xce, 0x99, 0x9c, 0x35, 0xbb,
-	0x16, 0x6d, 0xe2, 0xd8, 0x7b, 0x48, 0x62, 0xf7, 0xa1, 0x89, 0xb3, 0x27, 0x5d, 0x95, 0x6c, 0x03,
-	0xe9, 0xfe, 0x8c, 0x06, 0x76, 0x91, 0x23, 0xae, 0x41, 0x0d, 0xe5, 0x80, 0x64, 0xb1, 0x65, 0x48,
-	0x88, 0xdd, 0x82, 0xb6, 0xe3, 0xc5, 0xe2, 0x9e, 0xac, 0x78, 0x64, 0xf3, 0x28, 0x11, 0x94, 0x56,
-	0x8a, 0xdd, 0xe2, 0x51, 0xcc, 0x3e, 0x01, 0x62, 0x76, 0xb2, 0x60, 0x15, 0x17, 0x6c, 0xa7, 0x97,
-	0x18, 0xd1, 0x8a, 0xd8, 0x47, 0xae, 0x78, 0x17, 0x1a, 0xe2, 0x7c, 0xc9, 0x88, 0x1a, 0x8e, 0x68,
-	0xe2, 0x69, 0x24, 0x3b, 0x0c, 0x10, 0x1d, 0x64, 0x77, 0xc1, 0x1a, 0x21, 0x8c, 0x24, 0x3c, 0xd8,
-	0xd6, 0x7b, 0x50, 0xdd, 0x0f, 0x6d, 0x1e, 0xce, 0x7c, 0x0f, 0x0c, 0x2a, 0x36, 0x8f, 0x2c, 0x7c,
-	0xaa, 0xaa, 0x81, 0xed, 0xec, 0x8d, 0x94, 0x73, 0x6f, 0x44, 0xff, 0xd3, 0x12, 0x34, 0x06, 0x7e,
-	0x18, 0xef, 0xf1, 0x28, 0x32, 0x8f, 0x38, 0x5b, 0x82, 0xaa, 0x2f, 0xa6, 0x95, 0x1c, 0xd6, 0xc4,
-	0x9e, 0x70, 0x1d, 0x83, 0xf0, 0x53, 0xf7, 0xa0, 0x5c, 0x7e, 0x0f, 0x42, 0x76, 0xf0, 0x75, 0x95,
-	0xa5, 0xec, 0xe0, 0xdb, 0xba, 0x06, 0x35, 0xff, 0xf0, 0x30, 0xe2, 0xc4, 0xcb, 0xaa, 0x21, 0xa1,
-	0x4b, 0x45, 0x50, 0xff, 0x2d, 0x00, 0xb1, 0xbf, 0x6f, 0x29, 0x05, 0xfa, 0x2f, 0x4a, 0xd0, 0x30,
-	0xcc, 0xc3, 0x78, 0xd3, 0xf7, 0x62, 0x7e, 0x16, 0xb3, 0x36, 0x28, 0x8e, 0x8d, 0x3c, 0xaa, 0x19,
-	0x8a, 0x63, 0x8b, 0xdd, 0x1d, 0x85, 0xfe, 0x24, 0x40, 0x16, 0xb5, 0x0c, 0x02, 0x90, 0x97, 0xb6,
-	0x1d, 0xe2, 0x96, 0x05, 0x2f, 0x6d, 0x3b, 0x64, 0x4b, 0xd0, 0x88, 0x3c, 0x33, 0x88, 0x8e, 0xfd,
-	0x58, 0xec, 0xae, 0x82, 0xbb, 0x83, 0x04, 0x35, 0x8c, 0xc4, 0xe3, 0x72, 0xa2, 0x91, 0xcb, 0xcd,
-	0xd0, 0xe3, 0x21, 0x2a, 0x0c, 0xd5, 0xd0, 0x9c, 0x68, 0x97, 0x10, 0xfa, 0x2f, 0xca, 0x50, 0xdb,
-	0xe3, 0xe3, 0x03, 0x1e, 0x5e, 0xd8, 0xc4, 0x7d, 0x50, 0x71, 0xdd, 0x91, 0x63, 0xd3, 0x3e, 0x36,
-	0xbe, 0xf7, 0xf2, 0xc5, 0xd2, 0x02, 0xe2, 0x76, 0xec, 0x8f, 0xfd, 0xb1, 0x13, 0xf3, 0x71, 0x10,
-	0x9f, 0x1b, 0x75, 0x89, 0x9a, 0xb9, 0xc1, 0x6b, 0x50, 0x73, 0xb9, 0x29, 0xee, 0x8c, 0xc4, 0x53,
-	0x42, 0xec, 0x2e, 0xd4, 0xcd, 0xf1, 0xc8, 0xe6, 0xa6, 0x4d, 0x9b, 0xda, 0xb8, 0xfa, 0xf2, 0xc5,
-	0x52, 0xc7, 0x1c, 0x6f, 0x71, 0x33, 0x3f, 0x77, 0x8d, 0x30, 0xec, 0x33, 0x21, 0x93, 0x51, 0x3c,
-	0x9a, 0x04, 0xb6, 0x19, 0x73, 0xd4, 0x69, 0x95, 0x8d, 0xee, 0xcb, 0x17, 0x4b, 0x57, 0x05, 0xfa,
-	0x19, 0x62, 0x73, 0xc3, 0x20, 0xc3, 0x0a, 0xfd, 0x96, 0x1c, 0x5f, 0xea, 0x37, 0x09, 0xb2, 0x1d,
-	0x58, 0xb0, 0xdc, 0x49, 0x24, 0x94, 0xb0, 0xe3, 0x1d, 0xfa, 0x23, 0xdf, 0x73, 0xcf, 0xf1, 0x82,
-	0xd5, 0x8d, 0x77, 0x5f, 0xbe, 0x58, 0x7a, 0x5b, 0x12, 0x77, 0xbc, 0x43, 0x7f, 0xdf, 0x73, 0xcf,
-	0x73, 0xf3, 0xcf, 0x4f, 0x91, 0xd8, 0xef, 0x42, 0xfb, 0xd0, 0x0f, 0x2d, 0x3e, 0x4a, 0x59, 0xd6,
-	0xc6, 0x79, 0x16, 0x5f, 0xbe, 0x58, 0xba, 0x86, 0x94, 0x47, 0x17, 0xf8, 0xd6, 0xcc, 0xe3, 0xf5,
-	0x7f, 0x57, 0xa0, 0x8a, 0x6d, 0x76, 0x1f, 0xea, 0x63, 0xbc, 0x92, 0x44, 0x3f, 0x5d, 0x13, 0x32,
-	0x84, 0xb4, 0x55, 0xba, 0xab, 0xa8, 0xe7, 0xc5, 0xe1, 0xb9, 0x91, 0x74, 0x13, 0x23, 0x62, 0xf3,
-	0xc0, 0xe5, 0x71, 0x24, 0x65, 0x3e, 0x37, 0x62, 0x48, 0x04, 0x39, 0x42, 0x76, 0x9b, 0x96, 0x9b,
-	0xf2, 0x05, 0xb9, 0x59, 0x04, 0xd5, 0x3a, 0xe6, 0xd6, 0x49, 0x34, 0x19, 0x4b, 0xa9, 0x4a, 0x61,
-	0x76, 0x13, 0x5a, 0xd8, 0x0e, 0x7c, 0xc7, 0xc3, 0xe1, 0x55, 0xec, 0xd0, 0xcc, 0x90, 0xc3, 0x68,
-	0x71, 0x1b, 0x9a, 0xf9, 0xcd, 0x0a, 0xb3, 0x7d, 0xc2, 0xcf, 0x51, 0xbe, 0x2a, 0x86, 0x68, 0xb2,
-	0x65, 0xa8, 0xa2, 0xa2, 0x43, 0xe9, 0x6a, 0xac, 0x81, 0xd8, 0x33, 0x0d, 0x31, 0x88, 0xf0, 0x50,
-	0xf9, 0x7e, 0x49, 0xcc, 0x93, 0x3f, 0x42, 0x7e, 0x1e, 0xed, 0xf2, 0x79, 0x68, 0x48, 0x6e, 0x1e,
-	0xdd, 0x87, 0xfa, 0xae, 0x63, 0x71, 0x2f, 0x42, 0xe3, 0x3e, 0x89, 0x78, 0xaa, 0x94, 0x44, 0x5b,
-	0x9c, 0x77, 0x6c, 0x9e, 0xf5, 0x7d, 0x9b, 0x47, 0x38, 0x4f, 0xc5, 0x48, 0x61, 0x41, 0xe3, 0x67,
-	0x81, 0x13, 0x9e, 0x0f, 0x89, 0x53, 0x65, 0x23, 0x85, 0x85, 0x74, 0x71, 0x4f, 0x2c, 0x66, 0x27,
-	0x86, 0x5a, 0x82, 0xfa, 0xcf, 0x2b, 0xd0, 0xfc, 0x8a, 0x87, 0xfe, 0xd3, 0xd0, 0x0f, 0xfc, 0xc8,
-	0x74, 0xd9, 0x7a, 0x91, 0xe7, 0x74, 0xb7, 0xcb, 0x62, 0xb7, 0xf9, 0x6e, 0xab, 0x83, 0xf4, 0x12,
-	0xe8, 0xce, 0xf2, 0xb7, 0xa2, 0x43, 0x8d, 0xee, 0x7c, 0x06, 0xcf, 0x24, 0x45, 0xf4, 0xa1, 0x5b,
-	0xc6, 0xbd, 0x16, 0xf9, 0x21, 0x29, 0xe2, 0x55, 0x8e, 0xcd, 0xb3, 0x67, 0x3b, 0x5b, 0xf2, 0x6e,
-	0x25, 0x24, 0xb9, 0x30, 0x3c, 0xf3, 0x86, 0xc9, 0xa5, 0xa6, 0xb0, 0x38, 0xa9, 0xe0, 0x48, 0xb4,
-	0xb3, 0xd5, 0x6d, 0x22, 0x29, 0x01, 0xd9, 0x3b, 0xa0, 0x8d, 0xcd, 0x33, 0xa1, 0xd0, 0x76, 0x6c,
-	0x7a, 0x9a, 0x46, 0x86, 0x60, 0xef, 0x41, 0x39, 0x3e, 0xf3, 0xf0, 0xed, 0x09, 0xef, 0x41, 0xf8,
-	0x9d, 0xc3, 0x33, 0x4f, 0xaa, 0x3e, 0x43, 0xd0, 0xc4, 0x9d, 0x5a, 0x8e, 0x8d, 0xce, 0x82, 0x66,
-	0x88, 0x26, 0xbb, 0x05, 0x75, 0x97, 0x6e, 0x0b, 0x1d, 0x82, 0xc6, 0x5a, 0x83, 0xf4, 0x28, 0xa2,
-	0x8c, 0x84, 0xc6, 0x3e, 0x06, 0x35, 0xe1, 0x4e, 0xb7, 0x81, 0xfd, 0x3a, 0x09, 0x3f, 0x13, 0x36,
-	0x1a, 0x69, 0x0f, 0x76, 0x1f, 0x34, 0x9b, 0xbb, 0x3c, 0xe6, 0x23, 0x8f, 0x14, 0x79, 0x83, 0x1c,
-	0xc5, 0x2d, 0x44, 0xf6, 0x23, 0x83, 0xff, 0x64, 0xc2, 0xa3, 0xd8, 0x50, 0x6d, 0x89, 0x58, 0xfc,
-	0x1d, 0x98, 0x9f, 0xba, 0x8e, 0xbc, 0xfc, 0xb5, 0x48, 0xfe, 0xae, 0xe6, 0xe5, 0xaf, 0x92, 0x93,
-	0xb9, 0xc7, 0x15, 0x55, 0xed, 0x68, 0xfa, 0x7f, 0x95, 0x61, 0x5e, 0x3e, 0x85, 0x63, 0x27, 0x18,
-	0xc4, 0x52, 0x29, 0xa1, 0xc9, 0x91, 0x52, 0x58, 0x31, 0x12, 0x90, 0xfd, 0x36, 0xd4, 0x50, 0x87,
-	0x24, 0x4f, 0x79, 0x29, 0xbb, 0xe2, 0x74, 0x38, 0x3d, 0x6d, 0x29, 0x1f, 0xb2, 0x3b, 0xfb, 0x14,
-	0xaa, 0x3f, 0xe3, 0xa1, 0x4f, 0x26, 0xb4, 0xb1, 0x76, 0x63, 0xd6, 0x38, 0xc1, 0x18, 0x39, 0x8c,
-	0x3a, 0xff, 0x6f, 0x25, 0x01, 0xbe, 0x8d, 0x24, 0xbc, 0x2f, 0xcc, 0xe8, 0xd8, 0x3f, 0xe5, 0x76,
-	0xb7, 0x8e, 0x7b, 0xcc, 0x8b, 0x6f, 0x42, 0x4a, 0x84, 0x41, 0x9d, 0x29, 0x0c, 0xda, 0xe5, 0xc2,
-	0xb0, 0xb8, 0x05, 0x8d, 0x1c, 0x5f, 0x66, 0x5c, 0xd4, 0x52, 0x51, 0x51, 0x68, 0xa9, 0x92, 0xcc,
-	0xeb, 0x9b, 0x2d, 0x80, 0x8c, 0x4b, 0xdf, 0x55, 0x6b, 0xe9, 0x7f, 0x50, 0x82, 0xf9, 0x4d, 0xdf,
-	0xf3, 0x38, 0x3a, 0xdb, 0x74, 0xe7, 0xd9, 0xe3, 0x2d, 0x5d, 0xfa, 0x78, 0x3f, 0x82, 0x6a, 0x24,
-	0x3a, 0xcb, 0xd9, 0xaf, 0xcc, 0xb8, 0x44, 0x83, 0x7a, 0x08, 0x15, 0x3e, 0x36, 0xcf, 0x46, 0x01,
-	0xf7, 0x6c, 0xc7, 0x3b, 0x4a, 0x54, 0xf8, 0xd8, 0x3c, 0x7b, 0x4a, 0x18, 0xfd, 0x6f, 0x15, 0x80,
-	0xcf, 0xb9, 0xe9, 0xc6, 0xc7, 0xc2, 0x4c, 0x89, 0x1b, 0x75, 0xbc, 0x28, 0x36, 0x3d, 0x2b, 0x09,
-	0x75, 0x52, 0x58, 0xdc, 0xa8, 0xb0, 0xd6, 0x3c, 0x22, 0xe5, 0xa7, 0x19, 0x09, 0x28, 0xe4, 0x43,
-	0x2c, 0x37, 0x89, 0xa4, 0x55, 0x97, 0x50, 0xe6, 0xa2, 0x54, 0x10, 0x2d, 0x5d, 0x94, 0x2e, 0xd4,
-	0x45, 0xe8, 0xe0, 0xf8, 0x1e, 0x0a, 0x8d, 0x66, 0x24, 0xa0, 0x98, 0x67, 0x12, 0xc4, 0xce, 0x98,
-	0x6c, 0x77, 0xd9, 0x90, 0x90, 0xd8, 0x95, 0xb0, 0xd5, 0x3d, 0xeb, 0xd8, 0x47, 0x15, 0x51, 0x36,
-	0x52, 0x58, 0xcc, 0xe6, 0x7b, 0x47, 0xbe, 0x38, 0x9d, 0x8a, 0x6e, 0x61, 0x02, 0xd2, 0x59, 0x6c,
-	0x7e, 0x26, 0x48, 0x1a, 0x92, 0x52, 0x58, 0xf0, 0x85, 0xf3, 0xd1, 0x21, 0x37, 0xe3, 0x49, 0xc8,
-	0xa3, 0x2e, 0x20, 0x19, 0x38, 0xdf, 0x96, 0x18, 0xf6, 0x1e, 0x34, 0x05, 0xe3, 0xcc, 0x28, 0x72,
-	0x8e, 0x3c, 0x6e, 0xa3, 0xe2, 0xa8, 0x18, 0x82, 0x99, 0xeb, 0x12, 0xa5, 0xff, 0xbd, 0x02, 0x35,
-	0x52, 0x99, 0x05, 0x37, 0xa8, 0xf4, 0x46, 0x6e, 0xd0, 0x3b, 0xa0, 0x05, 0x21, 0xb7, 0x1d, 0x2b,
-	0xb9, 0x47, 0xcd, 0xc8, 0x10, 0x18, 0x9f, 0x08, 0xbb, 0x8f, 0xfc, 0x54, 0x0d, 0x02, 0x98, 0x0e,
-	0x2d, 0xdf, 0x1b, 0xd9, 0x4e, 0x74, 0x32, 0x3a, 0x38, 0x8f, 0x79, 0x24, 0x79, 0xd1, 0xf0, 0xbd,
-	0x2d, 0x27, 0x3a, 0xd9, 0x10, 0x28, 0xc1, 0x42, 0x7a, 0x23, 0xf8, 0x36, 0x54, 0x43, 0x42, 0xec,
-	0x01, 0x68, 0xe8, 0x9d, 0xa2, 0xfb, 0xa2, 0xa1, 0xdb, 0x71, 0xed, 0xe5, 0x8b, 0x25, 0x26, 0x90,
-	0x53, 0x7e, 0x8b, 0x9a, 0xe0, 0x84, 0xff, 0x25, 0x06, 0x0b, 0x43, 0x84, 0x6f, 0x98, 0xfc, 0x2f,
-	0x81, 0x1a, 0x46, 0x79, 0xff, 0x8b, 0x30, 0xec, 0x2e, 0xb0, 0x89, 0x67, 0xf9, 0xe3, 0x40, 0x08,
-	0x05, 0xb7, 0xe5, 0x26, 0x1b, 0xb8, 0xc9, 0x85, 0x3c, 0x05, 0xb7, 0xaa, 0xff, 0x9b, 0x02, 0xcd,
-	0x2d, 0x27, 0xe4, 0x56, 0xcc, 0xed, 0x9e, 0x7d, 0xc4, 0xc5, 0xde, 0xb9, 0x17, 0x3b, 0xf1, 0xb9,
-	0x74, 0x30, 0x25, 0x94, 0xc6, 0x07, 0x4a, 0x31, 0x5e, 0xa6, 0x17, 0x56, 0xc6, 0x10, 0x9f, 0x00,
-	0xb6, 0x06, 0x40, 0x91, 0x13, 0x86, 0xf9, 0x95, 0xcb, 0xc3, 0x7c, 0x0d, 0xbb, 0x89, 0xa6, 0x08,
-	0xa3, 0x69, 0x8c, 0x43, 0x5e, 0x66, 0x0d, 0x73, 0x00, 0x13, 0x4e, 0xbe, 0x2a, 0x06, 0x74, 0x75,
-	0x5a, 0x58, 0xb4, 0xd9, 0x4d, 0x50, 0xfc, 0x00, 0x99, 0x2b, 0xa7, 0xce, 0x1f, 0x61, 0x75, 0x3f,
-	0x30, 0x14, 0x3f, 0x10, 0xaf, 0x98, 0xa2, 0x57, 0x14, 0x3c, 0xf1, 0x8a, 0x85, 0x45, 0xc3, 0x58,
-	0xca, 0x90, 0x14, 0xa6, 0x43, 0xd3, 0x74, 0x5d, 0xff, 0xa7, 0xdc, 0x7e, 0x1a, 0x72, 0x3b, 0x91,
-	0xc1, 0x02, 0x4e, 0x48, 0x89, 0x67, 0x8e, 0x79, 0x14, 0x98, 0x16, 0x97, 0x22, 0x98, 0x21, 0xf4,
-	0x6b, 0xa0, 0xec, 0x07, 0xac, 0x0e, 0xe5, 0x41, 0x6f, 0xd8, 0x99, 0x13, 0x8d, 0xad, 0xde, 0x6e,
-	0x47, 0x58, 0x94, 0x5a, 0xa7, 0xae, 0x7f, 0xad, 0x80, 0xb6, 0x37, 0x89, 0x4d, 0xa1, 0x5b, 0x22,
-	0x71, 0xca, 0xa2, 0x84, 0x66, 0xa2, 0xf8, 0x36, 0xa8, 0x51, 0x6c, 0x86, 0xe8, 0x6f, 0x90, 0x75,
-	0xaa, 0x23, 0x3c, 0x8c, 0xd8, 0x07, 0x50, 0xe5, 0xf6, 0x11, 0x4f, 0xcc, 0x45, 0x67, 0xfa, 0xbc,
-	0x06, 0x91, 0xd9, 0x0a, 0xd4, 0x22, 0xeb, 0x98, 0x8f, 0xcd, 0x6e, 0x25, 0xeb, 0x38, 0x40, 0x0c,
-	0x39, 0xd8, 0x86, 0xa4, 0xb3, 0xf7, 0xa1, 0x2a, 0xee, 0x26, 0x92, 0x11, 0x23, 0xc6, 0x98, 0xe2,
-	0x1a, 0x64, 0x37, 0x22, 0x0a, 0xc1, 0xb3, 0x43, 0x3f, 0x18, 0xf9, 0x01, 0xf2, 0xbe, 0xbd, 0x76,
-	0x15, 0x75, 0x5c, 0x72, 0x9a, 0xd5, 0xad, 0xd0, 0x0f, 0xf6, 0x03, 0xa3, 0x66, 0xe3, 0xaf, 0x88,
-	0x5f, 0xb0, 0x3b, 0x49, 0x04, 0x19, 0x05, 0x4d, 0x60, 0x28, 0x19, 0xb4, 0x02, 0xea, 0x98, 0xc7,
-	0xa6, 0x6d, 0xc6, 0xa6, 0xb4, 0x0d, 0x4d, 0x52, 0x99, 0x84, 0x33, 0x52, 0xaa, 0x7e, 0x0f, 0x6a,
-	0x34, 0x35, 0x53, 0xa1, 0xd2, 0xdf, 0xef, 0xf7, 0x88, 0xad, 0xeb, 0xbb, 0xbb, 0x9d, 0x92, 0x40,
-	0x6d, 0xad, 0x0f, 0xd7, 0x3b, 0x8a, 0x68, 0x0d, 0x7f, 0xf4, 0xb4, 0xd7, 0x29, 0xeb, 0xff, 0x5c,
-	0x02, 0x35, 0x99, 0x87, 0x3d, 0x04, 0x10, 0x4f, 0x78, 0x74, 0xec, 0x78, 0xa9, 0xeb, 0x76, 0x3d,
-	0xbf, 0xd2, 0xaa, 0xb8, 0xd5, 0xcf, 0x05, 0x95, 0xcc, 0x2b, 0xbe, 0x78, 0x84, 0x17, 0x07, 0xd0,
-	0x2e, 0x12, 0x67, 0xf8, 0xb0, 0x77, 0xf2, 0x56, 0xa5, 0xbd, 0xf6, 0xbd, 0xc2, 0xd4, 0x62, 0x24,
-	0x8a, 0x76, 0xce, 0xc0, 0xdc, 0x05, 0x35, 0x41, 0xb3, 0x06, 0xd4, 0xb7, 0x7a, 0xdb, 0xeb, 0xcf,
-	0x76, 0x85, 0xa8, 0x00, 0xd4, 0x06, 0x3b, 0xfd, 0x47, 0xbb, 0x3d, 0x3a, 0xd6, 0xee, 0xce, 0x60,
-	0xd8, 0x51, 0xf4, 0x3f, 0x2e, 0x81, 0x9a, 0x78, 0x32, 0xec, 0x23, 0xe1, 0x7c, 0xa0, 0xfb, 0x25,
-	0x2d, 0x11, 0xe6, 0x74, 0x72, 0x01, 0xa9, 0x91, 0xd0, 0xc5, 0x5b, 0x44, 0xc5, 0x9a, 0xf8, 0x36,
-	0x08, 0xe4, 0xe3, 0xe1, 0x72, 0x21, 0x25, 0x23, 0x42, 0x7b, 0xdf, 0xe3, 0xd2, 0x15, 0xc6, 0x36,
-	0xca, 0xa0, 0xe3, 0x59, 0x3c, 0x0b, 0x14, 0xea, 0x08, 0x0f, 0x23, 0x3d, 0x26, 0x0f, 0x39, 0xdd,
-	0x58, 0xba, 0x5a, 0x29, 0xbf, 0xda, 0x85, 0x70, 0x43, 0xb9, 0x18, 0x6e, 0x64, 0x86, 0xb3, 0xfa,
-	0x3a, 0xc3, 0xa9, 0xff, 0x75, 0x05, 0xda, 0x06, 0x8f, 0x62, 0x3f, 0xe4, 0xd2, 0xe3, 0x7b, 0xd5,
-	0x13, 0x7a, 0x17, 0x20, 0xa4, 0xce, 0xd9, 0xd2, 0x9a, 0xc4, 0x50, 0x9c, 0xe4, 0xfa, 0x16, 0xca,
-	0xae, 0xb4, 0x90, 0x29, 0xcc, 0xae, 0x83, 0x76, 0x60, 0x5a, 0x27, 0x34, 0x2d, 0xd9, 0x49, 0x95,
-	0x10, 0x34, 0xaf, 0x69, 0x59, 0x3c, 0x8a, 0x46, 0x42, 0x14, 0xc8, 0x5a, 0x6a, 0x84, 0x79, 0xc2,
-	0xcf, 0x05, 0x39, 0xe2, 0x56, 0xc8, 0x63, 0x24, 0xd7, 0x88, 0x4c, 0x18, 0x41, 0xbe, 0x09, 0xad,
-	0x88, 0x47, 0xc2, 0xb2, 0x8e, 0x62, 0xff, 0x84, 0x7b, 0x52, 0x8f, 0x35, 0x25, 0x72, 0x28, 0x70,
-	0x42, 0xc5, 0x98, 0x9e, 0xef, 0x9d, 0x8f, 0xfd, 0x49, 0x24, 0x6d, 0x46, 0x86, 0x60, 0xab, 0x70,
-	0x85, 0x7b, 0x56, 0x78, 0x1e, 0x88, 0xbd, 0x8a, 0x55, 0x46, 0x87, 0x8e, 0xcb, 0xa5, 0x13, 0xbe,
-	0x90, 0x91, 0x9e, 0xf0, 0xf3, 0x6d, 0xc7, 0xe5, 0x62, 0x47, 0xa7, 0xe6, 0xc4, 0x8d, 0x47, 0x18,
-	0xe3, 0x03, 0xed, 0x08, 0x31, 0xeb, 0x22, 0xd0, 0xbf, 0x0d, 0x0b, 0x44, 0x0e, 0x7d, 0x97, 0x3b,
-	0x36, 0x4d, 0xd6, 0xc0, 0x5e, 0xf3, 0x48, 0x30, 0x10, 0x8f, 0x53, 0xad, 0xc2, 0x15, 0xea, 0x4b,
-	0x07, 0x4a, 0x7a, 0x37, 0x69, 0x69, 0x24, 0x0d, 0x24, 0xa5, 0xb8, 0x74, 0x60, 0xc6, 0xc7, 0xe8,
-	0xb9, 0x27, 0x4b, 0x3f, 0x35, 0xe3, 0x63, 0x61, 0xf1, 0x89, 0x7c, 0xe8, 0x70, 0x97, 0x22, 0x6f,
-	0xcd, 0xa0, 0x11, 0xdb, 0x02, 0x23, 0x2c, 0xbe, 0xec, 0xe0, 0x87, 0x63, 0x93, 0x52, 0x83, 0x9a,
-	0x41, 0x83, 0xb6, 0x11, 0x25, 0x96, 0x90, 0x77, 0xe5, 0x4d, 0xc6, 0xdd, 0x0e, 0x5d, 0x33, 0x61,
-	0xfa, 0x93, 0xb1, 0xfe, 0x2f, 0x65, 0x50, 0xd3, 0x40, 0xee, 0x0e, 0x68, 0xe3, 0x44, 0x5f, 0x49,
-	0x47, 0xad, 0x55, 0x50, 0x62, 0x46, 0x46, 0x67, 0xef, 0x82, 0x72, 0x72, 0x2a, 0x75, 0x67, 0x6b,
-	0x95, 0xb2, 0xea, 0xc1, 0xc1, 0x83, 0xd5, 0x27, 0xcf, 0x0d, 0xe5, 0xe4, 0xf4, 0x5b, 0xc8, 0x2d,
-	0xfb, 0x10, 0xe6, 0x2d, 0x97, 0x9b, 0xde, 0x28, 0xf3, 0x2e, 0x48, 0x2e, 0xda, 0x88, 0x7e, 0x9a,
-	0xba, 0x18, 0xb7, 0xa0, 0x6a, 0x73, 0x37, 0x36, 0xf3, 0x19, 0xdb, 0xfd, 0xd0, 0xb4, 0x5c, 0xbe,
-	0x25, 0xd0, 0x06, 0x51, 0x85, 0xee, 0x4c, 0x83, 0xa7, 0x9c, 0xee, 0x9c, 0x11, 0x38, 0xa5, 0xef,
-	0x12, 0xf2, 0xef, 0xf2, 0x0e, 0x2c, 0xf0, 0xb3, 0x00, 0x0d, 0xc6, 0x28, 0xcd, 0x15, 0x90, 0x25,
-	0xeb, 0x24, 0x84, 0xcd, 0x24, 0x67, 0xf0, 0xb1, 0x50, 0x19, 0xf8, 0x68, 0xf0, 0x9a, 0x1b, 0x6b,
-	0x0c, 0x75, 0x4e, 0xe1, 0x19, 0x1a, 0x49, 0x17, 0xf6, 0x11, 0x68, 0x96, 0x6d, 0x8d, 0x88, 0x33,
-	0xad, 0x6c, 0x6f, 0x9b, 0x5b, 0x9b, 0xc4, 0x12, 0xd5, 0xb2, 0x2d, 0xf2, 0xaa, 0x0b, 0x41, 0x5d,
-	0xfb, 0x0d, 0x82, 0xba, 0xc7, 0x15, 0xb5, 0xde, 0x51, 0xf5, 0x9b, 0xa0, 0x26, 0xb3, 0x09, 0x7d,
-	0x16, 0x71, 0x4f, 0x46, 0xe5, 0xa8, 0xcf, 0x04, 0x38, 0x8c, 0x74, 0x0b, 0xca, 0x4f, 0x9e, 0x0f,
-	0x50, 0xad, 0x09, 0x0b, 0x53, 0x45, 0x87, 0x04, 0xdb, 0xa9, 0xaa, 0x53, 0x72, 0xaa, 0xee, 0x06,
-	0x59, 0x09, 0xbc, 0x85, 0x24, 0x95, 0x99, 0xc3, 0x08, 0x3e, 0x92, 0x85, 0xac, 0x50, 0x96, 0x13,
-	0x01, 0xfd, 0x3f, 0xcb, 0x50, 0x97, 0x4e, 0x8c, 0xb0, 0x0c, 0x93, 0x34, 0x0b, 0x27, 0x9a, 0xc5,
-	0xe8, 0x32, 0xf5, 0x86, 0xf2, 0x25, 0x8f, 0xf2, 0xeb, 0x4b, 0x1e, 0xec, 0x21, 0x34, 0x03, 0xa2,
-	0xe5, 0xfd, 0xa7, 0xb7, 0xf2, 0x63, 0xe4, 0x2f, 0x8e, 0x6b, 0x04, 0x19, 0x20, 0x94, 0x23, 0xe6,
-	0x83, 0x63, 0xf3, 0x48, 0x72, 0xa0, 0x2e, 0xe0, 0xa1, 0x79, 0xf4, 0x46, 0xce, 0x50, 0x1b, 0xbd,
-	0xaa, 0x26, 0x6a, 0x55, 0xe1, 0x40, 0xe5, 0x7d, 0x92, 0x56, 0xd1, 0x27, 0xb9, 0x0e, 0x9a, 0xe5,
-	0x8f, 0xc7, 0x0e, 0xd2, 0xda, 0x32, 0xeb, 0x84, 0x88, 0x61, 0xa4, 0xff, 0xbc, 0x04, 0x75, 0x79,
-	0xae, 0x0b, 0x16, 0x6f, 0x63, 0xa7, 0xbf, 0x6e, 0xfc, 0xa8, 0x53, 0x12, 0x16, 0x7d, 0xa7, 0x3f,
-	0xec, 0x28, 0x4c, 0x83, 0xea, 0xf6, 0xee, 0xfe, 0xfa, 0xb0, 0x53, 0x16, 0x56, 0x70, 0x63, 0x7f,
-	0x7f, 0xb7, 0x53, 0x61, 0x4d, 0x50, 0xb7, 0xd6, 0x87, 0xbd, 0xe1, 0xce, 0x5e, 0xaf, 0x53, 0x15,
-	0x7d, 0x1f, 0xf5, 0xf6, 0x3b, 0x35, 0xd1, 0x78, 0xb6, 0xb3, 0xd5, 0xa9, 0x0b, 0xfa, 0xd3, 0xf5,
-	0xc1, 0xe0, 0x8b, 0x7d, 0x63, 0xab, 0xa3, 0xa2, 0x25, 0x1d, 0x1a, 0x3b, 0xfd, 0x47, 0x1d, 0x4d,
-	0xb4, 0xf7, 0x37, 0x1e, 0xf7, 0x36, 0x87, 0x1d, 0xd0, 0x3f, 0x81, 0x46, 0x8e, 0x57, 0x62, 0xb4,
-	0xd1, 0xdb, 0xee, 0xcc, 0x89, 0x25, 0x9f, 0xaf, 0xef, 0x3e, 0x13, 0x86, 0xb7, 0x0d, 0x80, 0xcd,
-	0xd1, 0xee, 0x7a, 0xff, 0x51, 0x47, 0x91, 0x6e, 0xdb, 0x1f, 0x95, 0xd2, 0x91, 0x58, 0x54, 0xf8,
-	0x10, 0x54, 0xc9, 0xe7, 0x24, 0xd8, 0x6f, 0xe4, 0x2e, 0xc4, 0x48, 0x89, 0x45, 0xbe, 0x94, 0x8b,
-	0x7c, 0xc1, 0x08, 0x2d, 0x70, 0x9d, 0x98, 0xa4, 0x4a, 0xc8, 0x2e, 0x42, 0x02, 0x4f, 0x65, 0x34,
-	0x79, 0x69, 0x12, 0x7a, 0x5c, 0x51, 0x4b, 0x1d, 0x45, 0xff, 0x14, 0x20, 0x2b, 0xe2, 0xcc, 0x70,
-	0x48, 0xae, 0x42, 0xd5, 0x74, 0x1d, 0x33, 0x89, 0x07, 0x09, 0xd0, 0xfb, 0xd0, 0xc8, 0x95, 0x7e,
-	0xc4, 0x55, 0x9a, 0xae, 0x2b, 0x6c, 0x07, 0x3d, 0x1c, 0xd5, 0xa8, 0x9b, 0xae, 0xfb, 0x84, 0x9f,
-	0x47, 0xc2, 0x19, 0xa4, 0xaa, 0x91, 0x32, 0x55, 0x70, 0xc0, 0xa1, 0x06, 0x11, 0xf5, 0x8f, 0xa1,
-	0xb6, 0x9d, 0xb8, 0xcc, 0x89, 0x24, 0x95, 0x2e, 0x93, 0x24, 0xfd, 0x33, 0xb9, 0x67, 0xac, 0x59,
-	0xb0, 0x3b, 0xb2, 0x3a, 0x15, 0x51, 0x2d, 0xac, 0x94, 0x65, 0x14, 0xa8, 0x93, 0x2c, 0x4c, 0x61,
-	0x67, 0x7d, 0x0b, 0xd4, 0x57, 0xd6, 0xfb, 0x24, 0x03, 0x94, 0x8c, 0x01, 0x33, 0x2a, 0x80, 0xfa,
-	0x8f, 0x01, 0xb2, 0x2a, 0x96, 0x14, 0x6c, 0x9a, 0x45, 0x08, 0xf6, 0x6d, 0x50, 0xad, 0x63, 0xc7,
-	0xb5, 0x43, 0xee, 0x15, 0x4e, 0x9d, 0xd5, 0xbd, 0x52, 0x3a, 0x5b, 0x86, 0x0a, 0x16, 0xe7, 0xca,
-	0x99, 0x6e, 0x4b, 0x2b, 0x73, 0x48, 0xd1, 0xcf, 0xa0, 0x45, 0x5e, 0xf6, 0x1b, 0xf8, 0x28, 0x45,
-	0xbd, 0xa3, 0x5c, 0xd0, 0x3b, 0xd7, 0xa0, 0x86, 0xa6, 0x31, 0x39, 0x8d, 0x84, 0x2e, 0xd1, 0x47,
-	0x7f, 0xa8, 0x00, 0xd0, 0xd2, 0x7d, 0xdf, 0xe6, 0xc5, 0x70, 0xb6, 0x34, 0x1d, 0xce, 0x32, 0xa8,
-	0xa4, 0x75, 0x57, 0xcd, 0xc0, 0x76, 0x66, 0x2e, 0x64, 0x88, 0x4b, 0xe6, 0xe2, 0x1d, 0xd0, 0xd0,
-	0x55, 0x71, 0x7e, 0x86, 0xc5, 0x00, 0xb1, 0x60, 0x86, 0xc8, 0x57, 0x21, 0xab, 0xc5, 0x2a, 0x64,
-	0x5a, 0xaa, 0xa9, 0xd1, 0x6c, 0x54, 0xaa, 0x99, 0x51, 0x75, 0xa2, 0x1c, 0x43, 0xc4, 0xc3, 0x38,
-	0x09, 0x90, 0x09, 0x4a, 0x63, 0x3d, 0x4d, 0xf6, 0x35, 0x29, 0x4b, 0xe0, 0xf9, 0x23, 0xcb, 0xf7,
-	0x0e, 0x5d, 0xc7, 0x8a, 0x65, 0xd5, 0x11, 0x3c, 0x7f, 0x53, 0x62, 0xf4, 0x87, 0xd0, 0x4c, 0xf8,
-	0x8f, 0xc5, 0x9d, 0xdb, 0x69, 0x1c, 0x54, 0xca, 0xee, 0x36, 0x63, 0xd3, 0x86, 0xd2, 0x2d, 0x25,
-	0x91, 0x90, 0xfe, 0xdf, 0xe5, 0x64, 0xb0, 0xac, 0x41, 0xbc, 0x9a, 0x87, 0xc5, 0xd0, 0x56, 0x79,
-	0xa3, 0xd0, 0xf6, 0xfb, 0xa0, 0xd9, 0x18, 0xad, 0x39, 0xa7, 0x89, 0x05, 0x58, 0x9c, 0x8e, 0xcc,
-	0x64, 0x3c, 0xe7, 0x9c, 0x72, 0x23, 0xeb, 0xfc, 0x9a, 0x7b, 0x48, 0xb9, 0x5d, 0x9d, 0xc5, 0xed,
-	0xda, 0x77, 0xe4, 0xf6, 0x7b, 0xd0, 0xf4, 0x7c, 0x6f, 0xe4, 0x4d, 0x5c, 0xd7, 0x3c, 0x70, 0xb9,
-	0x64, 0x77, 0xc3, 0xf3, 0xbd, 0xbe, 0x44, 0x09, 0xff, 0x31, 0xdf, 0x85, 0x1e, 0x75, 0x03, 0xfb,
-	0xcd, 0xe7, 0xfa, 0xe1, 0xd3, 0x5f, 0x81, 0x8e, 0x7f, 0xf0, 0x63, 0x6e, 0xc5, 0xc8, 0xb1, 0x11,
-	0xbe, 0x66, 0x72, 0x1e, 0xdb, 0x84, 0x17, 0x2c, 0xea, 0x8b, 0x77, 0x3d, 0x75, 0xcd, 0xad, 0x0b,
-	0xd7, 0xfc, 0x19, 0x68, 0x29, 0x97, 0x72, 0x91, 0xa1, 0x06, 0xd5, 0x9d, 0xfe, 0x56, 0xef, 0xcb,
-	0x4e, 0x49, 0xd8, 0x1a, 0xa3, 0xf7, 0xbc, 0x67, 0x0c, 0x7a, 0x1d, 0x45, 0xd8, 0x81, 0xad, 0xde,
-	0x6e, 0x6f, 0xd8, 0xeb, 0x94, 0xc9, 0x8f, 0xc0, 0x52, 0x80, 0xeb, 0x58, 0x4e, 0xac, 0x0f, 0x00,
-	0xb2, 0x70, 0x57, 0xe8, 0xec, 0x6c, 0x73, 0x32, 0xdf, 0x16, 0x27, 0xdb, 0x5a, 0x49, 0x1f, 0xa4,
-	0x72, 0x59, 0x50, 0x4d, 0x74, 0x7d, 0x0d, 0xb4, 0x3d, 0x33, 0xf8, 0x9c, 0x8a, 0x66, 0xb7, 0xa0,
-	0x1d, 0x98, 0x61, 0xec, 0x24, 0x1e, 0x3b, 0x29, 0xcb, 0xa6, 0xd1, 0x4a, 0xb1, 0x42, 0xf7, 0xea,
-	0x7f, 0x53, 0x82, 0xab, 0x7b, 0xfe, 0x29, 0x4f, 0x3d, 0xc2, 0xa7, 0xe6, 0xb9, 0xeb, 0x9b, 0xf6,
-	0x6b, 0xc4, 0x50, 0x84, 0x1c, 0xfe, 0x04, 0x8b, 0x58, 0x49, 0xc9, 0xcf, 0xd0, 0x08, 0xf3, 0x48,
-	0x7e, 0x93, 0xc0, 0xa3, 0x18, 0x89, 0x65, 0xd2, 0x3f, 0x02, 0x16, 0xa4, 0xef, 0x41, 0x2d, 0x3e,
-	0xf3, 0xb2, 0x02, 0x64, 0x35, 0xc6, 0x3c, 0xf1, 0x4c, 0x07, 0xb1, 0x3a, 0xdb, 0x41, 0xd4, 0x37,
-	0x41, 0x1b, 0x9e, 0x61, 0xa6, 0x74, 0x12, 0x15, 0x7c, 0x84, 0xd2, 0x2b, 0x7c, 0x04, 0x65, 0xca,
-	0x47, 0xf8, 0x4d, 0x09, 0x1a, 0x39, 0x4f, 0x97, 0xbd, 0x07, 0x95, 0xf8, 0xcc, 0x2b, 0xd6, 0xf9,
-	0x93, 0x45, 0x0c, 0x24, 0x5d, 0xc8, 0x06, 0x2a, 0x17, 0xb2, 0x81, 0x6c, 0x17, 0xe6, 0x49, 0xf3,
-	0x26, 0x87, 0x48, 0x92, 0x26, 0x37, 0xa7, 0x3c, 0x6b, 0xca, 0x26, 0x27, 0x47, 0x92, 0x99, 0x80,
-	0xf6, 0x51, 0x01, 0xb9, 0xb8, 0x0e, 0x57, 0x66, 0x74, 0xfb, 0x36, 0x75, 0x05, 0x7d, 0x09, 0x5a,
-	0xc3, 0x33, 0x6f, 0xe8, 0x8c, 0x79, 0x14, 0x9b, 0xe3, 0x00, 0x7d, 0x2c, 0x69, 0x39, 0x2b, 0x86,
-	0x12, 0x47, 0xfa, 0x07, 0xd0, 0x7c, 0xca, 0x79, 0x68, 0xf0, 0x28, 0xf0, 0xbd, 0x88, 0xe7, 0xb2,
-	0xb8, 0x64, 0xa6, 0x25, 0xa4, 0xff, 0x3e, 0x68, 0x22, 0xec, 0xdf, 0x30, 0x63, 0xeb, 0xf8, 0xdb,
-	0xa4, 0x05, 0x3e, 0x80, 0x7a, 0x40, 0x32, 0x25, 0xe3, 0x9f, 0x26, 0x9a, 0x6b, 0x29, 0x67, 0x46,
-	0x42, 0xd4, 0x7f, 0x0f, 0xae, 0x0c, 0x26, 0x07, 0x91, 0x15, 0x3a, 0x18, 0x4a, 0x26, 0xa6, 0x6c,
-	0x11, 0xd4, 0x20, 0xe4, 0x87, 0xce, 0x19, 0x4f, 0x24, 0x38, 0x85, 0xd9, 0x6d, 0xa8, 0x8f, 0xc5,
-	0x76, 0x78, 0xf6, 0x36, 0xb2, 0xa0, 0x69, 0x4f, 0x50, 0x8c, 0xa4, 0x83, 0xfe, 0x03, 0xb8, 0x5a,
-	0x9c, 0x5e, 0x1e, 0xf7, 0x26, 0x94, 0x4f, 0x4e, 0x23, 0x79, 0x8a, 0x85, 0x42, 0xd0, 0x85, 0xa5,
-	0x78, 0x41, 0xd5, 0xff, 0xa2, 0x04, 0xe5, 0xfe, 0x64, 0x9c, 0xff, 0x9e, 0xa8, 0x42, 0xdf, 0x13,
-	0x5d, 0xcf, 0x27, 0x54, 0xc9, 0xbf, 0xcf, 0x12, 0xa7, 0xef, 0x80, 0x76, 0xe8, 0x87, 0x3f, 0x35,
-	0x43, 0x9b, 0xdb, 0xd2, 0xc0, 0x65, 0x08, 0x76, 0x4b, 0x9a, 0x43, 0xf2, 0xaf, 0x17, 0x04, 0x03,
-	0xfb, 0x93, 0xf1, 0xaa, 0xcb, 0xcd, 0x08, 0xf5, 0x36, 0x59, 0x48, 0xfd, 0x0e, 0x68, 0x29, 0x4a,
-	0xe8, 0x9a, 0xfe, 0x60, 0xb4, 0xb3, 0x45, 0x09, 0x29, 0xe1, 0x89, 0x96, 0x84, 0x9e, 0x19, 0x7e,
-	0xd9, 0x1f, 0x0d, 0x07, 0x1d, 0x45, 0xff, 0x0a, 0x1a, 0x89, 0x28, 0xee, 0xd8, 0x58, 0x7d, 0xc1,
-	0xb7, 0xb0, 0x63, 0x17, 0x9e, 0xc6, 0x0e, 0x86, 0x0a, 0xdc, 0xb3, 0x77, 0x12, 0x19, 0x26, 0xa0,
-	0x78, 0x1a, 0x59, 0xca, 0x49, 0x4e, 0xa3, 0x6f, 0x43, 0x33, 0x89, 0xf7, 0xf6, 0x78, 0x6c, 0xe2,
-	0xeb, 0x72, 0x9d, 0x42, 0x2c, 0xa4, 0x12, 0x62, 0x58, 0x4c, 0x34, 0x2a, 0x05, 0x0f, 0x44, 0x5f,
-	0x85, 0x9a, 0x7c, 0xba, 0x0c, 0x2a, 0x96, 0x6f, 0x93, 0x7a, 0xa9, 0x1a, 0xd8, 0x16, 0x2c, 0x1e,
-	0x47, 0x47, 0x89, 0x77, 0x35, 0x8e, 0x8e, 0xf4, 0xbf, 0x53, 0xa0, 0xb5, 0x81, 0xd1, 0x75, 0x22,
-	0x13, 0xb9, 0x9c, 0x52, 0xa9, 0x90, 0x53, 0xca, 0xe7, 0x8f, 0x94, 0x42, 0xfe, 0xa8, 0xb0, 0xa1,
-	0x72, 0xd1, 0x25, 0x7a, 0x0b, 0xea, 0x13, 0xcf, 0x39, 0x4b, 0x74, 0x92, 0x66, 0xd4, 0x04, 0x38,
-	0x8c, 0xd8, 0x32, 0x34, 0x84, 0xda, 0x72, 0x3c, 0xca, 0xd9, 0x50, 0xe2, 0x25, 0x8f, 0x9a, 0xca,
-	0xcc, 0xd4, 0x5e, 0x9d, 0x99, 0xa9, 0xbf, 0x36, 0x33, 0xa3, 0xbe, 0x2e, 0x33, 0xa3, 0x4d, 0x67,
-	0x66, 0x8a, 0xee, 0x1c, 0x4c, 0xbb, 0x73, 0xfa, 0x2e, 0xb4, 0x13, 0xde, 0x49, 0x81, 0x7f, 0x08,
-	0xf3, 0x32, 0xa9, 0xca, 0x43, 0x99, 0x97, 0x20, 0x95, 0x87, 0x12, 0x48, 0x79, 0x4f, 0x49, 0x31,
-	0xda, 0x76, 0x1e, 0x8c, 0xf4, 0x5f, 0x96, 0xa0, 0x55, 0xe8, 0xc1, 0x3e, 0xc9, 0x52, 0xb4, 0x25,
-	0x94, 0xe3, 0xee, 0x85, 0x59, 0x5e, 0x9d, 0xa6, 0x55, 0xa6, 0xd2, 0xb4, 0xfa, 0xdd, 0x34, 0xf9,
-	0x2a, 0x53, 0xae, 0x73, 0x69, 0xca, 0x15, 0xb3, 0x94, 0xeb, 0xc3, 0xa1, 0xd1, 0x51, 0x58, 0x0d,
-	0x94, 0xfe, 0xa0, 0x53, 0xd6, 0x7f, 0xa5, 0x40, 0xab, 0x77, 0x16, 0xe0, 0x97, 0x35, 0xaf, 0x75,
-	0x7e, 0x73, 0x82, 0xa3, 0x14, 0x04, 0x27, 0x27, 0x02, 0x65, 0x59, 0x73, 0x22, 0x11, 0x10, 0xee,
-	0x30, 0x25, 0x82, 0xa4, 0x68, 0x10, 0xf4, 0xff, 0x41, 0x34, 0x0a, 0x55, 0x03, 0x98, 0xae, 0x1a,
-	0xec, 0x42, 0x3b, 0x61, 0x9b, 0x14, 0x8c, 0x37, 0x7a, 0x8d, 0xf4, 0xcd, 0x9c, 0x9b, 0xa6, 0x2c,
-	0x08, 0xd0, 0xff, 0x52, 0x01, 0x8d, 0xe4, 0x4c, 0x6c, 0xfe, 0x23, 0xa9, 0xd9, 0x4a, 0x59, 0x82,
-	0x3a, 0x25, 0xae, 0x3e, 0xe1, 0xe7, 0x99, 0x76, 0x9b, 0x59, 0xd4, 0x91, 0x89, 0x0d, 0x0a, 0x5e,
-	0x31, 0xb1, 0x71, 0x1d, 0x34, 0xb2, 0xf1, 0x13, 0x99, 0x1d, 0xad, 0x18, 0x64, 0xf4, 0x9f, 0x39,
-	0x58, 0x9e, 0x89, 0x79, 0x38, 0x96, 0x77, 0x80, 0xed, 0x62, 0x20, 0xd0, 0x4a, 0x5c, 0xd3, 0x02,
-	0x47, 0xea, 0xd3, 0x1c, 0x39, 0x86, 0xba, 0xdc, 0x9b, 0xf0, 0xe3, 0x9e, 0xf5, 0x9f, 0xf4, 0xf7,
-	0xbf, 0xe8, 0x17, 0xa4, 0x2f, 0xf5, 0xf4, 0x94, 0xbc, 0xa7, 0x57, 0x16, 0xf8, 0xcd, 0xfd, 0x67,
-	0xfd, 0x61, 0xa7, 0xc2, 0x5a, 0xa0, 0x61, 0x73, 0x64, 0xf4, 0x9e, 0x77, 0xaa, 0x98, 0x17, 0xd8,
-	0xfc, 0xbc, 0xb7, 0xb7, 0xde, 0xa9, 0xa5, 0xe5, 0x82, 0xba, 0xfe, 0xe7, 0x25, 0x58, 0x20, 0x86,
-	0xe4, 0x43, 0xfc, 0xfc, 0x87, 0xaf, 0x15, 0xf9, 0xe1, 0xeb, 0xff, 0x6d, 0xd8, 0x7f, 0x1d, 0xb4,
-	0x89, 0x93, 0x14, 0xe8, 0x28, 0xf2, 0x57, 0x27, 0x8e, 0xac, 0xcb, 0xfd, 0x63, 0x09, 0x16, 0xc9,
-	0xc1, 0x7c, 0x14, 0x9a, 0xc1, 0xf1, 0x0f, 0x77, 0x2f, 0x84, 0x98, 0x97, 0xb9, 0x5d, 0xb7, 0xa0,
-	0x8d, 0x9f, 0x06, 0xff, 0xc4, 0x1d, 0xc9, 0x30, 0x88, 0x6e, 0xb7, 0x25, 0xb1, 0x34, 0x11, 0x7b,
-	0x00, 0x4d, 0xfa, 0x84, 0x18, 0x93, 0x94, 0x85, 0xe2, 0x52, 0xc1, 0xbd, 0x6d, 0x50, 0x2f, 0x2a,
-	0x85, 0x7d, 0x92, 0x0e, 0xca, 0xa2, 0xd1, 0x8b, 0xf5, 0x23, 0x39, 0x64, 0x88, 0x31, 0xea, 0x3d,
-	0xb8, 0x3e, 0xf3, 0x1c, 0x52, 0xec, 0x73, 0x69, 0x34, 0x92, 0x36, 0xfd, 0x57, 0x25, 0x50, 0x37,
-	0x26, 0xee, 0x09, 0x5a, 0xb9, 0x77, 0x01, 0xb8, 0x7d, 0xc4, 0xe5, 0x07, 0xb6, 0x25, 0x54, 0x0e,
-	0x9a, 0xc0, 0xd0, 0x27, 0xb6, 0x0f, 0x01, 0xe8, 0x8c, 0xa3, 0xb1, 0x19, 0xc8, 0x2b, 0xc2, 0x62,
-	0x4f, 0x32, 0x81, 0x3c, 0xcb, 0x9e, 0x19, 0xc8, 0x62, 0x4f, 0x94, 0xc0, 0x8b, 0x7d, 0x68, 0x17,
-	0x89, 0x33, 0x72, 0x2b, 0x1f, 0x14, 0x3f, 0x21, 0xb8, 0xc8, 0x9d, 0x9c, 0xab, 0xf7, 0x18, 0xe6,
-	0xa7, 0x32, 0x99, 0xaf, 0xd2, 0x85, 0x85, 0xc7, 0xa0, 0x4c, 0x3d, 0x86, 0xb5, 0x7f, 0x28, 0x41,
-	0x45, 0xb8, 0x73, 0xec, 0x2e, 0x68, 0x9f, 0x73, 0x33, 0x8c, 0x0f, 0xb8, 0x19, 0xb3, 0x82, 0xeb,
-	0xb6, 0x88, 0x5c, 0xcf, 0xbe, 0x1a, 0xd0, 0xe7, 0xee, 0x97, 0xd8, 0x2a, 0x7d, 0xad, 0x98, 0x7c,
-	0x85, 0xd9, 0x4a, 0xdc, 0x42, 0x74, 0x1b, 0x17, 0x0b, 0xe3, 0xf5, 0xb9, 0x15, 0xec, 0xff, 0xd8,
-	0x77, 0xbc, 0x4d, 0xfa, 0x46, 0x8e, 0x4d, 0xbb, 0x91, 0xd3, 0x23, 0xd8, 0x5d, 0xa8, 0xed, 0x44,
-	0xc2, 0x5f, 0xbd, 0xd8, 0x15, 0x79, 0x93, 0x77, 0x65, 0xf5, 0xb9, 0xb5, 0xdf, 0x94, 0xa1, 0xf2,
-	0x15, 0x0f, 0x7d, 0xf6, 0x31, 0xd4, 0xe5, 0x37, 0x16, 0x2c, 0xf7, 0x2d, 0xc5, 0x22, 0x86, 0xce,
-	0x53, 0x1f, 0x5f, 0xe0, 0x2a, 0x1d, 0x62, 0x6f, 0x96, 0x5e, 0x67, 0xd9, 0x27, 0x20, 0x17, 0x36,
-	0xf5, 0x19, 0x74, 0x06, 0x71, 0xc8, 0xcd, 0x71, 0xae, 0x7b, 0x91, 0x55, 0xb3, 0x72, 0xf5, 0xc8,
-	0xaf, 0x3b, 0x50, 0xa3, 0xa0, 0x60, 0x6a, 0xc0, 0x74, 0x22, 0x1e, 0x3b, 0x7f, 0x08, 0x8d, 0xc1,
-	0xb1, 0x3f, 0x71, 0xed, 0x01, 0x0f, 0x4f, 0x39, 0xcb, 0x7d, 0xad, 0xb5, 0x98, 0x6b, 0xeb, 0x73,
-	0xec, 0x43, 0xd0, 0xc8, 0x0d, 0x14, 0x4e, 0x60, 0x5d, 0x7a, 0x96, 0x34, 0x67, 0xce, 0x3d, 0xd4,
-	0xe7, 0xd8, 0x0a, 0x40, 0x2e, 0x34, 0x78, 0x55, 0xcf, 0x07, 0xd0, 0xda, 0x44, 0x7d, 0xb2, 0x1f,
-	0xae, 0x1f, 0xf8, 0x61, 0xcc, 0xa6, 0x3f, 0xcf, 0x5a, 0x9c, 0x46, 0xe8, 0x73, 0xec, 0x3e, 0xa8,
-	0xc3, 0xf0, 0x9c, 0xfa, 0x2f, 0xc8, 0x88, 0x2a, 0x5b, 0x6f, 0xc6, 0x21, 0xd9, 0xa7, 0xa9, 0x0c,
-	0x27, 0xa2, 0xc8, 0x66, 0xa5, 0xe8, 0xe9, 0xbc, 0xe4, 0x46, 0xea, 0x73, 0x6b, 0x7f, 0x55, 0x85,
-	0xda, 0x17, 0x7e, 0x78, 0xc2, 0x43, 0x76, 0x1b, 0x6a, 0x58, 0x5b, 0x91, 0xb2, 0x97, 0xd6, 0x59,
-	0x66, 0x6d, 0xef, 0x7d, 0xd0, 0x90, 0x93, 0x43, 0x33, 0x3a, 0xa1, 0xfb, 0xc5, 0x2f, 0xf3, 0x69,
-	0x72, 0xca, 0xe5, 0xa0, 0x30, 0xb4, 0xe9, 0x76, 0xd3, 0xda, 0x63, 0xa1, 0xf6, 0xb1, 0x88, 0x5c,
-	0x7b, 0xf2, 0x7c, 0x20, 0xe4, 0xf9, 0x7e, 0x49, 0x18, 0xbf, 0x01, 0xf1, 0x47, 0x74, 0xca, 0xbe,
-	0x48, 0xa6, 0xe7, 0x92, 0x7d, 0x02, 0xac, 0xcf, 0xb1, 0x7b, 0x50, 0x93, 0xba, 0x70, 0x21, 0x7b,
-	0xd7, 0xc9, 0x09, 0x3b, 0x79, 0x94, 0x1c, 0xf0, 0x09, 0xd4, 0xc8, 0x6e, 0xd0, 0x80, 0x82, 0x57,
-	0xbc, 0xc8, 0xf2, 0xa8, 0xe4, 0x05, 0xb0, 0x3b, 0x50, 0x97, 0x95, 0x13, 0x36, 0xa3, 0x8c, 0x52,
-	0xe4, 0xa3, 0x98, 0x9f, 0x9c, 0x02, 0x9a, 0xbf, 0xe0, 0x57, 0xd1, 0xfc, 0x45, 0x9f, 0x81, 0x9e,
-	0x8a, 0xc1, 0x2d, 0xee, 0xe4, 0x52, 0x08, 0x2c, 0xe1, 0xc8, 0x8c, 0xf7, 0xfe, 0x19, 0xb4, 0x0a,
-	0xe9, 0x06, 0x86, 0xfe, 0xe2, 0xac, 0x0c, 0xc4, 0x85, 0x57, 0xf6, 0x03, 0xd0, 0x64, 0x04, 0x77,
-	0xc0, 0x19, 0x96, 0x23, 0x66, 0xc4, 0x8b, 0x8b, 0x17, 0x43, 0x38, 0x7c, 0x3a, 0x5f, 0xc2, 0x95,
-	0x19, 0x46, 0x80, 0xe1, 0x97, 0x6f, 0x97, 0x5b, 0xb9, 0xc5, 0xa5, 0x4b, 0xe9, 0x29, 0x03, 0xbe,
-	0x93, 0xc4, 0x6e, 0x74, 0xff, 0xe9, 0xeb, 0x1b, 0xa5, 0x5f, 0x7f, 0x7d, 0xa3, 0xf4, 0x1f, 0x5f,
-	0xdf, 0x28, 0xfd, 0xf2, 0x9b, 0x1b, 0x73, 0xbf, 0xfe, 0xe6, 0xc6, 0xdc, 0xbf, 0x7e, 0x73, 0x63,
-	0xee, 0xa0, 0x86, 0x7f, 0x87, 0x79, 0xf0, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xba, 0xa6, 0x45,
-	0xeb, 0x84, 0x33, 0x00, 0x00,
+	// 5197 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x7b, 0xcb, 0x6f, 0x1c, 0xe9,
+	0x71, 0x38, 0xa7, 0xe7, 0xd5, 0x5d, 0xf3, 0xd0, 0xf0, 0x93, 0x56, 0x1e, 0x53, 0xbb, 0x92, 0xb6,
+	0x65, 0xed, 0x72, 0xa5, 0x15, 0xa5, 0xa5, 0x6c, 0xfc, 0xbc, 0x6b, 0xfc, 0x80, 0xf0, 0x31, 0xd2,
+	0x72, 0x45, 0x0d, 0xe5, 0xe6, 0x48, 0x7e, 0x00, 0xc9, 0xa0, 0x39, 0xfd, 0x91, 0x6c, 0xb3, 0xa7,
+	0xbb, 0xdd, 0xdd, 0x43, 0x93, 0xbe, 0x19, 0x01, 0x6c, 0xe4, 0x66, 0x20, 0x97, 0x9c, 0x12, 0x20,
+	0x87, 0x5c, 0x72, 0x08, 0x12, 0xc0, 0x40, 0x10, 0x20, 0xb7, 0x20, 0x08, 0x72, 0x89, 0x8f, 0x39,
+	0x24, 0x8b, 0x60, 0x1d, 0xe4, 0xb0, 0xb7, 0x20, 0xff, 0x40, 0x50, 0x55, 0x5f, 0xbf, 0x86, 0xa3,
+	0xc7, 0x3a, 0xc8, 0x21, 0xa7, 0xf9, 0xaa, 0xea, 0x7b, 0xd6, 0x57, 0x5f, 0x3d, 0x7b, 0x40, 0x0f,
+	0x0f, 0xd6, 0xc2, 0x28, 0x48, 0x02, 0xa1, 0x85, 0x07, 0x2b, 0x86, 0x1d, 0xba, 0x0c, 0xae, 0xdc,
+	0x39, 0x72, 0x93, 0xe3, 0xd9, 0xc1, 0xda, 0x24, 0x98, 0xde, 0x77, 0x8e, 0x22, 0x3b, 0x3c, 0xbe,
+	0xe7, 0x06, 0xf7, 0x0f, 0x6c, 0xe7, 0x48, 0x46, 0xf7, 0x4f, 0x1f, 0xde, 0x0f, 0x0f, 0xee, 0xa7,
+	0x43, 0x57, 0xee, 0x15, 0xfa, 0x1e, 0x05, 0x47, 0xc1, 0x7d, 0x42, 0x1f, 0xcc, 0x0e, 0x09, 0x22,
+	0x80, 0x5a, 0xdc, 0xdd, 0x1c, 0x40, 0x6d, 0xd7, 0x8d, 0x13, 0x21, 0xa0, 0x36, 0x73, 0x9d, 0xb8,
+	0x5f, 0xb9, 0x59, 0x5d, 0x6d, 0x58, 0xd4, 0x16, 0x1f, 0xc0, 0xf2, 0x81, 0x9b, 0x4c, 0xed, 0x70,
+	0xec, 0x04, 0x63, 0x3f, 0x48, 0xc6, 0xb3, 0x58, 0xf6, 0xb5, 0x9b, 0x95, 0xd5, 0xb6, 0xd5, 0x65,
+	0xc2, 0x76, 0x30, 0x0c, 0x92, 0xe7, 0xb1, 0x34, 0x9f, 0x82, 0x31, 0xb2, 0xe3, 0x93, 0x17, 0xb6,
+	0x37, 0x93, 0xa2, 0x07, 0xd5, 0x53, 0xdb, 0xeb, 0x57, 0xa8, 0x27, 0x36, 0xc5, 0x1a, 0xe8, 0xa7,
+	0xb6, 0x37, 0x4e, 0xce, 0x43, 0x9e, 0xa0, 0xbb, 0x7e, 0x79, 0x2d, 0x3c, 0x58, 0x7b, 0x16, 0xc4,
+	0x89, 0xeb, 0x1f, 0xad, 0xbd, 0xb0, 0xbd, 0xd1, 0x79, 0x28, 0xad, 0xe6, 0x29, 0x37, 0xcc, 0x3d,
+	0x68, 0xed, 0x47, 0x93, 0x47, 0x33, 0x7f, 0x92, 0xb8, 0x81, 0x8f, 0x9b, 0xf3, 0xed, 0xa9, 0xa4,
+	0x19, 0x0d, 0x8b, 0xda, 0x88, 0xb3, 0xa3, 0xa3, 0xb8, 0x5f, 0xbd, 0x59, 0x45, 0x1c, 0xb6, 0x45,
+	0x1f, 0x9a, 0x6e, 0xbc, 0x15, 0xcc, 0xfc, 0xa4, 0x5f, 0xbb, 0x59, 0x59, 0xd5, 0xad, 0x14, 0x34,
+	0xff, 0xa4, 0x0a, 0xf5, 0xef, 0xce, 0x64, 0x74, 0x4e, 0xe3, 0x92, 0x24, 0x4a, 0xe7, 0xc2, 0xb6,
+	0xb8, 0x02, 0x75, 0xcf, 0xf6, 0x8f, 0xe2, 0xbe, 0x46, 0x93, 0x31, 0x20, 0xae, 0x81, 0x61, 0x1f,
+	0x26, 0x32, 0x1a, 0xcf, 0x5c, 0xa7, 0x5f, 0xbd, 0x59, 0x59, 0x6d, 0x58, 0x3a, 0x21, 0x9e, 0xbb,
+	0x8e, 0xf8, 0x3a, 0xe8, 0x4e, 0x30, 0x9e, 0x14, 0xd7, 0x72, 0x02, 0x5a, 0x4b, 0xdc, 0x02, 0x7d,
+	0xe6, 0x3a, 0x63, 0xcf, 0x8d, 0x93, 0x7e, 0xfd, 0x66, 0x65, 0xb5, 0xb5, 0xae, 0xe3, 0x61, 0x91,
+	0xcd, 0x56, 0x73, 0xe6, 0x3a, 0xc4, 0xef, 0x3b, 0xa0, 0xc7, 0xd1, 0x64, 0x7c, 0x38, 0xf3, 0x27,
+	0xfd, 0x06, 0x75, 0xba, 0x84, 0x9d, 0x0a, 0xa7, 0xb6, 0x9a, 0x31, 0x03, 0x78, 0xac, 0x48, 0x9e,
+	0xca, 0x28, 0x96, 0xfd, 0x26, 0x2f, 0xa5, 0x40, 0xf1, 0x00, 0x5a, 0x87, 0xf6, 0x44, 0x26, 0xe3,
+	0xd0, 0x8e, 0xec, 0x69, 0x5f, 0xcf, 0x27, 0x7a, 0x84, 0xe8, 0x67, 0x88, 0x8d, 0x2d, 0x38, 0xcc,
+	0x00, 0xf1, 0x10, 0x3a, 0x04, 0xc5, 0xe3, 0x43, 0xd7, 0x4b, 0x64, 0xd4, 0x37, 0x68, 0x4c, 0x97,
+	0xc6, 0x10, 0x66, 0x14, 0x49, 0x69, 0xb5, 0xb9, 0x13, 0x63, 0xc4, 0x3b, 0x00, 0xf2, 0x2c, 0xb4,
+	0x7d, 0x67, 0x6c, 0x7b, 0x5e, 0x1f, 0x68, 0x0f, 0x06, 0x63, 0x36, 0x3c, 0x4f, 0x7c, 0x0d, 0xf7,
+	0x67, 0x3b, 0xe3, 0x24, 0xee, 0x77, 0x6e, 0x56, 0x56, 0x6b, 0x56, 0x03, 0xc1, 0x51, 0x8c, 0x7c,
+	0x9d, 0xd8, 0x93, 0x63, 0xd9, 0xef, 0xde, 0xac, 0xac, 0xd6, 0x2d, 0x06, 0x10, 0x7b, 0xe8, 0x46,
+	0x71, 0xd2, 0xbf, 0xc4, 0x58, 0x02, 0xcc, 0x75, 0x30, 0x48, 0x7a, 0x88, 0x3b, 0xb7, 0xa1, 0x71,
+	0x8a, 0x00, 0xcb, 0x63, 0x6b, 0xbd, 0x83, 0xdb, 0xcb, 0x04, 0xcc, 0x52, 0x44, 0xf3, 0x3a, 0xe8,
+	0xbb, 0xb6, 0x7f, 0x94, 0x0a, 0x30, 0x5e, 0x1b, 0x0d, 0x30, 0x2c, 0x6a, 0x9b, 0x7f, 0xa4, 0x41,
+	0xc3, 0x92, 0xf1, 0xcc, 0x4b, 0xc4, 0xfb, 0x00, 0x78, 0x29, 0x53, 0x3b, 0x89, 0xdc, 0x33, 0x35,
+	0x6b, 0x7e, 0x2d, 0xc6, 0xcc, 0x75, 0x9e, 0x12, 0x49, 0x3c, 0x80, 0x36, 0xcd, 0x9e, 0x76, 0xd5,
+	0xf2, 0x0d, 0x64, 0xfb, 0xb3, 0x5a, 0xd4, 0x45, 0x8d, 0xb8, 0x0a, 0x0d, 0x92, 0x03, 0x96, 0xc5,
+	0x8e, 0xa5, 0x20, 0x71, 0x1b, 0xba, 0xae, 0x9f, 0xe0, 0x3d, 0x4d, 0x92, 0xb1, 0x23, 0xe3, 0x54,
+	0x50, 0x3a, 0x19, 0x76, 0x5b, 0xc6, 0x89, 0xf8, 0x08, 0x98, 0xd9, 0xe9, 0x82, 0x75, 0x5a, 0xb0,
+	0x9b, 0x5d, 0x62, 0xcc, 0x2b, 0x52, 0x1f, 0xb5, 0xe2, 0x3d, 0x68, 0xe1, 0xf9, 0xd2, 0x11, 0x0d,
+	0x1a, 0xd1, 0xa6, 0xd3, 0x28, 0x76, 0x58, 0x80, 0x1d, 0x54, 0x77, 0x64, 0x0d, 0x0a, 0x23, 0x0b,
+	0x0f, 0xb5, 0xcd, 0x01, 0xd4, 0xf7, 0x22, 0x47, 0x46, 0x0b, 0xdf, 0x83, 0x80, 0x9a, 0x23, 0xe3,
+	0x09, 0x3d, 0x55, 0xdd, 0xa2, 0x76, 0xfe, 0x46, 0xaa, 0x85, 0x37, 0x62, 0xfe, 0x71, 0x05, 0x5a,
+	0xfb, 0x41, 0x94, 0x3c, 0x95, 0x71, 0x6c, 0x1f, 0x49, 0x71, 0x03, 0xea, 0x01, 0x4e, 0xab, 0x38,
+	0x6c, 0xe0, 0x9e, 0x68, 0x1d, 0x8b, 0xf1, 0x73, 0xf7, 0xa0, 0xbd, 0xfc, 0x1e, 0x50, 0x76, 0xe8,
+	0x75, 0x55, 0x95, 0xec, 0xd0, 0xdb, 0xba, 0x0a, 0x8d, 0xe0, 0xf0, 0x30, 0x96, 0xcc, 0xcb, 0xba,
+	0xa5, 0xa0, 0x97, 0x8a, 0xa0, 0xf9, 0x2d, 0x00, 0xdc, 0xdf, 0x57, 0x94, 0x02, 0xf3, 0x17, 0x15,
+	0x68, 0x59, 0xf6, 0x61, 0xb2, 0x15, 0xf8, 0x89, 0x3c, 0x4b, 0x44, 0x17, 0x34, 0xd7, 0x21, 0x1e,
+	0x35, 0x2c, 0xcd, 0x75, 0x70, 0x77, 0x47, 0x51, 0x30, 0x0b, 0x89, 0x45, 0x1d, 0x8b, 0x01, 0xe2,
+	0xa5, 0xe3, 0x44, 0xb4, 0x65, 0xe4, 0xa5, 0xe3, 0x44, 0xe2, 0x06, 0xb4, 0x62, 0xdf, 0x0e, 0xe3,
+	0xe3, 0x20, 0xc1, 0xdd, 0xd5, 0x68, 0x77, 0x90, 0xa2, 0x46, 0x31, 0x3e, 0x2e, 0x37, 0x1e, 0x7b,
+	0xd2, 0x8e, 0x7c, 0x19, 0x91, 0xc2, 0xd0, 0x2d, 0xc3, 0x8d, 0x77, 0x19, 0x61, 0xfe, 0xa2, 0x0a,
+	0x8d, 0xa7, 0x72, 0x7a, 0x20, 0xa3, 0x0b, 0x9b, 0x78, 0x00, 0x3a, 0xad, 0x3b, 0x76, 0x1d, 0xde,
+	0xc7, 0xe6, 0x5b, 0x5f, 0x7e, 0x7e, 0x63, 0x99, 0x70, 0x3b, 0xce, 0x87, 0xc1, 0xd4, 0x4d, 0xe4,
+	0x34, 0x4c, 0xce, 0xad, 0xa6, 0x42, 0x2d, 0xdc, 0xe0, 0x55, 0x68, 0x78, 0xd2, 0xc6, 0x3b, 0x63,
+	0xf1, 0x54, 0x90, 0xb8, 0x07, 0x4d, 0x7b, 0x3a, 0x76, 0xa4, 0xed, 0xf0, 0xa6, 0x36, 0xaf, 0x7c,
+	0xf9, 0xf9, 0x8d, 0x9e, 0x3d, 0xdd, 0x96, 0x76, 0x71, 0xee, 0x06, 0x63, 0xc4, 0xc7, 0x28, 0x93,
+	0x71, 0x32, 0x9e, 0x85, 0x8e, 0x9d, 0x48, 0xd2, 0x69, 0xb5, 0xcd, 0xfe, 0x97, 0x9f, 0xdf, 0xb8,
+	0x82, 0xe8, 0xe7, 0x84, 0x2d, 0x0c, 0x83, 0x1c, 0x8b, 0xfa, 0x2d, 0x3d, 0xbe, 0xd2, 0x6f, 0x0a,
+	0x14, 0x3b, 0xb0, 0x3c, 0xf1, 0x66, 0x31, 0x2a, 0x61, 0xd7, 0x3f, 0x0c, 0xc6, 0x81, 0xef, 0x9d,
+	0xd3, 0x05, 0xeb, 0x9b, 0xef, 0x7c, 0xf9, 0xf9, 0x8d, 0xaf, 0x2b, 0xe2, 0x8e, 0x7f, 0x18, 0xec,
+	0xf9, 0xde, 0x79, 0x61, 0xfe, 0x4b, 0x73, 0x24, 0xf1, 0x3b, 0xd0, 0x3d, 0x0c, 0xa2, 0x89, 0x1c,
+	0x67, 0x2c, 0xeb, 0xd2, 0x3c, 0x2b, 0x5f, 0x7e, 0x7e, 0xe3, 0x2a, 0x51, 0x1e, 0x5f, 0xe0, 0x5b,
+	0xbb, 0x88, 0x37, 0xff, 0x55, 0x83, 0x3a, 0xb5, 0xc5, 0x03, 0x68, 0x4e, 0xe9, 0x4a, 0x52, 0xfd,
+	0x74, 0x15, 0x65, 0x88, 0x68, 0x6b, 0x7c, 0x57, 0xf1, 0xc0, 0x4f, 0xa2, 0x73, 0x2b, 0xed, 0x86,
+	0x23, 0x12, 0xfb, 0xc0, 0x93, 0x49, 0xac, 0x64, 0xbe, 0x30, 0x62, 0xc4, 0x04, 0x35, 0x42, 0x75,
+	0x9b, 0x97, 0x9b, 0xea, 0x05, 0xb9, 0x59, 0x01, 0x7d, 0x72, 0x2c, 0x27, 0x27, 0xf1, 0x6c, 0xaa,
+	0xa4, 0x2a, 0x83, 0xc5, 0x2d, 0xe8, 0x50, 0x3b, 0x0c, 0x5c, 0x9f, 0x86, 0xd7, 0xa9, 0x43, 0x3b,
+	0x47, 0x8e, 0xe2, 0x95, 0x47, 0xd0, 0x2e, 0x6e, 0x16, 0xcd, 0xf6, 0x89, 0x3c, 0x27, 0xf9, 0xaa,
+	0x59, 0xd8, 0x14, 0x37, 0xa1, 0x4e, 0x8a, 0x8e, 0xa4, 0xab, 0xb5, 0x0e, 0xb8, 0x67, 0x1e, 0x62,
+	0x31, 0xe1, 0x13, 0xed, 0xdb, 0x15, 0x9c, 0xa7, 0x78, 0x84, 0xe2, 0x3c, 0xc6, 0xcb, 0xe7, 0xe1,
+	0x21, 0x85, 0x79, 0xcc, 0x00, 0x9a, 0xbb, 0xee, 0x44, 0xfa, 0x31, 0x19, 0xf7, 0x59, 0x2c, 0x33,
+	0xa5, 0x84, 0x6d, 0x3c, 0xef, 0xd4, 0x3e, 0x1b, 0x06, 0x8e, 0x8c, 0x69, 0x9e, 0x9a, 0x95, 0xc1,
+	0x48, 0x93, 0x67, 0xa1, 0x1b, 0x9d, 0x8f, 0x98, 0x53, 0x55, 0x2b, 0x83, 0x51, 0xba, 0xa4, 0x8f,
+	0x8b, 0x39, 0xa9, 0xa1, 0x56, 0xa0, 0xf9, 0xf3, 0x1a, 0xb4, 0x7f, 0x28, 0xa3, 0xe0, 0x59, 0x14,
+	0x84, 0x41, 0x6c, 0x7b, 0x62, 0xa3, 0xcc, 0x73, 0xbe, 0xdb, 0x9b, 0xb8, 0xdb, 0x62, 0xb7, 0xb5,
+	0xfd, 0xec, 0x12, 0xf8, 0xce, 0x8a, 0xb7, 0x62, 0x42, 0x83, 0xef, 0x7c, 0x01, 0xcf, 0x14, 0x05,
+	0xfb, 0xf0, 0x2d, 0xd3, 0x5e, 0xcb, 0xfc, 0x50, 0x14, 0x7c, 0x95, 0x53, 0xfb, 0xec, 0xf9, 0xce,
+	0xb6, 0xba, 0x5b, 0x05, 0x29, 0x2e, 0x8c, 0xce, 0xfc, 0x51, 0x7a, 0xa9, 0x19, 0x8c, 0x27, 0x45,
+	0x8e, 0xc4, 0x3b, 0xdb, 0xfd, 0x36, 0x91, 0x52, 0x50, 0xbc, 0x0d, 0xc6, 0xd4, 0x3e, 0x43, 0x85,
+	0xb6, 0xe3, 0xf0, 0xd3, 0xb4, 0x72, 0x84, 0x78, 0x17, 0xaa, 0xc9, 0x99, 0x4f, 0x6f, 0x0f, 0xbd,
+	0x07, 0xf4, 0x3b, 0x47, 0x67, 0xbe, 0x52, 0x7d, 0x16, 0xd2, 0xf0, 0x4e, 0x27, 0xae, 0x43, 0xce,
+	0x82, 0x61, 0x61, 0x53, 0xdc, 0x86, 0xa6, 0xc7, 0xb7, 0x45, 0x0e, 0x41, 0x6b, 0xbd, 0xc5, 0x7a,
+	0x94, 0x50, 0x56, 0x4a, 0x13, 0x1f, 0x82, 0x9e, 0x72, 0xa7, 0xdf, 0xa2, 0x7e, 0xbd, 0x94, 0x9f,
+	0x29, 0x1b, 0xad, 0xac, 0x87, 0x78, 0x00, 0x86, 0x23, 0x3d, 0x99, 0xc8, 0xb1, 0xcf, 0x8a, 0xbc,
+	0xc5, 0x8e, 0xe2, 0x36, 0x21, 0x87, 0xb1, 0x25, 0x7f, 0x3c, 0x93, 0x71, 0x62, 0xe9, 0x8e, 0x42,
+	0xac, 0xfc, 0x7f, 0xb8, 0x34, 0x77, 0x1d, 0x45, 0xf9, 0xeb, 0xb0, 0xfc, 0x5d, 0x29, 0xca, 0x5f,
+	0xad, 0x20, 0x73, 0x9f, 0xd5, 0x74, 0xbd, 0x67, 0x98, 0xff, 0x59, 0x85, 0x4b, 0xea, 0x29, 0x1c,
+	0xbb, 0xe1, 0x7e, 0xa2, 0x94, 0x12, 0x99, 0x1c, 0x25, 0x85, 0x35, 0x2b, 0x05, 0xc5, 0xff, 0x83,
+	0x06, 0xe9, 0x90, 0xf4, 0x29, 0xdf, 0xc8, 0xaf, 0x38, 0x1b, 0xce, 0x4f, 0x5b, 0xc9, 0x87, 0xea,
+	0x2e, 0xbe, 0x09, 0xf5, 0x9f, 0xca, 0x28, 0x60, 0x13, 0xda, 0x5a, 0xbf, 0xbe, 0x68, 0x1c, 0x32,
+	0x46, 0x0d, 0xe3, 0xce, 0xff, 0x53, 0x49, 0x80, 0xaf, 0x22, 0x09, 0xdf, 0x40, 0x33, 0x3a, 0x0d,
+	0x4e, 0xa5, 0xd3, 0x6f, 0xd2, 0x1e, 0x8b, 0xe2, 0x9b, 0x92, 0x52, 0x61, 0xd0, 0x17, 0x0a, 0x83,
+	0xf1, 0x72, 0x61, 0x58, 0xd9, 0x86, 0x56, 0x81, 0x2f, 0x0b, 0x2e, 0xea, 0x46, 0x59, 0x51, 0x18,
+	0x99, 0x92, 0x2c, 0xea, 0x9b, 0x6d, 0x80, 0x9c, 0x4b, 0xbf, 0xad, 0xd6, 0x32, 0x7f, 0x56, 0x81,
+	0x4b, 0x5b, 0x81, 0xef, 0x4b, 0x72, 0xb6, 0xf9, 0xce, 0xf3, 0xc7, 0x5b, 0x79, 0xe9, 0xe3, 0xfd,
+	0x00, 0xea, 0x31, 0x76, 0x56, 0xb3, 0x5f, 0x5e, 0x70, 0x89, 0x16, 0xf7, 0x40, 0x15, 0x3e, 0xb5,
+	0xcf, 0xc6, 0xa1, 0xf4, 0x1d, 0xd7, 0x3f, 0x4a, 0x55, 0xf8, 0xd4, 0x3e, 0x7b, 0xc6, 0x18, 0xf3,
+	0xaf, 0x35, 0x80, 0x4f, 0xa5, 0xed, 0x25, 0xc7, 0x68, 0xa6, 0xf0, 0x46, 0x5d, 0x3f, 0x4e, 0x6c,
+	0x7f, 0x92, 0x86, 0x3a, 0x19, 0x8c, 0x37, 0x8a, 0xd6, 0x5a, 0xc6, 0xac, 0xfc, 0x0c, 0x2b, 0x05,
+	0x51, 0x3e, 0x70, 0xb9, 0x59, 0xac, 0xac, 0xba, 0x82, 0x72, 0x17, 0xa5, 0x46, 0x68, 0xe5, 0xa2,
+	0xf4, 0xa1, 0x89, 0xa1, 0x83, 0x1b, 0xf8, 0x24, 0x34, 0x86, 0x95, 0x82, 0x38, 0xcf, 0x2c, 0x4c,
+	0xdc, 0x29, 0xdb, 0xee, 0xaa, 0xa5, 0x20, 0xdc, 0x15, 0xda, 0xea, 0xc1, 0xe4, 0x38, 0x20, 0x15,
+	0x51, 0xb5, 0x32, 0x18, 0x67, 0x0b, 0xfc, 0xa3, 0x00, 0x4f, 0xa7, 0x93, 0x5b, 0x98, 0x82, 0x7c,
+	0x16, 0x47, 0x9e, 0x21, 0xc9, 0x20, 0x52, 0x06, 0x23, 0x5f, 0xa4, 0x1c, 0x1f, 0x4a, 0x3b, 0x99,
+	0x45, 0x32, 0xee, 0x03, 0x91, 0x41, 0xca, 0x47, 0x0a, 0x23, 0xde, 0x85, 0x36, 0x32, 0xce, 0x8e,
+	0x63, 0xf7, 0xc8, 0x97, 0x0e, 0x29, 0x8e, 0x9a, 0x85, 0xcc, 0xdc, 0x50, 0x28, 0xf3, 0x6f, 0x35,
+	0x68, 0xb0, 0xca, 0x2c, 0xb9, 0x41, 0x95, 0x37, 0x72, 0x83, 0xde, 0x06, 0x23, 0x8c, 0xa4, 0xe3,
+	0x4e, 0xd2, 0x7b, 0x34, 0xac, 0x1c, 0x41, 0xf1, 0x09, 0xda, 0x7d, 0xe2, 0xa7, 0x6e, 0x31, 0x20,
+	0x4c, 0xe8, 0x04, 0xfe, 0xd8, 0x71, 0xe3, 0x93, 0xf1, 0xc1, 0x79, 0x22, 0x63, 0xc5, 0x8b, 0x56,
+	0xe0, 0x6f, 0xbb, 0xf1, 0xc9, 0x26, 0xa2, 0x90, 0x85, 0xfc, 0x46, 0xe8, 0x6d, 0xe8, 0x96, 0x82,
+	0xc4, 0x43, 0x30, 0xc8, 0x3b, 0x25, 0xf7, 0xc5, 0x20, 0xb7, 0xe3, 0xea, 0x97, 0x9f, 0xdf, 0x10,
+	0x88, 0x9c, 0xf3, 0x5b, 0xf4, 0x14, 0x87, 0xfe, 0x17, 0x0e, 0x46, 0x43, 0x44, 0x6f, 0x98, 0xfd,
+	0x2f, 0x44, 0x8d, 0xe2, 0xa2, 0xff, 0xc5, 0x18, 0x71, 0x0f, 0xc4, 0xcc, 0x9f, 0x04, 0xd3, 0x10,
+	0x85, 0x42, 0x3a, 0x6a, 0x93, 0x2d, 0xda, 0xe4, 0x72, 0x91, 0x42, 0x5b, 0x35, 0xff, 0x45, 0x83,
+	0xf6, 0xb6, 0x1b, 0xc9, 0x49, 0x22, 0x9d, 0x81, 0x73, 0x24, 0x71, 0xef, 0xd2, 0x4f, 0xdc, 0xe4,
+	0x5c, 0x39, 0x98, 0x0a, 0xca, 0xe2, 0x03, 0xad, 0x1c, 0x2f, 0xf3, 0x0b, 0xab, 0x52, 0x88, 0xcf,
+	0x80, 0x58, 0x07, 0xe0, 0xc8, 0x89, 0xc2, 0xfc, 0xda, 0xcb, 0xc3, 0x7c, 0x83, 0xba, 0x61, 0x13,
+	0xc3, 0x68, 0x1e, 0xe3, 0xb2, 0x97, 0xd9, 0xa0, 0x1c, 0xc0, 0x4c, 0xb2, 0xaf, 0x4a, 0x01, 0x5d,
+	0x93, 0x17, 0xc6, 0xb6, 0xb8, 0x05, 0x5a, 0x10, 0x12, 0x73, 0xd5, 0xd4, 0xc5, 0x23, 0xac, 0xed,
+	0x85, 0x96, 0x16, 0x84, 0xf8, 0x8a, 0x39, 0x7a, 0x25, 0xc1, 0xc3, 0x57, 0x8c, 0x16, 0x8d, 0x62,
+	0x29, 0x4b, 0x51, 0x84, 0x09, 0x6d, 0xdb, 0xf3, 0x82, 0x9f, 0x48, 0xe7, 0x59, 0x24, 0x9d, 0x54,
+	0x06, 0x4b, 0x38, 0x94, 0x12, 0xdf, 0x9e, 0xca, 0x38, 0xb4, 0x27, 0x52, 0x89, 0x60, 0x8e, 0x30,
+	0xaf, 0x82, 0xb6, 0x17, 0x8a, 0x26, 0x54, 0xf7, 0x07, 0xa3, 0xde, 0x12, 0x36, 0xb6, 0x07, 0xbb,
+	0x3d, 0xb4, 0x28, 0x8d, 0x5e, 0xd3, 0xfc, 0x42, 0x03, 0xe3, 0xe9, 0x2c, 0xb1, 0x51, 0xb7, 0xc4,
+	0x78, 0xca, 0xb2, 0x84, 0xe6, 0xa2, 0xf8, 0x75, 0xd0, 0xe3, 0xc4, 0x8e, 0xc8, 0xdf, 0x60, 0xeb,
+	0xd4, 0x24, 0x78, 0x14, 0x8b, 0xf7, 0xa0, 0x2e, 0x9d, 0x23, 0x99, 0x9a, 0x8b, 0xde, 0xfc, 0x79,
+	0x2d, 0x26, 0x8b, 0x55, 0x68, 0xc4, 0x93, 0x63, 0x39, 0xb5, 0xfb, 0xb5, 0xbc, 0xe3, 0x3e, 0x61,
+	0xd8, 0xc1, 0xb6, 0x14, 0x5d, 0x7c, 0x03, 0xea, 0x78, 0x37, 0xb1, 0x8a, 0x18, 0x29, 0xc6, 0xc4,
+	0x6b, 0x50, 0xdd, 0x98, 0x88, 0x82, 0xe7, 0x44, 0x41, 0x38, 0x0e, 0x42, 0xe2, 0x7d, 0x77, 0xfd,
+	0x0a, 0xe9, 0xb8, 0xf4, 0x34, 0x6b, 0xdb, 0x51, 0x10, 0xee, 0x85, 0x56, 0xc3, 0xa1, 0x5f, 0x8c,
+	0x5f, 0xa8, 0x3b, 0x4b, 0x04, 0x1b, 0x05, 0x03, 0x31, 0x9c, 0x0c, 0x5a, 0x05, 0x7d, 0x2a, 0x13,
+	0xdb, 0xb1, 0x13, 0x5b, 0xd9, 0x86, 0x36, 0xab, 0x4c, 0xc6, 0x59, 0x19, 0xd5, 0xbc, 0x0f, 0x0d,
+	0x9e, 0x5a, 0xe8, 0x50, 0x1b, 0xee, 0x0d, 0x07, 0xcc, 0xd6, 0x8d, 0xdd, 0xdd, 0x5e, 0x05, 0x51,
+	0xdb, 0x1b, 0xa3, 0x8d, 0x9e, 0x86, 0xad, 0xd1, 0x0f, 0x9e, 0x0d, 0x7a, 0x55, 0xf3, 0x1f, 0x2b,
+	0xa0, 0xa7, 0xf3, 0x88, 0x4f, 0x00, 0xf0, 0x09, 0x8f, 0x8f, 0x5d, 0x3f, 0x73, 0xdd, 0xae, 0x15,
+	0x57, 0x5a, 0xc3, 0x5b, 0xfd, 0x14, 0xa9, 0x6c, 0x5e, 0xe9, 0xc5, 0x13, 0xbc, 0xb2, 0x0f, 0xdd,
+	0x32, 0x71, 0x81, 0x0f, 0x7b, 0xb7, 0x68, 0x55, 0xba, 0xeb, 0x6f, 0x95, 0xa6, 0xc6, 0x91, 0x24,
+	0xda, 0x05, 0x03, 0x73, 0x0f, 0xf4, 0x14, 0x2d, 0x5a, 0xd0, 0xdc, 0x1e, 0x3c, 0xda, 0x78, 0xbe,
+	0x8b, 0xa2, 0x02, 0xd0, 0xd8, 0xdf, 0x19, 0x3e, 0xde, 0x1d, 0xf0, 0xb1, 0x76, 0x77, 0xf6, 0x47,
+	0x3d, 0xcd, 0xfc, 0xc3, 0x0a, 0xe8, 0xa9, 0x27, 0x23, 0x3e, 0x40, 0xe7, 0x83, 0xdc, 0x2f, 0x65,
+	0x89, 0x28, 0xa7, 0x53, 0x08, 0x48, 0xad, 0x94, 0x8e, 0x6f, 0x91, 0x14, 0x6b, 0xea, 0xdb, 0x10,
+	0x50, 0x8c, 0x87, 0xab, 0xa5, 0x94, 0x0c, 0x86, 0xf6, 0x81, 0x2f, 0x95, 0x2b, 0x4c, 0x6d, 0x92,
+	0x41, 0xd7, 0x9f, 0xc8, 0x3c, 0x50, 0x68, 0x12, 0x3c, 0x8a, 0xcd, 0x84, 0x3d, 0xe4, 0x6c, 0x63,
+	0xd9, 0x6a, 0x95, 0xe2, 0x6a, 0x17, 0xc2, 0x0d, 0xed, 0x62, 0xb8, 0x91, 0x1b, 0xce, 0xfa, 0xeb,
+	0x0c, 0xa7, 0xf9, 0x97, 0x35, 0xe8, 0x5a, 0x32, 0x4e, 0x82, 0x48, 0x2a, 0x8f, 0xef, 0x55, 0x4f,
+	0xe8, 0x1d, 0x80, 0x88, 0x3b, 0xe7, 0x4b, 0x1b, 0x0a, 0xc3, 0x71, 0x92, 0x17, 0x4c, 0x48, 0x76,
+	0x95, 0x85, 0xcc, 0x60, 0x71, 0x0d, 0x8c, 0x03, 0x7b, 0x72, 0xc2, 0xd3, 0xb2, 0x9d, 0xd4, 0x19,
+	0xc1, 0xf3, 0xda, 0x93, 0x89, 0x8c, 0xe3, 0x31, 0x8a, 0x02, 0x5b, 0x4b, 0x83, 0x31, 0x4f, 0xe4,
+	0x39, 0x92, 0x63, 0x39, 0x89, 0x64, 0x42, 0xe4, 0x06, 0x93, 0x19, 0x83, 0xe4, 0x5b, 0xd0, 0x89,
+	0x65, 0x8c, 0x96, 0x75, 0x9c, 0x04, 0x27, 0xd2, 0x57, 0x7a, 0xac, 0xad, 0x90, 0x23, 0xc4, 0xa1,
+	0x8a, 0xb1, 0xfd, 0xc0, 0x3f, 0x9f, 0x06, 0xb3, 0x58, 0xd9, 0x8c, 0x1c, 0x21, 0xd6, 0xe0, 0xb2,
+	0xf4, 0x27, 0xd1, 0x79, 0x88, 0x7b, 0xc5, 0x55, 0xc6, 0x87, 0xae, 0x27, 0x95, 0x13, 0xbe, 0x9c,
+	0x93, 0x9e, 0xc8, 0xf3, 0x47, 0xae, 0x27, 0x71, 0x47, 0xa7, 0xf6, 0xcc, 0x4b, 0xc6, 0x14, 0xe3,
+	0x03, 0xef, 0x88, 0x30, 0x1b, 0x18, 0xe8, 0xdf, 0x81, 0x65, 0x26, 0x47, 0x81, 0x27, 0x5d, 0x87,
+	0x27, 0x6b, 0x51, 0xaf, 0x4b, 0x44, 0xb0, 0x08, 0x4f, 0x53, 0xad, 0xc1, 0x65, 0xee, 0xcb, 0x07,
+	0x4a, 0x7b, 0xb7, 0x79, 0x69, 0x22, 0xed, 0x2b, 0x4a, 0x79, 0xe9, 0xd0, 0x4e, 0x8e, 0xc9, 0x73,
+	0x4f, 0x97, 0x7e, 0x66, 0x27, 0xc7, 0x68, 0xf1, 0x99, 0x7c, 0xe8, 0x4a, 0x8f, 0x23, 0x6f, 0xc3,
+	0xe2, 0x11, 0x8f, 0x10, 0x83, 0x16, 0x5f, 0x75, 0x08, 0xa2, 0xa9, 0xcd, 0xa9, 0x41, 0xc3, 0xe2,
+	0x41, 0x8f, 0x08, 0x85, 0x4b, 0xa8, 0xbb, 0xf2, 0x67, 0xd3, 0x7e, 0x8f, 0xaf, 0x99, 0x31, 0xc3,
+	0xd9, 0xd4, 0xfc, 0xa7, 0x2a, 0xe8, 0x59, 0x20, 0x77, 0x17, 0x8c, 0x69, 0xaa, 0xaf, 0x94, 0xa3,
+	0xd6, 0x29, 0x29, 0x31, 0x2b, 0xa7, 0x8b, 0x77, 0x40, 0x3b, 0x39, 0x55, 0xba, 0xb3, 0xb3, 0xc6,
+	0x59, 0xf5, 0xf0, 0xe0, 0xe1, 0xda, 0x93, 0x17, 0x96, 0x76, 0x72, 0xfa, 0x15, 0xe4, 0x56, 0xbc,
+	0x0f, 0x97, 0x26, 0x9e, 0xb4, 0xfd, 0x71, 0xee, 0x5d, 0xb0, 0x5c, 0x74, 0x09, 0xfd, 0x2c, 0x73,
+	0x31, 0x6e, 0x43, 0xdd, 0x91, 0x5e, 0x62, 0x17, 0x33, 0xb6, 0x7b, 0x91, 0x3d, 0xf1, 0xe4, 0x36,
+	0xa2, 0x2d, 0xa6, 0xa2, 0xee, 0xcc, 0x82, 0xa7, 0x82, 0xee, 0x5c, 0x10, 0x38, 0x65, 0xef, 0x12,
+	0x8a, 0xef, 0xf2, 0x2e, 0x2c, 0xcb, 0xb3, 0x90, 0x0c, 0xc6, 0x38, 0xcb, 0x15, 0xb0, 0x25, 0xeb,
+	0xa5, 0x84, 0xad, 0x34, 0x67, 0xf0, 0x21, 0xaa, 0x0c, 0x7a, 0x34, 0x74, 0xcd, 0xad, 0x75, 0x41,
+	0x3a, 0xa7, 0xf4, 0x0c, 0xad, 0xb4, 0x8b, 0xf8, 0x00, 0x8c, 0x89, 0x33, 0x19, 0x33, 0x67, 0x3a,
+	0xf9, 0xde, 0xb6, 0xb6, 0xb7, 0x98, 0x25, 0xfa, 0xc4, 0x99, 0xb0, 0x57, 0x5d, 0x0a, 0xea, 0xba,
+	0x6f, 0x10, 0xd4, 0x7d, 0x56, 0xd3, 0x9b, 0x3d, 0xdd, 0xbc, 0x05, 0x7a, 0x3a, 0x1b, 0xea, 0xb3,
+	0x58, 0xfa, 0x2a, 0x2a, 0x27, 0x7d, 0x86, 0xe0, 0x28, 0x36, 0x27, 0x50, 0x7d, 0xf2, 0x62, 0x9f,
+	0xd4, 0x1a, 0x5a, 0x98, 0x3a, 0x39, 0x24, 0xd4, 0xce, 0x54, 0x9d, 0x56, 0x50, 0x75, 0xd7, 0xd9,
+	0x4a, 0xd0, 0x2d, 0xa4, 0xa9, 0xcc, 0x02, 0x06, 0xf9, 0xc8, 0x16, 0xb2, 0xc6, 0x59, 0x4e, 0x02,
+	0xcc, 0xff, 0xa8, 0x42, 0x53, 0x39, 0x31, 0x68, 0x19, 0x66, 0x59, 0x16, 0x0e, 0x9b, 0xe5, 0xe8,
+	0x32, 0xf3, 0x86, 0x8a, 0x25, 0x8f, 0xea, 0xeb, 0x4b, 0x1e, 0xe2, 0x13, 0x68, 0x87, 0x4c, 0x2b,
+	0xfa, 0x4f, 0x5f, 0x2b, 0x8e, 0x51, 0xbf, 0x34, 0xae, 0x15, 0xe6, 0x00, 0x2a, 0x47, 0xca, 0x07,
+	0x27, 0xf6, 0x91, 0xe2, 0x40, 0x13, 0xe1, 0x91, 0x7d, 0xf4, 0x46, 0xce, 0x50, 0x97, 0xbc, 0xaa,
+	0x36, 0x69, 0x55, 0x74, 0xa0, 0x8a, 0x3e, 0x49, 0xa7, 0xec, 0x93, 0x5c, 0x03, 0x63, 0x12, 0x4c,
+	0xa7, 0x2e, 0xd1, 0xba, 0x2a, 0xeb, 0x44, 0x88, 0x51, 0x6c, 0xfe, 0xbc, 0x02, 0x4d, 0x75, 0xae,
+	0x0b, 0x16, 0x6f, 0x73, 0x67, 0xb8, 0x61, 0xfd, 0xa0, 0x57, 0x41, 0x8b, 0xbe, 0x33, 0x1c, 0xf5,
+	0x34, 0x61, 0x40, 0xfd, 0xd1, 0xee, 0xde, 0xc6, 0xa8, 0x57, 0x45, 0x2b, 0xb8, 0xb9, 0xb7, 0xb7,
+	0xdb, 0xab, 0x89, 0x36, 0xe8, 0xdb, 0x1b, 0xa3, 0xc1, 0x68, 0xe7, 0xe9, 0xa0, 0x57, 0xc7, 0xbe,
+	0x8f, 0x07, 0x7b, 0xbd, 0x06, 0x36, 0x9e, 0xef, 0x6c, 0xf7, 0x9a, 0x48, 0x7f, 0xb6, 0xb1, 0xbf,
+	0xff, 0xbd, 0x3d, 0x6b, 0xbb, 0xa7, 0x93, 0x25, 0x1d, 0x59, 0x3b, 0xc3, 0xc7, 0x3d, 0x03, 0xdb,
+	0x7b, 0x9b, 0x9f, 0x0d, 0xb6, 0x46, 0x3d, 0x30, 0x3f, 0x82, 0x56, 0x81, 0x57, 0x38, 0xda, 0x1a,
+	0x3c, 0xea, 0x2d, 0xe1, 0x92, 0x2f, 0x36, 0x76, 0x9f, 0xa3, 0xe1, 0xed, 0x02, 0x50, 0x73, 0xbc,
+	0xbb, 0x31, 0x7c, 0xdc, 0xd3, 0x94, 0xdb, 0xf6, 0x07, 0x95, 0x6c, 0x24, 0x15, 0x15, 0xde, 0x07,
+	0x5d, 0xf1, 0x39, 0x0d, 0xf6, 0x5b, 0x85, 0x0b, 0xb1, 0x32, 0x62, 0x99, 0x2f, 0xd5, 0x32, 0x5f,
+	0x28, 0x42, 0x0b, 0x3d, 0x37, 0x61, 0xa9, 0x42, 0xd9, 0x25, 0x08, 0xf1, 0x5c, 0x46, 0x53, 0x97,
+	0xa6, 0xa0, 0xcf, 0x6a, 0x7a, 0xa5, 0xa7, 0x99, 0xdf, 0x04, 0xc8, 0x8b, 0x38, 0x0b, 0x1c, 0x92,
+	0x2b, 0x50, 0xb7, 0x3d, 0xd7, 0x4e, 0xe3, 0x41, 0x06, 0xcc, 0x21, 0xb4, 0x0a, 0xa5, 0x1f, 0xbc,
+	0x4a, 0xdb, 0xf3, 0xd0, 0x76, 0xf0, 0xc3, 0xd1, 0xad, 0xa6, 0xed, 0x79, 0x4f, 0xe4, 0x79, 0x8c,
+	0xce, 0x20, 0x57, 0x8d, 0xb4, 0xb9, 0x82, 0x03, 0x0d, 0xb5, 0x98, 0x68, 0x7e, 0x08, 0x8d, 0x47,
+	0xa9, 0xcb, 0x9c, 0x4a, 0x52, 0xe5, 0x65, 0x92, 0x64, 0x7e, 0xac, 0xf6, 0x4c, 0x35, 0x0b, 0x71,
+	0x57, 0x55, 0xa7, 0x62, 0xae, 0x85, 0x55, 0xf2, 0x8c, 0x02, 0x77, 0x52, 0x85, 0x29, 0xea, 0x6c,
+	0x6e, 0x83, 0xfe, 0xca, 0x7a, 0x9f, 0x62, 0x80, 0x96, 0x33, 0x60, 0x41, 0x05, 0xd0, 0xfc, 0x11,
+	0x40, 0x5e, 0xc5, 0x52, 0x82, 0xcd, 0xb3, 0xa0, 0x60, 0xdf, 0x01, 0x7d, 0x72, 0xec, 0x7a, 0x4e,
+	0x24, 0xfd, 0xd2, 0xa9, 0xf3, 0xba, 0x57, 0x46, 0x17, 0x37, 0xa1, 0x46, 0xc5, 0xb9, 0x6a, 0xae,
+	0xdb, 0xb2, 0xca, 0x1c, 0x51, 0xcc, 0x33, 0xe8, 0xb0, 0x97, 0xfd, 0x06, 0x3e, 0x4a, 0x59, 0xef,
+	0x68, 0x17, 0xf4, 0xce, 0x55, 0x68, 0x90, 0x69, 0x4c, 0x4f, 0xa3, 0xa0, 0x97, 0xe8, 0xa3, 0xdf,
+	0xd7, 0x00, 0x78, 0xe9, 0x61, 0xe0, 0xc8, 0x72, 0x38, 0x5b, 0x99, 0x0f, 0x67, 0x05, 0xd4, 0xb2,
+	0xba, 0xab, 0x61, 0x51, 0x3b, 0x37, 0x17, 0x2a, 0xc4, 0x65, 0x73, 0xf1, 0x36, 0x18, 0xe4, 0xaa,
+	0xb8, 0x3f, 0xa5, 0x62, 0x00, 0x2e, 0x98, 0x23, 0x8a, 0x55, 0xc8, 0x7a, 0xb9, 0x0a, 0x99, 0x95,
+	0x6a, 0x1a, 0x3c, 0x1b, 0x97, 0x6a, 0x16, 0x54, 0x9d, 0x38, 0xc7, 0x10, 0xcb, 0x28, 0x49, 0x03,
+	0x64, 0x86, 0xb2, 0x58, 0xcf, 0x50, 0x7d, 0x6d, 0xce, 0x12, 0xf8, 0xc1, 0x78, 0x12, 0xf8, 0x87,
+	0x9e, 0x3b, 0x49, 0x54, 0xd5, 0x11, 0xfc, 0x60, 0x4b, 0x61, 0xcc, 0x4f, 0xa0, 0x9d, 0xf2, 0x9f,
+	0x8a, 0x3b, 0x77, 0xb2, 0x38, 0xa8, 0x92, 0xdf, 0x6d, 0xce, 0xa6, 0x4d, 0xad, 0x5f, 0x49, 0x23,
+	0x21, 0xf3, 0xbf, 0xaa, 0xe9, 0x60, 0x55, 0x83, 0x78, 0x35, 0x0f, 0xcb, 0xa1, 0xad, 0xf6, 0x46,
+	0xa1, 0xed, 0xb7, 0xc1, 0x70, 0x28, 0x5a, 0x73, 0x4f, 0x53, 0x0b, 0xb0, 0x32, 0x1f, 0x99, 0xa9,
+	0x78, 0xce, 0x3d, 0x95, 0x56, 0xde, 0xf9, 0x35, 0xf7, 0x90, 0x71, 0xbb, 0xbe, 0x88, 0xdb, 0x8d,
+	0xdf, 0x92, 0xdb, 0xef, 0x42, 0xdb, 0x0f, 0xfc, 0xb1, 0x3f, 0xf3, 0x3c, 0xfb, 0xc0, 0x93, 0x8a,
+	0xdd, 0x2d, 0x3f, 0xf0, 0x87, 0x0a, 0x85, 0xfe, 0x63, 0xb1, 0x0b, 0x3f, 0xea, 0x16, 0xf5, 0xbb,
+	0x54, 0xe8, 0x47, 0x4f, 0x7f, 0x15, 0x7a, 0xc1, 0xc1, 0x8f, 0xe4, 0x24, 0x21, 0x8e, 0x8d, 0xe9,
+	0x35, 0xb3, 0xf3, 0xd8, 0x65, 0x3c, 0xb2, 0x68, 0x88, 0xef, 0x7a, 0xee, 0x9a, 0x3b, 0x17, 0xae,
+	0xf9, 0x63, 0x30, 0x32, 0x2e, 0x15, 0x22, 0x43, 0x03, 0xea, 0x3b, 0xc3, 0xed, 0xc1, 0xf7, 0x7b,
+	0x15, 0xb4, 0x35, 0xd6, 0xe0, 0xc5, 0xc0, 0xda, 0x1f, 0xf4, 0x34, 0xb4, 0x03, 0xdb, 0x83, 0xdd,
+	0xc1, 0x68, 0xd0, 0xab, 0xb2, 0x1f, 0x41, 0xa5, 0x00, 0xcf, 0x9d, 0xb8, 0x89, 0xb9, 0x0f, 0x90,
+	0x87, 0xbb, 0xa8, 0xb3, 0xf3, 0xcd, 0xa9, 0x7c, 0x5b, 0x92, 0x6e, 0x6b, 0x35, 0x7b, 0x90, 0xda,
+	0xcb, 0x82, 0x6a, 0xa6, 0x9b, 0xeb, 0x60, 0x3c, 0xb5, 0xc3, 0x4f, 0xb9, 0x68, 0x76, 0x1b, 0xba,
+	0xa1, 0x1d, 0x25, 0x6e, 0xea, 0xb1, 0xb3, 0xb2, 0x6c, 0x5b, 0x9d, 0x0c, 0x8b, 0xba, 0xd7, 0xfc,
+	0xab, 0x0a, 0x5c, 0x79, 0x1a, 0x9c, 0xca, 0xcc, 0x23, 0x7c, 0x66, 0x9f, 0x7b, 0x81, 0xed, 0xbc,
+	0x46, 0x0c, 0x31, 0xe4, 0x08, 0x66, 0x54, 0xc4, 0x4a, 0x4b, 0x7e, 0x96, 0xc1, 0x98, 0xc7, 0xea,
+	0x9b, 0x04, 0x19, 0x27, 0x44, 0xac, 0xb2, 0xfe, 0x41, 0x18, 0x49, 0x6f, 0x41, 0x23, 0x39, 0xf3,
+	0xf3, 0x02, 0x64, 0x3d, 0xa1, 0x3c, 0xf1, 0x42, 0x07, 0xb1, 0xbe, 0xd8, 0x41, 0x34, 0xb7, 0xc0,
+	0x18, 0x9d, 0x51, 0xa6, 0x74, 0x16, 0x97, 0x7c, 0x84, 0xca, 0x2b, 0x7c, 0x04, 0x6d, 0xce, 0x47,
+	0xf8, 0xf7, 0x0a, 0xb4, 0x0a, 0x9e, 0xae, 0x78, 0x17, 0x6a, 0xc9, 0x99, 0x5f, 0xae, 0xf3, 0xa7,
+	0x8b, 0x58, 0x44, 0xba, 0x90, 0x0d, 0xd4, 0x2e, 0x64, 0x03, 0xc5, 0x2e, 0x5c, 0x62, 0xcd, 0x9b,
+	0x1e, 0x22, 0x4d, 0x9a, 0xdc, 0x9a, 0xf3, 0xac, 0x39, 0x9b, 0x9c, 0x1e, 0x49, 0x65, 0x02, 0xba,
+	0x47, 0x25, 0xe4, 0xca, 0x06, 0x5c, 0x5e, 0xd0, 0xed, 0xab, 0xd4, 0x15, 0xcc, 0x1b, 0xd0, 0x19,
+	0x9d, 0xf9, 0x23, 0x77, 0x2a, 0xe3, 0xc4, 0x9e, 0x86, 0xe4, 0x63, 0x29, 0xcb, 0x59, 0xb3, 0xb4,
+	0x24, 0x36, 0xdf, 0x83, 0xf6, 0x33, 0x29, 0x23, 0x4b, 0xc6, 0x61, 0xe0, 0xc7, 0xb2, 0x90, 0xc5,
+	0x65, 0x33, 0xad, 0x20, 0xf3, 0xf7, 0xc0, 0xc0, 0xb0, 0x7f, 0xd3, 0x4e, 0x26, 0xc7, 0x5f, 0x25,
+	0x2d, 0xf0, 0x1e, 0x34, 0x43, 0x96, 0x29, 0x15, 0xff, 0xb4, 0xc9, 0x5c, 0x2b, 0x39, 0xb3, 0x52,
+	0xa2, 0xf9, 0xbb, 0x70, 0x79, 0x7f, 0x76, 0x10, 0x4f, 0x22, 0x97, 0x42, 0xc9, 0xd4, 0x94, 0xad,
+	0x80, 0x1e, 0x46, 0xf2, 0xd0, 0x3d, 0x93, 0xa9, 0x04, 0x67, 0xb0, 0xb8, 0x03, 0xcd, 0x29, 0x6e,
+	0x47, 0xe6, 0x6f, 0x23, 0x0f, 0x9a, 0x9e, 0x22, 0xc5, 0x4a, 0x3b, 0x98, 0xdf, 0x81, 0x2b, 0xe5,
+	0xe9, 0xd5, 0x71, 0x6f, 0x41, 0xf5, 0xe4, 0x34, 0x56, 0xa7, 0x58, 0x2e, 0x05, 0x5d, 0x54, 0x8a,
+	0x47, 0xaa, 0xf9, 0x67, 0x15, 0xa8, 0x0e, 0x67, 0xd3, 0xe2, 0xf7, 0x44, 0x35, 0xfe, 0x9e, 0xe8,
+	0x5a, 0x31, 0xa1, 0xca, 0xfe, 0x7d, 0x9e, 0x38, 0x7d, 0x1b, 0x8c, 0xc3, 0x20, 0xfa, 0x89, 0x1d,
+	0x39, 0xd2, 0x51, 0x06, 0x2e, 0x47, 0x88, 0xdb, 0xca, 0x1c, 0xb2, 0x7f, 0xbd, 0x8c, 0x0c, 0x1c,
+	0xce, 0xa6, 0x6b, 0x9e, 0xb4, 0x63, 0xd2, 0xdb, 0x6c, 0x21, 0xcd, 0xbb, 0x60, 0x64, 0x28, 0xd4,
+	0x35, 0xc3, 0xfd, 0xf1, 0xce, 0x36, 0x27, 0xa4, 0xd0, 0x13, 0xad, 0xa0, 0x9e, 0x19, 0x7d, 0x7f,
+	0x38, 0x1e, 0xed, 0xf7, 0x34, 0xf3, 0x87, 0xd0, 0x4a, 0x45, 0x71, 0xc7, 0xa1, 0xea, 0x0b, 0xbd,
+	0x85, 0x1d, 0xa7, 0xf4, 0x34, 0x76, 0x28, 0x54, 0x90, 0xbe, 0xb3, 0x93, 0xca, 0x30, 0x03, 0xe5,
+	0xd3, 0xa8, 0x52, 0x4e, 0x7a, 0x1a, 0x73, 0x00, 0xcb, 0x16, 0x65, 0x91, 0xd1, 0x86, 0xa5, 0xd7,
+	0x73, 0x15, 0x1a, 0x7e, 0xe0, 0xc8, 0x6c, 0x01, 0x05, 0xe1, 0xca, 0xca, 0xe3, 0x50, 0xda, 0x21,
+	0x05, 0x4d, 0x09, 0xcb, 0xa8, 0x70, 0x54, 0x95, 0x51, 0x4d, 0x53, 0xca, 0x70, 0x56, 0xe6, 0x32,
+	0x9c, 0xb8, 0x88, 0x2a, 0x53, 0xb2, 0xeb, 0x90, 0x96, 0x26, 0x57, 0x40, 0x77, 0xe2, 0x84, 0x5e,
+	0x88, 0x52, 0x33, 0x19, 0x6c, 0xde, 0x87, 0xcb, 0x1b, 0x61, 0xe8, 0x9d, 0xa7, 0xa5, 0x1f, 0xb5,
+	0x50, 0x3f, 0xaf, 0x0f, 0x55, 0x54, 0x7c, 0xc2, 0xa0, 0xf9, 0x08, 0xda, 0x69, 0x38, 0xfb, 0x54,
+	0x26, 0x36, 0x29, 0x0f, 0xcf, 0x2d, 0x85, 0x7a, 0x3a, 0x23, 0x46, 0xe5, 0x3c, 0xea, 0xdc, 0xf9,
+	0xd6, 0xa0, 0xa1, 0x34, 0x93, 0x80, 0xda, 0x24, 0x70, 0x78, 0xa1, 0xba, 0x45, 0x6d, 0x94, 0xa0,
+	0x69, 0x7c, 0x94, 0x3a, 0x8f, 0xd3, 0xf8, 0xc8, 0xfc, 0x1b, 0x0d, 0x3a, 0x9b, 0x94, 0x3c, 0x48,
+	0xf7, 0x58, 0x48, 0x99, 0x55, 0x4a, 0x29, 0xb3, 0x62, 0x7a, 0x4c, 0x2b, 0xa5, 0xc7, 0x4a, 0x1b,
+	0xaa, 0x96, 0x3d, 0xbe, 0xaf, 0x41, 0x73, 0xe6, 0xbb, 0x67, 0xa9, 0xca, 0x35, 0xac, 0x06, 0x82,
+	0xa3, 0x58, 0xdc, 0x84, 0x16, 0x6a, 0x65, 0xd7, 0xe7, 0x94, 0x14, 0xe7, 0x95, 0x8a, 0xa8, 0xb9,
+	0xc4, 0x53, 0xe3, 0xd5, 0x89, 0xa7, 0xe6, 0x6b, 0x13, 0x4f, 0xfa, 0xeb, 0x12, 0x4f, 0xc6, 0x7c,
+	0xe2, 0xa9, 0xec, 0xad, 0xc2, 0xbc, 0xb7, 0x6a, 0xee, 0x42, 0x37, 0xe5, 0x9d, 0x7a, 0xcf, 0x9f,
+	0xc0, 0x25, 0x95, 0x33, 0x96, 0x91, 0x4a, 0xbb, 0xb0, 0x46, 0xa7, 0x07, 0xc6, 0x69, 0x5d, 0x45,
+	0xb1, 0xba, 0x4e, 0x11, 0x8c, 0xcd, 0x5f, 0x56, 0xa0, 0x53, 0xea, 0x21, 0x3e, 0xca, 0x33, 0xd0,
+	0x15, 0x7a, 0xa6, 0xfd, 0x0b, 0xb3, 0xbc, 0x3a, 0x0b, 0xad, 0xcd, 0x65, 0xa1, 0xcd, 0x7b, 0x59,
+	0x6e, 0x59, 0x65, 0x94, 0x97, 0xb2, 0x8c, 0x32, 0x25, 0x61, 0x37, 0x46, 0x23, 0xab, 0xa7, 0x89,
+	0x06, 0x68, 0xc3, 0xfd, 0x5e, 0xd5, 0xfc, 0x95, 0x06, 0x9d, 0xc1, 0x59, 0x48, 0x1f, 0x0e, 0xbd,
+	0xd6, 0xb7, 0x2f, 0x08, 0x8e, 0x56, 0x12, 0x9c, 0x82, 0x08, 0x54, 0x55, 0x49, 0x8d, 0x45, 0x00,
+	0xbd, 0x7d, 0xce, 0x73, 0x29, 0xd1, 0x60, 0xe8, 0xff, 0x82, 0x68, 0x94, 0x54, 0x06, 0xcc, 0x17,
+	0x45, 0x76, 0xa1, 0x9b, 0xb2, 0x4d, 0x09, 0xc6, 0x1b, 0xbd, 0x46, 0xfe, 0x24, 0xd0, 0xcb, 0x32,
+	0x32, 0x0c, 0x98, 0x7f, 0xae, 0x81, 0xc1, 0x72, 0x86, 0x9b, 0xff, 0x40, 0x29, 0xee, 0x4a, 0x9e,
+	0x7f, 0xcf, 0x88, 0x6b, 0x4f, 0xe4, 0x79, 0xae, 0xbc, 0x17, 0xd6, 0xac, 0x54, 0xde, 0x86, 0x63,
+	0x73, 0xca, 0xdb, 0x5c, 0x03, 0x83, 0x5d, 0x98, 0x99, 0x4a, 0xfe, 0xd6, 0x2c, 0xf6, 0x69, 0x9e,
+	0xbb, 0x54, 0x7d, 0x4a, 0x64, 0x34, 0x55, 0x77, 0x40, 0xed, 0x72, 0x9c, 0xd3, 0x49, 0x3d, 0xef,
+	0x12, 0x47, 0x9a, 0xf3, 0x1c, 0x39, 0x86, 0xa6, 0xda, 0x1b, 0xba, 0xa9, 0xcf, 0x87, 0x4f, 0x86,
+	0x7b, 0xdf, 0x1b, 0x96, 0xa4, 0x2f, 0x73, 0x64, 0xb5, 0xa2, 0x23, 0x5b, 0x45, 0xfc, 0xd6, 0xde,
+	0xf3, 0xe1, 0xa8, 0x57, 0x13, 0x1d, 0x30, 0xa8, 0x39, 0xb6, 0x06, 0x2f, 0x7a, 0x75, 0x4a, 0x7b,
+	0x6c, 0x7d, 0x3a, 0x78, 0xba, 0xd1, 0x6b, 0x64, 0xd5, 0x90, 0xa6, 0xf9, 0xa7, 0x15, 0x58, 0x66,
+	0x86, 0x14, 0x33, 0x18, 0xc5, 0xef, 0x7a, 0x6b, 0xea, 0xbb, 0xde, 0xff, 0xdd, 0xac, 0xc6, 0x35,
+	0x30, 0x66, 0x6e, 0x5a, 0x7f, 0xe4, 0xc4, 0x86, 0x3e, 0x73, 0x55, 0xd9, 0xf1, 0xef, 0x2b, 0xb0,
+	0xc2, 0xfe, 0xf3, 0xe3, 0xc8, 0x0e, 0x8f, 0xbf, 0xbb, 0x7b, 0x21, 0x82, 0x7e, 0x99, 0x57, 0x79,
+	0x1b, 0xba, 0xf4, 0xe5, 0xf3, 0x8f, 0xbd, 0xb1, 0x8a, 0xf2, 0xf8, 0x76, 0x3b, 0x0a, 0xcb, 0x13,
+	0x89, 0x87, 0xd0, 0xe6, 0x2f, 0xa4, 0x29, 0x07, 0x5b, 0xaa, 0x9d, 0x95, 0xbc, 0xf7, 0x16, 0xf7,
+	0xe2, 0x4a, 0xdf, 0x47, 0xd9, 0xa0, 0x3c, 0xd8, 0xbe, 0x58, 0x1e, 0x53, 0x43, 0x46, 0x14, 0x82,
+	0xdf, 0x87, 0x6b, 0x0b, 0xcf, 0xa1, 0xc4, 0xbe, 0x90, 0x25, 0x64, 0x69, 0x33, 0x7f, 0x55, 0x01,
+	0x7d, 0x73, 0xe6, 0x9d, 0x90, 0x95, 0x7b, 0x07, 0x40, 0x3a, 0x47, 0x52, 0x7d, 0x3f, 0x5c, 0x21,
+	0xe5, 0x60, 0x20, 0x86, 0xbf, 0x20, 0xfe, 0x04, 0x80, 0xcf, 0x38, 0x9e, 0xda, 0xa1, 0xba, 0x22,
+	0xaa, 0x65, 0xa5, 0x13, 0xa8, 0xb3, 0x3c, 0xb5, 0x43, 0x55, 0xcb, 0x8a, 0x53, 0x78, 0x65, 0x08,
+	0xdd, 0x32, 0x71, 0x41, 0xea, 0xe8, 0xbd, 0xf2, 0x17, 0x12, 0x17, 0xb9, 0x53, 0xf0, 0x64, 0x3f,
+	0x83, 0x4b, 0x73, 0x89, 0xda, 0x57, 0xe9, 0xc2, 0xd2, 0x63, 0xd0, 0xe6, 0x1e, 0xc3, 0xfa, 0xdf,
+	0x55, 0xa0, 0x86, 0xde, 0xaa, 0xb8, 0x07, 0xc6, 0xa7, 0xd2, 0x8e, 0x92, 0x03, 0x69, 0x27, 0xa2,
+	0xe4, 0x99, 0xae, 0x10, 0xd7, 0xf3, 0x8f, 0x22, 0xcc, 0xa5, 0x07, 0x15, 0xb1, 0xc6, 0x1f, 0x63,
+	0xa6, 0x1f, 0x99, 0x76, 0x52, 0xaf, 0x97, 0xbc, 0xe2, 0x95, 0xd2, 0x78, 0x73, 0x69, 0x95, 0xfa,
+	0x7f, 0x16, 0xb8, 0xfe, 0x16, 0x7f, 0x02, 0x28, 0xe6, 0xbd, 0xe4, 0xf9, 0x11, 0xe2, 0x1e, 0x34,
+	0x76, 0x62, 0x74, 0xc7, 0x2f, 0x76, 0x25, 0xde, 0x14, 0x3d, 0x75, 0x73, 0x69, 0xfd, 0x67, 0x75,
+	0xa8, 0xfd, 0x50, 0x46, 0x81, 0xf8, 0x10, 0x9a, 0xea, 0x13, 0x12, 0x51, 0xf8, 0x54, 0x64, 0x85,
+	0x32, 0x03, 0x73, 0xdf, 0x96, 0xd0, 0x2a, 0x3d, 0x66, 0x6f, 0x5e, 0x3d, 0x10, 0xf9, 0x17, 0x2e,
+	0x17, 0x36, 0xf5, 0x31, 0xf4, 0xf6, 0x93, 0x48, 0xda, 0xd3, 0x42, 0xf7, 0x32, 0xab, 0x16, 0x95,
+	0x22, 0x88, 0x5f, 0x77, 0xa1, 0xc1, 0x31, 0xcf, 0xdc, 0x80, 0xf9, 0x3a, 0x03, 0x75, 0x7e, 0x1f,
+	0x5a, 0xfb, 0xc7, 0xc1, 0xcc, 0x73, 0xf6, 0x65, 0x74, 0x2a, 0x45, 0xe1, 0x63, 0xb4, 0x95, 0x42,
+	0xdb, 0x5c, 0x12, 0xef, 0x83, 0xc1, 0x5e, 0x2e, 0xfa, 0xb8, 0x4d, 0xe5, 0x38, 0xf3, 0x9c, 0x05,
+	0xef, 0xd7, 0x5c, 0x12, 0xab, 0x00, 0x85, 0xc8, 0xe7, 0x55, 0x3d, 0x1f, 0x42, 0x67, 0x8b, 0xf4,
+	0xc9, 0x5e, 0xb4, 0x71, 0x10, 0x44, 0x89, 0x98, 0xff, 0xfa, 0x6c, 0x65, 0x1e, 0x61, 0x2e, 0x89,
+	0x07, 0xa0, 0x8f, 0xa2, 0x73, 0xee, 0xbf, 0xac, 0x02, 0xc6, 0x7c, 0xbd, 0x05, 0x87, 0x14, 0xdf,
+	0xcc, 0x64, 0x38, 0x73, 0x6e, 0x17, 0x55, 0x20, 0xf8, 0xbc, 0xec, 0x46, 0x9a, 0x4b, 0xe2, 0x23,
+	0x80, 0xdc, 0xf3, 0x16, 0x6f, 0x71, 0x35, 0x64, 0xce, 0x13, 0xbf, 0x38, 0x24, 0xf7, 0xb2, 0x79,
+	0xc8, 0x05, 0xaf, 0x7b, 0x6e, 0xc8, 0xb7, 0xa0, 0x5d, 0xf4, 0x98, 0x05, 0x65, 0xfc, 0x17, 0xf8,
+	0xd0, 0xe5, 0x61, 0xeb, 0x7f, 0x51, 0x87, 0xc6, 0xf7, 0x82, 0xe8, 0x44, 0x46, 0xe2, 0x0e, 0x34,
+	0xa8, 0xae, 0xa5, 0x1e, 0x46, 0x56, 0xe3, 0x5a, 0xc4, 0xbb, 0x6f, 0x80, 0x41, 0xd7, 0x3c, 0xb2,
+	0xe3, 0x13, 0x16, 0x3e, 0xfa, 0x57, 0x04, 0x4f, 0xce, 0x79, 0x34, 0x92, 0xd4, 0x2e, 0x8b, 0x5e,
+	0x56, 0xf7, 0x2d, 0xd5, 0x9d, 0x56, 0xe8, 0x4a, 0x9f, 0xbc, 0xd8, 0xc7, 0xc7, 0xf6, 0xa0, 0x82,
+	0x96, 0x79, 0x9f, 0x2f, 0x0f, 0x3b, 0xe5, 0x5f, 0x83, 0xf3, 0x5b, 0xce, 0x3f, 0xbf, 0x36, 0x97,
+	0xc4, 0x7d, 0x68, 0x28, 0x45, 0xbd, 0x9c, 0x2b, 0x9d, 0xf4, 0x84, 0xbd, 0x22, 0x4a, 0x0d, 0xf8,
+	0x08, 0x1a, 0x6c, 0xd4, 0x78, 0x40, 0xc9, 0x65, 0x5f, 0x11, 0x45, 0x54, 0xfa, 0x3c, 0xc5, 0x5d,
+	0x68, 0xaa, 0xaa, 0x95, 0x58, 0x50, 0xc2, 0xba, 0x70, 0x63, 0x0d, 0xf6, 0x58, 0x78, 0xfe, 0x92,
+	0xd3, 0xc7, 0xf3, 0x97, 0x1d, 0x1a, 0x7e, 0xc7, 0x96, 0x9c, 0x48, 0xb7, 0x90, 0xbe, 0x11, 0x29,
+	0x47, 0x16, 0x28, 0xa3, 0x8f, 0xa1, 0x53, 0x4a, 0xf5, 0x88, 0x7e, 0x2a, 0x16, 0xf3, 0xd9, 0x9f,
+	0x0b, 0x2a, 0xe0, 0x3b, 0x60, 0xa8, 0xe8, 0xf9, 0x40, 0x09, 0xc6, 0x82, 0x58, 0x7d, 0xe5, 0x62,
+	0xf8, 0x4c, 0xef, 0xfa, 0xfb, 0x70, 0x79, 0x81, 0x85, 0x12, 0xf4, 0xd5, 0xe1, 0xcb, 0x4d, 0xf0,
+	0xca, 0x8d, 0x97, 0xd2, 0x33, 0x06, 0xfc, 0x56, 0xcf, 0x69, 0xb3, 0xff, 0x0f, 0x5f, 0x5c, 0xaf,
+	0xfc, 0xfa, 0x8b, 0xeb, 0x95, 0x7f, 0xfb, 0xe2, 0x7a, 0xe5, 0x97, 0xbf, 0xb9, 0xbe, 0xf4, 0xeb,
+	0xdf, 0x5c, 0x5f, 0xfa, 0xe7, 0xdf, 0x5c, 0x5f, 0x3a, 0x68, 0xd0, 0x5f, 0x91, 0x1e, 0xfe, 0x77,
+	0x00, 0x00, 0x00, 0xff, 0xff, 0x71, 0x4f, 0x53, 0xfe, 0x00, 0x35, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -5738,6 +5904,9 @@ type ZeroClient interface {
 	CommitOrAbort(ctx context.Context, in *api.TxnContext, opts ...grpc.CallOption) (*api.TxnContext, error)
 	TryAbort(ctx context.Context, in *TxnTimestamps, opts ...grpc.CallOption) (*OracleDelta, error)
 	DeleteNamespace(ctx context.Context, in *DeleteNsRequest, opts ...grpc.CallOption) (*Status, error)
+	RemoveNode(ctx context.Context, in *RemoveNodeRequest, opts ...grpc.CallOption) (*Status, error)
+	MoveTablet(ctx context.Context, in *MoveTabletRequest, opts ...grpc.CallOption) (*Status, error)
+	ApplyLicense(ctx context.Context, in *ApplyLicenseRequest, opts ...grpc.CallOption) (*Status, error)
 }
 
 type zeroClient struct {
@@ -5884,6 +6053,33 @@ func (c *zeroClient) DeleteNamespace(ctx context.Context, in *DeleteNsRequest, o
 	return out, nil
 }
 
+func (c *zeroClient) RemoveNode(ctx context.Context, in *RemoveNodeRequest, opts ...grpc.CallOption) (*Status, error) {
+	out := new(Status)
+	err := c.cc.Invoke(ctx, "/pb.Zero/RemoveNode", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *zeroClient) MoveTablet(ctx context.Context, in *MoveTabletRequest, opts ...grpc.CallOption) (*Status, error) {
+	out := new(Status)
+	err := c.cc.Invoke(ctx, "/pb.Zero/MoveTablet", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *zeroClient) ApplyLicense(ctx context.Context, in *ApplyLicenseRequest, opts ...grpc.CallOption) (*Status, error) {
+	out := new(Status)
+	err := c.cc.Invoke(ctx, "/pb.Zero/ApplyLicense", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // ZeroServer is the server API for Zero service.
 type ZeroServer interface {
 	// These 3 endpoints are for handling membership.
@@ -5897,6 +6093,9 @@ type ZeroServer interface {
 	CommitOrAbort(context.Context, *api.TxnContext) (*api.TxnContext, error)
 	TryAbort(context.Context, *TxnTimestamps) (*OracleDelta, error)
 	DeleteNamespace(context.Context, *DeleteNsRequest) (*Status, error)
+	RemoveNode(context.Context, *RemoveNodeRequest) (*Status, error)
+	MoveTablet(context.Context, *MoveTabletRequest) (*Status, error)
+	ApplyLicense(context.Context, *ApplyLicenseRequest) (*Status, error)
 }
 
 // UnimplementedZeroServer can be embedded to have forward compatible implementations.
@@ -5933,6 +6132,15 @@ func (*UnimplementedZeroServer) TryAbort(ctx context.Context, req *TxnTimestamps
 func (*UnimplementedZeroServer) DeleteNamespace(ctx context.Context, req *DeleteNsRequest) (*Status, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method DeleteNamespace not implemented")
 }
+func (*UnimplementedZeroServer) RemoveNode(ctx context.Context, req *RemoveNodeRequest) (*Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RemoveNode not implemented")
+}
+func (*UnimplementedZeroServer) MoveTablet(ctx context.Context, req *MoveTabletRequest) (*Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MoveTablet not implemented")
+}
+func (*UnimplementedZeroServer) ApplyLicense(ctx context.Context, req *ApplyLicenseRequest) (*Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ApplyLicense not implemented")
+}
 
 func RegisterZeroServer(s *grpc.Server, srv ZeroServer) {
 	s.RegisterService(&_Zero_serviceDesc, srv)
@@ -6124,6 +6332,60 @@ func _Zero_DeleteNamespace_Handler(srv interface{}, ctx context.Context, dec fun
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Zero_RemoveNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RemoveNodeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ZeroServer).RemoveNode(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/pb.Zero/RemoveNode",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ZeroServer).RemoveNode(ctx, req.(*RemoveNodeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Zero_MoveTablet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MoveTabletRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ZeroServer).MoveTablet(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/pb.Zero/MoveTablet",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ZeroServer).MoveTablet(ctx, req.(*MoveTabletRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Zero_ApplyLicense_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ApplyLicenseRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ZeroServer).ApplyLicense(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/pb.Zero/ApplyLicense",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ZeroServer).ApplyLicense(ctx, req.(*ApplyLicenseRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Zero_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "pb.Zero",
 	HandlerType: (*ZeroServer)(nil),
@@ -6160,6 +6422,18 @@ var _Zero_serviceDesc = grpc.ServiceDesc{
 			MethodName: "DeleteNamespace",
 			Handler:    _Zero_DeleteNamespace_Handler,
 		},
+		{
+			MethodName: "RemoveNode",
+			Handler:    _Zero_RemoveNode_Handler,
+		},
+		{
+			MethodName: "MoveTablet",
+			Handler:    _Zero_MoveTablet_Handler,
+		},
+		{
+			MethodName: "ApplyLicense",
+			Handler:    _Zero_ApplyLicense_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -10111,7 +10385,7 @@ func (m *AssignedIds) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *SnapshotMeta) Marshal() (dAtA []byte, err error) {
+func (m *RemoveNodeRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -10121,12 +10395,12 @@ func (m *SnapshotMeta) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *SnapshotMeta) MarshalTo(dAtA []byte) (int, error) {
+func (m *RemoveNodeRequest) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *SnapshotMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *RemoveNodeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -10136,15 +10410,15 @@ func (m *SnapshotMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x10
 	}
-	if m.ClientTs != 0 {
-		i = encodeVarintPb(dAtA, i, uint64(m.ClientTs))
+	if m.NodeId != 0 {
+		i = encodeVarintPb(dAtA, i, uint64(m.NodeId))
 		i--
 		dAtA[i] = 0x8
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Status) Marshal() (dAtA []byte, err error) {
+func (m *MoveTabletRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -10154,32 +10428,37 @@ func (m *Status) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Status) MarshalTo(dAtA []byte) (int, error) {
+func (m *MoveTabletRequest) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Status) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MoveTabletRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Msg) > 0 {
-		i -= len(m.Msg)
-		copy(dAtA[i:], m.Msg)
-		i = encodeVarintPb(dAtA, i, uint64(len(m.Msg)))
+	if m.DstGroup != 0 {
+		i = encodeVarintPb(dAtA, i, uint64(m.DstGroup))
+		i--
+		dAtA[i] = 0x18
+	}
+	if len(m.Tablet) > 0 {
+		i -= len(m.Tablet)
+		copy(dAtA[i:], m.Tablet)
+		i = encodeVarintPb(dAtA, i, uint64(len(m.Tablet)))
 		i--
 		dAtA[i] = 0x12
 	}
-	if m.Code != 0 {
-		i = encodeVarintPb(dAtA, i, uint64(m.Code))
+	if m.Namespace != 0 {
+		i = encodeVarintPb(dAtA, i, uint64(m.Namespace))
 		i--
 		dAtA[i] = 0x8
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *BackupRequest) Marshal() (dAtA []byte, err error) {
+func (m *ApplyLicenseRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -10189,48 +10468,146 @@ func (m *BackupRequest) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *BackupRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *ApplyLicenseRequest) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *BackupRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ApplyLicenseRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Predicates) > 0 {
-		for iNdEx := len(m.Predicates) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Predicates[iNdEx])
-			copy(dAtA[i:], m.Predicates[iNdEx])
-			i = encodeVarintPb(dAtA, i, uint64(len(m.Predicates[iNdEx])))
-			i--
-			dAtA[i] = 0x52
-		}
-	}
-	if m.Anonymous {
-		i--
-		if m.Anonymous {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
+	if len(m.License) > 0 {
+		i -= len(m.License)
+		copy(dAtA[i:], m.License)
+		i = encodeVarintPb(dAtA, i, uint64(len(m.License)))
 		i--
-		dAtA[i] = 0x48
-	}
-	if len(m.SessionToken) > 0 {
-		i -= len(m.SessionToken)
-		copy(dAtA[i:], m.SessionToken)
-		i = encodeVarintPb(dAtA, i, uint64(len(m.SessionToken)))
-		i--
-		dAtA[i] = 0x42
+		dAtA[i] = 0xa
 	}
-	if len(m.SecretKey) > 0 {
-		i -= len(m.SecretKey)
-		copy(dAtA[i:], m.SecretKey)
-		i = encodeVarintPb(dAtA, i, uint64(len(m.SecretKey)))
-		i--
-		dAtA[i] = 0x3a
+	return len(dAtA) - i, nil
+}
+
+func (m *SnapshotMeta) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *SnapshotMeta) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SnapshotMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.GroupId != 0 {
+		i = encodeVarintPb(dAtA, i, uint64(m.GroupId))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.ClientTs != 0 {
+		i = encodeVarintPb(dAtA, i, uint64(m.ClientTs))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Status) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Status) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Status) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Msg) > 0 {
+		i -= len(m.Msg)
+		copy(dAtA[i:], m.Msg)
+		i = encodeVarintPb(dAtA, i, uint64(len(m.Msg)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Code != 0 {
+		i = encodeVarintPb(dAtA, i, uint64(m.Code))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *BackupRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *BackupRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BackupRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Predicates) > 0 {
+		for iNdEx := len(m.Predicates) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Predicates[iNdEx])
+			copy(dAtA[i:], m.Predicates[iNdEx])
+			i = encodeVarintPb(dAtA, i, uint64(len(m.Predicates[iNdEx])))
+			i--
+			dAtA[i] = 0x52
+		}
+	}
+	if m.Anonymous {
+		i--
+		if m.Anonymous {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x48
+	}
+	if len(m.SessionToken) > 0 {
+		i -= len(m.SessionToken)
+		copy(dAtA[i:], m.SessionToken)
+		i = encodeVarintPb(dAtA, i, uint64(len(m.SessionToken)))
+		i--
+		dAtA[i] = 0x42
+	}
+	if len(m.SecretKey) > 0 {
+		i -= len(m.SecretKey)
+		copy(dAtA[i:], m.SecretKey)
+		i = encodeVarintPb(dAtA, i, uint64(len(m.SecretKey)))
+		i--
+		dAtA[i] = 0x3a
 	}
 	if len(m.AccessKey) > 0 {
 		i -= len(m.AccessKey)
@@ -12276,6 +12653,53 @@ func (m *AssignedIds) Size() (n int) {
 	return n
 }
 
+func (m *RemoveNodeRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.NodeId != 0 {
+		n += 1 + sovPb(uint64(m.NodeId))
+	}
+	if m.GroupId != 0 {
+		n += 1 + sovPb(uint64(m.GroupId))
+	}
+	return n
+}
+
+func (m *MoveTabletRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Namespace != 0 {
+		n += 1 + sovPb(uint64(m.Namespace))
+	}
+	l = len(m.Tablet)
+	if l > 0 {
+		n += 1 + l + sovPb(uint64(l))
+	}
+	if m.DstGroup != 0 {
+		n += 1 + sovPb(uint64(m.DstGroup))
+	}
+	return n
+}
+
+func (m *ApplyLicenseRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.License)
+	if l > 0 {
+		n += 1 + l + sovPb(uint64(l))
+	}
+	return n
+}
+
 func (m *SnapshotMeta) Size() (n int) {
 	if m == nil {
 		return 0
@@ -22353,6 +22777,298 @@ func (m *AssignedIds) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *RemoveNodeRequest) 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 ErrIntOverflowPb
+			}
+			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: RemoveNodeRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RemoveNodeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
+			}
+			m.NodeId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NodeId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType)
+			}
+			m.GroupId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.GroupId |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthPb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MoveTabletRequest) 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 ErrIntOverflowPb
+			}
+			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: MoveTabletRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MoveTabletRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
+			}
+			m.Namespace = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Namespace |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Tablet", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPb
+				}
+				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 ErrInvalidLengthPb
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Tablet = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DstGroup", wireType)
+			}
+			m.DstGroup = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.DstGroup |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthPb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ApplyLicenseRequest) 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 ErrIntOverflowPb
+			}
+			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: ApplyLicenseRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ApplyLicenseRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field License", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthPb
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPb
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.License = append(m.License[:0], dAtA[iNdEx:postIndex]...)
+			if m.License == nil {
+				m.License = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPb(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthPb
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *SnapshotMeta) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/systest/group-delete/docker-compose.yml b/systest/group-delete/docker-compose.yml
index f73b30d95a8..0afb849a766 100644
--- a/systest/group-delete/docker-compose.yml
+++ b/systest/group-delete/docker-compose.yml
@@ -16,7 +16,7 @@ services:
       target: /gobin
       read_only: true
     command: /gobin/dgraph alpha --my=alpha1:7080 --zero=zero1:5080 --logtostderr
-      -v=2 
+      -v=2 --raft "group=1"
       --security "whitelist=10.0.0.0/8,172.16.0.0/12,192.168.0.0/16;"
   alpha2:
     image: dgraph/dgraph:latest
@@ -32,7 +32,7 @@ services:
       target: /gobin
       read_only: true
     command: /gobin/dgraph alpha --my=alpha2:7080 --zero=zero1:5080 --logtostderr
-      -v=2 
+      -v=2 --raft "group=2"
       --security "whitelist=10.0.0.0/8,172.16.0.0/12,192.168.0.0/16;"
   alpha3:
     image: dgraph/dgraph:latest
@@ -48,7 +48,7 @@ services:
       target: /gobin
       read_only: true
     command: /gobin/dgraph alpha --my=alpha3:7080 --zero=zero1:5080 --logtostderr
-      -v=2 
+      -v=2 --raft "group=3"
       --security "whitelist=10.0.0.0/8,172.16.0.0/12,192.168.0.0/16;"
   zero1:
     image: dgraph/dgraph:latest
diff --git a/systest/group-delete/group_delete_test.go b/systest/group-delete/group_delete_test.go
index d3ac4f8e84b..ec53167ba7c 100644
--- a/systest/group-delete/group_delete_test.go
+++ b/systest/group-delete/group_delete_test.go
@@ -27,6 +27,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"strconv"
 	"testing"
 	"time"
 
@@ -151,11 +152,7 @@ func TestNodes(t *testing.T) {
 	require.NoError(t, err)
 
 	for pred := range state1.Groups["3"].Tablets {
-		moveUrl := fmt.Sprintf("http://"+testutil.SockAddrZeroHttp+"/moveTablet?tablet=%s&group=2",
-			url.QueryEscape(pred))
-		resp, err := http.Get(moveUrl)
-		require.NoError(t, err)
-		require.NoError(t, getError(resp.Body))
+		testutil.AssertMoveTablet(t, pred, 2)
 		time.Sleep(time.Second)
 	}
 
@@ -168,10 +165,9 @@ func TestNodes(t *testing.T) {
 
 	groupNodes, err := testutil.GetNodesInGroup("3")
 	require.NoError(t, err)
-	resp, err := http.Get("http://" + testutil.SockAddrZeroHttp + "/removeNode?group=3&id=" +
-		groupNodes[0])
+	nodeId, err := strconv.ParseUint(groupNodes[0], 10, 64)
 	require.NoError(t, err)
-	require.NoError(t, getError(resp.Body))
+	testutil.AssertRemoveNode(t, nodeId, 3)
 
 	state2, err = testutil.GetState()
 	require.NoError(t, err)
@@ -205,7 +201,7 @@ func TestNodes(t *testing.T) {
 
 	groupNodes, err = testutil.GetNodesInGroup("2")
 	require.NoError(t, err)
-	resp, err = http.Get("http://" + testutil.SockAddrZeroHttp + "/removeNode?group=2&id=" +
+	resp, err := http.Get("http://" + testutil.SockAddrZeroHttp + "/removeNode?group=2&id=" +
 		groupNodes[0])
 	require.NoError(t, err)
 	require.NoError(t, getError(resp.Body))
diff --git a/systest/license/license_test.go b/systest/license/license_test.go
index c6af58ddbeb..ef45d02d74d 100644
--- a/systest/license/license_test.go
+++ b/systest/license/license_test.go
@@ -91,7 +91,6 @@ type responseStruct struct {
 }
 
 func TestEnterpriseLicense(t *testing.T) {
-	stateURL := "http://" + testutil.SockAddrZeroHttp + "/state"
 	enterpriseLicenseURL := "http://" + testutil.SockAddrZeroHttp + "/enterpriseLicense"
 
 	var tests = []struct {
@@ -123,6 +122,8 @@ func TestEnterpriseLicense(t *testing.T) {
 			`while extracting enterprise details from the license: while decoding license file: EOF`,
 		},
 	}
+
+	// run these tests using the http endpoint
 	for _, tt := range tests {
 
 		// Apply the license
@@ -139,24 +140,47 @@ func TestEnterpriseLicense(t *testing.T) {
 		require.Equal(t, enterpriseResponse.Code, tt.code)
 
 		if enterpriseResponse.Code == `Success` {
-
 			// check the user information in case the license is applied
 			// Expired license should not be enabled even after it is applied
+			assertLicenseNotEnabled(t, tt.user)
+		} else {
+			// check the error message in case the license is not applied
+			require.Equal(t, enterpriseResponse.Errors[0].Message, tt.message)
+		}
+	}
 
-			response, err := http.Get(stateURL)
-			require.NoError(t, err)
+	// this time, run them using the GraphQL admin endpoint
+	for _, tt := range tests {
 
-			var stateResponse responseStruct
-			responseBody, err := ioutil.ReadAll(response.Body)
-			require.NoError(t, err)
-			err = json.Unmarshal(responseBody, &stateResponse)
-			require.NoError(t, err)
+		// Apply the license
+		resp := testutil.EnterpriseLicense(t, string(tt.licenseKey))
 
-			require.Equal(t, stateResponse.License["user"], tt.user)
-			require.Equal(t, stateResponse.License["enabled"], false)
+		if tt.code == `Success` {
+			// Check if the license is applied
+			testutil.CompareJSON(t, `{"enterpriseLicense":{"response":{"code":"Success"}}}`,
+				string(resp.Data))
+
+			// check the user information in case the license is applied
+			// Expired license should not be enabled even after it is applied
+			assertLicenseNotEnabled(t, tt.user)
 		} else {
+			testutil.CompareJSON(t, `{"enterpriseLicense":null}`, string(resp.Data))
 			// check the error message in case the license is not applied
-			require.Equal(t, enterpriseResponse.Errors[0].Message, tt.message)
+			require.Contains(t, resp.Errors[0].Message, tt.message)
 		}
 	}
 }
+
+func assertLicenseNotEnabled(t *testing.T, user string) {
+	response, err := http.Get("http://" + testutil.SockAddrZeroHttp + "/state")
+	require.NoError(t, err)
+
+	var stateResponse responseStruct
+	responseBody, err := ioutil.ReadAll(response.Body)
+	require.NoError(t, err)
+	err = json.Unmarshal(responseBody, &stateResponse)
+	require.NoError(t, err)
+
+	require.Equal(t, stateResponse.License["user"], user)
+	require.Equal(t, stateResponse.License["enabled"], false)
+}
diff --git a/testutil/graphql.go b/testutil/graphql.go
index 62c3fa4f4bb..d506427f826 100644
--- a/testutil/graphql.go
+++ b/testutil/graphql.go
@@ -129,6 +129,60 @@ func MakeGQLRequestWithAccessJwtAndTLS(t *testing.T, params *GraphQLParams, tls
 	return &gqlResp
 }
 
+func AssertRemoveNode(t *testing.T, nodeId uint64, groupId uint32) {
+	params := &GraphQLParams{
+		Query: `mutation ($nodeId: UInt64!, $groupId: UInt64!) {
+		  removeNode(input: {nodeId: $nodeId, groupId: $groupId}) {
+			response {
+				code
+			}
+		  }
+		}`,
+		Variables: map[string]interface{}{
+			"nodeId":  nodeId,
+			"groupId": groupId,
+		},
+	}
+	resp := MakeGQLRequest(t, params)
+	resp.RequireNoGraphQLErrors(t)
+	CompareJSON(t, `{"removeNode":{"response":{"code":"Success"}}}`, string(resp.Data))
+}
+
+func AssertMoveTablet(t *testing.T, tablet string, groupId uint32) {
+	params := &GraphQLParams{
+		Query: `mutation ($tablet: String!, $groupId: UInt64!) {
+		  moveTablet(input: {tablet: $tablet, groupId: $groupId}) {
+			response {
+				code
+			}
+		  }
+		}`,
+		Variables: map[string]interface{}{
+			"tablet":  tablet,
+			"groupId": groupId,
+		},
+	}
+	resp := MakeGQLRequest(t, params)
+	resp.RequireNoGraphQLErrors(t)
+	CompareJSON(t, `{"moveTablet":{"response":{"code":"Success"}}}`, string(resp.Data))
+}
+
+func EnterpriseLicense(t *testing.T, license string) *GraphQLResponse {
+	params := &GraphQLParams{
+		Query: `mutation ($license: String!) {
+		  enterpriseLicense(input: {license: $license}) {
+			response {
+				code
+			}
+		  }
+		}`,
+		Variables: map[string]interface{}{
+			"license": license,
+		},
+	}
+	return MakeGQLRequest(t, params)
+}
+
 type clientCustomClaims struct {
 	Namespace     string
 	AuthVariables map[string]interface{}
diff --git a/worker/mutation.go b/worker/mutation.go
index 384924f384e..45e4235be90 100644
--- a/worker/mutation.go
+++ b/worker/mutation.go
@@ -525,7 +525,7 @@ func ValidateAndConvert(edge *pb.DirectedEdge, su *pb.SchemaUpdate) error {
 	return nil
 }
 
-// AssignUidsOverNetwork sends a request to assign UIDs to blank nodes to the current zero leader.
+// AssignNsIdsOverNetwork sends a request to assign Namespace IDs to the current zero leader.
 func AssignNsIdsOverNetwork(ctx context.Context, num *pb.Num) (*pb.AssignedIds, error) {
 	pl := groups().Leader(0)
 	if pl == nil {
diff --git a/worker/zero.go b/worker/zero.go
new file mode 100644
index 00000000000..bc294a4d295
--- /dev/null
+++ b/worker/zero.go
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2020 Dgraph Labs, Inc. and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package worker
+
+import (
+	"context"
+
+	"github.com/dgraph-io/dgraph/conn"
+	"github.com/dgraph-io/dgraph/protos/pb"
+)
+
+// RemoveNodeOverNetwork sends a request to remove the given node from given group to a zero server.
+// This operation doesn't necessarily require a zero leader.
+func RemoveNodeOverNetwork(ctx context.Context, req *pb.RemoveNodeRequest) (*pb.Status, error) {
+	pl := groups().AnyServer(0)
+	if pl == nil {
+		return nil, conn.ErrNoConnection
+	}
+
+	con := pl.Get()
+	c := pb.NewZeroClient(con)
+	return c.RemoveNode(ctx, req)
+}
+
+// MoveTabletOverNetwork sends a request to move the given tablet to destination group to the
+// current zero leader.
+func MoveTabletOverNetwork(ctx context.Context, req *pb.MoveTabletRequest) (*pb.Status, error) {
+	pl := groups().Leader(0)
+	if pl == nil {
+		return nil, conn.ErrNoConnection
+	}
+
+	con := pl.Get()
+	c := pb.NewZeroClient(con)
+	return c.MoveTablet(ctx, req)
+}
+
+// ApplyLicenseOverNetwork sends a request to apply the given enterprise license to a zero server.
+// This operation doesn't necessarily require a zero leader.
+func ApplyLicenseOverNetwork(ctx context.Context, req *pb.ApplyLicenseRequest) (*pb.Status, error) {
+	pl := groups().AnyServer(0)
+	if pl == nil {
+		return nil, conn.ErrNoConnection
+	}
+
+	con := pl.Get()
+	c := pb.NewZeroClient(con)
+	return c.ApplyLicense(ctx, req)
+}