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

Add flushed segments (#9476) 

Signed-off-by: godchen <qingxiang.chen@zilliz.com>
pull/9510/head
godchen 2021-10-08 19:09:12 +08:00 committed by GitHub
parent f4e0736e01
commit 937dbf4279
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 274 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
internal/datacoord/datanode_helper.go
View File

@ -36,7 +36,7 @@ func (dp dummyPosProvider) GetVChanPositions(vchans []vchannel, seekFromStartPos
pairs = append(pairs, &datapb.VchannelInfo{
CollectionID: vchan.CollectionID,
ChannelName: vchan.DmlChannel,
FlushedSegments: []int64{},
FlushedSegments: []*datapb.SegmentInfo{},
UnflushedSegments: []*datapb.SegmentInfo{},
})
}

6
internal/datacoord/server.go
View File

@ -637,13 +637,13 @@ func (s *Server) GetVChanPositions(vchans []vchannel, seekFromStartPosition bool
for _, vchan := range vchans {
segments := s.meta.GetSegmentsByChannel(vchan.DmlChannel)
flushedSegmentIDs := make([]UniqueID, 0)
flushed := make([]*datapb.SegmentInfo, 0)
unflushed := make([]*datapb.SegmentInfo, 0)
var seekPosition *internalpb.MsgPosition
var useUnflushedPosition bool
for _, s := range segments {
if s.State == commonpb.SegmentState_Flushing || s.State == commonpb.SegmentState_Flushed {
flushedSegmentIDs = append(flushedSegmentIDs, s.ID)
flushed = append(flushed, s.SegmentInfo)
if seekPosition == nil || (!useUnflushedPosition && s.DmlPosition.Timestamp > seekPosition.Timestamp) {
seekPosition = s.DmlPosition
}
@ -685,7 +685,7 @@ func (s *Server) GetVChanPositions(vchans []vchannel, seekFromStartPosition bool
ChannelName: vchan.DmlChannel,
SeekPosition: seekPosition,
UnflushedSegments: unflushed,
FlushedSegments: flushedSegmentIDs,
FlushedSegments: flushed,
})
}
return pairs, nil

4
internal/datacoord/server_test.go
View File

@ -1097,7 +1097,7 @@ func TestGetVChannelPos(t *testing.T) {
assert.EqualValues(t, 1, len(pair))
assert.EqualValues(t, 0, pair[0].CollectionID)
assert.EqualValues(t, 1, len(pair[0].FlushedSegments))
assert.EqualValues(t, 1, pair[0].FlushedSegments[0])
assert.EqualValues(t, s1, pair[0].FlushedSegments[0])
assert.EqualValues(t, 1, len(pair[0].UnflushedSegments))
assert.EqualValues(t, 2, pair[0].UnflushedSegments[0].ID)
assert.EqualValues(t, []byte{1, 2, 3}, pair[0].UnflushedSegments[0].DmlPosition.MsgID)
@ -1173,7 +1173,7 @@ func TestGetRecoveryInfo(t *testing.T) {
assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
assert.EqualValues(t, 1, len(resp.GetChannels()))
assert.EqualValues(t, 0, len(resp.GetChannels()[0].GetUnflushedSegments()))
assert.ElementsMatch(t, []UniqueID{0, 1}, resp.GetChannels()[0].GetFlushedSegments())
assert.ElementsMatch(t, []*datapb.SegmentInfo{seg1, seg2}, resp.GetChannels()[0].GetFlushedSegments())
assert.EqualValues(t, 20, resp.GetChannels()[0].GetSeekPosition().GetTimestamp())
})

2
internal/datanode/data_node_test.go
View File

@ -208,7 +208,7 @@ func TestDataNode(t *testing.T) {
CollectionID: 1,
ChannelName: dmChannelName,
UnflushedSegments: []*datapb.SegmentInfo{},
FlushedSegments: []int64{},
FlushedSegments: []*datapb.SegmentInfo{},
}
err := node1.NewDataSyncService(vchan)
assert.Nil(t, err)

21
internal/datanode/data_sync_service.go
View File

@ -217,6 +217,27 @@ func (dsService *dataSyncService) initNodes(vchanInfo *datapb.VchannelInfo) erro
us.GetNumOfRows(), &segmentCheckPoint{us.GetNumOfRows(), *us.GetDmlPosition()})
}
for _, fs := range vchanInfo.GetFlushedSegments() {
if fs.CollectionID != dsService.collectionID ||
fs.GetInsertChannel() != vchanInfo.ChannelName {
log.Warn("Collection ID or ChannelName not compact",
zap.Int64("Wanted ID", dsService.collectionID),
zap.Int64("Actual ID", fs.CollectionID),
zap.String("Wanted Channel Name", vchanInfo.ChannelName),
zap.String("Actual Channel Name", fs.GetInsertChannel()),
)
continue
}
log.Info("Recover Segment NumOfRows form checkpoints",
zap.String("InsertChannel", fs.GetInsertChannel()),
zap.Int64("SegmentID", fs.GetID()),
zap.Int64("NumOfRows", fs.GetNumOfRows()),
)
dsService.replica.addFlushedSegment(fs.GetID(), fs.CollectionID, fs.PartitionID, fs.GetInsertChannel(),
fs.GetNumOfRows())
}
dsService.fg.AddNode(dmStreamNode)
dsService.fg.AddNode(ddNode)
dsService.fg.AddNode(insertBufferNode)

113
internal/datanode/data_sync_service_test.go
View File

@ -25,15 +25,24 @@ import (
"github.com/milvus-io/milvus/internal/proto/internalpb"
)
func getVchanInfo(cp bool, collID, ufCollID, ufSegID UniqueID, chanName, ufchanName string, ufNor int64) *datapb.VchannelInfo {
func getVchanInfo(info *testInfo) *datapb.VchannelInfo {
var ufs []*datapb.SegmentInfo
if cp {
var fs []*datapb.SegmentInfo
if info.isValidCase {
ufs = []*datapb.SegmentInfo{{
CollectionID: ufCollID,
CollectionID: info.ufCollID,
PartitionID: 1,
InsertChannel: ufchanName,
ID: ufSegID,
NumOfRows: ufNor,
InsertChannel: info.ufchanName,
ID: info.ufSegID,
NumOfRows: info.ufNor,
DmlPosition: &internalpb.MsgPosition{},
}}
fs = []*datapb.SegmentInfo{{
CollectionID: info.fCollID,
PartitionID: 1,
InsertChannel: info.fchanName,
ID: info.fSegID,
NumOfRows: info.fNor,
DmlPosition: &internalpb.MsgPosition{},
}}
} else {
@ -41,50 +50,70 @@ func getVchanInfo(cp bool, collID, ufCollID, ufSegID UniqueID, chanName, ufchanN
}
vi := &datapb.VchannelInfo{
CollectionID: collID,
ChannelName: chanName,
CollectionID: info.collID,
ChannelName: info.chanName,
SeekPosition: &internalpb.MsgPosition{},
UnflushedSegments: ufs,
FlushedSegments: []int64{},
FlushedSegments: fs,
}
return vi
}
type testInfo struct {
isValidCase bool
replicaNil bool
inMsgFactory msgstream.Factory
collID UniqueID
chanName string
ufCollID UniqueID
ufSegID UniqueID
ufchanName string
ufNor int64
fCollID UniqueID
fSegID UniqueID
fchanName string
fNor int64
description string
}
func TestDataSyncService_newDataSyncService(te *testing.T) {
ctx := context.Background()
tests := []struct {
isValidCase bool
replicaNil bool
inMsgFactory msgstream.Factory
collID UniqueID
ufCollID UniqueID
ufSegID UniqueID
chanName string
ufchanName string
ufNor int64
description string
}{
tests := []*testInfo{
{false, false, &mockMsgStreamFactory{false, true},
0, 0, 0, "", "", 0,
0, "",
0, 0, "", 0,
0, 0, "", 0,
"SetParamsReturnError"},
{true, false, &mockMsgStreamFactory{true, true},
0, 1, 0, "", "", 0,
0, "",
1, 0, "", 0,
1, 1, "", 0,
"CollID 0 mismach with seginfo collID 1"},
{true, false, &mockMsgStreamFactory{true, true},
1, 1, 0, "c1", "c2", 0,
1, "c1",
1, 0, "c2", 0,
1, 1, "c3", 0,
"chanName c1 mismach with seginfo chanName c2"},
{true, false, &mockMsgStreamFactory{true, true},
1, 1, 0, "c1", "c1", 0,
1, "c1",
1, 0, "c1", 0,
1, 1, "c2", 0,
"add normal segments"},
{false, false, &mockMsgStreamFactory{true, false},
0, 0, 0, "", "", 0,
0, "",
0, 0, "", 0,
0, 0, "", 0,
"error when newinsertbufernode"},
{false, true, &mockMsgStreamFactory{true, false},
0, 0, 0, "", "", 0,
0, "",
0, 0, "", 0,
0, 0, "", 0,
"replica nil"},
}
@ -102,7 +131,7 @@ func TestDataSyncService_newDataSyncService(te *testing.T) {
replica,
NewAllocatorFactory(),
test.inMsgFactory,
getVchanInfo(test.isValidCase, test.collID, test.ufCollID, test.ufSegID, test.chanName, test.ufchanName, test.ufNor),
getVchanInfo(test),
make(chan UniqueID),
df,
newCache(),
@ -148,7 +177,6 @@ func TestDataSyncService_newDataSyncService(te *testing.T) {
// NOTE: start pulsar before test
func TestDataSyncService_Start(t *testing.T) {
t.Skip()
const ctxTimeInMillisecond = 2000
delay := time.Now().Add(ctxTimeInMillisecond * time.Millisecond)
@ -179,11 +207,28 @@ func TestDataSyncService_Start(t *testing.T) {
ddlChannelName := "data_sync_service_test_ddl"
Params.FlushInsertBufferSize = 1
ufs := []*datapb.SegmentInfo{{
CollectionID: collMeta.ID,
InsertChannel: insertChannelName,
ID: 0,
NumOfRows: 0,
DmlPosition: &internalpb.MsgPosition{},
}}
fs := []*datapb.SegmentInfo{{
CollectionID: collMeta.ID,
PartitionID: 1,
InsertChannel: insertChannelName,
ID: 1,
NumOfRows: 0,
DmlPosition: &internalpb.MsgPosition{},
}}
vchan := &datapb.VchannelInfo{
CollectionID: collMeta.GetID(),
CollectionID: collMeta.ID,
ChannelName: insertChannelName,
UnflushedSegments: []*datapb.SegmentInfo{},
FlushedSegments: []int64{},
SeekPosition: &internalpb.MsgPosition{},
UnflushedSegments: ufs,
FlushedSegments: fs,
}
signalCh := make(chan UniqueID, 100)

8
internal/datanode/flow_graph_dd_node.go
View File

@ -50,7 +50,7 @@ type ddNode struct {
collectionID UniqueID
segID2SegInfo sync.Map // segment ID to *SegmentInfo
flushedSegments []UniqueID
flushedSegments []*datapb.SegmentInfo
}
// Name returns node name, implementing flowgraph.Node
@ -148,8 +148,8 @@ func (ddn *ddNode) filterFlushedSegmentInsertMessages(msg *msgstream.InsertMsg)
}
func (ddn *ddNode) isFlushed(segmentID UniqueID) bool {
for _, id := range ddn.flushedSegments {
if id == segmentID {
for _, s := range ddn.flushedSegments {
if s.ID == segmentID {
return true
}
}
@ -160,7 +160,7 @@ func newDDNode(clearSignal chan<- UniqueID, collID UniqueID, vchanInfo *datapb.V
baseNode := BaseNode{}
baseNode.SetMaxParallelism(Params.FlowGraphMaxQueueLength)
fs := make([]UniqueID, 0, len(vchanInfo.GetFlushedSegments()))
fs := make([]*datapb.SegmentInfo, 0, len(vchanInfo.GetFlushedSegments()))
fs = append(fs, vchanInfo.GetFlushedSegments()...)
log.Debug("ddNode add flushed segment",
zap.Int64("collectionID", vchanInfo.GetCollectionID()),

40
internal/datanode/flow_graph_dd_node_test.go
View File

@ -28,18 +28,19 @@ func TestFlowGraph_DDNode_newDDNode(te *testing.T) {
inCollID UniqueID
inFlushedSegs []UniqueID
inFlushedChannelTs Timestamp
inUnFlushedSegID UniqueID
inUnFlushedChannelTs Timestamp
description string
}{
{UniqueID(1), []UniqueID{100, 101, 102}, 200, 666666,
{UniqueID(1), []UniqueID{100, 101, 102}, 666666, 200, 666666,
"Input VchannelInfo with 3 flushed segs and 1 unflushed seg"},
{UniqueID(2), []UniqueID{103}, 200, 666666,
{UniqueID(2), []UniqueID{103}, 666666, 200, 666666,
"Input VchannelInfo with 1 flushed seg and 1 unflushed seg"},
{UniqueID(3), []UniqueID{}, 200, 666666,
{UniqueID(3), []UniqueID{}, 666666, 200, 666666,
"Input VchannelInfo with 0 flushed segs and 1 unflushed seg"},
{UniqueID(3), []UniqueID{104}, 0, 0,
{UniqueID(3), []UniqueID{104}, 666666, 0, 0,
"Input VchannelInfo with 1 flushed seg and empty unflushed seg"},
}
@ -52,19 +53,29 @@ func TestFlowGraph_DDNode_newDDNode(te *testing.T) {
di.DmlPosition = &internalpb.MsgPosition{Timestamp: test.inUnFlushedChannelTs}
}
fi := []*datapb.SegmentInfo{}
for _, id := range test.inFlushedSegs {
s := &datapb.SegmentInfo{ID: id}
fi = append(fi, s)
}
ddNode := newDDNode(
make(chan UniqueID),
test.inCollID,
&datapb.VchannelInfo{
FlushedSegments: test.inFlushedSegs,
FlushedSegments: fi,
UnflushedSegments: []*datapb.SegmentInfo{di},
},
)
flushedSegIDs := make([]int64, 0)
for _, seg := range ddNode.flushedSegments {
flushedSegIDs = append(flushedSegIDs, seg.ID)
}
assert.Equal(t, "ddNode", ddNode.Name())
assert.Equal(t, test.inCollID, ddNode.collectionID)
assert.Equal(t, len(test.inFlushedSegs), len(ddNode.flushedSegments))
assert.ElementsMatch(t, test.inFlushedSegs, ddNode.flushedSegments)
assert.ElementsMatch(t, test.inFlushedSegs, flushedSegIDs)
si, ok := ddNode.segID2SegInfo.Load(test.inUnFlushedSegID)
assert.True(t, ok)
@ -169,9 +180,10 @@ func TestFlowGraph_DDNode_Operate(to *testing.T) {
for _, test := range tests {
te.Run(test.description, func(t *testing.T) {
fs := &datapb.SegmentInfo{ID: test.ddnFlushedSegment}
// Prepare ddNode states
ddn := ddNode{
flushedSegments: []UniqueID{test.ddnFlushedSegment},
flushedSegments: []*datapb.SegmentInfo{fs},
collectionID: test.ddnCollID,
}
FilterThreshold = test.threshold
@ -226,9 +238,14 @@ func TestFlowGraph_DDNode_filterMessages(te *testing.T) {
for _, test := range tests {
te.Run(test.description, func(t *testing.T) {
fs := []*datapb.SegmentInfo{}
for _, id := range test.ddnFlushedSegments {
s := &datapb.SegmentInfo{ID: id}
fs = append(fs, s)
}
// Prepare ddNode states
ddn := ddNode{
flushedSegments: test.ddnFlushedSegments,
flushedSegments: fs,
}
for k, v := range test.ddnSegID2Ts {
@ -281,7 +298,12 @@ func TestFlowGraph_DDNode_isFlushed(te *testing.T) {
for _, test := range tests {
te.Run(test.description, func(t *testing.T) {
ddn := &ddNode{flushedSegments: test.influshedSegment}
fs := []*datapb.SegmentInfo{}
for _, id := range test.influshedSegment {
s := &datapb.SegmentInfo{ID: id}
fs = append(fs, s)
}
ddn := &ddNode{flushedSegments: fs}
assert.Equal(t, test.expectedOut, ddn.isFlushed(test.inSeg))
})
}

1
internal/datanode/segment_replica.go
View File

@ -44,6 +44,7 @@ type Replica interface {
addNewSegment(segID, collID, partitionID UniqueID, channelName string, startPos, endPos *internalpb.MsgPosition) error
addNormalSegment(segID, collID, partitionID UniqueID, channelName string, numOfRows int64, cp *segmentCheckPoint) error
filterSegments(channelName string, partitionID UniqueID) []*Segment
addFlushedSegment(segID, collID, partitionID UniqueID, channelName string, numOfRows int64) error
listNewSegmentsStartPositions() []*datapb.SegmentStartPosition
listSegmentsCheckPoints() map[UniqueID]segmentCheckPoint
updateSegmentEndPosition(segID UniqueID, endPos *internalpb.MsgPosition)

2
internal/proto/data_coord.proto
View File

@ -158,7 +158,7 @@ message VchannelInfo {
string channelName = 2;
internal.MsgPosition seek_position = 3;
repeated SegmentInfo unflushedSegments = 4;
repeated int64 flushedSegments = 5;
repeated SegmentInfo flushedSegments = 5;
}
message WatchDmChannelsRequest {

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

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

2
internal/querycoord/mock_3rd_component_test.go
View File

@ -339,7 +339,7 @@ func (data *dataCoordMock) GetRecoveryInfo(ctx context.Context, req *datapb.GetR
SeekPosition: &internalpb.MsgPosition{
ChannelName: vChannel,
},
FlushedSegments: []int64{segmentID},
FlushedSegments: []*datapb.SegmentInfo{{ID: segmentID}},
}
channelInfos = append(channelInfos, channelInfo)
}

2
internal/querycoord/task.go
View File

@ -1532,7 +1532,7 @@ func mergeVChannelInfo(info1 *datapb.VchannelInfo, info2 *datapb.VchannelInfo) *
checkPoints = append(checkPoints, info1.UnflushedSegments...)
checkPoints = append(checkPoints, info2.UnflushedSegments...)
flushedSegments := make([]UniqueID, 0)
flushedSegments := make([]*datapb.SegmentInfo, 0)
flushedSegments = append(flushedSegments, info1.FlushedSegments...)
flushedSegments = append(flushedSegments, info2.FlushedSegments...)