Repository: milvus-io/milvus-sdk-go
Pull request #146 (2021-07-16 07:05:00)

Fix examples and tests error due to API change
Fix broke example and tests
Update milvus.proto and related generated pb go file

Solves: #144 #145 

Signed-off-by: Congqi Xia <congqi.xia@zilliz.com>

sre-ci-robot: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/milvus-io/milvus-sdk-go/pull/146#" title="Author self-approved">congqixia</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=milvus-io%2Fmilvus-sdk-go).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/milvus-io/milvus-sdk-go/blob/master/OWNERS)~~ [congqixia]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->
sunby: /lgtm
/approve
sre-ci-robot: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/milvus-io/milvus-sdk-go/pull/146#" title="Author self-approved">congqixia</a>*, *<a href="https://github.com/milvus-io/milvus-sdk-go/pull/146#issuecomment-881227296" title="Approved">sunby</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=milvus-io%2Fmilvus-sdk-go).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[OWNERS](https://github.com/milvus-io/milvus-sdk-go/blob/master/OWNERS)~~ [congqixia,sunby]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->

Patch:
diff --git a/examples/insert/insert.go b/examples/insert/insert.go
index 6930a42..0472f9b 100644
--- a/examples/insert/insert.go
+++ b/examples/insert/insert.go
@@ -120,8 +120,10 @@ func main() {
 
 	searchFilm := films[0] // use first fim to search
 	vector := entity.FloatVector(searchFilm.Vector[:])
+	// Use flat search param
+	sp, _ := entity.NewIndexFlatSearchParam(10)
 	sr, err := c.Search(ctx, collectionName, []string{}, "Year > 1990", []string{"ID"}, []entity.Vector{vector}, "Vector",
-		entity.L2, 10, map[string]string{"nprobe": "10"})
+		entity.L2, 10, sp)
 	if err != nil {
 		log.Fatal("fail to search collection:", err.Error())
 	}
