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

Resolve an issue with bulk load where segments in flow graph replica are not updated (#16609) 

issue: #15604

/kind enhancement

Signed-off-by: Yuchen Gao <yuchen.gao@zilliz.com>
pull/16620/head
Ten Thousand Leaves 2022-04-25 11:07:47 +08:00 committed by GitHub
parent 65a9e01a8f
commit e66ac6a77c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 445 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
internal/datacoord/cluster.go
View File

@ -79,7 +79,7 @@ func (c *Cluster) Watch(ch string, collectionID UniqueID) error {
return c.channelManager.Watch(&channel{Name: ch, CollectionID: collectionID}) return c.channelManager.Watch(&channel{Name: ch, CollectionID: collectionID})
} }
// Flush sends flush requests to corresponding datanodes according to channels that segments belong to // Flush sends flush requests to corresponding dataNodes according to channels where segments are assigned to.
func (c *Cluster) Flush(ctx context.Context, segments []*datapb.SegmentInfo, markSegments []*datapb.SegmentInfo) { func (c *Cluster) Flush(ctx context.Context, segments []*datapb.SegmentInfo, markSegments []*datapb.SegmentInfo) {
channels := c.channelManager.GetChannels() channels := c.channelManager.GetChannels()
nodeSegments := make(map[int64][]int64) nodeSegments := make(map[int64][]int64)
@ -131,7 +131,10 @@ func (c *Cluster) Flush(ctx context.Context, segments []*datapb.SegmentInfo, mar
SegmentIDs: segments, SegmentIDs: segments,
MarkSegmentIDs: marks, MarkSegmentIDs: marks,
} }
log.Info("Plan to flush", zap.Int64("node_id", nodeID), zap.Int64s("segments", segments), zap.Int64s("marks", marks)) log.Info("calling dataNode to flush",
zap.Int64("dataNode ID", nodeID),
zap.Int64s("segments", segments),
zap.Int64s("marks", marks))
c.sessionManager.Flush(ctx, nodeID, req) c.sessionManager.Flush(ctx, nodeID, req)
} }
} }

17
internal/datacoord/segment_manager.go
View File

