Add DropVirtualChannel for DataCoord (#12361)

Signed-off-by: Congqi Xia <congqi.xia@zilliz.com>

internal/datacoord/channel_store.go

@@ -319,7 +319,7 @@ func (c *ChannelStore) remove(nodeID int64) error {
 
 func (c *ChannelStore) txn(opSet ChannelOpSet) error {
 	saves := make(map[string]string)
-	removals := make([]string, 0)
+	var removals []string
 	for _, update := range opSet {
 		for i, c := range update.Channels {
 			k := buildChannelKey(update.NodeID, c.Name)

internal/datacoord/meta.go

@@ -36,6 +36,7 @@ import (
 const (
 	metaPrefix           = "datacoord-meta"
 	segmentPrefix        = metaPrefix + "/s"
+	channelRemovePrefix  = metaPrefix + "/channel-removal"
 	handoffSegmentPrefix = "querycoord-handoff"
 )
 
@@ -334,6 +335,153 @@ func (m *meta) UpdateFlushSegmentsInfo(
 	return nil
 }
 
+// UpdateDropChannelSegmentInfo updates segment checkpoints and binlogs before drop
+// reusing segment info to pass segment id, binlogs, statslog, deltalog, start position and checkpoint
+func (m *meta) UpdateDropChannelSegmentInfo(channel string, segments []*SegmentInfo) error {
+	m.Lock()
+	defer m.Unlock()
+
+	modSegments := make(map[UniqueID]*SegmentInfo)
+
+	for _, seg2Drop := range segments {
+		segment := m.mergeDropSegment(seg2Drop)
+		if segment != nil {
+			modSegments[seg2Drop.GetID()] = segment
+		}
+	}
+
+	return m.batchSaveDropSegments(channel, modSegments)
+}
+
+// mergeDropSegment merges drop segment information with meta segments
+func (m *meta) mergeDropSegment(seg2Drop *SegmentInfo) *SegmentInfo {
+	segment := m.segments.GetSegment(seg2Drop.ID)
+	// healthy check makes sure the Idempotence
+	if segment == nil || !isSegmentHealthy(segment) {
+		log.Warn("UpdateDropChannel skipping nil or unhealthy", zap.Bool("is nil", segment == nil),
+			zap.Bool("isHealthy", isSegmentHealthy(segment)))
+		return nil
+	}
+
+	clonedSegment := segment.Clone()
+	clonedSegment.State = commonpb.SegmentState_Dropped
+
+	currBinlogs := clonedSegment.GetBinlogs()
+
+	var getFieldBinlogs = func(id UniqueID, binlogs []*datapb.FieldBinlog) *datapb.FieldBinlog {
+		for _, binlog := range binlogs {
+			if id == binlog.GetFieldID() {
+				return binlog
+			}
+		}
+		return nil
+	}
+	// binlogs
+	for _, tBinlogs := range seg2Drop.GetBinlogs() {
+		fieldBinlogs := getFieldBinlogs(tBinlogs.GetFieldID(), currBinlogs)
+		if fieldBinlogs == nil {
+			currBinlogs = append(currBinlogs, tBinlogs)
+		} else {
+			fieldBinlogs.Binlogs = append(fieldBinlogs.Binlogs, tBinlogs.Binlogs...)
+		}
+	}
+	clonedSegment.Binlogs = currBinlogs
+	// statlogs
+	currStatsLogs := clonedSegment.GetStatslogs()
+	for _, tStatsLogs := range seg2Drop.GetStatslogs() {
+		fieldStatsLog := getFieldBinlogs(tStatsLogs.GetFieldID(), currStatsLogs)
+		if fieldStatsLog == nil {
+			currStatsLogs = append(currStatsLogs, tStatsLogs)
+		} else {
+			fieldStatsLog.Binlogs = append(fieldStatsLog.Binlogs, tStatsLogs.Binlogs...)
+		}
+	}
+	clonedSegment.Statslogs = currStatsLogs
+	// deltalogs
+	clonedSegment.Deltalogs = append(clonedSegment.Deltalogs, seg2Drop.GetDeltalogs()...)
+
+	// start position
+	if seg2Drop.GetStartPosition() != nil {
+		clonedSegment.StartPosition = seg2Drop.GetStartPosition()
+	}
+	// checkpoint
+	if seg2Drop.GetDmlPosition() != nil {
+		clonedSegment.DmlPosition = seg2Drop.GetDmlPosition()
+	}
+	clonedSegment.currRows = seg2Drop.currRows
+	return clonedSegment
+}
+
+// batchSaveDropSegments saves drop segments info with channel removal flag
+// since the channel unwatching operation is not atomic here
+// ** the removal flag is always with last batch
+// ** the last batch must contains at least one segment
+// 1. when failure occurs between batches, failover mechanism will continue with the earlist  checkpoint of this channel
+//   since the flag is not marked so data node can re-consume the drop collection msg
+// 2. when failure occurs between save meta and unwatch channel, the removal flag shall be check before let datanode  watch this channel
+func (m *meta) batchSaveDropSegments(channel string, modSegments map[int64]*SegmentInfo) error {
+
+	// the limitation of etcd operations number per transaction is 128, since segment number might be enormous so we shall split
+	// all save operations into batches
+
+	// since the removal flag shall always be with the last batch, so the last batch shall be maxOperationNumber - 1
+	for len(modSegments) > maxOperationsPerTxn-1 {
+		err := m.saveDropSegmentAndRemove(channel, modSegments, false, func(kv map[string]string, modSegments map[int64]*SegmentInfo) bool {
+			// batch filled or only one segment left
+			// since the last batch must contains at least on segment
+			return len(kv) == maxOperationsPerTxn || len(modSegments) == 1
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	// removal flag should be saved with last batch
+	return m.saveDropSegmentAndRemove(channel, modSegments, true, func(_ map[string]string, _ map[int64]*SegmentInfo) bool { return false })
+}
+
+func (m *meta) saveDropSegmentAndRemove(channel string, modSegments map[int64]*SegmentInfo, withFlag bool, stopper func(kv map[string]string, modSegment map[int64]*SegmentInfo) bool) error {
+	kv := make(map[string]string)
+	update := make([]*SegmentInfo, 0, maxOperationsPerTxn)
+	for id, s := range modSegments {
+		key := buildSegmentPath(s.GetCollectionID(), s.GetPartitionID(), s.GetID())
+		delete(modSegments, id)
+		segBytes, err := proto.Marshal(s.SegmentInfo)
+		if err != nil {
+			return fmt.Errorf("DataCoord UpdateDropChannelSegmentInfo segmentID:%d, marshal failed:%w", s.GetID(), err)
+		}
+		kv[key] = string(segBytes)
+		update = append(update, s)
+		if stopper(kv, modSegments) {
+			break
+		}
+	}
+	if withFlag {
+		// add removal flag into meta, preventing non-atomic removal channel failure
+		removalFlag := buildChannelRemovePath(channel)
+
+		kv[removalFlag] = ""
+	}
+
+	err := m.saveKvTxn(kv)
+	if err != nil {
+		log.Warn("Failed to txn save segment info batch for DropChannel", zap.Error(err))
+		return err
+	}
+
+	// update memory info
+	for _, s := range update {
+		m.segments.SetSegment(s.GetID(), s)
+	}
+	return nil
+}
+
+// FinishRemoveChannel removes channel remove flag after whole procedure is finished
+func (m *meta) FinishRemoveChannel(channel string) error {
+	key := buildChannelRemovePath(channel)
+	return m.client.Remove(key)
+}
+
 // ListSegmentFiles lists all segments' logs
 func (m *meta) ListSegmentFiles() []string {
 	m.RLock()
@@ -758,6 +906,11 @@ func buildQuerySegmentPath(collectionID UniqueID, partitionID UniqueID, segmentI
 	return fmt.Sprintf("%s/%d/%d/%d", handoffSegmentPrefix, collectionID, partitionID, segmentID)
 }
 
+// buildChannelRemovePat builds vchannel remove flag path
+func buildChannelRemovePath(channel string) string {
+	return fmt.Sprintf("%s/%s", channelRemovePrefix, channel)
+}
+
 // buildSegment utility function for compose datapb.SegmentInfo struct with provided info
 func buildSegment(collectionID UniqueID, partitionID UniqueID, segmentID UniqueID, channelName string) *SegmentInfo {
 	info := &datapb.SegmentInfo{
@@ -772,6 +925,7 @@ func buildSegment(collectionID UniqueID, partitionID UniqueID, segmentID UniqueI
 }
 
 func isSegmentHealthy(segment *SegmentInfo) bool {
-	return segment.GetState() != commonpb.SegmentState_NotExist &&
+	return segment.GetState() != commonpb.SegmentState_SegmentStateNone &&
+		segment.GetState() != commonpb.SegmentState_NotExist &&
 		segment.GetState() != commonpb.SegmentState_Dropped
 }

internal/datacoord/meta_test.go

@@ -515,7 +515,8 @@ func Test_meta_SetSegmentCompacting(t *testing.T) {
 					map[int64]*SegmentInfo{
 						1: {
 							SegmentInfo: &datapb.SegmentInfo{
-								ID: 1,
+								ID:    1,
+								State: commonpb.SegmentState_Flushed,
 							},
 							isCompacting: false,
 						},
@@ -563,18 +564,21 @@ func Test_meta_GetSegmentsOfCollection(t *testing.T) {
 							SegmentInfo: &datapb.SegmentInfo{
 								ID:           1,
 								CollectionID: 1,
+								State:        commonpb.SegmentState_Flushed,
 							},
 						},
 						2: {
 							SegmentInfo: &datapb.SegmentInfo{
 								ID:           2,
 								CollectionID: 1,
+								State:        commonpb.SegmentState_Growing,
 							},
 						},
 						3: {
 							SegmentInfo: &datapb.SegmentInfo{
 								ID:           3,
 								CollectionID: 2,
+								State:        commonpb.SegmentState_Flushed,
 							},
 						},
 					},
@@ -588,12 +592,14 @@ func Test_meta_GetSegmentsOfCollection(t *testing.T) {
 					SegmentInfo: &datapb.SegmentInfo{
 						ID:           1,
 						CollectionID: 1,
+						State:        commonpb.SegmentState_Flushed,
 					},
 				},
 				{
 					SegmentInfo: &datapb.SegmentInfo{
 						ID:           2,
 						CollectionID: 1,
+						State:        commonpb.SegmentState_Growing,
 					},
 				},
 			},

internal/datacoord/segment_manager_test.go

@@ -520,12 +520,14 @@ func TestSegmentManager_DropSegmentsOfChannel(t *testing.T) {
 								SegmentInfo: &datapb.SegmentInfo{
 									ID:            1,
 									InsertChannel: "ch1",
+									State:         commonpb.SegmentState_Flushed,
 								},
 							},
 							2: {
 								SegmentInfo: &datapb.SegmentInfo{
 									ID:            2,
 									InsertChannel: "ch2",
+									State:         commonpb.SegmentState_Flushed,
 								},
 							},
 						},
@@ -555,6 +557,7 @@ func TestSegmentManager_DropSegmentsOfChannel(t *testing.T) {
 								SegmentInfo: &datapb.SegmentInfo{
 									ID:            2,
 									InsertChannel: "ch2",
+									State:         commonpb.SegmentState_Growing,
 								},
 							},
 						},

internal/datacoord/server_test.go

@@ -346,6 +346,7 @@ func TestGetInsertBinlogPaths(t *testing.T) {
 					},
 				},
 			},
+			State: commonpb.SegmentState_Growing,
 		}
 		err := svr.meta.AddSegment(NewSegmentInfo(info))
 		assert.Nil(t, err)
@@ -372,6 +373,8 @@ func TestGetInsertBinlogPaths(t *testing.T) {
 					},
 				},
 			},
+
+			State: commonpb.SegmentState_Growing,
 		}
 		err := svr.meta.AddSegment(NewSegmentInfo(info))
 		assert.Nil(t, err)
@@ -450,7 +453,8 @@ func TestGetSegmentInfo(t *testing.T) {
 		defer closeTestServer(t, svr)
 
 		segInfo := &datapb.SegmentInfo{
-			ID: 0,
+			ID:    0,
+			State: commonpb.SegmentState_Flushed,
 		}
 		err := svr.meta.AddSegment(NewSegmentInfo(segInfo))
 		assert.Nil(t, err)
@@ -467,7 +471,8 @@ func TestGetSegmentInfo(t *testing.T) {
 		defer closeTestServer(t, svr)
 
 		segInfo := &datapb.SegmentInfo{
-			ID: 0,
+			ID:    0,
+			State: commonpb.SegmentState_Flushed,
 		}
 		err := svr.meta.AddSegment(NewSegmentInfo(segInfo))
 		assert.Nil(t, err)
@@ -816,6 +821,7 @@ func TestSaveBinlogPaths(t *testing.T) {
 				ID:            segment.id,
 				CollectionID:  segment.collectionID,
 				InsertChannel: "ch1",
+				State:         commonpb.SegmentState_Growing,
 			}
 			err := svr.meta.AddSegment(NewSegmentInfo(s))
 			assert.Nil(t, err)
@@ -897,6 +903,7 @@ func TestSaveBinlogPaths(t *testing.T) {
 				ID:            1,
 				CollectionID:  1,
 				InsertChannel: "ch1",
+				State:         commonpb.SegmentState_Growing,
 			},
 		})
 		assert.Nil(t, err)
@@ -915,6 +922,143 @@ func TestSaveBinlogPaths(t *testing.T) {
 	})
 }
 
+func TestDropVirtualChannel(t *testing.T) {
+	t.Run("normal DropVirtualChannel", func(t *testing.T) {
+		spyCh := make(chan struct{}, 1)
+		svr := newTestServer(t, nil, SetSegmentManager(&spySegmentManager{spyCh: spyCh}))
+
+		defer closeTestServer(t, svr)
+
+		svr.meta.AddCollection(&datapb.CollectionInfo{ID: 0})
+		type testSegment struct {
+			id           UniqueID
+			collectionID UniqueID
+		}
+		segments := make([]testSegment, 0, maxOperationsPerTxn) // test batch overflow
+		for i := 0; i < maxOperationsPerTxn; i++ {
+			segments = append(segments, testSegment{
+				id:           int64(i),
+				collectionID: 0,
+			})
+		}
+		for idx, segment := range segments {
+			s := &datapb.SegmentInfo{
+				ID:            segment.id,
+				CollectionID:  segment.collectionID,
+				InsertChannel: "ch1",
+
+				State: commonpb.SegmentState_Growing,
+			}
+			if idx%2 == 0 {
+				s.Binlogs = []*datapb.FieldBinlog{
+					{FieldID: 1},
+				}
+				s.Statslogs = []*datapb.FieldBinlog{
+					{FieldID: 1},
+				}
+			}
+			err := svr.meta.AddSegment(NewSegmentInfo(s))
+			assert.Nil(t, err)
+		}
+
+		err := svr.channelManager.AddNode(0)
+		require.Nil(t, err)
+		err = svr.channelManager.Watch(&channel{"ch1", 0})
+		require.Nil(t, err)
+
+		ctx := context.Background()
+		req := &datapb.DropVirtualChannelRequest{
+			Base: &commonpb.MsgBase{
+				Timestamp: uint64(time.Now().Unix()),
+			},
+			ChannelName: "ch1",
+			Segments:    make([]*datapb.DropVirtualChannelSegment, 0, maxOperationsPerTxn),
+		}
+		for _, segment := range segments {
+			seg2Drop := &datapb.DropVirtualChannelSegment{
+				SegmentID:    segment.id,
+				CollectionID: segment.collectionID,
+				Field2BinlogPaths: []*datapb.FieldBinlog{
+					{
+						FieldID: 1,
+						Binlogs: []string{
+							"/by-dev/test/0/1/2/1/Allo1",
+							"/by-dev/test/0/1/2/1/Allo2",
+						},
+					},
+				},
+				Field2StatslogPaths: []*datapb.FieldBinlog{
+					{
+						FieldID: 1,
+						Binlogs: []string{
+							"/by-dev/test/0/1/2/1/stats1",
+							"/by-dev/test/0/1/2/1/stats2",
+						},
+					},
+				},
+				Deltalogs: []*datapb.DeltaLogInfo{
+					{
+						RecordEntries: 1,
+						DeltaLogPath:  "/by-dev/test/0/1/2/1/delta1",
+					},
+				},
+				CheckPoint: &internalpb.MsgPosition{
+					ChannelName: "ch1",
+					MsgID:       []byte{1, 2, 3},
+					MsgGroup:    "",
+					Timestamp:   0,
+				},
+				StartPosition: &internalpb.MsgPosition{
+					ChannelName: "ch1",
+					MsgID:       []byte{1, 2, 3},
+					MsgGroup:    "",
+					Timestamp:   0,
+				},
+				NumOfRows: 10,
+			}
+			req.Segments = append(req.Segments, seg2Drop)
+		}
+		resp, err := svr.DropVirtualChannel(ctx, req)
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
+
+		<-spyCh
+
+		err = svr.channelManager.Watch(&channel{"ch1", 0})
+		require.Nil(t, err)
+
+		//resend
+		resp, err = svr.DropVirtualChannel(ctx, req)
+		assert.NoError(t, err)
+		assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
+
+	})
+
+	t.Run("with channel not matched", func(t *testing.T) {
+		svr := newTestServer(t, nil)
+		defer closeTestServer(t, svr)
+		err := svr.channelManager.AddNode(0)
+		require.Nil(t, err)
+		err = svr.channelManager.Watch(&channel{"ch1", 0})
+		require.Nil(t, err)
+
+		resp, err := svr.DropVirtualChannel(context.Background(), &datapb.DropVirtualChannelRequest{
+			ChannelName: "ch2",
+		})
+		assert.Nil(t, err)
+		assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetStatus().GetErrorCode())
+	})
+
+	t.Run("with closed server", func(t *testing.T) {
+		svr := newTestServer(t, nil)
+		closeTestServer(t, svr)
+		resp, err := svr.DropVirtualChannel(context.Background(), &datapb.DropVirtualChannelRequest{})
+		assert.Nil(t, err)
+		assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetStatus().GetErrorCode())
+		assert.Equal(t, serverNotServingErrMsg, resp.GetStatus().GetReason())
+	})
+}
+
 func TestDataNodeTtChannel(t *testing.T) {
 	genMsg := func(msgType commonpb.MsgType, ch string, t Timestamp) *msgstream.DataNodeTtMsg {
 		return &msgstream.DataNodeTtMsg{

internal/datacoord/services.go

@@ -384,6 +384,70 @@ func (s *Server) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPath
 	return resp, nil
 }
 
+// DropVirtualChannel notifies vchannel dropped
+// And contains the remaining data log & checkpoint to update
+func (s *Server) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
+	resp := &datapb.DropVirtualChannelResponse{
+		Status: &commonpb.Status{
+			ErrorCode: commonpb.ErrorCode_UnexpectedError,
+		},
+	}
+	if s.isClosed() {
+		resp.Status.Reason = serverNotServingErrMsg
+		return resp, nil
+	}
+
+	channel := req.GetChannelName()
+	log.Debug("receive DropVirtualChannel request",
+		zap.String("channel name", channel))
+
+	// validate
+	nodeID := req.GetBase().GetSourceID()
+	if !s.channelManager.Match(nodeID, channel) {
+		FailResponse(resp.Status, fmt.Sprintf("channel %s is not watched on node %d", channel, nodeID))
+		log.Warn("node is not matched with channel", zap.String("channel", channel), zap.Int64("nodeID", nodeID))
+		return resp, nil
+	}
+
+	segments := make([]*SegmentInfo, 0, len(req.GetSegments()))
+	for _, seg2Drop := range req.GetSegments() {
+		info := &datapb.SegmentInfo{
+			ID:            seg2Drop.GetSegmentID(),
+			CollectionID:  seg2Drop.GetCollectionID(),
+			InsertChannel: channel,
+			Binlogs:       seg2Drop.GetField2BinlogPaths(),
+			Statslogs:     seg2Drop.GetField2StatslogPaths(),
+			Deltalogs:     seg2Drop.GetDeltalogs(),
+			StartPosition: seg2Drop.GetStartPosition(),
+			DmlPosition:   seg2Drop.GetCheckPoint(),
+			NumOfRows:     seg2Drop.GetNumOfRows(),
+		}
+		segment := NewSegmentInfo(info)
+		segments = append(segments, segment)
+	}
+
+	err := s.meta.UpdateDropChannelSegmentInfo(channel, segments)
+	if err != nil {
+		log.Error("Update Drop Channel segment info failed", zap.String("channel", channel), zap.Error(err))
+		resp.Status.Reason = err.Error()
+		return resp, nil
+	}
+
+	log.Debug("DropVChannel plan to remove", zap.String("channel", channel))
+	err = s.channelManager.RemoveChannel(channel)
+	if err != nil {
+		log.Warn("DropVChannel failed to RemoveChannel", zap.String("channel", channel), zap.Error(err))
+	}
+	s.segmentManager.DropSegmentsOfChannel(ctx, channel)
+
+	// clean up removal flag
+	s.meta.FinishRemoveChannel(channel)
+
+	// no compaction triggerred in Drop procedure
+	resp.Status.ErrorCode = commonpb.ErrorCode_Success
+	return resp, nil
+}
+
 // GetComponentStates returns DataCoord's current state
 func (s *Server) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
 	nodeID := common.NotRegisteredID

internal/distributed/datacoord/client/client.go

@@ -675,3 +675,21 @@ func (c *Client) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateR
 	}
 	return ret.(*milvuspb.GetFlushStateResponse), err
 }
