diff --git a/encoding/proto/proto.go b/encoding/proto/proto.go
index be6ae3511..ebd2532fd 100644
--- a/encoding/proto/proto.go
+++ b/encoding/proto/proto.go
@@ -1335,8 +1335,9 @@ func decodePairField(pb *internal.Pair) pilosa.PairField {
 
 func decodeValCount(pb *internal.ValCount) pilosa.ValCount {
 	return pilosa.ValCount{
-		Val:   pb.Val,
-		Count: pb.Count,
+		Val:      pb.Val,
+		FloatVal: pb.FloatVal,
+		Count:    pb.Count,
 	}
 }
 
@@ -1460,8 +1461,9 @@ func encodePairField(p pilosa.PairField) *internal.Pair {
 
 func encodeValCount(vc pilosa.ValCount) *internal.ValCount {
 	return &internal.ValCount{
-		Val:   vc.Val,
-		Count: vc.Count,
+		Val:      vc.Val,
+		FloatVal: vc.FloatVal,
+		Count:    vc.Count,
 	}
 }
 
diff --git a/executor.go b/executor.go
index 162680a24..ce0707be0 100644
--- a/executor.go
+++ b/executor.go
@@ -770,7 +770,8 @@ func (e *executor) executeSum(ctx context.Context, index string, c *pql.Call, sh
 	span, ctx := tracing.StartSpanFromContext(ctx, "Executor.executeSum")
 	defer span.Finish()
 
-	if field := c.Args["field"]; field == "" {
+	fieldName, ok := c.Args["field"].(string)
+	if !ok || fieldName == "" {
 		return ValCount{}, errors.New("Sum(): field required")
 	}
 
@@ -798,6 +799,21 @@ func (e *executor) executeSum(ctx context.Context, index string, c *pql.Call, sh
 	if other.Count == 0 {
 		return ValCount{}, nil
 	}
+
+	// scale summed response into float if decimal field and this is
+	// not a remote query (we're about to return to original client).
+	if !opt.Remote {
+		field := e.Holder.Field(index, fieldName)
+		if field == nil {
+			return ValCount{}, ErrFieldNotFound
+		}
+		if field.Type() == FieldTypeDecimal {
+			if scale := field.Options().Scale; scale != 0 {
+				other.FloatVal = float64(other.Val) / math.Pow10(int(scale))
+				other.Val = 0
+			}
+		}
+	}
 	return other, nil
 }
 
@@ -1244,24 +1260,7 @@ func (e *executor) executeMinShard(ctx context.Context, index string, c *pql.Cal
 		return ValCount{}, nil
 	}
 
-	bsig := field.bsiGroup(fieldName)
-	if bsig == nil {
-		return ValCount{}, nil
-	}
-
-	fragment := e.Holder.fragment(index, fieldName, viewBSIGroupPrefix+fieldName, shard)
-	if fragment == nil {
-		return ValCount{}, nil
-	}
-
-	fmin, fcount, err := fragment.min(filter, bsig.BitDepth)
-	if err != nil {
-		return ValCount{}, err
-	}
-	return ValCount{
-		Val:   int64(fmin) + bsig.Base,
-		Count: int64(fcount),
-	}, nil
+	return field.MinForShard(shard, filter)
 }
 
 // executeMaxShard calculates the max for bsiGroups on a shard.
@@ -1282,24 +1281,7 @@ func (e *executor) executeMaxShard(ctx context.Context, index string, c *pql.Cal
 		return ValCount{}, nil
 	}
 
-	bsig := field.bsiGroup(fieldName)
-	if bsig == nil {
-		return ValCount{}, nil
-	}
-
-	fragment := e.Holder.fragment(index, fieldName, viewBSIGroupPrefix+fieldName, shard)
-	if fragment == nil {
-		return ValCount{}, nil
-	}
-
-	fmax, fcount, err := fragment.max(filter, bsig.BitDepth)
-	if err != nil {
-		return ValCount{}, err
-	}
-	return ValCount{
-		Val:   int64(fmax) + bsig.Base,
-		Count: int64(fcount),
-	}, nil
+	return field.MaxForShard(shard, filter)
 }
 
 // executeMinRowShard returns the minimum row ID for a shard.
@@ -4113,10 +4095,11 @@ func (sr *SignedRow) union(other SignedRow) SignedRow {
 	return ret
 }
 
-// ValCount represents a grouping of sum & count for Sum() and Average() calls.
+// ValCount represents a grouping of sum & count for Sum() and Average() calls. Also Min, Max....
 type ValCount struct {
-	Val   int64 `json:"value"`
-	Count int64 `json:"count"`
+	Val      int64   `json:"value"`
+	FloatVal float64 `json:"floatValue"`
+	Count    int64   `json:"count"`
 }
 
 func (vc *ValCount) add(other ValCount) ValCount {
@@ -4128,6 +4111,9 @@ func (vc *ValCount) add(other ValCount) ValCount {
 
 // smaller returns the smaller of the two ValCounts.
 func (vc *ValCount) smaller(other ValCount) ValCount {
+	if vc.FloatVal != 0 || other.FloatVal != 0 {
+		return vc.floatSmaller(other)
+	}
 	if vc.Count == 0 || (other.Val < vc.Val && other.Count > 0) {
 		return other
 	}
@@ -4141,8 +4127,26 @@ func (vc *ValCount) smaller(other ValCount) ValCount {
 	}
 }
 
+func (vc *ValCount) floatSmaller(other ValCount) ValCount {
+	if vc.Count == 0 || (other.FloatVal < vc.FloatVal && other.Count > 0) {
+		return other
+	}
+	extra := int64(0)
+	if vc.FloatVal == other.FloatVal {
+		extra += other.Count
+	}
+	return ValCount{
+		FloatVal: vc.FloatVal,
+		Count:    vc.Count + extra,
+	}
+
+}
+
 // larger returns the larger of the two ValCounts.
 func (vc *ValCount) larger(other ValCount) ValCount {
+	if vc.FloatVal != 0 || other.FloatVal != 0 {
+		return vc.floatLarger(other)
+	}
 	if vc.Count == 0 || (other.Val > vc.Val && other.Count > 0) {
 		return other
 	}
@@ -4156,6 +4160,20 @@ func (vc *ValCount) larger(other ValCount) ValCount {
 	}
 }
 
+func (vc *ValCount) floatLarger(other ValCount) ValCount {
+	if vc.Count == 0 || (other.FloatVal > vc.FloatVal && other.Count > 0) {
+		return other
+	}
+	extra := int64(0)
+	if vc.FloatVal == other.FloatVal {
+		extra += other.Count
+	}
+	return ValCount{
+		FloatVal: vc.FloatVal,
+		Count:    vc.Count + extra,
+	}
+}
+
 func callArgBool(call *pql.Call, key string) (bool, error) {
 	value, ok := call.Args[key]
 	if !ok {
diff --git a/executor_internal_test.go b/executor_internal_test.go
index 8f2a5eafd..395ecdcfc 100644
--- a/executor_internal_test.go
+++ b/executor_internal_test.go
@@ -18,6 +18,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"strconv"
 	"strings"
 	"testing"
 
@@ -381,3 +382,59 @@ func TestExecutor_GroupCountCondition(t *testing.T) {
 		}
 	})
 }
+
+func TestValCountComparisons(t *testing.T) {
+	tests := []struct {
+		name       string
+		vc         ValCount
+		other      ValCount
+		expLarger  ValCount
+		expSmaller ValCount
+	}{
+		{
+			name: "zero",
+		},
+		{
+			name:       "ints",
+			vc:         ValCount{Val: 10, Count: 1},
+			other:      ValCount{Val: 3, Count: 2},
+			expLarger:  ValCount{Val: 10, Count: 1},
+			expSmaller: ValCount{Val: 3, Count: 2},
+		},
+		{
+			name:       "floats",
+			vc:         ValCount{FloatVal: 10.2, Count: 1},
+			other:      ValCount{FloatVal: 3.4, Count: 2},
+			expLarger:  ValCount{FloatVal: 10.2, Count: 1},
+			expSmaller: ValCount{FloatVal: 3.4, Count: 2},
+		},
+		{
+			name:       "intsEquality",
+			vc:         ValCount{Val: 10, Count: 1},
+			other:      ValCount{Val: 10, Count: 2},
+			expLarger:  ValCount{Val: 10, Count: 3},
+			expSmaller: ValCount{Val: 10, Count: 3},
+		},
+		{
+			name:       "floatsEquality",
+			vc:         ValCount{FloatVal: 10.7, Count: 1},
+			other:      ValCount{FloatVal: 10.7, Count: 2},
+			expLarger:  ValCount{FloatVal: 10.7, Count: 3},
+			expSmaller: ValCount{FloatVal: 10.7, Count: 3},
+		},
+	}
+
+	for i, test := range tests {
+		t.Run(test.name+strconv.Itoa(i), func(t *testing.T) {
+			gotLarger := test.vc.larger(test.other)
+			if gotLarger != test.expLarger {
+				t.Fatalf("larger failed, expected:\n%+v\ngot:\n%+v", test.expLarger, gotLarger)
+			}
+
+			gotSmaller := test.vc.smaller(test.other)
+			if gotSmaller != test.expSmaller {
+				t.Fatalf("smaller failed, expected:\n%+v\ngot:\n%+v", test.expSmaller, gotSmaller)
+			}
+		})
+	}
+}
diff --git a/executor_test.go b/executor_test.go
index e11429d0f..a2ff67232 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -4692,6 +4692,10 @@ func TestExecutor_Execute_MinMaxCountEqual(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	if _, err := idx.CreateField("dec", pilosa.OptFieldTypeDecimal(3)); err != nil {
+		t.Fatal(err)
+	}
+
 	if _, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `
 			Set(0, f=3)
 			Set(1, f=3)
@@ -4706,6 +4710,10 @@ func TestExecutor_Execute_MinMaxCountEqual(t *testing.T) {
 			Set(` + strconv.Itoa(2*ShardWidth+1) + `, f=3)
 			Set(0, x=3)
 			Set(1, x=3)
+            Set(0, dec=5.122)
+            Set(1, dec=12.985)
+            Set(2, dec=4.234)
+            Set(3, dec=12.985)
 
 		`}); err != nil {
 		t.Fatal(err)
@@ -4734,6 +4742,29 @@ func TestExecutor_Execute_MinMaxCountEqual(t *testing.T) {
 			}
 		}
 	})
+	t.Run("MinDec", func(t *testing.T) {
+		tests := []struct {
+			filter string
+			exp    float64
+			cnt    int64
+		}{
+			{filter: ``, exp: 4.234, cnt: 1},
+			{filter: `Row(x=3)`, exp: 5.122, cnt: 1},
+		}
+		for i, tt := range tests {
+			var pql string
+			if tt.filter == "" {
+				pql = `Min(field=dec)`
+			} else {
+				pql = fmt.Sprintf(`Min(%s, field=dec)`, tt.filter)
+			}
+			if result, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: pql}); err != nil {
+				t.Fatal(err)
+			} else if !reflect.DeepEqual(result.Results[0], pilosa.ValCount{FloatVal: tt.exp, Count: tt.cnt}) {
+				t.Fatalf("unexpected result, test %d: %s", i, spew.Sdump(result.Results[0]))
+			}
+		}
+	})
 
 	t.Run("Max", func(t *testing.T) {
 		tests := []struct {
@@ -4757,6 +4788,30 @@ func TestExecutor_Execute_MinMaxCountEqual(t *testing.T) {
 			}
 		}
 	})
