Fix lost delete msg caused by loadSegment after watchDeltaChannel (#17308)

Signed-off-by: Nxige-16 <xi.ge@zilliz.com>

internal/mq/msgstream/repack_func.go

@@ -19,7 +19,6 @@ package msgstream
 import (
 	"errors"
 	"fmt"
-	"strconv"
 
 	"github.com/milvus-io/milvus/internal/proto/commonpb"
 )
@@ -72,9 +71,6 @@ func DeleteRepackFunc(tsMsgs []TsMsg, hashKeys [][]int32) (map[int32]*MsgPack, e
 		if keysLen != timestampLen || int64(keysLen) != deleteRequest.NumRows {
 			return nil, errors.New("the length of hashValue, timestamps, primaryKeys are not equal")
 		}
-		if keysLen != 1 {
-			return nil, errors.New("len(msg.hashValue) must equal 1, but it is: " + strconv.Itoa(keysLen))
-		}
 
 		key := keys[0]
 		_, ok := result[key]

internal/proto/query_coord.proto

@@ -218,6 +218,7 @@ message LoadSegmentsRequest {
   int64 collectionID = 6;
   LoadMetaInfo load_meta = 7;
   int64 replicaID = 8;
+  repeated internal.MsgPosition delta_positions = 9;
 }
 
 message ReleaseSegmentsRequest {

internal/proto/querypb/query_coord.pb.go

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

internal/querycoord/cluster.go

@@ -33,9 +33,11 @@ import (
 	"github.com/milvus-io/milvus/internal/log"
 	"github.com/milvus-io/milvus/internal/metrics"
 	"github.com/milvus-io/milvus/internal/proto/commonpb"
+	"github.com/milvus-io/milvus/internal/proto/datapb"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
 	"github.com/milvus-io/milvus/internal/proto/milvuspb"
 	"github.com/milvus-io/milvus/internal/proto/querypb"
+	"github.com/milvus-io/milvus/internal/util/funcutil"
 	"github.com/milvus-io/milvus/internal/util/sessionutil"
 	"github.com/milvus-io/milvus/internal/util/typeutil"
 )
@@ -210,6 +212,48 @@ func (c *queryNodeCluster) LoadSegments(ctx context.Context, nodeID int64, in *q
 	c.RUnlock()
 
 	if targetNode != nil {
+		collectionID := in.CollectionID
+		// if node has watched the collection's deltaChannel
+		// then the node should recover part delete log from dmChanel
+		if c.HasWatchedDeltaChannel(ctx, nodeID, collectionID) {
+			// get all deltaChannelInfo of the collection from meta
+			deltaChannelInfos, err := c.clusterMeta.getDeltaChannelsByCollectionID(collectionID)
+			if err != nil {
+				// this case should not happen
+				// deltaChannelInfos should have been set to meta before executing child tasks
+				log.Error("loadSegments: failed to get deltaChannelInfo from meta", zap.Error(err))
+				return err
+			}
+			deltaChannel2Info := make(map[string]*datapb.VchannelInfo, len(deltaChannelInfos))
+			for _, info := range deltaChannelInfos {
+				deltaChannel2Info[info.ChannelName] = info
+			}
+
+			// check delta channel which should be reloaded
+			reloadDeltaChannels := make(map[string]struct{})
+			for _, segment := range in.Infos {
+				// convert vChannel to deltaChannel
+				deltaChannelName, err := funcutil.ConvertChannelName(segment.InsertChannel, Params.CommonCfg.RootCoordDml, Params.CommonCfg.RootCoordDelta)
+				if err != nil {
+					return err
+				}
+
+				reloadDeltaChannels[deltaChannelName] = struct{}{}
+			}
+
+			in.DeltaPositions = make([]*internalpb.MsgPosition, 0)
+			for deltaChannelName := range reloadDeltaChannels {
+				if info, ok := deltaChannel2Info[deltaChannelName]; ok {
+					in.DeltaPositions = append(in.DeltaPositions, info.SeekPosition)
+				} else {
+					// this case should not happen
+					err = fmt.Errorf("loadSegments: can't find deltaChannelInfo, channel name = %s", deltaChannelName)
+					log.Error(err.Error())
+					return err
+				}
+			}
+		}
+
 		err := targetNode.loadSegments(ctx, in)
 		if err != nil {
 			log.Warn("loadSegments: queryNode load segments error", zap.Int64("nodeID", nodeID), zap.String("error info", err.Error()))

internal/querycoord/cluster_test.go

@@ -27,8 +27,7 @@ import (
 	"sync/atomic"
 	"testing"
 
-	"github.com/milvus-io/milvus/internal/util/dependency"
-	"github.com/milvus-io/milvus/internal/util/indexcgowrapper"
+	"github.com/stretchr/testify/assert"
 
 	etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
 	"github.com/milvus-io/milvus/internal/log"
@@ -36,13 +35,15 @@ import (
 	"github.com/milvus-io/milvus/internal/proto/datapb"
 	"github.com/milvus-io/milvus/internal/proto/etcdpb"
 	"github.com/milvus-io/milvus/internal/proto/indexpb"
+	"github.com/milvus-io/milvus/internal/proto/internalpb"
 	"github.com/milvus-io/milvus/internal/proto/querypb"
 	"github.com/milvus-io/milvus/internal/proto/schemapb"
 	"github.com/milvus-io/milvus/internal/storage"
+	"github.com/milvus-io/milvus/internal/util/dependency"
 	"github.com/milvus-io/milvus/internal/util/etcd"
+	"github.com/milvus-io/milvus/internal/util/indexcgowrapper"
 	"github.com/milvus-io/milvus/internal/util/sessionutil"
 	"github.com/milvus-io/milvus/internal/util/typeutil"
-	"github.com/stretchr/testify/assert"
 )
 
 const (
@@ -426,6 +427,17 @@ func TestGrpcRequest(t *testing.T) {
 	}
 	meta, err := newMeta(baseCtx, kv, factory, idAllocator)
 	assert.Nil(t, err)
+	deltaChannelInfo := []*datapb.VchannelInfo{
+		{
+			CollectionID: defaultCollectionID,
+			ChannelName:  "by-dev-rootcoord-delta_1_2021v1",
+			SeekPosition: &internalpb.MsgPosition{
+				ChannelName: "by-dev-rootcoord-dml_1",
+			},
+		},
+	}
+	err = meta.setDeltaChannel(defaultCollectionID, deltaChannelInfo)
+	assert.Nil(t, err)
 
 	handler, err := newChannelUnsubscribeHandler(baseCtx, kv, factory)
 	assert.Nil(t, err)
@@ -471,10 +483,39 @@ func TestGrpcRequest(t *testing.T) {
 
 	t.Run("Test LoadSegments", func(t *testing.T) {
 		segmentLoadInfo := &querypb.SegmentLoadInfo{
-			SegmentID:    defaultSegmentID,
-			PartitionID:  defaultPartitionID,
+			SegmentID:     defaultSegmentID,
+			PartitionID:   defaultPartitionID,
+			CollectionID:  defaultCollectionID,
+			InsertChannel: "by-dev-rootcoord-dml_1_2021v1",
+		}
+		loadSegmentReq := &querypb.LoadSegmentsRequest{
+			DstNodeID:    nodeID,
+			Infos:        []*querypb.SegmentLoadInfo{segmentLoadInfo},
+			Schema:       genDefaultCollectionSchema(false),
 			CollectionID: defaultCollectionID,
 		}
+		err := cluster.LoadSegments(baseCtx, nodeID, loadSegmentReq)
+		assert.Equal(t, 0, len(loadSegmentReq.DeltaPositions))
+		assert.Nil(t, err)
+	})
+
+	t.Run("Test WatchDeletaChannel", func(t *testing.T) {
+		watchDeltaChannelReq := &querypb.WatchDeltaChannelsRequest{
+			CollectionID: defaultCollectionID,
+			Infos:        deltaChannelInfo,
+		}
+		err := cluster.WatchDeltaChannels(baseCtx, nodeID, watchDeltaChannelReq)
+		assert.Nil(t, err)
+		assert.Equal(t, true, cluster.HasWatchedDeltaChannel(baseCtx, nodeID, defaultCollectionID))
+	})
+
+	t.Run("Test LoadSegmentsAfterWatchDeltaChannel", func(t *testing.T) {
+		segmentLoadInfo := &querypb.SegmentLoadInfo{
+			SegmentID:     defaultSegmentID,
+			PartitionID:   defaultPartitionID,
+			CollectionID:  defaultCollectionID,
+			InsertChannel: "by-dev-rootcoord-dml_1_2021v1",
+		}
 		loadSegmentReq := &querypb.LoadSegmentsRequest{
 			DstNodeID:    nodeID,
 			Infos:        []*querypb.SegmentLoadInfo{segmentLoadInfo},
@@ -482,6 +523,7 @@ func TestGrpcRequest(t *testing.T) {
 			CollectionID: defaultCollectionID,
 		}
 		err := cluster.LoadSegments(baseCtx, nodeID, loadSegmentReq)
+		assert.Equal(t, 1, len(loadSegmentReq.DeltaPositions))
 		assert.Nil(t, err)
 	})
 

internal/querycoord/meta.go

@@ -923,6 +923,13 @@ func (m *MetaReplica) getDeltaChannelsByCollectionID(collectionID UniqueID) ([]*
 func (m *MetaReplica) setDeltaChannel(collectionID UniqueID, infos []*datapb.VchannelInfo) error {
 	m.deltaChannelMu.Lock()
 	defer m.deltaChannelMu.Unlock()
+
+	if len(infos) == 0 {
+		err := fmt.Errorf("set empty delta channel info to meta of collection %d", collectionID)
+		log.Error(err.Error())
+		return err
+	}
+
 	_, ok := m.deltaChannelInfos[collectionID]
 	if ok {
 		log.Debug("delta channel already exist", zap.Any("collectionID", collectionID))

internal/querycoord/mock_3rd_component_test.go

@@ -36,7 +36,6 @@ import (
 	"github.com/milvus-io/milvus/internal/proto/schemapb"
 	"github.com/milvus-io/milvus/internal/storage"
 	"github.com/milvus-io/milvus/internal/types"
-	"github.com/milvus-io/milvus/internal/util/funcutil"
 	"github.com/milvus-io/milvus/internal/util/typeutil"
 )
 
@@ -374,9 +373,8 @@ func (data *dataCoordMock) GetRecoveryInfo(ctx context.Context, req *datapb.GetR
 	if _, ok := data.col2DmChannels[collectionID]; !ok {
 		channelInfos := make([]*datapb.VchannelInfo, 0)
 		data.collections = append(data.collections, collectionID)
-		collectionName := funcutil.RandomString(8)
 		for i := int32(0); i < common.DefaultShardsNum; i++ {
-			vChannel := fmt.Sprintf("Dml_%s_%d_%d_v", collectionName, collectionID, i)
+			vChannel := fmt.Sprintf("%s_%d_%dv%d", Params.CommonCfg.RootCoordDml, i, collectionID, i)
 			channelInfo := &datapb.VchannelInfo{
 				CollectionID: collectionID,
 				ChannelName:  vChannel,

internal/querycoord/query_coord_test.go

@@ -54,8 +54,6 @@ func refreshParams() {
 	Params.CommonCfg.QueryNodeStats = Params.CommonCfg.QueryNodeStats + suffix
 	Params.CommonCfg.QueryCoordTimeTick = Params.CommonCfg.QueryCoordTimeTick + suffix
 	Params.EtcdCfg.MetaRootPath = Params.EtcdCfg.MetaRootPath + suffix
-	Params.CommonCfg.RootCoordDml = "Dml"
-	Params.CommonCfg.RootCoordDelta = "delta"
 	GlobalSegmentInfos = make(map[UniqueID]*querypb.SegmentInfo)
 }
 

internal/querycoord/task_scheduler_test.go

@@ -519,6 +519,16 @@ func Test_generateDerivedInternalTasks(t *testing.T) {
 	node1, err := startQueryNodeServer(baseCtx)
 	assert.Nil(t, err)
 	waitQueryNodeOnline(queryCoord.cluster, node1.queryNodeID)
+	vChannelInfos, _, err := queryCoord.broker.getRecoveryInfo(baseCtx, defaultCollectionID, defaultPartitionID)
+	assert.NoError(t, err)
+	deltaChannelInfos := make([]*datapb.VchannelInfo, len(vChannelInfos))
+	for i, info := range vChannelInfos {
+		deltaInfo, err := generateWatchDeltaChannelInfo(info)
+		assert.NoError(t, err)
+		deltaChannelInfos[i] = deltaInfo
+	}
+
+	queryCoord.meta.setDeltaChannel(defaultCollectionID, deltaChannelInfos)
 
 	loadCollectionTask := genLoadCollectionTask(baseCtx, queryCoord)
 	loadSegmentTask := genLoadSegmentTask(baseCtx, queryCoord, node1.queryNodeID)

internal/querycoord/task_test.go

@@ -37,7 +37,6 @@ import (
 )
 
 func genLoadCollectionTask(ctx context.Context, queryCoord *QueryCoord) *loadCollectionTask {
-	queryCoord.meta.setDeltaChannel(defaultCollectionID, nil)
 	req := &querypb.LoadCollectionRequest{
 		Base: &commonpb.MsgBase{
 			MsgType: commonpb.MsgType_LoadCollection,
@@ -58,7 +57,6 @@ func genLoadCollectionTask(ctx context.Context, queryCoord *QueryCoord) *loadCol
 }
 
 func genLoadPartitionTask(ctx context.Context, queryCoord *QueryCoord) *loadPartitionTask {
-	queryCoord.meta.setDeltaChannel(defaultCollectionID, nil)
 	req := &querypb.LoadPartitionsRequest{
 		Base: &commonpb.MsgBase{
 			MsgType: commonpb.MsgType_LoadPartitions,
@@ -195,7 +193,6 @@ func genWatchDmChannelTask(ctx context.Context, queryCoord *QueryCoord, nodeID i
 	return watchDmChannelTask
 }
 func genLoadSegmentTask(ctx context.Context, queryCoord *QueryCoord, nodeID int64) *loadSegmentTask {
-	queryCoord.meta.setDeltaChannel(defaultCollectionID, nil)
 	schema := genDefaultCollectionSchema(false)
 	segmentInfo := &querypb.SegmentLoadInfo{
 		SegmentID:    defaultSegmentID,
@@ -666,7 +663,6 @@ func Test_RescheduleSegment(t *testing.T) {
 
 	node1.loadSegment = returnFailedResult
 	loadSegmentTask := genLoadSegmentTask(ctx, queryCoord, node1.queryNodeID)
-	loadSegmentTask.meta.setDeltaChannel(defaultCollectionID, []*datapb.VchannelInfo{})
 	loadCollectionTask := loadSegmentTask.parentTask
 	queryCoord.scheduler.triggerTaskQueue.addTask(loadCollectionTask)
 
@@ -1445,8 +1441,7 @@ func Test_LoadSegment(t *testing.T) {
 	waitQueryNodeOnline(queryCoord.cluster, node1.queryNodeID)
 
 	loadSegmentTask := genLoadSegmentTask(ctx, queryCoord, node1.queryNodeID)
-	err = loadSegmentTask.meta.setDeltaChannel(111, []*datapb.VchannelInfo{})
-	assert.Nil(t, err)
+
 	loadCollectionTask := loadSegmentTask.parentTask
 	queryCoord.scheduler.triggerTaskQueue.addTask(loadCollectionTask)
 

internal/querynode/mock_test.go

@@ -23,6 +23,7 @@ import (
 	"fmt"
 	"math"
 	"math/rand"
+	"path"
 	"strconv"
 
 	"github.com/milvus-io/milvus/internal/util/dependency"
@@ -298,7 +299,7 @@ func loadIndexForSegment(ctx context.Context, node *QueryNode, segmentID UniqueI
 	schema := genTestCollectionSchema(pkType)
 
 	// generate insert binlog
-	fieldBinlog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, msgLength, schema)
+	fieldBinlog, _, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, msgLength, schema)
 	if err != nil {
 		return err
 	}
@@ -925,7 +926,7 @@ func genStorageBlob(collectionID UniqueID,
 	partitionID UniqueID,
 	segmentID UniqueID,
 	msgLength int,
-	schema *schemapb.CollectionSchema) ([]*storage.Blob, error) {
+	schema *schemapb.CollectionSchema) ([]*storage.Blob, []*storage.Blob, error) {
 	tmpSchema := &schemapb.CollectionSchema{
 		Name:   schema.Name,
 		AutoID: schema.AutoID,
@@ -936,11 +937,11 @@ func genStorageBlob(collectionID UniqueID,
 	inCodec := storage.NewInsertCodec(collMeta)
 	insertData, err := genInsertData(msgLength, schema)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	binLogs, _, err := inCodec.Serialize(partitionID, segmentID, insertData)
+	binLogs, statsLogs, err := inCodec.Serialize(partitionID, segmentID, insertData)
 
-	return binLogs, err
+	return binLogs, statsLogs, err
 }
 
 func genSimpleInsertMsg(schema *schemapb.CollectionSchema, numRows int) (*msgstream.InsertMsg, error) {
@@ -1000,14 +1001,14 @@ func saveBinLog(ctx context.Context,
 	partitionID UniqueID,
 	segmentID UniqueID,
 	msgLength int,
-	schema *schemapb.CollectionSchema) ([]*datapb.FieldBinlog, error) {
-	binLogs, err := genStorageBlob(collectionID,
+	schema *schemapb.CollectionSchema) ([]*datapb.FieldBinlog, []*datapb.FieldBinlog, error) {
+	binLogs, statsLogs, err := genStorageBlob(collectionID,
 		partitionID,
 		segmentID,
 		msgLength,
 		schema)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	log.Debug(".. [query node unittest] Saving bin logs to MinIO ..", zap.Int("number", len(binLogs)))
@@ -1019,10 +1020,11 @@ func saveBinLog(ctx context.Context,
 		fieldID, err := strconv.ParseInt(blob.GetKey(), 10, 64)
 		log.Debug("[query node unittest] save binlog", zap.Int64("fieldID", fieldID))
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 
-		key := JoinIDPath(collectionID, partitionID, segmentID, fieldID)
+		k := JoinIDPath(collectionID, partitionID, segmentID, fieldID)
+		key := path.Join("insert-log", k)
 		kvs[key] = blob.Value[:]
 		fieldBinlog = append(fieldBinlog, &datapb.FieldBinlog{
 			FieldID: fieldID,
@@ -1031,9 +1033,28 @@ func saveBinLog(ctx context.Context,
 	}
 	log.Debug("[query node unittest] save binlog file to MinIO/S3")
 
+	// write insert binlog
+	statsBinlog := make([]*datapb.FieldBinlog, 0)
+	for _, blob := range statsLogs {
+		fieldID, err := strconv.ParseInt(blob.GetKey(), 10, 64)
+		log.Debug("[query node unittest] save statLog", zap.Int64("fieldID", fieldID))
+		if err != nil {
+			return nil, nil, err
+		}
+
+		k := JoinIDPath(collectionID, partitionID, segmentID, fieldID)
+		key := path.Join("delta-log", k)
+		kvs[key] = blob.Value[:]
+		statsBinlog = append(statsBinlog, &datapb.FieldBinlog{
+			FieldID: fieldID,
+			Binlogs: []*datapb.Binlog{{LogPath: key}},
+		})
+	}
+	log.Debug("[query node unittest] save statsLog file to MinIO/S3")
+
 	cm := storage.NewLocalChunkManager(storage.RootPath(defaultLocalStorage))
 	err = cm.MultiWrite(kvs)
-	return fieldBinlog, err
+	return fieldBinlog, statsBinlog, err
 }
 
 // saveDeltaLog saves delta logs into MinIO for testing purpose.

internal/querynode/segment_loader_test.go

@@ -41,7 +41,7 @@ func TestSegmentLoader_loadSegment(t *testing.T) {
 	defer cancel()
 
 	schema := genTestCollectionSchema()
-	fieldBinlog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
+	fieldBinlog, statsLog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
 	assert.NoError(t, err)
 
 	t.Run("test load segment", func(t *testing.T) {
@@ -65,6 +65,7 @@ func TestSegmentLoader_loadSegment(t *testing.T) {
 					PartitionID:  defaultPartitionID,
 					CollectionID: defaultCollectionID,
 					BinlogPaths:  fieldBinlog,
+					Statslogs:    statsLog,
 				},
 			},
 		}
@@ -178,7 +179,7 @@ func TestSegmentLoader_loadSegmentFieldsData(t *testing.T) {
 			segmentTypeSealed)
 		assert.Nil(t, err)
 
-		binlog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
+		binlog, _, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
 		assert.NoError(t, err)
 
 		err = loader.loadFiledBinlogData(segment, binlog)
@@ -383,7 +384,7 @@ func TestSegmentLoader_testLoadGrowingAndSealed(t *testing.T) {
 	defer cancel()
 
 	schema := genTestCollectionSchema()
-	fieldBinlog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
+	fieldBinlog, statsLog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
 	assert.NoError(t, err)
 
 	deltaLogs, err := saveDeltaLog(defaultCollectionID, defaultPartitionID, defaultSegmentID)
@@ -410,6 +411,7 @@ func TestSegmentLoader_testLoadGrowingAndSealed(t *testing.T) {
 					PartitionID:  defaultPartitionID,
 					CollectionID: defaultCollectionID,
 					BinlogPaths:  fieldBinlog,
+					Statslogs:    statsLog,
 				},
 			},
 		}
@@ -517,7 +519,7 @@ func TestSegmentLoader_testLoadSealedSegmentWithIndex(t *testing.T) {
 	schema := genTestCollectionSchema()
 
 	// generate insert binlog
-	fieldBinlog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
+	fieldBinlog, statsLog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
 	assert.NoError(t, err)
 
 	segmentID := UniqueID(100)
@@ -555,6 +557,7 @@ func TestSegmentLoader_testLoadSealedSegmentWithIndex(t *testing.T) {
 				CollectionID: defaultCollectionID,
 				BinlogPaths:  fieldBinlog,
 				IndexInfos:   []*querypb.FieldIndexInfo{indexInfo},
+				Statslogs:    statsLog,
 			},
 		},
 	}

internal/querynode/task.go

@@ -529,6 +529,19 @@ func (l *loadSegmentsTask) Execute(ctx context.Context) error {
 		log.Warn(err.Error())
 		return err
 	}
+
+	// reload delete log from cp to latest position
+	for _, deltaPosition := range l.req.DeltaPositions {
+		err = l.node.loader.FromDmlCPLoadDelete(ctx, l.req.CollectionID, deltaPosition)
+		if err != nil {
+			for _, segment := range l.req.Infos {
+				l.node.metaReplica.removeSegment(segment.SegmentID, segmentTypeSealed)
+			}
+			log.Warn("LoadSegmentTask from delta check point load delete failed", zap.Int64("msgID", l.req.Base.MsgID), zap.Error(err))
+			return err
+		}
+	}
+
 	log.Info("LoadSegmentTask Execute done", zap.Int64("msgID", l.req.Base.MsgID))
 	return nil
 }

internal/querynode/task_test.go

@@ -19,9 +19,9 @@ package querynode
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/apache/pulsar-client-go/pulsar"
-
 	"github.com/stretchr/testify/assert"
 
 	"github.com/milvus-io/milvus/internal/mq/msgstream"
@@ -29,6 +29,8 @@ import (
 	"github.com/milvus-io/milvus/internal/proto/datapb"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
 	"github.com/milvus-io/milvus/internal/proto/querypb"
+	"github.com/milvus-io/milvus/internal/proto/schemapb"
+	"github.com/milvus-io/milvus/internal/util/funcutil"
 	"github.com/milvus-io/milvus/internal/util/typeutil"
 )
 
@@ -231,7 +233,7 @@ func TestTask_watchDmChannelsTask(t *testing.T) {
 			node: node,
 		}
 
-		fieldBinlog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
+		fieldBinlog, statsLog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
 		assert.NoError(t, err)
 
 		task.req.Infos = []*datapb.VchannelInfo{
@@ -246,7 +248,8 @@ func TestTask_watchDmChannelsTask(t *testing.T) {
 							ChannelName: defaultDMLChannel,
 							Timestamp:   typeutil.MaxTimestamp,
 						},
-						Binlogs: fieldBinlog,
+						Binlogs:   fieldBinlog,
+						Statslogs: statsLog,
 					},
 				},
 			},
@@ -384,7 +387,7 @@ func TestTask_loadSegmentsTask(t *testing.T) {
 		node, err := genSimpleQueryNode(ctx)
 		assert.NoError(t, err)
 
-		fieldBinlog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
+		fieldBinlog, statsLog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
 		assert.NoError(t, err)
 
 		req := &querypb.LoadSegmentsRequest{
@@ -396,6 +399,7 @@ func TestTask_loadSegmentsTask(t *testing.T) {
 					PartitionID:  defaultPartitionID,
 					CollectionID: defaultCollectionID,
 					BinlogPaths:  fieldBinlog,
+					Statslogs:    statsLog,
 				},
 			},
 		}
@@ -412,7 +416,7 @@ func TestTask_loadSegmentsTask(t *testing.T) {
 		node, err := genSimpleQueryNode(ctx)
 		assert.NoError(t, err)
 
-		fieldBinlog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
+		fieldBinlog, statsLog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, defaultSegmentID, defaultMsgLength, schema)
 		assert.NoError(t, err)
 
 		req := &querypb.LoadSegmentsRequest{
@@ -424,6 +428,7 @@ func TestTask_loadSegmentsTask(t *testing.T) {
 					PartitionID:  defaultPartitionID,
 					CollectionID: defaultCollectionID,
 					BinlogPaths:  fieldBinlog,
+					Statslogs:    statsLog,
 				},
 			},
 		}
@@ -446,42 +451,112 @@ func TestTask_loadSegmentsTask(t *testing.T) {
 		assert.Equal(t, 1, num)
 	})
 
-	t.Run("test execute grpc error", func(t *testing.T) {
+	t.Run("test FromDmlCPLoadDelete", func(t *testing.T) {
 		node, err := genSimpleQueryNode(ctx)
 		assert.NoError(t, err)
 
-		task := loadSegmentsTask{
-			req:  genLoadEmptySegmentsRequest(),
-			node: node,
+		vDmChannel := "by-dev-rootcoord-dml_1_2021v1"
+		pDmChannel := funcutil.ToPhysicalChannel(vDmChannel)
+		stream, err := node.factory.NewMsgStream(node.queryNodeLoopCtx)
+		assert.Nil(t, err)
+		stream.AsProducer([]string{pDmChannel})
+		timeTickMsg := &msgstream.TimeTickMsg{
+			BaseMsg: msgstream.BaseMsg{
+				HashValues: []uint32{1},
+			},
+			TimeTickMsg: internalpb.TimeTickMsg{
+				Base: &commonpb.MsgBase{
+					MsgType:   commonpb.MsgType_TimeTick,
+					Timestamp: 100,
+				},
+			},
 		}
-		task.req.Infos = []*querypb.SegmentLoadInfo{
-			{
-				SegmentID:    defaultSegmentID + 1,
-				PartitionID:  defaultPartitionID + 1,
-				CollectionID: defaultCollectionID + 1,
+
+		deleteMsg := &msgstream.DeleteMsg{
+			BaseMsg: msgstream.BaseMsg{
+				HashValues: []uint32{1, 1, 1},
+			},
+			DeleteRequest: internalpb.DeleteRequest{
+				Base: &commonpb.MsgBase{
+					MsgType:   commonpb.MsgType_Delete,
+					Timestamp: 110,
+				},
+				CollectionID: defaultCollectionID,
+				PartitionID:  defaultPartitionID,
+				PrimaryKeys: &schemapb.IDs{
+					IdField: &schemapb.IDs_IntId{
+						IntId: &schemapb.LongArray{
+							Data: []int64{1, 2, 3},
+						},
+					},
+				},
+				Timestamps: []Timestamp{110, 110, 110},
+				NumRows:    3,
 			},
 		}
-		err = task.Execute(ctx)
-		assert.Error(t, err)
-	})
 
-	t.Run("test execute node down", func(t *testing.T) {
-		node, err := genSimpleQueryNode(ctx)
+		pos1, err := stream.ProduceMark(&msgstream.MsgPack{Msgs: []msgstream.TsMsg{timeTickMsg}})
+		assert.NoError(t, err)
+		msgIDs, ok := pos1[pDmChannel]
+		assert.True(t, ok)
+		assert.Equal(t, 1, len(msgIDs))
+		err = stream.Produce(&msgstream.MsgPack{Msgs: []msgstream.TsMsg{deleteMsg}})
+		assert.NoError(t, err)
+
+		// to stop reader from cp
+		go func() {
+			for {
+				select {
+				case <-ctx.Done():
+					break
+				default:
+					timeTickMsg.Base.Timestamp += 100
+					stream.Produce(&msgstream.MsgPack{Msgs: []msgstream.TsMsg{timeTickMsg}})
+					time.Sleep(200 * time.Millisecond)
+				}
+			}
+		}()
+
+		segmentID := defaultSegmentID + 1
+		fieldBinlog, statsLog, err := saveBinLog(ctx, defaultCollectionID, defaultPartitionID, segmentID, defaultMsgLength, schema)
 		assert.NoError(t, err)
 
+		req := &querypb.LoadSegmentsRequest{
+			Base:   genCommonMsgBase(commonpb.MsgType_LoadSegments),
+			Schema: schema,
+			Infos: []*querypb.SegmentLoadInfo{
+				{
+					SegmentID:    segmentID,
+					PartitionID:  defaultPartitionID,
+					CollectionID: defaultCollectionID,
+					BinlogPaths:  fieldBinlog,
+					NumOfRows:    defaultMsgLength,
+					Statslogs:    statsLog,
+				},
+			},
+			DeltaPositions: []*internalpb.MsgPosition{
+				{
+					ChannelName: vDmChannel,
+					MsgID:       msgIDs[0].Serialize(),
+					Timestamp:   100,
+				},
+			},
+		}
+
 		task := loadSegmentsTask{
-			req:  genLoadEmptySegmentsRequest(),
+			req:  req,
 			node: node,
 		}
-		task.req.Infos = []*querypb.SegmentLoadInfo{
-			{
-				SegmentID:    defaultSegmentID + 1,
-				PartitionID:  defaultPartitionID + 1,
-				CollectionID: defaultCollectionID + 1,
-			},
-		}
+		err = task.PreExecute(ctx)
+		assert.NoError(t, err)
 		err = task.Execute(ctx)
-		assert.Error(t, err)
+		assert.NoError(t, err)
+		segment, err := node.metaReplica.getSegmentByID(segmentID, segmentTypeSealed)
+		assert.NoError(t, err)
+
+		// has reload 3 delete log from dm channel, so next delete offset should be 3
+		offset := segment.segmentPreDelete(1)
+		assert.Equal(t, int64(3), offset)
 	})
 
 	t.Run("test OOM", func(t *testing.T) {