+
+// DropVirtualChannel drops virtual channel in datacoord.
+func (c *Client) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
+	ret, err := c.recall(func() (interface{}, error) {
+		client, err := c.getGrpcClient()
+		if err != nil {
+			return nil, err
+		}
+		if !funcutil.CheckCtxValid(ctx) {
+			return nil, ctx.Err()
+		}
+		return client.DropVirtualChannel(ctx, req)
+	})
+	if err != nil || ret == nil {
+		return nil, err
+	}
+	return ret.(*datapb.DropVirtualChannelResponse), err
+}

internal/distributed/datacoord/client/client_test.go

@@ -116,6 +116,11 @@ func (m *MockDataCoordClient) WatchChannels(ctx context.Context, req *datapb.Wat
 func (m *MockDataCoordClient) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest, opts ...grpc.CallOption) (*milvuspb.GetFlushStateResponse, error) {
 	return &milvuspb.GetFlushStateResponse{}, m.err
 }
+
+func (m *MockDataCoordClient) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest, opts ...grpc.CallOption) (*datapb.DropVirtualChannelResponse, error) {
+	return &datapb.DropVirtualChannelResponse{}, m.err
+}
+
 func Test_NewClient(t *testing.T) {
 	proxy.Params.InitOnce()
 
@@ -203,6 +208,9 @@ func Test_NewClient(t *testing.T) {
 
 		r20, err := client.WatchChannels(ctx, nil)
 		retCheck(retNotNil, r20, err)
+
+		r21, err := client.DropVirtualChannel(ctx, nil)
+		retCheck(retNotNil, r21, err)
 	}
 
 	client.getGrpcClient = func() (datapb.DataCoordClient, error) {

internal/distributed/datacoord/service.go

@@ -305,3 +305,8 @@ func (s *Server) WatchChannels(ctx context.Context, req *datapb.WatchChannelsReq
 func (s *Server) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error) {
 	return s.dataCoord.GetFlushState(ctx, req)
 }
+
+// DropVirtualChannel drop virtual channel in datacoord
+func (s *Server) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
+	return s.dataCoord.DropVirtualChannel(ctx, req)
+}

internal/distributed/datacoord/service_test.go

@@ -53,6 +53,7 @@ type MockDataCoord struct {
 	compactionPlansResp  *milvuspb.GetCompactionPlansResponse
 	watchChannelsResp    *datapb.WatchChannelsResponse
 	getFlushStateResp    *milvuspb.GetFlushStateResponse
+	dropVChanResp        *datapb.DropVirtualChannelResponse
 }
 
 func (m *MockDataCoord) Init() error {
@@ -155,6 +156,10 @@ func (m *MockDataCoord) GetFlushState(ctx context.Context, req *milvuspb.GetFlus
 	return m.getFlushStateResp, m.err
 }
 
+func (m *MockDataCoord) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
+	return m.dropVChanResp, m.err
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 func Test_NewServer(t *testing.T) {
 	ctx := context.Background()
@@ -321,6 +326,15 @@ func Test_NewServer(t *testing.T) {
 		assert.NotNil(t, resp)
 	})
 
+	t.Run("DropVirtualChannel", func(t *testing.T) {
+		server.dataCoord = &MockDataCoord{
+			dropVChanResp: &datapb.DropVirtualChannelResponse{},
+		}
+		resp, err := server.DropVirtualChannel(ctx, nil)
+		assert.Nil(t, err)
+		assert.NotNil(t, resp)
+	})
+
 	err = server.Stop()
 	assert.Nil(t, err)
 }

internal/distributed/proxy/service_test.go

@@ -403,6 +403,10 @@ func (m *MockDataCoord) GetFlushState(ctx context.Context, req *milvuspb.GetFlus
 	return nil, nil
 }
 
+func (m *MockDataCoord) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
+	return &datapb.DropVirtualChannelResponse{}, nil
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 type MockProxy struct {
 	MockBase

internal/proto/data_coord.proto

@@ -40,6 +40,7 @@ service DataCoord {
 
   rpc WatchChannels(WatchChannelsRequest) returns (WatchChannelsResponse) {}
   rpc GetFlushState(milvus.GetFlushStateRequest) returns (milvus.GetFlushStateResponse) {}
+  rpc DropVirtualChannel(DropVirtualChannelRequest) returns (DropVirtualChannelResponse) {}
 }
 
 service DataNode {
@@ -364,3 +365,24 @@ message WatchChannelsRequest {
 message WatchChannelsResponse {
   common.Status status = 1;
 }
+
+message DropVirtualChannelRequest {
+  common.MsgBase base = 1; 
+  string channel_name = 2; 
+  repeated DropVirtualChannelSegment segments = 3;
+}
+
+message DropVirtualChannelSegment {
+  int64 segmentID = 1;
+  int64 collectionID = 2;
+  repeated FieldBinlog field2BinlogPaths = 3;
+  repeated FieldBinlog field2StatslogPaths = 4;
+  repeated DeltaLogInfo deltalogs = 5;
+  internal.MsgPosition startPosition = 6;
+  internal.MsgPosition checkPoint = 7;
+  int64 numOfRows = 8;
+}
+
+message DropVirtualChannelResponse {
+  common.Status status = 1;
+}

internal/proto/datapb/data_coord.pb.go

@@ -2766,6 +2766,195 @@ func (m *WatchChannelsResponse) GetStatus() *commonpb.Status {
 	return nil
 }
 
+type DropVirtualChannelRequest struct {
+	Base                 *commonpb.MsgBase            `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	ChannelName          string                       `protobuf:"bytes,2,opt,name=channel_name,json=channelName,proto3" json:"channel_name,omitempty"`
+	Segments             []*DropVirtualChannelSegment `protobuf:"bytes,3,rep,name=segments,proto3" json:"segments,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
+	XXX_unrecognized     []byte                       `json:"-"`
+	XXX_sizecache        int32                        `json:"-"`
+}
+
+func (m *DropVirtualChannelRequest) Reset()         { *m = DropVirtualChannelRequest{} }
+func (m *DropVirtualChannelRequest) String() string { return proto.CompactTextString(m) }
+func (*DropVirtualChannelRequest) ProtoMessage()    {}
+func (*DropVirtualChannelRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_82cd95f524594f49, []int{45}
+}
+
+func (m *DropVirtualChannelRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DropVirtualChannelRequest.Unmarshal(m, b)
+}
+func (m *DropVirtualChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DropVirtualChannelRequest.Marshal(b, m, deterministic)
+}
+func (m *DropVirtualChannelRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DropVirtualChannelRequest.Merge(m, src)
+}
+func (m *DropVirtualChannelRequest) XXX_Size() int {
+	return xxx_messageInfo_DropVirtualChannelRequest.Size(m)
+}
+func (m *DropVirtualChannelRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_DropVirtualChannelRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DropVirtualChannelRequest proto.InternalMessageInfo
+
+func (m *DropVirtualChannelRequest) GetBase() *commonpb.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *DropVirtualChannelRequest) GetChannelName() string {
+	if m != nil {
+		return m.ChannelName
+	}
+	return ""
+}
+
+func (m *DropVirtualChannelRequest) GetSegments() []*DropVirtualChannelSegment {
+	if m != nil {
+		return m.Segments
+	}
+	return nil
+}
+
+type DropVirtualChannelSegment struct {
+	SegmentID            int64                   `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
+	CollectionID         int64                   `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
+	Field2BinlogPaths    []*FieldBinlog          `protobuf:"bytes,3,rep,name=field2BinlogPaths,proto3" json:"field2BinlogPaths,omitempty"`
+	Field2StatslogPaths  []*FieldBinlog          `protobuf:"bytes,4,rep,name=field2StatslogPaths,proto3" json:"field2StatslogPaths,omitempty"`
+	Deltalogs            []*DeltaLogInfo         `protobuf:"bytes,5,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
+	StartPosition        *internalpb.MsgPosition `protobuf:"bytes,6,opt,name=startPosition,proto3" json:"startPosition,omitempty"`
+	CheckPoint           *internalpb.MsgPosition `protobuf:"bytes,7,opt,name=checkPoint,proto3" json:"checkPoint,omitempty"`
+	NumOfRows            int64                   `protobuf:"varint,8,opt,name=numOfRows,proto3" json:"numOfRows,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
+	XXX_unrecognized     []byte                  `json:"-"`
+	XXX_sizecache        int32                   `json:"-"`
+}
+
+func (m *DropVirtualChannelSegment) Reset()         { *m = DropVirtualChannelSegment{} }
+func (m *DropVirtualChannelSegment) String() string { return proto.CompactTextString(m) }
+func (*DropVirtualChannelSegment) ProtoMessage()    {}
+func (*DropVirtualChannelSegment) Descriptor() ([]byte, []int) {
+	return fileDescriptor_82cd95f524594f49, []int{46}
+}
+
+func (m *DropVirtualChannelSegment) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DropVirtualChannelSegment.Unmarshal(m, b)
+}
+func (m *DropVirtualChannelSegment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DropVirtualChannelSegment.Marshal(b, m, deterministic)
+}
+func (m *DropVirtualChannelSegment) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DropVirtualChannelSegment.Merge(m, src)
+}
+func (m *DropVirtualChannelSegment) XXX_Size() int {
+	return xxx_messageInfo_DropVirtualChannelSegment.Size(m)
+}
+func (m *DropVirtualChannelSegment) XXX_DiscardUnknown() {
+	xxx_messageInfo_DropVirtualChannelSegment.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DropVirtualChannelSegment proto.InternalMessageInfo
+
+func (m *DropVirtualChannelSegment) GetSegmentID() int64 {
+	if m != nil {
+		return m.SegmentID
+	}
+	return 0
+}
+
+func (m *DropVirtualChannelSegment) GetCollectionID() int64 {
+	if m != nil {
+		return m.CollectionID
+	}
+	return 0
+}
+
+func (m *DropVirtualChannelSegment) GetField2BinlogPaths() []*FieldBinlog {
+	if m != nil {
+		return m.Field2BinlogPaths
+	}
+	return nil
+}
+
+func (m *DropVirtualChannelSegment) GetField2StatslogPaths() []*FieldBinlog {
+	if m != nil {
+		return m.Field2StatslogPaths
+	}
+	return nil
+}
+
+func (m *DropVirtualChannelSegment) GetDeltalogs() []*DeltaLogInfo {
+	if m != nil {
+		return m.Deltalogs
+	}
+	return nil
+}
+
+func (m *DropVirtualChannelSegment) GetStartPosition() *internalpb.MsgPosition {
+	if m != nil {
+		return m.StartPosition
+	}
+	return nil
+}
+
+func (m *DropVirtualChannelSegment) GetCheckPoint() *internalpb.MsgPosition {
+	if m != nil {
+		return m.CheckPoint
+	}
+	return nil
+}
+
+func (m *DropVirtualChannelSegment) GetNumOfRows() int64 {
+	if m != nil {
+		return m.NumOfRows
+	}
+	return 0
+}
+
+type DropVirtualChannelResponse struct {
+	Status               *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *DropVirtualChannelResponse) Reset()         { *m = DropVirtualChannelResponse{} }
+func (m *DropVirtualChannelResponse) String() string { return proto.CompactTextString(m) }
+func (*DropVirtualChannelResponse) ProtoMessage()    {}
+func (*DropVirtualChannelResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_82cd95f524594f49, []int{47}
+}
+
+func (m *DropVirtualChannelResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DropVirtualChannelResponse.Unmarshal(m, b)
+}
+func (m *DropVirtualChannelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DropVirtualChannelResponse.Marshal(b, m, deterministic)
+}
+func (m *DropVirtualChannelResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DropVirtualChannelResponse.Merge(m, src)
+}
+func (m *DropVirtualChannelResponse) XXX_Size() int {
+	return xxx_messageInfo_DropVirtualChannelResponse.Size(m)
+}
+func (m *DropVirtualChannelResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_DropVirtualChannelResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DropVirtualChannelResponse proto.InternalMessageInfo
+
+func (m *DropVirtualChannelResponse) GetStatus() *commonpb.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterEnum("milvus.proto.data.ChannelWatchState", ChannelWatchState_name, ChannelWatchState_value)
 	proto.RegisterEnum("milvus.proto.data.CompactionType", CompactionType_name, CompactionType_value)
@@ -2814,177 +3003,188 @@ func init() {
 	proto.RegisterType((*SegmentFieldBinlogMeta)(nil), "milvus.proto.data.SegmentFieldBinlogMeta")
 	proto.RegisterType((*WatchChannelsRequest)(nil), "milvus.proto.data.WatchChannelsRequest")
 	proto.RegisterType((*WatchChannelsResponse)(nil), "milvus.proto.data.WatchChannelsResponse")
+	proto.RegisterType((*DropVirtualChannelRequest)(nil), "milvus.proto.data.DropVirtualChannelRequest")
+	proto.RegisterType((*DropVirtualChannelSegment)(nil), "milvus.proto.data.DropVirtualChannelSegment")
+	proto.RegisterType((*DropVirtualChannelResponse)(nil), "milvus.proto.data.DropVirtualChannelResponse")
 }
 
 func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
 
 var fileDescriptor_82cd95f524594f49 = []byte{
-	// 2631 bytes of a gzipped FileDescriptorProto
+	// 2758 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x5b, 0x6f, 0x1b, 0xc7,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xdf, 0x6f, 0x1b, 0xc7,
-	0x15, 0xf6, 0xf2, 0x22, 0x91, 0x87, 0x14, 0x45, 0x8f, 0x1d, 0x99, 0x65, 0x1c, 0x59, 0xde, 0x24,
+	0xf1, 0xf7, 0xf1, 0x87, 0x44, 0x0e, 0x29, 0x8a, 0x5e, 0x39, 0x32, 0xc3, 0x38, 0xb2, 0x7c, 0x49,
-	0xb6, 0xec, 0x38, 0x92, 0x2d, 0x37, 0x68, 0x50, 0x27, 0x0d, 0x2c, 0xcb, 0x56, 0x89, 0x4a, 0xae,
+	0x1c, 0xc5, 0x71, 0x24, 0x5b, 0xfe, 0x06, 0xdf, 0xa0, 0x4e, 0x1a, 0x58, 0x96, 0x2d, 0x13, 0x95,
-	0xba, 0x54, 0xe2, 0xa2, 0x01, 0x4a, 0xac, 0xb8, 0x23, 0x6a, 0x6b, 0xee, 0x2e, 0xbd, 0x33, 0x94,
+	0x5c, 0xe5, 0xa8, 0xd8, 0x45, 0x03, 0x94, 0x38, 0xf1, 0x56, 0xd4, 0xd5, 0xbc, 0x3b, 0xfa, 0x6e,
-	0xad, 0xbc, 0xc4, 0x48, 0x81, 0x02, 0x2d, 0xda, 0xa6, 0x45, 0x1f, 0x5b, 0xa0, 0x45, 0x9f, 0x0a,
+	0x29, 0x5b, 0x79, 0x89, 0x91, 0x02, 0x05, 0x5a, 0xb4, 0x4d, 0x8a, 0xbe, 0x16, 0x68, 0xd1, 0xa7,
-	0xf4, 0xa5, 0xe8, 0x63, 0xfb, 0x07, 0x8a, 0xf6, 0xbd, 0x7f, 0xa3, 0x7f, 0xa1, 0x98, 0xcb, 0xce,
+	0x02, 0x7d, 0x29, 0xfa, 0x98, 0xfe, 0x03, 0x45, 0xfb, 0xde, 0xbf, 0xa1, 0x6f, 0xfd, 0x17, 0x8a,
-	0x5e, 0xb8, 0x24, 0x57, 0x92, 0x2f, 0x6f, 0x9c, 0xd9, 0x73, 0x9b, 0x33, 0xe7, 0x7c, 0x73, 0xce,
+	0xfd, 0x71, 0x7b, 0x3f, 0x78, 0x47, 0x1e, 0x25, 0xff, 0x78, 0xe3, 0xee, 0xcd, 0xce, 0xcc, 0xce,
-	0x0c, 0xa1, 0x6e, 0x99, 0xd4, 0xec, 0x74, 0x3d, 0xcf, 0xb7, 0x56, 0x06, 0xbe, 0x47, 0x3d, 0x74,
+	0xce, 0x7c, 0x66, 0x66, 0x97, 0x50, 0x37, 0x74, 0xa2, 0x77, 0xba, 0x8e, 0xe3, 0x1a, 0xab, 0x03,
-	0xd6, 0xb1, 0xfb, 0x87, 0x43, 0x22, 0x46, 0x2b, 0xec, 0x73, 0xb3, 0xda, 0xf5, 0x1c, 0xc7, 0x73,
+	0xd7, 0x21, 0x0e, 0x3a, 0x6b, 0x99, 0xfd, 0xa3, 0xa1, 0xc7, 0x47, 0xab, 0xf4, 0x73, 0xb3, 0xda,
-	0xc5, 0x54, 0xb3, 0x66, 0xbb, 0x14, 0xfb, 0xae, 0xd9, 0x97, 0xe3, 0x6a, 0x94, 0xa1, 0x59, 0x25,
+	0x75, 0x2c, 0xcb, 0xb1, 0xf9, 0x54, 0xb3, 0x66, 0xda, 0x04, 0xbb, 0xb6, 0xde, 0x17, 0xe3, 0x6a,
-	0xdd, 0x03, 0xec, 0x98, 0x62, 0xa4, 0x3f, 0x83, 0xea, 0x83, 0xfe, 0x90, 0x1c, 0x18, 0xf8, 0xc9,
+	0x78, 0x41, 0xb3, 0xea, 0x75, 0x0f, 0xb1, 0xa5, 0xf3, 0x91, 0xfa, 0x14, 0xaa, 0x77, 0xfb, 0x43,
-	0x10, 0x13, 0x8a, 0x6e, 0x42, 0x61, 0xcf, 0x24, 0xb8, 0xa1, 0x2d, 0x69, 0xcb, 0x95, 0xb5, 0x8b,
+	0xef, 0x50, 0xc3, 0x8f, 0x87, 0xd8, 0x23, 0xe8, 0x1a, 0x14, 0xf6, 0x75, 0x0f, 0x37, 0x94, 0x65,
-	0x2b, 0x31, 0x5d, 0x52, 0xcb, 0x36, 0xe9, 0xad, 0x9b, 0x04, 0x1b, 0x9c, 0x12, 0x21, 0x28, 0x58,
+	0x65, 0xa5, 0xb2, 0x7e, 0x61, 0x35, 0x22, 0x4b, 0x48, 0xd9, 0xf1, 0x7a, 0x1b, 0xba, 0x87, 0x35,
-	0x7b, 0xad, 0x8d, 0x46, 0x6e, 0x49, 0x5b, 0xce, 0x1b, 0xfc, 0x37, 0xd2, 0xa1, 0xda, 0xf5, 0xfa,
+	0x46, 0x89, 0x10, 0x14, 0x8c, 0xfd, 0xd6, 0x66, 0x23, 0xb7, 0xac, 0xac, 0xe4, 0x35, 0xf6, 0x1b,
-	0x7d, 0xdc, 0xa5, 0xb6, 0xe7, 0xb6, 0x36, 0x1a, 0x05, 0xfe, 0x2d, 0x36, 0xa7, 0xff, 0x41, 0x83,
+	0xa9, 0x50, 0xed, 0x3a, 0xfd, 0x3e, 0xee, 0x12, 0xd3, 0xb1, 0x5b, 0x9b, 0x8d, 0x02, 0xfb, 0x16,
-	0x39, 0xa9, 0x9a, 0x0c, 0x3c, 0x97, 0x60, 0x74, 0x1b, 0x66, 0x08, 0x35, 0xe9, 0x90, 0x48, 0xed,
+	0x99, 0x53, 0x7f, 0xaf, 0xc0, 0x9c, 0x10, 0xed, 0x0d, 0x1c, 0xdb, 0xc3, 0xe8, 0x06, 0xcc, 0x78,
-	0x6f, 0xa6, 0x6a, 0x6f, 0x73, 0x12, 0x43, 0x92, 0x66, 0x52, 0x9f, 0x1f, 0x55, 0x8f, 0x16, 0x01,
+	0x44, 0x27, 0x43, 0x4f, 0x48, 0x7f, 0x23, 0x51, 0x7a, 0x9b, 0x91, 0x68, 0x82, 0x34, 0x93, 0xf8,
-	0x08, 0xee, 0x39, 0xd8, 0xa5, 0xad, 0x0d, 0xd2, 0x28, 0x2c, 0xe5, 0x97, 0xf3, 0x46, 0x64, 0x46,
+	0xfc, 0xa8, 0x78, 0xb4, 0x04, 0xe0, 0xe1, 0x9e, 0x85, 0x6d, 0xd2, 0xda, 0xf4, 0x1a, 0x85, 0xe5,
-	0xff, 0xad, 0x06, 0xf5, 0x76, 0x30, 0x0c, 0xbc, 0x73, 0x1e, 0x8a, 0x5d, 0x6f, 0xe8, 0x52, 0x6e,
+	0xfc, 0x4a, 0x5e, 0x0b, 0xcd, 0xa8, 0xbf, 0x55, 0xa0, 0xde, 0xf6, 0x87, 0xbe, 0x75, 0xce, 0x41,
-	0xe0, 0x9c, 0x21, 0x06, 0xe8, 0x32, 0x54, 0xbb, 0x07, 0xa6, 0xeb, 0xe2, 0x7e, 0xc7, 0x35, 0x1d,
+	0xb1, 0xeb, 0x0c, 0x6d, 0xc2, 0x14, 0x9c, 0xd3, 0xf8, 0x00, 0x5d, 0x82, 0x6a, 0xf7, 0x50, 0xb7,
-	0xcc, 0x4d, 0x29, 0x1b, 0x15, 0x39, 0xf7, 0xd0, 0x74, 0x70, 0x26, 0x8b, 0x96, 0xa0, 0x32, 0x30,
+	0x6d, 0xdc, 0xef, 0xd8, 0xba, 0x85, 0x99, 0x2a, 0x65, 0xad, 0x22, 0xe6, 0xee, 0xeb, 0x16, 0xce,
-	0x7d, 0x6a, 0xc7, 0x7c, 0x16, 0x9d, 0xd2, 0xff, 0xa4, 0xc1, 0xc2, 0x5d, 0x42, 0xec, 0x9e, 0x3b,
+	0xa4, 0xd1, 0x32, 0x54, 0x06, 0xba, 0x4b, 0xcc, 0x88, 0xcd, 0xc2, 0x53, 0xea, 0x1f, 0x15, 0x58,
-	0x62, 0xd9, 0x02, 0xcc, 0xb8, 0x9e, 0x85, 0x5b, 0x1b, 0xdc, 0xb4, 0xbc, 0x21, 0x47, 0xe8, 0x4d,
+	0xbc, 0xe5, 0x79, 0x66, 0xcf, 0x1e, 0xd1, 0x6c, 0x11, 0x66, 0x6c, 0xc7, 0xc0, 0xad, 0x4d, 0xa6,
-	0x28, 0x0f, 0x30, 0xf6, 0x3b, 0xbe, 0xd7, 0x0f, 0x0c, 0x2b, 0xb1, 0x09, 0xc3, 0xeb, 0x63, 0xf4,
+	0x5a, 0x5e, 0x13, 0x23, 0xf4, 0x06, 0x94, 0x07, 0x18, 0xbb, 0x1d, 0xd7, 0xe9, 0xfb, 0x8a, 0x95,
-	0x03, 0x38, 0x4b, 0x12, 0x82, 0x48, 0x23, 0xbf, 0x94, 0x5f, 0xae, 0xac, 0xbd, 0xbd, 0x32, 0x12,
+	0xe8, 0x84, 0xe6, 0xf4, 0x31, 0xfa, 0x0c, 0xce, 0x7a, 0x31, 0x46, 0x5e, 0x23, 0xbf, 0x9c, 0x5f,
-	0x65, 0x2b, 0x49, 0xa5, 0xc6, 0x28, 0xb7, 0xfe, 0x3c, 0x07, 0xe7, 0x14, 0x9d, 0xb0, 0x95, 0xfd,
+	0xa9, 0xac, 0xbf, 0xb5, 0x3a, 0xe2, 0x65, 0xab, 0x71, 0xa1, 0xda, 0xe8, 0x6a, 0xf5, 0x59, 0x0e,
-	0x66, 0x9e, 0x23, 0xb8, 0xa7, 0xcc, 0x13, 0x83, 0x2c, 0x9e, 0x53, 0x2e, 0xcf, 0x47, 0x5d, 0x9e,
+	0x16, 0x24, 0x1d, 0xd7, 0x95, 0xfe, 0xa6, 0x96, 0xf3, 0x70, 0x4f, 0xaa, 0xc7, 0x07, 0x59, 0x2c,
-	0x21, 0xc0, 0x92, 0xfe, 0x2c, 0x8e, 0xf8, 0x13, 0x5d, 0x82, 0x0a, 0x7e, 0x36, 0xb0, 0x7d, 0xdc,
+	0x27, 0x4d, 0x9e, 0x0f, 0x9b, 0x3c, 0x83, 0x83, 0xc5, 0xed, 0x59, 0x1c, 0xb1, 0x27, 0xba, 0x08,
-	0xa1, 0xb6, 0x83, 0x1b, 0x33, 0x4b, 0xda, 0x72, 0xc1, 0x00, 0x31, 0xb5, 0x6b, 0x3b, 0xd1, 0x88,
+	0x15, 0xfc, 0x74, 0x60, 0xba, 0xb8, 0x43, 0x4c, 0x0b, 0x37, 0x66, 0x96, 0x95, 0x95, 0x82, 0x06,
-	0x9c, 0xcd, 0x1c, 0x91, 0xfa, 0x9f, 0x35, 0xb8, 0x30, 0xb2, 0x4b, 0x32, 0xc4, 0x0d, 0xa8, 0xf3,
+	0x7c, 0x6a, 0xcf, 0xb4, 0xc2, 0x1e, 0x39, 0x9b, 0xd9, 0x23, 0xd5, 0x3f, 0x29, 0x70, 0x7e, 0xe4,
-	0x95, 0x87, 0x9e, 0x61, 0xc1, 0xce, 0x1c, 0x7e, 0x65, 0x92, 0xc3, 0x43, 0x72, 0x63, 0x84, 0x3f,
+	0x94, 0x84, 0x8b, 0x6b, 0x50, 0x67, 0x3b, 0x0f, 0x2c, 0x43, 0x9d, 0x9d, 0x1a, 0xfc, 0xf2, 0x38,
-	0x62, 0x64, 0x2e, 0xbb, 0x91, 0x8f, 0xe1, 0xc2, 0x26, 0xa6, 0x52, 0x01, 0xfb, 0x86, 0xc9, 0xc9,
+	0x83, 0x07, 0xe4, 0xda, 0xc8, 0xfa, 0x90, 0x92, 0xb9, 0xec, 0x4a, 0x3e, 0x82, 0xf3, 0x5b, 0x98,
-	0x21, 0x20, 0x9e, 0x4b, 0xb9, 0x91, 0x5c, 0xfa, 0x5b, 0x4e, 0xe5, 0x12, 0x57, 0xd5, 0x72, 0xf7,
+	0x08, 0x01, 0xf4, 0x1b, 0xf6, 0x4e, 0x0e, 0x01, 0xd1, 0x58, 0xca, 0x8d, 0xc4, 0xd2, 0x5f, 0x73,
-	0x3d, 0x74, 0x11, 0xca, 0x8a, 0x44, 0x46, 0x45, 0x38, 0x81, 0xbe, 0x05, 0x45, 0x66, 0xa9, 0x08,
+	0x32, 0x96, 0x98, 0xa8, 0x96, 0x7d, 0xe0, 0xa0, 0x0b, 0x50, 0x96, 0x24, 0xc2, 0x2b, 0x82, 0x09,
-	0x89, 0xda, 0xda, 0xe5, 0xf4, 0x35, 0x45, 0x64, 0x1a, 0x82, 0x1e, 0xb5, 0xa0, 0x46, 0xa8, 0xe9,
+	0xf4, 0xff, 0x50, 0xa4, 0x9a, 0x72, 0x97, 0xa8, 0xad, 0x5f, 0x4a, 0xde, 0x53, 0x88, 0xa7, 0xc6,
-	0xd3, 0xce, 0xc0, 0x23, 0x7c, 0x9f, 0x79, 0xe0, 0x54, 0xd6, 0xf4, 0xb8, 0x04, 0x05, 0x91, 0xdb,
+	0xe9, 0x51, 0x0b, 0x6a, 0x1e, 0xd1, 0x5d, 0xd2, 0x19, 0x38, 0x1e, 0x3b, 0x67, 0xe6, 0x38, 0x95,
-	0xa4, 0xb7, 0x23, 0x29, 0x8d, 0x39, 0xce, 0x19, 0x0c, 0xd1, 0x7d, 0xa8, 0x62, 0xd7, 0x0a, 0x05,
+	0x75, 0x35, 0xca, 0x41, 0x42, 0xe4, 0x8e, 0xd7, 0xdb, 0x15, 0x94, 0xda, 0x1c, 0x5b, 0xe9, 0x0f,
-	0x15, 0x32, 0x0b, 0xaa, 0x60, 0xd7, 0x52, 0x62, 0xc2, 0xfd, 0x29, 0x66, 0xdf, 0x9f, 0x5f, 0x6a,
+	0xd1, 0x1d, 0xa8, 0x62, 0xdb, 0x08, 0x18, 0x15, 0x32, 0x33, 0xaa, 0x60, 0xdb, 0x90, 0x6c, 0x82,
-	0xd0, 0x18, 0xdd, 0xa0, 0xd3, 0x00, 0xe5, 0x1d, 0xc1, 0x84, 0xc5, 0x06, 0x4d, 0xcc, 0x70, 0xb5,
+	0xf3, 0x29, 0x66, 0x3f, 0x9f, 0x5f, 0x29, 0xd0, 0x18, 0x3d, 0xa0, 0xd3, 0x00, 0xe5, 0x4d, 0xbe,
-	0x49, 0x86, 0x64, 0xd1, 0x6d, 0x78, 0x23, 0xb4, 0x86, 0x7f, 0x79, 0x69, 0xc1, 0xf2, 0x53, 0x0d,
+	0x08, 0xf3, 0x03, 0x1a, 0x1b, 0xe1, 0xf2, 0x90, 0x34, 0xb1, 0x44, 0x35, 0xe1, 0xb5, 0x40, 0x1b,
-	0x16, 0x92, 0xba, 0x4e, 0xb3, 0xee, 0x6f, 0x42, 0xd1, 0x76, 0xf7, 0xbd, 0x60, 0xd9, 0x8b, 0x13,
+	0xf6, 0xe5, 0x85, 0x39, 0xcb, 0xcf, 0x14, 0x58, 0x8c, 0xcb, 0x3a, 0xcd, 0xbe, 0xff, 0x0f, 0x8a,
-	0xf2, 0x8c, 0xe9, 0x12, 0xc4, 0xba, 0x03, 0x6f, 0x6e, 0x62, 0xda, 0x72, 0x09, 0xf6, 0xe9, 0xba,
+	0xa6, 0x7d, 0xe0, 0xf8, 0xdb, 0x5e, 0x1a, 0x13, 0x67, 0x54, 0x16, 0x27, 0x56, 0x2d, 0x78, 0x63,
-	0xed, 0xf6, 0xbd, 0xde, 0x8e, 0x49, 0x0f, 0x4e, 0x91, 0x23, 0xb1, 0x70, 0xcf, 0x25, 0xc2, 0x5d,
+	0x0b, 0x93, 0x96, 0xed, 0x61, 0x97, 0x6c, 0x98, 0x76, 0xdf, 0xe9, 0xed, 0xea, 0xe4, 0xf0, 0x14,
-	0xff, 0x8b, 0x06, 0x17, 0xd3, 0xf5, 0xc9, 0xa5, 0x37, 0xa1, 0xb4, 0x6f, 0xe3, 0xbe, 0xc5, 0x7c,
+	0x31, 0x12, 0x71, 0xf7, 0x5c, 0xcc, 0xdd, 0xd5, 0x3f, 0x2b, 0x70, 0x21, 0x59, 0x9e, 0xd8, 0x7a,
-	0xa6, 0x71, 0x9f, 0xa9, 0x31, 0xcb, 0x95, 0x01, 0x23, 0x96, 0x2b, 0xbc, 0x3c, 0x26, 0x40, 0xdb,
+	0x13, 0x4a, 0x07, 0x26, 0xee, 0x1b, 0xd4, 0x66, 0x0a, 0xb3, 0x99, 0x1c, 0xd3, 0x58, 0x19, 0x50,
-	0xd4, 0xb7, 0xdd, 0xde, 0x96, 0x4d, 0xa8, 0x21, 0xe8, 0x23, 0xfe, 0xcc, 0x67, 0x8f, 0xcc, 0x5f,
+	0x62, 0xb1, 0xc3, 0x4b, 0x29, 0x0e, 0xda, 0x26, 0xae, 0x69, 0xf7, 0xb6, 0x4d, 0x8f, 0x68, 0x9c,
-	0x68, 0xb0, 0xb8, 0x89, 0xe9, 0x3d, 0x05, 0xb5, 0xec, 0xbb, 0x4d, 0xa8, 0xdd, 0x25, 0x2f, 0xb7,
+	0x3e, 0x64, 0xcf, 0x7c, 0x76, 0xcf, 0xfc, 0xa5, 0x02, 0x4b, 0x5b, 0x98, 0xdc, 0x96, 0x50, 0x4b,
-	0x88, 0x48, 0x39, 0x33, 0xf5, 0xaf, 0x35, 0xb8, 0x34, 0xd6, 0x18, 0xe9, 0x3a, 0x09, 0x25, 0x01,
+	0xbf, 0x9b, 0x1e, 0x31, 0xbb, 0xde, 0x8b, 0x2d, 0x22, 0x12, 0x72, 0xa6, 0xfa, 0x8d, 0x02, 0x17,
-	0xd0, 0xa6, 0x43, 0xc9, 0xf7, 0xf0, 0xd1, 0x67, 0x66, 0x7f, 0x88, 0x77, 0x4c, 0xdb, 0x17, 0x50,
+	0x53, 0x95, 0x11, 0xa6, 0x13, 0x50, 0xe2, 0x03, 0x6d, 0x32, 0x94, 0xfc, 0x00, 0x1f, 0x3f, 0xd0,
-	0x72, 0x42, 0x60, 0xfd, 0xab, 0x06, 0x6f, 0x6d, 0x62, 0xba, 0x13, 0x1c, 0x33, 0xaf, 0xd1, 0x3b,
+	0xfb, 0x43, 0xbc, 0xab, 0x9b, 0x2e, 0x87, 0x92, 0x13, 0x02, 0xeb, 0x5f, 0x14, 0x78, 0x73, 0x0b,
-	0x19, 0x2a, 0x8a, 0x5f, 0x8b, 0xcd, 0x4c, 0xb5, 0xf6, 0xb5, 0xb8, 0x6f, 0x91, 0xe7, 0x41, 0x24,
+	0x93, 0x5d, 0x3f, 0xcd, 0xbc, 0x42, 0xeb, 0x64, 0xa8, 0x28, 0x7e, 0xc3, 0x0f, 0x33, 0x51, 0xdb,
-	0x21, 0xef, 0x89, 0x5a, 0x40, 0x3a, 0x4f, 0x7f, 0x9e, 0x87, 0xea, 0x67, 0xb2, 0x3e, 0xe0, 0xc7,
+	0x57, 0x62, 0xbe, 0x25, 0x16, 0x07, 0xa1, 0x80, 0xbc, 0xcd, 0x6b, 0x01, 0x61, 0x3c, 0xf5, 0x59,
-	0x48, 0xd2, 0x0f, 0x5a, 0xba, 0x1f, 0x22, 0x25, 0x45, 0x5a, 0x95, 0xb1, 0x09, 0x73, 0x04, 0xe3,
+	0x1e, 0xaa, 0x0f, 0x44, 0x7d, 0xc0, 0xd2, 0x48, 0xdc, 0x0e, 0x4a, 0xb2, 0x1d, 0x42, 0x25, 0x45,
-	0xc7, 0x27, 0x39, 0x34, 0xaa, 0x8c, 0x51, 0x81, 0xfd, 0x16, 0x9c, 0x1d, 0xba, 0xfb, 0xac, 0xac,
+	0x52, 0x95, 0xb1, 0x05, 0x73, 0x1e, 0xc6, 0x8f, 0x4e, 0x92, 0x34, 0xaa, 0x74, 0xa1, 0x04, 0xfb,
-	0xc5, 0x96, 0x5c, 0x85, 0xa8, 0x2e, 0xa7, 0x23, 0xcf, 0x28, 0x23, 0xfa, 0x2e, 0xcc, 0x27, 0x65,
+	0x6d, 0x38, 0x3b, 0xb4, 0x0f, 0x68, 0x59, 0x8b, 0x0d, 0xb1, 0x0b, 0x5e, 0x5d, 0x4e, 0x46, 0x9e,
-	0x15, 0x33, 0xc9, 0x4a, 0xb2, 0xa1, 0x16, 0xd4, 0x2d, 0xdf, 0x1b, 0x0c, 0xb0, 0xd5, 0x21, 0x81,
+	0xd1, 0x85, 0xe8, 0x1e, 0xcc, 0xc7, 0x79, 0x15, 0x33, 0xf1, 0x8a, 0x2f, 0x43, 0x2d, 0xa8, 0x1b,
-	0xa8, 0x99, 0x6c, 0xa2, 0x24, 0x5f, 0x20, 0x4a, 0xff, 0xb9, 0x06, 0x0b, 0x8f, 0x4c, 0xda, 0x3d,
+	0xae, 0x33, 0x18, 0x60, 0xa3, 0xe3, 0xf9, 0xac, 0x66, 0xb2, 0xb1, 0x12, 0xeb, 0x7c, 0x56, 0xea,
-	0xd8, 0x70, 0xe4, 0xe6, 0x9c, 0x22, 0xb4, 0x3f, 0x86, 0xf2, 0xa1, 0xdc, 0x88, 0x00, 0xbf, 0x2e,
+	0x2f, 0x14, 0x58, 0x7c, 0xa8, 0x93, 0xee, 0xe1, 0xa6, 0x25, 0x0e, 0xe7, 0x14, 0xae, 0xfd, 0x09,
-	0xa5, 0x18, 0x14, 0xdd, 0x72, 0x23, 0xe4, 0xd0, 0xff, 0xa5, 0xc1, 0x79, 0xde, 0x44, 0x04, 0xd6,
+	0x94, 0x8f, 0xc4, 0x41, 0xf8, 0xf8, 0x75, 0x31, 0x41, 0xa1, 0xf0, 0x91, 0x6b, 0xc1, 0x0a, 0xf5,
-	0xbd, 0xfa, 0x24, 0x9b, 0xd2, 0x48, 0xa0, 0x2b, 0x50, 0x73, 0x4c, 0xff, 0x71, 0x3b, 0xa4, 0x29,
+	0x1f, 0x0a, 0x9c, 0x63, 0x4d, 0x84, 0xaf, 0xdd, 0xcb, 0x0f, 0xb2, 0x09, 0x8d, 0x04, 0xba, 0x0c,
-	0x72, 0x9a, 0xc4, 0xac, 0xfe, 0x0c, 0x40, 0x8e, 0xb6, 0x49, 0xef, 0x04, 0xf6, 0x7f, 0x08, 0xb3,
+	0x35, 0x4b, 0x77, 0x1f, 0xb5, 0x03, 0x9a, 0x22, 0xa3, 0x89, 0xcd, 0xaa, 0x4f, 0x01, 0xc4, 0x68,
-	0x52, 0xab, 0xcc, 0xb7, 0x69, 0x1b, 0x1b, 0x90, 0xeb, 0xff, 0xd6, 0xa0, 0x16, 0x22, 0x28, 0xcf,
+	0xc7, 0xeb, 0x9d, 0x40, 0xff, 0x8f, 0x60, 0x56, 0x48, 0x15, 0xf1, 0x36, 0xe9, 0x60, 0x7d, 0x72,
-	0xaa, 0x1a, 0xe4, 0x54, 0x2e, 0xe5, 0x5a, 0x1b, 0xe8, 0x63, 0x98, 0x11, 0x6d, 0xa3, 0x94, 0xfd,
+	0xf5, 0x9f, 0x0a, 0xd4, 0x02, 0x04, 0x65, 0x51, 0x55, 0x83, 0x9c, 0x8c, 0xa5, 0x5c, 0x6b, 0x13,
-	0x6e, 0x5c, 0xb6, 0x6c, 0x29, 0x23, 0x30, 0xcc, 0x27, 0x0c, 0xc9, 0xc4, 0x7c, 0xa4, 0x50, 0x47,
+	0x7d, 0x02, 0x33, 0xbc, 0x6d, 0x14, 0xbc, 0xdf, 0x89, 0xf2, 0x16, 0x2d, 0x65, 0x08, 0x86, 0xd9,
-	0x74, 0x18, 0x79, 0x23, 0x32, 0x83, 0x5a, 0x30, 0x1f, 0x2f, 0xda, 0x82, 0x9c, 0x59, 0x1a, 0x87,
+	0x84, 0x26, 0x16, 0x51, 0x1b, 0x49, 0xd4, 0xe1, 0x1d, 0x46, 0x5e, 0x0b, 0xcd, 0xa0, 0x16, 0xcc,
-	0x36, 0x1b, 0x26, 0x35, 0x39, 0xd8, 0xd4, 0x62, 0x35, 0x1b, 0xd1, 0xff, 0x57, 0x84, 0x4a, 0x64,
+	0x47, 0x8b, 0x36, 0x3f, 0x66, 0x96, 0xd3, 0xd0, 0x66, 0x53, 0x27, 0x3a, 0x03, 0x9b, 0x5a, 0xa4,
-	0x95, 0x23, 0x2b, 0x49, 0x6e, 0x69, 0x6e, 0x3a, 0x6e, 0xe6, 0x47, 0x3b, 0x87, 0x77, 0xa1, 0x66,
+	0x66, 0xf3, 0xd4, 0xff, 0x16, 0xa1, 0x12, 0xda, 0xe5, 0xc8, 0x4e, 0xe2, 0x47, 0x9a, 0x9b, 0x8c,
-	0xf3, 0xb3, 0xba, 0x23, 0x43, 0x91, 0x83, 0x6b, 0xd9, 0x98, 0x13, 0xb3, 0x32, 0x2f, 0xd0, 0x22,
+	0x9b, 0xf9, 0xd1, 0xce, 0xe1, 0x1d, 0xa8, 0x99, 0x2c, 0x57, 0x77, 0x84, 0x2b, 0x32, 0x70, 0x2d,
-	0x54, 0xdc, 0xa1, 0xd3, 0xf1, 0xf6, 0x3b, 0xbe, 0xf7, 0x94, 0xc8, 0x16, 0xa4, 0xec, 0x0e, 0x9d,
+	0x6b, 0x73, 0x7c, 0x56, 0xc4, 0x05, 0x5a, 0x82, 0x8a, 0x3d, 0xb4, 0x3a, 0xce, 0x41, 0xc7, 0x75,
-	0xef, 0xef, 0x1b, 0xde, 0x53, 0x12, 0x56, 0xb9, 0x33, 0xc7, 0xac, 0x72, 0x17, 0xa1, 0xe2, 0x98,
+	0x9e, 0x78, 0xa2, 0x05, 0x29, 0xdb, 0x43, 0xeb, 0x87, 0x07, 0x9a, 0xf3, 0xc4, 0x0b, 0xaa, 0xdc,
-	0xcf, 0x98, 0xd4, 0x8e, 0x3b, 0x74, 0x78, 0x77, 0x92, 0x37, 0xca, 0x8e, 0xf9, 0xcc, 0xf0, 0x9e,
+	0x99, 0x29, 0xab, 0xdc, 0x25, 0xa8, 0x58, 0xfa, 0x53, 0xca, 0xb5, 0x63, 0x0f, 0x2d, 0xd6, 0x9d,
-	0x3e, 0x1c, 0x3a, 0x68, 0x19, 0xea, 0x7d, 0x93, 0xd0, 0x4e, 0xb4, 0xbd, 0x29, 0xf1, 0xf6, 0xa6,
+	0xe4, 0xb5, 0xb2, 0xa5, 0x3f, 0xd5, 0x9c, 0x27, 0xf7, 0x87, 0x16, 0x5a, 0x81, 0x7a, 0x5f, 0xf7,
-	0xc6, 0xe6, 0xef, 0x87, 0x2d, 0xce, 0x68, 0xbd, 0x5c, 0x3e, 0x45, 0xbd, 0x6c, 0x39, 0xfd, 0x50,
+	0x48, 0x27, 0xdc, 0xde, 0x94, 0x58, 0x7b, 0x53, 0xa3, 0xf3, 0x77, 0x82, 0x16, 0x67, 0xb4, 0x5e,
-	0x10, 0x64, 0xaf, 0x97, 0x2d, 0xa7, 0xaf, 0xc4, 0x7c, 0x08, 0xb3, 0x7b, 0xbc, 0x02, 0x22, 0x8d,
+	0x2e, 0x9f, 0xa2, 0x5e, 0x36, 0xac, 0x7e, 0xc0, 0x08, 0xb2, 0xd7, 0xcb, 0x86, 0xd5, 0x97, 0x6c,
-	0xca, 0x58, 0x84, 0x7a, 0xc0, 0x8a, 0x1f, 0x51, 0x28, 0x19, 0x01, 0x39, 0xfa, 0x08, 0xca, 0xfc,
+	0x3e, 0x82, 0xd9, 0x7d, 0x56, 0x01, 0x79, 0x8d, 0x4a, 0x2a, 0x42, 0xdd, 0xa5, 0xc5, 0x0f, 0x2f,
-	0xe8, 0xe1, 0xbc, 0xd5, 0x4c, 0xbc, 0x21, 0x03, 0x83, 0x22, 0x0b, 0xf7, 0xa9, 0xc9, 0xb9, 0xe7,
+	0x94, 0x34, 0x9f, 0x1c, 0x7d, 0x0c, 0x65, 0x96, 0x7a, 0xd8, 0xda, 0x6a, 0xa6, 0xb5, 0xc1, 0x02,
-	0xc6, 0x42, 0xd1, 0x06, 0xa3, 0xd9, 0xf2, 0x7a, 0x02, 0x8a, 0x14, 0x07, 0xba, 0x09, 0xe7, 0xba,
+	0x0a, 0x45, 0x06, 0xee, 0x13, 0x9d, 0xad, 0x9e, 0x4b, 0x85, 0xa2, 0x4d, 0x4a, 0xb3, 0xed, 0xf4,
-	0x3e, 0x36, 0x29, 0xb6, 0xd6, 0x8f, 0xee, 0x79, 0xce, 0xc0, 0xe4, 0xd1, 0xd4, 0xa8, 0x2d, 0x69,
+	0x38, 0x14, 0xc9, 0x15, 0xe8, 0x1a, 0x2c, 0x74, 0x5d, 0xac, 0x13, 0x6c, 0x6c, 0x1c, 0xdf, 0x76,
-	0xcb, 0x25, 0x23, 0xed, 0x13, 0x43, 0x86, 0xae, 0x1a, 0x3d, 0xf0, 0x3d, 0xa7, 0x31, 0x2f, 0x90,
+	0xac, 0x81, 0xce, 0xbc, 0xa9, 0x51, 0x5b, 0x56, 0x56, 0x4a, 0x5a, 0xd2, 0x27, 0x8a, 0x0c, 0x5d,
-	0x21, 0x3e, 0x8b, 0xde, 0x02, 0x08, 0xb0, 0xdb, 0xa4, 0x8d, 0x3a, 0xdf, 0xc6, 0xb2, 0x9c, 0xb9,
+	0x39, 0xba, 0xeb, 0x3a, 0x56, 0x63, 0x9e, 0x23, 0x43, 0x74, 0x16, 0xbd, 0x09, 0xe0, 0x63, 0xb7,
-	0x4b, 0xf5, 0x2f, 0xe1, 0x7c, 0x18, 0x22, 0x91, 0xed, 0x18, 0xdd, 0x59, 0xed, 0xa4, 0x3b, 0x3b,
+	0x4e, 0x1a, 0x75, 0x76, 0x8c, 0x65, 0x31, 0x73, 0x8b, 0xa8, 0x5f, 0xc1, 0xb9, 0xc0, 0x45, 0x42,
-	0xb9, 0x78, 0xfd, 0x7b, 0x01, 0x16, 0xda, 0xe6, 0x21, 0x7e, 0xf9, 0x75, 0x72, 0x26, 0x40, 0xde,
+	0xc7, 0x31, 0x7a, 0xb2, 0xca, 0x49, 0x4f, 0x76, 0x7c, 0xf1, 0xfa, 0xb7, 0x02, 0x2c, 0xb6, 0xf5,
-	0x82, 0xb3, 0xbc, 0x34, 0x5e, 0x8b, 0xd8, 0x33, 0xe1, 0x08, 0x8e, 0x46, 0xc3, 0x28, 0x23, 0xfa,
+	0x23, 0xfc, 0xe2, 0xeb, 0xe4, 0x4c, 0x80, 0xbc, 0x0d, 0x67, 0x59, 0x69, 0xbc, 0x1e, 0xd2, 0x67,
-	0x84, 0xd5, 0x0e, 0xb8, 0xfb, 0x78, 0xc7, 0xb3, 0xc3, 0xe3, 0xf7, 0xad, 0x14, 0x39, 0xf7, 0x14,
+	0x4c, 0x0a, 0x0e, 0x7b, 0xc3, 0xe8, 0x42, 0xf4, 0x29, 0xad, 0x1d, 0x70, 0xf7, 0xd1, 0xae, 0x63,
-	0x95, 0x11, 0xe5, 0x40, 0x3b, 0xa3, 0xd8, 0x26, 0x0e, 0xde, 0xab, 0x13, 0x1b, 0xb0, 0xd0, 0xfb,
+	0x06, 0xe9, 0xf7, 0xcd, 0x04, 0x3e, 0xb7, 0x25, 0x95, 0x16, 0x5e, 0x81, 0x76, 0x47, 0xb1, 0x8d,
-	0x49, 0x88, 0x43, 0x0d, 0x98, 0x95, 0xc7, 0x3b, 0x4f, 0xfc, 0x92, 0x11, 0x0c, 0xd1, 0x0e, 0x9c,
+	0x27, 0xde, 0x77, 0xc7, 0x36, 0x60, 0x81, 0xf5, 0xe3, 0x10, 0x87, 0x1a, 0x30, 0x2b, 0xd2, 0x3b,
-	0x13, 0x2b, 0x68, 0xcb, 0xa8, 0x16, 0x8b, 0x2f, 0x65, 0x5a, 0x7c, 0x1a, 0x6b, 0x3c, 0x29, 0xca,
+	0x0b, 0xfc, 0x92, 0xe6, 0x0f, 0xd1, 0x2e, 0x2c, 0xf0, 0x1d, 0xb4, 0x85, 0x57, 0xf3, 0xcd, 0x97,
-	0xc7, 0x4e, 0x8a, 0x06, 0xcc, 0xca, 0x40, 0xe5, 0x68, 0x50, 0x32, 0x82, 0x21, 0x6b, 0x23, 0x20,
+	0x32, 0x6d, 0x3e, 0x69, 0x69, 0x34, 0x28, 0xca, 0x53, 0x07, 0x45, 0x03, 0x66, 0x85, 0xa3, 0x32,
-	0x74, 0xd9, 0x94, 0xdb, 0x80, 0xef, 0x40, 0x49, 0x05, 0x71, 0x2e, 0x73, 0x10, 0x2b, 0x9e, 0x24,
+	0x34, 0x28, 0x69, 0xfe, 0x90, 0xb6, 0x11, 0x10, 0x98, 0x6c, 0xc2, 0x6d, 0xc0, 0xf7, 0xa1, 0x24,
-	0x0e, 0xe7, 0x13, 0x38, 0xac, 0xff, 0x47, 0x83, 0x6a, 0x74, 0x09, 0x0c, 0xdf, 0x7d, 0xdc, 0xf5,
+	0x9d, 0x38, 0x97, 0xd9, 0x89, 0xe5, 0x9a, 0x38, 0x0e, 0xe7, 0x63, 0x38, 0xac, 0xfe, 0x4b, 0x81,
-	0x7c, 0xab, 0x83, 0x5d, 0xea, 0xdb, 0x58, 0x74, 0x9c, 0x05, 0x63, 0x4e, 0xcc, 0xde, 0x17, 0x93,
+	0x6a, 0x78, 0x0b, 0x14, 0xdf, 0x5d, 0xdc, 0x75, 0x5c, 0xa3, 0x83, 0x6d, 0xe2, 0x9a, 0x98, 0x77,
-	0x8c, 0x8c, 0x41, 0x2b, 0xa1, 0xa6, 0x33, 0xe8, 0xec, 0xb3, 0x0c, 0xce, 0x09, 0x32, 0x35, 0xcb,
+	0x9c, 0x05, 0x6d, 0x8e, 0xcf, 0xde, 0xe1, 0x93, 0x94, 0x8c, 0x42, 0xab, 0x47, 0x74, 0x6b, 0xd0,
-	0x13, 0xf8, 0x32, 0x54, 0x43, 0x32, 0xea, 0x71, 0xfd, 0x05, 0xa3, 0xa2, 0xe6, 0x76, 0x3d, 0xf4,
+	0x39, 0xa0, 0x11, 0x9c, 0xe3, 0x64, 0x72, 0x96, 0x05, 0xf0, 0x25, 0xa8, 0x06, 0x64, 0xc4, 0x61,
-	0x0e, 0xd4, 0xb8, 0xd7, 0x3a, 0x7d, 0xaf, 0xd7, 0x61, 0xdd, 0x99, 0x3c, 0x50, 0xaa, 0x96, 0x34,
+	0xf2, 0x0b, 0x5a, 0x45, 0xce, 0xed, 0x39, 0xe8, 0x6d, 0xa8, 0x31, 0xab, 0x75, 0xfa, 0x4e, 0xaf,
-	0x8b, 0x6d, 0x47, 0x9c, 0x8a, 0xd8, 0x5f, 0x60, 0x79, 0xa4, 0x28, 0xaa, 0xb6, 0xfd, 0x05, 0xd6,
+	0x43, 0xbb, 0x33, 0x91, 0x50, 0xaa, 0x86, 0x50, 0x8b, 0x1e, 0x47, 0x94, 0xca, 0x33, 0xbf, 0xc4,
-	0xbf, 0xd2, 0x60, 0x8e, 0x9d, 0x8f, 0x0f, 0x3d, 0x0b, 0xef, 0x9e, 0xb0, 0x9a, 0xc8, 0x70, 0x33,
+	0x22, 0xa5, 0x48, 0xaa, 0xb6, 0xf9, 0x25, 0x56, 0xbf, 0x56, 0x60, 0x8e, 0xe6, 0xc7, 0xfb, 0x8e,
-	0x77, 0x11, 0xca, 0x6a, 0x05, 0x72, 0x49, 0xe1, 0x04, 0x6b, 0xe3, 0xe7, 0xe4, 0x31, 0xd8, 0x56,
+	0x81, 0xf7, 0x4e, 0x58, 0x4d, 0x64, 0xb8, 0x99, 0xbb, 0x00, 0x65, 0xb9, 0x03, 0xb1, 0xa5, 0x60,
-	0x37, 0xb5, 0x5c, 0x94, 0xc6, 0x45, 0xf1, 0xdf, 0xe8, 0xdb, 0xf1, 0x6b, 0x9e, 0x77, 0x52, 0xf3,
+	0x82, 0xb6, 0xf1, 0x73, 0x22, 0x0d, 0xb6, 0xe5, 0x4d, 0x2d, 0x63, 0xa5, 0x30, 0x56, 0xec, 0x37,
-	0x8a, 0x0b, 0xe1, 0x15, 0x67, 0xec, 0x0c, 0xcc, 0xd2, 0x1f, 0x3e, 0x67, 0x1b, 0x2b, 0x5d, 0xc1,
+	0xfa, 0x5e, 0xf4, 0x9a, 0xe7, 0xed, 0xc4, 0xb8, 0x62, 0x4c, 0x58, 0xc5, 0x19, 0xc9, 0x81, 0x59,
-	0x37, 0xb6, 0x01, 0xb3, 0xa6, 0x65, 0xf9, 0x98, 0x10, 0x69, 0x47, 0x30, 0x64, 0x5f, 0x0e, 0xb1,
+	0xfa, 0xc3, 0x67, 0xf4, 0x60, 0x85, 0x29, 0xd8, 0xc1, 0x36, 0x60, 0x56, 0x37, 0x0c, 0x17, 0x7b,
-	0x4f, 0x82, 0x10, 0xcb, 0x1b, 0xc1, 0x10, 0x7d, 0x04, 0x25, 0x55, 0xa2, 0xe6, 0xd3, 0xca, 0x92,
+	0x9e, 0xd0, 0xc3, 0x1f, 0xd2, 0x2f, 0x47, 0xd8, 0xf5, 0x7c, 0x17, 0xcb, 0x6b, 0xfe, 0x10, 0x7d,
-	0xa8, 0x9d, 0xb2, 0x9f, 0x51, 0x1c, 0xfa, 0xd7, 0x39, 0xa8, 0xc9, 0xb4, 0x5e, 0x97, 0xe7, 0xd4,
+	0x0c, 0x25, 0x59, 0xa2, 0xe6, 0x93, 0xca, 0x92, 0xb0, 0x9e, 0xa2, 0x9f, 0x91, 0x2b, 0xd4, 0x6f,
-	0xe4, 0x60, 0x5f, 0x87, 0xea, 0x7e, 0x98, 0x96, 0x93, 0xee, 0x2d, 0xa2, 0xd9, 0x1b, 0xe3, 0x99,
+	0x72, 0x50, 0x13, 0x61, 0xbd, 0x21, 0xf2, 0xd4, 0x78, 0x67, 0xdf, 0x80, 0xea, 0x41, 0x10, 0x96,
-	0x16, 0xf0, 0xf1, 0x93, 0xb2, 0x70, 0xaa, 0x93, 0xb2, 0x78, 0x5c, 0x50, 0xd0, 0xef, 0x42, 0x25,
+	0xe3, 0xee, 0x2d, 0xc2, 0xd1, 0x1b, 0x59, 0x33, 0xc9, 0xe1, 0xa3, 0x99, 0xb2, 0x70, 0xaa, 0x4c,
-	0x22, 0x98, 0xc3, 0x99, 0xb8, 0xca, 0x90, 0xbe, 0x08, 0x86, 0xec, 0xcb, 0x5e, 0xc4, 0x09, 0x65,
+	0x59, 0x9c, 0x16, 0x14, 0xd4, 0x5b, 0x50, 0x09, 0x31, 0x66, 0x70, 0xc6, 0xaf, 0x32, 0x84, 0x2d,
-	0x75, 0xd2, 0xb3, 0xba, 0xff, 0xc2, 0x26, 0xa6, 0x06, 0xee, 0x7a, 0x87, 0xd8, 0x3f, 0x3a, 0xfd,
+	0xfc, 0x21, 0xfd, 0xb2, 0x1f, 0x32, 0x42, 0x59, 0x66, 0x7a, 0x5a, 0xf7, 0x9f, 0xdf, 0xc2, 0x44,
-	0x2d, 0xd1, 0x9d, 0xc8, 0x1e, 0x67, 0x6c, 0x43, 0x14, 0x03, 0xba, 0x13, 0xda, 0x99, 0x4f, 0x6b,
+	0xc3, 0x5d, 0xe7, 0x08, 0xbb, 0xc7, 0xa7, 0xbf, 0x25, 0xba, 0x19, 0x3a, 0xe3, 0x8c, 0x6d, 0x88,
-	0x92, 0xa3, 0xd0, 0x2e, 0x77, 0x28, 0x5c, 0xca, 0x6f, 0xc4, 0x7d, 0x57, 0x7c, 0x29, 0x27, 0x3d,
+	0x5c, 0x80, 0x6e, 0x06, 0x7a, 0xe6, 0x93, 0x9a, 0xe4, 0x30, 0xb4, 0x8b, 0x13, 0x0a, 0xb6, 0xf2,
-	0x3d, 0x5f, 0x48, 0x75, 0xab, 0xff, 0x4e, 0x83, 0x6f, 0x6c, 0x62, 0xfa, 0x20, 0xde, 0x43, 0xbe,
+	0x2d, 0xbf, 0xef, 0x8a, 0x6e, 0xe5, 0xa4, 0xd9, 0xf3, 0xb9, 0x54, 0xb7, 0xea, 0xef, 0x14, 0x78,
-	0x6e, 0xab, 0x1c, 0x68, 0xa6, 0x19, 0x75, 0x9a, 0x5d, 0x6f, 0x42, 0x49, 0x75, 0xc3, 0xe2, 0x26,
+	0x7d, 0x0b, 0x93, 0xbb, 0xd1, 0x1e, 0xf2, 0x55, 0x6b, 0x65, 0x41, 0x33, 0x49, 0xa9, 0xd3, 0x9c,
-	0x52, 0x8d, 0xf5, 0x9f, 0x69, 0xd0, 0x90, 0x5a, 0xb8, 0x4e, 0x56, 0xb8, 0xf5, 0x31, 0xc5, 0xd6,
+	0x7a, 0x13, 0x4a, 0xb2, 0x1b, 0xe6, 0x37, 0x91, 0x72, 0xac, 0xfe, 0x5c, 0x81, 0x86, 0x90, 0xc2,
-	0xab, 0x6e, 0xcf, 0xfe, 0xa8, 0x41, 0x3d, 0x0a, 0x82, 0x1c, 0xc7, 0x3e, 0x80, 0x22, 0xef, 0x82,
+	0x64, 0xd2, 0xc2, 0xad, 0x8f, 0x09, 0x36, 0x5e, 0x76, 0x7b, 0xf6, 0x07, 0x05, 0xea, 0x61, 0x10,
-	0xa5, 0x05, 0x53, 0x83, 0x55, 0x50, 0xb3, 0x8c, 0xe2, 0xc5, 0xc4, 0x2e, 0x09, 0x40, 0x4e, 0x0e,
+	0x64, 0x38, 0xf6, 0x21, 0x14, 0x59, 0x17, 0x2c, 0x34, 0x98, 0xe8, 0xac, 0x9c, 0x9a, 0x46, 0x14,
-	0x43, 0x24, 0xce, 0x1f, 0x1b, 0x89, 0xf5, 0x5f, 0xe5, 0xa0, 0x11, 0xd6, 0xb5, 0xaf, 0x1c, 0xec,
+	0x2b, 0x26, 0xf6, 0x3c, 0x1f, 0xe4, 0xc4, 0x30, 0x40, 0xe2, 0xfc, 0xd4, 0x48, 0xac, 0xfe, 0x3a,
-	0xc6, 0x54, 0x3d, 0xf9, 0x17, 0x54, 0xf5, 0x14, 0x8e, 0x0d, 0x70, 0xff, 0xcc, 0xb1, 0x86, 0x3a,
+	0x07, 0x8d, 0xa0, 0xae, 0x7d, 0xe9, 0x60, 0x97, 0x52, 0xf5, 0xe4, 0x9f, 0x53, 0xd5, 0x53, 0x98,
-	0xf0, 0xc7, 0x4e, 0xdf, 0x74, 0xd1, 0x02, 0xcc, 0x0c, 0xfa, 0x66, 0x78, 0x41, 0x25, 0x47, 0xa8,
+	0x1a, 0xe0, 0xfe, 0x9e, 0xa3, 0x0d, 0xb5, 0x6f, 0x8f, 0xdd, 0xbe, 0x6e, 0xa3, 0x45, 0x98, 0x19,
-	0x0d, 0x35, 0x12, 0xf3, 0x97, 0xf4, 0xc0, 0x7b, 0x69, 0xfe, 0x1f, 0xe3, 0x62, 0x23, 0x21, 0x82,
+	0xf4, 0xf5, 0xe0, 0x82, 0x4a, 0x8c, 0x50, 0x1b, 0x6a, 0x5e, 0xc4, 0x5e, 0xc2, 0x02, 0xef, 0x27,
-	0x35, 0x0c, 0xa2, 0xe4, 0xe4, 0x7d, 0x9f, 0x3c, 0x9a, 0xc5, 0x46, 0xb3, 0x96, 0xef, 0x06, 0x20,
+	0xd9, 0x3f, 0xc5, 0xc4, 0x5a, 0x8c, 0x05, 0x6d, 0x18, 0x78, 0xc9, 0xc9, 0xfa, 0x3e, 0x91, 0x9a,
-	0xf6, 0xc1, 0x1b, 0xd2, 0x8e, 0xed, 0x76, 0x08, 0xee, 0x7a, 0xae, 0x45, 0x78, 0xbd, 0x51, 0x34,
+	0xf9, 0x41, 0xd3, 0x96, 0xef, 0x2a, 0x20, 0xfa, 0xc1, 0x19, 0x92, 0x8e, 0x69, 0x77, 0x3c, 0xdc,
-	0xea, 0xf2, 0x4b, 0xcb, 0x6d, 0x8b, 0x79, 0xf4, 0x01, 0x14, 0xe8, 0xd1, 0x40, 0x54, 0x1a, 0xb5,
+	0x75, 0x6c, 0xc3, 0x63, 0xf5, 0x46, 0x51, 0xab, 0x8b, 0x2f, 0x2d, 0xbb, 0xcd, 0xe7, 0xd1, 0x87,
-	0x54, 0x64, 0x0b, 0xed, 0xda, 0x3d, 0x1a, 0x60, 0x83, 0x93, 0xb3, 0x96, 0x9f, 0x89, 0xa2, 0xbe,
+	0x50, 0x20, 0xc7, 0x03, 0x5e, 0x69, 0xd4, 0x12, 0x91, 0x2d, 0xd0, 0x6b, 0xef, 0x78, 0x80, 0x35,
-	0x79, 0x88, 0xfb, 0xc1, 0xd3, 0x5a, 0x38, 0xc3, 0x22, 0x31, 0x68, 0x9d, 0x67, 0xc5, 0x41, 0x2c,
+	0x46, 0x4e, 0x5b, 0x7e, 0xca, 0x8a, 0xb8, 0xfa, 0x11, 0xee, 0xfb, 0x4f, 0x6b, 0xc1, 0x0c, 0xf5,
-	0x87, 0xfa, 0x3f, 0x72, 0x50, 0x0f, 0x45, 0x1a, 0x98, 0x0c, 0xfb, 0x74, 0xac, 0xff, 0x26, 0xb7,
+	0x44, 0xbf, 0x75, 0x9e, 0xe5, 0x89, 0x58, 0x0c, 0xd5, 0xef, 0x72, 0x50, 0x0f, 0x58, 0x6a, 0xd8,
-	0x0b, 0xd3, 0x8e, 0xc1, 0x4f, 0xa0, 0x22, 0xdb, 0xf8, 0x63, 0x1c, 0x84, 0x20, 0x58, 0xb6, 0x26,
+	0x1b, 0xf6, 0x49, 0xaa, 0xfd, 0xc6, 0xb7, 0x0b, 0x93, 0xd2, 0xe0, 0xa7, 0x50, 0x11, 0x6d, 0xfc,
-	0x84, 0x5e, 0xf1, 0x05, 0x85, 0xde, 0xcc, 0xb1, 0x43, 0xaf, 0x0d, 0x0b, 0x01, 0x68, 0x85, 0x9a,
+	0x14, 0x89, 0x10, 0xf8, 0x92, 0xed, 0x31, 0xae, 0x57, 0x7c, 0x4e, 0xae, 0x37, 0x33, 0xb5, 0xeb,
-	0xb6, 0x31, 0x35, 0x27, 0x1c, 0xb3, 0x97, 0xa0, 0x22, 0x0e, 0x23, 0x51, 0x78, 0x8a, 0x52, 0x0f,
+	0xb5, 0x61, 0xd1, 0x07, 0xad, 0x40, 0xd2, 0x0e, 0x26, 0xfa, 0x98, 0x34, 0x7b, 0x11, 0x2a, 0x3c,
-	0xf6, 0x54, 0x13, 0xa4, 0xff, 0x18, 0xce, 0xf3, 0xa4, 0x4f, 0x5e, 0xf7, 0x65, 0xb9, 0x7b, 0xd5,
+	0x19, 0xf1, 0xc2, 0x93, 0x97, 0x7a, 0xb0, 0x2f, 0x9b, 0x20, 0xf5, 0x27, 0x70, 0x8e, 0x05, 0x7d,
-	0x55, 0x21, 0xc9, 0x8a, 0xc6, 0xe0, 0x20, 0x8f, 0xcd, 0xe9, 0x5b, 0xf0, 0x46, 0x42, 0xfe, 0x29,
+	0xfc, 0xba, 0x2f, 0xcb, 0xdd, 0xab, 0x2a, 0x0b, 0x49, 0x5a, 0x34, 0xfa, 0x89, 0x3c, 0x32, 0xa7,
-	0x40, 0xfd, 0xfa, 0x2d, 0x38, 0x3b, 0x82, 0x54, 0xa8, 0x06, 0xf0, 0xa9, 0xdb, 0x95, 0x10, 0x5e,
+	0x6e, 0xc3, 0x6b, 0x31, 0xfe, 0xa7, 0x00, 0x75, 0xf5, 0x3b, 0x05, 0x5e, 0xdf, 0x74, 0x9d, 0xc1,
-	0x3f, 0x83, 0xaa, 0x50, 0x0a, 0x00, 0xbd, 0xae, 0x5d, 0x6f, 0x47, 0xf3, 0x95, 0x05, 0x31, 0xba,
+	0x03, 0xd3, 0x25, 0x43, 0xbd, 0x1f, 0xbd, 0x40, 0x7e, 0x31, 0xa5, 0xf0, 0xbd, 0x50, 0x1e, 0xe1,
-	0x00, 0xe7, 0x3e, 0x75, 0x2d, 0xbc, 0x6f, 0xbb, 0xd8, 0x0a, 0x3f, 0xd5, 0xcf, 0xa0, 0x73, 0x30,
+	0xb0, 0x73, 0x35, 0xe9, 0xcc, 0x46, 0x94, 0x12, 0x47, 0x15, 0xca, 0x3a, 0xff, 0xc9, 0x27, 0x29,
-	0xdf, 0x72, 0x5d, 0xec, 0x47, 0x26, 0x35, 0x36, 0xb9, 0x8d, 0xfd, 0x1e, 0x8e, 0x4c, 0xe6, 0xd6,
+	0x2f, 0xe8, 0x26, 0x60, 0x69, 0x96, 0x34, 0x9b, 0xd8, 0x1c, 0xe7, 0x4f, 0xda, 0x1c, 0xa7, 0xb8,
-	0x7e, 0x8f, 0xa0, 0xcc, 0x6a, 0xcf, 0x7b, 0x9e, 0xe7, 0x5b, 0x68, 0x00, 0x88, 0x3f, 0x54, 0x38,
+	0x7f, 0xe1, 0x39, 0xb9, 0xff, 0xd4, 0xa5, 0x25, 0xba, 0x07, 0xd1, 0x9b, 0x0b, 0x06, 0x3c, 0x27,
-	0x03, 0xcf, 0x55, 0x2f, 0x7a, 0xe8, 0xe6, 0x98, 0x36, 0x66, 0x94, 0x54, 0xfa, 0xbc, 0x79, 0x65,
+	0xba, 0xf2, 0xd8, 0x00, 0x08, 0xba, 0x78, 0xf1, 0xfc, 0x9f, 0x85, 0x4d, 0x68, 0x15, 0x3d, 0x2e,
-	0x0c, 0x47, 0x82, 0x5c, 0x3f, 0x83, 0x1c, 0xae, 0x91, 0x65, 0xfc, 0xae, 0xdd, 0x7d, 0x1c, 0x5c,
+	0x89, 0x35, 0xec, 0xfa, 0x2d, 0xd2, 0x74, 0x7e, 0x06, 0xcd, 0x24, 0x37, 0x3d, 0x85, 0xeb, 0x5f,
-	0x49, 0x4d, 0xd0, 0x98, 0x20, 0x0d, 0x34, 0x26, 0x1e, 0x0a, 0xe5, 0x40, 0xbc, 0x26, 0x05, 0x3b,
+	0xb9, 0x0e, 0x67, 0x47, 0x92, 0x34, 0xaa, 0x01, 0x7c, 0x6e, 0x77, 0x45, 0xf5, 0x52, 0x3f, 0x83,
-	0xa5, 0x9f, 0x41, 0x4f, 0xe0, 0xfc, 0x26, 0xa6, 0xe1, 0x03, 0x42, 0xa0, 0x70, 0x6d, 0xbc, 0xc2,
+	0xaa, 0x50, 0xf2, 0x6b, 0x99, 0xba, 0x72, 0xa5, 0x1d, 0x4e, 0x55, 0x14, 0xbf, 0xd1, 0x79, 0x58,
-	0x11, 0xe2, 0x63, 0xaa, 0xdc, 0x82, 0x22, 0x3f, 0x9a, 0x51, 0x5a, 0x86, 0x44, 0xff, 0xd6, 0xd2,
+	0xf8, 0xdc, 0x36, 0xf0, 0x81, 0x69, 0x63, 0x23, 0xf8, 0x54, 0x3f, 0x83, 0x16, 0x60, 0xbe, 0x65,
-	0x5c, 0x1a, 0x4f, 0xa0, 0xa4, 0xfd, 0x04, 0xe6, 0x13, 0xcf, 0xf6, 0xe8, 0x5a, 0x0a, 0x5b, 0xfa,
+	0xdb, 0xd8, 0x0d, 0x4d, 0x2a, 0x74, 0x72, 0x07, 0xbb, 0x3d, 0x1c, 0x9a, 0xcc, 0xad, 0x7f, 0xbb,
-	0x1f, 0x30, 0x9a, 0xd7, 0xb3, 0x90, 0x2a, 0x5d, 0x3d, 0xa8, 0xc5, 0x9f, 0x39, 0xd0, 0x72, 0x0a,
+	0x00, 0x65, 0xda, 0x76, 0xdd, 0x76, 0x1c, 0xd7, 0x40, 0x03, 0x40, 0xec, 0x8d, 0xce, 0x1a, 0x38,
-	0x7f, 0xea, 0x93, 0x6b, 0xf3, 0x5a, 0x06, 0x4a, 0xa5, 0xc8, 0x81, 0x7a, 0xf2, 0x19, 0x19, 0x5d,
+	0xb6, 0x7c, 0xcc, 0x46, 0xd7, 0x52, 0x8c, 0x39, 0x4a, 0x2a, 0x42, 0xb7, 0x79, 0x39, 0x65, 0x45,
-	0x9f, 0x28, 0x20, 0x1e, 0x6e, 0xef, 0x65, 0xa2, 0x55, 0xea, 0x8e, 0x78, 0x10, 0x8c, 0x3c, 0x63,
+	0x8c, 0x5c, 0x3d, 0x83, 0x2c, 0x26, 0x91, 0x26, 0xbb, 0x3d, 0xb3, 0xfb, 0xc8, 0xbf, 0x8d, 0x1d,
-	0xa2, 0x95, 0x74, 0x31, 0xe3, 0xde, 0x57, 0x9b, 0xab, 0x99, 0xe9, 0x95, 0xea, 0xaf, 0x44, 0x4b,
+	0x23, 0x31, 0x46, 0xea, 0x4b, 0x8c, 0xbd, 0x91, 0x8b, 0x01, 0x7f, 0x48, 0xf5, 0x4f, 0x4a, 0x3d,
-	0x90, 0xf6, 0x14, 0x88, 0x6e, 0xa5, 0x8b, 0x9b, 0xf0, 0x86, 0xd9, 0x5c, 0x3b, 0x0e, 0x8b, 0x32,
+	0x83, 0x1e, 0xc3, 0xb9, 0x2d, 0x4c, 0x82, 0xb7, 0x33, 0x5f, 0xe0, 0x7a, 0xba, 0xc0, 0x11, 0xe2,
-	0xe2, 0x4b, 0x5e, 0xcb, 0xa7, 0x3c, 0xa7, 0x25, 0xf3, 0x2e, 0x90, 0x37, 0xfe, 0x9d, 0xb0, 0x79,
+	0x29, 0x45, 0x6e, 0x43, 0x91, 0x55, 0xa5, 0x28, 0x29, 0x3a, 0xc2, 0xff, 0xe8, 0x6a, 0x2e, 0xa7,
-	0xeb, 0x18, 0x1c, 0xca, 0x00, 0x2f, 0xf9, 0x50, 0x1f, 0xa4, 0xe1, 0xea, 0xd4, 0xa8, 0x39, 0x59,
+	0x13, 0x48, 0x6e, 0x3f, 0x85, 0xf9, 0xd8, 0x3f, 0x56, 0xd0, 0x7b, 0x09, 0xcb, 0x92, 0xff, 0x7b,
-	0x0e, 0x7e, 0x0e, 0xf3, 0x89, 0xbb, 0xbf, 0xd4, 0xac, 0x49, 0xbf, 0x1f, 0x6c, 0x4e, 0x02, 0x74,
+	0xd4, 0xbc, 0x92, 0x85, 0x54, 0xca, 0xea, 0x41, 0x2d, 0xfa, 0xc2, 0x87, 0x56, 0x12, 0xd6, 0x27,
-	0x91, 0x92, 0x89, 0xd6, 0x08, 0x8d, 0x89, 0xfe, 0x94, 0xf6, 0xa9, 0x79, 0x3d, 0x0b, 0xa9, 0x5a,
+	0xfe, 0xdb, 0xa0, 0xf9, 0x5e, 0x06, 0x4a, 0x29, 0xc8, 0x82, 0x7a, 0xfc, 0x1f, 0x14, 0xe8, 0xca,
-	0x08, 0xe1, 0x70, 0x99, 0x68, 0x2f, 0xd0, 0x8d, 0x74, 0x19, 0xe9, 0xad, 0x51, 0xf3, 0xfd, 0x8c,
+	0x58, 0x06, 0x51, 0x77, 0x7b, 0x3f, 0x13, 0xad, 0x14, 0x77, 0xcc, 0x9c, 0x60, 0xe4, 0x05, 0x1f,
-	0xd4, 0x4a, 0x69, 0x07, 0x60, 0x13, 0xd3, 0x6d, 0x4c, 0x7d, 0x16, 0x23, 0x57, 0x52, 0x5d, 0x1e,
+	0xad, 0x26, 0xb3, 0x49, 0xfb, 0x6b, 0x41, 0x73, 0x2d, 0x33, 0xbd, 0x14, 0xfd, 0x35, 0xef, 0x86,
-	0x12, 0x04, 0x6a, 0xae, 0x4e, 0xa5, 0x53, 0x0a, 0x7e, 0x08, 0x28, 0x38, 0xe7, 0x22, 0x37, 0xcf,
+	0x93, 0x5e, 0xc1, 0xd1, 0xf5, 0x64, 0x76, 0x63, 0x9e, 0xef, 0x9b, 0xeb, 0xd3, 0x2c, 0x91, 0x4a,
-	0x6f, 0x4f, 0xac, 0xe2, 0x44, 0xc9, 0x35, 0x6d, 0x6f, 0x9e, 0x40, 0x7d, 0xdb, 0x74, 0x87, 0x66,
+	0x7c, 0xc5, 0xda, 0xd8, 0x84, 0x97, 0xe4, 0x78, 0xdc, 0xf9, 0xfc, 0xd2, 0x9f, 0xc8, 0x9b, 0xd7,
-	0x3f, 0x22, 0xf7, 0x46, 0xaa, 0x61, 0x49, 0xb2, 0x31, 0xde, 0x1a, 0x4b, 0xad, 0x16, 0xf3, 0x54,
+	0xa7, 0x58, 0x21, 0x15, 0x70, 0xe2, 0xff, 0x51, 0xf1, 0xc3, 0x70, 0x6d, 0xa2, 0xd7, 0x9c, 0x2c,
-	0x9d, 0xa1, 0xa6, 0x4a, 0x41, 0x9c, 0xc4, 0x96, 0xd0, 0x1b, 0x09, 0xc2, 0x31, 0xd8, 0x32, 0x81,
+	0x06, 0xbf, 0x80, 0xf9, 0xd8, 0xb5, 0x77, 0x62, 0xd4, 0x24, 0x5f, 0x8d, 0x37, 0xc7, 0x01, 0x3a,
-	0x5e, 0x29, 0x7e, 0xae, 0xf1, 0xbf, 0x83, 0x24, 0x08, 0x1e, 0xd9, 0xf4, 0x80, 0x15, 0xf7, 0x24,
+	0x0f, 0xc9, 0xd8, 0xad, 0x00, 0x4a, 0xf1, 0xfe, 0x84, 0x9b, 0x83, 0xe6, 0x95, 0x2c, 0xa4, 0x72,
-	0x8b, 0x09, 0x9c, 0xf0, 0x18, 0x26, 0x48, 0x7a, 0x65, 0x82, 0x05, 0x73, 0xb1, 0x1a, 0x09, 0xa5,
+	0x23, 0x1e, 0x83, 0xcb, 0x58, 0x67, 0x8d, 0xae, 0x26, 0xf3, 0x48, 0xbe, 0x15, 0x68, 0x7e, 0x90,
-	0x5d, 0x1f, 0xa7, 0x55, 0x69, 0xcd, 0xe5, 0xe9, 0x84, 0x4a, 0xcb, 0x01, 0xcc, 0x05, 0xf1, 0x2a,
+	0x91, 0x5a, 0x0a, 0xed, 0x00, 0x6c, 0x61, 0xb2, 0x83, 0x89, 0x4b, 0x7d, 0xe4, 0x72, 0xa2, 0xc9,
-	0x9c, 0x7b, 0x6d, 0x9c, 0xa5, 0x21, 0xcd, 0x98, 0x74, 0x4b, 0x27, 0x0d, 0x34, 0xad, 0xfd, 0xb7,
+	0x03, 0x02, 0x5f, 0xcc, 0xbb, 0x13, 0xe9, 0xa4, 0x80, 0x1f, 0x01, 0xf2, 0xf3, 0x5c, 0xe8, 0xd1,
-	0x00, 0xa5, 0xe0, 0x66, 0xee, 0x35, 0x14, 0x47, 0xaf, 0xa1, 0x5a, 0xf9, 0x1c, 0xe6, 0x13, 0xcf,
+	0xe5, 0xad, 0xb1, 0x0d, 0x0c, 0xef, 0x36, 0x26, 0x9d, 0xcd, 0x63, 0xa8, 0xef, 0xe8, 0x36, 0x4d,
-	0xe6, 0xa9, 0x60, 0x96, 0xfe, 0xb4, 0x3e, 0x2d, 0x1b, 0x1f, 0xc9, 0x3f, 0xd3, 0x2a, 0xe0, 0xba,
+	0xda, 0x01, 0xdf, 0xab, 0x89, 0x8a, 0xc5, 0xc9, 0x52, 0xac, 0x95, 0x4a, 0x2d, 0x37, 0xf3, 0x44,
-	0x3a, 0xae, 0xe2, 0x49, 0x62, 0xd6, 0x14, 0xc1, 0x2f, 0x1d, 0xa1, 0x1e, 0x02, 0x44, 0x10, 0x64,
+	0xe6, 0x50, 0x5d, 0x86, 0x20, 0x8e, 0x63, 0x4b, 0x60, 0x8d, 0x18, 0x61, 0x0a, 0xb6, 0x8c, 0xa1,
-	0x72, 0x7f, 0xc9, 0x92, 0x62, 0x8a, 0xc1, 0xeb, 0xb7, 0x7f, 0x74, 0xab, 0x67, 0xd3, 0x83, 0xe1,
+	0x97, 0x82, 0x9f, 0x29, 0xec, 0x9f, 0x50, 0x31, 0x82, 0x87, 0x26, 0x39, 0xa4, 0x7d, 0xad, 0x97,
-	0x1e, 0xfb, 0xb2, 0x2a, 0x48, 0xdf, 0xb7, 0x3d, 0xf9, 0x6b, 0x35, 0xd8, 0xd1, 0x55, 0xce, 0xbd,
+	0x45, 0x05, 0x46, 0x38, 0x85, 0x0a, 0x82, 0x5e, 0xaa, 0x60, 0xc0, 0x5c, 0xa4, 0x3d, 0x40, 0x49,
-	0xca, 0x14, 0x0c, 0xf6, 0xf6, 0x66, 0xf8, 0xe8, 0xf6, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0xdc,
+	0x2f, 0x27, 0x49, 0x0d, 0x4a, 0x73, 0x65, 0x32, 0xa1, 0x94, 0x72, 0x08, 0x73, 0xbe, 0xbf, 0x72,
-	0xd7, 0x3e, 0x5c, 0x6e, 0x2d, 0x00, 0x00,
+	0xe3, 0xbe, 0x97, 0xa6, 0x69, 0x40, 0x93, 0x12, 0x6e, 0xc9, 0xa4, 0xe1, 0x70, 0x1b, 0x2d, 0xfc,
+	0x50, 0xb6, 0x8e, 0x61, 0x5c, 0xb8, 0xa5, 0x57, 0x93, 0xea, 0x99, 0xf5, 0x7f, 0x17, 0xa0, 0xe4,
+	0xdf, 0x84, 0xbf, 0x82, 0x8a, 0xec, 0x15, 0x94, 0x48, 0x5f, 0xc0, 0x7c, 0xec, 0x6f, 0x2a, 0x89,
+	0x08, 0x9a, 0xfc, 0x57, 0x96, 0x49, 0x10, 0xf0, 0x50, 0xfc, 0x79, 0x5d, 0xa2, 0xe5, 0xbb, 0x69,
+	0x65, 0x56, 0x1c, 0x28, 0x27, 0x30, 0x7e, 0xe1, 0xb0, 0x78, 0x1f, 0x20, 0x04, 0x5b, 0xe3, 0xef,
+	0x73, 0x68, 0x24, 0x4e, 0x50, 0x78, 0xe3, 0xc6, 0x8f, 0xaf, 0xf7, 0x4c, 0x72, 0x38, 0xdc, 0xa7,
+	0x5f, 0xd6, 0x38, 0xe9, 0x07, 0xa6, 0x23, 0x7e, 0xad, 0xf9, 0x27, 0xba, 0xc6, 0x56, 0xaf, 0x51,
+	0x01, 0x83, 0xfd, 0xfd, 0x19, 0x36, 0xba, 0xf1, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe4, 0x4d,
+	0xf6, 0xb0, 0xde, 0x30, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3021,6 +3221,7 @@ type DataCoordClient interface {
 	GetCompactionStateWithPlans(ctx context.Context, in *milvuspb.GetCompactionPlansRequest, opts ...grpc.CallOption) (*milvuspb.GetCompactionPlansResponse, error)
 	WatchChannels(ctx context.Context, in *WatchChannelsRequest, opts ...grpc.CallOption) (*WatchChannelsResponse, error)
 	GetFlushState(ctx context.Context, in *milvuspb.GetFlushStateRequest, opts ...grpc.CallOption) (*milvuspb.GetFlushStateResponse, error)
+	DropVirtualChannel(ctx context.Context, in *DropVirtualChannelRequest, opts ...grpc.CallOption) (*DropVirtualChannelResponse, error)
 }
 
 type dataCoordClient struct {
@@ -3220,6 +3421,15 @@ func (c *dataCoordClient) GetFlushState(ctx context.Context, in *milvuspb.GetFlu
 	return out, nil
 }
 
+func (c *dataCoordClient) DropVirtualChannel(ctx context.Context, in *DropVirtualChannelRequest, opts ...grpc.CallOption) (*DropVirtualChannelResponse, error) {
+	out := new(DropVirtualChannelResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/DropVirtualChannel", 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, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
@@ -3244,6 +3454,7 @@ type DataCoordServer interface {
 	GetCompactionStateWithPlans(context.Context, *milvuspb.GetCompactionPlansRequest) (*milvuspb.GetCompactionPlansResponse, error)
 	WatchChannels(context.Context, *WatchChannelsRequest) (*WatchChannelsResponse, error)
 	GetFlushState(context.Context, *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)
+	DropVirtualChannel(context.Context, *DropVirtualChannelRequest) (*DropVirtualChannelResponse, error)
 }
 
 // UnimplementedDataCoordServer can be embedded to have forward compatible implementations.
@@ -3313,6 +3524,9 @@ func (*UnimplementedDataCoordServer) WatchChannels(ctx context.Context, req *Wat
 func (*UnimplementedDataCoordServer) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetFlushState not implemented")
 }
+func (*UnimplementedDataCoordServer) DropVirtualChannel(ctx context.Context, req *DropVirtualChannelRequest) (*DropVirtualChannelResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DropVirtualChannel not implemented")
+}
 
 func RegisterDataCoordServer(s *grpc.Server, srv DataCoordServer) {
 	s.RegisterService(&_DataCoord_serviceDesc, srv)
@@ -3696,6 +3910,24 @@ func _DataCoord_GetFlushState_Handler(srv interface{}, ctx context.Context, dec
 	return interceptor(ctx, in, info, handler)
 }
 
+func _DataCoord_DropVirtualChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DropVirtualChannelRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DataCoordServer).DropVirtualChannel(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.data.DataCoord/DropVirtualChannel",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DataCoordServer).DropVirtualChannel(ctx, req.(*DropVirtualChannelRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _DataCoord_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "milvus.proto.data.DataCoord",
 	HandlerType: (*DataCoordServer)(nil),
@@ -3784,6 +4016,10 @@ var _DataCoord_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetFlushState",
 			Handler:    _DataCoord_GetFlushState_Handler,
 		},
+		{
+			MethodName: "DropVirtualChannel",
+			Handler:    _DataCoord_DropVirtualChannel_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "data_coord.proto",

internal/proxy/data_coord_mock_test.go

@@ -202,6 +202,10 @@ func (coord *DataCoordMock) GetFlushState(ctx context.Context, req *milvuspb.Get
 	return &milvuspb.GetFlushStateResponse{}, nil
 }
 
+func (coord *DataCoordMock) DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error) {
+	return &datapb.DropVirtualChannelResponse{}, nil
+}
+
 func NewDataCoordMock() *DataCoordMock {
 	return &DataCoordMock{
 		nodeID:            typeutil.UniqueID(uniquegenerator.GetUniqueIntGeneratorIns().GetInt()),

internal/types/types.go

@@ -199,7 +199,7 @@ type DataCoord interface {
 	//  and related message stream positions
 	//
 	// ctx is the context to control request deadline and cancellation
-	// req contains the collection/partition id to query
+	// req contains the segment binlogs and checkpoint informations.
 	//
 	// response status contains the status/error code and failing reason if any
 	// error is returned only when some communication issue occurs
@@ -232,6 +232,17 @@ type DataCoord interface {
 	WatchChannels(ctx context.Context, req *datapb.WatchChannelsRequest) (*datapb.WatchChannelsResponse, error)
 	// GetFlushState gets the flush state of multiple segments
 	GetFlushState(ctx context.Context, req *milvuspb.GetFlushStateRequest) (*milvuspb.GetFlushStateResponse, error)
+
+	// DropVirtualChannel notifies DataCoord a virtual channel is dropped and
+	// updates related segments binlogs(including insert binlogs, stats logs and delta logs)
+	//  and related message stream positions
+	//
+	// ctx is the context to control request deadline and cancellation
+	// req contains the dropped virtual channel name and related segment information
+	//
+	// response status contains the status/error code and failing reason if any
+	// error is returned only when some communication issue occurs
+	DropVirtualChannel(ctx context.Context, req *datapb.DropVirtualChannelRequest) (*datapb.DropVirtualChannelResponse, error)
 }
 
 // IndexNode is the interface `indexnode` package implements