@ -72,8 +72,9 @@ type Manager interface {
AllocSegment(ctx context.Context, collectionID, partitionID UniqueID, channelName string, requestRows int64) ([]*Allocation, error) AllocSegment(ctx context.Context, collectionID, partitionID UniqueID, channelName string, requestRows int64) ([]*Allocation, error)
// DropSegment drops the segment from manager. // DropSegment drops the segment from manager.
DropSegment(ctx context.Context, segmentID UniqueID) DropSegment(ctx context.Context, segmentID UniqueID)
// SealAllSegments seals all segments of collection with collectionID and return sealed segments // SealAllSegments seals all segments of collection with collectionID and return sealed segments.
SealAllSegments(ctx context.Context, collectionID UniqueID) ([]UniqueID, error) // If segIDs is not empty, also seals segments in segIDs.
SealAllSegments(ctx context.Context, collectionID UniqueID, segIDs []UniqueID) ([]UniqueID, error)
// GetFlushableSegments returns flushable segment ids // GetFlushableSegments returns flushable segment ids
GetFlushableSegments(ctx context.Context, channel string, ts Timestamp) ([]UniqueID, error) GetFlushableSegments(ctx context.Context, channel string, ts Timestamp) ([]UniqueID, error)
// ExpireAllocations notifies segment status to expire old allocations // ExpireAllocations notifies segment status to expire old allocations
@ -360,17 +361,21 @@ func (s *SegmentManager) DropSegment(ctx context.Context, segmentID UniqueID) {
} }
} }
// SealAllSegments seals all segmetns of collection with collectionID and return sealed segments // SealAllSegments seals all segments of collection with collectionID and return sealed segments
func (s *SegmentManager) SealAllSegments(ctx context.Context, collectionID UniqueID) ([]UniqueID, error) { func (s *SegmentManager) SealAllSegments(ctx context.Context, collectionID UniqueID, segIDs []UniqueID) ([]UniqueID, error) {
sp, _ := trace.StartSpanFromContext(ctx) sp, _ := trace.StartSpanFromContext(ctx)
defer sp.Finish() defer sp.Finish()
s.mu.Lock() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
var ret []UniqueID var ret []UniqueID
for _, id := range s.segments { segCandidates := s.segments
if len(segIDs) != 0 {
segCandidates = segIDs
}
for _, id := range segCandidates {
info := s.meta.GetSegment(id) info := s.meta.GetSegment(id)
if info == nil { if info == nil {
log.Warn("Failed to get seg info from meta", zap.Int64("id", id)) log.Warn("failed to get seg info from meta", zap.Int64("segment ID", id))
continue continue
} }
if info.CollectionID != collectionID { if info.CollectionID != collectionID {

26
internal/datacoord/segment_manager_test.go
View File

@ -186,7 +186,29 @@ func TestSaveSegmentsToMeta(t *testing.T) {
allocations, err := segmentManager.AllocSegment(context.Background(), collID, 0, "c1", 1000) allocations, err := segmentManager.AllocSegment(context.Background(), collID, 0, "c1", 1000)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, 1, len(allocations)) assert.EqualValues(t, 1, len(allocations))
_, err = segmentManager.SealAllSegments(context.Background(), collID) _, err = segmentManager.SealAllSegments(context.Background(), collID, nil)
assert.Nil(t, err)
segment := meta.GetSegment(allocations[0].SegmentID)
assert.NotNil(t, segment)
assert.EqualValues(t, segment.LastExpireTime, allocations[0].ExpireTime)
assert.EqualValues(t, commonpb.SegmentState_Sealed, segment.State)
}
func TestSaveSegmentsToMetaWithSpecificSegments(t *testing.T) {
Params.Init()
mockAllocator := newMockAllocator()
meta, err := newMemoryMeta(mockAllocator)
assert.Nil(t, err)
schema := newTestSchema()
collID, err := mockAllocator.allocID(context.Background())
assert.Nil(t, err)
meta.AddCollection(&datapb.CollectionInfo{ID: collID, Schema: schema})
segmentManager := newSegmentManager(meta, mockAllocator)
allocations, err := segmentManager.AllocSegment(context.Background(), collID, 0, "c1", 1000)
assert.Nil(t, err)
assert.EqualValues(t, 1, len(allocations))
_, err = segmentManager.SealAllSegments(context.Background(), collID, []int64{allocations[0].SegmentID})
assert.Nil(t, err) assert.Nil(t, err)
segment := meta.GetSegment(allocations[0].SegmentID) segment := meta.GetSegment(allocations[0].SegmentID)
assert.NotNil(t, segment) assert.NotNil(t, segment)
@ -297,7 +319,7 @@ func TestGetFlushableSegments(t *testing.T) {
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, 1, len(allocations)) assert.EqualValues(t, 1, len(allocations))
ids, err := segmentManager.SealAllSegments(context.TODO(), collID) ids, err := segmentManager.SealAllSegments(context.TODO(), collID, nil)
assert.Nil(t, err) assert.Nil(t, err)
assert.EqualValues(t, 1, len(ids)) assert.EqualValues(t, 1, len(ids))
assert.EqualValues(t, allocations[0].SegmentID, ids[0]) assert.EqualValues(t, allocations[0].SegmentID, ids[0])

4
internal/datacoord/server.go
View File

@ -539,7 +539,9 @@ func (s *Server) handleTimetickMessage(ctx context.Context, ttMsg *msgstream.Dat
return nil return nil
} }
log.Info("flush segments", zap.Int64s("segmentIDs", flushableIDs), zap.Int("markSegments count", len(staleSegments))) log.Info("start flushing segments",
zap.Int64s("segment IDs", flushableIDs),
zap.Int("# of stale/mark segments", len(staleSegments)))
s.setLastFlushTime(flushableSegments) s.setLastFlushTime(flushableSegments)
s.setLastFlushTime(staleSegments) s.setLastFlushTime(staleSegments)

2
internal/datacoord/server_test.go
View File

@ -749,7 +749,7 @@ func (s *spySegmentManager) DropSegment(ctx context.Context, segmentID UniqueID)
} }
// SealAllSegments seals all segments of collection with collectionID and return sealed segments // SealAllSegments seals all segments of collection with collectionID and return sealed segments
func (s *spySegmentManager) SealAllSegments(ctx context.Context, collectionID UniqueID) ([]UniqueID, error) { func (s *spySegmentManager) SealAllSegments(ctx context.Context, collectionID UniqueID, segIDs []UniqueID) ([]UniqueID, error) {
panic("not implemented") // TODO: Implement panic("not implemented") // TODO: Implement
} }

12
internal/datacoord/services.go
View File

@ -84,7 +84,7 @@ func (s *Server) Flush(ctx context.Context, req *datapb.FlushRequest) (*datapb.F
resp.Status.Reason = serverNotServingErrMsg resp.Status.Reason = serverNotServingErrMsg
return resp, nil return resp, nil
} }
sealedSegments, err := s.segmentManager.SealAllSegments(ctx, req.CollectionID) sealedSegments, err := s.segmentManager.SealAllSegments(ctx, req.GetCollectionID(), req.GetSegmentIDs())
if err != nil { if err != nil {
resp.Status.Reason = fmt.Sprintf("failed to flush %d, %s", req.CollectionID, err) resp.Status.Reason = fmt.Sprintf("failed to flush %d, %s", req.CollectionID, err)
return resp, nil return resp, nil
@ -343,7 +343,7 @@ func (s *Server) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPath
s.segmentManager.DropSegment(ctx, segment.GetID()) s.segmentManager.DropSegment(ctx, segment.GetID())
} }
// set segment to SegmentState_Flushing and save binlogs and checkpoints // Set segment to SegmentState_Flushing. Also save binlogs and checkpoints.
err := s.meta.UpdateFlushSegmentsInfo( err := s.meta.UpdateFlushSegmentsInfo(
req.GetSegmentID(), req.GetSegmentID(),
req.GetFlushed(), req.GetFlushed(),
@ -362,7 +362,7 @@ func (s *Server) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPath
return resp, nil return resp, nil
} }
log.Info("flush segment with meta", zap.Int64("id", req.SegmentID), log.Info("flush segment with meta", zap.Int64("segment id", req.SegmentID),
zap.Any("meta", req.GetField2BinlogPaths())) zap.Any("meta", req.GetField2BinlogPaths()))
if req.GetFlushed() { if req.GetFlushed() {
@ -378,8 +378,12 @@ func (s *Server) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPath
err = s.compactionTrigger.triggerSingleCompaction(segment.GetCollectionID(), err = s.compactionTrigger.triggerSingleCompaction(segment.GetCollectionID(),
segment.GetPartitionID(), segmentID, segment.GetInsertChannel(), tt) segment.GetPartitionID(), segmentID, segment.GetInsertChannel(), tt)
if err != nil { if err != nil {
log.Warn("failed to trigger single compaction", zap.Int64("segmentID", segmentID)) log.Warn("failed to trigger single compaction", zap.Int64("segment ID", segmentID))
} else {
log.Info("compaction triggered for segment", zap.Int64("segment ID", segmentID))
} }
} else {
log.Warn("failed to get time travel reverse time")
} }
} }
} }

