diff --git a/dgraph/cmd/zero/zero.go b/dgraph/cmd/zero/zero.go
index 79972164903..51febe48c40 100644
--- a/dgraph/cmd/zero/zero.go
+++ b/dgraph/cmd/zero/zero.go
@@ -535,7 +535,7 @@ func (s *Server) ShouldServe(
 	if len(tablet.Predicate) == 0 {
 		return resp, x.Errorf("Tablet predicate is empty in %+v", tablet)
 	}
-	if tablet.GroupId == 0 {
+	if tablet.GroupId == 0 && !tablet.ReadOnly {
 		return resp, x.Errorf("Group ID is Zero in %+v", tablet)
 	}
 
@@ -548,6 +548,11 @@ func (s *Server) ShouldServe(
 		// serving.
 		return tab, nil
 	}
+	if tab == nil && tablet.ReadOnly {
+		// Read-only requests should return an empty tablet instead of asking zero to serve
+		// the predicate.
+		return &pb.Tablet{}, nil
+	}
 
 	// Set the tablet to be served by this server's group.
 	var proposal pb.ZeroProposal
diff --git a/protos/pb.proto b/protos/pb.proto
index 126a06e44c8..333242bc4e5 100644
--- a/protos/pb.proto
+++ b/protos/pb.proto
@@ -175,6 +175,7 @@ message Tablet {
 	bool force       = 3; // Used while moving predicate.
 	int64 space      = 7;
 	bool remove      = 8;
+  bool read_only   = 9; // If true, do not ask zero to serve any tablets.
 }
 
 message DirectedEdge {
diff --git a/protos/pb/pb.pb.go b/protos/pb/pb.pb.go
index 0e749a63aec..c70003a60a6 100644
--- a/protos/pb/pb.pb.go
+++ b/protos/pb/pb.pb.go
@@ -1368,6 +1368,7 @@ type Tablet struct {
 	Force                bool     `protobuf:"varint,3,opt,name=force,proto3" json:"force,omitempty"`
 	Space                int64    `protobuf:"varint,7,opt,name=space,proto3" json:"space,omitempty"`
 	Remove               bool     `protobuf:"varint,8,opt,name=remove,proto3" json:"remove,omitempty"`
+	ReadOnly             bool     `protobuf:"varint,9,opt,name=read_only,json=readOnly,proto3" json:"read_only,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1441,6 +1442,13 @@ func (m *Tablet) GetRemove() bool {
 	return false
 }
 
+func (m *Tablet) GetReadOnly() bool {
+	if m != nil {
+		return m.ReadOnly
+	}
+	return false
+}
+
 type DirectedEdge struct {
 	Entity               uint64          `protobuf:"fixed64,1,opt,name=entity,proto3" json:"entity,omitempty"`
 	Attr                 string          `protobuf:"bytes,2,opt,name=attr,proto3" json:"attr,omitempty"`
@@ -3645,216 +3653,217 @@ func init() {
 func init() { proto.RegisterFile("pb.proto", fileDescriptor_f80abaa17e25ccc8) }
 
 var fileDescriptor_f80abaa17e25ccc8 = []byte{
-	// 3342 bytes of a gzipped FileDescriptorProto
+	// 3350 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x39, 0xcb, 0x72, 0x24, 0x57,
-	0x56, 0x9d, 0xf5, 0xc8, 0xca, 0x3c, 0x55, 0x52, 0x97, 0xaf, 0x3d, 0xed, 0xb2, 0x3c, 0xd3, 0x2d,
-	0xa7, 0x1f, 0x2d, 0xb7, 0x6d, 0x75, 0x5b, 0x36, 0x30, 0x1e, 0x82, 0x85, 0x5a, 0xaa, 0x6e, 0x64,
-	0xeb, 0xc5, 0xad, 0x52, 0x0f, 0x38, 0x08, 0x2a, 0xae, 0x32, 0xaf, 0x4a, 0x39, 0xca, 0xca, 0x4c,
-	0xf2, 0x66, 0x29, 0x4a, 0xde, 0xb1, 0x80, 0x80, 0x3f, 0x98, 0x05, 0xc1, 0x8e, 0x0d, 0x1b, 0xb6,
-	0xb3, 0x64, 0x43, 0x04, 0x4b, 0x82, 0x2f, 0x20, 0x0c, 0xdf, 0x40, 0x04, 0x3b, 0xe2, 0x9c, 0x7b,
-	0xf3, 0x51, 0xd5, 0xea, 0xf6, 0x98, 0x88, 0x59, 0x55, 0x9e, 0xc7, 0x7d, 0x9d, 0xf7, 0x39, 0x05,
-	0x4e, 0x7a, 0xbe, 0x9d, 0x66, 0x49, 0x9e, 0xb0, 0x46, 0x7a, 0xbe, 0xe1, 0x8a, 0x34, 0xd4, 0xe0,
-	0xc6, 0xc3, 0x69, 0x98, 0x5f, 0xce, 0xcf, 0xb7, 0xfd, 0x64, 0xf6, 0x38, 0x98, 0x66, 0x22, 0xbd,
-	0xfc, 0x2c, 0x4c, 0x1e, 0x9f, 0x8b, 0x60, 0x2a, 0xb3, 0xc7, 0xe9, 0xf9, 0xe3, 0x62, 0x9d, 0xb7,
-	0x01, 0xad, 0xc3, 0x50, 0xe5, 0x8c, 0x41, 0x6b, 0x1e, 0x06, 0x6a, 0x60, 0x6d, 0x36, 0xb7, 0x6c,
-	0x4e, 0xdf, 0xde, 0x11, 0xb8, 0x63, 0xa1, 0xae, 0x5e, 0x88, 0x68, 0x2e, 0x59, 0x1f, 0x9a, 0xd7,
-	0x22, 0x1a, 0x58, 0x9b, 0xd6, 0x56, 0x8f, 0xe3, 0x27, 0xdb, 0x06, 0xe7, 0x5a, 0x44, 0x93, 0xfc,
-	0x26, 0x95, 0x83, 0xc6, 0xa6, 0xb5, 0xb5, 0xbe, 0xf3, 0xe6, 0x76, 0x7a, 0xbe, 0x7d, 0x9a, 0xa8,
-	0x3c, 0x8c, 0xa7, 0xdb, 0x2f, 0x44, 0x34, 0xbe, 0x49, 0x25, 0xef, 0x5c, 0xeb, 0x0f, 0xef, 0x04,
-	0xba, 0xa3, 0xcc, 0x7f, 0x36, 0x8f, 0xfd, 0x3c, 0x4c, 0x62, 0x3c, 0x31, 0x16, 0x33, 0x49, 0x3b,
-	0xba, 0x9c, 0xbe, 0x11, 0x27, 0xb2, 0xa9, 0x1a, 0x34, 0x37, 0x9b, 0x88, 0xc3, 0x6f, 0x36, 0x80,
-	0x4e, 0xa8, 0xf6, 0x92, 0x79, 0x9c, 0x0f, 0x5a, 0x9b, 0xd6, 0x96, 0xc3, 0x0b, 0xd0, 0xfb, 0xbb,
-	0x26, 0xb4, 0xff, 0x64, 0x2e, 0xb3, 0x1b, 0x5a, 0x97, 0xe7, 0x59, 0xb1, 0x17, 0x7e, 0xb3, 0xb7,
-	0xa0, 0x1d, 0x89, 0x78, 0xaa, 0x06, 0x0d, 0xda, 0x4c, 0x03, 0xec, 0x5d, 0x70, 0xc5, 0x45, 0x2e,
-	0xb3, 0xc9, 0x3c, 0x0c, 0x06, 0xcd, 0x4d, 0x6b, 0xcb, 0xe6, 0x0e, 0x21, 0xce, 0xc2, 0x80, 0xbd,
-	0x03, 0x4e, 0x90, 0x4c, 0xfc, 0xfa, 0x59, 0x41, 0x42, 0x67, 0xb1, 0xf7, 0xc1, 0x99, 0x87, 0xc1,
-	0x24, 0x0a, 0x55, 0x3e, 0x68, 0x6f, 0x5a, 0x5b, 0xdd, 0x1d, 0x07, 0x1f, 0x8b, 0xb2, 0xe3, 0x9d,
-	0x79, 0x18, 0x90, 0x10, 0x1f, 0x81, 0xa3, 0x32, 0x7f, 0x72, 0x31, 0x8f, 0xfd, 0x81, 0x4d, 0x4c,
-	0x77, 0x91, 0xa9, 0xf6, 0x6a, 0xde, 0x51, 0x1a, 0xc0, 0x67, 0x65, 0xf2, 0x5a, 0x66, 0x4a, 0x0e,
-	0x3a, 0xfa, 0x28, 0x03, 0xb2, 0x27, 0xd0, 0xbd, 0x10, 0xbe, 0xcc, 0x27, 0xa9, 0xc8, 0xc4, 0x6c,
-	0xe0, 0x54, 0x1b, 0x3d, 0x43, 0xf4, 0x29, 0x62, 0x15, 0x87, 0x8b, 0x12, 0x60, 0x5f, 0xc0, 0x1a,
-	0x41, 0x6a, 0x72, 0x11, 0x46, 0xb9, 0xcc, 0x06, 0x2e, 0xad, 0x59, 0xa7, 0x35, 0x84, 0x19, 0x67,
-	0x52, 0xf2, 0x9e, 0x66, 0xd2, 0x18, 0xf6, 0x33, 0x00, 0xb9, 0x48, 0x45, 0x1c, 0x4c, 0x44, 0x14,
-	0x0d, 0x80, 0xee, 0xe0, 0x6a, 0xcc, 0x6e, 0x14, 0xb1, 0xb7, 0xf1, 0x7e, 0x22, 0x98, 0xe4, 0x6a,
-	0xb0, 0xb6, 0x69, 0x6d, 0xb5, 0xb8, 0x8d, 0xe0, 0x58, 0xa1, 0x5c, 0x7d, 0xe1, 0x5f, 0xca, 0xc1,
-	0xfa, 0xa6, 0xb5, 0xd5, 0xe6, 0x1a, 0xf0, 0x76, 0xc0, 0x25, 0x3b, 0x21, 0x39, 0x7c, 0x08, 0xf6,
-	0x35, 0x02, 0xda, 0x9c, 0xba, 0x3b, 0x6b, 0x78, 0x91, 0xd2, 0x94, 0xb8, 0x21, 0x7a, 0xf7, 0xc1,
-	0x39, 0x14, 0xf1, 0xb4, 0xb0, 0x3f, 0x54, 0x10, 0x2d, 0x70, 0x39, 0x7d, 0x7b, 0xbf, 0x6e, 0x80,
-	0xcd, 0xa5, 0x9a, 0x47, 0x39, 0x7b, 0x08, 0x80, 0xe2, 0x9f, 0x89, 0x3c, 0x0b, 0x17, 0x66, 0xd7,
-	0x4a, 0x01, 0xee, 0x3c, 0x0c, 0x8e, 0x88, 0xc4, 0x9e, 0x40, 0x8f, 0x76, 0x2f, 0x58, 0x1b, 0xd5,
-	0x05, 0xca, 0xfb, 0xf1, 0x2e, 0xb1, 0x98, 0x15, 0xf7, 0xc0, 0x26, 0x8d, 0x6b, 0xab, 0x5b, 0xe3,
-	0x06, 0x62, 0x1f, 0xc2, 0x7a, 0x18, 0xe7, 0xa8, 0x11, 0x3f, 0x9f, 0x04, 0x52, 0x15, 0x26, 0xb1,
-	0x56, 0x62, 0xf7, 0xa5, 0xca, 0xd9, 0xe7, 0xa0, 0xc5, 0x5a, 0x1c, 0xd8, 0xa6, 0x03, 0xd7, 0x4b,
-	0x75, 0x29, 0x7d, 0x22, 0xf1, 0x98, 0x13, 0x3f, 0x83, 0x2e, 0xbe, 0xaf, 0x58, 0x61, 0xd3, 0x8a,
-	0x1e, 0xbd, 0xc6, 0x88, 0x83, 0x03, 0x32, 0x18, 0x76, 0x14, 0x0d, 0x9a, 0x9d, 0x36, 0x13, 0xfa,
-	0xf6, 0x86, 0xd0, 0x3e, 0xc9, 0x02, 0x99, 0xdd, 0x6a, 0xf9, 0x0c, 0x5a, 0x81, 0x54, 0x3e, 0x39,
-	0xa5, 0xc3, 0xe9, 0xbb, 0xf2, 0x86, 0x66, 0xcd, 0x1b, 0xbc, 0x7f, 0xb0, 0xa0, 0x3b, 0x4a, 0xb2,
-	0xfc, 0x48, 0x2a, 0x25, 0xa6, 0x92, 0x3d, 0x80, 0x76, 0x82, 0xdb, 0x1a, 0x09, 0xbb, 0x78, 0x27,
-	0x3a, 0x87, 0x6b, 0xfc, 0x8a, 0x1e, 0x1a, 0xaf, 0xd6, 0x03, 0x5a, 0x09, 0xf9, 0x51, 0xd3, 0x58,
-	0x09, 0x79, 0xd1, 0x3d, 0xb0, 0x93, 0x8b, 0x0b, 0x25, 0xb5, 0x2c, 0xdb, 0xdc, 0x40, 0xaf, 0x34,
-	0x36, 0xef, 0xf7, 0x00, 0xf0, 0x7e, 0x3f, 0xd2, 0x0a, 0xbc, 0x4b, 0xe8, 0x72, 0x71, 0x91, 0xef,
-	0x25, 0x71, 0x2e, 0x17, 0x39, 0x5b, 0x87, 0x46, 0x18, 0x90, 0x88, 0x6c, 0xde, 0x08, 0x03, 0xbc,
-	0xdc, 0x34, 0x4b, 0xe6, 0x29, 0x49, 0x68, 0x8d, 0x6b, 0x80, 0x44, 0x19, 0x04, 0x19, 0xdd, 0x18,
-	0x45, 0x19, 0x04, 0x19, 0x7b, 0x00, 0x5d, 0x15, 0x8b, 0x54, 0x5d, 0x26, 0x39, 0x5e, 0xae, 0x45,
-	0x97, 0x83, 0x02, 0x35, 0x56, 0xde, 0xbf, 0x5a, 0x60, 0x1f, 0xc9, 0xd9, 0xb9, 0xcc, 0x5e, 0x3a,
-	0xe5, 0x1d, 0x70, 0x68, 0xe3, 0x49, 0x18, 0x98, 0x83, 0x3a, 0x04, 0x1f, 0x04, 0xb7, 0x1e, 0x75,
-	0x0f, 0xec, 0x48, 0x0a, 0x14, 0xbe, 0xb6, 0x33, 0x03, 0xa1, 0x6c, 0xc4, 0x6c, 0x12, 0x48, 0x11,
-	0x50, 0xe0, 0x71, 0xb8, 0x2d, 0x66, 0xfb, 0x52, 0x04, 0x78, 0xb7, 0x48, 0xa8, 0x7c, 0x32, 0x4f,
-	0x03, 0x91, 0x4b, 0x0a, 0x38, 0x2d, 0x34, 0x1c, 0x95, 0x9f, 0x11, 0x86, 0x3d, 0x82, 0x37, 0xfc,
-	0x68, 0xae, 0x30, 0xda, 0x85, 0xf1, 0x45, 0x32, 0x49, 0xe2, 0xe8, 0x86, 0xe4, 0xeb, 0xf0, 0xbb,
-	0x86, 0x70, 0x10, 0x5f, 0x24, 0x27, 0x71, 0x74, 0xe3, 0xfd, 0xa6, 0x01, 0xed, 0xe7, 0x24, 0x86,
-	0x27, 0xd0, 0x99, 0xd1, 0x83, 0x0a, 0xef, 0xbd, 0x87, 0x12, 0x26, 0xda, 0xb6, 0x7e, 0xa9, 0x1a,
-	0xc6, 0x79, 0x76, 0xc3, 0x0b, 0x36, 0x5c, 0x91, 0x8b, 0xf3, 0x48, 0xe6, 0xca, 0x58, 0x44, 0x6d,
-	0xc5, 0x58, 0x13, 0xcc, 0x0a, 0xc3, 0xb6, 0x2a, 0xd6, 0xe6, 0xaa, 0x58, 0xd9, 0x06, 0x38, 0xfe,
-	0xa5, 0xf4, 0xaf, 0xd4, 0x7c, 0x66, 0x84, 0x5e, 0xc2, 0x1b, 0xcf, 0xa0, 0x57, 0xbf, 0x07, 0x66,
-	0xa6, 0x2b, 0x79, 0x43, 0x82, 0x6f, 0x71, 0xfc, 0x64, 0x9b, 0xd0, 0x26, 0x0f, 0x27, 0xb1, 0x77,
-	0x77, 0x00, 0xaf, 0xa3, 0x97, 0x70, 0x4d, 0xf8, 0x45, 0xe3, 0xe7, 0x16, 0xee, 0x53, 0xbf, 0x5d,
-	0x7d, 0x1f, 0xf7, 0xd5, 0xfb, 0xe8, 0x25, 0xb5, 0x7d, 0xbc, 0xff, 0x6d, 0x40, 0xef, 0x5b, 0x99,
-	0x25, 0xa7, 0x59, 0x92, 0x26, 0x4a, 0x44, 0x6c, 0x77, 0xf9, 0x75, 0x5a, 0x8a, 0x9b, 0xb8, 0xb8,
-	0xce, 0xb6, 0x3d, 0x2a, 0x9f, 0xab, 0xa5, 0x53, 0x7f, 0xbf, 0x07, 0xb6, 0x96, 0xee, 0x2d, 0x4f,
-	0x30, 0x14, 0xe4, 0xd1, 0xf2, 0x24, 0xf9, 0x2d, 0x5f, 0xcf, 0x50, 0xd8, 0x7d, 0x80, 0x99, 0x58,
-	0x1c, 0x4a, 0xa1, 0xe4, 0x41, 0x50, 0x98, 0x6f, 0x85, 0x41, 0x39, 0xcf, 0xc4, 0x62, 0xbc, 0x88,
-	0xc7, 0x8a, 0xac, 0xab, 0xc5, 0x4b, 0x98, 0xfd, 0x14, 0xdc, 0x99, 0x58, 0xa0, 0x1f, 0x1d, 0x04,
-	0xc6, 0xba, 0x2a, 0x04, 0x7b, 0x0f, 0x9a, 0xf9, 0x22, 0xa6, 0xa0, 0x84, 0xd9, 0x09, 0x4b, 0x8f,
-	0xf1, 0x22, 0x36, 0x1e, 0xc7, 0x91, 0x56, 0x08, 0xd4, 0xa9, 0x04, 0xda, 0x87, 0xa6, 0x1f, 0x06,
-	0x94, 0x9e, 0x5c, 0x8e, 0x9f, 0x1b, 0x7f, 0x04, 0x77, 0x57, 0xe4, 0x50, 0xd7, 0xc3, 0x9a, 0x5e,
-	0xf6, 0x56, 0x5d, 0x0f, 0xad, 0xba, 0xec, 0x7f, 0xd3, 0x84, 0xbb, 0xc6, 0x18, 0x2e, 0xc3, 0x74,
-	0x94, 0xa3, 0xd9, 0x0f, 0xa0, 0x43, 0xd1, 0x46, 0x66, 0xc6, 0x26, 0x0a, 0x90, 0xfd, 0x01, 0xd8,
-	0xe4, 0x81, 0x85, 0x9d, 0x3e, 0xa8, 0xa4, 0x5a, 0x2e, 0xd7, 0x76, 0x6b, 0x54, 0x62, 0xd8, 0xd9,
-	0x97, 0xd0, 0xfe, 0x4e, 0x66, 0x89, 0x8e, 0x9e, 0xdd, 0x9d, 0xfb, 0xb7, 0xad, 0x43, 0xdd, 0x9a,
-	0x65, 0x9a, 0xf9, 0x77, 0x28, 0xfc, 0x0f, 0x30, 0x5e, 0xce, 0x92, 0x6b, 0x19, 0x0c, 0x3a, 0x74,
-	0xa3, 0xba, 0x7d, 0x14, 0xa4, 0x42, 0xda, 0x4e, 0x25, 0xed, 0x7d, 0xe8, 0xd6, 0x9e, 0x77, 0x8b,
-	0xa4, 0x1f, 0x2c, 0x5b, 0xbc, 0x5b, 0x3a, 0x72, 0xdd, 0x71, 0xf6, 0x01, 0xaa, 0xc7, 0xfe, 0x7f,
-	0xdd, 0xcf, 0xfb, 0x2b, 0x0b, 0xee, 0xee, 0x25, 0x71, 0x2c, 0xa9, 0x30, 0xd2, 0xaa, 0xab, 0xcc,
-	0xde, 0x7a, 0xa5, 0xd9, 0x7f, 0x0c, 0x6d, 0x85, 0xcc, 0x66, 0xf7, 0x37, 0x6f, 0xd1, 0x05, 0xd7,
-	0x1c, 0x18, 0x66, 0x66, 0x62, 0x31, 0x49, 0x65, 0x1c, 0x84, 0xf1, 0xb4, 0x08, 0x33, 0x33, 0xb1,
-	0x38, 0xd5, 0x18, 0xef, 0xaf, 0x2d, 0xb0, 0xb5, 0xc7, 0x2c, 0x45, 0x6b, 0x6b, 0x39, 0x5a, 0xff,
-	0x14, 0xdc, 0x34, 0x93, 0x41, 0xe8, 0x17, 0xa7, 0xba, 0xbc, 0x42, 0xa0, 0x71, 0x5e, 0x24, 0x99,
-	0x2f, 0x69, 0x7b, 0x87, 0x6b, 0x00, 0xb1, 0x2a, 0x15, 0xbe, 0x2e, 0xee, 0x9a, 0x5c, 0x03, 0x18,
-	0xe3, 0xb5, 0x72, 0x48, 0x29, 0x0e, 0x37, 0x90, 0xf7, 0x4f, 0x0d, 0xe8, 0xed, 0x87, 0x99, 0xf4,
-	0x73, 0x19, 0x0c, 0x83, 0x29, 0x31, 0xca, 0x38, 0x0f, 0xf3, 0x1b, 0x93, 0x4f, 0x0c, 0x54, 0xa6,
-	0xfb, 0xc6, 0x72, 0xa1, 0xab, 0xc5, 0xdd, 0xa4, 0xda, 0x5c, 0x03, 0x6c, 0x07, 0x40, 0x17, 0x42,
-	0x54, 0x9f, 0xb7, 0x5e, 0x5d, 0x9f, 0xbb, 0xc4, 0x86, 0x9f, 0x28, 0x03, 0xbd, 0x26, 0xd4, 0xb9,
-	0xc6, 0xa6, 0xe2, 0x7d, 0x8e, 0xb6, 0x4a, 0xf5, 0xc3, 0xb9, 0x8c, 0xc8, 0x16, 0xa9, 0x7e, 0x38,
-	0x97, 0x51, 0x59, 0xb5, 0x75, 0xf4, 0x75, 0xf0, 0x9b, 0xbd, 0x0f, 0x8d, 0x24, 0xa5, 0xf7, 0x99,
-	0x03, 0xeb, 0x0f, 0xdb, 0x3e, 0x49, 0x79, 0x23, 0x49, 0x51, 0xd1, 0xba, 0x18, 0x1d, 0xb8, 0xc6,
-	0x7e, 0x31, 0x80, 0x50, 0xc1, 0xc4, 0x0d, 0xc5, 0xbb, 0x07, 0x8d, 0x93, 0x94, 0x75, 0xa0, 0x39,
-	0x1a, 0x8e, 0xfb, 0x77, 0xf0, 0x63, 0x7f, 0x78, 0xd8, 0xb7, 0xbc, 0xbf, 0x6d, 0x80, 0x7b, 0x34,
-	0xcf, 0x05, 0x9a, 0x8d, 0x7a, 0x9d, 0xde, 0xde, 0x01, 0x47, 0xe5, 0x22, 0xa3, 0x20, 0xac, 0x23,
-	0x47, 0x87, 0xe0, 0xb1, 0x62, 0x1f, 0x41, 0x5b, 0x06, 0x53, 0x59, 0x38, 0x74, 0x7f, 0xf5, 0x9e,
-	0x5c, 0x93, 0xd9, 0x16, 0xd8, 0xca, 0xbf, 0x94, 0x33, 0x31, 0x68, 0x55, 0x8c, 0x23, 0xc2, 0xe8,
-	0x24, 0xcb, 0x0d, 0x9d, 0x7a, 0x87, 0x2c, 0x49, 0xa9, 0x98, 0x6e, 0x9b, 0xde, 0x21, 0x4b, 0x52,
-	0x2c, 0xa5, 0x77, 0xe0, 0x27, 0xe1, 0x34, 0x4e, 0x32, 0x39, 0x09, 0xe3, 0x40, 0x2e, 0x26, 0x7e,
-	0x12, 0x5f, 0x44, 0xa1, 0x9f, 0x93, 0x2c, 0x1d, 0xfe, 0xa6, 0x26, 0x1e, 0x20, 0x6d, 0xcf, 0x90,
-	0xd8, 0x07, 0xd0, 0x46, 0xc5, 0x29, 0xe3, 0xdf, 0x54, 0x4f, 0xa2, 0x8e, 0xcc, 0xa9, 0x9a, 0xe8,
-	0x2d, 0xc0, 0x29, 0xa2, 0x27, 0xfb, 0x18, 0xc3, 0x1e, 0x45, 0x5f, 0xe3, 0x3c, 0xd4, 0x32, 0xd4,
-	0xca, 0x20, 0x5e, 0xd0, 0x51, 0x99, 0x74, 0x93, 0x22, 0x9e, 0x12, 0x50, 0x2f, 0xc2, 0x9a, 0x4b,
-	0x15, 0x3f, 0xd6, 0x93, 0x49, 0x2c, 0x4d, 0x5d, 0x42, 0xdf, 0xde, 0xdf, 0x37, 0xc0, 0x29, 0x13,
-	0xde, 0x27, 0xe0, 0xce, 0x0a, 0x85, 0x18, 0xb7, 0xa4, 0x8a, 0xbb, 0xd4, 0x12, 0xaf, 0xe8, 0xec,
-	0x1e, 0x34, 0xae, 0xae, 0x8d, 0x38, 0x6d, 0xe4, 0xfa, 0xe6, 0x05, 0x6f, 0x5c, 0x5d, 0x57, 0x7e,
-	0xdd, 0xfe, 0x41, 0xbf, 0x7e, 0x08, 0x77, 0xfd, 0x48, 0x8a, 0x78, 0x52, 0xb9, 0xa5, 0x36, 0xcb,
-	0x75, 0x42, 0x9f, 0x96, 0xbe, 0x69, 0x62, 0x53, 0xa7, 0xca, 0x40, 0x1f, 0x42, 0x3b, 0x90, 0x51,
-	0x2e, 0xea, 0x6d, 0xd5, 0x49, 0x26, 0xfc, 0x48, 0xee, 0x23, 0x9a, 0x6b, 0x2a, 0xdb, 0x02, 0xa7,
-	0xc8, 0xc6, 0xa6, 0x99, 0xa2, 0xfa, 0xbc, 0x10, 0x36, 0x2f, 0xa9, 0x95, 0x2c, 0xa1, 0x26, 0x4b,
-	0xef, 0x73, 0x68, 0x7e, 0xf3, 0x62, 0x64, 0xde, 0x6a, 0xbd, 0xf4, 0xd6, 0x42, 0xa2, 0x8d, 0x9a,
-	0x44, 0xff, 0xa7, 0x09, 0x1d, 0xe3, 0x9b, 0x78, 0xef, 0x79, 0x59, 0x4b, 0xe2, 0xe7, 0x72, 0x0a,
-	0x2c, 0x9d, 0xbc, 0xde, 0x82, 0x37, 0x7f, 0xb8, 0x05, 0x67, 0xbf, 0x80, 0x5e, 0xaa, 0x69, 0xf5,
-	0xb0, 0xf0, 0x76, 0x7d, 0x8d, 0xf9, 0xa5, 0x75, 0xdd, 0xb4, 0x02, 0xd0, 0xc0, 0xa9, 0x6b, 0xc9,
-	0xc5, 0x94, 0x54, 0xd4, 0xe3, 0x1d, 0x84, 0xc7, 0x62, 0xfa, 0x8a, 0xe0, 0xf0, 0x5b, 0xf8, 0x38,
-	0xd6, 0xcc, 0x49, 0x3a, 0xe8, 0x91, 0xdf, 0x62, 0x5c, 0xa8, 0xbb, 0xec, 0xda, 0xb2, 0xcb, 0xbe,
-	0x0b, 0xae, 0x9f, 0xcc, 0x66, 0x21, 0xd1, 0xd6, 0x4d, 0x4d, 0x48, 0x88, 0xb1, 0xf2, 0xfe, 0xc6,
-	0x82, 0x8e, 0x79, 0x2d, 0xeb, 0x42, 0x67, 0x7f, 0xf8, 0x6c, 0xf7, 0xec, 0x10, 0xa3, 0x06, 0x80,
-	0xfd, 0xf4, 0xe0, 0x78, 0x97, 0xff, 0x59, 0xdf, 0xc2, 0x08, 0x72, 0x70, 0x3c, 0xee, 0x37, 0x98,
-	0x0b, 0xed, 0x67, 0x87, 0x27, 0xbb, 0xe3, 0x7e, 0x93, 0x39, 0xd0, 0x7a, 0x7a, 0x72, 0x72, 0xd8,
-	0x6f, 0xb1, 0x1e, 0x38, 0xfb, 0xbb, 0xe3, 0xe1, 0xf8, 0xe0, 0x68, 0xd8, 0x6f, 0x23, 0xef, 0xf3,
-	0xe1, 0x49, 0xdf, 0xc6, 0x8f, 0xb3, 0x83, 0xfd, 0x7e, 0x07, 0xe9, 0xa7, 0xbb, 0xa3, 0xd1, 0x2f,
-	0x4f, 0xf8, 0x7e, 0xdf, 0xc1, 0x7d, 0x47, 0x63, 0x7e, 0x70, 0xfc, 0xbc, 0xef, 0xe2, 0xf7, 0xc9,
-	0xd3, 0xaf, 0x87, 0x7b, 0xe3, 0x3e, 0x78, 0x9f, 0x43, 0xb7, 0x26, 0x41, 0x5c, 0xcd, 0x87, 0xcf,
-	0xfa, 0x77, 0xf0, 0xc8, 0x17, 0xbb, 0x87, 0x67, 0xc3, 0xbe, 0xc5, 0xd6, 0x01, 0xe8, 0x73, 0x72,
-	0xb8, 0x7b, 0xfc, 0xbc, 0xdf, 0xf0, 0x7e, 0x1f, 0x9c, 0xb3, 0x30, 0x78, 0x1a, 0x25, 0xfe, 0x15,
-	0x1a, 0xc6, 0xb9, 0x50, 0xd2, 0x64, 0x53, 0xfa, 0xc6, 0x5c, 0x40, 0x46, 0xa9, 0x8c, 0xee, 0x0d,
-	0xe4, 0x1d, 0x43, 0xe7, 0x2c, 0x0c, 0x4e, 0x85, 0x7f, 0x85, 0xbd, 0xfc, 0x39, 0xae, 0x9f, 0xa8,
-	0xf0, 0x3b, 0x69, 0xc2, 0xa0, 0x4b, 0x98, 0x51, 0xf8, 0x9d, 0x64, 0x1f, 0x80, 0x4d, 0x40, 0x51,
-	0xf7, 0x90, 0x2d, 0x17, 0x67, 0x72, 0x43, 0xf3, 0xf2, 0xf2, 0xea, 0xd4, 0x91, 0x3f, 0x80, 0x56,
-	0x2a, 0xfc, 0x2b, 0x13, 0x4c, 0xba, 0x66, 0x09, 0x1e, 0xc7, 0x89, 0xc0, 0x1e, 0x82, 0x63, 0xec,
-	0xa3, 0xd8, 0xb7, 0x5b, 0x33, 0x24, 0x5e, 0x12, 0x97, 0x35, 0xd7, 0x5c, 0xd1, 0xdc, 0x97, 0x00,
-	0xd5, 0x58, 0xe3, 0x96, 0x1a, 0xfc, 0x2d, 0x68, 0x8b, 0x28, 0x34, 0x8f, 0x77, 0xb9, 0x06, 0xbc,
-	0x63, 0xe8, 0xd6, 0x86, 0x21, 0x68, 0x36, 0x22, 0x8a, 0x26, 0x57, 0xf2, 0x46, 0xd1, 0x5a, 0x87,
-	0x77, 0x44, 0x14, 0x7d, 0x23, 0x6f, 0x14, 0x06, 0x52, 0x3d, 0x47, 0x69, 0xac, 0x34, 0xe6, 0xb4,
-	0x94, 0x6b, 0xa2, 0xf7, 0x29, 0xd8, 0xba, 0x5b, 0xaf, 0x59, 0xad, 0xf5, 0xca, 0xcc, 0xf4, 0x95,
-	0xb9, 0x33, 0xf5, 0xf6, 0xec, 0x13, 0x33, 0xaf, 0x51, 0x7a, 0x3a, 0x64, 0x55, 0x05, 0x99, 0x66,
-	0x32, 0xa3, 0x1a, 0x62, 0xf6, 0xf6, 0xc1, 0x79, 0xed, 0x04, 0xcc, 0x08, 0xa0, 0x51, 0x09, 0xe0,
-	0x96, 0x99, 0x98, 0xf7, 0x2b, 0x80, 0x6a, 0xae, 0x63, 0x9c, 0x48, 0xef, 0x82, 0x4e, 0xf4, 0x08,
-	0x9b, 0xa7, 0x30, 0x0a, 0x32, 0x19, 0x2f, 0xbd, 0xba, 0x9a, 0x04, 0x95, 0x74, 0xb6, 0x09, 0x2d,
-	0x1a, 0x57, 0x35, 0xab, 0x20, 0x57, 0xce, 0xaa, 0x88, 0xe2, 0x2d, 0x60, 0x4d, 0x27, 0x3c, 0x2e,
-	0xff, 0x72, 0x2e, 0xd5, 0x6b, 0x2b, 0xa5, 0xfb, 0x00, 0x65, 0x48, 0x2e, 0x06, 0x6f, 0x35, 0x0c,
-	0x9a, 0xf2, 0x45, 0x28, 0xa3, 0xa0, 0x78, 0x8d, 0x81, 0x50, 0xc9, 0x3a, 0xdb, 0xb5, 0xf4, 0x74,
-	0x42, 0x67, 0xb7, 0x3f, 0x84, 0x5e, 0x71, 0x32, 0xb5, 0xff, 0x9f, 0x94, 0xc9, 0x58, 0xcb, 0x58,
-	0x77, 0x1d, 0x9a, 0xe5, 0x38, 0x09, 0xe4, 0xd3, 0xc6, 0xc0, 0x2a, 0xf2, 0xb1, 0xf7, 0x1f, 0xcd,
-	0x62, 0xb5, 0xe9, 0x86, 0x97, 0xaa, 0x38, 0x6b, 0xb5, 0x8a, 0x5b, 0x2e, 0x97, 0x1a, 0xbf, 0x55,
-	0xb9, 0xf4, 0x73, 0x70, 0x03, 0xaa, 0x19, 0xc2, 0xeb, 0x22, 0xfc, 0x6e, 0xac, 0xd6, 0x07, 0xa6,
-	0xaa, 0x08, 0xaf, 0x25, 0xaf, 0x98, 0xf1, 0x2e, 0x79, 0x72, 0x25, 0xe3, 0xf0, 0x3b, 0x6a, 0xf7,
-	0xf1, 0xcd, 0x15, 0xa2, 0x9a, 0x9d, 0xe8, 0x3a, 0xc2, 0xcc, 0x4e, 0x8a, 0x31, 0x90, 0x5d, 0x8d,
-	0x81, 0x50, 0x9e, 0xf3, 0x54, 0xc9, 0x2c, 0x2f, 0xea, 0x49, 0x0d, 0x95, 0x75, 0x99, 0x6b, 0x78,
-	0xb1, 0x2e, 0x7b, 0x0f, 0x7a, 0x71, 0x12, 0x4f, 0xe2, 0x79, 0x14, 0x61, 0xc5, 0x6b, 0x26, 0x7e,
-	0xdd, 0x38, 0x89, 0x8f, 0x0d, 0x8a, 0x3d, 0x82, 0x37, 0xea, 0x2c, 0xda, 0x9e, 0xbb, 0x7a, 0x60,
-	0x50, 0xe3, 0x23, 0xab, 0xdf, 0x82, 0x7e, 0x72, 0xfe, 0x2b, 0xe9, 0xe7, 0x24, 0xb1, 0x09, 0x19,
-	0x72, 0x4f, 0x27, 0x61, 0x8d, 0x47, 0x11, 0x1d, 0x8b, 0x99, 0xf4, 0xbe, 0x02, 0xb7, 0x14, 0x02,
-	0xc6, 0xdb, 0xe3, 0x93, 0xe3, 0xa1, 0x8e, 0x88, 0x07, 0xc7, 0xfb, 0xc3, 0x3f, 0xed, 0x5b, 0x18,
-	0xb1, 0xf9, 0xf0, 0xc5, 0x90, 0x8f, 0x86, 0xfd, 0x06, 0x46, 0xd3, 0xfd, 0xe1, 0xe1, 0x70, 0x3c,
-	0xec, 0x37, 0xbf, 0x6e, 0x39, 0x9d, 0xbe, 0xc3, 0x1d, 0xb9, 0x48, 0xa3, 0xd0, 0x0f, 0x73, 0x6f,
-	0x04, 0x50, 0x15, 0x41, 0x18, 0x57, 0xaa, 0xb3, 0xb5, 0x46, 0x9d, 0xdc, 0x9c, 0x8a, 0x95, 0x9b,
-	0x31, 0xb5, 0xc6, 0xab, 0x2a, 0x37, 0x4d, 0xf7, 0xce, 0xc0, 0x39, 0x12, 0xe9, 0x4b, 0xcd, 0x4c,
-	0xaf, 0x6c, 0x59, 0xe7, 0x66, 0x80, 0x63, 0x52, 0xf1, 0x87, 0xd0, 0x31, 0xa1, 0xcd, 0x78, 0xcd,
-	0x52, 0xd8, 0x2b, 0x68, 0xd8, 0x5b, 0xbc, 0x75, 0x94, 0x5c, 0xcb, 0xb2, 0x1a, 0x39, 0x15, 0x37,
-	0x51, 0x22, 0x82, 0x1f, 0x30, 0xc4, 0x9f, 0x01, 0xa8, 0x64, 0x9e, 0xf9, 0x72, 0x32, 0x2d, 0xe7,
-	0x46, 0xae, 0xc6, 0x3c, 0x37, 0x23, 0x6a, 0xa9, 0x72, 0x22, 0x36, 0xb5, 0xf3, 0x21, 0x8c, 0xa4,
-	0x9f, 0x80, 0x9d, 0x2f, 0xe2, 0x6a, 0x4c, 0xd5, 0xce, 0xb1, 0x93, 0xf4, 0xf6, 0xc0, 0x1d, 0x2f,
-	0xa8, 0xbf, 0x9a, 0xab, 0xa5, 0xfc, 0x6a, 0xbd, 0x26, 0xbf, 0x36, 0x56, 0xa2, 0xf4, 0x7f, 0x5b,
-	0xd0, 0xad, 0x95, 0x49, 0xec, 0x3d, 0x68, 0xe5, 0x8b, 0x78, 0x79, 0xbe, 0x5b, 0x1c, 0xc2, 0x89,
-	0x84, 0xf6, 0x86, 0xcd, 0x97, 0x50, 0x2a, 0x9c, 0xc6, 0x32, 0x30, 0x5b, 0x62, 0x43, 0xb6, 0x6b,
-	0x50, 0xec, 0x10, 0xee, 0xea, 0x48, 0x52, 0xcc, 0x76, 0x8a, 0x7a, 0xfc, 0xfd, 0x95, 0xb2, 0x4c,
-	0xf7, 0xa0, 0x7b, 0x05, 0x97, 0xee, 0xb2, 0xd7, 0xa7, 0x4b, 0xc8, 0x8d, 0x5d, 0x78, 0xf3, 0x16,
-	0xb6, 0x1f, 0x35, 0x4e, 0x78, 0x00, 0x6b, 0xd8, 0x7e, 0x87, 0x33, 0xa9, 0x72, 0x31, 0x4b, 0xa9,
-	0x3e, 0x31, 0x99, 0xa0, 0xc5, 0x1b, 0xb9, 0xf2, 0x3e, 0x82, 0xde, 0xa9, 0x94, 0x19, 0x97, 0x2a,
-	0x4d, 0x62, 0x9d, 0x9b, 0x15, 0x3d, 0xda, 0xa4, 0x1d, 0x03, 0x79, 0x7f, 0x01, 0x2e, 0x56, 0xde,
-	0x4f, 0x45, 0xee, 0x5f, 0xfe, 0x98, 0xca, 0xfc, 0x23, 0xe8, 0xa4, 0xda, 0x4c, 0x4c, 0x1d, 0xdd,
-	0xa3, 0x18, 0x67, 0x4c, 0x87, 0x17, 0x44, 0xef, 0x4b, 0x68, 0x1e, 0xcf, 0x67, 0xf5, 0x3f, 0x65,
-	0x5a, 0xfa, 0x4f, 0x99, 0x77, 0xc1, 0xa5, 0x22, 0x9e, 0x66, 0x7d, 0xba, 0xbc, 0x74, 0x10, 0x41,
-	0x43, 0xbe, 0x6f, 0xa1, 0x5b, 0xc8, 0xfe, 0x20, 0xa0, 0x7f, 0x56, 0x48, 0xf9, 0x07, 0xc1, 0x92,
-	0x2d, 0xe8, 0x6e, 0x4f, 0xc6, 0xc1, 0x41, 0xa1, 0x34, 0x0d, 0x2c, 0xef, 0x6d, 0x06, 0x16, 0xe5,
-	0xde, 0xcf, 0xa0, 0x57, 0x54, 0xc7, 0x47, 0x32, 0x17, 0x64, 0x4e, 0x51, 0x28, 0xe3, 0x9a, 0xa9,
-	0x39, 0x1a, 0x31, 0x56, 0xaf, 0x19, 0x8d, 0x7a, 0xdb, 0x60, 0x1b, 0x5b, 0x65, 0xd0, 0xf2, 0x93,
-	0x40, 0xbb, 0x48, 0x9b, 0xd3, 0x37, 0x3e, 0x78, 0xa6, 0xa6, 0x45, 0x7a, 0x9c, 0xa9, 0x29, 0xa6,
-	0xa7, 0xa7, 0xc2, 0xbf, 0x9a, 0xa7, 0x45, 0x7a, 0xaa, 0xb5, 0x31, 0xd6, 0x52, 0x1b, 0xf3, 0x9a,
-	0x79, 0xec, 0xdb, 0xd0, 0x99, 0xc7, 0xe1, 0xa2, 0xa8, 0x4f, 0x5c, 0x6e, 0x23, 0xa8, 0xe7, 0x90,
-	0x51, 0xe2, 0x53, 0xe7, 0x42, 0x5e, 0xe5, 0xf2, 0x12, 0xf6, 0xfe, 0x1c, 0xd6, 0x86, 0x8b, 0x94,
-	0xa6, 0xd3, 0x3f, 0x98, 0x18, 0x6b, 0x97, 0x6a, 0x2c, 0x5d, 0x6a, 0xe5, 0xe4, 0x66, 0x71, 0xf2,
-	0xce, 0xbf, 0x58, 0xd0, 0x42, 0x13, 0xc1, 0xe6, 0xea, 0x8f, 0xa5, 0xc8, 0xf2, 0x73, 0x29, 0x72,
-	0xb6, 0x64, 0x0e, 0x1b, 0x4b, 0x90, 0x77, 0xe7, 0x89, 0xc5, 0x3e, 0xd5, 0x83, 0xef, 0x62, 0x9e,
-	0xbf, 0x56, 0x18, 0x1a, 0x19, 0xe2, 0x2a, 0x3f, 0xdb, 0x86, 0xee, 0xd7, 0x49, 0x18, 0xef, 0xe9,
-	0x59, 0x30, 0x5b, 0x35, 0xcb, 0x97, 0xf8, 0x3f, 0x03, 0xfb, 0x40, 0xa1, 0xfd, 0xbf, 0xcc, 0x4a,
-	0xe1, 0xb5, 0xee, 0x1a, 0xde, 0x9d, 0x9d, 0x7f, 0x6e, 0x42, 0xeb, 0x5b, 0x99, 0x25, 0xec, 0x53,
-	0xe8, 0x98, 0x49, 0x0f, 0xab, 0x4d, 0x74, 0x36, 0x28, 0xbf, 0xae, 0x8c, 0x80, 0xe8, 0x94, 0xbe,
-	0x8e, 0xd0, 0x55, 0xf7, 0xc7, 0xaa, 0x41, 0xd4, 0x4b, 0x97, 0xfa, 0x0a, 0xfa, 0xa3, 0x3c, 0x93,
-	0x62, 0x56, 0x63, 0x5f, 0x16, 0xd3, 0x6d, 0xad, 0x24, 0x49, 0xeb, 0x13, 0xb0, 0x75, 0x90, 0x59,
-	0x59, 0xb0, 0xda, 0x15, 0x12, 0xf3, 0x43, 0xe8, 0x8e, 0x2e, 0x93, 0x79, 0x14, 0x8c, 0x64, 0x76,
-	0x2d, 0x59, 0x6d, 0xda, 0xba, 0x51, 0xfb, 0xf6, 0xee, 0xb0, 0x2d, 0x00, 0xed, 0x65, 0x67, 0x61,
-	0xa0, 0x58, 0x07, 0x69, 0xc7, 0xf3, 0x99, 0xde, 0xb4, 0xe6, 0x7e, 0x9a, 0xb3, 0x16, 0x6b, 0x5e,
-	0xc7, 0xf9, 0x05, 0xac, 0xed, 0x51, 0x2c, 0x3e, 0xc9, 0x76, 0xcf, 0x93, 0x2c, 0x67, 0xab, 0x13,
-	0xd7, 0x8d, 0x55, 0x84, 0x77, 0x87, 0x3d, 0x01, 0x67, 0x9c, 0xdd, 0x68, 0xfe, 0x37, 0x4c, 0x88,
-	0xae, 0xce, 0xbb, 0xe5, 0x95, 0x3b, 0xff, 0xd8, 0x04, 0xfb, 0x97, 0x49, 0x76, 0x25, 0x33, 0xf6,
-	0x08, 0x6c, 0x6a, 0xdf, 0x8d, 0x11, 0x95, 0xad, 0xfc, 0x6d, 0x07, 0x7d, 0x00, 0x2e, 0x09, 0x65,
-	0x2c, 0xd4, 0x95, 0x56, 0x15, 0xfd, 0x2d, 0xab, 0xe5, 0xa2, 0x8b, 0x37, 0xd2, 0xeb, 0xba, 0x56,
-	0x54, 0x39, 0xb2, 0x58, 0xea, 0xa9, 0x37, 0x3a, 0xba, 0x41, 0x1e, 0x79, 0x77, 0xb6, 0xac, 0x27,
-	0x16, 0xfb, 0x18, 0x5a, 0x23, 0xfd, 0x52, 0x64, 0xaa, 0xfe, 0xa4, 0xda, 0x58, 0x2f, 0x10, 0xe5,
-	0xce, 0x8f, 0xc1, 0xd6, 0x99, 0x5d, 0x3f, 0x73, 0xa9, 0x5c, 0xdd, 0xe8, 0xd7, 0x51, 0x66, 0xc1,
-	0xc7, 0x60, 0xeb, 0xa0, 0xa1, 0x17, 0x2c, 0x05, 0x10, 0x7d, 0x6b, 0x1d, 0x83, 0x34, 0xab, 0xf6,
-	0x72, 0xcd, 0xba, 0xe4, 0xf1, 0x2b, 0xac, 0x9f, 0x41, 0x9f, 0x4b, 0x5f, 0x86, 0xb5, 0x9c, 0xcf,
-	0x8a, 0x47, 0xad, 0x9a, 0xed, 0x96, 0xc5, 0xbe, 0x82, 0xb5, 0xa5, 0xfa, 0x80, 0x0d, 0x48, 0xd0,
-	0xb7, 0x94, 0x0c, 0xab, 0x8b, 0x9f, 0xf6, 0xff, 0xed, 0xfb, 0xfb, 0xd6, 0xbf, 0x7f, 0x7f, 0xdf,
-	0xfa, 0xcf, 0xef, 0xef, 0x5b, 0xbf, 0xfe, 0xaf, 0xfb, 0x77, 0xce, 0x6d, 0xfa, 0x3b, 0xff, 0x8b,
-	0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x02, 0x75, 0x7b, 0x47, 0x12, 0x20, 0x00, 0x00,
+	0x56, 0x9d, 0xf5, 0xc8, 0xca, 0x3c, 0x55, 0x52, 0x97, 0xaf, 0x3d, 0xed, 0xb2, 0x66, 0xa6, 0x5b,
+	0x4e, 0x3f, 0x5a, 0x6e, 0xdb, 0xea, 0xb6, 0x6c, 0x60, 0x3c, 0x04, 0x0b, 0xb5, 0x54, 0xdd, 0xc8,
+	0xd6, 0x8b, 0x5b, 0xa5, 0x1e, 0x70, 0x10, 0x54, 0x5c, 0x65, 0x5e, 0x95, 0x72, 0x94, 0x95, 0x99,
+	0xe4, 0xcd, 0x52, 0x94, 0xbc, 0x63, 0x01, 0x01, 0x7f, 0x30, 0x0b, 0x82, 0x05, 0x11, 0x6c, 0xd8,
+	0xb0, 0x9d, 0x25, 0x1b, 0x22, 0x58, 0x12, 0x7c, 0x01, 0x61, 0xf8, 0x06, 0x22, 0xd8, 0x11, 0xe7,
+	0xdc, 0x9b, 0x8f, 0xaa, 0x56, 0xb7, 0x6d, 0x22, 0x58, 0x55, 0x9e, 0xc7, 0x7d, 0x9d, 0xf7, 0x39,
+	0x05, 0x4e, 0x7a, 0xbe, 0x9d, 0x66, 0x49, 0x9e, 0xb0, 0x46, 0x7a, 0xbe, 0xe1, 0x8a, 0x34, 0xd4,
+	0xe0, 0xc6, 0xc3, 0x69, 0x98, 0x5f, 0xce, 0xcf, 0xb7, 0xfd, 0x64, 0xf6, 0x38, 0x98, 0x66, 0x22,
+	0xbd, 0xfc, 0x34, 0x4c, 0x1e, 0x9f, 0x8b, 0x60, 0x2a, 0xb3, 0xc7, 0xe9, 0xf9, 0xe3, 0x62, 0x9d,
+	0xb7, 0x01, 0xad, 0xc3, 0x50, 0xe5, 0x8c, 0x41, 0x6b, 0x1e, 0x06, 0x6a, 0x60, 0x6d, 0x36, 0xb7,
+	0x6c, 0x4e, 0xdf, 0xde, 0x11, 0xb8, 0x63, 0xa1, 0xae, 0x5e, 0x88, 0x68, 0x2e, 0x59, 0x1f, 0x9a,
+	0xd7, 0x22, 0x1a, 0x58, 0x9b, 0xd6, 0x56, 0x8f, 0xe3, 0x27, 0xdb, 0x06, 0xe7, 0x5a, 0x44, 0x93,
+	0xfc, 0x26, 0x95, 0x83, 0xc6, 0xa6, 0xb5, 0xb5, 0xbe, 0xf3, 0xe6, 0x76, 0x7a, 0xbe, 0x7d, 0x9a,
+	0xa8, 0x3c, 0x8c, 0xa7, 0xdb, 0x2f, 0x44, 0x34, 0xbe, 0x49, 0x25, 0xef, 0x5c, 0xeb, 0x0f, 0xef,
+	0x04, 0xba, 0xa3, 0xcc, 0x7f, 0x36, 0x8f, 0xfd, 0x3c, 0x4c, 0x62, 0x3c, 0x31, 0x16, 0x33, 0x49,
+	0x3b, 0xba, 0x9c, 0xbe, 0x11, 0x27, 0xb2, 0xa9, 0x1a, 0x34, 0x37, 0x9b, 0x88, 0xc3, 0x6f, 0x36,
+	0x80, 0x4e, 0xa8, 0xf6, 0x92, 0x79, 0x9c, 0x0f, 0x5a, 0x9b, 0xd6, 0x96, 0xc3, 0x0b, 0xd0, 0xfb,
+	0x9b, 0x26, 0xb4, 0xff, 0x68, 0x2e, 0xb3, 0x1b, 0x5a, 0x97, 0xe7, 0x59, 0xb1, 0x17, 0x7e, 0xb3,
+	0xb7, 0xa0, 0x1d, 0x89, 0x78, 0xaa, 0x06, 0x0d, 0xda, 0x4c, 0x03, 0xec, 0xa7, 0xe0, 0x8a, 0x8b,
+	0x5c, 0x66, 0x93, 0x79, 0x18, 0x0c, 0x9a, 0x9b, 0xd6, 0x96, 0xcd, 0x1d, 0x42, 0x9c, 0x85, 0x01,
+	0x7b, 0x07, 0x9c, 0x20, 0x99, 0xf8, 0xf5, 0xb3, 0x82, 0x84, 0xce, 0x62, 0xef, 0x81, 0x33, 0x0f,
+	0x83, 0x49, 0x14, 0xaa, 0x7c, 0xd0, 0xde, 0xb4, 0xb6, 0xba, 0x3b, 0x0e, 0x3e, 0x16, 0x65, 0xc7,
+	0x3b, 0xf3, 0x30, 0x20, 0x21, 0x3e, 0x02, 0x47, 0x65, 0xfe, 0xe4, 0x62, 0x1e, 0xfb, 0x03, 0x9b,
+	0x98, 0xee, 0x22, 0x53, 0xed, 0xd5, 0xbc, 0xa3, 0x34, 0x80, 0xcf, 0xca, 0xe4, 0xb5, 0xcc, 0x94,
+	0x1c, 0x74, 0xf4, 0x51, 0x06, 0x64, 0x4f, 0xa0, 0x7b, 0x21, 0x7c, 0x99, 0x4f, 0x52, 0x91, 0x89,
+	0xd9, 0xc0, 0xa9, 0x36, 0x7a, 0x86, 0xe8, 0x53, 0xc4, 0x2a, 0x0e, 0x17, 0x25, 0xc0, 0x3e, 0x87,
+	0x35, 0x82, 0xd4, 0xe4, 0x22, 0x8c, 0x72, 0x99, 0x0d, 0x5c, 0x5a, 0xb3, 0x4e, 0x6b, 0x08, 0x33,
+	0xce, 0xa4, 0xe4, 0x3d, 0xcd, 0xa4, 0x31, 0xec, 0xe7, 0x00, 0x72, 0x91, 0x8a, 0x38, 0x98, 0x88,
+	0x28, 0x1a, 0x00, 0xdd, 0xc1, 0xd5, 0x98, 0xdd, 0x28, 0x62, 0x6f, 0xe3, 0xfd, 0x44, 0x30, 0xc9,
+	0xd5, 0x60, 0x6d, 0xd3, 0xda, 0x6a, 0x71, 0x1b, 0xc1, 0xb1, 0x42, 0xb9, 0xfa, 0xc2, 0xbf, 0x94,
+	0x83, 0xf5, 0x4d, 0x6b, 0xab, 0xcd, 0x35, 0xe0, 0xed, 0x80, 0x4b, 0x76, 0x42, 0x72, 0xf8, 0x00,
+	0xec, 0x6b, 0x04, 0xb4, 0x39, 0x75, 0x77, 0xd6, 0xf0, 0x22, 0xa5, 0x29, 0x71, 0x43, 0xf4, 0xee,
+	0x83, 0x73, 0x28, 0xe2, 0x69, 0x61, 0x7f, 0xa8, 0x20, 0x5a, 0xe0, 0x72, 0xfa, 0xf6, 0x7e, 0xd3,
+	0x00, 0x9b, 0x4b, 0x35, 0x8f, 0x72, 0xf6, 0x10, 0x00, 0xc5, 0x3f, 0x13, 0x79, 0x16, 0x2e, 0xcc,
+	0xae, 0x95, 0x02, 0xdc, 0x79, 0x18, 0x1c, 0x11, 0x89, 0x3d, 0x81, 0x1e, 0xed, 0x5e, 0xb0, 0x36,
+	0xaa, 0x0b, 0x94, 0xf7, 0xe3, 0x5d, 0x62, 0x31, 0x2b, 0xee, 0x81, 0x4d, 0x1a, 0xd7, 0x56, 0xb7,
+	0xc6, 0x0d, 0xc4, 0x3e, 0x80, 0xf5, 0x30, 0xce, 0x51, 0x23, 0x7e, 0x3e, 0x09, 0xa4, 0x2a, 0x4c,
+	0x62, 0xad, 0xc4, 0xee, 0x4b, 0x95, 0xb3, 0xcf, 0x40, 0x8b, 0xb5, 0x38, 0xb0, 0x4d, 0x07, 0xae,
+	0x97, 0xea, 0x52, 0xfa, 0x44, 0xe2, 0x31, 0x27, 0x7e, 0x0a, 0x5d, 0x7c, 0x5f, 0xb1, 0xc2, 0xa6,
+	0x15, 0x3d, 0x7a, 0x8d, 0x11, 0x07, 0x07, 0x64, 0x30, 0xec, 0x28, 0x1a, 0x34, 0x3b, 0x6d, 0x26,
+	0xf4, 0xed, 0x0d, 0xa1, 0x7d, 0x92, 0x05, 0x32, 0xbb, 0xd5, 0xf2, 0x19, 0xb4, 0x02, 0xa9, 0x7c,
+	0x72, 0x4a, 0x87, 0xd3, 0x77, 0xe5, 0x0d, 0xcd, 0x9a, 0x37, 0x78, 0x7f, 0x67, 0x41, 0x77, 0x94,
+	0x64, 0xf9, 0x91, 0x54, 0x4a, 0x4c, 0x25, 0x7b, 0x00, 0xed, 0x04, 0xb7, 0x35, 0x12, 0x76, 0xf1,
+	0x4e, 0x74, 0x0e, 0xd7, 0xf8, 0x15, 0x3d, 0x34, 0x5e, 0xad, 0x07, 0xb4, 0x12, 0xf2, 0xa3, 0xa6,
+	0xb1, 0x12, 0xf2, 0xa2, 0x7b, 0x60, 0x27, 0x17, 0x17, 0x4a, 0x6a, 0x59, 0xb6, 0xb9, 0x81, 0x5e,
+	0x69, 0x6c, 0xde, 0xef, 0x00, 0xe0, 0xfd, 0x7e, 0xa4, 0x15, 0x78, 0x97, 0xd0, 0xe5, 0xe2, 0x22,
+	0xdf, 0x4b, 0xe2, 0x5c, 0x2e, 0x72, 0xb6, 0x0e, 0x8d, 0x30, 0x20, 0x11, 0xd9, 0xbc, 0x11, 0x06,
+	0x78, 0xb9, 0x69, 0x96, 0xcc, 0x53, 0x92, 0xd0, 0x1a, 0xd7, 0x00, 0x89, 0x32, 0x08, 0x32, 0xba,
+	0x31, 0x8a, 0x32, 0x08, 0x32, 0xf6, 0x00, 0xba, 0x2a, 0x16, 0xa9, 0xba, 0x4c, 0x72, 0xbc, 0x5c,
+	0x8b, 0x2e, 0x07, 0x05, 0x6a, 0xac, 0xbc, 0x7f, 0xb1, 0xc0, 0x3e, 0x92, 0xb3, 0x73, 0x99, 0xbd,
+	0x74, 0xca, 0x3b, 0xe0, 0xd0, 0xc6, 0x93, 0x30, 0x30, 0x07, 0x75, 0x08, 0x3e, 0x08, 0x6e, 0x3d,
+	0xea, 0x1e, 0xd8, 0x91, 0x14, 0x28, 0x7c, 0x6d, 0x67, 0x06, 0x42, 0xd9, 0x88, 0xd9, 0x24, 0x90,
+	0x22, 0xa0, 0xc0, 0xe3, 0x70, 0x5b, 0xcc, 0xf6, 0xa5, 0x08, 0xf0, 0x6e, 0x91, 0x50, 0xf9, 0x64,
+	0x9e, 0x06, 0x22, 0x97, 0x14, 0x70, 0x5a, 0x68, 0x38, 0x2a, 0x3f, 0x23, 0x0c, 0x7b, 0x04, 0x6f,
+	0xf8, 0xd1, 0x5c, 0x61, 0xb4, 0x0b, 0xe3, 0x8b, 0x64, 0x92, 0xc4, 0xd1, 0x0d, 0xc9, 0xd7, 0xe1,
+	0x77, 0x0d, 0xe1, 0x20, 0xbe, 0x48, 0x4e, 0xe2, 0xe8, 0xc6, 0xfb, 0x6d, 0x03, 0xda, 0xcf, 0x49,
+	0x0c, 0x4f, 0xa0, 0x33, 0xa3, 0x07, 0x15, 0xde, 0x7b, 0x0f, 0x25, 0x4c, 0xb4, 0x6d, 0xfd, 0x52,
+	0x35, 0x8c, 0xf3, 0xec, 0x86, 0x17, 0x6c, 0xb8, 0x22, 0x17, 0xe7, 0x91, 0xcc, 0x95, 0xb1, 0x88,
+	0xda, 0x8a, 0xb1, 0x26, 0x98, 0x15, 0x86, 0x6d, 0x55, 0xac, 0xcd, 0x55, 0xb1, 0xb2, 0x0d, 0x70,
+	0xfc, 0x4b, 0xe9, 0x5f, 0xa9, 0xf9, 0xcc, 0x08, 0xbd, 0x84, 0x37, 0x9e, 0x41, 0xaf, 0x7e, 0x0f,
+	0xcc, 0x4c, 0x57, 0xf2, 0x86, 0x04, 0xdf, 0xe2, 0xf8, 0xc9, 0x36, 0xa1, 0x4d, 0x1e, 0x4e, 0x62,
+	0xef, 0xee, 0x00, 0x5e, 0x47, 0x2f, 0xe1, 0x9a, 0xf0, 0xcb, 0xc6, 0x2f, 0x2c, 0xdc, 0xa7, 0x7e,
+	0xbb, 0xfa, 0x3e, 0xee, 0xab, 0xf7, 0xd1, 0x4b, 0x6a, 0xfb, 0x78, 0xff, 0xd3, 0x80, 0xde, 0x37,
+	0x32, 0x4b, 0x4e, 0xb3, 0x24, 0x4d, 0x94, 0x88, 0xd8, 0xee, 0xf2, 0xeb, 0xb4, 0x14, 0x37, 0x71,
+	0x71, 0x9d, 0x6d, 0x7b, 0x54, 0x3e, 0x57, 0x4b, 0xa7, 0xfe, 0x7e, 0x0f, 0x6c, 0x2d, 0xdd, 0x5b,
+	0x9e, 0x60, 0x28, 0xc8, 0xa3, 0xe5, 0x49, 0xf2, 0x5b, 0xbe, 0x9e, 0xa1, 0xb0, 0xfb, 0x00, 0x33,
+	0xb1, 0x38, 0x94, 0x42, 0xc9, 0x83, 0xa0, 0x30, 0xdf, 0x0a, 0x83, 0x72, 0x9e, 0x89, 0xc5, 0x78,
+	0x11, 0x8f, 0x15, 0x59, 0x57, 0x8b, 0x97, 0x30, 0xfb, 0x19, 0xb8, 0x33, 0xb1, 0x40, 0x3f, 0x3a,
+	0x08, 0x8c, 0x75, 0x55, 0x08, 0xf6, 0x2e, 0x34, 0xf3, 0x45, 0x4c, 0x41, 0x09, 0xb3, 0x13, 0x96,
+	0x1e, 0xe3, 0x45, 0x6c, 0x3c, 0x8e, 0x23, 0xad, 0x10, 0xa8, 0x53, 0x09, 0xb4, 0x0f, 0x4d, 0x3f,
+	0x0c, 0x28, 0x3d, 0xb9, 0x1c, 0x3f, 0x37, 0xfe, 0x00, 0xee, 0xae, 0xc8, 0xa1, 0xae, 0x87, 0x35,
+	0xbd, 0xec, 0xad, 0xba, 0x1e, 0x5a, 0x75, 0xd9, 0xff, 0xb6, 0x09, 0x77, 0x8d, 0x31, 0x5c, 0x86,
+	0xe9, 0x28, 0x47, 0xb3, 0x1f, 0x40, 0x87, 0xa2, 0x8d, 0xcc, 0x8c, 0x4d, 0x14, 0x20, 0xfb, 0x3d,
+	0xb0, 0xc9, 0x03, 0x0b, 0x3b, 0x7d, 0x50, 0x49, 0xb5, 0x5c, 0xae, 0xed, 0xd6, 0xa8, 0xc4, 0xb0,
+	0xb3, 0x2f, 0xa0, 0xfd, 0xad, 0xcc, 0x12, 0x1d, 0x3d, 0xbb, 0x3b, 0xf7, 0x6f, 0x5b, 0x87, 0xba,
+	0x35, 0xcb, 0x34, 0xf3, 0xff, 0xa3, 0xf0, 0xdf, 0xc7, 0x78, 0x39, 0x4b, 0xae, 0x65, 0x30, 0xe8,
+	0xd0, 0x8d, 0xea, 0xf6, 0x51, 0x90, 0x0a, 0x69, 0x3b, 0x95, 0xb4, 0xf7, 0xa1, 0x5b, 0x7b, 0xde,
+	0x2d, 0x92, 0x7e, 0xb0, 0x6c, 0xf1, 0x6e, 0xe9, 0xc8, 0x75, 0xc7, 0xd9, 0x07, 0xa8, 0x1e, 0xfb,
+	0x7f, 0x75, 0x3f, 0xef, 0x2f, 0x2c, 0xb8, 0xbb, 0x97, 0xc4, 0xb1, 0xa4, 0xc2, 0x48, 0xab, 0xae,
+	0x32, 0x7b, 0xeb, 0x95, 0x66, 0xff, 0x11, 0xb4, 0x15, 0x32, 0x9b, 0xdd, 0xdf, 0xbc, 0x45, 0x17,
+	0x5c, 0x73, 0x60, 0x98, 0x99, 0x89, 0xc5, 0x24, 0x95, 0x71, 0x10, 0xc6, 0xd3, 0x22, 0xcc, 0xcc,
+	0xc4, 0xe2, 0x54, 0x63, 0xbc, 0xbf, 0xb7, 0xc0, 0xd6, 0x1e, 0xb3, 0x14, 0xad, 0xad, 0xe5, 0x68,
+	0xfd, 0x33, 0x70, 0xd3, 0x4c, 0x06, 0xa1, 0x5f, 0x9c, 0xea, 0xf2, 0x0a, 0x81, 0xc6, 0x79, 0x91,
+	0x64, 0xbe, 0xa4, 0xed, 0x1d, 0xae, 0x01, 0xc4, 0xaa, 0x54, 0xf8, 0xba, 0xb8, 0x6b, 0x72, 0x0d,
+	0x60, 0x8c, 0xd7, 0xca, 0x21, 0xa5, 0x38, 0xdc, 0x40, 0x58, 0x95, 0x52, 0xfe, 0xa3, 0x08, 0xed,
+	0x12, 0xc9, 0x41, 0x04, 0x85, 0xe6, 0x7f, 0x6c, 0x40, 0x6f, 0x3f, 0xcc, 0xa4, 0x9f, 0xcb, 0x60,
+	0x18, 0x4c, 0x69, 0x17, 0x19, 0xe7, 0x61, 0x7e, 0x63, 0x92, 0x8d, 0x81, 0xca, 0x5a, 0xa0, 0xb1,
+	0x5c, 0x05, 0x6b, 0x5d, 0x34, 0xa9, 0x70, 0xd7, 0x00, 0xdb, 0x01, 0xd0, 0x55, 0x12, 0x15, 0xef,
+	0xad, 0x57, 0x17, 0xef, 0x2e, 0xb1, 0xe1, 0x27, 0x0a, 0x48, 0xaf, 0x09, 0x75, 0x22, 0xb2, 0xa9,
+	0xb2, 0x9f, 0xa3, 0x21, 0x53, 0x71, 0x71, 0x2e, 0x23, 0x32, 0x54, 0x2a, 0x2e, 0xce, 0x65, 0x54,
+	0x96, 0x74, 0x1d, 0x7d, 0x1d, 0xfc, 0x66, 0xef, 0x41, 0x23, 0x49, 0xe9, 0xf1, 0xe6, 0xc0, 0xfa,
+	0xc3, 0xb6, 0x4f, 0x52, 0xde, 0x48, 0x52, 0xb4, 0x02, 0x5d, 0xa9, 0x0e, 0x5c, 0x63, 0xdc, 0x18,
+	0x5d, 0xa8, 0x9a, 0xe2, 0x86, 0xe2, 0xdd, 0x83, 0xc6, 0x49, 0xca, 0x3a, 0xd0, 0x1c, 0x0d, 0xc7,
+	0xfd, 0x3b, 0xf8, 0xb1, 0x3f, 0x3c, 0xec, 0x5b, 0xde, 0x5f, 0x37, 0xc0, 0x3d, 0x9a, 0xe7, 0x02,
+	0x6d, 0x4a, 0xbd, 0x4e, 0xa9, 0xef, 0x80, 0xa3, 0x72, 0x91, 0x51, 0x84, 0xd6, 0x61, 0xa5, 0x43,
+	0xf0, 0x58, 0xb1, 0x0f, 0xa1, 0x2d, 0x83, 0xa9, 0x2c, 0xbc, 0xbd, 0xbf, 0x7a, 0x4f, 0xae, 0xc9,
+	0x6c, 0x0b, 0x6c, 0xe5, 0x5f, 0xca, 0x99, 0x18, 0xb4, 0x2a, 0xc6, 0x11, 0x61, 0x74, 0x06, 0xe6,
+	0x86, 0x4e, 0x8d, 0x45, 0x96, 0xa4, 0x54, 0x69, 0xb7, 0x4d, 0x63, 0x91, 0x25, 0x29, 0xd6, 0xd9,
+	0x3b, 0xf0, 0x93, 0x70, 0x1a, 0x27, 0x99, 0x9c, 0x84, 0x71, 0x20, 0x17, 0x13, 0x3f, 0x89, 0x2f,
+	0xa2, 0xd0, 0xcf, 0x49, 0x96, 0x0e, 0x7f, 0x53, 0x13, 0x0f, 0x90, 0xb6, 0x67, 0x48, 0xec, 0x7d,
+	0x68, 0xa3, 0xe2, 0x94, 0x71, 0x7e, 0x2a, 0x36, 0x51, 0x47, 0xe6, 0x54, 0x4d, 0xf4, 0x16, 0xe0,
+	0x14, 0xa1, 0x95, 0x7d, 0x84, 0x31, 0x91, 0x42, 0xb3, 0xf1, 0x2c, 0xea, 0x27, 0x6a, 0x35, 0x12,
+	0x2f, 0xe8, 0xa8, 0x4c, 0xba, 0x49, 0x11, 0x6c, 0x09, 0xa8, 0x57, 0x68, 0xcd, 0xa5, 0x76, 0x00,
+	0x8b, 0xcd, 0x24, 0x96, 0xa6, 0x68, 0xa1, 0x6f, 0xef, 0x6f, 0x1b, 0xe0, 0x94, 0xd9, 0xf0, 0x63,
+	0x70, 0x67, 0x85, 0x42, 0x8c, 0xcf, 0x52, 0x39, 0x5e, 0x6a, 0x89, 0x57, 0x74, 0x76, 0x0f, 0x1a,
+	0x57, 0xd7, 0x46, 0x9c, 0x36, 0x72, 0x7d, 0xfd, 0x82, 0x37, 0xae, 0xae, 0x2b, 0xa7, 0x6f, 0x7f,
+	0xaf, 0xd3, 0x3f, 0x84, 0xbb, 0x7e, 0x24, 0x45, 0x3c, 0xa9, 0x7c, 0x56, 0x9b, 0xe5, 0x3a, 0xa1,
+	0x4f, 0x4b, 0xc7, 0x35, 0x81, 0xab, 0x53, 0xa5, 0xa7, 0x0f, 0xa0, 0x1d, 0xc8, 0x28, 0x17, 0xf5,
+	0x9e, 0xeb, 0x24, 0x13, 0x7e, 0x24, 0xf7, 0x11, 0xcd, 0x35, 0x95, 0x6d, 0x81, 0x53, 0xa4, 0x6a,
+	0xd3, 0x69, 0x51, 0xf1, 0x5e, 0x08, 0x9b, 0x97, 0xd4, 0x4a, 0x96, 0x50, 0x93, 0xa5, 0xf7, 0x19,
+	0x34, 0xbf, 0x7e, 0x31, 0x32, 0x6f, 0xb5, 0x5e, 0x7a, 0x6b, 0x21, 0xd1, 0x46, 0x4d, 0xa2, 0xff,
+	0xdd, 0x84, 0x8e, 0xf1, 0x4d, 0xbc, 0xf7, 0xbc, 0x2c, 0x34, 0xf1, 0x73, 0x39, 0x3f, 0x96, 0x4e,
+	0x5e, 0xef, 0xcf, 0x9b, 0xdf, 0xdf, 0x9f, 0xb3, 0x5f, 0x42, 0x2f, 0xd5, 0xb4, 0x7a, 0x58, 0x78,
+	0xbb, 0xbe, 0xc6, 0xfc, 0xd2, 0xba, 0x6e, 0x5a, 0x01, 0x68, 0xe0, 0xd4, 0xd2, 0xe4, 0x62, 0x4a,
+	0x2a, 0xea, 0xf1, 0x0e, 0xc2, 0x63, 0x31, 0x7d, 0x45, 0x70, 0xf8, 0x01, 0x3e, 0x8e, 0x05, 0x75,
+	0x92, 0x0e, 0x7a, 0xe4, 0xb7, 0x18, 0x17, 0xea, 0x2e, 0xbb, 0xb6, 0xec, 0xb2, 0x3f, 0x05, 0xd7,
+	0x4f, 0x66, 0xb3, 0x90, 0x68, 0xeb, 0xa6, 0x60, 0x24, 0xc4, 0x58, 0x79, 0x7f, 0x65, 0x41, 0xc7,
+	0xbc, 0x96, 0x75, 0xa1, 0xb3, 0x3f, 0x7c, 0xb6, 0x7b, 0x76, 0x88, 0x51, 0x03, 0xc0, 0x7e, 0x7a,
+	0x70, 0xbc, 0xcb, 0xff, 0xa4, 0x6f, 0x61, 0x04, 0x39, 0x38, 0x1e, 0xf7, 0x1b, 0xcc, 0x85, 0xf6,
+	0xb3, 0xc3, 0x93, 0xdd, 0x71, 0xbf, 0xc9, 0x1c, 0x68, 0x3d, 0x3d, 0x39, 0x39, 0xec, 0xb7, 0x58,
+	0x0f, 0x9c, 0xfd, 0xdd, 0xf1, 0x70, 0x7c, 0x70, 0x34, 0xec, 0xb7, 0x91, 0xf7, 0xf9, 0xf0, 0xa4,
+	0x6f, 0xe3, 0xc7, 0xd9, 0xc1, 0x7e, 0xbf, 0x83, 0xf4, 0xd3, 0xdd, 0xd1, 0xe8, 0x57, 0x27, 0x7c,
+	0xbf, 0xef, 0xe0, 0xbe, 0xa3, 0x31, 0x3f, 0x38, 0x7e, 0xde, 0x77, 0xf1, 0xfb, 0xe4, 0xe9, 0x57,
+	0xc3, 0xbd, 0x71, 0x1f, 0xbc, 0xcf, 0xa0, 0x5b, 0x93, 0x20, 0xae, 0xe6, 0xc3, 0x67, 0xfd, 0x3b,
+	0x78, 0xe4, 0x8b, 0xdd, 0xc3, 0xb3, 0x61, 0xdf, 0x62, 0xeb, 0x00, 0xf4, 0x39, 0x39, 0xdc, 0x3d,
+	0x7e, 0xde, 0x6f, 0x78, 0xbf, 0x0b, 0xce, 0x59, 0x18, 0x3c, 0x8d, 0x12, 0xff, 0x0a, 0x0d, 0xe3,
+	0x5c, 0x28, 0x69, 0x52, 0x2d, 0x7d, 0x63, 0x2e, 0x20, 0xa3, 0x54, 0x46, 0xf7, 0x06, 0xf2, 0x8e,
+	0xa1, 0x73, 0x16, 0x06, 0xa7, 0xc2, 0xbf, 0xc2, 0x46, 0xff, 0x1c, 0xd7, 0x4f, 0x54, 0xf8, 0xad,
+	0x34, 0x61, 0xd0, 0x25, 0xcc, 0x28, 0xfc, 0x56, 0xb2, 0xf7, 0xc1, 0x26, 0xa0, 0x28, 0x8a, 0xc8,
+	0x96, 0x8b, 0x33, 0xb9, 0xa1, 0x79, 0x79, 0x79, 0x75, 0x6a, 0xd7, 0x1f, 0x40, 0x2b, 0x15, 0xfe,
+	0x95, 0x09, 0x26, 0x5d, 0xb3, 0x04, 0x8f, 0xe3, 0x44, 0x60, 0x0f, 0xc1, 0x31, 0xf6, 0x51, 0xec,
+	0xdb, 0xad, 0x19, 0x12, 0x2f, 0x89, 0xcb, 0x9a, 0x6b, 0xae, 0x68, 0xee, 0x0b, 0x80, 0x6a, 0xe6,
+	0x71, 0x4b, 0x81, 0xfe, 0x16, 0xb4, 0x45, 0x14, 0x9a, 0xc7, 0xbb, 0x5c, 0x03, 0xde, 0x31, 0x74,
+	0x6b, 0x93, 0x12, 0x34, 0x1b, 0x11, 0x45, 0x93, 0x2b, 0x79, 0xa3, 0x68, 0xad, 0xc3, 0x3b, 0x22,
+	0x8a, 0xbe, 0x96, 0x37, 0x0a, 0x03, 0xa9, 0x1e, 0xb2, 0x34, 0x56, 0xba, 0x76, 0x5a, 0xca, 0x35,
+	0xd1, 0xfb, 0x04, 0x6c, 0xdd, 0xca, 0xd7, 0xac, 0xd6, 0x7a, 0x65, 0x66, 0xfa, 0xd2, 0xdc, 0x99,
+	0x1a, 0x7f, 0xf6, 0xb1, 0x19, 0xe6, 0x28, 0x3d, 0x3a, 0xb2, 0xaa, 0x6a, 0x4d, 0x33, 0x99, 0x39,
+	0x0e, 0x31, 0x7b, 0xfb, 0xe0, 0xbc, 0x76, 0x3c, 0x66, 0x04, 0xd0, 0xa8, 0x04, 0x70, 0xcb, 0xc0,
+	0xcc, 0xfb, 0x35, 0x40, 0x35, 0xf4, 0x31, 0x4e, 0xa4, 0x77, 0x41, 0x27, 0x7a, 0x84, 0x9d, 0x55,
+	0x18, 0x05, 0x99, 0x8c, 0x97, 0x5e, 0x5d, 0x8d, 0x89, 0x4a, 0x3a, 0xdb, 0x84, 0x16, 0xcd, 0xb2,
+	0x9a, 0x55, 0x90, 0x2b, 0x07, 0x59, 0x44, 0xf1, 0x16, 0xb0, 0xa6, 0x13, 0x1e, 0x97, 0x7f, 0x3e,
+	0x97, 0xea, 0xb5, 0x65, 0xd4, 0x7d, 0x80, 0x32, 0x24, 0x17, 0x53, 0xb9, 0x1a, 0x06, 0x4d, 0xf9,
+	0x22, 0x94, 0x51, 0x50, 0xbc, 0xc6, 0x40, 0xa8, 0x64, 0x9d, 0xed, 0x5a, 0x7a, 0x74, 0xa1, 0xb3,
+	0xdb, 0xef, 0x43, 0xaf, 0x38, 0x99, 0x66, 0x03, 0x1f, 0x97, 0xc9, 0x58, 0xcb, 0x58, 0xb7, 0x24,
+	0x9a, 0xe5, 0x38, 0x09, 0xe4, 0xd3, 0xc6, 0xc0, 0x2a, 0xf2, 0xb1, 0xf7, 0xef, 0xcd, 0x62, 0xb5,
+	0x69, 0x95, 0x97, 0x4a, 0x3c, 0x6b, 0xb5, 0xc4, 0x5b, 0x2e, 0x97, 0x1a, 0x3f, 0xa8, 0x5c, 0xfa,
+	0x05, 0xb8, 0x01, 0xd5, 0x0c, 0xe1, 0x75, 0x11, 0x7e, 0x37, 0x56, 0xeb, 0x03, 0x53, 0x55, 0x84,
+	0xd7, 0x92, 0x57, 0xcc, 0x78, 0x97, 0x3c, 0xb9, 0x92, 0x71, 0xf8, 0x2d, 0xcd, 0x02, 0xf0, 0xcd,
+	0x15, 0xa2, 0x1a, 0xac, 0xe8, 0x3a, 0xc2, 0x0c, 0x56, 0x8a, 0x19, 0x91, 0x5d, 0xcd, 0x88, 0x50,
+	0x9e, 0xf3, 0x54, 0xc9, 0x2c, 0x2f, 0x8a, 0x4d, 0x0d, 0x95, 0x75, 0x99, 0x6b, 0x78, 0xb1, 0x2e,
+	0x7b, 0x17, 0x7a, 0x71, 0x12, 0x4f, 0xe2, 0x79, 0x14, 0x61, 0x39, 0x6c, 0xc6, 0x81, 0xdd, 0x38,
+	0x89, 0x8f, 0x0d, 0x8a, 0x3d, 0x82, 0x37, 0xea, 0x2c, 0xda, 0x9e, 0xbb, 0x7a, 0x9a, 0x50, 0xe3,
+	0x23, 0xab, 0xdf, 0x82, 0x7e, 0x72, 0xfe, 0x6b, 0xe9, 0xe7, 0x24, 0xb1, 0x09, 0x19, 0x72, 0x4f,
+	0x27, 0x61, 0x8d, 0x47, 0x11, 0x1d, 0x8b, 0x99, 0xf4, 0xbe, 0x04, 0xb7, 0x14, 0x02, 0xc6, 0xdb,
+	0xe3, 0x93, 0xe3, 0xa1, 0x8e, 0x88, 0x07, 0xc7, 0xfb, 0xc3, 0x3f, 0xee, 0x5b, 0x18, 0xb1, 0xf9,
+	0xf0, 0xc5, 0x90, 0x8f, 0x86, 0xfd, 0x06, 0x46, 0xd3, 0xfd, 0xe1, 0xe1, 0x70, 0x3c, 0xec, 0x37,
+	0xbf, 0x6a, 0x39, 0x9d, 0xbe, 0xc3, 0x1d, 0xb9, 0x48, 0xa3, 0xd0, 0x0f, 0x73, 0x6f, 0x04, 0x50,
+	0x15, 0x41, 0x18, 0x57, 0xaa, 0xb3, 0xb5, 0x46, 0x9d, 0xdc, 0x9c, 0x8a, 0x95, 0x9b, 0x31, 0xb5,
+	0xc6, 0xab, 0x2a, 0x37, 0x4d, 0xf7, 0xce, 0xc0, 0x39, 0x12, 0xe9, 0x4b, 0x9d, 0x4e, 0xaf, 0xec,
+	0x67, 0xe7, 0x66, 0xba, 0x63, 0x52, 0xf1, 0x07, 0xd0, 0x31, 0xa1, 0xcd, 0x78, 0xcd, 0x52, 0xd8,
+	0x2b, 0x68, 0xde, 0x5f, 0x5a, 0xf0, 0xd6, 0x51, 0x72, 0x2d, 0xcb, 0x6a, 0xe4, 0x54, 0xdc, 0x44,
+	0x89, 0x08, 0xbe, 0xc7, 0x10, 0x7f, 0x0e, 0xa0, 0x92, 0x79, 0xe6, 0xcb, 0xc9, 0xb4, 0x1c, 0x2a,
+	0xb9, 0x1a, 0xf3, 0xdc, 0xcc, 0xaf, 0xa5, 0xca, 0x89, 0xd8, 0xd4, 0xce, 0x87, 0x30, 0x92, 0x7e,
+	0x02, 0x76, 0xbe, 0x88, 0xab, 0x19, 0x56, 0x3b, 0xc7, 0x36, 0xd3, 0xdb, 0x03, 0x77, 0xbc, 0xa0,
+	0xe6, 0x6b, 0xae, 0x96, 0xf2, 0xab, 0xf5, 0x9a, 0xfc, 0xda, 0x58, 0x89, 0xd2, 0xff, 0x65, 0x41,
+	0xb7, 0x56, 0x26, 0xb1, 0x77, 0xa1, 0x95, 0x2f, 0xe2, 0xe5, 0xe1, 0x6f, 0x71, 0x08, 0x27, 0x12,
+	0xda, 0x1b, 0x76, 0x66, 0x42, 0xa9, 0x70, 0x1a, 0xcb, 0xc0, 0x6c, 0x89, 0xdd, 0xda, 0xae, 0x41,
+	0xb1, 0x43, 0xb8, 0xab, 0x23, 0x49, 0x31, 0xf8, 0x29, 0xea, 0xf1, 0xf7, 0x56, 0xca, 0x32, 0xdd,
+	0xa0, 0xee, 0x15, 0x5c, 0xba, 0x05, 0x5f, 0x9f, 0x2e, 0x21, 0x37, 0x76, 0xe1, 0xcd, 0x5b, 0xd8,
+	0x7e, 0xd4, 0xac, 0xe1, 0x01, 0xac, 0x61, 0x6f, 0x1e, 0xce, 0xa4, 0xca, 0xc5, 0x2c, 0xa5, 0xfa,
+	0xc4, 0x64, 0x82, 0x16, 0x6f, 0xe4, 0xca, 0xfb, 0x10, 0x7a, 0xa7, 0x52, 0x66, 0x5c, 0xaa, 0x34,
+	0x89, 0x75, 0x6e, 0x56, 0xf4, 0x68, 0x93, 0x76, 0x0c, 0xe4, 0xfd, 0x19, 0xb8, 0x58, 0x79, 0x3f,
+	0x15, 0xb9, 0x7f, 0xf9, 0x63, 0x2a, 0xf3, 0x0f, 0xa1, 0x93, 0x6a, 0x33, 0x31, 0x75, 0x74, 0x8f,
+	0x62, 0x9c, 0x31, 0x1d, 0x5e, 0x10, 0xbd, 0x2f, 0xa0, 0x79, 0x3c, 0x9f, 0xd5, 0xff, 0xb1, 0x69,
+	0xe9, 0x7f, 0x6c, 0x96, 0xda, 0xcc, 0xc6, 0x4a, 0x9b, 0xf9, 0x0d, 0x74, 0x0b, 0xd9, 0x1f, 0x04,
+	0xf4, 0xb7, 0x0b, 0x29, 0xff, 0x20, 0x58, 0xb2, 0x05, 0xdd, 0xed, 0xc9, 0x38, 0x38, 0x28, 0x94,
+	0xa6, 0x81, 0xe5, 0xbd, 0xcd, 0x34, 0xa3, 0xdc, 0xfb, 0x19, 0xf4, 0x8a, 0xea, 0xf8, 0x48, 0xe6,
+	0x82, 0xcc, 0x29, 0x0a, 0x65, 0x5c, 0x33, 0x35, 0x47, 0x23, 0xc6, 0xea, 0x35, 0x73, 0x53, 0x6f,
+	0x1b, 0x6c, 0x63, 0xab, 0x0c, 0x5a, 0x7e, 0x12, 0x68, 0x17, 0x69, 0x73, 0xfa, 0xc6, 0x07, 0xcf,
+	0xd4, 0xb4, 0x48, 0x8f, 0x33, 0x35, 0xc5, 0xf4, 0xf4, 0x54, 0xf8, 0x57, 0xf3, 0xb4, 0x48, 0x4f,
+	0xb5, 0x36, 0xc6, 0x5a, 0x6a, 0x63, 0x5e, 0x33, 0xac, 0x7d, 0x1b, 0x3a, 0xf3, 0x38, 0x5c, 0x14,
+	0xf5, 0x89, 0xcb, 0x6d, 0x04, 0xf5, 0x90, 0x32, 0x4a, 0x7c, 0xea, 0x5c, 0xc8, 0xab, 0x5c, 0x5e,
+	0xc2, 0xde, 0x9f, 0xc2, 0xda, 0x70, 0x91, 0xd2, 0xe8, 0xfa, 0x7b, 0x13, 0x63, 0xed, 0x52, 0x8d,
+	0xa5, 0x4b, 0xad, 0x9c, 0xdc, 0x2c, 0x4e, 0xde, 0xf9, 0x67, 0x0b, 0x5a, 0x68, 0x22, 0xd8, 0x5c,
+	0xfd, 0xa1, 0x14, 0x59, 0x7e, 0x2e, 0x45, 0xce, 0x96, 0xcc, 0x61, 0x63, 0x09, 0xf2, 0xee, 0x3c,
+	0xb1, 0xd8, 0x27, 0x7a, 0x2a, 0x5e, 0x0c, 0xfb, 0xd7, 0x0a, 0x43, 0x23, 0x43, 0x5c, 0xe5, 0x67,
+	0xdb, 0xd0, 0xfd, 0x2a, 0x09, 0xe3, 0x3d, 0x3d, 0x28, 0x66, 0xab, 0x66, 0xf9, 0x12, 0xff, 0xa7,
+	0x60, 0x1f, 0x28, 0xb4, 0xff, 0x97, 0x59, 0x29, 0xbc, 0xd6, 0x5d, 0xc3, 0xbb, 0xb3, 0xf3, 0x4f,
+	0x4d, 0x68, 0x7d, 0x23, 0xb3, 0x84, 0x7d, 0x02, 0x1d, 0x33, 0x06, 0x62, 0xb5, 0x71, 0xcf, 0x06,
+	0xe5, 0xd7, 0x95, 0xf9, 0x10, 0x9d, 0xd2, 0xd7, 0x11, 0xba, 0xea, 0xfe, 0x58, 0x35, 0xa5, 0x7a,
+	0xe9, 0x52, 0x5f, 0x42, 0x7f, 0x94, 0x67, 0x52, 0xcc, 0x6a, 0xec, 0xcb, 0x62, 0xba, 0xad, 0x95,
+	0x24, 0x69, 0x7d, 0x0c, 0xb6, 0x0e, 0x32, 0x2b, 0x0b, 0x56, 0xbb, 0x42, 0x62, 0x7e, 0x08, 0xdd,
+	0xd1, 0x65, 0x32, 0x8f, 0x82, 0x91, 0xcc, 0xae, 0x25, 0xab, 0x8d, 0x62, 0x37, 0x6a, 0xdf, 0xde,
+	0x1d, 0xb6, 0x05, 0xa0, 0xbd, 0xec, 0x2c, 0x0c, 0x14, 0xeb, 0x20, 0xed, 0x78, 0x3e, 0xd3, 0x9b,
+	0xd6, 0xdc, 0x4f, 0x73, 0xd6, 0x62, 0xcd, 0xeb, 0x38, 0x3f, 0x87, 0xb5, 0x3d, 0x8a, 0xc5, 0x27,
+	0xd9, 0xee, 0x79, 0x92, 0xe5, 0x6c, 0x75, 0x1c, 0xbb, 0xb1, 0x8a, 0xf0, 0xee, 0xb0, 0x27, 0xe0,
+	0x8c, 0xb3, 0x1b, 0xcd, 0xff, 0x86, 0x09, 0xd1, 0xd5, 0x79, 0xb7, 0xbc, 0x72, 0xe7, 0x1f, 0x9a,
+	0x60, 0xff, 0x2a, 0xc9, 0xae, 0x64, 0xc6, 0x1e, 0x81, 0x4d, 0xed, 0xbb, 0x31, 0xa2, 0xb2, 0x95,
+	0xbf, 0xed, 0xa0, 0xf7, 0xc1, 0x25, 0xa1, 0x8c, 0x85, 0xba, 0xd2, 0xaa, 0xa2, 0xff, 0x6c, 0xb5,
+	0x5c, 0x74, 0xf1, 0x46, 0x7a, 0x5d, 0xd7, 0x8a, 0x2a, 0x47, 0x16, 0x4b, 0x3d, 0xf5, 0x46, 0x47,
+	0x37, 0xc8, 0x23, 0xef, 0xce, 0x96, 0xf5, 0xc4, 0x62, 0x1f, 0x41, 0x6b, 0xa4, 0x5f, 0x8a, 0x4c,
+	0xd5, 0x3f, 0x58, 0x1b, 0xeb, 0x05, 0xa2, 0xdc, 0xf9, 0x31, 0xd8, 0x3a, 0xb3, 0xeb, 0x67, 0x2e,
+	0x95, 0xab, 0x1b, 0xfd, 0x3a, 0xca, 0x2c, 0xf8, 0x08, 0x6c, 0x1d, 0x34, 0xf4, 0x82, 0xa5, 0x00,
+	0xa2, 0x6f, 0xad, 0x63, 0x90, 0x66, 0xd5, 0x5e, 0xae, 0x59, 0x97, 0x3c, 0x7e, 0x85, 0xf5, 0x53,
+	0xe8, 0x73, 0xe9, 0xcb, 0xb0, 0x96, 0xf3, 0x59, 0xf1, 0xa8, 0x55, 0xb3, 0xdd, 0xb2, 0xd8, 0x97,
+	0xb0, 0xb6, 0x54, 0x1f, 0xb0, 0x01, 0x09, 0xfa, 0x96, 0x92, 0x61, 0x75, 0xf1, 0xd3, 0xfe, 0xbf,
+	0x7e, 0x77, 0xdf, 0xfa, 0xb7, 0xef, 0xee, 0x5b, 0xff, 0xf1, 0xdd, 0x7d, 0xeb, 0x37, 0xff, 0x79,
+	0xff, 0xce, 0xb9, 0x4d, 0xff, 0xf5, 0x7f, 0xfe, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xae, 0x40,
+	0x09, 0x1c, 0x2f, 0x20, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -5905,6 +5914,16 @@ func (m *Tablet) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i++
 	}
+	if m.ReadOnly {
+		dAtA[i] = 0x48
+		i++
+		if m.ReadOnly {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
 	if m.XXX_unrecognized != nil {
 		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
@@ -7996,6 +8015,9 @@ func (m *Tablet) Size() (n int) {
 	if m.Remove {
 		n += 2
 	}
+	if m.ReadOnly {
+		n += 2
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -12025,6 +12047,26 @@ func (m *Tablet) Unmarshal(dAtA []byte) error {
 				}
 			}
 			m.Remove = bool(v != 0)
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPb
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.ReadOnly = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPb(dAtA[iNdEx:])
diff --git a/query/query.go b/query/query.go
index 1bd6b7d80a6..ce4089bc6e9 100644
--- a/query/query.go
+++ b/query/query.go
@@ -171,6 +171,7 @@ type SubGraph struct {
 	ReadTs       uint64
 	Cache        int
 	Attr         string
+	UnknownAttr  bool
 	Params       params
 	counts       []uint32
 	valueMatrix  []*pb.ValueList
@@ -2031,7 +2032,9 @@ func ProcessGraph(ctx context.Context, sg, parent *SubGraph, rch chan error) {
 				return
 			}
 			result, err := worker.ProcessTaskOverNetwork(ctx, taskQuery)
-			if err != nil {
+			if err != nil && strings.Contains(err.Error(), worker.ErrUnservedTabletMessage) {
+				sg.UnknownAttr = true
+			} else if err != nil {
 				rch <- err
 				return
 			}
diff --git a/query/query0_test.go b/query/query0_test.go
index db4f10a8705..49999d82dc4 100644
--- a/query/query0_test.go
+++ b/query/query0_test.go
@@ -946,7 +946,7 @@ func TestQueryVarValOrderError(t *testing.T) {
 	`
 	_, err := processQuery(t, context.Background(), query)
 	require.Error(t, err)
-	require.Contains(t, err.Error(), "Cannot sort attribute n of type object.")
+	require.Contains(t, err.Error(), "Cannot sort by unknown attribute n")
 }
 
 func TestQueryVarValOrderDesc(t *testing.T) {
diff --git a/query/recurse.go b/query/recurse.go
index a06b6bb3557..cd4861c3bd2 100644
--- a/query/recurse.go
+++ b/query/recurse.go
@@ -51,6 +51,10 @@ func (start *SubGraph) expandRecurse(ctx context.Context, maxDepth uint64) error
 		return ctx.Err()
 	}
 
+	if start.UnknownAttr {
+		return nil
+	}
+
 	// Add children back and expand if necessary
 	if exec, err = expandChildren(ctx, start, startChildren); err != nil {
 		return err
@@ -90,6 +94,10 @@ func (start *SubGraph) expandRecurse(ctx context.Context, maxDepth uint64) error
 		}
 
 		for _, sg := range exec {
+			if sg.UnknownAttr {
+				continue
+			}
+
 			if len(sg.Filters) > 0 {
 				// We need to do this in case we had some filters.
 				sg.updateUidMatrix()
@@ -126,6 +134,9 @@ func (start *SubGraph) expandRecurse(ctx context.Context, maxDepth uint64) error
 		var out []*SubGraph
 		var exp []*SubGraph
 		for _, sg := range exec {
+			if sg.UnknownAttr == true {
+				continue
+			}
 			if len(sg.DestUIDs.Uids) == 0 {
 				continue
 			}
diff --git a/query/shortest.go b/query/shortest.go
index a0a78300246..7f5542759c2 100644
--- a/query/shortest.go
+++ b/query/shortest.go
@@ -176,6 +176,10 @@ func (sg *SubGraph) expandOut(ctx context.Context,
 				rch <- ctx.Err()
 				return
 			default:
+				if subgraph.UnknownAttr {
+					continue
+				}
+
 				// Send the destuids in res chan.
 				for mIdx, fromUID := range subgraph.SrcUIDs.Uids {
 					for lIdx, toUID := range subgraph.uidMatrix[mIdx].Uids {
diff --git a/worker/draft.go b/worker/draft.go
index 09e9b267f6c..7a601dd6a87 100644
--- a/worker/draft.go
+++ b/worker/draft.go
@@ -182,8 +182,10 @@ func (n *node) applyMutations(ctx context.Context, proposal *pb.Proposal) (rerr
 					return err
 				}
 
-				if !groups().ServesTablet(s.Predicate) {
-					return fmt.Errorf("Group 1 should always serve reserved predicate %s",
+				if servesTablet, err := groups().ServesTablet(s.Predicate); err != nil {
+					return err
+				} else if !servesTablet {
+					return fmt.Errorf("group 1 should always serve reserved predicate %s",
 						s.Predicate)
 				}
 			}
diff --git a/worker/export.go b/worker/export.go
index 357cce05d0c..bda92249e80 100644
--- a/worker/export.go
+++ b/worker/export.go
@@ -290,7 +290,7 @@ func export(ctx context.Context, in *pb.ExportRequest) error {
 		if pk.Attr == "_predicate_" {
 			return false
 		}
-		if !groups().ServesTablet(pk.Attr) {
+		if servesTablet, err := groups().ServesTablet(pk.Attr); err != nil || !servesTablet {
 			return false
 		}
 		// We need to ensure that schema keys are separately identifiable, so they can be
diff --git a/worker/groups.go b/worker/groups.go
index 7cc42ea52f9..e421e0d41d3 100644
--- a/worker/groups.go
+++ b/worker/groups.go
@@ -158,7 +158,10 @@ func (g *groupi) informZeroAboutTablets() {
 		failed := false
 		preds := schema.State().Predicates()
 		for _, pred := range preds {
-			if tablet := g.Tablet(pred); tablet == nil {
+			if tablet, err := g.Tablet(pred); err != nil {
+				failed = true
+				glog.Errorf("Error while getting tablet for pred %q: %v", pred, err)
+			} else if tablet == nil {
 				failed = true
 			}
 		}
@@ -308,31 +311,76 @@ func (g *groupi) ChecksumsMatch(ctx context.Context) error {
 	}
 }
 
-func (g *groupi) BelongsTo(key string) uint32 {
-	tablet := g.Tablet(key)
+func (g *groupi) BelongsTo(key string) (uint32, error) {
+	if tablet, err := g.Tablet(key); err != nil {
+		return 0, err
+	} else if tablet != nil {
+		return tablet.GroupId, nil
+	}
+	return 0, nil
+}
+
+// BelongsToReadOnly acts like BelongsTo except it does not ask zero to serve
+// the tablet for key if no group is currently serving it.
+func (g *groupi) BelongsToReadOnly(key string) (uint32, error) {
+	g.RLock()
+	tablet := g.tablets[key]
+	g.RUnlock()
 	if tablet != nil {
-		return tablet.GroupId
+		return tablet.GetGroupId(), nil
 	}
-	return 0
+
+	// We don't know about this tablet. Talk to dgraphzero to find out who is
+	// serving this tablet.
+	pl := g.connToZeroLeader()
+	zc := pb.NewZeroClient(pl.Get())
+
+	tablet = &pb.Tablet{
+		Predicate: key,
+		ReadOnly:  true,
+	}
+	out, err := zc.ShouldServe(context.Background(), tablet)
+	if err != nil {
+		glog.Errorf("Error while ShouldServe grpc call %v", err)
+		return 0, err
+	}
+	if out.GetGroupId() == 0 {
+		return 0, nil
+	}
+
+	g.Lock()
+	defer g.Unlock()
+	g.tablets[key] = out
+	return out.GetGroupId(), nil
+}
+
+func (g *groupi) ServesTablet(key string) (bool, error) {
+	if tablet, err := g.Tablet(key); err != nil {
+		return false, err
+	} else if tablet != nil && tablet.GroupId == groups().groupId() {
+		return true, nil
+	}
+	return false, nil
 }
 
-func (g *groupi) ServesTablet(key string) bool {
-	tablet := g.Tablet(key)
-	if tablet != nil && tablet.GroupId == groups().groupId() {
-		return true
+// ServesTabletReadOnly acts like ServesTablet except it does not ask zero to
+// serve the tablet for key if no group is currently serving it.
+func (g *groupi) ServesTabletReadOnly(key string) (bool, error) {
+	gid, err := g.BelongsToReadOnly(key)
+	if err != nil {
+		return false, err
 	}
-	return false
+	return gid == groups().groupId(), nil
 }
 
 // Do not modify the returned Tablet
-// TODO: This should return error.
-func (g *groupi) Tablet(key string) *pb.Tablet {
+func (g *groupi) Tablet(key string) (*pb.Tablet, error) {
 	// TODO: Remove all this later, create a membership state and apply it
 	g.RLock()
 	tablet, ok := g.tablets[key]
 	g.RUnlock()
 	if ok {
-		return tablet
+		return tablet, nil
 	}
 
 	// We don't know about this tablet.
@@ -344,7 +392,7 @@ func (g *groupi) Tablet(key string) *pb.Tablet {
 	out, err := zc.ShouldServe(context.Background(), tablet)
 	if err != nil {
 		glog.Errorf("Error while ShouldServe grpc call %v", err)
-		return nil
+		return nil, err
 	}
 	g.Lock()
 	g.tablets[key] = out
@@ -353,7 +401,7 @@ func (g *groupi) Tablet(key string) *pb.Tablet {
 	if out.GroupId == groups().groupId() {
 		glog.Infof("Serving tablet for: %v\n", key)
 	}
-	return out
+	return out, nil
 }
 
 func (g *groupi) HasMeInState() bool {
diff --git a/worker/mutation.go b/worker/mutation.go
index 9fed5521e2c..b1a5c936faa 100644
--- a/worker/mutation.go
+++ b/worker/mutation.go
@@ -39,7 +39,8 @@ import (
 )
 
 var (
-	errUnservedTablet = x.Errorf("Tablet isn't being served by this instance.")
+	ErrUnservedTabletMessage = "Tablet isn't being served by this instance"
+	errUnservedTablet        = x.Errorf(ErrUnservedTabletMessage)
 )
 
 func isStarAll(v []byte) bool {
@@ -111,10 +112,12 @@ func runSchemaMutation(ctx context.Context, update *pb.SchemaUpdate, startTs uin
 }
 
 func runSchemaMutationHelper(ctx context.Context, update *pb.SchemaUpdate, startTs uint64) error {
-	if !groups().ServesTablet(update.Predicate) {
-		tablet := groups().Tablet(update.Predicate)
+	if tablet, err := groups().Tablet(update.Predicate); err != nil {
+		return err
+	} else if tablet.GetGroupId() != groups().groupId() {
 		return x.Errorf("Tablet isn't being served by this group. Tablet: %+v", tablet)
 	}
+
 	if err := checkSchema(update); err != nil {
 		return err
 	}
@@ -442,10 +445,14 @@ func proposeOrSend(ctx context.Context, gid uint32, m *pb.Mutations, chr chan re
 
 // populateMutationMap populates a map from group id to the mutation that
 // should be sent to that group.
-func populateMutationMap(src *pb.Mutations) map[uint32]*pb.Mutations {
+func populateMutationMap(src *pb.Mutations) (map[uint32]*pb.Mutations, error) {
 	mm := make(map[uint32]*pb.Mutations)
 	for _, edge := range src.Edges {
-		gid := groups().BelongsTo(edge.Attr)
+		gid, err := groups().BelongsTo(edge.Attr)
+		if err != nil {
+			return nil, err
+		}
+
 		mu := mm[gid]
 		if mu == nil {
 			mu = &pb.Mutations{GroupId: gid}
@@ -455,7 +462,11 @@ func populateMutationMap(src *pb.Mutations) map[uint32]*pb.Mutations {
 	}
 
 	for _, schema := range src.Schema {
-		gid := groups().BelongsTo(schema.Predicate)
+		gid, err := groups().BelongsTo(schema.Predicate)
+		if err != nil {
+			return nil, err
+		}
+
 		mu := mm[gid]
 		if mu == nil {
 			mu = &pb.Mutations{GroupId: gid}
@@ -487,7 +498,7 @@ func populateMutationMap(src *pb.Mutations) map[uint32]*pb.Mutations {
 		}
 	}
 
-	return mm
+	return mm, nil
 }
 
 func commitOrAbort(ctx context.Context, startTs, commitTs uint64) error {
@@ -511,7 +522,10 @@ func MutateOverNetwork(ctx context.Context, m *pb.Mutations) (*api.TxnContext, e
 	defer span.End()
 
 	tctx := &api.TxnContext{StartTs: m.StartTs}
-	mutationMap := populateMutationMap(m)
+	mutationMap, err := populateMutationMap(m)
+	if err != nil {
+		return tctx, err
+	}
 
 	resCh := make(chan res, len(mutationMap))
 	for gid, mu := range mutationMap {
diff --git a/worker/mutation_test.go b/worker/mutation_test.go
index a72fc241a30..4a8070f5b61 100644
--- a/worker/mutation_test.go
+++ b/worker/mutation_test.go
@@ -126,7 +126,8 @@ func TestPopulateMutationMap(t *testing.T) {
 	}}
 	m := &pb.Mutations{Edges: edges, Schema: schema}
 
-	mutationsMap := populateMutationMap(m)
+	mutationsMap, err := populateMutationMap(m)
+	require.NoError(t, err)
 	mu := mutationsMap[1]
 	require.NotNil(t, mu)
 	require.NotNil(t, mu.Edges)
diff --git a/worker/predicate_move.go b/worker/predicate_move.go
index 2dec7326900..83efe4f2aae 100644
--- a/worker/predicate_move.go
+++ b/worker/predicate_move.go
@@ -186,7 +186,9 @@ func (w *grpcWorker) MovePredicate(ctx context.Context,
 	if err := posting.Oracle().WaitForTs(ctx, in.TxnTs); err != nil {
 		return &emptyPayload, x.Errorf("While waiting for txn ts: %d. Error: %v", in.TxnTs, err)
 	}
-	if !groups().ServesTablet(in.Predicate) {
+	if servesTablet, err := groups().ServesTablet(in.Predicate); err != nil {
+		return &emptyPayload, err
+	} else if !servesTablet {
 		return &emptyPayload, errUnservedTablet
 	}
 
diff --git a/worker/proposal.go b/worker/proposal.go
index 85220e08359..756bc202794 100644
--- a/worker/proposal.go
+++ b/worker/proposal.go
@@ -134,8 +134,9 @@ func (n *node) proposeAndWait(ctx context.Context, proposal *pb.Proposal) (perr
 	var noTimeout bool
 
 	checkTablet := func(pred string) error {
-		if tablet := groups().Tablet(pred); tablet == nil ||
-			tablet.GroupId != groups().groupId() {
+		if tablet, err := groups().Tablet(pred); err != nil {
+			return err
+		} else if tablet == nil || tablet.GroupId != groups().groupId() {
 			return errUnservedTablet
 		}
 		return nil
diff --git a/worker/schema.go b/worker/schema.go
index 7e22e6baf94..d8415aa3a8e 100644
--- a/worker/schema.go
+++ b/worker/schema.go
@@ -62,9 +62,12 @@ func getSchema(ctx context.Context, s *pb.SchemaRequest) (*pb.SchemaResult, erro
 	for _, attr := range predicates {
 		// This can happen after a predicate is moved. We don't delete predicate from schema state
 		// immediately. So lets ignore this predicate.
-		if !groups().ServesTablet(attr) {
+		if servesTablet, err := groups().ServesTabletReadOnly(attr); err != nil {
+			return nil, err
+		} else if !servesTablet {
 			continue
 		}
+
 		if schemaNode := populateSchema(attr, fields); schemaNode != nil {
 			result.Schema = append(result.Schema, schemaNode)
 		}
@@ -111,9 +114,13 @@ func populateSchema(attr string, fields []string) *api.SchemaNode {
 
 // addToSchemaMap groups the predicates by group id, if list of predicates is
 // empty then it adds all known groups
-func addToSchemaMap(schemaMap map[uint32]*pb.SchemaRequest, schema *pb.SchemaRequest) {
+func addToSchemaMap(schemaMap map[uint32]*pb.SchemaRequest, schema *pb.SchemaRequest) error {
 	for _, attr := range schema.Predicates {
-		gid := groups().BelongsTo(attr)
+		gid, err := groups().BelongsTo(attr)
+		if err != nil {
+			return err
+		}
+
 		s := schemaMap[gid]
 		if s == nil {
 			s = &pb.SchemaRequest{GroupId: gid}
@@ -123,7 +130,7 @@ func addToSchemaMap(schemaMap map[uint32]*pb.SchemaRequest, schema *pb.SchemaReq
 		s.Predicates = append(s.Predicates, attr)
 	}
 	if len(schema.Predicates) > 0 {
-		return
+		return nil
 	}
 	// TODO: Janardhan - node shouldn't serve any request until membership
 	// information is synced, should we fail health check till then ?
@@ -139,6 +146,7 @@ func addToSchemaMap(schemaMap map[uint32]*pb.SchemaRequest, schema *pb.SchemaReq
 			schemaMap[gid] = s
 		}
 	}
+	return nil
 }
 
 // If the current node serves the group serve the schema or forward
@@ -178,7 +186,9 @@ func GetSchemaOverNetwork(ctx context.Context, schema *pb.SchemaRequest) ([]*api
 
 	// Map of groupd id => Predicates for that group.
 	schemaMap := make(map[uint32]*pb.SchemaRequest)
-	addToSchemaMap(schemaMap, schema)
+	if err := addToSchemaMap(schemaMap, schema); err != nil {
+		return nil, err
+	}
 
 	results := make(chan resultErr, len(schemaMap))
 	var schemaNodes []*api.SchemaNode
diff --git a/worker/sort.go b/worker/sort.go
index 0e601a4ace3..77fac01e2a7 100644
--- a/worker/sort.go
+++ b/worker/sort.go
@@ -45,7 +45,13 @@ type sortresult struct {
 
 // SortOverNetwork sends sort query over the network.
 func SortOverNetwork(ctx context.Context, q *pb.SortMessage) (*pb.SortResult, error) {
-	gid := groups().BelongsTo(q.Order[0].Attr)
+	gid, err := groups().BelongsToReadOnly(q.Order[0].Attr)
+	if err != nil {
+		return &emptySortResult, err
+	} else if gid == 0 {
+		return &emptySortResult, fmt.Errorf("Cannot sort by unknown attribute %s", q.Order[0].Attr)
+	}
+
 	if span := otrace.FromContext(ctx); span != nil {
 		span.Annotatef(nil, "worker.SortOverNetwork. Attr: %s. Group: %d", q.Order[0].Attr, gid)
 	}
@@ -59,7 +65,7 @@ func SortOverNetwork(ctx context.Context, q *pb.SortMessage) (*pb.SortResult, er
 		return c.Sort(ctx, q)
 	})
 	if err != nil {
-		return nil, err
+		return &emptySortResult, err
 	}
 	return result.(*pb.SortResult), nil
 }
@@ -72,7 +78,11 @@ func (w *grpcWorker) Sort(ctx context.Context, s *pb.SortMessage) (*pb.SortResul
 	ctx, span := otrace.StartSpan(ctx, "worker.Sort")
 	defer span.End()
 
-	gid := groups().BelongsTo(s.Order[0].Attr)
+	gid, err := groups().BelongsToReadOnly(s.Order[0].Attr)
+	if err != nil {
+		return &emptySortResult, err
+	}
+
 	span.Annotatef(nil, "Sorting: Attribute: %q groupId: %v Sort", s.Order[0].Attr, gid)
 	if gid != groups().groupId() {
 		return nil, x.Errorf("attr: %q groupId: %v Request sent to wrong server.", s.Order[0].Attr, gid)
diff --git a/worker/task.go b/worker/task.go
index 0d09a91fb76..1c40e98482f 100644
--- a/worker/task.go
+++ b/worker/task.go
@@ -137,10 +137,13 @@ func processWithBackupRequest(
 // query.
 func ProcessTaskOverNetwork(ctx context.Context, q *pb.Query) (*pb.Result, error) {
 	attr := q.Attr
-	gid := groups().BelongsTo(attr)
-	if gid == 0 {
-		return &pb.Result{}, errUnservedTablet
+	gid, err := groups().BelongsToReadOnly(attr)
+	if err != nil {
+		return &emptyResult, err
+	} else if gid == 0 {
+		return &emptyResult, errUnservedTablet
 	}
+
 	span := otrace.FromContext(ctx)
 	if span != nil {
 		span.Annotatef(nil, "ProcessTaskOverNetwork. attr: %v gid: %v, readTs: %d, node id: %d",
@@ -157,6 +160,9 @@ func ProcessTaskOverNetwork(ctx context.Context, q *pb.Query) (*pb.Result, error
 			return c.ServeTask(ctx, q)
 		})
 
+	if err == errUnservedTablet {
+		return &emptyResult, errUnservedTablet
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -716,7 +722,7 @@ func processTask(ctx context.Context, q *pb.Query, gid uint32) (*pb.Result, erro
 
 	span.Annotatef(nil, "Waiting for startTs: %d", q.ReadTs)
 	if err := posting.Oracle().WaitForTs(ctx, q.ReadTs); err != nil {
-		return nil, err
+		return &emptyResult, err
 	}
 	if span != nil {
 		maxAssigned := posting.Oracle().MaxAssigned()
@@ -724,15 +730,19 @@ func processTask(ctx context.Context, q *pb.Query, gid uint32) (*pb.Result, erro
 			q.Attr, q.ReadTs, maxAssigned)
 	}
 	if err := groups().ChecksumsMatch(ctx); err != nil {
-		return nil, err
+		return &emptyResult, err
 	}
 	span.Annotatef(nil, "Done waiting for checksum match")
 
-	// If a group stops serving tablet and it gets partitioned away from group zero, then it
-	// wouldn't know that this group is no longer serving this predicate.
-	// There's no issue if a we are serving a particular tablet and we get partitioned away from
-	// group zero as long as it's not removed.
-	if !groups().ServesTablet(q.Attr) {
+	// If a group stops serving tablet and it gets partitioned away from group
+	// zero, then it wouldn't know that this group is no longer serving this
+	// predicate. There's no issue if a we are serving a particular tablet and
+	// we get partitioned away from group zero as long as it's not removed.
+	// ServesTabletReadOnly is called instead of ServesTablet to prevent this
+	// alpha from requesting to serve this tablet.
+	if servesTablet, err := groups().ServesTabletReadOnly(q.Attr); err != nil {
+		return &emptyResult, err
+	} else if !servesTablet {
 		return &emptyResult, errUnservedTablet
 	}
 	var qs queryState
@@ -1615,7 +1625,13 @@ func (w *grpcWorker) ServeTask(ctx context.Context, q *pb.Query) (*pb.Result, er
 		return &emptyResult, ctx.Err()
 	}
 
-	gid := groups().BelongsTo(q.Attr)
+	gid, err := groups().BelongsToReadOnly(q.Attr)
+	if err != nil {
+		return &emptyResult, err
+	} else if gid == 0 {
+		return &emptyResult, errUnservedTablet
+	}
+
 	var numUids int
 	if q.UidList != nil {
 		numUids = len(q.UidList.Uids)
@@ -1623,8 +1639,8 @@ func (w *grpcWorker) ServeTask(ctx context.Context, q *pb.Query) (*pb.Result, er
 	span.Annotatef(nil, "Attribute: %q NumUids: %v groupId: %v ServeTask", q.Attr, numUids, gid)
 
 	if !groups().ServesGroup(gid) {
-		return nil, fmt.Errorf("Temporary error, attr: %q groupId: %v Request sent to wrong server",
-			q.Attr, gid)
+		return &emptyResult, fmt.Errorf(
+			"Temporary error, attr: %q groupId: %v Request sent to wrong server", q.Attr, gid)
 	}
 
 	type reply struct {
@@ -1639,7 +1655,7 @@ func (w *grpcWorker) ServeTask(ctx context.Context, q *pb.Query) (*pb.Result, er
 
 	select {
 	case <-ctx.Done():
-		return nil, ctx.Err()
+		return &emptyResult, ctx.Err()
 	case reply := <-c:
 		return reply.result, reply.err
 	}