Remove collection meta after GC finished (#21595)

Signed-off-by: longjiquan <jiquan.long@zilliz.com>

Makefile

@@ -297,6 +297,9 @@ mock-datanode:
 mock-rootcoord:
 	mockery --name=RootCoord --dir=$(PWD)/internal/types --output=$(PWD)/internal/mocks --filename=mock_rootcoord.go --with-expecter
 
+mock-datacoord:
+	mockery --name=DataCoord --dir=$(PWD)/internal/types --output=$(PWD)/internal/mocks --filename=mock_datacoord.go --with-expecter
+
 mock-tnx-kv:
 	mockery --name=TxnKV --dir=$(PWD)/internal/kv --output=$(PWD)/internal/kv/mocks --filename=TxnKV.go --with-expecter
 

internal/datacoord/meta.go

@@ -1269,6 +1269,10 @@ func (m *meta) DropChannelCheckpoint(vChannel string) error {
 	return nil
 }
 
+func (m *meta) GcConfirm(ctx context.Context, collectionID, partitionID UniqueID) bool {
+	return m.catalog.GcConfirm(ctx, collectionID, partitionID)
+}
+
 // addNewSeg update metrics update for a new segment.
 func (s *segMetricMutation) addNewSeg(state commonpb.SegmentState, rowCount int64) {
 	s.stateChange[state.String()]++

internal/datacoord/meta_test.go

@@ -23,19 +23,18 @@ import (
 	"testing"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/samber/lo"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
 	"github.com/milvus-io/milvus/internal/common"
 	"github.com/milvus-io/milvus/internal/kv"
 	"github.com/milvus-io/milvus/internal/metastore/kv/datacoord"
-	"github.com/milvus-io/milvus/internal/metastore/mocks"
 	"github.com/milvus-io/milvus/internal/metastore/model"
+	"github.com/milvus-io/milvus/internal/mocks"
 	"github.com/milvus-io/milvus/internal/proto/datapb"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
+	"github.com/samber/lo"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMetaReloadFromKV(t *testing.T) {
@@ -945,3 +944,17 @@ func TestChannelCP(t *testing.T) {
 		assert.NoError(t, err)
 	})
 }
+
+func Test_meta_GcConfirm(t *testing.T) {
+	m := &meta{}
+	catalog := mocks.NewDataCoordCatalog(t)
+	m.catalog = catalog
+
+	catalog.On("GcConfirm",
+		mock.Anything,
+		mock.AnythingOfType("int64"),
+		mock.AnythingOfType("int64")).
+		Return(false)
+
+	assert.False(t, m.GcConfirm(context.TODO(), 100, 10000))
+}

internal/datacoord/services.go

@@ -1443,3 +1443,21 @@ func (s *Server) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthReque
 
 	return &milvuspb.CheckHealthResponse{IsHealthy: true, Reasons: errReasons}, nil
 }
+
+func (s *Server) GcConfirm(ctx context.Context, request *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
+	resp := &datapb.GcConfirmResponse{
+		Status: &commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_UnexpectedError,
+		},
+		GcFinished: false,
+	}
+
+	if s.isClosed() {
+		resp.Status.Reason = msgDataCoordIsUnhealthy(paramtable.GetNodeID())
+		return resp, nil
+	}
+
+	resp.GcFinished = s.meta.GcConfirm(ctx, request.GetCollectionId(), request.GetPartitionId())
+	resp.Status.ErrorCode = commonpb.ErrorCode_Success
+	return resp, nil
+}

internal/datacoord/services_test.go

@@ -4,6 +4,9 @@ import (
 	"context"
 	"testing"
 
+	"github.com/milvus-io/milvus/internal/mocks"
+	"github.com/stretchr/testify/mock"
+
 	"github.com/stretchr/testify/assert"
 
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
@@ -54,3 +57,35 @@ func TestBroadcastAlteredCollection(t *testing.T) {
 		assert.NotNil(t, s.meta.collections[1].Properties)
 	})
 }
+
+func TestServer_GcConfirm(t *testing.T) {
+	t.Run("closed server", func(t *testing.T) {
+		s := &Server{}
+		s.stateCode.Store(commonpb.StateCode_Initializing)
+		resp, err := s.GcConfirm(context.TODO(), &datapb.GcConfirmRequest{CollectionId: 100, PartitionId: 10000})
+		assert.NoError(t, err)
+		assert.NotEqual(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
+	})
+
+	t.Run("normal case", func(t *testing.T) {
+		s := &Server{}
+		s.stateCode.Store(commonpb.StateCode_Healthy)
+
+		m := &meta{}
+		catalog := mocks.NewDataCoordCatalog(t)
+		m.catalog = catalog
+
+		catalog.On("GcConfirm",
+			mock.Anything,
+			mock.AnythingOfType("int64"),
+			mock.AnythingOfType("int64")).
+			Return(false)
+
+		s.meta = m
+
+		resp, err := s.GcConfirm(context.TODO(), &datapb.GcConfirmRequest{CollectionId: 100, PartitionId: 10000})
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
+		assert.False(t, resp.GetGcFinished())
+	})
+}

internal/distributed/datacoord/client/client.go

@@ -760,6 +760,19 @@ func (c *Client) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthReque
 	return ret.(*milvuspb.CheckHealthResponse), err
 }
 
+func (c *Client) GcConfirm(ctx context.Context, req *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
+	ret, err := c.grpcClient.ReCall(ctx, func(client datapb.DataCoordClient) (any, error) {
+		if !funcutil.CheckCtxValid(ctx) {
+			return nil, ctx.Err()
+		}
+		return client.GcConfirm(ctx, req)
+	})
+	if err != nil || ret == nil {
+		return nil, err
+	}
+	return ret.(*datapb.GcConfirmResponse), err
+}
+
 // CreateIndex sends the build index request to IndexCoord.
 func (c *Client) CreateIndex(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
 	ret, err := c.grpcClient.ReCall(ctx, func(client datapb.DataCoordClient) (any, error) {

internal/distributed/datacoord/service.go

@@ -386,6 +386,10 @@ func (s *Server) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthReque
 	return s.dataCoord.CheckHealth(ctx, req)
 }
 
+func (s *Server) GcConfirm(ctx context.Context, request *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
+	return s.dataCoord.GcConfirm(ctx, request)
+}
+
 // CreateIndex sends the build index request to DataCoord.
 func (s *Server) CreateIndex(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
 	return s.dataCoord.CreateIndex(ctx, req)

internal/distributed/datacoord/service_test.go

@@ -21,12 +21,12 @@ import (
 	"errors"
 	"testing"
 
-	"github.com/milvus-io/milvus/internal/proto/indexpb"
-
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
 	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
 	"github.com/milvus-io/milvus/internal/proto/datapb"
+	"github.com/milvus-io/milvus/internal/proto/indexpb"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
+	"github.com/milvus-io/milvus/internal/types"
 	"github.com/milvus-io/milvus/internal/util/paramtable"
 	"github.com/stretchr/testify/assert"
 	clientv3 "go.etcd.io/etcd/client/v3"
@@ -34,6 +34,8 @@ import (
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 type MockDataCoord struct {
+	types.DataCoord
+
 	states                    *milvuspb.ComponentStates
 	status                    *commonpb.Status
 	err                       error

internal/distributed/proxy/service_test.go

@@ -554,6 +554,10 @@ func (m *MockDataCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHeal
 	return nil, nil
 }
 
+func (m *MockDataCoord) GcConfirm(ctx context.Context, req *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
+	return nil, nil
+}
+
 func (m *MockDataCoord) CreateIndex(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
 	return nil, nil
 }

internal/kv/mocks/MetaKv.go

@@ -82,10 +82,10 @@ type MetaKv_CompareValueAndSwap_Call struct {
 }
 
 // CompareValueAndSwap is a helper method to define mock.On call
-//   - key string
+//  - key string
-//   - value string
+//  - value string
-//   - target string
+//  - target string
-//   - opts ...clientv3.OpOption
+//  - opts ...clientv3.OpOption
 func (_e *MetaKv_Expecter) CompareValueAndSwap(key interface{}, value interface{}, target interface{}, opts ...interface{}) *MetaKv_CompareValueAndSwap_Call {
 	return &MetaKv_CompareValueAndSwap_Call{Call: _e.mock.On("CompareValueAndSwap",
 		append([]interface{}{key, value, target}, opts...)...)}
@@ -143,10 +143,10 @@ type MetaKv_CompareVersionAndSwap_Call struct {
 }
 
 // CompareVersionAndSwap is a helper method to define mock.On call
-//   - key string
+//  - key string
-//   - version int64
+//  - version int64
-//   - target string
+//  - target string
-//   - opts ...clientv3.OpOption
+//  - opts ...clientv3.OpOption
 func (_e *MetaKv_Expecter) CompareVersionAndSwap(key interface{}, version interface{}, target interface{}, opts ...interface{}) *MetaKv_CompareVersionAndSwap_Call {
 	return &MetaKv_CompareVersionAndSwap_Call{Call: _e.mock.On("CompareVersionAndSwap",
 		append([]interface{}{key, version, target}, opts...)...)}
@@ -190,7 +190,7 @@ type MetaKv_GetPath_Call struct {
 }
 
 // GetPath is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *MetaKv_Expecter) GetPath(key interface{}) *MetaKv_GetPath_Call {
 	return &MetaKv_GetPath_Call{Call: _e.mock.On("GetPath", key)}
 }
@@ -234,7 +234,7 @@ type MetaKv_Grant_Call struct {
 }
 
 // Grant is a helper method to define mock.On call
-//   - ttl int64
+//  - ttl int64
 func (_e *MetaKv_Expecter) Grant(ttl interface{}) *MetaKv_Grant_Call {
 	return &MetaKv_Grant_Call{Call: _e.mock.On("Grant", ttl)}
 }
@@ -280,7 +280,7 @@ type MetaKv_KeepAlive_Call struct {
 }
 
 // KeepAlive is a helper method to define mock.On call
-//   - id clientv3.LeaseID
+//  - id clientv3.LeaseID
 func (_e *MetaKv_Expecter) KeepAlive(id interface{}) *MetaKv_KeepAlive_Call {
 	return &MetaKv_KeepAlive_Call{Call: _e.mock.On("KeepAlive", id)}
 }
@@ -324,7 +324,7 @@ type MetaKv_Load_Call struct {
 }
 
 // Load is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *MetaKv_Expecter) Load(key interface{}) *MetaKv_Load_Call {
 	return &MetaKv_Load_Call{Call: _e.mock.On("Load", key)}
 }
@@ -379,7 +379,7 @@ type MetaKv_LoadWithPrefix_Call struct {
 }
 
 // LoadWithPrefix is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *MetaKv_Expecter) LoadWithPrefix(key interface{}) *MetaKv_LoadWithPrefix_Call {
 	return &MetaKv_LoadWithPrefix_Call{Call: _e.mock.On("LoadWithPrefix", key)}
 }
@@ -443,7 +443,7 @@ type MetaKv_LoadWithPrefix2_Call struct {
 }
 
 // LoadWithPrefix2 is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *MetaKv_Expecter) LoadWithPrefix2(key interface{}) *MetaKv_LoadWithPrefix2_Call {
 	return &MetaKv_LoadWithPrefix2_Call{Call: _e.mock.On("LoadWithPrefix2", key)}
 }
@@ -505,7 +505,7 @@ type MetaKv_LoadWithRevision_Call struct {
 }
 
 // LoadWithRevision is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *MetaKv_Expecter) LoadWithRevision(key interface{}) *MetaKv_LoadWithRevision_Call {
 	return &MetaKv_LoadWithRevision_Call{Call: _e.mock.On("LoadWithRevision", key)}
 }
@@ -576,7 +576,7 @@ type MetaKv_LoadWithRevisionAndVersions_Call struct {
 }
 
 // LoadWithRevisionAndVersions is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *MetaKv_Expecter) LoadWithRevisionAndVersions(key interface{}) *MetaKv_LoadWithRevisionAndVersions_Call {
 	return &MetaKv_LoadWithRevisionAndVersions_Call{Call: _e.mock.On("LoadWithRevisionAndVersions", key)}
 }
@@ -622,7 +622,7 @@ type MetaKv_MultiLoad_Call struct {
 }
 
 // MultiLoad is a helper method to define mock.On call
-//   - keys []string
+//  - keys []string
 func (_e *MetaKv_Expecter) MultiLoad(keys interface{}) *MetaKv_MultiLoad_Call {
 	return &MetaKv_MultiLoad_Call{Call: _e.mock.On("MultiLoad", keys)}
 }
@@ -659,7 +659,7 @@ type MetaKv_MultiRemove_Call struct {
 }
 
 // MultiRemove is a helper method to define mock.On call
-//   - keys []string
+//  - keys []string
 func (_e *MetaKv_Expecter) MultiRemove(keys interface{}) *MetaKv_MultiRemove_Call {
 	return &MetaKv_MultiRemove_Call{Call: _e.mock.On("MultiRemove", keys)}
 }
@@ -696,7 +696,7 @@ type MetaKv_MultiRemoveWithPrefix_Call struct {
 }
 
 // MultiRemoveWithPrefix is a helper method to define mock.On call
-//   - keys []string
+//  - keys []string
 func (_e *MetaKv_Expecter) MultiRemoveWithPrefix(keys interface{}) *MetaKv_MultiRemoveWithPrefix_Call {
 	return &MetaKv_MultiRemoveWithPrefix_Call{Call: _e.mock.On("MultiRemoveWithPrefix", keys)}
 }
@@ -733,7 +733,7 @@ type MetaKv_MultiSave_Call struct {
 }
 
 // MultiSave is a helper method to define mock.On call
-//   - kvs map[string]string
+//  - kvs map[string]string
 func (_e *MetaKv_Expecter) MultiSave(kvs interface{}) *MetaKv_MultiSave_Call {
 	return &MetaKv_MultiSave_Call{Call: _e.mock.On("MultiSave", kvs)}
 }
@@ -770,8 +770,8 @@ type MetaKv_MultiSaveAndRemove_Call struct {
 }
 
 // MultiSaveAndRemove is a helper method to define mock.On call
-//   - saves map[string]string
+//  - saves map[string]string
-//   - removals []string
+//  - removals []string
 func (_e *MetaKv_Expecter) MultiSaveAndRemove(saves interface{}, removals interface{}) *MetaKv_MultiSaveAndRemove_Call {
 	return &MetaKv_MultiSaveAndRemove_Call{Call: _e.mock.On("MultiSaveAndRemove", saves, removals)}
 }
@@ -808,8 +808,8 @@ type MetaKv_MultiSaveAndRemoveWithPrefix_Call struct {
 }
 
 // MultiSaveAndRemoveWithPrefix is a helper method to define mock.On call
-//   - saves map[string]string
+//  - saves map[string]string
-//   - removals []string
+//  - removals []string
 func (_e *MetaKv_Expecter) MultiSaveAndRemoveWithPrefix(saves interface{}, removals interface{}) *MetaKv_MultiSaveAndRemoveWithPrefix_Call {
 	return &MetaKv_MultiSaveAndRemoveWithPrefix_Call{Call: _e.mock.On("MultiSaveAndRemoveWithPrefix", saves, removals)}
 }
@@ -846,7 +846,7 @@ type MetaKv_Remove_Call struct {
 }
 
 // Remove is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *MetaKv_Expecter) Remove(key interface{}) *MetaKv_Remove_Call {
 	return &MetaKv_Remove_Call{Call: _e.mock.On("Remove", key)}
 }
@@ -883,7 +883,7 @@ type MetaKv_RemoveWithPrefix_Call struct {
 }
 
 // RemoveWithPrefix is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *MetaKv_Expecter) RemoveWithPrefix(key interface{}) *MetaKv_RemoveWithPrefix_Call {
 	return &MetaKv_RemoveWithPrefix_Call{Call: _e.mock.On("RemoveWithPrefix", key)}
 }
@@ -920,8 +920,8 @@ type MetaKv_Save_Call struct {
 }
 
 // Save is a helper method to define mock.On call
-//   - key string
+//  - key string
-//   - value string
+//  - value string
 func (_e *MetaKv_Expecter) Save(key interface{}, value interface{}) *MetaKv_Save_Call {
 	return &MetaKv_Save_Call{Call: _e.mock.On("Save", key, value)}
 }
@@ -958,8 +958,8 @@ type MetaKv_SaveWithIgnoreLease_Call struct {
 }
 
 // SaveWithIgnoreLease is a helper method to define mock.On call
-//   - key string
+//  - key string
-//   - value string
+//  - value string
 func (_e *MetaKv_Expecter) SaveWithIgnoreLease(key interface{}, value interface{}) *MetaKv_SaveWithIgnoreLease_Call {
 	return &MetaKv_SaveWithIgnoreLease_Call{Call: _e.mock.On("SaveWithIgnoreLease", key, value)}
 }
@@ -996,9 +996,9 @@ type MetaKv_SaveWithLease_Call struct {
 }
 
 // SaveWithLease is a helper method to define mock.On call
-//   - key string
+//  - key string
-//   - value string
+//  - value string
-//   - id clientv3.LeaseID
+//  - id clientv3.LeaseID
 func (_e *MetaKv_Expecter) SaveWithLease(key interface{}, value interface{}, id interface{}) *MetaKv_SaveWithLease_Call {
 	return &MetaKv_SaveWithLease_Call{Call: _e.mock.On("SaveWithLease", key, value, id)}
 }
@@ -1035,9 +1035,9 @@ type MetaKv_WalkWithPrefix_Call struct {
 }
 
 // WalkWithPrefix is a helper method to define mock.On call
-//   - prefix string
+//  - prefix string
-//   - paginationSize int
+//  - paginationSize int
-//   - fn func([]byte , []byte) error
+//  - fn func([]byte , []byte) error
 func (_e *MetaKv_Expecter) WalkWithPrefix(prefix interface{}, paginationSize interface{}, fn interface{}) *MetaKv_WalkWithPrefix_Call {
 	return &MetaKv_WalkWithPrefix_Call{Call: _e.mock.On("WalkWithPrefix", prefix, paginationSize, fn)}
 }
@@ -1076,7 +1076,7 @@ type MetaKv_Watch_Call struct {
 }
 
 // Watch is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *MetaKv_Expecter) Watch(key interface{}) *MetaKv_Watch_Call {
 	return &MetaKv_Watch_Call{Call: _e.mock.On("Watch", key)}
 }
@@ -1115,7 +1115,7 @@ type MetaKv_WatchWithPrefix_Call struct {
 }
 
 // WatchWithPrefix is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *MetaKv_Expecter) WatchWithPrefix(key interface{}) *MetaKv_WatchWithPrefix_Call {
 	return &MetaKv_WatchWithPrefix_Call{Call: _e.mock.On("WatchWithPrefix", key)}
 }
@@ -1154,8 +1154,8 @@ type MetaKv_WatchWithRevision_Call struct {
 }
 
 // WatchWithRevision is a helper method to define mock.On call
-//   - key string
+//  - key string
-//   - revision int64
+//  - revision int64
 func (_e *MetaKv_Expecter) WatchWithRevision(key interface{}, revision interface{}) *MetaKv_WatchWithRevision_Call {
 	return &MetaKv_WatchWithRevision_Call{Call: _e.mock.On("WatchWithRevision", key, revision)}
 }

internal/kv/mocks/SnapShotKV.go

@@ -44,8 +44,8 @@ type SnapShotKV_Load_Call struct {
 }
 
 // Load is a helper method to define mock.On call
-//   - key string
+//  - key string
-//   - ts uint64
+//  - ts uint64
 func (_e *SnapShotKV_Expecter) Load(key interface{}, ts interface{}) *SnapShotKV_Load_Call {
 	return &SnapShotKV_Load_Call{Call: _e.mock.On("Load", key, ts)}
 }
@@ -100,8 +100,8 @@ type SnapShotKV_LoadWithPrefix_Call struct {
 }
 
 // LoadWithPrefix is a helper method to define mock.On call
-//   - key string
+//  - key string
-//   - ts uint64
+//  - ts uint64
 func (_e *SnapShotKV_Expecter) LoadWithPrefix(key interface{}, ts interface{}) *SnapShotKV_LoadWithPrefix_Call {
 	return &SnapShotKV_LoadWithPrefix_Call{Call: _e.mock.On("LoadWithPrefix", key, ts)}
 }
@@ -138,8 +138,8 @@ type SnapShotKV_MultiSave_Call struct {
 }
 
 // MultiSave is a helper method to define mock.On call
-//   - kvs map[string]string
+//  - kvs map[string]string
-//   - ts uint64
+//  - ts uint64
 func (_e *SnapShotKV_Expecter) MultiSave(kvs interface{}, ts interface{}) *SnapShotKV_MultiSave_Call {
 	return &SnapShotKV_MultiSave_Call{Call: _e.mock.On("MultiSave", kvs, ts)}
 }
@@ -176,9 +176,9 @@ type SnapShotKV_MultiSaveAndRemoveWithPrefix_Call struct {
 }
 
 // MultiSaveAndRemoveWithPrefix is a helper method to define mock.On call
-//   - saves map[string]string
+//  - saves map[string]string
-//   - removals []string
+//  - removals []string
-//   - ts uint64
+//  - ts uint64
 func (_e *SnapShotKV_Expecter) MultiSaveAndRemoveWithPrefix(saves interface{}, removals interface{}, ts interface{}) *SnapShotKV_MultiSaveAndRemoveWithPrefix_Call {
 	return &SnapShotKV_MultiSaveAndRemoveWithPrefix_Call{Call: _e.mock.On("MultiSaveAndRemoveWithPrefix", saves, removals, ts)}
 }
@@ -215,9 +215,9 @@ type SnapShotKV_Save_Call struct {
 }
 
 // Save is a helper method to define mock.On call
-//   - key string
+//  - key string
-//   - value string
+//  - value string
-//   - ts uint64
+//  - ts uint64
 func (_e *SnapShotKV_Expecter) Save(key interface{}, value interface{}, ts interface{}) *SnapShotKV_Save_Call {
 	return &SnapShotKV_Save_Call{Call: _e.mock.On("Save", key, value, ts)}
 }

internal/kv/mocks/TxnKV.go

@@ -71,7 +71,7 @@ type TxnKV_Load_Call struct {
 }
 
 // Load is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *TxnKV_Expecter) Load(key interface{}) *TxnKV_Load_Call {
 	return &TxnKV_Load_Call{Call: _e.mock.On("Load", key)}
 }
@@ -126,7 +126,7 @@ type TxnKV_LoadWithPrefix_Call struct {
 }
 
 // LoadWithPrefix is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *TxnKV_Expecter) LoadWithPrefix(key interface{}) *TxnKV_LoadWithPrefix_Call {
 	return &TxnKV_LoadWithPrefix_Call{Call: _e.mock.On("LoadWithPrefix", key)}
 }
@@ -172,7 +172,7 @@ type TxnKV_MultiLoad_Call struct {
 }
 
 // MultiLoad is a helper method to define mock.On call
-//   - keys []string
+//  - keys []string
 func (_e *TxnKV_Expecter) MultiLoad(keys interface{}) *TxnKV_MultiLoad_Call {
 	return &TxnKV_MultiLoad_Call{Call: _e.mock.On("MultiLoad", keys)}
 }
@@ -209,7 +209,7 @@ type TxnKV_MultiRemove_Call struct {
 }
 
 // MultiRemove is a helper method to define mock.On call
-//   - keys []string
+//  - keys []string
 func (_e *TxnKV_Expecter) MultiRemove(keys interface{}) *TxnKV_MultiRemove_Call {
 	return &TxnKV_MultiRemove_Call{Call: _e.mock.On("MultiRemove", keys)}
 }
@@ -246,7 +246,7 @@ type TxnKV_MultiRemoveWithPrefix_Call struct {
 }
 
 // MultiRemoveWithPrefix is a helper method to define mock.On call
-//   - keys []string
+//  - keys []string
 func (_e *TxnKV_Expecter) MultiRemoveWithPrefix(keys interface{}) *TxnKV_MultiRemoveWithPrefix_Call {
 	return &TxnKV_MultiRemoveWithPrefix_Call{Call: _e.mock.On("MultiRemoveWithPrefix", keys)}
 }
@@ -283,7 +283,7 @@ type TxnKV_MultiSave_Call struct {
 }
 
 // MultiSave is a helper method to define mock.On call
-//   - kvs map[string]string
+//  - kvs map[string]string
 func (_e *TxnKV_Expecter) MultiSave(kvs interface{}) *TxnKV_MultiSave_Call {
 	return &TxnKV_MultiSave_Call{Call: _e.mock.On("MultiSave", kvs)}
 }
@@ -320,8 +320,8 @@ type TxnKV_MultiSaveAndRemove_Call struct {
 }
 
 // MultiSaveAndRemove is a helper method to define mock.On call
-//   - saves map[string]string
+//  - saves map[string]string
-//   - removals []string
+//  - removals []string
 func (_e *TxnKV_Expecter) MultiSaveAndRemove(saves interface{}, removals interface{}) *TxnKV_MultiSaveAndRemove_Call {
 	return &TxnKV_MultiSaveAndRemove_Call{Call: _e.mock.On("MultiSaveAndRemove", saves, removals)}
 }
@@ -358,8 +358,8 @@ type TxnKV_MultiSaveAndRemoveWithPrefix_Call struct {
 }
 
 // MultiSaveAndRemoveWithPrefix is a helper method to define mock.On call
-//   - saves map[string]string
+//  - saves map[string]string
-//   - removals []string
+//  - removals []string
 func (_e *TxnKV_Expecter) MultiSaveAndRemoveWithPrefix(saves interface{}, removals interface{}) *TxnKV_MultiSaveAndRemoveWithPrefix_Call {
 	return &TxnKV_MultiSaveAndRemoveWithPrefix_Call{Call: _e.mock.On("MultiSaveAndRemoveWithPrefix", saves, removals)}
 }
@@ -396,7 +396,7 @@ type TxnKV_Remove_Call struct {
 }
 
 // Remove is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *TxnKV_Expecter) Remove(key interface{}) *TxnKV_Remove_Call {
 	return &TxnKV_Remove_Call{Call: _e.mock.On("Remove", key)}
 }
@@ -433,7 +433,7 @@ type TxnKV_RemoveWithPrefix_Call struct {
 }
 
 // RemoveWithPrefix is a helper method to define mock.On call
-//   - key string
+//  - key string
 func (_e *TxnKV_Expecter) RemoveWithPrefix(key interface{}) *TxnKV_RemoveWithPrefix_Call {
 	return &TxnKV_RemoveWithPrefix_Call{Call: _e.mock.On("RemoveWithPrefix", key)}
 }
@@ -470,8 +470,8 @@ type TxnKV_Save_Call struct {
 }
 
 // Save is a helper method to define mock.On call
-//   - key string
+//  - key string
-//   - value string
+//  - value string
 func (_e *TxnKV_Expecter) Save(key interface{}, value interface{}) *TxnKV_Save_Call {
 	return &TxnKV_Save_Call{Call: _e.mock.On("Save", key, value)}
 }

internal/metastore/catalog.go