diff --git a/internal/proto/milvus.proto b/internal/proto/milvus.proto
index 7beea2f..392c77d 100644
--- a/internal/proto/milvus.proto
+++ b/internal/proto/milvus.proto
@@ -35,6 +35,7 @@ service MilvusService {
   rpc Retrieve(RetrieveRequest) returns (RetrieveResults) {}
   rpc Flush(FlushRequest) returns (FlushResponse) {}
   rpc Query(QueryRequest) returns (QueryResults) {}
+  rpc CalcDistance(CalcDistanceRequest) returns (CalcDistanceResults) {}
 
   rpc GetPersistentSegmentInfo(GetPersistentSegmentInfoRequest) returns (GetPersistentSegmentInfoResponse) {}
   rpc GetQuerySegmentInfo(GetQuerySegmentInfoRequest) returns (GetQuerySegmentInfoResponse) {}
@@ -389,6 +390,36 @@ message QueryResults {
   repeated schema.FieldData fields_data = 2;
 }
 
+message VectorIDs {
+  string collection_name = 1;
+  string field_name = 2;
+  schema.IDs id_array = 3;
+  repeated string partition_names = 4;
+}
+
+message VectorsArray {
+  oneof array {
+    VectorIDs id_array = 1; // vector ids
+    schema.VectorField data_array = 2; // vectors data
+  } 
+}
+
+message CalcDistanceRequest {
+  common.MsgBase base = 1;
+  VectorsArray op_left = 2; // vectors on the left of operator
+  VectorsArray op_right = 3; // vectors on the right of operator
+  repeated common.KeyValuePair params = 4; // "metric":"L2"/"IP"/"HAMMIN"/"TANIMOTO"
+}
+
+message CalcDistanceResults {
+  common.Status status = 1;
+  // num(op_left)*num(op_right) distance values, "HAMMIN" return integer distance
+  oneof array {
+    	schema.IntArray int_dist = 2;
+	schema.FloatArray float_dist = 3;
+  }
+}
+
 message PersistentSegmentInfo {
   int64 segmentID = 1;
   int64 collectionID = 2;
diff --git a/internal/proto/server/milvus.pb.go b/internal/proto/server/milvus.pb.go
index af0bd2b..f6bf592 100644
--- a/internal/proto/server/milvus.pb.go
+++ b/internal/proto/server/milvus.pb.go
@@ -3058,6 +3058,302 @@ func (m *QueryResults) GetFieldsData() []*schema.FieldData {
 	return nil
 }
 
+type VectorIDs struct {
+	CollectionName       string      `protobuf:"bytes,1,opt,name=collection_name,json=collectionName,proto3" json:"collection_name,omitempty"`
+	FieldName            string      `protobuf:"bytes,2,opt,name=field_name,json=fieldName,proto3" json:"field_name,omitempty"`
+	IdArray              *schema.IDs `protobuf:"bytes,3,opt,name=id_array,json=idArray,proto3" json:"id_array,omitempty"`
+	PartitionNames       []string    `protobuf:"bytes,4,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *VectorIDs) Reset()         { *m = VectorIDs{} }
+func (m *VectorIDs) String() string { return proto.CompactTextString(m) }
+func (*VectorIDs) ProtoMessage()    {}
+func (*VectorIDs) Descriptor() ([]byte, []int) {
+	return fileDescriptor_02345ba45cc0e303, []int{48}
+}
+
+func (m *VectorIDs) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VectorIDs.Unmarshal(m, b)
+}
+func (m *VectorIDs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VectorIDs.Marshal(b, m, deterministic)
+}
+func (m *VectorIDs) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VectorIDs.Merge(m, src)
+}
+func (m *VectorIDs) XXX_Size() int {
+	return xxx_messageInfo_VectorIDs.Size(m)
+}
+func (m *VectorIDs) XXX_DiscardUnknown() {
+	xxx_messageInfo_VectorIDs.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VectorIDs proto.InternalMessageInfo
+
+func (m *VectorIDs) GetCollectionName() string {
+	if m != nil {
+		return m.CollectionName
+	}
+	return ""
+}
+
+func (m *VectorIDs) GetFieldName() string {
+	if m != nil {
+		return m.FieldName
+	}
+	return ""
+}
+
+func (m *VectorIDs) GetIdArray() *schema.IDs {
+	if m != nil {
+		return m.IdArray
+	}
+	return nil
+}
+
+func (m *VectorIDs) GetPartitionNames() []string {
+	if m != nil {
+		return m.PartitionNames
+	}
+	return nil
+}
+
+type VectorsArray struct {
+	// Types that are valid to be assigned to Array:
+	//	*VectorsArray_IdArray
+	//	*VectorsArray_DataArray
+	Array                isVectorsArray_Array `protobuf_oneof:"array"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *VectorsArray) Reset()         { *m = VectorsArray{} }
+func (m *VectorsArray) String() string { return proto.CompactTextString(m) }
+func (*VectorsArray) ProtoMessage()    {}
+func (*VectorsArray) Descriptor() ([]byte, []int) {
+	return fileDescriptor_02345ba45cc0e303, []int{49}
+}
+
+func (m *VectorsArray) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VectorsArray.Unmarshal(m, b)
+}
+func (m *VectorsArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VectorsArray.Marshal(b, m, deterministic)
+}
+func (m *VectorsArray) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VectorsArray.Merge(m, src)
+}
+func (m *VectorsArray) XXX_Size() int {
+	return xxx_messageInfo_VectorsArray.Size(m)
+}
+func (m *VectorsArray) XXX_DiscardUnknown() {
+	xxx_messageInfo_VectorsArray.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VectorsArray proto.InternalMessageInfo
+
+type isVectorsArray_Array interface {
+	isVectorsArray_Array()
+}
+
+type VectorsArray_IdArray struct {
+	IdArray *VectorIDs `protobuf:"bytes,1,opt,name=id_array,json=idArray,proto3,oneof"`
+}
+
+type VectorsArray_DataArray struct {
+	DataArray *schema.VectorField `protobuf:"bytes,2,opt,name=data_array,json=dataArray,proto3,oneof"`
+}
+
+func (*VectorsArray_IdArray) isVectorsArray_Array() {}
+
+func (*VectorsArray_DataArray) isVectorsArray_Array() {}
+
+func (m *VectorsArray) GetArray() isVectorsArray_Array {
+	if m != nil {
+		return m.Array
+	}
+	return nil
+}
+
+func (m *VectorsArray) GetIdArray() *VectorIDs {
+	if x, ok := m.GetArray().(*VectorsArray_IdArray); ok {
+		return x.IdArray
+	}
+	return nil
+}
+
+func (m *VectorsArray) GetDataArray() *schema.VectorField {
+	if x, ok := m.GetArray().(*VectorsArray_DataArray); ok {
+		return x.DataArray
+	}
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*VectorsArray) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*VectorsArray_IdArray)(nil),
+		(*VectorsArray_DataArray)(nil),
+	}
+}
+
+type CalcDistanceRequest struct {
+	Base                 *common.MsgBase        `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	OpLeft               *VectorsArray          `protobuf:"bytes,2,opt,name=op_left,json=opLeft,proto3" json:"op_left,omitempty"`
+	OpRight              *VectorsArray          `protobuf:"bytes,3,opt,name=op_right,json=opRight,proto3" json:"op_right,omitempty"`
+	Params               []*common.KeyValuePair `protobuf:"bytes,4,rep,name=params,proto3" json:"params,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
+	XXX_unrecognized     []byte                 `json:"-"`
+	XXX_sizecache        int32                  `json:"-"`
+}
+
+func (m *CalcDistanceRequest) Reset()         { *m = CalcDistanceRequest{} }
+func (m *CalcDistanceRequest) String() string { return proto.CompactTextString(m) }
+func (*CalcDistanceRequest) ProtoMessage()    {}
+func (*CalcDistanceRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_02345ba45cc0e303, []int{50}
+}
+
+func (m *CalcDistanceRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_CalcDistanceRequest.Unmarshal(m, b)
+}
+func (m *CalcDistanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CalcDistanceRequest.Marshal(b, m, deterministic)
+}
+func (m *CalcDistanceRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CalcDistanceRequest.Merge(m, src)
+}
+func (m *CalcDistanceRequest) XXX_Size() int {
+	return xxx_messageInfo_CalcDistanceRequest.Size(m)
+}
+func (m *CalcDistanceRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_CalcDistanceRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CalcDistanceRequest proto.InternalMessageInfo
+
+func (m *CalcDistanceRequest) GetBase() *common.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *CalcDistanceRequest) GetOpLeft() *VectorsArray {
+	if m != nil {
+		return m.OpLeft
+	}
+	return nil
+}
+
+func (m *CalcDistanceRequest) GetOpRight() *VectorsArray {
+	if m != nil {
+		return m.OpRight
+	}
+	return nil
+}
+
+func (m *CalcDistanceRequest) GetParams() []*common.KeyValuePair {
+	if m != nil {
+		return m.Params
+	}
+	return nil
+}
+
+type CalcDistanceResults struct {
+	Status *common.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	// num(op_left)*num(op_right) distance values, "HAMMIN" return integer distance
+	//
+	// Types that are valid to be assigned to Array:
+	//	*CalcDistanceResults_IntDist
+	//	*CalcDistanceResults_FloatDist
+	Array                isCalcDistanceResults_Array `protobuf_oneof:"array"`
+	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
+	XXX_unrecognized     []byte                      `json:"-"`
+	XXX_sizecache        int32                       `json:"-"`
+}
+
+func (m *CalcDistanceResults) Reset()         { *m = CalcDistanceResults{} }
+func (m *CalcDistanceResults) String() string { return proto.CompactTextString(m) }
+func (*CalcDistanceResults) ProtoMessage()    {}
+func (*CalcDistanceResults) Descriptor() ([]byte, []int) {
+	return fileDescriptor_02345ba45cc0e303, []int{51}
+}
+
+func (m *CalcDistanceResults) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_CalcDistanceResults.Unmarshal(m, b)
+}
+func (m *CalcDistanceResults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CalcDistanceResults.Marshal(b, m, deterministic)
+}
+func (m *CalcDistanceResults) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CalcDistanceResults.Merge(m, src)
+}
+func (m *CalcDistanceResults) XXX_Size() int {
+	return xxx_messageInfo_CalcDistanceResults.Size(m)
+}
+func (m *CalcDistanceResults) XXX_DiscardUnknown() {
+	xxx_messageInfo_CalcDistanceResults.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CalcDistanceResults proto.InternalMessageInfo
+
+func (m *CalcDistanceResults) GetStatus() *common.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
+type isCalcDistanceResults_Array interface {
+	isCalcDistanceResults_Array()
+}
+
+type CalcDistanceResults_IntDist struct {
+	IntDist *schema.IntArray `protobuf:"bytes,2,opt,name=int_dist,json=intDist,proto3,oneof"`
+}
+
+type CalcDistanceResults_FloatDist struct {
+	FloatDist *schema.FloatArray `protobuf:"bytes,3,opt,name=float_dist,json=floatDist,proto3,oneof"`
+}
+
+func (*CalcDistanceResults_IntDist) isCalcDistanceResults_Array() {}
+
+func (*CalcDistanceResults_FloatDist) isCalcDistanceResults_Array() {}
+
+func (m *CalcDistanceResults) GetArray() isCalcDistanceResults_Array {
+	if m != nil {
+		return m.Array
+	}
+	return nil
+}
+
+func (m *CalcDistanceResults) GetIntDist() *schema.IntArray {
+	if x, ok := m.GetArray().(*CalcDistanceResults_IntDist); ok {
+		return x.IntDist
+	}
+	return nil
+}
+
+func (m *CalcDistanceResults) GetFloatDist() *schema.FloatArray {
+	if x, ok := m.GetArray().(*CalcDistanceResults_FloatDist); ok {
+		return x.FloatDist
+	}
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*CalcDistanceResults) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*CalcDistanceResults_IntDist)(nil),
+		(*CalcDistanceResults_FloatDist)(nil),
+	}
+}
+
 type PersistentSegmentInfo struct {
 	SegmentID            int64               `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
 	CollectionID         int64               `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
@@ -3073,7 +3369,7 @@ func (m *PersistentSegmentInfo) Reset()         { *m = PersistentSegmentInfo{} }
 func (m *PersistentSegmentInfo) String() string { return proto.CompactTextString(m) }
 func (*PersistentSegmentInfo) ProtoMessage()    {}
 func (*PersistentSegmentInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{48}
+	return fileDescriptor_02345ba45cc0e303, []int{52}
 }
 
 func (m *PersistentSegmentInfo) XXX_Unmarshal(b []byte) error {
@@ -3142,7 +3438,7 @@ func (m *GetPersistentSegmentInfoRequest) Reset()         { *m = GetPersistentSe
 func (m *GetPersistentSegmentInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*GetPersistentSegmentInfoRequest) ProtoMessage()    {}
 func (*GetPersistentSegmentInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{49}
+	return fileDescriptor_02345ba45cc0e303, []int{53}
 }
 
 func (m *GetPersistentSegmentInfoRequest) XXX_Unmarshal(b []byte) error {
@@ -3196,7 +3492,7 @@ func (m *GetPersistentSegmentInfoResponse) Reset()         { *m = GetPersistentS
 func (m *GetPersistentSegmentInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*GetPersistentSegmentInfoResponse) ProtoMessage()    {}
 func (*GetPersistentSegmentInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{50}
+	return fileDescriptor_02345ba45cc0e303, []int{54}
 }
 
 func (m *GetPersistentSegmentInfoResponse) XXX_Unmarshal(b []byte) error {
@@ -3248,7 +3544,7 @@ func (m *QuerySegmentInfo) Reset()         { *m = QuerySegmentInfo{} }
 func (m *QuerySegmentInfo) String() string { return proto.CompactTextString(m) }
 func (*QuerySegmentInfo) ProtoMessage()    {}
 func (*QuerySegmentInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{51}
+	return fileDescriptor_02345ba45cc0e303, []int{55}
 }
 
 func (m *QuerySegmentInfo) XXX_Unmarshal(b []byte) error {
@@ -3331,7 +3627,7 @@ func (m *GetQuerySegmentInfoRequest) Reset()         { *m = GetQuerySegmentInfoR
 func (m *GetQuerySegmentInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*GetQuerySegmentInfoRequest) ProtoMessage()    {}
 func (*GetQuerySegmentInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{52}
+	return fileDescriptor_02345ba45cc0e303, []int{56}
 }
 
 func (m *GetQuerySegmentInfoRequest) XXX_Unmarshal(b []byte) error {
@@ -3385,7 +3681,7 @@ func (m *GetQuerySegmentInfoResponse) Reset()         { *m = GetQuerySegmentInfo
 func (m *GetQuerySegmentInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*GetQuerySegmentInfoResponse) ProtoMessage()    {}
 func (*GetQuerySegmentInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{53}
+	return fileDescriptor_02345ba45cc0e303, []int{57}
 }
 
 func (m *GetQuerySegmentInfoResponse) XXX_Unmarshal(b []byte) error {
@@ -3431,7 +3727,7 @@ func (m *DummyRequest) Reset()         { *m = DummyRequest{} }
 func (m *DummyRequest) String() string { return proto.CompactTextString(m) }
 func (*DummyRequest) ProtoMessage()    {}
 func (*DummyRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{54}
+	return fileDescriptor_02345ba45cc0e303, []int{58}
 }
 
 func (m *DummyRequest) XXX_Unmarshal(b []byte) error {
@@ -3470,7 +3766,7 @@ func (m *DummyResponse) Reset()         { *m = DummyResponse{} }
 func (m *DummyResponse) String() string { return proto.CompactTextString(m) }
 func (*DummyResponse) ProtoMessage()    {}
 func (*DummyResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{55}
+	return fileDescriptor_02345ba45cc0e303, []int{59}
 }
 
 func (m *DummyResponse) XXX_Unmarshal(b []byte) error {
@@ -3508,7 +3804,7 @@ func (m *RegisterLinkRequest) Reset()         { *m = RegisterLinkRequest{} }
 func (m *RegisterLinkRequest) String() string { return proto.CompactTextString(m) }
 func (*RegisterLinkRequest) ProtoMessage()    {}
 func (*RegisterLinkRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{56}
+	return fileDescriptor_02345ba45cc0e303, []int{60}
 }
 
 func (m *RegisterLinkRequest) XXX_Unmarshal(b []byte) error {
@@ -3541,7 +3837,7 @@ func (m *RegisterLinkResponse) Reset()         { *m = RegisterLinkResponse{} }
 func (m *RegisterLinkResponse) String() string { return proto.CompactTextString(m) }
 func (*RegisterLinkResponse) ProtoMessage()    {}
 func (*RegisterLinkResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_02345ba45cc0e303, []int{57}
+	return fileDescriptor_02345ba45cc0e303, []int{61}
 }
 
 func (m *RegisterLinkResponse) XXX_Unmarshal(b []byte) error {
@@ -3628,6 +3924,10 @@ func init() {
 	proto.RegisterMapType((map[string]*schema.LongArray)(nil), "milvus.proto.milvus.FlushResponse.CollSegIDsEntry")
 	proto.RegisterType((*QueryRequest)(nil), "milvus.proto.milvus.QueryRequest")
 	proto.RegisterType((*QueryResults)(nil), "milvus.proto.milvus.QueryResults")
+	proto.RegisterType((*VectorIDs)(nil), "milvus.proto.milvus.VectorIDs")
+	proto.RegisterType((*VectorsArray)(nil), "milvus.proto.milvus.VectorsArray")
+	proto.RegisterType((*CalcDistanceRequest)(nil), "milvus.proto.milvus.CalcDistanceRequest")
+	proto.RegisterType((*CalcDistanceResults)(nil), "milvus.proto.milvus.CalcDistanceResults")
 	proto.RegisterType((*PersistentSegmentInfo)(nil), "milvus.proto.milvus.PersistentSegmentInfo")
 	proto.RegisterType((*GetPersistentSegmentInfoRequest)(nil), "milvus.proto.milvus.GetPersistentSegmentInfoRequest")
 	proto.RegisterType((*GetPersistentSegmentInfoResponse)(nil), "milvus.proto.milvus.GetPersistentSegmentInfoResponse")
@@ -3643,173 +3943,187 @@ func init() {
 func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
 
 var fileDescriptor_02345ba45cc0e303 = []byte{
-	// 2652 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x1a, 0x4d, 0x8f, 0x1c, 0x47,
-	0x75, 0x7b, 0x66, 0xe7, 0xeb, 0x4d, 0xcf, 0xee, 0xb8, 0xf6, 0x6b, 0x3c, 0xfe, 0xc8, 0x6e, 0x27,
-	0x26, 0xeb, 0xb5, 0xbd, 0x9b, 0x8c, 0x1d, 0x12, 0x08, 0x21, 0xd8, 0x5e, 0x6c, 0xaf, 0xfc, 0xc1,
-	0xa6, 0xc7, 0x44, 0x84, 0xc8, 0x1a, 0xf5, 0x4e, 0x97, 0x67, 0x5a, 0xdb, 0xd3, 0x3d, 0x54, 0xf5,
-	0xec, 0x7a, 0x7c, 0x42, 0x72, 0x40, 0x42, 0x80, 0x23, 0x44, 0x84, 0x04, 0x07, 0x84, 0x40, 0x39,
-	0x70, 0x02, 0x14, 0x24, 0x24, 0x4e, 0x1c, 0x72, 0xe0, 0x80, 0x04, 0xe2, 0xca, 0x15, 0x8e, 0xf9,
-	0x0f, 0xa8, 0xab, 0xba, 0x7b, 0xba, 0x7b, 0xab, 0x67, 0x67, 0x3d, 0x71, 0x76, 0xf7, 0xd6, 0xfd,
-	0xea, 0xbd, 0xaa, 0xf7, 0x5d, 0xaf, 0x5e, 0x15, 0xc8, 0x1d, 0xc3, 0xdc, 0xe9, 0xd1, 0xd5, 0x2e,
-	0xb1, 0x1d, 0x1b, 0xcd, 0x84, 0xff, 0x56, 0xf9, 0x4f, 0x55, 0x6e, 0xda, 0x9d, 0x8e, 0x6d, 0x71,
-	0x60, 0x55, 0xa6, 0xcd, 0x36, 0xee, 0x68, 0xfc, 0x4f, 0xf9, 0x54, 0x82, 0x85, 0xeb, 0x04, 0x6b,
-	0x0e, 0xbe, 0x6e, 0x9b, 0x26, 0x6e, 0x3a, 0x86, 0x6d, 0xa9, 0xf8, 0x7b, 0x3d, 0x4c, 0x1d, 0xf4,
-	0x0a, 0x4c, 0x6e, 0x69, 0x14, 0x57, 0xa4, 0x45, 0x69, 0xb9, 0x58, 0x3b, 0xbd, 0x1a, 0x99, 0xdb,
-	0x9b, 0xf3, 0x2e, 0x6d, 0x5d, 0xd3, 0x28, 0x56, 0x19, 0x26, 0x5a, 0x80, 0x9c, 0xbe, 0xd5, 0xb0,
-	0xb4, 0x0e, 0xae, 0xa4, 0x16, 0xa5, 0xe5, 0x82, 0x9a, 0xd5, 0xb7, 0xee, 0x69, 0x1d, 0x8c, 0x5e,
-	0x86, 0xe9, 0x66, 0x30, 0x3f, 0x47, 0x48, 0x33, 0x84, 0xa9, 0x01, 0x98, 0x21, 0xce, 0x43, 0x96,
-	0xf3, 0x57, 0x99, 0x5c, 0x94, 0x96, 0x65, 0xd5, 0xfb, 0x43, 0x67, 0x00, 0x68, 0x5b, 0x23, 0x3a,
-	0x6d, 0x58, 0xbd, 0x4e, 0x25, 0xb3, 0x28, 0x2d, 0x67, 0xd4, 0x02, 0x87, 0xdc, 0xeb, 0x75, 0x94,
-	0x1f, 0x4b, 0x30, 0xb7, 0x4e, 0xec, 0xee, 0x91, 0x10, 0x42, 0xf9, 0xbd, 0x04, 0xb3, 0xb7, 0x34,
-	0x7a, 0x34, 0x34, 0x7a, 0x06, 0xc0, 0x31, 0x3a, 0xb8, 0x41, 0x1d, 0xad, 0xd3, 0x65, 0x5a, 0x9d,
-	0x54, 0x0b, 0x2e, 0xa4, 0xee, 0x02, 0x94, 0xf7, 0x40, 0xbe, 0x66, 0xdb, 0xa6, 0x8a, 0x69, 0xd7,
-	0xb6, 0x28, 0x46, 0x97, 0x21, 0x4b, 0x1d, 0xcd, 0xe9, 0x51, 0x8f, 0xc9, 0x53, 0x42, 0x26, 0xeb,
-	0x0c, 0x45, 0xf5, 0x50, 0xd1, 0x2c, 0x64, 0x76, 0x34, 0xb3, 0xc7, 0x79, 0xcc, 0xab, 0xfc, 0x47,
-	0x79, 0x1f, 0xa6, 0xea, 0x0e, 0x31, 0xac, 0xd6, 0xe7, 0x38, 0x79, 0xc1, 0x9f, 0xfc, 0xdf, 0x12,
-	0x9c, 0x5c, 0xc7, 0xb4, 0x49, 0x8c, 0xad, 0x23, 0xe2, 0xba, 0x0a, 0xc8, 0x03, 0xc8, 0xc6, 0x3a,
-	0x53, 0x75, 0x5a, 0x8d, 0xc0, 0x62, 0xc6, 0xc8, 0xc4, 0x8d, 0xf1, 0xeb, 0x14, 0x54, 0x45, 0x42,
-	0x8d, 0xa3, 0xbe, 0xb7, 0x82, 0x88, 0x4a, 0x31, 0xa2, 0x73, 0x51, 0x22, 0x2f, 0x1b, 0x0c, 0x56,
-	0xab, 0x33, 0x40, 0x10, 0x78, 0x71, 0xa9, 0xd2, 0x02, 0xa9, 0x6a, 0x30, 0xb7, 0x63, 0x10, 0xa7,
-	0xa7, 0x99, 0x8d, 0x66, 0x5b, 0xb3, 0x2c, 0x6c, 0x32, 0x3d, 0xd1, 0xca, 0xe4, 0x62, 0x7a, 0xb9,
-	0xa0, 0xce, 0x78, 0x83, 0xd7, 0xf9, 0x98, 0xab, 0x2c, 0x8a, 0xae, 0xc0, 0x7c, 0xb7, 0xdd, 0xa7,
-	0x46, 0x73, 0x0f, 0x51, 0x86, 0x11, 0xcd, 0xfa, 0xa3, 0x61, 0x2a, 0x16, 0xe7, 0x77, 0x6c, 0x4d,
-	0x3f, 0x1a, 0x71, 0xfe, 0x54, 0x82, 0x8a, 0x8a, 0x4d, 0xac, 0xd1, 0xa3, 0xe1, 0x82, 0xca, 0x47,
-	0x12, 0x9c, 0xbd, 0x89, 0x9d, 0x90, 0x31, 0x1d, 0xcd, 0x31, 0xa8, 0x63, 0x34, 0xe9, 0x61, 0xb2,
-	0xf5, 0xa1, 0x04, 0x2f, 0x24, 0xb2, 0x35, 0x8e, 0x6f, 0xbf, 0x0e, 0x19, 0xf7, 0x8b, 0x56, 0x52,
-	0x8b, 0xe9, 0xe5, 0x62, 0x6d, 0x49, 0x48, 0x73, 0x1b, 0xf7, 0xdf, 0x75, 0x53, 0xc6, 0xa6, 0x66,
-	0x10, 0x95, 0xe3, 0x2b, 0x7f, 0x93, 0x60, 0xbe, 0xde, 0xb6, 0x77, 0x07, 0x2c, 0x3d, 0x0f, 0x05,
-	0x45, 0xa3, 0x3d, 0x1d, 0x8b, 0x76, 0xf4, 0x35, 0x98, 0x74, 0xfa, 0x5d, 0xcc, 0x12, 0xc5, 0x54,
-	0x6d, 0x79, 0x55, 0xb0, 0x77, 0xaf, 0xc6, 0x98, 0xbc, 0xdf, 0xef, 0x62, 0x95, 0x51, 0x29, 0xbf,
-	0x91, 0x60, 0x61, 0x8f, 0x08, 0xe3, 0x28, 0xf3, 0x3c, 0x94, 0x63, 0xe6, 0xe4, 0x7a, 0x2d, 0xa8,
-	0xd3, 0x51, 0x7b, 0x52, 0x74, 0x0e, 0x42, 0x26, 0x6e, 0x18, 0x3a, 0xad, 0xa4, 0x17, 0xd3, 0xcb,
-	0x69, 0xb5, 0x14, 0x4a, 0x0b, 0x3a, 0x55, 0x3e, 0x91, 0x60, 0x9e, 0x17, 0x17, 0x9b, 0x1a, 0x71,
-	0x8c, 0xc3, 0x4e, 0xd0, 0xe7, 0x60, 0xaa, 0xeb, 0xf3, 0xc1, 0xf1, 0x26, 0x19, 0x5e, 0x29, 0x80,
-	0x32, 0x6f, 0xfd, 0x93, 0x04, 0xb3, 0x6e, 0x2d, 0x71, 0x9c, 0x78, 0xfe, 0xa3, 0x04, 0x33, 0xb7,
-	0x34, 0x7a, 0x9c, 0x58, 0xfe, 0xb3, 0x97, 0xca, 0x03, 0x9e, 0x0f, 0x33, 0x45, 0xb9, 0x88, 0x51,
-	0xa6, 0xfd, 0xcd, 0x6b, 0x2a, 0xc2, 0x35, 0x55, 0xfe, 0x32, 0xc8, 0xf9, 0xc7, 0x8c, 0xf3, 0xbf,
-	0x4a, 0x70, 0xe6, 0x26, 0x76, 0x02, 0xae, 0x8f, 0xc4, 0xde, 0x30, 0xaa, 0xb7, 0x3c, 0xe5, 0x3b,
-	0x9b, 0x90, 0xf9, 0x43, 0xd9, 0x41, 0xfe, 0x20, 0xc1, 0x9c, 0x9b, 0x7e, 0x8f, 0x86, 0x13, 0x8c,
-	0x50, 0x7b, 0x2a, 0xbf, 0xf2, 0xf6, 0xbc, 0x30, 0xc7, 0xe3, 0xa8, 0x4e, 0xe0, 0x78, 0x29, 0x91,
-	0xe3, 0xb9, 0xcc, 0x05, 0x90, 0x8d, 0x75, 0x7f, 0xaf, 0x88, 0xc0, 0x94, 0x9f, 0x48, 0x30, 0xef,
-	0x57, 0xbe, 0x75, 0xdc, 0xea, 0x60, 0xcb, 0x79, 0x76, 0x7d, 0xc6, 0xb5, 0x91, 0x12, 0xd4, 0xac,
-	0xa7, 0xa1, 0x40, 0xf9, 0x3a, 0x41, 0x51, 0x3b, 0x00, 0x28, 0x1f, 0x4b, 0xb0, 0xb0, 0x87, 0x9d,
-	0x71, 0x94, 0x55, 0x81, 0x9c, 0x61, 0xe9, 0xf8, 0x51, 0xc0, 0x8d, 0xff, 0xeb, 0x8e, 0x6c, 0xf5,
-	0x0c, 0x53, 0x0f, 0xd8, 0xf0, 0x7f, 0xd1, 0x12, 0xc8, 0xd8, 0xd2, 0xb6, 0x4c, 0xdc, 0x60, 0xb8,
-	0xcc, 0xa8, 0x79, 0xb5, 0xc8, 0x61, 0x1b, 0x2e, 0x48, 0xf9, 0xa9, 0x04, 0x33, 0xae, 0x4d, 0x3d,
-	0x1e, 0xe9, 0xf3, 0xd5, 0xd9, 0x22, 0x14, 0x43, 0x46, 0xf3, 0xd8, 0x0d, 0x83, 0x94, 0x6d, 0x98,
-	0x8d, 0xb2, 0x33, 0x8e, 0xce, 0xce, 0x02, 0x04, 0x16, 0xe1, 0xbe, 0x95, 0x56, 0x43, 0x10, 0xe5,
-	0x33, 0x09, 0x10, 0x2f, 0x2f, 0x98, 0x32, 0x0e, 0xf9, 0x90, 0xfd, 0xd0, 0xc0, 0xa6, 0x1e, 0xce,
-	0x60, 0x05, 0x06, 0x61, 0xc3, 0xeb, 0x20, 0xe3, 0x47, 0x0e, 0xd1, 0x1a, 0x5d, 0x8d, 0x68, 0x1d,
-	0x7e, 0xc4, 0x19, 0x29, 0xd9, 0x14, 0x19, 0xd9, 0x26, 0xa3, 0x52, 0xfe, 0xee, 0x16, 0x26, 0x9e,
-	0x53, 0x1e, 0x75, 0x89, 0xcf, 0x00, 0x30, 0xa7, 0xe5, 0xc3, 0x19, 0x3e, 0xcc, 0x20, 0x2c, 0x9d,
-	0x7f, 0x2c, 0x41, 0x99, 0x89, 0xc0, 0xe5, 0xe9, 0xba, 0xd3, 0xc6, 0x68, 0xa4, 0x18, 0xcd, 0x90,
-	0x10, 0xfa, 0x0a, 0x64, 0x3d, 0xc5, 0xa6, 0x47, 0x55, 0xac, 0x47, 0xb0, 0x8f, 0x18, 0xca, 0x6f,
-	0x25, 0x98, 0x8b, 0xa9, 0x7c, 0x1c, 0x8f, 0xbe, 0x0f, 0x88, 0x4b, 0xa8, 0x0f, 0xc4, 0xf6, 0xb7,
-	0x9e, 0x73, 0xc2, 0xfa, 0x3f, 0xae, 0x24, 0xf5, 0x84, 0x11, 0x83, 0x50, 0xe5, 0x5f, 0x12, 0x9c,
-	0xbe, 0x89, 0x1d, 0x86, 0x7a, 0xcd, 0xcd, 0x1d, 0x9b, 0xc4, 0x6e, 0x11, 0x4c, 0xe9, 0xf1, 0xf5,
-	0x8f, 0x5f, 0xf0, 0x5a, 0x45, 0x24, 0xd2, 0x38, 0xfa, 0x5f, 0x02, 0x99, 0xad, 0x81, 0xf5, 0x06,
-	0xb1, 0x77, 0xa9, 0xe7, 0x47, 0x45, 0x0f, 0xa6, 0xda, 0xbb, 0xcc, 0x21, 0x1c, 0xdb, 0xd1, 0x4c,
-	0x8e, 0xe0, 0x6d, 0x0c, 0x0c, 0xe2, 0x0e, 0xb3, 0x18, 0xf4, 0x19, 0x73, 0x27, 0xc7, 0xc7, 0x57,
-	0xc7, 0x4f, 0x24, 0x98, 0x8b, 0x89, 0x32, 0x8e, 0x6e, 0x5f, 0xe3, 0x95, 0x14, 0x17, 0x66, 0xaa,
-	0xf6, 0x82, 0x90, 0x26, 0xb4, 0x18, 0xc7, 0x56, 0x3e, 0x95, 0xa0, 0xec, 0x9e, 0xb6, 0x8e, 0x79,
-	0x42, 0xfb, 0x5d, 0x0a, 0x4a, 0x1b, 0x16, 0xc5, 0xc4, 0x39, 0xfa, 0xc5, 0x34, 0x7a, 0x1b, 0x8a,
-	0x4c, 0x30, 0xda, 0xd0, 0x35, 0x47, 0xf3, 0x76, 0xa3, 0xb3, 0xc2, 0xbe, 0xe0, 0x0d, 0x17, 0x6f,
-	0x5d, 0x73, 0x34, 0x95, 0x6b, 0x87, 0xba, 0xdf, 0xe8, 0x14, 0x14, 0xda, 0x1a, 0x6d, 0x37, 0xb6,
-	0x71, 0x9f, 0x56, 0xb2, 0x8b, 0xe9, 0xe5, 0x92, 0x9a, 0x77, 0x01, 0xb7, 0x71, 0x9f, 0xa2, 0x93,
-	0x90, 0xb7, 0x7a, 0x1d, 0x1e, 0x3f, 0xb9, 0x45, 0x69, 0xb9, 0xa4, 0xe6, 0xac, 0x5e, 0x87, 0x45,
-	0xcf, 0x3f, 0x52, 0x30, 0x75, 0xb7, 0xe7, 0x96, 0xee, 0xac, 0xab, 0xd9, 0x33, 0x9d, 0x67, 0xf3,
-	0xb5, 0x15, 0x48, 0xf3, 0x92, 0xc0, 0xa5, 0xa8, 0x08, 0x19, 0xdf, 0x58, 0xa7, 0xaa, 0x8b, 0xc4,
-	0x6e, 0x0e, 0x7a, 0xcd, 0xa6, 0x57, 0x43, 0xa5, 0x19, 0xb3, 0x05, 0x17, 0xc2, 0x3c, 0xce, 0x15,
-	0x05, 0x13, 0x12, 0x54, 0x58, 0x4c, 0x14, 0x4c, 0x08, 0x1f, 0x54, 0x40, 0xd6, 0x9a, 0xdb, 0x96,
-	0xbd, 0x6b, 0x62, 0xbd, 0x85, 0x75, 0x66, 0xf6, 0xbc, 0x1a, 0x81, 0x71, 0xc7, 0x70, 0x0d, 0xdf,
-	0x68, 0x5a, 0x4e, 0x25, 0xcb, 0x13, 0x06, 0x87, 0x5c, 0xb7, 0x1c, 0x77, 0x58, 0xc7, 0x26, 0x76,
-	0x30, 0x1b, 0xce, 0xf1, 0x61, 0x0e, 0xf1, 0x86, 0x7b, 0xdd, 0x80, 0x3a, 0xcf, 0x87, 0x39, 0xc4,
-	0x1d, 0x3e, 0x0d, 0xac, 0x5f, 0xc4, 0x1b, 0x48, 0x85, 0x41, 0x03, 0x89, 0x01, 0x94, 0x1d, 0x28,
-	0x6f, 0x9a, 0x5a, 0x13, 0xb7, 0x6d, 0x53, 0xc7, 0x84, 0x6d, 0x6e, 0xa8, 0x0c, 0x69, 0x47, 0x6b,
-	0x79, 0xbb, 0xa7, 0xfb, 0x89, 0xde, 0xf0, 0xda, 0x4c, 0x3c, 0x2e, 0x5f, 0x12, 0x6e, 0x33, 0xa1,
-	0x69, 0x06, 0x2d, 0x26, 0x34, 0x0f, 0x59, 0xd6, 0x6c, 0xe7, 0xfb, 0xaa, 0xac, 0x7a, 0x7f, 0xca,
-	0x83, 0xc8, 0xba, 0x37, 0x89, 0xdd, 0xeb, 0xa2, 0x0d, 0x90, 0xbb, 0x03, 0x98, 0x6b, 0xcd, 0xe4,
-	0x4d, 0x2d, 0xce, 0xb4, 0x1a, 0x21, 0x55, 0x3e, 0x4b, 0x43, 0xa9, 0x8e, 0x35, 0xd2, 0x6c, 0x1f,
-	0x87, 0x73, 0xb5, 0xab, 0x71, 0x9d, 0x9a, 0x5e, 0x4a, 0x70, 0x3f, 0xd1, 0x05, 0x38, 0x11, 0x12,
-	0xa8, 0xd1, 0x72, 0x15, 0xc4, 0x3c, 0x43, 0x56, 0xcb, 0xdd, 0xb8, 0xe2, 0x5e, 0x87, 0xbc, 0x4e,
-	0xcd, 0x06, 0x33, 0x51, 0x8e, 0x99, 0x48, 0x2c, 0xdf, 0x3a, 0x35, 0x99, 0x69, 0x72, 0x3a, 0xff,
-	0x40, 0x2f, 0x42, 0xc9, 0xee, 0x39, 0xdd, 0x9e, 0xd3, 0xe0, 0x91, 0x59, 0xc9, 0x33, 0xf6, 0x64,
-	0x0e, 0x64, 0x81, 0x4b, 0xd1, 0x0d, 0x28, 0x51, 0xa6, 0x4a, 0xbf, 0xf4, 0x2c, 0x8c, 0x5a, 0x21,
-	0xc9, 0x9c, 0x8e, 0xd7, 0x9e, 0xe8, 0x3c, 0x94, 0x1d, 0xa2, 0xed, 0x60, 0xb3, 0x31, 0xf0, 0x47,
-	0x60, 0xfe, 0x38, 0xcd, 0xe1, 0xf7, 0x7d, 0x30, 0x5a, 0x83, 0x99, 0x56, 0x4f, 0x23, 0x9a, 0xe5,
-	0x60, 0x1c, 0xc2, 0x2e, 0x32, 0x6c, 0x14, 0x0c, 0x05, 0x04, 0xca, 0x7f, 0x52, 0x30, 0xad, 0x62,
-	0x87, 0x18, 0x78, 0x07, 0x1f, 0x0b, 0x8b, 0xaf, 0x40, 0xda, 0xd0, 0x29, 0xb3, 0xf8, 0xd0, 0xf4,
-	0x63, 0xe8, 0x74, 0xaf, 0x95, 0xb2, 0x02, 0x2b, 0x89, 0xb4, 0x9b, 0x3b, 0x90, 0x76, 0xf3, 0x89,
-	0xda, 0xfd, 0x44, 0x0a, 0x6b, 0xd7, 0xcd, 0xb9, 0xf4, 0x99, 0x93, 0xae, 0x2b, 0x75, 0x6a, 0x14,
-	0xa9, 0x63, 0x3b, 0x4c, 0xfa, 0xa0, 0x3b, 0x8c, 0x72, 0x1b, 0x26, 0x6f, 0x19, 0x0e, 0x0b, 0x2e,
-	0x37, 0xd3, 0x4b, 0xec, 0xf0, 0xc7, 0xf2, 0xf9, 0x49, 0xc8, 0x13, 0x7b, 0x97, 0xcf, 0x9b, 0x62,
-	0x69, 0x29, 0x47, 0xec, 0x5d, 0xb6, 0x2d, 0xb1, 0xcb, 0x63, 0x9b, 0x78, 0xf9, 0x2a, 0xa5, 0x7a,
-	0x7f, 0xca, 0x0f, 0xa4, 0x41, 0x42, 0x19, 0x43, 0x01, 0x6f, 0x43, 0x8e, 0x70, 0xfa, 0xa1, 0x57,
-	0x69, 0xe1, 0x95, 0x98, 0x5c, 0x3e, 0x95, 0xf2, 0x81, 0x04, 0xf2, 0x0d, 0xb3, 0x47, 0x9f, 0x47,
-	0x5e, 0x13, 0x75, 0xef, 0xd3, 0xc2, 0xee, 0xbd, 0xf2, 0xb3, 0x14, 0x94, 0x3c, 0x36, 0xc6, 0x29,
-	0xf8, 0x12, 0x59, 0xa9, 0x43, 0xd1, 0x5d, 0xb2, 0x41, 0x71, 0xcb, 0x6f, 0xf7, 0x14, 0x6b, 0x35,
-	0xe1, 0x4e, 0x10, 0x61, 0x83, 0x5d, 0x42, 0xd6, 0x19, 0xd1, 0x37, 0x2d, 0x87, 0xf4, 0x55, 0x68,
-	0x06, 0x80, 0xea, 0x03, 0x98, 0x8e, 0x0d, 0xbb, 0xbe, 0xb1, 0x8d, 0xfb, 0xfe, 0x56, 0xb7, 0x8d,
-	0xfb, 0xe8, 0x4a, 0xf8, 0xaa, 0x38, 0xc9, 0xe1, 0xee, 0xd8, 0x56, 0xeb, 0x2a, 0x21, 0x5a, 0xdf,
-	0xbb, 0x4a, 0xfe, 0x6a, 0xea, 0x0d, 0x49, 0xf9, 0xaf, 0x04, 0xf2, 0x3b, 0x3d, 0x4c, 0xfa, 0x87,
-	0x99, 0x80, 0x10, 0x4c, 0xe2, 0x47, 0x5d, 0xe2, 0x15, 0x6d, 0xec, 0x7b, 0x6f, 0xfe, 0xc8, 0x08,
-	0xf2, 0x87, 0x20, 0x73, 0x65, 0x85, 0x3d, 0xe0, 0x0f, 0x06, 0x62, 0x8e, 0x15, 0x08, 0x91, 0xe8,
-	0x4e, 0x1d, 0x38, 0xba, 0xff, 0x29, 0xc1, 0xdc, 0x26, 0x26, 0xd4, 0xa0, 0x0e, 0xb6, 0x1c, 0xaf,
-	0x5b, 0xb4, 0x61, 0x3d, 0xb4, 0xa3, 0x6d, 0x39, 0x29, 0xd6, 0x96, 0xfb, 0x7c, 0x9a, 0x54, 0x91,
-	0x02, 0x95, 0x37, 0x4a, 0xfd, 0x02, 0xd5, 0x6f, 0x07, 0xf3, 0x02, 0x7f, 0x2a, 0x61, 0x9b, 0xf4,
-	0xf8, 0x8d, 0x1c, 0x63, 0x7e, 0xce, 0xaf, 0x38, 0x85, 0x42, 0x3d, 0xbb, 0x4b, 0xcd, 0x83, 0xe7,
-	0x43, 0x31, 0x8f, 0xfa, 0x12, 0xc4, 0x5c, 0x27, 0xe1, 0xe2, 0xf5, 0x97, 0x12, 0x2c, 0x26, 0x73,
-	0x35, 0x4e, 0xf0, 0x7f, 0x03, 0x32, 0x86, 0xf5, 0xd0, 0xf6, 0x9b, 0x17, 0x2b, 0xe2, 0x3a, 0x4f,
-	0xb8, 0x2e, 0x27, 0x54, 0xfe, 0x27, 0x41, 0x99, 0xb9, 0xe2, 0x21, 0x98, 0xbf, 0x83, 0x3b, 0x0d,
-	0x6a, 0x3c, 0xc6, 0xbe, 0xf9, 0x3b, 0xb8, 0x53, 0x37, 0x1e, 0xe3, 0x88, 0x67, 0x64, 0xa2, 0x9e,
-	0x11, 0x3d, 0xff, 0x65, 0x87, 0x34, 0xa7, 0x72, 0x91, 0xe6, 0x94, 0xf2, 0x54, 0x82, 0xea, 0x4d,
-	0xec, 0xc4, 0x45, 0x3d, 0x3c, 0xa7, 0xf8, 0x50, 0x82, 0x53, 0x42, 0x86, 0xc6, 0xf1, 0x87, 0x37,
-	0xa3, 0xfe, 0x20, 0xae, 0xfb, 0xf7, 0x2c, 0xe9, 0xb9, 0xc2, 0xab, 0x20, 0xaf, 0xf7, 0x3a, 0x9d,
-	0x20, 0xf7, 0x2e, 0x81, 0x4c, 0xf8, 0x27, 0x2f, 0x8b, 0x79, 0x86, 0x2f, 0x7a, 0x30, 0xb7, 0xf8,
-	0x55, 0x2e, 0x40, 0xc9, 0x23, 0xf1, 0xb8, 0xae, 0x42, 0x9e, 0x78, 0xdf, 0x1e, 0x7e, 0xf0, 0xaf,
-	0xcc, 0xc1, 0x8c, 0x8a, 0x5b, 0xae, 0x27, 0x92, 0x3b, 0x86, 0xb5, 0xed, 0x2d, 0xa3, 0x3c, 0x91,
-	0x60, 0x36, 0x0a, 0xf7, 0xe6, 0xfa, 0x32, 0xe4, 0x34, 0x5d, 0x27, 0x98, 0xd2, 0xa1, 0x66, 0xb9,
-	0xca, 0x71, 0x54, 0x1f, 0x39, 0xa4, 0xb9, 0xd4, 0xc8, 0x9a, 0x5b, 0xb9, 0xc8, 0x3b, 0xf8, 0xb1,
-	0x4b, 0x7e, 0x94, 0x83, 0xf4, 0x55, 0xd3, 0x2c, 0x4f, 0x20, 0x19, 0xf2, 0x1b, 0xd6, 0x5d, 0xdc,
-	0xb1, 0x49, 0xbf, 0x2c, 0xad, 0x7c, 0x1d, 0xa6, 0x63, 0x67, 0x35, 0x94, 0x87, 0xc9, 0x7b, 0xb6,
-	0x85, 0xcb, 0x13, 0xa8, 0x0c, 0xf2, 0x35, 0xc3, 0xd2, 0x48, 0xff, 0x5d, 0xdc, 0x74, 0x6c, 0x52,
-	0xd6, 0xd1, 0x34, 0x14, 0x6f, 0x98, 0xb6, 0xe6, 0x78, 0x00, 0x5c, 0xfb, 0x68, 0x01, 0x4a, 0x77,
-	0x19, 0x53, 0x75, 0x4c, 0x76, 0x8c, 0x26, 0x46, 0x0d, 0x28, 0xc7, 0x1f, 0x00, 0xa2, 0x8b, 0x42,
-	0xf3, 0x25, 0xbc, 0x13, 0xac, 0x0e, 0x13, 0x53, 0x99, 0x40, 0xef, 0xc3, 0x54, 0xf4, 0x69, 0x1e,
-	0x12, 0x67, 0x0b, 0xe1, 0xfb, 0xbd, 0xfd, 0x26, 0x6f, 0x40, 0x29, 0xf2, 0xd2, 0x0e, 0x9d, 0x17,
-	0xce, 0x2d, 0x7a, 0x8d, 0x57, 0x5d, 0x12, 0xa2, 0x86, 0x5f, 0xc3, 0x71, 0xee, 0xa3, 0x0f, 0x8e,
-	0x12, 0xb8, 0x17, 0xbe, 0x4a, 0xda, 0x8f, 0x7b, 0x0d, 0x4e, 0xec, 0x79, 0x3f, 0x84, 0x2e, 0x09,
-	0xe7, 0x4f, 0x7a, 0x67, 0xb4, 0xdf, 0x12, 0xbb, 0x80, 0xf6, 0xbe, 0x28, 0x43, 0xab, 0x62, 0x0b,
-	0x24, 0xbd, 0xa7, 0xab, 0xae, 0x8d, 0x8c, 0x1f, 0x28, 0xee, 0x87, 0x12, 0x2c, 0x24, 0x3c, 0xfa,
-	0x41, 0x97, 0x85, 0xd3, 0x0d, 0x7f, 0xb9, 0x54, 0xbd, 0x72, 0x30, 0xa2, 0x80, 0x11, 0x0b, 0xa6,
-	0x63, 0x01, 0x86, 0x2e, 0x8c, 0xf2, 0xd6, 0xc6, 0x5f, 0xf7, 0xe2, 0x68, 0xc8, 0xc1, 0x7a, 0x6e,
-	0xa5, 0x1a, 0x7d, 0xf4, 0x92, 0xb0, 0x9e, 0xf8, 0x69, 0xcc, 0x7e, 0x06, 0x7d, 0x0f, 0x4a, 0x91,
-	0xd7, 0x29, 0x09, 0x1e, 0x2f, 0x7a, 0xc1, 0xb2, 0xdf, 0xd4, 0x0f, 0x40, 0x0e, 0x3f, 0x22, 0x41,
-	0xcb, 0x49, 0xb1, 0xb4, 0x67, 0xe2, 0x83, 0x84, 0xd2, 0xe0, 0xfe, 0x79, 0x48, 0x28, 0xed, 0xb9,
-	0x56, 0x1f, 0x3d, 0x94, 0x42, 0xf3, 0x0f, 0x0d, 0xa5, 0x03, 0x2f, 0xf1, 0x44, 0x82, 0x79, 0xf1,
-	0x1b, 0x04, 0x54, 0x4b, 0xf2, 0xcd, 0xe4, 0xd7, 0x16, 0xd5, 0xcb, 0x07, 0xa2, 0x09, 0xb4, 0xb8,
-	0x0d, 0x53, 0xd1, 0x5b, 0xfc, 0x04, 0x2d, 0x0a, 0x1f, 0x27, 0x54, 0x2f, 0x8c, 0x84, 0x1b, 0x2c,
-	0xf6, 0x6d, 0x28, 0x86, 0x6e, 0x58, 0xd1, 0xcb, 0x43, 0xfc, 0x38, 0xdc, 0xc0, 0xdf, 0x4f, 0x93,
-	0x6d, 0x28, 0x45, 0x6e, 0xd5, 0x92, 0x7c, 0x58, 0x70, 0xd9, 0x59, 0x5d, 0x19, 0x05, 0x35, 0x10,
-	0xa0, 0x0d, 0xa5, 0xc8, 0x1d, 0x47, 0xc2, 0x4a, 0xa2, 0x2b, 0x9d, 0x84, 0x95, 0x84, 0x57, 0x26,
-	0xca, 0x04, 0xfa, 0x7e, 0xe8, 0x3a, 0x25, 0x72, 0x65, 0x85, 0x5e, 0x1d, 0x3a, 0x8f, 0xe8, 0xc6,
-	0xae, 0x5a, 0x3b, 0x08, 0x49, 0xc0, 0xc2, 0x3b, 0x50, 0x08, 0xae, 0x52, 0xd0, 0xb9, 0xc4, 0xb4,
-	0x70, 0x10, 0x4b, 0xd5, 0x21, 0xcb, 0xaf, 0x35, 0x90, 0x92, 0x70, 0x3f, 0x19, 0xba, 0xf3, 0xa8,
-	0xbe, 0x28, 0xc4, 0x89, 0x76, 0xfc, 0x95, 0x09, 0xa4, 0x42, 0x96, 0x37, 0x49, 0x12, 0x26, 0x8d,
-	0x34, 0x7f, 0xab, 0xc3, 0x71, 0x78, 0x67, 0x65, 0x02, 0x7d, 0x07, 0xf2, 0x7e, 0x97, 0x0b, 0xbd,
-	0x94, 0x10, 0xf6, 0x91, 0x16, 0x63, 0x75, 0x3f, 0x2c, 0x7f, 0xe6, 0x4d, 0xc8, 0xb0, 0x36, 0x05,
-	0x5a, 0x1a, 0xd6, 0xc2, 0x18, 0xc6, 0x6b, 0xa4, 0xcb, 0xa1, 0x4c, 0xa0, 0x6f, 0x41, 0x86, 0x95,
-	0xc2, 0x09, 0x33, 0x86, 0xfb, 0x10, 0xd5, 0xa1, 0x28, 0x3e, 0x8b, 0x3f, 0x92, 0xa0, 0x92, 0x74,
-	0xce, 0x43, 0x89, 0xfb, 0xe6, 0xb0, 0xc3, 0x6a, 0xf5, 0xb5, 0x03, 0x52, 0x05, 0xc2, 0x3d, 0x86,
-	0x19, 0xc1, 0xe9, 0x02, 0xad, 0x25, 0xcd, 0x97, 0x70, 0x30, 0xaa, 0xbe, 0x32, 0x3a, 0x41, 0xb0,
-	0xf6, 0x26, 0x64, 0xd8, 0xa9, 0x20, 0x41, 0xb1, 0xe1, 0x43, 0x46, 0x82, 0xa9, 0x22, 0x87, 0x0a,
-	0x65, 0x02, 0x61, 0x90, 0xc3, 0x47, 0x84, 0x84, 0x2d, 0x51, 0x70, 0xba, 0xa8, 0x9e, 0x1f, 0x01,
-	0xd3, 0x5f, 0xa6, 0xd6, 0x03, 0x79, 0x93, 0xd8, 0x8f, 0xfa, 0x7e, 0x51, 0xfe, 0xc5, 0x2c, 0x7b,
-	0xed, 0xad, 0xef, 0xbe, 0xd9, 0x32, 0x9c, 0x76, 0x6f, 0xcb, 0x8d, 0xfb, 0x35, 0x8e, 0x7b, 0xc9,
-	0xb0, 0xfd, 0x2f, 0xaa, 0x6f, 0x5f, 0x6a, 0xd9, 0x6b, 0x3b, 0xb5, 0x35, 0xc3, 0x72, 0x30, 0xb1,
-	0x34, 0x73, 0x8d, 0xcd, 0xba, 0x46, 0x31, 0xd9, 0xc1, 0x64, 0x2b, 0xcb, 0xfe, 0x2e, 0xff, 0x3f,
-	0x00, 0x00, 0xff, 0xff, 0x82, 0x15, 0xc2, 0xda, 0x84, 0x34, 0x00, 0x00,
+	// 2880 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3a, 0xcd, 0x6f, 0x24, 0x47,
+	0xf5, 0xae, 0x19, 0xcf, 0xd7, 0x9b, 0x1e, 0x7b, 0x52, 0x5e, 0x7b, 0x27, 0x93, 0xdd, 0xc4, 0xdb,
+	0xc9, 0xfe, 0xe2, 0xdd, 0x4d, 0xd6, 0x89, 0x37, 0xf9, 0x25, 0xbf, 0x7c, 0xfc, 0x92, 0xdd, 0x35,
+	0xd9, 0xb5, 0xb2, 0x1b, 0x9c, 0x76, 0x88, 0x08, 0x51, 0x34, 0x6a, 0x4f, 0xd7, 0xce, 0xb4, 0xdc,
+	0xd3, 0x3d, 0x74, 0xd5, 0xd8, 0x3b, 0x39, 0x21, 0x25, 0x20, 0x21, 0x20, 0x11, 0x02, 0x81, 0xe0,
+	0x80, 0x10, 0x28, 0x07, 0x4e, 0x10, 0x05, 0x09, 0x89, 0x13, 0x87, 0x1c, 0x38, 0x20, 0xf1, 0x71,
+	0xe5, 0x0a, 0xc7, 0xfc, 0x03, 0x88, 0x03, 0xaa, 0xaa, 0xee, 0x9e, 0xee, 0x76, 0xf5, 0x78, 0xbc,
+	0x93, 0x60, 0xfb, 0xd6, 0xfd, 0xea, 0xbd, 0xaa, 0xf7, 0x55, 0xaf, 0x5e, 0xbd, 0x7a, 0xa0, 0xf5,
+	0x6c, 0x67, 0x77, 0x40, 0x2f, 0xf7, 0x7d, 0x8f, 0x79, 0x78, 0x21, 0xfe, 0x77, 0x59, 0xfe, 0x34,
+	0xb5, 0xb6, 0xd7, 0xeb, 0x79, 0xae, 0x04, 0x36, 0x35, 0xda, 0xee, 0x92, 0x9e, 0x29, 0xff, 0xf4,
+	0x4f, 0x11, 0x9c, 0xbe, 0xee, 0x13, 0x93, 0x91, 0xeb, 0x9e, 0xe3, 0x90, 0x36, 0xb3, 0x3d, 0xd7,
+	0x20, 0x5f, 0x1f, 0x10, 0xca, 0xf0, 0x13, 0x30, 0xbb, 0x6d, 0x52, 0xd2, 0x40, 0xcb, 0x68, 0xa5,
+	0xba, 0x76, 0xe6, 0x72, 0x62, 0xee, 0x60, 0xce, 0xdb, 0xb4, 0x73, 0xcd, 0xa4, 0xc4, 0x10, 0x98,
+	0xf8, 0x34, 0x94, 0xac, 0xed, 0x96, 0x6b, 0xf6, 0x48, 0x23, 0xb7, 0x8c, 0x56, 0x2a, 0x46, 0xd1,
+	0xda, 0x7e, 0xcd, 0xec, 0x11, 0xfc, 0x28, 0xcc, 0xb7, 0xa3, 0xf9, 0x25, 0x42, 0x5e, 0x20, 0xcc,
+	0x8d, 0xc0, 0x02, 0x71, 0x09, 0x8a, 0x92, 0xbf, 0xc6, 0xec, 0x32, 0x5a, 0xd1, 0x8c, 0xe0, 0x0f,
+	0x9f, 0x05, 0xa0, 0x5d, 0xd3, 0xb7, 0x68, 0xcb, 0x1d, 0xf4, 0x1a, 0x85, 0x65, 0xb4, 0x52, 0x30,
+	0x2a, 0x12, 0xf2, 0xda, 0xa0, 0xa7, 0x7f, 0x07, 0xc1, 0xe2, 0xba, 0xef, 0xf5, 0x8f, 0x85, 0x10,
+	0xfa, 0xaf, 0x10, 0x9c, 0xba, 0x69, 0xd2, 0xe3, 0xa1, 0xd1, 0xb3, 0x00, 0xcc, 0xee, 0x91, 0x16,
+	0x65, 0x66, 0xaf, 0x2f, 0xb4, 0x3a, 0x6b, 0x54, 0x38, 0x64, 0x8b, 0x03, 0xf4, 0xb7, 0x40, 0xbb,
+	0xe6, 0x79, 0x8e, 0x41, 0x68, 0xdf, 0x73, 0x29, 0xc1, 0x57, 0xa0, 0x48, 0x99, 0xc9, 0x06, 0x34,
+	0x60, 0xf2, 0x01, 0x25, 0x93, 0x5b, 0x02, 0xc5, 0x08, 0x50, 0xf1, 0x29, 0x28, 0xec, 0x9a, 0xce,
+	0x40, 0xf2, 0x58, 0x36, 0xe4, 0x8f, 0xfe, 0x36, 0xcc, 0x6d, 0x31, 0xdf, 0x76, 0x3b, 0x9f, 0xe3,
+	0xe4, 0x95, 0x70, 0xf2, 0xbf, 0x21, 0xb8, 0x7f, 0x9d, 0xd0, 0xb6, 0x6f, 0x6f, 0x1f, 0x13, 0xd7,
+	0xd5, 0x41, 0x1b, 0x41, 0x36, 0xd6, 0x85, 0xaa, 0xf3, 0x46, 0x02, 0x96, 0x32, 0x46, 0x21, 0x6d,
+	0x8c, 0x9f, 0xe5, 0xa0, 0xa9, 0x12, 0x6a, 0x1a, 0xf5, 0xbd, 0x18, 0xed, 0xa8, 0x9c, 0x20, 0x3a,
+	0x9f, 0x24, 0x0a, 0xa2, 0xc1, 0x68, 0xb5, 0x2d, 0x01, 0x88, 0x36, 0x5e, 0x5a, 0xaa, 0xbc, 0x42,
+	0xaa, 0x35, 0x58, 0xdc, 0xb5, 0x7d, 0x36, 0x30, 0x9d, 0x56, 0xbb, 0x6b, 0xba, 0x2e, 0x71, 0x84,
+	0x9e, 0x68, 0x63, 0x76, 0x39, 0xbf, 0x52, 0x31, 0x16, 0x82, 0xc1, 0xeb, 0x72, 0x8c, 0x2b, 0x8b,
+	0xe2, 0xa7, 0x60, 0xa9, 0xdf, 0x1d, 0x52, 0xbb, 0xbd, 0x8f, 0xa8, 0x20, 0x88, 0x4e, 0x85, 0xa3,
+	0x71, 0x2a, 0xb1, 0xcf, 0x6f, 0x79, 0xa6, 0x75, 0x3c, 0xf6, 0xf9, 0x07, 0x08, 0x1a, 0x06, 0x71,
+	0x88, 0x49, 0x8f, 0x87, 0x0b, 0xea, 0x3f, 0x44, 0xf0, 0xe0, 0x0d, 0xc2, 0x62, 0xc6, 0x64, 0x26,
+	0xb3, 0x29, 0xb3, 0xdb, 0xf4, 0x28, 0xd9, 0xfa, 0x10, 0xc1, 0x43, 0x99, 0x6c, 0x4d, 0xe3, 0xdb,
+	0xcf, 0x40, 0x81, 0x7f, 0xd1, 0x46, 0x6e, 0x39, 0xbf, 0x52, 0x5d, 0x3b, 0xa7, 0xa4, 0x79, 0x95,
+	0x0c, 0xdf, 0xe4, 0x21, 0x63, 0xd3, 0xb4, 0x7d, 0x43, 0xe2, 0xeb, 0x7f, 0x40, 0xb0, 0xb4, 0xd5,
+	0xf5, 0xf6, 0x46, 0x2c, 0x7d, 0x11, 0x0a, 0x4a, 0xee, 0xf6, 0x7c, 0x6a, 0xb7, 0xe3, 0x17, 0x60,
+	0x96, 0x0d, 0xfb, 0x44, 0x04, 0x8a, 0xb9, 0xb5, 0x95, 0xcb, 0x8a, 0xb3, 0xfb, 0x72, 0x8a, 0xc9,
+	0x37, 0x86, 0x7d, 0x62, 0x08, 0x2a, 0xfd, 0xe7, 0x08, 0x4e, 0xef, 0x13, 0x61, 0x1a, 0x65, 0x5e,
+	0x80, 0x7a, 0xca, 0x9c, 0x52, 0xaf, 0x15, 0x63, 0x3e, 0x69, 0x4f, 0x8a, 0xcf, 0x43, 0xcc, 0xc4,
+	0x2d, 0xdb, 0xa2, 0x8d, 0xfc, 0x72, 0x7e, 0x25, 0x6f, 0xd4, 0x62, 0x61, 0xc1, 0xa2, 0xfa, 0x27,
+	0x08, 0x96, 0x64, 0x72, 0xb1, 0x69, 0xfa, 0xcc, 0x3e, 0xea, 0x00, 0x7d, 0x1e, 0xe6, 0xfa, 0x21,
+	0x1f, 0x12, 0x6f, 0x56, 0xe0, 0xd5, 0x22, 0xa8, 0xf0, 0xd6, 0x8f, 0x11, 0x9c, 0xe2, 0xb9, 0xc4,
+	0x49, 0xe2, 0xf9, 0x37, 0x08, 0x16, 0x6e, 0x9a, 0xf4, 0x24, 0xb1, 0xfc, 0xdb, 0x20, 0x94, 0x47,
+	0x3c, 0x1f, 0x65, 0x88, 0xe2, 0x88, 0x49, 0xa6, 0xc3, 0xc3, 0x6b, 0x2e, 0xc1, 0x35, 0xd5, 0x7f,
+	0x37, 0x8a, 0xf9, 0x27, 0x8c, 0xf3, 0xdf, 0x23, 0x38, 0x7b, 0x83, 0xb0, 0x88, 0xeb, 0x63, 0x71,
+	0x36, 0x4c, 0xea, 0x2d, 0x1f, 0xc8, 0x93, 0x4d, 0xc9, 0xfc, 0x91, 0x9c, 0x20, 0xbf, 0x46, 0xb0,
+	0xc8, 0xc3, 0xef, 0xf1, 0x70, 0x82, 0x09, 0x72, 0x4f, 0xfd, 0xa7, 0xc1, 0x99, 0x17, 0xe7, 0x78,
+	0x1a, 0xd5, 0x29, 0x1c, 0x2f, 0xa7, 0x72, 0x3c, 0xce, 0x5c, 0x04, 0xd9, 0x58, 0x0f, 0xcf, 0x8a,
+	0x04, 0x4c, 0xff, 0x2e, 0x82, 0xa5, 0x30, 0xf3, 0xdd, 0x22, 0x9d, 0x1e, 0x71, 0xd9, 0xbd, 0xeb,
+	0x33, 0xad, 0x8d, 0x9c, 0x22, 0x67, 0x3d, 0x03, 0x15, 0x2a, 0xd7, 0x89, 0x92, 0xda, 0x11, 0x40,
+	0xff, 0x08, 0xc1, 0xe9, 0x7d, 0xec, 0x4c, 0xa3, 0xac, 0x06, 0x94, 0x6c, 0xd7, 0x22, 0x77, 0x23,
+	0x6e, 0xc2, 0x5f, 0x3e, 0xb2, 0x3d, 0xb0, 0x1d, 0x2b, 0x62, 0x23, 0xfc, 0xc5, 0xe7, 0x40, 0x23,
+	0xae, 0xb9, 0xed, 0x90, 0x96, 0xc0, 0x15, 0x46, 0x2d, 0x1b, 0x55, 0x09, 0xdb, 0xe0, 0x20, 0xfd,
+	0x7b, 0x08, 0x16, 0xb8, 0x4d, 0x03, 0x1e, 0xe9, 0x17, 0xab, 0xb3, 0x65, 0xa8, 0xc6, 0x8c, 0x16,
+	0xb0, 0x1b, 0x07, 0xe9, 0x3b, 0x70, 0x2a, 0xc9, 0xce, 0x34, 0x3a, 0x7b, 0x10, 0x20, 0xb2, 0x88,
+	0xf4, 0xad, 0xbc, 0x11, 0x83, 0xe8, 0x9f, 0x21, 0xc0, 0x32, 0xbd, 0x10, 0xca, 0x38, 0xe2, 0x4b,
+	0xf6, 0x1d, 0x9b, 0x38, 0x56, 0x3c, 0x82, 0x55, 0x04, 0x44, 0x0c, 0xaf, 0x83, 0x46, 0xee, 0x32,
+	0xdf, 0x6c, 0xf5, 0x4d, 0xdf, 0xec, 0xc9, 0x2b, 0xce, 0x44, 0xc1, 0xa6, 0x2a, 0xc8, 0x36, 0x05,
+	0x95, 0xfe, 0x47, 0x9e, 0x98, 0x04, 0x4e, 0x79, 0xdc, 0x25, 0x3e, 0x0b, 0x20, 0x9c, 0x56, 0x0e,
+	0x17, 0xe4, 0xb0, 0x80, 0x88, 0x70, 0xfe, 0x11, 0x82, 0xba, 0x10, 0x41, 0xca, 0xd3, 0xe7, 0xd3,
+	0xa6, 0x68, 0x50, 0x8a, 0x66, 0xcc, 0x16, 0xfa, 0x3f, 0x28, 0x06, 0x8a, 0xcd, 0x4f, 0xaa, 0xd8,
+	0x80, 0xe0, 0x00, 0x31, 0xf4, 0x5f, 0x20, 0x58, 0x4c, 0xa9, 0x7c, 0x1a, 0x8f, 0x7e, 0x03, 0xb0,
+	0x94, 0xd0, 0x1a, 0x89, 0x1d, 0x1e, 0x3d, 0xe7, 0x95, 0xf9, 0x7f, 0x5a, 0x49, 0xc6, 0x7d, 0x76,
+	0x0a, 0x42, 0xf5, 0xbf, 0x20, 0x38, 0x73, 0x83, 0x30, 0x81, 0x7a, 0x8d, 0xc7, 0x8e, 0x4d, 0xdf,
+	0xeb, 0xf8, 0x84, 0xd2, 0x93, 0xeb, 0x1f, 0x3f, 0x92, 0xb9, 0x8a, 0x4a, 0xa4, 0x69, 0xf4, 0x7f,
+	0x0e, 0x34, 0xb1, 0x06, 0xb1, 0x5a, 0xbe, 0xb7, 0x47, 0x03, 0x3f, 0xaa, 0x06, 0x30, 0xc3, 0xdb,
+	0x13, 0x0e, 0xc1, 0x3c, 0x66, 0x3a, 0x12, 0x21, 0x38, 0x18, 0x04, 0x84, 0x0f, 0x8b, 0x3d, 0x18,
+	0x32, 0xc6, 0x27, 0x27, 0x27, 0x57, 0xc7, 0xef, 0x21, 0x58, 0x4c, 0x89, 0x32, 0x8d, 0x6e, 0x9f,
+	0x96, 0x99, 0x94, 0x14, 0x66, 0x6e, 0xed, 0x21, 0x25, 0x4d, 0x6c, 0x31, 0x89, 0xad, 0x7f, 0x8a,
+	0xa0, 0xce, 0x6f, 0x5b, 0x27, 0x3c, 0xa0, 0xfd, 0x32, 0x07, 0xb5, 0x0d, 0x97, 0x12, 0x9f, 0x1d,
+	0xff, 0x64, 0x1a, 0xbf, 0x04, 0x55, 0x21, 0x18, 0x6d, 0x59, 0x26, 0x33, 0x83, 0xd3, 0xe8, 0x41,
+	0x65, 0x5d, 0xf0, 0x15, 0x8e, 0xb7, 0x6e, 0x32, 0xd3, 0x90, 0xda, 0xa1, 0xfc, 0x1b, 0x3f, 0x00,
+	0x95, 0xae, 0x49, 0xbb, 0xad, 0x1d, 0x32, 0xa4, 0x8d, 0xe2, 0x72, 0x7e, 0xa5, 0x66, 0x94, 0x39,
+	0xe0, 0x55, 0x32, 0xa4, 0xf8, 0x7e, 0x28, 0xbb, 0x83, 0x9e, 0xdc, 0x3f, 0xa5, 0x65, 0xb4, 0x52,
+	0x33, 0x4a, 0xee, 0xa0, 0x27, 0x76, 0xcf, 0x9f, 0x72, 0x30, 0x77, 0x7b, 0xc0, 0x53, 0x77, 0x51,
+	0xd5, 0x1c, 0x38, 0xec, 0xde, 0x7c, 0xed, 0x22, 0xe4, 0x65, 0x4a, 0xc0, 0x29, 0x1a, 0x4a, 0xc6,
+	0x37, 0xd6, 0xa9, 0xc1, 0x91, 0xc4, 0xcb, 0xc1, 0xa0, 0xdd, 0x0e, 0x72, 0xa8, 0xbc, 0x60, 0xb6,
+	0xc2, 0x21, 0xc2, 0xe3, 0xb8, 0x28, 0xc4, 0xf7, 0xa3, 0x0c, 0x4b, 0x88, 0x42, 0x7c, 0x5f, 0x0e,
+	0xea, 0xa0, 0x99, 0xed, 0x1d, 0xd7, 0xdb, 0x73, 0x88, 0xd5, 0x21, 0x96, 0x30, 0x7b, 0xd9, 0x48,
+	0xc0, 0xa4, 0x63, 0x70, 0xc3, 0xb7, 0xda, 0x2e, 0x6b, 0x14, 0x65, 0xc0, 0x90, 0x90, 0xeb, 0x2e,
+	0xe3, 0xc3, 0x16, 0x71, 0x08, 0x23, 0x62, 0xb8, 0x24, 0x87, 0x25, 0x24, 0x18, 0x1e, 0xf4, 0x23,
+	0xea, 0xb2, 0x1c, 0x96, 0x10, 0x3e, 0x7c, 0x06, 0x44, 0xbd, 0x48, 0x16, 0x90, 0x2a, 0xa3, 0x02,
+	0x92, 0x00, 0xe8, 0xbb, 0x50, 0xdf, 0x74, 0xcc, 0x36, 0xe9, 0x7a, 0x8e, 0x45, 0x7c, 0x71, 0xb8,
+	0xe1, 0x3a, 0xe4, 0x99, 0xd9, 0x09, 0x4e, 0x4f, 0xfe, 0x89, 0x9f, 0x0d, 0xca, 0x4c, 0x72, 0x5f,
+	0x3e, 0xa2, 0x3c, 0x66, 0x62, 0xd3, 0x8c, 0x4a, 0x4c, 0x78, 0x09, 0x8a, 0xa2, 0xd8, 0x2e, 0xcf,
+	0x55, 0xcd, 0x08, 0xfe, 0xf4, 0x77, 0x12, 0xeb, 0xde, 0xf0, 0xbd, 0x41, 0x1f, 0x6f, 0x80, 0xd6,
+	0x1f, 0xc1, 0xb8, 0x35, 0xb3, 0x0f, 0xb5, 0x34, 0xd3, 0x46, 0x82, 0x54, 0xff, 0x2c, 0x0f, 0xb5,
+	0x2d, 0x62, 0xfa, 0xed, 0xee, 0x49, 0xb8, 0x57, 0x73, 0x8d, 0x5b, 0xd4, 0x09, 0x42, 0x02, 0xff,
+	0xc4, 0x97, 0xe0, 0xbe, 0x98, 0x40, 0xad, 0x0e, 0x57, 0x90, 0xf0, 0x0c, 0xcd, 0xa8, 0xf7, 0xd3,
+	0x8a, 0x7b, 0x06, 0xca, 0x16, 0x75, 0x5a, 0xc2, 0x44, 0x25, 0x61, 0x22, 0xb5, 0x7c, 0xeb, 0xd4,
+	0x11, 0xa6, 0x29, 0x59, 0xf2, 0x03, 0x3f, 0x0c, 0x35, 0x6f, 0xc0, 0xfa, 0x03, 0xd6, 0x92, 0x3b,
+	0xb3, 0x51, 0x16, 0xec, 0x69, 0x12, 0x28, 0x36, 0x2e, 0xc5, 0xaf, 0x40, 0x8d, 0x0a, 0x55, 0x86,
+	0xa9, 0x67, 0x65, 0xd2, 0x0c, 0x49, 0x93, 0x74, 0x32, 0xf7, 0xc4, 0x17, 0xa0, 0xce, 0x7c, 0x73,
+	0x97, 0x38, 0xad, 0x91, 0x3f, 0x82, 0xf0, 0xc7, 0x79, 0x09, 0x7f, 0x23, 0x04, 0xe3, 0x55, 0x58,
+	0xe8, 0x0c, 0x4c, 0xdf, 0x74, 0x19, 0x21, 0x31, 0xec, 0xaa, 0xc0, 0xc6, 0xd1, 0x50, 0x44, 0xa0,
+	0xff, 0x3d, 0x07, 0xf3, 0x06, 0x61, 0xbe, 0x4d, 0x76, 0xc9, 0x89, 0xb0, 0xf8, 0x45, 0xc8, 0xdb,
+	0x16, 0x15, 0x16, 0x1f, 0x1b, 0x7e, 0x6c, 0x8b, 0xee, 0xb7, 0x52, 0x51, 0x61, 0x25, 0x95, 0x76,
+	0x4b, 0x87, 0xd2, 0x6e, 0x39, 0x53, 0xbb, 0x9f, 0xa0, 0xb8, 0x76, 0x79, 0xcc, 0xa5, 0xf7, 0x1c,
+	0x74, 0xb9, 0xd4, 0xb9, 0x49, 0xa4, 0x4e, 0x9d, 0x30, 0xf9, 0xc3, 0x9e, 0x30, 0xfa, 0xab, 0x30,
+	0x7b, 0xd3, 0x66, 0x62, 0x73, 0xf1, 0x48, 0x8f, 0xc4, 0xe5, 0x4f, 0xc4, 0xf3, 0xfb, 0xa1, 0xec,
+	0x7b, 0x7b, 0x72, 0xde, 0x9c, 0x08, 0x4b, 0x25, 0xdf, 0xdb, 0x13, 0xc7, 0x92, 0x78, 0x3c, 0xf6,
+	0xfc, 0x20, 0x5e, 0xe5, 0x8c, 0xe0, 0x4f, 0xff, 0x26, 0x1a, 0x05, 0x94, 0x29, 0x14, 0xf0, 0x12,
+	0x94, 0x7c, 0x49, 0x3f, 0xf6, 0x29, 0x2d, 0xbe, 0x92, 0x90, 0x2b, 0xa4, 0xd2, 0xdf, 0x47, 0xa0,
+	0xbd, 0xe2, 0x0c, 0xe8, 0x17, 0x11, 0xd7, 0x54, 0xd5, 0xfb, 0xbc, 0xb2, 0x7a, 0xaf, 0x7f, 0x3f,
+	0x07, 0xb5, 0x80, 0x8d, 0x69, 0x12, 0xbe, 0x4c, 0x56, 0xb6, 0xa0, 0xca, 0x97, 0x6c, 0x51, 0xd2,
+	0x09, 0xcb, 0x3d, 0xd5, 0xb5, 0x35, 0xe5, 0x49, 0x90, 0x60, 0x43, 0x3c, 0x42, 0x6e, 0x09, 0xa2,
+	0x2f, 0xb9, 0xcc, 0x1f, 0x1a, 0xd0, 0x8e, 0x00, 0xcd, 0x77, 0x60, 0x3e, 0x35, 0xcc, 0x7d, 0x63,
+	0x87, 0x0c, 0xc3, 0xa3, 0x6e, 0x87, 0x0c, 0xf1, 0x53, 0xf1, 0xa7, 0xe2, 0x2c, 0x87, 0xbb, 0xe5,
+	0xb9, 0x9d, 0xab, 0xbe, 0x6f, 0x0e, 0x83, 0xa7, 0xe4, 0xe7, 0x72, 0xcf, 0x22, 0xfd, 0x1f, 0x08,
+	0xb4, 0xd7, 0x07, 0xc4, 0x1f, 0x1e, 0x65, 0x00, 0xc2, 0x30, 0x4b, 0xee, 0xf6, 0xfd, 0x20, 0x69,
+	0x13, 0xdf, 0xfb, 0xe3, 0x47, 0x41, 0x11, 0x3f, 0x14, 0x91, 0xab, 0xa8, 0xac, 0x01, 0xbf, 0x3f,
+	0x12, 0x73, 0xaa, 0x8d, 0x90, 0xd8, 0xdd, 0xb9, 0x43, 0xef, 0xee, 0x8f, 0x11, 0x54, 0xde, 0x24,
+	0x6d, 0xe6, 0xf9, 0x7c, 0x47, 0x2b, 0xf4, 0x83, 0x26, 0x48, 0xd1, 0x73, 0xe9, 0x14, 0xfd, 0x0a,
+	0x94, 0x6d, 0xab, 0x65, 0x72, 0xd3, 0x0a, 0x05, 0x8f, 0x8b, 0x52, 0x25, 0xdb, 0x12, 0x3e, 0x30,
+	0x79, 0xf9, 0xfc, 0xc7, 0x08, 0x34, 0xc9, 0x33, 0x95, 0x94, 0xcf, 0xc7, 0x96, 0x43, 0x2a, 0x7f,
+	0x0b, 0x7e, 0x22, 0x41, 0x6f, 0xce, 0x8c, 0x96, 0xbd, 0x0a, 0xc0, 0x75, 0x17, 0x90, 0x4b, 0x77,
+	0x5d, 0x56, 0x72, 0x2b, 0xc9, 0x85, 0x1e, 0x6f, 0xce, 0x18, 0x15, 0x4e, 0x25, 0xa6, 0xb8, 0x56,
+	0x82, 0x82, 0xa0, 0xd6, 0xff, 0x8d, 0x60, 0xe1, 0xba, 0xe9, 0xb4, 0xd7, 0x6d, 0xca, 0x4c, 0xb7,
+	0x3d, 0xc5, 0x19, 0xfa, 0x1c, 0x94, 0xbc, 0x7e, 0xcb, 0x21, 0x77, 0x58, 0xc0, 0xd2, 0xb9, 0x31,
+	0x12, 0x49, 0x35, 0x18, 0x45, 0xaf, 0x7f, 0x8b, 0xdc, 0x61, 0xf8, 0x05, 0x28, 0x7b, 0xfd, 0x96,
+	0x6f, 0x77, 0xba, 0x2c, 0xd0, 0xfe, 0x04, 0xc4, 0x25, 0xaf, 0x6f, 0x70, 0x8a, 0x58, 0x09, 0x67,
+	0xf6, 0x90, 0x25, 0x1c, 0xfd, 0xaf, 0xfb, 0xc4, 0x9f, 0xc2, 0xb5, 0x9f, 0x83, 0xb2, 0xed, 0xb2,
+	0x96, 0x65, 0xd3, 0x50, 0x05, 0x67, 0xd5, 0x3e, 0xe4, 0x32, 0x21, 0x81, 0xb0, 0xa9, 0xcb, 0xf8,
+	0xda, 0xf8, 0x65, 0x80, 0x3b, 0x8e, 0x67, 0x06, 0xd4, 0x52, 0x07, 0x0f, 0xa9, 0x77, 0x05, 0x47,
+	0x0b, 0xe9, 0x2b, 0x82, 0x88, 0xcf, 0x30, 0x32, 0xe9, 0x9f, 0x11, 0x2c, 0x6e, 0x12, 0x9f, 0xda,
+	0x94, 0x11, 0x97, 0x05, 0xe5, 0xd4, 0x0d, 0xf7, 0x8e, 0x97, 0xac, 0x5b, 0xa3, 0x54, 0xdd, 0xfa,
+	0xf3, 0xa9, 0xe2, 0x26, 0x6e, 0x70, 0xf2, 0x25, 0x21, 0xbc, 0xc1, 0x85, 0xef, 0x25, 0xf2, 0x06,
+	0x3c, 0x97, 0x61, 0xa6, 0x80, 0xdf, 0xc4, 0x3d, 0xff, 0x07, 0xb2, 0x07, 0x40, 0x29, 0xd4, 0xbd,
+	0x3b, 0xec, 0x12, 0x04, 0x41, 0x36, 0x15, 0x72, 0xff, 0x07, 0x52, 0xb1, 0x23, 0xa3, 0x33, 0xe1,
+	0x27, 0x08, 0x96, 0xb3, 0xb9, 0x9a, 0xe6, 0x74, 0x7c, 0x19, 0x0a, 0xb6, 0x7b, 0xc7, 0x0b, 0xab,
+	0x7b, 0x17, 0xd5, 0x17, 0x21, 0xe5, 0xba, 0x92, 0x50, 0xff, 0x27, 0x82, 0xba, 0x88, 0xd5, 0x47,
+	0x60, 0xfe, 0x1e, 0xe9, 0xb5, 0xa8, 0xfd, 0x2e, 0x09, 0xcd, 0xdf, 0x23, 0xbd, 0x2d, 0xfb, 0x5d,
+	0x92, 0xf0, 0x8c, 0x42, 0xd2, 0x33, 0x92, 0x05, 0x92, 0xe2, 0x98, 0xea, 0x6d, 0x29, 0x51, 0xbd,
+	0xd5, 0x3f, 0x40, 0xd0, 0xbc, 0x41, 0x58, 0x5a, 0xd4, 0xa3, 0x73, 0x8a, 0x0f, 0x11, 0x3c, 0xa0,
+	0x64, 0x68, 0x1a, 0x7f, 0x78, 0x3e, 0xe9, 0x0f, 0xea, 0x8b, 0xf1, 0xbe, 0x25, 0x03, 0x57, 0x78,
+	0x12, 0xb4, 0xf5, 0x41, 0xaf, 0x17, 0x25, 0x27, 0xe7, 0x40, 0xf3, 0xe5, 0xa7, 0xbc, 0x37, 0xca,
+	0xe3, 0xb2, 0x1a, 0xc0, 0xf8, 0xed, 0x50, 0xbf, 0x04, 0xb5, 0x80, 0x24, 0xe0, 0xba, 0x09, 0x65,
+	0x3f, 0xf8, 0x0e, 0xf0, 0xa3, 0x7f, 0x7d, 0x11, 0x16, 0x0c, 0xd2, 0xe1, 0x9e, 0xe8, 0xdf, 0xb2,
+	0xdd, 0x9d, 0x60, 0x19, 0xfd, 0x3d, 0x04, 0xa7, 0x92, 0xf0, 0x60, 0xae, 0xff, 0x85, 0x92, 0x69,
+	0x59, 0x3e, 0xa1, 0x74, 0xac, 0x59, 0xae, 0x4a, 0x1c, 0x23, 0x44, 0x8e, 0x69, 0x2e, 0x37, 0xb1,
+	0xe6, 0x2e, 0x3e, 0x26, 0x9f, 0xb8, 0x52, 0x5d, 0x30, 0xb8, 0x04, 0xf9, 0xab, 0x8e, 0x53, 0x9f,
+	0xc1, 0x1a, 0x94, 0x37, 0xdc, 0xdb, 0xa4, 0xe7, 0xf9, 0xc3, 0x3a, 0xba, 0xf8, 0xff, 0x30, 0x9f,
+	0x2a, 0x66, 0xe0, 0x32, 0xcc, 0xbe, 0xe6, 0xb9, 0xa4, 0x3e, 0x83, 0xeb, 0xa0, 0x5d, 0xb3, 0x5d,
+	0xd3, 0x1f, 0xca, 0x43, 0xa8, 0x6e, 0xe1, 0x79, 0xa8, 0x8a, 0x60, 0x1c, 0x00, 0xc8, 0xda, 0xbf,
+	0x4e, 0x43, 0xed, 0xb6, 0x60, 0x6a, 0x8b, 0xf8, 0xbb, 0x76, 0x9b, 0xe0, 0x16, 0xd4, 0xd3, 0x1d,
+	0xb2, 0xf8, 0x31, 0xa5, 0xf9, 0x32, 0x1a, 0x69, 0x9b, 0xe3, 0xc4, 0xd4, 0x67, 0xf0, 0xdb, 0x30,
+	0x97, 0xec, 0x5d, 0xc5, 0xea, 0x68, 0xa1, 0x6c, 0x70, 0x3d, 0x68, 0xf2, 0x16, 0xd4, 0x12, 0xad,
+	0xa8, 0xf8, 0x82, 0x72, 0x6e, 0x55, 0xbb, 0x6a, 0x53, 0x7d, 0x80, 0xc7, 0xdb, 0x45, 0x25, 0xf7,
+	0xc9, 0x8e, 0xbc, 0x0c, 0xee, 0x95, 0x6d, 0x7b, 0x07, 0x71, 0x6f, 0xc2, 0x7d, 0xfb, 0x1a, 0xec,
+	0xf0, 0xe3, 0xca, 0xf9, 0xb3, 0x1a, 0xf1, 0x0e, 0x5a, 0x62, 0x0f, 0xf0, 0xfe, 0x96, 0x4b, 0x7c,
+	0x59, 0x6d, 0x81, 0xac, 0x86, 0xd3, 0xe6, 0xea, 0xc4, 0xf8, 0x91, 0xe2, 0xbe, 0x85, 0xe0, 0x74,
+	0x46, 0x57, 0x1c, 0xbe, 0xa2, 0x9c, 0x6e, 0x7c, 0x6b, 0x5f, 0xf3, 0xa9, 0xc3, 0x11, 0x45, 0x8c,
+	0xb8, 0x30, 0x9f, 0xda, 0x60, 0xf8, 0xd2, 0x24, 0xcd, 0x68, 0xe1, 0xba, 0x8f, 0x4d, 0x86, 0x1c,
+	0xad, 0xc7, 0xaf, 0x72, 0xc9, 0xae, 0xb0, 0x8c, 0xf5, 0xd4, 0xbd, 0x63, 0x07, 0x19, 0xf4, 0x2d,
+	0xa8, 0x25, 0xda, 0xb7, 0x32, 0x3c, 0x5e, 0xd5, 0xe2, 0x75, 0xd0, 0xd4, 0xef, 0x80, 0x16, 0xef,
+	0xb2, 0xc2, 0x2b, 0x59, 0x7b, 0x69, 0xdf, 0xc4, 0x87, 0xd9, 0x4a, 0xa3, 0x06, 0x8d, 0x31, 0x5b,
+	0x69, 0x5f, 0xdf, 0xc9, 0xe4, 0x5b, 0x29, 0x36, 0xff, 0xd8, 0xad, 0x74, 0xe8, 0x25, 0xde, 0x43,
+	0xb0, 0xa4, 0x6e, 0xd2, 0xc1, 0x6b, 0x59, 0xbe, 0x99, 0xdd, 0x8e, 0xd4, 0xbc, 0x72, 0x28, 0x9a,
+	0x48, 0x8b, 0x3b, 0x30, 0x97, 0x6c, 0x73, 0xc9, 0xd0, 0xa2, 0xb2, 0x7b, 0xa7, 0x79, 0x69, 0x22,
+	0xdc, 0x68, 0xb1, 0xaf, 0x40, 0x35, 0xd6, 0x82, 0x80, 0x1f, 0x1d, 0xe3, 0xc7, 0xf1, 0x17, 0xae,
+	0x83, 0x34, 0xd9, 0x85, 0x5a, 0xe2, 0xd9, 0x39, 0xcb, 0x87, 0x15, 0xdd, 0x00, 0xcd, 0x8b, 0x93,
+	0xa0, 0x46, 0x02, 0x74, 0xa1, 0x96, 0x78, 0x04, 0xcc, 0x58, 0x49, 0xf5, 0xe6, 0x99, 0xb1, 0x92,
+	0xf2, 0x4d, 0x51, 0x9f, 0xc1, 0xdf, 0x88, 0xbd, 0x37, 0x26, 0xde, 0x74, 0xf1, 0x93, 0x63, 0xe7,
+	0x51, 0x3d, 0x69, 0x37, 0xd7, 0x0e, 0x43, 0x12, 0xb1, 0xf0, 0x3a, 0x54, 0xa2, 0xb7, 0x46, 0x7c,
+	0x3e, 0x33, 0x2c, 0x1c, 0xc6, 0x52, 0x5b, 0x50, 0x94, 0xef, 0x7e, 0x58, 0xcf, 0x78, 0xc0, 0x8f,
+	0x3d, 0x0a, 0x36, 0x1f, 0x56, 0xe2, 0x24, 0x9f, 0xc4, 0xf4, 0x19, 0x6c, 0x40, 0x51, 0x56, 0x11,
+	0x33, 0x26, 0x4d, 0xbc, 0x8e, 0x34, 0xc7, 0xe3, 0xc8, 0xd2, 0xe3, 0x0c, 0xfe, 0x2a, 0x94, 0xc3,
+	0x32, 0x30, 0x7e, 0x24, 0x63, 0xdb, 0x27, 0x6a, 0xf0, 0xcd, 0x83, 0xb0, 0xc2, 0x99, 0x37, 0xa1,
+	0x20, 0xea, 0x78, 0xf8, 0xdc, 0xb8, 0x1a, 0xdf, 0x38, 0x5e, 0x13, 0x65, 0x40, 0x7d, 0x06, 0x7f,
+	0x19, 0x0a, 0x22, 0x15, 0xce, 0x98, 0x31, 0x5e, 0xa8, 0x6b, 0x8e, 0x45, 0x09, 0x59, 0xb4, 0x40,
+	0x8b, 0x97, 0x08, 0x32, 0x02, 0xb7, 0xa2, 0x88, 0xd2, 0x9c, 0x04, 0x33, 0x5c, 0xe5, 0xdb, 0x08,
+	0x1a, 0x59, 0xb7, 0x49, 0x9c, 0x79, 0x3a, 0x8f, 0xbb, 0x12, 0x37, 0x9f, 0x3e, 0x24, 0x55, 0xa4,
+	0xc2, 0x77, 0x61, 0x41, 0x71, 0x87, 0xc1, 0xab, 0x59, 0xf3, 0x65, 0x5c, 0xbf, 0x9a, 0x4f, 0x4c,
+	0x4e, 0x10, 0xad, 0xbd, 0x09, 0x05, 0x71, 0xf7, 0xc8, 0x30, 0x5f, 0xfc, 0x2a, 0x93, 0xe1, 0x10,
+	0x89, 0xab, 0x8b, 0x3e, 0x83, 0x09, 0x68, 0xf1, 0x8b, 0x48, 0x86, 0xfd, 0x14, 0x77, 0x98, 0xe6,
+	0x85, 0x09, 0x30, 0xc3, 0x65, 0xd6, 0x06, 0xa0, 0x6d, 0xfa, 0xde, 0xdd, 0x61, 0x98, 0xfa, 0xff,
+	0x77, 0x96, 0xbd, 0xf6, 0xe2, 0xd7, 0x9e, 0xef, 0xd8, 0xac, 0x3b, 0xd8, 0xe6, 0xd1, 0x65, 0x55,
+	0xe2, 0x3e, 0x6e, 0x7b, 0xe1, 0x17, 0xb5, 0x76, 0x1e, 0xef, 0x78, 0xab, 0xbb, 0x6b, 0xab, 0xb6,
+	0xcb, 0x88, 0xef, 0x9a, 0xce, 0xaa, 0x98, 0x75, 0x95, 0x12, 0x7f, 0x97, 0xf8, 0xdb, 0x45, 0xf1,
+	0x77, 0xe5, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9b, 0x0b, 0x74, 0x8e, 0x0b, 0x38, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3849,6 +4163,7 @@ type MilvusServiceClient interface {
 	Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveResults, error)
 	Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*FlushResponse, error)
 	Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResults, error)
+	CalcDistance(ctx context.Context, in *CalcDistanceRequest, opts ...grpc.CallOption) (*CalcDistanceResults, error)
 	GetPersistentSegmentInfo(ctx context.Context, in *GetPersistentSegmentInfoRequest, opts ...grpc.CallOption) (*GetPersistentSegmentInfoResponse, error)
 	GetQuerySegmentInfo(ctx context.Context, in *GetQuerySegmentInfoRequest, opts ...grpc.CallOption) (*GetQuerySegmentInfoResponse, error)
 	Dummy(ctx context.Context, in *DummyRequest, opts ...grpc.CallOption) (*DummyResponse, error)
@@ -4089,6 +4404,15 @@ func (c *milvusServiceClient) Query(ctx context.Context, in *QueryRequest, opts
 	return out, nil
 }
 
+func (c *milvusServiceClient) CalcDistance(ctx context.Context, in *CalcDistanceRequest, opts ...grpc.CallOption) (*CalcDistanceResults, error) {
+	out := new(CalcDistanceResults)
+	err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/CalcDistance", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *milvusServiceClient) GetPersistentSegmentInfo(ctx context.Context, in *GetPersistentSegmentInfoRequest, opts ...grpc.CallOption) (*GetPersistentSegmentInfoResponse, error) {
 	out := new(GetPersistentSegmentInfoResponse)
 	err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/GetPersistentSegmentInfo", in, out, opts...)
@@ -4152,6 +4476,7 @@ type MilvusServiceServer interface {
 	Retrieve(context.Context, *RetrieveRequest) (*RetrieveResults, error)
 	Flush(context.Context, *FlushRequest) (*FlushResponse, error)
 	Query(context.Context, *QueryRequest) (*QueryResults, error)
+	CalcDistance(context.Context, *CalcDistanceRequest) (*CalcDistanceResults, error)
 	GetPersistentSegmentInfo(context.Context, *GetPersistentSegmentInfoRequest) (*GetPersistentSegmentInfoResponse, error)
 	GetQuerySegmentInfo(context.Context, *GetQuerySegmentInfoRequest) (*GetQuerySegmentInfoResponse, error)
 	Dummy(context.Context, *DummyRequest) (*DummyResponse, error)
@@ -4238,6 +4563,9 @@ func (*UnimplementedMilvusServiceServer) Flush(ctx context.Context, req *FlushRe
 func (*UnimplementedMilvusServiceServer) Query(ctx context.Context, req *QueryRequest) (*QueryResults, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Query not implemented")
 }
+func (*UnimplementedMilvusServiceServer) CalcDistance(ctx context.Context, req *CalcDistanceRequest) (*CalcDistanceResults, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CalcDistance not implemented")
+}
 func (*UnimplementedMilvusServiceServer) GetPersistentSegmentInfo(ctx context.Context, req *GetPersistentSegmentInfoRequest) (*GetPersistentSegmentInfoResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetPersistentSegmentInfo not implemented")
 }
@@ -4705,6 +5033,24 @@ func _MilvusService_Query_Handler(srv interface{}, ctx context.Context, dec func
 	return interceptor(ctx, in, info, handler)
 }
 
+func _MilvusService_CalcDistance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CalcDistanceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MilvusServiceServer).CalcDistance(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.milvus.MilvusService/CalcDistance",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MilvusServiceServer).CalcDistance(ctx, req.(*CalcDistanceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _MilvusService_GetPersistentSegmentInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(GetPersistentSegmentInfoRequest)
 	if err := dec(in); err != nil {
@@ -4881,6 +5227,10 @@ var _MilvusService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "Query",
 			Handler:    _MilvusService_Query_Handler,
 		},
+		{
+			MethodName: "CalcDistance",
+			Handler:    _MilvusService_CalcDistance_Handler,
+		},
 		{
 			MethodName: "GetPersistentSegmentInfo",
 			Handler:    _MilvusService_GetPersistentSegmentInfo_Handler,


Test patch:
diff --git a/client/client_mock_test.go b/client/client_mock_test.go
index 63e257f..fc50737 100644
--- a/client/client_mock_test.go
+++ b/client/client_mock_test.go
@@ -424,3 +424,10 @@ func (m *mockServer) Dummy(_ context.Context, _ *server.DummyRequest) (*server.D
 func (m *mockServer) RegisterLink(_ context.Context, _ *server.RegisterLinkRequest) (*server.RegisterLinkResponse, error) {
 	panic("not implemented") // TODO: Implement
 }
+
+func (m *mockServer) CalcDistance(_ context.Context, req *server.CalcDistanceRequest) (*server.CalcDistanceResults, error) {
+	resp := &server.CalcDistanceResults{}
+	s, err := successStatus()
+	resp.Status = s
+	return resp, err
+}
diff --git a/tests/client_collection_test.go b/tests/client_collection_test.go
index a84a573..44f031f 100644
--- a/tests/client_collection_test.go
+++ b/tests/client_collection_test.go
@@ -42,7 +42,7 @@ func TestCreateCollection(t *testing.T) {
 		defer c.Close()
 	}
 
-	schema := entity.Schema{
+	schema := &entity.Schema{
 		CollectionName: "test_go_sdk",
 		AutoID:         false,
 		Fields: []*entity.Field{
diff --git a/tests/client_dm_test.go b/tests/client_dm_test.go
index 4258a9e..23ca976 100644
--- a/tests/client_dm_test.go
+++ b/tests/client_dm_test.go
@@ -20,10 +20,9 @@ func TestSearch(t *testing.T) {
 
 	waitRowCountChanged(t, c)
 	c.LoadCollection(context.Background(), testCollectionName, false)
+	sp, _ := entity.NewIndexFlatSearchParam(10)
 	results, err := c.Search(context.Background(), testCollectionName, []string{}, "int64 > 0", []string{"int64"}, []entity.Vector{entity.FloatVector(vectors[0])},
-		testVectorField, entity.L2, 10, map[string]string{
-			"nprobe": "10",
-		})
+		testVectorField, entity.L2, 10, sp)
 
 	assert.Nil(t, err)
 	for _, result := range results {
diff --git a/tests/client_index_test.go b/tests/client_index_test.go
index a9f2739..e152518 100644
--- a/tests/client_index_test.go
+++ b/tests/client_index_test.go
@@ -21,7 +21,7 @@ func TestCreateIndex(t *testing.T) {
 		"nlist":       "1024",
 		"metric_type": "IP",
 	})
-	err = c.CreateIndex(context.Background(), "test_go_sdk", "vector", idx)
+	err = c.CreateIndex(context.Background(), "test_go_sdk", "vector", idx, false)
 	assert.Nil(t, err)
 	indexes, err := c.DescribeIndex(context.Background(), "test_go_sdk", "vector")
 	if assert.Nil(t, err) {
diff --git a/tests/util.go b/tests/util.go
index 7217f7a..c6a3ab2 100644
--- a/tests/util.go
+++ b/tests/util.go
@@ -57,8 +57,8 @@ func generateTestCollection(t *testing.T, c client.Client) [][]float32 {
 	return vector
 }
 
-func defaultSchema() entity.Schema {
-	return entity.Schema{
+func defaultSchema() *entity.Schema {
+	return &entity.Schema{
 		CollectionName: testCollectionName,
 		AutoID:         false,
 		Fields: []*entity.Field{