From 45f02865c02e05639a80d2fdfeb2868af6e56bb4 Mon Sep 17 00:00:00 2001
From: NamanJain8 <jnaman806@gmail.com>
Date: Fri, 5 Feb 2021 01:37:17 +0530
Subject: [PATCH 1/7] basic bulk loader working

---
 chunker/json_parser.go          | 33 ++++++++++++++++++++---
 chunker/json_parser_test.go     |  1 +
 chunker/rdf_parser.go           | 10 +++++++
 dgraph/cmd/bulk/loader.go       | 12 ++++++++-
 dgraph/cmd/bulk/mapper.go       | 35 +++++++++++++++---------
 dgraph/cmd/bulk/merge_shards.go |  1 +
 dgraph/cmd/bulk/run.go          |  4 +++
 dgraph/cmd/bulk/schema.go       | 47 +++++++++++++++++++++++----------
 dgraph/cmd/bulk/shard_map.go    |  1 +
 dgraph/cmd/debug/run.go         |  4 ++-
 go.mod                          |  5 ++--
 gql/mutation.go                 |  4 ++-
 graphql/admin/namespace.go      |  5 ++--
 query/mutation.go               |  1 +
 x/keys.go                       |  6 +++++
 15 files changed, 131 insertions(+), 38 deletions(-)