@@ -130,6 +130,8 @@ type DataCoordCatalog interface {
 	AlterSegmentIndex(ctx context.Context, newSegIndex *model.SegmentIndex) error
 	AlterSegmentIndexes(ctx context.Context, newSegIdxes []*model.SegmentIndex) error
 	DropSegmentIndex(ctx context.Context, collID, partID, segID, buildID typeutil.UniqueID) error
+
+	GcConfirm(ctx context.Context, collectionID, partitionID typeutil.UniqueID) bool
 }
 
 type IndexCoordCatalog interface {

internal/metastore/kv/datacoord/kv_catalog.go

@@ -685,6 +685,23 @@ func (kc *Catalog) DropSegmentIndex(ctx context.Context, collID, partID, segID,
 	return nil
 }
 
+const allPartitionID = -1
+
+// GcConfirm returns true if related collection/partition is not found.
+// DataCoord will remove all the meta eventually after GC is finished.
+func (kc *Catalog) GcConfirm(ctx context.Context, collectionID, partitionID typeutil.UniqueID) bool {
+	prefix := buildCollectionPrefix(collectionID)
+	if partitionID != allPartitionID {
+		prefix = buildPartitionPrefix(collectionID, partitionID)
+	}
+	keys, values, err := kc.MetaKv.LoadWithPrefix(prefix)
+	if err != nil {
+		// error case can be regarded as not finished.
+		return false
+	}
+	return len(keys) == 0 && len(values) == 0
+}
+
 func fillLogPathByLogID(chunkManagerRootPath string, binlogType storage.BinlogType, collectionID, partitionID,
 	segmentID typeutil.UniqueID, fieldBinlog *datapb.FieldBinlog) error {
 	for _, binlog := range fieldBinlog.Binlogs {
@@ -956,3 +973,11 @@ func BuildIndexKey(collectionID, indexID int64) string {
 func BuildSegmentIndexKey(collectionID, partitionID, segmentID, buildID int64) string {
 	return fmt.Sprintf("%s/%d/%d/%d/%d", util.SegmentIndexPrefix, collectionID, partitionID, segmentID, buildID)
 }
+
+func buildCollectionPrefix(collectionID typeutil.UniqueID) string {
+	return fmt.Sprintf("%s/%d", SegmentPrefix, collectionID)
+}
+
+func buildPartitionPrefix(collectionID, partitionID typeutil.UniqueID) string {
+	return fmt.Sprintf("%s/%d/%d", SegmentPrefix, collectionID, partitionID)
+}

internal/metastore/kv/datacoord/kv_catalog_test.go

@@ -1346,3 +1346,20 @@ func TestMain(m *testing.M) {
 	code := m.Run()
 	os.Exit(code)
 }
+
+func TestCatalog_GcConfirm(t *testing.T) {
+	kc := &Catalog{}
+	txn := mocks.NewMetaKv(t)
+	kc.MetaKv = txn
+
+	txn.On("LoadWithPrefix",
+		mock.AnythingOfType("string")).
+		Return(nil, nil, errors.New("error mock LoadWithPrefix")).
+		Once()
+	assert.False(t, kc.GcConfirm(context.TODO(), 100, 10000))
+
+	txn.On("LoadWithPrefix",
+		mock.AnythingOfType("string")).
+		Return(nil, nil, nil)
+	assert.True(t, kc.GcConfirm(context.TODO(), 100, 10000))
+}

internal/metastore/mocks/DataCoordCatalog.go

@@ -46,8 +46,8 @@ type DataCoordCatalog_AddSegment_Call struct {
 }
 
 // AddSegment is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - segment *datapb.SegmentInfo
+//  - segment *datapb.SegmentInfo
 func (_e *DataCoordCatalog_Expecter) AddSegment(ctx interface{}, segment interface{}) *DataCoordCatalog_AddSegment_Call {
 	return &DataCoordCatalog_AddSegment_Call{Call: _e.mock.On("AddSegment", ctx, segment)}
 }
@@ -84,8 +84,8 @@ type DataCoordCatalog_AlterIndex_Call struct {
 }
 
 // AlterIndex is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - newIndex *model.Index
+//  - newIndex *model.Index
 func (_e *DataCoordCatalog_Expecter) AlterIndex(ctx interface{}, newIndex interface{}) *DataCoordCatalog_AlterIndex_Call {
 	return &DataCoordCatalog_AlterIndex_Call{Call: _e.mock.On("AlterIndex", ctx, newIndex)}
 }
@@ -122,8 +122,8 @@ type DataCoordCatalog_AlterIndexes_Call struct {
 }
 
 // AlterIndexes is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - newIndexes []*model.Index
+//  - newIndexes []*model.Index
 func (_e *DataCoordCatalog_Expecter) AlterIndexes(ctx interface{}, newIndexes interface{}) *DataCoordCatalog_AlterIndexes_Call {
 	return &DataCoordCatalog_AlterIndexes_Call{Call: _e.mock.On("AlterIndexes", ctx, newIndexes)}
 }
@@ -160,9 +160,9 @@ type DataCoordCatalog_AlterSegment_Call struct {
 }
 
 // AlterSegment is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - newSegment *datapb.SegmentInfo
+//  - newSegment *datapb.SegmentInfo
-//   - oldSegment *datapb.SegmentInfo
+//  - oldSegment *datapb.SegmentInfo
 func (_e *DataCoordCatalog_Expecter) AlterSegment(ctx interface{}, newSegment interface{}, oldSegment interface{}) *DataCoordCatalog_AlterSegment_Call {
 	return &DataCoordCatalog_AlterSegment_Call{Call: _e.mock.On("AlterSegment", ctx, newSegment, oldSegment)}
 }
@@ -199,8 +199,8 @@ type DataCoordCatalog_AlterSegmentIndex_Call struct {
 }
 
 // AlterSegmentIndex is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - newSegIndex *model.SegmentIndex
+//  - newSegIndex *model.SegmentIndex
 func (_e *DataCoordCatalog_Expecter) AlterSegmentIndex(ctx interface{}, newSegIndex interface{}) *DataCoordCatalog_AlterSegmentIndex_Call {
 	return &DataCoordCatalog_AlterSegmentIndex_Call{Call: _e.mock.On("AlterSegmentIndex", ctx, newSegIndex)}
 }
@@ -237,8 +237,8 @@ type DataCoordCatalog_AlterSegmentIndexes_Call struct {
 }
 
 // AlterSegmentIndexes is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - newSegIdxes []*model.SegmentIndex
+//  - newSegIdxes []*model.SegmentIndex
 func (_e *DataCoordCatalog_Expecter) AlterSegmentIndexes(ctx interface{}, newSegIdxes interface{}) *DataCoordCatalog_AlterSegmentIndexes_Call {
 	return &DataCoordCatalog_AlterSegmentIndexes_Call{Call: _e.mock.On("AlterSegmentIndexes", ctx, newSegIdxes)}
 }
@@ -275,8 +275,8 @@ type DataCoordCatalog_AlterSegments_Call struct {
 }
 
 // AlterSegments is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - newSegments []*datapb.SegmentInfo
+//  - newSegments []*datapb.SegmentInfo
 func (_e *DataCoordCatalog_Expecter) AlterSegments(ctx interface{}, newSegments interface{}) *DataCoordCatalog_AlterSegments_Call {
 	return &DataCoordCatalog_AlterSegments_Call{Call: _e.mock.On("AlterSegments", ctx, newSegments)}
 }
@@ -313,9 +313,9 @@ type DataCoordCatalog_AlterSegmentsAndAddNewSegment_Call struct {
 }
 
 // AlterSegmentsAndAddNewSegment is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - segments []*datapb.SegmentInfo
+//  - segments []*datapb.SegmentInfo
-//   - newSegment *datapb.SegmentInfo
+//  - newSegment *datapb.SegmentInfo
 func (_e *DataCoordCatalog_Expecter) AlterSegmentsAndAddNewSegment(ctx interface{}, segments interface{}, newSegment interface{}) *DataCoordCatalog_AlterSegmentsAndAddNewSegment_Call {
 	return &DataCoordCatalog_AlterSegmentsAndAddNewSegment_Call{Call: _e.mock.On("AlterSegmentsAndAddNewSegment", ctx, segments, newSegment)}
 }
@@ -352,8 +352,8 @@ type DataCoordCatalog_CreateIndex_Call struct {
 }
 
 // CreateIndex is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - index *model.Index
+//  - index *model.Index
 func (_e *DataCoordCatalog_Expecter) CreateIndex(ctx interface{}, index interface{}) *DataCoordCatalog_CreateIndex_Call {
 	return &DataCoordCatalog_CreateIndex_Call{Call: _e.mock.On("CreateIndex", ctx, index)}
 }
@@ -390,8 +390,8 @@ type DataCoordCatalog_CreateSegmentIndex_Call struct {
 }
 
 // CreateSegmentIndex is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - segIdx *model.SegmentIndex
+//  - segIdx *model.SegmentIndex
 func (_e *DataCoordCatalog_Expecter) CreateSegmentIndex(ctx interface{}, segIdx interface{}) *DataCoordCatalog_CreateSegmentIndex_Call {
 	return &DataCoordCatalog_CreateSegmentIndex_Call{Call: _e.mock.On("CreateSegmentIndex", ctx, segIdx)}
 }
@@ -428,8 +428,8 @@ type DataCoordCatalog_DropChannel_Call struct {
 }
 
 // DropChannel is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - channel string
+//  - channel string
 func (_e *DataCoordCatalog_Expecter) DropChannel(ctx interface{}, channel interface{}) *DataCoordCatalog_DropChannel_Call {
 	return &DataCoordCatalog_DropChannel_Call{Call: _e.mock.On("DropChannel", ctx, channel)}
 }
@@ -466,8 +466,8 @@ type DataCoordCatalog_DropChannelCheckpoint_Call struct {
 }
 
 // DropChannelCheckpoint is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - vChannel string
+//  - vChannel string
 func (_e *DataCoordCatalog_Expecter) DropChannelCheckpoint(ctx interface{}, vChannel interface{}) *DataCoordCatalog_DropChannelCheckpoint_Call {
 	return &DataCoordCatalog_DropChannelCheckpoint_Call{Call: _e.mock.On("DropChannelCheckpoint", ctx, vChannel)}
 }
@@ -504,9 +504,9 @@ type DataCoordCatalog_DropIndex_Call struct {
 }
 
 // DropIndex is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - collID int64
+//  - collID int64
-//   - dropIdxID int64
+//  - dropIdxID int64
 func (_e *DataCoordCatalog_Expecter) DropIndex(ctx interface{}, collID interface{}, dropIdxID interface{}) *DataCoordCatalog_DropIndex_Call {
 	return &DataCoordCatalog_DropIndex_Call{Call: _e.mock.On("DropIndex", ctx, collID, dropIdxID)}
 }
@@ -543,8 +543,8 @@ type DataCoordCatalog_DropSegment_Call struct {
 }
 
 // DropSegment is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - segment *datapb.SegmentInfo
+//  - segment *datapb.SegmentInfo
 func (_e *DataCoordCatalog_Expecter) DropSegment(ctx interface{}, segment interface{}) *DataCoordCatalog_DropSegment_Call {
 	return &DataCoordCatalog_DropSegment_Call{Call: _e.mock.On("DropSegment", ctx, segment)}
 }
@@ -581,11 +581,11 @@ type DataCoordCatalog_DropSegmentIndex_Call struct {
 }
 
 // DropSegmentIndex is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - collID int64
+//  - collID int64
-//   - partID int64
+//  - partID int64
-//   - segID int64
+//  - segID int64
-//   - buildID int64
+//  - buildID int64
 func (_e *DataCoordCatalog_Expecter) DropSegmentIndex(ctx interface{}, collID interface{}, partID interface{}, segID interface{}, buildID interface{}) *DataCoordCatalog_DropSegmentIndex_Call {
 	return &DataCoordCatalog_DropSegmentIndex_Call{Call: _e.mock.On("DropSegmentIndex", ctx, collID, partID, segID, buildID)}
 }
@@ -602,6 +602,45 @@ func (_c *DataCoordCatalog_DropSegmentIndex_Call) Return(_a0 error) *DataCoordCa
 	return _c
 }
 
+// GcConfirm provides a mock function with given fields: ctx, collectionID, partitionID
+func (_m *DataCoordCatalog) GcConfirm(ctx context.Context, collectionID int64, partitionID int64) bool {
+	ret := _m.Called(ctx, collectionID, partitionID)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(context.Context, int64, int64) bool); ok {
+		r0 = rf(ctx, collectionID, partitionID)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// DataCoordCatalog_GcConfirm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GcConfirm'
+type DataCoordCatalog_GcConfirm_Call struct {
+	*mock.Call
+}
+
+// GcConfirm is a helper method to define mock.On call
+//  - ctx context.Context
+//  - collectionID int64
+//  - partitionID int64
+func (_e *DataCoordCatalog_Expecter) GcConfirm(ctx interface{}, collectionID interface{}, partitionID interface{}) *DataCoordCatalog_GcConfirm_Call {
+	return &DataCoordCatalog_GcConfirm_Call{Call: _e.mock.On("GcConfirm", ctx, collectionID, partitionID)}
+}
+
+func (_c *DataCoordCatalog_GcConfirm_Call) Run(run func(ctx context.Context, collectionID int64, partitionID int64)) *DataCoordCatalog_GcConfirm_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(int64), args[2].(int64))
+	})
+	return _c
+}
+
+func (_c *DataCoordCatalog_GcConfirm_Call) Return(_a0 bool) *DataCoordCatalog_GcConfirm_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
 // IsChannelDropped provides a mock function with given fields: ctx, channel
 func (_m *DataCoordCatalog) IsChannelDropped(ctx context.Context, channel string) bool {
 	ret := _m.Called(ctx, channel)
@@ -622,8 +661,8 @@ type DataCoordCatalog_IsChannelDropped_Call struct {
 }
 
 // IsChannelDropped is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - channel string
+//  - channel string
 func (_e *DataCoordCatalog_Expecter) IsChannelDropped(ctx interface{}, channel interface{}) *DataCoordCatalog_IsChannelDropped_Call {
 	return &DataCoordCatalog_IsChannelDropped_Call{Call: _e.mock.On("IsChannelDropped", ctx, channel)}
 }
@@ -669,7 +708,7 @@ type DataCoordCatalog_ListChannelCheckpoint_Call struct {
 }
 
 // ListChannelCheckpoint is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
 func (_e *DataCoordCatalog_Expecter) ListChannelCheckpoint(ctx interface{}) *DataCoordCatalog_ListChannelCheckpoint_Call {
 	return &DataCoordCatalog_ListChannelCheckpoint_Call{Call: _e.mock.On("ListChannelCheckpoint", ctx)}
 }
@@ -715,7 +754,7 @@ type DataCoordCatalog_ListIndexes_Call struct {
 }
 
 // ListIndexes is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
 func (_e *DataCoordCatalog_Expecter) ListIndexes(ctx interface{}) *DataCoordCatalog_ListIndexes_Call {
 	return &DataCoordCatalog_ListIndexes_Call{Call: _e.mock.On("ListIndexes", ctx)}
 }
@@ -761,7 +800,7 @@ type DataCoordCatalog_ListSegmentIndexes_Call struct {
 }
 
 // ListSegmentIndexes is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
 func (_e *DataCoordCatalog_Expecter) ListSegmentIndexes(ctx interface{}) *DataCoordCatalog_ListSegmentIndexes_Call {
 	return &DataCoordCatalog_ListSegmentIndexes_Call{Call: _e.mock.On("ListSegmentIndexes", ctx)}
 }
@@ -807,7 +846,7 @@ type DataCoordCatalog_ListSegments_Call struct {
 }
 
 // ListSegments is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
 func (_e *DataCoordCatalog_Expecter) ListSegments(ctx interface{}) *DataCoordCatalog_ListSegments_Call {
 	return &DataCoordCatalog_ListSegments_Call{Call: _e.mock.On("ListSegments", ctx)}
 }
@@ -844,8 +883,8 @@ type DataCoordCatalog_MarkChannelDeleted_Call struct {
 }
 
 // MarkChannelDeleted is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - channel string
+//  - channel string
 func (_e *DataCoordCatalog_Expecter) MarkChannelDeleted(ctx interface{}, channel interface{}) *DataCoordCatalog_MarkChannelDeleted_Call {
 	return &DataCoordCatalog_MarkChannelDeleted_Call{Call: _e.mock.On("MarkChannelDeleted", ctx, channel)}
 }
@@ -882,9 +921,9 @@ type DataCoordCatalog_RevertAlterSegmentsAndAddNewSegment_Call struct {
 }
 
 // RevertAlterSegmentsAndAddNewSegment is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - segments []*datapb.SegmentInfo
+//  - segments []*datapb.SegmentInfo
-//   - removalSegment *datapb.SegmentInfo
+//  - removalSegment *datapb.SegmentInfo
 func (_e *DataCoordCatalog_Expecter) RevertAlterSegmentsAndAddNewSegment(ctx interface{}, segments interface{}, removalSegment interface{}) *DataCoordCatalog_RevertAlterSegmentsAndAddNewSegment_Call {
 	return &DataCoordCatalog_RevertAlterSegmentsAndAddNewSegment_Call{Call: _e.mock.On("RevertAlterSegmentsAndAddNewSegment", ctx, segments, removalSegment)}
 }
@@ -921,9 +960,9 @@ type DataCoordCatalog_SaveChannelCheckpoint_Call struct {
 }
 
 // SaveChannelCheckpoint is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - vChannel string
+//  - vChannel string
-//   - pos *internalpb.MsgPosition
+//  - pos *internalpb.MsgPosition
 func (_e *DataCoordCatalog_Expecter) SaveChannelCheckpoint(ctx interface{}, vChannel interface{}, pos interface{}) *DataCoordCatalog_SaveChannelCheckpoint_Call {
 	return &DataCoordCatalog_SaveChannelCheckpoint_Call{Call: _e.mock.On("SaveChannelCheckpoint", ctx, vChannel, pos)}
 }
@@ -960,8 +999,8 @@ type DataCoordCatalog_SaveDroppedSegmentsInBatch_Call struct {
 }
 
 // SaveDroppedSegmentsInBatch is a helper method to define mock.On call
-//   - ctx context.Context
+//  - ctx context.Context
-//   - segments []*datapb.SegmentInfo
+//  - segments []*datapb.SegmentInfo
 func (_e *DataCoordCatalog_Expecter) SaveDroppedSegmentsInBatch(ctx interface{}, segments interface{}) *DataCoordCatalog_SaveDroppedSegmentsInBatch_Call {
 	return &DataCoordCatalog_SaveDroppedSegmentsInBatch_Call{Call: _e.mock.On("SaveDroppedSegmentsInBatch", ctx, segments)}
 }

internal/metastore/mocks/RootCoordCatalog.go

@@ -1,4 +1,4 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery v2.16.0. DO NOT EDIT.
 
 package mocks
 

internal/mocks/mock_datacoord.go

@@ -1,4 +1,4 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery v2.16.0. DO NOT EDIT.
 
 package mocks
 
@@ -9,6 +9,8 @@ import (
 
 	datapb "github.com/milvus-io/milvus/internal/proto/datapb"
 
+	indexpb "github.com/milvus-io/milvus/internal/proto/indexpb"
+
 	internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"
 
 	milvuspb "github.com/milvus-io/milvus-proto/go-api/milvuspb"
@@ -77,11 +79,11 @@ func (_c *DataCoord_AssignSegmentID_Call) Return(_a0 *datapb.AssignSegmentIDResp
 }
 
 // BroadcastAlteredCollection provides a mock function with given fields: ctx, req
-func (_m *DataCoord) BroadcastAlteredCollection(ctx context.Context, req *milvuspb.AlterCollectionRequest) (*commonpb.Status, error) {
+func (_m *DataCoord) BroadcastAlteredCollection(ctx context.Context, req *datapb.AlterCollectionRequest) (*commonpb.Status, error) {
 	ret := _m.Called(ctx, req)
 
 	var r0 *commonpb.Status
-	if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.AlterCollectionRequest) *commonpb.Status); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *datapb.AlterCollectionRequest) *commonpb.Status); ok {
 		r0 = rf(ctx, req)
 	} else {
 		if ret.Get(0) != nil {
@@ -90,7 +92,7 @@ func (_m *DataCoord) BroadcastAlteredCollection(ctx context.Context, req *milvus
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.AlterCollectionRequest) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *datapb.AlterCollectionRequest) error); ok {
 		r1 = rf(ctx, req)
 	} else {
 		r1 = ret.Error(1)
@@ -106,14 +108,14 @@ type DataCoord_BroadcastAlteredCollection_Call struct {
 
 // BroadcastAlteredCollection is a helper method to define mock.On call
 //  - ctx context.Context
-//  - req *milvuspb.AlterCollectionRequest
+//  - req *datapb.AlterCollectionRequest
 func (_e *DataCoord_Expecter) BroadcastAlteredCollection(ctx interface{}, req interface{}) *DataCoord_BroadcastAlteredCollection_Call {
 	return &DataCoord_BroadcastAlteredCollection_Call{Call: _e.mock.On("BroadcastAlteredCollection", ctx, req)}
 }
 
-func (_c *DataCoord_BroadcastAlteredCollection_Call) Run(run func(ctx context.Context, req *milvuspb.AlterCollectionRequest)) *DataCoord_BroadcastAlteredCollection_Call {
+func (_c *DataCoord_BroadcastAlteredCollection_Call) Run(run func(ctx context.Context, req *datapb.AlterCollectionRequest)) *DataCoord_BroadcastAlteredCollection_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*milvuspb.AlterCollectionRequest))
+		run(args[0].(context.Context), args[1].(*datapb.AlterCollectionRequest))
 	})
 	return _c
 }
@@ -170,6 +172,147 @@ func (_c *DataCoord_CheckHealth_Call) Return(_a0 *milvuspb.CheckHealthResponse,
 	return _c
 }
 
+// CreateIndex provides a mock function with given fields: ctx, req
+func (_m *DataCoord) CreateIndex(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *commonpb.Status
+	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.CreateIndexRequest) *commonpb.Status); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.CreateIndexRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_CreateIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIndex'
+type DataCoord_CreateIndex_Call struct {
+	*mock.Call
+}
+
+// CreateIndex is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *indexpb.CreateIndexRequest
+func (_e *DataCoord_Expecter) CreateIndex(ctx interface{}, req interface{}) *DataCoord_CreateIndex_Call {
+	return &DataCoord_CreateIndex_Call{Call: _e.mock.On("CreateIndex", ctx, req)}
+}
+
+func (_c *DataCoord_CreateIndex_Call) Run(run func(ctx context.Context, req *indexpb.CreateIndexRequest)) *DataCoord_CreateIndex_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*indexpb.CreateIndexRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_CreateIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_CreateIndex_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+// DescribeIndex provides a mock function with given fields: ctx, req
+func (_m *DataCoord) DescribeIndex(ctx context.Context, req *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *indexpb.DescribeIndexResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DescribeIndexRequest) *indexpb.DescribeIndexResponse); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*indexpb.DescribeIndexResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.DescribeIndexRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_DescribeIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DescribeIndex'
+type DataCoord_DescribeIndex_Call struct {
+	*mock.Call
+}
+
+// DescribeIndex is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *indexpb.DescribeIndexRequest
+func (_e *DataCoord_Expecter) DescribeIndex(ctx interface{}, req interface{}) *DataCoord_DescribeIndex_Call {
+	return &DataCoord_DescribeIndex_Call{Call: _e.mock.On("DescribeIndex", ctx, req)}
+}
+
+func (_c *DataCoord_DescribeIndex_Call) Run(run func(ctx context.Context, req *indexpb.DescribeIndexRequest)) *DataCoord_DescribeIndex_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*indexpb.DescribeIndexRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_DescribeIndex_Call) Return(_a0 *indexpb.DescribeIndexResponse, _a1 error) *DataCoord_DescribeIndex_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+// DropIndex provides a mock function with given fields: ctx, req
+func (_m *DataCoord) DropIndex(ctx context.Context, req *indexpb.DropIndexRequest) (*commonpb.Status, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *commonpb.Status
+	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.DropIndexRequest) *commonpb.Status); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.DropIndexRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_DropIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropIndex'
+type DataCoord_DropIndex_Call struct {
+	*mock.Call
+}
+
+// DropIndex is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *indexpb.DropIndexRequest
+func (_e *DataCoord_Expecter) DropIndex(ctx interface{}, req interface{}) *DataCoord_DropIndex_Call {
+	return &DataCoord_DropIndex_Call{Call: _e.mock.On("DropIndex", ctx, req)}
+}
+
+func (_c *DataCoord_DropIndex_Call) Run(run func(ctx context.Context, req *indexpb.DropIndexRequest)) *DataCoord_DropIndex_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*indexpb.DropIndexRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_DropIndex_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_DropIndex_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
 // DropVirtualChannel provides a mock function with given fields: ctx, req
 func (_m *DataCoord) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
 	ret := _m.Called(ctx, req)
@@ -264,6 +407,53 @@ func (_c *DataCoord_Flush_Call) Return(_a0 *datapb.FlushResponse, _a1 error) *Da
 	return _c
 }
 
