milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Drop segment indexes when drop partition (#19022) 

Signed-off-by: cai.zhang <cai.zhang@zilliz.com>

Signed-off-by: cai.zhang <cai.zhang@zilliz.com>
pull/19390/head
cai.zhang 2022-09-23 09:36:51 +08:00 committed by GitHub
parent 5f02f0975c
commit 17f5e3c7fe
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 376 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
internal/distributed/indexcoord/client/client_test.go
View File

@ -163,7 +163,6 @@ func TestIndexCoordClient(t *testing.T) {
req := &indexpb.DropIndexRequest{
CollectionID: 0,
IndexName: "default",
FieldID: 0,
}
resp, err := icc.DropIndex(ctx, req)
assert.NoError(t, err)

1
internal/distributed/indexcoord/service_test.go
View File

@ -132,7 +132,6 @@ func TestIndexCoordinateServer(t *testing.T) {
req := &indexpb.DropIndexRequest{
CollectionID: 0,
IndexName: "default",
FieldID: 0,
}
resp, err := server.DropIndex(ctx, req)
assert.NoError(t, err)

34
internal/indexcoord/flushed_segment_watcher_test.go
View File

@ -487,3 +487,37 @@ func Test_flushSegmentWatcher_prepare_error(t *testing.T) {
assert.ErrorIs(t, err, ErrSegmentNotFound)
})
}
func Test_flushSegmentWatcher_removeFlushedSegment(t *testing.T) {
task := &internalTask{
state: indexTaskDone,
segmentInfo: &datapb.SegmentInfo{
ID: segID,
CollectionID: collID,
PartitionID: partID,
},
}
t.Run("success", func(t *testing.T) {
fsw := &flushedSegmentWatcher{
kvClient: &mockETCDKV{
removeWithPrefix: func(key string) error {
return nil
},
},
}
err := fsw.removeFlushedSegment(task)
assert.NoError(t, err)
})
t.Run("fail", func(t *testing.T) {
fsw := &flushedSegmentWatcher{
kvClient: &mockETCDKV{
removeWithPrefix: func(key string) error {
return errors.New("error")
},
},
}
err := fsw.removeFlushedSegment(task)
assert.Error(t, err)
})
}

10
internal/indexcoord/garbage_collector.go
View File

@ -22,13 +22,13 @@ import (
"sync"
"time"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"go.uber.org/zap"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/internal/common"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/metastore/model"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/storage"
)
@ -158,7 +158,9 @@ func (gc *garbageCollector) recycleSegIndexesMeta() {
if _, ok := flushedSegments[segID]; !ok {
log.Debug("segment is already not exist, mark it deleted", zap.Int64("collID", collID),
zap.Int64("segID", segID))
if err := gc.metaTable.MarkSegmentsIndexAsDeleted([]int64{segID}); err != nil {
if err := gc.metaTable.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
return segIndex.SegmentID == segID
}); err != nil {
continue
}
}

36
internal/indexcoord/index_coord.go
View File

@ -614,7 +614,7 @@ func (i *IndexCoord) GetIndexBuildProgress(ctx context.Context, req *indexpb.Get
// index tasks.
func (i *IndexCoord) DropIndex(ctx context.Context, req *indexpb.DropIndexRequest) (*commonpb.Status, error) {
log.Info("IndexCoord DropIndex", zap.Int64("collectionID", req.CollectionID),
zap.Int64("fieldID", req.FieldID), zap.String("indexName", req.IndexName))
zap.Int64s("partitionIDs", req.PartitionIDs), zap.String("indexName", req.IndexName))
if !i.isHealthy() {
log.Warn(msgIndexCoordIsUnhealthy(i.serverID))
return &commonpb.Status{
@ -636,15 +636,37 @@ func (i *IndexCoord) DropIndex(ctx context.Context, req *indexpb.DropIndexReques
for indexID := range indexID2CreateTs {
indexIDs = append(indexIDs, indexID)
}
err := i.metaTable.MarkIndexAsDeleted(req.CollectionID, indexIDs)
if err != nil {
ret.ErrorCode = commonpb.ErrorCode_UnexpectedError
ret.Reason = err.Error()
return ret, nil
if len(req.GetPartitionIDs()) == 0 {
// drop collection index
err := i.metaTable.MarkIndexAsDeleted(req.CollectionID, indexIDs)
if err != nil {
log.Error("IndexCoord drop index fail", zap.Int64("collectionID", req.CollectionID),
zap.String("indexName", req.IndexName), zap.Error(err))
ret.ErrorCode = commonpb.ErrorCode_UnexpectedError
ret.Reason = err.Error()
return ret, nil
}
} else {
err := i.metaTable.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
for _, partitionID := range req.PartitionIDs {
if segIndex.CollectionID == req.CollectionID && segIndex.PartitionID == partitionID {
return true
}
}
return false
})
if err != nil {
log.Error("IndexCoord drop index fail", zap.Int64("collectionID", req.CollectionID),
zap.Int64s("partitionIDs", req.PartitionIDs), zap.String("indexName", req.IndexName), zap.Error(err))
ret.ErrorCode = commonpb.ErrorCode_UnexpectedError
ret.Reason = err.Error()
return ret, nil
}
}
log.Info("IndexCoord DropIndex success", zap.Int64("collID", req.CollectionID),
zap.String("indexName", req.IndexName), zap.Int64s("indexIDs", indexIDs))
zap.Int64s("partitionIDs", req.PartitionIDs), zap.String("indexName", req.IndexName),
zap.Int64s("indexIDs", indexIDs))
return ret, nil
}

79
internal/indexcoord/index_coord_test.go
View File

@ -31,6 +31,7 @@ import (
"github.com/milvus-io/milvus/internal/common"
"github.com/milvus-io/milvus/internal/indexnode"
etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
"github.com/milvus-io/milvus/internal/metastore/kv/indexcoord"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
@ -251,8 +252,8 @@ func TestIndexCoord(t *testing.T) {
t.Run("DropIndex", func(t *testing.T) {
req := &indexpb.DropIndexRequest{
CollectionID: collID,
PartitionIDs: nil,
IndexName: indexName,
FieldID: fieldID,
}
resp, err := ic.DropIndex(ctx, req)
assert.NoError(t, err)
@ -366,7 +367,6 @@ func TestIndexCoord_UnHealthy(t *testing.T) {
req := &indexpb.DropIndexRequest{
CollectionID: collID,
IndexName: indexName,
FieldID: fieldID,
}
resp, err := ic.DropIndex(ctx, req)
assert.NoError(t, err)
@ -398,6 +398,81 @@ func TestIndexCoord_UnHealthy(t *testing.T) {
}
func TestIndexCoord_DropIndex(t *testing.T) {
t.Run("success", func(t *testing.T) {
ic := &IndexCoord{
metaTable: constructMetaTable(&indexcoord.Catalog{
Txn: &mockETCDKV{
multiSave: func(m map[string]string) error {
return nil
},
},
}),
}
ic.UpdateStateCode(internalpb.StateCode_Healthy)
resp, err := ic.DropIndex(context.Background(), &indexpb.DropIndexRequest{
CollectionID: collID,
PartitionIDs: []int64{partID},
IndexName: indexName,
})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
resp, err = ic.DropIndex(context.Background(), &indexpb.DropIndexRequest{
CollectionID: collID,
PartitionIDs: []int64{partID},
IndexName: indexName,
})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
resp, err = ic.DropIndex(context.Background(), &indexpb.DropIndexRequest{
CollectionID: collID,
PartitionIDs: nil,
IndexName: indexName,
})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
resp, err = ic.DropIndex(context.Background(), &indexpb.DropIndexRequest{
CollectionID: collID,
PartitionIDs: nil,
IndexName: indexName,
})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
})
t.Run("fail", func(t *testing.T) {
ic := &IndexCoord{
metaTable: constructMetaTable(&indexcoord.Catalog{
Txn: &mockETCDKV{
multiSave: func(m map[string]string) error {
return errors.New("error")
},
},
}),
}
ic.UpdateStateCode(internalpb.StateCode_Healthy)
resp, err := ic.DropIndex(context.Background(), &indexpb.DropIndexRequest{
CollectionID: collID,
PartitionIDs: []int64{partID},
IndexName: indexName,
})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode())
resp, err = ic.DropIndex(context.Background(), &indexpb.DropIndexRequest{
CollectionID: collID,
PartitionIDs: nil,
IndexName: indexName,
})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode())
})
}
// TODO @xiaocai2333: add ut for error occurred.
//func TestIndexCoord_watchNodeLoop(t *testing.T) {

35
internal/indexcoord/meta_table.go
View File

@ -699,13 +699,16 @@ func (mt *metaTable) MarkIndexAsDeleted(collID UniqueID, indexIDs []UniqueID) er
indexes := make([]*model.Index, 0)
for _, indexID := range indexIDs {
index, ok := fieldIndexes[indexID]
if !ok {
if !ok || index.IsDeleted {
continue
}
clonedIndex := model.CloneIndex(index)
clonedIndex.IsDeleted = true
indexes = append(indexes, clonedIndex)
}
if len(indexes) == 0 {
return nil
}
err := mt.alterIndexes(indexes)
if err != nil {
log.Error("IndexCoord metaTable MarkIndexAsDeleted fail", zap.Int64("collID", collID),
@ -718,38 +721,32 @@ func (mt *metaTable) MarkIndexAsDeleted(collID UniqueID, indexIDs []UniqueID) er
}
// MarkSegmentsIndexAsDeleted will mark the index on the segment corresponding the buildID as deleted, and recycleUnusedSegIndexes will recycle these tasks.
func (mt *metaTable) MarkSegmentsIndexAsDeleted(segIDs []UniqueID) error {
log.Info("IndexCoord metaTable MarkSegmentsIndexAsDeleted", zap.Int64s("segIDs", segIDs))
func (mt *metaTable) MarkSegmentsIndexAsDeleted(selector func(index *model.SegmentIndex) bool) error {
mt.segmentIndexLock.Lock()
defer mt.segmentIndexLock.Unlock()
buildIDs := make([]UniqueID, 0)
segIdxes := make([]*model.SegmentIndex, 0)
for _, segID := range segIDs {
if segIndexes, ok := mt.segmentIndexes[segID]; ok {
for _, segIdx := range segIndexes {
if segIdx.IsDeleted {
continue
}
clonedSegIdx := model.CloneSegmentIndex(segIdx)
clonedSegIdx.IsDeleted = true
segIdxes = append(segIdxes, clonedSegIdx)
buildIDs = append(buildIDs, segIdx.BuildID)
}
for _, segIdx := range mt.buildID2SegmentIndex {
if segIdx.IsDeleted {
continue
}
if selector(segIdx) {
clonedSegIdx := model.CloneSegmentIndex(segIdx)
clonedSegIdx.IsDeleted = true
segIdxes = append(segIdxes, clonedSegIdx)
buildIDs = append(buildIDs, segIdx.BuildID)
}
}
if len(segIdxes) == 0 {
log.Debug("IndexCoord metaTable MarkSegmentsIndexAsDeleted success, already have deleted",
zap.Int64s("segIDs", segIDs))
log.Debug("IndexCoord metaTable MarkSegmentsIndexAsDeleted success, no segment index need to mark")
return nil
}
err := mt.alterSegmentIndexes(segIdxes)
if err != nil {
log.Error("IndexCoord metaTable MarkSegmentsIndexAsDeleted fail", zap.Int64s("segIDs", segIDs), zap.Error(err))
return err
}
log.Info("IndexCoord metaTable MarkSegmentsIndexAsDeleted success", zap.Int64s("segIDs", segIDs))
return nil
}

40
internal/indexcoord/meta_table_test.go
View File

@ -362,7 +362,9 @@ func TestMetaTable_UpdateVersion(t *testing.T) {
err = mt.UpdateVersion(newBuildID, nodeID)
assert.Error(t, err)
err = mt.MarkSegmentsIndexAsDeleted([]int64{segID})
err = mt.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
return segIndex.SegmentID == segID
})
assert.NoError(t, err)
err = mt.UpdateVersion(newBuildID, nodeID)
@ -432,7 +434,9 @@ func TestMetaTable_BuildIndex(t *testing.T) {
err = mt.BuildIndex(buildID)
assert.Error(t, err)
err = mt.MarkSegmentsIndexAsDeleted([]int64{segID})
err = mt.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
return segIndex.SegmentID == segID
})
assert.NoError(t, err)
err = mt.BuildIndex(newBuildID)
@ -694,13 +698,19 @@ func TestMetaTable_MarkSegmentsIndexAsDeleted(t *testing.T) {
},
})
err := mt.MarkSegmentsIndexAsDeleted([]int64{segID})
err := mt.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
return segIndex.SegmentID == segID
})
assert.NoError(t, err)
err = mt.MarkSegmentsIndexAsDeleted([]int64{segID})
err = mt.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
return segIndex.SegmentID == segID
})
assert.NoError(t, err)
err = mt.MarkSegmentsIndexAsDeleted([]int64{segID + 1})
err = mt.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
return segIndex.SegmentID == segID+1
})
assert.NoError(t, err)
})
@ -713,7 +723,9 @@ func TestMetaTable_MarkSegmentsIndexAsDeleted(t *testing.T) {
},
})
err := mt.MarkSegmentsIndexAsDeleted([]int64{segID})
err := mt.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
return segIndex.SegmentID == segID
})
assert.Error(t, err)
})
}
@ -825,6 +837,10 @@ func TestMetaTable_IsIndexDeleted(t *testing.T) {
err := mt.MarkIndexAsDeleted(collID, []int64{indexID})
assert.NoError(t, err)
err = mt.MarkIndexAsDeleted(collID, []int64{indexID})
assert.NoError(t, err)
deleted = mt.IsIndexDeleted(collID, indexID)
assert.True(t, deleted)
@ -847,7 +863,9 @@ func TestMetaTable_IsSegIndexDeleted(t *testing.T) {
deleted := mt.IsSegIndexDeleted(buildID)
assert.False(t, deleted)
err := mt.MarkSegmentsIndexAsDeleted([]int64{segID})
err := mt.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
return segIndex.SegmentID == segID
})
assert.NoError(t, err)
deleted = mt.IsSegIndexDeleted(buildID)
assert.True(t, deleted)
@ -882,7 +900,9 @@ func TestMetaTable_GetMetasByNodeID(t *testing.T) {
segIdxes := mt.GetMetasByNodeID(nodeID)
assert.Equal(t, 1, len(segIdxes))
err = mt.MarkSegmentsIndexAsDeleted([]int64{segID + 1})
err = mt.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
return segIndex.SegmentID == segID+1
})
assert.NoError(t, err)
segIdxes = mt.GetMetasByNodeID(nodeID)
@ -900,7 +920,9 @@ func TestMetaTable_GetAllSegIndexes(t *testing.T) {
segIdxes := mt.GetAllSegIndexes()
assert.Equal(t, 1, len(segIdxes))
err := mt.MarkSegmentsIndexAsDeleted([]int64{segID})
err := mt.MarkSegmentsIndexAsDeleted(func(segIndex *model.SegmentIndex) bool {
return segIndex.SegmentID == segID
})
assert.NoError(t, err)
segIdxes = mt.GetAllSegIndexes()

2
internal/proto/index_coord.proto
View File

@ -150,8 +150,8 @@ message GetIndexInfoResponse {
message DropIndexRequest {
int64 collectionID = 1;
repeated int64 partitionIDs = 2;
string index_name = 3;
int64 fieldID = 2;
}
message DescribeIndexRequest {

274
internal/proto/indexpb/index_coord.pb.go
View File

@ -1022,8 +1022,8 @@ func (m *GetIndexInfoResponse) GetSegmentInfo() map[int64]*SegmentInfo {
type DropIndexRequest struct {
CollectionID int64 `protobuf:"varint,1,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
PartitionIDs []int64 `protobuf:"varint,2,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
IndexName string `protobuf:"bytes,3,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
FieldID int64 `protobuf:"varint,2,opt,name=fieldID,proto3" json:"fieldID,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1061,6 +1061,13 @@ func (m *DropIndexRequest) GetCollectionID() int64 {
return 0
}
func (m *DropIndexRequest) GetPartitionIDs() []int64 {
if m != nil {
return m.PartitionIDs
}
return nil
}
func (m *DropIndexRequest) GetIndexName() string {
if m != nil {
return m.IndexName
@ -1068,13 +1075,6 @@ func (m *DropIndexRequest) GetIndexName() string {
return ""
}
func (m *DropIndexRequest) GetFieldID() int64 {
if m != nil {
return m.FieldID
}
return 0
}
type DescribeIndexRequest struct {
CollectionID int64 `protobuf:"varint,1,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
IndexName string `protobuf:"bytes,2,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
@ -1938,135 +1938,135 @@ func init() {
func init() { proto.RegisterFile("index_coord.proto", fileDescriptor_f9e019eb3fda53c2) }
var fileDescriptor_f9e019eb3fda53c2 = []byte{
// 2036 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0xdd, 0x6e, 0xdb, 0xc8,
0x15, 0x36, 0x25, 0xff, 0x88, 0x47, 0x92, 0xed, 0x4c, 0xb2, 0x85, 0x56, 0x49, 0x1a, 0x9b, 0x69,
0x12, 0xb5, 0xc0, 0xda, 0xa9, 0xb7, 0x2d, 0xb6, 0x45, 0x5b, 0xc0, 0x3f, 0x9b, 0xac, 0x9c, 0xb5,
0xe1, 0x52, 0xc1, 0x02, 0x5d, 0x14, 0x60, 0x29, 0x71, 0x64, 0xcf, 0x5a, 0x9a, 0x51, 0x38, 0xa3,
0x24, 0x4e, 0x81, 0xa2, 0x37, 0xbd, 0xd8, 0x62, 0x81, 0x02, 0xbd, 0x68, 0xd1, 0x9b, 0x5e, 0xf5,
0x6a, 0x0b, 0xf4, 0x01, 0xfa, 0x0a, 0xed, 0x23, 0xf4, 0xaa, 0x4f, 0x52, 0xcc, 0x0f, 0x29, 0x92,
0xa2, 0x2c, 0xc5, 0xf2, 0x5e, 0xe5, 0x4e, 0x73, 0x78, 0x66, 0x86, 0xf3, 0x9d, 0x33, 0xe7, 0xfb,
0x0e, 0x05, 0x37, 0x08, 0x0d, 0xf0, 0x6b, 0xaf, 0xc3, 0x58, 0x18, 0x6c, 0x0d, 0x42, 0x26, 0x18,
0x42, 0x7d, 0xd2, 0x7b, 0x39, 0xe4, 0x7a, 0xb4, 0xa5, 0x9e, 0xd7, 0x2b, 0x1d, 0xd6, 0xef, 0x33,
0xaa, 0x6d, 0xf5, 0x55, 0x42, 0x05, 0x0e, 0xa9, 0xdf, 0x33, 0xe3, 0x4a, 0x72, 0x86, 0xf3, 0x55,
0x01, 0xec, 0xa6, 0x9c, 0xd5, 0xa4, 0x5d, 0x86, 0x1c, 0xa8, 0x74, 0x58, 0xaf, 0x87, 0x3b, 0x82,
0x30, 0xda, 0x3c, 0xa8, 0x59, 0x1b, 0x56, 0xa3, 0xe8, 0xa6, 0x6c, 0xa8, 0x06, 0x2b, 0x5d, 0x82,
0x7b, 0x41, 0xf3, 0xa0, 0x56, 0x50, 0x8f, 0xa3, 0x21, 0xba, 0x0b, 0xa0, 0x5f, 0x90, 0xfa, 0x7d,
0x5c, 0x2b, 0x6e, 0x58, 0x0d, 0xdb, 0xb5, 0x95, 0xe5, 0xd8, 0xef, 0x63, 0x39, 0x51, 0x0d, 0x9a,
0x07, 0xb5, 0x45, 0x3d, 0xd1, 0x0c, 0xd1, 0x1e, 0x94, 0xc5, 0xc5, 0x00, 0x7b, 0x03, 0x3f, 0xf4,
0xfb, 0xbc, 0xb6, 0xb4, 0x51, 0x6c, 0x94, 0x77, 0x36, 0xb7, 0x52, 0x47, 0x33, 0x67, 0x7a, 0x86,
0x2f, 0x3e, 0xf3, 0x7b, 0x43, 0x7c, 0xe2, 0x93, 0xd0, 0x05, 0x39, 0xeb, 0x44, 0x4d, 0x42, 0x07,
0x50, 0xd1, 0x9b, 0x9b, 0x45, 0x96, 0x67, 0x5d, 0xa4, 0xac, 0xa6, 0xe9, 0x55, 0x9c, 0xdf, 0x5b,
0x00, 0x4f, 0xd4, 0x71, 0xa4, 0x11, 0xfd, 0x34, 0x3a, 0x11, 0xa1, 0x5d, 0xa6, 0xd0, 0x28, 0xef,
0xdc, 0xdd, 0x1a, 0x87, 0x7c, 0x2b, 0x86, 0xd0, 0x1c, 0x58, 0xa1, 0x59, 0x83, 0x95, 0x00, 0xf7,
0xb0, 0xc0, 0x81, 0x42, 0xaa, 0xe4, 0x46, 0x43, 0x74, 0x0f, 0xca, 0x9d, 0x10, 0xfb, 0x02, 0x7b,
0x82, 0x18, 0xa8, 0x16, 0x5d, 0xd0, 0xa6, 0xe7, 0xa4, 0x8f, 0x9d, 0x2f, 0x17, 0xa1, 0xd2, 0xc2,
0xa7, 0x7d, 0x4c, 0x85, 0x7e, 0x93, 0x59, 0x22, 0xb3, 0x01, 0xe5, 0x81, 0x1f, 0x0a, 0x62, 0x5c,
0x74, 0x74, 0x92, 0x26, 0x74, 0x07, 0x6c, 0x6e, 0x56, 0x3d, 0x50, 0xbb, 0x16, 0xdd, 0x91, 0x01,
0xbd, 0x0f, 0x25, 0x3a, 0xec, 0x7b, 0x21, 0x7b, 0xc5, 0xa3, 0x08, 0xd1, 0x61, 0xdf, 0x65, 0xaf,
0x78, 0x32, 0x76, 0x4b, 0xe9, 0xd8, 0xd5, 0x60, 0xa5, 0x3d, 0x24, 0x2a, 0x1d, 0x96, 0xf5, 0x13,
0x33, 0x44, 0xdf, 0x82, 0x65, 0xca, 0x02, 0xdc, 0x3c, 0xa8, 0xad, 0xa8, 0x07, 0x66, 0x84, 0xee,
0x43, 0x55, 0x83, 0xfa, 0x12, 0x87, 0x9c, 0x30, 0x5a, 0x2b, 0xe9, 0xb3, 0x28, 0xe3, 0x67, 0xda,
0x86, 0x7e, 0x08, 0x4b, 0x5c, 0xf8, 0x02, 0xd7, 0xec, 0x0d, 0xab, 0xb1, 0xba, 0x73, 0x2f, 0x37,
0x8e, 0x0a, 0x9a, 0x96, 0x74, 0x73, 0xb5, 0xb7, 0x04, 0xb6, 0xeb, 0x93, 0x9e, 0x17, 0x62, 0x9f,
0x33, 0x5a, 0x03, 0x95, 0x83, 0x20, 0x4d, 0xae, 0xb2, 0xa0, 0xef, 0x45, 0x97, 0xa8, 0x4b, 0x7a,
0x98, 0x7b, 0x03, 0x5f, 0x9c, 0xf1, 0x5a, 0x79, 0xa3, 0xd8, 0xb0, 0xdd, 0x35, 0xf5, 0xe0, 0x89,
0xb4, 0x9f, 0x48, 0x73, 0x32, 0x7e, 0x95, 0x4b, 0xe3, 0x57, 0xcd, 0xc6, 0x0f, 0x3d, 0x80, 0x55,
0x8e, 0x43, 0xe2, 0xf7, 0xc8, 0x1b, 0xec, 0x71, 0xf2, 0x06, 0xd7, 0x56, 0x95, 0x4f, 0x35, 0xb6,
0xb6, 0xc8, 0x1b, 0x2c, 0xa1, 0x78, 0x15, 0x12, 0x81, 0xbd, 0x33, 0x9f, 0x06, 0xac, 0xdb, 0xad,
0xad, 0xa9, 0x7d, 0x2a, 0xca, 0xf8, 0x89, 0xb6, 0x39, 0x7f, 0xb1, 0xe0, 0xa6, 0x8b, 0x4f, 0x09,
0x17, 0x38, 0x3c, 0x66, 0x01, 0x76, 0xf1, 0x8b, 0x21, 0xe6, 0x02, 0x3d, 0x86, 0xc5, 0xb6, 0xcf,
0xb1, 0x49, 0xcb, 0x3b, 0xb9, 0x08, 0x1d, 0xf1, 0xd3, 0x3d, 0x9f, 0x63, 0x57, 0x79, 0xa2, 0x1f,
0xc1, 0x8a, 0x1f, 0x04, 0x21, 0xe6, 0x5c, 0x25, 0xc7, 0xa4, 0x49, 0xbb, 0xda, 0xc7, 0x8d, 0x9c,
0x13, 0x91, 0x2c, 0x26, 0x23, 0xe9, 0xfc, 0xd1, 0x82, 0x5b, 0xe9, 0x37, 0xe3, 0x03, 0x46, 0x39,
0x46, 0x1f, 0xc2, 0xb2, 0x8c, 0xc7, 0x90, 0x9b, 0x97, 0xbb, 0x9d, 0xbb, 0x4f, 0x4b, 0xb9, 0xb8,
0xc6, 0x55, 0x56, 0x01, 0x42, 0x89, 0x88, 0x2e, 0xb0, 0x7e, 0xc3, 0xcd, 0xec, 0x6d, 0x33, 0xb5,
0xac, 0x49, 0x89, 0xd0, 0x77, 0xd6, 0x05, 0x12, 0xff, 0x76, 0x7e, 0x09, 0xb7, 0x9e, 0x62, 0x91,
0xc8, 0x0b, 0x83, 0xd5, 0x2c, 0xd7, 0x27, 0x5d, 0xbe, 0x0a, 0x99, 0xf2, 0xe5, 0xfc, 0xdd, 0x82,
0xf7, 0x32, 0x6b, 0xcf, 0x73, 0xda, 0x38, 0xc1, 0x0b, 0xf3, 0x24, 0x78, 0x31, 0x9b, 0xe0, 0xce,
0xef, 0x2c, 0xb8, 0xfd, 0x14, 0x8b, 0x64, 0xf1, 0xb8, 0x66, 0x24, 0xd0, 0xb7, 0x01, 0xe2, 0xa2,
0xc1, 0x6b, 0xc5, 0x8d, 0x62, 0xa3, 0xe8, 0x26, 0x2c, 0xce, 0x97, 0x16, 0xdc, 0x18, 0xdb, 0x3f,
0x5d, 0x7b, 0xac, 0x6c, 0xed, 0xf9, 0xa6, 0xe0, 0xf8, 0x93, 0x05, 0x77, 0xf2, 0xe1, 0x98, 0x27,
0x78, 0x3f, 0xd3, 0x93, 0xb0, 0xcc, 0x52, 0x49, 0x33, 0x0f, 0xf2, 0x38, 0x61, 0x7c, 0x4f, 0x33,
0xc9, 0xf9, 0x6b, 0x01, 0xd0, 0xbe, 0x2a, 0x16, 0xea, 0xe1, 0xdb, 0x84, 0xe6, 0xca, 0xec, 0x9b,
0xe1, 0xd8, 0xc5, 0xeb, 0xe0, 0xd8, 0xa5, 0xab, 0x70, 0xac, 0x4c, 0x04, 0x59, 0x35, 0xb9, 0xf0,
0xfb, 0x03, 0xc5, 0x19, 0x8b, 0xee, 0xc8, 0xe0, 0xbc, 0x86, 0x9b, 0xd1, 0x2d, 0x53, 0x7c, 0xfa,
0x16, 0xd8, 0xa4, 0xf3, 0xb2, 0x90, 0xcd, 0xcb, 0x29, 0x08, 0x39, 0xff, 0x2d, 0xc0, 0x8d, 0x66,
0x44, 0x01, 0x92, 0x01, 0x14, 0x89, 0x5f, 0x9e, 0xb6, 0x93, 0xc3, 0x91, 0x60, 0xcc, 0xe2, 0x44,
0xc6, 0x5c, 0x4c, 0x33, 0x66, 0xfa, 0x05, 0x97, 0xb2, 0x21, 0xbc, 0x16, 0x89, 0x83, 0x1a, 0xb0,
0x3e, 0x62, 0x40, 0x43, 0x80, 0x2b, 0x8a, 0x00, 0x57, 0x49, 0xf2, 0xf4, 0x1c, 0x3d, 0x82, 0xb5,
0x98, 0xae, 0x02, 0xcd, 0x62, 0x25, 0x15, 0xae, 0x11, 0xb7, 0x05, 0x11, 0x8d, 0xa5, 0x19, 0xdd,
0x1e, 0x67, 0x74, 0xe7, 0x5f, 0x16, 0x94, 0xe3, 0x2b, 0x31, 0xa3, 0xd6, 0x4c, 0x81, 0x5f, 0xc8,
0x82, 0xbf, 0x09, 0x15, 0x4c, 0xfd, 0x76, 0x0f, 0x7b, 0x6a, 0x23, 0x85, 0x73, 0xc9, 0x2d, 0x6b,
0x9b, 0x96, 0x4d, 0x4f, 0xa0, 0x3c, 0x12, 0x70, 0x51, 0xd6, 0x3f, 0x98, 0xa8, 0xe0, 0x92, 0x91,
0x77, 0x21, 0x56, 0x72, 0xdc, 0xf9, 0x43, 0x61, 0x44, 0x2c, 0x3a, 0x2d, 0xe7, 0x29, 0x1f, 0xbf,
0x82, 0x8a, 0x39, 0x85, 0x16, 0x96, 0xba, 0x88, 0xfc, 0x38, 0xef, 0xb5, 0xf2, 0x36, 0xdd, 0x4a,
0xc0, 0xf8, 0x31, 0x15, 0xe1, 0x85, 0x5b, 0xe6, 0x23, 0x4b, 0xdd, 0x83, 0xf5, 0xac, 0x03, 0x5a,
0x87, 0xe2, 0x39, 0xbe, 0x30, 0x18, 0xcb, 0x9f, 0xb2, 0xe0, 0xbe, 0x94, 0x09, 0x62, 0x78, 0xf6,
0xde, 0xa5, 0x15, 0xac, 0xcb, 0x5c, 0xed, 0xfd, 0x93, 0xc2, 0x47, 0x96, 0xc3, 0x60, 0xfd, 0x20,
0x64, 0x83, 0xb7, 0xae, 0x5d, 0xd3, 0xfb, 0x83, 0xfc, 0xbb, 0x24, 0x59, 0xfd, 0x00, 0xf3, 0x4e,
0x48, 0xda, 0x78, 0xce, 0x4d, 0xc7, 0x58, 0xfd, 0x2b, 0x0b, 0xde, 0xcb, 0xac, 0x3d, 0x4f, 0x64,
0x7f, 0x9e, 0xce, 0x37, 0x1d, 0xd8, 0x29, 0x1d, 0x43, 0x32, 0xcf, 0x7c, 0xc5, 0x56, 0xea, 0xd9,
0x9e, 0x2c, 0x0a, 0x27, 0x21, 0x3b, 0x55, 0x5a, 0xec, 0xfa, 0x4e, 0xfc, 0x67, 0x0b, 0xee, 0x4e,
0xd8, 0x63, 0x9e, 0x93, 0x6f, 0x9a, 0xe2, 0x84, 0x03, 0xdd, 0x40, 0x98, 0xee, 0xc3, 0xd8, 0x54,
0x13, 0x71, 0x17, 0x40, 0x30, 0xe1, 0xf7, 0xb4, 0x83, 0x69, 0x3f, 0x94, 0x45, 0x3e, 0x76, 0xfe,
0x51, 0x80, 0x6a, 0x4b, 0xb0, 0xd0, 0x3f, 0xc5, 0xfb, 0x8c, 0x76, 0xc9, 0xa9, 0xcc, 0x88, 0x48,
0xaf, 0x5a, 0xea, 0x18, 0xb1, 0x22, 0xdd, 0x84, 0x8a, 0xdf, 0xe9, 0x60, 0xce, 0xbd, 0x73, 0x7c,
0x61, 0x12, 0xc6, 0x76, 0xcb, 0xda, 0xf6, 0x4c, 0x9a, 0xa4, 0xd2, 0xe7, 0xb8, 0x13, 0x62, 0xe1,
0x8d, 0x3c, 0x4d, 0xd2, 0xad, 0xe9, 0x07, 0xbb, 0x91, 0xb7, 0x14, 0xb8, 0x43, 0x8e, 0x5b, 0xad,
0x4f, 0x55, 0x45, 0x2e, 0xb9, 0x66, 0x24, 0xe5, 0x45, 0x7b, 0xd8, 0x39, 0xc7, 0x22, 0x59, 0x91,
0x41, 0x9b, 0x54, 0xce, 0xde, 0x06, 0x3b, 0x64, 0x4c, 0xa8, 0x32, 0xaa, 0xb8, 0xcc, 0x76, 0x4b,
0xd2, 0x20, 0x8b, 0x88, 0x59, 0xb5, 0xb9, 0x7b, 0xa4, 0x1a, 0x20, 0xbd, 0x6a, 0x73, 0xf7, 0x48,
0xf6, 0x69, 0xcd, 0xdd, 0xa3, 0x8f, 0x69, 0x30, 0x60, 0x84, 0x0a, 0x55, 0x53, 0x6d, 0x37, 0x69,
0x92, 0xc7, 0xe3, 0x1a, 0x09, 0x4f, 0xd2, 0xaf, 0xaa, 0xa7, 0xb6, 0x5b, 0x36, 0xb6, 0xe7, 0x17,
0x03, 0xec, 0xfc, 0xaf, 0x08, 0xeb, 0x5a, 0x43, 0x1c, 0xb2, 0x76, 0x94, 0x1e, 0x77, 0xc0, 0xee,
0xf4, 0x86, 0x52, 0x8e, 0x9b, 0xdc, 0xb0, 0xdd, 0x91, 0x21, 0xdd, 0xfb, 0x78, 0x83, 0x10, 0x77,
0xc9, 0x6b, 0x83, 0xdc, 0xa8, 0xf7, 0x39, 0x51, 0xe6, 0x24, 0x49, 0x15, 0xc7, 0x48, 0x2a, 0xf0,
0x85, 0x6f, 0x98, 0x63, 0x51, 0x31, 0x87, 0x2d, 0x2d, 0x9a, 0x34, 0xc6, 0xb8, 0x60, 0x29, 0xa7,
0xbb, 0x4b, 0x90, 0xe3, 0x72, 0x9a, 0x1c, 0xd3, 0xc9, 0xbb, 0x92, 0xad, 0x11, 0x9f, 0xc0, 0x6a,
0x04, 0x4c, 0x47, 0xe5, 0x88, 0x42, 0x2f, 0xa7, 0x4d, 0x50, 0xe5, 0x2b, 0x99, 0x4c, 0x6e, 0x95,
0xa7, 0x72, 0x2b, 0x4b, 0xa6, 0xf6, 0x95, 0xc8, 0x34, 0xa3, 0xaa, 0xe0, 0x2a, 0xaa, 0x2a, 0xd9,
0x76, 0x97, 0x53, 0x6d, 0xb7, 0xf3, 0x29, 0xac, 0xff, 0x62, 0x88, 0xc3, 0x8b, 0x43, 0xd6, 0xe6,
0xb3, 0xc5, 0xb8, 0x0e, 0x25, 0x13, 0xa8, 0x48, 0x01, 0xc5, 0x63, 0xe7, 0xdf, 0x16, 0x54, 0xd5,
0xb5, 0x7f, 0xee, 0xf3, 0xf3, 0xe8, 0x0b, 0x45, 0x14, 0x65, 0x2b, 0x1d, 0xe5, 0xab, 0xeb, 0xf1,
0x44, 0x7b, 0xad, 0x7a, 0x03, 0xdb, 0x14, 0x38, 0xd5, 0x58, 0xe7, 0x69, 0x8a, 0xc5, 0x5c, 0x4d,
0x91, 0x51, 0xf6, 0x4b, 0x63, 0xca, 0xfe, 0x6b, 0x0b, 0x6e, 0x24, 0xc0, 0x99, 0xa7, 0x76, 0xa5,
0x20, 0x2d, 0x64, 0x21, 0xdd, 0x4b, 0xd7, 0xf4, 0x62, 0x5e, 0x8c, 0x13, 0x35, 0x3d, 0x02, 0x37,
0x55, 0xd7, 0x9f, 0xc1, 0x9a, 0xa4, 0xcc, 0xeb, 0x89, 0xe3, 0x7f, 0x2c, 0x58, 0x39, 0x64, 0x6d,
0x15, 0xc1, 0x64, 0xf2, 0x58, 0xe9, 0x6f, 0x36, 0xeb, 0x50, 0x0c, 0x48, 0xdf, 0x14, 0x62, 0xf9,
0x53, 0x5e, 0x2e, 0x2e, 0xfc, 0x50, 0x8c, 0xbe, 0x3a, 0x49, 0x3d, 0x25, 0x2d, 0xea, 0xa3, 0xc5,
0xfb, 0x50, 0xc2, 0x34, 0xd0, 0x0f, 0x8d, 0x32, 0xc5, 0x34, 0x50, 0x8f, 0xae, 0x47, 0xf9, 0xdf,
0x82, 0xa5, 0x01, 0x1b, 0x7d, 0x29, 0xd2, 0x03, 0xe7, 0x16, 0xa0, 0xa7, 0x58, 0x1c, 0xb2, 0xb6,
0x8c, 0x4a, 0x04, 0x8f, 0xf3, 0xb7, 0x82, 0x6a, 0x04, 0x46, 0xe6, 0x79, 0x02, 0xec, 0x40, 0x55,
0x33, 0xcf, 0x17, 0xac, 0xed, 0xd1, 0x61, 0x04, 0x4a, 0x59, 0x19, 0x0f, 0x59, 0xfb, 0x78, 0xd8,
0x47, 0x1f, 0xc0, 0x4d, 0x42, 0xbd, 0x81, 0x21, 0xc3, 0xd8, 0x53, 0xa3, 0xb4, 0x4e, 0x68, 0x44,
0x93, 0xc6, 0xfd, 0x21, 0xac, 0x61, 0xfa, 0x62, 0x88, 0x87, 0x38, 0x76, 0xd5, 0x98, 0x55, 0x8d,
0xd9, 0xf8, 0x49, 0xd2, 0xf3, 0xf9, 0xb9, 0xc7, 0x7b, 0x4c, 0x70, 0x53, 0x0c, 0x6d, 0x69, 0x69,
0x49, 0x03, 0xfa, 0x08, 0x6c, 0x39, 0x5d, 0xa7, 0x96, 0x16, 0xf4, 0xb7, 0xf3, 0x52, 0xcb, 0xc4,
0xdb, 0x2d, 0x7d, 0xa1, 0x7f, 0xf0, 0x9d, 0xaf, 0x6d, 0x00, 0x95, 0x70, 0xfb, 0x8c, 0x85, 0x01,
0x1a, 0x28, 0x14, 0xf7, 0x59, 0x7f, 0xc0, 0x28, 0xa6, 0x42, 0xdd, 0x4a, 0x8e, 0x1e, 0x4f, 0xf8,
0x7c, 0x32, 0xee, 0x6a, 0x70, 0xaf, 0x3f, 0x9c, 0x30, 0x23, 0xe3, 0xee, 0x2c, 0xa0, 0x17, 0x4a,
0x12, 0xcb, 0x21, 0xe1, 0x82, 0x74, 0xf8, 0xfe, 0x99, 0x4f, 0x29, 0xee, 0xa1, 0x9d, 0xc9, 0x7b,
0x8e, 0x39, 0x47, 0xbb, 0xde, 0x4f, 0xcf, 0x31, 0x83, 0x96, 0x08, 0x09, 0x3d, 0x8d, 0x42, 0xef,
0x2c, 0xa0, 0xe7, 0x50, 0x4e, 0xf4, 0xcd, 0xe8, 0x61, 0x1e, 0x52, 0xe3, 0x8d, 0x75, 0xfd, 0xb2,
0x1c, 0x71, 0x16, 0x50, 0x17, 0xaa, 0xa9, 0x0f, 0x3b, 0xa8, 0x71, 0x99, 0x12, 0x4f, 0x7e, 0x4d,
0xa9, 0x7f, 0x77, 0x06, 0xcf, 0xf8, 0xed, 0x7f, 0xa3, 0x01, 0x1b, 0xfb, 0x32, 0xb2, 0x3d, 0x61,
0x91, 0x49, 0xdf, 0x70, 0xea, 0x8f, 0x67, 0x9f, 0x10, 0x6f, 0x1e, 0x8c, 0x0e, 0xa9, 0xf2, 0x07,
0x3d, 0x9a, 0xde, 0x6e, 0xe8, 0xdd, 0x1a, 0xb3, 0xf6, 0x25, 0xce, 0x02, 0x3a, 0x01, 0x3b, 0x6e,
0x0d, 0xd0, 0x77, 0xf2, 0x26, 0x66, 0x3b, 0x87, 0x19, 0x82, 0x93, 0xd2, 0xe7, 0xf9, 0xc1, 0xc9,
0x6b, 0x0f, 0xf2, 0x83, 0x93, 0x2b, 0xf6, 0x9d, 0x05, 0xf4, 0xdb, 0xd1, 0xd7, 0xbd, 0x94, 0x2a,
0x46, 0x8f, 0x2f, 0x3b, 0x7e, 0x9e, 0x48, 0xaf, 0x7f, 0xff, 0x2d, 0x66, 0x24, 0x92, 0x03, 0xb5,
0xce, 0xd8, 0x2b, 0xad, 0x4e, 0x86, 0xa1, 0x2f, 0xc5, 0xfc, 0xe4, 0xfb, 0x3b, 0xee, 0x3a, 0x71,
0xf3, 0x4b, 0x66, 0xc4, 0x9b, 0x7b, 0x00, 0x4f, 0xb1, 0x38, 0xc2, 0x22, 0x24, 0x1d, 0x9e, 0xbd,
0x56, 0x66, 0x30, 0x72, 0x88, 0xb6, 0x7a, 0x34, 0xd5, 0x2f, 0xda, 0x60, 0xe7, 0x9f, 0xcb, 0xe6,
0x6f, 0xa6, 0x63, 0x16, 0xe0, 0x77, 0xa3, 0x56, 0x9d, 0x80, 0x1d, 0xeb, 0xf3, 0xfc, 0xab, 0x90,
0x95, 0xef, 0xd3, 0xae, 0xc2, 0xe7, 0x60, 0xc7, 0x82, 0x27, 0x7f, 0xc5, 0xac, 0x58, 0xac, 0x3f,
0x98, 0xe2, 0x15, 0xbf, 0xed, 0x31, 0x94, 0x22, 0x81, 0x82, 0xee, 0x4f, 0xba, 0xb7, 0xc9, 0x95,
0xa7, 0xbc, 0xeb, 0xaf, 0xa1, 0x9c, 0x60, 0xef, 0xfc, 0x4a, 0x3d, 0xce, 0xfa, 0xf5, 0x47, 0x53,
0xfd, 0xde, 0x8d, 0x0b, 0xb3, 0xf7, 0x83, 0xcf, 0x77, 0x4e, 0x89, 0x38, 0x1b, 0xb6, 0x25, 0xb2,
0xdb, 0xda, 0xf3, 0x03, 0xc2, 0xcc, 0xaf, 0xed, 0xe8, 0x2d, 0xb7, 0xd5, 0x4a, 0xdb, 0x0a, 0xa7,
0x41, 0xbb, 0xbd, 0xac, 0x86, 0x1f, 0xfe, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xfc, 0x5f, 0xd8, 0xa9,
0x29, 0x1e, 0x00, 0x00,
// 2041 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0x5b, 0x6f, 0x23, 0x49,
0x15, 0x4e, 0xdb, 0xb9, 0xb8, 0x8f, 0xed, 0x24, 0x53, 0x93, 0x45, 0x5e, 0xcf, 0x0c, 0x93, 0xf4,
0x30, 0x33, 0x06, 0x69, 0x93, 0x21, 0x0b, 0x68, 0x41, 0x80, 0x94, 0xcb, 0xce, 0xac, 0x33, 0x9b,
0x28, 0xb4, 0x47, 0x2b, 0xed, 0x0a, 0xa9, 0x69, 0xbb, 0xcb, 0x49, 0x6d, 0xec, 0x2a, 0x4f, 0x57,
0x79, 0x66, 0x32, 0x48, 0x88, 0x17, 0x1e, 0x16, 0xad, 0x84, 0xc4, 0x03, 0x88, 0x17, 0x9e, 0x78,
0x5a, 0x24, 0x7e, 0x00, 0x7f, 0x01, 0x7e, 0x02, 0x4f, 0xfc, 0x12, 0x54, 0x97, 0x6e, 0x77, 0xb7,
0xdb, 0xb1, 0x73, 0xe1, 0x69, 0xde, 0x5c, 0xa7, 0x4f, 0xdd, 0xbe, 0x73, 0xf9, 0xce, 0x29, 0xc3,
0x2d, 0x42, 0x03, 0xfc, 0xc6, 0xeb, 0x30, 0x16, 0x06, 0x9b, 0x83, 0x90, 0x09, 0x86, 0x50, 0x9f,
0xf4, 0x5e, 0x0d, 0xb9, 0x1e, 0x6d, 0xaa, 0xef, 0xf5, 0x4a, 0x87, 0xf5, 0xfb, 0x8c, 0x6a, 0x59,
0x7d, 0x99, 0x50, 0x81, 0x43, 0xea, 0xf7, 0xcc, 0xb8, 0x92, 0x9c, 0xe1, 0x7c, 0x5d, 0x00, 0xbb,
0x29, 0x67, 0x35, 0x69, 0x97, 0x21, 0x07, 0x2a, 0x1d, 0xd6, 0xeb, 0xe1, 0x8e, 0x20, 0x8c, 0x36,
0xf7, 0x6b, 0xd6, 0xba, 0xd5, 0x28, 0xba, 0x29, 0x19, 0xaa, 0xc1, 0x52, 0x97, 0xe0, 0x5e, 0xd0,
0xdc, 0xaf, 0x15, 0xd4, 0xe7, 0x68, 0x88, 0xee, 0x01, 0xe8, 0x03, 0x52, 0xbf, 0x8f, 0x6b, 0xc5,
0x75, 0xab, 0x61, 0xbb, 0xb6, 0x92, 0x1c, 0xf9, 0x7d, 0x2c, 0x27, 0xaa, 0x41, 0x73, 0xbf, 0x36,
0xaf, 0x27, 0x9a, 0x21, 0xda, 0x85, 0xb2, 0x38, 0x1f, 0x60, 0x6f, 0xe0, 0x87, 0x7e, 0x9f, 0xd7,
0x16, 0xd6, 0x8b, 0x8d, 0xf2, 0xf6, 0xc6, 0x66, 0xea, 0x6a, 0xe6, 0x4e, 0xcf, 0xf1, 0xf9, 0x67,
0x7e, 0x6f, 0x88, 0x8f, 0x7d, 0x12, 0xba, 0x20, 0x67, 0x1d, 0xab, 0x49, 0x68, 0x1f, 0x2a, 0x7a,
0x73, 0xb3, 0xc8, 0xe2, 0xac, 0x8b, 0x94, 0xd5, 0x34, 0xbd, 0x8a, 0xf3, 0x3b, 0x0b, 0xe0, 0xa9,
0xba, 0x8e, 0x14, 0xa2, 0x9f, 0x46, 0x37, 0x22, 0xb4, 0xcb, 0x14, 0x1a, 0xe5, 0xed, 0x7b, 0x9b,
0xe3, 0x90, 0x6f, 0xc6, 0x10, 0x9a, 0x0b, 0x2b, 0x34, 0x6b, 0xb0, 0x14, 0xe0, 0x1e, 0x16, 0x38,
0x50, 0x48, 0x95, 0xdc, 0x68, 0x88, 0xee, 0x43, 0xb9, 0x13, 0x62, 0x5f, 0x60, 0x4f, 0x10, 0x03,
0xd5, 0xbc, 0x0b, 0x5a, 0xf4, 0x82, 0xf4, 0xb1, 0xf3, 0xd5, 0x3c, 0x54, 0x5a, 0xf8, 0xa4, 0x8f,
0xa9, 0xd0, 0x27, 0x99, 0xc5, 0x32, 0xeb, 0x50, 0x1e, 0xf8, 0xa1, 0x20, 0x46, 0x45, 0x5b, 0x27,
0x29, 0x42, 0x77, 0xc1, 0xe6, 0x66, 0xd5, 0x7d, 0xb5, 0x6b, 0xd1, 0x1d, 0x09, 0xd0, 0xfb, 0x50,
0xa2, 0xc3, 0xbe, 0x17, 0xb2, 0xd7, 0x3c, 0xb2, 0x10, 0x1d, 0xf6, 0x5d, 0xf6, 0x9a, 0x27, 0x6d,
0xb7, 0x90, 0xb6, 0x5d, 0x0d, 0x96, 0xda, 0x43, 0xa2, 0xdc, 0x61, 0x51, 0x7f, 0x31, 0x43, 0xf4,
0x2d, 0x58, 0xa4, 0x2c, 0xc0, 0xcd, 0xfd, 0xda, 0x92, 0xfa, 0x60, 0x46, 0xe8, 0x01, 0x54, 0x35,
0xa8, 0xaf, 0x70, 0xc8, 0x09, 0xa3, 0xb5, 0x92, 0xbe, 0x8b, 0x12, 0x7e, 0xa6, 0x65, 0xe8, 0x87,
0xb0, 0xc0, 0x85, 0x2f, 0x70, 0xcd, 0x5e, 0xb7, 0x1a, 0xcb, 0xdb, 0xf7, 0x73, 0xed, 0xa8, 0xa0,
0x69, 0x49, 0x35, 0x57, 0x6b, 0x4b, 0x60, 0xbb, 0x3e, 0xe9, 0x79, 0x21, 0xf6, 0x39, 0xa3, 0x35,
0x50, 0x3e, 0x08, 0x52, 0xe4, 0x2a, 0x09, 0xfa, 0x5e, 0x14, 0x44, 0x5d, 0xd2, 0xc3, 0xdc, 0x1b,
0xf8, 0xe2, 0x94, 0xd7, 0xca, 0xeb, 0xc5, 0x86, 0xed, 0xae, 0xa8, 0x0f, 0x4f, 0xa5, 0xfc, 0x58,
0x8a, 0x93, 0xf6, 0xab, 0x5c, 0x68, 0xbf, 0x6a, 0xd6, 0x7e, 0xe8, 0x21, 0x2c, 0x73, 0x1c, 0x12,
0xbf, 0x47, 0xde, 0x62, 0x8f, 0x93, 0xb7, 0xb8, 0xb6, 0xac, 0x74, 0xaa, 0xb1, 0xb4, 0x45, 0xde,
0x62, 0x09, 0xc5, 0xeb, 0x90, 0x08, 0xec, 0x9d, 0xfa, 0x34, 0x60, 0xdd, 0x6e, 0x6d, 0x45, 0xed,
0x53, 0x51, 0xc2, 0x4f, 0xb4, 0xcc, 0xf9, 0xb3, 0x05, 0xb7, 0x5d, 0x7c, 0x42, 0xb8, 0xc0, 0xe1,
0x11, 0x0b, 0xb0, 0x8b, 0x5f, 0x0e, 0x31, 0x17, 0xe8, 0x09, 0xcc, 0xb7, 0x7d, 0x8e, 0x8d, 0x5b,
0xde, 0xcd, 0x45, 0xe8, 0x90, 0x9f, 0xec, 0xfa, 0x1c, 0xbb, 0x4a, 0x13, 0xfd, 0x08, 0x96, 0xfc,
0x20, 0x08, 0x31, 0xe7, 0xca, 0x39, 0x26, 0x4d, 0xda, 0xd1, 0x3a, 0x6e, 0xa4, 0x9c, 0xb0, 0x64,
0x31, 0x69, 0x49, 0xe7, 0x0f, 0x16, 0xac, 0xa5, 0x4f, 0xc6, 0x07, 0x8c, 0x72, 0x8c, 0x3e, 0x84,
0x45, 0x69, 0x8f, 0x21, 0x37, 0x87, 0xbb, 0x93, 0xbb, 0x4f, 0x4b, 0xa9, 0xb8, 0x46, 0x55, 0x66,
0x01, 0x42, 0x89, 0x88, 0x02, 0x58, 0x9f, 0x70, 0x23, 0x1b, 0x6d, 0x26, 0x97, 0x35, 0x29, 0x11,
0x3a, 0x66, 0x5d, 0x20, 0xf1, 0x6f, 0xe7, 0x73, 0x58, 0x7b, 0x86, 0x45, 0xc2, 0x2f, 0x0c, 0x56,
0xb3, 0x84, 0x4f, 0x3a, 0x7d, 0x15, 0x32, 0xe9, 0xcb, 0xf9, 0x9b, 0x05, 0xef, 0x65, 0xd6, 0xbe,
0xce, 0x6d, 0x63, 0x07, 0x2f, 0x5c, 0xc7, 0xc1, 0x8b, 0x59, 0x07, 0x77, 0x7e, 0x6b, 0xc1, 0x9d,
0x67, 0x58, 0x24, 0x93, 0xc7, 0x0d, 0x23, 0x81, 0xbe, 0x0d, 0x10, 0x27, 0x0d, 0x5e, 0x2b, 0xae,
0x17, 0x1b, 0x45, 0x37, 0x21, 0x71, 0xbe, 0xb2, 0xe0, 0xd6, 0xd8, 0xfe, 0xe9, 0xdc, 0x63, 0x65,
0x73, 0xcf, 0xff, 0x0b, 0x8e, 0x3f, 0x5a, 0x70, 0x37, 0x1f, 0x8e, 0xeb, 0x18, 0xef, 0x67, 0x7a,
0x12, 0x96, 0x5e, 0x2a, 0x69, 0xe6, 0x61, 0x1e, 0x27, 0x8c, 0xef, 0x69, 0x26, 0x39, 0x7f, 0x29,
0x00, 0xda, 0x53, 0xc9, 0x42, 0x7d, 0xbc, 0x8c, 0x69, 0xae, 0xcc, 0xbe, 0x19, 0x8e, 0x9d, 0xbf,
0x09, 0x8e, 0x5d, 0xb8, 0x0a, 0xc7, 0x4a, 0x47, 0x90, 0x59, 0x93, 0x0b, 0xbf, 0x3f, 0x50, 0x9c,
0x31, 0xef, 0x8e, 0x04, 0xce, 0x1b, 0xb8, 0x1d, 0x45, 0x99, 0xe2, 0xd3, 0x4b, 0x60, 0x93, 0xf6,
0xcb, 0x42, 0xd6, 0x2f, 0xa7, 0x20, 0xe4, 0xfc, 0xa7, 0x00, 0xb7, 0x9a, 0x11, 0x05, 0x48, 0x06,
0x50, 0x24, 0x7e, 0xb1, 0xdb, 0x4e, 0x36, 0x47, 0x82, 0x31, 0x8b, 0x13, 0x19, 0x73, 0x3e, 0xcd,
0x98, 0xe9, 0x03, 0x2e, 0x64, 0x4d, 0x78, 0x23, 0x25, 0x0e, 0x6a, 0xc0, 0xea, 0x88, 0x01, 0x0d,
0x01, 0x2e, 0x29, 0x02, 0x5c, 0x26, 0xc9, 0xdb, 0x73, 0xf4, 0x18, 0x56, 0x62, 0xba, 0x0a, 0x34,
0x8b, 0x95, 0x94, 0xb9, 0x46, 0xdc, 0x16, 0x44, 0x34, 0x96, 0x66, 0x74, 0x7b, 0x9c, 0xd1, 0x9d,
0x7f, 0x5a, 0x50, 0x8e, 0x43, 0x62, 0xc6, 0x5a, 0x33, 0x05, 0x7e, 0x21, 0x0b, 0xfe, 0x06, 0x54,
0x30, 0xf5, 0xdb, 0x3d, 0xec, 0xa9, 0x8d, 0x14, 0xce, 0x25, 0xb7, 0xac, 0x65, 0xba, 0x6c, 0x7a,
0x0a, 0xe5, 0x51, 0x01, 0x17, 0x79, 0xfd, 0xc3, 0x89, 0x15, 0x5c, 0xd2, 0xf2, 0x2e, 0xc4, 0x95,
0x1c, 0x77, 0x7e, 0x5f, 0x18, 0x11, 0x8b, 0x76, 0xcb, 0xeb, 0xa4, 0x8f, 0x5f, 0x42, 0xc5, 0xdc,
0x42, 0x17, 0x96, 0x3a, 0x89, 0xfc, 0x38, 0xef, 0x58, 0x79, 0x9b, 0x6e, 0x26, 0x60, 0xfc, 0x98,
0x8a, 0xf0, 0xdc, 0x2d, 0xf3, 0x91, 0xa4, 0xee, 0xc1, 0x6a, 0x56, 0x01, 0xad, 0x42, 0xf1, 0x0c,
0x9f, 0x1b, 0x8c, 0xe5, 0x4f, 0x99, 0x70, 0x5f, 0x49, 0x07, 0x31, 0x3c, 0x7b, 0xff, 0xc2, 0x0c,
0xd6, 0x65, 0xae, 0xd6, 0xfe, 0x49, 0xe1, 0x23, 0xcb, 0x39, 0x87, 0xd5, 0xfd, 0x90, 0x0d, 0x2e,
0x9d, 0xbb, 0x1c, 0xa8, 0x24, 0x8a, 0xd1, 0x28, 0x42, 0x53, 0xb2, 0x69, 0x31, 0xfa, 0x39, 0xac,
0xed, 0x63, 0xde, 0x09, 0x49, 0xfb, 0xf2, 0xa9, 0x73, 0x0a, 0xbf, 0x7f, 0x6d, 0xc1, 0x7b, 0x99,
0xb5, 0xaf, 0x63, 0xe3, 0x9f, 0xa7, 0x3d, 0x4f, 0x9b, 0x78, 0x4a, 0xef, 0x90, 0xf4, 0x38, 0x5f,
0xf1, 0x96, 0xfa, 0xb6, 0x2b, 0xd3, 0xc3, 0x71, 0xc8, 0x4e, 0x54, 0x55, 0x76, 0x73, 0x37, 0xfe,
0x93, 0x05, 0xf7, 0x26, 0xec, 0x71, 0x9d, 0x9b, 0x6f, 0x98, 0x34, 0x85, 0x03, 0xdd, 0x4a, 0x98,
0x3e, 0xc4, 0xc8, 0x54, 0x3b, 0x71, 0x0f, 0x40, 0x30, 0xe1, 0xf7, 0xb4, 0x82, 0x69, 0x44, 0x94,
0x44, 0x7e, 0x76, 0xfe, 0x5e, 0x80, 0x6a, 0x4b, 0xb0, 0xd0, 0x3f, 0xc1, 0x7b, 0x8c, 0x76, 0xc9,
0x89, 0xcc, 0x99, 0x51, 0xe5, 0x6a, 0xa9, 0x6b, 0xc4, 0xb5, 0xe9, 0x06, 0x54, 0xfc, 0x4e, 0x07,
0x73, 0xee, 0x9d, 0xe1, 0x73, 0x93, 0x25, 0x6c, 0xb7, 0xac, 0x65, 0xcf, 0xa5, 0x48, 0xd6, 0xfc,
0x1c, 0x77, 0x42, 0x2c, 0xbc, 0x91, 0xa6, 0x71, 0xad, 0x15, 0xfd, 0x61, 0x27, 0xd2, 0x96, 0xa5,
0xee, 0x90, 0xe3, 0x56, 0xeb, 0x53, 0x95, 0x9b, 0x4b, 0xae, 0x19, 0xc9, 0x42, 0xa3, 0x3d, 0xec,
0x9c, 0x61, 0x91, 0xcc, 0xcd, 0xa0, 0x45, 0x2a, 0x39, 0xdf, 0x01, 0x3b, 0x64, 0x4c, 0xa8, 0x84,
0xaa, 0x58, 0xcd, 0x76, 0x4b, 0x52, 0x20, 0xd3, 0x89, 0x59, 0xb5, 0xb9, 0x73, 0xa8, 0x5a, 0x21,
0xbd, 0x6a, 0x73, 0xe7, 0x50, 0x76, 0x6c, 0xcd, 0x9d, 0xc3, 0x8f, 0x69, 0x30, 0x60, 0x84, 0x0a,
0x95, 0x5d, 0x6d, 0x37, 0x29, 0x92, 0xd7, 0xe3, 0x1a, 0x09, 0x4f, 0x12, 0xb1, 0xca, 0xac, 0xb6,
0x5b, 0x36, 0xb2, 0x17, 0xe7, 0x03, 0xec, 0xfc, 0xb7, 0x08, 0xab, 0xba, 0x9a, 0x38, 0x60, 0xed,
0xc8, 0x3d, 0xee, 0x82, 0xdd, 0xe9, 0x0d, 0x65, 0x61, 0x6e, 0x7c, 0xc3, 0x76, 0x47, 0x82, 0x74,
0x17, 0xe4, 0x0d, 0x42, 0xdc, 0x25, 0x6f, 0x0c, 0x72, 0xa3, 0x2e, 0xe8, 0x58, 0x89, 0x93, 0x74,
0x55, 0x1c, 0xa3, 0xab, 0xc0, 0x17, 0xbe, 0xe1, 0x90, 0x79, 0xc5, 0x21, 0xb6, 0x94, 0x68, 0xfa,
0x18, 0x63, 0x85, 0x85, 0x9c, 0x3e, 0x2f, 0x41, 0x93, 0x8b, 0x69, 0x9a, 0x4c, 0x3b, 0xef, 0x52,
0x96, 0x0c, 0x3f, 0x81, 0xe5, 0x08, 0x98, 0x8e, 0xf2, 0x11, 0x85, 0x5e, 0x4e, 0xc3, 0xa0, 0x12,
0x59, 0xd2, 0x99, 0xdc, 0x2a, 0x4f, 0xf9, 0x56, 0x96, 0x56, 0xed, 0x2b, 0xd1, 0x6a, 0xa6, 0xbe,
0x82, 0xab, 0xd4, 0x57, 0xc9, 0x06, 0xbc, 0x9c, 0x6a, 0xc0, 0x9d, 0x4f, 0x61, 0xf5, 0x17, 0x43,
0x1c, 0x9e, 0x1f, 0xb0, 0x36, 0x9f, 0xcd, 0xc6, 0x75, 0x28, 0x19, 0x43, 0x45, 0x99, 0x36, 0x1e,
0x3b, 0xff, 0xb2, 0xa0, 0xaa, 0xc2, 0xfe, 0x85, 0xcf, 0xcf, 0xa2, 0xb7, 0x8a, 0xc8, 0xca, 0x56,
0xda, 0xca, 0x57, 0xaf, 0xcc, 0x13, 0x8d, 0xb6, 0xea, 0x12, 0x6c, 0x93, 0xe0, 0x54, 0x8b, 0x9d,
0x57, 0x5d, 0xcc, 0xe7, 0x56, 0x17, 0x99, 0x1a, 0x7f, 0x61, 0xac, 0xc6, 0xff, 0xc6, 0x82, 0x5b,
0x09, 0x70, 0xae, 0x93, 0xbb, 0x52, 0x90, 0x16, 0xb2, 0x90, 0xee, 0xa6, 0x73, 0x7a, 0x31, 0xcf,
0xc6, 0x89, 0x9c, 0x1e, 0x81, 0x9b, 0xca, 0xeb, 0xcf, 0x61, 0x45, 0x92, 0xe7, 0xcd, 0xd8, 0xf1,
0xdf, 0x16, 0x2c, 0x1d, 0xb0, 0xb6, 0xb2, 0x60, 0xd2, 0x79, 0xac, 0xf4, 0xeb, 0xcd, 0x2a, 0x14,
0x03, 0xd2, 0x37, 0x89, 0x58, 0xfe, 0x94, 0xc1, 0xc5, 0x85, 0x1f, 0x8a, 0xd1, 0xfb, 0x93, 0xac,
0xac, 0xa4, 0x44, 0x3d, 0x5f, 0xbc, 0x0f, 0x25, 0x4c, 0x03, 0xfd, 0xd1, 0xd4, 0xa8, 0x98, 0x06,
0xea, 0xd3, 0xcd, 0xf4, 0x00, 0x6b, 0xb0, 0x30, 0x60, 0xa3, 0x37, 0x23, 0x3d, 0x70, 0xd6, 0x00,
0x3d, 0xc3, 0xe2, 0x80, 0xb5, 0xa5, 0x55, 0x22, 0x78, 0x9c, 0xbf, 0x16, 0x54, 0x4b, 0x30, 0x12,
0x5f, 0xc7, 0xc0, 0x0e, 0x54, 0x35, 0xf3, 0x7c, 0xc9, 0xda, 0x1e, 0x1d, 0x46, 0xa0, 0x94, 0x95,
0xf0, 0x80, 0xb5, 0x8f, 0x86, 0x7d, 0xf4, 0x01, 0xdc, 0x26, 0xd4, 0x1b, 0x18, 0x32, 0x8c, 0x35,
0x35, 0x4a, 0xab, 0x84, 0x46, 0x34, 0x69, 0xd4, 0x1f, 0xc1, 0x0a, 0xa6, 0x2f, 0x87, 0x78, 0x88,
0x63, 0x55, 0x8d, 0x59, 0xd5, 0x88, 0x8d, 0x9e, 0x24, 0x3d, 0x9f, 0x9f, 0x79, 0xbc, 0xc7, 0x04,
0x37, 0xc9, 0xd0, 0x96, 0x92, 0x96, 0x14, 0xa0, 0x8f, 0xc0, 0x96, 0xd3, 0xb5, 0x6b, 0xe9, 0xd2,
0xfe, 0x4e, 0x9e, 0x6b, 0x19, 0x7b, 0xbb, 0xa5, 0x2f, 0xf5, 0x0f, 0xbe, 0xfd, 0x8d, 0x0d, 0xa0,
0x1c, 0x6e, 0x8f, 0xb1, 0x30, 0x40, 0x03, 0x85, 0xe2, 0x1e, 0xeb, 0x0f, 0x18, 0xc5, 0x54, 0xa8,
0xa8, 0xe4, 0xe8, 0xc9, 0x84, 0x87, 0x94, 0x71, 0x55, 0x83, 0x7b, 0xfd, 0xd1, 0x84, 0x19, 0x19,
0x75, 0x67, 0x0e, 0xbd, 0x54, 0xc5, 0xb1, 0x1c, 0x12, 0x2e, 0x48, 0x87, 0xef, 0x9d, 0xfa, 0x94,
0xe2, 0x1e, 0xda, 0x9e, 0xbc, 0xe7, 0x98, 0x72, 0xb4, 0xeb, 0x83, 0xf4, 0x1c, 0x33, 0x68, 0x89,
0x90, 0xd0, 0x93, 0xc8, 0xf4, 0xce, 0x1c, 0x7a, 0x01, 0xe5, 0x44, 0x07, 0x8d, 0x1e, 0xe5, 0x21,
0x35, 0xde, 0x62, 0xd7, 0x2f, 0xf2, 0x11, 0x67, 0x0e, 0x75, 0xa1, 0x9a, 0x7a, 0xe2, 0x41, 0x8d,
0x8b, 0x6a, 0xf2, 0xe4, 0xbb, 0x4a, 0xfd, 0xbb, 0x33, 0x68, 0xc6, 0xa7, 0xff, 0xb5, 0x06, 0x6c,
0xec, 0x8d, 0x64, 0x6b, 0xc2, 0x22, 0x93, 0x5e, 0x73, 0xea, 0x4f, 0x66, 0x9f, 0x10, 0x6f, 0x1e,
0x8c, 0x2e, 0xa9, 0xfc, 0x07, 0x3d, 0x9e, 0xde, 0x78, 0xe8, 0xdd, 0x1a, 0xb3, 0x76, 0x28, 0xce,
0x1c, 0x3a, 0x06, 0x3b, 0x6e, 0x12, 0xd0, 0x77, 0xf2, 0x26, 0x66, 0x7b, 0x88, 0x19, 0x8c, 0x93,
0xaa, 0xcf, 0xf3, 0x8d, 0x93, 0xd7, 0x1e, 0xe4, 0x1b, 0x27, 0xb7, 0xd8, 0x77, 0xe6, 0xd0, 0x6f,
0x46, 0xef, 0x7c, 0xa9, 0xaa, 0x18, 0x3d, 0xb9, 0xe8, 0xfa, 0x79, 0x45, 0x7a, 0xfd, 0xfb, 0x97,
0x98, 0x91, 0x70, 0x0e, 0xd4, 0x3a, 0x65, 0xaf, 0x75, 0x75, 0x32, 0x0c, 0x7d, 0x59, 0xcc, 0x4f,
0x8e, 0xdf, 0x71, 0xd5, 0x89, 0x9b, 0x5f, 0x30, 0x23, 0xde, 0xdc, 0x03, 0x78, 0x86, 0xc5, 0x21,
0x16, 0x21, 0xe9, 0xf0, 0x6c, 0x58, 0x99, 0xc1, 0x48, 0x21, 0xda, 0xea, 0xf1, 0x54, 0xbd, 0x68,
0x83, 0xed, 0x7f, 0x2c, 0x9a, 0x3f, 0x9c, 0x8e, 0x58, 0x80, 0xdf, 0x8d, 0x5c, 0x75, 0x0c, 0x76,
0x5c, 0x9f, 0xe7, 0x87, 0x42, 0xb6, 0x7c, 0x9f, 0x16, 0x0a, 0x5f, 0x80, 0x1d, 0x17, 0x3c, 0xf9,
0x2b, 0x66, 0x8b, 0xc5, 0xfa, 0xc3, 0x29, 0x5a, 0xf1, 0x69, 0x8f, 0xa0, 0x14, 0x15, 0x28, 0xe8,
0xc1, 0xa4, 0xb8, 0x4d, 0xae, 0x3c, 0xe5, 0xac, 0xbf, 0x82, 0x72, 0x82, 0xbd, 0xf3, 0x33, 0xf5,
0x38, 0xeb, 0xd7, 0x1f, 0x4f, 0xd5, 0x7b, 0x37, 0x02, 0x66, 0xf7, 0x07, 0x5f, 0x6c, 0x9f, 0x10,
0x71, 0x3a, 0x6c, 0x4b, 0x64, 0xb7, 0xb4, 0xe6, 0x07, 0x84, 0x99, 0x5f, 0x5b, 0xd1, 0x29, 0xb7,
0xd4, 0x4a, 0x5b, 0x0a, 0xa7, 0x41, 0xbb, 0xbd, 0xa8, 0x86, 0x1f, 0xfe, 0x2f, 0x00, 0x00, 0xff,
0xff, 0x81, 0x1e, 0xf7, 0xff, 0x33, 0x1e, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

1
internal/proxy/task.go
View File

@ -1530,6 +1530,7 @@ func (dit *dropIndexTask) Execute(ctx context.Context) error {
var err error
dit.result, err = dit.indexCoord.DropIndex(ctx, &indexpb.DropIndexRequest{
CollectionID: dit.collectionID,
PartitionIDs: nil,
IndexName: dit.IndexName,
})
if dit.result == nil {

5
internal/rootcoord/broker.go
View File

@ -35,7 +35,7 @@ type Broker interface {
Flush(ctx context.Context, cID int64, segIDs []int64) error
Import(ctx context.Context, req *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error)
DropCollectionIndex(ctx context.Context, collID UniqueID) error
DropCollectionIndex(ctx context.Context, collID UniqueID, partIDs []UniqueID) error
GetSegmentIndexState(ctx context.Context, collID UniqueID, indexName string, segIDs []UniqueID) ([]*indexpb.SegmentIndexState, error)
}
@ -181,9 +181,10 @@ func (b *ServerBroker) Import(ctx context.Context, req *datapb.ImportTaskRequest
return b.s.dataCoord.Import(ctx, req)
}
func (b *ServerBroker) DropCollectionIndex(ctx context.Context, collID UniqueID) error {
func (b *ServerBroker) DropCollectionIndex(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
rsp, err := b.s.indexCoord.DropIndex(ctx, &indexpb.DropIndexRequest{
CollectionID: collID,
PartitionIDs: partIDs,
IndexName: "",
})
if err != nil {

6
internal/rootcoord/broker_test.go
View File

@ -216,7 +216,7 @@ func TestServerBroker_DropCollectionIndex(t *testing.T) {
c := newTestCore(withInvalidIndexCoord())
b := newServerBroker(c)
ctx := context.Background()
err := b.DropCollectionIndex(ctx, 1)
err := b.DropCollectionIndex(ctx, 1, nil)
assert.Error(t, err)
})
@ -224,7 +224,7 @@ func TestServerBroker_DropCollectionIndex(t *testing.T) {
c := newTestCore(withFailedIndexCoord())
b := newServerBroker(c)
ctx := context.Background()
err := b.DropCollectionIndex(ctx, 1)
err := b.DropCollectionIndex(ctx, 1, nil)
assert.Error(t, err)
})
@ -232,7 +232,7 @@ func TestServerBroker_DropCollectionIndex(t *testing.T) {
c := newTestCore(withValidIndexCoord())
b := newServerBroker(c)
ctx := context.Background()
err := b.DropCollectionIndex(ctx, 1)
err := b.DropCollectionIndex(ctx, 1, nil)
assert.NoError(t, err)
})
}

1
internal/rootcoord/drop_collection_task.go
View File

@ -74,6 +74,7 @@ func (t *dropCollectionTask) Execute(ctx context.Context) error {
redoTask.AddAsyncStep(&dropIndexStep{
baseStep: baseStep{core: t.core},
collID: collMeta.CollectionID,
partIDs: nil,
})
redoTask.AddAsyncStep(&deleteCollectionDataStep{
baseStep: baseStep{core: t.core},

2
internal/rootcoord/drop_collection_task_test.go
View File

@ -165,7 +165,7 @@ func Test_dropCollectionTask_Execute(t *testing.T) {
}
dropIndexCalled := false
dropIndexChan := make(chan struct{}, 1)
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID) error {
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
dropIndexCalled = true
dropIndexChan <- struct{}{}
return nil

6
internal/rootcoord/drop_partition_task.go
View File

@ -68,6 +68,12 @@ func (t *dropPartitionTask) Execute(ctx context.Context) error {
ts: t.GetTs(),
})
redoTask.AddAsyncStep(&dropIndexStep{
baseStep: baseStep{core: t.core},
collID: t.collMeta.CollectionID,
partIDs: []UniqueID{partID},
})
// TODO: release partition when query coord is ready.
redoTask.AddAsyncStep(&deletePartitionDataStep{
baseStep: baseStep{core: t.core},

2
internal/rootcoord/drop_partition_task_test.go
View File

@ -150,7 +150,7 @@ func Test_dropPartitionTask_Execute(t *testing.T) {
return 0, nil
}
core := newTestCore(withValidProxyManager(), withMeta(meta), withGarbageCollector(gc))
core := newTestCore(withValidProxyManager(), withMeta(meta), withGarbageCollector(gc), withDropIndex())
task := &dropPartitionTask{
baseTaskV2: baseTaskV2{core: core},

6
internal/rootcoord/garbage_collector.go
View File

@ -38,6 +38,7 @@ func (c *bgGarbageCollector) ReDropCollection(collMeta *model.Collection, ts Tim
redo.AddAsyncStep(&dropIndexStep{
baseStep: baseStep{core: c.s},
collID: collMeta.CollectionID,
partIDs: nil,
})
redo.AddAsyncStep(&deleteCollectionDataStep{
baseStep: baseStep{core: c.s},
@ -93,6 +94,11 @@ func (c *bgGarbageCollector) ReDropPartition(pChannels []string, partition *mode
baseStep: baseStep{core: c.s},
pChannels: pChannels,
})
redo.AddAsyncStep(&dropIndexStep{
baseStep: baseStep{core: c.s},
collID: partition.CollectionID,
partIDs: []UniqueID{partition.PartitionID},
})
redo.AddAsyncStep(&removePartitionMetaStep{
baseStep: baseStep{core: c.s},
collectionID: partition.CollectionID,

14
internal/rootcoord/garbage_collector_test.go
View File

@ -31,7 +31,7 @@ func TestGarbageCollectorCtx_ReDropCollection(t *testing.T) {
releaseCollectionChan <- struct{}{}
return nil
}
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID) error {
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
return errors.New("error mock DropCollectionIndex")
}
ticker := newTickerWithMockNormalStream()
@ -54,7 +54,7 @@ func TestGarbageCollectorCtx_ReDropCollection(t *testing.T) {
}
dropCollectionIndexCalled := false
dropCollectionIndexChan := make(chan struct{}, 1)
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID) error {
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
dropCollectionIndexCalled = true
dropCollectionIndexChan <- struct{}{}
return nil
@ -88,7 +88,7 @@ func TestGarbageCollectorCtx_ReDropCollection(t *testing.T) {
}
dropCollectionIndexCalled := false
dropCollectionIndexChan := make(chan struct{}, 1)
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID) error {
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
dropCollectionIndexCalled = true
dropCollectionIndexChan <- struct{}{}
return nil
@ -127,7 +127,7 @@ func TestGarbageCollectorCtx_ReDropCollection(t *testing.T) {
}
dropCollectionIndexCalled := false
dropCollectionIndexChan := make(chan struct{}, 1)
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID) error {
broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
dropCollectionIndexCalled = true
dropCollectionIndexChan <- struct{}{}
return nil
@ -230,7 +230,7 @@ func TestGarbageCollectorCtx_ReDropPartition(t *testing.T) {
tsoAllocator.GenerateTSOF = func(count uint32) (uint64, error) {
return 100, nil
}
core := newTestCore(withTtSynchronizer(ticker), withTsoAllocator(tsoAllocator))
core := newTestCore(withTtSynchronizer(ticker), withTsoAllocator(tsoAllocator), withDropIndex())
core.ddlTsLockManager = newDdlTsLockManagerV2(core.tsoAllocator)
gc := newBgGarbageCollector(core)
core.garbageCollector = gc
@ -249,7 +249,7 @@ func TestGarbageCollectorCtx_ReDropPartition(t *testing.T) {
tsoAllocator.GenerateTSOF = func(count uint32) (uint64, error) {
return 100, nil
}
core := newTestCore(withMeta(meta), withTtSynchronizer(ticker), withTsoAllocator(tsoAllocator))
core := newTestCore(withMeta(meta), withTtSynchronizer(ticker), withTsoAllocator(tsoAllocator), withDropIndex())
core.ddlTsLockManager = newDdlTsLockManagerV2(core.tsoAllocator)
gc := newBgGarbageCollector(core)
core.garbageCollector = gc
@ -272,7 +272,7 @@ func TestGarbageCollectorCtx_ReDropPartition(t *testing.T) {
tsoAllocator.GenerateTSOF = func(count uint32) (uint64, error) {
return 100, nil
}
core := newTestCore(withMeta(meta), withTtSynchronizer(ticker), withTsoAllocator(tsoAllocator))
core := newTestCore(withMeta(meta), withTtSynchronizer(ticker), withTsoAllocator(tsoAllocator), withDropIndex())
core.ddlTsLockManager = newDdlTsLockManagerV2(core.tsoAllocator)
gc := newBgGarbageCollector(core)
core.garbageCollector = gc

16
internal/rootcoord/mock_test.go
View File

@ -296,6 +296,16 @@ func withInvalidProxyManager() Opt {
}
}
func withDropIndex() Opt {
return func(c *Core) {
c.broker = &mockBroker{
DropCollectionIndexFunc: func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
return nil
},
}
}
}
func withMeta(meta IMetaTable) Opt {
return func(c *Core) {
c.meta = meta
@ -743,7 +753,7 @@ type mockBroker struct {
FlushFunc func(ctx context.Context, cID int64, segIDs []int64) error
ImportFunc func(ctx context.Context, req *datapb.ImportTaskRequest) (*datapb.ImportTaskResponse, error)
DropCollectionIndexFunc func(ctx context.Context, collID UniqueID) error
DropCollectionIndexFunc func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error
}
func newMockBroker() *mockBroker {
@ -762,8 +772,8 @@ func (b mockBroker) ReleaseCollection(ctx context.Context, collectionID UniqueID
return b.ReleaseCollectionFunc(ctx, collectionID)
}
func (b mockBroker) DropCollectionIndex(ctx context.Context, collID UniqueID) error {
return b.DropCollectionIndexFunc(ctx, collID)
func (b mockBroker) DropCollectionIndex(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
return b.DropCollectionIndexFunc(ctx, collID, partIDs)
}
func withBroker(b Broker) Opt {

5
internal/rootcoord/step.go
View File

@ -252,11 +252,12 @@ func (s *releaseCollectionStep) Weight() stepPriority {
type dropIndexStep struct {
baseStep
collID UniqueID
collID UniqueID
partIDs []UniqueID
}
func (s *dropIndexStep) Execute(ctx context.Context) ([]nestedStep, error) {
err := s.core.broker.DropCollectionIndex(ctx, s.collID)
err := s.core.broker.DropCollectionIndex(ctx, s.collID, s.partIDs)
return nil, err
}