+
+	t.Run("MaxDec", func(t *testing.T) {
+		tests := []struct {
+			filter string
+			exp    float64
+			cnt    int64
+		}{
+			{filter: ``, exp: 12.985, cnt: 2},
+			{filter: `Row(x=3)`, exp: 12.985, cnt: 1},
+		}
+		for i, tt := range tests {
+			var pql string
+			if tt.filter == "" {
+				pql = `Max(field=dec)`
+			} else {
+				pql = fmt.Sprintf(`Max(%s, field=dec)`, tt.filter)
+			}
+			if result, err := c[0].API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: pql}); err != nil {
+				t.Fatal(err)
+			} else if !reflect.DeepEqual(result.Results[0], pilosa.ValCount{FloatVal: tt.exp, Count: tt.cnt}) {
+				t.Fatalf("unexpected result, test %d: %s", i, spew.Sdump(result.Results[0]))
+			}
+		}
+	})
 }
 
 func TestExecutor_Execute_NoIndex(t *testing.T) {
diff --git a/field.go b/field.go
index e040b4441..31f4873f7 100644
--- a/field.go
+++ b/field.go
@@ -1369,6 +1369,7 @@ func (f *Field) Sum(filter *Row, name string) (sum, count int64, err error) {
 
 // FloatMin performs a Min query and converts the result to a float
 // based on the field's configured scale.
+// TODO: this and Min are probably worthless
 func (f *Field) FloatMin(filter *Row, name string) (min float64, count int64, err error) {
 	bsig := f.bsiGroup(f.name)
 	if bsig == nil {
@@ -1404,6 +1405,11 @@ func (f *Field) Min(filter *Row, name string) (min, count int64, err error) {
 
 // FloatMax performs a max query and converts the result to a float
 // based on the field's configured scale.
+//
+// TODO, this isn't really used, because it's kind of useless. It will
+// only get the max among shards on this node, but all query execution
+// already happens at the shard level and bypasses this entirely
+// calling fragment.max instead.
 func (f *Field) FloatMax(filter *Row, name string) (max float64, count int64, err error) {
 	bsig := f.bsiGroup(f.name)
 	if bsig == nil {
@@ -1417,6 +1423,73 @@ func (f *Field) FloatMax(filter *Row, name string) (max float64, count int64, er
 	return max, count, err
 }
 
+func (f *Field) MaxForShard(shard uint64, filter *Row) (ValCount, error) {
+	bsig := f.bsiGroup(f.name)
+	if bsig == nil {
+		return ValCount{}, ErrBSIGroupNotFound
+	}
+
+	view := f.view(viewBSIGroupPrefix + f.name)
+	if view == nil {
+		return ValCount{}, nil
+	}
+
+	fragment := view.Fragment(shard)
+	if fragment == nil {
+		return ValCount{}, nil
+	}
+
+	max, cnt, err := fragment.max(filter, bsig.BitDepth)
+	if err != nil {
+		return ValCount{}, errors.Wrap(err, "calling fragment.max")
+	}
+
+	valCount := ValCount{Count: int64(cnt)}
+
+	if f.Options().Type == FieldTypeDecimal {
+		valCount.FloatVal = float64(max) / math.Pow10(int(bsig.Scale))
+	} else {
+		valCount.Val = max
+	}
+
+	return valCount, nil
+}
+
+// MinForShard returns the minimum value which appears in this shard
+// (this field must be an Int or Decimal field). It also returns the
+// number of times the minimum value appears.
+func (f *Field) MinForShard(shard uint64, filter *Row) (ValCount, error) {
+	bsig := f.bsiGroup(f.name)
+	if bsig == nil {
+		return ValCount{}, ErrBSIGroupNotFound
+	}
+
+	view := f.view(viewBSIGroupPrefix + f.name)
+	if view == nil {
+		return ValCount{}, nil
+	}
+
+	fragment := view.Fragment(shard)
+	if fragment == nil {
+		return ValCount{}, nil
+	}
+
+	min, cnt, err := fragment.min(filter, bsig.BitDepth)
+	if err != nil {
+		return ValCount{}, errors.Wrap(err, "calling fragment.min")
+	}
+
+	valCount := ValCount{Count: int64(cnt)}
+
+	if f.Options().Type == FieldTypeDecimal {
+		valCount.FloatVal = float64(min) / math.Pow10(int(bsig.Scale))
+	} else {
+		valCount.Val = min
+	}
+
+	return valCount, nil
+}
+
 // Max returns the max for a field.
 // An optional filtering row can be provided.
 func (f *Field) Max(filter *Row, name string) (max, count int64, err error) {
diff --git a/field_internal_test.go b/field_internal_test.go
index feea5501c..38a023c1f 100644
--- a/field_internal_test.go
+++ b/field_internal_test.go
@@ -21,6 +21,7 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
+	"strconv"
 	"testing"
 	"time"
 
@@ -576,3 +577,155 @@ func TestBSIGroup_importValue(t *testing.T) {
 		}
 	}
 }
+
+func TestIntField_MinMaxForShard(t *testing.T) {
+	f := MustOpenField(OptFieldTypeInt(-100, 200))
+
+	options := &ImportOptions{}
+	for i, test := range []struct {
+		name      string
+		columnIDs []uint64
+		values    []int64
+		expMax    ValCount
+		expMin    ValCount
+	}{
+		{
+			name:      "zero",
+			columnIDs: []uint64{},
+			values:    []int64{},
+		},
+		{
+			name:      "single",
+			columnIDs: []uint64{1},
+			values:    []int64{10},
+			expMax:    ValCount{Val: 10, Count: 1},
+			expMin:    ValCount{Val: 10, Count: 1},
+		},
+		{
+			name:      "twovals",
+			columnIDs: []uint64{1, 2},
+			values:    []int64{10, 20},
+			expMax:    ValCount{Val: 20, Count: 1},
+			expMin:    ValCount{Val: 10, Count: 1},
+		},
+		{
+			name:      "multiplecounts",
+			columnIDs: []uint64{1, 2, 3, 4, 5},
+			values:    []int64{10, 20, 10, 10, 20},
+			expMax:    ValCount{Val: 20, Count: 2},
+			expMin:    ValCount{Val: 10, Count: 3},
+		},
+		{
+			name:      "middlevals",
+			columnIDs: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			values:    []int64{10, 20, 10, 10, 20, 11, 12, 11, 13, 11},
+			expMax:    ValCount{Val: 20, Count: 2},
+			expMin:    ValCount{Val: 10, Count: 3},
+		},
+		{
+			name:      "middlevals",
+			columnIDs: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100000000, 100000001},
+			values:    []int64{10, 20, 10, 10, 20, 11, 12, 11, 13, 11, 44, 1},
+			expMax:    ValCount{Val: 20, Count: 2},
+			expMin:    ValCount{Val: 10, Count: 3},
+		},
+	} {
+		t.Run(test.name+strconv.Itoa(i), func(t *testing.T) {
+			if err := f.importValue(test.columnIDs, test.values, options); err != nil {
+				t.Fatalf("test %d, importing values: %s", i, err.Error())
+			}
+
+			maxvc, err := f.MaxForShard(0, nil)
+			if err != nil {
+				t.Fatalf("getting max for shard: %v", err)
+			}
+			if maxvc != test.expMax {
+				t.Fatalf("max expected:\n%+v\ngot:\n%+v", test.expMax, maxvc)
+			}
+
+			minvc, err := f.MinForShard(0, nil)
+			if err != nil {
+				t.Fatalf("getting min for shard: %v", err)
+			}
+			if minvc != test.expMin {
+				t.Fatalf("min expected:\n%+v\ngot:\n%+v", test.expMin, minvc)
+			}
+		})
+	}
+}
+
+func TestDecimalField_MinMaxForShard(t *testing.T) {
+	f := MustOpenField(OptFieldTypeDecimal(3))
+
+	options := &ImportOptions{}
+	for i, test := range []struct {
+		name      string
+		columnIDs []uint64
+		values    []float64
+		expMax    ValCount
+		expMin    ValCount
+	}{
+		{
+			name:      "zero",
+			columnIDs: []uint64{},
+			values:    []float64{},
+		},
+		{
+			name:      "single",
+			columnIDs: []uint64{1},
+			values:    []float64{10.1},
+			expMax:    ValCount{FloatVal: 10.1, Count: 1},
+			expMin:    ValCount{FloatVal: 10.1, Count: 1},
+		},
+		{
+			name:      "twovals",
+			columnIDs: []uint64{1, 2},
+			values:    []float64{10.1, 20.2},
+			expMax:    ValCount{FloatVal: 20.2, Count: 1},
+			expMin:    ValCount{FloatVal: 10.1, Count: 1},
+		},
+		{
+			name:      "multiplecounts",
+			columnIDs: []uint64{1, 2, 3, 4, 5},
+			values:    []float64{10.1, 20.2, 10.1, 10.1, 20.2},
+			expMax:    ValCount{FloatVal: 20.2, Count: 2},
+			expMin:    ValCount{FloatVal: 10.1, Count: 3},
+		},
+		{
+			name:      "middlevals",
+			columnIDs: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			values:    []float64{10.1, 20.2, 10.1, 10.1, 20.2, 11, 12, 11, 13, 11},
+			expMax:    ValCount{FloatVal: 20.2, Count: 2},
+			expMin:    ValCount{FloatVal: 10.1, Count: 3},
+		},
+		{
+			name:      "another shard",
+			columnIDs: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100000000, 100000001},
+			values:    []float64{10.1, 20.2, 10.1, 10.1, 20.2, 11, 12, 11, 13, 11, 44.39, 0.23},
+			expMax:    ValCount{FloatVal: 20.2, Count: 2},
+			expMin:    ValCount{FloatVal: 10.1, Count: 3},
+		},
+	} {
+		t.Run(test.name+strconv.Itoa(i), func(t *testing.T) {
+			if err := f.importFloatValue(test.columnIDs, test.values, options); err != nil {
+				t.Fatalf("test %d, importing values: %s", i, err.Error())
+			}
+
+			maxvc, err := f.MaxForShard(0, nil)
+			if err != nil {
+				t.Fatalf("getting max for shard: %v", err)
+			}
+			if maxvc != test.expMax {
+				t.Fatalf("max expected:\n%+v\ngot:\n%+v", test.expMax, maxvc)
+			}
+
+			minvc, err := f.MinForShard(0, nil)
+			if err != nil {
+				t.Fatalf("getting min for shard: %v", err)
+			}
+			if minvc != test.expMin {
+				t.Fatalf("min expected:\n%+v\ngot:\n%+v", test.expMin, minvc)
+			}
+		})
+	}
+}
diff --git a/internal/private.pb.go b/internal/private.pb.go
index f64f9b5b7..df22cdc09 100644
--- a/internal/private.pb.go
+++ b/internal/private.pb.go
@@ -3,11 +3,13 @@
 
 package internal
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-import io "io"
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -18,7 +20,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type IndexMeta struct {
 	Keys                 bool     `protobuf:"varint,3,opt,name=Keys,proto3" json:"Keys,omitempty"`
@@ -32,7 +34,7 @@ func (m *IndexMeta) Reset()         { *m = IndexMeta{} }
 func (m *IndexMeta) String() string { return proto.CompactTextString(m) }
 func (*IndexMeta) ProtoMessage()    {}
 func (*IndexMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{0}
+	return fileDescriptor_d2a91b51c7bdc125, []int{0}
 }
 func (m *IndexMeta) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -42,15 +44,15 @@ func (m *IndexMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_IndexMeta.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *IndexMeta) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_IndexMeta.Merge(dst, src)
+func (m *IndexMeta) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexMeta.Merge(m, src)
 }
 func (m *IndexMeta) XXX_Size() int {
 	return m.Size()
@@ -97,7 +99,7 @@ func (m *FieldOptions) Reset()         { *m = FieldOptions{} }
 func (m *FieldOptions) String() string { return proto.CompactTextString(m) }
 func (*FieldOptions) ProtoMessage()    {}
 func (*FieldOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{1}
+	return fileDescriptor_d2a91b51c7bdc125, []int{1}
 }
 func (m *FieldOptions) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -107,15 +109,15 @@ func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *FieldOptions) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FieldOptions.Merge(dst, src)
+func (m *FieldOptions) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldOptions.Merge(m, src)
 }
 func (m *FieldOptions) XXX_Size() int {
 	return m.Size()
@@ -221,7 +223,7 @@ func (m *ImportResponse) Reset()         { *m = ImportResponse{} }
 func (m *ImportResponse) String() string { return proto.CompactTextString(m) }
 func (*ImportResponse) ProtoMessage()    {}
 func (*ImportResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{2}
+	return fileDescriptor_d2a91b51c7bdc125, []int{2}
 }
 func (m *ImportResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -231,15 +233,15 @@ func (m *ImportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return xxx_messageInfo_ImportResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ImportResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportResponse.Merge(dst, src)
+func (m *ImportResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportResponse.Merge(m, src)
 }
 func (m *ImportResponse) XXX_Size() int {
 	return m.Size()
@@ -272,7 +274,7 @@ func (m *BlockDataRequest) Reset()         { *m = BlockDataRequest{} }
 func (m *BlockDataRequest) String() string { return proto.CompactTextString(m) }
 func (*BlockDataRequest) ProtoMessage()    {}
 func (*BlockDataRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{3}
+	return fileDescriptor_d2a91b51c7bdc125, []int{3}
 }
 func (m *BlockDataRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -282,15 +284,15 @@ func (m *BlockDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return xxx_messageInfo_BlockDataRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *BlockDataRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BlockDataRequest.Merge(dst, src)
+func (m *BlockDataRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlockDataRequest.Merge(m, src)
 }
 func (m *BlockDataRequest) XXX_Size() int {
 	return m.Size()
@@ -337,8 +339,8 @@ func (m *BlockDataRequest) GetBlock() uint64 {
 }
 
 type BlockDataResponse struct {
-	RowIDs               []uint64 `protobuf:"varint,1,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
-	ColumnIDs            []uint64 `protobuf:"varint,2,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
+	RowIDs               []uint64 `protobuf:"varint,1,rep,packed,name=RowIDs,proto3" json:"RowIDs,omitempty"`
+	ColumnIDs            []uint64 `protobuf:"varint,2,rep,packed,name=ColumnIDs,proto3" json:"ColumnIDs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -348,7 +350,7 @@ func (m *BlockDataResponse) Reset()         { *m = BlockDataResponse{} }
 func (m *BlockDataResponse) String() string { return proto.CompactTextString(m) }
 func (*BlockDataResponse) ProtoMessage()    {}
 func (*BlockDataResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{4}
+	return fileDescriptor_d2a91b51c7bdc125, []int{4}
 }
 func (m *BlockDataResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -358,15 +360,15 @@ func (m *BlockDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_BlockDataResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *BlockDataResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BlockDataResponse.Merge(dst, src)
+func (m *BlockDataResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlockDataResponse.Merge(m, src)
 }
 func (m *BlockDataResponse) XXX_Size() int {
 	return m.Size()
@@ -392,7 +394,7 @@ func (m *BlockDataResponse) GetColumnIDs() []uint64 {
 }
 
 type Cache struct {
-	IDs                  []uint64 `protobuf:"varint,1,rep,packed,name=IDs" json:"IDs,omitempty"`
+	IDs                  []uint64 `protobuf:"varint,1,rep,packed,name=IDs,proto3" json:"IDs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -402,7 +404,7 @@ func (m *Cache) Reset()         { *m = Cache{} }
 func (m *Cache) String() string { return proto.CompactTextString(m) }
 func (*Cache) ProtoMessage()    {}
 func (*Cache) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{5}
+	return fileDescriptor_d2a91b51c7bdc125, []int{5}
 }
 func (m *Cache) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -412,15 +414,15 @@ func (m *Cache) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Cache.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *Cache) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Cache.Merge(dst, src)
+func (m *Cache) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Cache.Merge(m, src)
 }
 func (m *Cache) XXX_Size() int {
 	return m.Size()
@@ -439,7 +441,7 @@ func (m *Cache) GetIDs() []uint64 {
 }
 
 type MaxShards struct {
-	Standard             map[string]uint64 `protobuf:"bytes,1,rep,name=Standard" json:"Standard,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	Standard             map[string]uint64 `protobuf:"bytes,1,rep,name=Standard,proto3" json:"Standard,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
 	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
 	XXX_unrecognized     []byte            `json:"-"`
 	XXX_sizecache        int32             `json:"-"`
@@ -449,7 +451,7 @@ func (m *MaxShards) Reset()         { *m = MaxShards{} }
 func (m *MaxShards) String() string { return proto.CompactTextString(m) }
 func (*MaxShards) ProtoMessage()    {}
 func (*MaxShards) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{6}
+	return fileDescriptor_d2a91b51c7bdc125, []int{6}
 }
 func (m *MaxShards) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -459,15 +461,15 @@ func (m *MaxShards) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_MaxShards.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *MaxShards) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MaxShards.Merge(dst, src)
+func (m *MaxShards) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MaxShards.Merge(m, src)
 }
 func (m *MaxShards) XXX_Size() int {
 	return m.Size()
@@ -498,7 +500,7 @@ func (m *CreateShardMessage) Reset()         { *m = CreateShardMessage{} }
 func (m *CreateShardMessage) String() string { return proto.CompactTextString(m) }
 func (*CreateShardMessage) ProtoMessage()    {}
 func (*CreateShardMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{7}
+	return fileDescriptor_d2a91b51c7bdc125, []int{7}
 }
 func (m *CreateShardMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -508,15 +510,15 @@ func (m *CreateShardMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_CreateShardMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *CreateShardMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateShardMessage.Merge(dst, src)
+func (m *CreateShardMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateShardMessage.Merge(m, src)
 }
 func (m *CreateShardMessage) XXX_Size() int {
 	return m.Size()
@@ -559,7 +561,7 @@ func (m *DeleteIndexMessage) Reset()         { *m = DeleteIndexMessage{} }
 func (m *DeleteIndexMessage) String() string { return proto.CompactTextString(m) }
 func (*DeleteIndexMessage) ProtoMessage()    {}
 func (*DeleteIndexMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{8}
+	return fileDescriptor_d2a91b51c7bdc125, []int{8}
 }
 func (m *DeleteIndexMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -569,15 +571,15 @@ func (m *DeleteIndexMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_DeleteIndexMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *DeleteIndexMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteIndexMessage.Merge(dst, src)
+func (m *DeleteIndexMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteIndexMessage.Merge(m, src)
 }
 func (m *DeleteIndexMessage) XXX_Size() int {
 	return m.Size()
@@ -597,7 +599,7 @@ func (m *DeleteIndexMessage) GetIndex() string {
 
 type CreateIndexMessage struct {
 	Index                string     `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
-	Meta                 *IndexMeta `protobuf:"bytes,2,opt,name=Meta" json:"Meta,omitempty"`
+	Meta                 *IndexMeta `protobuf:"bytes,2,opt,name=Meta,proto3" json:"Meta,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
 	XXX_unrecognized     []byte     `json:"-"`
 	XXX_sizecache        int32      `json:"-"`
@@ -607,7 +609,7 @@ func (m *CreateIndexMessage) Reset()         { *m = CreateIndexMessage{} }
 func (m *CreateIndexMessage) String() string { return proto.CompactTextString(m) }
 func (*CreateIndexMessage) ProtoMessage()    {}
 func (*CreateIndexMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{9}
+	return fileDescriptor_d2a91b51c7bdc125, []int{9}
 }
 func (m *CreateIndexMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -617,15 +619,15 @@ func (m *CreateIndexMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_CreateIndexMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *CreateIndexMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateIndexMessage.Merge(dst, src)
+func (m *CreateIndexMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateIndexMessage.Merge(m, src)
 }
 func (m *CreateIndexMessage) XXX_Size() int {
 	return m.Size()
@@ -653,7 +655,7 @@ func (m *CreateIndexMessage) GetMeta() *IndexMeta {
 type CreateFieldMessage struct {
 	Index                string        `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
 	Field                string        `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	Meta                 *FieldOptions `protobuf:"bytes,3,opt,name=Meta" json:"Meta,omitempty"`
+	Meta                 *FieldOptions `protobuf:"bytes,3,opt,name=Meta,proto3" json:"Meta,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
 	XXX_unrecognized     []byte        `json:"-"`
 	XXX_sizecache        int32         `json:"-"`
@@ -663,7 +665,7 @@ func (m *CreateFieldMessage) Reset()         { *m = CreateFieldMessage{} }
 func (m *CreateFieldMessage) String() string { return proto.CompactTextString(m) }
 func (*CreateFieldMessage) ProtoMessage()    {}
 func (*CreateFieldMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{10}
+	return fileDescriptor_d2a91b51c7bdc125, []int{10}
 }
 func (m *CreateFieldMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -673,15 +675,15 @@ func (m *CreateFieldMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_CreateFieldMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *CreateFieldMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateFieldMessage.Merge(dst, src)
+func (m *CreateFieldMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateFieldMessage.Merge(m, src)
 }
 func (m *CreateFieldMessage) XXX_Size() int {
 	return m.Size()
@@ -725,7 +727,7 @@ func (m *DeleteFieldMessage) Reset()         { *m = DeleteFieldMessage{} }
 func (m *DeleteFieldMessage) String() string { return proto.CompactTextString(m) }
 func (*DeleteFieldMessage) ProtoMessage()    {}
 func (*DeleteFieldMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{11}
+	return fileDescriptor_d2a91b51c7bdc125, []int{11}
 }
 func (m *DeleteFieldMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -735,15 +737,15 @@ func (m *DeleteFieldMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_DeleteFieldMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *DeleteFieldMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteFieldMessage.Merge(dst, src)
+func (m *DeleteFieldMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteFieldMessage.Merge(m, src)
 }
 func (m *DeleteFieldMessage) XXX_Size() int {
 	return m.Size()
@@ -781,7 +783,7 @@ func (m *DeleteAvailableShardMessage) Reset()         { *m = DeleteAvailableShar
 func (m *DeleteAvailableShardMessage) String() string { return proto.CompactTextString(m) }
 func (*DeleteAvailableShardMessage) ProtoMessage()    {}
 func (*DeleteAvailableShardMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{12}
+	return fileDescriptor_d2a91b51c7bdc125, []int{12}
 }
 func (m *DeleteAvailableShardMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -791,15 +793,15 @@ func (m *DeleteAvailableShardMessage) XXX_Marshal(b []byte, deterministic bool)
 		return xxx_messageInfo_DeleteAvailableShardMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *DeleteAvailableShardMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteAvailableShardMessage.Merge(dst, src)
+func (m *DeleteAvailableShardMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteAvailableShardMessage.Merge(m, src)
 }
 func (m *DeleteAvailableShardMessage) XXX_Size() int {
 	return m.Size()
@@ -833,8 +835,8 @@ func (m *DeleteAvailableShardMessage) GetShardID() uint64 {
 
 type Field struct {
 	Name                 string        `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	Meta                 *FieldOptions `protobuf:"bytes,2,opt,name=Meta" json:"Meta,omitempty"`
-	Views                []string      `protobuf:"bytes,3,rep,name=Views" json:"Views,omitempty"`
+	Meta                 *FieldOptions `protobuf:"bytes,2,opt,name=Meta,proto3" json:"Meta,omitempty"`
+	Views                []string      `protobuf:"bytes,3,rep,name=Views,proto3" json:"Views,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
 	XXX_unrecognized     []byte        `json:"-"`
 	XXX_sizecache        int32         `json:"-"`
@@ -844,7 +846,7 @@ func (m *Field) Reset()         { *m = Field{} }
 func (m *Field) String() string { return proto.CompactTextString(m) }
 func (*Field) ProtoMessage()    {}
 func (*Field) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{13}
+	return fileDescriptor_d2a91b51c7bdc125, []int{13}
 }
 func (m *Field) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -854,15 +856,15 @@ func (m *Field) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Field.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *Field) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Field.Merge(dst, src)
+func (m *Field) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Field.Merge(m, src)
 }
 func (m *Field) XXX_Size() int {
 	return m.Size()
@@ -895,7 +897,7 @@ func (m *Field) GetViews() []string {
 }
 
 type Schema struct {
-	Indexes              []*Index `protobuf:"bytes,1,rep,name=Indexes" json:"Indexes,omitempty"`
+	Indexes              []*Index `protobuf:"bytes,1,rep,name=Indexes,proto3" json:"Indexes,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -905,7 +907,7 @@ func (m *Schema) Reset()         { *m = Schema{} }
 func (m *Schema) String() string { return proto.CompactTextString(m) }
 func (*Schema) ProtoMessage()    {}
 func (*Schema) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{14}
+	return fileDescriptor_d2a91b51c7bdc125, []int{14}
 }
 func (m *Schema) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -915,15 +917,15 @@ func (m *Schema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Schema.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *Schema) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Schema.Merge(dst, src)
+func (m *Schema) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Schema.Merge(m, src)
 }
 func (m *Schema) XXX_Size() int {
 	return m.Size()
@@ -943,7 +945,7 @@ func (m *Schema) GetIndexes() []*Index {
 
 type Index struct {
 	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	Fields               []*Field `protobuf:"bytes,4,rep,name=Fields" json:"Fields,omitempty"`
+	Fields               []*Field `protobuf:"bytes,4,rep,name=Fields,proto3" json:"Fields,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -953,7 +955,7 @@ func (m *Index) Reset()         { *m = Index{} }
 func (m *Index) String() string { return proto.CompactTextString(m) }
 func (*Index) ProtoMessage()    {}
 func (*Index) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{15}
+	return fileDescriptor_d2a91b51c7bdc125, []int{15}
 }
 func (m *Index) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -963,15 +965,15 @@ func (m *Index) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Index.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *Index) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Index.Merge(dst, src)
+func (m *Index) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Index.Merge(m, src)
 }
 func (m *Index) XXX_Size() int {
 	return m.Size()
@@ -1009,7 +1011,7 @@ func (m *URI) Reset()         { *m = URI{} }
 func (m *URI) String() string { return proto.CompactTextString(m) }
 func (*URI) ProtoMessage()    {}
 func (*URI) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{16}
+	return fileDescriptor_d2a91b51c7bdc125, []int{16}
 }
 func (m *URI) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1019,15 +1021,15 @@ func (m *URI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_URI.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *URI) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_URI.Merge(dst, src)
+func (m *URI) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_URI.Merge(m, src)
 }
 func (m *URI) XXX_Size() int {
 	return m.Size()
@@ -1061,7 +1063,7 @@ func (m *URI) GetPort() uint32 {
 
 type Node struct {
 	ID                   string   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
-	URI                  *URI     `protobuf:"bytes,2,opt,name=URI" json:"URI,omitempty"`
+	URI                  *URI     `protobuf:"bytes,2,opt,name=URI,proto3" json:"URI,omitempty"`
 	IsCoordinator        bool     `protobuf:"varint,3,opt,name=IsCoordinator,proto3" json:"IsCoordinator,omitempty"`
 	State                string   `protobuf:"bytes,4,opt,name=State,proto3" json:"State,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -1073,7 +1075,7 @@ func (m *Node) Reset()         { *m = Node{} }
 func (m *Node) String() string { return proto.CompactTextString(m) }
 func (*Node) ProtoMessage()    {}
 func (*Node) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{17}
+	return fileDescriptor_d2a91b51c7bdc125, []int{17}
 }
 func (m *Node) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1083,15 +1085,15 @@ func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Node.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *Node) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Node.Merge(dst, src)
+func (m *Node) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Node.Merge(m, src)
 }
 func (m *Node) XXX_Size() int {
 	return m.Size()
@@ -1142,7 +1144,7 @@ func (m *NodeStateMessage) Reset()         { *m = NodeStateMessage{} }
 func (m *NodeStateMessage) String() string { return proto.CompactTextString(m) }
 func (*NodeStateMessage) ProtoMessage()    {}
 func (*NodeStateMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{18}
+	return fileDescriptor_d2a91b51c7bdc125, []int{18}
 }
 func (m *NodeStateMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1152,15 +1154,15 @@ func (m *NodeStateMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return xxx_messageInfo_NodeStateMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *NodeStateMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeStateMessage.Merge(dst, src)
+func (m *NodeStateMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeStateMessage.Merge(m, src)
 }
 func (m *NodeStateMessage) XXX_Size() int {
 	return m.Size()
@@ -1187,7 +1189,7 @@ func (m *NodeStateMessage) GetState() string {
 
 type NodeEventMessage struct {
 	Event                uint32   `protobuf:"varint,1,opt,name=Event,proto3" json:"Event,omitempty"`
-	Node                 *Node    `protobuf:"bytes,2,opt,name=Node" json:"Node,omitempty"`
+	Node                 *Node    `protobuf:"bytes,2,opt,name=Node,proto3" json:"Node,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1197,7 +1199,7 @@ func (m *NodeEventMessage) Reset()         { *m = NodeEventMessage{} }
 func (m *NodeEventMessage) String() string { return proto.CompactTextString(m) }
 func (*NodeEventMessage) ProtoMessage()    {}
 func (*NodeEventMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{19}
+	return fileDescriptor_d2a91b51c7bdc125, []int{19}
 }
 func (m *NodeEventMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1207,15 +1209,15 @@ func (m *NodeEventMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return xxx_messageInfo_NodeEventMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *NodeEventMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeEventMessage.Merge(dst, src)
+func (m *NodeEventMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeEventMessage.Merge(m, src)
 }
 func (m *NodeEventMessage) XXX_Size() int {
 	return m.Size()
@@ -1241,9 +1243,9 @@ func (m *NodeEventMessage) GetNode() *Node {
 }
 
 type NodeStatus struct {
-	Node                 *Node          `protobuf:"bytes,1,opt,name=Node" json:"Node,omitempty"`
-	Schema               *Schema        `protobuf:"bytes,3,opt,name=Schema" json:"Schema,omitempty"`
-	Indexes              []*IndexStatus `protobuf:"bytes,4,rep,name=Indexes" json:"Indexes,omitempty"`
+	Node                 *Node          `protobuf:"bytes,1,opt,name=Node,proto3" json:"Node,omitempty"`
+	Schema               *Schema        `protobuf:"bytes,3,opt,name=Schema,proto3" json:"Schema,omitempty"`
+	Indexes              []*IndexStatus `protobuf:"bytes,4,rep,name=Indexes,proto3" json:"Indexes,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
 	XXX_unrecognized     []byte         `json:"-"`
 	XXX_sizecache        int32          `json:"-"`
@@ -1253,7 +1255,7 @@ func (m *NodeStatus) Reset()         { *m = NodeStatus{} }
 func (m *NodeStatus) String() string { return proto.CompactTextString(m) }
 func (*NodeStatus) ProtoMessage()    {}
 func (*NodeStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{20}
+	return fileDescriptor_d2a91b51c7bdc125, []int{20}
 }
 func (m *NodeStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1263,15 +1265,15 @@ func (m *NodeStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_NodeStatus.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *NodeStatus) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_NodeStatus.Merge(dst, src)
+func (m *NodeStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeStatus.Merge(m, src)
 }
 func (m *NodeStatus) XXX_Size() int {
 	return m.Size()
@@ -1305,7 +1307,7 @@ func (m *NodeStatus) GetIndexes() []*IndexStatus {
 
 type IndexStatus struct {
 	Name                 string         `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	Fields               []*FieldStatus `protobuf:"bytes,2,rep,name=Fields" json:"Fields,omitempty"`
+	Fields               []*FieldStatus `protobuf:"bytes,2,rep,name=Fields,proto3" json:"Fields,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
 	XXX_unrecognized     []byte         `json:"-"`
 	XXX_sizecache        int32          `json:"-"`
@@ -1315,7 +1317,7 @@ func (m *IndexStatus) Reset()         { *m = IndexStatus{} }
 func (m *IndexStatus) String() string { return proto.CompactTextString(m) }
 func (*IndexStatus) ProtoMessage()    {}
 func (*IndexStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{21}
+	return fileDescriptor_d2a91b51c7bdc125, []int{21}
 }
 func (m *IndexStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1325,15 +1327,15 @@ func (m *IndexStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_IndexStatus.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *IndexStatus) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_IndexStatus.Merge(dst, src)
+func (m *IndexStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexStatus.Merge(m, src)
 }
 func (m *IndexStatus) XXX_Size() int {
 	return m.Size()
@@ -1360,7 +1362,7 @@ func (m *IndexStatus) GetFields() []*FieldStatus {
 
 type FieldStatus struct {
 	Name                 string   `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
-	AvailableShards      []uint64 `protobuf:"varint,2,rep,packed,name=AvailableShards" json:"AvailableShards,omitempty"`
+	AvailableShards      []uint64 `protobuf:"varint,2,rep,packed,name=AvailableShards,proto3" json:"AvailableShards,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1370,7 +1372,7 @@ func (m *FieldStatus) Reset()         { *m = FieldStatus{} }
 func (m *FieldStatus) String() string { return proto.CompactTextString(m) }
 func (*FieldStatus) ProtoMessage()    {}
 func (*FieldStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{22}
+	return fileDescriptor_d2a91b51c7bdc125, []int{22}
 }
 func (m *FieldStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1380,15 +1382,15 @@ func (m *FieldStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_FieldStatus.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *FieldStatus) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FieldStatus.Merge(dst, src)
+func (m *FieldStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldStatus.Merge(m, src)
 }
 func (m *FieldStatus) XXX_Size() int {
 	return m.Size()
@@ -1416,7 +1418,7 @@ func (m *FieldStatus) GetAvailableShards() []uint64 {
 type ClusterStatus struct {
 	ClusterID            string   `protobuf:"bytes,1,opt,name=ClusterID,proto3" json:"ClusterID,omitempty"`
 	State                string   `protobuf:"bytes,2,opt,name=State,proto3" json:"State,omitempty"`
-	Nodes                []*Node  `protobuf:"bytes,3,rep,name=Nodes" json:"Nodes,omitempty"`
+	Nodes                []*Node  `protobuf:"bytes,3,rep,name=Nodes,proto3" json:"Nodes,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1426,7 +1428,7 @@ func (m *ClusterStatus) Reset()         { *m = ClusterStatus{} }
 func (m *ClusterStatus) String() string { return proto.CompactTextString(m) }
 func (*ClusterStatus) ProtoMessage()    {}
 func (*ClusterStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{23}
+	return fileDescriptor_d2a91b51c7bdc125, []int{23}
 }
 func (m *ClusterStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1436,15 +1438,15 @@ func (m *ClusterStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_ClusterStatus.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ClusterStatus) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ClusterStatus.Merge(dst, src)
+func (m *ClusterStatus) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ClusterStatus.Merge(m, src)
 }
 func (m *ClusterStatus) XXX_Size() int {
 	return m.Size()
@@ -1490,7 +1492,7 @@ func (m *BSIGroup) Reset()         { *m = BSIGroup{} }
 func (m *BSIGroup) String() string { return proto.CompactTextString(m) }
 func (*BSIGroup) ProtoMessage()    {}
 func (*BSIGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{24}
+	return fileDescriptor_d2a91b51c7bdc125, []int{24}
 }
 func (m *BSIGroup) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1500,15 +1502,15 @@ func (m *BSIGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_BSIGroup.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *BSIGroup) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BSIGroup.Merge(dst, src)
+func (m *BSIGroup) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BSIGroup.Merge(m, src)
 }
 func (m *BSIGroup) XXX_Size() int {
 	return m.Size()
@@ -1560,7 +1562,7 @@ func (m *CreateViewMessage) Reset()         { *m = CreateViewMessage{} }
 func (m *CreateViewMessage) String() string { return proto.CompactTextString(m) }
 func (*CreateViewMessage) ProtoMessage()    {}
 func (*CreateViewMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{25}
+	return fileDescriptor_d2a91b51c7bdc125, []int{25}
 }
 func (m *CreateViewMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1570,15 +1572,15 @@ func (m *CreateViewMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_CreateViewMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *CreateViewMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateViewMessage.Merge(dst, src)
+func (m *CreateViewMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateViewMessage.Merge(m, src)
 }
 func (m *CreateViewMessage) XXX_Size() int {
 	return m.Size()
@@ -1623,7 +1625,7 @@ func (m *DeleteViewMessage) Reset()         { *m = DeleteViewMessage{} }
 func (m *DeleteViewMessage) String() string { return proto.CompactTextString(m) }
 func (*DeleteViewMessage) ProtoMessage()    {}
 func (*DeleteViewMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{26}
+	return fileDescriptor_d2a91b51c7bdc125, []int{26}
 }
 func (m *DeleteViewMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1633,15 +1635,15 @@ func (m *DeleteViewMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_DeleteViewMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *DeleteViewMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DeleteViewMessage.Merge(dst, src)
+func (m *DeleteViewMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DeleteViewMessage.Merge(m, src)
 }
 func (m *DeleteViewMessage) XXX_Size() int {
 	return m.Size()
@@ -1675,11 +1677,11 @@ func (m *DeleteViewMessage) GetView() string {
 
 type ResizeInstruction struct {
 	JobID                int64           `protobuf:"varint,1,opt,name=JobID,proto3" json:"JobID,omitempty"`
-	Node                 *Node           `protobuf:"bytes,2,opt,name=Node" json:"Node,omitempty"`
-	Coordinator          *Node           `protobuf:"bytes,3,opt,name=Coordinator" json:"Coordinator,omitempty"`
-	Sources              []*ResizeSource `protobuf:"bytes,4,rep,name=Sources" json:"Sources,omitempty"`
-	NodeStatus           *NodeStatus     `protobuf:"bytes,7,opt,name=NodeStatus" json:"NodeStatus,omitempty"`
-	ClusterStatus        *ClusterStatus  `protobuf:"bytes,6,opt,name=ClusterStatus" json:"ClusterStatus,omitempty"`
+	Node                 *Node           `protobuf:"bytes,2,opt,name=Node,proto3" json:"Node,omitempty"`
+	Coordinator          *Node           `protobuf:"bytes,3,opt,name=Coordinator,proto3" json:"Coordinator,omitempty"`
+	Sources              []*ResizeSource `protobuf:"bytes,4,rep,name=Sources,proto3" json:"Sources,omitempty"`
+	NodeStatus           *NodeStatus     `protobuf:"bytes,7,opt,name=NodeStatus,proto3" json:"NodeStatus,omitempty"`
+	ClusterStatus        *ClusterStatus  `protobuf:"bytes,6,opt,name=ClusterStatus,proto3" json:"ClusterStatus,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
 	XXX_unrecognized     []byte          `json:"-"`
 	XXX_sizecache        int32           `json:"-"`
@@ -1689,7 +1691,7 @@ func (m *ResizeInstruction) Reset()         { *m = ResizeInstruction{} }
 func (m *ResizeInstruction) String() string { return proto.CompactTextString(m) }
 func (*ResizeInstruction) ProtoMessage()    {}
 func (*ResizeInstruction) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{27}
+	return fileDescriptor_d2a91b51c7bdc125, []int{27}
 }
 func (m *ResizeInstruction) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1699,15 +1701,15 @@ func (m *ResizeInstruction) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_ResizeInstruction.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ResizeInstruction) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ResizeInstruction.Merge(dst, src)
+func (m *ResizeInstruction) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ResizeInstruction.Merge(m, src)
 }
 func (m *ResizeInstruction) XXX_Size() int {
 	return m.Size()
@@ -1761,7 +1763,7 @@ func (m *ResizeInstruction) GetClusterStatus() *ClusterStatus {
 }
 
 type ResizeSource struct {
-	Node                 *Node    `protobuf:"bytes,1,opt,name=Node" json:"Node,omitempty"`
+	Node                 *Node    `protobuf:"bytes,1,opt,name=Node,proto3" json:"Node,omitempty"`
 	Index                string   `protobuf:"bytes,2,opt,name=Index,proto3" json:"Index,omitempty"`
 	Field                string   `protobuf:"bytes,3,opt,name=Field,proto3" json:"Field,omitempty"`
 	View                 string   `protobuf:"bytes,4,opt,name=View,proto3" json:"View,omitempty"`
@@ -1775,7 +1777,7 @@ func (m *ResizeSource) Reset()         { *m = ResizeSource{} }
 func (m *ResizeSource) String() string { return proto.CompactTextString(m) }
 func (*ResizeSource) ProtoMessage()    {}
 func (*ResizeSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{28}
+	return fileDescriptor_d2a91b51c7bdc125, []int{28}
 }
 func (m *ResizeSource) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1785,15 +1787,15 @@ func (m *ResizeSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_ResizeSource.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ResizeSource) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ResizeSource.Merge(dst, src)
+func (m *ResizeSource) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ResizeSource.Merge(m, src)
 }
 func (m *ResizeSource) XXX_Size() int {
 	return m.Size()
@@ -1841,7 +1843,7 @@ func (m *ResizeSource) GetShard() uint64 {
 
 type ResizeInstructionComplete struct {
 	JobID                int64    `protobuf:"varint,1,opt,name=JobID,proto3" json:"JobID,omitempty"`
-	Node                 *Node    `protobuf:"bytes,2,opt,name=Node" json:"Node,omitempty"`
+	Node                 *Node    `protobuf:"bytes,2,opt,name=Node,proto3" json:"Node,omitempty"`
 	Error                string   `protobuf:"bytes,3,opt,name=Error,proto3" json:"Error,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -1852,7 +1854,7 @@ func (m *ResizeInstructionComplete) Reset()         { *m = ResizeInstructionComp
 func (m *ResizeInstructionComplete) String() string { return proto.CompactTextString(m) }
 func (*ResizeInstructionComplete) ProtoMessage()    {}
 func (*ResizeInstructionComplete) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{29}
+	return fileDescriptor_d2a91b51c7bdc125, []int{29}
 }
 func (m *ResizeInstructionComplete) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1862,15 +1864,15 @@ func (m *ResizeInstructionComplete) XXX_Marshal(b []byte, deterministic bool) ([
 		return xxx_messageInfo_ResizeInstructionComplete.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ResizeInstructionComplete) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ResizeInstructionComplete.Merge(dst, src)
+func (m *ResizeInstructionComplete) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ResizeInstructionComplete.Merge(m, src)
 }
 func (m *ResizeInstructionComplete) XXX_Size() int {
 	return m.Size()
@@ -1903,7 +1905,7 @@ func (m *ResizeInstructionComplete) GetError() string {
 }
 
 type SetCoordinatorMessage struct {
-	New                  *Node    `protobuf:"bytes,1,opt,name=New" json:"New,omitempty"`
+	New                  *Node    `protobuf:"bytes,1,opt,name=New,proto3" json:"New,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1913,7 +1915,7 @@ func (m *SetCoordinatorMessage) Reset()         { *m = SetCoordinatorMessage{} }
 func (m *SetCoordinatorMessage) String() string { return proto.CompactTextString(m) }
 func (*SetCoordinatorMessage) ProtoMessage()    {}
 func (*SetCoordinatorMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{30}
+	return fileDescriptor_d2a91b51c7bdc125, []int{30}
 }
 func (m *SetCoordinatorMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1923,15 +1925,15 @@ func (m *SetCoordinatorMessage) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return xxx_messageInfo_SetCoordinatorMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *SetCoordinatorMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SetCoordinatorMessage.Merge(dst, src)
+func (m *SetCoordinatorMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetCoordinatorMessage.Merge(m, src)
 }
 func (m *SetCoordinatorMessage) XXX_Size() int {
 	return m.Size()
@@ -1950,7 +1952,7 @@ func (m *SetCoordinatorMessage) GetNew() *Node {
 }
 
 type UpdateCoordinatorMessage struct {
-	New                  *Node    `protobuf:"bytes,1,opt,name=New" json:"New,omitempty"`
+	New                  *Node    `protobuf:"bytes,1,opt,name=New,proto3" json:"New,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1960,7 +1962,7 @@ func (m *UpdateCoordinatorMessage) Reset()         { *m = UpdateCoordinatorMessa
 func (m *UpdateCoordinatorMessage) String() string { return proto.CompactTextString(m) }
 func (*UpdateCoordinatorMessage) ProtoMessage()    {}
 func (*UpdateCoordinatorMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{31}
+	return fileDescriptor_d2a91b51c7bdc125, []int{31}
 }
 func (m *UpdateCoordinatorMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1970,15 +1972,15 @@ func (m *UpdateCoordinatorMessage) XXX_Marshal(b []byte, deterministic bool) ([]
 		return xxx_messageInfo_UpdateCoordinatorMessage.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *UpdateCoordinatorMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_UpdateCoordinatorMessage.Merge(dst, src)
+func (m *UpdateCoordinatorMessage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UpdateCoordinatorMessage.Merge(m, src)
 }
 func (m *UpdateCoordinatorMessage) XXX_Size() int {
 	return m.Size()
@@ -1998,7 +2000,7 @@ func (m *UpdateCoordinatorMessage) GetNew() *Node {
 
 type Topology struct {
 	ClusterID            string   `protobuf:"bytes,1,opt,name=ClusterID,proto3" json:"ClusterID,omitempty"`
-	NodeIDs              []string `protobuf:"bytes,2,rep,name=NodeIDs" json:"NodeIDs,omitempty"`
+	NodeIDs              []string `protobuf:"bytes,2,rep,name=NodeIDs,proto3" json:"NodeIDs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -2008,7 +2010,7 @@ func (m *Topology) Reset()         { *m = Topology{} }
 func (m *Topology) String() string { return proto.CompactTextString(m) }
 func (*Topology) ProtoMessage()    {}
 func (*Topology) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{32}
+	return fileDescriptor_d2a91b51c7bdc125, []int{32}
 }
 func (m *Topology) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2018,15 +2020,15 @@ func (m *Topology) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Topology.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *Topology) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Topology.Merge(dst, src)
+func (m *Topology) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Topology.Merge(m, src)
 }
 func (m *Topology) XXX_Size() int {
 	return m.Size()
@@ -2061,7 +2063,7 @@ func (m *RecalculateCaches) Reset()         { *m = RecalculateCaches{} }
 func (m *RecalculateCaches) String() string { return proto.CompactTextString(m) }
 func (*RecalculateCaches) ProtoMessage()    {}
 func (*RecalculateCaches) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_54a82f4803638cdd, []int{33}
+	return fileDescriptor_d2a91b51c7bdc125, []int{33}
 }
 func (m *RecalculateCaches) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2071,15 +2073,15 @@ func (m *RecalculateCaches) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_RecalculateCaches.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *RecalculateCaches) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RecalculateCaches.Merge(dst, src)
+func (m *RecalculateCaches) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RecalculateCaches.Merge(m, src)
 }
 func (m *RecalculateCaches) XXX_Size() int {
 	return m.Size()
@@ -2127,10 +2129,92 @@ func init() {
 	proto.RegisterType((*Topology)(nil), "internal.Topology")
 	proto.RegisterType((*RecalculateCaches)(nil), "internal.RecalculateCaches")
 }
+
+func init() { proto.RegisterFile("private.proto", fileDescriptor_d2a91b51c7bdc125) }
+
+var fileDescriptor_d2a91b51c7bdc125 = []byte{
+	// 1191 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdb, 0x6e, 0x1b, 0x45,
+	0x18, 0x66, 0x0f, 0x71, 0xec, 0xdf, 0x71, 0xea, 0x4e, 0x0f, 0x6c, 0x0b, 0x0a, 0x66, 0x54, 0x51,
+	0x53, 0x89, 0x50, 0xb5, 0x5c, 0x70, 0xaa, 0x54, 0x1c, 0xa7, 0x65, 0x29, 0x09, 0x65, 0x9c, 0xf6,
+	0x8e, 0x8b, 0xa9, 0x3d, 0x6a, 0x56, 0x59, 0xef, 0x98, 0xdd, 0x71, 0x12, 0xf7, 0x82, 0x5b, 0x90,
+	0x78, 0x01, 0x9e, 0x80, 0x67, 0x41, 0x5c, 0xf1, 0x08, 0x28, 0xbc, 0x08, 0x9a, 0x7f, 0x66, 0x0f,
+	0x76, 0x5c, 0x12, 0x02, 0x77, 0xf3, 0x7f, 0xff, 0xfc, 0xe7, 0xc3, 0xce, 0x42, 0x6b, 0x92, 0x46,
+	0x87, 0x5c, 0x89, 0xcd, 0x49, 0x2a, 0x95, 0x24, 0xf5, 0x28, 0x51, 0x22, 0x4d, 0x78, 0x4c, 0x1f,
+	0x43, 0x23, 0x4c, 0x46, 0xe2, 0x78, 0x47, 0x28, 0x4e, 0x08, 0xf8, 0x4f, 0xc4, 0x2c, 0x0b, 0xbc,
+	0x8e, 0xd3, 0xad, 0x33, 0x3c, 0x93, 0xf7, 0x60, 0x7d, 0x2f, 0xe5, 0xc3, 0x83, 0xed, 0xe3, 0x28,
+	0x53, 0x22, 0x19, 0x8a, 0xc0, 0x47, 0xee, 0x02, 0x4a, 0x7f, 0x77, 0x61, 0xed, 0x51, 0x24, 0xe2,
+	0xd1, 0x37, 0x13, 0x15, 0xc9, 0x24, 0xd3, 0xca, 0xf6, 0x66, 0x13, 0x11, 0xd4, 0x3b, 0x4e, 0xb7,
+	0xc1, 0xf0, 0x4c, 0xde, 0x86, 0xc6, 0x16, 0x1f, 0xee, 0x0b, 0x64, 0x78, 0xc8, 0x28, 0x81, 0x82,
+	0x3b, 0x88, 0x5e, 0x19, 0x2b, 0x2d, 0x56, 0x02, 0xa4, 0x03, 0xcd, 0xbd, 0x68, 0x2c, 0xbe, 0x9d,
+	0xf2, 0x44, 0x4d, 0xc7, 0xc1, 0x0a, 0x4a, 0x57, 0x21, 0xd2, 0x06, 0x6f, 0x27, 0x4a, 0x82, 0x46,
+	0xc7, 0xe9, 0x7a, 0x4c, 0x1f, 0x11, 0xe1, 0xc7, 0x01, 0x58, 0x84, 0x1f, 0x17, 0x21, 0x36, 0xe7,
+	0x43, 0xdc, 0x95, 0x03, 0xc5, 0x93, 0x11, 0x4f, 0x47, 0xcf, 0x23, 0x71, 0x14, 0xac, 0x99, 0x10,
+	0xe7, 0x51, 0x2d, 0xdb, 0xe3, 0x99, 0x08, 0x5a, 0xa8, 0x0e, 0xcf, 0xe4, 0x26, 0xd4, 0x7b, 0x91,
+	0xea, 0x8b, 0x89, 0xda, 0x0f, 0xd6, 0x3b, 0x4e, 0xd7, 0x67, 0x05, 0x4d, 0xae, 0xc2, 0xca, 0x60,
+	0xc8, 0x63, 0x11, 0x5c, 0x42, 0x01, 0x43, 0x10, 0x0a, 0x6b, 0x8f, 0x64, 0x2a, 0xa2, 0x97, 0x09,
+	0x26, 0x3e, 0x68, 0x63, 0x20, 0x73, 0x18, 0xa5, 0xb0, 0x1e, 0x8e, 0x27, 0x32, 0x55, 0x4c, 0x64,
+	0x13, 0x99, 0x64, 0x42, 0x47, 0xb2, 0x9d, 0xa6, 0x81, 0x83, 0x97, 0xf5, 0x91, 0xfe, 0x00, 0xed,
+	0x5e, 0x2c, 0x87, 0x07, 0x7d, 0xae, 0x38, 0x13, 0xdf, 0x4f, 0x45, 0xa6, 0xb4, 0x45, 0xa3, 0xd4,
+	0xdc, 0x33, 0x84, 0x46, 0xb1, 0x32, 0x81, 0x6b, 0x50, 0x24, 0x74, 0x34, 0x18, 0xab, 0x49, 0x24,
+	0x9e, 0xd1, 0xe3, 0x7d, 0x9e, 0x8e, 0x30, 0xfb, 0x3e, 0x33, 0x84, 0x46, 0xd1, 0x12, 0x56, 0xcc,
+	0x67, 0x86, 0xa0, 0x21, 0x5c, 0xae, 0xd8, 0xb7, 0x6e, 0x5e, 0x87, 0x1a, 0x93, 0x47, 0x61, 0x3f,
+	0x0b, 0x9c, 0x8e, 0xd7, 0xf5, 0x99, 0xa5, 0xb0, 0xb4, 0x32, 0x9e, 0x8e, 0x13, 0xcd, 0x72, 0x91,
+	0x55, 0x02, 0xf4, 0x06, 0xac, 0x60, 0x9d, 0x75, 0x94, 0xa5, 0xac, 0x3e, 0xd2, 0x1f, 0x1d, 0x68,
+	0xec, 0xf0, 0x63, 0x74, 0x24, 0x23, 0x0f, 0xa0, 0x9e, 0x57, 0x04, 0x2f, 0x35, 0xef, 0xbd, 0xbb,
+	0x99, 0xb7, 0xf2, 0x66, 0x71, 0x6d, 0x33, 0xbf, 0xb3, 0x9d, 0xa8, 0x74, 0xc6, 0x0a, 0x91, 0x9b,
+	0x9f, 0x41, 0x6b, 0x8e, 0xa5, 0xed, 0x1d, 0x88, 0x59, 0x9e, 0xd5, 0x03, 0x31, 0xd3, 0xb1, 0x1e,
+	0xf2, 0x78, 0x2a, 0x30, 0x57, 0x3e, 0x33, 0xc4, 0xa7, 0xee, 0xc7, 0x0e, 0x7d, 0x0e, 0x64, 0x2b,
+	0x15, 0x5c, 0x09, 0x34, 0xb2, 0x23, 0xb2, 0x8c, 0xbf, 0x14, 0x67, 0x65, 0xdc, 0xab, 0x66, 0xbc,
+	0xc8, 0xae, 0x5b, 0xc9, 0x2e, 0xbd, 0x03, 0xa4, 0x2f, 0x62, 0xa1, 0x84, 0x9d, 0xc3, 0x7f, 0xd0,
+	0x4b, 0x07, 0xb9, 0x0f, 0x67, 0xdf, 0x25, 0xb7, 0xc1, 0xd7, 0x43, 0x8d, 0xc6, 0x9a, 0xf7, 0xae,
+	0x94, 0x79, 0x2a, 0xe6, 0x9d, 0xe1, 0x05, 0x1a, 0xe7, 0x4a, 0xd1, 0xcb, 0x73, 0x06, 0x36, 0xd7,
+	0x4a, 0x77, 0xac, 0x29, 0x0f, 0x4d, 0x5d, 0x2f, 0x4d, 0x55, 0x17, 0x82, 0xb5, 0xf6, 0x30, 0x0f,
+	0xf7, 0xa2, 0xd6, 0xe8, 0x10, 0xde, 0x32, 0x1a, 0xbe, 0x38, 0xe4, 0x51, 0xcc, 0x5f, 0xc4, 0xff,
+	0xaa, 0x22, 0x73, 0x8e, 0x07, 0xb0, 0x8a, 0xb2, 0x61, 0xdf, 0xf6, 0x76, 0x4e, 0xd2, 0xef, 0xa0,
+	0x1c, 0x93, 0x5d, 0x3e, 0x16, 0x56, 0x1b, 0x9e, 0x8b, 0x78, 0xdd, 0xb3, 0xe3, 0xd5, 0x86, 0xf5,
+	0x68, 0xe9, 0xa5, 0xea, 0x69, 0xc3, 0x48, 0xd0, 0xfb, 0x50, 0x1b, 0x0c, 0xf7, 0xc5, 0x98, 0x93,
+	0xf7, 0x61, 0x15, 0x3d, 0x14, 0x99, 0xed, 0xe8, 0x4b, 0x0b, 0x95, 0x62, 0x39, 0x9f, 0xf6, 0x6d,
+	0x64, 0x4b, 0x7d, 0xba, 0x0d, 0x35, 0xb4, 0x9e, 0x05, 0xfe, 0xa2, 0x1a, 0xc4, 0x99, 0x65, 0xd3,
+	0x6d, 0xf0, 0x9e, 0xb1, 0x50, 0x4f, 0x2a, 0x7a, 0x90, 0x6b, 0xb1, 0x94, 0xd6, 0xfd, 0xa5, 0xcc,
+	0x94, 0xcd, 0x13, 0x9e, 0x35, 0xf6, 0x54, 0xa6, 0x0a, 0x73, 0xd4, 0x62, 0x78, 0xa6, 0x19, 0xf8,
+	0xbb, 0x72, 0x24, 0xc8, 0x3a, 0xb8, 0x61, 0xdf, 0xea, 0x70, 0xc3, 0x3e, 0x79, 0x07, 0xd5, 0xdb,
+	0xd4, 0xb4, 0x4a, 0x27, 0x9e, 0xb1, 0x90, 0xa1, 0xe1, 0x5b, 0xd0, 0x0a, 0xb3, 0x2d, 0x29, 0xd3,
+	0x51, 0x94, 0x70, 0x25, 0x53, 0xfb, 0xb5, 0x99, 0x07, 0x71, 0x56, 0x14, 0x57, 0xe6, 0x3b, 0xd0,
+	0x60, 0x86, 0xa0, 0x0f, 0xa1, 0xad, 0x8d, 0x22, 0x91, 0xd7, 0xfb, 0x3a, 0xd4, 0x34, 0x56, 0x38,
+	0x61, 0xa9, 0x52, 0x83, 0x5b, 0xd5, 0xf0, 0xb5, 0xd1, 0xb0, 0x7d, 0x28, 0x12, 0x55, 0xe9, 0x18,
+	0xa4, 0x51, 0x41, 0x8b, 0x19, 0x82, 0x50, 0x13, 0xa0, 0x8d, 0x64, 0xbd, 0x8c, 0x44, 0xa3, 0x0c,
+	0x79, 0xf4, 0x67, 0x07, 0x20, 0x77, 0x68, 0x9a, 0x15, 0x22, 0xce, 0xeb, 0x45, 0x48, 0x37, 0xaf,
+	0xbc, 0x9d, 0x96, 0x76, 0x79, 0xcb, 0xe0, 0x2c, 0xef, 0x8c, 0x0f, 0xcb, 0xce, 0x30, 0x25, 0xbd,
+	0xb6, 0xd0, 0x19, 0xc6, 0x6a, 0xd9, 0x1f, 0x4f, 0xa1, 0x59, 0xc1, 0x97, 0x76, 0xc9, 0x07, 0x45,
+	0x97, 0xb8, 0x8b, 0x2a, 0x11, 0xb7, 0x2a, 0xf3, 0x5e, 0x79, 0x02, 0xcd, 0x0a, 0xbc, 0x54, 0x63,
+	0x17, 0x2e, 0xcd, 0xcf, 0x61, 0xbe, 0xdf, 0x17, 0x61, 0x1a, 0x41, 0x6b, 0x2b, 0x9e, 0x66, 0x4a,
+	0xa4, 0x56, 0x9d, 0xfe, 0x28, 0x18, 0xa0, 0x28, 0x5e, 0x09, 0x2c, 0xaf, 0x1f, 0xb9, 0x05, 0x2b,
+	0x3a, 0x8d, 0x66, 0x9c, 0x4e, 0xe7, 0xd8, 0x30, 0xe9, 0x73, 0xa8, 0xf7, 0x06, 0xe1, 0xe3, 0x54,
+	0x4e, 0x27, 0x4b, 0x9d, 0xce, 0xdf, 0x26, 0x6e, 0xe5, 0x6d, 0x62, 0x5f, 0x0f, 0xde, 0xa9, 0xd7,
+	0x83, 0x5f, 0xbc, 0x1e, 0xe8, 0x00, 0x2e, 0x9b, 0x55, 0xa9, 0xa7, 0xf8, 0x22, 0x0b, 0x27, 0xff,
+	0xe8, 0x7a, 0xe5, 0x47, 0x57, 0x2b, 0x35, 0xfb, 0xec, 0xff, 0x54, 0xfa, 0xab, 0x0b, 0x97, 0x99,
+	0xc8, 0xa2, 0x57, 0x22, 0x4c, 0x32, 0x95, 0x4e, 0x87, 0x7a, 0x27, 0x69, 0xf9, 0xaf, 0xe4, 0x0b,
+	0x9b, 0x6d, 0x8f, 0x19, 0xe2, 0x3c, 0x9d, 0x4e, 0xee, 0x42, 0x73, 0x71, 0x66, 0x4f, 0x5f, 0xad,
+	0x5e, 0x21, 0x77, 0x61, 0x75, 0x20, 0xa7, 0xe9, 0xb0, 0x68, 0xdf, 0xca, 0x9e, 0x34, 0x9e, 0x19,
+	0x36, 0xcb, 0xaf, 0x91, 0x8f, 0xaa, 0xc3, 0x14, 0xac, 0xa2, 0x89, 0xab, 0xf3, 0x26, 0x6c, 0x7f,
+	0x56, 0x87, 0xee, 0xc1, 0x42, 0x5b, 0x05, 0x35, 0x14, 0x7c, 0xb3, 0x14, 0x9c, 0x63, 0xb3, 0xf9,
+	0xdb, 0xf4, 0x27, 0x07, 0xd6, 0xaa, 0xee, 0x9c, 0x6b, 0x88, 0x8b, 0xea, 0xb8, 0x67, 0x7f, 0xf5,
+	0xf3, 0xea, 0xf8, 0xcb, 0xde, 0x59, 0x2b, 0xd5, 0x97, 0xc0, 0x01, 0xdc, 0x38, 0x55, 0xb2, 0x2d,
+	0x39, 0x9e, 0xe8, 0xde, 0xf8, 0x0f, 0xa5, 0xd3, 0xeb, 0x2d, 0x4d, 0x6d, 0xd1, 0x1a, 0xcc, 0x10,
+	0xf4, 0x13, 0xb8, 0x36, 0x10, 0xaa, 0x52, 0xb0, 0xbc, 0xf3, 0x3a, 0xe0, 0xed, 0x8a, 0xa3, 0xd7,
+	0x84, 0xaf, 0x59, 0xf4, 0x73, 0x08, 0x9e, 0x4d, 0x46, 0x5c, 0x89, 0x0b, 0x49, 0xf7, 0xa0, 0xbe,
+	0x27, 0x27, 0x32, 0x96, 0x2f, 0x67, 0x67, 0x6c, 0x80, 0x00, 0x56, 0xcd, 0x2e, 0x37, 0x2b, 0xa5,
+	0xc1, 0x72, 0x92, 0x5e, 0xd1, 0xcd, 0x3d, 0xe4, 0xf1, 0x70, 0x1a, 0x6b, 0x37, 0xf4, 0xdb, 0x31,
+	0xeb, 0xb5, 0x7f, 0x3b, 0xd9, 0x70, 0xfe, 0x38, 0xd9, 0x70, 0xfe, 0x3c, 0xd9, 0x70, 0x7e, 0xf9,
+	0x6b, 0xe3, 0x8d, 0x17, 0x35, 0xfc, 0xdb, 0xb9, 0xff, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xde,
+	0xfb, 0x46, 0xba, 0xfe, 0x0c, 0x00, 0x00,
+}
+
 func (m *IndexMeta) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2138,40 +2222,46 @@ func (m *IndexMeta) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *IndexMeta) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *IndexMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Keys {
-		dAtA[i] = 0x18
-		i++
-		if m.Keys {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i++
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if m.TrackExistence {
-		dAtA[i] = 0x20
-		i++
+		i--
 		if m.TrackExistence {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i++
+		i--
+		dAtA[i] = 0x20
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Keys {
+		i--
+		if m.Keys {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x18
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *FieldOptions) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2179,96 +2269,106 @@ func (m *FieldOptions) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *FieldOptions) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FieldOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.CacheType) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.CacheType)))
-		i += copy(dAtA[i:], m.CacheType)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.CacheSize != 0 {
-		dAtA[i] = 0x20
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.CacheSize))
+	if len(m.ForeignIndex) > 0 {
+		i -= len(m.ForeignIndex)
+		copy(dAtA[i:], m.ForeignIndex)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ForeignIndex)))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0x82
 	}
-	if len(m.TimeQuantum) > 0 {
-		dAtA[i] = 0x2a
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.TimeQuantum)))
-		i += copy(dAtA[i:], m.TimeQuantum)
+	if m.Scale != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Scale))
+		i--
+		dAtA[i] = 0x78
 	}
-	if len(m.Type) > 0 {
-		dAtA[i] = 0x42
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Type)))
-		i += copy(dAtA[i:], m.Type)
+	if m.BitDepth != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.BitDepth))
+		i--
+		dAtA[i] = 0x70
 	}
-	if m.Min != 0 {
-		dAtA[i] = 0x48
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Min))
-	}
-	if m.Max != 0 {
-		dAtA[i] = 0x50
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Max))
-	}
-	if m.Keys {
-		dAtA[i] = 0x58
-		i++
-		if m.Keys {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i++
+	if m.Base != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Base))
+		i--
+		dAtA[i] = 0x68
 	}
 	if m.NoStandardView {
-		dAtA[i] = 0x60
-		i++
+		i--
 		if m.NoStandardView {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i++
+		i--
+		dAtA[i] = 0x60
 	}
-	if m.Base != 0 {
-		dAtA[i] = 0x68
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Base))
+	if m.Keys {
+		i--
+		if m.Keys {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x58
 	}
-	if m.BitDepth != 0 {
-		dAtA[i] = 0x70
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.BitDepth))
+	if m.Max != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Max))
+		i--
+		dAtA[i] = 0x50
 	}
-	if m.Scale != 0 {
-		dAtA[i] = 0x78
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Scale))
+	if m.Min != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Min))
+		i--
+		dAtA[i] = 0x48
 	}
-	if len(m.ForeignIndex) > 0 {
-		dAtA[i] = 0x82
-		i++
-		dAtA[i] = 0x1
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ForeignIndex)))
-		i += copy(dAtA[i:], m.ForeignIndex)
+	if len(m.Type) > 0 {
+		i -= len(m.Type)
+		copy(dAtA[i:], m.Type)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Type)))
+		i--
+		dAtA[i] = 0x42
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.TimeQuantum) > 0 {
+		i -= len(m.TimeQuantum)
+		copy(dAtA[i:], m.TimeQuantum)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.TimeQuantum)))
+		i--
+		dAtA[i] = 0x2a
 	}
-	return i, nil
+	if m.CacheSize != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.CacheSize))
+		i--
+		dAtA[i] = 0x20
+	}
+	if len(m.CacheType) > 0 {
+		i -= len(m.CacheType)
+		copy(dAtA[i:], m.CacheType)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.CacheType)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *ImportResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2276,26 +2376,33 @@ func (m *ImportResponse) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportResponse) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ImportResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Err) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Err)))
-		i += copy(dAtA[i:], m.Err)
-	}
 	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return i, nil
