admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2025-12-07 01:28:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add index info in loadSegmentRequest (#14524)

Browse Source 
Signed-off-by: xige-16 <xi.ge@zilliz.com>
This commit is contained in:
xige-16 2021-12-30 19:09:33 +08:00 committed by GitHub
parent f96cd84efb
commit b063bfda8f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 409 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
internal/proto/query_coord.proto
View File

@ -9,7 +9,6 @@ import "milvus.proto";
import "internal.proto"; import "internal.proto";
import "schema.proto"; import "schema.proto";
import "data_coord.proto"; import "data_coord.proto";
import "index_coord.proto";
service QueryCoord { service QueryCoord {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {} rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
@ -190,8 +189,19 @@ message SegmentLoadInfo {
repeated data.FieldBinlog statslogs = 8; repeated data.FieldBinlog statslogs = 8;
repeated data.FieldBinlog deltalogs = 9; repeated data.FieldBinlog deltalogs = 9;
repeated int64 compactionFrom = 10; // segmentIDs compacted from repeated int64 compactionFrom = 10; // segmentIDs compacted from
bool enable_index = 11; repeated VecFieldIndexInfo index_infos = 11;
repeated index.IndexFilePathInfo index_path_infos = 12; int64 segment_size = 12;
}
message VecFieldIndexInfo {
int64 fieldID =1;
bool enable_index = 2;
string index_name = 3;
int64 indexID = 4;
int64 buildID = 5;
repeated common.KeyValuePair index_params = 6;
repeated string index_file_paths = 7;
int64 index_size = 8;
} }
message LoadSegmentsRequest { message LoadSegmentsRequest {
@ -285,8 +295,7 @@ message SegmentInfo {
repeated int64 compactionFrom = 10; repeated int64 compactionFrom = 10;
bool createdByCompaction = 11; bool createdByCompaction = 11;
common.SegmentState segment_state = 12; common.SegmentState segment_state = 12;
bool enable_index = 13; repeated VecFieldIndexInfo index_infos = 13;
repeated index.IndexFilePathInfo index_path_infos = 14;
} }
message CollectionInfo { message CollectionInfo {

426
internal/proto/querypb/query_coord.pb.go
View File

@ -9,7 +9,6 @@ import (
proto "github.com/golang/protobuf/proto" proto "github.com/golang/protobuf/proto"
commonpb "github.com/milvus-io/milvus/internal/proto/commonpb" commonpb "github.com/milvus-io/milvus/internal/proto/commonpb"
datapb "github.com/milvus-io/milvus/internal/proto/datapb" datapb "github.com/milvus-io/milvus/internal/proto/datapb"
indexpb "github.com/milvus-io/milvus/internal/proto/indexpb"
internalpb "github.com/milvus-io/milvus/internal/proto/internalpb" internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"
milvuspb "github.com/milvus-io/milvus/internal/proto/milvuspb" milvuspb "github.com/milvus-io/milvus/internal/proto/milvuspb"
schemapb "github.com/milvus-io/milvus/internal/proto/schemapb" schemapb "github.com/milvus-io/milvus/internal/proto/schemapb"
@ -1265,8 +1264,8 @@ type SegmentLoadInfo struct {
Statslogs []*datapb.FieldBinlog `protobuf:"bytes,8,rep,name=statslogs,proto3" json:"statslogs,omitempty"` Statslogs []*datapb.FieldBinlog `protobuf:"bytes,8,rep,name=statslogs,proto3" json:"statslogs,omitempty"`
Deltalogs []*datapb.FieldBinlog `protobuf:"bytes,9,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"` Deltalogs []*datapb.FieldBinlog `protobuf:"bytes,9,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"`
CompactionFrom []int64 `protobuf:"varint,10,rep,packed,name=compactionFrom,proto3" json:"compactionFrom,omitempty"` CompactionFrom []int64 `protobuf:"varint,10,rep,packed,name=compactionFrom,proto3" json:"compactionFrom,omitempty"`
EnableIndex bool `protobuf:"varint,11,opt,name=enable_index,json=enableIndex,proto3" json:"enable_index,omitempty"` IndexInfos []*VecFieldIndexInfo `protobuf:"bytes,11,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"`
IndexPathInfos []*indexpb.IndexFilePathInfo `protobuf:"bytes,12,rep,name=index_path_infos,json=indexPathInfos,proto3" json:"index_path_infos,omitempty"` SegmentSize int64 `protobuf:"varint,12,opt,name=segment_size,json=segmentSize,proto3" json:"segment_size,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -1367,20 +1366,115 @@ func (m *SegmentLoadInfo) GetCompactionFrom() []int64 {
return nil return nil
} }
func (m *SegmentLoadInfo) GetEnableIndex() bool { func (m *SegmentLoadInfo) GetIndexInfos() []*VecFieldIndexInfo {
if m != nil {
return m.IndexInfos
}
return nil
}
func (m *SegmentLoadInfo) GetSegmentSize() int64 {
if m != nil {
return m.SegmentSize
}
return 0
}
type VecFieldIndexInfo struct {
FieldID int64 `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"`
EnableIndex bool `protobuf:"varint,2,opt,name=enable_index,json=enableIndex,proto3" json:"enable_index,omitempty"`
IndexName string `protobuf:"bytes,3,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"`
IndexID int64 `protobuf:"varint,4,opt,name=indexID,proto3" json:"indexID,omitempty"`
BuildID int64 `protobuf:"varint,5,opt,name=buildID,proto3" json:"buildID,omitempty"`
IndexParams []*commonpb.KeyValuePair `protobuf:"bytes,6,rep,name=index_params,json=indexParams,proto3" json:"index_params,omitempty"`
IndexFilePaths []string `protobuf:"bytes,7,rep,name=index_file_paths,json=indexFilePaths,proto3" json:"index_file_paths,omitempty"`
IndexSize int64 `protobuf:"varint,8,opt,name=index_size,json=indexSize,proto3" json:"index_size,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *VecFieldIndexInfo) Reset() { *m = VecFieldIndexInfo{} }
func (m *VecFieldIndexInfo) String() string { return proto.CompactTextString(m) }
func (*VecFieldIndexInfo) ProtoMessage() {}
func (*VecFieldIndexInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{19}
}
func (m *VecFieldIndexInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_VecFieldIndexInfo.Unmarshal(m, b)
}
func (m *VecFieldIndexInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_VecFieldIndexInfo.Marshal(b, m, deterministic)
}
func (m *VecFieldIndexInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_VecFieldIndexInfo.Merge(m, src)
}
func (m *VecFieldIndexInfo) XXX_Size() int {
return xxx_messageInfo_VecFieldIndexInfo.Size(m)
}
func (m *VecFieldIndexInfo) XXX_DiscardUnknown() {
xxx_messageInfo_VecFieldIndexInfo.DiscardUnknown(m)
}
var xxx_messageInfo_VecFieldIndexInfo proto.InternalMessageInfo
func (m *VecFieldIndexInfo) GetFieldID() int64 {
if m != nil {
return m.FieldID
}
return 0
}
func (m *VecFieldIndexInfo) GetEnableIndex() bool {
if m != nil { if m != nil {
return m.EnableIndex return m.EnableIndex
} }
return false return false
} }
func (m *SegmentLoadInfo) GetIndexPathInfos() []*indexpb.IndexFilePathInfo { func (m *VecFieldIndexInfo) GetIndexName() string {
if m != nil { if m != nil {
return m.IndexPathInfos return m.IndexName
}
return ""
}
func (m *VecFieldIndexInfo) GetIndexID() int64 {
if m != nil {
return m.IndexID
}
return 0
}
func (m *VecFieldIndexInfo) GetBuildID() int64 {
if m != nil {
return m.BuildID
}
return 0
}
func (m *VecFieldIndexInfo) GetIndexParams() []*commonpb.KeyValuePair {
if m != nil {
return m.IndexParams
} }
return nil return nil
} }
func (m *VecFieldIndexInfo) GetIndexFilePaths() []string {
if m != nil {
return m.IndexFilePaths
}
return nil
}
func (m *VecFieldIndexInfo) GetIndexSize() int64 {
if m != nil {
return m.IndexSize
}
return 0
}
type LoadSegmentsRequest struct { type LoadSegmentsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
DstNodeID int64 `protobuf:"varint,2,opt,name=dst_nodeID,json=dstNodeID,proto3" json:"dst_nodeID,omitempty"` DstNodeID int64 `protobuf:"varint,2,opt,name=dst_nodeID,json=dstNodeID,proto3" json:"dst_nodeID,omitempty"`
@ -1397,7 +1491,7 @@ func (m *LoadSegmentsRequest) Reset() { *m = LoadSegmentsRequest{} }
func (m *LoadSegmentsRequest) String() string { return proto.CompactTextString(m) } func (m *LoadSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*LoadSegmentsRequest) ProtoMessage() {} func (*LoadSegmentsRequest) ProtoMessage() {}
func (*LoadSegmentsRequest) Descriptor() ([]byte, []int) { func (*LoadSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{19} return fileDescriptor_aab7cc9a69ed26e8, []int{20}
} }
func (m *LoadSegmentsRequest) XXX_Unmarshal(b []byte) error { func (m *LoadSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -1477,7 +1571,7 @@ func (m *ReleaseSegmentsRequest) Reset() { *m = ReleaseSegmentsRequest{}
func (m *ReleaseSegmentsRequest) String() string { return proto.CompactTextString(m) } func (m *ReleaseSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*ReleaseSegmentsRequest) ProtoMessage() {} func (*ReleaseSegmentsRequest) ProtoMessage() {}
func (*ReleaseSegmentsRequest) Descriptor() ([]byte, []int) { func (*ReleaseSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{20} return fileDescriptor_aab7cc9a69ed26e8, []int{21}
} }
func (m *ReleaseSegmentsRequest) XXX_Unmarshal(b []byte) error { func (m *ReleaseSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -1553,7 +1647,7 @@ func (m *HandoffSegmentsRequest) Reset() { *m = HandoffSegmentsRequest{}
func (m *HandoffSegmentsRequest) String() string { return proto.CompactTextString(m) } func (m *HandoffSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*HandoffSegmentsRequest) ProtoMessage() {} func (*HandoffSegmentsRequest) ProtoMessage() {}
func (*HandoffSegmentsRequest) Descriptor() ([]byte, []int) { func (*HandoffSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{21} return fileDescriptor_aab7cc9a69ed26e8, []int{22}
} }
func (m *HandoffSegmentsRequest) XXX_Unmarshal(b []byte) error { func (m *HandoffSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -1603,7 +1697,7 @@ func (m *LoadBalanceRequest) Reset() { *m = LoadBalanceRequest{} }
func (m *LoadBalanceRequest) String() string { return proto.CompactTextString(m) } func (m *LoadBalanceRequest) String() string { return proto.CompactTextString(m) }
func (*LoadBalanceRequest) ProtoMessage() {} func (*LoadBalanceRequest) ProtoMessage() {}
func (*LoadBalanceRequest) Descriptor() ([]byte, []int) { func (*LoadBalanceRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{22} return fileDescriptor_aab7cc9a69ed26e8, []int{23}
} }
func (m *LoadBalanceRequest) XXX_Unmarshal(b []byte) error { func (m *LoadBalanceRequest) XXX_Unmarshal(b []byte) error {
@ -1672,7 +1766,7 @@ func (m *DmChannelWatchInfo) Reset() { *m = DmChannelWatchInfo{} }
func (m *DmChannelWatchInfo) String() string { return proto.CompactTextString(m) } func (m *DmChannelWatchInfo) String() string { return proto.CompactTextString(m) }
func (*DmChannelWatchInfo) ProtoMessage() {} func (*DmChannelWatchInfo) ProtoMessage() {}
func (*DmChannelWatchInfo) Descriptor() ([]byte, []int) { func (*DmChannelWatchInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{23} return fileDescriptor_aab7cc9a69ed26e8, []int{24}
} }
func (m *DmChannelWatchInfo) XXX_Unmarshal(b []byte) error { func (m *DmChannelWatchInfo) XXX_Unmarshal(b []byte) error {
@ -1729,7 +1823,7 @@ func (m *QueryChannelInfo) Reset() { *m = QueryChannelInfo{} }
func (m *QueryChannelInfo) String() string { return proto.CompactTextString(m) } func (m *QueryChannelInfo) String() string { return proto.CompactTextString(m) }
func (*QueryChannelInfo) ProtoMessage() {} func (*QueryChannelInfo) ProtoMessage() {}
func (*QueryChannelInfo) Descriptor() ([]byte, []int) { func (*QueryChannelInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{24} return fileDescriptor_aab7cc9a69ed26e8, []int{25}
} }
func (m *QueryChannelInfo) XXX_Unmarshal(b []byte) error { func (m *QueryChannelInfo) XXX_Unmarshal(b []byte) error {
@ -1798,7 +1892,7 @@ func (m *PartitionStates) Reset() { *m = PartitionStates{} }
func (m *PartitionStates) String() string { return proto.CompactTextString(m) } func (m *PartitionStates) String() string { return proto.CompactTextString(m) }
func (*PartitionStates) ProtoMessage() {} func (*PartitionStates) ProtoMessage() {}
func (*PartitionStates) Descriptor() ([]byte, []int) { func (*PartitionStates) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{25} return fileDescriptor_aab7cc9a69ed26e8, []int{26}
} }
func (m *PartitionStates) XXX_Unmarshal(b []byte) error { func (m *PartitionStates) XXX_Unmarshal(b []byte) error {
@ -1853,8 +1947,7 @@ type SegmentInfo struct {
CompactionFrom []int64 `protobuf:"varint,10,rep,packed,name=compactionFrom,proto3" json:"compactionFrom,omitempty"` CompactionFrom []int64 `protobuf:"varint,10,rep,packed,name=compactionFrom,proto3" json:"compactionFrom,omitempty"`
CreatedByCompaction bool `protobuf:"varint,11,opt,name=createdByCompaction,proto3" json:"createdByCompaction,omitempty"` CreatedByCompaction bool `protobuf:"varint,11,opt,name=createdByCompaction,proto3" json:"createdByCompaction,omitempty"`
SegmentState commonpb.SegmentState `protobuf:"varint,12,opt,name=segment_state,json=segmentState,proto3,enum=milvus.proto.common.SegmentState" json:"segment_state,omitempty"` SegmentState commonpb.SegmentState `protobuf:"varint,12,opt,name=segment_state,json=segmentState,proto3,enum=milvus.proto.common.SegmentState" json:"segment_state,omitempty"`
EnableIndex bool `protobuf:"varint,13,opt,name=enable_index,json=enableIndex,proto3" json:"enable_index,omitempty"` IndexInfos []*VecFieldIndexInfo `protobuf:"bytes,13,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"`
IndexPathInfos []*indexpb.IndexFilePathInfo `protobuf:"bytes,14,rep,name=index_path_infos,json=indexPathInfos,proto3" json:"index_path_infos,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -1864,7 +1957,7 @@ func (m *SegmentInfo) Reset() { *m = SegmentInfo{} }
func (m *SegmentInfo) String() string { return proto.CompactTextString(m) } func (m *SegmentInfo) String() string { return proto.CompactTextString(m) }
func (*SegmentInfo) ProtoMessage() {} func (*SegmentInfo) ProtoMessage() {}
func (*SegmentInfo) Descriptor() ([]byte, []int) { func (*SegmentInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{26} return fileDescriptor_aab7cc9a69ed26e8, []int{27}
} }
func (m *SegmentInfo) XXX_Unmarshal(b []byte) error { func (m *SegmentInfo) XXX_Unmarshal(b []byte) error {
@ -1969,16 +2062,9 @@ func (m *SegmentInfo) GetSegmentState() commonpb.SegmentState {
return commonpb.SegmentState_SegmentStateNone return commonpb.SegmentState_SegmentStateNone
} }
func (m *SegmentInfo) GetEnableIndex() bool { func (m *SegmentInfo) GetIndexInfos() []*VecFieldIndexInfo {
if m != nil { if m != nil {
return m.EnableIndex return m.IndexInfos
}
return false
}
func (m *SegmentInfo) GetIndexPathInfos() []*indexpb.IndexFilePathInfo {
if m != nil {
return m.IndexPathInfos
} }
return nil return nil
} }
@ -2000,7 +2086,7 @@ func (m *CollectionInfo) Reset() { *m = CollectionInfo{} }
func (m *CollectionInfo) String() string { return proto.CompactTextString(m) } func (m *CollectionInfo) String() string { return proto.CompactTextString(m) }
func (*CollectionInfo) ProtoMessage() {} func (*CollectionInfo) ProtoMessage() {}
func (*CollectionInfo) Descriptor() ([]byte, []int) { func (*CollectionInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{27} return fileDescriptor_aab7cc9a69ed26e8, []int{28}
} }
func (m *CollectionInfo) XXX_Unmarshal(b []byte) error { func (m *CollectionInfo) XXX_Unmarshal(b []byte) error {
@ -2085,7 +2171,7 @@ func (m *SegmentChangeInfo) Reset() { *m = SegmentChangeInfo{} }
func (m *SegmentChangeInfo) String() string { return proto.CompactTextString(m) } func (m *SegmentChangeInfo) String() string { return proto.CompactTextString(m) }
func (*SegmentChangeInfo) ProtoMessage() {} func (*SegmentChangeInfo) ProtoMessage() {}
func (*SegmentChangeInfo) Descriptor() ([]byte, []int) { func (*SegmentChangeInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{28} return fileDescriptor_aab7cc9a69ed26e8, []int{29}
} }
func (m *SegmentChangeInfo) XXX_Unmarshal(b []byte) error { func (m *SegmentChangeInfo) XXX_Unmarshal(b []byte) error {
@ -2146,7 +2232,7 @@ func (m *SealedSegmentsChangeInfo) Reset() { *m = SealedSegmentsChangeIn
func (m *SealedSegmentsChangeInfo) String() string { return proto.CompactTextString(m) } func (m *SealedSegmentsChangeInfo) String() string { return proto.CompactTextString(m) }
func (*SealedSegmentsChangeInfo) ProtoMessage() {} func (*SealedSegmentsChangeInfo) ProtoMessage() {}
func (*SealedSegmentsChangeInfo) Descriptor() ([]byte, []int) { func (*SealedSegmentsChangeInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{29} return fileDescriptor_aab7cc9a69ed26e8, []int{30}
} }
func (m *SealedSegmentsChangeInfo) XXX_Unmarshal(b []byte) error { func (m *SealedSegmentsChangeInfo) XXX_Unmarshal(b []byte) error {
@ -2204,6 +2290,7 @@ func init() {
proto.RegisterType((*WatchDmChannelsRequest)(nil), "milvus.proto.query.WatchDmChannelsRequest") proto.RegisterType((*WatchDmChannelsRequest)(nil), "milvus.proto.query.WatchDmChannelsRequest")
proto.RegisterType((*WatchDeltaChannelsRequest)(nil), "milvus.proto.query.WatchDeltaChannelsRequest") proto.RegisterType((*WatchDeltaChannelsRequest)(nil), "milvus.proto.query.WatchDeltaChannelsRequest")
proto.RegisterType((*SegmentLoadInfo)(nil), "milvus.proto.query.SegmentLoadInfo") proto.RegisterType((*SegmentLoadInfo)(nil), "milvus.proto.query.SegmentLoadInfo")
proto.RegisterType((*VecFieldIndexInfo)(nil), "milvus.proto.query.VecFieldIndexInfo")
proto.RegisterType((*LoadSegmentsRequest)(nil), "milvus.proto.query.LoadSegmentsRequest") proto.RegisterType((*LoadSegmentsRequest)(nil), "milvus.proto.query.LoadSegmentsRequest")
proto.RegisterType((*ReleaseSegmentsRequest)(nil), "milvus.proto.query.ReleaseSegmentsRequest") proto.RegisterType((*ReleaseSegmentsRequest)(nil), "milvus.proto.query.ReleaseSegmentsRequest")
proto.RegisterType((*HandoffSegmentsRequest)(nil), "milvus.proto.query.HandoffSegmentsRequest") proto.RegisterType((*HandoffSegmentsRequest)(nil), "milvus.proto.query.HandoffSegmentsRequest")
@ -2220,145 +2307,150 @@ func init() {
func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) } func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
var fileDescriptor_aab7cc9a69ed26e8 = []byte{ var fileDescriptor_aab7cc9a69ed26e8 = []byte{
// 2193 bytes of a gzipped FileDescriptorProto // 2282 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x19, 0x4d, 0x73, 0xdc, 0x48, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x39, 0x4f, 0x73, 0x1b, 0x49,
0xd5, 0x9a, 0x2f, 0x7b, 0xde, 0x8c, 0x67, 0xe4, 0x4e, 0x62, 0xc6, 0x43, 0x92, 0xf5, 0x6a, 0xd7, 0xf5, 0x1e, 0xfd, 0xb3, 0xf5, 0x24, 0x4b, 0xe3, 0x8e, 0xed, 0x9f, 0xac, 0x5f, 0x36, 0x9b, 0x9d,
0xd9, 0xe0, 0x65, 0xed, 0xe0, 0x40, 0x15, 0x5b, 0xc0, 0x21, 0xb6, 0x89, 0xd7, 0xec, 0xc6, 0x31, 0x5d, 0x67, 0x83, 0x97, 0xb5, 0x83, 0x03, 0x55, 0x6c, 0x01, 0x87, 0xd8, 0xc6, 0x5e, 0x93, 0x8d,
0x63, 0x67, 0x29, 0x52, 0xa9, 0x12, 0x9a, 0x51, 0x7b, 0xac, 0x8a, 0xa4, 0x9e, 0xa8, 0x35, 0x6b, 0xd7, 0xc8, 0x4e, 0x28, 0x52, 0xa9, 0x12, 0x23, 0x4d, 0x4b, 0x9e, 0xca, 0xcc, 0xb4, 0x32, 0x3d,
0x3b, 0x5c, 0x39, 0x2c, 0x07, 0x8a, 0x3f, 0x40, 0x71, 0x01, 0x0a, 0x52, 0xc5, 0xfe, 0x87, 0x5c, 0x5a, 0xdb, 0xe1, 0xc2, 0x81, 0xc3, 0x72, 0xa0, 0xb8, 0x53, 0x14, 0x27, 0x28, 0xc8, 0x61, 0x2f,
0xf8, 0x1b, 0x14, 0x07, 0xf8, 0x09, 0x1c, 0xa9, 0xa2, 0xba, 0xd5, 0xd2, 0xe8, 0xa3, 0x65, 0xcb, 0x7c, 0x82, 0x5c, 0xf8, 0x1a, 0x14, 0x07, 0xf8, 0x08, 0x1c, 0xa9, 0xa2, 0xfa, 0xcf, 0x8c, 0x66,
0x76, 0x79, 0x93, 0xa2, 0xb8, 0x49, 0xaf, 0xdf, 0xeb, 0xf7, 0xfa, 0x7d, 0x77, 0x3f, 0x98, 0x7b, 0x46, 0x3d, 0xb6, 0x6c, 0x97, 0x37, 0x29, 0x8a, 0xdb, 0xcc, 0xeb, 0xd7, 0xef, 0xbd, 0x7e, 0xff,
0x31, 0xc6, 0xde, 0x89, 0x3e, 0x20, 0xc4, 0x33, 0x57, 0x46, 0x1e, 0xf1, 0x09, 0x42, 0x8e, 0x65, 0xbb, 0x1f, 0xcc, 0xbd, 0x18, 0x62, 0xff, 0xb4, 0xdd, 0x25, 0xc4, 0xb7, 0x56, 0x07, 0x3e, 0x09,
0x7f, 0x31, 0xa6, 0xc1, 0xdf, 0x0a, 0x5f, 0xef, 0x36, 0x07, 0xc4, 0x71, 0x88, 0x1b, 0xc0, 0xba, 0x08, 0x42, 0xae, 0xed, 0x7c, 0x31, 0xa4, 0xe2, 0x6f, 0x95, 0xaf, 0x37, 0xab, 0x5d, 0xe2, 0xba,
0xcd, 0x38, 0x46, 0xb7, 0x65, 0xb9, 0x3e, 0xf6, 0x5c, 0xc3, 0x0e, 0x57, 0xe9, 0xe0, 0x10, 0x3b, 0xc4, 0x13, 0xb0, 0x66, 0x35, 0x8e, 0xd1, 0xac, 0xd9, 0x5e, 0x80, 0x7d, 0xcf, 0x74, 0xc2, 0x55,
0x86, 0xf8, 0x53, 0x4d, 0xc3, 0x37, 0xe2, 0xfb, 0x77, 0xe7, 0x2c, 0xd7, 0xc4, 0xc7, 0x71, 0x90, 0xda, 0x3d, 0xc2, 0xae, 0x29, 0xff, 0x74, 0xcb, 0x0c, 0xcc, 0x38, 0x7d, 0xe3, 0x97, 0x1a, 0x2c,
0xf6, 0x2b, 0x05, 0xe6, 0xf7, 0x0e, 0xc9, 0xd1, 0x06, 0xb1, 0x6d, 0x3c, 0xf0, 0x2d, 0xe2, 0xd2, 0x1e, 0x1c, 0x91, 0xe3, 0x4d, 0xe2, 0x38, 0xb8, 0x1b, 0xd8, 0xc4, 0xa3, 0x2d, 0xfc, 0x62, 0x88,
0x1e, 0x7e, 0x31, 0xc6, 0xd4, 0x47, 0xf7, 0xa0, 0xd2, 0x37, 0x28, 0xee, 0x28, 0x8b, 0xca, 0xdd, 0x69, 0x80, 0xee, 0x41, 0xa1, 0x63, 0x52, 0xdc, 0xd0, 0x6e, 0x6b, 0x77, 0x2b, 0xeb, 0x37, 0x57,
0xc6, 0xda, 0xcd, 0x95, 0x84, 0x70, 0x42, 0xaa, 0x47, 0x74, 0xb8, 0x6e, 0x50, 0xdc, 0xe3, 0x98, 0x13, 0x92, 0x48, 0x11, 0x1e, 0xd1, 0xfe, 0x86, 0x49, 0x71, 0x8b, 0x63, 0x22, 0x04, 0x05, 0xab,
0x08, 0x41, 0xc5, 0xec, 0x6f, 0x6f, 0x76, 0x4a, 0x8b, 0xca, 0xdd, 0x72, 0x8f, 0x7f, 0xa3, 0xf7, 0xb3, 0xbb, 0xd5, 0xc8, 0xdd, 0xd6, 0xee, 0xe6, 0x5b, 0xfc, 0x1b, 0x7d, 0x00, 0xb3, 0xdd, 0x88,
0x61, 0x76, 0x10, 0xed, 0xbd, 0xbd, 0x49, 0x3b, 0xe5, 0xc5, 0xf2, 0xdd, 0x72, 0x2f, 0x09, 0xd4, 0xf6, 0xee, 0x16, 0x6d, 0xe4, 0x6f, 0xe7, 0xef, 0xe6, 0x5b, 0x49, 0xa0, 0xf1, 0x27, 0x0d, 0xfe,
0xfe, 0xac, 0xc0, 0x37, 0x32, 0x62, 0xd0, 0x11, 0x71, 0x29, 0x46, 0xf7, 0xa1, 0x46, 0x7d, 0xc3, 0x6f, 0x4c, 0x0c, 0x3a, 0x20, 0x1e, 0xc5, 0xe8, 0x3e, 0x94, 0x68, 0x60, 0x06, 0x43, 0x2a, 0x25,
0x1f, 0x53, 0x21, 0xc9, 0x37, 0xa5, 0x92, 0xec, 0x71, 0x94, 0x9e, 0x40, 0xcd, 0xb2, 0x2d, 0x49, 0xf9, 0x7f, 0xa5, 0x24, 0x07, 0x1c, 0xa5, 0x25, 0x51, 0xc7, 0xd9, 0xe6, 0x14, 0x6c, 0xd1, 0xb7,
0xd8, 0xa2, 0xef, 0xc0, 0x75, 0xcb, 0x7d, 0x84, 0x1d, 0xe2, 0x9d, 0xe8, 0x23, 0xec, 0x0d, 0xb0, 0x60, 0xde, 0xf6, 0x1e, 0x61, 0x97, 0xf8, 0xa7, 0xed, 0x01, 0xf6, 0xbb, 0xd8, 0x0b, 0xcc, 0x3e,
0xeb, 0x1b, 0x43, 0x1c, 0xca, 0x78, 0x2d, 0x5c, 0xdb, 0x9d, 0x2c, 0x69, 0x7f, 0x52, 0xe0, 0x06, 0x0e, 0x65, 0xbc, 0x11, 0xae, 0xed, 0x8f, 0x96, 0x8c, 0x3f, 0x6a, 0xb0, 0xc0, 0x24, 0xdd, 0x37,
0x93, 0x74, 0xd7, 0xf0, 0x7c, 0xeb, 0x0a, 0xf4, 0xa5, 0x41, 0x33, 0x2e, 0x63, 0xa7, 0xcc, 0xd7, 0xfd, 0xc0, 0xbe, 0x06, 0x7d, 0x19, 0x50, 0x8d, 0xcb, 0xd8, 0xc8, 0xf3, 0xb5, 0x04, 0x8c, 0xe1,
0x12, 0x30, 0x86, 0x33, 0x0a, 0xd9, 0xb3, 0xb3, 0x55, 0xb8, 0xb8, 0x09, 0x98, 0xf6, 0x47, 0x61, 0x0c, 0x42, 0xf6, 0xec, 0x6c, 0x05, 0x2e, 0x6e, 0x02, 0x66, 0xfc, 0x41, 0x1a, 0x36, 0x2e, 0xe7,
0xd8, 0xb8, 0x9c, 0x97, 0x51, 0x68, 0x9a, 0x67, 0x29, 0xcb, 0xf3, 0x22, 0xea, 0x7c, 0xad, 0xc0, 0x55, 0x14, 0x9a, 0xe6, 0x99, 0x1b, 0xe7, 0x79, 0x19, 0x75, 0xbe, 0xd6, 0x60, 0xe1, 0x33, 0x62,
0x8d, 0xcf, 0x88, 0x61, 0x4e, 0x0c, 0xff, 0xf5, 0xab, 0xf3, 0x47, 0x50, 0x0b, 0x02, 0xa7, 0x53, 0x5a, 0x23, 0xc3, 0x7f, 0xfd, 0xea, 0xfc, 0x01, 0x94, 0x44, 0x94, 0x34, 0x0a, 0x9c, 0xd7, 0x72,
0xe1, 0xbc, 0x96, 0x92, 0xbc, 0x44, 0x50, 0x4d, 0x24, 0xdc, 0xe3, 0x80, 0x9e, 0x20, 0xd2, 0x7e, 0x92, 0x97, 0x8c, 0xa0, 0x91, 0x84, 0x07, 0x1c, 0xd0, 0x92, 0x9b, 0x8c, 0xdf, 0x69, 0xd0, 0x68,
0xa7, 0x40, 0xa7, 0x87, 0x6d, 0x6c, 0x50, 0xfc, 0x26, 0x4f, 0x31, 0x0f, 0x35, 0x97, 0x98, 0x78, 0x61, 0x07, 0x9b, 0x14, 0xbf, 0xc9, 0x53, 0x2c, 0x42, 0xc9, 0x23, 0x16, 0xde, 0xdd, 0xe2, 0xa7,
0x7b, 0x93, 0x9f, 0xa2, 0xdc, 0x13, 0x7f, 0xda, 0x3f, 0x85, 0x86, 0xdf, 0x72, 0x87, 0x8d, 0x59, 0xc8, 0xb7, 0xe4, 0x9f, 0xf1, 0x0f, 0xa9, 0xe1, 0xb7, 0xdc, 0x61, 0x63, 0x56, 0x28, 0x5e, 0xc6,
0xa1, 0x7a, 0x11, 0x2b, 0xbc, 0x9e, 0x58, 0xe1, 0x6d, 0x3f, 0xe9, 0xc4, 0x52, 0xd5, 0x84, 0xa5, 0x0a, 0xaf, 0x47, 0x56, 0x78, 0xdb, 0x4f, 0x3a, 0xb2, 0x54, 0x31, 0x61, 0xa9, 0x9f, 0xc2, 0xd2,
0x7e, 0x0e, 0x0b, 0x1b, 0x1e, 0x36, 0x7c, 0xfc, 0x53, 0x96, 0xf9, 0x37, 0x0e, 0x0d, 0xd7, 0xc5, 0xa6, 0x8f, 0xcd, 0x00, 0xff, 0x98, 0xa5, 0xf9, 0xcd, 0x23, 0xd3, 0xf3, 0xb0, 0x13, 0x1e, 0x21,
0x76, 0x78, 0x84, 0x34, 0x73, 0x45, 0xc2, 0xbc, 0x03, 0xd3, 0x23, 0x8f, 0x1c, 0x9f, 0x44, 0x72, 0xcd, 0x5c, 0x53, 0x30, 0x6f, 0xc0, 0xf4, 0xc0, 0x27, 0x27, 0xa7, 0x91, 0xdc, 0xe1, 0xaf, 0xf1,
0x87, 0xbf, 0xda, 0x5f, 0x14, 0xe8, 0xca, 0xf6, 0xbe, 0x4c, 0x46, 0x78, 0x0f, 0x66, 0x45, 0x09, 0x67, 0x0d, 0x9a, 0x2a, 0xda, 0x57, 0xc9, 0x08, 0xef, 0xc3, 0xac, 0xac, 0x57, 0x82, 0x1a, 0xe7,
0x0b, 0x76, 0xe3, 0x3c, 0xeb, 0xbd, 0xe6, 0x8b, 0x18, 0x07, 0x74, 0x0f, 0xae, 0x07, 0x48, 0x1e, 0x59, 0x6e, 0x55, 0x5f, 0xc4, 0x38, 0xa0, 0x7b, 0x30, 0x2f, 0x90, 0x7c, 0x4c, 0x87, 0x4e, 0x10,
0xa6, 0x63, 0xdb, 0x8f, 0x70, 0xcb, 0x1c, 0x17, 0xf1, 0xb5, 0x1e, 0x5f, 0x12, 0x14, 0xda, 0x2b, 0xe1, 0xe6, 0x39, 0x2e, 0xe2, 0x6b, 0x2d, 0xbe, 0x24, 0x77, 0x18, 0xaf, 0x34, 0x58, 0xda, 0xc1,
0x05, 0x16, 0xb6, 0xb0, 0x1f, 0x19, 0x91, 0x71, 0xc5, 0x6f, 0x69, 0x92, 0xfd, 0x4a, 0x81, 0xae, 0x41, 0x64, 0x44, 0xc6, 0x15, 0xbf, 0xa5, 0x49, 0xf6, 0x2b, 0x0d, 0x9a, 0x2a, 0x59, 0xaf, 0xa2,
0x4c, 0xd6, 0xcb, 0xa8, 0xf5, 0x29, 0xcc, 0x47, 0x3c, 0x74, 0x13, 0xd3, 0x81, 0x67, 0x8d, 0xb8, 0xd6, 0xa7, 0xb0, 0x18, 0xf1, 0x68, 0x5b, 0x98, 0x76, 0x7d, 0x7b, 0xc0, 0x9d, 0x99, 0xa7, 0xdc,
0x33, 0xf3, 0x94, 0xdb, 0x58, 0x7b, 0x6f, 0x25, 0xdb, 0x25, 0xac, 0xa4, 0x25, 0xb8, 0x11, 0x6d, 0xca, 0xfa, 0xfb, 0xab, 0xe3, 0x2d, 0xc1, 0x6a, 0x5a, 0x82, 0x85, 0x88, 0xc4, 0x56, 0x8c, 0x82,
0xb1, 0x19, 0xdb, 0x41, 0xfb, 0x8d, 0x02, 0x37, 0xb6, 0xb0, 0xbf, 0x87, 0x87, 0x0e, 0x76, 0xfd, 0xf1, 0x6b, 0x0d, 0x16, 0x76, 0x70, 0x70, 0x80, 0xfb, 0x2e, 0xf6, 0x82, 0x5d, 0xaf, 0x47, 0x2e,
0x6d, 0xf7, 0x80, 0x5c, 0x5c, 0xaf, 0xb7, 0x01, 0xa8, 0xd8, 0x27, 0x2a, 0x07, 0x31, 0x48, 0x11, 0xaf, 0xd7, 0x5b, 0x00, 0x54, 0xd2, 0x89, 0xca, 0x41, 0x0c, 0x32, 0x89, 0x8e, 0x79, 0xf7, 0x91,
0x1d, 0xf3, 0xee, 0x23, 0x2d, 0xcf, 0x65, 0x74, 0xf7, 0x3d, 0xa8, 0x5a, 0xee, 0x01, 0x09, 0x55, 0x96, 0xe7, 0x2a, 0xba, 0xfb, 0x0e, 0x14, 0x6d, 0xaf, 0x47, 0x42, 0x55, 0xbd, 0xab, 0x52, 0x55,
0xf5, 0x8e, 0x4c, 0x55, 0x71, 0x66, 0x01, 0xb6, 0xf6, 0x9f, 0x12, 0xcc, 0x3f, 0x30, 0x4d, 0x59, 0x9c, 0x99, 0xc0, 0x36, 0xfe, 0x9d, 0x83, 0xc5, 0x07, 0x96, 0xa5, 0x0a, 0xbb, 0x8b, 0xeb, 0x65,
0xd8, 0x9d, 0x5f, 0x2f, 0x93, 0xe8, 0x2e, 0xc5, 0xa3, 0xbb, 0x90, 0xcf, 0x65, 0x42, 0xaa, 0x72, 0x14, 0xdd, 0xb9, 0x78, 0x74, 0x4f, 0xe4, 0x73, 0x63, 0x21, 0x55, 0xb8, 0x40, 0x48, 0x15, 0xb3,
0x8e, 0x90, 0xaa, 0xe6, 0x85, 0x14, 0xda, 0x82, 0x59, 0x8a, 0xf1, 0x73, 0x7d, 0x44, 0x28, 0xf7, 0x42, 0x0a, 0xed, 0xc0, 0x2c, 0xc5, 0xf8, 0x79, 0x7b, 0x40, 0x28, 0xf7, 0x89, 0x46, 0x89, 0x9f,
0x89, 0x4e, 0x8d, 0x9f, 0x46, 0x4b, 0x9e, 0x26, 0x6a, 0x26, 0x1f, 0xd1, 0xe1, 0xae, 0xc0, 0xec, 0xc6, 0x48, 0x9e, 0x26, 0xea, 0x1c, 0x1f, 0xd1, 0xfe, 0xbe, 0xc4, 0x6c, 0x55, 0xd9, 0xc6, 0xf0,
0x35, 0x19, 0x61, 0xf8, 0x87, 0x9e, 0xc0, 0xfc, 0xd0, 0x26, 0x7d, 0xc3, 0xd6, 0x29, 0x36, 0x6c, 0x0f, 0x3d, 0x86, 0xc5, 0xbe, 0x43, 0x3a, 0xa6, 0xd3, 0xa6, 0xd8, 0x74, 0xb0, 0xd5, 0x96, 0xf6,
0x6c, 0xea, 0xc2, 0xde, 0xb4, 0x33, 0x5d, 0x4c, 0xe1, 0xd7, 0x03, 0xf2, 0x3d, 0x4e, 0x2d, 0x16, 0xa6, 0x8d, 0xe9, 0xc9, 0x14, 0x3e, 0x2f, 0xb6, 0x1f, 0xf0, 0xdd, 0x72, 0x81, 0x1a, 0x7f, 0xd7,
0xa8, 0xf6, 0x0f, 0x05, 0x16, 0x7a, 0xd8, 0x21, 0x5f, 0xe0, 0xff, 0x55, 0x13, 0x68, 0xff, 0x2a, 0x60, 0xa9, 0x85, 0x5d, 0xf2, 0x05, 0xfe, 0x6f, 0x35, 0x81, 0xf1, 0xcf, 0x1c, 0x2c, 0xfe, 0xc4,
0xc1, 0xfc, 0xcf, 0x0c, 0x7f, 0x70, 0xb8, 0xe9, 0x08, 0x10, 0x7d, 0x33, 0xe7, 0x2b, 0x52, 0xa0, 0x0c, 0xba, 0x47, 0x5b, 0xae, 0x04, 0xd1, 0x37, 0x73, 0xbe, 0x49, 0x0a, 0x54, 0x14, 0x46, 0x45,
0xa2, 0x30, 0xaa, 0xca, 0xac, 0xca, 0xae, 0x15, 0x2b, 0x9f, 0x8b, 0x23, 0xc7, 0xc2, 0x28, 0x56, 0x95, 0x55, 0xd9, 0x1d, 0x62, 0xf5, 0x89, 0x3c, 0x72, 0x2c, 0x8c, 0x62, 0x15, 0xbc, 0x74, 0x89,
0xc1, 0x6b, 0x17, 0xa8, 0xe0, 0x68, 0x03, 0x66, 0xf1, 0xf1, 0xc0, 0x1e, 0x9b, 0x58, 0x0f, 0xb8, 0x0a, 0x8e, 0x36, 0x61, 0x16, 0x9f, 0x74, 0x9d, 0xa1, 0x85, 0xdb, 0x82, 0xbb, 0xf0, 0xa9, 0x5b,
0x07, 0x3e, 0x75, 0x5b, 0xc2, 0x3d, 0xee, 0x52, 0x4d, 0x41, 0xb4, 0xcd, 0x43, 0xf9, 0xb5, 0x02, 0x0a, 0xee, 0x71, 0x97, 0xaa, 0xca, 0x4d, 0xbb, 0x3c, 0x94, 0x5f, 0x6b, 0xb0, 0x24, 0xf4, 0x8c,
0x0b, 0x81, 0x9e, 0xb1, 0xed, 0x1b, 0x6f, 0x56, 0xd5, 0x91, 0x1a, 0x2b, 0xe7, 0x51, 0xa3, 0xf6, 0x9d, 0xc0, 0x7c, 0xb3, 0xaa, 0x8e, 0xd4, 0x58, 0xb8, 0x88, 0x1a, 0x8d, 0xdf, 0x16, 0xa0, 0x2e,
0x87, 0x0a, 0xb4, 0xc5, 0x01, 0x59, 0xdf, 0xc6, 0x96, 0xd0, 0x4d, 0xa8, 0x47, 0xa9, 0x55, 0x94, 0x0f, 0xc8, 0xfa, 0x36, 0xb6, 0x84, 0x6e, 0x42, 0x39, 0x4a, 0xad, 0xb2, 0xf4, 0x8f, 0x00, 0xe8,
0xfe, 0x09, 0x00, 0x2d, 0x42, 0x23, 0x66, 0x3f, 0x21, 0x69, 0x1c, 0x54, 0x48, 0xdc, 0xb0, 0x50, 0x36, 0x54, 0x62, 0xf6, 0x93, 0x92, 0xc6, 0x41, 0x13, 0x89, 0x1b, 0x16, 0xca, 0x42, 0xac, 0x50,
0x56, 0x62, 0x85, 0xf2, 0x16, 0xc0, 0x81, 0x3d, 0xa6, 0x87, 0xba, 0x6f, 0x39, 0x58, 0xb4, 0x2b, 0xbe, 0x03, 0xd0, 0x73, 0x86, 0xf4, 0xa8, 0x1d, 0xd8, 0x2e, 0x96, 0xed, 0x4a, 0x99, 0x43, 0x0e,
0x75, 0x0e, 0xd9, 0xb7, 0x1c, 0x8c, 0x1e, 0x40, 0xb3, 0x6f, 0xb9, 0x36, 0x19, 0xea, 0x23, 0xc3, 0x6d, 0x17, 0xa3, 0x07, 0x50, 0xed, 0xd8, 0x9e, 0x43, 0xfa, 0xed, 0x81, 0x19, 0x1c, 0xd1, 0x46,
0x3f, 0xa4, 0x9d, 0x5a, 0xae, 0xc5, 0x1e, 0x5a, 0xd8, 0x36, 0xd7, 0x39, 0x6e, 0xaf, 0x11, 0xd0, 0x29, 0xd3, 0x62, 0xdb, 0x36, 0x76, 0xac, 0x0d, 0x8e, 0xdb, 0xaa, 0x88, 0x3d, 0xfb, 0x6c, 0x0b,
0xec, 0x32, 0x12, 0x74, 0x1b, 0x1a, 0xee, 0xd8, 0xd1, 0xc9, 0x81, 0xee, 0x91, 0x23, 0x66, 0x73, 0xba, 0x05, 0x15, 0x6f, 0xe8, 0xb6, 0x49, 0xaf, 0xed, 0x93, 0x63, 0x66, 0x73, 0xce, 0xc2, 0x1b,
0xce, 0xc2, 0x1d, 0x3b, 0x8f, 0x0f, 0x7a, 0xe4, 0x88, 0xa2, 0x1f, 0x42, 0x9d, 0x25, 0x77, 0x6a, 0xba, 0x9f, 0xf7, 0x5a, 0xe4, 0x98, 0xa2, 0xef, 0x43, 0x99, 0x25, 0x77, 0xea, 0x90, 0x3e, 0x6d,
0x93, 0x21, 0xed, 0xcc, 0x14, 0xda, 0x7f, 0x42, 0xc0, 0xa8, 0x4d, 0xe6, 0x08, 0x9c, 0xba, 0x5e, 0xcc, 0x4c, 0x44, 0x7f, 0xb4, 0x81, 0xed, 0xb6, 0x98, 0x23, 0xf0, 0xdd, 0xe5, 0xc9, 0x76, 0x47,
0x8c, 0x3a, 0x22, 0x40, 0x77, 0xa0, 0x35, 0x20, 0xce, 0xc8, 0xe0, 0x1a, 0x7a, 0xe8, 0x11, 0xa7, 0x1b, 0xd0, 0x1d, 0xa8, 0x75, 0x89, 0x3b, 0x30, 0xb9, 0x86, 0xb6, 0x7d, 0xe2, 0x36, 0x80, 0x47,
0x03, 0x3c, 0x5a, 0x52, 0x50, 0xf4, 0x2e, 0x34, 0xb1, 0x6b, 0xf4, 0x6d, 0xe6, 0xb8, 0x26, 0x3e, 0x4b, 0x0a, 0x8a, 0xb6, 0xa1, 0x62, 0x7b, 0x16, 0x3e, 0x91, 0x7e, 0x5b, 0xe1, 0x7c, 0x96, 0x55,
0xee, 0x34, 0x16, 0x95, 0xbb, 0x33, 0xbd, 0x46, 0x00, 0xdb, 0x66, 0x20, 0xf4, 0x18, 0xd4, 0xe0, 0xb9, 0xf0, 0x09, 0xee, 0x72, 0x5e, 0xbb, 0x0c, 0x9d, 0x1b, 0x1d, 0xec, 0xf0, 0x93, 0xa2, 0xf7,
0xf2, 0xcd, 0x14, 0x25, 0xfc, 0xbb, 0xc9, 0xe5, 0x59, 0x4a, 0x67, 0x61, 0x13, 0x1f, 0xaf, 0x70, 0xa0, 0x2a, 0x8d, 0xda, 0xa6, 0xf6, 0x4b, 0xdc, 0xa8, 0x0a, 0x43, 0x4a, 0xd8, 0x81, 0xfd, 0x12,
0xa2, 0x87, 0x96, 0x8d, 0x99, 0x92, 0xb8, 0x73, 0xb4, 0xf8, 0x42, 0xf8, 0x4b, 0xb5, 0x57, 0x25, 0x1b, 0x7f, 0xc9, 0xc1, 0xdc, 0x18, 0x11, 0xd6, 0xf8, 0xf5, 0x38, 0x24, 0x74, 0x8e, 0xf0, 0x97,
0xb8, 0xc6, 0xdc, 0x23, 0x4c, 0xa2, 0x17, 0x77, 0xf1, 0x5b, 0x00, 0x26, 0xf5, 0xf5, 0x84, 0x9b, 0x91, 0xc4, 0x9e, 0xd9, 0x71, 0x58, 0x4c, 0x59, 0xf8, 0x84, 0xfb, 0xc6, 0x4c, 0xab, 0x22, 0x60,
0xd7, 0x4d, 0xea, 0xef, 0x04, 0x9e, 0xfe, 0x71, 0xe8, 0xc5, 0xe5, 0xfc, 0xf6, 0x23, 0xe5, 0xae, 0x9c, 0x00, 0xb3, 0xb1, 0x90, 0xde, 0x33, 0x5d, 0x2c, 0x1b, 0xb3, 0x32, 0x87, 0xec, 0x99, 0x2e,
0xd9, 0x84, 0x70, 0x91, 0x8b, 0x15, 0x4b, 0xc5, 0x94, 0x8c, 0xbd, 0x01, 0xd6, 0x13, 0xed, 0x72, 0x66, 0xb4, 0x85, 0x88, 0xa1, 0x67, 0x84, 0xbf, 0x6c, 0xa5, 0x33, 0xb4, 0x39, 0x57, 0xe1, 0x19,
0x33, 0x00, 0xee, 0xc8, 0x03, 0xb1, 0x26, 0x69, 0x33, 0xfe, 0xae, 0xc0, 0xbc, 0xb8, 0x1b, 0x5c, 0xe1, 0x2f, 0xda, 0x82, 0xaa, 0x20, 0x39, 0x30, 0x7d, 0xd3, 0x0d, 0xfd, 0xe2, 0x3d, 0x65, 0xbc,
0x5e, 0x5d, 0x79, 0x19, 0x21, 0x0c, 0x9f, 0xf2, 0x29, 0x7d, 0x66, 0xa5, 0x40, 0x42, 0xae, 0x4a, 0x3d, 0xc4, 0xa7, 0x4f, 0x4c, 0x67, 0x88, 0xf7, 0x4d, 0xdb, 0x6f, 0x09, 0x3d, 0xee, 0xf3, 0x5d,
0x12, 0x72, 0xb2, 0xd7, 0xaa, 0xa5, 0x7b, 0x2d, 0xed, 0xb7, 0x0a, 0xcc, 0x7f, 0x62, 0xb8, 0x26, 0xe8, 0x2e, 0xe8, 0x82, 0x4a, 0xcf, 0x76, 0xb0, 0xf4, 0x30, 0x96, 0x13, 0xca, 0xad, 0x1a, 0x87,
0x39, 0x38, 0xb8, 0xfc, 0x01, 0x37, 0xa0, 0x49, 0x27, 0xf9, 0xb5, 0x70, 0x2f, 0x95, 0x20, 0xd2, 0x6f, 0xdb, 0x0e, 0x16, 0x4e, 0x14, 0x1d, 0x81, 0xab, 0x6d, 0x46, 0xf8, 0x10, 0x87, 0x70, 0xa5,
0xbe, 0x2c, 0x01, 0x62, 0xee, 0xb0, 0x6e, 0xd8, 0x86, 0x3b, 0xc0, 0x17, 0x97, 0x66, 0x09, 0x5a, 0xbd, 0xca, 0xc1, 0x0d, 0x16, 0x4a, 0x61, 0xc1, 0xb9, 0x7c, 0x3a, 0x78, 0x07, 0xc0, 0xa2, 0x41,
0x09, 0x27, 0x88, 0x5e, 0x72, 0xe2, 0x5e, 0x40, 0xd1, 0xa7, 0xd0, 0xea, 0x07, 0xac, 0x74, 0x0f, 0x3b, 0x91, 0x12, 0xca, 0x16, 0x0d, 0xf6, 0x44, 0x56, 0xf8, 0x24, 0x8c, 0xf8, 0x7c, 0x76, 0xab,
0x1b, 0x94, 0xb8, 0xdc, 0x0e, 0xad, 0xb5, 0xf7, 0x65, 0x62, 0xef, 0x7b, 0xd6, 0x70, 0x88, 0xbd, 0x96, 0x0a, 0xed, 0xf1, 0xe4, 0x79, 0x99, 0x4b, 0x28, 0x2b, 0x5b, 0x94, 0x0c, 0xfd, 0x2e, 0x6e,
0x0d, 0xe2, 0x9a, 0x41, 0x97, 0x33, 0xdb, 0x0f, 0xc5, 0x64, 0xa4, 0xe8, 0x1d, 0x68, 0x4c, 0x22, 0x27, 0xae, 0x16, 0x55, 0x01, 0xdc, 0x53, 0x27, 0xad, 0x92, 0xa2, 0x25, 0xfb, 0x9b, 0x06, 0x8b,
0x22, 0x2c, 0x91, 0x10, 0x85, 0x04, 0x45, 0x1f, 0xc2, 0x5c, 0xb2, 0x01, 0x9a, 0x18, 0x4e, 0xa5, 0xf2, 0x1e, 0x75, 0x75, 0x75, 0x65, 0x65, 0xcf, 0x30, 0xd5, 0xe4, 0xcf, 0xe8, 0xc9, 0x0b, 0x13,
0xf1, 0xde, 0x86, 0x19, 0xe7, 0x97, 0x80, 0xa2, 0xa2, 0xcf, 0x4b, 0x13, 0xcf, 0xe8, 0x45, 0xee, 0x14, 0xaf, 0xa2, 0xa2, 0x78, 0x25, 0xfb, 0xd2, 0x52, 0xba, 0x2f, 0x35, 0x7e, 0xa3, 0xc1, 0xe2,
0x73, 0x37, 0xa1, 0x6e, 0x86, 0x94, 0xe2, 0x76, 0x35, 0x01, 0xb0, 0xf0, 0x08, 0x24, 0xd4, 0x6d, 0xa7, 0xa6, 0x67, 0x91, 0x5e, 0xef, 0xea, 0x07, 0xdc, 0x8c, 0x22, 0x76, 0xf7, 0x22, 0x7d, 0x67,
0x62, 0x98, 0xd8, 0x0c, 0x93, 0x7a, 0x00, 0xfc, 0x8c, 0xc3, 0xb4, 0xaf, 0x4a, 0xa0, 0xc6, 0x9b, 0x62, 0x93, 0xf1, 0x65, 0x0e, 0x10, 0x73, 0x87, 0x0d, 0xd3, 0x31, 0xbd, 0x2e, 0xbe, 0xbc, 0x34,
0xaa, 0xc2, 0xbc, 0xaf, 0xe6, 0x76, 0x77, 0x4a, 0x07, 0x59, 0xb9, 0x44, 0x07, 0x99, 0xed, 0x70, 0xcb, 0x50, 0x4b, 0x38, 0x41, 0xf4, 0xea, 0x15, 0xf7, 0x02, 0x8a, 0x1e, 0x42, 0xad, 0x23, 0x58,
0xab, 0x17, 0xeb, 0x70, 0xb5, 0xdf, 0x2b, 0xd0, 0x4e, 0x5d, 0xa6, 0xd2, 0xe5, 0x55, 0xc9, 0x96, 0xb5, 0x7d, 0x6c, 0x52, 0xe2, 0x71, 0x3b, 0xd4, 0xd6, 0x3f, 0x50, 0x89, 0x7d, 0xe8, 0xdb, 0xfd,
0xd7, 0xef, 0x43, 0x95, 0xd5, 0x1c, 0xcc, 0x95, 0xd4, 0x4a, 0xb3, 0x95, 0x5d, 0xd1, 0x7a, 0x01, 0x3e, 0xf6, 0x37, 0x89, 0x67, 0x89, 0x8e, 0x70, 0xb6, 0x13, 0x8a, 0xc9, 0xb6, 0xa2, 0x77, 0xa1,
0x01, 0x5a, 0x85, 0x6b, 0x92, 0x27, 0x33, 0x61, 0x4a, 0x94, 0x7d, 0x31, 0xd3, 0xfe, 0x5a, 0x81, 0x32, 0x8a, 0x88, 0xb0, 0x9d, 0x80, 0x28, 0x24, 0x28, 0xfa, 0x08, 0xe6, 0x92, 0xcd, 0xe2, 0xc8,
0x46, 0x4c, 0x1f, 0x67, 0x74, 0x06, 0x69, 0x4b, 0x97, 0x24, 0x96, 0x4e, 0x1d, 0xaf, 0x9c, 0x3d, 0x70, 0x3a, 0x8d, 0xf7, 0x81, 0xcc, 0x38, 0x3f, 0x07, 0x14, 0x35, 0x48, 0xbc, 0x8c, 0xf3, 0xf4,
0x5e, 0xce, 0xd3, 0x12, 0x5a, 0x80, 0x19, 0x07, 0x3b, 0x3a, 0xb5, 0x5e, 0x86, 0xbd, 0xc1, 0xb4, 0x36, 0xc9, 0xdd, 0xf7, 0x26, 0x94, 0xad, 0x70, 0xa7, 0xbc, 0x89, 0x8e, 0x00, 0x2c, 0x3c, 0x84,
0x83, 0x9d, 0x3d, 0xeb, 0x25, 0x66, 0x4b, 0xac, 0xac, 0xf3, 0x9a, 0x1e, 0xa4, 0xe4, 0x69, 0x77, 0x84, 0x6d, 0x87, 0x98, 0x16, 0xb6, 0xc2, 0x02, 0x28, 0x80, 0x9f, 0x71, 0x98, 0xf1, 0x55, 0x0e,
0xec, 0xf0, 0x8a, 0x7e, 0x0b, 0x20, 0x28, 0x85, 0xae, 0xe1, 0x60, 0x5e, 0xf0, 0xeb, 0xbd, 0x3a, 0xf4, 0x78, 0x03, 0x3a, 0x31, 0xef, 0xeb, 0xb9, 0x09, 0x9f, 0xd1, 0x6d, 0x17, 0xae, 0xd0, 0x6d,
0x87, 0xec, 0x18, 0x0e, 0x46, 0x1d, 0x98, 0xe6, 0x3f, 0xdb, 0x9b, 0x9d, 0x99, 0x80, 0x50, 0xfc, 0x8f, 0xdf, 0x06, 0x8a, 0x97, 0xbb, 0x0d, 0x18, 0xbf, 0xd7, 0xa0, 0x9e, 0xba, 0x78, 0xa6, 0x5b,
0x26, 0xc3, 0xa1, 0x9e, 0x0e, 0x87, 0xa2, 0xc5, 0xfa, 0x1e, 0x5c, 0x1b, 0xf0, 0x97, 0x10, 0x73, 0x11, 0x6d, 0xbc, 0x15, 0xf9, 0x2e, 0x14, 0x59, 0x7d, 0xc6, 0x5c, 0x49, 0xb5, 0x34, 0x5b, 0xd5,
0xfd, 0x64, 0x23, 0x5a, 0x12, 0x35, 0x5b, 0xb6, 0x84, 0x1e, 0x32, 0xe7, 0xe2, 0x1a, 0xd5, 0x03, 0x75, 0xb6, 0x25, 0x36, 0xa0, 0x35, 0xb8, 0xa1, 0x78, 0x5e, 0x94, 0xa6, 0x44, 0xe3, 0xaf, 0x8b,
0x2b, 0x37, 0xb9, 0x95, 0xdf, 0x95, 0xdf, 0x48, 0x03, 0xcc, 0xc0, 0xc8, 0x61, 0x4e, 0xe4, 0x7f, 0xc6, 0x2f, 0x0a, 0x50, 0x89, 0xe9, 0xe3, 0x9c, 0x2e, 0x2a, 0x6d, 0xe9, 0x9c, 0xc2, 0xd2, 0xa9,
0x99, 0x36, 0x61, 0xb6, 0x58, 0x9b, 0xd0, 0xba, 0x4c, 0x9b, 0xf0, 0x65, 0x19, 0x5a, 0x93, 0x02, 0xe3, 0xe5, 0xc7, 0x8f, 0x97, 0xf1, 0x0c, 0x87, 0x96, 0x60, 0xc6, 0xc5, 0xae, 0x28, 0x50, 0xb2,
0x5b, 0x38, 0xfa, 0x8b, 0xbc, 0xf6, 0xee, 0x80, 0x3a, 0x79, 0xa8, 0xe0, 0x8a, 0x39, 0xb5, 0x47, 0x5a, 0xba, 0xd8, 0x65, 0xe5, 0x89, 0x2d, 0xb1, 0x16, 0x88, 0xf7, 0x3f, 0x22, 0x25, 0x4f, 0x7b,
0x48, 0x3f, 0x51, 0xb4, 0x47, 0xa9, 0x30, 0xfb, 0x18, 0xea, 0x2c, 0x91, 0xe9, 0xfe, 0xc9, 0x08, 0x43, 0x97, 0x77, 0x3f, 0xc9, 0xda, 0x3c, 0x7d, 0x46, 0x6d, 0x9e, 0x49, 0xd6, 0xe6, 0x44, 0x38,
0x73, 0x47, 0x6b, 0xa5, 0x0b, 0x44, 0xb0, 0x11, 0xcb, 0x6c, 0xfb, 0x27, 0x23, 0xdc, 0x9b, 0xb1, 0x94, 0xd3, 0xe1, 0x30, 0x69, 0x63, 0x73, 0x0f, 0x6e, 0x74, 0xf9, 0xab, 0x91, 0xb5, 0x71, 0xba,
0xc5, 0xd7, 0x25, 0xdf, 0x0e, 0xd1, 0x7d, 0xb8, 0xe1, 0x05, 0xed, 0x81, 0xa9, 0x27, 0x8e, 0x1d, 0x19, 0x2d, 0x35, 0x2a, 0xbc, 0x89, 0x50, 0x2d, 0xa1, 0x6d, 0xe6, 0x5c, 0xb2, 0x85, 0xe1, 0x56,
0x54, 0xda, 0xeb, 0xe1, 0xe2, 0x6e, 0xfc, 0xf8, 0x39, 0x91, 0x3b, 0x9d, 0x1b, 0xb9, 0xff, 0x56, 0xae, 0x72, 0x2b, 0xab, 0x4b, 0xbf, 0xb4, 0x8d, 0x30, 0x72, 0x98, 0x13, 0xf9, 0x5f, 0xba, 0xa5,
0x60, 0x4e, 0x78, 0x07, 0xf3, 0xd9, 0x21, 0xbf, 0xb1, 0xb0, 0x3c, 0x4b, 0x5c, 0xdb, 0x72, 0xa3, 0x9a, 0xbd, 0x64, 0x4b, 0x65, 0x7c, 0x99, 0x87, 0xda, 0xa8, 0x68, 0x4e, 0x1c, 0xd1, 0x93, 0xbc,
0x26, 0x47, 0x98, 0x23, 0x00, 0x8a, 0x26, 0xe7, 0x13, 0x68, 0x0b, 0xa4, 0x28, 0x5d, 0x16, 0xac, 0x76, 0xef, 0x81, 0x3e, 0x7a, 0xa8, 0xe1, 0x87, 0x3d, 0xb3, 0xee, 0xa7, 0x9f, 0x68, 0xea, 0x83,
0xca, 0xad, 0x80, 0x2e, 0x4a, 0x94, 0x4b, 0xd0, 0x22, 0x07, 0x07, 0x71, 0x7e, 0x41, 0xbc, 0xcf, 0x54, 0xe8, 0x7c, 0x02, 0x65, 0x96, 0x9c, 0xda, 0xc1, 0xe9, 0x00, 0x73, 0xe7, 0xa9, 0xa5, 0x93,
0x0a, 0xa8, 0x60, 0xf8, 0x13, 0x50, 0x43, 0xb4, 0xf3, 0x26, 0xe8, 0xb6, 0x20, 0x8c, 0x6e, 0xf7, 0xbe, 0x20, 0xc4, 0xb2, 0xd5, 0xe1, 0xe9, 0x00, 0xb7, 0x66, 0x1c, 0xf9, 0x75, 0xc5, 0xb7, 0x53,
0xbf, 0x56, 0xa0, 0x93, 0x4c, 0xd7, 0xb1, 0xe3, 0x9f, 0xbf, 0x21, 0xf8, 0x41, 0xf2, 0x8d, 0x67, 0x74, 0x1f, 0x16, 0x7c, 0x51, 0xf2, 0xad, 0x76, 0xe2, 0xd8, 0xa2, 0x7a, 0xce, 0x87, 0x8b, 0xfb,
0xe9, 0x14, 0x79, 0x26, 0x7c, 0x44, 0x47, 0xba, 0xfc, 0x12, 0x5a, 0x49, 0x3f, 0x44, 0x4d, 0x98, 0xf1, 0xe3, 0x67, 0x44, 0xe3, 0x74, 0x66, 0x34, 0xfe, 0x4b, 0x83, 0x39, 0x69, 0x71, 0xe6, 0x87,
0xd9, 0x21, 0xfe, 0x8f, 0x8f, 0x2d, 0xea, 0xab, 0x53, 0xa8, 0x05, 0xb0, 0x43, 0xfc, 0x5d, 0x0f, 0x7d, 0x7e, 0x63, 0x63, 0xb9, 0x93, 0x78, 0x8e, 0xed, 0x45, 0x8d, 0x8b, 0x34, 0x87, 0x00, 0xca,
0x53, 0xec, 0xfa, 0xaa, 0x82, 0x00, 0x6a, 0x8f, 0xdd, 0x4d, 0x8b, 0x3e, 0x57, 0x4b, 0xe8, 0x9a, 0xc6, 0xe5, 0x53, 0xa8, 0x4b, 0xa4, 0x28, 0x05, 0x4e, 0x58, 0x69, 0x6b, 0x62, 0x5f, 0x94, 0xfc,
0xa8, 0x0c, 0x86, 0xbd, 0x2d, 0x8c, 0xab, 0x96, 0x19, 0x79, 0xf4, 0x57, 0x41, 0x2a, 0x34, 0x23, 0x96, 0xa1, 0x46, 0x7a, 0xbd, 0x38, 0x3f, 0x11, 0xc3, 0xb3, 0x12, 0x2a, 0x19, 0xfe, 0x08, 0xf4,
0x94, 0xad, 0xdd, 0x27, 0x6a, 0x15, 0xd5, 0xa1, 0x1a, 0x7c, 0xd6, 0x96, 0x4d, 0x50, 0xd3, 0x8d, 0x10, 0xed, 0xa2, 0x49, 0xb7, 0x2e, 0x37, 0x46, 0xaf, 0x1b, 0xbf, 0xd2, 0xa0, 0x91, 0x4c, 0xc1,
0x07, 0xdb, 0xf3, 0x89, 0xfb, 0xa9, 0x4b, 0x8e, 0x22, 0x90, 0x3a, 0x85, 0x1a, 0x30, 0x2d, 0x9a, 0xb1, 0xe3, 0x5f, 0xbc, 0xc8, 0x7f, 0x2f, 0xf9, 0xc6, 0xb5, 0x7c, 0x86, 0x3c, 0x23, 0x3e, 0xb2,
0x39, 0x55, 0x41, 0x6d, 0x68, 0xc4, 0xfa, 0x28, 0xb5, 0xc4, 0x00, 0x5b, 0xde, 0x68, 0x20, 0x3a, 0xcb, 0x5c, 0x79, 0x09, 0xb5, 0xa4, 0x1f, 0xa2, 0x2a, 0xcc, 0xec, 0x91, 0xe0, 0x87, 0x27, 0x36,
0xaa, 0x40, 0x04, 0x66, 0xb5, 0x4d, 0x72, 0xe4, 0xaa, 0x95, 0xe5, 0x07, 0x30, 0x13, 0x06, 0x08, 0x0d, 0xf4, 0x29, 0x54, 0x03, 0xd8, 0x23, 0xc1, 0xbe, 0x8f, 0x29, 0xf6, 0x02, 0x5d, 0x43, 0x00,
0x3b, 0x4d, 0xb0, 0x3b, 0xfb, 0x53, 0xa7, 0xd0, 0x1c, 0xcc, 0x26, 0x26, 0x01, 0xaa, 0x82, 0x10, 0xa5, 0xcf, 0xbd, 0x2d, 0x9b, 0x3e, 0xd7, 0x73, 0xe8, 0x86, 0xcc, 0xf6, 0xa6, 0xb3, 0x2b, 0x8d,
0xb4, 0xec, 0xc4, 0xf8, 0x45, 0x2d, 0xad, 0xfd, 0xad, 0x01, 0x10, 0xf4, 0x0c, 0x84, 0x78, 0x26, 0xab, 0xe7, 0xd9, 0xf6, 0xe8, 0xaf, 0x80, 0x74, 0xa8, 0x46, 0x28, 0x3b, 0xfb, 0x8f, 0xf5, 0x22,
0x1a, 0x01, 0xda, 0xc2, 0x3e, 0xcb, 0x87, 0xc4, 0x0d, 0x73, 0x19, 0x45, 0xf7, 0x72, 0x4a, 0x6b, 0x2a, 0x43, 0x51, 0x7c, 0x96, 0x56, 0x2c, 0xd0, 0xd3, 0xcd, 0x04, 0xa3, 0xf9, 0xd8, 0x7b, 0xe8,
0x16, 0x55, 0x48, 0xda, 0xbd, 0x93, 0x43, 0x91, 0x42, 0xd7, 0xa6, 0x90, 0xc3, 0x39, 0xb2, 0x1b, 0x91, 0xe3, 0x08, 0xa4, 0x4f, 0xa1, 0x0a, 0x4c, 0xcb, 0x06, 0x4d, 0xd7, 0x50, 0x1d, 0x2a, 0xb1,
0xe6, 0xbe, 0x35, 0x78, 0x1e, 0x35, 0x1b, 0xf9, 0x1c, 0x53, 0xa8, 0x21, 0xc7, 0x54, 0x1e, 0x12, 0xde, 0x48, 0xcf, 0x31, 0xc0, 0x8e, 0x3f, 0xe8, 0xca, 0x2e, 0x49, 0x88, 0xc0, 0xac, 0xb6, 0x45,
0x3f, 0x7b, 0xbe, 0x67, 0xb9, 0xc3, 0xf0, 0xa1, 0x51, 0x9b, 0x42, 0x2f, 0xe0, 0xfa, 0x16, 0xe6, 0x8e, 0x3d, 0xbd, 0xb0, 0xf2, 0x00, 0x66, 0xc2, 0x00, 0x61, 0xa7, 0x11, 0xd4, 0xd9, 0x9f, 0x3e,
0xdc, 0x2d, 0xea, 0x5b, 0x03, 0x1a, 0x32, 0x5c, 0xcb, 0x67, 0x98, 0x41, 0x3e, 0x27, 0x4b, 0x1b, 0x85, 0xe6, 0x60, 0x36, 0x31, 0x09, 0xd1, 0x35, 0x84, 0xa0, 0xe6, 0x24, 0xc6, 0x4f, 0x7a, 0x6e,
0xda, 0xa9, 0x71, 0x27, 0x5a, 0x96, 0x3a, 0xb2, 0x74, 0x34, 0xdb, 0xfd, 0xb0, 0x10, 0x6e, 0xc4, 0xfd, 0xaf, 0x15, 0x00, 0xd1, 0x07, 0x10, 0xe2, 0x5b, 0x68, 0x00, 0x68, 0x07, 0x07, 0x2c, 0xc7,
0xcd, 0x82, 0x56, 0x72, 0x14, 0x88, 0xbe, 0x95, 0xb7, 0x41, 0x66, 0x76, 0xd2, 0x5d, 0x2e, 0x82, 0x11, 0x2f, 0xcc, 0x4f, 0x14, 0xdd, 0xcb, 0x28, 0x97, 0xe3, 0xa8, 0x52, 0xd2, 0xe6, 0x9d, 0x8c,
0x1a, 0xb1, 0x7a, 0x0a, 0xad, 0xe4, 0xb0, 0x49, 0xce, 0x4a, 0x3a, 0x90, 0xea, 0x9e, 0xf6, 0xc6, 0x1d, 0x29, 0x74, 0x63, 0x0a, 0xb9, 0x9c, 0x23, 0xbb, 0x61, 0x1f, 0xda, 0xdd, 0xe7, 0x51, 0x03,
0xab, 0x4d, 0xa1, 0x5f, 0xc0, 0x5c, 0x66, 0xc2, 0x83, 0xbe, 0x2d, 0xdb, 0x3e, 0x6f, 0x10, 0x74, 0x91, 0xcd, 0x31, 0x85, 0x1a, 0x72, 0x4c, 0xe5, 0x21, 0xf9, 0x73, 0x10, 0xf8, 0xb6, 0xd7, 0x0f,
0x16, 0x07, 0x21, 0xfd, 0x44, 0x8b, 0xf9, 0xd2, 0x67, 0x46, 0x7d, 0xc5, 0xa5, 0x8f, 0x6d, 0x7f, 0x1f, 0x5a, 0x8d, 0x29, 0xf4, 0x02, 0xe6, 0x77, 0x30, 0xe7, 0x6e, 0xd3, 0xc0, 0xee, 0xd2, 0x90,
0x9a, 0xf4, 0xe7, 0xe6, 0x30, 0x06, 0x94, 0x9d, 0xf1, 0xa0, 0x8f, 0x64, 0x2c, 0x72, 0xe7, 0x4c, 0xe1, 0x7a, 0x36, 0xc3, 0x31, 0xe4, 0x0b, 0xb2, 0x74, 0xa0, 0x9e, 0x1a, 0xf7, 0xa2, 0x15, 0xa5,
0xdd, 0x95, 0xa2, 0xe8, 0x91, 0xc9, 0xc7, 0x3c, 0x5a, 0xd3, 0x4d, 0xb3, 0x94, 0x6d, 0xee, 0x5c, 0x23, 0x2b, 0x47, 0xd3, 0xcd, 0x8f, 0x26, 0xc2, 0x8d, 0xb8, 0xd9, 0x50, 0x4b, 0x8e, 0x42, 0xd1,
0x47, 0xce, 0x36, 0x7f, 0xb4, 0x12, 0x38, 0x75, 0x72, 0x74, 0x20, 0xb7, 0x95, 0x74, 0xdc, 0x21, 0x37, 0xb2, 0x08, 0x8c, 0xcd, 0x8e, 0x9a, 0x2b, 0x93, 0xa0, 0x46, 0xac, 0x9e, 0x42, 0x2d, 0x39,
0x77, 0x6a, 0xf9, 0x24, 0x42, 0x9b, 0x42, 0xfb, 0x89, 0x1c, 0x8c, 0xee, 0xe4, 0xf9, 0x44, 0xf2, 0x6c, 0x53, 0xb3, 0x52, 0x0e, 0xe4, 0x9a, 0x67, 0xbd, 0x71, 0x1b, 0x53, 0xe8, 0x67, 0x30, 0x37,
0xb2, 0x7b, 0x96, 0xb9, 0x74, 0x80, 0x2d, 0xec, 0x3f, 0xc2, 0xbe, 0x67, 0x0d, 0x68, 0x7a, 0x53, 0x36, 0xe1, 0x42, 0xdf, 0x54, 0x91, 0xcf, 0x1a, 0x84, 0x9d, 0xc7, 0x41, 0x4a, 0x3f, 0xd2, 0x62,
0xf1, 0x33, 0x41, 0x08, 0x37, 0xfd, 0xe0, 0x4c, 0xbc, 0x50, 0xec, 0xb5, 0x57, 0x00, 0x75, 0x6e, 0xb6, 0xf4, 0x63, 0xa3, 0xce, 0xc9, 0xa5, 0x8f, 0x91, 0x3f, 0x4b, 0xfa, 0x0b, 0x73, 0x18, 0x02,
0x33, 0x56, 0x1e, 0xfe, 0x9f, 0xc6, 0xaf, 0x20, 0x8d, 0x3f, 0x83, 0x76, 0x6a, 0x6e, 0x24, 0x4f, 0x1a, 0x9f, 0x71, 0xa1, 0x8f, 0x55, 0x2c, 0x32, 0xe7, 0x6c, 0xcd, 0xd5, 0x49, 0xd1, 0x23, 0x93,
0xe3, 0xf2, 0xe1, 0xd2, 0x59, 0x0e, 0xd2, 0x07, 0x94, 0x9d, 0x8a, 0xc8, 0x03, 0x2b, 0x77, 0x7a, 0x0f, 0x79, 0xb4, 0xa6, 0x1b, 0x61, 0x25, 0xdb, 0xcc, 0xb9, 0x96, 0x9a, 0x6d, 0xf6, 0x68, 0x49,
0x72, 0x16, 0x8f, 0x67, 0xd0, 0x4e, 0x8d, 0x25, 0xe4, 0x27, 0x90, 0xcf, 0x2e, 0x0a, 0x9c, 0x20, 0x38, 0x75, 0x72, 0x74, 0xa2, 0xb6, 0x95, 0x72, 0xdc, 0xa3, 0x76, 0x6a, 0xf5, 0x24, 0xc6, 0x98,
0xfb, 0x18, 0x2f, 0x3f, 0x41, 0xee, 0xa3, 0xfd, 0x59, 0x3c, 0x3e, 0x87, 0x66, 0xfc, 0x1d, 0x14, 0x42, 0x87, 0x89, 0x1c, 0x8c, 0xee, 0x64, 0xf9, 0x44, 0xf2, 0x02, 0x7b, 0x9e, 0xb9, 0xda, 0x00,
0x7d, 0x90, 0x17, 0x9d, 0xa9, 0x97, 0xb1, 0x37, 0x9f, 0xaf, 0xaf, 0xbe, 0x9e, 0x3d, 0x83, 0x76, 0x3b, 0x38, 0x78, 0x84, 0x03, 0xdf, 0xee, 0xd2, 0x34, 0x51, 0xf9, 0x33, 0x42, 0x08, 0x89, 0x7e,
0xea, 0xdd, 0x53, 0x6e, 0x5d, 0xf9, 0xe3, 0xe8, 0x59, 0xbb, 0x7f, 0x8d, 0x19, 0xf8, 0xaa, 0x73, 0x78, 0x2e, 0x5e, 0x28, 0xf6, 0xfa, 0x2b, 0x80, 0x32, 0xb7, 0x19, 0x2b, 0x0f, 0xff, 0x4b, 0xe3,
0xe5, 0xfa, 0x77, 0x9f, 0xae, 0x0d, 0x2d, 0xff, 0x70, 0xdc, 0x67, 0xa7, 0x5c, 0x0d, 0x30, 0x3f, 0xd7, 0x90, 0xc6, 0x9f, 0x41, 0x3d, 0x35, 0x37, 0x53, 0xa7, 0x71, 0xf5, 0x70, 0xed, 0x3c, 0x07,
0xb2, 0x88, 0xf8, 0x5a, 0x0d, 0x93, 0xc6, 0x2a, 0xdf, 0x69, 0x95, 0x4b, 0x3b, 0xea, 0xf7, 0x6b, 0xe9, 0x00, 0x1a, 0x9f, 0x0a, 0xa9, 0x03, 0x2b, 0x73, 0x7a, 0x74, 0x1e, 0x8f, 0x67, 0x50, 0x4f,
0xfc, 0xf7, 0xfe, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x7f, 0xb6, 0xed, 0xcc, 0x27, 0x00, 0x8d, 0x65, 0xd4, 0x27, 0x50, 0xcf, 0x6e, 0x26, 0x38, 0xc1, 0xf8, 0x30, 0x42, 0x7d, 0x82, 0xcc,
0x00, 0xa1, 0xc5, 0x79, 0x3c, 0x9e, 0x40, 0x35, 0xfe, 0xb6, 0x89, 0x3e, 0xcc, 0x8a, 0xce, 0xd4, 0x6b,
0xd7, 0x9b, 0xcf, 0xd7, 0xd7, 0x5f, 0xcf, 0x9e, 0x41, 0x3d, 0xf5, 0x96, 0xa9, 0xb6, 0xae, 0xfa,
0xc1, 0xf3, 0x3c, 0xea, 0x5f, 0x63, 0x06, 0xbe, 0xee, 0x5c, 0xb9, 0xf1, 0xed, 0xa7, 0xeb, 0x7d,
0x3b, 0x38, 0x1a, 0x76, 0xd8, 0x29, 0xd7, 0x04, 0xe6, 0xc7, 0x36, 0x91, 0x5f, 0x6b, 0x61, 0xd2,
0x58, 0xe3, 0x94, 0xd6, 0xb8, 0xb4, 0x83, 0x4e, 0xa7, 0xc4, 0x7f, 0xef, 0xff, 0x27, 0x00, 0x00,
0xff, 0xff, 0x7b, 0x37, 0x4e, 0x07, 0xb9, 0x28, 0x00, 0x00,
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.

36
internal/querycoord/cluster.go
View File

@ -706,32 +706,32 @@ func defaultSegEstimatePolicy() segEstimatePolicy {
type segEstimatePolicy func(request *querypb.LoadSegmentsRequest, dataKv kv.DataKV) (int64, error) type segEstimatePolicy func(request *querypb.LoadSegmentsRequest, dataKv kv.DataKV) (int64, error)
func estimateSegmentsSize(segments *querypb.LoadSegmentsRequest, kvClient kv.DataKV) (int64, error) { func estimateSegmentsSize(segments *querypb.LoadSegmentsRequest, kvClient kv.DataKV) (int64, error) {
segmentSize := int64(0) requestSize := int64(0)
//TODO:: collection has multi vector field
//vecFields := make([]int64, 0)
//for _, field := range segments.Schema.Fields {
// if field.DataType == schemapb.DataType_BinaryVector || field.DataType == schemapb.DataType_FloatVector {
// vecFields = append(vecFields, field.FieldID)
// }
//}
// get fields data size, if len(indexFieldIDs) == 0, vector field would be involved in fieldBinLogs
for _, loadInfo := range segments.Infos { for _, loadInfo := range segments.Infos {
// get index size segmentSize := int64(0)
if loadInfo.EnableIndex { // get which field has index file
for _, pathInfo := range loadInfo.IndexPathInfos { vecFieldIndexInfo := make(map[int64]*querypb.VecFieldIndexInfo)
segmentSize += int64(pathInfo.GetSerializedSize()) for _, indexInfo := range loadInfo.IndexInfos {
if indexInfo.EnableIndex {
fieldID := indexInfo.FieldID
vecFieldIndexInfo[fieldID] = indexInfo
} }
continue
} }
// get binlog size
for _, binlogPath := range loadInfo.BinlogPaths { for _, binlogPath := range loadInfo.BinlogPaths {
fieldID := binlogPath.FieldID
// if index node has built index, cal segment size by index file size, or use raw data's binlog size
if indexInfo, ok := vecFieldIndexInfo[fieldID]; ok {
segmentSize += indexInfo.IndexSize
} else {
for _, binlog := range binlogPath.Binlogs { for _, binlog := range binlogPath.Binlogs {
segmentSize += binlog.GetLogSize() segmentSize += binlog.GetLogSize()
} }
} }
} }
loadInfo.SegmentSize = segmentSize
return segmentSize, nil requestSize += segmentSize
}
return requestSize, nil
} }

53
internal/querycoord/cluster_test.go
View File

@ -37,7 +37,6 @@ import (
"github.com/milvus-io/milvus/internal/proto/commonpb" "github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/datapb" "github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/etcdpb" "github.com/milvus-io/milvus/internal/proto/etcdpb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/querypb" "github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/proto/schemapb" "github.com/milvus-io/milvus/internal/proto/schemapb"
"github.com/milvus-io/milvus/internal/storage" "github.com/milvus-io/milvus/internal/storage"
@ -652,22 +651,9 @@ func TestGrpcRequest(t *testing.T) {
func TestEstimateSegmentSize(t *testing.T) { func TestEstimateSegmentSize(t *testing.T) {
refreshParams() refreshParams()
baseCtx, cancel := context.WithCancel(context.Background())
option := &minioKV.Option{
Address: Params.QueryCoordCfg.MinioEndPoint,
AccessKeyID: Params.QueryCoordCfg.MinioAccessKeyID,
SecretAccessKeyID: Params.QueryCoordCfg.MinioSecretAccessKey,
UseSSL: Params.QueryCoordCfg.MinioUseSSLStr,
CreateBucket: true,
BucketName: Params.QueryCoordCfg.MinioBucketName,
}
dataKV, err := minioKV.NewMinIOKV(baseCtx, option)
assert.Nil(t, err)
schema := genCollectionSchema(defaultCollectionID, false)
binlog := []*datapb.FieldBinlog{ binlog := []*datapb.FieldBinlog{
{ {
FieldID: simpleConstField.id, FieldID: defaultVecFieldID,
Binlogs: []*datapb.Binlog{{LogPath: "by-dev/rand/path", LogSize: 1024}}, Binlogs: []*datapb.Binlog{{LogPath: "by-dev/rand/path", LogSize: 1024}},
}, },
} }
@ -681,43 +667,22 @@ func TestEstimateSegmentSize(t *testing.T) {
} }
loadReq := &querypb.LoadSegmentsRequest{ loadReq := &querypb.LoadSegmentsRequest{
Schema: schema,
Infos: []*querypb.SegmentLoadInfo{loadInfo}, Infos: []*querypb.SegmentLoadInfo{loadInfo},
CollectionID: defaultCollectionID, CollectionID: defaultCollectionID,
} }
size, err := estimateSegmentsSize(loadReq, dataKV) size, err := estimateSegmentsSize(loadReq, nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1024), size) assert.Equal(t, int64(1024), size)
binlog, err = saveSimpleBinLog(baseCtx, schema, dataKV) indexInfo := &querypb.VecFieldIndexInfo{
assert.NoError(t, err) FieldID: defaultVecFieldID,
EnableIndex: true,
loadInfo.BinlogPaths = binlog IndexSize: 2048,
size, err = estimateSegmentsSize(loadReq, dataKV)
assert.NoError(t, err)
assert.NotEqual(t, int64(1024), size)
indexPath, err := generateIndex(defaultSegmentID)
assert.NoError(t, err)
indexInfo := &indexpb.IndexFilePathInfo{
IndexFilePaths: indexPath,
SerializedSize: 1024,
} }
loadInfo.IndexPathInfos = []*indexpb.IndexFilePathInfo{indexInfo}
loadInfo.EnableIndex = true
size, err = estimateSegmentsSize(loadReq, dataKV) loadInfo.IndexInfos = []*querypb.VecFieldIndexInfo{indexInfo}
size, err = estimateSegmentsSize(loadReq, nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1024), size) assert.Equal(t, int64(2048), size)
indexInfo.IndexFilePaths = []string{"&*^*(^*(&*%^&*^(&"}
indexInfo.SerializedSize = 0
size, err = estimateSegmentsSize(loadReq, dataKV)
assert.NoError(t, err)
assert.Equal(t, int64(0), size)
cancel()
} }

75
internal/querycoord/index_checker.go
View File

@ -31,18 +31,10 @@ import (
"github.com/milvus-io/milvus/internal/proto/indexpb" "github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb" "github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/querypb" "github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/proto/schemapb"
"github.com/milvus-io/milvus/internal/types" "github.com/milvus-io/milvus/internal/types"
) )
type indexInfo struct {
segmentID UniqueID
collectionID UniqueID
partitionID UniqueID
infos []*indexpb.IndexFilePathInfo
enableIndex bool
}
// IndexChecker checks index // IndexChecker checks index
type IndexChecker struct { type IndexChecker struct {
ctx context.Context ctx context.Context
@ -127,7 +119,8 @@ func (ic *IndexChecker) reloadFromKV() error {
log.Error("reloadFromKV: unmarshal failed", zap.Any("error", err.Error())) log.Error("reloadFromKV: unmarshal failed", zap.Any("error", err.Error()))
return err return err
} }
if ic.verifyHandoffReqValid(segmentInfo) && Params.QueryCoordCfg.AutoHandoff { validHandoffReq, _ := ic.verifyHandoffReqValid(segmentInfo)
if validHandoffReq && Params.QueryCoordCfg.AutoHandoff {
// push the req to handoffReqChan and then wait to load after index created // push the req to handoffReqChan and then wait to load after index created
// in case handoffReqChan is full, and block start process // in case handoffReqChan is full, and block start process
go ic.enqueueHandoffReq(segmentInfo) go ic.enqueueHandoffReq(segmentInfo)
@ -146,7 +139,7 @@ func (ic *IndexChecker) reloadFromKV() error {
return nil return nil
} }
func (ic *IndexChecker) verifyHandoffReqValid(req *querypb.SegmentInfo) bool { func (ic *IndexChecker) verifyHandoffReqValid(req *querypb.SegmentInfo) (bool, *querypb.CollectionInfo) {
// if collection has not been loaded, then skip the segment // if collection has not been loaded, then skip the segment
collectionInfo, err := ic.meta.getCollectionInfoByID(req.CollectionID) collectionInfo, err := ic.meta.getCollectionInfoByID(req.CollectionID)
if err == nil { if err == nil {
@ -154,7 +147,7 @@ func (ic *IndexChecker) verifyHandoffReqValid(req *querypb.SegmentInfo) bool {
if collectionInfo.LoadType == querypb.LoadType_LoadPartition { if collectionInfo.LoadType == querypb.LoadType_LoadPartition {
for _, id := range collectionInfo.PartitionIDs { for _, id := range collectionInfo.PartitionIDs {
if id == req.PartitionID { if id == req.PartitionID {
return true return true, collectionInfo
} }
} }
} else { } else {
@ -165,12 +158,12 @@ func (ic *IndexChecker) verifyHandoffReqValid(req *querypb.SegmentInfo) bool {
} }
} }
if !partitionReleased { if !partitionReleased {
return true return true, collectionInfo
} }
} }
} }
return false return false, nil
} }
func (ic *IndexChecker) enqueueHandoffReq(req *querypb.SegmentInfo) { func (ic *IndexChecker) enqueueHandoffReq(req *querypb.SegmentInfo) {
@ -196,15 +189,14 @@ func (ic *IndexChecker) checkIndexLoop() {
// TODO:: check whether the index exists in parallel, in case indexCoord cannot create the index normally, and then block the loop // TODO:: check whether the index exists in parallel, in case indexCoord cannot create the index normally, and then block the loop
log.Debug("checkIndexLoop: start check index for handoff segment", zap.Int64("segmentID", segmentInfo.SegmentID)) log.Debug("checkIndexLoop: start check index for handoff segment", zap.Int64("segmentID", segmentInfo.SegmentID))
for { for {
if ic.verifyHandoffReqValid(segmentInfo) && Params.QueryCoordCfg.AutoHandoff { validHandoffReq, collectionInfo := ic.verifyHandoffReqValid(segmentInfo)
indexInfo, err := getIndexInfo(ic.ctx, segmentInfo, ic.rootCoord, ic.indexCoord) if validHandoffReq && Params.QueryCoordCfg.AutoHandoff {
indexInfo, err := getIndexInfo(ic.ctx, segmentInfo, collectionInfo.Schema, ic.rootCoord, ic.indexCoord)
if err != nil { if err != nil {
continue continue
} }
if indexInfo.enableIndex {
segmentInfo.EnableIndex = true segmentInfo.IndexInfos = indexInfo
}
segmentInfo.IndexPathInfos = indexInfo.infos
ic.enqueueIndexedSegment(segmentInfo) ic.enqueueIndexedSegment(segmentInfo)
break break
} }
@ -278,13 +270,18 @@ func (ic *IndexChecker) processHandoffAfterIndexDone() {
} }
} }
func getIndexInfo(ctx context.Context, info *querypb.SegmentInfo, root types.RootCoord, index types.IndexCoord) (*indexInfo, error) { func getIndexInfo(ctx context.Context, info *querypb.SegmentInfo, schema *schemapb.CollectionSchema, root types.RootCoord, index types.IndexCoord) ([]*querypb.VecFieldIndexInfo, error) {
indexInfo := &indexInfo{ // TODO:: collection has multi vec field, and build index for every vec field, get indexInfo by fieldID
segmentID: info.SegmentID, // Currently, each collection can only have one vector field
partitionID: info.PartitionID, vecFieldIDs := getVecFieldIDs(schema)
collectionID: info.CollectionID, if len(vecFieldIDs) != 1 {
err := fmt.Errorf("collection %d has multi vec field, num of vec fields = %d", info.CollectionID, len(vecFieldIDs))
log.Error("get index info failed", zap.Int64("collectionID", info.CollectionID), zap.Int64("segmentID", info.SegmentID), zap.Error(err))
return nil, err
}
indexInfo := &querypb.VecFieldIndexInfo{
FieldID: vecFieldIDs[0],
} }
// check the buildID of the segment's index whether exist on rootCoord // check the buildID of the segment's index whether exist on rootCoord
req := &milvuspb.DescribeSegmentRequest{ req := &milvuspb.DescribeSegmentRequest{
Base: &commonpb.MsgBase{ Base: &commonpb.MsgBase{
@ -305,10 +302,10 @@ func getIndexInfo(ctx context.Context, info *querypb.SegmentInfo, root types.Roo
// if the segment.EnableIndex == false, then load the segment immediately // if the segment.EnableIndex == false, then load the segment immediately
if !response.EnableIndex { if !response.EnableIndex {
indexInfo.enableIndex = false indexInfo.EnableIndex = false
return indexInfo, nil } else {
} indexInfo.BuildID = response.BuildID
indexInfo.EnableIndex = true
// if index created done on indexNode, then handoff start // if index created done on indexNode, then handoff start
indexFilePathRequest := &indexpb.GetIndexFilePathsRequest{ indexFilePathRequest := &indexpb.GetIndexFilePathsRequest{
IndexBuildIDs: []UniqueID{response.BuildID}, IndexBuildIDs: []UniqueID{response.BuildID},
@ -324,17 +321,17 @@ func getIndexInfo(ctx context.Context, info *querypb.SegmentInfo, root types.Roo
return nil, errors.New(pathResponse.Status.Reason) return nil, errors.New(pathResponse.Status.Reason)
} }
if len(pathResponse.FilePaths) <= 0 { if len(pathResponse.FilePaths) != 1 {
return nil, errors.New("illegal index file paths") return nil, errors.New("illegal index file paths, there should be only one vector column")
} }
for _, fieldPath := range pathResponse.FilePaths {
if len(fieldPath.IndexFilePaths) == 0 { fieldPathInfo := pathResponse.FilePaths[0]
if len(fieldPathInfo.IndexFilePaths) == 0 {
return nil, errors.New("empty index paths") return nil, errors.New("empty index paths")
} }
}
indexInfo.enableIndex = true indexInfo.IndexFilePaths = fieldPathInfo.IndexFilePaths
indexInfo.infos = pathResponse.FilePaths indexInfo.IndexSize = int64(fieldPathInfo.SerializedSize)
}
return indexInfo, nil return []*querypb.VecFieldIndexInfo{indexInfo}, nil
} }

5
internal/querycoord/mock_3rd_component_test.go
View File

@ -49,13 +49,14 @@ const (
defaultQueryNodeID = int64(100) defaultQueryNodeID = int64(100)
defaultChannelNum = 2 defaultChannelNum = 2
defaultNumRowPerSegment = 1000 defaultNumRowPerSegment = 1000
defaultVecFieldID = 101
) )
func genCollectionSchema(collectionID UniqueID, isBinary bool) *schemapb.CollectionSchema { func genCollectionSchema(collectionID UniqueID, isBinary bool) *schemapb.CollectionSchema {
var fieldVec schemapb.FieldSchema var fieldVec schemapb.FieldSchema
if isBinary { if isBinary {
fieldVec = schemapb.FieldSchema{ fieldVec = schemapb.FieldSchema{
FieldID: UniqueID(101), FieldID: UniqueID(defaultVecFieldID),
Name: "vec", Name: "vec",
IsPrimaryKey: false, IsPrimaryKey: false,
DataType: schemapb.DataType_BinaryVector, DataType: schemapb.DataType_BinaryVector,
@ -74,7 +75,7 @@ func genCollectionSchema(collectionID UniqueID, isBinary bool) *schemapb.Collect
} }
} else { } else {
fieldVec = schemapb.FieldSchema{ fieldVec = schemapb.FieldSchema{
FieldID: UniqueID(101), FieldID: UniqueID(defaultVecFieldID),
Name: "vec", Name: "vec",
IsPrimaryKey: false, IsPrimaryKey: false,
DataType: schemapb.DataType_FloatVector, DataType: schemapb.DataType_FloatVector,

3
internal/querycoord/query_coord.go
View File

@ -423,7 +423,8 @@ func (qc *QueryCoord) watchHandoffSegmentLoop() {
} }
switch event.Type { switch event.Type {
case mvccpb.PUT: case mvccpb.PUT:
if Params.QueryCoordCfg.AutoHandoff && qc.indexChecker.verifyHandoffReqValid(segmentInfo) { validHandoffReq, _ := qc.indexChecker.verifyHandoffReqValid(segmentInfo)
if Params.QueryCoordCfg.AutoHandoff && validHandoffReq {
qc.indexChecker.enqueueHandoffReq(segmentInfo) qc.indexChecker.enqueueHandoffReq(segmentInfo)
log.Debug("watchHandoffSegmentLoop: enqueue a handoff request to index checker", zap.Any("segment info", segmentInfo)) log.Debug("watchHandoffSegmentLoop: enqueue a handoff request to index checker", zap.Any("segment info", segmentInfo))
} else { } else {

31
internal/querycoord/task.go
View File

@ -374,11 +374,10 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{ indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{
CollectionID: collectionID, CollectionID: collectionID,
SegmentID: segmentID, SegmentID: segmentID,
}, lct.rootCoord, lct.indexCoord) }, lct.Schema, lct.rootCoord, lct.indexCoord)
if err == nil && indexInfo.enableIndex { if err == nil {
segmentLoadInfo.EnableIndex = true segmentLoadInfo.IndexInfos = indexInfo
segmentLoadInfo.IndexPathInfos = indexInfo.infos
} }
msgBase := proto.Clone(lct.Base).(*commonpb.MsgBase) msgBase := proto.Clone(lct.Base).(*commonpb.MsgBase)
@ -726,11 +725,10 @@ func (lpt *loadPartitionTask) execute(ctx context.Context) error {
indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{ indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{
CollectionID: collectionID, CollectionID: collectionID,
SegmentID: segmentID, SegmentID: segmentID,
}, lpt.rootCoord, lpt.indexCoord) }, lpt.Schema, lpt.rootCoord, lpt.indexCoord)
if err == nil && indexInfo.enableIndex { if err == nil {
segmentLoadInfo.EnableIndex = true segmentLoadInfo.IndexInfos = indexInfo
segmentLoadInfo.IndexPathInfos = indexInfo.infos
} }
msgBase := proto.Clone(lpt.Base).(*commonpb.MsgBase) msgBase := proto.Clone(lpt.Base).(*commonpb.MsgBase)
@ -1501,8 +1499,7 @@ func (ht *handoffTask) execute(ctx context.Context) error {
BinlogPaths: segmentBinlogs.FieldBinlogs, BinlogPaths: segmentBinlogs.FieldBinlogs,
NumOfRows: segmentBinlogs.NumOfRows, NumOfRows: segmentBinlogs.NumOfRows,
CompactionFrom: segmentInfo.CompactionFrom, CompactionFrom: segmentInfo.CompactionFrom,
EnableIndex: segmentInfo.EnableIndex, IndexInfos: segmentInfo.IndexInfos,
IndexPathInfos: segmentInfo.IndexPathInfos,
} }
msgBase := proto.Clone(ht.Base).(*commonpb.MsgBase) msgBase := proto.Clone(ht.Base).(*commonpb.MsgBase)
@ -1697,11 +1694,10 @@ func (lbt *loadBalanceTask) execute(ctx context.Context) error {
indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{ indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{
CollectionID: collectionID, CollectionID: collectionID,
SegmentID: segmentID, SegmentID: segmentID,
}, lbt.rootCoord, lbt.indexCoord) }, collectionInfo.Schema, lbt.rootCoord, lbt.indexCoord)
if err == nil && indexInfo.enableIndex { if err == nil {
segmentLoadInfo.EnableIndex = true segmentLoadInfo.IndexInfos = indexInfo
segmentLoadInfo.IndexPathInfos = indexInfo.infos
} }
msgBase := proto.Clone(lbt.Base).(*commonpb.MsgBase) msgBase := proto.Clone(lbt.Base).(*commonpb.MsgBase)
@ -1869,11 +1865,10 @@ func (lbt *loadBalanceTask) execute(ctx context.Context) error {
indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{ indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{
CollectionID: collectionID, CollectionID: collectionID,
SegmentID: segmentID, SegmentID: segmentID,
}, lbt.rootCoord, lbt.indexCoord) }, collectionInfo.Schema, lbt.rootCoord, lbt.indexCoord)
if err == nil && indexInfo.enableIndex { if err == nil {
segmentLoadInfo.EnableIndex = true segmentLoadInfo.IndexInfos = indexInfo
segmentLoadInfo.IndexPathInfos = indexInfo.infos
} }
msgBase := proto.Clone(lbt.Base).(*commonpb.MsgBase) msgBase := proto.Clone(lbt.Base).(*commonpb.MsgBase)

13
internal/querycoord/util.go
View File

@ -16,6 +16,8 @@
package querycoord package querycoord
import "github.com/milvus-io/milvus/internal/proto/schemapb"
func getCompareMapFromSlice(sliceData []int64) map[int64]struct{} { func getCompareMapFromSlice(sliceData []int64) map[int64]struct{} {
compareMap := make(map[int64]struct{}) compareMap := make(map[int64]struct{})
for _, data := range sliceData { for _, data := range sliceData {
@ -24,3 +26,14 @@ func getCompareMapFromSlice(sliceData []int64) map[int64]struct{} {
return compareMap return compareMap
} }
func getVecFieldIDs(schema *schemapb.CollectionSchema) []int64 {
var vecFieldIDs []int64
for _, field := range schema.Fields {
if field.DataType == schemapb.DataType_BinaryVector || field.DataType == schemapb.DataType_FloatVector {
vecFieldIDs = append(vecFieldIDs, field.FieldID)
}
}
return vecFieldIDs
}