+// GcConfirm provides a mock function with given fields: ctx, request
+func (_m *DataCoord) GcConfirm(ctx context.Context, request *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) {
+	ret := _m.Called(ctx, request)
+
+	var r0 *datapb.GcConfirmResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *datapb.GcConfirmRequest) *datapb.GcConfirmResponse); ok {
+		r0 = rf(ctx, request)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*datapb.GcConfirmResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *datapb.GcConfirmRequest) error); ok {
+		r1 = rf(ctx, request)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_GcConfirm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GcConfirm'
+type DataCoord_GcConfirm_Call struct {
+	*mock.Call
+}
+
+// GcConfirm is a helper method to define mock.On call
+//  - ctx context.Context
+//  - request *datapb.GcConfirmRequest
+func (_e *DataCoord_Expecter) GcConfirm(ctx interface{}, request interface{}) *DataCoord_GcConfirm_Call {
+	return &DataCoord_GcConfirm_Call{Call: _e.mock.On("GcConfirm", ctx, request)}
+}
+
+func (_c *DataCoord_GcConfirm_Call) Run(run func(ctx context.Context, request *datapb.GcConfirmRequest)) *DataCoord_GcConfirm_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*datapb.GcConfirmRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_GcConfirm_Call) Return(_a0 *datapb.GcConfirmResponse, _a1 error) *DataCoord_GcConfirm_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
 // GetCollectionStatistics provides a mock function with given fields: ctx, req
 func (_m *DataCoord) GetCollectionStatistics(ctx context.Context, req *datapb.GetCollectionStatisticsRequest) (*datapb.GetCollectionStatisticsResponse, error) {
 	ret := _m.Called(ctx, req)
@@ -545,6 +735,147 @@ func (_c *DataCoord_GetFlushedSegments_Call) Return(_a0 *datapb.GetFlushedSegmen
 	return _c
 }
 
+// GetIndexBuildProgress provides a mock function with given fields: ctx, req
+func (_m *DataCoord) GetIndexBuildProgress(ctx context.Context, req *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *indexpb.GetIndexBuildProgressResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexBuildProgressRequest) *indexpb.GetIndexBuildProgressResponse); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*indexpb.GetIndexBuildProgressResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexBuildProgressRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_GetIndexBuildProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexBuildProgress'
+type DataCoord_GetIndexBuildProgress_Call struct {
+	*mock.Call
+}
+
+// GetIndexBuildProgress is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *indexpb.GetIndexBuildProgressRequest
+func (_e *DataCoord_Expecter) GetIndexBuildProgress(ctx interface{}, req interface{}) *DataCoord_GetIndexBuildProgress_Call {
+	return &DataCoord_GetIndexBuildProgress_Call{Call: _e.mock.On("GetIndexBuildProgress", ctx, req)}
+}
+
+func (_c *DataCoord_GetIndexBuildProgress_Call) Run(run func(ctx context.Context, req *indexpb.GetIndexBuildProgressRequest)) *DataCoord_GetIndexBuildProgress_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*indexpb.GetIndexBuildProgressRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_GetIndexBuildProgress_Call) Return(_a0 *indexpb.GetIndexBuildProgressResponse, _a1 error) *DataCoord_GetIndexBuildProgress_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+// GetIndexInfos provides a mock function with given fields: ctx, req
+func (_m *DataCoord) GetIndexInfos(ctx context.Context, req *indexpb.GetIndexInfoRequest) (*indexpb.GetIndexInfoResponse, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *indexpb.GetIndexInfoResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexInfoRequest) *indexpb.GetIndexInfoResponse); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*indexpb.GetIndexInfoResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexInfoRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_GetIndexInfos_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexInfos'
+type DataCoord_GetIndexInfos_Call struct {
+	*mock.Call
+}
+
+// GetIndexInfos is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *indexpb.GetIndexInfoRequest
+func (_e *DataCoord_Expecter) GetIndexInfos(ctx interface{}, req interface{}) *DataCoord_GetIndexInfos_Call {
+	return &DataCoord_GetIndexInfos_Call{Call: _e.mock.On("GetIndexInfos", ctx, req)}
+}
+
+func (_c *DataCoord_GetIndexInfos_Call) Run(run func(ctx context.Context, req *indexpb.GetIndexInfoRequest)) *DataCoord_GetIndexInfos_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*indexpb.GetIndexInfoRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_GetIndexInfos_Call) Return(_a0 *indexpb.GetIndexInfoResponse, _a1 error) *DataCoord_GetIndexInfos_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+// GetIndexState provides a mock function with given fields: ctx, req
+func (_m *DataCoord) GetIndexState(ctx context.Context, req *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *indexpb.GetIndexStateResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetIndexStateRequest) *indexpb.GetIndexStateResponse); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*indexpb.GetIndexStateResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetIndexStateRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_GetIndexState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIndexState'
+type DataCoord_GetIndexState_Call struct {
+	*mock.Call
+}
+
+// GetIndexState is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *indexpb.GetIndexStateRequest
+func (_e *DataCoord_Expecter) GetIndexState(ctx interface{}, req interface{}) *DataCoord_GetIndexState_Call {
+	return &DataCoord_GetIndexState_Call{Call: _e.mock.On("GetIndexState", ctx, req)}
+}
+
+func (_c *DataCoord_GetIndexState_Call) Run(run func(ctx context.Context, req *indexpb.GetIndexStateRequest)) *DataCoord_GetIndexState_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*indexpb.GetIndexStateRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_GetIndexState_Call) Return(_a0 *indexpb.GetIndexStateResponse, _a1 error) *DataCoord_GetIndexState_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
 // GetInsertBinlogPaths provides a mock function with given fields: ctx, req
 func (_m *DataCoord) GetInsertBinlogPaths(ctx context.Context, req *datapb.GetInsertBinlogPathsRequest) (*datapb.GetInsertBinlogPathsResponse, error) {
 	ret := _m.Called(ctx, req)
@@ -733,6 +1064,53 @@ func (_c *DataCoord_GetRecoveryInfo_Call) Return(_a0 *datapb.GetRecoveryInfoResp
 	return _c
 }
 
+// GetSegmentIndexState provides a mock function with given fields: ctx, req
+func (_m *DataCoord) GetSegmentIndexState(ctx context.Context, req *indexpb.GetSegmentIndexStateRequest) (*indexpb.GetSegmentIndexStateResponse, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *indexpb.GetSegmentIndexStateResponse
+	if rf, ok := ret.Get(0).(func(context.Context, *indexpb.GetSegmentIndexStateRequest) *indexpb.GetSegmentIndexStateResponse); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*indexpb.GetSegmentIndexStateResponse)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *indexpb.GetSegmentIndexStateRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_GetSegmentIndexState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSegmentIndexState'
+type DataCoord_GetSegmentIndexState_Call struct {
+	*mock.Call
+}
+
+// GetSegmentIndexState is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *indexpb.GetSegmentIndexStateRequest
+func (_e *DataCoord_Expecter) GetSegmentIndexState(ctx interface{}, req interface{}) *DataCoord_GetSegmentIndexState_Call {
+	return &DataCoord_GetSegmentIndexState_Call{Call: _e.mock.On("GetSegmentIndexState", ctx, req)}
+}
+
+func (_c *DataCoord_GetSegmentIndexState_Call) Run(run func(ctx context.Context, req *indexpb.GetSegmentIndexStateRequest)) *DataCoord_GetSegmentIndexState_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*indexpb.GetSegmentIndexStateRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_GetSegmentIndexState_Call) Return(_a0 *indexpb.GetSegmentIndexStateResponse, _a1 error) *DataCoord_GetSegmentIndexState_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
 // GetSegmentInfo provides a mock function with given fields: ctx, req
 func (_m *DataCoord) GetSegmentInfo(ctx context.Context, req *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) {
 	ret := _m.Called(ctx, req)
@@ -1532,6 +1910,53 @@ func (_c *DataCoord_UnsetIsImportingState_Call) Return(_a0 *commonpb.Status, _a1
 	return _c
 }
 
+// UpdateChannelCheckpoint provides a mock function with given fields: ctx, req
+func (_m *DataCoord) UpdateChannelCheckpoint(ctx context.Context, req *datapb.UpdateChannelCheckpointRequest) (*commonpb.Status, error) {
+	ret := _m.Called(ctx, req)
+
+	var r0 *commonpb.Status
+	if rf, ok := ret.Get(0).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) *commonpb.Status); ok {
+		r0 = rf(ctx, req)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*commonpb.Status)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, *datapb.UpdateChannelCheckpointRequest) error); ok {
+		r1 = rf(ctx, req)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DataCoord_UpdateChannelCheckpoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannelCheckpoint'
+type DataCoord_UpdateChannelCheckpoint_Call struct {
+	*mock.Call
+}
+
+// UpdateChannelCheckpoint is a helper method to define mock.On call
+//  - ctx context.Context
+//  - req *datapb.UpdateChannelCheckpointRequest
+func (_e *DataCoord_Expecter) UpdateChannelCheckpoint(ctx interface{}, req interface{}) *DataCoord_UpdateChannelCheckpoint_Call {
+	return &DataCoord_UpdateChannelCheckpoint_Call{Call: _e.mock.On("UpdateChannelCheckpoint", ctx, req)}
+}
+
+func (_c *DataCoord_UpdateChannelCheckpoint_Call) Run(run func(ctx context.Context, req *datapb.UpdateChannelCheckpointRequest)) *DataCoord_UpdateChannelCheckpoint_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*datapb.UpdateChannelCheckpointRequest))
+	})
+	return _c
+}
+
+func (_c *DataCoord_UpdateChannelCheckpoint_Call) Return(_a0 *commonpb.Status, _a1 error) *DataCoord_UpdateChannelCheckpoint_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
 // UpdateSegmentStatistics provides a mock function with given fields: ctx, req
 func (_m *DataCoord) UpdateSegmentStatistics(ctx context.Context, req *datapb.UpdateSegmentStatisticsRequest) (*commonpb.Status, error) {
 	ret := _m.Called(ctx, req)

internal/proto/data_coord.proto

@@ -77,6 +77,8 @@ service DataCoord {
   rpc DescribeIndex(index.DescribeIndexRequest) returns (index.DescribeIndexResponse) {}
   // Deprecated: use DescribeIndex instead
   rpc GetIndexBuildProgress(index.GetIndexBuildProgressRequest) returns (index.GetIndexBuildProgressResponse) {}
+
+  rpc GcConfirm(GcConfirmRequest) returns (GcConfirmResponse) {}
 }
 
 service DataNode {
@@ -643,6 +645,16 @@ message AlterCollectionRequest {
   repeated common.KeyValuePair properties = 5;
 }
 
+message GcConfirmRequest {
+  int64 collection_id = 1;
+  int64 partition_id = 2; // -1 means whole collection.
+}
+
+message GcConfirmResponse {
+  common.Status status = 1;
+  bool gc_finished = 2;
+}
+
 //message IndexInfo {
 //  int64 collectionID = 1;
 //  int64 fieldID = 2;

internal/proto/datapb/data_coord.pb.go

@@ -4781,6 +4781,100 @@ func (m *AlterCollectionRequest) GetProperties() []*commonpb.KeyValuePair {
 	return nil
 }
 
+type GcConfirmRequest struct {
+	CollectionId         int64    `protobuf:"varint,1,opt,name=collection_id,json=collectionId,proto3" json:"collection_id,omitempty"`
+	PartitionId          int64    `protobuf:"varint,2,opt,name=partition_id,json=partitionId,proto3" json:"partition_id,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GcConfirmRequest) Reset()         { *m = GcConfirmRequest{} }
+func (m *GcConfirmRequest) String() string { return proto.CompactTextString(m) }
+func (*GcConfirmRequest) ProtoMessage()    {}
+func (*GcConfirmRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_82cd95f524594f49, []int{74}
+}
+
+func (m *GcConfirmRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GcConfirmRequest.Unmarshal(m, b)
+}
+func (m *GcConfirmRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GcConfirmRequest.Marshal(b, m, deterministic)
+}
+func (m *GcConfirmRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GcConfirmRequest.Merge(m, src)
+}
+func (m *GcConfirmRequest) XXX_Size() int {
+	return xxx_messageInfo_GcConfirmRequest.Size(m)
+}
+func (m *GcConfirmRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_GcConfirmRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GcConfirmRequest proto.InternalMessageInfo
+
+func (m *GcConfirmRequest) GetCollectionId() int64 {
+	if m != nil {
+		return m.CollectionId
+	}
+	return 0
+}
+
+func (m *GcConfirmRequest) GetPartitionId() int64 {
+	if m != nil {
+		return m.PartitionId
+	}
+	return 0
+}
+
+type GcConfirmResponse struct {
+	Status               *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	GcFinished           bool             `protobuf:"varint,2,opt,name=gc_finished,json=gcFinished,proto3" json:"gc_finished,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *GcConfirmResponse) Reset()         { *m = GcConfirmResponse{} }
+func (m *GcConfirmResponse) String() string { return proto.CompactTextString(m) }
+func (*GcConfirmResponse) ProtoMessage()    {}
+func (*GcConfirmResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_82cd95f524594f49, []int{75}
+}
+
+func (m *GcConfirmResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GcConfirmResponse.Unmarshal(m, b)
+}
+func (m *GcConfirmResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GcConfirmResponse.Marshal(b, m, deterministic)
+}
+func (m *GcConfirmResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GcConfirmResponse.Merge(m, src)
+}
+func (m *GcConfirmResponse) XXX_Size() int {
+	return xxx_messageInfo_GcConfirmResponse.Size(m)
+}
+func (m *GcConfirmResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_GcConfirmResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GcConfirmResponse proto.InternalMessageInfo
+
+func (m *GcConfirmResponse) GetStatus() *commonpb.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
+func (m *GcConfirmResponse) GetGcFinished() bool {
+	if m != nil {
+		return m.GcFinished
+	}
+	return false
+}
+
 func init() {
 	proto.RegisterEnum("milvus.proto.data.SegmentType", SegmentType_name, SegmentType_value)
 	proto.RegisterEnum("milvus.proto.data.ChannelWatchState", ChannelWatchState_name, ChannelWatchState_value)
@@ -4860,300 +4954,306 @@ func init() {
 	proto.RegisterType((*MarkSegmentsDroppedRequest)(nil), "milvus.proto.data.MarkSegmentsDroppedRequest")
 	proto.RegisterType((*SegmentReferenceLock)(nil), "milvus.proto.data.SegmentReferenceLock")
 	proto.RegisterType((*AlterCollectionRequest)(nil), "milvus.proto.data.AlterCollectionRequest")
+	proto.RegisterType((*GcConfirmRequest)(nil), "milvus.proto.data.GcConfirmRequest")
+	proto.RegisterType((*GcConfirmResponse)(nil), "milvus.proto.data.GcConfirmResponse")
 }
 
 func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
 
 var fileDescriptor_82cd95f524594f49 = []byte{
-	// 4597 bytes of a gzipped FileDescriptorProto
+	// 4664 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x3c, 0x4b, 0x8c, 0x1c, 0x49,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7c, 0x4b, 0x8c, 0x1c, 0x49,
-	0x56, 0xce, 0xfa, 0x75, 0xd5, 0xab, 0x4f, 0x57, 0x87, 0x3d, 0xed, 0x72, 0xf9, 0x9f, 0xb6, 0xc7,
+	0x5a, 0xb0, 0xb3, 0x5e, 0x5d, 0xf5, 0xd5, 0xa3, 0xab, 0xc3, 0x9e, 0x76, 0xb9, 0x66, 0xfc, 0x4a,
-	0x3d, 0x1e, 0x8f, 0xed, 0xf1, 0x30, 0x5a, 0xb3, 0xde, 0x99, 0xc5, 0xdd, 0x6d, 0x7b, 0x0a, 0xdc,
+	0xdb, 0xe3, 0x1e, 0x8f, 0xc7, 0xf6, 0x78, 0xfe, 0xd1, 0xfa, 0x5f, 0xef, 0xcc, 0xe2, 0xee, 0x76,
-	0xbd, 0xbd, 0xd9, 0xed, 0xb1, 0xb4, 0x8b, 0x54, 0xca, 0xae, 0x8c, 0xae, 0xce, 0xed, 0xaa, 0xcc,
+	0x7b, 0x0a, 0xdc, 0xbd, 0xbd, 0xd9, 0xed, 0x31, 0x9a, 0x45, 0x2a, 0x65, 0x57, 0x46, 0x57, 0xe7,
-	0x72, 0x66, 0x56, 0xb7, 0x7b, 0x91, 0xd8, 0x01, 0x24, 0xa4, 0x41, 0x08, 0x10, 0x12, 0x02, 0x24,
+	0x76, 0x55, 0x66, 0x39, 0x33, 0xab, 0xdb, 0xbd, 0x48, 0xec, 0x00, 0x12, 0xd2, 0x20, 0x04, 0x08,
-	0x0e, 0x88, 0xd3, 0xb2, 0x68, 0x11, 0xd2, 0x8a, 0x0b, 0x17, 0xae, 0x23, 0x38, 0x8c, 0x10, 0x12,
+	0x09, 0x01, 0x37, 0xc4, 0x69, 0x59, 0xb4, 0x08, 0x69, 0xc5, 0x85, 0x0b, 0xd7, 0x11, 0x1c, 0x56,
-	0x47, 0x8e, 0xc0, 0x9d, 0x2b, 0x07, 0x14, 0x9f, 0x8c, 0xfc, 0x45, 0x56, 0x65, 0x57, 0xd9, 0x63,
+	0x08, 0x89, 0x23, 0x47, 0xe0, 0x8e, 0xc4, 0x89, 0x03, 0x8a, 0x47, 0x46, 0xbe, 0x22, 0xab, 0xb2,
-	0x09, 0x6e, 0x15, 0x91, 0x2f, 0x5e, 0xbc, 0x88, 0xf7, 0x7f, 0x11, 0x51, 0xd0, 0x34, 0x74, 0x4f,
+	0xab, 0xec, 0xb1, 0x04, 0xb7, 0x8a, 0x2f, 0xbf, 0xf8, 0xe2, 0x8b, 0x88, 0xef, 0x1d, 0x11, 0x05,
-	0xef, 0xf6, 0x6c, 0xdb, 0x31, 0xee, 0x8c, 0x1c, 0xdb, 0xb3, 0xd1, 0xd2, 0xd0, 0x1c, 0x1c, 0x8e,
+	0x4d, 0x43, 0xf7, 0xf4, 0x6e, 0xcf, 0xb6, 0x1d, 0xe3, 0xce, 0xc8, 0xb1, 0x3d, 0x1b, 0x2d, 0x0d,
-	0x5d, 0xd6, 0xba, 0x43, 0x3e, 0xb7, 0x6b, 0x3d, 0x7b, 0x38, 0xb4, 0x2d, 0xd6, 0xd5, 0x6e, 0x98,
+	0xcd, 0xc1, 0xd1, 0xd8, 0x65, 0xad, 0x3b, 0xe4, 0x73, 0xbb, 0xd6, 0xb3, 0x87, 0x43, 0xdb, 0x62,
-	0x96, 0x87, 0x1d, 0x4b, 0x1f, 0xf0, 0x76, 0x2d, 0x3c, 0xa0, 0x5d, 0x73, 0x7b, 0xfb, 0x78, 0xa8,
+	0xa0, 0x76, 0xc3, 0xb4, 0x3c, 0xec, 0x58, 0xfa, 0x80, 0xb7, 0x6b, 0xe1, 0x0e, 0xed, 0x9a, 0xdb,
-	0xf3, 0xd6, 0x92, 0x69, 0x19, 0xf8, 0x55, 0x18, 0xbf, 0xba, 0x00, 0xc5, 0xc7, 0xc3, 0x91, 0x77,
+	0x3b, 0xc0, 0x43, 0x9d, 0xb7, 0x96, 0x4c, 0xcb, 0xc0, 0x2f, 0xc3, 0xf4, 0xd5, 0x05, 0x28, 0x3e,
-	0xac, 0xfe, 0x99, 0x02, 0xb5, 0x27, 0x83, 0xb1, 0xbb, 0xaf, 0xe1, 0x97, 0x63, 0xec, 0x7a, 0xe8,
+	0x1e, 0x8e, 0xbc, 0x13, 0xf5, 0x4f, 0x15, 0xa8, 0x6d, 0x0c, 0xc6, 0xee, 0x81, 0x86, 0x5f, 0x8c,
-	0x1e, 0x14, 0x76, 0x75, 0x17, 0xb7, 0x94, 0x2b, 0xca, 0x4a, 0xf5, 0xfe, 0x85, 0x3b, 0x11, 0x42,
+	0xb1, 0xeb, 0xa1, 0x7b, 0x50, 0xd8, 0xd3, 0x5d, 0xdc, 0x52, 0xae, 0x28, 0x2b, 0xd5, 0xfb, 0xef,
-	0x38, 0x09, 0x1b, 0x6e, 0x7f, 0x55, 0x77, 0xb1, 0x46, 0x21, 0x11, 0x82, 0x82, 0xb1, 0xdb, 0x59,
+	0xdc, 0x89, 0x30, 0xc2, 0x59, 0xd8, 0x74, 0xfb, 0xab, 0xba, 0x8b, 0x35, 0x8a, 0x89, 0x10, 0x14,
-	0x6f, 0xe5, 0xae, 0x28, 0x2b, 0x79, 0x8d, 0xfe, 0x46, 0x97, 0x00, 0x5c, 0xdc, 0x1f, 0x62, 0xcb,
+	0x8c, 0xbd, 0xce, 0x7a, 0x2b, 0x77, 0x45, 0x59, 0xc9, 0x6b, 0xf4, 0x37, 0xba, 0x04, 0xe0, 0xe2,
-	0xeb, 0xac, 0xbb, 0xad, 0xfc, 0x95, 0xfc, 0x4a, 0x5e, 0x0b, 0xf5, 0x20, 0x15, 0x6a, 0x3d, 0x7b,
+	0xfe, 0x10, 0x5b, 0x5e, 0x67, 0xdd, 0x6d, 0xe5, 0xaf, 0xe4, 0x57, 0xf2, 0x5a, 0x08, 0x82, 0x54,
-	0x30, 0xc0, 0x3d, 0xcf, 0xb4, 0xad, 0xce, 0x7a, 0xab, 0x40, 0xc7, 0x46, 0xfa, 0xd4, 0xff, 0x50,
+	0xa8, 0xf5, 0xec, 0xc1, 0x00, 0xf7, 0x3c, 0xd3, 0xb6, 0x3a, 0xeb, 0xad, 0x02, 0xed, 0x1b, 0x81,
-	0xa0, 0xce, 0x49, 0x73, 0x47, 0xb6, 0xe5, 0x62, 0xf4, 0x11, 0x94, 0x5c, 0x4f, 0xf7, 0xc6, 0x2e,
+	0xa9, 0xff, 0xa6, 0x40, 0x9d, 0xb3, 0xe6, 0x8e, 0x6c, 0xcb, 0xc5, 0xe8, 0x23, 0x28, 0xb9, 0x9e,
-	0xa7, 0xee, 0xbc, 0x94, 0xba, 0x6d, 0x0a, 0xa2, 0x71, 0x50, 0x29, 0x79, 0xf1, 0xe9, 0xf3, 0xc9,
+	0xee, 0x8d, 0x5d, 0xce, 0xdd, 0xdb, 0x52, 0xee, 0x76, 0x28, 0x8a, 0xc6, 0x51, 0xa5, 0xec, 0xc5,
-	0xe9, 0x63, 0x4b, 0x28, 0x24, 0x96, 0xb0, 0x02, 0x8b, 0x7b, 0x84, 0xba, 0xed, 0x00, 0xa8, 0x48,
+	0x87, 0xcf, 0x27, 0x87, 0x8f, 0x4d, 0xa1, 0x90, 0x98, 0xc2, 0x0a, 0x2c, 0xee, 0x13, 0xee, 0x76,
-	0x81, 0xe2, 0xdd, 0x04, 0x93, 0x67, 0x0e, 0xf1, 0xf7, 0xf6, 0xb6, 0xb1, 0x3e, 0x68, 0x95, 0xe8,
+	0x02, 0xa4, 0x22, 0x45, 0x8a, 0x83, 0x09, 0x25, 0xcf, 0x1c, 0xe2, 0xef, 0xed, 0xef, 0x60, 0x7d,
-	0x5c, 0xa1, 0x1e, 0xf5, 0x5f, 0x14, 0x68, 0x0a, 0x70, 0x9f, 0x0f, 0x67, 0xa0, 0xd8, 0xb3, 0xc7,
+	0xd0, 0x2a, 0xd1, 0xb1, 0x42, 0x10, 0xf5, 0x9f, 0x14, 0x68, 0x0a, 0x74, 0x7f, 0x1f, 0xce, 0x41,
-	0x96, 0x47, 0x97, 0x5a, 0xd7, 0x58, 0x03, 0x5d, 0x85, 0x5a, 0x6f, 0x5f, 0xb7, 0x2c, 0x3c, 0xe8,
+	0xb1, 0x67, 0x8f, 0x2d, 0x8f, 0x4e, 0xb5, 0xae, 0xb1, 0x06, 0xba, 0x0a, 0xb5, 0xde, 0x81, 0x6e,
-	0x5a, 0xfa, 0x10, 0xd3, 0x45, 0x55, 0xb4, 0x2a, 0xef, 0xdb, 0xd4, 0x87, 0x38, 0xd3, 0xda, 0xae,
+	0x59, 0x78, 0xd0, 0xb5, 0xf4, 0x21, 0xa6, 0x93, 0xaa, 0x68, 0x55, 0x0e, 0xdb, 0xd2, 0x87, 0x38,
-	0x40, 0x75, 0xa4, 0x3b, 0x9e, 0x19, 0xd9, 0xfd, 0x70, 0x17, 0x6a, 0x43, 0xd9, 0x74, 0x3b, 0xc3,
+	0xd3, 0xdc, 0xae, 0x40, 0x75, 0xa4, 0x3b, 0x9e, 0x19, 0x59, 0xfd, 0x30, 0x08, 0xb5, 0xa1, 0x6c,
-	0x91, 0xed, 0x78, 0xad, 0xe2, 0x15, 0x65, 0xa5, 0xac, 0x89, 0x36, 0x99, 0xc1, 0xa4, 0xbf, 0x76,
+	0xba, 0x9d, 0xe1, 0xc8, 0x76, 0xbc, 0x56, 0xf1, 0x8a, 0xb2, 0x52, 0xd6, 0x44, 0x9b, 0x8c, 0x60,
-	0x74, 0xf7, 0xa0, 0xb3, 0xce, 0x57, 0x14, 0xe9, 0x53, 0xff, 0x52, 0x81, 0xe5, 0x47, 0xae, 0x6b,
+	0xd2, 0x5f, 0xbb, 0xba, 0x7b, 0xd8, 0x59, 0xe7, 0x33, 0x8a, 0xc0, 0xd4, 0x3f, 0x57, 0x60, 0xf9,
-	0xf6, 0xad, 0xc4, 0xca, 0x96, 0xa1, 0x64, 0xd9, 0x06, 0xee, 0xac, 0xd3, 0xa5, 0xe5, 0x35, 0xde,
+	0x91, 0xeb, 0x9a, 0x7d, 0x2b, 0x31, 0xb3, 0x65, 0x28, 0x59, 0xb6, 0x81, 0x3b, 0xeb, 0x74, 0x6a,
-	0x42, 0xe7, 0xa1, 0x32, 0xc2, 0xd8, 0xe9, 0x3a, 0xf6, 0xc0, 0x5f, 0x58, 0x99, 0x74, 0x68, 0xf6,
+	0x79, 0x8d, 0xb7, 0xd0, 0xdb, 0x50, 0x19, 0x61, 0xec, 0x74, 0x1d, 0x7b, 0xe0, 0x4f, 0xac, 0x4c,
-	0x00, 0xa3, 0xef, 0xc3, 0x92, 0x1b, 0x43, 0xc4, 0xe4, 0xaa, 0x7a, 0xff, 0xda, 0x9d, 0x84, 0xb2,
+	0x00, 0x9a, 0x3d, 0xc0, 0xe8, 0xfb, 0xb0, 0xe4, 0xc6, 0x08, 0x31, 0xb9, 0xaa, 0xde, 0xbf, 0x76,
-	0xdc, 0x89, 0x4f, 0xaa, 0x25, 0x47, 0xab, 0x5f, 0xe4, 0xe0, 0xb4, 0x80, 0x63, 0xb4, 0x92, 0xdf,
+	0x27, 0xa1, 0x2c, 0x77, 0xe2, 0x83, 0x6a, 0xc9, 0xde, 0xea, 0x97, 0x39, 0x38, 0x2b, 0xf0, 0x18,
-	0x64, 0xe7, 0x5d, 0xdc, 0x17, 0xe4, 0xb1, 0x46, 0x96, 0x9d, 0x17, 0x2c, 0xcb, 0x87, 0x59, 0x96,
+	0xaf, 0xe4, 0x37, 0x59, 0x79, 0x17, 0xf7, 0x05, 0x7b, 0xac, 0x91, 0x65, 0xe5, 0xc5, 0x96, 0xe5,
-	0x41, 0xd4, 0xe3, 0xfc, 0x28, 0x26, 0xf9, 0x71, 0x19, 0xaa, 0xf8, 0xd5, 0xc8, 0x74, 0x70, 0x97,
+	0xc3, 0x5b, 0x96, 0x41, 0xd4, 0xe3, 0xfb, 0x51, 0x4c, 0xee, 0xc7, 0x65, 0xa8, 0xe2, 0x97, 0x23,
-	0x08, 0x0e, 0xdd, 0xf2, 0x82, 0x06, 0xac, 0x6b, 0xc7, 0x1c, 0x86, 0x75, 0x63, 0x21, 0xb3, 0x6e,
+	0xd3, 0xc1, 0x5d, 0x22, 0x38, 0x74, 0xc9, 0x0b, 0x1a, 0x30, 0xd0, 0xae, 0x39, 0x0c, 0xeb, 0xc6,
-	0xa8, 0x7f, 0xa5, 0xc0, 0xd9, 0x04, 0x97, 0xb8, 0xb2, 0x69, 0xd0, 0xa4, 0x2b, 0x0f, 0x76, 0x86,
+	0x42, 0x66, 0xdd, 0x50, 0xff, 0x42, 0x81, 0xf3, 0x89, 0x5d, 0xe2, 0xca, 0xa6, 0x41, 0x93, 0xce,
-	0xa8, 0x1d, 0xd9, 0xf0, 0x77, 0x27, 0x6d, 0x78, 0x00, 0xae, 0x25, 0xc6, 0x87, 0x88, 0xcc, 0x65,
+	0x3c, 0x58, 0x19, 0xa2, 0x76, 0x64, 0xc1, 0xdf, 0x9d, 0xb4, 0xe0, 0x01, 0xba, 0x96, 0xe8, 0x1f,
-	0x27, 0xf2, 0x00, 0xce, 0x3e, 0xc5, 0x1e, 0x9f, 0x80, 0x7c, 0xc3, 0xee, 0xec, 0xc6, 0x2a, 0xaa,
+	0x62, 0x32, 0x97, 0x9d, 0xc9, 0x43, 0x38, 0xff, 0x04, 0x7b, 0x7c, 0x00, 0xf2, 0x0d, 0xbb, 0xb3,
-	0xd5, 0xb9, 0xb8, 0x56, 0xab, 0x7f, 0x97, 0x13, 0xba, 0x48, 0xa7, 0xea, 0x58, 0x7b, 0x36, 0xba,
+	0x1b, 0xab, 0xa8, 0x56, 0xe7, 0xe2, 0x5a, 0xad, 0xfe, 0x4d, 0x4e, 0xe8, 0x22, 0x1d, 0xaa, 0x63,
-	0x00, 0x15, 0x01, 0xc2, 0xa5, 0x22, 0xe8, 0x40, 0xdf, 0x82, 0x22, 0xa1, 0x94, 0x89, 0x44, 0xe3,
+	0xed, 0xdb, 0xe8, 0x1d, 0xa8, 0x08, 0x14, 0x2e, 0x15, 0x01, 0x00, 0x7d, 0x0b, 0x8a, 0x84, 0x53,
-	0xfe, 0x55, 0xf9, 0x9a, 0x42, 0x38, 0x35, 0x06, 0x8f, 0x3a, 0xd0, 0x70, 0x3d, 0xdd, 0xf1, 0xba,
+	0x26, 0x12, 0x8d, 0xfb, 0x57, 0xe5, 0x73, 0x0a, 0xd1, 0xd4, 0x18, 0x3e, 0xea, 0x40, 0xc3, 0xf5,
-	0x23, 0xdb, 0xa5, 0x7c, 0xa6, 0x82, 0x53, 0xbd, 0xaf, 0x46, 0x31, 0x08, 0x4b, 0xbf, 0xe1, 0xf6,
+	0x74, 0xc7, 0xeb, 0x8e, 0x6c, 0x97, 0xee, 0x33, 0x15, 0x9c, 0xea, 0x7d, 0x35, 0x4a, 0x41, 0x58,
-	0xb7, 0x38, 0xa4, 0x56, 0xa7, 0x23, 0xfd, 0x26, 0x7a, 0x0c, 0x35, 0x6c, 0x19, 0x01, 0xa2, 0x42,
+	0xfa, 0x4d, 0xb7, 0xbf, 0xcd, 0x31, 0xb5, 0x3a, 0xed, 0xe9, 0x37, 0xd1, 0x63, 0xa8, 0x61, 0xcb,
-	0x66, 0x44, 0x55, 0x6c, 0x19, 0x02, 0x4d, 0xc0, 0x9f, 0x62, 0x76, 0xfe, 0xfc, 0xbe, 0x02, 0xad,
+	0x08, 0x08, 0x15, 0x32, 0x13, 0xaa, 0x62, 0xcb, 0x10, 0x64, 0x82, 0xfd, 0x29, 0x66, 0xdf, 0x9f,
-	0x24, 0x83, 0xe6, 0x31, 0xd9, 0x0f, 0xd9, 0x20, 0xcc, 0x18, 0x34, 0x51, 0xc3, 0x05, 0x93, 0x34,
+	0xdf, 0x53, 0xa0, 0x95, 0xdc, 0xa0, 0x79, 0x4c, 0xf6, 0x43, 0xd6, 0x09, 0xb3, 0x0d, 0x9a, 0xa8,
-	0x3e, 0x44, 0xfd, 0x13, 0x05, 0xde, 0x09, 0xc8, 0xa1, 0x9f, 0xde, 0x94, 0xb4, 0xa0, 0x5b, 0xd0,
+	0xe1, 0x62, 0x93, 0x34, 0xde, 0x45, 0xfd, 0x63, 0x05, 0xde, 0x0a, 0xd8, 0xa1, 0x9f, 0x5e, 0x97,
-	0x34, 0xad, 0xde, 0x60, 0x6c, 0xe0, 0xe7, 0xd6, 0x67, 0x58, 0x1f, 0x78, 0xfb, 0xc7, 0x94, 0x87,
+	0xb4, 0xa0, 0x5b, 0xd0, 0x34, 0xad, 0xde, 0x60, 0x6c, 0xe0, 0x67, 0xd6, 0x67, 0x58, 0x1f, 0x78,
-	0x65, 0x2d, 0xd1, 0xaf, 0xfe, 0x7b, 0x0e, 0x96, 0xe3, 0x74, 0xcd, 0xb3, 0x49, 0xbf, 0x04, 0x45,
+	0x07, 0x27, 0x74, 0x0f, 0xcb, 0x5a, 0x02, 0xae, 0xfe, 0x6b, 0x0e, 0x96, 0xe3, 0x7c, 0xcd, 0xb3,
-	0xd3, 0xda, 0xb3, 0xfd, 0x3d, 0xba, 0x34, 0x41, 0x29, 0xc9, 0x5c, 0x0c, 0x18, 0xd9, 0x80, 0x7c,
+	0x48, 0xff, 0x0f, 0x8a, 0xa6, 0xb5, 0x6f, 0xfb, 0x6b, 0x74, 0x69, 0x82, 0x52, 0x92, 0xb1, 0x18,
-	0x33, 0xd6, 0xdb, 0xc7, 0xbd, 0x83, 0x91, 0x6d, 0x52, 0x83, 0x45, 0x50, 0xfc, 0x8a, 0x04, 0x85,
+	0x32, 0xb2, 0x01, 0xf9, 0x66, 0xac, 0x77, 0x80, 0x7b, 0x87, 0x23, 0xdb, 0xa4, 0x06, 0x8b, 0x90,
-	0x9c, 0xe2, 0x3b, 0x6b, 0x0c, 0xc7, 0x9a, 0x40, 0xf1, 0xd8, 0xf2, 0x9c, 0x63, 0x6d, 0xa9, 0x17,
+	0xf8, 0x25, 0x09, 0x09, 0x39, 0xc7, 0x77, 0xd6, 0x18, 0x8d, 0x35, 0x41, 0xe2, 0xb1, 0xe5, 0x39,
-	0xef, 0x6f, 0xef, 0xc3, 0xb2, 0x1c, 0x18, 0x35, 0x21, 0x7f, 0x80, 0x8f, 0xe9, 0x92, 0x2b, 0x1a,
+	0x27, 0xda, 0x52, 0x2f, 0x0e, 0x6f, 0x1f, 0xc0, 0xb2, 0x1c, 0x19, 0x35, 0x21, 0x7f, 0x88, 0x4f,
-	0xf9, 0x89, 0x1e, 0x40, 0xf1, 0x50, 0x1f, 0x8c, 0x31, 0xb7, 0x0e, 0x59, 0xc4, 0x97, 0x0d, 0xf8,
+	0xe8, 0x94, 0x2b, 0x1a, 0xf9, 0x89, 0x1e, 0x40, 0xf1, 0x48, 0x1f, 0x8c, 0x31, 0xb7, 0x0e, 0x59,
-	0x76, 0xee, 0x81, 0xa2, 0x0e, 0xe1, 0xfc, 0x53, 0xec, 0x75, 0x2c, 0x17, 0x3b, 0xde, 0xaa, 0x69,
+	0xc4, 0x97, 0x75, 0xf8, 0x76, 0xee, 0x81, 0xa2, 0x0e, 0xe1, 0xed, 0x27, 0xd8, 0xeb, 0x58, 0x2e,
-	0x0d, 0xec, 0xfe, 0x96, 0xee, 0xed, 0xcf, 0x61, 0x2b, 0x22, 0x6a, 0x9f, 0x8b, 0xa9, 0xbd, 0xfa,
+	0x76, 0xbc, 0x55, 0xd3, 0x1a, 0xd8, 0xfd, 0x6d, 0xdd, 0x3b, 0x98, 0xc3, 0x56, 0x44, 0xd4, 0x3e,
-	0x53, 0x05, 0x2e, 0xc8, 0xe7, 0xe3, 0x5c, 0x6d, 0x43, 0x79, 0xcf, 0xc4, 0x03, 0x83, 0x88, 0x8e,
+	0x17, 0x53, 0x7b, 0xf5, 0x27, 0x0a, 0xbc, 0x23, 0x1f, 0x8f, 0xef, 0x6a, 0x1b, 0xca, 0xfb, 0x26,
-	0x42, 0x45, 0x47, 0xb4, 0x89, 0xcd, 0x18, 0x11, 0x60, 0xce, 0xbc, 0xab, 0x29, 0x2b, 0xdd, 0xf6,
+	0x1e, 0x18, 0x44, 0x74, 0x14, 0x2a, 0x3a, 0xa2, 0x4d, 0x6c, 0xc6, 0x88, 0x20, 0xf3, 0xcd, 0xbb,
-	0x1c, 0xd3, 0xea, 0x3f, 0x33, 0x5d, 0x4f, 0x63, 0xf0, 0x21, 0x51, 0xc9, 0x67, 0xd7, 0xd0, 0xdf,
+	0x9a, 0x32, 0xd3, 0x1d, 0xcf, 0x31, 0xad, 0xfe, 0x53, 0xd3, 0xf5, 0x34, 0x86, 0x1f, 0x12, 0x95,
-	0x53, 0xe0, 0xd2, 0x53, 0xec, 0xad, 0x09, 0x97, 0x43, 0xbe, 0x9b, 0xae, 0x67, 0xf6, 0xdc, 0xd7,
+	0x7c, 0x76, 0x0d, 0xfd, 0x5d, 0x05, 0x2e, 0x3d, 0xc1, 0xde, 0x9a, 0x70, 0x39, 0xe4, 0xbb, 0xe9,
-	0x1b, 0xf6, 0x65, 0x88, 0x3d, 0xd4, 0x3f, 0x54, 0xe0, 0x72, 0x2a, 0x31, 0x7c, 0xeb, 0xb8, 0x49,
+	0x7a, 0x66, 0xcf, 0x7d, 0xb5, 0x61, 0x5f, 0x86, 0xd8, 0x43, 0xfd, 0x03, 0x05, 0x2e, 0xa7, 0x32,
-	0xf5, 0x1d, 0x8e, 0xdc, 0xa4, 0xfe, 0x1a, 0x3e, 0xfe, 0x9c, 0x30, 0x7f, 0x4b, 0x37, 0x1d, 0x66,
+	0xc3, 0x97, 0x8e, 0x9b, 0x54, 0xdf, 0xe1, 0xc8, 0x4d, 0xea, 0xaf, 0xe0, 0x93, 0xcf, 0xc9, 0xe6,
-	0x52, 0x67, 0x74, 0x30, 0x3f, 0x57, 0xe0, 0xe2, 0x53, 0xec, 0x6d, 0xf9, 0xee, 0xf6, 0x2d, 0xee,
+	0x6f, 0xeb, 0xa6, 0xc3, 0x4c, 0xea, 0x8c, 0x0e, 0xe6, 0x67, 0x0a, 0x5c, 0x7c, 0x82, 0xbd, 0x6d,
-	0x0e, 0x81, 0x09, 0xb9, 0x7d, 0x3f, 0xee, 0x8c, 0xf4, 0xa9, 0x7f, 0xc0, 0xd8, 0x29, 0xa5, 0xf7,
+	0xdf, 0xdd, 0xbe, 0xc1, 0xd5, 0x21, 0x38, 0x21, 0xb7, 0xef, 0xc7, 0x9d, 0x11, 0x98, 0xfa, 0xfb,
-	0xad, 0x6c, 0xe0, 0x25, 0xaa, 0x09, 0x21, 0x3b, 0xc1, 0x35, 0x9e, 0x6f, 0x9f, 0xfa, 0x65, 0x11,
+	0x6c, 0x3b, 0xa5, 0xfc, 0xbe, 0x91, 0x05, 0xbc, 0x44, 0x35, 0x21, 0x64, 0x27, 0xb8, 0xc6, 0xf3,
-	0x6a, 0x9f, 0x73, 0xd3, 0x40, 0x1d, 0x6a, 0x7c, 0x27, 0x14, 0x79, 0x4c, 0x14, 0x0a, 0xae, 0x64,
+	0xe5, 0x53, 0xbf, 0x2a, 0x42, 0xed, 0x73, 0x6e, 0x1a, 0xa8, 0x43, 0x8d, 0xaf, 0x84, 0x22, 0x8f,
-	0xf1, 0xd6, 0x53, 0xa8, 0xbb, 0x18, 0x1f, 0xcc, 0xe2, 0x3e, 0x6b, 0x64, 0xa0, 0x70, 0x7b, 0xcf,
+	0x89, 0x42, 0xc1, 0x95, 0x2c, 0xde, 0x7a, 0x02, 0x75, 0x17, 0xe3, 0xc3, 0x59, 0xdc, 0x67, 0x8d,
-	0x60, 0x69, 0x6c, 0xd1, 0xa8, 0x1d, 0x1b, 0x7c, 0x15, 0x6c, 0xe7, 0xa7, 0x9b, 0xd5, 0xe4, 0x40,
+	0x74, 0x14, 0x6e, 0xef, 0x29, 0x2c, 0x8d, 0x2d, 0x1a, 0xb5, 0x63, 0x83, 0xcf, 0x82, 0xad, 0xfc,
-	0xf4, 0x19, 0x4f, 0x0c, 0x42, 0xb8, 0x8a, 0x99, 0x70, 0xc5, 0x87, 0xa1, 0x0e, 0x34, 0x0d, 0xc7,
+	0x74, 0xb3, 0x9a, 0xec, 0x88, 0x3e, 0xe3, 0x89, 0x41, 0x88, 0x56, 0x31, 0x13, 0xad, 0x78, 0x37,
-	0x1e, 0x8d, 0xb0, 0xd1, 0x75, 0x7d, 0x54, 0xa5, 0x6c, 0xa8, 0xf8, 0x38, 0x81, 0xea, 0x1e, 0x9c,
+	0xd4, 0x81, 0xa6, 0xe1, 0xd8, 0xa3, 0x11, 0x36, 0xba, 0xae, 0x4f, 0xaa, 0x94, 0x8d, 0x14, 0xef,
-	0x8e, 0x53, 0xda, 0x31, 0x48, 0xac, 0x48, 0xc4, 0x4b, 0xf6, 0x09, 0xdd, 0x86, 0xa5, 0x24, 0x7c,
+	0x27, 0x48, 0xdd, 0x83, 0xb3, 0x71, 0x4e, 0x3b, 0x06, 0x89, 0x15, 0x89, 0x78, 0xc9, 0x3e, 0xa1,
-	0x99, 0xc2, 0x27, 0x3f, 0xa0, 0x0f, 0x00, 0xc5, 0x48, 0x25, 0xe0, 0x15, 0x06, 0x1e, 0x25, 0x86,
+	0xdb, 0xb0, 0x94, 0xc4, 0x2f, 0x53, 0xfc, 0xe4, 0x07, 0xf4, 0x01, 0xa0, 0x18, 0xab, 0x04, 0xbd,
-	0x83, 0xd3, 0xa4, 0x34, 0x0a, 0x0e, 0x0c, 0x9c, 0x7f, 0x09, 0x81, 0x77, 0x88, 0x9f, 0x8d, 0x80,
+	0xc2, 0xd0, 0xa3, 0xcc, 0x70, 0x74, 0x9a, 0x94, 0x46, 0xd1, 0x81, 0xa1, 0xf3, 0x2f, 0x21, 0xf4,
-	0xbb, 0xad, 0x6a, 0xb6, 0x8d, 0x88, 0x22, 0x73, 0xd5, 0x2f, 0x15, 0x58, 0x7e, 0xa1, 0x7b, 0xbd,
+	0x0e, 0xf1, 0xb3, 0x11, 0x74, 0xb7, 0x55, 0xcd, 0xb6, 0x10, 0x51, 0x62, 0xae, 0xfa, 0x95, 0x02,
-	0xfd, 0xf5, 0x21, 0x97, 0xd2, 0x39, 0xb4, 0xfc, 0x13, 0xa8, 0x1c, 0x72, 0x89, 0xf4, 0x4d, 0xf9,
+	0xcb, 0xcf, 0x75, 0xaf, 0x77, 0xb0, 0x3e, 0xe4, 0x52, 0x3a, 0x87, 0x96, 0x7f, 0x02, 0x95, 0x23,
-	0x65, 0x09, 0x41, 0x61, 0xd9, 0xd7, 0x82, 0x11, 0x24, 0x49, 0x3a, 0xf3, 0x24, 0x94, 0x2c, 0xbe,
+	0x2e, 0x91, 0xbe, 0x29, 0xbf, 0x2c, 0x61, 0x28, 0x2c, 0xfb, 0x5a, 0xd0, 0x83, 0x24, 0x49, 0xe7,
-	0x05, 0x7b, 0x33, 0x25, 0xcb, 0x55, 0x5f, 0x01, 0x70, 0xe2, 0x36, 0xdc, 0xfe, 0x0c, 0x74, 0x3d,
+	0x36, 0x42, 0xc9, 0xe2, 0x1b, 0xb0, 0x37, 0x53, 0xb2, 0x5c, 0xf5, 0x25, 0x00, 0x67, 0x6e, 0xd3,
-	0x80, 0x05, 0x8e, 0x8d, 0x1b, 0x94, 0x69, 0x0c, 0xf3, 0xc1, 0xd5, 0x9f, 0x95, 0xa0, 0x1a, 0xfa,
+	0xed, 0xcf, 0xc0, 0xd7, 0x03, 0x58, 0xe0, 0xd4, 0xb8, 0x41, 0x99, 0xb6, 0x61, 0x3e, 0xba, 0xfa,
-	0x80, 0x1a, 0x90, 0x13, 0x96, 0x22, 0x27, 0x59, 0x5d, 0x6e, 0x7a, 0x5e, 0x95, 0x4f, 0xe6, 0x55,
+	0xd3, 0x12, 0x54, 0x43, 0x1f, 0x50, 0x03, 0x72, 0xc2, 0x52, 0xe4, 0x24, 0xb3, 0xcb, 0x4d, 0xcf,
-	0x37, 0xa0, 0x61, 0x52, 0x0f, 0xde, 0xe5, 0x5c, 0xa1, 0xa1, 0x73, 0x45, 0xab, 0xb3, 0x5e, 0x2e,
+	0xab, 0xf2, 0xc9, 0xbc, 0xea, 0x06, 0x34, 0x4c, 0xea, 0xc1, 0xbb, 0x7c, 0x57, 0x68, 0xe8, 0x5c,
-	0x22, 0xe8, 0x12, 0x54, 0xad, 0xf1, 0xb0, 0x6b, 0xef, 0x75, 0x1d, 0xfb, 0xc8, 0xe5, 0x09, 0x5a,
+	0xd1, 0xea, 0x0c, 0xca, 0x45, 0x04, 0x5d, 0x82, 0xaa, 0x35, 0x1e, 0x76, 0xed, 0xfd, 0xae, 0x63,
-	0xc5, 0x1a, 0x0f, 0xbf, 0xb7, 0xa7, 0xd9, 0x47, 0x6e, 0x90, 0x03, 0x94, 0x4e, 0x98, 0x03, 0x5c,
+	0x1f, 0xbb, 0x3c, 0x41, 0xab, 0x58, 0xe3, 0xe1, 0xf7, 0xf6, 0x35, 0xfb, 0xd8, 0x0d, 0x72, 0x80,
-	0x82, 0xea, 0x50, 0x7f, 0x45, 0xb0, 0x76, 0xad, 0xf1, 0x90, 0xe6, 0x6e, 0x79, 0xad, 0x32, 0xd4,
+	0xd2, 0x29, 0x73, 0x80, 0x4b, 0x50, 0x1d, 0xea, 0x2f, 0x09, 0xd5, 0xae, 0x35, 0x1e, 0xd2, 0xdc,
-	0x5f, 0x69, 0xf6, 0xd1, 0xe6, 0x78, 0x88, 0x56, 0xa0, 0x39, 0xd0, 0x5d, 0xaf, 0x1b, 0x4e, 0xfe,
+	0x2d, 0xaf, 0x55, 0x86, 0xfa, 0x4b, 0xcd, 0x3e, 0xde, 0x1a, 0x0f, 0xd1, 0x0a, 0x34, 0x07, 0xba,
-	0xca, 0x34, 0xf9, 0x6b, 0x90, 0xfe, 0xc7, 0x41, 0x02, 0x98, 0xcc, 0x26, 0x2a, 0x73, 0x64, 0x13,
+	0xeb, 0x75, 0xc3, 0xc9, 0x5f, 0x99, 0x26, 0x7f, 0x0d, 0x02, 0x7f, 0x1c, 0x24, 0x80, 0xc9, 0x6c,
-	0xc6, 0x70, 0x10, 0x20, 0x82, 0xec, 0xd9, 0x84, 0x31, 0x1c, 0x08, 0x34, 0x0f, 0x60, 0x61, 0x97,
+	0xa2, 0x32, 0x47, 0x36, 0x61, 0x0c, 0x07, 0x01, 0x21, 0xc8, 0x9e, 0x4d, 0x18, 0xc3, 0x81, 0x20,
-	0xc6, 0x45, 0x93, 0x94, 0xf5, 0x09, 0x09, 0x89, 0x58, 0xf8, 0xa4, 0xf9, 0xe0, 0xe8, 0x3b, 0x50,
+	0xf3, 0x00, 0x16, 0xf6, 0x68, 0x5c, 0x34, 0x49, 0x59, 0x37, 0x48, 0x48, 0xc4, 0xc2, 0x27, 0xcd,
-	0xa1, 0xee, 0x88, 0x8e, 0xad, 0x65, 0x1a, 0x1b, 0x0c, 0x20, 0xa3, 0x0d, 0x3c, 0xf0, 0x74, 0x3a,
+	0x47, 0x47, 0xdf, 0x81, 0x0a, 0x75, 0x47, 0xb4, 0x6f, 0x2d, 0x53, 0xdf, 0xa0, 0x03, 0xe9, 0x6d,
-	0xba, 0x9e, 0x6d, 0xb4, 0x18, 0x40, 0x2c, 0x65, 0xcf, 0xc1, 0xba, 0x87, 0x8d, 0xd5, 0xe3, 0x35,
+	0xe0, 0x81, 0xa7, 0xd3, 0xde, 0xf5, 0x6c, 0xbd, 0x45, 0x07, 0x62, 0x29, 0x7b, 0x0e, 0xd6, 0x3d,
-	0x7b, 0x38, 0xd2, 0xa9, 0x30, 0xb5, 0x1a, 0x34, 0xac, 0x97, 0x7d, 0x42, 0xef, 0x42, 0xa3, 0x27,
+	0x6c, 0xac, 0x9e, 0xac, 0xd9, 0xc3, 0x91, 0x4e, 0x85, 0xa9, 0xd5, 0xa0, 0x61, 0xbd, 0xec, 0x13,
-	0x5a, 0x4f, 0x1c, 0x7b, 0xd8, 0x5a, 0xa4, 0x7a, 0x14, 0xeb, 0x45, 0x17, 0x01, 0x7c, 0x1b, 0xa9,
+	0x7a, 0x17, 0x1a, 0x3d, 0xd1, 0xda, 0x70, 0xec, 0x61, 0x6b, 0x91, 0xea, 0x51, 0x0c, 0x8a, 0x2e,
-	0x7b, 0xad, 0x26, 0xe5, 0x62, 0x85, 0xf7, 0x3c, 0xa2, 0xb5, 0x1d, 0xd3, 0xed, 0xb2, 0x2a, 0x8a,
+	0x02, 0xf8, 0x36, 0x52, 0xf7, 0x5a, 0x4d, 0xba, 0x8b, 0x15, 0x0e, 0x79, 0x44, 0x6b, 0x3b, 0xa6,
-	0x69, 0xf5, 0x5b, 0x4b, 0x74, 0xc6, 0xaa, 0x5f, 0x76, 0x31, 0xad, 0x3e, 0x3a, 0x0b, 0x0b, 0xa6,
+	0xdb, 0x65, 0x55, 0x14, 0xd3, 0xea, 0xb7, 0x96, 0xe8, 0x88, 0x55, 0xbf, 0xec, 0x62, 0x5a, 0x7d,
-	0xdb, 0xdd, 0xd3, 0x0f, 0x70, 0x0b, 0xd1, 0xaf, 0x25, 0xd3, 0x7d, 0xa2, 0x1f, 0x60, 0xf5, 0x27,
+	0x74, 0x1e, 0x16, 0x4c, 0xb7, 0xbb, 0xaf, 0x1f, 0xe2, 0x16, 0xa2, 0x5f, 0x4b, 0xa6, 0xbb, 0xa1,
-	0x70, 0x26, 0x90, 0xae, 0x10, 0x27, 0x93, 0x42, 0xa1, 0xcc, 0x2a, 0x14, 0x93, 0xa3, 0xe1, 0xaf,
+	0x1f, 0x62, 0xf5, 0xc7, 0x70, 0x2e, 0x90, 0xae, 0xd0, 0x4e, 0x26, 0x85, 0x42, 0x99, 0x55, 0x28,
-	0x0b, 0xb0, 0xbc, 0xad, 0x1f, 0xe2, 0x37, 0x1f, 0x78, 0x67, 0x32, 0x6b, 0xcf, 0x60, 0x89, 0xc6,
+	0x26, 0x47, 0xc3, 0xbf, 0x28, 0xc0, 0xf2, 0x8e, 0x7e, 0x84, 0x5f, 0x7f, 0xe0, 0x9d, 0xc9, 0xac,
-	0xda, 0xf7, 0x43, 0xf4, 0x4c, 0xf0, 0xe8, 0x61, 0x51, 0x48, 0x0e, 0x44, 0xdf, 0x25, 0xa1, 0x08,
+	0x3d, 0x85, 0x25, 0x1a, 0x6b, 0xdf, 0x0f, 0xf1, 0x33, 0xc1, 0xa3, 0x87, 0x45, 0x21, 0xd9, 0x11,
-	0xee, 0x1d, 0x6c, 0x91, 0xe4, 0xc5, 0xf7, 0xe6, 0x17, 0x25, 0x78, 0xd6, 0x04, 0x94, 0x16, 0x1e,
+	0x7d, 0x97, 0x84, 0x22, 0xb8, 0x77, 0xb8, 0x4d, 0x92, 0x17, 0xdf, 0x9b, 0x5f, 0x94, 0xd0, 0x59,
-	0x81, 0xb6, 0x60, 0x31, 0xca, 0x06, 0xdf, 0x8f, 0xdf, 0x9c, 0x98, 0xd9, 0x06, 0xbb, 0xaf, 0x35,
+	0x13, 0x58, 0x5a, 0xb8, 0x07, 0xda, 0x86, 0xc5, 0xe8, 0x36, 0xf8, 0x7e, 0xfc, 0xe6, 0xc4, 0xcc,
-	0x22, 0xcc, 0x70, 0x51, 0x0b, 0x16, 0xb8, 0x13, 0xa6, 0x36, 0xa3, 0xac, 0xf9, 0x4d, 0xb4, 0x05,
+	0x36, 0x58, 0x7d, 0xad, 0x11, 0xd9, 0x0c, 0x17, 0xb5, 0x60, 0x81, 0x3b, 0x61, 0x6a, 0x33, 0xca,
-	0xa7, 0xd9, 0x0a, 0xb6, 0xb9, 0x42, 0xb0, 0xc5, 0x97, 0x33, 0x2d, 0x5e, 0x36, 0x34, 0xaa, 0x4f,
+	0x9a, 0xdf, 0x44, 0xdb, 0x70, 0x96, 0xcd, 0x60, 0x87, 0x2b, 0x04, 0x9b, 0x7c, 0x39, 0xd3, 0xe4,
-	0x95, 0x93, 0xea, 0x53, 0x0b, 0x16, 0xb8, 0x8c, 0x53, 0x3b, 0x52, 0xd6, 0xfc, 0x26, 0x61, 0x73,
+	0x65, 0x5d, 0xa3, 0xfa, 0x54, 0x39, 0xad, 0x3e, 0xb5, 0x60, 0x81, 0xcb, 0x38, 0xb5, 0x23, 0x65,
-	0x20, 0xed, 0x55, 0xfa, 0x2d, 0xe8, 0x20, 0x49, 0x0b, 0x04, 0xfb, 0x39, 0xa5, 0x06, 0xf3, 0x29,
+	0xcd, 0x6f, 0x92, 0x6d, 0x0e, 0xa4, 0xbd, 0x4a, 0xbf, 0x05, 0x00, 0x92, 0xb4, 0x40, 0xb0, 0x9e,
-	0x94, 0x85, 0x84, 0x67, 0x4f, 0x1e, 0xc5, 0x98, 0xb8, 0x7d, 0xcf, 0xc7, 0xec, 0xbb, 0xfa, 0xcf,
+	0x53, 0x6a, 0x30, 0x9f, 0x42, 0x59, 0x48, 0x78, 0xf6, 0xe4, 0x51, 0xf4, 0x89, 0xdb, 0xf7, 0x7c,
-	0x0a, 0xd4, 0xd6, 0xc9, 0x92, 0x9e, 0xd9, 0x7d, 0xea, 0x8d, 0x6e, 0x40, 0xc3, 0xc1, 0x3d, 0xdb,
+	0xcc, 0xbe, 0xab, 0xff, 0xa8, 0x40, 0x6d, 0x9d, 0x4c, 0xe9, 0xa9, 0xdd, 0xa7, 0xde, 0xe8, 0x06,
-	0x31, 0xba, 0xd8, 0xf2, 0x1c, 0x13, 0xb3, 0xd4, 0xbd, 0xa0, 0xd5, 0x59, 0xef, 0x63, 0xd6, 0x49,
+	0x34, 0x1c, 0xdc, 0xb3, 0x1d, 0xa3, 0x8b, 0x2d, 0xcf, 0x31, 0x31, 0x4b, 0xdd, 0x0b, 0x5a, 0x9d,
-	0xc0, 0x88, 0xc9, 0x76, 0x3d, 0x7d, 0x38, 0xea, 0xee, 0x11, 0xd3, 0x90, 0x63, 0x60, 0xa2, 0x97,
+	0x41, 0x1f, 0x33, 0x20, 0x41, 0x23, 0x26, 0xdb, 0xf5, 0xf4, 0xe1, 0xa8, 0xbb, 0x4f, 0x4c, 0x43,
-	0x5a, 0x86, 0xab, 0x50, 0x0b, 0xc0, 0x3c, 0x9b, 0xce, 0x5f, 0xd0, 0xaa, 0xa2, 0x6f, 0xc7, 0x46,
+	0x8e, 0xa1, 0x09, 0x28, 0xb5, 0x0c, 0x57, 0xa1, 0x16, 0xa0, 0x79, 0x36, 0x1d, 0xbf, 0xa0, 0x55,
-	0xd7, 0xa1, 0x41, 0xf7, 0xb4, 0x3b, 0xb0, 0xfb, 0x5d, 0x92, 0x0b, 0x72, 0x47, 0x55, 0x33, 0x38,
+	0x05, 0x6c, 0xd7, 0x46, 0xd7, 0xa1, 0x41, 0xd7, 0xb4, 0x3b, 0xb0, 0xfb, 0x5d, 0x92, 0x0b, 0x72,
-	0x59, 0x84, 0x57, 0x51, 0x28, 0xd7, 0xfc, 0x31, 0xe6, 0xae, 0x4a, 0x40, 0x6d, 0x9b, 0x3f, 0xc6,
+	0x47, 0x55, 0x33, 0x38, 0x5b, 0x64, 0xaf, 0xa2, 0x58, 0xae, 0xf9, 0x23, 0xcc, 0x5d, 0x95, 0xc0,
-	0xea, 0x3f, 0x29, 0x50, 0x5f, 0xd7, 0x3d, 0x7d, 0xd3, 0x36, 0xf0, 0xce, 0x8c, 0x8e, 0x3d, 0x43,
+	0xda, 0x31, 0x7f, 0x84, 0xd5, 0x7f, 0x50, 0xa0, 0xbe, 0xae, 0x7b, 0xfa, 0x96, 0x6d, 0xe0, 0xdd,
-	0x3d, 0xf4, 0x02, 0x54, 0xc4, 0x0a, 0xf8, 0x92, 0x82, 0x0e, 0xf4, 0x04, 0x1a, 0x7e, 0x2c, 0xd7,
+	0x19, 0x1d, 0x7b, 0x86, 0x7a, 0xe8, 0x3b, 0x50, 0x11, 0x33, 0xe0, 0x53, 0x0a, 0x00, 0x68, 0x03,
-	0x65, 0xb9, 0x4a, 0x21, 0x35, 0x80, 0x0a, 0x79, 0x4e, 0x57, 0xab, 0xfb, 0xc3, 0x68, 0x53, 0x7d,
+	0x1a, 0x7e, 0x2c, 0xd7, 0x65, 0xb9, 0x4a, 0x21, 0x35, 0x80, 0x0a, 0x79, 0x4e, 0x57, 0xab, 0xfb,
-	0x02, 0xb5, 0xf0, 0x67, 0x32, 0xeb, 0x76, 0x5c, 0x50, 0x44, 0x07, 0x91, 0xc6, 0xcd, 0xf1, 0x90,
+	0xdd, 0x68, 0x53, 0xdd, 0x80, 0x5a, 0xf8, 0x33, 0x19, 0x75, 0x27, 0x2e, 0x28, 0x02, 0x40, 0xa4,
-	0xf0, 0x94, 0x1b, 0x16, 0xbf, 0xa9, 0xfe, 0x8e, 0x02, 0x75, 0xee, 0xee, 0xb7, 0xc5, 0xc9, 0x01,
+	0x71, 0x6b, 0x3c, 0x24, 0x7b, 0xca, 0x0d, 0x8b, 0xdf, 0x54, 0x7f, 0x5b, 0x81, 0x3a, 0x77, 0xf7,
-	0x5d, 0x1a, 0xab, 0x50, 0xd0, 0xdf, 0xe8, 0xdb, 0xd1, 0x62, 0xdf, 0x75, 0xa9, 0x11, 0xa0, 0x48,
+	0x3b, 0xe2, 0xe4, 0x80, 0x4e, 0x8d, 0x55, 0x28, 0xe8, 0x6f, 0xf4, 0xed, 0x68, 0xb1, 0xef, 0xba,
-	0x68, 0x90, 0x19, 0xf1, 0xf5, 0x59, 0xb2, 0xe3, 0x2f, 0x88, 0xa0, 0x71, 0xd6, 0x50, 0x41, 0x6b,
+	0xd4, 0x08, 0x50, 0x22, 0x34, 0xc8, 0x8c, 0xf8, 0xfa, 0x2c, 0xd9, 0xf1, 0x97, 0x44, 0xd0, 0xf8,
-	0xc1, 0x82, 0x6e, 0x18, 0x0e, 0x76, 0x5d, 0x4e, 0x87, 0xdf, 0x24, 0x5f, 0x0e, 0xb1, 0xe3, 0xfa,
+	0xd6, 0x50, 0x41, 0x6b, 0xc1, 0x82, 0x6e, 0x18, 0x0e, 0x76, 0x5d, 0xce, 0x87, 0xdf, 0x24, 0x5f,
-	0x22, 0x9f, 0xd7, 0xfc, 0x26, 0xfa, 0x0e, 0x94, 0x45, 0x54, 0xca, 0x4a, 0x3b, 0x57, 0xd2, 0xe9,
+	0x8e, 0xb0, 0xe3, 0xfa, 0x22, 0x9f, 0xd7, 0xfc, 0x26, 0xfa, 0x0e, 0x94, 0x45, 0x54, 0xca, 0x4a,
-	0xe4, 0xb9, 0x9c, 0x18, 0xa1, 0xfe, 0x7d, 0x0e, 0x1a, 0x7c, 0xc3, 0x56, 0xb9, 0x3f, 0x9e, 0xac,
+	0x3b, 0x57, 0xd2, 0xf9, 0xe4, 0xb9, 0x9c, 0xe8, 0xa1, 0xfe, 0x6d, 0x0e, 0x1a, 0x7c, 0xc1, 0x56,
-	0x7c, 0xab, 0x50, 0xdb, 0x0b, 0x74, 0x7f, 0x52, 0x41, 0x2a, 0x6c, 0x22, 0x22, 0x63, 0xa6, 0x29,
+	0xb9, 0x3f, 0x9e, 0xac, 0x7c, 0xab, 0x50, 0xdb, 0x0f, 0x74, 0x7f, 0x52, 0x41, 0x2a, 0x6c, 0x22,
-	0x60, 0x34, 0x22, 0x28, 0xcc, 0x15, 0x11, 0x14, 0x4f, 0x6a, 0xc1, 0x92, 0x31, 0x62, 0x49, 0x12,
+	0x22, 0x7d, 0xa6, 0x29, 0x60, 0x34, 0x22, 0x28, 0xcc, 0x15, 0x11, 0x14, 0x4f, 0x6b, 0xc1, 0x92,
-	0x23, 0xaa, 0xbf, 0x0e, 0xd5, 0x10, 0x02, 0x6a, 0xa1, 0x59, 0xb9, 0x87, 0xef, 0x98, 0xdf, 0x44,
+	0x31, 0x62, 0x49, 0x12, 0x23, 0xaa, 0xbf, 0x06, 0xd5, 0x10, 0x01, 0x6a, 0xa1, 0x59, 0xb9, 0x87,
-	0x1f, 0x05, 0x71, 0x11, 0xdb, 0xaa, 0x73, 0x12, 0x5a, 0x62, 0x21, 0x91, 0xfa, 0x8f, 0x0a, 0x94,
+	0xaf, 0x98, 0xdf, 0x44, 0x1f, 0x05, 0x71, 0x11, 0x5b, 0xaa, 0x0b, 0x12, 0x5e, 0x62, 0x21, 0x91,
-	0x38, 0xe6, 0xcb, 0x50, 0xe5, 0x46, 0x87, 0xc6, 0x8c, 0x0c, 0x3b, 0xf0, 0x2e, 0x12, 0x34, 0xbe,
+	0xfa, 0xf7, 0x0a, 0x94, 0x38, 0xe5, 0xcb, 0x50, 0xe5, 0x46, 0x87, 0xc6, 0x8c, 0x8c, 0x3a, 0x70,
-	0x3e, 0xab, 0x73, 0x0e, 0xca, 0x31, 0x7b, 0xb3, 0xc0, 0xdd, 0x82, 0xff, 0x29, 0x64, 0x64, 0xc8,
+	0x10, 0x09, 0x1a, 0x5f, 0x9d, 0xd5, 0xb9, 0x00, 0xe5, 0x98, 0xbd, 0x59, 0xe0, 0x6e, 0xc1, 0xff,
-	0x27, 0x62, 0x5f, 0xd0, 0x19, 0x28, 0x0e, 0xec, 0xbe, 0x38, 0x19, 0x62, 0x0d, 0xf5, 0x2b, 0x85,
+	0x14, 0x32, 0x32, 0xe4, 0x13, 0xb1, 0x2f, 0xe8, 0x1c, 0x14, 0x07, 0x76, 0x5f, 0x9c, 0x0c, 0xb1,
-	0x16, 0xf2, 0x35, 0xdc, 0xb3, 0x0f, 0xb1, 0x73, 0x3c, 0x7f, 0x05, 0xf4, 0x61, 0x48, 0xcc, 0x33,
+	0x86, 0xfa, 0xb5, 0x42, 0x0b, 0xf9, 0x1a, 0xee, 0xd9, 0x47, 0xd8, 0x39, 0x99, 0xbf, 0x02, 0xfa,
-	0x26, 0x5f, 0x62, 0x00, 0x7a, 0x18, 0x30, 0x21, 0x2f, 0xab, 0x91, 0x84, 0xed, 0x0e, 0x17, 0xd2,
+	0x30, 0x24, 0xe6, 0x19, 0x93, 0x2f, 0xd1, 0x01, 0x3d, 0x0c, 0x36, 0x21, 0x2f, 0xab, 0x91, 0x84,
-	0x80, 0x19, 0x7f, 0xa4, 0xd0, 0x5a, 0x6e, 0x74, 0x29, 0xb3, 0x46, 0x3b, 0xaf, 0x25, 0x91, 0x51,
+	0xed, 0x0e, 0x17, 0xd2, 0x60, 0x33, 0xfe, 0x50, 0xa1, 0xb5, 0xdc, 0xe8, 0x54, 0x66, 0x8d, 0x76,
-	0xbf, 0x56, 0xa0, 0x1d, 0x14, 0x61, 0xdc, 0xd5, 0xe3, 0x79, 0x4f, 0x4a, 0x5e, 0x4f, 0x7e, 0xf5,
+	0x5e, 0x49, 0x22, 0xa3, 0xfe, 0x42, 0x81, 0x76, 0x50, 0x84, 0x71, 0x57, 0x4f, 0xe6, 0x3d, 0x29,
-	0xcb, 0xa2, 0x94, 0x4f, 0x94, 0x36, 0x53, 0x66, 0xe4, 0x17, 0xf2, 0x2d, 0x5a, 0xcf, 0x4d, 0x2e,
+	0x79, 0x35, 0xf9, 0xd5, 0xff, 0x17, 0xa5, 0x7c, 0xa2, 0xb4, 0x99, 0x32, 0x23, 0xbf, 0x90, 0x6f,
-	0x68, 0x1e, 0x91, 0x69, 0x43, 0x59, 0x14, 0x10, 0x58, 0x39, 0x5f, 0xb4, 0x89, 0x86, 0x9d, 0x7b,
+	0xd1, 0x7a, 0x6e, 0x72, 0x42, 0xf3, 0x88, 0x4c, 0x1b, 0xca, 0xa2, 0x80, 0xc0, 0xca, 0xf9, 0xa2,
-	0x8a, 0xbd, 0x27, 0xd1, 0x22, 0xcc, 0xdb, 0xde, 0xc0, 0xf0, 0x11, 0xc3, 0x3e, 0x3f, 0x62, 0x28,
+	0x4d, 0x34, 0xec, 0xc2, 0x13, 0xec, 0x6d, 0x44, 0x8b, 0x30, 0x6f, 0x7a, 0x01, 0xc3, 0x47, 0x0c,
-	0xc4, 0x8e, 0x18, 0x78, 0xbf, 0x3a, 0xa4, 0x22, 0x90, 0x58, 0xc0, 0x9b, 0xda, 0xb0, 0xdf, 0x55,
+	0x07, 0xfc, 0x88, 0xa1, 0x10, 0x3b, 0x62, 0xe0, 0x70, 0x75, 0x48, 0x45, 0x20, 0x31, 0x81, 0xd7,
-	0xa0, 0xc5, 0x67, 0xa1, 0x73, 0x92, 0x94, 0x68, 0x80, 0x3d, 0x6c, 0x7c, 0xd3, 0xa5, 0x82, 0xff,
+	0xb5, 0x60, 0xbf, 0xa3, 0x40, 0x8b, 0x8f, 0x42, 0xc7, 0x24, 0x29, 0xd1, 0x00, 0x7b, 0xd8, 0xf8,
-	0x51, 0xa0, 0x19, 0xf6, 0xba, 0xd4, 0x71, 0x7e, 0x0c, 0x45, 0x5a, 0x69, 0xe1, 0x14, 0x4c, 0x35,
+	0xa6, 0x4b, 0x05, 0xff, 0xad, 0x40, 0x33, 0xec, 0x75, 0xa9, 0xe3, 0xfc, 0x18, 0x8a, 0xb4, 0xd2,
-	0x0d, 0x0c, 0x9a, 0x98, 0x6d, 0x1a, 0x6a, 0xef, 0x88, 0x00, 0x81, 0x37, 0x03, 0xd7, 0x9f, 0x3f,
+	0xc2, 0x39, 0x98, 0x6a, 0x1a, 0x18, 0x36, 0x31, 0xdb, 0x34, 0xd4, 0xde, 0x15, 0x01, 0x02, 0x6f,
-	0xb9, 0xeb, 0xe7, 0xa1, 0x90, 0x3d, 0x26, 0x78, 0xd9, 0x09, 0x70, 0xd0, 0x81, 0x3e, 0x81, 0x12,
+	0x06, 0xae, 0x3f, 0x7f, 0x7a, 0xd7, 0xcf, 0x43, 0x21, 0x7b, 0x4c, 0xe8, 0xb2, 0x13, 0xe0, 0x00,
-	0xbb, 0xb0, 0xc1, 0x8f, 0xdd, 0x6e, 0x44, 0x51, 0xf3, 0xcb, 0x1c, 0xa1, 0x8a, 0x39, 0xed, 0xd0,
+	0x80, 0x3e, 0x81, 0x12, 0xbb, 0xb0, 0xc1, 0x8f, 0xdd, 0x6e, 0x44, 0x49, 0xf3, 0xcb, 0x1c, 0xa1,
-	0xf8, 0x20, 0xf5, 0x57, 0x61, 0x39, 0xc8, 0x46, 0xd9, 0xb4, 0xb3, 0x0a, 0xad, 0xfa, 0x6f, 0x0a,
+	0x8a, 0x39, 0x05, 0x68, 0xbc, 0x93, 0xfa, 0xcb, 0xb0, 0x1c, 0x64, 0xa3, 0x6c, 0xd8, 0x59, 0x85,
-	0x9c, 0xde, 0x3e, 0xb6, 0x7a, 0x71, 0xf1, 0x5f, 0x86, 0xd2, 0x68, 0xa0, 0x07, 0xb5, 0x5a, 0xde,
+	0x56, 0xfd, 0x17, 0x05, 0xce, 0xee, 0x9c, 0x58, 0xbd, 0xb8, 0xf8, 0x2f, 0x43, 0x69, 0x34, 0xd0,
-	0xa2, 0x61, 0x20, 0x9b, 0x1b, 0x1b, 0xc4, 0x87, 0xb0, 0x3d, 0xab, 0x8a, 0xbe, 0x1d, 0x7b, 0xaa,
+	0x83, 0x5a, 0x2d, 0x6f, 0xd1, 0x30, 0x90, 0x8d, 0x8d, 0x0d, 0xe2, 0x43, 0xd8, 0x9a, 0x55, 0x05,
-	0x6b, 0xbf, 0x21, 0xd2, 0x67, 0x6c, 0x30, 0x6f, 0xc5, 0xca, 0x50, 0x75, 0xd1, 0x4b, 0xbd, 0xd5,
+	0x6c, 0xd7, 0x9e, 0xea, 0xda, 0x6f, 0x88, 0xf4, 0x19, 0x1b, 0xcc, 0x5b, 0xb1, 0x32, 0x54, 0x5d,
-	0x27, 0x00, 0xd4, 0xa1, 0x77, 0x4f, 0xe2, 0xc4, 0xe9, 0x88, 0x67, 0xc4, 0x64, 0xff, 0x22, 0x07,
+	0x40, 0xa9, 0xb7, 0xfa, 0x04, 0x80, 0x3a, 0xf4, 0xee, 0x69, 0x9c, 0x38, 0xed, 0xf1, 0x94, 0x98,
-	0xad, 0xd0, 0x2e, 0x7d, 0xd3, 0xf1, 0x4d, 0x4a, 0x56, 0x96, 0x7f, 0x4d, 0x59, 0x59, 0x61, 0xfe,
+	0xec, 0x9f, 0xe7, 0xa0, 0x15, 0x5a, 0xa5, 0x6f, 0x3a, 0xbe, 0x49, 0xc9, 0xca, 0xf2, 0xaf, 0x28,
-	0x98, 0xa6, 0x28, 0x8b, 0x69, 0x7e, 0x2b, 0x0f, 0x8d, 0x60, 0xd7, 0xb6, 0x06, 0xba, 0x95, 0x2a,
+	0x2b, 0x2b, 0xcc, 0x1f, 0xd3, 0x14, 0x65, 0x31, 0xcd, 0x6f, 0xe6, 0xa1, 0x11, 0xac, 0xda, 0xf6,
-	0x09, 0xdb, 0x22, 0x9e, 0x8f, 0xee, 0xd3, 0xfb, 0x32, 0x3d, 0x49, 0x61, 0x84, 0x16, 0x43, 0x81,
+	0x40, 0xb7, 0x52, 0x25, 0x61, 0x47, 0xc4, 0xf3, 0xd1, 0x75, 0x7a, 0x5f, 0xa6, 0x27, 0x29, 0x1b,
-	0x2e, 0x52, 0xa6, 0x3b, 0x1e, 0x2b, 0x7c, 0xf1, 0x1c, 0x82, 0x29, 0xa4, 0x39, 0xc4, 0xe8, 0x36,
+	0xa1, 0xc5, 0x48, 0xa0, 0x8b, 0x74, 0xd3, 0x1d, 0x8f, 0x15, 0xbe, 0x78, 0x0e, 0xc1, 0x14, 0xd2,
-	0x20, 0xae, 0x45, 0x5d, 0xd3, 0xea, 0xba, 0xb8, 0x67, 0x5b, 0x06, 0xd3, 0xaf, 0xa2, 0xd6, 0xe4,
+	0x1c, 0x62, 0x74, 0x1b, 0x10, 0xd7, 0xa2, 0xae, 0x69, 0x75, 0x5d, 0xdc, 0xb3, 0x2d, 0x83, 0xe9,
-	0x5f, 0x3a, 0xd6, 0x36, 0xeb, 0x47, 0x1f, 0x43, 0xc1, 0x3b, 0x1e, 0xb1, 0x68, 0xa5, 0x21, 0xf5,
+	0x57, 0x51, 0x6b, 0xf2, 0x2f, 0x1d, 0x6b, 0x87, 0xc1, 0xd1, 0xc7, 0x50, 0xf0, 0x4e, 0x46, 0x2c,
-	0xf7, 0x01, 0x5d, 0x3b, 0xc7, 0x23, 0xac, 0x51, 0x70, 0xff, 0xfa, 0x8e, 0xe7, 0xe8, 0x87, 0x3c,
+	0x5a, 0x69, 0x48, 0xfd, 0x7d, 0xc0, 0xd7, 0xee, 0xc9, 0x08, 0x6b, 0x14, 0xdd, 0xbf, 0xbe, 0xe3,
-	0xf4, 0x2b, 0x68, 0xa1, 0x1e, 0x62, 0x31, 0xfc, 0x3d, 0x5c, 0x60, 0x21, 0x12, 0x6f, 0x32, 0xc9,
+	0x39, 0xfa, 0x11, 0x0f, 0xfd, 0x0a, 0x5a, 0x08, 0x42, 0x2c, 0x86, 0xbf, 0x86, 0x0b, 0x2c, 0x44,
-	0xf6, 0x95, 0xb6, 0xeb, 0x79, 0x03, 0x5a, 0xba, 0xa3, 0x92, 0xed, 0xf7, 0xee, 0x78, 0x03, 0xb2,
+	0xe2, 0x4d, 0x26, 0xd9, 0xbe, 0xd2, 0x76, 0x3d, 0x6f, 0x40, 0x4b, 0x77, 0x54, 0xb2, 0x7d, 0xe8,
-	0x48, 0xcf, 0xf6, 0xf4, 0x01, 0xd3, 0x8f, 0x0a, 0xb7, 0x0e, 0xa4, 0x87, 0x26, 0x26, 0xff, 0x9a,
+	0xae, 0x37, 0x20, 0x93, 0xf4, 0x6c, 0x4f, 0x1f, 0x30, 0xfd, 0xa8, 0x70, 0xeb, 0x40, 0x20, 0x34,
-	0x83, 0x66, 0x40, 0x98, 0x86, 0xdd, 0xf1, 0x20, 0x5d, 0x1f, 0x27, 0x97, 0x4e, 0xa6, 0xa9, 0xe2,
+	0x31, 0xf9, 0xe7, 0x1c, 0x34, 0x03, 0xc6, 0x34, 0xec, 0x8e, 0x07, 0xe9, 0xfa, 0x38, 0xb9, 0x74,
-	0x77, 0xa1, 0xca, 0xa5, 0xe2, 0x04, 0x52, 0x05, 0x6c, 0xc8, 0xb3, 0x09, 0x62, 0x5e, 0x7c, 0x4d,
+	0x32, 0x4d, 0x15, 0xbf, 0x0b, 0x55, 0x2e, 0x15, 0xa7, 0x90, 0x2a, 0x60, 0x5d, 0x9e, 0x4e, 0x10,
-	0x62, 0x5e, 0x9a, 0xa1, 0xf8, 0x20, 0xe7, 0x8d, 0xfa, 0x53, 0x05, 0xde, 0x49, 0x58, 0xcd, 0x89,
+	0xf3, 0xe2, 0x2b, 0x12, 0xf3, 0xd2, 0x0c, 0xc5, 0x07, 0xf9, 0xde, 0xa8, 0x3f, 0x51, 0xe0, 0xad,
-	0x5b, 0x3b, 0x39, 0xf5, 0xe3, 0xd6, 0x34, 0x8e, 0x92, 0xdb, 0xff, 0x87, 0x50, 0x72, 0x28, 0x76,
+	0x84, 0xd5, 0x9c, 0xb8, 0xb4, 0x93, 0x53, 0x3f, 0x6e, 0x4d, 0xe3, 0x24, 0xb9, 0xfd, 0x7f, 0x08,
-	0x7e, 0x46, 0x75, 0x6d, 0xa2, 0xf0, 0x31, 0x42, 0x34, 0x3e, 0x44, 0xfd, 0x63, 0x05, 0xce, 0x26,
+	0x25, 0x87, 0x52, 0xe7, 0x67, 0x54, 0xd7, 0x26, 0x0a, 0x1f, 0x63, 0x44, 0xe3, 0x5d, 0xd4, 0x3f,
-	0x49, 0x9d, 0xc3, 0xa9, 0xaf, 0xc2, 0x02, 0x43, 0xed, 0xeb, 0xe8, 0xca, 0x64, 0x1d, 0x0d, 0x36,
+	0x52, 0xe0, 0x7c, 0x92, 0xd5, 0x39, 0x9c, 0xfa, 0x2a, 0x2c, 0x30, 0xd2, 0xbe, 0x8e, 0xae, 0x4c,
-	0x47, 0xf3, 0x07, 0xaa, 0xdb, 0xb0, 0xec, 0xfb, 0xfe, 0x60, 0xeb, 0x37, 0xb0, 0xa7, 0x4f, 0x48,
+	0xd6, 0xd1, 0x60, 0x71, 0x34, 0xbf, 0xa3, 0xba, 0x03, 0xcb, 0xbe, 0xef, 0x0f, 0x96, 0x7e, 0x13,
-	0x7c, 0x2e, 0x43, 0x95, 0x45, 0xd0, 0x2c, 0xa1, 0x60, 0x25, 0x03, 0xd8, 0x15, 0x95, 0x36, 0xf5,
+	0x7b, 0xfa, 0x84, 0xc4, 0xe7, 0x32, 0x54, 0x59, 0x04, 0xcd, 0x12, 0x0a, 0x56, 0x32, 0x80, 0x3d,
-	0xbf, 0x14, 0x38, 0x43, 0x9d, 0x67, 0xfc, 0x68, 0x26, 0xcb, 0x81, 0xa1, 0x2a, 0x2a, 0x12, 0x9b,
+	0x51, 0x69, 0x53, 0xff, 0x43, 0x81, 0x73, 0xd4, 0x79, 0xc6, 0x8f, 0x66, 0xb2, 0x1c, 0x18, 0xaa,
-	0xfa, 0x90, 0xdf, 0x1d, 0xa9, 0x68, 0x91, 0x3e, 0xd4, 0x49, 0x16, 0xe2, 0xa4, 0x09, 0x72, 0x70,
+	0xa2, 0x22, 0xb1, 0xa5, 0x0f, 0xf9, 0xdd, 0x91, 0x8a, 0x16, 0x81, 0xa1, 0x4e, 0xb2, 0x10, 0x27,
-	0x42, 0x4a, 0x92, 0x71, 0x7a, 0x40, 0x1a, 0xaf, 0xc0, 0x05, 0x4e, 0xbb, 0x30, 0x8b, 0xd3, 0x7e,
+	0x4d, 0x90, 0x83, 0x13, 0x52, 0x92, 0x8c, 0xd3, 0x03, 0xd2, 0x78, 0x05, 0x2e, 0x70, 0xda, 0x85,
-	0x06, 0xef, 0xc4, 0x56, 0x3a, 0x07, 0x47, 0xd5, 0xbf, 0x56, 0x08, 0x3b, 0x22, 0x77, 0x70, 0x66,
+	0x59, 0x9c, 0xf6, 0x53, 0x78, 0x2b, 0x36, 0xd3, 0x39, 0x76, 0x54, 0xfd, 0x4b, 0x85, 0x6c, 0x47,
-	0x0f, 0x5c, 0x2f, 0x8a, 0x33, 0xa1, 0xae, 0x69, 0xc4, 0x8d, 0x88, 0x81, 0x3e, 0x85, 0x8a, 0x85,
+	0xe4, 0x0e, 0xce, 0xec, 0x81, 0xeb, 0x45, 0x71, 0x26, 0xd4, 0x35, 0x8d, 0xb8, 0x11, 0x31, 0xd0,
-	0x8f, 0xba, 0xe1, 0x58, 0x28, 0x43, 0x54, 0x5f, 0xb6, 0xf0, 0x11, 0xfd, 0xa5, 0x6e, 0xc2, 0xd9,
+	0xa7, 0x50, 0xb1, 0xf0, 0x71, 0x37, 0x1c, 0x0b, 0x65, 0x88, 0xea, 0xcb, 0x16, 0x3e, 0xa6, 0xbf,
-	0x04, 0xa9, 0xf3, 0xac, 0xfd, 0x1f, 0x14, 0x38, 0xb7, 0xee, 0xd8, 0xa3, 0xcf, 0x4d, 0xc7, 0x1b,
+	0xd4, 0x2d, 0x38, 0x9f, 0x60, 0x75, 0x9e, 0xb9, 0xff, 0x9d, 0x02, 0x17, 0xd6, 0x1d, 0x7b, 0xf4,
-	0xeb, 0x83, 0xe8, 0xd9, 0xf3, 0x9b, 0xa9, 0x6c, 0x7d, 0x16, 0x8a, 0x8a, 0x99, 0xfc, 0xdc, 0x96,
+	0xb9, 0xe9, 0x78, 0x63, 0x7d, 0x10, 0x3d, 0x7b, 0x7e, 0x3d, 0x95, 0xad, 0xcf, 0x42, 0x51, 0x31,
-	0x68, 0x50, 0x92, 0x28, 0xbe, 0xe8, 0x50, 0x0c, 0xfd, 0x9f, 0x79, 0x19, 0xf1, 0x1c, 0x6e, 0x4a,
+	0x93, 0x9f, 0xdb, 0x12, 0x0d, 0x4a, 0x32, 0xc5, 0x27, 0x1d, 0x8a, 0xa1, 0xff, 0x3d, 0x2f, 0x63,
-	0x5c, 0x92, 0x25, 0xc1, 0x90, 0x16, 0xc2, 0xf3, 0xb3, 0x16, 0xc2, 0x53, 0xcc, 0x7b, 0xe1, 0x35,
+	0x9e, 0xe3, 0x4d, 0x89, 0x4b, 0xb2, 0x24, 0x18, 0xd2, 0x42, 0x78, 0x7e, 0xd6, 0x42, 0x78, 0x8a,
-	0x99, 0xf7, 0x13, 0x57, 0x66, 0x3e, 0x83, 0xe8, 0x21, 0x05, 0xf5, 0xce, 0x33, 0x9d, 0x6e, 0xac,
+	0x79, 0x2f, 0xbc, 0x22, 0xf3, 0x7e, 0xea, 0xca, 0xcc, 0x67, 0x10, 0x3d, 0xa4, 0xa0, 0xde, 0x79,
-	0x02, 0x04, 0x05, 0x7b, 0x7e, 0x85, 0x32, 0x0b, 0x9a, 0xd0, 0x28, 0xc2, 0x2d, 0xe1, 0x4a, 0xb9,
+	0xa6, 0xd3, 0x8d, 0x55, 0x80, 0xa0, 0x60, 0xcf, 0xaf, 0x50, 0x66, 0x21, 0x13, 0xea, 0x45, 0x76,
-	0xa7, 0x0f, 0x95, 0x90, 0xbf, 0x0f, 0x6d, 0x99, 0x94, 0xce, 0x23, 0xf9, 0xbf, 0xc8, 0x01, 0x74,
+	0x4b, 0xb8, 0x52, 0xee, 0xe9, 0x43, 0x25, 0xe4, 0xef, 0x43, 0x5b, 0x26, 0xa5, 0xf3, 0x48, 0xfe,
-	0xc4, 0xad, 0xdb, 0xd9, 0x7c, 0xc1, 0x35, 0x08, 0x45, 0x23, 0x81, 0xbe, 0x87, 0xa5, 0xc8, 0x20,
+	0xcf, 0x73, 0x00, 0x1d, 0x71, 0xeb, 0x76, 0x36, 0x5f, 0x70, 0x0d, 0x42, 0xd1, 0x48, 0xa0, 0xef,
-	0x2a, 0x21, 0x72, 0x52, 0x02, 0x93, 0xc8, 0x53, 0x0d, 0x8a, 0x27, 0xa4, 0x35, 0x4c, 0x28, 0xe2,
+	0x61, 0x29, 0x32, 0x88, 0x4a, 0x88, 0x9c, 0x94, 0xe0, 0x24, 0xf2, 0x54, 0x83, 0xd2, 0x09, 0x69,
-	0xe6, 0xf7, 0x3c, 0x54, 0x1c, 0xfb, 0xa8, 0x4b, 0xd4, 0xcc, 0xf0, 0xaf, 0x15, 0x3b, 0xf6, 0x11,
+	0x0d, 0x13, 0x8a, 0xb8, 0xf9, 0x7d, 0x1b, 0x2a, 0x8e, 0x7d, 0xdc, 0x25, 0x6a, 0x66, 0xf8, 0xd7,
-	0x51, 0x3e, 0x03, 0x9d, 0x85, 0x05, 0x4f, 0x77, 0x0f, 0x08, 0x7e, 0x56, 0x37, 0x2a, 0x91, 0x66,
+	0x8a, 0x1d, 0xfb, 0x98, 0x28, 0x9f, 0x81, 0xce, 0xc3, 0x82, 0xa7, 0xbb, 0x87, 0x84, 0x3e, 0xab,
-	0xc7, 0x40, 0x67, 0xa0, 0xb8, 0x67, 0x0e, 0x30, 0xbb, 0xad, 0x50, 0xd1, 0x58, 0x03, 0x7d, 0xcb,
+	0x1b, 0x95, 0x48, 0xb3, 0x63, 0xa0, 0x73, 0x50, 0xdc, 0x37, 0x07, 0x98, 0xdd, 0x56, 0xa8, 0x68,
-	0xbf, 0xff, 0x56, 0xce, 0x7c, 0xc5, 0x85, 0xc2, 0xab, 0x5f, 0x29, 0xb0, 0x18, 0xec, 0x1a, 0x35,
+	0xac, 0x81, 0xbe, 0xe5, 0xdf, 0x7f, 0x2b, 0x67, 0xbe, 0xe2, 0x42, 0xf1, 0xd5, 0xaf, 0x15, 0x58,
-	0x40, 0xc4, 0xa6, 0x51, 0x7b, 0xb6, 0x66, 0x1b, 0xcc, 0x54, 0x34, 0x52, 0x3c, 0x02, 0x1b, 0xc8,
+	0x0c, 0x56, 0x8d, 0x1a, 0x20, 0x62, 0xd3, 0xa8, 0x3d, 0x5b, 0xb3, 0x0d, 0x66, 0x2a, 0x1a, 0x29,
-	0xac, 0x56, 0x30, 0x64, 0x52, 0x9a, 0x4c, 0xd6, 0x45, 0x16, 0x6d, 0x1a, 0xfe, 0x45, 0xf8, 0x92,
+	0x1e, 0x81, 0x75, 0x64, 0x56, 0x2b, 0xe8, 0x32, 0x29, 0x4d, 0x26, 0xf3, 0x22, 0x93, 0x36, 0x0d,
-	0x63, 0x1f, 0x75, 0x0c, 0xb1, 0x1b, 0xec, 0xce, 0x30, 0x4b, 0x0a, 0xc9, 0x6e, 0xac, 0xd1, 0x6b,
+	0xff, 0x22, 0x7c, 0xc9, 0xb1, 0x8f, 0x3b, 0x86, 0x58, 0x0d, 0x76, 0x67, 0x98, 0x25, 0x85, 0x64,
-	0xc3, 0xd7, 0xa0, 0x8e, 0x1d, 0xc7, 0x76, 0xba, 0x43, 0xec, 0xba, 0x7a, 0x1f, 0xf3, 0xf8, 0xbc,
+	0x35, 0xd6, 0xe8, 0xb5, 0xe1, 0x6b, 0x50, 0xc7, 0x8e, 0x63, 0x3b, 0xdd, 0x21, 0x76, 0x5d, 0xbd,
-	0x46, 0x3b, 0x37, 0x58, 0x9f, 0xfa, 0xa7, 0x05, 0x68, 0x04, 0x4b, 0xf1, 0x8f, 0xc9, 0x4d, 0xc3,
+	0x8f, 0x79, 0x7c, 0x5e, 0xa3, 0xc0, 0x4d, 0x06, 0x53, 0xff, 0xa4, 0x00, 0x8d, 0x60, 0x2a, 0xfe,
-	0x3f, 0x26, 0x37, 0x09, 0xeb, 0xc0, 0x61, 0xa6, 0x50, 0x30, 0x77, 0x35, 0xd7, 0x52, 0xb4, 0x0a,
+	0x31, 0xb9, 0x69, 0xf8, 0xc7, 0xe4, 0x26, 0xd9, 0x3a, 0x70, 0x98, 0x29, 0x14, 0x9b, 0xbb, 0x9a,
-	0xef, 0xed, 0x18, 0xc4, 0x2d, 0x13, 0x25, 0xb3, 0x6c, 0x03, 0x07, 0xcc, 0x05, 0xbf, 0x8b, 0xf3,
+	0x6b, 0x29, 0x5a, 0x85, 0x43, 0x3b, 0x06, 0x71, 0xcb, 0x44, 0xc9, 0x2c, 0xdb, 0xc0, 0xc1, 0xe6,
-	0x36, 0x22, 0x23, 0x85, 0x0c, 0x32, 0x52, 0xcc, 0x20, 0x23, 0x25, 0x89, 0x8c, 0x2c, 0x43, 0x69,
+	0x82, 0x0f, 0xe2, 0x7b, 0x1b, 0x91, 0x91, 0x42, 0x06, 0x19, 0x29, 0x66, 0x90, 0x91, 0x92, 0x44,
-	0x77, 0xdc, 0x3b, 0xc0, 0x1e, 0x8f, 0xd8, 0x78, 0x2b, 0x2a, 0x3b, 0xe5, 0x98, 0xec, 0x08, 0x11,
+	0x46, 0x96, 0xa1, 0xb4, 0x37, 0xee, 0x1d, 0x62, 0x8f, 0x47, 0x6c, 0xbc, 0x15, 0x95, 0x9d, 0x72,
-	0xa9, 0x84, 0x45, 0xe4, 0x3c, 0x54, 0xd8, 0x79, 0x6d, 0xd7, 0x73, 0xe9, 0xe1, 0x53, 0x5e, 0x2b,
+	0x4c, 0x76, 0x84, 0x88, 0x54, 0xc2, 0x22, 0xf2, 0x36, 0x54, 0xd8, 0x79, 0x6d, 0xd7, 0x73, 0xe9,
-	0xb3, 0x8e, 0x1d, 0x17, 0x3d, 0xf0, 0xc3, 0xb9, 0xaa, 0x4c, 0xd9, 0xa9, 0xd5, 0x89, 0x49, 0x89,
+	0xe1, 0x53, 0x5e, 0x2b, 0x33, 0xc0, 0xae, 0x8b, 0x1e, 0xf8, 0xe1, 0x5c, 0x55, 0xa6, 0xec, 0xd4,
-	0x1f, 0xcc, 0xdd, 0x84, 0xc5, 0xd0, 0x76, 0x50, 0x1f, 0x51, 0xa3, 0xa4, 0x86, 0xa2, 0x7d, 0xea,
+	0xea, 0xc4, 0xa4, 0xc4, 0x0f, 0xe6, 0x6e, 0xc2, 0x62, 0x68, 0x39, 0xa8, 0x8f, 0xa8, 0x51, 0x56,
-	0x26, 0x6e, 0x40, 0x23, 0xd8, 0x12, 0x0a, 0x57, 0x67, 0x49, 0x96, 0xe8, 0xa5, 0x60, 0x42, 0x92,
+	0x43, 0xd1, 0x3e, 0x75, 0x13, 0x37, 0xa0, 0x11, 0x2c, 0x09, 0xc5, 0xab, 0xb3, 0x24, 0x4b, 0x40,
-	0x1b, 0x27, 0x93, 0x64, 0x74, 0x0e, 0xca, 0x3c, 0x3b, 0x72, 0x5b, 0x8b, 0x91, 0x62, 0x85, 0xfa,
+	0x29, 0x9a, 0x90, 0xe4, 0xc6, 0xe9, 0x24, 0x19, 0x5d, 0x80, 0x32, 0xcf, 0x8e, 0xdc, 0xd6, 0x62,
-	0x23, 0x40, 0x01, 0xf5, 0xf3, 0x45, 0x8b, 0x31, 0xf1, 0xc8, 0xc5, 0xc5, 0x43, 0xfd, 0x99, 0x02,
+	0xa4, 0x58, 0xa1, 0xfe, 0x10, 0x50, 0xc0, 0xfd, 0x7c, 0xd1, 0x62, 0x4c, 0x3c, 0x72, 0x71, 0xf1,
-	0x4b, 0xe1, 0xc9, 0x66, 0x75, 0xbc, 0x9f, 0x42, 0x95, 0x1d, 0xff, 0x75, 0x89, 0xe2, 0xf3, 0x22,
+	0x50, 0x7f, 0xaa, 0xc0, 0x52, 0x78, 0xb0, 0x59, 0x1d, 0xef, 0xa7, 0x50, 0x65, 0xc7, 0x7f, 0x5d,
-	0xd0, 0xc5, 0x89, 0x7c, 0xd1, 0x20, 0x78, 0x75, 0x40, 0xc4, 0xeb, 0xc8, 0x76, 0x0e, 0x4c, 0xab,
+	0xa2, 0xf8, 0xbc, 0x08, 0x74, 0x71, 0xe2, 0xbe, 0x68, 0x10, 0xbc, 0x3a, 0x20, 0xe2, 0x75, 0x6c,
-	0xdf, 0x25, 0x94, 0xf9, 0xea, 0x56, 0xe3, 0x9d, 0x9b, 0xa4, 0x4f, 0xfd, 0x52, 0x81, 0x4b, 0xcf,
+	0x3b, 0x87, 0xa6, 0xd5, 0xef, 0x12, 0xce, 0x7c, 0x75, 0xab, 0x71, 0xe0, 0x16, 0x81, 0xa9, 0x5f,
-	0x47, 0x86, 0xee, 0xe1, 0x50, 0x04, 0x32, 0xef, 0x6d, 0xbf, 0x8f, 0xfd, 0xeb, 0x76, 0xb9, 0x6c,
+	0x29, 0x70, 0xe9, 0xd9, 0xc8, 0xd0, 0x3d, 0x1c, 0x8a, 0x40, 0xe6, 0xbd, 0xed, 0xf7, 0xb1, 0x7f,
-	0x47, 0x58, 0x0c, 0x5a, 0xfd, 0x5b, 0x41, 0x4b, 0xe2, 0x8a, 0xec, 0xec, 0xb4, 0xb4, 0xa1, 0x7c,
+	0xdd, 0x2e, 0x97, 0xed, 0x08, 0x8b, 0x61, 0xab, 0x7f, 0x2d, 0x78, 0x49, 0x5c, 0x91, 0x9d, 0x9d,
-	0xc8, 0xd1, 0xf9, 0xaf, 0x28, 0xfc, 0x76, 0xe4, 0x98, 0x34, 0x7f, 0xf2, 0x63, 0x52, 0x75, 0x03,
+	0x97, 0x36, 0x94, 0x8f, 0x38, 0x39, 0xff, 0x15, 0x85, 0xdf, 0x8e, 0x1c, 0x93, 0xe6, 0x4f, 0x7f,
-	0xce, 0x69, 0xd8, 0xc5, 0x96, 0x11, 0x59, 0xcd, 0xcc, 0xc5, 0xa6, 0x11, 0xb4, 0x65, 0xe8, 0xe6,
+	0x4c, 0xaa, 0x6e, 0xc2, 0x05, 0x0d, 0xbb, 0xd8, 0x32, 0x22, 0xb3, 0x99, 0xb9, 0xd8, 0x34, 0x82,
-	0x11, 0x56, 0x16, 0xbb, 0x76, 0x1d, 0x82, 0xd6, 0xe3, 0xa6, 0x98, 0x84, 0x4c, 0x74, 0x1e, 0x4f,
+	0xb6, 0x8c, 0xdc, 0x3c, 0xc2, 0xca, 0x62, 0xd7, 0xae, 0x43, 0xc8, 0x7a, 0xdc, 0x14, 0x93, 0x90,
-	0xfd, 0x9b, 0x1c, 0x9c, 0x7d, 0x64, 0x18, 0xdc, 0x8a, 0xf3, 0x68, 0xec, 0x4d, 0x05, 0xca, 0xf1,
+	0x89, 0x8e, 0xe3, 0xa9, 0x7f, 0x95, 0x83, 0xf3, 0x8f, 0x0c, 0x83, 0x5b, 0x71, 0x1e, 0x8d, 0xbd,
-	0x40, 0x32, 0x9f, 0x0c, 0x24, 0x5f, 0x97, 0x65, 0xe5, 0x3e, 0xc6, 0x1a, 0x0f, 0x7d, 0xdf, 0xe9,
+	0xae, 0x40, 0x39, 0x1e, 0x48, 0xe6, 0x93, 0x81, 0xe4, 0xab, 0xb2, 0xac, 0xdc, 0xc7, 0x58, 0xe3,
-	0xb0, 0xfb, 0x43, 0x0f, 0xf9, 0xb9, 0x19, 0x49, 0xe8, 0xa9, 0xff, 0x9c, 0x1e, 0x5f, 0x95, 0xfd,
+	0xa1, 0xef, 0x3b, 0x1d, 0x76, 0x7f, 0xe8, 0x21, 0x3f, 0x37, 0x23, 0x09, 0x3d, 0xf5, 0x9f, 0xd3,
-	0xa2, 0x99, 0x3a, 0x82, 0x56, 0x72, 0xb3, 0xe6, 0x34, 0x25, 0xfe, 0x8e, 0x8c, 0x6c, 0x56, 0x60,
+	0xe3, 0xab, 0xb2, 0x5f, 0x34, 0x53, 0x47, 0xd0, 0x4a, 0x2e, 0xd6, 0x9c, 0xa6, 0xc4, 0x5f, 0x91,
-	0xad, 0x91, 0x10, 0x8a, 0x76, 0x6d, 0xd9, 0xae, 0xfa, 0xdf, 0x39, 0x68, 0x6d, 0xeb, 0x87, 0xf8,
+	0x91, 0xcd, 0x0a, 0xac, 0x35, 0x12, 0x42, 0x51, 0xd0, 0xb6, 0xed, 0xaa, 0xff, 0x99, 0x83, 0xd6,
-	0xff, 0x0f, 0x83, 0x7e, 0x00, 0x67, 0x5c, 0xfd, 0x10, 0x77, 0x43, 0x89, 0x71, 0xd7, 0xc1, 0x2f,
+	0x8e, 0x7e, 0x84, 0xff, 0xef, 0x6c, 0xd0, 0x17, 0x70, 0xce, 0xd5, 0x8f, 0x70, 0x37, 0x94, 0x18,
-	0x79, 0x08, 0xfa, 0x9e, 0xcc, 0x92, 0x48, 0xaf, 0xd9, 0x68, 0x4b, 0x6e, 0xa4, 0x5f, 0xc3, 0x2f,
+	0x77, 0x1d, 0xfc, 0x82, 0x87, 0xa0, 0xef, 0xc9, 0x2c, 0x89, 0xf4, 0x9a, 0x8d, 0xb6, 0xe4, 0x46,
-	0xd1, 0xbb, 0xb0, 0x18, 0xbe, 0xc7, 0x45, 0x48, 0x2b, 0xd3, 0x2d, 0xaf, 0x87, 0xae, 0x69, 0x75,
+	0xe0, 0x1a, 0x7e, 0x81, 0xde, 0x85, 0xc5, 0xf0, 0x3d, 0x2e, 0xc2, 0x5a, 0x99, 0x2e, 0x79, 0x3d,
-	0x0c, 0xf5, 0x25, 0x5c, 0x78, 0x6e, 0xb9, 0xd8, 0xeb, 0x04, 0x57, 0x8d, 0xe6, 0x4c, 0x21, 0x2f,
+	0x74, 0x4d, 0xab, 0x63, 0xa8, 0x2f, 0xe0, 0x9d, 0x67, 0x96, 0x8b, 0xbd, 0x4e, 0x70, 0xd5, 0x68,
-	0x43, 0x35, 0xd8, 0xf8, 0xc4, 0xcb, 0x09, 0xc3, 0x55, 0x6d, 0x68, 0x6f, 0xe8, 0xce, 0x81, 0x5f,
+	0xce, 0x14, 0xf2, 0x32, 0x54, 0x83, 0x85, 0x4f, 0xbc, 0x9c, 0x30, 0x5c, 0xd5, 0x86, 0xf6, 0xa6,
-	0x66, 0x5e, 0x67, 0x57, 0x42, 0xde, 0xe0, 0x84, 0x7b, 0xe2, 0x86, 0x94, 0x86, 0xf7, 0xb0, 0x83,
+	0xee, 0x1c, 0xfa, 0x65, 0xe6, 0x75, 0x76, 0x25, 0xe4, 0x35, 0x0e, 0xb8, 0x2f, 0x6e, 0x48, 0x69,
-	0xad, 0x1e, 0x7e, 0x66, 0xf7, 0x0e, 0x48, 0xb8, 0xe1, 0xb1, 0x67, 0x6c, 0x4a, 0x28, 0xe8, 0x5c,
+	0x78, 0x1f, 0x3b, 0xd8, 0xea, 0xe1, 0xa7, 0x76, 0xef, 0x90, 0x84, 0x1b, 0x1e, 0x7b, 0xc6, 0xa6,
-	0x0f, 0xbd, 0x52, 0xcb, 0x45, 0x5e, 0xa9, 0x4d, 0x79, 0xd9, 0xa8, 0xfe, 0x3c, 0x07, 0xcb, 0x8f,
+	0x84, 0x82, 0xce, 0xf5, 0xd0, 0x2b, 0xb5, 0x5c, 0xe4, 0x95, 0xda, 0x94, 0x97, 0x8d, 0xea, 0xcf,
-	0x06, 0x1e, 0x76, 0x82, 0xcc, 0xff, 0x24, 0x45, 0x8c, 0xa0, 0xaa, 0x90, 0x9b, 0xa1, 0xaa, 0x90,
+	0x72, 0xb0, 0xfc, 0x68, 0xe0, 0x61, 0x27, 0xc8, 0xfc, 0x4f, 0x53, 0xc4, 0x08, 0xaa, 0x0a, 0xb9,
-	0xb8, 0x3e, 0x9e, 0x4f, 0x5e, 0x1f, 0x97, 0xd5, 0x40, 0x0a, 0x33, 0xd6, 0x40, 0x1e, 0x01, 0x8c,
+	0x19, 0xaa, 0x0a, 0x89, 0xeb, 0xe3, 0xf9, 0xe4, 0xf5, 0x71, 0x59, 0x0d, 0xa4, 0x30, 0x63, 0x0d,
-	0x1c, 0x7b, 0x84, 0x1d, 0xcf, 0xc4, 0x7e, 0xfa, 0x96, 0x21, 0x7c, 0x09, 0x0d, 0xba, 0xf5, 0xa9,
+	0xe4, 0x11, 0xc0, 0xc8, 0xb1, 0x47, 0xd8, 0xf1, 0x4c, 0xec, 0xa7, 0x6f, 0x19, 0xc2, 0x97, 0x50,
-	0xb8, 0xe5, 0xb9, 0x73, 0x3c, 0xc2, 0x68, 0x01, 0xf2, 0x9b, 0xf8, 0xa8, 0x79, 0x0a, 0x01, 0x94,
+	0x27, 0xf5, 0x0b, 0x68, 0x3e, 0xe9, 0xad, 0xd9, 0xd6, 0xbe, 0xe9, 0x0c, 0xfd, 0x85, 0x4a, 0x28,
-	0x36, 0x6d, 0x67, 0xa8, 0x0f, 0x9a, 0x0a, 0xaa, 0xc2, 0x02, 0x3f, 0xd4, 0x6a, 0xe6, 0x50, 0x1d,
+	0x9d, 0x92, 0x41, 0xe9, 0x72, 0x09, 0xa5, 0x53, 0x4d, 0x58, 0x0a, 0xd1, 0x9e, 0xd3, 0x70, 0xf5,
-	0x2a, 0x6b, 0xfe, 0xc1, 0x40, 0x33, 0x7f, 0xeb, 0xcf, 0x15, 0x58, 0x4a, 0x1c, 0xbb, 0xa0, 0x06,
+	0x7b, 0xdd, 0x7d, 0xd3, 0x32, 0xe9, 0x95, 0xab, 0x1c, 0x0d, 0x3f, 0xa1, 0xdf, 0xdb, 0xe0, 0x90,
-	0xc0, 0x73, 0xab, 0xc7, 0xcf, 0xa3, 0x9a, 0xa7, 0x50, 0x0d, 0xca, 0xfe, 0xe9, 0x14, 0xc3, 0xb7,
+	0x5b, 0x9f, 0x8a, 0xcb, 0xaa, 0xbb, 0x27, 0x23, 0x8c, 0x16, 0x20, 0xbf, 0x85, 0x8f, 0x9b, 0x67,
-	0x63, 0x53, 0xe8, 0x66, 0x0e, 0x35, 0xa1, 0xc6, 0x06, 0x8e, 0x7b, 0x3d, 0xec, 0xba, 0xcd, 0xbc,
+	0x10, 0x40, 0x69, 0xcb, 0x76, 0x86, 0xfa, 0xa0, 0xa9, 0xa0, 0x2a, 0x2c, 0xf0, 0xb3, 0xb9, 0x66,
-	0xe8, 0x79, 0xa2, 0x9b, 0x83, 0xb1, 0x83, 0x9b, 0x05, 0x32, 0xe7, 0x8e, 0xad, 0xe1, 0x01, 0xd6,
+	0x0e, 0xd5, 0xa1, 0xb2, 0xe6, 0x9f, 0x6f, 0x34, 0xf3, 0xb7, 0xfe, 0x4c, 0x81, 0xa5, 0xc4, 0xe9,
-	0x5d, 0xdc, 0x2c, 0x22, 0x04, 0x0d, 0xde, 0xf0, 0x07, 0x95, 0x42, 0x7d, 0xfe, 0xb0, 0x85, 0x5b,
+	0x11, 0x6a, 0x00, 0x3c, 0xb3, 0x7a, 0xfc, 0x58, 0xad, 0x79, 0x06, 0xd5, 0xa0, 0xec, 0x1f, 0xb2,
-	0x2f, 0xc2, 0xc5, 0x73, 0xba, 0xbc, 0xb3, 0x70, 0xfa, 0xb9, 0x65, 0xe0, 0x3d, 0xd3, 0xc2, 0x46,
+	0x31, 0x7a, 0xbb, 0x36, 0xc5, 0x6e, 0xe6, 0x50, 0x13, 0x6a, 0xac, 0xe3, 0xb8, 0xd7, 0xc3, 0xae,
-	0xf0, 0xa9, 0x79, 0x0a, 0x9d, 0x86, 0xc5, 0x0d, 0xec, 0xf4, 0x71, 0xa8, 0x33, 0x87, 0x96, 0xa0,
+	0xdb, 0xcc, 0x0b, 0xc8, 0x86, 0x6e, 0x0e, 0xc6, 0x0e, 0x6e, 0x16, 0xc8, 0x98, 0xbb, 0xb6, 0x86,
-	0xbe, 0x61, 0xbe, 0x0a, 0x75, 0xe5, 0xd5, 0x42, 0x59, 0x69, 0x2a, 0xf7, 0xff, 0xe2, 0x2a, 0x54,
+	0x07, 0x58, 0x77, 0x71, 0xb3, 0x88, 0x10, 0x34, 0x78, 0xc3, 0xef, 0x54, 0x0a, 0xc1, 0xfc, 0x6e,
-	0x08, 0x53, 0xd6, 0x6c, 0xdb, 0x31, 0xd0, 0x00, 0x10, 0x7d, 0x50, 0x31, 0x1c, 0xd9, 0x96, 0x78,
+	0x0b, 0xb7, 0x9e, 0x87, 0xcf, 0x00, 0xe8, 0xf4, 0xce, 0xc3, 0xd9, 0x67, 0x96, 0x81, 0xf7, 0x4d,
-	0x81, 0x85, 0xee, 0x44, 0xf9, 0xc0, 0x1b, 0x49, 0x40, 0x2e, 0x9d, 0xed, 0xeb, 0x52, 0xf8, 0x18,
+	0x0b, 0x1b, 0xc1, 0xa7, 0xe6, 0x19, 0x74, 0x16, 0x16, 0x37, 0xb1, 0xd3, 0xc7, 0x21, 0x60, 0x0e,
-	0xb0, 0x7a, 0x0a, 0x0d, 0xe9, 0x6c, 0x3b, 0xe6, 0x10, 0xef, 0x98, 0xbd, 0x03, 0x3f, 0xb2, 0xb8,
+	0x2d, 0x41, 0x7d, 0xd3, 0x7c, 0x19, 0x02, 0xe5, 0xd5, 0x42, 0x59, 0x69, 0x2a, 0xf7, 0xff, 0xeb,
-	0x97, 0x12, 0x47, 0x24, 0x41, 0xfd, 0xf9, 0xae, 0x49, 0xe7, 0x63, 0x2f, 0x5e, 0x7c, 0x2f, 0xa3,
+	0x2a, 0x54, 0x88, 0x6c, 0xad, 0xd9, 0xb6, 0x63, 0xa0, 0x01, 0x20, 0xfa, 0x2e, 0x64, 0x38, 0xb2,
-	0x9e, 0x42, 0x2f, 0xe1, 0xcc, 0x53, 0x1c, 0x0a, 0xd2, 0xfc, 0x09, 0xef, 0xa7, 0x4f, 0x98, 0x00,
+	0x2d, 0xf1, 0x90, 0x0c, 0xdd, 0x89, 0x6e, 0x0f, 0x6f, 0x24, 0x11, 0xb9, 0xec, 0xb4, 0xaf, 0x4b,
-	0x3e, 0xe1, 0x94, 0xcf, 0xa0, 0x48, 0xc5, 0x0d, 0xc9, 0xe2, 0xb8, 0xf0, 0x63, 0xe9, 0xf6, 0x95,
+	0xf1, 0x63, 0xc8, 0xea, 0x19, 0x34, 0xa4, 0xa3, 0xed, 0x9a, 0x43, 0xbc, 0x6b, 0xf6, 0x0e, 0xfd,
-	0x74, 0x00, 0x81, 0xed, 0x47, 0xb0, 0x18, 0x7b, 0x62, 0x89, 0x64, 0x56, 0x5d, 0xfe, 0x58, 0xb6,
+	0x00, 0xe9, 0x5e, 0x4a, 0x38, 0x94, 0x44, 0xf5, 0xc7, 0xbb, 0x26, 0x1d, 0x8f, 0x3d, 0xdc, 0xf1,
-	0x7d, 0x2b, 0x0b, 0xa8, 0x98, 0xab, 0x0f, 0x8d, 0xe8, 0x43, 0x0c, 0xb4, 0x92, 0xe1, 0x4d, 0x17,
+	0x65, 0x4e, 0x3d, 0x83, 0x5e, 0xc0, 0xb9, 0x27, 0x38, 0x14, 0x6b, 0xfa, 0x03, 0xde, 0x4f, 0x1f,
-	0x9b, 0xe9, 0xbd, 0xcc, 0xaf, 0xbf, 0xa8, 0x10, 0x34, 0xe3, 0x4f, 0xfe, 0xd0, 0xad, 0x89, 0x08,
+	0x30, 0x81, 0x7c, 0xca, 0x21, 0x9f, 0x42, 0x91, 0x8a, 0x1b, 0x92, 0x85, 0xa3, 0xe1, 0x37, 0xdf,
-	0xa2, 0xc2, 0xf6, 0x7e, 0x26, 0x58, 0x31, 0xdd, 0x31, 0x15, 0x82, 0xc4, 0x53, 0xab, 0xb8, 0x8c,
+	0xed, 0x2b, 0xe9, 0x08, 0x82, 0xda, 0x0f, 0x61, 0x31, 0xf6, 0x52, 0x14, 0xc9, 0x9c, 0x93, 0xfc,
-	0xfb, 0x68, 0xd2, 0xde, 0x80, 0xb5, 0xef, 0x66, 0x86, 0x17, 0x53, 0xff, 0x36, 0xbb, 0xb5, 0x22,
+	0xcd, 0x6f, 0xfb, 0x56, 0x16, 0x54, 0x31, 0x56, 0x1f, 0x1a, 0xd1, 0xf7, 0x24, 0x68, 0x25, 0xc3,
-	0x7b, 0xae, 0x84, 0x3e, 0x94, 0xa3, 0x9b, 0xf0, 0xce, 0xaa, 0x7d, 0xff, 0x24, 0x43, 0x04, 0x11,
+	0xd3, 0x34, 0x36, 0xd2, 0x7b, 0x99, 0x1f, 0xb1, 0x51, 0x21, 0x68, 0xc6, 0x5f, 0x2e, 0xa2, 0x5b,
-	0x3f, 0xa1, 0xd7, 0x4d, 0x24, 0x0f, 0x7e, 0xe2, 0x7a, 0xe7, 0xe3, 0x4b, 0x7f, 0xcb, 0xd4, 0xfe,
+	0x13, 0x09, 0x44, 0x85, 0xed, 0xfd, 0x4c, 0xb8, 0x62, 0xb8, 0x13, 0x2a, 0x04, 0x89, 0x17, 0x63,
-	0xf0, 0x04, 0x23, 0x04, 0x01, 0x76, 0xfc, 0x4d, 0xa5, 0xaf, 0x86, 0x77, 0xa7, 0x4a, 0xcd, 0x6c,
+	0x71, 0x19, 0xf7, 0xc9, 0xa4, 0x3d, 0x65, 0x6b, 0xdf, 0xcd, 0x8c, 0x2f, 0x86, 0xfe, 0x2d, 0x76,
-	0x3a, 0xf8, 0x43, 0x58, 0x8c, 0xc5, 0x39, 0x28, 0x7b, 0x2c, 0xd4, 0x9e, 0x14, 0x8c, 0x32, 0x95,
+	0xf9, 0x46, 0xf6, 0xea, 0x0a, 0x7d, 0x28, 0x27, 0x37, 0xe1, 0xb9, 0x58, 0xfb, 0xfe, 0x69, 0xba,
-	0x8c, 0xdd, 0xde, 0x41, 0x29, 0xd2, 0x2f, 0xb9, 0xe1, 0xd3, 0xbe, 0x95, 0x05, 0x54, 0x2c, 0xc4,
+	0x08, 0x26, 0x7e, 0x4c, 0x6f, 0xcd, 0x48, 0xde, 0x2d, 0xc5, 0xf5, 0xce, 0xa7, 0x97, 0xfe, 0x24,
-	0xa5, 0xe6, 0x32, 0x76, 0x27, 0x03, 0xdd, 0x96, 0xe3, 0x90, 0xdf, 0x3d, 0x69, 0x7f, 0x90, 0x11,
+	0xab, 0xfd, 0xe1, 0x29, 0x7a, 0x08, 0x06, 0xec, 0xf8, 0xd3, 0x50, 0x5f, 0x0d, 0xef, 0x4e, 0x95,
-	0x5a, 0x4c, 0x7a, 0x08, 0xa7, 0x25, 0x57, 0x67, 0xd0, 0x07, 0x13, 0x99, 0x15, 0xbf, 0x33, 0xd4,
+	0x9a, 0xd9, 0x74, 0xf0, 0x07, 0xb0, 0x18, 0x0b, 0xd7, 0x50, 0xf6, 0x90, 0xae, 0x3d, 0xc9, 0x35,
-	0xbe, 0x93, 0x15, 0x5c, 0xcc, 0xfb, 0x1b, 0x80, 0xb6, 0xf7, 0xed, 0xa3, 0x35, 0xdb, 0xda, 0x33,
+	0x31, 0x95, 0x8c, 0x5d, 0x42, 0x42, 0x29, 0xd2, 0x2f, 0xb9, 0xa8, 0xd4, 0xbe, 0x95, 0x05, 0x55,
-	0xfb, 0x63, 0x47, 0x67, 0x51, 0x42, 0x9a, 0x6f, 0x48, 0x82, 0xa6, 0xc8, 0xe8, 0xc4, 0x11, 0x62,
+	0x4c, 0xc4, 0xa5, 0xe6, 0x32, 0x76, 0xb5, 0x04, 0xdd, 0x96, 0xd3, 0x90, 0x5f, 0xa1, 0x69, 0x7f,
-	0xf2, 0x2e, 0xc0, 0x53, 0xec, 0x6d, 0x60, 0xcf, 0x21, 0x8a, 0xf1, 0x6e, 0x9a, 0xfb, 0xe3, 0x00,
+	0x90, 0x11, 0x5b, 0x0c, 0x7a, 0x04, 0x67, 0x25, 0x37, 0x80, 0xd0, 0x07, 0x13, 0x37, 0x2b, 0x7e,
-	0xfe, 0x54, 0x37, 0xa7, 0xc2, 0x85, 0x5c, 0x51, 0x73, 0x43, 0xb7, 0xc6, 0xfa, 0x20, 0x74, 0xf7,
+	0xf5, 0xa9, 0x7d, 0x27, 0x2b, 0xba, 0x18, 0xf7, 0xd7, 0x01, 0xed, 0x1c, 0xd8, 0xc7, 0x34, 0x72,
-	0xff, 0xb6, 0x74, 0x78, 0x1c, 0x2c, 0x85, 0x91, 0xa9, 0xd0, 0x62, 0xca, 0x23, 0xe1, 0xda, 0x43,
+	0xe8, 0x8f, 0x1d, 0x9d, 0x05, 0x3b, 0x69, 0xbe, 0x21, 0x89, 0x9a, 0x22, 0xa3, 0x13, 0x7b, 0x88,
-	0x47, 0x71, 0x93, 0x5d, 0x7b, 0xf2, 0x1a, 0x48, 0xdc, 0xec, 0x4d, 0x80, 0x17, 0x13, 0x7f, 0xa1,
+	0xc1, 0xbb, 0x00, 0x4f, 0xb0, 0xb7, 0x89, 0x3d, 0x87, 0x28, 0xc6, 0xbb, 0x69, 0xee, 0x8f, 0x23,
-	0xd0, 0xdb, 0x57, 0x31, 0x80, 0x17, 0xa6, 0xb7, 0xbf, 0x35, 0xd0, 0x2d, 0x37, 0x0b, 0x09, 0x14,
+	0xf8, 0x43, 0xdd, 0x9c, 0x8a, 0x17, 0x72, 0x45, 0xcd, 0x4d, 0xdd, 0x1a, 0xeb, 0x83, 0xd0, 0x13,
-	0xf0, 0x04, 0x24, 0x70, 0x78, 0x41, 0x82, 0x01, 0xf5, 0xc8, 0x09, 0x19, 0x92, 0x5d, 0x96, 0x97,
+	0x86, 0xdb, 0xd2, 0xee, 0x71, 0xb4, 0x94, 0x8d, 0x4c, 0xc5, 0x16, 0x43, 0x1e, 0x0b, 0xd7, 0x1e,
-	0x9d, 0x16, 0xb6, 0x57, 0xa6, 0x03, 0x8a, 0x59, 0xf6, 0xa1, 0xee, 0xab, 0x12, 0xdb, 0xdc, 0xf7,
+	0x3a, 0x51, 0x9c, 0xec, 0xda, 0x93, 0xb7, 0x59, 0xe2, 0x66, 0x6f, 0x02, 0xbe, 0x18, 0xf8, 0x4b,
-	0xd2, 0x28, 0x0d, 0x60, 0x52, 0x2c, 0x81, 0x1c, 0x34, 0x6c, 0x09, 0x92, 0x07, 0x00, 0x28, 0xdb,
+	0x85, 0x5e, 0x22, 0x8b, 0x21, 0x3c, 0x37, 0xbd, 0x83, 0xed, 0x81, 0x6e, 0xb9, 0x59, 0x58, 0xa0,
-	0xc1, 0xd1, 0x24, 0x4b, 0x90, 0x7e, 0xaa, 0xc0, 0x4c, 0x5d, 0xec, 0xb0, 0x4d, 0x6e, 0x47, 0xa5,
+	0x88, 0xa7, 0x60, 0x81, 0xe3, 0x0b, 0x16, 0x0c, 0xa8, 0x47, 0x0e, 0xfa, 0x90, 0xec, 0xce, 0xbf,
-	0x67, 0x87, 0x52, 0x53, 0x97, 0x72, 0x76, 0xa7, 0x9e, 0x42, 0x2f, 0xa0, 0xc4, 0xff, 0x21, 0xe4,
+	0xec, 0xd0, 0xb3, 0xbd, 0x32, 0x1d, 0x51, 0x8c, 0x72, 0x00, 0x75, 0x5f, 0x95, 0xd8, 0xe2, 0xbe,
-	0xfa, 0xe4, 0xa2, 0x1d, 0xc7, 0x7e, 0x63, 0x0a, 0x94, 0x40, 0x7c, 0x00, 0x67, 0x53, 0x4a, 0x76,
+	0x97, 0xc6, 0x69, 0x80, 0x93, 0x62, 0x09, 0xe4, 0xa8, 0x61, 0x4b, 0x90, 0x3c, 0xc7, 0x40, 0xd9,
-	0x52, 0x17, 0x3c, 0xb9, 0xbc, 0x37, 0xcd, 0x39, 0x88, 0xc9, 0x12, 0x35, 0xb9, 0x09, 0x93, 0xa5,
+	0xce, 0xbf, 0x26, 0x59, 0x82, 0xf4, 0xc3, 0x11, 0x66, 0xea, 0x62, 0x67, 0x86, 0x72, 0x3b, 0x2a,
-	0xd5, 0xef, 0xa6, 0x4d, 0xd6, 0x85, 0xa5, 0x44, 0xb9, 0x03, 0xbd, 0x9f, 0xe2, 0xe8, 0x64, 0x45,
+	0x3d, 0x02, 0x95, 0x9a, 0xba, 0x94, 0x23, 0x48, 0xf5, 0x0c, 0x7a, 0x0e, 0x25, 0xfe, 0x47, 0x27,
-	0x91, 0x69, 0x13, 0xf4, 0xe1, 0x1d, 0x69, 0x6a, 0x2f, 0x75, 0xdc, 0x93, 0x8a, 0x00, 0xd3, 0x26,
+	0xd7, 0x27, 0xd7, 0x1e, 0x39, 0xf5, 0x1b, 0x53, 0xb0, 0x04, 0xe1, 0x43, 0x38, 0x9f, 0x52, 0x79,
-	0xea, 0xc1, 0x69, 0x49, 0x42, 0x2f, 0x75, 0x39, 0xe9, 0x89, 0xff, 0xb4, 0x49, 0xf6, 0xa0, 0xbd,
+	0x94, 0xba, 0xe0, 0xc9, 0x55, 0xca, 0x69, 0xce, 0x41, 0x0c, 0x96, 0x28, 0x2d, 0x4e, 0x18, 0x2c,
-	0xea, 0xd8, 0xba, 0xd1, 0xd3, 0x5d, 0x8f, 0x26, 0xd9, 0x24, 0x8b, 0xf2, 0x23, 0x27, 0x79, 0x58,
+	0xad, 0x0c, 0x39, 0x6d, 0xb0, 0x2e, 0x2c, 0x25, 0xaa, 0x36, 0xe8, 0xfd, 0x14, 0x47, 0x27, 0xab,
-	0x2d, 0x4d, 0xc5, 0xa7, 0xcd, 0xb3, 0x0b, 0x55, 0xca, 0x4a, 0xf6, 0xdf, 0x0d, 0x48, 0xee, 0x23,
+	0xed, 0x4c, 0x1b, 0xa0, 0x0f, 0x6f, 0x49, 0x2b, 0x14, 0x52, 0xc7, 0x3d, 0xa9, 0x96, 0x31, 0x6d,
-	0x42, 0x10, 0x29, 0x86, 0x47, 0x06, 0x28, 0x84, 0x7a, 0x07, 0xaa, 0x6b, 0xf4, 0x2c, 0xa2, 0x63,
+	0xa0, 0x1e, 0x9c, 0x95, 0xd4, 0x25, 0xa4, 0x2e, 0x27, 0xbd, 0x7e, 0x31, 0x6d, 0x90, 0x7d, 0x68,
-	0x19, 0xf8, 0x55, 0xdc, 0x5f, 0xd1, 0x67, 0xab, 0x77, 0x42, 0x00, 0x99, 0x77, 0xa8, 0x4e, 0x03,
+	0xaf, 0x3a, 0xb6, 0x6e, 0xf4, 0x74, 0xd7, 0xa3, 0xb5, 0x02, 0x92, 0x45, 0xf9, 0x91, 0x93, 0x3c,
-	0x5a, 0x03, 0xbf, 0x62, 0x7c, 0x5e, 0x91, 0xe1, 0x8d, 0x80, 0xa4, 0x24, 0x00, 0x52, 0xc8, 0x90,
+	0xac, 0x96, 0x56, 0x14, 0xa6, 0x8d, 0xb3, 0x07, 0x55, 0xba, 0x95, 0xec, 0x2f, 0x28, 0x90, 0xdc,
-	0xa7, 0x3f, 0x13, 0x0e, 0xf3, 0xc4, 0x74, 0x77, 0x53, 0x90, 0x24, 0x20, 0xfd, 0x59, 0xef, 0x65,
+	0x47, 0x84, 0x30, 0x52, 0x0c, 0x8f, 0x0c, 0x51, 0x08, 0xf5, 0x2e, 0x54, 0xd7, 0xe8, 0x91, 0x4a,
-	0x1f, 0x10, 0xf6, 0x0c, 0x3e, 0x5d, 0x1d, 0x7a, 0x10, 0x72, 0x73, 0x12, 0xe9, 0xe1, 0xd8, 0x6d,
+	0xc7, 0x32, 0xf0, 0xcb, 0xb8, 0xbf, 0xa2, 0xaf, 0x6f, 0xef, 0x84, 0x10, 0x32, 0xaf, 0x50, 0x9d,
-	0x65, 0x3a, 0xa0, 0x98, 0x65, 0x0b, 0x2a, 0x44, 0x3a, 0x19, 0x7b, 0xae, 0xcb, 0x06, 0x8a, 0xcf,
+	0x06, 0xb4, 0x06, 0x7e, 0xc9, 0xf6, 0x79, 0x45, 0x46, 0x37, 0x82, 0x92, 0x92, 0x00, 0x48, 0x31,
-	0xd9, 0x99, 0xb3, 0x8e, 0xdd, 0x9e, 0x63, 0xee, 0x72, 0xa6, 0x4b, 0xc9, 0x89, 0x80, 0x4c, 0x64,
+	0x43, 0x9e, 0xfe, 0x5c, 0x38, 0xcc, 0x13, 0xc3, 0xdd, 0x4d, 0x21, 0x92, 0xc0, 0xf4, 0x47, 0xbd,
-	0x4e, 0x0c, 0x52, 0x50, 0xfe, 0x9b, 0x34, 0x5a, 0xa7, 0xbd, 0xab, 0x63, 0x73, 0x60, 0x6c, 0x39,
+	0x97, 0xbd, 0x43, 0xd8, 0x33, 0xf8, 0x7c, 0x75, 0xe8, 0x79, 0xce, 0xcd, 0x49, 0xac, 0x87, 0x63,
-	0x76, 0x9f, 0x3e, 0x19, 0xb9, 0x37, 0x69, 0xf9, 0x11, 0xd0, 0xd4, 0x48, 0x6c, 0xc2, 0x08, 0x7f,
+	0xb7, 0x95, 0xe9, 0x88, 0x62, 0x94, 0x6d, 0xa8, 0x10, 0xe9, 0x64, 0xdb, 0x73, 0x5d, 0xd6, 0x51,
-	0xfe, 0xfb, 0x5f, 0x55, 0xa0, 0xec, 0x3f, 0x62, 0xf9, 0x86, 0xab, 0x13, 0x6f, 0xa1, 0x5c, 0xf0,
+	0x7c, 0xce, 0xbe, 0x39, 0xeb, 0xd8, 0xed, 0x39, 0xe6, 0x1e, 0xdf, 0x74, 0x29, 0x3b, 0x11, 0x94,
-	0x43, 0x58, 0x8c, 0x3d, 0x28, 0x97, 0x5a, 0x22, 0xf9, 0xa3, 0xf3, 0x69, 0x22, 0xf3, 0x82, 0xff,
+	0x89, 0x9b, 0x13, 0xc3, 0x14, 0x9c, 0xff, 0x06, 0x8d, 0xd6, 0x29, 0x74, 0x75, 0x6c, 0x0e, 0x8c,
-	0x07, 0x9a, 0xc8, 0x1c, 0x6e, 0xa6, 0x95, 0x1c, 0xe2, 0x49, 0xc3, 0x14, 0xc4, 0xff, 0xb7, 0x43,
+	0x6d, 0xc7, 0xee, 0xd3, 0x97, 0x2f, 0xf7, 0x26, 0x4d, 0x3f, 0x82, 0x9a, 0x1a, 0x89, 0x4d, 0xe8,
-	0xf5, 0x4d, 0x80, 0x50, 0x90, 0x3e, 0xf9, 0xaa, 0x27, 0x89, 0x3b, 0xa7, 0xed, 0xd6, 0x50, 0x1a,
+	0x21, 0xc6, 0xff, 0x55, 0xa8, 0x88, 0xf2, 0x11, 0x92, 0xdd, 0xd8, 0x8a, 0x17, 0xae, 0xda, 0xd7,
-	0x87, 0xbf, 0x97, 0xe5, 0xda, 0x5c, 0x7a, 0x24, 0x95, 0x1e, 0x7d, 0x3f, 0x87, 0x5a, 0xf8, 0x12,
+	0x27, 0x23, 0xf9, 0x94, 0xef, 0x7f, 0x5d, 0x81, 0xb2, 0xff, 0xca, 0xe7, 0x1b, 0xae, 0x7b, 0xbc,
-	0x36, 0x92, 0xfe, 0xe3, 0x56, 0xf2, 0x96, 0xf6, 0xb4, 0x55, 0x6c, 0x9c, 0x30, 0x40, 0x9b, 0x82,
+	0x81, 0x42, 0xc4, 0x0f, 0x60, 0x31, 0xf6, 0xe2, 0x5e, 0x6a, 0xe3, 0xe4, 0xaf, 0xf2, 0xa7, 0x09,
-	0xce, 0x05, 0x94, 0x3c, 0xbe, 0x93, 0x06, 0xb4, 0xa9, 0x87, 0x86, 0xd2, 0x80, 0x36, 0xfd, 0x4c,
+	0xe3, 0x73, 0xfe, 0x27, 0x71, 0x22, 0x27, 0xb9, 0x99, 0x56, 0xcc, 0x88, 0xa7, 0x23, 0x53, 0x08,
-	0x90, 0x55, 0x9e, 0xe2, 0x67, 0x52, 0xd2, 0xca, 0x53, 0xca, 0x29, 0x9f, 0xb4, 0xf2, 0x94, 0x76,
+	0xff, 0xef, 0x4e, 0x02, 0xb6, 0x00, 0x42, 0xe1, 0xff, 0xe4, 0xbb, 0xb0, 0x24, 0xa2, 0x9d, 0xb6,
-	0xc8, 0xa5, 0x9e, 0x5a, 0xfd, 0xe8, 0x07, 0x1f, 0xf6, 0x4d, 0x6f, 0x7f, 0xbc, 0x4b, 0x56, 0x7f,
+	0x5a, 0x43, 0x69, 0x84, 0xff, 0x5e, 0x96, 0x7b, 0x85, 0xe9, 0x31, 0x5a, 0x7a, 0x5c, 0xff, 0x0c,
-	0x97, 0x0d, 0xfd, 0xc0, 0xb4, 0xf9, 0xaf, 0xbb, 0xbe, 0xb8, 0xdf, 0xa5, 0xd8, 0xee, 0x12, 0x6c,
+	0x6a, 0xe1, 0x5b, 0xea, 0x48, 0xfa, 0x97, 0x64, 0xc9, 0x6b, 0xec, 0xd3, 0x66, 0xb1, 0x79, 0xca,
-	0xa3, 0xdd, 0xdd, 0x12, 0x6d, 0x7d, 0xf4, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb0, 0x82, 0x83,
+	0xd0, 0x6f, 0x0a, 0x39, 0x17, 0x50, 0xf2, 0x7c, 0x53, 0x1a, 0x2a, 0xa7, 0x9e, 0xaa, 0x4a, 0x43,
-	0x41, 0xd8, 0x51, 0x00, 0x00,
+	0xe5, 0xf4, 0x43, 0x53, 0x56, 0xd3, 0x8a, 0x1f, 0xda, 0x49, 0x6b, 0x5a, 0x29, 0xc7, 0xa0, 0xd2,
+	0x9a, 0x56, 0xda, 0x29, 0xa0, 0x7a, 0x66, 0xf5, 0xa3, 0x2f, 0x3e, 0xec, 0x9b, 0xde, 0xc1, 0x78,
+	0x8f, 0xcc, 0xfe, 0x2e, 0xeb, 0xfa, 0x81, 0x69, 0xf3, 0x5f, 0x77, 0x7d, 0x71, 0xbf, 0x4b, 0xa9,
+	0xdd, 0x25, 0xd4, 0x46, 0x7b, 0x7b, 0x25, 0xda, 0xfa, 0xe8, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff,
+	0x4a, 0x84, 0x21, 0x10, 0xf9, 0x52, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -5211,6 +5311,7 @@ type DataCoordClient interface {
 	DescribeIndex(ctx context.Context, in *indexpb.DescribeIndexRequest, opts ...grpc.CallOption) (*indexpb.DescribeIndexResponse, error)
 	// Deprecated: use DescribeIndex instead
 	GetIndexBuildProgress(ctx context.Context, in *indexpb.GetIndexBuildProgressRequest, opts ...grpc.CallOption) (*indexpb.GetIndexBuildProgressResponse, error)
+	GcConfirm(ctx context.Context, in *GcConfirmRequest, opts ...grpc.CallOption) (*GcConfirmResponse, error)
 }
 
 type dataCoordClient struct {
@@ -5572,6 +5673,15 @@ func (c *dataCoordClient) GetIndexBuildProgress(ctx context.Context, in *indexpb
 	return out, nil
 }
 
+func (c *dataCoordClient) GcConfirm(ctx context.Context, in *GcConfirmRequest, opts ...grpc.CallOption) (*GcConfirmResponse, error) {
+	out := new(GcConfirmResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/GcConfirm", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // DataCoordServer is the server API for DataCoord service.
 type DataCoordServer interface {
 	GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
@@ -5617,6 +5727,7 @@ type DataCoordServer interface {
 	DescribeIndex(context.Context, *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error)
 	// Deprecated: use DescribeIndex instead
 	GetIndexBuildProgress(context.Context, *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error)
+	GcConfirm(context.Context, *GcConfirmRequest) (*GcConfirmResponse, error)
 }
 
 // UnimplementedDataCoordServer can be embedded to have forward compatible implementations.
@@ -5740,6 +5851,9 @@ func (*UnimplementedDataCoordServer) DescribeIndex(ctx context.Context, req *ind
 func (*UnimplementedDataCoordServer) GetIndexBuildProgress(ctx context.Context, req *indexpb.GetIndexBuildProgressRequest) (*indexpb.GetIndexBuildProgressResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetIndexBuildProgress not implemented")
 }
+func (*UnimplementedDataCoordServer) GcConfirm(ctx context.Context, req *GcConfirmRequest) (*GcConfirmResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GcConfirm not implemented")
+}
 
 func RegisterDataCoordServer(s *grpc.Server, srv DataCoordServer) {
 	s.RegisterService(&_DataCoord_serviceDesc, srv)
@@ -6447,6 +6561,24 @@ func _DataCoord_GetIndexBuildProgress_Handler(srv interface{}, ctx context.Conte
 	return interceptor(ctx, in, info, handler)
 }
 
+func _DataCoord_GcConfirm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GcConfirmRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DataCoordServer).GcConfirm(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.data.DataCoord/GcConfirm",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DataCoordServer).GcConfirm(ctx, req.(*GcConfirmRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _DataCoord_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "milvus.proto.data.DataCoord",
 	HandlerType: (*DataCoordServer)(nil),
@@ -6607,6 +6739,10 @@ var _DataCoord_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetIndexBuildProgress",
 			Handler:    _DataCoord_GetIndexBuildProgress_Handler,
 		},
+		{
+			MethodName: "GcConfirm",
+			Handler:    _DataCoord_GcConfirm_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "data_coord.proto",

internal/proxy/data_coord_mock_test.go

@@ -18,20 +18,22 @@ package proxy
 
 import (
 	"context"
-	"sync/atomic"
-
-	"github.com/milvus-io/milvus/internal/proto/indexpb"
 
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
 	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
 	"github.com/milvus-io/milvus/internal/proto/datapb"
+	"github.com/milvus-io/milvus/internal/proto/indexpb"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
+	"github.com/milvus-io/milvus/internal/types"
 	"github.com/milvus-io/milvus/internal/util/funcutil"
 	"github.com/milvus-io/milvus/internal/util/typeutil"
 	"github.com/milvus-io/milvus/internal/util/uniquegenerator"
+	"go.uber.org/atomic"
 )
 
 type DataCoordMock struct {
+	types.DataCoord
+
 	nodeID  typeutil.UniqueID
 	address string
 

internal/rootcoord/broker.go

@@ -40,6 +40,7 @@ type Broker interface {
 	UnsetIsImportingState(context.Context, *datapb.UnsetIsImportingStateRequest) (*commonpb.Status, error)
 	MarkSegmentsDropped(context.Context, *datapb.MarkSegmentsDroppedRequest) (*commonpb.Status, error)
 	GetSegmentStates(context.Context, *datapb.GetSegmentStatesRequest) (*datapb.GetSegmentStatesResponse, error)
+	GcConfirm(ctx context.Context, collectionID, partitionID UniqueID) bool
 
 	DropCollectionIndex(ctx context.Context, collID UniqueID, partIDs []UniqueID) error
 	GetSegmentIndexState(ctx context.Context, collID UniqueID, indexName string, segIDs []UniqueID) ([]*indexpb.SegmentIndexState, error)
@@ -235,3 +236,15 @@ func (b *ServerBroker) DescribeIndex(ctx context.Context, colID UniqueID) (*inde
 		CollectionID: colID,
 	})
 }
+
+func (b *ServerBroker) GcConfirm(ctx context.Context, collectionID, partitionID UniqueID) bool {
+	req := &datapb.GcConfirmRequest{CollectionId: collectionID, PartitionId: partitionID}
+	resp, err := b.s.dataCoord.GcConfirm(ctx, req)
+	if err != nil {
+		return false
+	}
+	if resp.GetStatus().GetErrorCode() != commonpb.ErrorCode_Success {
+		return false
+	}
+	return resp.GetGcFinished()
+}

internal/rootcoord/broker_test.go

@@ -5,15 +5,15 @@ import (
 	"errors"
 	"testing"
 
-	"github.com/milvus-io/milvus/internal/proto/indexpb"
+	"github.com/milvus-io/milvus/internal/proto/datapb"
-
-	"github.com/milvus-io/milvus/internal/metastore/model"
-
-	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
 
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
-	"github.com/milvus-io/milvus/internal/proto/datapb"
+	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
+	"github.com/milvus-io/milvus/internal/metastore/model"
+	"github.com/milvus-io/milvus/internal/mocks"
+	"github.com/milvus-io/milvus/internal/proto/indexpb"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 )
 
 func TestServerBroker_ReleaseCollection(t *testing.T) {
@@ -304,3 +304,42 @@ func TestServerBroker_BroadcastAlteredCollection(t *testing.T) {
 		assert.NoError(t, err)
 	})
 }
+
+func TestServerBroker_GcConfirm(t *testing.T) {
+	t.Run("invalid datacoord", func(t *testing.T) {
+		dc := mocks.NewDataCoord(t)
+		dc.On("GcConfirm",
+			mock.Anything, // context.Context
+			mock.Anything, // *datapb.GcConfirmRequest
+		).Return(nil, errors.New("error mock GcConfirm"))
+		c := newTestCore(withDataCoord(dc))
+		broker := newServerBroker(c)
+		assert.False(t, broker.GcConfirm(context.Background(), 100, 10000))
+	})
+
+	t.Run("non success", func(t *testing.T) {
+		dc := mocks.NewDataCoord(t)
+		dc.On("GcConfirm",
+			mock.Anything, // context.Context
+			mock.Anything, // *datapb.GcConfirmRequest
+		).Return(
+			&datapb.GcConfirmResponse{Status: failStatus(commonpb.ErrorCode_UnexpectedError, "error mock GcConfirm")},
+			nil)
+		c := newTestCore(withDataCoord(dc))
+		broker := newServerBroker(c)
+		assert.False(t, broker.GcConfirm(context.Background(), 100, 10000))
+	})
+
+	t.Run("normal case", func(t *testing.T) {
+		dc := mocks.NewDataCoord(t)
+		dc.On("GcConfirm",
+			mock.Anything, // context.Context
+			mock.Anything, // *datapb.GcConfirmRequest
+		).Return(
+			&datapb.GcConfirmResponse{Status: succStatus(), GcFinished: true},
+			nil)
+		c := newTestCore(withDataCoord(dc))
+		broker := newServerBroker(c)
+		assert.True(t, broker.GcConfirm(context.Background(), 100, 10000))
+	})
+}

internal/rootcoord/drop_collection_task.go

@@ -91,6 +91,7 @@ func (t *dropCollectionTask) Execute(ctx context.Context) error {
 		baseStep:  baseStep{core: t.core},
 		pChannels: collMeta.PhysicalChannelNames,
 	})
+	redoTask.AddAsyncStep(newConfirmGCStep(t.core, collMeta.CollectionID, allPartition))
 	redoTask.AddAsyncStep(&deleteCollectionMetaStep{
 		baseStep:     baseStep{core: t.core},
 		collectionID: collMeta.CollectionID,

internal/rootcoord/drop_collection_task_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"testing"
+	"time"
 
 	"github.com/milvus-io/milvus/internal/common"
 
@@ -148,6 +149,9 @@ func Test_dropCollectionTask_Execute(t *testing.T) {
 	t.Run("normal case, redo", func(t *testing.T) {
 		defer cleanTestEnv()
 
+		confirmGCInterval = time.Millisecond
+		defer restoreConfirmGCInterval()
+
 		collectionName := funcutil.GenRandomStr()
 		shardNum := 2
 
@@ -187,8 +191,12 @@ func Test_dropCollectionTask_Execute(t *testing.T) {
 		broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
 			dropIndexCalled = true
 			dropIndexChan <- struct{}{}
+			time.Sleep(confirmGCInterval)
 			return nil
 		}
+		broker.GCConfirmFunc = func(ctx context.Context, collectionID, partitionID UniqueID) bool {
+			return true
+		}
 
 		gc := newMockGarbageCollector()
 		deleteCollectionCalled := false

internal/rootcoord/drop_partition_task.go

@@ -79,6 +79,7 @@ func (t *dropPartitionTask) Execute(ctx context.Context) error {
 			CollectionID:  t.collMeta.CollectionID,
 		},
 	})
+	redoTask.AddAsyncStep(newConfirmGCStep(t.core, t.collMeta.CollectionID, partID))
 	redoTask.AddAsyncStep(&removePartitionMetaStep{
 		baseStep:     baseStep{core: t.core},
 		collectionID: t.collMeta.CollectionID,

internal/rootcoord/drop_partition_task_test.go

@@ -3,6 +3,7 @@ package rootcoord
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/milvus-io/milvus/internal/metastore/model"
 	"github.com/milvus-io/milvus/internal/proto/etcdpb"
@@ -125,6 +126,9 @@ func Test_dropPartitionTask_Execute(t *testing.T) {
 	})
 
 	t.Run("normal case", func(t *testing.T) {
+		confirmGCInterval = time.Millisecond
+		defer restoreConfirmGCInterval()
+
 		collectionName := funcutil.GenRandomStr()
 		partitionName := funcutil.GenRandomStr()
 		coll := &model.Collection{Name: collectionName, Partitions: []*model.Partition{{PartitionName: partitionName}}}
@@ -146,10 +150,23 @@ func Test_dropPartitionTask_Execute(t *testing.T) {
 		gc.GcPartitionDataFunc = func(ctx context.Context, pChannels []string, coll *model.Partition) (Timestamp, error) {
 			deletePartitionChan <- struct{}{}
 			deletePartitionCalled = true
+			time.Sleep(confirmGCInterval)
 			return 0, nil
 		}
 
-		core := newTestCore(withValidProxyManager(), withMeta(meta), withGarbageCollector(gc), withDropIndex())
+		broker := newMockBroker()
+		broker.GCConfirmFunc = func(ctx context.Context, collectionID, partitionID UniqueID) bool {
+			return true
+		}
+		broker.DropCollectionIndexFunc = func(ctx context.Context, collID UniqueID, partIDs []UniqueID) error {
+			return nil
+		}
+
+		core := newTestCore(
+			withValidProxyManager(),
+			withMeta(meta),
+			withGarbageCollector(gc),
+			withBroker(broker))
 
 		task := &dropPartitionTask{
 			baseTask: baseTask{core: core},

internal/rootcoord/meta_table.go

@@ -35,7 +35,6 @@ import (
 	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
 	"github.com/milvus-io/milvus/internal/log"
 	"github.com/milvus-io/milvus/internal/metastore"
-	"github.com/milvus-io/milvus/internal/metastore/kv/rootcoord"
 	"github.com/milvus-io/milvus/internal/metastore/model"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
 	"github.com/milvus-io/milvus/internal/util/contextutil"
@@ -43,29 +42,6 @@ import (
 	"github.com/milvus-io/milvus/internal/util/typeutil"
 )
 
-const (
-	// TimestampPrefix prefix for timestamp
-	TimestampPrefix = rootcoord.ComponentPrefix + "/timestamp"
-
-	// CreateCollectionDDType name of DD type for create collection
-	CreateCollectionDDType = "CreateCollection"
-
-	// DropCollectionDDType name of DD type for drop collection
-	DropCollectionDDType = "DropCollection"
-
-	// CreatePartitionDDType name of DD type for create partition
-	CreatePartitionDDType = "CreatePartition"
-
-	// DropPartitionDDType name of DD type for drop partition
-	DropPartitionDDType = "DropPartition"
-
-	// DefaultIndexType name of default index type for scalar field
-	DefaultIndexType = "STL_SORT"
-
-	// DefaultStringIndexType name of default index type for varChar/string field
-	DefaultStringIndexType = "Trie"
-)
-
 //go:generate mockery --name=IMetaTable --outpkg=mockrootcoord
 type IMetaTable interface {
 	AddCollection(ctx context.Context, coll *model.Collection) error

internal/rootcoord/mock_test.go

@@ -765,6 +765,8 @@ type mockBroker struct {
 	GetSegmentIndexStateFunc func(ctx context.Context, collID UniqueID, indexName string, segIDs []UniqueID) ([]*indexpb.SegmentIndexState, error)
 
 	BroadcastAlteredCollectionFunc func(ctx context.Context, req *milvuspb.AlterCollectionRequest) error
+
+	GCConfirmFunc func(ctx context.Context, collectionID, partitionID UniqueID) bool
 }
 
 func newMockBroker() *mockBroker {
@@ -799,6 +801,10 @@ func (b mockBroker) BroadcastAlteredCollection(ctx context.Context, req *milvusp
 	return b.BroadcastAlteredCollectionFunc(ctx, req)
 }
 
+func (b mockBroker) GcConfirm(ctx context.Context, collectionID, partitionID UniqueID) bool {
+	return b.GCConfirmFunc(ctx, collectionID, partitionID)
+}
+
 func withBroker(b Broker) Opt {
 	return func(c *Core) {
 		c.broker = b

internal/rootcoord/step.go

@@ -3,6 +3,7 @@ package rootcoord
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
 
@@ -14,10 +15,10 @@ import (
 type stepPriority int
 
 const (
-	stepPriorityLow = iota
+	stepPriorityLow       = 0
-	stepPriorityNormal
+	stepPriorityNormal    = 1
-	stepPriorityImportant
+	stepPriorityImportant = 10
-	stepPriorityUrgent
+	stepPriorityUrgent    = 1000
 )
 
 type nestedStep interface {
@@ -374,3 +375,50 @@ func (b *BroadcastAlteredCollectionStep) Execute(ctx context.Context) ([]nestedS
 func (b *BroadcastAlteredCollectionStep) Desc() string {
 	return fmt.Sprintf("broadcast altered collection, collectionID: %d", b.req.CollectionID)
 }
+
+var (
+	confirmGCInterval          = time.Minute * 20
+	allPartition      UniqueID = -1
+)
+
+type confirmGCStep struct {
+	baseStep
+	collectionID      UniqueID
+	partitionID       UniqueID
+	lastScheduledTime time.Time
+}
+
+func newConfirmGCStep(core *Core, collectionID, partitionID UniqueID) *confirmGCStep {
+	return &confirmGCStep{
+		baseStep:          baseStep{core: core},
+		collectionID:      collectionID,
+		partitionID:       partitionID,
+		lastScheduledTime: time.Now(),
+	}
+}
+
+func (b *confirmGCStep) Execute(ctx context.Context) ([]nestedStep, error) {
+	if time.Since(b.lastScheduledTime) < confirmGCInterval {
+		return nil, fmt.Errorf("wait for reschedule to confirm GC, collection: %d, partition: %d, last scheduled time: %s, now: %s",
+			b.collectionID, b.partitionID, b.lastScheduledTime.String(), time.Now().String())
+	}
+
+	finished := b.core.broker.GcConfirm(ctx, b.collectionID, b.partitionID)
+	if finished {
+		return nil, nil
+	}
+
+	b.lastScheduledTime = time.Now()
+
+	return nil, fmt.Errorf("GC is not finished, collection: %d, partition: %d, last scheduled time: %s, now: %s",
+		b.collectionID, b.partitionID, b.lastScheduledTime.String(), time.Now().String())
+}
+
+func (b *confirmGCStep) Desc() string {
+	return fmt.Sprintf("wait for GC finished, collection: %d, partition: %d, last scheduled time: %s, now: %s",
+		b.collectionID, b.partitionID, b.lastScheduledTime.String(), time.Now().String())
+}
+
+func (b *confirmGCStep) Weight() stepPriority {
+	return stepPriorityLow
+}

internal/rootcoord/step_executor.go

@@ -2,6 +2,7 @@ package rootcoord
 
 import (
 	"context"
+	"sort"
 	"sync"
 	"time"
 
@@ -25,14 +26,26 @@ type stepStack struct {
 	steps []nestedStep
 }
 
+func (s *stepStack) totalPriority() int {
+	total := 0
+	for _, step := range s.steps {
+		total += int(step.Weight())
+	}
+	return total
+}
+
 func (s *stepStack) Execute(ctx context.Context) *stepStack {
 	steps := s.steps
 	for len(steps) > 0 {
 		l := len(steps)
 		todo := steps[l-1]
 		childSteps, err := todo.Execute(ctx)
+
 		// TODO: maybe a interface `step.LogOnError` is better.
-		_, skipLog := todo.(*waitForTsSyncedStep)
+		_, isWaitForTsSyncedStep := todo.(*waitForTsSyncedStep)
+		_, isConfirmGCStep := todo.(*confirmGCStep)
+		skipLog := isWaitForTsSyncedStep || isConfirmGCStep
+
 		if retry.IsUnRecoverable(err) {
 			if !skipLog {
 				log.Warn("failed to execute step, not able to reschedule", zap.Error(err), zap.String("step", todo.Desc()))
@@ -76,8 +89,28 @@ func randomSelectPolicy(parallel int) selectStepPolicy {
 	}
 }
 
+func selectByPriority(parallel int, m map[*stepStack]struct{}) []*stepStack {
+	h := make([]*stepStack, 0, len(m))
+	for k := range m {
+		h = append(h, k)
+	}
+	sort.Slice(h, func(i, j int) bool {
+		return h[i].totalPriority() > h[j].totalPriority()
+	})
+	if len(h) <= parallel {
+		return h
+	}
+	return h[:parallel]
+}
+
+func selectByPriorityPolicy(parallel int) selectStepPolicy {
+	return func(m map[*stepStack]struct{}) []*stepStack {
+		return selectByPriority(parallel, m)
+	}
+}
+
 func defaultSelectPolicy() selectStepPolicy {
-	return randomSelectPolicy(defaultBgExecutingParallel)
+	return selectByPriorityPolicy(defaultBgExecutingParallel)
 }
 
 type bgOpt func(*bgStepExecutor)

internal/rootcoord/step_executor_test.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/milvus-io/milvus/internal/util/retry"
-
 	"github.com/stretchr/testify/assert"
 )
 
@@ -128,7 +127,7 @@ func Test_randomSelect(t *testing.T) {
 
 func Test_bgStepExecutor_scheduleLoop(t *testing.T) {
 	bg := newBgStepExecutor(context.Background(),
-		withSelectStepPolicy(defaultSelectPolicy()),
+		withSelectStepPolicy(randomSelectPolicy(defaultBgExecutingParallel)),
 		withBgInterval(time.Millisecond*10))
 	bg.Start()
 	n := 20
@@ -173,3 +172,43 @@ func Test_bgStepExecutor_scheduleLoop(t *testing.T) {
 	}
 	bg.Stop()
 }
+
+func Test_selectByPriorityPolicy(t *testing.T) {
+	policy := selectByPriorityPolicy(4)
+
+	t.Run("select all", func(t *testing.T) {
+		m := map[*stepStack]struct{}{
+			{steps: []nestedStep{}}: {},
+			{steps: []nestedStep{}}: {},
+		}
+		selected := policy(m)
+		assert.Equal(t, 2, len(selected))
+	})
+
+	t.Run("select by priority", func(t *testing.T) {
+		steps := []nestedStep{
+			&releaseCollectionStep{},
+			&releaseCollectionStep{},
+			&releaseCollectionStep{},
+			&releaseCollectionStep{},
+			&releaseCollectionStep{},
+		}
+		s1 := &stepStack{steps: steps[0:1]}
+		s2 := &stepStack{steps: steps[0:2]}
+		s3 := &stepStack{steps: steps[0:3]}
+		s4 := &stepStack{steps: steps[0:4]}
+		s5 := &stepStack{steps: steps[0:5]}
+		m := map[*stepStack]struct{}{
+			s1: {},
+			s2: {},
+			s3: {},
+			s4: {},
+			s5: {},
+		}
+		selected := policy(m)
+		assert.Equal(t, 4, len(selected))
+		for i := 1; i < len(selected); i++ {
+			assert.True(t, selected[i].totalPriority() <= selected[i-1].totalPriority())
+		}
+	})
+}

internal/rootcoord/step_test.go

@@ -3,6 +3,7 @@ package rootcoord
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -27,3 +28,54 @@ func Test_waitForTsSyncedStep_Execute(t *testing.T) {
 	assert.Equal(t, 0, len(children))
 	assert.NoError(t, err)
 }
+
+func restoreConfirmGCInterval() {
+	confirmGCInterval = time.Minute * 20
+}
+
+func Test_confirmGCStep_Execute(t *testing.T) {
+	t.Run("wait for reschedule", func(t *testing.T) {
+		confirmGCInterval = time.Minute * 1000
+		defer restoreConfirmGCInterval()
+
+		s := &confirmGCStep{lastScheduledTime: time.Now()}
+		_, err := s.Execute(context.TODO())
+		assert.Error(t, err)
+	})
+
+	t.Run("GC not finished", func(t *testing.T) {
+		broker := newMockBroker()
+		broker.GCConfirmFunc = func(ctx context.Context, collectionID, partitionID UniqueID) bool {
+			return false
+		}
+
+		core := newTestCore(withBroker(broker))
+
+		confirmGCInterval = time.Millisecond
+		defer restoreConfirmGCInterval()
+
+		s := newConfirmGCStep(core, 100, 1000)
+		time.Sleep(confirmGCInterval)
+
+		_, err := s.Execute(context.TODO())
+		assert.Error(t, err)
+	})
+
+	t.Run("normal case", func(t *testing.T) {
+		broker := newMockBroker()
+		broker.GCConfirmFunc = func(ctx context.Context, collectionID, partitionID UniqueID) bool {
+			return true
+		}
+
+		core := newTestCore(withBroker(broker))
+
+		confirmGCInterval = time.Millisecond
+		defer restoreConfirmGCInterval()
+
+		s := newConfirmGCStep(core, 100, 1000)
+		time.Sleep(confirmGCInterval)
+
+		_, err := s.Execute(context.TODO())
+		assert.NoError(t, err)
+	})
+}

internal/types/types.go

@@ -331,6 +331,8 @@ type DataCoord interface {
 
 	CheckHealth(ctx context.Context, req *milvuspb.CheckHealthRequest) (*milvuspb.CheckHealthResponse, error)
 
+	GcConfirm(ctx context.Context, request *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error)
+
 	// CreateIndex create an index on collection.
 	// Index building is asynchronous, so when an index building request comes, an IndexID is assigned to the task and
 	// will get all flushed segments from DataCoord and record tasks with these segments. The background process

internal/util/mock/datacoord_client.go

@@ -19,16 +19,17 @@ package mock
 import (
 	"context"
 
-	"google.golang.org/grpc"
-
 	"github.com/milvus-io/milvus-proto/go-api/commonpb"
 	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
 	"github.com/milvus-io/milvus/internal/proto/datapb"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
+	"github.com/milvus-io/milvus/internal/types"
+	"google.golang.org/grpc"
 )
 
 // DataCoordClient mocks of DataCoordClient
 type DataCoordClient struct {
+	types.DataCoord
 	Err error
 }
 

internal/util/mock/grpc_datacoord_client.go

@@ -36,6 +36,10 @@ type GrpcDataCoordClient struct {
 	Err error
 }
 
+func (m *GrpcDataCoordClient) GcConfirm(ctx context.Context, in *datapb.GcConfirmRequest, opts ...grpc.CallOption) (*datapb.GcConfirmResponse, error) {
+	return &datapb.GcConfirmResponse{}, m.Err
+}
+
 func (m *GrpcDataCoordClient) CheckHealth(ctx context.Context, in *milvuspb.CheckHealthRequest, opts ...grpc.CallOption) (*milvuspb.CheckHealthResponse, error) {
 	return &milvuspb.CheckHealthResponse{}, m.Err
 }