+	if len(m.Err) > 0 {
+		i -= len(m.Err)
+		copy(dAtA[i:], m.Err)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Err)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *BlockDataRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2303,48 +2410,57 @@ func (m *BlockDataRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *BlockDataRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BlockDataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
-	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
-	}
-	if m.Block != 0 {
-		dAtA[i] = 0x18
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Block))
-	}
-	if m.Shard != 0 {
-		dAtA[i] = 0x20
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.View) > 0 {
-		dAtA[i] = 0x2a
-		i++
+		i -= len(m.View)
+		copy(dAtA[i:], m.View)
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
-		i += copy(dAtA[i:], m.View)
+		i--
+		dAtA[i] = 0x2a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Shard != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
+		i--
+		dAtA[i] = 0x20
 	}
-	return i, nil
+	if m.Block != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Block))
+		i--
+		dAtA[i] = 0x18
+	}
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *BlockDataResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2352,14 +2468,23 @@ func (m *BlockDataResponse) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *BlockDataResponse) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BlockDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.RowIDs) > 0 {
-		dAtA2 := make([]byte, len(m.RowIDs)*10)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.ColumnIDs) > 0 {
+		dAtA2 := make([]byte, len(m.ColumnIDs)*10)
 		var j1 int
-		for _, num := range m.RowIDs {
+		for _, num := range m.ColumnIDs {
 			for num >= 1<<7 {
 				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
@@ -2368,15 +2493,16 @@ func (m *BlockDataResponse) MarshalTo(dAtA []byte) (int, error) {
 			dAtA2[j1] = uint8(num)
 			j1++
 		}
-		dAtA[i] = 0xa
-		i++
+		i -= j1
+		copy(dAtA[i:], dAtA2[:j1])
 		i = encodeVarintPrivate(dAtA, i, uint64(j1))
-		i += copy(dAtA[i:], dAtA2[:j1])
+		i--
+		dAtA[i] = 0x12
 	}
-	if len(m.ColumnIDs) > 0 {
-		dAtA4 := make([]byte, len(m.ColumnIDs)*10)
+	if len(m.RowIDs) > 0 {
+		dAtA4 := make([]byte, len(m.RowIDs)*10)
 		var j3 int
-		for _, num := range m.ColumnIDs {
+		for _, num := range m.RowIDs {
 			for num >= 1<<7 {
 				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
@@ -2385,21 +2511,19 @@ func (m *BlockDataResponse) MarshalTo(dAtA []byte) (int, error) {
 			dAtA4[j3] = uint8(num)
 			j3++
 		}
-		dAtA[i] = 0x12
-		i++
+		i -= j3
+		copy(dAtA[i:], dAtA4[:j3])
 		i = encodeVarintPrivate(dAtA, i, uint64(j3))
-		i += copy(dAtA[i:], dAtA4[:j3])
+		i--
+		dAtA[i] = 0xa
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *Cache) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2407,10 +2531,19 @@ func (m *Cache) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Cache) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Cache) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	if len(m.IDs) > 0 {
 		dAtA6 := make([]byte, len(m.IDs)*10)
 		var j5 int
@@ -2423,21 +2556,19 @@ func (m *Cache) MarshalTo(dAtA []byte) (int, error) {
 			dAtA6[j5] = uint8(num)
 			j5++
 		}
-		dAtA[i] = 0xa
-		i++
+		i -= j5
+		copy(dAtA[i:], dAtA6[:j5])
 		i = encodeVarintPrivate(dAtA, i, uint64(j5))
-		i += copy(dAtA[i:], dAtA6[:j5])
+		i--
+		dAtA[i] = 0xa
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *MaxShards) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2445,36 +2576,43 @@ func (m *MaxShards) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *MaxShards) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MaxShards) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	if len(m.Standard) > 0 {
-		for k, _ := range m.Standard {
-			dAtA[i] = 0xa
-			i++
+		for k := range m.Standard {
 			v := m.Standard[k]
-			mapSize := 1 + len(k) + sovPrivate(uint64(len(k))) + 1 + sovPrivate(uint64(v))
-			i = encodeVarintPrivate(dAtA, i, uint64(mapSize))
-			dAtA[i] = 0xa
-			i++
-			i = encodeVarintPrivate(dAtA, i, uint64(len(k)))
-			i += copy(dAtA[i:], k)
-			dAtA[i] = 0x10
-			i++
+			baseI := i
 			i = encodeVarintPrivate(dAtA, i, uint64(v))
+			i--
+			dAtA[i] = 0x10
+			i -= len(k)
+			copy(dAtA[i:], k)
+			i = encodeVarintPrivate(dAtA, i, uint64(len(k)))
+			i--
+			dAtA[i] = 0xa
+			i = encodeVarintPrivate(dAtA, i, uint64(baseI-i))
+			i--
+			dAtA[i] = 0xa
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *CreateShardMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2482,37 +2620,45 @@ func (m *CreateShardMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *CreateShardMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CreateShardMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
-	if m.Shard != 0 {
-		dAtA[i] = 0x10
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Field) > 0 {
-		dAtA[i] = 0x1a
-		i++
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Shard != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
+		i--
+		dAtA[i] = 0x10
 	}
-	return i, nil
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *DeleteIndexMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2520,26 +2666,33 @@ func (m *DeleteIndexMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *DeleteIndexMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DeleteIndexMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
 	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return i, nil
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *CreateIndexMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2547,36 +2700,45 @@ func (m *CreateIndexMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *CreateIndexMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CreateIndexMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if m.Meta != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Meta.Size()))
-		n7, err := m.Meta.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
+		{
+			size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
 		}
-		i += n7
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *CreateFieldMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2584,42 +2746,52 @@ func (m *CreateFieldMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *CreateFieldMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CreateFieldMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
-	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if m.Meta != nil {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Meta.Size()))
-		n8, err := m.Meta.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
+		{
+			size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
 		}
-		i += n8
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *DeleteFieldMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2627,32 +2799,40 @@ func (m *DeleteFieldMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *DeleteFieldMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DeleteFieldMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *DeleteAvailableShardMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2660,37 +2840,45 @@ func (m *DeleteAvailableShardMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *DeleteAvailableShardMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DeleteAvailableShardMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
-	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if m.ShardID != 0 {
-		dAtA[i] = 0x18
-		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(m.ShardID))
+		i--
+		dAtA[i] = 0x18
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *Field) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2698,51 +2886,54 @@ func (m *Field) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Field) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Field) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Name) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
-		i += copy(dAtA[i:], m.Name)
-	}
-	if m.Meta != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Meta.Size()))
-		n9, err := m.Meta.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n9
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Views) > 0 {
-		for _, s := range m.Views {
+		for iNdEx := len(m.Views) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Views[iNdEx])
+			copy(dAtA[i:], m.Views[iNdEx])
+			i = encodeVarintPrivate(dAtA, i, uint64(len(m.Views[iNdEx])))
+			i--
 			dAtA[i] = 0x1a
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Meta != nil {
+		{
+			size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *Schema) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2750,32 +2941,40 @@ func (m *Schema) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Schema) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Schema) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	if len(m.Indexes) > 0 {
-		for _, msg := range m.Indexes {
-			dAtA[i] = 0xa
-			i++
-			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
+		for iNdEx := len(m.Indexes) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Indexes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPrivate(dAtA, i, uint64(size))
 			}
-			i += n
+			i--
+			dAtA[i] = 0xa
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *Index) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2783,38 +2982,47 @@ func (m *Index) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Index) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Index) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Name) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
-		i += copy(dAtA[i:], m.Name)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Fields) > 0 {
-		for _, msg := range m.Fields {
-			dAtA[i] = 0x22
-			i++
-			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
+		for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Fields[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPrivate(dAtA, i, uint64(size))
 			}
-			i += n
+			i--
+			dAtA[i] = 0x22
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *URI) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2822,37 +3030,45 @@ func (m *URI) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *URI) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *URI) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Scheme) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Scheme)))
-		i += copy(dAtA[i:], m.Scheme)
-	}
-	if len(m.Host) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Host)))
-		i += copy(dAtA[i:], m.Host)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if m.Port != 0 {
-		dAtA[i] = 0x18
-		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(m.Port))
+		i--
+		dAtA[i] = 0x18
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Host) > 0 {
+		i -= len(m.Host)
+		copy(dAtA[i:], m.Host)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Host)))
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if len(m.Scheme) > 0 {
+		i -= len(m.Scheme)
+		copy(dAtA[i:], m.Scheme)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Scheme)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *Node) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2860,52 +3076,62 @@ func (m *Node) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Node) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.ID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ID)))
-		i += copy(dAtA[i:], m.ID)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.URI != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.URI.Size()))
-		n10, err := m.URI.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n10
+	if len(m.State) > 0 {
+		i -= len(m.State)
+		copy(dAtA[i:], m.State)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
+		i--
+		dAtA[i] = 0x22
 	}
 	if m.IsCoordinator {
-		dAtA[i] = 0x18
-		i++
+		i--
 		if m.IsCoordinator {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i++
+		i--
+		dAtA[i] = 0x18
 	}
-	if len(m.State) > 0 {
-		dAtA[i] = 0x22
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
-		i += copy(dAtA[i:], m.State)
+	if m.URI != nil {
+		{
+			size, err := m.URI.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.ID) > 0 {
+		i -= len(m.ID)
+		copy(dAtA[i:], m.ID)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ID)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *NodeStateMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2913,32 +3139,40 @@ func (m *NodeStateMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *NodeStateMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *NodeStateMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.NodeID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.NodeID)))
-		i += copy(dAtA[i:], m.NodeID)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.State) > 0 {
-		dAtA[i] = 0x12
-		i++
+		i -= len(m.State)
+		copy(dAtA[i:], m.State)
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
-		i += copy(dAtA[i:], m.State)
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.NodeID) > 0 {
+		i -= len(m.NodeID)
+		copy(dAtA[i:], m.NodeID)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.NodeID)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *NodeEventMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2946,35 +3180,43 @@ func (m *NodeEventMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *NodeEventMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *NodeEventMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Event != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Event))
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if m.Node != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Node.Size()))
-		n11, err := m.Node.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
+		{
+			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
 		}