62
internal/datanode/data_node.go
View File

@ -556,8 +556,9 @@ func (node *DataNode) FlushSegments(ctx context.Context, req *datapb.FlushSegmen
} }
log.Info("Receive FlushSegments req", log.Info("Receive FlushSegments req",
zap.Int64("collectionID", req.GetCollectionID()), zap.Int("num", len(req.SegmentIDs)), zap.Int64("collectionID", req.GetCollectionID()),
zap.Int64s("segments", req.SegmentIDs), zap.Int64s("segments", req.GetSegmentIDs()),
zap.Int64s("stale segments", req.GetMarkSegmentIDs()),
) )
processSegments := func(segmentIDs []UniqueID, flushed bool) bool { processSegments := func(segmentIDs []UniqueID, flushed bool) bool {
@ -565,9 +566,10 @@ func (node *DataNode) FlushSegments(ctx context.Context, req *datapb.FlushSegmen
for _, id := range segmentIDs { for _, id := range segmentIDs {
if node.segmentCache.checkIfCached(id) { if node.segmentCache.checkIfCached(id) {
// Segment in flushing, ignore // Segment in flushing, ignore
log.Info("Segment flushing, ignore the flush request until flush is done.", log.Info("segment flushing, ignore the flush request until flush is done.",
zap.Int64("collectionID", req.GetCollectionID()), zap.Int64("segmentID", id)) zap.Int64("collectionID", req.GetCollectionID()), zap.Int64("segmentID", id))
status.Reason = "segment is flushing, nothing is done"
noErr = false
continue continue
} }
@ -575,8 +577,8 @@ func (node *DataNode) FlushSegments(ctx context.Context, req *datapb.FlushSegmen
flushCh, err := node.flowgraphManager.getFlushCh(id) flushCh, err := node.flowgraphManager.getFlushCh(id)
if err != nil { if err != nil {
status.Reason = "DataNode abnormal, restarting" status.Reason = "no flush channel found for v-channel"
log.Error("DataNode abnormal, no flushCh for a vchannel", zap.Error(err)) log.Error("no flush channel found for v-channel", zap.Error(err))
noErr = false noErr = false
continue continue
} }
@ -589,9 +591,11 @@ func (node *DataNode) FlushSegments(ctx context.Context, req *datapb.FlushSegmen
flushed: flushed, flushed: flushed,
} }
} }
log.Info("Flowgraph flushSegment tasks triggered", zap.Bool("flushed", flushed), log.Info("flow graph flushSegment tasks triggered",
zap.Int64("collectionID", req.GetCollectionID()), zap.Int64s("segments", segmentIDs)) zap.Bool("flushed", flushed),
zap.Int64("collection ID", req.GetCollectionID()),
zap.Int64s("segments", segmentIDs),
zap.Int64s("mark segments", req.GetMarkSegmentIDs()))
return noErr return noErr
} }
@ -868,13 +872,15 @@ func importFlushReqFunc(node *DataNode, req *datapb.ImportTaskRequest, res *root
return func(fields map[storage.FieldID]storage.FieldData, shardNum int) error { return func(fields map[storage.FieldID]storage.FieldData, shardNum int) error {
if shardNum >= len(req.GetImportTask().GetChannelNames()) { if shardNum >= len(req.GetImportTask().GetChannelNames()) {
log.Error("import task returns invalid shard number", log.Error("import task returns invalid shard number",
zap.Int("# of shards", shardNum), zap.Int("shard num", shardNum),
zap.Int("# of channels", len(req.GetImportTask().GetChannelNames())), zap.Int("# of channels", len(req.GetImportTask().GetChannelNames())),
zap.Any("channel names", req.GetImportTask().GetChannelNames()), zap.Any("channel names", req.GetImportTask().GetChannelNames()),
) )
return fmt.Errorf("syncSegmentID Failed: invalid shard number %d", shardNum) return fmt.Errorf("syncSegmentID Failed: invalid shard number %d", shardNum)
} }
log.Info("import task flush segment", zap.Any("ChannelNames", req.ImportTask.ChannelNames), zap.Int("shardNum", shardNum)) log.Info("import task flush segment",
zap.Any("channel names", req.ImportTask.ChannelNames),
zap.Int("shard num", shardNum))
segReqs := []*datapb.SegmentIDRequest{ segReqs := []*datapb.SegmentIDRequest{
{ {
ChannelName: req.ImportTask.ChannelNames[shardNum], ChannelName: req.ImportTask.ChannelNames[shardNum],
@ -899,6 +905,7 @@ func importFlushReqFunc(node *DataNode, req *datapb.ImportTaskRequest, res *root
} }
segmentID := resp.SegIDAssignments[0].SegID segmentID := resp.SegIDAssignments[0].SegID
// TODO: this code block is long and tedious, maybe split it into separate functions.
var rowNum int var rowNum int
for _, field := range fields { for _, field := range fields {
rowNum = field.RowNum() rowNum = field.RowNum()
@ -1018,6 +1025,38 @@ func importFlushReqFunc(node *DataNode, req *datapb.ImportTaskRequest, res *root
fieldStats = append(fieldStats, &datapb.FieldBinlog{FieldID: k, Binlogs: []*datapb.Binlog{v}}) fieldStats = append(fieldStats, &datapb.FieldBinlog{FieldID: k, Binlogs: []*datapb.Binlog{v}})
} }
ds, ok := node.flowgraphManager.getFlowgraphService(segReqs[0].GetChannelName())
if !ok {
log.Warn("channel not found in current dataNode",
zap.String("channel name", segReqs[0].GetChannelName()),
zap.Int64("node ID", node.NodeID))
return errors.New("channel " + segReqs[0].GetChannelName() + " not found in current dataNode")
}
// Update flow graph replica segment info.
// TODO: Duplicate code. Add wrapper function.
if !ds.replica.hasSegment(segmentID, true) {
err = ds.replica.addNewSegment(segmentID,
req.GetImportTask().GetCollectionId(),
req.GetImportTask().GetPartitionId(),
segReqs[0].GetChannelName(),
&internalpb.MsgPosition{
ChannelName: segReqs[0].GetChannelName(),
},
&internalpb.MsgPosition{
ChannelName: segReqs[0].GetChannelName(),
})
if err != nil {
log.Error("failed to add segment",
zap.Int64("segment ID", segmentID),
zap.Int64("collection ID", req.GetImportTask().GetCollectionId()),
zap.Int64("partition ID", req.GetImportTask().GetPartitionId()),
zap.String("channel mame", segReqs[0].GetChannelName()),
zap.Error(err))
}
}
ds.replica.updateStatistics(segmentID, int64(rowNum))
req := &datapb.SaveBinlogPathsRequest{ req := &datapb.SaveBinlogPathsRequest{
Base: &commonpb.MsgBase{ Base: &commonpb.MsgBase{
MsgType: 0, //TODO msg type MsgType: 0, //TODO msg type
@ -1030,7 +1069,6 @@ func importFlushReqFunc(node *DataNode, req *datapb.ImportTaskRequest, res *root
Field2BinlogPaths: fieldInsert, Field2BinlogPaths: fieldInsert,
Field2StatslogPaths: fieldStats, Field2StatslogPaths: fieldStats,
Importing: true, Importing: true,
Flushed: true,
} }
err = retry.Do(context.Background(), func() error { err = retry.Do(context.Background(), func() error {

58
internal/datanode/data_node_test.go
View File

@ -236,7 +236,7 @@ func TestDataNode(t *testing.T) {
// dup call // dup call
status, err := node1.FlushSegments(node1.ctx, req) status, err := node1.FlushSegments(node1.ctx, req)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, status.ErrorCode) assert.Equal(t, commonpb.ErrorCode_UnexpectedError, status.ErrorCode)
// failure call // failure call
req = &datapb.FlushSegmentsRequest{ req = &datapb.FlushSegmentsRequest{
@ -356,6 +356,62 @@ func TestDataNode(t *testing.T) {
assert.Equal(t, "", stat.GetReason()) assert.Equal(t, "", stat.GetReason())
}) })
t.Run("Test Import w/ bad flow graph", func(t *testing.T) {
node.rootCoord = &RootCoordFactory{
collectionID: 100,
pkType: schemapb.DataType_Int64,
}
chName1 := "fake-by-dev-rootcoord-dml-testimport-1"
chName2 := "fake-by-dev-rootcoord-dml-testimport-2"
err := node.flowgraphManager.addAndStart(node, &datapb.VchannelInfo{
CollectionID: 100,
ChannelName: chName1,
UnflushedSegments: []*datapb.SegmentInfo{},
FlushedSegments: []*datapb.SegmentInfo{},
})
require.Nil(t, err)
err = node.flowgraphManager.addAndStart(node, &datapb.VchannelInfo{
CollectionID: 999, // wrong collection ID.
ChannelName: chName2,
UnflushedSegments: []*datapb.SegmentInfo{},
FlushedSegments: []*datapb.SegmentInfo{},
})
require.Nil(t, err)
_, ok := node.flowgraphManager.getFlowgraphService(chName1)
assert.True(t, ok)
_, ok = node.flowgraphManager.getFlowgraphService(chName2)
assert.True(t, ok)
content := []byte(`{
"rows":[
{"bool_field": true, "int8_field": 10, "int16_field": 101, "int32_field": 1001, "int64_field": 10001, "float32_field": 3.14, "float64_field": 1.56, "varChar_field": "hello world", "binary_vector_field": [254, 0, 254, 0], "float_vector_field": [1.1, 1.2]},
{"bool_field": false, "int8_field": 11, "int16_field": 102, "int32_field": 1002, "int64_field": 10002, "float32_field": 3.15, "float64_field": 2.56, "varChar_field": "hello world", "binary_vector_field": [253, 0, 253, 0], "float_vector_field": [2.1, 2.2]},
{"bool_field": true, "int8_field": 12, "int16_field": 103, "int32_field": 1003, "int64_field": 10003, "float32_field": 3.16, "float64_field": 3.56, "varChar_field": "hello world", "binary_vector_field": [252, 0, 252, 0], "float_vector_field": [3.1, 3.2]},
{"bool_field": false, "int8_field": 13, "int16_field": 104, "int32_field": 1004, "int64_field": 10004, "float32_field": 3.17, "float64_field": 4.56, "varChar_field": "hello world", "binary_vector_field": [251, 0, 251, 0], "float_vector_field": [4.1, 4.2]},
{"bool_field": true, "int8_field": 14, "int16_field": 105, "int32_field": 1005, "int64_field": 10005, "float32_field": 3.18, "float64_field": 5.56, "varChar_field": "hello world", "binary_vector_field": [250, 0, 250, 0], "float_vector_field": [5.1, 5.2]}
]
}`)
filePath := "import/rows_1.json"
err = node.chunkManager.Write(filePath, content)
assert.NoError(t, err)
req := &datapb.ImportTaskRequest{
ImportTask: &datapb.ImportTask{
CollectionId: 100,
PartitionId: 100,
ChannelNames: []string{chName1, chName2},
Files: []string{filePath},
RowBased: true,
},
}
stat, err := node.Import(context.WithValue(ctx, ctxKey{}, ""), req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, stat.GetErrorCode())
assert.Equal(t, "", stat.GetReason())
})
t.Run("Test Import report import error", func(t *testing.T) { t.Run("Test Import report import error", func(t *testing.T) {
node.rootCoord = &RootCoordFactory{ node.rootCoord = &RootCoordFactory{
collectionID: 100, collectionID: 100,

4
internal/datanode/flow_graph_insert_buffer_node.go
View File

@ -306,10 +306,10 @@ func (ibNode *insertBufferNode) Operate(in []Msg) []Msg {
select { select {
case fmsg := <-ibNode.flushChan: case fmsg := <-ibNode.flushChan:
log.Info(". Receiving flush message", log.Info("receiving flush message",
zap.Int64("segmentID", fmsg.segmentID), zap.Int64("segmentID", fmsg.segmentID),
zap.Int64("collectionID", fmsg.collectionID), zap.Int64("collectionID", fmsg.collectionID),
zap.String("vchannel name", ibNode.channelName), zap.String("v-channel name", ibNode.channelName),
) )
// merging auto&manual flush segment same segment id // merging auto&manual flush segment same segment id
dup := false dup := false

1
internal/proto/data_coord.proto
View File

@ -69,6 +69,7 @@ service DataNode {
message FlushRequest { message FlushRequest {
common.MsgBase base = 1; common.MsgBase base = 1;
int64 dbID = 2; int64 dbID = 2;
repeated int64 segmentIDs = 3;
int64 collectionID = 4; int64 collectionID = 4;
} }

432
internal/proto/datapb/data_coord.pb.go
View File

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

28
internal/rootcoord/import_manager_test.go
View File

@ -18,6 +18,7 @@ package rootcoord
import ( import (
"context" "context"
"errors"
"sync" "sync"
"testing" "testing"
"time" "time"
@ -307,3 +308,30 @@ func TestImportManager_TaskState(t *testing.T) {
assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode) assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
assert.Equal(t, commonpb.ImportState_ImportPending, resp.State) assert.Equal(t, commonpb.ImportState_ImportPending, resp.State)
} }
func TestImportManager_AllocFail(t *testing.T) {
var idAlloc = func(count uint32) (typeutil.UniqueID, typeutil.UniqueID, error) {
return 0, 0, errors.New("injected failure")
}
Params.RootCoordCfg.ImportTaskSubPath = "test_import_task"
colID := int64(100)
mockKv := &kv.MockMetaKV{}
mockKv.InMemKv = make(map[string]string)
fn := func(ctx context.Context, req *datapb.ImportTaskRequest) *datapb.ImportTaskResponse {
return &datapb.ImportTaskResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
}
}
rowReq := &milvuspb.ImportRequest{
CollectionName: "c1",
PartitionName: "p1",
RowBased: true,
Files: []string{"f1", "f2", "f3"},
}
mgr := newImportManager(context.TODO(), mockKv, idAlloc, fn)
mgr.importJob(context.TODO(), rowReq, colID, 0)
}

29
internal/rootcoord/root_coord.go
View File

@ -19,6 +19,7 @@ package rootcoord
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"errors"
"fmt" "fmt"
"math/rand" "math/rand"
"os" "os"
@ -157,6 +158,9 @@ type Core struct {
//assign import task to data service //assign import task to data service
CallImportService func(ctx context.Context, req *datapb.ImportTaskRequest) *datapb.ImportTaskResponse CallImportService func(ctx context.Context, req *datapb.ImportTaskRequest) *datapb.ImportTaskResponse
// Seals segments in collection cID, so they can get flushed later.
CallFlushOnCollection func(ctx context.Context, cID int64, segIDs []int64) error
//Proxy manager //Proxy manager
proxyManager *proxyManager proxyManager *proxyManager
@ -728,6 +732,7 @@ func (c *Core) SetDataCoord(ctx context.Context, s types.DataCoord) error {
} }
return nil return nil
} }
c.CallImportService = func(ctx context.Context, req *datapb.ImportTaskRequest) *datapb.ImportTaskResponse { c.CallImportService = func(ctx context.Context, req *datapb.ImportTaskRequest) *datapb.ImportTaskResponse {
resp := &datapb.ImportTaskResponse{ resp := &datapb.ImportTaskResponse{
Status: &commonpb.Status{ Status: &commonpb.Status{
@ -750,6 +755,26 @@ func (c *Core) SetDataCoord(ctx context.Context, s types.DataCoord) error {
return resp return resp
} }
c.CallFlushOnCollection = func(ctx context.Context, cID int64, segIDs []int64) error {
resp, err := s.Flush(ctx, &datapb.FlushRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_Flush,
SourceID: c.session.ServerID,
},
DbID: 0,
SegmentIDs: segIDs,
CollectionID: cID,
})
if err != nil {
return errors.New("failed to call flush to data coordinator: " + err.Error())
}
if resp.Status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(resp.Status.Reason)
}
log.Info("flush on collection succeed", zap.Int64("collection ID", cID))
return nil
}
return nil return nil
} }
@ -2335,9 +2360,7 @@ func (c *Core) ReportImport(ctx context.Context, ir *rootcoordpb.ImportResult) (
}() }()
// TODO: Resurrect index check when ready. // TODO: Resurrect index check when ready.
// Start a loop to check segments' index states periodically. c.CallFlushOnCollection(ctx, ti.GetCollectionId(), ir.GetSegments())
// c.wg.Add(1)
// go c.checkCompleteIndexLoop(ctx, ti, colName, ir.Segments)
return &commonpb.Status{ return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success, ErrorCode: commonpb.ErrorCode_Success,

9
internal/rootcoord/root_coord_test.go
View File

@ -200,6 +200,15 @@ func (d *dataMock) Import(ctx context.Context, req *datapb.ImportTaskRequest) (*
}, nil }, nil
} }
func (d *dataMock) Flush(ctx context.Context, req *datapb.FlushRequest) (*datapb.FlushResponse, error) {
return &datapb.FlushResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
},
}, nil
}
type queryMock struct { type queryMock struct {
types.QueryCoord types.QueryCoord
collID []typeutil.UniqueID collID []typeutil.UniqueID