diff --git a/chunker/json_parser.go b/chunker/json_parser.go
index 4f894052dde..1d55f8ebb3c 100644
--- a/chunker/json_parser.go
+++ b/chunker/json_parser.go
@@ -189,8 +189,9 @@ func parseScalarFacets(m map[string]interface{}, prefix string) ([]*api.Facet, e
 
 // This is the response for a map[string]interface{} i.e. a struct.
 type mapResponse struct {
-	uid  string       // uid retrieved or allocated for the node.
-	fcts []*api.Facet // facets on the edge connecting this node to the source if any.
+	uid       string       // uid retrieved or allocated for the node.
+	namespace uint64       // namespace to which the node belongs.
+	fcts      []*api.Facet // facets on the edge connecting this node to the source if any.
 }
 
 func handleBasicType(k string, v interface{}, op int, nq *api.NQuad) error {
@@ -267,6 +268,7 @@ func (buf *NQuadBuffer) checkForDeletion(mr mapResponse, m map[string]interface{
 		buf.Push(&api.NQuad{
 			Subject:     mr.uid,
 			Predicate:   x.Star,
+			Namespace:   mr.namespace,
 			ObjectValue: &api.Value{Val: &api.Value_DefaultVal{DefaultVal: x.Star}},
 		})
 	}
@@ -447,12 +449,29 @@ func (buf *NQuadBuffer) mapToNquads(m map[string]interface{}, op int, parentPred
 		mr.uid = getNextBlank()
 	}
 
+	namespace := x.DefaultNamespace
+	if ns, ok := m["namespace"]; ok {
+		switch ns := ns.(type) {
+		case json.Number:
+			nsi, err := ns.Int64()
+			if err != nil {
+				return mr, err
+			}
+			namespace = uint64(nsi)
+
+		// this int64 case is needed for FastParseJSON, which doesn't use json.Number
+		case int64:
+			namespace = uint64(ns)
+		}
+	}
+	mr.namespace = namespace
+
 	for pred, v := range m {
 		// We have already extracted the uid above so we skip that edge.
 		// v can be nil if user didn't set a value and if omitEmpty was not supplied as JSON
 		// option.
 		// We also skip facets here because we parse them with the corresponding predicate.
-		if pred == "uid" {
+		if pred == "uid" || pred == "namespace" {
 			continue
 		}
 
@@ -462,6 +481,7 @@ func (buf *NQuadBuffer) mapToNquads(m map[string]interface{}, op int, parentPred
 				nq := &api.NQuad{
 					Subject:     mr.uid,
 					Predicate:   pred,
+					Namespace:   namespace,
 					ObjectValue: &api.Value{Val: &api.Value_DefaultVal{DefaultVal: x.Star}},
 				}
 				// Here we split predicate and lang directive (ex: "name@en"), if needed. With JSON
@@ -478,6 +498,7 @@ func (buf *NQuadBuffer) mapToNquads(m map[string]interface{}, op int, parentPred
 		nq := api.NQuad{
 			Subject:   mr.uid,
 			Predicate: pred,
+			Namespace: namespace,
 		}
 
 		prefix := pred + x.FacetDelimeter
@@ -545,6 +566,7 @@ func (buf *NQuadBuffer) mapToNquads(m map[string]interface{}, op int, parentPred
 				nq := api.NQuad{
 					Subject:   mr.uid,
 					Predicate: pred,
+					Namespace: namespace,
 				}
 
 				switch iv := item.(type) {
@@ -739,8 +761,11 @@ func (buf *NQuadBuffer) ParseJSON(b []byte, op int) error {
 		return nil
 	}
 	mr, err := buf.mapToNquads(ms, op, "")
+	if err != nil {
+		return err
+	}
 	buf.checkForDeletion(mr, ms, op)
-	return err
+	return nil
 }
 
 // ParseJSON is a convenience wrapper function to get all NQuads in one call. This can however, lead
diff --git a/chunker/json_parser_test.go b/chunker/json_parser_test.go
index f49044c12fc..4808940cc56 100644
--- a/chunker/json_parser_test.go
+++ b/chunker/json_parser_test.go
@@ -116,6 +116,7 @@ func TestNquadsFromJson1(t *testing.T) {
 	tn := time.Now().UTC()
 	m := true
 	p := Person{
+		Uid:     "1",
 		Name:    "Alice",
 		Age:     26,
 		Married: &m,
diff --git a/chunker/rdf_parser.go b/chunker/rdf_parser.go
index 1f465095e36..dd798bd54b8 100644
--- a/chunker/rdf_parser.go
+++ b/chunker/rdf_parser.go
@@ -226,6 +226,16 @@ L:
 		return rnq, errors.Errorf("NQuad failed sanity check:%+v", rnq)
 	}
 
+	// TODO(Naman): Ensure the label contains valid namespace.
+	// Append the namespace to the predicate before returning NQuad.
+	if rnq.Label != "" {
+		ns, err := strconv.ParseUint(rnq.Label, 0, 64)
+		if err != nil {
+			return rnq, err
+		}
+		rnq.Namespace = ns
+	}
+
 	return rnq, nil
 }
 
diff --git a/dgraph/cmd/bulk/loader.go b/dgraph/cmd/bulk/loader.go
index 537c63daf7d..665c15f0a58 100644
--- a/dgraph/cmd/bulk/loader.go
+++ b/dgraph/cmd/bulk/loader.go
@@ -76,6 +76,8 @@ type options struct {
 	MapShards    int
 	ReduceShards int
 
+	Namespace uint64
+
 	shardOutputDirs []string
 
 	// ........... Badger options ..........
@@ -100,6 +102,7 @@ type state struct {
 	dbs           []*badger.DB
 	tmpDbs        []*badger.DB // Temporary DB to write the split lists to avoid ordering issues.
 	writeTs       uint64       // All badger writes use this timestamp
+	namespaces    *sync.Map    // To store the encountered namespaces.
 }
 
 type loader struct {
@@ -136,6 +139,7 @@ func newLoader(opt *options) *loader {
 		// Lots of gz readers, so not much channel buffer needed.
 		readerChunkCh: make(chan *bytes.Buffer, opt.NumGoroutines),
 		writeTs:       getWriteTimestamp(zero),
+		namespaces:    &sync.Map{},
 	}
 	st.schema = newSchemaStore(readSchema(opt), opt, st)
 	ld := &loader{
@@ -183,7 +187,7 @@ func readSchema(opt *options) *schema.ParsedSchema {
 	buf, err := ioutil.ReadAll(r)
 	x.Check(err)
 
-	result, err := schema.Parse(string(buf))
+	result, err := schema.ParseWithNamespace(string(buf), opt.Namespace)
 	x.Check(err)
 	return result
 }
@@ -262,6 +266,8 @@ func (ld *loader) mapStage() {
 	// Send the graphql triples
 	ld.processGqlSchema(loadType)
 
+	// By this time, we will know about all the namespaces encountered. Else, we depend on the schema
+	// to contain whole of the information about namespace.
 	close(ld.readerChunkCh)
 	mapperWg.Wait()
 
@@ -276,6 +282,7 @@ func (ld *loader) mapStage() {
 	ld.xids = nil
 }
 
+// TODO(Naman): Fix this for multi-tenancy.
 func (ld *loader) processGqlSchema(loadType chunker.InputFormat) {
 	if ld.opt.GqlSchemaFile == "" {
 		return
@@ -299,6 +306,7 @@ func (ld *loader) processGqlSchema(loadType chunker.InputFormat) {
 	buf, err := ioutil.ReadAll(r)
 	x.Check(err)
 
+	// TODO(Naman): We will nedd this for all the namespaces.
 	rdfSchema := `_:gqlschema <dgraph.type> "dgraph.graphql" .
 	_:gqlschema <dgraph.graphql.xid> "dgraph.graphql.schema" .
 	_:gqlschema <dgraph.graphql.schema> %s .
@@ -310,6 +318,8 @@ func (ld *loader) processGqlSchema(loadType chunker.InputFormat) {
 		"dgraph.graphql.schema": %s
 	}`
 
+	// TODO(Naman): Process the GQL schema here.
+
 	gqlBuf := &bytes.Buffer{}
 	schema := strconv.Quote(string(buf))
 	switch loadType {
diff --git a/dgraph/cmd/bulk/mapper.go b/dgraph/cmd/bulk/mapper.go
index 79ada3b837b..a5c17757b24 100644
--- a/dgraph/cmd/bulk/mapper.go
+++ b/dgraph/cmd/bulk/mapper.go
@@ -84,7 +84,7 @@ type MapEntry []byte
 // }
 
 func mapEntrySize(key []byte, p *pb.Posting) int {
-	return 8 + 4 + 4 + len(key) + p.Size()
+	return 8 + 4 + 4 + len(key) + p.Size() // UID + keySz + postingSz + len(key) + size(p)
 }
 
 func marshalMapEntry(dst []byte, uid uint64, key []byte, p *pb.Posting) {
@@ -290,14 +290,17 @@ func (m *mapper) addMapEntry(key []byte, p *pb.Posting, shard int) {
 }
 
 func (m *mapper) processNQuad(nq gql.NQuad) {
-	sid := m.uid(nq.GetSubject())
+	if m.opt.Namespace != math.MaxUint64 {
+		nq.Namespace = m.opt.Namespace
+	}
+	sid := m.uid(nq.GetSubject(), nq.Namespace)
 	if sid == 0 {
 		panic(fmt.Sprintf("invalid UID with value 0 for %v", nq.GetSubject()))
 	}
 	var oid uint64
 	var de *pb.DirectedEdge
 	if nq.GetObjectValue() == nil {
-		oid = m.uid(nq.GetObjectId())
+		oid = m.uid(nq.GetObjectId(), nq.Namespace)
 		if oid == 0 {
 			panic(fmt.Sprintf("invalid UID with value 0 for %v", nq.GetObjectId()))
 		}
@@ -308,19 +311,23 @@ func (m *mapper) processNQuad(nq gql.NQuad) {
 		x.Check(err)
 	}
 
+	m.schema.checkAndSetInitialSchema(nq.Namespace)
+
+	// Appropriate schema must exist for the nquad's namespace by this time.
+	attr := x.NamespaceAttr(nq.Namespace, nq.Predicate)
 	fwd, rev := m.createPostings(nq, de)
-	shard := m.state.shards.shardFor(nq.Predicate)
-	key := x.DataKey(nq.Predicate, sid)
+	shard := m.state.shards.shardFor(attr)
+	key := x.DataKey(attr, sid)
 	m.addMapEntry(key, fwd, shard)
 
 	if rev != nil {
-		key = x.ReverseKey(nq.Predicate, oid)
+		key = x.ReverseKey(attr, oid)
 		m.addMapEntry(key, rev, shard)
 	}
 	m.addIndexMapEntries(nq, de)
 }
 
-func (m *mapper) uid(xid string) uint64 {
+func (m *mapper) uid(xid string, ns uint64) uint64 {
 	if !m.opt.NewUids {
 		if uid, err := strconv.ParseUint(xid, 0, 64); err == nil {
 			m.xids.BumpTo(uid)
@@ -328,10 +335,10 @@ func (m *mapper) uid(xid string) uint64 {
 		}
 	}
 
-	return m.lookupUid(xid)
+	return m.lookupUid(xid, ns)
 }
 
-func (m *mapper) lookupUid(xid string) uint64 {
+func (m *mapper) lookupUid(xid string, ns uint64) uint64 {
 	// We create a copy of xid string here because it is stored in
 	// the map in AssignUid and going to be around throughout the process.
 	// We don't want to keep the whole line that we read from file alive.
@@ -359,6 +366,7 @@ func (m *mapper) lookupUid(xid string) uint64 {
 		ObjectValue: &api.Value{
 			Val: &api.Value_StrVal{StrVal: xid},
 		},
+		Namespace: ns,
 	}}
 	m.processNQuad(nq)
 	return uid
@@ -370,7 +378,7 @@ func (m *mapper) createPostings(nq gql.NQuad,
 	m.schema.validateType(de, nq.ObjectValue == nil)
 
 	p := posting.NewPosting(de)
-	sch := m.schema.getSchema(nq.GetPredicate())
+	sch := m.schema.getSchema(x.NamespaceAttr(nq.GetNamespace(), nq.GetPredicate()))
 	if nq.GetObjectValue() != nil {
 		lang := de.GetLang()
 		switch {
@@ -405,7 +413,7 @@ func (m *mapper) addIndexMapEntries(nq gql.NQuad, de *pb.DirectedEdge) {
 		return // Cannot index UIDs
 	}
 
-	sch := m.schema.getSchema(nq.GetPredicate())
+	sch := m.schema.getSchema(x.NamespaceAttr(nq.GetNamespace(), nq.GetPredicate()))
 	for _, tokerName := range sch.GetTokenizer() {
 		// Find tokeniser.
 		toker, ok := tok.GetTokenizer(tokerName)
@@ -429,15 +437,16 @@ func (m *mapper) addIndexMapEntries(nq gql.NQuad, de *pb.DirectedEdge) {
 		toks, err := tok.BuildTokens(schemaVal.Value, tok.GetTokenizerForLang(toker, nq.Lang))
 		x.Check(err)
 
+		attr := x.NamespaceAttr(nq.Namespace, nq.Predicate)
 		// Store index posting.
 		for _, t := range toks {
 			m.addMapEntry(
-				x.IndexKey(nq.Predicate, t),
+				x.IndexKey(attr, t),
 				&pb.Posting{
 					Uid:         de.GetEntity(),
 					PostingType: pb.Posting_REF,
 				},
-				m.state.shards.shardFor(nq.Predicate),
+				m.state.shards.shardFor(attr),
 			)
 		}
 	}
diff --git a/dgraph/cmd/bulk/merge_shards.go b/dgraph/cmd/bulk/merge_shards.go
index e18748751a4..3192a21af6b 100644
--- a/dgraph/cmd/bulk/merge_shards.go
+++ b/dgraph/cmd/bulk/merge_shards.go
@@ -60,6 +60,7 @@ func mergeMapShardsIntoReduceShards(opt *options) {
 
 	// Put the first map shard in the first reduce shard since it contains all the reserved
 	// predicates.
+	// TODO(Naman): Why do we handle first shard differently?
 	reduceShard := filepath.Join(reduceShards[0], filepath.Base(firstShard))
 	fmt.Printf("Shard %s -> Reduce %s\n", firstShard, reduceShard)
 	x.Check(os.Rename(firstShard, reduceShard))
diff --git a/dgraph/cmd/bulk/run.go b/dgraph/cmd/bulk/run.go
index 40260a06d26..0ab9a8827f7 100644
--- a/dgraph/cmd/bulk/run.go
+++ b/dgraph/cmd/bulk/run.go
@@ -113,6 +113,8 @@ func init() {
 		"Comma separated list of tokenizer plugins")
 	flag.Bool("new_uids", false,
 		"Ignore UIDs in load files and assign new ones.")
+	flag.Uint64("force-namespace", math.MaxUint64,
+		"Namespace onto which to load the data. If not set, will preserve the namespace.")
 
 	// Options around how to set up Badger.
 	flag.String("badger.compression", "snappy",
@@ -156,6 +158,8 @@ func run() {
 		CustomTokenizers: Bulk.Conf.GetString("custom_tokenizers"),
 		NewUids:          Bulk.Conf.GetBool("new_uids"),
 		ClientDir:        Bulk.Conf.GetString("xidmap"),
+		Namespace:        Bulk.Conf.GetUint64("force-namespace"),
+
 		// Badger options
 		BadgerCompression:      ctype,
 		BadgerCompressionLevel: clevel,
diff --git a/dgraph/cmd/bulk/schema.go b/dgraph/cmd/bulk/schema.go
index 294dad5f943..6d35ecd2244 100644
--- a/dgraph/cmd/bulk/schema.go
+++ b/dgraph/cmd/bulk/schema.go
@@ -47,22 +47,12 @@ func newSchemaStore(initial *schema.ParsedSchema, opt *options, state *state) *s
 		state:     state,
 	}
 
-	// Load all initial predicates. Some predicates that might not be used when
-	// the alpha is started (e.g ACL predicates) might be included but it's
-	// better to include them in case the input data contains triples with these
-	// predicates.
 	// TODO(Ahsan): Use the right namespace here.
-	for _, update := range schema.CompleteInitialSchema(x.DefaultNamespace) {
-		s.schemaMap[update.Predicate] = update
-	}
-
-	if opt.StoreXids {
-		s.schemaMap["xid"] = &pb.SchemaUpdate{
-			ValueType: pb.Posting_STRING,
-			Tokenizer: []string{"hash"},
-		}
-	}
+	// Initialize only for the default namespace. Initialization for other namespaces will be done
+	// whenever we see data for a new namespace.
+	s.checkAndSetInitialSchema(x.DefaultNamespace)
 
+	// This is from the schema read from the schema file.
 	for _, sch := range initial.Preds {
 		p := sch.Predicate
 		sch.Predicate = "" // Predicate is stored in the (badger) key, so not needed in the value.
@@ -70,9 +60,12 @@ func newSchemaStore(initial *schema.ParsedSchema, opt *options, state *state) *s
 			fmt.Printf("Predicate %q already exists in schema\n", p)
 			continue
 		}
+		s.checkAndSetInitialSchema(x.ParseNamespace(p))
 		s.schemaMap[p] = sch
 	}
 
+	// TODO(Naman): Can types be there without the schema? Need to add initial schema for these
+	// namespaces?
 	s.types = initial.Types
 
 	return s
@@ -94,6 +87,32 @@ func (s *schemaStore) setSchemaAsList(pred string) {
 	sch.List = true
 }
 
+// checkAndSetInitialSchema initializes the schema for namespace if it does not already exist.
+func (s *schemaStore) checkAndSetInitialSchema(namespace uint64) {
+	if _, ok := s.namespaces.Load(namespace); !ok {
+		s.Lock()
+		defer s.Unlock()
+		if _, ok := s.namespaces.Load(namespace); !ok {
+			// Load all initial predicates. Some predicates that might not be used when
+			// the alpha is started (e.g ACL predicates) might be included but it's
+			// better to include them in case the input data contains triples with these
+			// predicates.
+			for _, update := range schema.CompleteInitialSchema(namespace) {
+				s.schemaMap[update.Predicate] = update
+			}
+
+			if s.opt.StoreXids {
+				s.schemaMap[x.NamespaceAttr(namespace, "xid")] = &pb.SchemaUpdate{
+					ValueType: pb.Posting_STRING,
+					Tokenizer: []string{"hash"},
+				}
+			}
+			s.namespaces.Store(namespace, struct{}{})
+		}
+	}
+	return
+}
+
 func (s *schemaStore) validateType(de *pb.DirectedEdge, objectIsUID bool) {
 	if objectIsUID {
 		de.ValueType = pb.Posting_UID
diff --git a/dgraph/cmd/bulk/shard_map.go b/dgraph/cmd/bulk/shard_map.go
index fe91f96895b..9721ae05bd2 100644
--- a/dgraph/cmd/bulk/shard_map.go
+++ b/dgraph/cmd/bulk/shard_map.go
@@ -37,6 +37,7 @@ func newShardMap(numShards int) *shardMap {
 }
 
 func (m *shardMap) shardFor(pred string) int {
+	// TODO(Naman): Figure out why?
 	// Always assign NQuads with reserved predicates to the first map shard.
 	if x.IsReservedPredicate(pred) {
 		return 0
diff --git a/dgraph/cmd/debug/run.go b/dgraph/cmd/debug/run.go
index 4509d63e5b4..8fd1e7b85e3 100644
--- a/dgraph/cmd/debug/run.go
+++ b/dgraph/cmd/debug/run.go
@@ -570,7 +570,9 @@ func printKeys(db *badger.DB) {
 		if pk.IsReverse() {
 			x.Check2(buf.WriteString("{r}"))
 		}
-		x.Check2(buf.WriteString(" attr: " + pk.Attr))
+		ns, attr := x.ParseNamespaceAttr(pk.Attr)
+		x.Check2(buf.WriteString(fmt.Sprintf(" ns: 0x%x ", ns)))
+		x.Check2(buf.WriteString(" attr: " + attr))
 		if len(pk.Term) > 0 {
 			fmt.Fprintf(&buf, " term: [%d] %s ", pk.Term[0], pk.Term[1:])
 		}
diff --git a/go.mod b/go.mod
index 3bf39e9353e..9949e6bbb6a 100644
--- a/go.mod
+++ b/go.mod
@@ -2,6 +2,8 @@ module github.com/dgraph-io/dgraph
 
 go 1.12
 
+replace github.com/dgraph-io/dgo/v200 => /home/algod/go/src/github.com/dgraph-io/dgo
+
 // replace github.com/dgraph-io/badger/v2 => /home/mrjn/go/src/github.com/dgraph-io/badger
 // replace github.com/dgraph-io/ristretto => /home/mrjn/go/src/github.com/dgraph-io/ristretto
 
@@ -67,8 +69,7 @@ require (
 	golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9
 	golang.org/x/sys v0.0.0-20210105210732-16f7687f5001
 	golang.org/x/text v0.3.3
-	golang.org/x/tools v0.0.0-20210106214847-113979e3529a
-	google.golang.org/grpc v1.23.0
+	google.golang.org/grpc v1.27.0
 	gopkg.in/DataDog/dd-trace-go.v1 v1.13.1 // indirect
 	gopkg.in/square/go-jose.v2 v2.3.1
 	gopkg.in/yaml.v2 v2.2.4
diff --git a/gql/mutation.go b/gql/mutation.go
index 50438d0abae..82482cbda14 100644
--- a/gql/mutation.go
+++ b/gql/mutation.go
@@ -115,9 +115,11 @@ func toUid(subject string, newToUid map[string]uint64) (uid uint64, err error) {
 var emptyEdge pb.DirectedEdge
 
 func (nq NQuad) createEdgePrototype(subjectUid uint64) *pb.DirectedEdge {
+	// TODO(Naman): Check all occurances of NQuad and directed edges.
+	// Check if we are passing the appropriate namespace everywhere.
 	return &pb.DirectedEdge{
 		Entity: subjectUid,
-		Attr:   nq.Predicate,
+		Attr:   x.NamespaceAttr(nq.Namespace, nq.Predicate),
 		Label:  nq.Label,
 		Lang:   nq.Lang,
 		Facets: nq.Facets,
diff --git a/graphql/admin/namespace.go b/graphql/admin/namespace.go
index b98c60519e4..b54be0d5fe0 100644
--- a/graphql/admin/namespace.go
+++ b/graphql/admin/namespace.go
@@ -3,6 +3,7 @@ package admin
 import (
 	"context"
 	"encoding/json"
+	"strconv"
 
 	"github.com/dgraph-io/dgraph/edgraph"
 	"github.com/dgraph-io/dgraph/graphql/resolve"
@@ -24,7 +25,7 @@ func resolveCreateNamespace(ctx context.Context, m schema.Mutation) (*resolve.Re
 	return resolve.DataResult(
 		m,
 		map[string]interface{}{m.Name(): map[string]interface{}{
-			"namespaceId": req.NamespaceId,
+			"namespaceId": strconv.Itoa(req.NamespaceId),
 			"message":     "Created namespace successfully",
 		}},
 		nil,
@@ -42,7 +43,7 @@ func resolveDeleteNamespace(ctx context.Context, m schema.Mutation) (*resolve.Re
 	return resolve.DataResult(
 		m,
 		map[string]interface{}{m.Name(): map[string]interface{}{
-			"namespaceId": req.NamespaceId,
+			"namespaceId": strconv.Itoa(req.NamespaceId),
 			"message":     "Deleted namespace successfully",
 		}},
 		nil,
diff --git a/query/mutation.go b/query/mutation.go
index 181656057e2..666f87218bd 100644
--- a/query/mutation.go
+++ b/query/mutation.go
@@ -194,6 +194,7 @@ func AssignUids(ctx context.Context, gmuList []*gql.Mutation) (map[string]uint64
 }
 
 // ToDirectedEdges converts the gql.Mutation input into a set of directed edges.
+// TODO(Naman): We have namespace in NQuad. Check if this function needs special handling.
 func ToDirectedEdges(gmuList []*gql.Mutation, newUids map[string]uint64) (
 	edges []*pb.DirectedEdge, err error) {
 
diff --git a/x/keys.go b/x/keys.go
index 778cf2868d7..ef914d44ef9 100644
--- a/x/keys.go
+++ b/x/keys.go
@@ -90,6 +90,12 @@ func ParseAttr(attr string) string {
 	return attr[8:]
 }
 
+// ParseNamespace returns the namespace from the given value.
+func ParseNamespace(attr string) uint64 {
+	AssertTrue(len(attr) >= 8)
+	return binary.BigEndian.Uint64([]byte(attr[:8]))
+}
+
 func ParseAttrList(attrs []string) []string {
 	var resp []string
 	for _, attr := range attrs {

From 2a529a6084f0a536c1b1b4ff8b7af870f8557302 Mon Sep 17 00:00:00 2001
From: NamanJain8 <jnaman806@gmail.com>
Date: Fri, 5 Feb 2021 16:31:52 +0530
Subject: [PATCH 2/7] lease the namespaces after map phase

---
 dgraph/cmd/bulk/loader.go | 24 ++++++++++++++++++++++++
 dgraph/cmd/bulk/run.go    |  1 +
 2 files changed, 25 insertions(+)

diff --git a/dgraph/cmd/bulk/loader.go b/dgraph/cmd/bulk/loader.go
index 665c15f0a58..9340e7ec5fd 100644
--- a/dgraph/cmd/bulk/loader.go
+++ b/dgraph/cmd/bulk/loader.go
@@ -168,6 +168,30 @@ func getWriteTimestamp(zero *grpc.ClientConn) uint64 {
 	}
 }
 
+func (ld *loader) leaseNamespaces() {
+	var maxNs uint64
+	ld.namespaces.Range(func(key, value interface{}) bool {
+		if ns := key.(uint64); ns > maxNs {
+			maxNs = ns
+		}
+		return true
+	})
+
+	client := pb.NewZeroClient(ld.zero)
+	for {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		// TODO(Naman): Maybe lease maxNs-1 with some handling. Using maxNs for simplicity for now.
+		ns, err := client.AssignIds(ctx, &pb.Num{Val: maxNs, Type: pb.Num_NS_ID})
+		cancel()
+		if err == nil {
+			fmt.Printf("Assigned namespaces till %d", ns.GetEndId())
+			return
+		}
+		fmt.Printf("Error communicating with dgraph zero, retrying: %v", err)
+		time.Sleep(time.Second)
+	}
+}
+
 func readSchema(opt *options) *schema.ParsedSchema {
 	f, err := filestore.Open(opt.SchemaFile)
 	x.Check(err)
diff --git a/dgraph/cmd/bulk/run.go b/dgraph/cmd/bulk/run.go
index 0ab9a8827f7..875700ab21b 100644
--- a/dgraph/cmd/bulk/run.go
+++ b/dgraph/cmd/bulk/run.go
@@ -330,6 +330,7 @@ func run() {
 	} else {
 		loader.mapStage()
 		mergeMapShardsIntoReduceShards(&opt)
+		loader.leaseNamespaces()
 
 		bulkMeta := pb.BulkMeta{
 			EdgeCount: loader.prog.mapEdgeCount,

From 52e88f09ebb45a54f04ae6a7c01741e3cd770847 Mon Sep 17 00:00:00 2001
From: NamanJain8 <jnaman806@gmail.com>
Date: Fri, 5 Feb 2021 17:46:08 +0530
Subject: [PATCH 3/7] test fixtures and cleanup

---
 chunker/json_parser_test.go | 29 ++++++++++++++++-------------
 chunker/rdf_parser_test.go  | 27 ++++++++++++++++-----------
 dgraph/cmd/bulk/loader.go   |  4 +---
 dgraph/cmd/bulk/mapper.go   |  7 ++++++-
 worker/online_restore_ee.go |  1 +
 5 files changed, 40 insertions(+), 28 deletions(-)

diff --git a/chunker/json_parser_test.go b/chunker/json_parser_test.go
index 4808940cc56..be3209adbf0 100644
--- a/chunker/json_parser_test.go
+++ b/chunker/json_parser_test.go
@@ -60,14 +60,15 @@ type address struct {
 }
 
 type Person struct {
-	Uid     string     `json:"uid,omitempty"`
-	Name    string     `json:"name,omitempty"`
-	Age     int        `json:"age,omitempty"`
-	Married *bool      `json:"married,omitempty"`
-	Now     *time.Time `json:"now,omitempty"`
-	Address address    `json:"address,omitempty"` // geo value
-	Friends []Person   `json:"friend,omitempty"`
-	School  *School    `json:"school,omitempty"`
+	Uid       string     `json:"uid,omitempty"`
+	Namespace string     `json:"namespace,omitempty"`
+	Name      string     `json:"name,omitempty"`
+	Age       int        `json:"age,omitempty"`
+	Married   *bool      `json:"married,omitempty"`
+	Now       *time.Time `json:"now,omitempty"`
+	Address   address    `json:"address,omitempty"` // geo value
+	Friends   []Person   `json:"friend,omitempty"`
+	School    *School    `json:"school,omitempty"`
 }
 
 func Parse(b []byte, op int) ([]*api.NQuad, error) {
@@ -90,6 +91,7 @@ func (exp *Experiment) verify() {
 		exp.t.Fatalf("Error while getting a dgraph client: %v", err)
 	}
 
+	// TODO(Naman): Fix these tests, once the ACL is integrated.
 	ctx := context.Background()
 	require.NoError(exp.t, dg.Alter(ctx, &api.Operation{DropAll: true}), "drop all failed")
 	require.NoError(exp.t, dg.Alter(ctx, &api.Operation{Schema: exp.schema}),
@@ -116,11 +118,12 @@ func TestNquadsFromJson1(t *testing.T) {
 	tn := time.Now().UTC()
 	m := true
 	p := Person{
-		Uid:     "1",
-		Name:    "Alice",
-		Age:     26,
-		Married: &m,
-		Now:     &tn,
+		Uid:       "1",
+		Namespace: "0x2",
+		Name:      "Alice",
+		Age:       26,
+		Married:   &m,
+		Now:       &tn,
 		Address: address{
 			Type:   "Point",
 			Coords: []float64{1.1, 2.0},
diff --git a/chunker/rdf_parser_test.go b/chunker/rdf_parser_test.go
index 3aadbfec4b9..55a1915c0b3 100644
--- a/chunker/rdf_parser_test.go
+++ b/chunker/rdf_parser_test.go
@@ -346,40 +346,43 @@ var testNQuads = []struct {
 		expectedErr: false,
 	},
 	{
-		input: `_:alice <knows> "stuff"^^<xs:string> <label> .`,
+		input: `_:alice <knows> "stuff"^^<xs:string> <0xf2> .`,
 		nq: api.NQuad{
 			Subject:     "_:alice",
 			Predicate:   "knows",
 			ObjectId:    "",
 			ObjectValue: &api.Value{Val: &api.Value_StrVal{StrVal: "stuff"}},
-			Label:       "label",
+			Label:       "0xf2",
+			Namespace:   0xf2,
 		},
 		expectedErr: false,
 	},
 	{
-		input: `_:alice <knows> "stuff"^^<xs:string> _:label .`,
+		input: `_:alice <knows> "stuff"^^<xs:string> <0xf2> .`,
 		nq: api.NQuad{
 			Subject:     "_:alice",
 			Predicate:   "knows",
 			ObjectId:    "",
 			ObjectValue: &api.Value{Val: &api.Value_StrVal{StrVal: "stuff"}},
-			Label:       "_:label",
+			Label:       "0xf2",
+			Namespace:   0xf2,
 		},
 		expectedErr: false,
 	},
 	{
-		input: `_:alice <knows> "stuff"^^<xs:string> _:label . # comment`,
+		input: `_:alice <knows> "stuff"^^<xs:string> <10> . # comment`,
 		nq: api.NQuad{
 			Subject:     "_:alice",
 			Predicate:   "knows",
 			ObjectId:    "",
 			ObjectValue: &api.Value{Val: &api.Value_StrVal{StrVal: "stuff"}},
-			Label:       "_:label",
+			Label:       "10",
+			Namespace:   10,
 		},
 		expectedErr: false,
 	},
 	{
-		input:       `_:alice <knows> "stuff"^^<xs:string> "label" .`,
+		input:       `_:alice <knows> "stuff"^^<xs:string> "0xf2" .`,
 		expectedErr: true,
 	},
 	{
@@ -599,13 +602,14 @@ var testNQuads = []struct {
 
 	// Edge Facets test.
 	{
-		input: `_:alice <knows> "stuff" _:label (key1="val1",key2=13) .`,
+		input: `_:alice <knows> "stuff" <0x10> (key1="val1",key2=13) .`,
 		nq: api.NQuad{
 			Subject:     "_:alice",
 			Predicate:   "knows",
 			ObjectId:    "",
 			ObjectValue: &api.Value{Val: &api.Value_DefaultVal{DefaultVal: "stuff"}},
-			Label:       "_:label",
+			Label:       "0x10",
+			Namespace:   0x10,
 			Facets: []*api.Facet{
 				{
 					Key:     "key1",
@@ -623,13 +627,14 @@ var testNQuads = []struct {
 		expectedErr: false,
 	},
 	{
-		input: `_:alice <knows> "stuff" _:label (key1=,key2=13) .`,
+		input: `_:alice <knows> "stuff" <0x12> (key1=,key2=13) .`,
 		nq: api.NQuad{
 			Subject:     "_:alice",
 			Predicate:   "knows",
 			ObjectId:    "",
 			ObjectValue: &api.Value{Val: &api.Value_DefaultVal{DefaultVal: "stuff"}},
-			Label:       "_:label",
+			Label:       "0x12",
+			Namespace:   0x12,
 			Facets: []*api.Facet{
 				{
 					Key:     "key1",
diff --git a/dgraph/cmd/bulk/loader.go b/dgraph/cmd/bulk/loader.go
index 9340e7ec5fd..4ab86b3c3ca 100644
--- a/dgraph/cmd/bulk/loader.go
+++ b/dgraph/cmd/bulk/loader.go
@@ -288,11 +288,9 @@ func (ld *loader) mapStage() {
 	x.Check(thr.Finish())
 
 	// Send the graphql triples
+	// TODO(Naman): Handle this.
 	ld.processGqlSchema(loadType)
 
-	// By this time, we will know about all the namespaces encountered. Else, we depend on the schema
-	// to contain whole of the information about namespace.
-	close(ld.readerChunkCh)
 	mapperWg.Wait()
 
 	// Allow memory to GC before the reduce phase.
diff --git a/dgraph/cmd/bulk/mapper.go b/dgraph/cmd/bulk/mapper.go
index a5c17757b24..73e1dfaea1a 100644
--- a/dgraph/cmd/bulk/mapper.go
+++ b/dgraph/cmd/bulk/mapper.go
@@ -291,6 +291,7 @@ func (m *mapper) addMapEntry(key []byte, p *pb.Posting, shard int) {
 
 func (m *mapper) processNQuad(nq gql.NQuad) {
 	if m.opt.Namespace != math.MaxUint64 {
+		// Use the specified namespace passed through '--force-namespace' flag.
 		nq.Namespace = m.opt.Namespace
 	}
 	sid := m.uid(nq.GetSubject(), nq.Namespace)
@@ -328,6 +329,8 @@ func (m *mapper) processNQuad(nq gql.NQuad) {
 }
 
 func (m *mapper) uid(xid string, ns uint64) uint64 {
+	// TODO(Naman): Q: Can 2 namespaces have nquad with same xid and still use newUids=false?
+	// Think about this check.
 	if !m.opt.NewUids {
 		if uid, err := strconv.ParseUint(xid, 0, 64); err == nil {
 			m.xids.BumpTo(uid)
@@ -352,7 +355,9 @@ func (m *mapper) lookupUid(xid string, ns uint64) uint64 {
 	// sb := strings.Builder{}
 	// x.Check2(sb.WriteString(xid))
 	// uid, isNew := m.xids.AssignUid(sb.String())
-	uid, isNew := m.xids.AssignUid(xid)
+
+	// There might be a case where Nquad from different namespace have the same xid.
+	uid, isNew := m.xids.AssignUid(x.NamespaceAttr(ns, xid))
 	if !m.opt.StoreXids || !isNew {
 		return uid
 	}
diff --git a/worker/online_restore_ee.go b/worker/online_restore_ee.go
index 1f152153758..527eabc788c 100644
--- a/worker/online_restore_ee.go
+++ b/worker/online_restore_ee.go
@@ -366,6 +366,7 @@ func writeBackup(ctx context.Context, req *pb.RestoreRequest) error {
 					"cannot update uid lease due to no connection to zero leader")
 			}
 			zc := pb.NewZeroClient(pl.Get())
+			// TODO(Naman): Assign NsID as well.
 			if _, err = zc.AssignIds(ctx, &pb.Num{Val: maxUid, Type: pb.Num_UID}); err != nil {
 				return 0, errors.Wrapf(err, "cannot update max uid lease after restore.")
 			}

From 59e71787137634d316844b036f5ddbcada3721d8 Mon Sep 17 00:00:00 2001
From: NamanJain8 <jnaman806@gmail.com>
Date: Fri, 5 Feb 2021 20:34:30 +0530
Subject: [PATCH 4/7] fix bug

---
 dgraph/cmd/bulk/loader.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dgraph/cmd/bulk/loader.go b/dgraph/cmd/bulk/loader.go
index 4ab86b3c3ca..d86eb9307a3 100644
--- a/dgraph/cmd/bulk/loader.go
+++ b/dgraph/cmd/bulk/loader.go
@@ -291,6 +291,7 @@ func (ld *loader) mapStage() {
 	// TODO(Naman): Handle this.
 	ld.processGqlSchema(loadType)
 
+	close(ld.readerChunkCh)
 	mapperWg.Wait()
 
 	// Allow memory to GC before the reduce phase.

From 90b9768c22f523cf2755cae3dbb4bf8ebc0901a1 Mon Sep 17 00:00:00 2001
From: NamanJain8 <jnaman806@gmail.com>
Date: Fri, 5 Feb 2021 22:02:09 +0530
Subject: [PATCH 5/7] address comments

---
 chunker/rdf_parser.go           |  1 -
 dgraph/cmd/bulk/loader.go       |  1 -
 dgraph/cmd/bulk/mapper.go       |  6 ++--
 dgraph/cmd/bulk/merge_shards.go |  3 +-
 dgraph/cmd/bulk/schema.go       | 50 +++++++++++++++++----------------
 dgraph/cmd/bulk/shard_map.go    |  1 -
 dgraph/cmd/debug/run.go         |  2 +-
 gql/mutation.go                 |  4 +--
 query/mutation.go               |  1 -
 worker/export.go                |  8 +++---
 worker/export_test.go           | 13 ++++-----
 worker/online_restore_ee.go     |  1 -
 12 files changed, 41 insertions(+), 50 deletions(-)

diff --git a/chunker/rdf_parser.go b/chunker/rdf_parser.go
index dd798bd54b8..812b0d83491 100644
--- a/chunker/rdf_parser.go
+++ b/chunker/rdf_parser.go
@@ -226,7 +226,6 @@ L:
 		return rnq, errors.Errorf("NQuad failed sanity check:%+v", rnq)
 	}
 
-	// TODO(Naman): Ensure the label contains valid namespace.
 	// Append the namespace to the predicate before returning NQuad.
 	if rnq.Label != "" {
 		ns, err := strconv.ParseUint(rnq.Label, 0, 64)
diff --git a/dgraph/cmd/bulk/loader.go b/dgraph/cmd/bulk/loader.go
index d86eb9307a3..7cf32ce2d64 100644
--- a/dgraph/cmd/bulk/loader.go
+++ b/dgraph/cmd/bulk/loader.go
@@ -180,7 +180,6 @@ func (ld *loader) leaseNamespaces() {
 	client := pb.NewZeroClient(ld.zero)
 	for {
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-		// TODO(Naman): Maybe lease maxNs-1 with some handling. Using maxNs for simplicity for now.
 		ns, err := client.AssignIds(ctx, &pb.Num{Val: maxNs, Type: pb.Num_NS_ID})
 		cancel()
 		if err == nil {
diff --git a/dgraph/cmd/bulk/mapper.go b/dgraph/cmd/bulk/mapper.go
index 73e1dfaea1a..371bcd7cf00 100644
--- a/dgraph/cmd/bulk/mapper.go
+++ b/dgraph/cmd/bulk/mapper.go
@@ -329,8 +329,6 @@ func (m *mapper) processNQuad(nq gql.NQuad) {
 }
 
 func (m *mapper) uid(xid string, ns uint64) uint64 {
-	// TODO(Naman): Q: Can 2 namespaces have nquad with same xid and still use newUids=false?
-	// Think about this check.
 	if !m.opt.NewUids {
 		if uid, err := strconv.ParseUint(xid, 0, 64); err == nil {
 			m.xids.BumpTo(uid)
@@ -380,7 +378,7 @@ func (m *mapper) lookupUid(xid string, ns uint64) uint64 {
 func (m *mapper) createPostings(nq gql.NQuad,
 	de *pb.DirectedEdge) (*pb.Posting, *pb.Posting) {
 
-	m.schema.validateType(de, nq.ObjectValue == nil)
+	m.schema.validateType(de, nq.Namespace, nq.ObjectValue == nil)
 
 	p := posting.NewPosting(de)
 	sch := m.schema.getSchema(x.NamespaceAttr(nq.GetNamespace(), nq.GetPredicate()))
@@ -405,7 +403,7 @@ func (m *mapper) createPostings(nq gql.NQuad,
 	// Reverse predicate
 	x.AssertTruef(nq.GetObjectValue() == nil, "only has reverse schema if object is UID")
 	de.Entity, de.ValueId = de.ValueId, de.Entity
-	m.schema.validateType(de, true)
+	m.schema.validateType(de, nq.Namespace, true)
 	rp := posting.NewPosting(de)
 
 	de.Entity, de.ValueId = de.ValueId, de.Entity // de reused so swap back.
diff --git a/dgraph/cmd/bulk/merge_shards.go b/dgraph/cmd/bulk/merge_shards.go
index 3192a21af6b..5a03936d7c4 100644
--- a/dgraph/cmd/bulk/merge_shards.go
+++ b/dgraph/cmd/bulk/merge_shards.go
@@ -59,8 +59,7 @@ func mergeMapShardsIntoReduceShards(opt *options) {
 	}
 
 	// Put the first map shard in the first reduce shard since it contains all the reserved
-	// predicates.
-	// TODO(Naman): Why do we handle first shard differently?
+	// predicates. We want all the reserved predicates in group 1.
 	reduceShard := filepath.Join(reduceShards[0], filepath.Base(firstShard))
 	fmt.Printf("Shard %s -> Reduce %s\n", firstShard, reduceShard)
 	x.Check(os.Rename(firstShard, reduceShard))
diff --git a/dgraph/cmd/bulk/schema.go b/dgraph/cmd/bulk/schema.go
index 6d35ecd2244..b7a7960ba2a 100644
--- a/dgraph/cmd/bulk/schema.go
+++ b/dgraph/cmd/bulk/schema.go
@@ -64,8 +64,6 @@ func newSchemaStore(initial *schema.ParsedSchema, opt *options, state *state) *s
 		s.schemaMap[p] = sch
 	}
 
-	// TODO(Naman): Can types be there without the schema? Need to add initial schema for these
-	// namespaces?
 	s.types = initial.Types
 
 	return s
@@ -89,47 +87,51 @@ func (s *schemaStore) setSchemaAsList(pred string) {
 
 // checkAndSetInitialSchema initializes the schema for namespace if it does not already exist.
 func (s *schemaStore) checkAndSetInitialSchema(namespace uint64) {
-	if _, ok := s.namespaces.Load(namespace); !ok {
-		s.Lock()
-		defer s.Unlock()
-		if _, ok := s.namespaces.Load(namespace); !ok {
-			// Load all initial predicates. Some predicates that might not be used when
-			// the alpha is started (e.g ACL predicates) might be included but it's
-			// better to include them in case the input data contains triples with these
-			// predicates.
-			for _, update := range schema.CompleteInitialSchema(namespace) {
-				s.schemaMap[update.Predicate] = update
-			}
+	if _, ok := s.namespaces.Load(namespace); ok {
+		return
+	}
+	s.Lock()
+	defer s.Unlock()
 
-			if s.opt.StoreXids {
-				s.schemaMap[x.NamespaceAttr(namespace, "xid")] = &pb.SchemaUpdate{
-					ValueType: pb.Posting_STRING,
-					Tokenizer: []string{"hash"},
-				}
-			}
-			s.namespaces.Store(namespace, struct{}{})
+	if _, ok := s.namespaces.Load(namespace); ok {
+		return
+	}
+	// Load all initial predicates. Some predicates that might not be used when
+	// the alpha is started (e.g ACL predicates) might be included but it's
+	// better to include them in case the input data contains triples with these
+	// predicates.
+	for _, update := range schema.CompleteInitialSchema(namespace) {
+		s.schemaMap[update.Predicate] = update
+	}
+
+	if s.opt.StoreXids {
+		s.schemaMap[x.NamespaceAttr(namespace, "xid")] = &pb.SchemaUpdate{
+			ValueType: pb.Posting_STRING,
+			Tokenizer: []string{"hash"},
 		}
 	}
+	s.namespaces.Store(namespace, struct{}{})
 	return
 }
 
-func (s *schemaStore) validateType(de *pb.DirectedEdge, objectIsUID bool) {
+func (s *schemaStore) validateType(de *pb.DirectedEdge, namespace uint64, objectIsUID bool) {
 	if objectIsUID {
 		de.ValueType = pb.Posting_UID
 	}
 
+	attr := x.NamespaceAttr(namespace, de.Attr)
 	s.RLock()
-	sch, ok := s.schemaMap[de.Attr]
+	sch, ok := s.schemaMap[attr]
 	s.RUnlock()
 	if !ok {
 		s.Lock()
-		sch, ok = s.schemaMap[de.Attr]
+		sch, ok = s.schemaMap[attr]
 		if !ok {
 			sch = &pb.SchemaUpdate{ValueType: de.ValueType}
 			if objectIsUID {
 				sch.List = true
 			}
-			s.schemaMap[de.Attr] = sch
+			s.schemaMap[attr] = sch
 		}
 		s.Unlock()
 	}
diff --git a/dgraph/cmd/bulk/shard_map.go b/dgraph/cmd/bulk/shard_map.go
index 9721ae05bd2..fe91f96895b 100644
--- a/dgraph/cmd/bulk/shard_map.go
+++ b/dgraph/cmd/bulk/shard_map.go
@@ -37,7 +37,6 @@ func newShardMap(numShards int) *shardMap {
 }
 
 func (m *shardMap) shardFor(pred string) int {
-	// TODO(Naman): Figure out why?
 	// Always assign NQuads with reserved predicates to the first map shard.
 	if x.IsReservedPredicate(pred) {
 		return 0
diff --git a/dgraph/cmd/debug/run.go b/dgraph/cmd/debug/run.go
index 8fd1e7b85e3..dd05f3ef501 100644
--- a/dgraph/cmd/debug/run.go
+++ b/dgraph/cmd/debug/run.go
@@ -571,7 +571,7 @@ func printKeys(db *badger.DB) {
 			x.Check2(buf.WriteString("{r}"))
 		}
 		ns, attr := x.ParseNamespaceAttr(pk.Attr)
-		x.Check2(buf.WriteString(fmt.Sprintf(" ns: 0x%x ", ns)))
+		x.Check2(buf.WriteString(fmt.Sprintf(" ns: %#x ", ns)))
 		x.Check2(buf.WriteString(" attr: " + attr))
 		if len(pk.Term) > 0 {
 			fmt.Fprintf(&buf, " term: [%d] %s ", pk.Term[0], pk.Term[1:])
diff --git a/gql/mutation.go b/gql/mutation.go
index 82482cbda14..50438d0abae 100644
--- a/gql/mutation.go
+++ b/gql/mutation.go
@@ -115,11 +115,9 @@ func toUid(subject string, newToUid map[string]uint64) (uid uint64, err error) {
 var emptyEdge pb.DirectedEdge
 
 func (nq NQuad) createEdgePrototype(subjectUid uint64) *pb.DirectedEdge {
-	// TODO(Naman): Check all occurances of NQuad and directed edges.
-	// Check if we are passing the appropriate namespace everywhere.
 	return &pb.DirectedEdge{
 		Entity: subjectUid,
-		Attr:   x.NamespaceAttr(nq.Namespace, nq.Predicate),
+		Attr:   nq.Predicate,
 		Label:  nq.Label,
 		Lang:   nq.Lang,
 		Facets: nq.Facets,
diff --git a/query/mutation.go b/query/mutation.go
index 666f87218bd..181656057e2 100644
--- a/query/mutation.go
+++ b/query/mutation.go
@@ -194,7 +194,6 @@ func AssignUids(ctx context.Context, gmuList []*gql.Mutation) (map[string]uint64
 }
 
 // ToDirectedEdges converts the gql.Mutation input into a set of directed edges.
-// TODO(Naman): We have namespace in NQuad. Check if this function needs special handling.
 func ToDirectedEdges(gmuList []*gql.Mutation, newUids map[string]uint64) (
 	edges []*pb.DirectedEdge, err error) {
 
diff --git a/worker/export.go b/worker/export.go
index 9a5f3298f81..af7bad5b3ca 100644
--- a/worker/export.go
+++ b/worker/export.go
@@ -95,8 +95,8 @@ var rdfTypeMap = map[types.TypeID]string{
 }
 
 // UIDs like 0x1 look weird but 64-bit ones like 0x0000000000000001 are too long.
-var uidFmtStrRdf = "<0x%x>"
-var uidFmtStrJson = "\"0x%x\""
+var uidFmtStrRdf = "<%#x>"
+var uidFmtStrJson = "\"%#x\""
 
 // valToStr converts a posting value to a string.
 func valToStr(v types.Val) (string, error) {
@@ -242,7 +242,7 @@ func (e *exporter) toRDF() (*bpb.KVList, error) {
 		}
 		// Let's skip labels. Dgraph doesn't support them for any functionality.
 		// Use label for storing namespace.
-		fmt.Fprintf(bp, " <0x%x>", e.namespace)
+		fmt.Fprintf(bp, " <%#x>", e.namespace)
 
 		// Facets.
 		if len(p.Facets) != 0 {
@@ -288,7 +288,7 @@ func toSchema(attr string, update *pb.SchemaUpdate) *bpb.KV {
 	// bytes.Buffer never returns error for any of the writes. So, we don't need to check them.
 	ns, attr := x.ParseNamespaceAttr(attr)
 	var buf bytes.Buffer
-	x.Check2(buf.WriteString(fmt.Sprintf("[0x%x]", ns)))
+	x.Check2(buf.WriteString(fmt.Sprintf("[%#x]", ns)))
 	x.Check2(buf.WriteRune(' '))
 	x.Check2(buf.WriteRune('<'))
 	x.Check2(buf.WriteString(attr))
diff --git a/worker/export_test.go b/worker/export_test.go
index 0e4385c0cd7..1ba4980ca5a 100644
--- a/worker/export_test.go
+++ b/worker/export_test.go
@@ -73,15 +73,15 @@ var personType = &pb.TypeUpdate{
 
 func populateGraphExport(t *testing.T) {
 	rdfEdges := []string{
-		`<1> <friend> <5> <author0> .`,
-		`<2> <friend> <5> <author0> .`,
+		`<1> <friend> <5> .`,
+		`<2> <friend> <5> .`,
 		`<3> <friend> <5> .`,
-		`<4> <friend> <5> <author0> (since=2005-05-02T15:04:05,close=true,` +
+		`<4> <friend> <5> (since=2005-05-02T15:04:05,close=true,` +
 			`age=33,game="football",poem="roses are red\nviolets are blue") .`,
-		`<1> <name> "pho\ton\u0000" <author0> .`,
-		`<2> <name> "pho\ton"@en <author0> .`,
+		`<1> <name> "pho\ton\u0000" .`,
+		`<2> <name> "pho\ton"@en .`,
 		`<3> <name> "First Line\nSecondLine" .`,
-		"<1> <friend_not_served> <5> <author0> .",
+		"<1> <friend_not_served> <5> .",
 		`<5> <name> "" .`,
 		`<6> <name> "Ding!\u0007Ding!\u0007Ding!\u0007" .`,
 		`<7> <name> "node_to_delete" .`,
@@ -441,7 +441,6 @@ type skv struct {
 	schema pb.SchemaUpdate
 }
 
-// TODO(Naman): Update this test according to namespace format.
 func TestToSchema(t *testing.T) {
 	testCases := []struct {
 		skv      *skv
diff --git a/worker/online_restore_ee.go b/worker/online_restore_ee.go
index 527eabc788c..1f152153758 100644
--- a/worker/online_restore_ee.go
+++ b/worker/online_restore_ee.go
@@ -366,7 +366,6 @@ func writeBackup(ctx context.Context, req *pb.RestoreRequest) error {
 					"cannot update uid lease due to no connection to zero leader")
 			}
 			zc := pb.NewZeroClient(pl.Get())
-			// TODO(Naman): Assign NsID as well.
 			if _, err = zc.AssignIds(ctx, &pb.Num{Val: maxUid, Type: pb.Num_UID}); err != nil {
 				return 0, errors.Wrapf(err, "cannot update max uid lease after restore.")
 			}

From 50bc6868aa53bc63546e5f5081a5def26c7409a7 Mon Sep 17 00:00:00 2001
From: NamanJain8 <jnaman806@gmail.com>
Date: Mon, 8 Feb 2021 16:23:11 +0530
Subject: [PATCH 6/7] remove label from nquad, directed edge and posting list

---
 chunker/json_parser.go     |  15 +-
 chunker/rdf_parser.go      |  23 +-
 chunker/rdf_parser_test.go |   5 -
 dgraph/cmd/bulk/loader.go  |  11 +-
 dgraph/cmd/live/batch.go   |  12 +-
 gql/mutation.go            |  24 +-
 graphql/admin/namespace.go |   4 +-
 posting/index.go           |   2 -
 posting/list.go            |   3 +-
 posting/size.go            |   3 -
 protos/pb.proto            |   5 +-
 protos/pb/pb.pb.go         | 769 +++++++++++++++++--------------------
 worker/export.go           |   3 +-
 worker/export_test.go      |  28 +-
 worker/mutation_test.go    |   8 -
 worker/worker_test.go      |  11 +-
 16 files changed, 434 insertions(+), 492 deletions(-)

diff --git a/chunker/json_parser.go b/chunker/json_parser.go
index 1d55f8ebb3c..b356db05134 100644
--- a/chunker/json_parser.go
+++ b/chunker/json_parser.go
@@ -451,9 +451,9 @@ func (buf *NQuadBuffer) mapToNquads(m map[string]interface{}, op int, parentPred
 
 	namespace := x.DefaultNamespace
 	if ns, ok := m["namespace"]; ok {
-		switch ns := ns.(type) {
+		switch nsVal := ns.(type) {
 		case json.Number:
-			nsi, err := ns.Int64()
+			nsi, err := nsVal.Int64()
 			if err != nil {
 				return mr, err
 			}
@@ -461,7 +461,16 @@ func (buf *NQuadBuffer) mapToNquads(m map[string]interface{}, op int, parentPred
 
 		// this int64 case is needed for FastParseJSON, which doesn't use json.Number
 		case int64:
-			namespace = uint64(ns)
+			namespace = uint64(nsVal)
+		case string:
+			s := stripSpaces(nsVal)
+			if s == "" {
+				namespace = 0
+			} else if n, err := strconv.ParseUint(s, 0, 64); err == nil {
+				namespace = n
+			} else {
+				return mr, err
+			}
 		}
 	}
 	mr.namespace = namespace
diff --git a/chunker/rdf_parser.go b/chunker/rdf_parser.go
index 812b0d83491..ea0acc20377 100644
--- a/chunker/rdf_parser.go
+++ b/chunker/rdf_parser.go
@@ -36,9 +36,9 @@ var (
 	ErrEmpty = errors.New("RDF: harmless error, e.g. comment line")
 )
 
-// Function to do sanity check for subject, predicate, object and label strings.
+// Function to do sanity check for subject, predicate and object strings.
 func sane(s string) bool {
-	// Label and ObjectId can be "", we already check that subject and predicate
+	// ObjectId can be "", we already check that subject and predicate
 	// shouldn't be empty.
 	if len(s) == 0 {
 		return true
@@ -194,7 +194,12 @@ L:
 			break L
 
 		case itemLabel:
-			rnq.Label = strings.TrimFunc(item.Val, isSpaceRune)
+			s := strings.TrimFunc(item.Val, isSpaceRune)
+			namespace, err := strconv.ParseUint(s, 0, 64)
+			if err != nil {
+				return rnq, errors.Errorf("Invalid namespace ID. Input: [%s]", line)
+			}
+			rnq.Namespace = namespace
 
 		case itemLeftRound:
 			it.Prev() // backup '('
@@ -221,20 +226,10 @@ L:
 	if len(rnq.ObjectId) == 0 && rnq.ObjectValue == nil {
 		return rnq, errors.Errorf("No Object in NQuad. Input: [%s]", line)
 	}
-	if !sane(rnq.Subject) || !sane(rnq.Predicate) ||
-		!sane(rnq.ObjectId) || !sane(rnq.Label) {
+	if !sane(rnq.Subject) || !sane(rnq.Predicate) || !sane(rnq.ObjectId) {
 		return rnq, errors.Errorf("NQuad failed sanity check:%+v", rnq)
 	}
 
-	// Append the namespace to the predicate before returning NQuad.
-	if rnq.Label != "" {
-		ns, err := strconv.ParseUint(rnq.Label, 0, 64)
-		if err != nil {
-			return rnq, err
-		}
-		rnq.Namespace = ns
-	}
-
 	return rnq, nil
 }
 
diff --git a/chunker/rdf_parser_test.go b/chunker/rdf_parser_test.go
index 55a1915c0b3..637854ae65a 100644
--- a/chunker/rdf_parser_test.go
+++ b/chunker/rdf_parser_test.go
@@ -352,7 +352,6 @@ var testNQuads = []struct {
 			Predicate:   "knows",
 			ObjectId:    "",
 			ObjectValue: &api.Value{Val: &api.Value_StrVal{StrVal: "stuff"}},
-			Label:       "0xf2",
 			Namespace:   0xf2,
 		},
 		expectedErr: false,
@@ -364,7 +363,6 @@ var testNQuads = []struct {
 			Predicate:   "knows",
 			ObjectId:    "",
 			ObjectValue: &api.Value{Val: &api.Value_StrVal{StrVal: "stuff"}},
-			Label:       "0xf2",
 			Namespace:   0xf2,
 		},
 		expectedErr: false,
@@ -376,7 +374,6 @@ var testNQuads = []struct {
 			Predicate:   "knows",
 			ObjectId:    "",
 			ObjectValue: &api.Value{Val: &api.Value_StrVal{StrVal: "stuff"}},
-			Label:       "10",
 			Namespace:   10,
 		},
 		expectedErr: false,
@@ -608,7 +605,6 @@ var testNQuads = []struct {
 			Predicate:   "knows",
 			ObjectId:    "",
 			ObjectValue: &api.Value{Val: &api.Value_DefaultVal{DefaultVal: "stuff"}},
-			Label:       "0x10",
 			Namespace:   0x10,
 			Facets: []*api.Facet{
 				{
@@ -633,7 +629,6 @@ var testNQuads = []struct {
 			Predicate:   "knows",
 			ObjectId:    "",
 			ObjectValue: &api.Value{Val: &api.Value_DefaultVal{DefaultVal: "stuff"}},
-			Label:       "0x12",
 			Namespace:   0x12,
 			Facets: []*api.Facet{
 				{
diff --git a/dgraph/cmd/bulk/loader.go b/dgraph/cmd/bulk/loader.go
index 7cf32ce2d64..262391fd0b6 100644
--- a/dgraph/cmd/bulk/loader.go
+++ b/dgraph/cmd/bulk/loader.go
@@ -168,6 +168,8 @@ func getWriteTimestamp(zero *grpc.ClientConn) uint64 {
 	}
 }
 
+// leaseNamespace is called at the end of map phase. It leases the namespace ids till the maximum
+// seen namespace id.
 func (ld *loader) leaseNamespaces() {
 	var maxNs uint64
 	ld.namespaces.Range(func(key, value interface{}) bool {
@@ -177,6 +179,11 @@ func (ld *loader) leaseNamespaces() {
 		return true
 	})
 
+	// If only the default namespace is seen, do nothing.
+	if maxNs == 0 {
+		return
+	}
+
 	client := pb.NewZeroClient(ld.zero)
 	for {
 		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
@@ -287,7 +294,9 @@ func (ld *loader) mapStage() {
 	x.Check(thr.Finish())
 
 	// Send the graphql triples
-	// TODO(Naman): Handle this.
+	// TODO(Naman): Handle this. Currently we are not attaching the namespace info with the exported
+	// graphql schema (See exportInternal). Also, attach the namespace information once for the
+	// namespace we are loading into.
 	ld.processGqlSchema(loadType)
 
 	close(ld.readerChunkCh)
diff --git a/dgraph/cmd/live/batch.go b/dgraph/cmd/live/batch.go
index 2a56087e536..dc3746e7503 100644
--- a/dgraph/cmd/live/batch.go
+++ b/dgraph/cmd/live/batch.go
@@ -211,7 +211,7 @@ func createUidEdge(nq *api.NQuad, sid, oid uint64) *pb.DirectedEdge {
 	return &pb.DirectedEdge{
 		Entity:    sid,
 		Attr:      nq.Predicate,
-		Label:     nq.Label,
+		Namespace: nq.Namespace,
 		Lang:      nq.Lang,
 		Facets:    nq.Facets,
 		ValueId:   oid,
@@ -221,11 +221,11 @@ func createUidEdge(nq *api.NQuad, sid, oid uint64) *pb.DirectedEdge {
 
 func createValueEdge(nq *api.NQuad, sid uint64) (*pb.DirectedEdge, error) {
 	p := &pb.DirectedEdge{
-		Entity: sid,
-		Attr:   nq.Predicate,
-		Label:  nq.Label,
-		Lang:   nq.Lang,
-		Facets: nq.Facets,
+		Entity:    sid,
+		Attr:      nq.Predicate,
+		Namespace: nq.Namespace,
+		Lang:      nq.Lang,
+		Facets:    nq.Facets,
 	}
 	val, err := getTypeVal(nq.ObjectValue)
 	if err != nil {
diff --git a/gql/mutation.go b/gql/mutation.go
index 50438d0abae..3b56b6837d1 100644
--- a/gql/mutation.go
+++ b/gql/mutation.go
@@ -116,11 +116,11 @@ var emptyEdge pb.DirectedEdge
 
 func (nq NQuad) createEdgePrototype(subjectUid uint64) *pb.DirectedEdge {
 	return &pb.DirectedEdge{
-		Entity: subjectUid,
-		Attr:   nq.Predicate,
-		Label:  nq.Label,
-		Lang:   nq.Lang,
-		Facets: nq.Facets,
+		Entity:    subjectUid,
+		Attr:      nq.Predicate,
+		Namespace: nq.Namespace,
+		Lang:      nq.Lang,
+		Facets:    nq.Facets,
 	}
 }
 
@@ -132,7 +132,7 @@ func (nq NQuad) CreateUidEdge(subjectUid uint64, objectUid uint64) *pb.DirectedE
 	return out
 }
 
-// CreateValueEdge returns a DirectedEdge with the given subject. The predicate, label,
+// CreateValueEdge returns a DirectedEdge with the given subject. The predicate,
 // language, and facet values are derived from the NQuad.
 func (nq NQuad) CreateValueEdge(subjectUid uint64) (*pb.DirectedEdge, error) {
 	var err error
@@ -154,12 +154,12 @@ func (nq NQuad) ToDeletePredEdge() (*pb.DirectedEdge, error) {
 	out := &pb.DirectedEdge{
 		// This along with edge.ObjectValue == x.Star would indicate
 		// that we want to delete the predicate.
-		Entity: 0,
-		Attr:   nq.Predicate,
-		Label:  nq.Label,
-		Lang:   nq.Lang,
-		Facets: nq.Facets,
-		Op:     pb.DirectedEdge_DEL,
+		Entity:    0,
+		Attr:      nq.Predicate,
+		Namespace: nq.Namespace,
+		Lang:      nq.Lang,
+		Facets:    nq.Facets,
+		Op:        pb.DirectedEdge_DEL,
 	}
 
 	if err := copyValue(out, nq); err != nil {
diff --git a/graphql/admin/namespace.go b/graphql/admin/namespace.go
index b54be0d5fe0..537d8bccbdf 100644
--- a/graphql/admin/namespace.go
+++ b/graphql/admin/namespace.go
@@ -25,7 +25,7 @@ func resolveCreateNamespace(ctx context.Context, m schema.Mutation) (*resolve.Re
 	return resolve.DataResult(
 		m,
 		map[string]interface{}{m.Name(): map[string]interface{}{
-			"namespaceId": strconv.Itoa(req.NamespaceId),
+			"namespaceId": json.Number(strconv.Itoa(req.NamespaceId)),
 			"message":     "Created namespace successfully",
 		}},
 		nil,
@@ -43,7 +43,7 @@ func resolveDeleteNamespace(ctx context.Context, m schema.Mutation) (*resolve.Re
 	return resolve.DataResult(
 		m,
 		map[string]interface{}{m.Name(): map[string]interface{}{
-			"namespaceId": strconv.Itoa(req.NamespaceId),
+			"namespaceId": json.Number(strconv.Itoa(req.NamespaceId)),
 			"message":     "Deleted namespace successfully",
 		}},
 		nil,
diff --git a/posting/index.go b/posting/index.go
index 3a35421745f..f00db564a23 100644
--- a/posting/index.go
+++ b/posting/index.go
@@ -1139,7 +1139,6 @@ func rebuildReverseEdges(ctx context.Context, rb *IndexRebuild) error {
 			edge.ValueId = puid
 			edge.Op = pb.DirectedEdge_SET
 			edge.Facets = pp.Facets
-			edge.Label = pp.Label
 
 			for {
 				// we only need to build reverse index here.
@@ -1220,7 +1219,6 @@ func rebuildListType(ctx context.Context, rb *IndexRebuild) error {
 			Value:     mpost.Value,
 			ValueType: mpost.ValType,
 			Op:        pb.DirectedEdge_SET,
-			Label:     mpost.Label,
 			Facets:    mpost.Facets,
 		}
 		return pl.addMutation(ctx, txn, newEdge)
diff --git a/posting/list.go b/posting/list.go
index c3116a0f1c5..2d27c3bd4b0 100644
--- a/posting/list.go
+++ b/posting/list.go
@@ -315,7 +315,6 @@ func NewPosting(t *pb.DirectedEdge) *pb.Posting {
 		ValType:     t.ValueType,
 		PostingType: postingType,
 		LangTag:     []byte(t.Lang),
-		Label:       t.Label,
 		Op:          op,
 		Facets:      t.Facets,
 	}
@@ -1026,7 +1025,7 @@ func (l *List) encode(out *rollupOutput, readTs uint64, split bool) error {
 		}
 
 		enc.Add(p.Uid)
-		if p.Facets != nil || p.PostingType != pb.Posting_REF || len(p.Label) != 0 {
+		if p.Facets != nil || p.PostingType != pb.Posting_REF {
 			plist.Postings = append(plist.Postings, p)
 		}
 		return nil
diff --git a/posting/size.go b/posting/size.go
index 023ae02a8e4..9435037c161 100644
--- a/posting/size.go
+++ b/posting/size.go
@@ -129,9 +129,6 @@ func calculatePostingSize(posting *pb.Posting) uint64 {
 	// Adding the size of each entry in LangTag array.
 	size += uint64(cap(posting.LangTag))
 
-	// Adding the size of each entry in Lables array.
-	size += uint64(len(posting.Label))
-
 	for _, f := range posting.Facets {
 		// Add the size of each facet.
 		size += calculateFacet(f)
diff --git a/protos/pb.proto b/protos/pb.proto
index 6cc7932e00d..6b78e0a5215 100644
--- a/protos/pb.proto
+++ b/protos/pb.proto
@@ -216,12 +216,12 @@ message Tablet {
 }
 
 message DirectedEdge {
+	reserved 6;  // This was used for label.
 	fixed64 entity             = 1;    // Subject or source node / UID.
 	string attr                = 2;       // Attribute or predicate. Labels the edge.
 	bytes value                = 3;       // Edge points to a value.
 	Posting.ValType value_type = 4;  // The type of the value
 	fixed64 value_id           = 5;   // Object or destination node / UID.
-	string label               = 6;
 	string lang                = 7;
 	enum Op {
 		SET = 0;
@@ -230,6 +230,7 @@ message DirectedEdge {
 	Op op = 8;
 	repeated api.Facet facets = 9;
 	repeated string allowedPreds = 10;
+	uint64 namespace = 11;
 }
 
 message Mutations {
@@ -333,6 +334,7 @@ message KVS {
 
 // Posting messages.
 message Posting {
+	reserved 6; // This was used for label.
 	fixed64 uid = 1;
 	bytes value = 2;
 	enum ValType {
@@ -356,7 +358,6 @@ message Posting {
 	}
 	PostingType posting_type = 4;
 	bytes lang_tag = 5; // Only set for VALUE_LANG
-	string label = 6;
 	repeated api.Facet facets = 9;
 
 	// TODO: op is only used temporarily. See if we can remove it from here.
diff --git a/protos/pb/pb.pb.go b/protos/pb/pb.pb.go
index 82da80b4ed7..c4101f25e2d 100644
--- a/protos/pb/pb.pb.go
+++ b/protos/pb/pb.pb.go
@@ -1851,11 +1851,11 @@ type DirectedEdge struct {
 	Value        []byte          `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
 	ValueType    Posting_ValType `protobuf:"varint,4,opt,name=value_type,json=valueType,proto3,enum=pb.Posting_ValType" json:"value_type,omitempty"`
 	ValueId      uint64          `protobuf:"fixed64,5,opt,name=value_id,json=valueId,proto3" json:"value_id,omitempty"`
-	Label        string          `protobuf:"bytes,6,opt,name=label,proto3" json:"label,omitempty"`
 	Lang         string          `protobuf:"bytes,7,opt,name=lang,proto3" json:"lang,omitempty"`
 	Op           DirectedEdge_Op `protobuf:"varint,8,opt,name=op,proto3,enum=pb.DirectedEdge_Op" json:"op,omitempty"`
 	Facets       []*api.Facet    `protobuf:"bytes,9,rep,name=facets,proto3" json:"facets,omitempty"`
 	AllowedPreds []string        `protobuf:"bytes,10,rep,name=allowedPreds,proto3" json:"allowedPreds,omitempty"`
+	Namespace    uint64          `protobuf:"varint,11,opt,name=namespace,proto3" json:"namespace,omitempty"`
 }
 
 func (m *DirectedEdge) Reset()         { *m = DirectedEdge{} }
@@ -1926,13 +1926,6 @@ func (m *DirectedEdge) GetValueId() uint64 {
 	return 0
 }
 
-func (m *DirectedEdge) GetLabel() string {
-	if m != nil {
-		return m.Label
-	}
-	return ""
-}
-
 func (m *DirectedEdge) GetLang() string {
 	if m != nil {
 		return m.Lang
@@ -1961,6 +1954,13 @@ func (m *DirectedEdge) GetAllowedPreds() []string {
 	return nil
 }
 
+func (m *DirectedEdge) GetNamespace() uint64 {
+	if m != nil {
+		return m.Namespace
+	}
+	return 0
+}
+
 type Mutations struct {
 	GroupId   uint32           `protobuf:"varint,1,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
 	StartTs   uint64           `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
@@ -2597,7 +2597,6 @@ type Posting struct {
 	ValType     Posting_ValType     `protobuf:"varint,3,opt,name=val_type,json=valType,proto3,enum=pb.Posting_ValType" json:"val_type,omitempty"`
 	PostingType Posting_PostingType `protobuf:"varint,4,opt,name=posting_type,json=postingType,proto3,enum=pb.Posting_PostingType" json:"posting_type,omitempty"`
 	LangTag     []byte              `protobuf:"bytes,5,opt,name=lang_tag,json=langTag,proto3" json:"lang_tag,omitempty"`
-	Label       string              `protobuf:"bytes,6,opt,name=label,proto3" json:"label,omitempty"`
 	Facets      []*api.Facet        `protobuf:"bytes,9,rep,name=facets,proto3" json:"facets,omitempty"`
 	// TODO: op is only used temporarily. See if we can remove it from here.
 	Op       uint32 `protobuf:"varint,12,opt,name=op,proto3" json:"op,omitempty"`
@@ -2673,13 +2672,6 @@ func (m *Posting) GetLangTag() []byte {
 	return nil
 }
 
-func (m *Posting) GetLabel() string {
-	if m != nil {
-		return m.Label
-	}
-	return ""
-}
-
 func (m *Posting) GetFacets() []*api.Facet {
 	if m != nil {
 		return m.Facets
@@ -5149,322 +5141,322 @@ func init() {
 func init() { proto.RegisterFile("pb.proto", fileDescriptor_f80abaa17e25ccc8) }
 
 var fileDescriptor_f80abaa17e25ccc8 = []byte{
-	// 5037 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x7b, 0x4d, 0x6c, 0xdc, 0x58,
-	0x72, 0xb0, 0xc8, 0xfe, 0x23, 0xab, 0x7f, 0xdc, 0x7e, 0xf6, 0x7a, 0x7a, 0xdb, 0x33, 0x96, 0x86,
-	0x1e, 0xcf, 0x68, 0xed, 0xb1, 0x6c, 0xcb, 0xfb, 0xe1, 0xdb, 0xf1, 0x22, 0x40, 0x24, 0xab, 0xe5,
-	0xd1, 0x58, 0x96, 0xb4, 0xec, 0x96, 0x77, 0x77, 0x0e, 0x69, 0x50, 0xe4, 0x93, 0xc4, 0x15, 0x9b,
-	0xe4, 0x92, 0x6c, 0xad, 0x34, 0xb7, 0x20, 0x40, 0x36, 0x87, 0x1c, 0x02, 0xe4, 0x92, 0x53, 0x02,
-	0xe4, 0x90, 0x4b, 0x80, 0x00, 0x09, 0xb0, 0x40, 0x10, 0x20, 0xb7, 0x20, 0x08, 0x72, 0x08, 0xf6,
-	0x90, 0x43, 0x2e, 0x31, 0x82, 0x99, 0x9c, 0x7c, 0x4b, 0x02, 0x04, 0xc8, 0x2d, 0x78, 0x55, 0x8f,
-	0x7f, 0xad, 0x96, 0x3d, 0xb3, 0x41, 0x0e, 0x39, 0xf5, 0xab, 0xaa, 0xf7, 0x5b, 0xaf, 0x5e, 0xfd,
-	0xb2, 0x41, 0x0b, 0x0f, 0x56, 0xc2, 0x28, 0x48, 0x02, 0xa6, 0x86, 0x07, 0x7d, 0xdd, 0x0a, 0x5d,
-	0x02, 0xfb, 0x77, 0x8f, 0xdc, 0xe4, 0x78, 0x7a, 0xb0, 0x62, 0x07, 0x93, 0x07, 0xce, 0x51, 0x64,
-	0x85, 0xc7, 0xf7, 0xdd, 0xe0, 0xc1, 0x81, 0xe5, 0x1c, 0xf1, 0xe8, 0xc1, 0xe9, 0xe3, 0x07, 0xe1,
-	0xc1, 0x83, 0x74, 0x68, 0xff, 0x7e, 0xa1, 0xef, 0x51, 0x70, 0x14, 0x3c, 0x40, 0xf4, 0xc1, 0xf4,
-	0x10, 0x21, 0x04, 0xb0, 0x45, 0xdd, 0x8d, 0x3e, 0x54, 0xb7, 0xdd, 0x38, 0x61, 0x0c, 0xaa, 0x53,
-	0xd7, 0x89, 0x7b, 0xca, 0x52, 0x65, 0xb9, 0x6e, 0x62, 0xdb, 0x78, 0x01, 0xfa, 0xc8, 0x8a, 0x4f,
-	0x5e, 0x5a, 0xde, 0x94, 0xb3, 0x2e, 0x54, 0x4e, 0x2d, 0xaf, 0xa7, 0x2c, 0x29, 0xcb, 0x2d, 0x53,
-	0x34, 0xd9, 0x0a, 0x68, 0xa7, 0x96, 0x37, 0x4e, 0xce, 0x43, 0xde, 0x53, 0x97, 0x94, 0xe5, 0xce,
-	0xea, 0xb5, 0x95, 0xf0, 0x60, 0x65, 0x2f, 0x88, 0x13, 0xd7, 0x3f, 0x5a, 0x79, 0x69, 0x79, 0xa3,
-	0xf3, 0x90, 0x9b, 0x8d, 0x53, 0x6a, 0x18, 0xbb, 0xd0, 0x1c, 0x46, 0xf6, 0xe6, 0xd4, 0xb7, 0x13,
-	0x37, 0xf0, 0xc5, 0x8a, 0xbe, 0x35, 0xe1, 0x38, 0xa3, 0x6e, 0x62, 0x5b, 0xe0, 0xac, 0xe8, 0x28,
-	0xee, 0x55, 0x96, 0x2a, 0x02, 0x27, 0xda, 0xac, 0x07, 0x0d, 0x37, 0x7e, 0x1a, 0x4c, 0xfd, 0xa4,
-	0x57, 0x5d, 0x52, 0x96, 0x35, 0x33, 0x05, 0x8d, 0x3f, 0xaa, 0x40, 0xed, 0x07, 0x53, 0x1e, 0x9d,
-	0xe3, 0xb8, 0x24, 0x89, 0xd2, 0xb9, 0x44, 0x9b, 0x5d, 0x87, 0x9a, 0x67, 0xf9, 0x47, 0x71, 0x4f,
-	0xc5, 0xc9, 0x08, 0x60, 0x37, 0x41, 0xb7, 0x0e, 0x13, 0x1e, 0x8d, 0xa7, 0xae, 0xd3, 0xab, 0x2c,
-	0x29, 0xcb, 0x75, 0x53, 0x43, 0xc4, 0xbe, 0xeb, 0xb0, 0x6f, 0x83, 0xe6, 0x04, 0x63, 0xbb, 0xb8,
-	0x96, 0x13, 0xe0, 0x5a, 0xec, 0x36, 0x68, 0x53, 0xd7, 0x19, 0x7b, 0x6e, 0x9c, 0xf4, 0x6a, 0x4b,
-	0xca, 0x72, 0x73, 0x55, 0x13, 0x87, 0x15, 0xbc, 0x33, 0x1b, 0x53, 0xd7, 0x41, 0x26, 0xde, 0x05,
-	0x2d, 0x8e, 0xec, 0xf1, 0xe1, 0xd4, 0xb7, 0x7b, 0x75, 0xec, 0x74, 0x45, 0x74, 0x2a, 0x9c, 0xda,
-	0x6c, 0xc4, 0x04, 0x88, 0x63, 0x45, 0xfc, 0x94, 0x47, 0x31, 0xef, 0x35, 0x68, 0x29, 0x09, 0xb2,
-	0x87, 0xd0, 0x3c, 0xb4, 0x6c, 0x9e, 0x8c, 0x43, 0x2b, 0xb2, 0x26, 0x3d, 0x2d, 0x9f, 0x68, 0x53,
-	0xa0, 0xf7, 0x04, 0x36, 0x36, 0xe1, 0x30, 0x03, 0xd8, 0x63, 0x68, 0x23, 0x14, 0x8f, 0x0f, 0x5d,
-	0x2f, 0xe1, 0x51, 0x4f, 0xc7, 0x31, 0x1d, 0x1c, 0x83, 0x98, 0x51, 0xc4, 0xb9, 0xd9, 0xa2, 0x4e,
-	0x84, 0x61, 0xef, 0x01, 0xf0, 0xb3, 0xd0, 0xf2, 0x9d, 0xb1, 0xe5, 0x79, 0x3d, 0xc0, 0x3d, 0xe8,
-	0x84, 0x59, 0xf3, 0x3c, 0xf6, 0x8e, 0xd8, 0x9f, 0xe5, 0x8c, 0x93, 0xb8, 0xd7, 0x5e, 0x52, 0x96,
-	0xab, 0x66, 0x5d, 0x80, 0xa3, 0x58, 0xf0, 0xd5, 0xb6, 0xec, 0x63, 0xde, 0xeb, 0x2c, 0x29, 0xcb,
-	0x35, 0x93, 0x00, 0x81, 0x3d, 0x74, 0xa3, 0x38, 0xe9, 0x5d, 0x21, 0x2c, 0x02, 0xc6, 0x2a, 0xe8,
-	0x28, 0x3d, 0xc8, 0x9d, 0x3b, 0x50, 0x3f, 0x15, 0x00, 0x09, 0x59, 0x73, 0xb5, 0x2d, 0xb6, 0x97,
-	0x09, 0x98, 0x29, 0x89, 0xc6, 0x2d, 0xd0, 0xb6, 0x2d, 0xff, 0x28, 0x95, 0x4a, 0x71, 0x6d, 0x38,
-	0x40, 0x37, 0xb1, 0x6d, 0xfc, 0x81, 0x0a, 0x75, 0x93, 0xc7, 0x53, 0x2f, 0x61, 0x1f, 0x01, 0x88,
-	0x4b, 0x99, 0x58, 0x49, 0xe4, 0x9e, 0xc9, 0x59, 0xf3, 0x6b, 0xd1, 0xa7, 0xae, 0xf3, 0x02, 0x49,
-	0xec, 0x21, 0xb4, 0x70, 0xf6, 0xb4, 0xab, 0x9a, 0x6f, 0x20, 0xdb, 0x9f, 0xd9, 0xc4, 0x2e, 0x72,
-	0xc4, 0x0d, 0xa8, 0xa3, 0x1c, 0x90, 0x2c, 0xb6, 0x4d, 0x09, 0xb1, 0x3b, 0xd0, 0x71, 0xfd, 0x44,
-	0xdc, 0x93, 0x9d, 0x8c, 0x1d, 0x1e, 0xa7, 0x82, 0xd2, 0xce, 0xb0, 0x1b, 0x3c, 0x4e, 0xd8, 0x23,
-	0x20, 0x66, 0xa7, 0x0b, 0xd6, 0x70, 0xc1, 0x4e, 0x76, 0x89, 0x31, 0xad, 0x88, 0x7d, 0xe4, 0x8a,
-	0xf7, 0xa1, 0x29, 0xce, 0x97, 0x8e, 0xa8, 0xe3, 0x88, 0x16, 0x9e, 0x46, 0xb2, 0xc3, 0x04, 0xd1,
-	0x41, 0x76, 0x17, 0xac, 0x11, 0xc2, 0x48, 0xc2, 0x83, 0x6d, 0x63, 0x00, 0xb5, 0xdd, 0xc8, 0xe1,
-	0xd1, 0xdc, 0xf7, 0xc0, 0xa0, 0xea, 0xf0, 0xd8, 0xc6, 0xa7, 0xaa, 0x99, 0xd8, 0xce, 0xdf, 0x48,
-	0xa5, 0xf0, 0x46, 0x8c, 0x3f, 0x54, 0xa0, 0x39, 0x0c, 0xa2, 0xe4, 0x05, 0x8f, 0x63, 0xeb, 0x88,
-	0xb3, 0x45, 0xa8, 0x05, 0x62, 0x5a, 0xc9, 0x61, 0x5d, 0xec, 0x09, 0xd7, 0x31, 0x09, 0x3f, 0x73,
-	0x0f, 0xea, 0xe5, 0xf7, 0x20, 0x64, 0x07, 0x5f, 0x57, 0x45, 0xca, 0x0e, 0xbe, 0xad, 0x1b, 0x50,
-	0x0f, 0x0e, 0x0f, 0x63, 0x4e, 0xbc, 0xac, 0x99, 0x12, 0xba, 0x54, 0x04, 0x8d, 0xff, 0x07, 0x20,
-	0xf6, 0xf7, 0x0d, 0xa5, 0xc0, 0xf8, 0xb9, 0x02, 0x4d, 0xd3, 0x3a, 0x4c, 0x9e, 0x06, 0x7e, 0xc2,
-	0xcf, 0x12, 0xd6, 0x01, 0xd5, 0x75, 0x90, 0x47, 0x75, 0x53, 0x75, 0x1d, 0xb1, 0xbb, 0xa3, 0x28,
-	0x98, 0x86, 0xc8, 0xa2, 0xb6, 0x49, 0x00, 0xf2, 0xd2, 0x71, 0x22, 0xdc, 0xb2, 0xe0, 0xa5, 0xe3,
-	0x44, 0x6c, 0x11, 0x9a, 0xb1, 0x6f, 0x85, 0xf1, 0x71, 0x90, 0x88, 0xdd, 0x55, 0x71, 0x77, 0x90,
-	0xa2, 0x46, 0xb1, 0x78, 0x5c, 0x6e, 0x3c, 0xf6, 0xb8, 0x15, 0xf9, 0x3c, 0x42, 0x85, 0xa1, 0x99,
-	0xba, 0x1b, 0x6f, 0x13, 0xc2, 0xf8, 0x79, 0x05, 0xea, 0x2f, 0xf8, 0xe4, 0x80, 0x47, 0x17, 0x36,
-	0xf1, 0x10, 0x34, 0x5c, 0x77, 0xec, 0x3a, 0xb4, 0x8f, 0xf5, 0x6f, 0xbd, 0x7e, 0xb5, 0x78, 0x15,
-	0x71, 0x5b, 0xce, 0xc7, 0xc1, 0xc4, 0x4d, 0xf8, 0x24, 0x4c, 0xce, 0xcd, 0x86, 0x44, 0xcd, 0xdd,
-	0xe0, 0x0d, 0xa8, 0x7b, 0xdc, 0x12, 0x77, 0x46, 0xe2, 0x29, 0x21, 0x76, 0x1f, 0x1a, 0xd6, 0x64,
-	0xec, 0x70, 0xcb, 0xa1, 0x4d, 0xad, 0x5f, 0x7f, 0xfd, 0x6a, 0xb1, 0x6b, 0x4d, 0x36, 0xb8, 0x55,
-	0x9c, 0xbb, 0x4e, 0x18, 0xf6, 0x89, 0x90, 0xc9, 0x38, 0x19, 0x4f, 0x43, 0xc7, 0x4a, 0x38, 0xea,
-	0xb4, 0xea, 0x7a, 0xef, 0xf5, 0xab, 0xc5, 0xeb, 0x02, 0xbd, 0x8f, 0xd8, 0xc2, 0x30, 0xc8, 0xb1,
-	0x42, 0xbf, 0xa5, 0xc7, 0x97, 0xfa, 0x4d, 0x82, 0x6c, 0x0b, 0xae, 0xda, 0xde, 0x34, 0x16, 0x4a,
-	0xd8, 0xf5, 0x0f, 0x83, 0x71, 0xe0, 0x7b, 0xe7, 0x78, 0xc1, 0xda, 0xfa, 0x7b, 0xaf, 0x5f, 0x2d,
-	0x7e, 0x5b, 0x12, 0xb7, 0xfc, 0xc3, 0x60, 0xd7, 0xf7, 0xce, 0x0b, 0xf3, 0x5f, 0x99, 0x21, 0xb1,
-	0x5f, 0x87, 0xce, 0x61, 0x10, 0xd9, 0x7c, 0x9c, 0xb1, 0xac, 0x83, 0xf3, 0xf4, 0x5f, 0xbf, 0x5a,
-	0xbc, 0x81, 0x94, 0x67, 0x17, 0xf8, 0xd6, 0x2a, 0xe2, 0x8d, 0x7f, 0x56, 0xa1, 0x86, 0x6d, 0xf6,
-	0x10, 0x1a, 0x13, 0xbc, 0x92, 0x54, 0x3f, 0xdd, 0x10, 0x32, 0x84, 0xb4, 0x15, 0xba, 0xab, 0x78,
-	0xe0, 0x27, 0xd1, 0xb9, 0x99, 0x76, 0x13, 0x23, 0x12, 0xeb, 0xc0, 0xe3, 0x49, 0x2c, 0x65, 0xbe,
-	0x30, 0x62, 0x44, 0x04, 0x39, 0x42, 0x76, 0x9b, 0x95, 0x9b, 0xca, 0x05, 0xb9, 0xe9, 0x83, 0x66,
-	0x1f, 0x73, 0xfb, 0x24, 0x9e, 0x4e, 0xa4, 0x54, 0x65, 0x30, 0xbb, 0x0d, 0x6d, 0x6c, 0x87, 0x81,
-	0xeb, 0xe3, 0xf0, 0x1a, 0x76, 0x68, 0xe5, 0xc8, 0x51, 0xdc, 0xdf, 0x84, 0x56, 0x71, 0xb3, 0xc2,
-	0x6c, 0x9f, 0xf0, 0x73, 0x94, 0xaf, 0xaa, 0x29, 0x9a, 0x6c, 0x09, 0x6a, 0xa8, 0xe8, 0x50, 0xba,
-	0x9a, 0xab, 0x20, 0xf6, 0x4c, 0x43, 0x4c, 0x22, 0x3c, 0x51, 0xbf, 0xa7, 0x88, 0x79, 0x8a, 0x47,
-	0x28, 0xce, 0xa3, 0x5f, 0x3e, 0x0f, 0x0d, 0x29, 0xcc, 0x63, 0x04, 0xd0, 0xd8, 0x76, 0x6d, 0xee,
-	0xc7, 0x68, 0xdc, 0xa7, 0x31, 0xcf, 0x94, 0x92, 0x68, 0x8b, 0xf3, 0x4e, 0xac, 0xb3, 0x9d, 0xc0,
-	0xe1, 0x31, 0xce, 0x53, 0x35, 0x33, 0x58, 0xd0, 0xf8, 0x59, 0xe8, 0x46, 0xe7, 0x23, 0xe2, 0x54,
-	0xc5, 0xcc, 0x60, 0x21, 0x5d, 0xdc, 0x17, 0x8b, 0x39, 0xa9, 0xa1, 0x96, 0xa0, 0xf1, 0x8f, 0x15,
-	0x68, 0x7d, 0xce, 0xa3, 0x60, 0x2f, 0x0a, 0xc2, 0x20, 0xb6, 0x3c, 0xb6, 0x56, 0xe6, 0x39, 0xdd,
-	0xed, 0x92, 0xd8, 0x6d, 0xb1, 0xdb, 0xca, 0x30, 0xbb, 0x04, 0xba, 0xb3, 0xe2, 0xad, 0x18, 0x50,
-	0xa7, 0x3b, 0x9f, 0xc3, 0x33, 0x49, 0x11, 0x7d, 0xe8, 0x96, 0x71, 0xaf, 0x65, 0x7e, 0x48, 0x8a,
-	0x78, 0x95, 0x13, 0xeb, 0x6c, 0x7f, 0x6b, 0x43, 0xde, 0xad, 0x84, 0x24, 0x17, 0x46, 0x67, 0xfe,
-	0x28, 0xbd, 0xd4, 0x0c, 0x16, 0x27, 0x15, 0x1c, 0x89, 0xb7, 0x36, 0x7a, 0x2d, 0x24, 0xa5, 0x20,
-	0x7b, 0x17, 0xf4, 0x89, 0x75, 0x26, 0x14, 0xda, 0x96, 0x43, 0x4f, 0xd3, 0xcc, 0x11, 0xec, 0x7d,
-	0xa8, 0x24, 0x67, 0x3e, 0xbe, 0x3d, 0xe1, 0x3d, 0x08, 0x67, 0x72, 0x74, 0xe6, 0x4b, 0xd5, 0x67,
-	0x0a, 0x9a, 0xb8, 0x53, 0xdb, 0x75, 0xd0, 0x59, 0xd0, 0x4d, 0xd1, 0x64, 0x77, 0xa0, 0xe1, 0xd1,
-	0x6d, 0xa1, 0x43, 0xd0, 0x5c, 0x6d, 0x92, 0x1e, 0x45, 0x94, 0x99, 0xd2, 0xd8, 0xc7, 0xa0, 0xa5,
-	0xdc, 0xe9, 0x35, 0xb1, 0x5f, 0x37, 0xe5, 0x67, 0xca, 0x46, 0x33, 0xeb, 0xd1, 0xff, 0x35, 0xb8,
-	0x32, 0xc3, 0xdc, 0xa2, 0x34, 0xb5, 0x49, 0x9a, 0xae, 0x17, 0xa5, 0xa9, 0x5a, 0x90, 0xa0, 0xcf,
-	0xaa, 0x9a, 0xd6, 0xd5, 0x8d, 0x7f, 0xab, 0xc0, 0x15, 0x29, 0xd8, 0xc7, 0x6e, 0x38, 0x4c, 0xa4,
-	0x8a, 0x41, 0x03, 0x22, 0x65, 0xaa, 0x6a, 0xa6, 0x20, 0xfb, 0xff, 0x50, 0x47, 0x8d, 0x90, 0x3e,
-	0xcc, 0xc5, 0xfc, 0xc2, 0xb2, 0xe1, 0xf4, 0x50, 0xe5, 0x6d, 0xcb, 0xee, 0xec, 0xbb, 0x50, 0xfb,
-	0x82, 0x47, 0x01, 0x19, 0xc4, 0xe6, 0xea, 0xad, 0x79, 0xe3, 0xc4, 0x31, 0xe5, 0x30, 0xea, 0xfc,
-	0x3f, 0xbd, 0x57, 0xf8, 0x26, 0xf7, 0xfa, 0x81, 0x30, 0x8a, 0x93, 0xe0, 0x94, 0x3b, 0xbd, 0x06,
-	0xee, 0xb1, 0x28, 0x8c, 0x29, 0x29, 0xbd, 0x5a, 0x6d, 0xee, 0xd5, 0xea, 0x97, 0x5f, 0x6d, 0x7f,
-	0x03, 0x9a, 0x05, 0xbe, 0xcc, 0xb9, 0xa8, 0xc5, 0xf2, 0xb3, 0xd7, 0x33, 0x95, 0x57, 0xd4, 0x1e,
-	0x1b, 0x00, 0x39, 0x97, 0x7e, 0x55, 0x1d, 0x64, 0xfc, 0xa6, 0x02, 0x57, 0x9e, 0x06, 0xbe, 0xcf,
-	0xd1, 0x75, 0xa6, 0x3b, 0xcf, 0x9f, 0xa2, 0x72, 0xe9, 0x53, 0xfc, 0x0e, 0xd4, 0x62, 0xd1, 0x59,
-	0xce, 0x7e, 0x6d, 0xce, 0x25, 0x9a, 0xd4, 0x43, 0x28, 0xe4, 0x89, 0x75, 0x36, 0x0e, 0xb9, 0xef,
-	0xb8, 0xfe, 0x51, 0xaa, 0x90, 0x27, 0xd6, 0xd9, 0x1e, 0x61, 0x8c, 0xbf, 0x54, 0x01, 0x3e, 0xe5,
-	0x96, 0x97, 0x1c, 0x0b, 0xa3, 0x23, 0x6e, 0xd4, 0xf5, 0xe3, 0xc4, 0xf2, 0xed, 0x34, 0x70, 0xc9,
-	0x60, 0x71, 0xa3, 0xc2, 0xf6, 0xf2, 0x98, 0x54, 0x99, 0x6e, 0xa6, 0xa0, 0x90, 0x0f, 0xb1, 0xdc,
-	0x34, 0x96, 0x36, 0x5a, 0x42, 0xb9, 0xc3, 0x51, 0x45, 0xb4, 0x74, 0x38, 0x7a, 0xd0, 0x10, 0x81,
-	0x80, 0x1b, 0xf8, 0x28, 0x34, 0xba, 0x99, 0x82, 0x62, 0x9e, 0x69, 0x98, 0xb8, 0x13, 0xb2, 0xc4,
-	0x15, 0x53, 0x42, 0x62, 0x57, 0xc2, 0xf2, 0x0e, 0xec, 0xe3, 0x00, 0x1f, 0x7c, 0xc5, 0xcc, 0x60,
-	0x31, 0x5b, 0xe0, 0x1f, 0x05, 0xe2, 0x74, 0x1a, 0x3a, 0x79, 0x29, 0x48, 0x67, 0x71, 0xf8, 0x99,
-	0x20, 0xe9, 0x48, 0xca, 0x60, 0xc1, 0x17, 0xce, 0xc7, 0x87, 0xdc, 0x4a, 0xa6, 0x11, 0x8f, 0x7b,
-	0x80, 0x64, 0xe0, 0x7c, 0x53, 0x62, 0xd8, 0xfb, 0xd0, 0x12, 0x8c, 0xb3, 0xe2, 0xd8, 0x3d, 0xf2,
-	0xb9, 0x83, 0x6a, 0xa0, 0x6a, 0x0a, 0x66, 0xae, 0x49, 0x94, 0xf1, 0xd7, 0x2a, 0xd4, 0x49, 0x01,
-	0x96, 0x9c, 0x1a, 0xe5, 0x6b, 0x39, 0x35, 0xef, 0x82, 0x1e, 0x46, 0xdc, 0x71, 0xed, 0xf4, 0x1e,
-	0x75, 0x33, 0x47, 0x60, 0xb4, 0x21, 0xac, 0x38, 0xf2, 0x53, 0x33, 0x09, 0x60, 0x06, 0xb4, 0x03,
-	0x7f, 0xec, 0xb8, 0xf1, 0xc9, 0xf8, 0xe0, 0x3c, 0xe1, 0xb1, 0xe4, 0x45, 0x33, 0xf0, 0x37, 0xdc,
-	0xf8, 0x64, 0x5d, 0xa0, 0x04, 0x0b, 0xe9, 0x8d, 0xe0, 0xdb, 0xd0, 0x4c, 0x09, 0xb1, 0xc7, 0xa0,
-	0xa3, 0xaf, 0x89, 0xce, 0x88, 0x8e, 0x4e, 0xc4, 0x8d, 0xd7, 0xaf, 0x16, 0x99, 0x40, 0xce, 0x78,
-	0x21, 0x5a, 0x8a, 0x13, 0xde, 0x94, 0x18, 0x2c, 0xcc, 0x0a, 0xbe, 0x61, 0xf2, 0xa6, 0x04, 0x6a,
-	0x14, 0x17, 0xbd, 0x29, 0xc2, 0xb0, 0xfb, 0xc0, 0xa6, 0xbe, 0x1d, 0x4c, 0x42, 0x21, 0x14, 0xdc,
-	0x91, 0x9b, 0x6c, 0xe2, 0x26, 0xaf, 0x16, 0x29, 0xb8, 0x55, 0xe3, 0x1f, 0x54, 0x68, 0x6d, 0xb8,
-	0x11, 0xb7, 0x13, 0xee, 0x0c, 0x9c, 0x23, 0x2e, 0xf6, 0xce, 0xfd, 0xc4, 0x4d, 0xce, 0xa5, 0xbb,
-	0x28, 0xa1, 0xcc, 0xdb, 0x57, 0xcb, 0xd1, 0x2f, 0xbd, 0xb0, 0x0a, 0x06, 0xec, 0x04, 0xb0, 0x55,
-	0x00, 0x8a, 0x83, 0x30, 0x68, 0xaf, 0x5e, 0x1e, 0xb4, 0xeb, 0xd8, 0x4d, 0x34, 0x45, 0x50, 0x4c,
-	0x63, 0x5c, 0xf2, 0x19, 0xeb, 0x18, 0xd1, 0x4f, 0xf9, 0x96, 0x43, 0xe1, 0xc3, 0x01, 0xf7, 0x50,
-	0x1c, 0x31, 0x7c, 0x38, 0xe0, 0x5e, 0x16, 0xb4, 0x35, 0x68, 0x3b, 0xa2, 0xcd, 0x6e, 0x83, 0x1a,
-	0x84, 0xc8, 0x72, 0xb9, 0x60, 0xf1, 0x60, 0x2b, 0xbb, 0xa1, 0xa9, 0x06, 0xa1, 0x78, 0xdb, 0x14,
-	0xa1, 0xa2, 0x38, 0x8a, 0xb7, 0x2d, 0xac, 0x16, 0xc6, 0x4b, 0xa6, 0xa4, 0x30, 0x03, 0x5a, 0x96,
-	0xe7, 0x05, 0x3f, 0xe3, 0xce, 0x5e, 0xc4, 0x9d, 0x54, 0x32, 0x4b, 0x38, 0xe3, 0x06, 0xa8, 0xbb,
-	0x21, 0x6b, 0x40, 0x65, 0x38, 0x18, 0x75, 0x17, 0x44, 0x63, 0x63, 0xb0, 0xdd, 0x55, 0x8c, 0x2f,
-	0x55, 0xd0, 0x5f, 0x4c, 0x13, 0x4b, 0x68, 0x93, 0x58, 0x9c, 0xab, 0x2c, 0x93, 0xb9, 0xf0, 0x7d,
-	0x1b, 0xb4, 0x38, 0xb1, 0x22, 0xf4, 0x17, 0xc8, 0x1e, 0x35, 0x10, 0x1e, 0xc5, 0xec, 0x43, 0xa8,
-	0x71, 0xe7, 0x88, 0xa7, 0x06, 0xa2, 0x3b, 0x7b, 0x16, 0x93, 0xc8, 0x6c, 0x19, 0xea, 0xb1, 0x7d,
-	0xcc, 0x27, 0x56, 0xaf, 0x9a, 0x77, 0x1c, 0x22, 0x86, 0x1c, 0x64, 0x53, 0xd2, 0xd9, 0x07, 0x50,
-	0x13, 0xb7, 0x11, 0xcb, 0x88, 0x0f, 0x63, 0x44, 0xc1, 0x78, 0xd9, 0x8d, 0x88, 0x42, 0xd4, 0x9c,
-	0x28, 0x08, 0xc7, 0x41, 0x88, 0x7c, 0xed, 0xac, 0x5e, 0x47, 0xad, 0x96, 0x9e, 0x66, 0x65, 0x23,
-	0x0a, 0xc2, 0xdd, 0xd0, 0xac, 0x3b, 0xf8, 0x2b, 0xe2, 0x0f, 0xec, 0x4e, 0x32, 0x40, 0x66, 0x40,
-	0x17, 0x18, 0x4a, 0xe6, 0x2c, 0x83, 0x36, 0xe1, 0x89, 0xe5, 0x58, 0x89, 0x25, 0xad, 0x41, 0x8b,
-	0x94, 0x24, 0xe1, 0xcc, 0x8c, 0x6a, 0x3c, 0x80, 0x3a, 0x4d, 0xcd, 0x34, 0xa8, 0xee, 0xec, 0xee,
-	0x0c, 0x88, 0xa1, 0x6b, 0xdb, 0xdb, 0x5d, 0x45, 0xa0, 0x36, 0xd6, 0x46, 0x6b, 0x5d, 0x55, 0xb4,
-	0x46, 0x3f, 0xde, 0x1b, 0x74, 0x2b, 0xc6, 0xdf, 0x2b, 0xa0, 0xa5, 0xf3, 0xb0, 0x27, 0x00, 0xe2,
-	0xd1, 0x8e, 0x8f, 0x5d, 0x3f, 0x73, 0xbd, 0x6e, 0x16, 0x57, 0x5a, 0x11, 0x37, 0xf6, 0xa9, 0xa0,
-	0x92, 0x41, 0xc5, 0x37, 0x8e, 0x70, 0x7f, 0x08, 0x9d, 0x32, 0x71, 0x8e, 0x0f, 0x7a, 0xaf, 0x68,
-	0x47, 0x3a, 0xab, 0xdf, 0x2a, 0x4d, 0x2d, 0x46, 0xa2, 0x30, 0x17, 0x4c, 0xca, 0x7d, 0xd0, 0x52,
-	0x34, 0x6b, 0x42, 0x63, 0x63, 0xb0, 0xb9, 0xb6, 0xbf, 0x2d, 0x84, 0x04, 0xa0, 0x3e, 0xdc, 0xda,
-	0x79, 0xb6, 0x3d, 0xa0, 0x63, 0x6d, 0x6f, 0x0d, 0x47, 0x5d, 0xd5, 0xf8, 0x7d, 0x05, 0xb4, 0xd4,
-	0x77, 0x61, 0xdf, 0x11, 0xee, 0x06, 0xba, 0x4f, 0xd2, 0xf6, 0x60, 0x4e, 0xa6, 0x10, 0x50, 0x9a,
-	0x29, 0x5d, 0x3c, 0x0c, 0x54, 0xa5, 0xa9, 0x37, 0x83, 0x40, 0x31, 0x9e, 0xad, 0x94, 0x52, 0x2a,
-	0x22, 0x34, 0x0f, 0x7c, 0x2e, 0x5d, 0x59, 0x6c, 0xa3, 0x0c, 0xba, 0xbe, 0xcd, 0x73, 0x47, 0xbf,
-	0x81, 0xf0, 0x28, 0x36, 0x12, 0xf2, 0x70, 0xb3, 0x8d, 0x65, 0xab, 0x29, 0xc5, 0xd5, 0x2e, 0x84,
-	0x0b, 0xea, 0xc5, 0x70, 0x21, 0x37, 0x95, 0xb5, 0xb7, 0x99, 0x4a, 0xe3, 0xcf, 0xab, 0xd0, 0x31,
-	0x79, 0x9c, 0x04, 0x11, 0x37, 0xf9, 0x4f, 0xa7, 0x3c, 0x4e, 0xde, 0xf4, 0x84, 0xde, 0x03, 0x88,
-	0xa8, 0x73, 0xbe, 0xb4, 0x2e, 0x31, 0x14, 0xe7, 0x78, 0x81, 0x8d, 0xb2, 0x2b, 0x6d, 0x62, 0x06,
-	0xb3, 0x9b, 0xa0, 0x1f, 0x58, 0xf6, 0x09, 0x4d, 0x4b, 0x96, 0x51, 0x23, 0x04, 0xcd, 0x6b, 0xd9,
-	0x36, 0x8f, 0xe3, 0xb1, 0x10, 0x05, 0xb2, 0x8f, 0x3a, 0x61, 0x9e, 0xf3, 0x73, 0x41, 0x8e, 0xb9,
-	0x1d, 0xf1, 0x04, 0xc9, 0xa4, 0x96, 0x74, 0xc2, 0x08, 0xf2, 0x6d, 0x68, 0xc7, 0x3c, 0x16, 0xb6,
-	0x74, 0x9c, 0x04, 0x27, 0xdc, 0x97, 0x3a, 0xaa, 0x25, 0x91, 0x23, 0x81, 0x13, 0xa6, 0xc7, 0xf2,
-	0x03, 0xff, 0x7c, 0x12, 0x4c, 0x63, 0x69, 0x25, 0x72, 0x04, 0x5b, 0x81, 0x6b, 0xdc, 0xb7, 0xa3,
-	0xf3, 0x50, 0xec, 0x55, 0xac, 0x32, 0x3e, 0x74, 0x3d, 0x2e, 0x9d, 0xe8, 0xab, 0x39, 0xe9, 0x39,
-	0x3f, 0xdf, 0x74, 0x3d, 0x2e, 0x76, 0x74, 0x6a, 0x4d, 0xbd, 0x64, 0x8c, 0x31, 0x3a, 0xd0, 0x8e,
-	0x10, 0xb3, 0x26, 0x02, 0xf5, 0xbb, 0x70, 0x95, 0xc8, 0x51, 0xe0, 0x71, 0xd7, 0xa1, 0xc9, 0x9a,
-	0xd8, 0xeb, 0x0a, 0x12, 0x4c, 0xc4, 0xe3, 0x54, 0x2b, 0x70, 0x8d, 0xfa, 0xd2, 0x81, 0xd2, 0xde,
-	0x2d, 0x5a, 0x1a, 0x49, 0x43, 0x49, 0x29, 0x2f, 0x1d, 0x5a, 0xc9, 0x31, 0x46, 0xd8, 0xe9, 0xd2,
-	0x7b, 0x56, 0x72, 0x2c, 0x6c, 0x3c, 0x91, 0x0f, 0x5d, 0xee, 0x51, 0xe4, 0xac, 0x9b, 0x34, 0x62,
-	0x53, 0x60, 0x84, 0x8d, 0x97, 0x1d, 0x82, 0x68, 0x62, 0x51, 0x6a, 0x4f, 0x37, 0x69, 0xd0, 0x26,
-	0xa2, 0xc4, 0x12, 0xf2, 0xae, 0xfc, 0xe9, 0xa4, 0xd7, 0xa5, 0x6b, 0x26, 0xcc, 0xce, 0x74, 0x62,
-	0xfc, 0xbb, 0x0a, 0x5a, 0x16, 0x88, 0xdd, 0x03, 0x7d, 0x92, 0xea, 0x2b, 0xe9, 0x9a, 0xb5, 0x4b,
-	0x4a, 0xcc, 0xcc, 0xe9, 0xec, 0x3d, 0x50, 0x4f, 0x4e, 0xa5, 0xee, 0x6c, 0xaf, 0x50, 0xaa, 0x3b,
-	0x3c, 0x78, 0xbc, 0xf2, 0xfc, 0xa5, 0xa9, 0x9e, 0x9c, 0x7e, 0x03, 0xb9, 0x65, 0x1f, 0xc1, 0x15,
-	0xdb, 0xe3, 0x96, 0x3f, 0xce, 0xfd, 0x09, 0x92, 0x8b, 0x0e, 0xa2, 0xf7, 0x32, 0xa7, 0xe2, 0x0e,
-	0xd4, 0x1c, 0xee, 0x25, 0x56, 0x31, 0xe3, 0xba, 0x1b, 0x59, 0xb6, 0xc7, 0x37, 0x04, 0xda, 0x24,
-	0xaa, 0xd0, 0x9d, 0x59, 0xf0, 0x53, 0xd0, 0x9d, 0x17, 0x03, 0x9f, 0xfc, 0x5d, 0x42, 0xf1, 0x5d,
-	0xde, 0x83, 0xab, 0xfc, 0x2c, 0x44, 0x83, 0x31, 0xce, 0x62, 0x7d, 0x72, 0x9f, 0xba, 0x29, 0xe1,
-	0x69, 0x1a, 0xf3, 0x7f, 0x2c, 0x54, 0x06, 0x3e, 0x1a, 0xbc, 0xe6, 0xe6, 0x2a, 0x43, 0x9d, 0x53,
-	0x7a, 0x86, 0x66, 0xda, 0xe5, 0xb3, 0xaa, 0xd6, 0xe8, 0x6a, 0x86, 0x0d, 0x95, 0xe7, 0x2f, 0x87,
-	0xa8, 0x54, 0x84, 0x7e, 0xaf, 0xa1, 0x03, 0x80, 0xed, 0x4c, 0xd1, 0xa8, 0x05, 0x45, 0x73, 0x8b,
-	0x74, 0x34, 0xf2, 0x20, 0x4d, 0x04, 0x16, 0x30, 0xe2, 0x14, 0x64, 0x9f, 0xaa, 0x94, 0x23, 0x44,
-	0xc0, 0xf8, 0xcf, 0x0a, 0x34, 0xa4, 0xd3, 0x20, 0xf4, 0xf2, 0x34, 0xcb, 0x61, 0x89, 0x66, 0x39,
-	0x9a, 0xcb, 0xbc, 0x8f, 0x62, 0xc1, 0xa0, 0xf2, 0xf6, 0x82, 0x01, 0x7b, 0x02, 0xad, 0x90, 0x68,
-	0x45, 0x7f, 0xe5, 0x9d, 0xe2, 0x18, 0xf9, 0x8b, 0xe3, 0x9a, 0x61, 0x0e, 0x08, 0xd5, 0x84, 0xd9,
-	0xd4, 0xc4, 0x3a, 0x92, 0x1c, 0x68, 0x08, 0x78, 0x64, 0x1d, 0x5d, 0xe2, 0xb5, 0x7c, 0x1d, 0xe7,
-	0xa3, 0x83, 0x5e, 0x4c, 0x0b, 0x35, 0x9d, 0x70, 0x58, 0x8a, 0x7e, 0x42, 0xbb, 0xec, 0x27, 0xdc,
-	0x04, 0xdd, 0x0e, 0x26, 0x13, 0x17, 0x69, 0x1d, 0x99, 0xc9, 0x41, 0xc4, 0x28, 0x36, 0x7e, 0x5b,
-	0x81, 0x86, 0x3c, 0xed, 0x05, 0x2b, 0xb4, 0xbe, 0xb5, 0xb3, 0x66, 0xfe, 0xb8, 0xab, 0x08, 0x2b,
-	0xbb, 0xb5, 0x33, 0xea, 0xaa, 0x4c, 0x87, 0xda, 0xe6, 0xf6, 0xee, 0xda, 0xa8, 0x5b, 0x11, 0x96,
-	0x69, 0x7d, 0x77, 0x77, 0xbb, 0x5b, 0x65, 0x2d, 0xd0, 0x36, 0xd6, 0x46, 0x83, 0xd1, 0xd6, 0x8b,
-	0x41, 0xb7, 0x26, 0xfa, 0x3e, 0x1b, 0xec, 0x76, 0xeb, 0xa2, 0xb1, 0xbf, 0xb5, 0xd1, 0x6d, 0x08,
-	0xfa, 0xde, 0xda, 0x70, 0xf8, 0xc3, 0x5d, 0x73, 0xa3, 0xab, 0xa1, 0x75, 0x1b, 0x99, 0x5b, 0x3b,
-	0xcf, 0xba, 0xba, 0x68, 0xef, 0xae, 0x7f, 0x36, 0x78, 0x3a, 0xea, 0x82, 0xf1, 0x08, 0x9a, 0x05,
-	0x0e, 0x8a, 0xd1, 0xe6, 0x60, 0xb3, 0xbb, 0x20, 0x96, 0x7c, 0xb9, 0xb6, 0xbd, 0x2f, 0x8c, 0x61,
-	0x07, 0x00, 0x9b, 0xe3, 0xed, 0xb5, 0x9d, 0x67, 0x5d, 0xd5, 0xf8, 0x01, 0x68, 0xfb, 0xae, 0xb3,
-	0xee, 0x05, 0xf6, 0x89, 0x10, 0xa7, 0x03, 0x2b, 0xe6, 0xd2, 0xee, 0x60, 0x5b, 0x38, 0xa9, 0xf8,
-	0x4e, 0x62, 0x79, 0xf7, 0x12, 0x12, 0xbc, 0xf2, 0xa7, 0x93, 0x31, 0x16, 0x99, 0x2a, 0x64, 0x2b,
-	0xfc, 0xe9, 0x64, 0xdf, 0x75, 0x62, 0xe3, 0x04, 0x1a, 0xfb, 0xae, 0xb3, 0x67, 0xd9, 0x27, 0xa8,
-	0x4f, 0xc4, 0xd4, 0xe3, 0xd8, 0xfd, 0x82, 0x4b, 0x9b, 0xa2, 0x23, 0x66, 0xe8, 0x7e, 0xc1, 0xd9,
-	0x07, 0x50, 0x47, 0x20, 0x8d, 0xeb, 0xf1, 0xe5, 0xa5, 0xdb, 0x31, 0x25, 0x0d, 0x6b, 0x3c, 0x9e,
-	0x17, 0xd8, 0xe3, 0x88, 0x1f, 0xf6, 0xde, 0x21, 0xde, 0x23, 0xc2, 0xe4, 0x87, 0xc6, 0xef, 0x2a,
-	0xd9, 0x99, 0xb1, 0xc4, 0xb0, 0x08, 0xd5, 0xd0, 0xb2, 0x4f, 0xa4, 0x49, 0x6f, 0xca, 0x09, 0xc5,
-	0x66, 0x4c, 0x24, 0xb0, 0x8f, 0x40, 0x93, 0x82, 0x95, 0xae, 0xda, 0x2c, 0x48, 0xa0, 0x99, 0x11,
-	0xcb, 0x57, 0x5e, 0x29, 0x5f, 0x39, 0x86, 0x80, 0xa1, 0xe7, 0x26, 0xf4, 0x8c, 0xaa, 0xa6, 0x84,
-	0x8c, 0xef, 0x02, 0xe4, 0x55, 0x9d, 0x39, 0x1e, 0xce, 0x75, 0xa8, 0x59, 0x9e, 0x6b, 0xa5, 0x21,
-	0x25, 0x01, 0xc6, 0x0e, 0x34, 0x0b, 0xb5, 0x20, 0xc1, 0x5b, 0xcb, 0xf3, 0x84, 0x31, 0x8a, 0x71,
-	0xac, 0x66, 0x36, 0x2c, 0xcf, 0x7b, 0xce, 0xcf, 0x63, 0xe1, 0x5d, 0x52, 0x19, 0x49, 0x9d, 0xa9,
-	0x40, 0xe0, 0x50, 0x93, 0x88, 0xc6, 0xc7, 0x50, 0xdf, 0x4c, 0xfd, 0xeb, 0xf4, 0x19, 0x28, 0x97,
-	0x3d, 0x03, 0xe3, 0x13, 0xb9, 0x67, 0x2c, 0x62, 0xb0, 0x7b, 0xb2, 0x5c, 0x15, 0x53, 0x71, 0x4c,
-	0xc9, 0x93, 0x12, 0xd4, 0x49, 0x56, 0xaa, 0xb0, 0xb3, 0xb1, 0x01, 0xda, 0x1b, 0x0b, 0x80, 0x92,
-	0x01, 0x6a, 0xce, 0x80, 0x39, 0x25, 0x41, 0xe3, 0x27, 0x00, 0x79, 0x59, 0x4b, 0xbe, 0x4a, 0x9a,
-	0x45, 0xbc, 0xca, 0xbb, 0xa0, 0xd9, 0xc7, 0xae, 0xe7, 0x44, 0xdc, 0x2f, 0x9d, 0x3a, 0x2f, 0x84,
-	0x65, 0x74, 0xb6, 0x04, 0x55, 0xac, 0xd6, 0x55, 0x72, 0x45, 0x9e, 0x95, 0xea, 0x90, 0x62, 0x9c,
-	0x41, 0x9b, 0xdc, 0xf6, 0xaf, 0xe1, 0xf4, 0x94, 0x55, 0xa9, 0x7a, 0x41, 0x95, 0xde, 0x80, 0x3a,
-	0xda, 0xda, 0xf4, 0x34, 0x12, 0xba, 0x44, 0xc5, 0xfe, 0x96, 0x0a, 0x40, 0x4b, 0xef, 0x04, 0x0e,
-	0x2f, 0x47, 0xc4, 0xca, 0x6c, 0x44, 0xcc, 0xa0, 0x9a, 0x15, 0x62, 0x75, 0x13, 0xdb, 0xb9, 0xfd,
-	0x91, 0x51, 0x32, 0xd9, 0x9f, 0x77, 0x41, 0x47, 0xdf, 0xc7, 0xfd, 0x02, 0xab, 0x03, 0x62, 0xc1,
-	0x1c, 0x51, 0x2c, 0x4b, 0xd6, 0xca, 0x65, 0xc9, 0xac, 0x76, 0x53, 0xa7, 0xd9, 0xa8, 0x76, 0x33,
-	0xa7, 0x0c, 0x45, 0x69, 0x8a, 0x98, 0x47, 0x49, 0x1a, 0x63, 0x13, 0x94, 0x05, 0x86, 0xba, 0xec,
-	0x6b, 0x51, 0xa2, 0xc1, 0x0f, 0xc6, 0x76, 0xe0, 0x1f, 0x7a, 0xae, 0x9d, 0xc8, 0x32, 0x24, 0xf8,
-	0xc1, 0x53, 0x89, 0x31, 0x9e, 0x40, 0x2b, 0xe5, 0x3f, 0x56, 0x7b, 0xee, 0x66, 0x81, 0x95, 0x92,
-	0xdf, 0x6d, 0xce, 0xa6, 0x75, 0xb5, 0xa7, 0xa4, 0xa1, 0x95, 0xf1, 0x1f, 0x95, 0x74, 0xb0, 0x2c,
-	0x4a, 0xbc, 0x99, 0x87, 0xe5, 0xe8, 0x58, 0xfd, 0x5a, 0xd1, 0xf1, 0xf7, 0x40, 0x77, 0x30, 0xfc,
-	0x73, 0x4f, 0x53, 0xa3, 0xd6, 0x9f, 0x0d, 0xf5, 0x64, 0x80, 0xe8, 0x9e, 0x72, 0x33, 0xef, 0xfc,
-	0x96, 0x7b, 0xc8, 0xb8, 0x5d, 0x9b, 0xc7, 0xed, 0xfa, 0xaf, 0xc8, 0xed, 0xf7, 0xa1, 0xe5, 0x07,
-	0xfe, 0xd8, 0x9f, 0x7a, 0x9e, 0x75, 0xe0, 0x71, 0xc9, 0xee, 0xa6, 0x1f, 0xf8, 0x3b, 0x12, 0x25,
-	0x1c, 0xd2, 0x62, 0x17, 0x7a, 0xd4, 0x4d, 0xec, 0x77, 0xa5, 0xd0, 0x0f, 0x9f, 0xfe, 0x32, 0x74,
-	0x83, 0x83, 0x9f, 0x70, 0x3b, 0x41, 0x8e, 0x8d, 0xf1, 0x35, 0x93, 0x37, 0xda, 0x21, 0xbc, 0x60,
-	0xd1, 0x8e, 0x78, 0xd7, 0x33, 0xd7, 0xdc, 0xbe, 0x70, 0xcd, 0x9f, 0x80, 0x9e, 0x71, 0xa9, 0x10,
-	0x6a, 0xea, 0x50, 0xdb, 0xda, 0xd9, 0x18, 0xfc, 0xa8, 0xab, 0x08, 0x43, 0x69, 0x0e, 0x5e, 0x0e,
-	0xcc, 0xe1, 0xa0, 0xab, 0x0a, 0x23, 0xb6, 0x31, 0xd8, 0x1e, 0x8c, 0x06, 0xdd, 0x0a, 0x79, 0x3d,
-	0x58, 0x1b, 0xf0, 0x5c, 0xdb, 0x4d, 0x8c, 0x21, 0x40, 0x1e, 0x3f, 0x0b, 0xad, 0x9c, 0x6f, 0x4e,
-	0xa6, 0xec, 0x92, 0x74, 0x5b, 0xcb, 0xd9, 0x83, 0x54, 0x2f, 0x8b, 0xd2, 0x89, 0x6e, 0xac, 0x82,
-	0xfe, 0xc2, 0x0a, 0x3f, 0xa5, 0x2a, 0xda, 0x1d, 0xe8, 0x84, 0x56, 0x94, 0xb8, 0x69, 0x08, 0x40,
-	0xca, 0xb2, 0x65, 0xb6, 0x33, 0xac, 0xd0, 0xbd, 0xc6, 0x5f, 0x28, 0x70, 0xfd, 0x45, 0x70, 0xca,
-	0x33, 0x17, 0x73, 0xcf, 0x3a, 0xf7, 0x02, 0xcb, 0x79, 0x8b, 0x18, 0x8a, 0x18, 0x26, 0x98, 0x62,
-	0x55, 0x2b, 0xad, 0x01, 0x9a, 0x3a, 0x61, 0x9e, 0xc9, 0x8f, 0x14, 0x78, 0x9c, 0x20, 0x51, 0x1a,
-	0x52, 0x01, 0x0b, 0xd2, 0xb7, 0xa0, 0x9e, 0x9c, 0xf9, 0x79, 0x45, 0xb2, 0x96, 0x60, 0xaa, 0x79,
-	0xae, 0xc7, 0x59, 0x9b, 0xef, 0x71, 0x1a, 0x4f, 0x41, 0x1f, 0x9d, 0x61, 0xb2, 0x75, 0x1a, 0x97,
-	0x1c, 0x1c, 0xe5, 0x0d, 0x0e, 0x8e, 0x3a, 0xe3, 0xe0, 0xfc, 0xab, 0x02, 0xcd, 0x82, 0xeb, 0xcc,
-	0xde, 0x87, 0x6a, 0x72, 0xe6, 0x97, 0x0b, 0xff, 0xe9, 0x22, 0x26, 0x92, 0x2e, 0x24, 0x14, 0xd5,
-	0x0b, 0x09, 0x45, 0xb6, 0x0d, 0x57, 0x48, 0xf3, 0xa6, 0x87, 0x48, 0xb3, 0x30, 0xb7, 0x67, 0x5c,
-	0x75, 0x4a, 0x48, 0xa7, 0x47, 0x92, 0xa9, 0x85, 0xce, 0x51, 0x09, 0xd9, 0x5f, 0x83, 0x6b, 0x73,
-	0xba, 0x7d, 0x93, 0xd2, 0x84, 0xb1, 0x08, 0xed, 0xd1, 0x99, 0x3f, 0x72, 0x27, 0x3c, 0x4e, 0xac,
-	0x49, 0x88, 0x0e, 0xa2, 0xb4, 0x9c, 0x55, 0x53, 0x4d, 0x62, 0xe3, 0x43, 0x68, 0xed, 0x71, 0x1e,
-	0x99, 0x3c, 0x0e, 0x03, 0x9f, 0x9c, 0x23, 0x99, 0x08, 0x26, 0x33, 0x2d, 0x21, 0xe3, 0x37, 0x40,
-	0x37, 0xad, 0xc3, 0x64, 0xdd, 0x4a, 0xec, 0xe3, 0x6f, 0x92, 0x67, 0xf8, 0x10, 0x1a, 0x21, 0xc9,
-	0x94, 0x0c, 0xa8, 0x5a, 0x68, 0xae, 0xa5, 0x9c, 0x99, 0x29, 0xd1, 0x78, 0x04, 0xd7, 0x86, 0xd3,
-	0x83, 0xd8, 0x8e, 0x5c, 0x8c, 0x4d, 0x53, 0x53, 0xd6, 0x07, 0x2d, 0x8c, 0xf8, 0xa1, 0x7b, 0xc6,
-	0x53, 0x09, 0xce, 0x60, 0xe3, 0xfb, 0x70, 0xbd, 0x3c, 0x44, 0x1e, 0xe1, 0x36, 0x54, 0x4e, 0x4e,
-	0x63, 0xb9, 0xb3, 0xab, 0xa5, 0xc8, 0x0c, 0xeb, 0xed, 0x82, 0x6a, 0xfc, 0x89, 0x02, 0x95, 0x9d,
-	0xe9, 0xa4, 0xf8, 0xd1, 0x50, 0x95, 0x3e, 0x1a, 0xba, 0x59, 0xcc, 0xb3, 0x52, 0x18, 0x92, 0xe7,
-	0x53, 0xdf, 0x05, 0xfd, 0x30, 0x88, 0x7e, 0x66, 0x45, 0x0e, 0x77, 0xa4, 0xd1, 0xca, 0x11, 0xec,
-	0x8e, 0x34, 0x71, 0x14, 0x06, 0x5c, 0x15, 0x4c, 0xd9, 0x99, 0x4e, 0x56, 0x3c, 0x6e, 0xc5, 0xa8,
-	0x8b, 0xc9, 0xea, 0x19, 0xf7, 0x40, 0xcf, 0x50, 0x42, 0x7f, 0xec, 0x0c, 0xc7, 0x5b, 0x1b, 0x94,
-	0xb5, 0x12, 0xae, 0xb1, 0x22, 0x74, 0xc7, 0xe8, 0x47, 0x3b, 0xe3, 0xd1, 0xb0, 0xab, 0x1a, 0x9f,
-	0x43, 0x33, 0x15, 0xaf, 0x2d, 0x07, 0x8b, 0x32, 0x28, 0xdf, 0x5b, 0x4e, 0x49, 0xdc, 0x29, 0xd5,
-	0xc9, 0x7d, 0x67, 0x2b, 0x95, 0x4b, 0x02, 0xca, 0xa7, 0x91, 0x15, 0x9e, 0xf4, 0x34, 0xc6, 0x26,
-	0xb4, 0xd2, 0xa0, 0xf0, 0x05, 0x4f, 0x2c, 0x7c, 0x31, 0x9e, 0xcb, 0xfd, 0xc2, 0x6b, 0xd2, 0x08,
-	0x31, 0x2a, 0x67, 0x23, 0xd5, 0x92, 0x57, 0x61, 0xac, 0x40, 0x5d, 0x3e, 0x47, 0x06, 0x55, 0x3b,
-	0x70, 0x48, 0x65, 0xd4, 0x4c, 0x6c, 0x0b, 0x16, 0x4f, 0xe2, 0xa3, 0xd4, 0x63, 0x9a, 0xc4, 0x47,
-	0xc6, 0x5f, 0xa9, 0xd0, 0x5e, 0xc7, 0x10, 0x3c, 0xbd, 0xe7, 0x42, 0xe2, 0x49, 0x29, 0x25, 0x9e,
-	0x8a, 0x49, 0x26, 0xb5, 0x94, 0x64, 0x2a, 0x6d, 0xa8, 0x52, 0x76, 0x73, 0xde, 0x81, 0xc6, 0xd4,
-	0x77, 0xcf, 0x52, 0x3d, 0xa3, 0x9b, 0x75, 0x01, 0x8e, 0x62, 0xb6, 0x04, 0x4d, 0xa1, 0x8a, 0x5c,
-	0x9f, 0x12, 0x3b, 0x94, 0x9d, 0x29, 0xa2, 0x66, 0xd2, 0x37, 0xf5, 0x37, 0xa7, 0x6f, 0x1a, 0x6f,
-	0x4d, 0xdf, 0x68, 0x6f, 0x4b, 0xdf, 0xe8, 0xb3, 0xe9, 0x9b, 0xb2, 0x8b, 0x06, 0xb3, 0x2e, 0x9a,
-	0xb1, 0x0d, 0x9d, 0x94, 0x77, 0x52, 0xe0, 0x9f, 0xc0, 0x15, 0x99, 0x79, 0xe5, 0x91, 0x4c, 0x5e,
-	0x90, 0x1a, 0x43, 0x09, 0xa4, 0xe4, 0xa8, 0xa4, 0x98, 0x1d, 0xa7, 0x08, 0xc6, 0xc6, 0xef, 0x28,
-	0xd0, 0x2e, 0xf5, 0x60, 0x8f, 0xf2, 0x3c, 0xae, 0x82, 0x72, 0xdc, 0xbb, 0x30, 0xcb, 0x9b, 0x73,
-	0xb9, 0xea, 0x4c, 0x2e, 0xd7, 0xb8, 0x93, 0x65, 0x68, 0x65, 0x5e, 0x76, 0x21, 0xcb, 0xcb, 0x62,
-	0x2a, 0x73, 0x6d, 0x34, 0x32, 0xbb, 0xaa, 0xf1, 0x0b, 0x15, 0xda, 0x83, 0xb3, 0x10, 0x3f, 0x9b,
-	0x79, 0xab, 0x23, 0x5b, 0x10, 0x18, 0xb5, 0x24, 0x30, 0x85, 0xab, 0xaf, 0xc8, 0x12, 0x14, 0x5d,
-	0xbd, 0x70, 0x6d, 0x29, 0x4b, 0x24, 0x45, 0x82, 0xa0, 0xff, 0x0b, 0x22, 0xf1, 0x2e, 0xe8, 0xc2,
-	0x39, 0x88, 0x43, 0xcb, 0xe6, 0x32, 0x55, 0x93, 0x23, 0x84, 0x40, 0xa4, 0x6c, 0x93, 0x02, 0xf1,
-	0xb5, 0x5e, 0x21, 0x7d, 0x10, 0xe7, 0x65, 0x19, 0x15, 0x02, 0x8c, 0x3f, 0x55, 0x41, 0x27, 0xf9,
-	0x12, 0x9b, 0xff, 0x8e, 0xd4, 0x68, 0x4a, 0x9e, 0xbd, 0xce, 0x88, 0x2b, 0xcf, 0xf9, 0x79, 0xae,
-	0xd5, 0xe6, 0xd6, 0x78, 0x64, 0xde, 0x85, 0x42, 0x4d, 0xcc, 0xbb, 0xdc, 0x04, 0x9d, 0xec, 0xf5,
-	0x54, 0xa6, 0x4e, 0xab, 0x26, 0x19, 0xf0, 0x7d, 0x17, 0xbf, 0x13, 0x4a, 0x78, 0x34, 0x91, 0x77,
-	0x80, 0xed, 0xb2, 0x53, 0xdf, 0x4e, 0xdd, 0xcc, 0x12, 0x47, 0x1a, 0xb3, 0x1c, 0x39, 0x86, 0x86,
-	0xdc, 0x9b, 0xf0, 0xc9, 0xf6, 0x77, 0x9e, 0xef, 0xec, 0xfe, 0x70, 0xa7, 0x24, 0x75, 0x99, 0xd7,
-	0xa6, 0x16, 0xbd, 0xb6, 0x8a, 0xc0, 0x3f, 0xdd, 0xdd, 0xdf, 0x19, 0x75, 0xab, 0xac, 0x0d, 0x3a,
-	0x36, 0xc7, 0xe6, 0xe0, 0x65, 0xb7, 0x86, 0x09, 0x8a, 0xa7, 0x9f, 0x0e, 0x5e, 0xac, 0x75, 0xeb,
-	0x59, 0x2d, 0xa1, 0x61, 0xfc, 0xb1, 0x02, 0x57, 0x89, 0x21, 0xc5, 0x88, 0xbd, 0xf8, 0xa9, 0x6a,
-	0x95, 0x3e, 0x55, 0xfd, 0xdf, 0x0d, 0xd2, 0xc5, 0xa0, 0xa9, 0x9b, 0xd6, 0xeb, 0x28, 0x9b, 0xa4,
-	0x4d, 0x5d, 0x59, 0xa6, 0xfb, 0x5b, 0x05, 0xfa, 0xe4, 0x2c, 0x3e, 0x8b, 0xac, 0xf0, 0xf8, 0x07,
-	0xdb, 0x17, 0xc2, 0xc5, 0xcb, 0x5c, 0xa8, 0x3b, 0xd0, 0xc1, 0x8f, 0x79, 0x7f, 0xea, 0x8d, 0x65,
-	0x48, 0x43, 0xb7, 0xdb, 0x96, 0x58, 0x9a, 0x88, 0x3d, 0x86, 0x16, 0x7d, 0xf4, 0x8b, 0x19, 0xcc,
-	0x52, 0xe5, 0xa9, 0xe4, 0xaa, 0x36, 0xa9, 0x17, 0xd6, 0xc0, 0xd8, 0xa3, 0x6c, 0x50, 0x1e, 0x59,
-	0x5e, 0x2c, 0x2e, 0xc9, 0x21, 0x23, 0x8c, 0x37, 0x1f, 0xc0, 0xcd, 0xb9, 0xe7, 0x90, 0x62, 0x5f,
-	0xc8, 0xf2, 0x91, 0xb4, 0x19, 0xbf, 0x50, 0x40, 0x5b, 0x9f, 0x7a, 0x27, 0x68, 0xdd, 0xde, 0x03,
-	0xe0, 0xce, 0x11, 0x97, 0x5f, 0xcf, 0x2a, 0xa8, 0x1c, 0x74, 0x81, 0xa1, 0xef, 0x67, 0x9f, 0x00,
-	0xd0, 0x19, 0xc7, 0x13, 0x2b, 0x94, 0x57, 0x84, 0x95, 0xa0, 0x74, 0x02, 0x79, 0x96, 0x17, 0x56,
-	0x28, 0x2b, 0x41, 0x71, 0x0a, 0xf7, 0x77, 0xa0, 0x53, 0x26, 0xce, 0xc9, 0x93, 0x7c, 0x58, 0xfe,
-	0xa2, 0xe0, 0x22, 0x77, 0x72, 0xb7, 0x6d, 0xf5, 0x6f, 0x14, 0xa8, 0x0a, 0x77, 0x8a, 0xdd, 0x07,
-	0xfd, 0x53, 0x6e, 0x45, 0xc9, 0x01, 0xb7, 0x12, 0x56, 0x72, 0x9d, 0xfa, 0xc8, 0xa9, 0xbc, 0xf0,
-	0x6f, 0x2c, 0x3c, 0x54, 0xd8, 0x0a, 0x7d, 0x3e, 0x98, 0x7e, 0x16, 0xd9, 0x4e, 0xdd, 0x32, 0x74,
-	0xdb, 0xfa, 0xa5, 0xf1, 0xc6, 0xc2, 0x32, 0xf6, 0xff, 0x2c, 0x70, 0xfd, 0xa7, 0xf4, 0xd1, 0x1a,
-	0x9b, 0x75, 0xe3, 0x66, 0x47, 0xb0, 0xfb, 0x50, 0xdf, 0x8a, 0x85, 0xbf, 0x78, 0xb1, 0x2b, 0x9e,
-	0xa7, 0xe8, 0x4a, 0x1a, 0x0b, 0xab, 0x7f, 0x56, 0x81, 0xea, 0xe7, 0x3c, 0x0a, 0xd8, 0xc7, 0xd0,
-	0x90, 0x9f, 0x49, 0xb0, 0xc2, 0xe7, 0x10, 0x7d, 0x0c, 0x5d, 0x67, 0xbe, 0x9f, 0xc0, 0x55, 0xba,
-	0xc4, 0x92, 0x3c, 0x5f, 0xce, 0xf2, 0xaf, 0x38, 0x2e, 0x6c, 0xea, 0x13, 0xe8, 0x0e, 0x93, 0x88,
-	0x5b, 0x93, 0x42, 0xf7, 0x32, 0xab, 0xe6, 0x25, 0xdf, 0x91, 0x5f, 0xf7, 0xa0, 0x4e, 0x4e, 0xf9,
-	0xcc, 0x80, 0xd9, 0xcc, 0x3a, 0x76, 0xfe, 0x08, 0x9a, 0xc3, 0xe3, 0x60, 0xea, 0x39, 0x43, 0x1e,
-	0x9d, 0x72, 0x56, 0xf8, 0x7c, 0xaa, 0x5f, 0x68, 0x1b, 0x0b, 0xec, 0x23, 0xd0, 0xc9, 0x65, 0x13,
-	0x0e, 0x5b, 0x43, 0x7a, 0x81, 0x34, 0x67, 0xc1, 0x95, 0x33, 0x16, 0xd8, 0x32, 0x40, 0xc1, 0x35,
-	0x7f, 0x53, 0xcf, 0xc7, 0xd0, 0x7e, 0x8a, 0x3a, 0x60, 0x37, 0x5a, 0x3b, 0x08, 0xa2, 0x84, 0xcd,
-	0x7e, 0x2f, 0xd5, 0x9f, 0x45, 0x18, 0x0b, 0xec, 0x21, 0x68, 0xa3, 0xe8, 0x9c, 0xfa, 0x5f, 0x95,
-	0x11, 0x4d, 0xbe, 0xde, 0x9c, 0x43, 0xae, 0xfe, 0x57, 0x15, 0xea, 0x3f, 0x0c, 0xa2, 0x13, 0x1e,
-	0xb1, 0xbb, 0x50, 0xc7, 0xb2, 0x87, 0x94, 0xa2, 0xac, 0x04, 0x32, 0x6f, 0xa1, 0x0f, 0x40, 0x47,
-	0x9e, 0x8c, 0xac, 0xf8, 0x84, 0x6e, 0x0a, 0x3f, 0x7a, 0x27, 0xb6, 0x50, 0x56, 0x04, 0xaf, 0xb5,
-	0x43, 0xf7, 0x94, 0x95, 0x05, 0x4b, 0x65, 0x89, 0x3e, 0x9e, 0xff, 0xf9, 0xcb, 0xa1, 0x90, 0xcc,
-	0x87, 0x8a, 0x30, 0x3d, 0x43, 0x3a, 0xa9, 0xe8, 0x94, 0x7f, 0xec, 0x4b, 0x82, 0x9f, 0x7f, 0x5d,
-	0x6b, 0x2c, 0xb0, 0x07, 0x50, 0x97, 0x9a, 0xe8, 0x6a, 0xfe, 0xaa, 0xa4, 0x7a, 0xeb, 0x77, 0x8b,
-	0x28, 0x39, 0xe0, 0x11, 0xd4, 0x49, 0x6b, 0xd3, 0x80, 0x92, 0x2f, 0xda, 0x67, 0x45, 0x54, 0x2a,
-	0xcb, 0xec, 0x1e, 0x34, 0x64, 0x51, 0x83, 0xcd, 0xa9, 0x70, 0xd0, 0x51, 0xc9, 0x09, 0xa6, 0xf9,
-	0xc9, 0x24, 0xd3, 0xfc, 0x25, 0xaf, 0x86, 0xe6, 0x2f, 0x5b, 0x6c, 0x12, 0x7a, 0x93, 0xdb, 0xdc,
-	0x2d, 0x04, 0xe3, 0x2c, 0xe5, 0xc8, 0x9c, 0x97, 0xfb, 0x09, 0xb4, 0x4b, 0x81, 0x3b, 0x43, 0x2f,
-	0x6d, 0x5e, 0x2c, 0x7f, 0xe1, 0xbd, 0x7c, 0x1f, 0x74, 0x19, 0x37, 0x1d, 0x70, 0x86, 0xb5, 0x8a,
-	0x39, 0x91, 0x57, 0xff, 0x62, 0xe0, 0x84, 0x8f, 0xe0, 0x47, 0x70, 0x6d, 0x8e, 0x0a, 0x66, 0xf8,
-	0x19, 0xda, 0xe5, 0x36, 0xa6, 0xbf, 0x78, 0x29, 0x3d, 0x65, 0xc0, 0x7a, 0xef, 0xef, 0xbe, 0xbc,
-	0xa5, 0xfc, 0xf2, 0xcb, 0x5b, 0xca, 0xbf, 0x7c, 0x79, 0x4b, 0xf9, 0xbd, 0xaf, 0x6e, 0x2d, 0xfc,
-	0xf2, 0xab, 0x5b, 0x0b, 0xff, 0xf4, 0xd5, 0xad, 0x85, 0x83, 0x3a, 0xfe, 0x11, 0xe4, 0xf1, 0x7f,
-	0x07, 0x00, 0x00, 0xff, 0xff, 0x35, 0x6c, 0x7d, 0xd3, 0x7e, 0x32, 0x00, 0x00,
+	// 5033 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x7b, 0x4d, 0x6c, 0x1c, 0x57,
+	0x72, 0x30, 0xa7, 0xe7, 0xb7, 0x6b, 0x7e, 0x34, 0x7a, 0xd2, 0xca, 0xb3, 0x23, 0x5b, 0xa4, 0xdb,
+	0x96, 0xcd, 0xb5, 0x2c, 0x4a, 0xa6, 0xf6, 0xc3, 0xb7, 0xf6, 0x22, 0x40, 0x48, 0x71, 0x24, 0xd3,
+	0xa2, 0x48, 0x6d, 0x73, 0xa4, 0xfd, 0x39, 0x64, 0xd0, 0xec, 0x7e, 0x24, 0x7b, 0xd9, 0xd3, 0xdd,
+	0xdb, 0xdd, 0xc3, 0x25, 0x7d, 0x0b, 0x02, 0x64, 0x73, 0xc8, 0x21, 0x40, 0x2e, 0x39, 0x25, 0x40,
+	0x0e, 0xb9, 0x04, 0x08, 0x90, 0x00, 0x0b, 0x04, 0x01, 0x72, 0x0b, 0x82, 0x20, 0xa7, 0x3d, 0xe4,
+	0x90, 0x43, 0x62, 0x04, 0xde, 0x20, 0x07, 0xdd, 0x92, 0x9c, 0x72, 0x0b, 0xaa, 0xea, 0xf5, 0xdf,
+	0x70, 0x28, 0xd9, 0x1b, 0xe4, 0x90, 0xd3, 0xbc, 0xaa, 0x7a, 0xbf, 0xf5, 0xea, 0xd5, 0x6f, 0x0f,
+	0xb4, 0xc2, 0x83, 0xb5, 0x30, 0x0a, 0x92, 0x40, 0x68, 0xe1, 0xc1, 0x50, 0xb7, 0x42, 0x97, 0xc1,
+	0xe1, 0x07, 0x47, 0x6e, 0x72, 0x3c, 0x3b, 0x58, 0xb3, 0x83, 0xe9, 0x3d, 0xe7, 0x28, 0xb2, 0xc2,
+	0xe3, 0xbb, 0x6e, 0x70, 0xef, 0xc0, 0x72, 0x8e, 0x64, 0x74, 0xef, 0xf4, 0xc1, 0xbd, 0xf0, 0xe0,
+	0x5e, 0x3a, 0x74, 0x78, 0xb7, 0xd0, 0xf7, 0x28, 0x38, 0x0a, 0xee, 0x11, 0xfa, 0x60, 0x76, 0x48,
+	0x10, 0x01, 0xd4, 0xe2, 0xee, 0xc6, 0x10, 0x6a, 0x3b, 0x6e, 0x9c, 0x08, 0x01, 0xb5, 0x99, 0xeb,
+	0xc4, 0x83, 0xca, 0x4a, 0x75, 0xb5, 0x61, 0x52, 0xdb, 0x78, 0x0a, 0xfa, 0xd8, 0x8a, 0x4f, 0x5e,
+	0x58, 0xde, 0x4c, 0x8a, 0x3e, 0x54, 0x4f, 0x2d, 0x6f, 0x50, 0x59, 0xa9, 0xac, 0x76, 0x4c, 0x6c,
+	0x8a, 0x35, 0x68, 0x9d, 0x5a, 0xde, 0x24, 0x39, 0x0f, 0xe5, 0x40, 0x5b, 0xa9, 0xac, 0xf6, 0xd6,
+	0xaf, 0xad, 0x85, 0x07, 0x6b, 0xcf, 0x82, 0x38, 0x71, 0xfd, 0xa3, 0xb5, 0x17, 0x96, 0x37, 0x3e,
+	0x0f, 0xa5, 0xd9, 0x3c, 0xe5, 0x86, 0xb1, 0x07, 0xed, 0xfd, 0xc8, 0x7e, 0x34, 0xf3, 0xed, 0xc4,
+	0x0d, 0x7c, 0x5c, 0xd1, 0xb7, 0xa6, 0x92, 0x66, 0xd4, 0x4d, 0x6a, 0x23, 0xce, 0x8a, 0x8e, 0xe2,
+	0x41, 0x75, 0xa5, 0x8a, 0x38, 0x6c, 0x8b, 0x01, 0x34, 0xdd, 0xf8, 0x61, 0x30, 0xf3, 0x93, 0x41,
+	0x6d, 0xa5, 0xb2, 0xda, 0x32, 0x53, 0xd0, 0xf8, 0xa3, 0x2a, 0xd4, 0xbf, 0x37, 0x93, 0xd1, 0x39,
+	0x8d, 0x4b, 0x92, 0x28, 0x9d, 0x0b, 0xdb, 0xe2, 0x3a, 0xd4, 0x3d, 0xcb, 0x3f, 0x8a, 0x07, 0x1a,
+	0x4d, 0xc6, 0x80, 0xb8, 0x09, 0xba, 0x75, 0x98, 0xc8, 0x68, 0x32, 0x73, 0x9d, 0x41, 0x75, 0xa5,
+	0xb2, 0xda, 0x30, 0x5b, 0x84, 0x78, 0xee, 0x3a, 0xe2, 0x9b, 0xd0, 0x72, 0x82, 0x89, 0x5d, 0x5c,
+	0xcb, 0x09, 0x68, 0x2d, 0xf1, 0x0e, 0xb4, 0x66, 0xae, 0x33, 0xf1, 0xdc, 0x38, 0x19, 0xd4, 0x57,
+	0x2a, 0xab, 0xed, 0xf5, 0x16, 0x1e, 0x16, 0x79, 0x67, 0x36, 0x67, 0xae, 0x43, 0x4c, 0xfc, 0x00,
+	0x5a, 0x71, 0x64, 0x4f, 0x0e, 0x67, 0xbe, 0x3d, 0x68, 0x50, 0xa7, 0x2b, 0xd8, 0xa9, 0x70, 0x6a,
+	0xb3, 0x19, 0x33, 0x80, 0xc7, 0x8a, 0xe4, 0xa9, 0x8c, 0x62, 0x39, 0x68, 0xf2, 0x52, 0x0a, 0x14,
+	0xf7, 0xa1, 0x7d, 0x68, 0xd9, 0x32, 0x99, 0x84, 0x56, 0x64, 0x4d, 0x07, 0xad, 0x7c, 0xa2, 0x47,
+	0x88, 0x7e, 0x86, 0xd8, 0xd8, 0x84, 0xc3, 0x0c, 0x10, 0x0f, 0xa0, 0x4b, 0x50, 0x3c, 0x39, 0x74,
+	0xbd, 0x44, 0x46, 0x03, 0x9d, 0xc6, 0xf4, 0x68, 0x0c, 0x61, 0xc6, 0x91, 0x94, 0x66, 0x87, 0x3b,
+	0x31, 0x46, 0xbc, 0x05, 0x20, 0xcf, 0x42, 0xcb, 0x77, 0x26, 0x96, 0xe7, 0x0d, 0x80, 0xf6, 0xa0,
+	0x33, 0x66, 0xc3, 0xf3, 0xc4, 0x1b, 0xb8, 0x3f, 0xcb, 0x99, 0x24, 0xf1, 0xa0, 0xbb, 0x52, 0x59,
+	0xad, 0x99, 0x0d, 0x04, 0xc7, 0x31, 0xf2, 0xd5, 0xb6, 0xec, 0x63, 0x39, 0xe8, 0xad, 0x54, 0x56,
+	0xeb, 0x26, 0x03, 0x88, 0x3d, 0x74, 0xa3, 0x38, 0x19, 0x5c, 0x61, 0x2c, 0x01, 0xc6, 0x3a, 0xe8,
+	0x24, 0x3d, 0xc4, 0x9d, 0xdb, 0xd0, 0x38, 0x45, 0x80, 0x85, 0xac, 0xbd, 0xde, 0xc5, 0xed, 0x65,
+	0x02, 0x66, 0x2a, 0xa2, 0x71, 0x0b, 0x5a, 0x3b, 0x96, 0x7f, 0x94, 0x4a, 0x25, 0x5e, 0x1b, 0x0d,
+	0xd0, 0x4d, 0x6a, 0x1b, 0x7f, 0xa0, 0x41, 0xc3, 0x94, 0xf1, 0xcc, 0x4b, 0xc4, 0xfb, 0x00, 0x78,
+	0x29, 0x53, 0x2b, 0x89, 0xdc, 0x33, 0x35, 0x6b, 0x7e, 0x2d, 0xfa, 0xcc, 0x75, 0x9e, 0x12, 0x49,
+	0xdc, 0x87, 0x0e, 0xcd, 0x9e, 0x76, 0xd5, 0xf2, 0x0d, 0x64, 0xfb, 0x33, 0xdb, 0xd4, 0x45, 0x8d,
+	0xb8, 0x01, 0x0d, 0x92, 0x03, 0x96, 0xc5, 0xae, 0xa9, 0x20, 0x71, 0x1b, 0x7a, 0xae, 0x9f, 0xe0,
+	0x3d, 0xd9, 0xc9, 0xc4, 0x91, 0x71, 0x2a, 0x28, 0xdd, 0x0c, 0xbb, 0x25, 0xe3, 0x44, 0x7c, 0x04,
+	0xcc, 0xec, 0x74, 0xc1, 0x3a, 0x2d, 0xd8, 0xcb, 0x2e, 0x31, 0xe6, 0x15, 0xa9, 0x8f, 0x5a, 0xf1,
+	0x2e, 0xb4, 0xf1, 0x7c, 0xe9, 0x88, 0x06, 0x8d, 0xe8, 0xd0, 0x69, 0x14, 0x3b, 0x4c, 0xc0, 0x0e,
+	0xaa, 0x3b, 0xb2, 0x06, 0x85, 0x91, 0x85, 0x87, 0xda, 0xc6, 0x08, 0xea, 0x7b, 0x91, 0x23, 0xa3,
+	0x85, 0xef, 0x41, 0x40, 0xcd, 0x91, 0xb1, 0x4d, 0x4f, 0xb5, 0x65, 0x52, 0x3b, 0x7f, 0x23, 0xd5,
+	0xc2, 0x1b, 0x31, 0xfe, 0xb0, 0x02, 0xed, 0xfd, 0x20, 0x4a, 0x9e, 0xca, 0x38, 0xb6, 0x8e, 0xa4,
+	0x58, 0x86, 0x7a, 0x80, 0xd3, 0x2a, 0x0e, 0xeb, 0xb8, 0x27, 0x5a, 0xc7, 0x64, 0xfc, 0xdc, 0x3d,
+	0x68, 0x97, 0xdf, 0x03, 0xca, 0x0e, 0xbd, 0xae, 0xaa, 0x92, 0x1d, 0x7a, 0x5b, 0x37, 0xa0, 0x11,
+	0x1c, 0x1e, 0xc6, 0x92, 0x79, 0x59, 0x37, 0x15, 0x74, 0xa9, 0x08, 0x1a, 0xff, 0x0f, 0x00, 0xf7,
+	0xf7, 0x35, 0xa5, 0xc0, 0xf8, 0x59, 0x05, 0xda, 0xa6, 0x75, 0x98, 0x3c, 0x0c, 0xfc, 0x44, 0x9e,
+	0x25, 0xa2, 0x07, 0x9a, 0xeb, 0x10, 0x8f, 0x1a, 0xa6, 0xe6, 0x3a, 0xb8, 0xbb, 0xa3, 0x28, 0x98,
+	0x85, 0xc4, 0xa2, 0xae, 0xc9, 0x00, 0xf1, 0xd2, 0x71, 0x22, 0xda, 0x32, 0xf2, 0xd2, 0x71, 0x22,
+	0xb1, 0x0c, 0xed, 0xd8, 0xb7, 0xc2, 0xf8, 0x38, 0x48, 0x70, 0x77, 0x35, 0xda, 0x1d, 0xa4, 0xa8,
+	0x71, 0x8c, 0x8f, 0xcb, 0x8d, 0x27, 0x9e, 0xb4, 0x22, 0x5f, 0x46, 0xa4, 0x30, 0x5a, 0xa6, 0xee,
+	0xc6, 0x3b, 0x8c, 0x30, 0x7e, 0x56, 0x85, 0xc6, 0x53, 0x39, 0x3d, 0x90, 0xd1, 0x85, 0x4d, 0xdc,
+	0x87, 0x16, 0xad, 0x3b, 0x71, 0x1d, 0xde, 0xc7, 0xe6, 0x37, 0x5e, 0x7e, 0xb1, 0x7c, 0x95, 0x70,
+	0xdb, 0xce, 0x87, 0xc1, 0xd4, 0x4d, 0xe4, 0x34, 0x4c, 0xce, 0xcd, 0xa6, 0x42, 0x2d, 0xdc, 0xe0,
+	0x0d, 0x68, 0x78, 0xd2, 0xc2, 0x3b, 0x63, 0xf1, 0x54, 0x90, 0xb8, 0x0b, 0x4d, 0x6b, 0x3a, 0x71,
+	0xa4, 0xe5, 0xf0, 0xa6, 0x36, 0xaf, 0xbf, 0xfc, 0x62, 0xb9, 0x6f, 0x4d, 0xb7, 0xa4, 0x55, 0x9c,
+	0xbb, 0xc1, 0x18, 0xf1, 0x31, 0xca, 0x64, 0x9c, 0x4c, 0x66, 0xa1, 0x63, 0x25, 0x92, 0x74, 0x5a,
+	0x6d, 0x73, 0xf0, 0xf2, 0x8b, 0xe5, 0xeb, 0x88, 0x7e, 0x4e, 0xd8, 0xc2, 0x30, 0xc8, 0xb1, 0xa8,
+	0xdf, 0xd2, 0xe3, 0x2b, 0xfd, 0xa6, 0x40, 0xb1, 0x0d, 0x57, 0x6d, 0x6f, 0x16, 0xa3, 0x12, 0x76,
+	0xfd, 0xc3, 0x60, 0x12, 0xf8, 0xde, 0x39, 0x5d, 0x70, 0x6b, 0xf3, 0xad, 0x97, 0x5f, 0x2c, 0x7f,
+	0x53, 0x11, 0xb7, 0xfd, 0xc3, 0x60, 0xcf, 0xf7, 0xce, 0x0b, 0xf3, 0x5f, 0x99, 0x23, 0x89, 0x5f,
+	0x87, 0xde, 0x61, 0x10, 0xd9, 0x72, 0x92, 0xb1, 0xac, 0x47, 0xf3, 0x0c, 0x5f, 0x7e, 0xb1, 0x7c,
+	0x83, 0x28, 0x8f, 0x2f, 0xf0, 0xad, 0x53, 0xc4, 0x1b, 0xff, 0xac, 0x41, 0x9d, 0xda, 0xe2, 0x3e,
+	0x34, 0xa7, 0x74, 0x25, 0xa9, 0x7e, 0xba, 0x81, 0x32, 0x44, 0xb4, 0x35, 0xbe, 0xab, 0x78, 0xe4,
+	0x27, 0xd1, 0xb9, 0x99, 0x76, 0xc3, 0x11, 0x89, 0x75, 0xe0, 0xc9, 0x24, 0x56, 0x32, 0x5f, 0x18,
+	0x31, 0x66, 0x82, 0x1a, 0xa1, 0xba, 0xcd, 0xcb, 0x4d, 0xf5, 0x82, 0xdc, 0x0c, 0xa1, 0x65, 0x1f,
+	0x4b, 0xfb, 0x24, 0x9e, 0x4d, 0x95, 0x54, 0x65, 0xb0, 0x78, 0x07, 0xba, 0xd4, 0x0e, 0x03, 0xd7,
+	0xa7, 0xe1, 0x75, 0xea, 0xd0, 0xc9, 0x91, 0xe3, 0x78, 0xf8, 0x08, 0x3a, 0xc5, 0xcd, 0xa2, 0xd9,
+	0x3e, 0x91, 0xe7, 0x24, 0x5f, 0x35, 0x13, 0x9b, 0x62, 0x05, 0xea, 0xa4, 0xe8, 0x48, 0xba, 0xda,
+	0xeb, 0x80, 0x7b, 0xe6, 0x21, 0x26, 0x13, 0x3e, 0xd1, 0xbe, 0x53, 0xc1, 0x79, 0x8a, 0x47, 0x28,
+	0xce, 0xa3, 0x5f, 0x3e, 0x0f, 0x0f, 0x29, 0xcc, 0x63, 0x04, 0xd0, 0xdc, 0x71, 0x6d, 0xe9, 0xc7,
+	0x64, 0xdc, 0x67, 0xb1, 0xcc, 0x94, 0x12, 0xb6, 0xf1, 0xbc, 0x53, 0xeb, 0x6c, 0x37, 0x70, 0x64,
+	0x4c, 0xf3, 0xd4, 0xcc, 0x0c, 0x46, 0x9a, 0x3c, 0x0b, 0xdd, 0xe8, 0x7c, 0xcc, 0x9c, 0xaa, 0x9a,
+	0x19, 0x8c, 0xd2, 0x25, 0x7d, 0x5c, 0xcc, 0x49, 0x0d, 0xb5, 0x02, 0x8d, 0x7f, 0xa8, 0x42, 0xe7,
+	0x47, 0x32, 0x0a, 0x9e, 0x45, 0x41, 0x18, 0xc4, 0x96, 0x27, 0x36, 0xca, 0x3c, 0xe7, 0xbb, 0x5d,
+	0xc1, 0xdd, 0x16, 0xbb, 0xad, 0xed, 0x67, 0x97, 0xc0, 0x77, 0x56, 0xbc, 0x15, 0x03, 0x1a, 0x7c,
+	0xe7, 0x0b, 0x78, 0xa6, 0x28, 0xd8, 0x87, 0x6f, 0x99, 0xf6, 0x5a, 0xe6, 0x87, 0xa2, 0xe0, 0xab,
+	0x9c, 0x5a, 0x67, 0xcf, 0xb7, 0xb7, 0xd4, 0xdd, 0x2a, 0x48, 0x71, 0x61, 0x7c, 0xe6, 0x8f, 0xd3,
+	0x4b, 0xcd, 0x60, 0x3c, 0x29, 0x72, 0x24, 0xde, 0xde, 0x1a, 0x74, 0x88, 0x94, 0x82, 0xe2, 0x4d,
+	0xd0, 0xa7, 0xd6, 0x19, 0x2a, 0xb4, 0x6d, 0x87, 0x9f, 0xa6, 0x99, 0x23, 0xc4, 0xdb, 0x50, 0x4d,
+	0xce, 0x7c, 0x7a, 0x7b, 0xe8, 0x3d, 0xa0, 0x33, 0x39, 0x3e, 0xf3, 0x95, 0xea, 0x33, 0x91, 0x86,
+	0x77, 0x6a, 0xbb, 0x0e, 0x39, 0x0b, 0xba, 0x89, 0x4d, 0x71, 0x1b, 0x9a, 0x1e, 0xdf, 0x16, 0x39,
+	0x04, 0xed, 0xf5, 0x36, 0xeb, 0x51, 0x42, 0x99, 0x29, 0x4d, 0x7c, 0x08, 0xad, 0x94, 0x3b, 0x83,
+	0x36, 0xf5, 0xeb, 0xa7, 0xfc, 0x4c, 0xd9, 0x68, 0x66, 0x3d, 0x86, 0xbf, 0x06, 0x57, 0xe6, 0x98,
+	0x5b, 0x94, 0xa6, 0x2e, 0x4b, 0xd3, 0xf5, 0xa2, 0x34, 0xd5, 0x0a, 0x12, 0xf4, 0x59, 0xad, 0xd5,
+	0xea, 0xeb, 0xc6, 0xbf, 0x57, 0xe1, 0x8a, 0x12, 0xec, 0x63, 0x37, 0xdc, 0x4f, 0x94, 0x8a, 0x21,
+	0x03, 0xa2, 0x64, 0xaa, 0x66, 0xa6, 0xa0, 0xf8, 0xff, 0xd0, 0x20, 0x8d, 0x90, 0x3e, 0xcc, 0xe5,
+	0xfc, 0xc2, 0xb2, 0xe1, 0xfc, 0x50, 0xd5, 0x6d, 0xab, 0xee, 0xe2, 0xdb, 0x50, 0xff, 0x5c, 0x46,
+	0x01, 0x1b, 0xc4, 0xf6, 0xfa, 0xad, 0x45, 0xe3, 0xf0, 0x98, 0x6a, 0x18, 0x77, 0xfe, 0x9f, 0xde,
+	0x2b, 0x7c, 0x9d, 0x7b, 0x7d, 0x17, 0x8d, 0xe2, 0x34, 0x38, 0x95, 0xce, 0xa0, 0x49, 0x7b, 0x2c,
+	0x0a, 0x63, 0x4a, 0x4a, 0xaf, 0xb6, 0xb5, 0xf0, 0x6a, 0xf5, 0xcb, 0xaf, 0x76, 0xb8, 0x05, 0xed,
+	0x02, 0x5f, 0x16, 0x5c, 0xd4, 0x72, 0xf9, 0xd9, 0xeb, 0x99, 0xca, 0x2b, 0x6a, 0x8f, 0x2d, 0x80,
+	0x9c, 0x4b, 0xbf, 0xaa, 0x0e, 0x32, 0x7e, 0xb3, 0x02, 0x57, 0x1e, 0x06, 0xbe, 0x2f, 0xc9, 0x75,
+	0xe6, 0x3b, 0xcf, 0x9f, 0x62, 0xe5, 0xd2, 0xa7, 0xf8, 0x2d, 0xa8, 0xc7, 0xd8, 0x59, 0xcd, 0x7e,
+	0x6d, 0xc1, 0x25, 0x9a, 0xdc, 0x03, 0x15, 0xf2, 0xd4, 0x3a, 0x9b, 0x84, 0xd2, 0x77, 0x5c, 0xff,
+	0x28, 0x55, 0xc8, 0x53, 0xeb, 0xec, 0x19, 0x63, 0x8c, 0xbf, 0xd4, 0x00, 0x3e, 0x95, 0x96, 0x97,
+	0x1c, 0xa3, 0xd1, 0xc1, 0x1b, 0x75, 0xfd, 0x38, 0xb1, 0x7c, 0x3b, 0x0d, 0x5c, 0x32, 0x18, 0x6f,
+	0x14, 0x6d, 0xaf, 0x8c, 0x59, 0x95, 0xe9, 0x66, 0x0a, 0xa2, 0x7c, 0xe0, 0x72, 0xb3, 0x58, 0xd9,
+	0x68, 0x05, 0xe5, 0x0e, 0x47, 0x8d, 0xd0, 0xca, 0xe1, 0x18, 0x40, 0x13, 0x03, 0x01, 0x37, 0xf0,
+	0x49, 0x68, 0x74, 0x33, 0x05, 0x71, 0x9e, 0x59, 0x98, 0xb8, 0x53, 0xb6, 0xc4, 0x55, 0x53, 0x41,
+	0xb8, 0x2b, 0xb4, 0xbc, 0x23, 0xfb, 0x38, 0xa0, 0x07, 0x5f, 0x35, 0x33, 0x18, 0x67, 0x0b, 0xfc,
+	0xa3, 0x00, 0x4f, 0xd7, 0x22, 0x27, 0x2f, 0x05, 0xf9, 0x2c, 0x8e, 0x3c, 0x43, 0x92, 0x4e, 0xa4,
+	0x0c, 0x46, 0xbe, 0x48, 0x39, 0x39, 0x94, 0x56, 0x32, 0x8b, 0x64, 0x3c, 0x00, 0x22, 0x83, 0x94,
+	0x8f, 0x14, 0x46, 0xbc, 0x0d, 0x1d, 0x64, 0x9c, 0x15, 0xc7, 0xee, 0x91, 0x2f, 0x1d, 0x52, 0x03,
+	0x35, 0x13, 0x99, 0xb9, 0xa1, 0x50, 0xc6, 0x5f, 0x6b, 0xd0, 0x60, 0x05, 0x58, 0x72, 0x6a, 0x2a,
+	0x5f, 0xc9, 0xa9, 0x79, 0x13, 0xf4, 0x30, 0x92, 0x8e, 0x6b, 0xa7, 0xf7, 0xa8, 0x9b, 0x39, 0x82,
+	0xa2, 0x0d, 0xb4, 0xe2, 0xc4, 0xcf, 0x96, 0xc9, 0x80, 0x30, 0xa0, 0x1b, 0xf8, 0x13, 0xc7, 0x8d,
+	0x4f, 0x26, 0x07, 0xe7, 0x89, 0x8c, 0x15, 0x2f, 0xda, 0x81, 0xbf, 0xe5, 0xc6, 0x27, 0x9b, 0x88,
+	0x42, 0x16, 0xf2, 0x1b, 0xa1, 0xb7, 0xd1, 0x32, 0x15, 0x24, 0x1e, 0x80, 0x4e, 0xbe, 0x26, 0x39,
+	0x23, 0x3a, 0x39, 0x11, 0x37, 0x5e, 0x7e, 0xb1, 0x2c, 0x10, 0x39, 0xe7, 0x85, 0xb4, 0x52, 0x1c,
+	0x7a, 0x53, 0x38, 0x18, 0xcd, 0x0a, 0xbd, 0x61, 0xf6, 0xa6, 0x10, 0x35, 0x8e, 0x8b, 0xde, 0x14,
+	0x63, 0xc4, 0x5d, 0x10, 0x33, 0xdf, 0x0e, 0xa6, 0x21, 0x0a, 0x85, 0x74, 0xd4, 0x26, 0xdb, 0xb4,
+	0xc9, 0xab, 0x45, 0x0a, 0x6d, 0xd5, 0xf8, 0x27, 0x0d, 0x3a, 0x5b, 0x6e, 0x24, 0xed, 0x44, 0x3a,
+	0x23, 0xe7, 0x48, 0xe2, 0xde, 0xa5, 0x9f, 0xb8, 0xc9, 0xb9, 0x72, 0x17, 0x15, 0x94, 0x79, 0xfb,
+	0x5a, 0x39, 0xfa, 0xe5, 0x17, 0x56, 0xa5, 0x80, 0x9d, 0x01, 0xb1, 0x0e, 0xc0, 0x71, 0x10, 0x05,
+	0xed, 0xb5, 0xcb, 0x83, 0x76, 0x9d, 0xba, 0x61, 0x13, 0x83, 0x62, 0x1e, 0xe3, 0xb2, 0xcf, 0xd8,
+	0xa0, 0x88, 0x7e, 0x26, 0xd9, 0xf3, 0xa4, 0xf0, 0xac, 0xc9, 0x0b, 0x63, 0x5b, 0xbc, 0x03, 0x5a,
+	0x10, 0x12, 0x73, 0xd5, 0xd4, 0xc5, 0x23, 0xac, 0xed, 0x85, 0xa6, 0x16, 0x84, 0xf8, 0x8a, 0x39,
+	0x16, 0x25, 0xc1, 0xc3, 0x57, 0x8c, 0xf6, 0x89, 0x22, 0x23, 0x53, 0x51, 0x84, 0x01, 0x1d, 0xcb,
+	0xf3, 0x82, 0x9f, 0x4a, 0xe7, 0x59, 0x24, 0x9d, 0x54, 0x06, 0x4b, 0x38, 0x94, 0x12, 0xdf, 0x9a,
+	0xca, 0x38, 0xb4, 0x6c, 0xa9, 0x44, 0x30, 0x47, 0x18, 0x37, 0x40, 0xdb, 0x0b, 0x45, 0x13, 0xaa,
+	0xfb, 0xa3, 0x71, 0x7f, 0x09, 0x1b, 0x5b, 0xa3, 0x9d, 0x3e, 0x5a, 0x94, 0x46, 0xbf, 0x69, 0x7c,
+	0xa9, 0x81, 0xfe, 0x74, 0x96, 0x58, 0xa8, 0x5b, 0x62, 0x3c, 0x65, 0x59, 0x42, 0x73, 0x51, 0xfc,
+	0x26, 0xb4, 0xe2, 0xc4, 0x8a, 0xc8, 0x7b, 0x60, 0xeb, 0xd4, 0x24, 0x78, 0x1c, 0x8b, 0xf7, 0xa0,
+	0x2e, 0x9d, 0x23, 0x99, 0x9a, 0x8b, 0xfe, 0xfc, 0x79, 0x4d, 0x26, 0x8b, 0x55, 0x68, 0xc4, 0xf6,
+	0xb1, 0x9c, 0x5a, 0x83, 0x5a, 0xde, 0x71, 0x9f, 0x30, 0xec, 0x2e, 0x9b, 0x8a, 0x2e, 0xde, 0x85,
+	0x3a, 0xde, 0x4d, 0xac, 0xe2, 0x3f, 0x8a, 0x18, 0xf1, 0x1a, 0x54, 0x37, 0x26, 0xa2, 0xe0, 0x39,
+	0x51, 0x10, 0x4e, 0x82, 0x90, 0x78, 0xdf, 0x5b, 0xbf, 0x4e, 0x3a, 0x2e, 0x3d, 0xcd, 0xda, 0x56,
+	0x14, 0x84, 0x7b, 0xa1, 0xd9, 0x70, 0xe8, 0x17, 0xa3, 0x11, 0xea, 0xce, 0x12, 0xc1, 0x46, 0x41,
+	0x47, 0x0c, 0xa7, 0x76, 0x56, 0xa1, 0x35, 0x95, 0x89, 0xe5, 0x58, 0x89, 0xa5, 0x6c, 0x43, 0x87,
+	0x55, 0x26, 0xe3, 0xcc, 0x8c, 0x6a, 0xdc, 0x83, 0x06, 0x4f, 0x2d, 0x5a, 0x50, 0xdb, 0xdd, 0xdb,
+	0x1d, 0x31, 0x5b, 0x37, 0x76, 0x76, 0xfa, 0x15, 0x44, 0x6d, 0x6d, 0x8c, 0x37, 0xfa, 0x1a, 0xb6,
+	0xc6, 0x3f, 0x7c, 0x36, 0xea, 0x57, 0x8d, 0xbf, 0xaf, 0x40, 0x2b, 0x9d, 0x47, 0x7c, 0x02, 0x80,
+	0x4f, 0x78, 0x72, 0xec, 0xfa, 0x99, 0x23, 0x76, 0xb3, 0xb8, 0xd2, 0x1a, 0xde, 0xea, 0xa7, 0x48,
+	0x65, 0xf3, 0x4a, 0x2f, 0x9e, 0xe0, 0xe1, 0x3e, 0xf4, 0xca, 0xc4, 0x05, 0x1e, 0xe9, 0x9d, 0xa2,
+	0x55, 0xe9, 0xad, 0x7f, 0xa3, 0x34, 0x35, 0x8e, 0x24, 0xd1, 0x2e, 0x18, 0x98, 0xbb, 0xd0, 0x4a,
+	0xd1, 0xa2, 0x0d, 0xcd, 0xad, 0xd1, 0xa3, 0x8d, 0xe7, 0x3b, 0x28, 0x2a, 0x00, 0x8d, 0xfd, 0xed,
+	0xdd, 0xc7, 0x3b, 0x23, 0x3e, 0xd6, 0xce, 0xf6, 0xfe, 0xb8, 0xaf, 0x19, 0xbf, 0x5f, 0x81, 0x56,
+	0xea, 0xc9, 0x88, 0x6f, 0xa1, 0xf3, 0x41, 0xce, 0x94, 0xb2, 0x44, 0x94, 0xa1, 0x29, 0x84, 0x97,
+	0x66, 0x4a, 0xc7, 0xb7, 0x48, 0x8a, 0x35, 0xf5, 0x6d, 0x08, 0x28, 0x46, 0xb7, 0xd5, 0x52, 0x82,
+	0x05, 0x03, 0xf5, 0xc0, 0x97, 0xca, 0xb1, 0xa5, 0x36, 0xc9, 0xa0, 0xeb, 0xdb, 0x32, 0x77, 0xfb,
+	0x9b, 0x04, 0x8f, 0x63, 0x23, 0x61, 0x7f, 0x37, 0xdb, 0x58, 0xb6, 0x5a, 0xa5, 0xb8, 0xda, 0x85,
+	0xe0, 0x41, 0xbb, 0x18, 0x3c, 0xe4, 0x86, 0xb3, 0xfe, 0x3a, 0xc3, 0x69, 0xfc, 0x79, 0x0d, 0x7a,
+	0xa6, 0x8c, 0x93, 0x20, 0x92, 0xa6, 0xfc, 0xc9, 0x4c, 0xc6, 0xc9, 0xab, 0x9e, 0xd0, 0x5b, 0x00,
+	0x11, 0x77, 0xce, 0x97, 0xd6, 0x15, 0x86, 0xa3, 0x1e, 0x2f, 0xb0, 0x49, 0x76, 0x95, 0x85, 0xcc,
+	0x60, 0x71, 0x13, 0xf4, 0x03, 0xcb, 0x3e, 0xe1, 0x69, 0xd9, 0x4e, 0xb6, 0x18, 0xc1, 0xf3, 0x5a,
+	0xb6, 0x2d, 0xe3, 0x78, 0x82, 0xa2, 0xc0, 0xd6, 0x52, 0x67, 0xcc, 0x13, 0x79, 0x8e, 0xe4, 0x58,
+	0xda, 0x91, 0x4c, 0x88, 0xdc, 0x60, 0x32, 0x63, 0x90, 0xfc, 0x0e, 0x74, 0x63, 0x19, 0xa3, 0x65,
+	0x9d, 0x24, 0xc1, 0x89, 0xf4, 0x95, 0x1e, 0xeb, 0x28, 0xe4, 0x18, 0x71, 0xa8, 0x62, 0x2c, 0x3f,
+	0xf0, 0xcf, 0xa7, 0xc1, 0x2c, 0x56, 0x36, 0x23, 0x47, 0x88, 0x35, 0xb8, 0x26, 0x7d, 0x3b, 0x3a,
+	0x0f, 0x71, 0xaf, 0xb8, 0xca, 0xe4, 0xd0, 0xf5, 0xa4, 0x72, 0xa9, 0xaf, 0xe6, 0xa4, 0x27, 0xf2,
+	0xfc, 0x91, 0xeb, 0x49, 0xdc, 0xd1, 0xa9, 0x35, 0xf3, 0x92, 0x09, 0x45, 0xec, 0xc0, 0x3b, 0x22,
+	0xcc, 0x06, 0x86, 0xed, 0x1f, 0xc0, 0x55, 0x26, 0x47, 0x81, 0x27, 0x5d, 0x87, 0x27, 0x6b, 0x53,
+	0xaf, 0x2b, 0x44, 0x30, 0x09, 0x4f, 0x53, 0xad, 0xc1, 0x35, 0xee, 0xcb, 0x07, 0x4a, 0x7b, 0x77,
+	0x78, 0x69, 0x22, 0xed, 0x2b, 0x4a, 0x79, 0xe9, 0xd0, 0x4a, 0x8e, 0x29, 0xde, 0x4e, 0x97, 0x7e,
+	0x66, 0x25, 0xc7, 0x68, 0xf1, 0x99, 0x7c, 0xe8, 0x4a, 0x8f, 0xe3, 0x68, 0xdd, 0xe4, 0x11, 0x8f,
+	0x10, 0x83, 0x16, 0x5f, 0x75, 0x08, 0xa2, 0xa9, 0xc5, 0x89, 0x3e, 0xdd, 0xe4, 0x41, 0x8f, 0x08,
+	0x85, 0x4b, 0xa8, 0xbb, 0xf2, 0x67, 0xd3, 0x41, 0x9f, 0xaf, 0x99, 0x31, 0xbb, 0xb3, 0xa9, 0xf1,
+	0x1f, 0x1a, 0xb4, 0xb2, 0xb0, 0xec, 0x0e, 0xe8, 0xd3, 0x54, 0x5f, 0x29, 0x47, 0xad, 0x5b, 0x52,
+	0x62, 0x66, 0x4e, 0x17, 0x6f, 0x81, 0x76, 0x72, 0xaa, 0x74, 0x67, 0x77, 0x8d, 0x13, 0xdf, 0xe1,
+	0xc1, 0x83, 0xb5, 0x27, 0x2f, 0x4c, 0xed, 0xe4, 0xf4, 0x6b, 0xc8, 0xad, 0x78, 0x1f, 0xae, 0xd8,
+	0x9e, 0xb4, 0xfc, 0x49, 0xee, 0x5d, 0xb0, 0x5c, 0xf4, 0x08, 0xfd, 0x2c, 0x73, 0x31, 0x6e, 0x43,
+	0xdd, 0x91, 0x5e, 0x62, 0x15, 0xf3, 0xaf, 0x7b, 0x91, 0x65, 0x7b, 0x72, 0x0b, 0xd1, 0x26, 0x53,
+	0x51, 0x77, 0x66, 0xa1, 0x50, 0x41, 0x77, 0x5e, 0x0c, 0x83, 0xf2, 0x77, 0x09, 0xc5, 0x77, 0x79,
+	0x07, 0xae, 0xca, 0xb3, 0x90, 0x0c, 0xc6, 0x24, 0x8b, 0xfc, 0xd9, 0x92, 0xf5, 0x53, 0xc2, 0xc3,
+	0x34, 0x03, 0xf0, 0x21, 0xaa, 0x0c, 0x7a, 0x34, 0x74, 0xcd, 0xed, 0x75, 0x41, 0x3a, 0xa7, 0xf4,
+	0x0c, 0xcd, 0xb4, 0xcb, 0x67, 0xb5, 0x56, 0xb3, 0xdf, 0x32, 0x6c, 0xa8, 0x3e, 0x79, 0xb1, 0x4f,
+	0x4a, 0x05, 0xf5, 0x7b, 0x9d, 0xdc, 0x01, 0x6a, 0x67, 0x8a, 0x46, 0x2b, 0x28, 0x9a, 0x5b, 0xac,
+	0xa3, 0x89, 0x07, 0x69, 0x5a, 0xb0, 0x80, 0xc1, 0x53, 0xb0, 0x7d, 0xaa, 0x71, 0xc6, 0x90, 0x00,
+	0xe3, 0xdf, 0xaa, 0xd0, 0x54, 0x2e, 0x04, 0xea, 0xe5, 0x59, 0x96, 0xd1, 0xc2, 0x66, 0x39, 0xb6,
+	0xcb, 0x7c, 0x91, 0x62, 0xf9, 0xa0, 0xfa, 0xfa, 0xf2, 0x81, 0xf8, 0x04, 0x3a, 0x21, 0xd3, 0x8a,
+	0xde, 0xcb, 0x1b, 0xc5, 0x31, 0xea, 0x97, 0xc6, 0xb5, 0xc3, 0x1c, 0x40, 0xd5, 0x44, 0xb9, 0xd5,
+	0xc4, 0x3a, 0x52, 0x1c, 0x68, 0x22, 0x3c, 0xb6, 0x8e, 0xbe, 0x92, 0x2b, 0xd2, 0x23, 0x9f, 0xa6,
+	0x43, 0x3a, 0x0d, 0xdd, 0x97, 0xa2, 0x47, 0xd0, 0x2d, 0x7b, 0x04, 0x37, 0x41, 0xb7, 0x83, 0xe9,
+	0xd4, 0x25, 0x5a, 0x4f, 0x65, 0x70, 0x08, 0x31, 0x8e, 0x8d, 0xdf, 0xae, 0x40, 0x53, 0x9d, 0xeb,
+	0x82, 0xbd, 0xd9, 0xdc, 0xde, 0xdd, 0x30, 0x7f, 0xd8, 0xaf, 0xa0, 0x3d, 0xdd, 0xde, 0x1d, 0xf7,
+	0x35, 0xa1, 0x43, 0xfd, 0xd1, 0xce, 0xde, 0xc6, 0xb8, 0x5f, 0x45, 0x1b, 0xb4, 0xb9, 0xb7, 0xb7,
+	0xd3, 0xaf, 0x89, 0x0e, 0xb4, 0xb6, 0x36, 0xc6, 0xa3, 0xf1, 0xf6, 0xd3, 0x51, 0xbf, 0x8e, 0x7d,
+	0x1f, 0x8f, 0xf6, 0xfa, 0x0d, 0x6c, 0x3c, 0xdf, 0xde, 0xea, 0x37, 0x91, 0xfe, 0x6c, 0x63, 0x7f,
+	0xff, 0xfb, 0x7b, 0xe6, 0x56, 0xbf, 0x45, 0x76, 0x6c, 0x6c, 0x6e, 0xef, 0x3e, 0xee, 0xeb, 0xd8,
+	0xde, 0xdb, 0xfc, 0x6c, 0xf4, 0x70, 0xdc, 0x07, 0xe3, 0x23, 0x68, 0x17, 0x78, 0x85, 0xa3, 0xcd,
+	0xd1, 0xa3, 0xfe, 0x12, 0x2e, 0xf9, 0x62, 0x63, 0xe7, 0x39, 0x9a, 0xbd, 0x1e, 0x00, 0x35, 0x27,
+	0x3b, 0x1b, 0xbb, 0x8f, 0xfb, 0x9a, 0x72, 0x9a, 0xbe, 0x07, 0xad, 0xe7, 0xae, 0xb3, 0xe9, 0x05,
+	0xf6, 0x09, 0x8a, 0xcf, 0x81, 0x15, 0x4b, 0x65, 0x67, 0xa8, 0x8d, 0x2e, 0x2a, 0xbd, 0x8b, 0x58,
+	0xdd, 0xb5, 0x82, 0x90, 0x63, 0xfe, 0x6c, 0x3a, 0xa1, 0x12, 0x53, 0x95, 0x6d, 0x83, 0x3f, 0x9b,
+	0x3e, 0x77, 0x9d, 0xd8, 0x38, 0x81, 0xe6, 0x73, 0xd7, 0x79, 0x66, 0xd9, 0x27, 0xa4, 0x3f, 0x70,
+	0xea, 0x49, 0xec, 0x7e, 0x2e, 0x95, 0x0d, 0xd1, 0x09, 0xb3, 0xef, 0x7e, 0x2e, 0xc5, 0xbb, 0xd0,
+	0x20, 0x20, 0x8d, 0xea, 0xe9, 0xa5, 0xa5, 0xdb, 0x31, 0x15, 0x8d, 0x2a, 0x3c, 0x9e, 0x17, 0xd8,
+	0x93, 0x48, 0x1e, 0x0e, 0xde, 0xe0, 0x1b, 0x20, 0x84, 0x29, 0x0f, 0x8d, 0xdf, 0xad, 0x64, 0x27,
+	0xa7, 0x02, 0xc3, 0x32, 0xd4, 0x42, 0xcb, 0x3e, 0x51, 0x26, 0xbc, 0xad, 0x26, 0xc4, 0xcd, 0x98,
+	0x44, 0x10, 0xef, 0x43, 0x4b, 0x09, 0x52, 0xba, 0x6a, 0xbb, 0x20, 0x71, 0x66, 0x46, 0x2c, 0x5f,
+	0x7c, 0xb5, 0x7c, 0xf1, 0x14, 0x00, 0x86, 0x9e, 0x9b, 0xf0, 0xb3, 0xa9, 0x99, 0x0a, 0x32, 0xbe,
+	0x0d, 0x90, 0xd7, 0x74, 0x16, 0x78, 0x34, 0xd7, 0xa1, 0x6e, 0x79, 0xae, 0x95, 0x06, 0x94, 0x0c,
+	0x18, 0xbb, 0xd0, 0x2e, 0x54, 0x82, 0x90, 0xb7, 0x96, 0xe7, 0xa1, 0xf1, 0x89, 0x69, 0x6c, 0xcb,
+	0x6c, 0x5a, 0x9e, 0xf7, 0x44, 0x9e, 0xc7, 0xe8, 0x4d, 0x72, 0x11, 0x49, 0x9b, 0xab, 0x3f, 0xd0,
+	0x50, 0x93, 0x89, 0xc6, 0x87, 0xd0, 0x78, 0x94, 0xfa, 0xdc, 0xe9, 0x63, 0xa8, 0x5c, 0xf6, 0x18,
+	0x8c, 0x8f, 0xd5, 0x9e, 0xa9, 0x84, 0x21, 0xee, 0xa8, 0x62, 0x55, 0xcc, 0xa5, 0xb1, 0x4a, 0x9e,
+	0x92, 0xe0, 0x4e, 0xaa, 0x4e, 0x45, 0x9d, 0x8d, 0x2d, 0x68, 0xbd, 0xb2, 0xfc, 0xa7, 0x18, 0xa0,
+	0xe5, 0x0c, 0x58, 0x50, 0x10, 0x34, 0x7e, 0x0c, 0x90, 0x17, 0xb5, 0xd4, 0xdb, 0xe4, 0x59, 0xf0,
+	0x6d, 0x7e, 0x00, 0x2d, 0xfb, 0xd8, 0xf5, 0x9c, 0x48, 0xfa, 0xa5, 0x53, 0xe7, 0x65, 0xb0, 0x8c,
+	0x2e, 0x56, 0xa0, 0x46, 0xb5, 0xba, 0x6a, 0xae, 0xb8, 0xb3, 0x42, 0x1d, 0x51, 0x8c, 0x33, 0xe8,
+	0xb2, 0x9b, 0xfe, 0x15, 0x9c, 0x9c, 0xb2, 0xea, 0xd4, 0x2e, 0xa8, 0xce, 0x1b, 0xd0, 0x20, 0xdb,
+	0x9a, 0x9e, 0x46, 0x41, 0x97, 0xa8, 0xd4, 0xdf, 0xd2, 0x00, 0x78, 0xe9, 0xdd, 0xc0, 0x91, 0xe5,
+	0x78, 0xb8, 0x32, 0x1f, 0x0f, 0x0b, 0xa8, 0x65, 0x65, 0x58, 0xdd, 0xa4, 0x76, 0x6e, 0x6f, 0x54,
+	0x8c, 0xcc, 0xf6, 0xe6, 0x4d, 0xd0, 0xc9, 0xd7, 0x71, 0x3f, 0xa7, 0xda, 0x00, 0x2e, 0x98, 0x23,
+	0x8a, 0x45, 0xc9, 0x7a, 0xb9, 0x28, 0x99, 0x55, 0x6e, 0x1a, 0x3c, 0x1b, 0x57, 0x6e, 0x16, 0x14,
+	0xa1, 0x38, 0x49, 0x11, 0xcb, 0x28, 0x49, 0x23, 0x6c, 0x86, 0xb2, 0x60, 0x51, 0x57, 0x7d, 0x2d,
+	0x4e, 0x33, 0xf8, 0xc1, 0xc4, 0x0e, 0xfc, 0x43, 0xcf, 0xb5, 0x13, 0x55, 0x84, 0x04, 0x3f, 0x78,
+	0xa8, 0x30, 0xc6, 0x27, 0xd0, 0x49, 0xf9, 0x4f, 0xb5, 0x9e, 0x0f, 0xb2, 0x40, 0xaa, 0x92, 0xdf,
+	0x6d, 0xce, 0xa6, 0x4d, 0x6d, 0x50, 0x49, 0x43, 0x29, 0xe3, 0x3f, 0xab, 0xe9, 0x60, 0x55, 0x92,
+	0x78, 0x35, 0x0f, 0xcb, 0xb1, 0xb1, 0xf6, 0x95, 0x62, 0xe3, 0xef, 0x80, 0xee, 0x50, 0xb8, 0xe7,
+	0x9e, 0xa6, 0x46, 0x6c, 0x38, 0x1f, 0xda, 0xa9, 0x80, 0xd0, 0x3d, 0x95, 0x66, 0xde, 0xf9, 0x35,
+	0xf7, 0x90, 0x71, 0xbb, 0xbe, 0x88, 0xdb, 0x8d, 0x5f, 0x91, 0xdb, 0x6f, 0x43, 0xc7, 0x0f, 0xfc,
+	0x89, 0x3f, 0xf3, 0x3c, 0xeb, 0xc0, 0x93, 0x8a, 0xdd, 0x6d, 0x3f, 0xf0, 0x77, 0x15, 0x0a, 0x1d,
+	0xd0, 0x62, 0x17, 0x7e, 0xd4, 0x6d, 0xea, 0x77, 0xa5, 0xd0, 0x8f, 0x9e, 0xfe, 0x2a, 0xf4, 0x83,
+	0x83, 0x1f, 0x4b, 0x3b, 0x21, 0x8e, 0x4d, 0xe8, 0x35, 0xb3, 0xf7, 0xd9, 0x63, 0x3c, 0xb2, 0x68,
+	0x17, 0xdf, 0xf5, 0xdc, 0x35, 0x77, 0x2f, 0x5c, 0xf3, 0xc7, 0xa0, 0x67, 0x5c, 0x2a, 0x84, 0x96,
+	0x3a, 0xd4, 0xb7, 0x77, 0xb7, 0x46, 0x3f, 0xe8, 0x57, 0xd0, 0x5c, 0x9a, 0xa3, 0x17, 0x23, 0x73,
+	0x7f, 0xd4, 0xd7, 0xd0, 0x94, 0x6d, 0x8d, 0x76, 0x46, 0xe3, 0x51, 0xbf, 0xca, 0x5e, 0x0e, 0x55,
+	0x06, 0x3c, 0xd7, 0x76, 0x13, 0x63, 0x1f, 0x20, 0x8f, 0x97, 0x51, 0x2b, 0xe7, 0x9b, 0x53, 0x09,
+	0xbb, 0x24, 0xdd, 0xd6, 0x6a, 0xf6, 0x20, 0xb5, 0xcb, 0xa2, 0x72, 0xa6, 0x1b, 0xeb, 0xa0, 0x3f,
+	0xb5, 0xc2, 0x4f, 0xb9, 0x86, 0x76, 0x1b, 0x7a, 0xa1, 0x15, 0x25, 0x6e, 0xea, 0xf2, 0xb3, 0xb2,
+	0xec, 0x98, 0xdd, 0x0c, 0x8b, 0xba, 0xd7, 0xf8, 0x8b, 0x0a, 0x5c, 0x7f, 0x1a, 0x9c, 0xca, 0xcc,
+	0xa5, 0x7c, 0x66, 0x9d, 0x7b, 0x81, 0xe5, 0xbc, 0x46, 0x0c, 0x31, 0x66, 0x09, 0x66, 0x54, 0xd3,
+	0x4a, 0x2b, 0x80, 0xa6, 0xce, 0x98, 0xc7, 0xea, 0x13, 0x05, 0x19, 0x27, 0x44, 0x54, 0x86, 0x14,
+	0x61, 0x24, 0x7d, 0x03, 0x1a, 0xc9, 0x99, 0x9f, 0xd7, 0x23, 0xeb, 0x09, 0x25, 0x9a, 0x17, 0x7a,
+	0x98, 0xf5, 0xc5, 0x1e, 0xa6, 0xf1, 0x10, 0xf4, 0xf1, 0x19, 0xa5, 0x5a, 0x67, 0x71, 0xc9, 0xcd,
+	0xa9, 0xbc, 0xc2, 0xcd, 0xd1, 0xe6, 0xdc, 0x9c, 0x7f, 0xad, 0x40, 0xbb, 0xe0, 0x2a, 0x8b, 0xb7,
+	0xa1, 0x96, 0x9c, 0xf9, 0xe5, 0xb2, 0x7f, 0xba, 0x88, 0x49, 0xa4, 0x0b, 0xe9, 0x44, 0xed, 0x42,
+	0x3a, 0x51, 0xec, 0xc0, 0x15, 0xd6, 0xbc, 0xe9, 0x21, 0xd2, 0xac, 0xcb, 0x3b, 0x73, 0xae, 0x39,
+	0xa7, 0xa3, 0xd3, 0x23, 0xa9, 0x54, 0x42, 0xef, 0xa8, 0x84, 0x1c, 0x6e, 0xc0, 0xb5, 0x05, 0xdd,
+	0xbe, 0x4e, 0x61, 0xc2, 0x58, 0x86, 0xee, 0xf8, 0xcc, 0x1f, 0xbb, 0x53, 0x19, 0x27, 0xd6, 0x34,
+	0x24, 0x37, 0x51, 0x59, 0xce, 0x9a, 0xa9, 0x25, 0xb1, 0xf1, 0x1e, 0x74, 0x9e, 0x49, 0x19, 0x99,
+	0x32, 0x0e, 0x03, 0x9f, 0x9d, 0x23, 0x95, 0x06, 0x66, 0x33, 0xad, 0x20, 0xe3, 0x37, 0x40, 0x37,
+	0xad, 0xc3, 0x64, 0xd3, 0x4a, 0xec, 0xe3, 0xaf, 0x93, 0x57, 0x78, 0x0f, 0x9a, 0x21, 0xcb, 0x94,
+	0x0a, 0xa0, 0x3a, 0x64, 0xae, 0x95, 0x9c, 0x99, 0x29, 0xd1, 0xf8, 0x08, 0xae, 0xed, 0xcf, 0x0e,
+	0x62, 0x3b, 0x72, 0x29, 0x16, 0x4d, 0x4d, 0xd9, 0x10, 0x5a, 0x61, 0x24, 0x0f, 0xdd, 0x33, 0x99,
+	0x4a, 0x70, 0x06, 0x1b, 0xdf, 0x85, 0xeb, 0xe5, 0x21, 0xea, 0x08, 0xef, 0x40, 0xf5, 0xe4, 0x34,
+	0x56, 0x3b, 0xbb, 0x5a, 0x8a, 0xc4, 0xa8, 0xda, 0x8e, 0x54, 0xe3, 0x4f, 0x2a, 0x50, 0xdd, 0x9d,
+	0x4d, 0x8b, 0x9f, 0x0c, 0xd5, 0xf8, 0x93, 0xa1, 0x9b, 0xc5, 0x2c, 0x2b, 0x87, 0x1d, 0x79, 0x36,
+	0xf5, 0x4d, 0xd0, 0x0f, 0x83, 0xe8, 0xa7, 0x56, 0xe4, 0x48, 0x47, 0x19, 0xad, 0x1c, 0x21, 0x6e,
+	0x2b, 0x13, 0xc7, 0x6e, 0xff, 0x55, 0x64, 0xca, 0xee, 0x6c, 0xba, 0xe6, 0x49, 0x2b, 0x26, 0x5d,
+	0xcc, 0x56, 0xcf, 0xb8, 0x03, 0x7a, 0x86, 0x42, 0xfd, 0xb1, 0xbb, 0x3f, 0xd9, 0xde, 0xe2, 0x2c,
+	0x15, 0x3a, 0xc8, 0x15, 0xd4, 0x1d, 0xe3, 0x1f, 0xec, 0x4e, 0xc6, 0xfb, 0x7d, 0xcd, 0xf8, 0x11,
+	0xb4, 0x53, 0xf1, 0xda, 0x76, 0xa8, 0x24, 0x43, 0xf2, 0xbd, 0xed, 0x94, 0xc4, 0x7d, 0x9b, 0x22,
+	0x18, 0xe9, 0x3b, 0xdb, 0xa9, 0x5c, 0x32, 0x50, 0x3e, 0x8d, 0xaa, 0xef, 0xa4, 0xa7, 0x31, 0x1e,
+	0x41, 0x27, 0x0d, 0x02, 0x9f, 0xca, 0xc4, 0xa2, 0x17, 0xe3, 0xb9, 0xd2, 0x2f, 0xbc, 0xa6, 0x16,
+	0x23, 0xc6, 0xe5, 0xec, 0xa3, 0x56, 0xf2, 0x2a, 0x8c, 0x35, 0x68, 0xa8, 0xe7, 0x28, 0xa0, 0x66,
+	0x07, 0x0e, 0xab, 0x8c, 0xba, 0x49, 0x6d, 0x64, 0xf1, 0x34, 0x3e, 0x4a, 0x3d, 0xa6, 0x69, 0x7c,
+	0x64, 0xfc, 0x95, 0x06, 0xdd, 0x4d, 0x0a, 0xb9, 0xd3, 0x7b, 0x2e, 0x24, 0x9a, 0x2a, 0xa5, 0x44,
+	0x53, 0x31, 0xa9, 0xa4, 0x95, 0x92, 0x4a, 0xa5, 0x0d, 0x55, 0xcb, 0x6e, 0xce, 0x1b, 0xd0, 0x9c,
+	0xf9, 0xee, 0x59, 0xaa, 0x67, 0x74, 0xb3, 0x81, 0xe0, 0x38, 0x16, 0x2b, 0xd0, 0x46, 0x55, 0xe4,
+	0xfa, 0x9c, 0xc8, 0xe1, 0x6c, 0x4c, 0x11, 0x35, 0x97, 0xae, 0x69, 0xbc, 0x3a, 0x5d, 0xd3, 0x7c,
+	0x6d, 0xba, 0xa6, 0xf5, 0xba, 0x74, 0x8d, 0x3e, 0x9f, 0xae, 0x29, 0xbb, 0x68, 0x30, 0xef, 0xa2,
+	0x19, 0x3b, 0xd0, 0x4b, 0x79, 0xa7, 0x04, 0xfe, 0x13, 0xb8, 0xa2, 0x32, 0xad, 0x32, 0x52, 0xc9,
+	0x0a, 0x56, 0x63, 0x24, 0x81, 0x9c, 0x0c, 0x55, 0x14, 0xb3, 0xe7, 0x14, 0xc1, 0xd8, 0xf8, 0x9d,
+	0x0a, 0x74, 0x4b, 0x3d, 0xc4, 0x47, 0x79, 0xde, 0xb6, 0x42, 0x72, 0x3c, 0xb8, 0x30, 0xcb, 0xab,
+	0x73, 0xb7, 0xda, 0x5c, 0xee, 0xd6, 0xb8, 0x9d, 0x65, 0x64, 0x55, 0x1e, 0x76, 0x29, 0xcb, 0xc3,
+	0x52, 0xea, 0x72, 0x63, 0x3c, 0x36, 0xfb, 0x9a, 0xf1, 0x73, 0x0d, 0xba, 0xa3, 0xb3, 0x90, 0x3e,
+	0x9a, 0x79, 0xad, 0x23, 0x5b, 0x10, 0x18, 0xad, 0x24, 0x30, 0x85, 0xab, 0xaf, 0xaa, 0x02, 0x14,
+	0x5f, 0x3d, 0xba, 0xb6, 0x9c, 0x15, 0x52, 0x22, 0xc1, 0xd0, 0xff, 0x05, 0x91, 0x28, 0x95, 0x10,
+	0x60, 0xbe, 0x84, 0xb0, 0x03, 0xbd, 0x94, 0x6d, 0x4a, 0x20, 0xbe, 0xd2, 0x2b, 0xe4, 0xcf, 0xe1,
+	0xbc, 0x2c, 0x83, 0xc2, 0x80, 0xf1, 0xa7, 0x1a, 0xe8, 0x2c, 0x5f, 0xb8, 0xf9, 0x6f, 0x29, 0x8d,
+	0x56, 0xc9, 0xb3, 0xd5, 0x19, 0x71, 0xed, 0x89, 0x3c, 0xcf, 0xb5, 0xda, 0xc2, 0x0a, 0x8f, 0xca,
+	0xb3, 0x70, 0xa8, 0x49, 0x79, 0x96, 0x9b, 0xa0, 0xb3, 0xbd, 0x9e, 0xa9, 0x54, 0x69, 0xcd, 0x64,
+	0x03, 0xfe, 0xdc, 0xa5, 0x5a, 0x4d, 0x22, 0xa3, 0xa9, 0xba, 0x03, 0x6a, 0x97, 0x9d, 0xfa, 0x6e,
+	0xea, 0x66, 0x96, 0x38, 0xd2, 0x9c, 0xe7, 0xc8, 0x31, 0x34, 0xd5, 0xde, 0xd0, 0x27, 0x7b, 0xbe,
+	0xfb, 0x64, 0x77, 0xef, 0xfb, 0xbb, 0x25, 0xa9, 0xcb, 0xbc, 0x36, 0xad, 0xe8, 0xb5, 0x55, 0x11,
+	0xff, 0x70, 0xef, 0xf9, 0xee, 0xb8, 0x5f, 0x13, 0x5d, 0xd0, 0xa9, 0x39, 0x31, 0x47, 0x2f, 0xfa,
+	0x75, 0x4a, 0x53, 0x3c, 0xfc, 0x74, 0xf4, 0x74, 0xa3, 0xdf, 0xc8, 0x6a, 0x07, 0x4d, 0xe3, 0x8f,
+	0x2b, 0x70, 0x95, 0x19, 0x52, 0x8c, 0xd8, 0x8b, 0x1f, 0xaa, 0xd6, 0xf8, 0x43, 0xd5, 0xff, 0xdd,
+	0x20, 0x1d, 0x07, 0xcd, 0xdc, 0xb4, 0x5a, 0xc7, 0xd9, 0xa3, 0xd6, 0xcc, 0x55, 0x45, 0xba, 0xbf,
+	0xad, 0xc0, 0x90, 0x9d, 0xc5, 0xc7, 0x91, 0x15, 0x1e, 0x7f, 0x6f, 0xe7, 0x42, 0xb8, 0x78, 0x99,
+	0x0b, 0x75, 0x1b, 0x7a, 0xf4, 0x29, 0xef, 0x4f, 0xbc, 0x89, 0x0a, 0x69, 0xf8, 0x76, 0xbb, 0x0a,
+	0xcb, 0x13, 0x89, 0x07, 0xd0, 0xe1, 0x4f, 0x7e, 0x29, 0x63, 0x59, 0xaa, 0x34, 0x95, 0x5c, 0xd5,
+	0x36, 0xf7, 0xe2, 0xba, 0xd8, 0x47, 0xd9, 0xa0, 0x3c, 0xb2, 0xbc, 0x58, 0x4c, 0x52, 0x43, 0xc6,
+	0x14, 0x6f, 0xde, 0x83, 0x9b, 0x0b, 0xcf, 0xa1, 0xc4, 0xbe, 0x90, 0xd5, 0x63, 0x69, 0x33, 0x7e,
+	0x5e, 0x81, 0xd6, 0xe6, 0xcc, 0x3b, 0x21, 0xeb, 0xf6, 0x16, 0x80, 0x74, 0x8e, 0xa4, 0xfa, 0x76,
+	0xb6, 0x42, 0xca, 0x41, 0x47, 0x0c, 0x7f, 0x3d, 0xfb, 0x09, 0x00, 0x9f, 0x71, 0x32, 0xb5, 0x42,
+	0x75, 0x45, 0x54, 0xf9, 0x49, 0x27, 0x50, 0x67, 0x79, 0x6a, 0x85, 0xaa, 0xf2, 0x13, 0xa7, 0xf0,
+	0x70, 0x17, 0x7a, 0x65, 0xe2, 0x82, 0x3c, 0xc9, 0x7b, 0xe5, 0xef, 0x09, 0x2e, 0x72, 0x27, 0x77,
+	0xdb, 0xd6, 0xff, 0xa6, 0x02, 0x35, 0x74, 0xa7, 0xc4, 0x5d, 0xd0, 0x3f, 0x95, 0x56, 0x94, 0x1c,
+	0x48, 0x2b, 0x11, 0x25, 0xd7, 0x69, 0x48, 0x9c, 0xca, 0xcb, 0xfe, 0xc6, 0xd2, 0xfd, 0x8a, 0x58,
+	0xe3, 0x8f, 0x07, 0xd3, 0x8f, 0x22, 0xbb, 0xa9, 0x5b, 0x46, 0x6e, 0xdb, 0xb0, 0x34, 0xde, 0x58,
+	0x5a, 0xa5, 0xfe, 0x9f, 0x05, 0xae, 0xff, 0x90, 0x3f, 0x59, 0x13, 0xf3, 0x6e, 0xdc, 0xfc, 0x08,
+	0x71, 0x17, 0x1a, 0xdb, 0x31, 0xfa, 0x8b, 0x17, 0xbb, 0xd2, 0x79, 0x8a, 0xae, 0xa4, 0xb1, 0xb4,
+	0xfe, 0x67, 0x55, 0xa8, 0xfd, 0x48, 0x46, 0x81, 0xf8, 0x10, 0x9a, 0xea, 0x23, 0x09, 0x51, 0xf8,
+	0x18, 0x62, 0x48, 0xa1, 0xeb, 0xdc, 0xd7, 0x13, 0xb4, 0x4a, 0x9f, 0x59, 0x92, 0xe7, 0xc7, 0x45,
+	0xfe, 0x0d, 0xc7, 0x85, 0x4d, 0x7d, 0x0c, 0xfd, 0xfd, 0x24, 0x92, 0xd6, 0xb4, 0xd0, 0xbd, 0xcc,
+	0xaa, 0x45, 0xc9, 0x76, 0xe2, 0xd7, 0x1d, 0x68, 0xb0, 0x53, 0x3e, 0x37, 0x60, 0x3e, 0x93, 0x4e,
+	0x9d, 0xdf, 0x87, 0xf6, 0xfe, 0x71, 0x30, 0xf3, 0x9c, 0x7d, 0x19, 0x9d, 0x4a, 0x51, 0xf8, 0x78,
+	0x6a, 0x58, 0x68, 0x1b, 0x4b, 0xe2, 0x7d, 0xd0, 0xd9, 0x65, 0x43, 0x87, 0xad, 0xa9, 0xbc, 0x40,
+	0x9e, 0xb3, 0xe0, 0xca, 0x19, 0x4b, 0x62, 0x15, 0xa0, 0xe0, 0x9a, 0xbf, 0xaa, 0xe7, 0x03, 0xe8,
+	0x3e, 0x24, 0x1d, 0xb0, 0x17, 0x6d, 0x1c, 0x04, 0x51, 0x22, 0xe6, 0xbf, 0x96, 0x1a, 0xce, 0x23,
+	0x8c, 0x25, 0x71, 0x1f, 0x5a, 0xe3, 0xe8, 0x9c, 0xfb, 0x5f, 0x55, 0x11, 0x4d, 0xbe, 0xde, 0x82,
+	0x43, 0xae, 0xff, 0x57, 0x0d, 0x1a, 0xdf, 0x0f, 0xa2, 0x13, 0x19, 0x89, 0x0f, 0xa0, 0x41, 0x65,
+	0x0e, 0x25, 0x45, 0x59, 0xc9, 0x63, 0xd1, 0x42, 0xef, 0x82, 0x4e, 0x3c, 0x19, 0x5b, 0xf1, 0x09,
+	0xdf, 0x14, 0x7d, 0xf2, 0xce, 0x6c, 0xe1, 0xac, 0x08, 0x5d, 0x6b, 0x8f, 0xef, 0x29, 0x2b, 0x03,
+	0x96, 0xca, 0x10, 0x43, 0x3a, 0xff, 0x93, 0x17, 0xfb, 0x28, 0x99, 0xf7, 0x2b, 0x68, 0x7a, 0xf6,
+	0xf9, 0xa4, 0xd8, 0x29, 0xff, 0xd4, 0x97, 0x05, 0x3f, 0xff, 0xb6, 0xd6, 0x58, 0x12, 0xf7, 0xa0,
+	0xa1, 0x34, 0xd1, 0xd5, 0xfc, 0x55, 0x29, 0xf5, 0x36, 0xec, 0x17, 0x51, 0x6a, 0xc0, 0x47, 0xd0,
+	0x60, 0xad, 0xcd, 0x03, 0x4a, 0xbe, 0xe8, 0x50, 0x14, 0x51, 0xa9, 0x2c, 0x8b, 0x3b, 0xd0, 0x54,
+	0x45, 0x0c, 0xb1, 0xa0, 0xa2, 0xc1, 0x47, 0x65, 0x27, 0x98, 0xe7, 0x67, 0x93, 0xcc, 0xf3, 0x97,
+	0xbc, 0x1a, 0x9e, 0xbf, 0x6c, 0xb1, 0x59, 0xe8, 0x4d, 0x69, 0x4b, 0xb7, 0x10, 0x8c, 0x8b, 0x94,
+	0x23, 0x0b, 0x5e, 0xee, 0xc7, 0xd0, 0x2d, 0x05, 0xee, 0x82, 0xbc, 0xb4, 0x45, 0xb1, 0xfc, 0x85,
+	0xf7, 0xf2, 0x5d, 0xd0, 0x55, 0xdc, 0x74, 0x20, 0x05, 0xd5, 0x26, 0x16, 0x44, 0x5e, 0xc3, 0x8b,
+	0x81, 0x13, 0x3d, 0x82, 0x1f, 0xc0, 0xb5, 0x05, 0x2a, 0x58, 0xd0, 0x47, 0x68, 0x97, 0xdb, 0x98,
+	0xe1, 0xf2, 0xa5, 0xf4, 0x94, 0x01, 0x9b, 0x83, 0xbf, 0xfb, 0xf2, 0x56, 0xe5, 0x17, 0x5f, 0xde,
+	0xaa, 0xfc, 0xcb, 0x97, 0xb7, 0x2a, 0xbf, 0xf7, 0xcb, 0x5b, 0x4b, 0xbf, 0xf8, 0xe5, 0xad, 0xa5,
+	0x7f, 0xfc, 0xe5, 0xad, 0xa5, 0x83, 0x06, 0xfd, 0x0d, 0xe4, 0xc1, 0x7f, 0x07, 0x00, 0x00, 0xff,
+	0xff, 0x62, 0xc5, 0xef, 0xad, 0x7c, 0x32, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -8086,6 +8078,11 @@ func (m *DirectedEdge) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.Namespace != 0 {
+		i = encodeVarintPb(dAtA, i, uint64(m.Namespace))
+		i--
+		dAtA[i] = 0x58
+	}
 	if len(m.AllowedPreds) > 0 {
 		for iNdEx := len(m.AllowedPreds) - 1; iNdEx >= 0; iNdEx-- {
 			i -= len(m.AllowedPreds[iNdEx])
@@ -8121,13 +8118,6 @@ func (m *DirectedEdge) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x3a
 	}
-	if len(m.Label) > 0 {
-		i -= len(m.Label)
-		copy(dAtA[i:], m.Label)
-		i = encodeVarintPb(dAtA, i, uint64(len(m.Label)))
-		i--
-		dAtA[i] = 0x32
-	}
 	if m.ValueId != 0 {
 		i -= 8
 		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.ValueId))
@@ -8761,13 +8751,6 @@ func (m *Posting) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA[i] = 0x4a
 		}
 	}
-	if len(m.Label) > 0 {
-		i -= len(m.Label)
-		copy(dAtA[i:], m.Label)
-		i = encodeVarintPb(dAtA, i, uint64(len(m.Label)))
-		i--
-		dAtA[i] = 0x32
-	}
 	if len(m.LangTag) > 0 {
 		i -= len(m.LangTag)
 		copy(dAtA[i:], m.LangTag)
@@ -11345,10 +11328,6 @@ func (m *DirectedEdge) Size() (n int) {
 	if m.ValueId != 0 {
 		n += 9
 	}
-	l = len(m.Label)
-	if l > 0 {
-		n += 1 + l + sovPb(uint64(l))
-	}
 	l = len(m.Lang)
 	if l > 0 {
 		n += 1 + l + sovPb(uint64(l))
@@ -11368,6 +11347,9 @@ func (m *DirectedEdge) Size() (n int) {
 			n += 1 + l + sovPb(uint64(l))
 		}
 	}
+	if m.Namespace != 0 {
+		n += 1 + sovPb(uint64(m.Namespace))
+	}
 	return n
 }
 
@@ -11641,10 +11623,6 @@ func (m *Posting) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovPb(uint64(l))
 	}
-	l = len(m.Label)
-	if l > 0 {
-		n += 1 + l + sovPb(uint64(l))
-	}
 	if len(m.Facets) > 0 {
 		for _, e := range m.Facets {
 			l = e.Size()
@@ -16734,38 +16712,6 @@ func (m *DirectedEdge) Unmarshal(dAtA []byte) error {
 			}
 			m.ValueId = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
 			iNdEx += 8
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Label", 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.Label = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		case 7:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Lang", wireType)
@@ -16883,6 +16829,25 @@ func (m *DirectedEdge) Unmarshal(dAtA []byte) error {
 			}
 			m.AllowedPreds = append(m.AllowedPreds, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
+		case 11:
+			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
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPb(dAtA[iNdEx:])
@@ -18789,38 +18754,6 @@ func (m *Posting) Unmarshal(dAtA []byte) error {
 				m.LangTag = []byte{}
 			}
 			iNdEx = postIndex
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Label", 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.Label = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		case 9:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Facets", wireType)
diff --git a/worker/export.go b/worker/export.go
index af7bad5b3ca..472ad6203b5 100644
--- a/worker/export.go
+++ b/worker/export.go
@@ -240,7 +240,6 @@ func (e *exporter) toRDF() (*bpb.KVList, error) {
 				fmt.Fprint(bp, "^^<"+rdfType+">")
 			}
 		}
-		// Let's skip labels. Dgraph doesn't support them for any functionality.
 		// Use label for storing namespace.
 		fmt.Fprintf(bp, " <%#x>", e.namespace)
 
@@ -609,6 +608,7 @@ func exportInternal(ctx context.Context, in *pb.ExportRequest, db *badger.DB,
 			return false
 		}
 
+		fmt.Println(pk)
 		// Do not pick keys storing parts of a multi-part list. They will be read
 		// from the main key.
 		if pk.HasStartUid {
@@ -626,7 +626,6 @@ func exportInternal(ctx context.Context, in *pb.ExportRequest, db *badger.DB,
 				return false
 			}
 		}
-
 		return pk.IsData()
 	}
 	stream.KeyToList = func(key []byte, itr *badger.Iterator) (*bpb.KVList, error) {
diff --git a/worker/export_test.go b/worker/export_test.go
index 1ba4980ca5a..0b3c90c2d19 100644
--- a/worker/export_test.go
+++ b/worker/export_test.go
@@ -88,9 +88,15 @@ func populateGraphExport(t *testing.T) {
 		fmt.Sprintf("<8> <dgraph.graphql.schema> \"%s\" .", gqlSchema),
 		`<8> <dgraph.graphql.xid> "dgraph.graphql.schema" .`,
 		`<8> <dgraph.type> "dgraph.graphql" .`,
+		`<9> <name> "ns2" <0x2> .`,
+		`<10> <name> "ns2_node_to_delete" <0x2> .`,
 	}
 	// This triplet will be deleted to ensure deleted nodes do not affect the output of the export.
-	edgeToDelete := `<7> <name> "node_to_delete" .`
+	edgesToDelete := []string{
+		`<7> <name> "node_to_delete" .`,
+		`<10> <name> "ns2_node_to_delete" <0x2> .`,
+	}
+
 	idMap := map[string]uint64{
 		"1": 1,
 		"2": 2,
@@ -109,7 +115,7 @@ func populateGraphExport(t *testing.T) {
 		err = facets.SortAndValidate(rnq.Facets)
 		require.NoError(t, err)
 		e, err := rnq.ToEdgeUsing(idMap)
-		e.Attr = testutil.DefaultNamespaceAttr(e.Attr)
+		e.Attr = x.NamespaceAttr(nq.Namespace, e.Attr)
 		require.NoError(t, err)
 		if set {
 			addEdge(t, e, getOrCreate(x.DataKey(e.Attr, e.Entity)))
@@ -121,7 +127,9 @@ func populateGraphExport(t *testing.T) {
 	for _, edge := range rdfEdges {
 		processEdge(edge, true)
 	}
-	processEdge(edgeToDelete, false)
+	for _, edge := range edgesToDelete {
+		processEdge(edge, false)
+	}
 }
 
 func initTestExport(t *testing.T, schemaStr string) {
@@ -228,6 +236,7 @@ func TestExportRdf(t *testing.T) {
 	initTestExport(t, `
 		name: string @index(exact) .
 		age: int .
+		[0x2] name: string @index(exact) .
 		`)
 
 	bdir, err := ioutil.TempDir("", "export")
@@ -241,7 +250,8 @@ func TestExportRdf(t *testing.T) {
 	readTs := timestamp()
 	// Do the following so export won't block forever for readTs.
 	posting.Oracle().ProcessDelta(&pb.OracleDelta{MaxAssigned: readTs})
-	files, err := export(context.Background(), &pb.ExportRequest{ReadTs: readTs, GroupId: 1, Format: "rdf"})
+	files, err := export(context.Background(), &pb.ExportRequest{ReadTs: readTs, GroupId: 1,
+		Namespace: math.MaxUint64, Format: "rdf"})
 	require.NoError(t, err)
 
 	fileList, schemaFileList, gqlSchema := getExportFileList(t, bdir)
@@ -261,7 +271,7 @@ func TestExportRdf(t *testing.T) {
 	for scanner.Scan() {
 		nq, err := chunker.ParseRDF(scanner.Text(), l)
 		require.NoError(t, err)
-		require.Contains(t, []string{"0x1", "0x2", "0x3", "0x4", "0x5", "0x6"}, nq.Subject)
+		require.Contains(t, []string{"0x1", "0x2", "0x3", "0x4", "0x5", "0x6", "0x9"}, nq.Subject)
 		if nq.ObjectValue != nil {
 			switch nq.Subject {
 			case "0x1", "0x2":
@@ -276,6 +286,8 @@ func TestExportRdf(t *testing.T) {
 			case "0x6":
 				require.Equal(t, `<0x6> <name> "Ding!\u0007Ding!\u0007Ding!\u0007" <0x0> .`,
 					scanner.Text())
+			case "0x9":
+				require.Equal(t, `<0x9> <name> "ns2" <0x2> .`, scanner.Text())
 			default:
 				t.Errorf("Unexpected subject: %v", nq.Subject)
 			}
@@ -326,7 +338,8 @@ func TestExportRdf(t *testing.T) {
 
 func TestExportJson(t *testing.T) {
 	// Index the name predicate. We ensure it doesn't show up on export.
-	initTestExport(t, `name: string @index(exact) .`)
+	initTestExport(t, `name: string @index(exact) .
+				 [0x2] name: string @index(exact) .`)
 
 	bdir, err := ioutil.TempDir("", "export")
 	require.NoError(t, err)
@@ -365,7 +378,8 @@ func TestExportJson(t *testing.T) {
 		{"uid":"0x3","namespace":"0x0","friend":[{"uid":"0x5"}]},
 		{"uid":"0x4","namespace":"0x0","friend":[{"uid":"0x5"}],"friend|age":33,
 			"friend|close":"true","friend|game":"football",
-			"friend|poem":"roses are red\nviolets are blue","friend|since":"2005-05-02T15:04:05Z"}
+			"friend|poem":"roses are red\nviolets are blue","friend|since":"2005-05-02T15:04:05Z"},
+		{"uid":"0x9","namespace":"0x2","name":"ns2"}
 	]
 	`
 	gotJson, err := ioutil.ReadAll(r)
diff --git a/worker/mutation_test.go b/worker/mutation_test.go
index dd12c7e271a..0010d68fb98 100644
--- a/worker/mutation_test.go
+++ b/worker/mutation_test.go
@@ -38,14 +38,12 @@ func TestConvertEdgeType(t *testing.T) {
 		{
 			input: &pb.DirectedEdge{
 				Value: []byte("set edge"),
-				Label: "test-mutation",
 				Attr:  "name",
 			},
 			to:        types.StringID,
 			expectErr: false,
 			output: &pb.DirectedEdge{
 				Value:     []byte("set edge"),
-				Label:     "test-mutation",
 				Attr:      "name",
 				ValueType: 9,
 			},
@@ -53,7 +51,6 @@ func TestConvertEdgeType(t *testing.T) {
 		{
 			input: &pb.DirectedEdge{
 				Value: []byte("set edge"),
-				Label: "test-mutation",
 				Attr:  "name",
 				Op:    pb.DirectedEdge_DEL,
 			},
@@ -61,7 +58,6 @@ func TestConvertEdgeType(t *testing.T) {
 			expectErr: false,
 			output: &pb.DirectedEdge{
 				Value:     []byte("set edge"),
-				Label:     "test-mutation",
 				Attr:      "name",
 				Op:        pb.DirectedEdge_DEL,
 				ValueType: 9,
@@ -70,7 +66,6 @@ func TestConvertEdgeType(t *testing.T) {
 		{
 			input: &pb.DirectedEdge{
 				ValueId: 123,
-				Label:   "test-mutation",
 				Attr:    "name",
 			},
 			to:        types.StringID,
@@ -79,7 +74,6 @@ func TestConvertEdgeType(t *testing.T) {
 		{
 			input: &pb.DirectedEdge{
 				Value: []byte("set edge"),
-				Label: "test-mutation",
 				Attr:  "name",
 			},
 			to:        types.UidID,
@@ -105,7 +99,6 @@ func TestConvertEdgeType(t *testing.T) {
 func TestValidateEdgeTypeError(t *testing.T) {
 	edge := &pb.DirectedEdge{
 		Value: []byte("set edge"),
-		Label: "test-mutation",
 		Attr:  "name",
 	}
 
@@ -119,7 +112,6 @@ func TestValidateEdgeTypeError(t *testing.T) {
 func TestPopulateMutationMap(t *testing.T) {
 	edges := []*pb.DirectedEdge{{
 		Value: []byte("set edge"),
-		Label: "test-mutation",
 	}}
 	schema := []*pb.SchemaUpdate{{
 		Predicate: "name",
diff --git a/worker/worker_test.go b/worker/worker_test.go
index cfb40f3c97f..45a6a7b0109 100644
--- a/worker/worker_test.go
+++ b/worker/worker_test.go
@@ -101,7 +101,6 @@ func populateGraph(t *testing.T) {
 	// Add uid edges : predicate neightbour.
 	edge := &pb.DirectedEdge{
 		ValueId: 23,
-		Label:   "author0",
 		Attr:    "neighbour",
 	}
 	edge.Entity = 10
@@ -366,15 +365,17 @@ func TestMain(m *testing.M) {
 	gr = new(groupi)
 	gr.gid = 1
 	gr.tablets = make(map[string]*pb.Tablet)
-	addTablets := func(attrs []string, gid uint32) {
+	addTablets := func(attrs []string, gid uint32, namespace uint64) {
 		for _, attr := range attrs {
-			gr.tablets[x.NamespaceAttr(x.DefaultNamespace, attr)] = &pb.Tablet{GroupId: gid}
+			gr.tablets[x.NamespaceAttr(namespace, attr)] = &pb.Tablet{GroupId: gid}
 		}
 	}
 
 	addTablets([]string{"name", "name2", "age", "http://www.w3.org/2000/01/rdf-schema#range", "",
-		"friend", "dgraph.type", "dgraph.graphql.xid", "dgraph.graphql.schema"}, 1)
-	addTablets([]string{"friend_not_served"}, 2)
+		"friend", "dgraph.type", "dgraph.graphql.xid", "dgraph.graphql.schema"},
+		1, x.DefaultNamespace)
+	addTablets([]string{"friend_not_served"}, 2, x.DefaultNamespace)
+	addTablets([]string{"name"}, 1, 0x2)
 
 	dir, err := ioutil.TempDir("", "storetest_")
 	x.Check(err)

From c1ae74f8198438badb9f22807da3c801f40c9bfa Mon Sep 17 00:00:00 2001
From: NamanJain8 <jnaman806@gmail.com>
Date: Mon, 8 Feb 2021 16:34:40 +0530
Subject: [PATCH 7/7] use updated dgo

---
 go.mod |  5 ++---
 go.sum | 16 ++++++++++++++--
 x/x.go |  2 +-
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/go.mod b/go.mod
index 9949e6bbb6a..1985ac1432c 100644
--- a/go.mod
+++ b/go.mod
@@ -2,8 +2,6 @@ module github.com/dgraph-io/dgraph
 
 go 1.12
 
-replace github.com/dgraph-io/dgo/v200 => /home/algod/go/src/github.com/dgraph-io/dgo
-
 // replace github.com/dgraph-io/badger/v2 => /home/mrjn/go/src/github.com/dgraph-io/badger
 // replace github.com/dgraph-io/ristretto => /home/mrjn/go/src/github.com/dgraph-io/ristretto
 
@@ -19,7 +17,7 @@ require (
 	github.com/blevesearch/bleve v1.0.13
 	github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd
 	github.com/dgraph-io/badger/v3 v3.0.0-20210125092849-88bf5aab9f50
-	github.com/dgraph-io/dgo/v200 v200.0.0-20210125093441-2ab429259580
+	github.com/dgraph-io/dgo/v200 v200.0.0-20210208110130-c589adec3d8f
 	github.com/dgraph-io/gqlgen v0.13.2
 	github.com/dgraph-io/gqlparser/v2 v2.1.4
 	github.com/dgraph-io/graphql-transport-ws v0.0.0-20200916064635-48589439591b
@@ -69,6 +67,7 @@ require (
 	golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9
 	golang.org/x/sys v0.0.0-20210105210732-16f7687f5001
 	golang.org/x/text v0.3.3
+	golang.org/x/tools v0.0.0-20210106214847-113979e3529a
 	google.golang.org/grpc v1.27.0
 	gopkg.in/DataDog/dd-trace-go.v1 v1.13.1 // indirect
 	gopkg.in/square/go-jose.v2 v2.3.1
diff --git a/go.sum b/go.sum
index a14161e8806..0213cf79660 100644
--- a/go.sum
+++ b/go.sum
@@ -83,6 +83,7 @@ github.com/blevesearch/zap/v13 v13.0.5/go.mod h1:HTfWECmzBN7BbdBxdEigpUsD6MOPFOO
 github.com/blevesearch/zap/v14 v14.0.4/go.mod h1:sTwuFoe1n/+VtaHNAjY3W5GzHZ5UxFkw1MZ82P/WKpA=
 github.com/blevesearch/zap/v15 v15.0.2/go.mod h1:nfycXPgfbio8l+ZSkXUkhSNjTpp57jZ0/MKa6TigWvM=
 github.com/cenkalti/backoff v2.1.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
@@ -116,8 +117,8 @@ github.com/dgraph-io/badger v1.6.0 h1:DshxFxZWXUcO0xX476VJC07Xsr6ZCBVRHKZ93Oh7Ev
 github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4=
 github.com/dgraph-io/badger/v3 v3.0.0-20210125092849-88bf5aab9f50 h1:Wu6wyQIBjESBZWt6lSLMWH37h63MxH6jdsPKOog6CNY=
 github.com/dgraph-io/badger/v3 v3.0.0-20210125092849-88bf5aab9f50/go.mod h1:pT2S4DGi7y9kA1WsiB2cv+X+g1Q+SQLt9x83sGIG/Qc=
-github.com/dgraph-io/dgo/v200 v200.0.0-20210125093441-2ab429259580 h1:ZdOpRE98+fV+z9dPAixXX+LsRTFKYxqQbacc9yT4MQs=
-github.com/dgraph-io/dgo/v200 v200.0.0-20210125093441-2ab429259580/go.mod h1:1LUTb0AVUKsPQhajQinkz2TnpIrD2C1yFNtVgk5lW5A=
+github.com/dgraph-io/dgo/v200 v200.0.0-20210208110130-c589adec3d8f h1:XZRsTllGQWUu0SpAb8mGW9motF0KmD7f6UEKa7y2grE=
+github.com/dgraph-io/dgo/v200 v200.0.0-20210208110130-c589adec3d8f/go.mod h1:ky1IOcEAlOxmk89KxXGECgRAEkdJrNHVymvCmixaVuM=
 github.com/dgraph-io/gqlgen v0.13.2 h1:TNhndk+eHKj5qE7BenKKSYdSIdOGhLqxR1rCiMso9KM=
 github.com/dgraph-io/gqlgen v0.13.2/go.mod h1:iCOrOv9lngN7KAo+jMgvUPVDlYHdf7qDwsTkQby2Sis=
 github.com/dgraph-io/gqlparser/v2 v2.1.1/go.mod h1:MYS4jppjyx8b9tuUtjV7jU1UFZK6P9fvO8TsIsQtRKU=
@@ -156,6 +157,8 @@ github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5m
 github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
 github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
 github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
@@ -471,6 +474,8 @@ github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 h1:S/YWwWx/RA8rT8tKFRuGUZhuA90OyIBpPCXkcbwU8DE=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4 h1:gQz4mCbXsO+nc9n1hCxHcGA3Zx3Eo+UHZoInFGUIXNM=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/common v0.0.0-20180518154759-7600349dcfe1/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.0.0-20181126121408-4724e9255275/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
@@ -785,6 +790,8 @@ google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98
 google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
 google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a h1:Ob5/580gVHBJZgXnff1cZDbG+xLtMVE5mDRTe+nIsX4=
 google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 h1:+kGHl1aib/qcwaRi1CbqBZ1rk19r85MNUf8HaBghugY=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
@@ -793,6 +800,8 @@ google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ij
 google.golang.org/grpc v1.22.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.23.0 h1:AzbTB6ux+okLTzP8Ru1Xs41C303zdcfEht7MQnYJt5A=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.27.0 h1:rRYRFMVgRv6E0D70Skyfsr28tDXIuuPZyWGMPdMcnXg=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -800,6 +809,9 @@ google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miE
 google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
 google.golang.org/protobuf v1.22.0 h1:cJv5/xdbk1NnMPR1VP9+HU6gupuG9MLBoH1r6RHZ2MY=
 google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 gopkg.in/DataDog/dd-trace-go.v1 v1.13.1 h1:oTzOClfuudNhW9Skkp2jxjqYO92uDKXqKLbiuPA13Rk=
 gopkg.in/DataDog/dd-trace-go.v1 v1.13.1/go.mod h1:DVp8HmDh8PuTu2Z0fVVlBsyWaC++fzwVCaGWylTe3tg=
 gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
diff --git a/x/x.go b/x/x.go
index c28941b5011..1bdc5b0bd02 100644
--- a/x/x.go
+++ b/x/x.go
@@ -1019,7 +1019,7 @@ func GetPassAndLogin(dg *dgo.Dgraph, opt *CredOpt) error {
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
-	if err := dg.Login(ctx, opt.UserID, password); err != nil {
+	if err := dg.Login(ctx, opt.UserID, password, DefaultNamespace); err != nil {
 		return errors.Wrapf(err, "unable to login to the %v account", opt.UserID)
 	}
 	fmt.Println("Login successful.")