-		i += n11
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Event != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Event))
+		i--
+		dAtA[i] = 0x8
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *NodeStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2982,52 +3224,64 @@ func (m *NodeStatus) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *NodeStatus) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *NodeStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Node != nil {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Node.Size()))
-		n12, err := m.Node.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n12
-	}
-	if m.Schema != nil {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Schema.Size()))
-		n13, err := m.Schema.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n13
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Indexes) > 0 {
-		for _, msg := range m.Indexes {
+		for iNdEx := len(m.Indexes) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Indexes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPrivate(dAtA, i, uint64(size))
+			}
+			i--
 			dAtA[i] = 0x22
-			i++
-			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
+		}
+	}
+	if m.Schema != nil {
+		{
+			size, err := m.Schema.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
-			i += n
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Node != nil {
+		{
+			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *IndexStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3035,38 +3289,47 @@ func (m *IndexStatus) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *IndexStatus) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *IndexStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Name) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
-		i += copy(dAtA[i:], m.Name)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Fields) > 0 {
-		for _, msg := range m.Fields {
-			dAtA[i] = 0x12
-			i++
-			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
+		for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Fields[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPrivate(dAtA, i, uint64(size))
 			}
-			i += n
+			i--
+			dAtA[i] = 0x12
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *FieldStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3074,15 +3337,18 @@ func (m *FieldStatus) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *FieldStatus) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FieldStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Name) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
-		i += copy(dAtA[i:], m.Name)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.AvailableShards) > 0 {
 		dAtA15 := make([]byte, len(m.AvailableShards)*10)
@@ -3096,21 +3362,26 @@ func (m *FieldStatus) MarshalTo(dAtA []byte) (int, error) {
 			dAtA15[j14] = uint8(num)
 			j14++
 		}
-		dAtA[i] = 0x12
-		i++
+		i -= j14
+		copy(dAtA[i:], dAtA15[:j14])
 		i = encodeVarintPrivate(dAtA, i, uint64(j14))
-		i += copy(dAtA[i:], dAtA15[:j14])
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *ClusterStatus) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3118,44 +3389,54 @@ func (m *ClusterStatus) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ClusterStatus) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ClusterStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.ClusterID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ClusterID)))
-		i += copy(dAtA[i:], m.ClusterID)
-	}
-	if len(m.State) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
-		i += copy(dAtA[i:], m.State)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Nodes) > 0 {
-		for _, msg := range m.Nodes {
-			dAtA[i] = 0x1a
-			i++
-			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
+		for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Nodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPrivate(dAtA, i, uint64(size))
 			}
-			i += n
+			i--
+			dAtA[i] = 0x1a
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.State) > 0 {
+		i -= len(m.State)
+		copy(dAtA[i:], m.State)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if len(m.ClusterID) > 0 {
+		i -= len(m.ClusterID)
+		copy(dAtA[i:], m.ClusterID)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ClusterID)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *BSIGroup) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3163,42 +3444,50 @@ func (m *BSIGroup) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *BSIGroup) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BSIGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Name) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
-		i += copy(dAtA[i:], m.Name)
-	}
-	if len(m.Type) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Type)))
-		i += copy(dAtA[i:], m.Type)
-	}
-	if m.Min != 0 {
-		dAtA[i] = 0x18
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Min))
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if m.Max != 0 {
-		dAtA[i] = 0x20
-		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(m.Max))
+		i--
+		dAtA[i] = 0x20
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Min != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.Min))
+		i--
+		dAtA[i] = 0x18
 	}
-	return i, nil
+	if len(m.Type) > 0 {
+		i -= len(m.Type)
+		copy(dAtA[i:], m.Type)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Type)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *CreateViewMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3206,38 +3495,47 @@ func (m *CreateViewMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *CreateViewMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CreateViewMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
-	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.View) > 0 {
-		dAtA[i] = 0x1a
-		i++
+		i -= len(m.View)
+		copy(dAtA[i:], m.View)
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
-		i += copy(dAtA[i:], m.View)
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *DeleteViewMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3245,38 +3543,47 @@ func (m *DeleteViewMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *DeleteViewMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DeleteViewMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
-	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.View) > 0 {
-		dAtA[i] = 0x1a
-		i++
+		i -= len(m.View)
+		copy(dAtA[i:], m.View)
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
-		i += copy(dAtA[i:], m.View)
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *ResizeInstruction) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3284,77 +3591,93 @@ func (m *ResizeInstruction) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ResizeInstruction) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ResizeInstruction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.JobID != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.JobID))
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.Node != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Node.Size()))
-		n16, err := m.Node.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n16
-	}
-	if m.Coordinator != nil {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Coordinator.Size()))
-		n17, err := m.Coordinator.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n17
-	}
-	if len(m.Sources) > 0 {
-		for _, msg := range m.Sources {
-			dAtA[i] = 0x22
-			i++
-			i = encodeVarintPrivate(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
+	if m.NodeStatus != nil {
+		{
+			size, err := m.NodeStatus.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
-			i += n
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x3a
 	}
 	if m.ClusterStatus != nil {
+		{
+			size, err := m.ClusterStatus.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
+		}
+		i--
 		dAtA[i] = 0x32
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.ClusterStatus.Size()))
-		n18, err := m.ClusterStatus.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
+	}
+	if len(m.Sources) > 0 {
+		for iNdEx := len(m.Sources) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Sources[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPrivate(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x22
 		}
-		i += n18
 	}
-	if m.NodeStatus != nil {
-		dAtA[i] = 0x3a
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.NodeStatus.Size()))
-		n19, err := m.NodeStatus.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
+	if m.Coordinator != nil {
+		{
+			size, err := m.Coordinator.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
 		}
-		i += n19
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Node != nil {
+		{
+			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if m.JobID != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.JobID))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *ResizeSource) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3362,53 +3685,64 @@ func (m *ResizeSource) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ResizeSource) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ResizeSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Node != nil {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Node.Size()))
-		n20, err := m.Node.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n20
-	}
-	if len(m.Index) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
-	if len(m.Field) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
-	}
-	if len(m.View) > 0 {
-		dAtA[i] = 0x22
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
-		i += copy(dAtA[i:], m.View)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if m.Shard != 0 {
-		dAtA[i] = 0x28
-		i++
 		i = encodeVarintPrivate(dAtA, i, uint64(m.Shard))
+		i--
+		dAtA[i] = 0x28
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.View) > 0 {
+		i -= len(m.View)
+		copy(dAtA[i:], m.View)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.View)))
+		i--
+		dAtA[i] = 0x22
 	}
-	return i, nil
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Node != nil {
+		{
+			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *ResizeInstructionComplete) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3416,41 +3750,50 @@ func (m *ResizeInstructionComplete) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ResizeInstructionComplete) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ResizeInstructionComplete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.JobID != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.JobID))
-	}
-	if m.Node != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.Node.Size()))
-		n21, err := m.Node.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n21
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Error) > 0 {
-		dAtA[i] = 0x1a
-		i++
+		i -= len(m.Error)
+		copy(dAtA[i:], m.Error)
 		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Error)))
-		i += copy(dAtA[i:], m.Error)
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Node != nil {
+		{
+			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if m.JobID != 0 {
+		i = encodeVarintPrivate(dAtA, i, uint64(m.JobID))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *SetCoordinatorMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3458,30 +3801,38 @@ func (m *SetCoordinatorMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *SetCoordinatorMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SetCoordinatorMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.New != nil {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.New.Size()))
-		n22, err := m.New.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n22
-	}
 	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return i, nil
+	if m.New != nil {
+		{
+			size, err := m.New.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *UpdateCoordinatorMessage) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3489,30 +3840,38 @@ func (m *UpdateCoordinatorMessage) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *UpdateCoordinatorMessage) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UpdateCoordinatorMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.New != nil {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(m.New.Size()))
-		n23, err := m.New.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n23
-	}
 	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return i, nil
+	if m.New != nil {
+		{
+			size, err := m.New.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPrivate(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *Topology) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3520,41 +3879,42 @@ func (m *Topology) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Topology) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Topology) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.ClusterID) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ClusterID)))
-		i += copy(dAtA[i:], m.ClusterID)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.NodeIDs) > 0 {
-		for _, s := range m.NodeIDs {
+		for iNdEx := len(m.NodeIDs) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.NodeIDs[iNdEx])
+			copy(dAtA[i:], m.NodeIDs[iNdEx])
+			i = encodeVarintPrivate(dAtA, i, uint64(len(m.NodeIDs[iNdEx])))
+			i--
 			dAtA[i] = 0x12
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.ClusterID) > 0 {
+		i -= len(m.ClusterID)
+		copy(dAtA[i:], m.ClusterID)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.ClusterID)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *RecalculateCaches) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -3562,24 +3922,32 @@ func (m *RecalculateCaches) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *RecalculateCaches) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *RecalculateCaches) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
 	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func encodeVarintPrivate(dAtA []byte, offset int, v uint64) int {
+	offset -= sovPrivate(v)
+	base := offset
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
 		v >>= 7
 		offset++
 	}
 	dAtA[offset] = uint8(v)
-	return offset + 1
+	return base
 }
 func (m *IndexMeta) Size() (n int) {
 	if m == nil {
@@ -4372,14 +4740,7 @@ func (m *RecalculateCaches) Size() (n int) {
 }
 
 func sovPrivate(x uint64) (n int) {
-	for {
-		n++
-		x >>= 7
-		if x == 0 {
-			break
-		}
-	}
-	return n
+	return (math_bits.Len64(x|1) + 6) / 7
 }
 func sozPrivate(x uint64) (n int) {
 	return sovPrivate(uint64((x << 1) ^ uint64((int64(x) >> 63))))
@@ -4399,7 +4760,7 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4427,7 +4788,7 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4447,7 +4808,7 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4462,6 +4823,9 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4490,7 +4854,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4518,7 +4882,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4528,6 +4892,9 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4547,7 +4914,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.CacheSize |= (uint32(b) & 0x7F) << shift
+				m.CacheSize |= uint32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4566,7 +4933,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4576,6 +4943,9 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4595,7 +4965,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4605,6 +4975,9 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4624,7 +4997,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Min |= (int64(b) & 0x7F) << shift
+				m.Min |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4643,7 +5016,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Max |= (int64(b) & 0x7F) << shift
+				m.Max |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4662,7 +5035,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4682,7 +5055,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4702,7 +5075,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Base |= (int64(b) & 0x7F) << shift
+				m.Base |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4721,7 +5094,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.BitDepth |= (uint64(b) & 0x7F) << shift
+				m.BitDepth |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4740,7 +5113,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Scale |= (int64(b) & 0x7F) << shift
+				m.Scale |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4759,7 +5132,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4769,6 +5142,9 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4783,6 +5159,9 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4811,7 +5190,7 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4839,7 +5218,7 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4849,6 +5228,9 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4863,6 +5245,9 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4891,7 +5276,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4919,7 +5304,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4929,6 +5314,9 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4948,7 +5336,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4958,6 +5346,9 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4977,7 +5368,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Block |= (uint64(b) & 0x7F) << shift
+				m.Block |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4996,7 +5387,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= (uint64(b) & 0x7F) << shift
+				m.Shard |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5015,7 +5406,7 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5025,6 +5416,9 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5039,6 +5433,9 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5067,7 +5464,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5093,7 +5490,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5110,7 +5507,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5119,12 +5516,15 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPrivate
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPrivate
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -5144,7 +5544,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5166,7 +5566,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5183,7 +5583,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5192,12 +5592,15 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPrivate
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPrivate
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -5217,7 +5620,7 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5236,6 +5639,9 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5264,7 +5670,7 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5290,7 +5696,7 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5307,7 +5713,7 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5316,12 +5722,15 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPrivate
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPrivate
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -5341,7 +5750,7 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5360,6 +5769,9 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5388,7 +5800,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5416,7 +5828,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5425,6 +5837,9 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5445,7 +5860,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					wire |= (uint64(b) & 0x7F) << shift
+					wire |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5462,7 +5877,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						stringLenmapkey |= (uint64(b) & 0x7F) << shift
+						stringLenmapkey |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5472,6 +5887,9 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 						return ErrInvalidLengthPrivate
 					}
 					postStringIndexmapkey := iNdEx + intStringLenmapkey
+					if postStringIndexmapkey < 0 {
+						return ErrInvalidLengthPrivate
+					}
 					if postStringIndexmapkey > l {
 						return io.ErrUnexpectedEOF
 					}
@@ -5487,7 +5905,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						mapvalue |= (uint64(b) & 0x7F) << shift
+						mapvalue |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5518,6 +5936,9 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5546,7 +5967,7 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5574,7 +5995,7 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5584,6 +6005,9 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5603,7 +6027,7 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= (uint64(b) & 0x7F) << shift
+				m.Shard |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5622,7 +6046,7 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5632,6 +6056,9 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5646,6 +6073,9 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5674,7 +6104,7 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5702,7 +6132,7 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5712,6 +6142,9 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5726,6 +6159,9 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5754,7 +6190,7 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5782,7 +6218,7 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5792,6 +6228,9 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5811,7 +6250,7 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5820,6 +6259,9 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5839,6 +6281,9 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5867,7 +6312,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5895,7 +6340,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5905,6 +6350,9 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5924,7 +6372,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5934,6 +6382,9 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5953,7 +6404,7 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5962,6 +6413,9 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5981,6 +6435,9 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6009,7 +6466,7 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6037,7 +6494,7 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6047,6 +6504,9 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6066,7 +6526,7 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6076,6 +6536,9 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6090,6 +6553,9 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6118,7 +6584,7 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6146,7 +6612,7 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6156,6 +6622,9 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6175,7 +6644,7 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6185,6 +6654,9 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6204,7 +6676,7 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.ShardID |= (uint64(b) & 0x7F) << shift
+				m.ShardID |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6218,6 +6690,9 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6246,7 +6721,7 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6274,7 +6749,7 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6284,6 +6759,9 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6303,7 +6781,7 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6312,6 +6790,9 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6336,7 +6817,7 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6346,6 +6827,9 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6360,6 +6844,9 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6388,7 +6875,7 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6416,7 +6903,7 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6425,6 +6912,9 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6442,6 +6932,9 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6470,7 +6963,7 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6498,7 +6991,7 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6508,6 +7001,9 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6527,7 +7023,7 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6536,6 +7032,9 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6553,6 +7052,9 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6581,7 +7083,7 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6609,7 +7111,7 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6619,6 +7121,9 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6638,7 +7143,7 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6648,6 +7153,9 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6667,7 +7175,7 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Port |= (uint32(b) & 0x7F) << shift
+				m.Port |= uint32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6681,6 +7189,9 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6709,7 +7220,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6737,7 +7248,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6747,6 +7258,9 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6766,7 +7280,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6775,6 +7289,9 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6799,7 +7316,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6819,7 +7336,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6829,6 +7346,9 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6843,6 +7363,9 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6871,7 +7394,7 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6899,7 +7422,7 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6909,6 +7432,9 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6928,7 +7454,7 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6938,6 +7464,9 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6952,6 +7481,9 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6980,7 +7512,7 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7008,7 +7540,7 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Event |= (uint32(b) & 0x7F) << shift
+				m.Event |= uint32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7027,7 +7559,7 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7036,6 +7568,9 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7055,6 +7590,9 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7083,7 +7621,7 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7111,7 +7649,7 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7120,6 +7658,9 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7144,7 +7685,7 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7153,6 +7694,9 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7177,7 +7721,7 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7186,6 +7730,9 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7203,6 +7750,9 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7231,7 +7781,7 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7259,7 +7809,7 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7269,6 +7819,9 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7288,7 +7841,7 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7297,6 +7850,9 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7314,6 +7870,9 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7342,7 +7901,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7370,7 +7929,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7380,6 +7939,9 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7397,7 +7959,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7414,7 +7976,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7423,12 +7985,15 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPrivate
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPrivate
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -7448,7 +8013,7 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -7467,6 +8032,9 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7495,7 +8063,7 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7523,7 +8091,7 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7533,6 +8101,9 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7552,7 +8123,7 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7562,6 +8133,9 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7581,7 +8155,7 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7590,6 +8164,9 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7607,6 +8184,9 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7635,7 +8215,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7663,7 +8243,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7673,6 +8253,9 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7692,7 +8275,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7702,6 +8285,9 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7721,7 +8307,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Min |= (int64(b) & 0x7F) << shift
+				m.Min |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7740,7 +8326,7 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Max |= (int64(b) & 0x7F) << shift
+				m.Max |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7754,6 +8340,9 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7782,7 +8371,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7810,7 +8399,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7820,6 +8409,9 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7839,7 +8431,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7849,6 +8441,9 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7868,7 +8463,7 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7878,6 +8473,9 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7892,6 +8490,9 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7920,7 +8521,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7948,7 +8549,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7958,6 +8559,9 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7977,7 +8581,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7987,6 +8591,9 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8006,7 +8613,7 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8016,6 +8623,9 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8030,6 +8640,9 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8058,7 +8671,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8086,7 +8699,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.JobID |= (int64(b) & 0x7F) << shift
+				m.JobID |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8105,7 +8718,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8114,6 +8727,9 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8138,7 +8754,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8147,6 +8763,9 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8171,7 +8790,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8180,6 +8799,9 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8202,7 +8824,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8211,6 +8833,9 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8235,7 +8860,7 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8244,6 +8869,9 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8263,6 +8891,9 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8291,7 +8922,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8319,7 +8950,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8328,6 +8959,9 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8352,7 +8986,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8362,6 +8996,9 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8381,7 +9018,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8391,6 +9028,9 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8410,7 +9050,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8420,6 +9060,9 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8439,7 +9082,7 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= (uint64(b) & 0x7F) << shift
+				m.Shard |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8453,6 +9096,9 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8481,7 +9127,7 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8509,7 +9155,7 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.JobID |= (int64(b) & 0x7F) << shift
+				m.JobID |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8528,7 +9174,7 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8537,6 +9183,9 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8561,7 +9210,7 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8571,6 +9220,9 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8585,6 +9237,9 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8613,7 +9268,7 @@ func (m *SetCoordinatorMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8641,7 +9296,7 @@ func (m *SetCoordinatorMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8650,6 +9305,9 @@ func (m *SetCoordinatorMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8669,6 +9327,9 @@ func (m *SetCoordinatorMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8697,7 +9358,7 @@ func (m *UpdateCoordinatorMessage) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8725,7 +9386,7 @@ func (m *UpdateCoordinatorMessage) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8734,6 +9395,9 @@ func (m *UpdateCoordinatorMessage) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8753,6 +9417,9 @@ func (m *UpdateCoordinatorMessage) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8781,7 +9448,7 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8809,7 +9476,7 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8819,6 +9486,9 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8838,7 +9508,7 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -8848,6 +9518,9 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPrivate
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8862,6 +9535,9 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8890,7 +9566,7 @@ func (m *RecalculateCaches) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -8913,6 +9589,9 @@ func (m *RecalculateCaches) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPrivate
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPrivate
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -8929,6 +9608,7 @@ func (m *RecalculateCaches) Unmarshal(dAtA []byte) error {
 func skipPrivate(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
+	depth := 0
 	for iNdEx < l {
 		var wire uint64
 		for shift := uint(0); ; shift += 7 {
@@ -8960,10 +9640,8 @@ func skipPrivate(dAtA []byte) (n int, err error) {
 					break
 				}
 			}
-			return iNdEx, nil
 		case 1:
 			iNdEx += 8
-			return iNdEx, nil
 		case 2:
 			var length int
 			for shift := uint(0); ; shift += 7 {
@@ -8980,134 +9658,34 @@ func skipPrivate(dAtA []byte) (n int, err error) {
 					break
 				}
 			}
-			iNdEx += length
 			if length < 0 {
 				return 0, ErrInvalidLengthPrivate
 			}
-			return iNdEx, nil
+			iNdEx += length
 		case 3:
-			for {
-				var innerWire uint64
-				var start int = iNdEx
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return 0, ErrIntOverflowPrivate
-					}
-					if iNdEx >= l {
-						return 0, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					innerWire |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				innerWireType := int(innerWire & 0x7)
-				if innerWireType == 4 {
-					break
-				}
-				next, err := skipPrivate(dAtA[start:])
-				if err != nil {
-					return 0, err
-				}
-				iNdEx = start + next
-			}
-			return iNdEx, nil
+			depth++
 		case 4:
-			return iNdEx, nil
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupPrivate
+			}
+			depth--
 		case 5:
 			iNdEx += 4
-			return iNdEx, nil
 		default:
 			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthPrivate
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
 	}
-	panic("unreachable")
+	return 0, io.ErrUnexpectedEOF
 }
 
 var (
-	ErrInvalidLengthPrivate = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowPrivate   = fmt.Errorf("proto: integer overflow")
+	ErrInvalidLengthPrivate        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowPrivate          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupPrivate = fmt.Errorf("proto: unexpected end of group")
 )
-
-func init() { proto.RegisterFile("private.proto", fileDescriptor_private_54a82f4803638cdd) }
-
-var fileDescriptor_private_54a82f4803638cdd = []byte{
-	// 1192 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdb, 0x6e, 0x1b, 0x45,
-	0x18, 0x66, 0x0f, 0x71, 0xec, 0xdf, 0x71, 0xe2, 0x6c, 0xdb, 0xb0, 0x2d, 0x28, 0x98, 0x51, 0x45,
-	0x4d, 0x25, 0x42, 0xd5, 0x72, 0xc1, 0xa9, 0x52, 0x71, 0x9c, 0x96, 0xa5, 0x24, 0x94, 0x71, 0x92,
-	0x3b, 0x2e, 0x26, 0xf6, 0x28, 0x59, 0x65, 0xbd, 0x63, 0x76, 0xc7, 0x49, 0xdc, 0x0b, 0x6e, 0x41,
-	0xe2, 0x05, 0x78, 0x02, 0x9e, 0x05, 0x71, 0xc5, 0x23, 0xa0, 0xf0, 0x22, 0x68, 0xfe, 0x99, 0x3d,
-	0xd8, 0x71, 0x48, 0x14, 0x7a, 0x37, 0xff, 0xf9, 0xf0, 0xfd, 0xff, 0xec, 0x2c, 0x34, 0x46, 0x49,
-	0x78, 0xc2, 0x24, 0xdf, 0x18, 0x25, 0x42, 0x0a, 0xaf, 0x1a, 0xc6, 0x92, 0x27, 0x31, 0x8b, 0xc8,
-	0x0b, 0xa8, 0x05, 0xf1, 0x80, 0x9f, 0x6d, 0x73, 0xc9, 0x3c, 0x0f, 0xdc, 0x97, 0x7c, 0x92, 0xfa,
-	0x4e, 0xcb, 0x6a, 0x57, 0x29, 0x9e, 0xbd, 0x0f, 0x60, 0x79, 0x37, 0x61, 0xfd, 0xe3, 0xad, 0xb3,
-	0x30, 0x95, 0x3c, 0xee, 0x73, 0xdf, 0x45, 0xe9, 0x0c, 0x97, 0xfc, 0x69, 0xc3, 0xd2, 0xf3, 0x90,
-	0x47, 0x83, 0xef, 0x46, 0x32, 0x14, 0x71, 0xea, 0xbd, 0x0b, 0xb5, 0x4d, 0xd6, 0x3f, 0xe2, 0xbb,
-	0x93, 0x11, 0x47, 0x8f, 0x35, 0x5a, 0x30, 0x72, 0x69, 0x2f, 0x7c, 0xad, 0x3d, 0x36, 0x68, 0xc1,
-	0xf0, 0x5a, 0x50, 0xdf, 0x0d, 0x87, 0xfc, 0xfb, 0x31, 0x8b, 0xe5, 0x78, 0xe8, 0x2f, 0xa0, 0x75,
-	0x99, 0xa5, 0x52, 0x45, 0xc7, 0x55, 0x14, 0xe1, 0xd9, 0x6b, 0x82, 0xb3, 0x1d, 0xc6, 0x7e, 0xad,
-	0x65, 0xb5, 0x1d, 0xaa, 0x8e, 0xc8, 0x61, 0x67, 0x3e, 0x18, 0x0e, 0x3b, 0xcb, 0x4b, 0xac, 0x4f,
-	0x97, 0xb8, 0x23, 0x7a, 0x92, 0xc5, 0x03, 0x96, 0x0c, 0xf6, 0x43, 0x7e, 0xea, 0x2f, 0xe9, 0x12,
-	0xa7, 0xb9, 0xca, 0xb6, 0xc3, 0x52, 0xee, 0x37, 0xd0, 0x1d, 0x9e, 0xbd, 0x7b, 0x50, 0xed, 0x84,
-	0xb2, 0xcb, 0x47, 0xf2, 0xc8, 0x5f, 0x6e, 0x59, 0x6d, 0x97, 0xe6, 0xb4, 0x77, 0x1b, 0x16, 0x7a,
-	0x7d, 0x16, 0x71, 0x7f, 0x05, 0x0d, 0x34, 0xe1, 0x11, 0x58, 0x7a, 0x2e, 0x12, 0x1e, 0x1e, 0xc6,
-	0xd8, 0x78, 0xbf, 0x89, 0x15, 0x4c, 0xf1, 0x08, 0x81, 0xe5, 0x60, 0x38, 0x12, 0x89, 0xa4, 0x3c,
-	0x1d, 0x89, 0x38, 0xc5, 0xda, 0xb6, 0x92, 0xc4, 0xb7, 0x50, 0x59, 0x1d, 0xc9, 0x4f, 0xd0, 0xec,
-	0x44, 0xa2, 0x7f, 0xdc, 0x65, 0x92, 0x51, 0xfe, 0xe3, 0x98, 0xa7, 0x52, 0x45, 0xd4, 0x4e, 0xb5,
-	0x9e, 0x26, 0x14, 0x17, 0x91, 0xf1, 0x6d, 0xcd, 0x45, 0x42, 0x71, 0xd1, 0x1e, 0xb1, 0x71, 0xa9,
-	0x26, 0x30, 0xe7, 0x23, 0x96, 0x0c, 0x10, 0x13, 0x97, 0x6a, 0x42, 0x55, 0x8e, 0x7d, 0xd1, 0x40,
-	0xe0, 0x99, 0x04, 0xb0, 0x5a, 0x8a, 0x6f, 0xd2, 0x5c, 0x83, 0x0a, 0x15, 0xa7, 0x41, 0x37, 0xf5,
-	0xad, 0x96, 0xd3, 0x76, 0xa9, 0xa1, 0x10, 0x6e, 0x11, 0x8d, 0x87, 0xb1, 0x12, 0xd9, 0x28, 0x2a,
-	0x18, 0xe4, 0x2e, 0x2c, 0x20, 0xf6, 0xaa, 0xca, 0xc2, 0x56, 0x1d, 0xc9, 0xcf, 0x16, 0xd4, 0xb6,
-	0xd9, 0x19, 0xa6, 0x91, 0x7a, 0x4f, 0xa1, 0x9a, 0x21, 0x82, 0x4a, 0xf5, 0xc7, 0xef, 0x6f, 0x64,
-	0xa3, 0xbc, 0x91, 0xab, 0x6d, 0x64, 0x3a, 0x5b, 0xb1, 0x4c, 0x26, 0x34, 0x37, 0xb9, 0xf7, 0x05,
-	0x34, 0xa6, 0x44, 0x2a, 0xde, 0x31, 0x9f, 0x64, 0x5d, 0x3d, 0xe6, 0x13, 0x55, 0xff, 0x09, 0x8b,
-	0xc6, 0x1c, 0x7b, 0xe5, 0x52, 0x4d, 0x7c, 0x6e, 0x7f, 0x6a, 0x91, 0x7d, 0xf0, 0x36, 0x13, 0xce,
-	0x24, 0xc7, 0x20, 0xdb, 0x3c, 0x4d, 0xd9, 0x21, 0xbf, 0xbc, 0xe3, 0xba, 0x8b, 0x76, 0xb9, 0x8b,
-	0x39, 0x0e, 0x4e, 0x09, 0x07, 0xf2, 0x10, 0xbc, 0x2e, 0x8f, 0xb8, 0xe4, 0x66, 0x0f, 0xff, 0xc3,
-	0x2f, 0xe9, 0x65, 0x39, 0x5c, 0xad, 0xeb, 0x3d, 0x00, 0x57, 0x2d, 0x35, 0xa6, 0x50, 0x7f, 0x7c,
-	0xab, 0xe8, 0x53, 0xbe, 0xef, 0x14, 0x15, 0x48, 0x94, 0x39, 0xc5, 0x7c, 0xae, 0x2c, 0x6c, 0xce,
-	0x28, 0x3d, 0x34, 0xa1, 0x1c, 0x0c, 0xb5, 0x56, 0x84, 0x2a, 0x5f, 0x08, 0x26, 0xda, 0xb3, 0xac,
-	0xdc, 0x9b, 0x46, 0x23, 0x7d, 0x78, 0x47, 0x7b, 0xf8, 0xea, 0x84, 0x85, 0x11, 0x3b, 0x88, 0xae,
-	0x89, 0xc8, 0x9c, 0xc4, 0x7d, 0x58, 0x44, 0xdb, 0xa0, 0x6b, 0xb6, 0x20, 0x23, 0xc9, 0x0f, 0x46,
-	0x5f, 0x8d, 0xfe, 0x0e, 0x1b, 0x72, 0xe3, 0x0d, 0xcf, 0x79, 0xbd, 0xf6, 0xd5, 0xf5, 0xaa, 0xc0,
-	0x6a, 0x5d, 0xd4, 0xa5, 0xea, 0xa8, 0xc0, 0x48, 0x90, 0x27, 0x50, 0xe9, 0xf5, 0x8f, 0xf8, 0x90,
-	0x79, 0x1f, 0xc2, 0x22, 0x66, 0xc8, 0x53, 0x33, 0xd1, 0x2b, 0x33, 0x48, 0xd1, 0x4c, 0x4e, 0xba,
-	0xa6, 0xb2, 0xb9, 0x39, 0x3d, 0x80, 0x0a, 0x46, 0x4f, 0x7d, 0x77, 0xd6, 0x0d, 0xf2, 0xa9, 0x11,
-	0x93, 0x2d, 0x70, 0xf6, 0x68, 0xa0, 0x36, 0x15, 0x33, 0xc8, 0xbc, 0x18, 0x4a, 0xf9, 0xfe, 0x5a,
-	0xa4, 0xd2, 0xf4, 0x09, 0xcf, 0x8a, 0xf7, 0x4a, 0x24, 0x12, 0x7b, 0xd4, 0xa0, 0x78, 0x26, 0x29,
-	0xb8, 0x3b, 0x62, 0xc0, 0xbd, 0x65, 0xb0, 0x83, 0xae, 0xf1, 0x61, 0x07, 0x5d, 0xef, 0x3d, 0x74,
-	0x6f, 0x5a, 0xd3, 0x28, 0x92, 0xd8, 0xa3, 0x01, 0xc5, 0xc0, 0xf7, 0xa1, 0x11, 0xa4, 0x9b, 0x42,
-	0x24, 0x83, 0x30, 0x66, 0x52, 0x24, 0xe6, 0x6b, 0x33, 0xcd, 0xc4, 0x0d, 0x92, 0x4c, 0xea, 0x6f,
-	0x43, 0x8d, 0x6a, 0x82, 0x3c, 0x83, 0xa6, 0x0a, 0x8a, 0x44, 0x86, 0xf7, 0x1a, 0x54, 0x14, 0x2f,
-	0x4f, 0xc2, 0x50, 0x85, 0x07, 0xbb, 0xec, 0xe1, 0x5b, 0xed, 0x61, 0xeb, 0x84, 0xc7, 0xb2, 0x34,
-	0x31, 0x48, 0xa3, 0x83, 0x06, 0xd5, 0x84, 0x47, 0x74, 0x81, 0xa6, 0x92, 0xe5, 0xa2, 0x12, 0xc5,
-	0xa5, 0x28, 0x23, 0xbf, 0x5a, 0x00, 0x59, 0x42, 0xe3, 0x34, 0x37, 0xb1, 0x2e, 0x37, 0xf1, 0xda,
-	0x19, 0xf2, 0x66, 0x5b, 0x9a, 0x85, 0x96, 0xe6, 0xd3, 0x6c, 0x32, 0x3e, 0x2e, 0x26, 0x43, 0x43,
-	0x7a, 0x67, 0x66, 0x32, 0x74, 0xd4, 0x62, 0x3e, 0x5e, 0x41, 0xbd, 0xc4, 0x9f, 0x3b, 0x25, 0x1f,
-	0xe5, 0x53, 0x62, 0xcf, 0xba, 0x44, 0xbe, 0x71, 0x99, 0xcd, 0xca, 0x4b, 0xa8, 0x97, 0xd8, 0x73,
-	0x3d, 0xb6, 0x61, 0x65, 0x7a, 0x0f, 0xb3, 0xfb, 0x7d, 0x96, 0x4d, 0x42, 0x68, 0x6c, 0x46, 0xe3,
-	0x54, 0xf2, 0xc4, 0xb8, 0x53, 0x1f, 0x05, 0xcd, 0xc8, 0xc1, 0x2b, 0x18, 0xf3, 0xf1, 0xf3, 0xee,
-	0xc3, 0x82, 0x6a, 0xa3, 0x5e, 0xa7, 0x8b, 0x3d, 0xd6, 0x42, 0xb2, 0x0f, 0xd5, 0x4e, 0x2f, 0x78,
-	0x91, 0x88, 0xf1, 0x68, 0x6e, 0xd2, 0xd9, 0xeb, 0xc1, 0xbe, 0xf8, 0x7a, 0x70, 0x2e, 0xbc, 0x1e,
-	0xdc, 0xfc, 0xf5, 0x40, 0x7a, 0xb0, 0xaa, 0xaf, 0x4a, 0xb5, 0xc5, 0x37, 0xb9, 0x70, 0xb2, 0x0f,
-	0xa9, 0x53, 0xfa, 0x90, 0xf6, 0x60, 0x55, 0xdf, 0x67, 0x6f, 0xd2, 0xe9, 0xef, 0x36, 0xac, 0x52,
-	0x9e, 0x86, 0xaf, 0x79, 0x10, 0xa7, 0x32, 0x19, 0xf7, 0xd5, 0x9d, 0xa4, 0xec, 0xbf, 0x11, 0x07,
-	0xa6, 0xdb, 0x0e, 0xd5, 0xc4, 0x75, 0x26, 0xdd, 0x7b, 0x04, 0xf5, 0xd9, 0x9d, 0xbd, 0xa8, 0x5a,
-	0x56, 0xf1, 0x1e, 0xc1, 0x62, 0x4f, 0x8c, 0x93, 0x7e, 0x3e, 0xbe, 0xa5, 0x7b, 0x52, 0x67, 0xa6,
-	0xc5, 0x34, 0x53, 0xf3, 0x9e, 0xce, 0x0c, 0x88, 0x5f, 0xc1, 0x28, 0x6f, 0x17, 0x76, 0x53, 0x62,
-	0x3a, 0x33, 0x4e, 0x9f, 0x94, 0x77, 0xd1, 0x5f, 0x44, 0xdb, 0xdb, 0xd3, 0x19, 0x1a, 0xc3, 0x92,
-	0x1e, 0xf9, 0xc5, 0x82, 0xa5, 0x72, 0x3a, 0xd7, 0x5a, 0xe2, 0x1c, 0x1d, 0x7b, 0x2e, 0x3a, 0xce,
-	0x3c, 0x74, 0xdc, 0x02, 0x9d, 0xe2, 0x7d, 0xb0, 0x50, 0x7a, 0x1f, 0x90, 0x63, 0xb8, 0x7b, 0x01,
-	0xb2, 0x4d, 0x31, 0x1c, 0xa9, 0xd9, 0xf8, 0x1f, 0xd0, 0xa9, 0xeb, 0x2d, 0x49, 0x0c, 0x68, 0x35,
-	0xaa, 0x09, 0xf2, 0x19, 0xdc, 0xe9, 0x71, 0x59, 0x02, 0x2c, 0x9b, 0xbc, 0x16, 0x38, 0x3b, 0xfc,
-	0xf4, 0x92, 0xf2, 0x95, 0x88, 0x7c, 0x09, 0xfe, 0xde, 0x68, 0xc0, 0x24, 0xbf, 0x91, 0x75, 0x07,
-	0xaa, 0xbb, 0x62, 0x24, 0x22, 0x71, 0x38, 0xb9, 0xe2, 0x06, 0xf0, 0x61, 0x51, 0xdf, 0xe5, 0xfa,
-	0x4a, 0xa9, 0xd1, 0x8c, 0x24, 0xb7, 0xd4, 0x70, 0xf7, 0x59, 0xd4, 0x1f, 0x47, 0x2a, 0x0d, 0xf5,
-	0x76, 0x4c, 0x3b, 0xcd, 0x3f, 0xce, 0xd7, 0xad, 0xbf, 0xce, 0xd7, 0xad, 0xbf, 0xcf, 0xd7, 0xad,
-	0xdf, 0xfe, 0x59, 0x7f, 0xeb, 0xa0, 0x82, 0x7f, 0x3b, 0x4f, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff,
-	0xf4, 0x25, 0x10, 0xc0, 0xfe, 0x0c, 0x00, 0x00,
-}
diff --git a/internal/public.pb.go b/internal/public.pb.go
index 514d3ad25..8c1e33061 100644
--- a/internal/public.pb.go
+++ b/internal/public.pb.go
@@ -3,13 +3,14 @@
 
 package internal
 
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-import encoding_binary "encoding/binary"
-
-import io "io"
+import (
+	encoding_binary "encoding/binary"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	io "io"
+	math "math"
+	math_bits "math/bits"
+)
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -20,12 +21,12 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
 
 type Row struct {
-	Columns              []uint64 `protobuf:"varint,1,rep,packed,name=Columns" json:"Columns,omitempty"`
-	Keys                 []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
-	Attrs                []*Attr  `protobuf:"bytes,2,rep,name=Attrs" json:"Attrs,omitempty"`
+	Columns              []uint64 `protobuf:"varint,1,rep,packed,name=Columns,proto3" json:"Columns,omitempty"`
+	Keys                 []string `protobuf:"bytes,3,rep,name=Keys,proto3" json:"Keys,omitempty"`
+	Attrs                []*Attr  `protobuf:"bytes,2,rep,name=Attrs,proto3" json:"Attrs,omitempty"`
 	Roaring              []byte   `protobuf:"bytes,4,opt,name=Roaring,proto3" json:"Roaring,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -36,7 +37,7 @@ func (m *Row) Reset()         { *m = Row{} }
 func (m *Row) String() string { return proto.CompactTextString(m) }
 func (*Row) ProtoMessage()    {}
 func (*Row) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{0}
+	return fileDescriptor_413a91106d7bcce8, []int{0}
 }
 func (m *Row) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -46,15 +47,15 @@ func (m *Row) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Row.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *Row) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Row.Merge(dst, src)
+func (m *Row) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Row.Merge(m, src)
 }
 func (m *Row) XXX_Size() int {
 	return m.Size()
@@ -94,8 +95,8 @@ func (m *Row) GetRoaring() []byte {
 }
 
 type SignedRow struct {
-	Pos                  *Row     `protobuf:"bytes,1,opt,name=Pos" json:"Pos,omitempty"`
-	Neg                  *Row     `protobuf:"bytes,2,opt,name=Neg" json:"Neg,omitempty"`
+	Pos                  *Row     `protobuf:"bytes,1,opt,name=Pos,proto3" json:"Pos,omitempty"`
+	Neg                  *Row     `protobuf:"bytes,2,opt,name=Neg,proto3" json:"Neg,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -105,7 +106,7 @@ func (m *SignedRow) Reset()         { *m = SignedRow{} }
 func (m *SignedRow) String() string { return proto.CompactTextString(m) }
 func (*SignedRow) ProtoMessage()    {}
 func (*SignedRow) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{1}
+	return fileDescriptor_413a91106d7bcce8, []int{1}
 }
 func (m *SignedRow) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -115,15 +116,15 @@ func (m *SignedRow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_SignedRow.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *SignedRow) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SignedRow.Merge(dst, src)
+func (m *SignedRow) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SignedRow.Merge(m, src)
 }
 func (m *SignedRow) XXX_Size() int {
 	return m.Size()
@@ -149,8 +150,8 @@ func (m *SignedRow) GetNeg() *Row {
 }
 
 type RowIdentifiers struct {
-	Rows                 []uint64 `protobuf:"varint,1,rep,packed,name=Rows" json:"Rows,omitempty"`
-	Keys                 []string `protobuf:"bytes,2,rep,name=Keys" json:"Keys,omitempty"`
+	Rows                 []uint64 `protobuf:"varint,1,rep,packed,name=Rows,proto3" json:"Rows,omitempty"`
+	Keys                 []string `protobuf:"bytes,2,rep,name=Keys,proto3" json:"Keys,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -160,7 +161,7 @@ func (m *RowIdentifiers) Reset()         { *m = RowIdentifiers{} }
 func (m *RowIdentifiers) String() string { return proto.CompactTextString(m) }
 func (*RowIdentifiers) ProtoMessage()    {}
 func (*RowIdentifiers) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{2}
+	return fileDescriptor_413a91106d7bcce8, []int{2}
 }
 func (m *RowIdentifiers) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -170,15 +171,15 @@ func (m *RowIdentifiers) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return xxx_messageInfo_RowIdentifiers.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *RowIdentifiers) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RowIdentifiers.Merge(dst, src)
+func (m *RowIdentifiers) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RowIdentifiers.Merge(m, src)
 }
 func (m *RowIdentifiers) XXX_Size() int {
 	return m.Size()
@@ -216,7 +217,7 @@ func (m *Pair) Reset()         { *m = Pair{} }
 func (m *Pair) String() string { return proto.CompactTextString(m) }
 func (*Pair) ProtoMessage()    {}
 func (*Pair) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{3}
+	return fileDescriptor_413a91106d7bcce8, []int{3}
 }
 func (m *Pair) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -226,15 +227,15 @@ func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Pair.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *Pair) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Pair.Merge(dst, src)
+func (m *Pair) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Pair.Merge(m, src)
 }
 func (m *Pair) XXX_Size() int {
 	return m.Size()
@@ -267,7 +268,7 @@ func (m *Pair) GetCount() uint64 {
 }
 
 type PairField struct {
-	Pair                 *Pair    `protobuf:"bytes,1,opt,name=Pair" json:"Pair,omitempty"`
+	Pair                 *Pair    `protobuf:"bytes,1,opt,name=Pair,proto3" json:"Pair,omitempty"`
 	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -278,7 +279,7 @@ func (m *PairField) Reset()         { *m = PairField{} }
 func (m *PairField) String() string { return proto.CompactTextString(m) }
 func (*PairField) ProtoMessage()    {}
 func (*PairField) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{4}
+	return fileDescriptor_413a91106d7bcce8, []int{4}
 }
 func (m *PairField) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -288,15 +289,15 @@ func (m *PairField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_PairField.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *PairField) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PairField.Merge(dst, src)
+func (m *PairField) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PairField.Merge(m, src)
 }
 func (m *PairField) XXX_Size() int {
 	return m.Size()
@@ -322,7 +323,7 @@ func (m *PairField) GetField() string {
 }
 
 type PairsField struct {
-	Pairs                []*Pair  `protobuf:"bytes,1,rep,name=Pairs" json:"Pairs,omitempty"`
+	Pairs                []*Pair  `protobuf:"bytes,1,rep,name=Pairs,proto3" json:"Pairs,omitempty"`
 	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -333,7 +334,7 @@ func (m *PairsField) Reset()         { *m = PairsField{} }
 func (m *PairsField) String() string { return proto.CompactTextString(m) }
 func (*PairsField) ProtoMessage()    {}
 func (*PairsField) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{5}
+	return fileDescriptor_413a91106d7bcce8, []int{5}
 }
 func (m *PairsField) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -343,15 +344,15 @@ func (m *PairsField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_PairsField.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *PairsField) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PairsField.Merge(dst, src)
+func (m *PairsField) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PairsField.Merge(m, src)
 }
 func (m *PairsField) XXX_Size() int {
 	return m.Size()
@@ -389,7 +390,7 @@ func (m *FieldRow) Reset()         { *m = FieldRow{} }
 func (m *FieldRow) String() string { return proto.CompactTextString(m) }
 func (*FieldRow) ProtoMessage()    {}
 func (*FieldRow) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{6}
+	return fileDescriptor_413a91106d7bcce8, []int{6}
 }
 func (m *FieldRow) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -399,15 +400,15 @@ func (m *FieldRow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_FieldRow.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *FieldRow) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FieldRow.Merge(dst, src)
+func (m *FieldRow) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldRow.Merge(m, src)
 }
 func (m *FieldRow) XXX_Size() int {
 	return m.Size()
@@ -440,7 +441,7 @@ func (m *FieldRow) GetRowKey() string {
 }
 
 type GroupCount struct {
-	Group                []*FieldRow `protobuf:"bytes,1,rep,name=Group" json:"Group,omitempty"`
+	Group                []*FieldRow `protobuf:"bytes,1,rep,name=Group,proto3" json:"Group,omitempty"`
 	Count                uint64      `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
 	Sum                  int64       `protobuf:"varint,3,opt,name=Sum,proto3" json:"Sum,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
@@ -452,7 +453,7 @@ func (m *GroupCount) Reset()         { *m = GroupCount{} }
 func (m *GroupCount) String() string { return proto.CompactTextString(m) }
 func (*GroupCount) ProtoMessage()    {}
 func (*GroupCount) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{7}
+	return fileDescriptor_413a91106d7bcce8, []int{7}
 }
 func (m *GroupCount) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -462,15 +463,15 @@ func (m *GroupCount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_GroupCount.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *GroupCount) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GroupCount.Merge(dst, src)
+func (m *GroupCount) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GroupCount.Merge(m, src)
 }
 func (m *GroupCount) XXX_Size() int {
 	return m.Size()
@@ -505,6 +506,7 @@ func (m *GroupCount) GetSum() int64 {
 type ValCount struct {
 	Val                  int64    `protobuf:"varint,1,opt,name=Val,proto3" json:"Val,omitempty"`
 	Count                int64    `protobuf:"varint,2,opt,name=Count,proto3" json:"Count,omitempty"`
+	FloatVal             float64  `protobuf:"fixed64,3,opt,name=FloatVal,proto3" json:"FloatVal,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -514,7 +516,7 @@ func (m *ValCount) Reset()         { *m = ValCount{} }
 func (m *ValCount) String() string { return proto.CompactTextString(m) }
 func (*ValCount) ProtoMessage()    {}
 func (*ValCount) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{8}
+	return fileDescriptor_413a91106d7bcce8, []int{8}
 }
 func (m *ValCount) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -524,15 +526,15 @@ func (m *ValCount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_ValCount.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ValCount) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ValCount.Merge(dst, src)
+func (m *ValCount) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ValCount.Merge(m, src)
 }
 func (m *ValCount) XXX_Size() int {
 	return m.Size()
@@ -557,10 +559,17 @@ func (m *ValCount) GetCount() int64 {
 	return 0
 }
 
+func (m *ValCount) GetFloatVal() float64 {
+	if m != nil {
+		return m.FloatVal
+	}
+	return 0
+}
+
 type ColumnAttrSet struct {
 	ID                   uint64   `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
 	Key                  string   `protobuf:"bytes,3,opt,name=Key,proto3" json:"Key,omitempty"`
-	Attrs                []*Attr  `protobuf:"bytes,2,rep,name=Attrs" json:"Attrs,omitempty"`
+	Attrs                []*Attr  `protobuf:"bytes,2,rep,name=Attrs,proto3" json:"Attrs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -570,7 +579,7 @@ func (m *ColumnAttrSet) Reset()         { *m = ColumnAttrSet{} }
 func (m *ColumnAttrSet) String() string { return proto.CompactTextString(m) }
 func (*ColumnAttrSet) ProtoMessage()    {}
 func (*ColumnAttrSet) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{9}
+	return fileDescriptor_413a91106d7bcce8, []int{9}
 }
 func (m *ColumnAttrSet) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -580,15 +589,15 @@ func (m *ColumnAttrSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_ColumnAttrSet.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ColumnAttrSet) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ColumnAttrSet.Merge(dst, src)
+func (m *ColumnAttrSet) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ColumnAttrSet.Merge(m, src)
 }
 func (m *ColumnAttrSet) XXX_Size() int {
 	return m.Size()
@@ -636,7 +645,7 @@ func (m *Attr) Reset()         { *m = Attr{} }
 func (m *Attr) String() string { return proto.CompactTextString(m) }
 func (*Attr) ProtoMessage()    {}
 func (*Attr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{10}
+	return fileDescriptor_413a91106d7bcce8, []int{10}
 }
 func (m *Attr) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -646,15 +655,15 @@ func (m *Attr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_Attr.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *Attr) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Attr.Merge(dst, src)
+func (m *Attr) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Attr.Merge(m, src)
 }
 func (m *Attr) XXX_Size() int {
 	return m.Size()
@@ -708,7 +717,7 @@ func (m *Attr) GetFloatValue() float64 {
 }
 
 type AttrMap struct {
-	Attrs                []*Attr  `protobuf:"bytes,1,rep,name=Attrs" json:"Attrs,omitempty"`
+	Attrs                []*Attr  `protobuf:"bytes,1,rep,name=Attrs,proto3" json:"Attrs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -718,7 +727,7 @@ func (m *AttrMap) Reset()         { *m = AttrMap{} }
 func (m *AttrMap) String() string { return proto.CompactTextString(m) }
 func (*AttrMap) ProtoMessage()    {}
 func (*AttrMap) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{11}
+	return fileDescriptor_413a91106d7bcce8, []int{11}
 }
 func (m *AttrMap) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -728,15 +737,15 @@ func (m *AttrMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_AttrMap.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *AttrMap) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_AttrMap.Merge(dst, src)
+func (m *AttrMap) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AttrMap.Merge(m, src)
 }
 func (m *AttrMap) XXX_Size() int {
 	return m.Size()
@@ -756,12 +765,12 @@ func (m *AttrMap) GetAttrs() []*Attr {
 
 type QueryRequest struct {
 	Query                string   `protobuf:"bytes,1,opt,name=Query,proto3" json:"Query,omitempty"`
-	Shards               []uint64 `protobuf:"varint,2,rep,packed,name=Shards" json:"Shards,omitempty"`
+	Shards               []uint64 `protobuf:"varint,2,rep,packed,name=Shards,proto3" json:"Shards,omitempty"`
 	ColumnAttrs          bool     `protobuf:"varint,3,opt,name=ColumnAttrs,proto3" json:"ColumnAttrs,omitempty"`
 	Remote               bool     `protobuf:"varint,5,opt,name=Remote,proto3" json:"Remote,omitempty"`
 	ExcludeRowAttrs      bool     `protobuf:"varint,6,opt,name=ExcludeRowAttrs,proto3" json:"ExcludeRowAttrs,omitempty"`
 	ExcludeColumns       bool     `protobuf:"varint,7,opt,name=ExcludeColumns,proto3" json:"ExcludeColumns,omitempty"`
-	EmbeddedData         []*Row   `protobuf:"bytes,8,rep,name=EmbeddedData" json:"EmbeddedData,omitempty"`
+	EmbeddedData         []*Row   `protobuf:"bytes,8,rep,name=EmbeddedData,proto3" json:"EmbeddedData,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -771,7 +780,7 @@ func (m *QueryRequest) Reset()         { *m = QueryRequest{} }
 func (m *QueryRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryRequest) ProtoMessage()    {}
 func (*QueryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{12}
+	return fileDescriptor_413a91106d7bcce8, []int{12}
 }
 func (m *QueryRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -781,15 +790,15 @@ func (m *QueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_QueryRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *QueryRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryRequest.Merge(dst, src)
+func (m *QueryRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryRequest.Merge(m, src)
 }
 func (m *QueryRequest) XXX_Size() int {
 	return m.Size()
@@ -851,8 +860,8 @@ func (m *QueryRequest) GetEmbeddedData() []*Row {
 
 type QueryResponse struct {
 	Err                  string           `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
-	Results              []*QueryResult   `protobuf:"bytes,2,rep,name=Results" json:"Results,omitempty"`
-	ColumnAttrSets       []*ColumnAttrSet `protobuf:"bytes,3,rep,name=ColumnAttrSets" json:"ColumnAttrSets,omitempty"`
+	Results              []*QueryResult   `protobuf:"bytes,2,rep,name=Results,proto3" json:"Results,omitempty"`
+	ColumnAttrSets       []*ColumnAttrSet `protobuf:"bytes,3,rep,name=ColumnAttrSets,proto3" json:"ColumnAttrSets,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
 	XXX_unrecognized     []byte           `json:"-"`
 	XXX_sizecache        int32            `json:"-"`
@@ -862,7 +871,7 @@ func (m *QueryResponse) Reset()         { *m = QueryResponse{} }
 func (m *QueryResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryResponse) ProtoMessage()    {}
 func (*QueryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{13}
+	return fileDescriptor_413a91106d7bcce8, []int{13}
 }
 func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -872,15 +881,15 @@ func (m *QueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_QueryResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *QueryResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryResponse.Merge(dst, src)
+func (m *QueryResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryResponse.Merge(m, src)
 }
 func (m *QueryResponse) XXX_Size() int {
 	return m.Size()
@@ -914,16 +923,16 @@ func (m *QueryResponse) GetColumnAttrSets() []*ColumnAttrSet {
 
 type QueryResult struct {
 	Type                 uint32          `protobuf:"varint,6,opt,name=Type,proto3" json:"Type,omitempty"`
-	Row                  *Row            `protobuf:"bytes,1,opt,name=Row" json:"Row,omitempty"`
+	Row                  *Row            `protobuf:"bytes,1,opt,name=Row,proto3" json:"Row,omitempty"`
 	N                    uint64          `protobuf:"varint,2,opt,name=N,proto3" json:"N,omitempty"`
-	Pairs                []*Pair         `protobuf:"bytes,3,rep,name=Pairs" json:"Pairs,omitempty"`
+	Pairs                []*Pair         `protobuf:"bytes,3,rep,name=Pairs,proto3" json:"Pairs,omitempty"`
 	Changed              bool            `protobuf:"varint,4,opt,name=Changed,proto3" json:"Changed,omitempty"`
-	ValCount             *ValCount       `protobuf:"bytes,5,opt,name=ValCount" json:"ValCount,omitempty"`
-	RowIDs               []uint64        `protobuf:"varint,7,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
-	GroupCounts          []*GroupCount   `protobuf:"bytes,8,rep,name=GroupCounts" json:"GroupCounts,omitempty"`
-	RowIdentifiers       *RowIdentifiers `protobuf:"bytes,9,opt,name=RowIdentifiers" json:"RowIdentifiers,omitempty"`
-	SignedRow            *SignedRow      `protobuf:"bytes,10,opt,name=SignedRow" json:"SignedRow,omitempty"`
-	PairsField           *PairsField     `protobuf:"bytes,11,opt,name=PairsField" json:"PairsField,omitempty"`
+	ValCount             *ValCount       `protobuf:"bytes,5,opt,name=ValCount,proto3" json:"ValCount,omitempty"`
+	RowIDs               []uint64        `protobuf:"varint,7,rep,packed,name=RowIDs,proto3" json:"RowIDs,omitempty"`
+	GroupCounts          []*GroupCount   `protobuf:"bytes,8,rep,name=GroupCounts,proto3" json:"GroupCounts,omitempty"`
+	RowIdentifiers       *RowIdentifiers `protobuf:"bytes,9,opt,name=RowIdentifiers,proto3" json:"RowIdentifiers,omitempty"`
+	SignedRow            *SignedRow      `protobuf:"bytes,10,opt,name=SignedRow,proto3" json:"SignedRow,omitempty"`
+	PairsField           *PairsField     `protobuf:"bytes,11,opt,name=PairsField,proto3" json:"PairsField,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
 	XXX_unrecognized     []byte          `json:"-"`
 	XXX_sizecache        int32           `json:"-"`
@@ -933,7 +942,7 @@ func (m *QueryResult) Reset()         { *m = QueryResult{} }
 func (m *QueryResult) String() string { return proto.CompactTextString(m) }
 func (*QueryResult) ProtoMessage()    {}
 func (*QueryResult) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{14}
+	return fileDescriptor_413a91106d7bcce8, []int{14}
 }
 func (m *QueryResult) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -943,15 +952,15 @@ func (m *QueryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_QueryResult.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *QueryResult) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryResult.Merge(dst, src)
+func (m *QueryResult) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryResult.Merge(m, src)
 }
 func (m *QueryResult) XXX_Size() int {
 	return m.Size()
@@ -1043,11 +1052,11 @@ type ImportRequest struct {
 	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
 	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	Shard                uint64   `protobuf:"varint,3,opt,name=Shard,proto3" json:"Shard,omitempty"`
-	RowIDs               []uint64 `protobuf:"varint,4,rep,packed,name=RowIDs" json:"RowIDs,omitempty"`
-	ColumnIDs            []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
-	RowKeys              []string `protobuf:"bytes,7,rep,name=RowKeys" json:"RowKeys,omitempty"`
-	ColumnKeys           []string `protobuf:"bytes,8,rep,name=ColumnKeys" json:"ColumnKeys,omitempty"`
-	Timestamps           []int64  `protobuf:"varint,6,rep,packed,name=Timestamps" json:"Timestamps,omitempty"`
+	RowIDs               []uint64 `protobuf:"varint,4,rep,packed,name=RowIDs,proto3" json:"RowIDs,omitempty"`
+	ColumnIDs            []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs,proto3" json:"ColumnIDs,omitempty"`
+	RowKeys              []string `protobuf:"bytes,7,rep,name=RowKeys,proto3" json:"RowKeys,omitempty"`
+	ColumnKeys           []string `protobuf:"bytes,8,rep,name=ColumnKeys,proto3" json:"ColumnKeys,omitempty"`
+	Timestamps           []int64  `protobuf:"varint,6,rep,packed,name=Timestamps,proto3" json:"Timestamps,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1057,7 +1066,7 @@ func (m *ImportRequest) Reset()         { *m = ImportRequest{} }
 func (m *ImportRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportRequest) ProtoMessage()    {}
 func (*ImportRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{15}
+	return fileDescriptor_413a91106d7bcce8, []int{15}
 }
 func (m *ImportRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1067,15 +1076,15 @@ func (m *ImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_ImportRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ImportRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportRequest.Merge(dst, src)
+func (m *ImportRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportRequest.Merge(m, src)
 }
 func (m *ImportRequest) XXX_Size() int {
 	return m.Size()
@@ -1146,11 +1155,11 @@ type ImportValueRequest struct {
 	Index                string    `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
 	Field                string    `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
 	Shard                uint64    `protobuf:"varint,3,opt,name=Shard,proto3" json:"Shard,omitempty"`
-	ColumnIDs            []uint64  `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
-	ColumnKeys           []string  `protobuf:"bytes,7,rep,name=ColumnKeys" json:"ColumnKeys,omitempty"`
-	Values               []int64   `protobuf:"varint,6,rep,packed,name=Values" json:"Values,omitempty"`
-	FloatValues          []float64 `protobuf:"fixed64,8,rep,packed,name=FloatValues" json:"FloatValues,omitempty"`
-	StringValues         []string  `protobuf:"bytes,9,rep,name=StringValues" json:"StringValues,omitempty"`
+	ColumnIDs            []uint64  `protobuf:"varint,5,rep,packed,name=ColumnIDs,proto3" json:"ColumnIDs,omitempty"`
+	ColumnKeys           []string  `protobuf:"bytes,7,rep,name=ColumnKeys,proto3" json:"ColumnKeys,omitempty"`
+	Values               []int64   `protobuf:"varint,6,rep,packed,name=Values,proto3" json:"Values,omitempty"`
+	FloatValues          []float64 `protobuf:"fixed64,8,rep,packed,name=FloatValues,proto3" json:"FloatValues,omitempty"`
+	StringValues         []string  `protobuf:"bytes,9,rep,name=StringValues,proto3" json:"StringValues,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
 	XXX_unrecognized     []byte    `json:"-"`
 	XXX_sizecache        int32     `json:"-"`
@@ -1160,7 +1169,7 @@ func (m *ImportValueRequest) Reset()         { *m = ImportValueRequest{} }
 func (m *ImportValueRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportValueRequest) ProtoMessage()    {}
 func (*ImportValueRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{16}
+	return fileDescriptor_413a91106d7bcce8, []int{16}
 }
 func (m *ImportValueRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1170,15 +1179,15 @@ func (m *ImportValueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_ImportValueRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ImportValueRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportValueRequest.Merge(dst, src)
+func (m *ImportValueRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportValueRequest.Merge(m, src)
 }
 func (m *ImportValueRequest) XXX_Size() int {
 	return m.Size()
@@ -1248,7 +1257,7 @@ func (m *ImportValueRequest) GetStringValues() []string {
 type TranslateKeysRequest struct {
 	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
 	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	Keys                 []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
+	Keys                 []string `protobuf:"bytes,3,rep,name=Keys,proto3" json:"Keys,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1258,7 +1267,7 @@ func (m *TranslateKeysRequest) Reset()         { *m = TranslateKeysRequest{} }
 func (m *TranslateKeysRequest) String() string { return proto.CompactTextString(m) }
 func (*TranslateKeysRequest) ProtoMessage()    {}
 func (*TranslateKeysRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{17}
+	return fileDescriptor_413a91106d7bcce8, []int{17}
 }
 func (m *TranslateKeysRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1268,15 +1277,15 @@ func (m *TranslateKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return xxx_messageInfo_TranslateKeysRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *TranslateKeysRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TranslateKeysRequest.Merge(dst, src)
+func (m *TranslateKeysRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TranslateKeysRequest.Merge(m, src)
 }
 func (m *TranslateKeysRequest) XXX_Size() int {
 	return m.Size()
@@ -1309,7 +1318,7 @@ func (m *TranslateKeysRequest) GetKeys() []string {
 }
 
 type TranslateKeysResponse struct {
-	IDs                  []uint64 `protobuf:"varint,3,rep,packed,name=IDs" json:"IDs,omitempty"`
+	IDs                  []uint64 `protobuf:"varint,3,rep,packed,name=IDs,proto3" json:"IDs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1319,7 +1328,7 @@ func (m *TranslateKeysResponse) Reset()         { *m = TranslateKeysResponse{} }
 func (m *TranslateKeysResponse) String() string { return proto.CompactTextString(m) }
 func (*TranslateKeysResponse) ProtoMessage()    {}
 func (*TranslateKeysResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{18}
+	return fileDescriptor_413a91106d7bcce8, []int{18}
 }
 func (m *TranslateKeysResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1329,15 +1338,15 @@ func (m *TranslateKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return xxx_messageInfo_TranslateKeysResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *TranslateKeysResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TranslateKeysResponse.Merge(dst, src)
+func (m *TranslateKeysResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TranslateKeysResponse.Merge(m, src)
 }
 func (m *TranslateKeysResponse) XXX_Size() int {
 	return m.Size()
@@ -1358,7 +1367,7 @@ func (m *TranslateKeysResponse) GetIDs() []uint64 {
 type TranslateIDsRequest struct {
 	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
 	Field                string   `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"`
-	IDs                  []uint64 `protobuf:"varint,3,rep,packed,name=IDs" json:"IDs,omitempty"`
+	IDs                  []uint64 `protobuf:"varint,3,rep,packed,name=IDs,proto3" json:"IDs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1368,7 +1377,7 @@ func (m *TranslateIDsRequest) Reset()         { *m = TranslateIDsRequest{} }
 func (m *TranslateIDsRequest) String() string { return proto.CompactTextString(m) }
 func (*TranslateIDsRequest) ProtoMessage()    {}
 func (*TranslateIDsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{19}
+	return fileDescriptor_413a91106d7bcce8, []int{19}
 }
 func (m *TranslateIDsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1378,15 +1387,15 @@ func (m *TranslateIDsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_TranslateIDsRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *TranslateIDsRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TranslateIDsRequest.Merge(dst, src)
+func (m *TranslateIDsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TranslateIDsRequest.Merge(m, src)
 }
 func (m *TranslateIDsRequest) XXX_Size() int {
 	return m.Size()
@@ -1419,7 +1428,7 @@ func (m *TranslateIDsRequest) GetIDs() []uint64 {
 }
 
 type TranslateIDsResponse struct {
-	Keys                 []string `protobuf:"bytes,3,rep,name=Keys" json:"Keys,omitempty"`
+	Keys                 []string `protobuf:"bytes,3,rep,name=Keys,proto3" json:"Keys,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1429,7 +1438,7 @@ func (m *TranslateIDsResponse) Reset()         { *m = TranslateIDsResponse{} }
 func (m *TranslateIDsResponse) String() string { return proto.CompactTextString(m) }
 func (*TranslateIDsResponse) ProtoMessage()    {}
 func (*TranslateIDsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{20}
+	return fileDescriptor_413a91106d7bcce8, []int{20}
 }
 func (m *TranslateIDsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1439,15 +1448,15 @@ func (m *TranslateIDsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return xxx_messageInfo_TranslateIDsResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *TranslateIDsResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TranslateIDsResponse.Merge(dst, src)
+func (m *TranslateIDsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TranslateIDsResponse.Merge(m, src)
 }
 func (m *TranslateIDsResponse) XXX_Size() int {
 	return m.Size()
@@ -1477,7 +1486,7 @@ func (m *ImportRoaringRequestView) Reset()         { *m = ImportRoaringRequestVi
 func (m *ImportRoaringRequestView) String() string { return proto.CompactTextString(m) }
 func (*ImportRoaringRequestView) ProtoMessage()    {}
 func (*ImportRoaringRequestView) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{21}
+	return fileDescriptor_413a91106d7bcce8, []int{21}
 }
 func (m *ImportRoaringRequestView) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1487,15 +1496,15 @@ func (m *ImportRoaringRequestView) XXX_Marshal(b []byte, deterministic bool) ([]
 		return xxx_messageInfo_ImportRoaringRequestView.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ImportRoaringRequestView) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportRoaringRequestView.Merge(dst, src)
+func (m *ImportRoaringRequestView) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportRoaringRequestView.Merge(m, src)
 }
 func (m *ImportRoaringRequestView) XXX_Size() int {
 	return m.Size()
@@ -1522,7 +1531,7 @@ func (m *ImportRoaringRequestView) GetData() []byte {
 
 type ImportRoaringRequest struct {
 	Clear                bool                        `protobuf:"varint,1,opt,name=Clear,proto3" json:"Clear,omitempty"`
-	Views                []*ImportRoaringRequestView `protobuf:"bytes,2,rep,name=views" json:"views,omitempty"`
+	Views                []*ImportRoaringRequestView `protobuf:"bytes,2,rep,name=views,proto3" json:"views,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
 	XXX_unrecognized     []byte                      `json:"-"`
 	XXX_sizecache        int32                       `json:"-"`
@@ -1532,7 +1541,7 @@ func (m *ImportRoaringRequest) Reset()         { *m = ImportRoaringRequest{} }
 func (m *ImportRoaringRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportRoaringRequest) ProtoMessage()    {}
 func (*ImportRoaringRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{22}
+	return fileDescriptor_413a91106d7bcce8, []int{22}
 }
 func (m *ImportRoaringRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1542,15 +1551,15 @@ func (m *ImportRoaringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return xxx_messageInfo_ImportRoaringRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ImportRoaringRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportRoaringRequest.Merge(dst, src)
+func (m *ImportRoaringRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportRoaringRequest.Merge(m, src)
 }
 func (m *ImportRoaringRequest) XXX_Size() int {
 	return m.Size()
@@ -1579,8 +1588,8 @@ type ImportColumnAttrsRequest struct {
 	Index                string   `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"`
 	Shard                int64    `protobuf:"varint,2,opt,name=Shard,proto3" json:"Shard,omitempty"`
 	AttrKey              string   `protobuf:"bytes,3,opt,name=AttrKey,proto3" json:"AttrKey,omitempty"`
-	AttrVals             []string `protobuf:"bytes,4,rep,name=AttrVals" json:"AttrVals,omitempty"`
-	ColumnIDs            []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs" json:"ColumnIDs,omitempty"`
+	AttrVals             []string `protobuf:"bytes,4,rep,name=AttrVals,proto3" json:"AttrVals,omitempty"`
+	ColumnIDs            []uint64 `protobuf:"varint,5,rep,packed,name=ColumnIDs,proto3" json:"ColumnIDs,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1590,7 +1599,7 @@ func (m *ImportColumnAttrsRequest) Reset()         { *m = ImportColumnAttrsReque
 func (m *ImportColumnAttrsRequest) String() string { return proto.CompactTextString(m) }
 func (*ImportColumnAttrsRequest) ProtoMessage()    {}
 func (*ImportColumnAttrsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_public_34478dbd0ceb9d33, []int{23}
+	return fileDescriptor_413a91106d7bcce8, []int{23}
 }
 func (m *ImportColumnAttrsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1600,15 +1609,15 @@ func (m *ImportColumnAttrsRequest) XXX_Marshal(b []byte, deterministic bool) ([]
 		return xxx_messageInfo_ImportColumnAttrsRequest.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalTo(b)
+		n, err := m.MarshalToSizedBuffer(b)
 		if err != nil {
 			return nil, err
 		}
 		return b[:n], nil
 	}
 }
-func (dst *ImportColumnAttrsRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ImportColumnAttrsRequest.Merge(dst, src)
+func (m *ImportColumnAttrsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ImportColumnAttrsRequest.Merge(m, src)
 }
 func (m *ImportColumnAttrsRequest) XXX_Size() int {
 	return m.Size()
@@ -1680,10 +1689,86 @@ func init() {
 	proto.RegisterType((*ImportRoaringRequest)(nil), "internal.ImportRoaringRequest")
 	proto.RegisterType((*ImportColumnAttrsRequest)(nil), "internal.ImportColumnAttrsRequest")
 }
+
+func init() { proto.RegisterFile("public.proto", fileDescriptor_413a91106d7bcce8) }
+
+var fileDescriptor_413a91106d7bcce8 = []byte{
+	// 1103 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x8e, 0x1b, 0x45,
+	0x10, 0xa6, 0x3d, 0xe3, 0xb5, 0x5d, 0xf6, 0x2e, 0x51, 0xc7, 0x09, 0x23, 0x14, 0x6d, 0xac, 0x56,
+	0x84, 0x0c, 0x87, 0x8d, 0x12, 0x10, 0xca, 0x89, 0x9f, 0x8d, 0x37, 0x60, 0x45, 0xb1, 0x42, 0x7b,
+	0x65, 0x6e, 0x48, 0xb3, 0x71, 0xc7, 0x19, 0x69, 0x3c, 0x63, 0xe6, 0x07, 0x67, 0x9f, 0x83, 0x0b,
+	0xe2, 0x09, 0x78, 0x07, 0x5e, 0x80, 0x23, 0x8f, 0x00, 0xcb, 0x1b, 0x70, 0xe5, 0x82, 0xaa, 0x7a,
+	0xda, 0xdd, 0xe3, 0xf5, 0x2e, 0x51, 0xc4, 0xad, 0xfe, 0xba, 0xba, 0xbe, 0xea, 0xea, 0xaf, 0x1b,
+	0x7a, 0xab, 0xf2, 0x2c, 0x8e, 0x5e, 0x1c, 0xad, 0xb2, 0xb4, 0x48, 0x79, 0x3b, 0x4a, 0x0a, 0x95,
+	0x25, 0x61, 0x2c, 0x72, 0xf0, 0x64, 0xba, 0xe6, 0x01, 0xb4, 0x1e, 0xa7, 0x71, 0xb9, 0x4c, 0xf2,
+	0x80, 0x0d, 0xbc, 0xa1, 0x2f, 0x8d, 0xca, 0x39, 0xf8, 0x4f, 0xd5, 0x79, 0x1e, 0x78, 0x03, 0x6f,
+	0xd8, 0x91, 0x24, 0xf3, 0x7b, 0xd0, 0xfc, 0xb2, 0x28, 0xb2, 0x3c, 0x68, 0x0c, 0xbc, 0x61, 0xf7,
+	0xe1, 0xc1, 0x91, 0x49, 0x77, 0x84, 0x66, 0xa9, 0x9d, 0x98, 0x53, 0xa6, 0x61, 0x16, 0x25, 0x8b,
+	0xc0, 0x1f, 0xb0, 0x61, 0x4f, 0x1a, 0x55, 0x3c, 0x83, 0xce, 0x34, 0x5a, 0x24, 0x6a, 0x8e, 0x5b,
+	0xdf, 0x05, 0xef, 0x79, 0x8a, 0xdb, 0xb2, 0x61, 0xf7, 0xe1, 0xbe, 0x4d, 0x25, 0xd3, 0xb5, 0x44,
+	0x0f, 0x06, 0x4c, 0xd4, 0x22, 0x68, 0xec, 0x0c, 0x98, 0xa8, 0x85, 0x78, 0x04, 0x07, 0x32, 0x5d,
+	0x8f, 0xe7, 0x2a, 0x29, 0xa2, 0x97, 0x91, 0xca, 0xa8, 0x68, 0x99, 0xae, 0x0d, 0x16, 0x92, 0x37,
+	0x40, 0x1a, 0x16, 0x88, 0xf8, 0x0c, 0xfc, 0xe7, 0x61, 0x94, 0xf1, 0x03, 0x68, 0x8c, 0x47, 0x54,
+	0x82, 0x2f, 0x1b, 0xe3, 0x11, 0xbf, 0x01, 0xde, 0x53, 0x75, 0x1e, 0x78, 0x03, 0x36, 0xec, 0x48,
+	0x14, 0x79, 0x1f, 0x9a, 0x8f, 0xd3, 0x32, 0x29, 0xa8, 0x0c, 0x5f, 0x6a, 0x45, 0x9c, 0x40, 0x07,
+	0xd7, 0x3f, 0x89, 0x54, 0x3c, 0xe7, 0x42, 0x27, 0xab, 0x90, 0x38, 0x4d, 0x41, 0xab, 0xd4, 0x1b,
+	0xf5, 0xa1, 0x49, 0xc1, 0x94, 0xa6, 0x23, 0xb5, 0x22, 0xbe, 0x06, 0x40, 0x6f, 0xae, 0xf3, 0xdc,
+	0x83, 0x26, 0x69, 0x54, 0xfd, 0xe5, 0x44, 0xda, 0x79, 0x45, 0xa6, 0x09, 0xb4, 0x49, 0xc0, 0xc6,
+	0x6e, 0x22, 0x98, 0x13, 0x81, 0x56, 0x6c, 0xd6, 0xc8, 0x00, 0x21, 0x85, 0xdf, 0x86, 0x3d, 0x99,
+	0xae, 0x2d, 0xe6, 0x4a, 0x13, 0xdf, 0x01, 0x7c, 0x95, 0xa5, 0xe5, 0x8a, 0xe0, 0xf2, 0x21, 0x34,
+	0x49, 0xab, 0x2a, 0xe3, 0xb6, 0x32, 0xb3, 0xa9, 0xd4, 0x01, 0xbb, 0xdb, 0x85, 0x6d, 0x9d, 0x96,
+	0x4b, 0xda, 0xc2, 0x93, 0x28, 0x62, 0xbd, 0xb3, 0x30, 0xde, 0x78, 0x67, 0x61, 0x4c, 0xd5, 0x7a,
+	0x12, 0xc5, 0x7a, 0x16, 0xcf, 0x64, 0x79, 0x1f, 0xda, 0x4f, 0xe2, 0x34, 0x2c, 0x30, 0x18, 0x53,
+	0x31, 0xb9, 0xd1, 0xc5, 0xb7, 0xb0, 0xaf, 0x07, 0x17, 0x47, 0x70, 0xaa, 0x8a, 0x37, 0x38, 0xd9,
+	0x37, 0x1a, 0x66, 0xf1, 0x0b, 0x03, 0x1f, 0x25, 0x93, 0x80, 0xd9, 0x04, 0x1c, 0xfc, 0xd3, 0xf3,
+	0x95, 0xaa, 0xa0, 0x92, 0xcc, 0x07, 0xd0, 0x9d, 0x16, 0x38, 0xeb, 0xb3, 0x30, 0x2e, 0x55, 0xb5,
+	0x9d, 0x6b, 0x42, 0x14, 0xe3, 0xa4, 0xd0, 0x6e, 0x9f, 0xe0, 0x6d, 0x74, 0x7e, 0x07, 0x3a, 0xc7,
+	0x69, 0x1a, 0x6b, 0x67, 0x73, 0xc0, 0x86, 0x6d, 0x69, 0x0d, 0xfc, 0x10, 0xc0, 0xe0, 0x2d, 0x55,
+	0xb0, 0x47, 0x1d, 0x70, 0x2c, 0xe2, 0x3e, 0xb4, 0xb0, 0xd2, 0x67, 0xe1, 0xca, 0x62, 0x63, 0xd7,
+	0x61, 0xfb, 0x87, 0x41, 0xef, 0x9b, 0x52, 0x65, 0xe7, 0x52, 0x7d, 0x5f, 0xaa, 0xbc, 0xc0, 0xbe,
+	0x93, 0x6e, 0x26, 0x87, 0x14, 0x9c, 0x91, 0xe9, 0xab, 0x30, 0x9b, 0xeb, 0x4e, 0xf9, 0xb2, 0xd2,
+	0x10, 0xab, 0xed, 0x79, 0x4e, 0x58, 0xdb, 0xd2, 0x35, 0xd1, 0x74, 0xa9, 0x65, 0x5a, 0x18, 0x30,
+	0x95, 0xc6, 0x87, 0xf0, 0xee, 0xc9, 0xeb, 0x17, 0x71, 0x39, 0x57, 0x32, 0x5d, 0xeb, 0xd5, 0x7b,
+	0x14, 0xb0, 0x6d, 0xe6, 0x1f, 0xc0, 0x41, 0x65, 0x32, 0x34, 0xd5, 0xa2, 0xc0, 0x2d, 0x2b, 0x7f,
+	0x00, 0xbd, 0x93, 0xe5, 0x99, 0x9a, 0xcf, 0xd5, 0x7c, 0x14, 0x16, 0x61, 0xd0, 0x26, 0xdc, 0x5b,
+	0xa4, 0x51, 0x0b, 0x11, 0x3f, 0x32, 0xd8, 0xaf, 0xd0, 0xe7, 0xab, 0x34, 0xc9, 0x15, 0x1e, 0xf1,
+	0x49, 0x96, 0x99, 0x23, 0x3e, 0xc9, 0x32, 0x7e, 0x1f, 0x5a, 0x52, 0xe5, 0x65, 0x5c, 0x98, 0x29,
+	0xb9, 0x65, 0x33, 0x9a, 0xb5, 0x65, 0x5c, 0x48, 0x13, 0xc5, 0x3f, 0x87, 0x83, 0xda, 0x1c, 0x6a,
+	0xfe, 0xec, 0x3e, 0x7c, 0xcf, 0xae, 0xab, 0xf9, 0xe5, 0x56, 0xb8, 0xf8, 0xd5, 0x83, 0xae, 0x93,
+	0x79, 0x33, 0x64, 0xd8, 0x9f, 0xfd, 0x6a, 0xc8, 0xee, 0x12, 0x77, 0x5f, 0xc1, 0x9c, 0xc8, 0x00,
+	0x3d, 0x60, 0x93, 0x6a, 0x2c, 0xd9, 0xc4, 0xf2, 0x8a, 0x77, 0x1d, 0xaf, 0xe0, 0x4b, 0xf0, 0x2a,
+	0x4c, 0x16, 0x6a, 0x4e, 0x63, 0xd9, 0x96, 0x46, 0xe5, 0x47, 0xf6, 0xae, 0xd2, 0x39, 0xd6, 0x08,
+	0xc0, 0x78, 0xa4, 0xbd, 0xcf, 0x9a, 0x53, 0xc6, 0x23, 0x3c, 0x2b, 0x9a, 0x17, 0xad, 0xf1, 0x4f,
+	0xa1, 0x6b, 0x39, 0x25, 0xaf, 0x8e, 0xa8, 0x6f, 0x53, 0x59, 0xa7, 0x74, 0x03, 0xf9, 0x17, 0xdb,
+	0x34, 0x1f, 0x74, 0xa8, 0x8a, 0xa0, 0x86, 0xdc, 0xf1, 0xcb, 0xed, 0x67, 0xe1, 0x81, 0xf3, 0xee,
+	0x04, 0x40, 0x8b, 0x6f, 0xda, 0xc5, 0x1b, 0x97, 0x74, 0x5e, 0xa7, 0x4f, 0x5c, 0x6a, 0x0e, 0xba,
+	0xb4, 0xa6, 0x5f, 0xef, 0x9c, 0xf6, 0x49, 0x27, 0x4e, 0xfc, 0xc9, 0x60, 0x7f, 0xbc, 0x5c, 0xa5,
+	0x59, 0xe1, 0x5c, 0xa9, 0x71, 0x32, 0x57, 0xaf, 0xcd, 0x95, 0x22, 0x65, 0x37, 0x89, 0xa3, 0x95,
+	0xae, 0x16, 0x5d, 0x25, 0x5f, 0x6a, 0xc5, 0x69, 0xa7, 0x5f, 0x6b, 0xe7, 0x1d, 0xe8, 0xe8, 0xd9,
+	0x41, 0x57, 0x93, 0x5c, 0xd6, 0xa0, 0x1f, 0xe1, 0x35, 0x3d, 0x7c, 0x2d, 0x7a, 0xf8, 0x8c, 0x8a,
+	0x34, 0xa2, 0xc3, 0xc8, 0xd9, 0x26, 0xa7, 0x63, 0x41, 0xff, 0x69, 0xb4, 0x54, 0x79, 0x11, 0x2e,
+	0x57, 0x78, 0x2f, 0xbd, 0xa1, 0x27, 0x1d, 0x8b, 0xf8, 0x9b, 0x01, 0xd7, 0x18, 0x89, 0x76, 0xfe,
+	0x3f, 0xa0, 0xd7, 0x03, 0xaa, 0x97, 0xdd, 0xba, 0x54, 0xf6, 0x6d, 0xd8, 0xa3, 0x7a, 0x4c, 0xc9,
+	0x95, 0x86, 0x2c, 0x65, 0x39, 0x52, 0xe3, 0x65, 0xd2, 0x35, 0x71, 0x01, 0x3d, 0x87, 0xa0, 0x71,
+	0xba, 0x30, 0x77, 0xcd, 0x26, 0x66, 0xd0, 0x3f, 0xcd, 0xc2, 0x24, 0x8f, 0xc3, 0x42, 0xe1, 0x76,
+	0x6f, 0x83, 0x7a, 0xc7, 0x8f, 0x4a, 0x7c, 0x08, 0xb7, 0xb6, 0xf2, 0x5a, 0x2e, 0xc2, 0x36, 0x78,
+	0xd4, 0x06, 0x14, 0xc5, 0x14, 0x6e, 0x6e, 0x42, 0xc7, 0xa3, 0xb7, 0xaa, 0xe0, 0x72, 0xd2, 0x8f,
+	0x1c, 0x5c, 0x94, 0xb4, 0xda, 0x7e, 0x57, 0xad, 0xc7, 0x10, 0x54, 0xb3, 0xad, 0xbf, 0x73, 0x55,
+	0x05, 0xb3, 0x48, 0xad, 0x31, 0x7e, 0x12, 0x2e, 0x55, 0x55, 0x04, 0xc9, 0x68, 0x23, 0x2e, 0x6e,
+	0xd0, 0x27, 0x90, 0x64, 0xf1, 0x12, 0xfa, 0xbb, 0x72, 0xd0, 0x8b, 0x1f, 0xab, 0x50, 0x93, 0x6f,
+	0x5b, 0x6a, 0x85, 0x3f, 0x82, 0xe6, 0x0f, 0x91, 0x5a, 0x1b, 0xf2, 0x15, 0xf6, 0xfe, 0x5d, 0x55,
+	0x88, 0xd4, 0x0b, 0xc4, 0xcf, 0xcc, 0x14, 0xeb, 0xbc, 0x47, 0xff, 0xd9, 0x32, 0x3d, 0x94, 0xd5,
+	0xa7, 0x43, 0x0f, 0x65, 0xa0, 0x1f, 0x55, 0xfb, 0x77, 0x30, 0x2a, 0x3e, 0xe4, 0x28, 0xce, 0xc2,
+	0x58, 0xdf, 0xcc, 0x8e, 0xdc, 0xe8, 0xd7, 0x8f, 0xf2, 0xf1, 0x8d, 0xdf, 0x2e, 0x0e, 0xd9, 0xef,
+	0x17, 0x87, 0xec, 0x8f, 0x8b, 0x43, 0xf6, 0xd3, 0x5f, 0x87, 0xef, 0x9c, 0xed, 0xd1, 0xf7, 0xfc,
+	0xe3, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xe1, 0xfe, 0xaf, 0x13, 0xae, 0x0b, 0x00, 0x00,
+}
+
 func (m *Row) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -1691,10 +1776,49 @@ func (m *Row) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Row) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Row) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Roaring) > 0 {
+		i -= len(m.Roaring)
+		copy(dAtA[i:], m.Roaring)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Roaring)))
+		i--
+		dAtA[i] = 0x22
+	}
+	if len(m.Keys) > 0 {
+		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Keys[iNdEx])
+			copy(dAtA[i:], m.Keys[iNdEx])
+			i = encodeVarintPublic(dAtA, i, uint64(len(m.Keys[iNdEx])))
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	if len(m.Attrs) > 0 {
+		for iNdEx := len(m.Attrs) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Attrs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
 	if len(m.Columns) > 0 {
 		dAtA2 := make([]byte, len(m.Columns)*10)
 		var j1 int
@@ -1707,54 +1831,19 @@ func (m *Row) MarshalTo(dAtA []byte) (int, error) {
 			dAtA2[j1] = uint8(num)
 			j1++
 		}
-		dAtA[i] = 0xa
-		i++
+		i -= j1
+		copy(dAtA[i:], dAtA2[:j1])
 		i = encodeVarintPublic(dAtA, i, uint64(j1))
-		i += copy(dAtA[i:], dAtA2[:j1])
+		i--
+		dAtA[i] = 0xa
 	}
-	if len(m.Attrs) > 0 {
-		for _, msg := range m.Attrs {
-			dAtA[i] = 0x12
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
-	if len(m.Keys) > 0 {
-		for _, s := range m.Keys {
-			dAtA[i] = 0x1a
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
-		}
-	}
-	if len(m.Roaring) > 0 {
-		dAtA[i] = 0x22
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Roaring)))
-		i += copy(dAtA[i:], m.Roaring)
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *SignedRow) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -1762,40 +1851,50 @@ func (m *SignedRow) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *SignedRow) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SignedRow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Pos != nil {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Pos.Size()))
-		n3, err := m.Pos.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n3
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if m.Neg != nil {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Neg.Size()))
-		n4, err := m.Neg.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
+		{
+			size, err := m.Neg.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPublic(dAtA, i, uint64(size))
 		}
-		i += n4
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Pos != nil {
+		{
+			size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPublic(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *RowIdentifiers) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -1803,10 +1902,28 @@ func (m *RowIdentifiers) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *RowIdentifiers) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *RowIdentifiers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Keys) > 0 {
+		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Keys[iNdEx])
+			copy(dAtA[i:], m.Keys[iNdEx])
+			i = encodeVarintPublic(dAtA, i, uint64(len(m.Keys[iNdEx])))
+			i--
+			dAtA[i] = 0x12
+		}
+	}
 	if len(m.Rows) > 0 {
 		dAtA6 := make([]byte, len(m.Rows)*10)
 		var j5 int
@@ -1819,36 +1936,19 @@ func (m *RowIdentifiers) MarshalTo(dAtA []byte) (int, error) {
 			dAtA6[j5] = uint8(num)
 			j5++
 		}
-		dAtA[i] = 0xa
-		i++
+		i -= j5
+		copy(dAtA[i:], dAtA6[:j5])
 		i = encodeVarintPublic(dAtA, i, uint64(j5))
-		i += copy(dAtA[i:], dAtA6[:j5])
+		i--
+		dAtA[i] = 0xa
 	}
-	if len(m.Keys) > 0 {
-		for _, s := range m.Keys {
-			dAtA[i] = 0x12
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
-		}
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *Pair) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -1856,36 +1956,43 @@ func (m *Pair) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Pair) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Pair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.ID != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.ID))
-	}
-	if m.Count != 0 {
-		dAtA[i] = 0x10
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Key) > 0 {
-		dAtA[i] = 0x1a
-		i++
+		i -= len(m.Key)
+		copy(dAtA[i:], m.Key)
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
-		i += copy(dAtA[i:], m.Key)
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Count != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
+		i--
+		dAtA[i] = 0x10
 	}
-	return i, nil
+	if m.ID != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.ID))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *PairField) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -1893,36 +2000,45 @@ func (m *PairField) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *PairField) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PairField) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Pair != nil {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Pair.Size()))
-		n7, err := m.Pair.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n7
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Pair != nil {
+		{
+			size, err := m.Pair.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPublic(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *PairsField) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -1930,38 +2046,47 @@ func (m *PairsField) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *PairsField) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PairsField) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Pairs) > 0 {
-		for _, msg := range m.Pairs {
-			dAtA[i] = 0xa
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Pairs) > 0 {
+		for iNdEx := len(m.Pairs) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Pairs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *FieldRow) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -1969,37 +2094,45 @@ func (m *FieldRow) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *FieldRow) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FieldRow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Field) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
-	}
-	if m.RowID != 0 {
-		dAtA[i] = 0x10
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.RowID))
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.RowKey) > 0 {
-		dAtA[i] = 0x1a
-		i++
+		i -= len(m.RowKey)
+		copy(dAtA[i:], m.RowKey)
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.RowKey)))
-		i += copy(dAtA[i:], m.RowKey)
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.RowID != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.RowID))
+		i--
+		dAtA[i] = 0x10
 	}
-	return i, nil
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *GroupCount) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2007,42 +2140,50 @@ func (m *GroupCount) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *GroupCount) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GroupCount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Group) > 0 {
-		for _, msg := range m.Group {
-			dAtA[i] = 0xa
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
-	if m.Count != 0 {
-		dAtA[i] = 0x10
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if m.Sum != 0 {
-		dAtA[i] = 0x18
-		i++
 		i = encodeVarintPublic(dAtA, i, uint64(m.Sum))
+		i--
+		dAtA[i] = 0x18
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Count != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
+		i--
+		dAtA[i] = 0x10
 	}
-	return i, nil
+	if len(m.Group) > 0 {
+		for iNdEx := len(m.Group) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Group[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *ValCount) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2050,30 +2191,42 @@ func (m *ValCount) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ValCount) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValCount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Val != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Val))
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.FloatVal != 0 {
+		i -= 8
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FloatVal))))
+		i--
+		dAtA[i] = 0x19
 	}
 	if m.Count != 0 {
-		dAtA[i] = 0x10
-		i++
 		i = encodeVarintPublic(dAtA, i, uint64(m.Count))
+		i--
+		dAtA[i] = 0x10
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if m.Val != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.Val))
+		i--
+		dAtA[i] = 0x8
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *ColumnAttrSet) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2081,43 +2234,52 @@ func (m *ColumnAttrSet) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ColumnAttrSet) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ColumnAttrSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.ID != 0 {
-		dAtA[i] = 0x8
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.ID))
-	}
-	if len(m.Attrs) > 0 {
-		for _, msg := range m.Attrs {
-			dAtA[i] = 0x12
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Key) > 0 {
-		dAtA[i] = 0x1a
-		i++
+		i -= len(m.Key)
+		copy(dAtA[i:], m.Key)
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
-		i += copy(dAtA[i:], m.Key)
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Attrs) > 0 {
+		for iNdEx := len(m.Attrs) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Attrs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
 	}
-	return i, nil
+	if m.ID != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.ID))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *Attr) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2125,58 +2287,66 @@ func (m *Attr) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *Attr) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Attr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Key) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
-		i += copy(dAtA[i:], m.Key)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.Type != 0 {
-		dAtA[i] = 0x10
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Type))
-	}
-	if len(m.StringValue) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.StringValue)))
-		i += copy(dAtA[i:], m.StringValue)
-	}
-	if m.IntValue != 0 {
-		dAtA[i] = 0x20
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.IntValue))
+	if m.FloatValue != 0 {
+		i -= 8
+		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FloatValue))))
+		i--
+		dAtA[i] = 0x31
 	}
 	if m.BoolValue {
-		dAtA[i] = 0x28
-		i++
+		i--
 		if m.BoolValue {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i++
+		i--
+		dAtA[i] = 0x28
 	}
-	if m.FloatValue != 0 {
-		dAtA[i] = 0x31
-		i++
-		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FloatValue))))
-		i += 8
+	if m.IntValue != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.IntValue))
+		i--
+		dAtA[i] = 0x20
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.StringValue) > 0 {
+		i -= len(m.StringValue)
+		copy(dAtA[i:], m.StringValue)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.StringValue)))
+		i--
+		dAtA[i] = 0x1a
 	}
-	return i, nil
+	if m.Type != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.Type))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Key) > 0 {
+		i -= len(m.Key)
+		copy(dAtA[i:], m.Key)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Key)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *AttrMap) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2184,32 +2354,40 @@ func (m *AttrMap) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *AttrMap) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AttrMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	if len(m.Attrs) > 0 {
-		for _, msg := range m.Attrs {
-			dAtA[i] = 0xa
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
+		for iNdEx := len(m.Attrs) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Attrs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
 			}
-			i += n
+			i--
+			dAtA[i] = 0xa
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *QueryRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2217,15 +2395,72 @@ func (m *QueryRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *QueryRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Query) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Query)))
-		i += copy(dAtA[i:], m.Query)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.EmbeddedData) > 0 {
+		for iNdEx := len(m.EmbeddedData) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.EmbeddedData[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x42
+		}
+	}
+	if m.ExcludeColumns {
+		i--
+		if m.ExcludeColumns {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x38
+	}
+	if m.ExcludeRowAttrs {
+		i--
+		if m.ExcludeRowAttrs {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x30
+	}
+	if m.Remote {
+		i--
+		if m.Remote {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x28
+	}
+	if m.ColumnAttrs {
+		i--
+		if m.ColumnAttrs {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x18
 	}
 	if len(m.Shards) > 0 {
 		dAtA9 := make([]byte, len(m.Shards)*10)
@@ -2239,73 +2474,26 @@ func (m *QueryRequest) MarshalTo(dAtA []byte) (int, error) {
 			dAtA9[j8] = uint8(num)
 			j8++
 		}
-		dAtA[i] = 0x12
-		i++
+		i -= j8
+		copy(dAtA[i:], dAtA9[:j8])
 		i = encodeVarintPublic(dAtA, i, uint64(j8))
-		i += copy(dAtA[i:], dAtA9[:j8])
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.ColumnAttrs {
-		dAtA[i] = 0x18
-		i++
-		if m.ColumnAttrs {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i++
+	if len(m.Query) > 0 {
+		i -= len(m.Query)
+		copy(dAtA[i:], m.Query)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Query)))
+		i--
+		dAtA[i] = 0xa
 	}
-	if m.Remote {
-		dAtA[i] = 0x28
-		i++
-		if m.Remote {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i++
-	}
-	if m.ExcludeRowAttrs {
-		dAtA[i] = 0x30
-		i++
-		if m.ExcludeRowAttrs {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i++
-	}
-	if m.ExcludeColumns {
-		dAtA[i] = 0x38
-		i++
-		if m.ExcludeColumns {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i++
-	}
-	if len(m.EmbeddedData) > 0 {
-		for _, msg := range m.EmbeddedData {
-			dAtA[i] = 0x42
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *QueryResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2313,50 +2501,61 @@ func (m *QueryResponse) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *QueryResponse) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Err) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Err)))
-		i += copy(dAtA[i:], m.Err)
-	}
-	if len(m.Results) > 0 {
-		for _, msg := range m.Results {
-			dAtA[i] = 0x12
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.ColumnAttrSets) > 0 {
-		for _, msg := range m.ColumnAttrSets {
-			dAtA[i] = 0x1a
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
+		for iNdEx := len(m.ColumnAttrSets) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.ColumnAttrSets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
 			}
-			i += n
+			i--
+			dAtA[i] = 0x1a
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Results) > 0 {
+		for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Results[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
 	}
-	return i, nil
+	if len(m.Err) > 0 {
+		i -= len(m.Err)
+		copy(dAtA[i:], m.Err)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Err)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *QueryResult) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2364,131 +2563,152 @@ func (m *QueryResult) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *QueryResult) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Row != nil {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Row.Size()))
-		n10, err := m.Row.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n10
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.N != 0 {
-		dAtA[i] = 0x10
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.N))
-	}
-	if len(m.Pairs) > 0 {
-		for _, msg := range m.Pairs {
-			dAtA[i] = 0x1a
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
+	if m.PairsField != nil {
+		{
+			size, err := m.PairsField.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
-			i += n
+			i -= size
+			i = encodeVarintPublic(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x5a
+	}
+	if m.SignedRow != nil {
+		{
+			size, err := m.SignedRow.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPublic(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x52
+	}
+	if m.RowIdentifiers != nil {
+		{
+			size, err := m.RowIdentifiers.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPublic(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x4a
+	}
+	if len(m.GroupCounts) > 0 {
+		for iNdEx := len(m.GroupCounts) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.GroupCounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x42
 		}
 	}
+	if len(m.RowIDs) > 0 {
+		dAtA14 := make([]byte, len(m.RowIDs)*10)
+		var j13 int
+		for _, num := range m.RowIDs {
+			for num >= 1<<7 {
+				dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
+				num >>= 7
+				j13++
+			}
+			dAtA14[j13] = uint8(num)
+			j13++
+		}
+		i -= j13
+		copy(dAtA[i:], dAtA14[:j13])
+		i = encodeVarintPublic(dAtA, i, uint64(j13))
+		i--
+		dAtA[i] = 0x3a
+	}
+	if m.Type != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.Type))
+		i--
+		dAtA[i] = 0x30
+	}
+	if m.ValCount != nil {
+		{
+			size, err := m.ValCount.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPublic(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x2a
+	}
 	if m.Changed {
-		dAtA[i] = 0x20
-		i++
+		i--
 		if m.Changed {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i++
+		i--
+		dAtA[i] = 0x20
 	}
-	if m.ValCount != nil {
-		dAtA[i] = 0x2a
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.ValCount.Size()))
-		n11, err := m.ValCount.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n11
-	}
-	if m.Type != 0 {
-		dAtA[i] = 0x30
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Type))
-	}
-	if len(m.RowIDs) > 0 {
-		dAtA13 := make([]byte, len(m.RowIDs)*10)
-		var j12 int
-		for _, num := range m.RowIDs {
-			for num >= 1<<7 {
-				dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80)
-				num >>= 7
-				j12++
+	if len(m.Pairs) > 0 {
+		for iNdEx := len(m.Pairs) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Pairs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
 			}
-			dAtA13[j12] = uint8(num)
-			j12++
+			i--
+			dAtA[i] = 0x1a
 		}
-		dAtA[i] = 0x3a
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(j12))
-		i += copy(dAtA[i:], dAtA13[:j12])
 	}
-	if len(m.GroupCounts) > 0 {
-		for _, msg := range m.GroupCounts {
-			dAtA[i] = 0x42
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
+	if m.N != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.N))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Row != nil {
+		{
+			size, err := m.Row.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
-			i += n
+			i -= size
+			i = encodeVarintPublic(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0xa
 	}
-	if m.RowIdentifiers != nil {
-		dAtA[i] = 0x4a
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.RowIdentifiers.Size()))
-		n14, err := m.RowIdentifiers.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n14
-	}
-	if m.SignedRow != nil {
-		dAtA[i] = 0x52
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.SignedRow.Size()))
-		n15, err := m.SignedRow.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n15
-	}
-	if m.PairsField != nil {
-		dAtA[i] = 0x5a
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.PairsField.Size()))
-		n16, err := m.PairsField.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += n16
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *ImportRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2496,31 +2716,42 @@ func (m *ImportRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ImportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+	if len(m.ColumnKeys) > 0 {
+		for iNdEx := len(m.ColumnKeys) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.ColumnKeys[iNdEx])
+			copy(dAtA[i:], m.ColumnKeys[iNdEx])
+			i = encodeVarintPublic(dAtA, i, uint64(len(m.ColumnKeys[iNdEx])))
+			i--
+			dAtA[i] = 0x42
+		}
 	}
-	if m.Shard != 0 {
-		dAtA[i] = 0x18
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
+	if len(m.RowKeys) > 0 {
+		for iNdEx := len(m.RowKeys) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.RowKeys[iNdEx])
+			copy(dAtA[i:], m.RowKeys[iNdEx])
+			i = encodeVarintPublic(dAtA, i, uint64(len(m.RowKeys[iNdEx])))
+			i--
+			dAtA[i] = 0x3a
+		}
 	}
-	if len(m.RowIDs) > 0 {
-		dAtA18 := make([]byte, len(m.RowIDs)*10)
+	if len(m.Timestamps) > 0 {
+		dAtA18 := make([]byte, len(m.Timestamps)*10)
 		var j17 int
-		for _, num := range m.RowIDs {
+		for _, num1 := range m.Timestamps {
+			num := uint64(num1)
 			for num >= 1<<7 {
 				dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
@@ -2529,10 +2760,11 @@ func (m *ImportRequest) MarshalTo(dAtA []byte) (int, error) {
 			dAtA18[j17] = uint8(num)
 			j17++
 		}
-		dAtA[i] = 0x22
-		i++
+		i -= j17
+		copy(dAtA[i:], dAtA18[:j17])
 		i = encodeVarintPublic(dAtA, i, uint64(j17))
-		i += copy(dAtA[i:], dAtA18[:j17])
+		i--
+		dAtA[i] = 0x32
 	}
 	if len(m.ColumnIDs) > 0 {
 		dAtA20 := make([]byte, len(m.ColumnIDs)*10)
@@ -2546,16 +2778,16 @@ func (m *ImportRequest) MarshalTo(dAtA []byte) (int, error) {
 			dAtA20[j19] = uint8(num)
 			j19++
 		}
-		dAtA[i] = 0x2a
-		i++
+		i -= j19
+		copy(dAtA[i:], dAtA20[:j19])
 		i = encodeVarintPublic(dAtA, i, uint64(j19))
-		i += copy(dAtA[i:], dAtA20[:j19])
+		i--
+		dAtA[i] = 0x2a
 	}
-	if len(m.Timestamps) > 0 {
-		dAtA22 := make([]byte, len(m.Timestamps)*10)
+	if len(m.RowIDs) > 0 {
+		dAtA22 := make([]byte, len(m.RowIDs)*10)
 		var j21 int
-		for _, num1 := range m.Timestamps {
-			num := uint64(num1)
+		for _, num := range m.RowIDs {
 			for num >= 1<<7 {
 				dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
@@ -2564,51 +2796,38 @@ func (m *ImportRequest) MarshalTo(dAtA []byte) (int, error) {
 			dAtA22[j21] = uint8(num)
 			j21++
 		}
-		dAtA[i] = 0x32
-		i++
+		i -= j21
+		copy(dAtA[i:], dAtA22[:j21])
 		i = encodeVarintPublic(dAtA, i, uint64(j21))
-		i += copy(dAtA[i:], dAtA22[:j21])
+		i--
+		dAtA[i] = 0x22
 	}
-	if len(m.RowKeys) > 0 {
-		for _, s := range m.RowKeys {
-			dAtA[i] = 0x3a
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
-		}
+	if m.Shard != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
+		i--
+		dAtA[i] = 0x18
 	}
-	if len(m.ColumnKeys) > 0 {
-		for _, s := range m.ColumnKeys {
-			dAtA[i] = 0x42
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
-		}
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *ImportValueRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2616,112 +2835,110 @@ func (m *ImportValueRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportValueRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ImportValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
-	}
-	if m.Shard != 0 {
-		dAtA[i] = 0x18
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
-	}
-	if len(m.ColumnIDs) > 0 {
-		dAtA24 := make([]byte, len(m.ColumnIDs)*10)
-		var j23 int
-		for _, num := range m.ColumnIDs {
-			for num >= 1<<7 {
-				dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80)
-				num >>= 7
-				j23++
-			}
-			dAtA24[j23] = uint8(num)
-			j23++
-		}
-		dAtA[i] = 0x2a
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(j23))
-		i += copy(dAtA[i:], dAtA24[:j23])
-	}
-	if len(m.Values) > 0 {
-		dAtA26 := make([]byte, len(m.Values)*10)
-		var j25 int
-		for _, num1 := range m.Values {
-			num := uint64(num1)
-			for num >= 1<<7 {
-				dAtA26[j25] = uint8(uint64(num)&0x7f | 0x80)
-				num >>= 7
-				j25++
-			}
-			dAtA26[j25] = uint8(num)
-			j25++
-		}
-		dAtA[i] = 0x32
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(j25))
-		i += copy(dAtA[i:], dAtA26[:j25])
-	}
-	if len(m.ColumnKeys) > 0 {
-		for _, s := range m.ColumnKeys {
-			dAtA[i] = 0x3a
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
+	if len(m.StringValues) > 0 {
+		for iNdEx := len(m.StringValues) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.StringValues[iNdEx])
+			copy(dAtA[i:], m.StringValues[iNdEx])
+			i = encodeVarintPublic(dAtA, i, uint64(len(m.StringValues[iNdEx])))
+			i--
+			dAtA[i] = 0x4a
 		}
 	}
 	if len(m.FloatValues) > 0 {
-		dAtA[i] = 0x42
-		i++
+		for iNdEx := len(m.FloatValues) - 1; iNdEx >= 0; iNdEx-- {
+			f23 := math.Float64bits(float64(m.FloatValues[iNdEx]))
+			i -= 8
+			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f23))
+		}
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.FloatValues)*8))
-		for _, num := range m.FloatValues {
-			f27 := math.Float64bits(float64(num))
-			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f27))
-			i += 8
+		i--
+		dAtA[i] = 0x42
+	}
+	if len(m.ColumnKeys) > 0 {
+		for iNdEx := len(m.ColumnKeys) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.ColumnKeys[iNdEx])
+			copy(dAtA[i:], m.ColumnKeys[iNdEx])
+			i = encodeVarintPublic(dAtA, i, uint64(len(m.ColumnKeys[iNdEx])))
+			i--
+			dAtA[i] = 0x3a
 		}
 	}
-	if len(m.StringValues) > 0 {
-		for _, s := range m.StringValues {
-			dAtA[i] = 0x4a
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
+	if len(m.Values) > 0 {
+		dAtA25 := make([]byte, len(m.Values)*10)
+		var j24 int
+		for _, num1 := range m.Values {
+			num := uint64(num1)
+			for num >= 1<<7 {
+				dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80)
+				num >>= 7
+				j24++
 			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
+			dAtA25[j24] = uint8(num)
+			j24++
 		}
+		i -= j24
+		copy(dAtA[i:], dAtA25[:j24])
+		i = encodeVarintPublic(dAtA, i, uint64(j24))
+		i--
+		dAtA[i] = 0x32
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.ColumnIDs) > 0 {
+		dAtA27 := make([]byte, len(m.ColumnIDs)*10)
+		var j26 int
+		for _, num := range m.ColumnIDs {
+			for num >= 1<<7 {
+				dAtA27[j26] = uint8(uint64(num)&0x7f | 0x80)
+				num >>= 7
+				j26++
+			}
+			dAtA27[j26] = uint8(num)
+			j26++
+		}
+		i -= j26
+		copy(dAtA[i:], dAtA27[:j26])
+		i = encodeVarintPublic(dAtA, i, uint64(j26))
+		i--
+		dAtA[i] = 0x2a
 	}
-	return i, nil
+	if m.Shard != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
+		i--
+		dAtA[i] = 0x18
+	}
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *TranslateKeysRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2729,47 +2946,49 @@ func (m *TranslateKeysRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *TranslateKeysRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TranslateKeysRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
-	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Keys) > 0 {
-		for _, s := range m.Keys {
+		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Keys[iNdEx])
+			copy(dAtA[i:], m.Keys[iNdEx])
+			i = encodeVarintPublic(dAtA, i, uint64(len(m.Keys[iNdEx])))
+			i--
 			dAtA[i] = 0x1a
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *TranslateKeysResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2777,10 +2996,19 @@ func (m *TranslateKeysResponse) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *TranslateKeysResponse) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TranslateKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	if len(m.IDs) > 0 {
 		dAtA29 := make([]byte, len(m.IDs)*10)
 		var j28 int
@@ -2793,21 +3021,19 @@ func (m *TranslateKeysResponse) MarshalTo(dAtA []byte) (int, error) {
 			dAtA29[j28] = uint8(num)
 			j28++
 		}
-		dAtA[i] = 0x1a
-		i++
+		i -= j28
+		copy(dAtA[i:], dAtA29[:j28])
 		i = encodeVarintPublic(dAtA, i, uint64(j28))
-		i += copy(dAtA[i:], dAtA29[:j28])
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *TranslateIDsRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2815,21 +3041,18 @@ func (m *TranslateIDsRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *TranslateIDsRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TranslateIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
-	if len(m.Field) > 0 {
-		dAtA[i] = 0x12
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
-		i += copy(dAtA[i:], m.Field)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.IDs) > 0 {
 		dAtA31 := make([]byte, len(m.IDs)*10)
@@ -2843,21 +3066,33 @@ func (m *TranslateIDsRequest) MarshalTo(dAtA []byte) (int, error) {
 			dAtA31[j30] = uint8(num)
 			j30++
 		}
-		dAtA[i] = 0x1a
-		i++
+		i -= j30
+		copy(dAtA[i:], dAtA31[:j30])
 		i = encodeVarintPublic(dAtA, i, uint64(j30))
-		i += copy(dAtA[i:], dAtA31[:j30])
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Field) > 0 {
+		i -= len(m.Field)
+		copy(dAtA[i:], m.Field)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Field)))
+		i--
+		dAtA[i] = 0x12
 	}
-	return i, nil
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *TranslateIDsResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2865,35 +3100,35 @@ func (m *TranslateIDsResponse) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *TranslateIDsResponse) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TranslateIDsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	if len(m.Keys) > 0 {
-		for _, s := range m.Keys {
+		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Keys[iNdEx])
+			copy(dAtA[i:], m.Keys[iNdEx])
+			i = encodeVarintPublic(dAtA, i, uint64(len(m.Keys[iNdEx])))
+			i--
 			dAtA[i] = 0x1a
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *ImportRoaringRequestView) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2901,32 +3136,40 @@ func (m *ImportRoaringRequestView) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportRoaringRequestView) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ImportRoaringRequestView) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Name) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Name)))
-		i += copy(dAtA[i:], m.Name)
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.Data) > 0 {
-		dAtA[i] = 0x12
-		i++
+		i -= len(m.Data)
+		copy(dAtA[i:], m.Data)
 		i = encodeVarintPublic(dAtA, i, uint64(len(m.Data)))
-		i += copy(dAtA[i:], m.Data)
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
 	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *ImportRoaringRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2934,42 +3177,50 @@ func (m *ImportRoaringRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportRoaringRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ImportRoaringRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Views) > 0 {
+		for iNdEx := len(m.Views) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Views[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPublic(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x12
+		}
+	}
 	if m.Clear {
-		dAtA[i] = 0x8
-		i++
+		i--
 		if m.Clear {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i++
+		i--
+		dAtA[i] = 0x8
 	}
-	if len(m.Views) > 0 {
-		for _, msg := range m.Views {
-			dAtA[i] = 0x12
-			i++
-			i = encodeVarintPublic(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
-	}
-	return i, nil
+	return len(dAtA) - i, nil
 }
 
 func (m *ImportColumnAttrsRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalTo(dAtA)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 	if err != nil {
 		return nil, err
 	}
@@ -2977,41 +3228,18 @@ func (m *ImportColumnAttrsRequest) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ImportColumnAttrsRequest) MarshalTo(dAtA []byte) (int, error) {
-	var i int
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ImportColumnAttrsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.Index) > 0 {
-		dAtA[i] = 0xa
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
-		i += copy(dAtA[i:], m.Index)
-	}
-	if m.Shard != 0 {
-		dAtA[i] = 0x10
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
-	}
-	if len(m.AttrKey) > 0 {
-		dAtA[i] = 0x1a
-		i++
-		i = encodeVarintPublic(dAtA, i, uint64(len(m.AttrKey)))
-		i += copy(dAtA[i:], m.AttrKey)
-	}
-	if len(m.AttrVals) > 0 {
-		for _, s := range m.AttrVals {
-			dAtA[i] = 0x22
-			i++
-			l = len(s)
-			for l >= 1<<7 {
-				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
-				l >>= 7
-				i++
-			}
-			dAtA[i] = uint8(l)
-			i++
-			i += copy(dAtA[i:], s)
-		}
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	if len(m.ColumnIDs) > 0 {
 		dAtA33 := make([]byte, len(m.ColumnIDs)*10)
@@ -3025,25 +3253,53 @@ func (m *ImportColumnAttrsRequest) MarshalTo(dAtA []byte) (int, error) {
 			dAtA33[j32] = uint8(num)
 			j32++
 		}
-		dAtA[i] = 0x2a
-		i++
+		i -= j32
+		copy(dAtA[i:], dAtA33[:j32])
 		i = encodeVarintPublic(dAtA, i, uint64(j32))
-		i += copy(dAtA[i:], dAtA33[:j32])
+		i--
+		dAtA[i] = 0x2a
 	}
-	if m.XXX_unrecognized != nil {
-		i += copy(dAtA[i:], m.XXX_unrecognized)
+	if len(m.AttrVals) > 0 {
+		for iNdEx := len(m.AttrVals) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.AttrVals[iNdEx])
+			copy(dAtA[i:], m.AttrVals[iNdEx])
+			i = encodeVarintPublic(dAtA, i, uint64(len(m.AttrVals[iNdEx])))
+			i--
+			dAtA[i] = 0x22
+		}
 	}
-	return i, nil
+	if len(m.AttrKey) > 0 {
+		i -= len(m.AttrKey)
+		copy(dAtA[i:], m.AttrKey)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.AttrKey)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.Shard != 0 {
+		i = encodeVarintPublic(dAtA, i, uint64(m.Shard))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Index) > 0 {
+		i -= len(m.Index)
+		copy(dAtA[i:], m.Index)
+		i = encodeVarintPublic(dAtA, i, uint64(len(m.Index)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func encodeVarintPublic(dAtA []byte, offset int, v uint64) int {
+	offset -= sovPublic(v)
+	base := offset
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
 		v >>= 7
 		offset++
 	}
 	dAtA[offset] = uint8(v)
-	return offset + 1
+	return base
 }
 func (m *Row) Size() (n int) {
 	if m == nil {
@@ -3248,6 +3504,9 @@ func (m *ValCount) Size() (n int) {
 	if m.Count != 0 {
 		n += 1 + sovPublic(uint64(m.Count))
 	}
+	if m.FloatVal != 0 {
+		n += 9
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -3734,14 +3993,7 @@ func (m *ImportColumnAttrsRequest) Size() (n int) {
 }
 
 func sovPublic(x uint64) (n int) {
-	for {
-		n++
-		x >>= 7
-		if x == 0 {
-			break
-		}
-	}
-	return n
+	return (math_bits.Len64(x|1) + 6) / 7
 }
 func sozPublic(x uint64) (n int) {
 	return sovPublic(uint64((x << 1) ^ uint64((int64(x) >> 63))))
@@ -3761,7 +4013,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -3787,7 +4039,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -3804,7 +4056,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -3813,12 +4065,15 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -3838,7 +4093,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -3862,7 +4117,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -3871,6 +4126,9 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -3893,7 +4151,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -3903,6 +4161,9 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -3922,7 +4183,7 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -3931,6 +4192,9 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -3948,6 +4212,9 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -3976,7 +4243,7 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4004,7 +4271,7 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4013,6 +4280,9 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4037,7 +4307,7 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4046,6 +4316,9 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4065,6 +4338,9 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4093,7 +4369,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4119,7 +4395,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -4136,7 +4412,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -4145,12 +4421,15 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -4170,7 +4449,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -4194,7 +4473,7 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4204,6 +4483,9 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4218,6 +4500,9 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4246,7 +4531,7 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4274,7 +4559,7 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.ID |= (uint64(b) & 0x7F) << shift
+				m.ID |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4293,7 +4578,7 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Count |= (uint64(b) & 0x7F) << shift
+				m.Count |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4312,7 +4597,7 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4322,6 +4607,9 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4336,6 +4624,9 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4364,7 +4655,7 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4392,7 +4683,7 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4401,6 +4692,9 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4425,7 +4719,7 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4435,6 +4729,9 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4449,6 +4746,9 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4477,7 +4777,7 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4505,7 +4805,7 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4514,6 +4814,9 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4536,7 +4839,7 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4546,6 +4849,9 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4560,6 +4866,9 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4588,7 +4897,7 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4616,7 +4925,7 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4626,6 +4935,9 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4645,7 +4957,7 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.RowID |= (uint64(b) & 0x7F) << shift
+				m.RowID |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4664,7 +4976,7 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4674,6 +4986,9 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4688,6 +5003,9 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4716,7 +5034,7 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4744,7 +5062,7 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4753,6 +5071,9 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4775,7 +5096,7 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Count |= (uint64(b) & 0x7F) << shift
+				m.Count |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4794,7 +5115,7 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Sum |= (int64(b) & 0x7F) << shift
+				m.Sum |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4808,6 +5129,9 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4836,7 +5160,7 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4864,7 +5188,7 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Val |= (int64(b) & 0x7F) << shift
+				m.Val |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4883,11 +5207,22 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Count |= (int64(b) & 0x7F) << shift
+				m.Count |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+		case 3:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FloatVal", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.FloatVal = float64(math.Float64frombits(v))
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPublic(dAtA[iNdEx:])
@@ -4897,6 +5232,9 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -4925,7 +5263,7 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -4953,7 +5291,7 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.ID |= (uint64(b) & 0x7F) << shift
+				m.ID |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4972,7 +5310,7 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4981,6 +5319,9 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5003,7 +5344,7 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5013,6 +5354,9 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5027,6 +5371,9 @@ func (m *ColumnAttrSet) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5055,7 +5402,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5083,7 +5430,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5093,6 +5440,9 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5112,7 +5462,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Type |= (uint64(b) & 0x7F) << shift
+				m.Type |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5131,7 +5481,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5141,6 +5491,9 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5160,7 +5513,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.IntValue |= (int64(b) & 0x7F) << shift
+				m.IntValue |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5179,7 +5532,7 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5205,6 +5558,9 @@ func (m *Attr) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5233,7 +5589,7 @@ func (m *AttrMap) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5261,7 +5617,7 @@ func (m *AttrMap) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5270,6 +5626,9 @@ func (m *AttrMap) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5287,6 +5646,9 @@ func (m *AttrMap) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5315,7 +5677,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5343,7 +5705,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5353,6 +5715,9 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5370,7 +5735,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5387,7 +5752,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5396,12 +5761,15 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -5421,7 +5789,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5445,7 +5813,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5465,7 +5833,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5485,7 +5853,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5505,7 +5873,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5525,7 +5893,7 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5534,6 +5902,9 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5551,6 +5922,9 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5579,7 +5953,7 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5607,7 +5981,7 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5617,6 +5991,9 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5636,7 +6013,7 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5645,6 +6022,9 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5667,7 +6047,7 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5676,6 +6056,9 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5693,6 +6076,9 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5721,7 +6107,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -5749,7 +6135,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5758,6 +6144,9 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5782,7 +6171,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.N |= (uint64(b) & 0x7F) << shift
+				m.N |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5801,7 +6190,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5810,6 +6199,9 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5832,7 +6224,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5852,7 +6244,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5861,6 +6253,9 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -5885,7 +6280,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Type |= (uint32(b) & 0x7F) << shift
+				m.Type |= uint32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5902,7 +6297,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5919,7 +6314,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -5928,12 +6323,15 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -5953,7 +6351,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -5977,7 +6375,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -5986,6 +6384,9 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6008,7 +6409,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6017,6 +6418,9 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6041,7 +6445,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6050,6 +6454,9 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6074,7 +6481,7 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6083,6 +6490,9 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6102,6 +6512,9 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6130,7 +6543,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6158,7 +6571,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6168,6 +6581,9 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6187,7 +6603,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6197,6 +6613,9 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6216,7 +6635,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= (uint64(b) & 0x7F) << shift
+				m.Shard |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6233,7 +6652,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6250,7 +6669,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6259,12 +6678,15 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -6284,7 +6706,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -6306,7 +6728,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6323,7 +6745,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6332,12 +6754,15 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -6357,7 +6782,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -6379,7 +6804,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (int64(b) & 0x7F) << shift
+					v |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6396,7 +6821,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6405,12 +6830,15 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -6430,7 +6858,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (int64(b) & 0x7F) << shift
+						v |= int64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -6454,7 +6882,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6464,6 +6892,9 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6483,7 +6914,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6493,6 +6924,9 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6507,6 +6941,9 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6535,7 +6972,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6563,7 +7000,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6573,6 +7010,9 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6592,7 +7032,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6602,6 +7042,9 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6621,7 +7064,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= (uint64(b) & 0x7F) << shift
+				m.Shard |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6638,7 +7081,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6655,7 +7098,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6664,12 +7107,15 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -6689,7 +7135,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -6711,7 +7157,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (int64(b) & 0x7F) << shift
+					v |= int64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6728,7 +7174,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6737,12 +7183,15 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -6762,7 +7211,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (int64(b) & 0x7F) << shift
+						v |= int64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -6786,7 +7235,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6796,6 +7245,9 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6822,7 +7274,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -6831,6 +7283,9 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
@@ -6866,7 +7321,7 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6876,6 +7331,9 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6890,6 +7348,9 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6918,7 +7379,7 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -6946,7 +7407,7 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6956,6 +7417,9 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -6975,7 +7439,7 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -6985,6 +7449,9 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7004,7 +7471,7 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7014,6 +7481,9 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7028,6 +7498,9 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7056,7 +7529,7 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7082,7 +7555,7 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7099,7 +7572,7 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7108,12 +7581,15 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -7133,7 +7609,7 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -7152,6 +7628,9 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7180,7 +7659,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7208,7 +7687,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7218,6 +7697,9 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7237,7 +7719,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7247,6 +7729,9 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7264,7 +7749,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7281,7 +7766,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7290,12 +7775,15 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -7315,7 +7803,7 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -7334,6 +7822,9 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7362,7 +7853,7 @@ func (m *TranslateIDsResponse) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7390,7 +7881,7 @@ func (m *TranslateIDsResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7400,6 +7891,9 @@ func (m *TranslateIDsResponse) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7414,6 +7908,9 @@ func (m *TranslateIDsResponse) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7442,7 +7939,7 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7470,7 +7967,7 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7480,6 +7977,9 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7499,7 +7999,7 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= (int(b) & 0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7508,6 +8008,9 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7525,6 +8028,9 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7553,7 +8059,7 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7581,7 +8087,7 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= (int(b) & 0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7601,7 +8107,7 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= (int(b) & 0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7610,6 +8116,9 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7627,6 +8136,9 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7655,7 +8167,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 			}
 			b := dAtA[iNdEx]
 			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
+			wire |= uint64(b&0x7F) << shift
 			if b < 0x80 {
 				break
 			}
@@ -7683,7 +8195,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7693,6 +8205,9 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7712,7 +8227,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Shard |= (int64(b) & 0x7F) << shift
+				m.Shard |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7731,7 +8246,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7741,6 +8256,9 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7760,7 +8278,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= (uint64(b) & 0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7770,6 +8288,9 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 				return ErrInvalidLengthPublic
 			}
 			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7787,7 +8308,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					v |= (uint64(b) & 0x7F) << shift
+					v |= uint64(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7804,7 +8325,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 					}
 					b := dAtA[iNdEx]
 					iNdEx++
-					packedLen |= (int(b) & 0x7F) << shift
+					packedLen |= int(b&0x7F) << shift
 					if b < 0x80 {
 						break
 					}
@@ -7813,12 +8334,15 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 					return ErrInvalidLengthPublic
 				}
 				postIndex := iNdEx + packedLen
+				if postIndex < 0 {
+					return ErrInvalidLengthPublic
+				}
 				if postIndex > l {
 					return io.ErrUnexpectedEOF
 				}
 				var elementCount int
 				var count int
-				for _, integer := range dAtA {
+				for _, integer := range dAtA[iNdEx:postIndex] {
 					if integer < 128 {
 						count++
 					}
@@ -7838,7 +8362,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 						}
 						b := dAtA[iNdEx]
 						iNdEx++
-						v |= (uint64(b) & 0x7F) << shift
+						v |= uint64(b&0x7F) << shift
 						if b < 0x80 {
 							break
 						}
@@ -7857,6 +8381,9 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 			if skippy < 0 {
 				return ErrInvalidLengthPublic
 			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPublic
+			}
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
@@ -7873,6 +8400,7 @@ func (m *ImportColumnAttrsRequest) Unmarshal(dAtA []byte) error {
 func skipPublic(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
+	depth := 0
 	for iNdEx < l {
 		var wire uint64
 		for shift := uint(0); ; shift += 7 {
@@ -7904,10 +8432,8 @@ func skipPublic(dAtA []byte) (n int, err error) {
 					break
 				}
 			}
-			return iNdEx, nil
 		case 1:
 			iNdEx += 8
-			return iNdEx, nil
 		case 2:
 			var length int
 			for shift := uint(0); ; shift += 7 {
@@ -7924,128 +8450,34 @@ func skipPublic(dAtA []byte) (n int, err error) {
 					break
 				}
 			}
-			iNdEx += length
 			if length < 0 {
 				return 0, ErrInvalidLengthPublic
 			}
-			return iNdEx, nil
+			iNdEx += length
 		case 3:
-			for {
-				var innerWire uint64
-				var start int = iNdEx
-				for shift := uint(0); ; shift += 7 {
-					if shift >= 64 {
-						return 0, ErrIntOverflowPublic
-					}
-					if iNdEx >= l {
-						return 0, io.ErrUnexpectedEOF
-					}
-					b := dAtA[iNdEx]
-					iNdEx++
-					innerWire |= (uint64(b) & 0x7F) << shift
-					if b < 0x80 {
-						break
-					}
-				}
-				innerWireType := int(innerWire & 0x7)
-				if innerWireType == 4 {
-					break
-				}
-				next, err := skipPublic(dAtA[start:])
-				if err != nil {
-					return 0, err
-				}
-				iNdEx = start + next
-			}
-			return iNdEx, nil
+			depth++
 		case 4:
-			return iNdEx, nil
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupPublic
+			}
+			depth--
 		case 5:
 			iNdEx += 4
-			return iNdEx, nil
 		default:
 			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthPublic
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
 	}
-	panic("unreachable")
+	return 0, io.ErrUnexpectedEOF
 }
 
 var (
-	ErrInvalidLengthPublic = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowPublic   = fmt.Errorf("proto: integer overflow")
+	ErrInvalidLengthPublic        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowPublic          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupPublic = fmt.Errorf("proto: unexpected end of group")
 )
-
-func init() { proto.RegisterFile("public.proto", fileDescriptor_public_34478dbd0ceb9d33) }
-
-var fileDescriptor_public_34478dbd0ceb9d33 = []byte{
-	// 1097 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x8e, 0x1b, 0x45,
-	0x10, 0xa6, 0x3d, 0xf6, 0xda, 0x2e, 0x7b, 0x97, 0xa8, 0xe3, 0x84, 0x11, 0x8a, 0x16, 0xab, 0x15,
-	0xa1, 0x81, 0xc3, 0x46, 0x59, 0x10, 0xca, 0x89, 0x9f, 0x8d, 0x37, 0x60, 0x45, 0xb1, 0x42, 0x79,
-	0x65, 0x6e, 0x48, 0xb3, 0x71, 0x67, 0x33, 0xd2, 0x78, 0xc6, 0xcc, 0x0f, 0xce, 0x3e, 0x07, 0x17,
-	0xc4, 0x13, 0xf0, 0x0e, 0xbc, 0x00, 0x47, 0x1e, 0x01, 0x96, 0x37, 0xe0, 0xca, 0x05, 0x55, 0xf5,
-	0xb4, 0x7b, 0xec, 0xfd, 0x01, 0x45, 0xdc, 0xfa, 0xab, 0xaa, 0xae, 0xae, 0xaa, 0xae, 0xfa, 0xba,
-	0xa1, 0xbf, 0x2c, 0x4f, 0xe3, 0xe8, 0xc5, 0xc1, 0x32, 0x4b, 0x8b, 0x54, 0x76, 0xa2, 0xa4, 0xd0,
-	0x59, 0x12, 0xc6, 0x2a, 0x07, 0x0f, 0xd3, 0x95, 0xf4, 0xa1, 0xfd, 0x38, 0x8d, 0xcb, 0x45, 0x92,
-	0xfb, 0x62, 0xe8, 0x05, 0x4d, 0xb4, 0x50, 0xde, 0x87, 0xd6, 0x17, 0x45, 0x91, 0xe5, 0x7e, 0x63,
-	0xe8, 0x05, 0xbd, 0xc3, 0xbd, 0x03, 0xbb, 0xf5, 0x80, 0xc4, 0x68, 0x94, 0x52, 0x42, 0xf3, 0xa9,
-	0x3e, 0xcf, 0x7d, 0x6f, 0xe8, 0x05, 0x5d, 0xe4, 0x35, 0xf9, 0xc4, 0x34, 0xcc, 0xa2, 0xe4, 0xcc,
-	0x6f, 0x0e, 0x45, 0xd0, 0x47, 0x0b, 0xd5, 0x33, 0xe8, 0x4e, 0xa3, 0xb3, 0x44, 0xcf, 0xe9, 0xe8,
-	0xf7, 0xc0, 0x7b, 0x9e, 0xd2, 0xb1, 0x22, 0xe8, 0x1d, 0xee, 0x3a, 0xf7, 0x98, 0xae, 0x90, 0x34,
-	0x64, 0x30, 0xd1, 0x67, 0x7e, 0xe3, 0x4a, 0x83, 0x89, 0x3e, 0x53, 0x8f, 0x60, 0x0f, 0xd3, 0xd5,
-	0x78, 0xae, 0x93, 0x22, 0x7a, 0x19, 0x69, 0x13, 0x0e, 0xa6, 0x2b, 0x9b, 0x0b, 0xaf, 0xd7, 0x21,
-	0x36, 0x5c, 0x88, 0xea, 0x53, 0x68, 0x3e, 0x0f, 0xa3, 0x4c, 0xee, 0x41, 0x63, 0x3c, 0xe2, 0x10,
-	0x9a, 0xd8, 0x18, 0x8f, 0xe4, 0x00, 0x5a, 0x8f, 0xd3, 0x32, 0x29, 0xf8, 0xd0, 0x26, 0x1a, 0x20,
-	0x6f, 0x81, 0xf7, 0x54, 0x9f, 0xfb, 0xde, 0x50, 0x04, 0x5d, 0xa4, 0xa5, 0x3a, 0x86, 0x2e, 0xed,
-	0x7f, 0x12, 0xe9, 0x78, 0x2e, 0x95, 0x71, 0x56, 0x65, 0x52, 0x2b, 0x14, 0x49, 0xd1, 0x1c, 0x34,
-	0x80, 0x16, 0x1b, 0xb3, 0xe3, 0x2e, 0x1a, 0xa0, 0xbe, 0x02, 0x20, 0x6d, 0x6e, 0xfc, 0xdc, 0x87,
-	0x16, 0x23, 0x8e, 0xfe, 0xb2, 0x23, 0xa3, 0xbc, 0xc6, 0xd3, 0x04, 0x3a, 0xbc, 0xa0, 0xc2, 0xae,
-	0x2d, 0x44, 0xcd, 0x82, 0xa4, 0x54, 0xac, 0x91, 0x4d, 0x8d, 0x81, 0xbc, 0x0b, 0x3b, 0x98, 0xae,
-	0x5c, 0x76, 0x15, 0x52, 0xdf, 0x02, 0x7c, 0x99, 0xa5, 0xe5, 0xd2, 0x14, 0x20, 0x80, 0x16, 0xa3,
-	0x2a, 0x32, 0xe9, 0x22, 0xb3, 0x87, 0xa2, 0x31, 0xb8, 0xbe, 0x80, 0xd3, 0x72, 0xc1, 0x47, 0x78,
-	0x48, 0x4b, 0x75, 0x08, 0x9d, 0x59, 0x18, 0xaf, 0xb5, 0xb3, 0x30, 0xe6, 0x68, 0x3d, 0xa4, 0xe5,
-	0xa6, 0x17, 0xaf, 0xf2, 0xa2, 0xbe, 0x81, 0x5d, 0xd3, 0x9c, 0xd4, 0x7a, 0x53, 0x5d, 0x5c, 0xba,
-	0xbd, 0xff, 0xd6, 0xb2, 0x97, 0x6f, 0xf3, 0x67, 0x01, 0x4d, 0xd2, 0x59, 0x95, 0x58, 0xab, 0xa8,
-	0x79, 0x4e, 0xce, 0x97, 0xba, 0x4a, 0x87, 0xd7, 0x72, 0x08, 0xbd, 0x69, 0x41, 0xfd, 0x3c, 0x0b,
-	0xe3, 0x52, 0x57, 0x8e, 0xea, 0x22, 0xf9, 0x2e, 0x74, 0xc6, 0x49, 0x61, 0xd4, 0x4d, 0x4e, 0x61,
-	0x8d, 0xe5, 0x3d, 0xe8, 0x1e, 0xa5, 0x69, 0x6c, 0x94, 0xad, 0xa1, 0x08, 0x3a, 0xe8, 0x04, 0x72,
-	0x1f, 0xe0, 0x49, 0x9c, 0x86, 0xd5, 0xde, 0x9d, 0xa1, 0x08, 0x04, 0xd6, 0x24, 0xea, 0x01, 0xb4,
-	0x29, 0xd2, 0x67, 0xe1, 0xd2, 0x65, 0x2b, 0x6e, 0xc8, 0x56, 0xfd, 0x2d, 0xa0, 0xff, 0x75, 0xa9,
-	0xb3, 0x73, 0xd4, 0xdf, 0x95, 0x3a, 0x2f, 0xa8, 0xb6, 0x8c, 0x6d, 0x77, 0x30, 0xa0, 0x3e, 0x98,
-	0xbe, 0x0a, 0xb3, 0xb9, 0xa9, 0x5d, 0x13, 0x2b, 0x44, 0xb9, 0xba, 0x9a, 0xe7, 0x9c, 0x6b, 0x07,
-	0xeb, 0x22, 0xee, 0x20, 0xbd, 0x48, 0x0b, 0x9b, 0x4c, 0x85, 0x64, 0x00, 0x6f, 0x1f, 0xbf, 0x7e,
-	0x11, 0x97, 0x73, 0x8d, 0xe9, 0xca, 0xec, 0xde, 0x61, 0x83, 0x6d, 0xb1, 0x7c, 0x1f, 0xf6, 0x2a,
-	0x91, 0xa5, 0xa2, 0x36, 0x1b, 0x6e, 0x49, 0xe5, 0x43, 0xe8, 0x1f, 0x2f, 0x4e, 0xf5, 0x7c, 0xae,
-	0xe7, 0xa3, 0xb0, 0x08, 0xfd, 0x0e, 0xe7, 0xbd, 0x45, 0x0c, 0x1b, 0x26, 0xea, 0x07, 0x01, 0xbb,
-	0x55, 0xf6, 0xf9, 0x32, 0x4d, 0x72, 0x4d, 0x57, 0x7c, 0x9c, 0x65, 0xf6, 0x8a, 0x8f, 0xb3, 0x4c,
-	0x3e, 0x80, 0x36, 0xea, 0xbc, 0x8c, 0x0b, 0xdb, 0x37, 0x77, 0x9c, 0x47, 0xbb, 0xb7, 0x8c, 0x0b,
-	0xb4, 0x56, 0xf2, 0x33, 0xd8, 0xdb, 0xe8, 0x43, 0xc3, 0x7e, 0xbd, 0xc3, 0x77, 0xdc, 0xbe, 0x0d,
-	0x3d, 0x6e, 0x99, 0xab, 0x5f, 0x3c, 0xe8, 0xd5, 0x3c, 0x13, 0xd1, 0x61, 0xba, 0xba, 0x86, 0x09,
-	0x69, 0xa2, 0xfb, 0x20, 0x26, 0x55, 0x0b, 0x8a, 0x89, 0xe3, 0x09, 0xef, 0x26, 0x9e, 0x20, 0x66,
-	0x7f, 0x15, 0x26, 0x67, 0x7a, 0xce, 0x2d, 0xd8, 0x41, 0x0b, 0xe5, 0x81, 0x9b, 0x3d, 0xbe, 0xb3,
-	0x8d, 0x81, 0xb6, 0x1a, 0x74, 0xf3, 0x69, 0x67, 0x80, 0xae, 0x6f, 0xb7, 0x9a, 0x01, 0xc3, 0x1b,
-	0xe3, 0x11, 0xdd, 0x15, 0xf7, 0x8b, 0x41, 0xf2, 0x13, 0xe8, 0x39, 0xde, 0xc8, 0xab, 0x2b, 0x1a,
-	0x38, 0xf7, 0x4e, 0x89, 0x75, 0x43, 0xf9, 0xf9, 0x36, 0x95, 0xfb, 0x5d, 0x8e, 0xcc, 0xdf, 0xa8,
-	0x46, 0x4d, 0x8f, 0xdb, 0xd4, 0xff, 0xb0, 0xf6, 0xb6, 0xf8, 0xc0, 0x9b, 0x6f, 0xbb, 0xcd, 0x6b,
-	0x15, 0xd6, 0x5e, 0xa0, 0x8f, 0xeb, 0xf4, 0xeb, 0xf7, 0x78, 0xcf, 0x60, 0xb3, 0x9a, 0x46, 0x87,
-	0x35, 0x3b, 0xf5, 0x87, 0x80, 0xdd, 0xf1, 0x62, 0x99, 0x66, 0x45, 0x6d, 0xa4, 0xc6, 0xc9, 0x5c,
-	0xbf, 0xb6, 0x23, 0xc5, 0xe0, 0x6a, 0xa2, 0x26, 0x29, 0x8f, 0x16, 0x8f, 0x52, 0x13, 0x0d, 0xa8,
-	0x95, 0xb3, 0xb9, 0x51, 0xce, 0x7b, 0xd0, 0x35, 0xbd, 0x43, 0xaa, 0x16, 0xab, 0x9c, 0x80, 0xc8,
-	0xe2, 0x24, 0x5a, 0xe8, 0xbc, 0x08, 0x17, 0x4b, 0x9a, 0x2e, 0x2f, 0xf0, 0xb0, 0x26, 0x31, 0x0f,
-	0xf1, 0x8a, 0x1f, 0xbf, 0x36, 0x3f, 0x7e, 0x16, 0xd2, 0x4e, 0xe3, 0x86, 0x95, 0x1d, 0x56, 0xd6,
-	0x24, 0xea, 0x2f, 0x01, 0xd2, 0xe4, 0xc8, 0xb4, 0xf3, 0xff, 0x25, 0x7a, 0x73, 0x42, 0x77, 0x61,
-	0x87, 0xcf, 0xb3, 0xc9, 0x54, 0x68, 0x2b, 0xdc, 0xf6, 0x76, 0xb8, 0xc4, 0x52, 0x8e, 0x23, 0x4d,
-	0x3e, 0x02, 0xeb, 0x22, 0xa9, 0xa0, 0x5f, 0x23, 0x68, 0xea, 0x2e, 0xf2, 0xb1, 0x21, 0x53, 0x33,
-	0x18, 0x9c, 0x64, 0x61, 0x92, 0xc7, 0x61, 0xa1, 0xc9, 0xed, 0x9b, 0x64, 0x7d, 0xc5, 0x7f, 0x48,
-	0x7d, 0x00, 0x77, 0xb6, 0xfc, 0x3a, 0x2e, 0xa2, 0x32, 0x78, 0x5c, 0x06, 0x5a, 0xaa, 0x29, 0xdc,
-	0x5e, 0x9b, 0x8e, 0x47, 0x6f, 0x14, 0xc1, 0x65, 0xa7, 0x1f, 0xd6, 0xf2, 0x62, 0xa7, 0xd5, 0xf1,
-	0x57, 0xc5, 0x7a, 0x04, 0x7e, 0xd5, 0xdb, 0xe6, 0xcb, 0x56, 0x45, 0x30, 0x8b, 0xf4, 0x8a, 0xec,
-	0x27, 0xe1, 0x42, 0x57, 0x41, 0xf0, 0x9a, 0x64, 0xcc, 0xc5, 0x0d, 0xfe, 0xe8, 0xf1, 0x5a, 0xbd,
-	0x84, 0xc1, 0x55, 0x3e, 0xf8, 0x55, 0x8f, 0x75, 0x68, 0xc8, 0xb7, 0x83, 0x06, 0xc8, 0x47, 0xd0,
-	0xfa, 0x3e, 0xd2, 0x2b, 0x4b, 0xbe, 0xca, 0xcd, 0xdf, 0x75, 0x81, 0xa0, 0xd9, 0xa0, 0x7e, 0x12,
-	0x36, 0xd8, 0xda, 0x7b, 0xf4, 0xaf, 0x25, 0x33, 0x4d, 0x59, 0x7d, 0x2c, 0x4c, 0x53, 0xfa, 0xe6,
-	0x51, 0x75, 0xbf, 0x02, 0x0b, 0xe9, 0x21, 0xa7, 0xe5, 0x2c, 0x8c, 0xcd, 0x64, 0x76, 0x71, 0x8d,
-	0x6f, 0x6e, 0xe5, 0xa3, 0x5b, 0xbf, 0x5e, 0xec, 0x8b, 0xdf, 0x2e, 0xf6, 0xc5, 0xef, 0x17, 0xfb,
-	0xe2, 0xc7, 0x3f, 0xf7, 0xdf, 0x3a, 0xdd, 0xe1, 0x2f, 0xf8, 0x47, 0xff, 0x04, 0x00, 0x00, 0xff,
-	0xff, 0x7f, 0x3f, 0x32, 0x93, 0x92, 0x0b, 0x00, 0x00,
-}
diff --git a/internal/public.proto b/internal/public.proto
index 7ba89bd75..c87cd3357 100644
--- a/internal/public.proto
+++ b/internal/public.proto
@@ -50,6 +50,7 @@ message GroupCount{
 message ValCount {
 	int64 Val = 1;
 	int64 Count = 2;
+	double FloatVal = 3;
 }
 
 message ColumnAttrSet {
diff --git a/server/grpc.go b/server/grpc.go
index 8358a9db1..def1bb768 100644
--- a/server/grpc.go
+++ b/server/grpc.go
@@ -777,16 +777,32 @@ func makeRows(resp pilosa.QueryResponse, logger logger.Logger) chan *pb.RowRespo
 						&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_BoolVal{BoolVal: r}},
 					}}
 			case pilosa.ValCount:
-				ci := []*pb.ColumnInfo{
-					{Name: "value", Datatype: "int64"},
-					{Name: "count", Datatype: "int64"},
+				var ci []*pb.ColumnInfo
+				// ValCount can have a float or integeger value, but
+				// not both (as of this writing).
+				if r.FloatVal != 0 {
+					ci = []*pb.ColumnInfo{
+						{Name: "value", Datatype: "float64"},
+						{Name: "count", Datatype: "int64"},
+					}
+					results <- &pb.RowResponse{
+						Headers: ci,
+						Columns: []*pb.ColumnResponse{
+							&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Float64Val{Float64Val: r.FloatVal}},
+							&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: r.Count}},
+						}}
+				} else {
+					ci = []*pb.ColumnInfo{
+						{Name: "value", Datatype: "int64"},
+						{Name: "count", Datatype: "int64"},
+					}
+					results <- &pb.RowResponse{
+						Headers: ci,
+						Columns: []*pb.ColumnResponse{
+							&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: r.Val}},
+							&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: r.Count}},
+						}}
 				}
-				results <- &pb.RowResponse{
-					Headers: ci,
-					Columns: []*pb.ColumnResponse{
-						&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: r.Val}},
-						&pb.ColumnResponse{ColumnVal: &pb.ColumnResponse_Int64Val{Int64Val: r.Count}},
-					}}
 			case pilosa.SignedRow:
 				// TODO: address the overflow issue with values outside the int64 range
 				ci := []*pb.ColumnInfo{{Name: r.Field(), Datatype: "int64"}}
diff --git a/server/grpc_internal_test.go b/server/grpc_internal_test.go
index c0701be3e..722a6a694 100644
--- a/server/grpc_internal_test.go
+++ b/server/grpc_internal_test.go
@@ -35,6 +35,16 @@ func TestGRPC(t *testing.T) {
 			expHeaders []expHeader
 			expColumns [][]expColumn
 		}{
+			{
+				pilosa.ValCount{Val: 1, Count: 1},
+				[]expHeader{{"value", "int64"}, {"count", "int64"}},
+				[][]expColumn{{int64(1), int64(1)}},
+			},
+			{
+				pilosa.ValCount{FloatVal: 1.24, Count: 1},
+				[]expHeader{{"value", "float64"}, {"count", "int64"}},
+				[][]expColumn{{float64(1.24), int64(1)}},
+			},
 			// Row (uint64)
 			{
 				pilosa.NewRow(10, 11, 12),
@@ -266,6 +276,11 @@ func TestGRPC(t *testing.T) {
 						if val != v {
 							t.Fatalf("test %d expected column val: %v but got: %v", ti, v, val)
 						}
+					case float64:
+						val := column.GetFloat64Val()
+						if val != v {
+							t.Fatalf("test %d expected column val: %v but got: %v", ti, v, val)
+						}
 					default:
 						t.Fatalf("test %d has unhandled data type: %T", ti, v)
 					}
diff --git a/server/server_test.go b/server/server_test.go
index b3c82a142..5225e7a05 100644
--- a/server/server_test.go
+++ b/server/server_test.go
@@ -298,6 +298,41 @@ func TestMain_GroupBy(t *testing.T) {
 	}
 }
 
+func TestMain_MinMaxFloat(t *testing.T) {
+	m := test.MustRunCommand()
+	defer m.Close()
+
+	// Create fields.
+	client := m.Client()
+	if err := client.CreateIndex(context.Background(), "i", pilosa.IndexOptions{}); err != nil && err != pilosa.ErrIndexExists {
+		t.Fatal(err)
+	}
+	if err := client.CreateFieldWithOptions(context.Background(), "i", "dec", pilosa.FieldOptions{Type: pilosa.FieldTypeDecimal, Scale: 3, Max: 100000}); err != nil {
+		t.Fatal(err)
+	}
+
+	query := `
+		Set(0, dec=1.32)
+		Set(1, dec=4.44)
+	`
+
+	// Set columns on row.
+	if _, err := m.Query("i", "", query); err != nil {
+		t.Fatal(err)
+	}
+
+	// Query row.
+	exp0 := pilosa.ValCount{FloatVal: 4.44, Count: 1}
+	exp1 := pilosa.ValCount{FloatVal: 1.32, Count: 1}
+	if res, err := m.QueryProtobuf("i", `Max(field=dec) Min(field=dec)`); err != nil {
+		t.Fatal(err)
+	} else if res.Results[0] != exp0 ||
+		res.Results[1] != exp1 {
+		t.Fatalf("unexpected results: %+v", res.Results)
+
+	}
+}
+
 // Ensure the host can be parsed.
 func TestConfig_Parse_Host(t *testing.T) {
 	if c, err := ParseConfig(`bind = "local"`); err != nil {
@@ -984,3 +1019,45 @@ func TestClusterExhaustingConnectionsImport(t *testing.T) {
 		t.Fatalf("setting lots of shards: %v", err)
 	}
 }
+
+func TestClusterMinMaxSumDecimal(t *testing.T) {
+	cluster := test.MustRunCluster(t, 3)
+	defer cluster.Close()
+	cmd := cluster[0]
+
+	cmd.MustCreateIndex(t, "testdec", pilosa.IndexOptions{Keys: true, TrackExistence: true})
+	cmd.MustCreateField(t, "testdec", "adec", pilosa.OptFieldTypeDecimal(2))
+
+	test.MustDo("POST", cluster[0].URL()+"/index/testdec/query", `
+Set("a", adec=42.2)
+Set("b", adec=11.12)
+Set("c", adec=13.41)
+Set("d", adec=99.87)
+Set("e", adec=11.13)
+Set("f", adec=12.12)
+Set("g", adec=15.52)
+Set("h", adec=100.22)
+`)
+
+	result := test.MustDo("POST", cluster[0].URL()+"/index/testdec/query", "Sum(field=adec)")
+	if !strings.Contains(result.Body, `"floatValue":305.59`) {
+		t.Fatalf("expected float sum of 305.59, but got: '%s'", result.Body)
+	} else if !strings.Contains(result.Body, `"count":8`) {
+		t.Fatalf("expected count 8, but got: '%s'", result.Body)
+	}
+
+	result = test.MustDo("POST", cluster[0].URL()+"/index/testdec/query", "Max(field=adec)")
+	if !strings.Contains(result.Body, `"floatValue":100.22`) {
+		t.Fatalf("expected float max of 100.22, but got: '%s'", result.Body)
+	} else if !strings.Contains(result.Body, `"count":1`) {
+		t.Fatalf("expected count 1, but got: '%s'", result.Body)
+	}
+
+	result = test.MustDo("POST", cluster[0].URL()+"/index/testdec/query", "Min(field=adec)")
+	if !strings.Contains(result.Body, `"floatValue":11.12`) {
+		t.Fatalf("expected float min of 11.12, but got: '%s'", result.Body)
+	} else if !strings.Contains(result.Body, `"count":1`) {
+		t.Fatalf("expected count 1, but got: '%s'", result.Body)
+	}
+
+}