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

Fix dynamic partitions loading (#24112) 

Signed-off-by: bigsheeper <yihao.dai@zilliz.com>
pull/24208/head
yihao.dai 2023-05-18 09:17:23 +08:00 committed by GitHub
parent 7da5a31bad
commit 1a3dca9b5e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 682 additions and 533 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
internal/proto/query_coord.proto
View File

@ -146,6 +146,7 @@ message LoadPartitionsRequest {
bool refresh = 8;
// resource group names
repeated string resource_groups = 9;
repeated index.IndexInfo index_info_list = 10;
}
message ReleasePartitionsRequest {
@ -199,7 +200,6 @@ message SyncNewCreatedPartitionRequest {
common.MsgBase base = 1;
int64 collectionID = 2;
int64 partitionID = 3;
schema.CollectionSchema schema = 4;
}
//-----------------query node grpc request and response proto----------------
@ -215,16 +215,15 @@ message WatchDmChannelsRequest {
int64 collectionID = 3;
repeated int64 partitionIDs = 4;
repeated data.VchannelInfo infos = 5;
schema.CollectionSchema schema = 6;
schema.CollectionSchema schema = 6; // keep it for compatibility of rolling upgrade from 2.2.x to 2.3
repeated data.SegmentInfo exclude_infos = 7;
LoadMetaInfo load_meta = 8;
LoadMetaInfo load_meta = 8; // keep it for compatibility of rolling upgrade from 2.2.x to 2.3
int64 replicaID = 9;
map<int64, data.SegmentInfo> segment_infos = 10;
// Deprecated
// for node down load balance, need to remove offline node in time after every watchDmChannel finish.
int64 offlineNodeID = 11;
int64 version = 12;
repeated index.IndexInfo index_info_list = 13;
}
message UnsubDmChannelRequest {
@ -275,10 +274,10 @@ message LoadSegmentsRequest {
common.MsgBase base = 1;
int64 dst_nodeID = 2;
repeated SegmentLoadInfo infos = 3;
schema.CollectionSchema schema = 4;
schema.CollectionSchema schema = 4; // keep it for compatibility of rolling upgrade from 2.2.x to 2.3
int64 source_nodeID = 5;
int64 collectionID = 6;
LoadMetaInfo load_meta = 7;
LoadMetaInfo load_meta = 7; // keep it for compatibility of rolling upgrade from 2.2.x to 2.3
int64 replicaID = 8;
repeated msg.MsgPosition delta_positions = 9; // keep it for compatibility of rolling upgrade from 2.2.x to 2.3
int64 version = 10;

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

@ -741,10 +741,11 @@ type LoadPartitionsRequest struct {
FieldIndexID map[int64]int64 `protobuf:"bytes,7,rep,name=field_indexID,json=fieldIndexID,proto3" json:"field_indexID,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
Refresh bool `protobuf:"varint,8,opt,name=refresh,proto3" json:"refresh,omitempty"`
// resource group names
ResourceGroups []string `protobuf:"bytes,9,rep,name=resource_groups,json=resourceGroups,proto3" json:"resource_groups,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
ResourceGroups []string `protobuf:"bytes,9,rep,name=resource_groups,json=resourceGroups,proto3" json:"resource_groups,omitempty"`
IndexInfoList []*indexpb.IndexInfo `protobuf:"bytes,10,rep,name=index_info_list,json=indexInfoList,proto3" json:"index_info_list,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *LoadPartitionsRequest) Reset() { *m = LoadPartitionsRequest{} }
@ -835,6 +836,13 @@ func (m *LoadPartitionsRequest) GetResourceGroups() []string {
return nil
}
func (m *LoadPartitionsRequest) GetIndexInfoList() []*indexpb.IndexInfo {
if m != nil {
return m.IndexInfoList
}
return nil
}
type ReleasePartitionsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
DbID int64 `protobuf:"varint,2,opt,name=dbID,proto3" json:"dbID,omitempty"`
@ -1268,13 +1276,12 @@ func (m *ShardLeadersList) GetNodeAddrs() []string {
}
type SyncNewCreatedPartitionRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
PartitionID int64 `protobuf:"varint,3,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
Schema *schemapb.CollectionSchema `protobuf:"bytes,4,opt,name=schema,proto3" json:"schema,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
PartitionID int64 `protobuf:"varint,3,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SyncNewCreatedPartitionRequest) Reset() { *m = SyncNewCreatedPartitionRequest{} }
@ -1323,13 +1330,6 @@ func (m *SyncNewCreatedPartitionRequest) GetPartitionID() int64 {
return 0
}
func (m *SyncNewCreatedPartitionRequest) GetSchema() *schemapb.CollectionSchema {
if m != nil {
return m.Schema
}
return nil
}
//-----------------query node grpc request and response proto----------------
type LoadMetaInfo struct {
LoadType LoadType `protobuf:"varint,1,opt,name=load_type,json=loadType,proto3,enum=milvus.proto.query.LoadType" json:"load_type,omitempty"`
@ -1399,12 +1399,11 @@ type WatchDmChannelsRequest struct {
SegmentInfos map[int64]*datapb.SegmentInfo `protobuf:"bytes,10,rep,name=segment_infos,json=segmentInfos,proto3" json:"segment_infos,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Deprecated
// for node down load balance, need to remove offline node in time after every watchDmChannel finish.
OfflineNodeID int64 `protobuf:"varint,11,opt,name=offlineNodeID,proto3" json:"offlineNodeID,omitempty"`
Version int64 `protobuf:"varint,12,opt,name=version,proto3" json:"version,omitempty"`
IndexInfoList []*indexpb.IndexInfo `protobuf:"bytes,13,rep,name=index_info_list,json=indexInfoList,proto3" json:"index_info_list,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
OfflineNodeID int64 `protobuf:"varint,11,opt,name=offlineNodeID,proto3" json:"offlineNodeID,omitempty"`
Version int64 `protobuf:"varint,12,opt,name=version,proto3" json:"version,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WatchDmChannelsRequest) Reset() { *m = WatchDmChannelsRequest{} }
@ -1516,13 +1515,6 @@ func (m *WatchDmChannelsRequest) GetVersion() int64 {
return 0
}
func (m *WatchDmChannelsRequest) GetIndexInfoList() []*indexpb.IndexInfo {
if m != nil {
return m.IndexInfoList
}
return nil
}
type UnsubDmChannelRequest 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"`
@ -4495,295 +4487,295 @@ func init() {
func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
var fileDescriptor_aab7cc9a69ed26e8 = []byte{
// 4597 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3c, 0x4b, 0x6f, 0x24, 0xc7,
0x79, 0xdb, 0xf3, 0xe2, 0xcc, 0x37, 0x4f, 0x16, 0xc9, 0xdd, 0xf1, 0x78, 0x77, 0x45, 0xf5, 0xea,
0x41, 0x53, 0x12, 0x29, 0x73, 0x6d, 0x59, 0xb6, 0x64, 0x28, 0xbb, 0xa4, 0x76, 0x45, 0x4b, 0xa2,
0x98, 0xe6, 0xae, 0x1c, 0x08, 0xb2, 0xc7, 0xcd, 0xe9, 0xe2, 0xb0, 0xb1, 0xfd, 0x98, 0xed, 0xea,
0x21, 0x45, 0x05, 0xc8, 0x29, 0x97, 0x18, 0x71, 0x90, 0x9c, 0x72, 0x09, 0x72, 0x48, 0x10, 0xc0,
0x09, 0x92, 0x5b, 0x72, 0xcb, 0x21, 0xb7, 0x04, 0x09, 0xf2, 0xb8, 0x04, 0xfe, 0x03, 0xc9, 0x21,
0x40, 0x82, 0x20, 0x07, 0x23, 0xd0, 0x2d, 0xa8, 0x47, 0x3f, 0xaa, 0xbb, 0x86, 0x33, 0xe4, 0xec,
0x5a, 0x52, 0xe0, 0xdb, 0x74, 0xbd, 0xbe, 0xaf, 0xbe, 0xf7, 0xf7, 0x55, 0xd5, 0xc0, 0xe2, 0xe3,
0x31, 0x0e, 0xce, 0xfa, 0x03, 0xdf, 0x0f, 0xac, 0x8d, 0x51, 0xe0, 0x87, 0x3e, 0x42, 0xae, 0xed,
0x9c, 0x8c, 0x09, 0xff, 0xda, 0x60, 0xfd, 0xbd, 0xc6, 0xc0, 0x77, 0x5d, 0xdf, 0xe3, 0x6d, 0xbd,
0x46, 0x7a, 0x44, 0xaf, 0x65, 0x7b, 0x21, 0x0e, 0x3c, 0xd3, 0x89, 0x7a, 0xc9, 0xe0, 0x18, 0xbb,
0xa6, 0xf8, 0xaa, 0xb9, 0x64, 0x28, 0x7e, 0x76, 0x2c, 0x33, 0x34, 0xd3, 0xa0, 0x7a, 0x8b, 0xb6,
0x67, 0xe1, 0x4f, 0xd2, 0x4d, 0xfa, 0x6f, 0x6a, 0x70, 0xf5, 0xe0, 0xd8, 0x3f, 0xdd, 0xf6, 0x1d,
0x07, 0x0f, 0x42, 0xdb, 0xf7, 0x88, 0x81, 0x1f, 0x8f, 0x31, 0x09, 0xd1, 0xab, 0x50, 0x3a, 0x34,
0x09, 0xee, 0x6a, 0xab, 0xda, 0x5a, 0x7d, 0xeb, 0xfa, 0x86, 0x84, 0xa7, 0x40, 0xf0, 0x7d, 0x32,
0xbc, 0x6b, 0x12, 0x6c, 0xb0, 0x91, 0x08, 0x41, 0xc9, 0x3a, 0xdc, 0xdd, 0xe9, 0x16, 0x56, 0xb5,
0xb5, 0xa2, 0xc1, 0x7e, 0xa3, 0xe7, 0xa0, 0x39, 0x88, 0xd7, 0xde, 0xdd, 0x21, 0xdd, 0xe2, 0x6a,
0x71, 0xad, 0x68, 0xc8, 0x8d, 0xfa, 0x8f, 0x0b, 0x70, 0x2d, 0x87, 0x06, 0x19, 0xf9, 0x1e, 0xc1,
0xe8, 0x36, 0x54, 0x48, 0x68, 0x86, 0x63, 0x22, 0x30, 0xf9, 0xaa, 0x12, 0x93, 0x03, 0x36, 0xc4,
0x10, 0x43, 0xf3, 0x60, 0x0b, 0x0a, 0xb0, 0xe8, 0xeb, 0xb0, 0x6c, 0x7b, 0xef, 0x63, 0xd7, 0x0f,
0xce, 0xfa, 0x23, 0x1c, 0x0c, 0xb0, 0x17, 0x9a, 0x43, 0x1c, 0xe1, 0xb8, 0x14, 0xf5, 0xed, 0x27,
0x5d, 0xe8, 0x35, 0xb8, 0xc6, 0x79, 0x48, 0x70, 0x70, 0x62, 0x0f, 0x70, 0xdf, 0x3c, 0x31, 0x6d,
0xc7, 0x3c, 0x74, 0x70, 0xb7, 0xb4, 0x5a, 0x5c, 0xab, 0x1a, 0x2b, 0xac, 0xfb, 0x80, 0xf7, 0xde,
0x89, 0x3a, 0xd1, 0xd7, 0xa0, 0x13, 0xe0, 0xa3, 0x00, 0x93, 0xe3, 0xfe, 0x28, 0xf0, 0x87, 0x01,
0x26, 0xa4, 0x5b, 0x66, 0x60, 0xda, 0xa2, 0x7d, 0x5f, 0x34, 0xeb, 0x7f, 0xa2, 0xc1, 0x0a, 0x25,
0xc6, 0xbe, 0x19, 0x84, 0xf6, 0x53, 0x60, 0x89, 0x0e, 0x8d, 0x34, 0x19, 0xba, 0x45, 0xd6, 0x27,
0xb5, 0xd1, 0x31, 0xa3, 0x08, 0x3c, 0x25, 0x5f, 0x89, 0xa1, 0x2a, 0xb5, 0xe9, 0xff, 0x2c, 0x64,
0x27, 0x8d, 0xe7, 0x3c, 0x3c, 0xcb, 0xc2, 0x2c, 0xe4, 0x61, 0x5e, 0x86, 0x63, 0x2a, 0xca, 0x97,
0xd4, 0x94, 0xff, 0xc7, 0x22, 0xac, 0xbc, 0xe7, 0x9b, 0x56, 0x22, 0x86, 0xbf, 0x78, 0xca, 0x7f,
0x17, 0x2a, 0x5c, 0xa3, 0xbb, 0x25, 0x06, 0xeb, 0x79, 0x19, 0x96, 0xd0, 0xf6, 0x04, 0xc3, 0x03,
0xd6, 0x60, 0x88, 0x49, 0xe8, 0x79, 0x68, 0x05, 0x78, 0xe4, 0xd8, 0x03, 0xb3, 0xef, 0x8d, 0xdd,
0x43, 0x1c, 0x74, 0xcb, 0xab, 0xda, 0x5a, 0xd9, 0x68, 0x8a, 0xd6, 0x3d, 0xd6, 0x88, 0x7e, 0x04,
0xcd, 0x23, 0x1b, 0x3b, 0x56, 0x9f, 0x99, 0x84, 0xdd, 0x9d, 0x6e, 0x65, 0xb5, 0xb8, 0x56, 0xdf,
0x7a, 0x63, 0x23, 0x6f, 0x8d, 0x36, 0x94, 0x14, 0xd9, 0xb8, 0x47, 0xa7, 0xef, 0xf2, 0xd9, 0x6f,
0x7b, 0x61, 0x70, 0x66, 0x34, 0x8e, 0x52, 0x4d, 0xa8, 0x0b, 0x0b, 0x82, 0xbc, 0xdd, 0x85, 0x55,
0x6d, 0xad, 0x6a, 0x44, 0x9f, 0xe8, 0x45, 0x68, 0x07, 0x98, 0xf8, 0xe3, 0x60, 0x80, 0xfb, 0xc3,
0xc0, 0x1f, 0x8f, 0x48, 0xb7, 0xba, 0x5a, 0x5c, 0xab, 0x19, 0xad, 0xa8, 0xf9, 0x3e, 0x6b, 0xed,
0xbd, 0x05, 0x8b, 0x39, 0x28, 0xa8, 0x03, 0xc5, 0x47, 0xf8, 0x8c, 0x31, 0xa2, 0x68, 0xd0, 0x9f,
0x68, 0x19, 0xca, 0x27, 0xa6, 0x33, 0xc6, 0x82, 0xd4, 0xfc, 0xe3, 0x3b, 0x85, 0xd7, 0x35, 0xfd,
0x0f, 0x34, 0xe8, 0x1a, 0xd8, 0xc1, 0x26, 0xc1, 0x9f, 0x27, 0x4b, 0xaf, 0x42, 0xc5, 0xf3, 0x2d,
0xbc, 0xbb, 0xc3, 0x58, 0x5a, 0x34, 0xc4, 0x97, 0xfe, 0x99, 0x06, 0xcb, 0xf7, 0x71, 0x48, 0xd5,
0xc0, 0x26, 0xa1, 0x3d, 0x88, 0xf5, 0xfc, 0xbb, 0x50, 0x0c, 0xf0, 0x63, 0x81, 0xd9, 0x4b, 0x32,
0x66, 0xb1, 0xf9, 0x57, 0xcd, 0x34, 0xe8, 0x3c, 0xf4, 0x2c, 0x34, 0x2c, 0xd7, 0xe9, 0x0f, 0x8e,
0x4d, 0xcf, 0xc3, 0x0e, 0x57, 0xa4, 0x9a, 0x51, 0xb7, 0x5c, 0x67, 0x5b, 0x34, 0xa1, 0x9b, 0x00,
0x04, 0x0f, 0x5d, 0xec, 0x85, 0x89, 0x4d, 0x4e, 0xb5, 0xa0, 0x75, 0x58, 0x3c, 0x0a, 0x7c, 0xb7,
0x4f, 0x8e, 0xcd, 0xc0, 0xea, 0x3b, 0xd8, 0xb4, 0x70, 0xc0, 0xb0, 0xaf, 0x1a, 0x6d, 0xda, 0x71,
0x40, 0xdb, 0xdf, 0x63, 0xcd, 0xe8, 0x36, 0x94, 0xc9, 0xc0, 0x1f, 0x61, 0x26, 0x69, 0xad, 0xad,
0x1b, 0x2a, 0x19, 0xda, 0x31, 0x43, 0xf3, 0x80, 0x0e, 0x32, 0xf8, 0x58, 0xfd, 0x7f, 0x84, 0xaa,
0x7d, 0xc1, 0x8d, 0x5c, 0x4a, 0x1d, 0xcb, 0x4f, 0x46, 0x1d, 0x2b, 0x33, 0xa9, 0xe3, 0xc2, 0xf9,
0xea, 0x98, 0xa3, 0xda, 0x45, 0xd4, 0xb1, 0x3a, 0x55, 0x1d, 0x6b, 0x4f, 0x47, 0x1d, 0xff, 0x26,
0x51, 0xc7, 0x2f, 0x3a, 0xdb, 0x13, 0x95, 0x2d, 0x4b, 0x2a, 0xfb, 0xa7, 0x1a, 0x7c, 0xe5, 0x3e,
0x0e, 0x63, 0xf4, 0xa9, 0x06, 0xe2, 0x2f, 0xa8, 0x7f, 0xfe, 0x0b, 0x0d, 0x7a, 0x2a, 0x5c, 0xe7,
0xf1, 0xd1, 0x1f, 0xc1, 0xd5, 0x18, 0x46, 0xdf, 0xc2, 0x64, 0x10, 0xd8, 0x23, 0xc6, 0x46, 0x66,
0x64, 0xea, 0x5b, 0xb7, 0x54, 0x12, 0x9b, 0xc5, 0x60, 0x25, 0x5e, 0x62, 0x27, 0xb5, 0x82, 0xfe,
0x13, 0x0d, 0x56, 0xa8, 0x51, 0x13, 0x56, 0xc8, 0x3b, 0xf2, 0x2f, 0x4f, 0x57, 0xd9, 0xbe, 0x15,
0x72, 0xf6, 0x6d, 0x06, 0x1a, 0xb3, 0xd8, 0x38, 0x8b, 0xcf, 0x3c, 0xb4, 0xfb, 0x26, 0x94, 0x6d,
0xef, 0xc8, 0x8f, 0x48, 0xf5, 0x8c, 0x8a, 0x54, 0x69, 0x60, 0x7c, 0xb4, 0xee, 0x71, 0x2c, 0x12,
0x83, 0x3b, 0x87, 0xb8, 0x65, 0xb7, 0x5d, 0x50, 0x6c, 0xfb, 0xb7, 0x35, 0xb8, 0x96, 0x03, 0x38,
0xcf, 0xbe, 0xdf, 0x84, 0x0a, 0x73, 0x23, 0xd1, 0xc6, 0x9f, 0x53, 0x6e, 0x3c, 0x05, 0xee, 0x3d,
0x9b, 0x84, 0x86, 0x98, 0xa3, 0xfb, 0xd0, 0xc9, 0xf6, 0x51, 0x07, 0x27, 0x9c, 0x5b, 0xdf, 0x33,
0x5d, 0x4e, 0x80, 0x9a, 0x51, 0x17, 0x6d, 0x7b, 0xa6, 0x8b, 0xd1, 0x57, 0xa0, 0x4a, 0x55, 0xb6,
0x6f, 0x5b, 0x11, 0xfb, 0x17, 0x98, 0x0a, 0x5b, 0x04, 0xdd, 0x00, 0x60, 0x5d, 0xa6, 0x65, 0x05,
0xdc, 0xf7, 0xd5, 0x8c, 0x1a, 0x6d, 0xb9, 0x43, 0x1b, 0xf4, 0x9f, 0x69, 0x70, 0xf3, 0xe0, 0xcc,
0x1b, 0xec, 0xe1, 0xd3, 0xed, 0x00, 0x9b, 0x21, 0x4e, 0xac, 0xed, 0x53, 0x25, 0x3c, 0x5a, 0x85,
0x7a, 0x4a, 0x7f, 0x85, 0x48, 0xa6, 0x9b, 0xe6, 0x8c, 0x0d, 0xf5, 0xdf, 0xd3, 0xa0, 0x41, 0xbd,
0xc7, 0xfb, 0x38, 0x34, 0xa9, 0x84, 0xa1, 0x6f, 0x43, 0xcd, 0xf1, 0x4d, 0xab, 0x1f, 0x9e, 0x8d,
0xf8, 0x66, 0x5a, 0xd9, 0xcd, 0x24, 0x2e, 0xe7, 0xc1, 0xd9, 0x08, 0x1b, 0x55, 0x47, 0xfc, 0x9a,
0x69, 0x43, 0x59, 0x23, 0x55, 0x54, 0x18, 0xa9, 0x9f, 0x54, 0xe0, 0xea, 0xf7, 0xcd, 0x70, 0x70,
0xbc, 0xe3, 0x46, 0xc1, 0xc9, 0xe5, 0xa9, 0x9c, 0x58, 0xed, 0x42, 0xda, 0x6a, 0x3f, 0x31, 0xaf,
0x10, 0x6b, 0x70, 0x59, 0xa5, 0xc1, 0x34, 0xdf, 0xde, 0xf8, 0x50, 0x08, 0x61, 0x4a, 0x83, 0x53,
0x6c, 0xab, 0x5c, 0x26, 0x86, 0xd8, 0x86, 0x26, 0xfe, 0x64, 0xe0, 0x8c, 0xa9, 0x34, 0x33, 0xe8,
0x3c, 0x38, 0xb8, 0xa9, 0x80, 0x9e, 0x36, 0x1f, 0x0d, 0x31, 0x69, 0x57, 0xe0, 0xc0, 0x59, 0xed,
0xe2, 0xd0, 0x64, 0x11, 0x40, 0x7d, 0x6b, 0x75, 0x12, 0xab, 0x23, 0xf9, 0xe0, 0xec, 0xa6, 0x5f,
0xe8, 0x3a, 0xd4, 0x44, 0xc4, 0xb2, 0xbb, 0xd3, 0xad, 0x31, 0xf2, 0x25, 0x0d, 0xc8, 0x84, 0xa6,
0xb0, 0xad, 0x02, 0x43, 0x60, 0x18, 0xbe, 0xa9, 0x02, 0xa0, 0x66, 0x76, 0x1a, 0x73, 0x22, 0xe2,
0x17, 0x92, 0x6a, 0xa2, 0x09, 0xbd, 0x7f, 0x74, 0xe4, 0xd8, 0x1e, 0xde, 0xe3, 0x1c, 0xae, 0x33,
0x24, 0xe4, 0x46, 0x1a, 0xe5, 0x9c, 0xe0, 0x80, 0xd8, 0xbe, 0xd7, 0x6d, 0xb0, 0xfe, 0xe8, 0x13,
0xbd, 0x0d, 0x6d, 0x5e, 0xfd, 0xa0, 0x08, 0xf6, 0x1d, 0x9b, 0x84, 0xdd, 0x26, 0x43, 0xf2, 0x46,
0x36, 0xbc, 0xb6, 0xf0, 0x27, 0x1b, 0x3c, 0xc4, 0xa1, 0x24, 0x68, 0xda, 0xd1, 0x4f, 0x6a, 0x79,
0x7a, 0x7d, 0x58, 0xcc, 0x61, 0xaa, 0x88, 0x81, 0xbe, 0x91, 0x8e, 0x81, 0xa6, 0xb3, 0x2a, 0x15,
0x23, 0xfd, 0x54, 0x83, 0x95, 0x87, 0x1e, 0x19, 0x1f, 0xc6, 0x24, 0xfa, 0x7c, 0xd4, 0x21, 0x6b,
0x62, 0x4b, 0x39, 0x13, 0xab, 0xff, 0x7d, 0x19, 0xda, 0x62, 0x17, 0x54, 0x6a, 0x98, 0x45, 0xb9,
0x0e, 0xb5, 0xd8, 0xcb, 0x0a, 0x82, 0x24, 0x0d, 0x59, 0x0b, 0x57, 0xc8, 0x5b, 0xb8, 0x59, 0x50,
0x8b, 0x62, 0xa6, 0x52, 0x2a, 0x66, 0xba, 0x01, 0x70, 0xe4, 0x8c, 0xc9, 0x71, 0x3f, 0xb4, 0x5d,
0x2c, 0x62, 0xb6, 0x1a, 0x6b, 0x79, 0x60, 0xbb, 0x18, 0xdd, 0x81, 0xc6, 0xa1, 0xed, 0x39, 0xfe,
0xb0, 0x3f, 0x32, 0xc3, 0x63, 0x22, 0xb2, 0x5d, 0x15, 0x5b, 0x58, 0x84, 0x7b, 0x97, 0x8d, 0x35,
0xea, 0x7c, 0xce, 0x3e, 0x9d, 0x82, 0x6e, 0x42, 0xdd, 0x1b, 0xbb, 0x7d, 0xff, 0xa8, 0x1f, 0xf8,
0xa7, 0x84, 0xe5, 0xb4, 0x45, 0xa3, 0xe6, 0x8d, 0xdd, 0x0f, 0x8e, 0x0c, 0xff, 0x94, 0x7a, 0xb9,
0x1a, 0xf5, 0x77, 0xc4, 0xf1, 0x87, 0x3c, 0x9f, 0x9d, 0xbe, 0x7e, 0x32, 0x81, 0xce, 0xb6, 0xb0,
0x13, 0x9a, 0x6c, 0x76, 0x6d, 0xb6, 0xd9, 0xf1, 0x04, 0xf4, 0x02, 0xb4, 0x06, 0xbe, 0x3b, 0x32,
0x19, 0x85, 0xee, 0x05, 0xbe, 0xcb, 0x14, 0xb0, 0x68, 0x64, 0x5a, 0xd1, 0x36, 0xd4, 0x13, 0x25,
0x20, 0xdd, 0x3a, 0x83, 0xa3, 0xab, 0xb4, 0x34, 0x15, 0xe8, 0x53, 0x01, 0x85, 0x58, 0x0b, 0x08,
0x95, 0x8c, 0x48, 0xd9, 0x89, 0xfd, 0x29, 0x16, 0x8a, 0x56, 0x17, 0x6d, 0x07, 0xf6, 0xa7, 0x98,
0x66, 0x3d, 0xb6, 0x47, 0x70, 0x10, 0x46, 0x39, 0x68, 0xb7, 0xc9, 0xc4, 0xa7, 0xc9, 0x5b, 0x85,
0x60, 0xa3, 0x1d, 0x68, 0x91, 0xd0, 0x0c, 0xc2, 0xfe, 0xc8, 0x27, 0x4c, 0x00, 0xba, 0x2d, 0x26,
0xdb, 0x19, 0x95, 0x74, 0xc9, 0x90, 0x0a, 0xf6, 0xbe, 0x18, 0x64, 0x34, 0xd9, 0xa4, 0xe8, 0x93,
0xae, 0xc2, 0x28, 0x91, 0xac, 0xd2, 0x9e, 0x69, 0x15, 0x36, 0x29, 0xfa, 0xd4, 0xff, 0xbb, 0x00,
0x2d, 0x79, 0xd3, 0xd4, 0x98, 0xf0, 0x14, 0x2a, 0x92, 0xe4, 0xe8, 0x93, 0x92, 0x00, 0x7b, 0xe6,
0xa1, 0x83, 0x79, 0xbe, 0xc6, 0x04, 0xb9, 0x6a, 0xd4, 0x79, 0x1b, 0x5b, 0x80, 0x0a, 0x24, 0x27,
0x35, 0xd3, 0x9e, 0x22, 0xdb, 0x7e, 0x8d, 0xb5, 0xb0, 0xf0, 0xa4, 0x0b, 0x0b, 0x51, 0xaa, 0xc7,
0xc5, 0x38, 0xfa, 0xa4, 0x3d, 0x87, 0x63, 0x9b, 0x41, 0xe5, 0x62, 0x1c, 0x7d, 0xa2, 0x1d, 0x68,
0xf0, 0x25, 0x47, 0x66, 0x60, 0xba, 0x91, 0x10, 0x3f, 0xab, 0x34, 0x04, 0xef, 0xe2, 0xb3, 0x0f,
0xa9, 0x4d, 0xd9, 0x37, 0xed, 0xc0, 0xe0, 0x4c, 0xdf, 0x67, 0xb3, 0xd0, 0x1a, 0x74, 0xf8, 0x2a,
0x47, 0xb6, 0x83, 0x85, 0x3a, 0x2c, 0xf0, 0x7c, 0x8f, 0xb5, 0xdf, 0xb3, 0x1d, 0xcc, 0x25, 0x3e,
0xde, 0x02, 0x63, 0x73, 0x95, 0x0b, 0x3c, 0x6b, 0x61, 0x4c, 0xbe, 0x05, 0xdc, 0x36, 0xf6, 0x23,
0x8b, 0xcb, 0xdd, 0x02, 0xc7, 0xf1, 0x43, 0x61, 0x76, 0x69, 0x18, 0x36, 0x76, 0xb9, 0xca, 0x00,
0xdf, 0x8e, 0x37, 0x76, 0xa9, 0xc2, 0xe8, 0xff, 0x50, 0x82, 0x25, 0x6a, 0x37, 0x84, 0x09, 0x99,
0xc3, 0xed, 0xdf, 0x00, 0xb0, 0x48, 0xd8, 0x97, 0x6c, 0x5d, 0xcd, 0x22, 0xa1, 0x70, 0x0a, 0xdf,
0x8e, 0xbc, 0x76, 0x71, 0x72, 0x8a, 0x92, 0xb1, 0x63, 0x79, 0xcf, 0x7d, 0xa9, 0x62, 0xdc, 0x2d,
0x68, 0x8a, 0xc4, 0x5a, 0x4a, 0x26, 0x1b, 0xbc, 0x71, 0x4f, 0x6d, 0x8d, 0x2b, 0xca, 0xa2, 0x60,
0xca, 0x7b, 0x2f, 0xcc, 0xe7, 0xbd, 0xab, 0x59, 0xef, 0x7d, 0x0f, 0xda, 0xb2, 0x02, 0x45, 0x16,
0x68, 0x8a, 0x06, 0xb5, 0x24, 0x0d, 0x22, 0x69, 0xe7, 0x0b, 0xb2, 0xf3, 0xbd, 0x05, 0x4d, 0x0f,
0x63, 0xab, 0x1f, 0x06, 0xa6, 0x47, 0x8e, 0x70, 0xc0, 0x9c, 0x77, 0xd5, 0x68, 0xd0, 0xc6, 0x07,
0xa2, 0x0d, 0xbd, 0x09, 0xc0, 0xf6, 0xc8, 0x6b, 0x49, 0x8d, 0xc9, 0xb5, 0x24, 0x26, 0x34, 0xac,
0x96, 0xc4, 0x88, 0xc2, 0x7e, 0xea, 0xff, 0x54, 0x80, 0xab, 0xa2, 0xb6, 0x30, 0xbf, 0x40, 0x4d,
0x72, 0x9c, 0x91, 0xe7, 0x29, 0x9e, 0x93, 0xad, 0x97, 0x66, 0x88, 0x2d, 0xcb, 0x8a, 0xd8, 0x52,
0xce, 0x58, 0x2b, 0xb9, 0x8c, 0x35, 0xae, 0xb2, 0x2d, 0xcc, 0x5e, 0x65, 0x43, 0xcb, 0x50, 0x66,
0x69, 0x14, 0x63, 0x7a, 0xcd, 0xe0, 0x1f, 0x33, 0xb1, 0x43, 0xff, 0xfd, 0x02, 0x34, 0x0f, 0xb0,
0x19, 0x0c, 0x8e, 0x23, 0x3a, 0xbe, 0x96, 0xae, 0x4a, 0x3e, 0x37, 0xa1, 0x2a, 0x29, 0x4d, 0xf9,
0xd2, 0x94, 0x23, 0x29, 0x80, 0xd0, 0x0f, 0xcd, 0x18, 0xcb, 0xbe, 0x37, 0x76, 0x45, 0xa9, 0xae,
0xcd, 0x3a, 0x04, 0xaa, 0x7b, 0x63, 0x57, 0xff, 0x4f, 0x0d, 0x1a, 0xbf, 0x4a, 0x97, 0x89, 0x08,
0xf3, 0x7a, 0x9a, 0x30, 0x2f, 0x4c, 0x20, 0x8c, 0x81, 0xc3, 0xc0, 0xc6, 0x27, 0xf8, 0x4b, 0x57,
0xa9, 0xfd, 0x5b, 0x0d, 0x7a, 0x34, 0x1f, 0x36, 0xb8, 0xc1, 0x98, 0x5f, 0xbb, 0x6e, 0x41, 0xf3,
0x44, 0x8a, 0x2d, 0x0b, 0x4c, 0x38, 0x1b, 0x27, 0xe9, 0xfc, 0xdd, 0x80, 0x4e, 0x54, 0x38, 0x15,
0x9b, 0x8d, 0xec, 0xf7, 0x8b, 0x2a, 0xac, 0x33, 0xc8, 0x31, 0xfb, 0xd7, 0x0e, 0xe4, 0x46, 0xfd,
0x77, 0x34, 0x58, 0x52, 0x0c, 0x44, 0xd7, 0x60, 0x41, 0xd4, 0x0a, 0x84, 0xa3, 0xe7, 0xfa, 0x6e,
0x51, 0xf6, 0x24, 0xd5, 0x2e, 0xdb, 0xca, 0x07, 0xac, 0x16, 0x7a, 0x06, 0xea, 0x71, 0xea, 0x63,
0xe5, 0xf8, 0x63, 0x11, 0xd4, 0x83, 0xaa, 0x30, 0x83, 0x51, 0x4e, 0x19, 0x7f, 0xeb, 0x8f, 0x00,
0xdd, 0xc7, 0x89, 0xd3, 0x99, 0x87, 0xa2, 0x89, 0xbd, 0x49, 0x10, 0x4d, 0x1b, 0x21, 0x4b, 0xff,
0x37, 0x0d, 0x96, 0x24, 0x68, 0xf3, 0xd4, 0x74, 0x12, 0xc7, 0x58, 0xb8, 0x8c, 0x63, 0x94, 0x0a,
0x0f, 0xc5, 0x0b, 0x15, 0x1e, 0x6e, 0x02, 0xc4, 0xf4, 0x8f, 0x28, 0x9a, 0x6a, 0xd1, 0xff, 0x5a,
0x83, 0xab, 0xef, 0x98, 0x9e, 0xe5, 0x1f, 0x1d, 0xcd, 0x2f, 0xaa, 0xdb, 0x20, 0x65, 0xa1, 0xb3,
0x56, 0xee, 0xe4, 0xd4, 0xf5, 0x25, 0x58, 0x0c, 0xb8, 0x67, 0xb2, 0x64, 0x59, 0x2e, 0x1a, 0x9d,
0xa8, 0x23, 0x96, 0xd1, 0x3f, 0x2f, 0x00, 0xa2, 0xbb, 0xbe, 0x6b, 0x3a, 0xa6, 0x37, 0xc0, 0x97,
0x47, 0xfd, 0x79, 0x68, 0x49, 0xb1, 0x47, 0x7c, 0x04, 0x9e, 0x0e, 0x3e, 0x08, 0x7a, 0x17, 0x5a,
0x87, 0x1c, 0x54, 0x3f, 0xc0, 0x26, 0xf1, 0x3d, 0xc1, 0x0e, 0x65, 0x91, 0xee, 0x41, 0x60, 0x0f,
0x87, 0x38, 0xd8, 0xf6, 0x3d, 0x4b, 0x04, 0xd1, 0x87, 0x11, 0x9a, 0x74, 0x2a, 0x55, 0x86, 0x24,
0x10, 0x8b, 0x99, 0x13, 0x47, 0x62, 0x8c, 0x14, 0x04, 0x9b, 0x4e, 0x42, 0x88, 0xc4, 0x1b, 0x76,
0x78, 0xc7, 0xc1, 0xe4, 0x1a, 0xad, 0x22, 0x30, 0xd2, 0xff, 0x52, 0x03, 0x14, 0x67, 0xca, 0xac,
0xb4, 0xc0, 0x34, 0x3a, 0x3b, 0x55, 0x53, 0x38, 0xe5, 0xeb, 0x50, 0xb3, 0xa2, 0x99, 0xc2, 0x04,
0x25, 0x0d, 0xcc, 0x47, 0x32, 0xa4, 0xfb, 0x54, 0xf2, 0xb0, 0x15, 0x65, 0xa2, 0xbc, 0xf1, 0x3d,
0xd6, 0x26, 0xc7, 0x55, 0xa5, 0x6c, 0x5c, 0x95, 0x2e, 0x41, 0x96, 0xa5, 0x12, 0xa4, 0xfe, 0xd3,
0x02, 0x74, 0x98, 0x0b, 0xd9, 0x4e, 0xaa, 0x45, 0x33, 0x21, 0x7d, 0x0b, 0x9a, 0xe2, 0x0a, 0x89,
0x84, 0x78, 0xe3, 0x71, 0x6a, 0x31, 0xf4, 0x2a, 0x2c, 0xf3, 0x41, 0x01, 0x26, 0x63, 0x27, 0x49,
0xc2, 0x78, 0x16, 0x82, 0x1e, 0x73, 0xdf, 0x45, 0xbb, 0xa2, 0x19, 0x0f, 0xe1, 0xea, 0xd0, 0xf1,
0x0f, 0x4d, 0xa7, 0x2f, 0xb3, 0x87, 0xf3, 0x70, 0x06, 0x89, 0x5f, 0xe6, 0xd3, 0x0f, 0xd2, 0x3c,
0x24, 0xe8, 0x2e, 0x34, 0x09, 0xc6, 0x8f, 0x92, 0xcc, 0xac, 0x3c, 0x4b, 0x66, 0xd6, 0xa0, 0x73,
0xe2, 0xc4, 0xec, 0x0f, 0x35, 0x68, 0x67, 0x0e, 0x10, 0xb2, 0x75, 0x04, 0x2d, 0x5f, 0x47, 0x78,
0x1d, 0xca, 0xd4, 0x52, 0x71, 0xdf, 0xd2, 0x52, 0xe7, 0xb8, 0xf2, 0xaa, 0x06, 0x9f, 0x80, 0x36,
0x61, 0x49, 0x71, 0xc3, 0x40, 0xb0, 0x1f, 0xe5, 0x2f, 0x18, 0xe8, 0x3f, 0x2f, 0x41, 0x3d, 0x45,
0x8a, 0x29, 0x25, 0x90, 0x27, 0x53, 0x08, 0x9e, 0x70, 0xa2, 0x4c, 0x45, 0xce, 0xc5, 0x2e, 0x4f,
0xd8, 0x44, 0xf6, 0xe8, 0x62, 0x97, 0xa5, 0x6b, 0xe9, 0x4c, 0xac, 0x22, 0x65, 0x62, 0x99, 0x5c,
0x75, 0xe1, 0x9c, 0x5c, 0xb5, 0x2a, 0xe7, 0xaa, 0x92, 0x0a, 0xd5, 0xb2, 0x2a, 0x34, 0x6b, 0x55,
0xe2, 0x55, 0x58, 0x1a, 0xf0, 0x42, 0xfb, 0xdd, 0xb3, 0xed, 0xb8, 0x4b, 0x04, 0xa5, 0xaa, 0x2e,
0x74, 0x2f, 0xa9, 0x37, 0x72, 0x2e, 0xf3, 0x6c, 0x41, 0x9d, 0x0a, 0x0b, 0xde, 0x70, 0x26, 0x47,
0x96, 0x99, 0x7d, 0x65, 0xeb, 0x21, 0xcd, 0x4b, 0xd5, 0x43, 0x9e, 0x81, 0x7a, 0x14, 0xa9, 0x50,
0x4d, 0x6f, 0x71, 0xa3, 0x17, 0x99, 0x01, 0x8b, 0x48, 0x76, 0xa0, 0x2d, 0x1f, 0x45, 0x64, 0x0b,
0x09, 0x9d, 0x7c, 0x21, 0xe1, 0x1a, 0x2c, 0xd8, 0xa4, 0x7f, 0x64, 0x3e, 0xc2, 0xdd, 0x45, 0xd6,
0x5b, 0xb1, 0xc9, 0x3d, 0xf3, 0x11, 0xd6, 0xff, 0xa5, 0x08, 0xad, 0xc4, 0xc1, 0xce, 0x6c, 0x41,
0x66, 0xb9, 0x65, 0xb3, 0x07, 0x9d, 0x24, 0xee, 0x61, 0x14, 0x3e, 0x37, 0x79, 0xce, 0x9e, 0xef,
0xb5, 0x47, 0x19, 0x7d, 0x95, 0xdc, 0x7d, 0xe9, 0x42, 0xee, 0x7e, 0xce, 0xf3, 0xf7, 0xdb, 0xb0,
0x12, 0xfb, 0x5e, 0x69, 0xdb, 0x3c, 0xc1, 0x5a, 0x8e, 0x3a, 0xf7, 0xd3, 0xdb, 0x9f, 0x60, 0x02,
0x16, 0x26, 0x99, 0x80, 0xac, 0x08, 0x54, 0x73, 0x22, 0x90, 0xbf, 0x06, 0x50, 0x53, 0x5c, 0x03,
0xd0, 0x1f, 0xc2, 0x12, 0xab, 0xfd, 0x92, 0x41, 0x60, 0x1f, 0xe2, 0x38, 0x05, 0x98, 0x85, 0xad,
0x3d, 0xa8, 0x66, 0xb2, 0x88, 0xf8, 0x5b, 0xff, 0xb1, 0x06, 0x57, 0xf3, 0xeb, 0x32, 0x89, 0x49,
0x0c, 0x89, 0x26, 0x19, 0x92, 0x5f, 0x83, 0xa5, 0x54, 0x44, 0x29, 0xad, 0x3c, 0x21, 0x02, 0x57,
0x20, 0x6e, 0xa0, 0x64, 0x8d, 0xa8, 0x4d, 0xff, 0xb9, 0x16, 0x97, 0xd0, 0x69, 0xdb, 0x90, 0x9d,
0x4f, 0x50, 0xbf, 0xe6, 0x7b, 0x8e, 0xed, 0xc5, 0x95, 0x12, 0xb1, 0x47, 0xde, 0x28, 0x2a, 0x25,
0xef, 0x40, 0x5b, 0x0c, 0x8a, 0xdd, 0xd3, 0x8c, 0x01, 0x59, 0x8b, 0xcf, 0x8b, 0x1d, 0xd3, 0xf3,
0xd0, 0x12, 0x07, 0x07, 0x11, 0xbc, 0xa2, 0xea, 0x38, 0xe1, 0x7b, 0xd0, 0x89, 0x86, 0x5d, 0xd4,
0x21, 0xb6, 0xc5, 0xc4, 0x38, 0xb0, 0xfb, 0x2d, 0x0d, 0xba, 0xb2, 0x7b, 0x4c, 0x6d, 0xff, 0xe2,
0xe1, 0xdd, 0x1b, 0xf2, 0x61, 0xf2, 0xf3, 0xe7, 0xe0, 0x93, 0xc0, 0x89, 0x8e, 0x94, 0x7f, 0xb7,
0xc0, 0x6e, 0x06, 0xd0, 0x54, 0x6f, 0xc7, 0x26, 0x61, 0x60, 0x1f, 0x8e, 0xe7, 0x3b, 0xde, 0x34,
0xa1, 0x3e, 0x38, 0xc6, 0x83, 0x47, 0x23, 0xdf, 0x4e, 0xb8, 0xf2, 0x96, 0x0a, 0xa7, 0xc9, 0x60,
0x37, 0xb6, 0x93, 0x15, 0xf8, 0x09, 0x50, 0x7a, 0xcd, 0xde, 0x0f, 0xa0, 0x93, 0x1d, 0x90, 0x3e,
0x78, 0xa9, 0xf1, 0x83, 0x97, 0xdb, 0xf2, 0xc1, 0xcb, 0x94, 0x48, 0x23, 0x75, 0xee, 0xf2, 0x57,
0x05, 0xf8, 0xaa, 0x12, 0xb7, 0x79, 0xb2, 0xa4, 0x49, 0x75, 0xa4, 0xbb, 0x50, 0xcd, 0x24, 0xb5,
0x2f, 0x9c, 0xc3, 0x3f, 0x51, 0x4b, 0xe5, 0x35, 0x3d, 0x92, 0xc4, 0x56, 0x89, 0xc2, 0x97, 0x26,
0xaf, 0x21, 0xf4, 0x4e, 0x5a, 0x23, 0x9a, 0x87, 0xee, 0x40, 0x83, 0x17, 0x0c, 0xfa, 0x27, 0x36,
0x3e, 0x8d, 0x8e, 0x35, 0x6f, 0x2a, 0x4d, 0x33, 0x1b, 0xf7, 0xa1, 0x8d, 0x4f, 0x8d, 0xba, 0x13,
0xff, 0x26, 0xfa, 0x7f, 0x15, 0x01, 0x92, 0x3e, 0x9a, 0x9d, 0x25, 0x3a, 0x2f, 0x94, 0x38, 0xd5,
0x42, 0x63, 0x09, 0x39, 0x72, 0x8d, 0x3e, 0x91, 0x91, 0x1c, 0x2b, 0x58, 0x36, 0x09, 0x05, 0x5d,
0x36, 0xcf, 0xc7, 0x25, 0x22, 0x11, 0x65, 0x99, 0x90, 0x19, 0x92, 0xb4, 0xa0, 0x57, 0x00, 0x0d,
0x03, 0xff, 0xd4, 0xf6, 0x86, 0xe9, 0x7c, 0x83, 0xa7, 0x25, 0x8b, 0xa2, 0x27, 0x95, 0x70, 0xfc,
0x10, 0x3a, 0x99, 0xe1, 0x11, 0x49, 0x6e, 0x4f, 0x41, 0xe3, 0xbe, 0xb4, 0x96, 0x10, 0xdf, 0xb6,
0x0c, 0x81, 0xf4, 0xfa, 0xd0, 0xc9, 0xe2, 0xab, 0x38, 0x3b, 0xfc, 0xa6, 0x2c, 0xc2, 0xe7, 0x59,
0x1a, 0xba, 0x4c, 0x4a, 0x88, 0x7b, 0x26, 0x2c, 0xab, 0x30, 0x51, 0x00, 0xb9, 0xb4, 0x9e, 0xbc,
0x15, 0x07, 0xbb, 0x8c, 0xc2, 0x93, 0xfc, 0x47, 0xaa, 0x16, 0x5c, 0x90, 0x6a, 0xc1, 0xfa, 0xdf,
0x69, 0x80, 0xf2, 0x82, 0x8d, 0x5a, 0x50, 0x88, 0x17, 0x29, 0xec, 0xee, 0x64, 0x04, 0xa9, 0x90,
0x13, 0xa4, 0xeb, 0x50, 0x8b, 0xfd, 0xb9, 0x30, 0xde, 0x49, 0x43, 0x5a, 0xcc, 0x4a, 0xb2, 0x98,
0xa5, 0x10, 0x2b, 0xcb, 0x45, 0xea, 0x57, 0x61, 0xd9, 0x31, 0x49, 0xd8, 0xe7, 0xb5, 0xf0, 0xd0,
0x76, 0x31, 0x09, 0x4d, 0x77, 0xc4, 0x82, 0xe5, 0x92, 0x81, 0x68, 0xdf, 0x0e, 0xed, 0x7a, 0x10,
0xf5, 0xe8, 0xc7, 0x80, 0xf2, 0xea, 0x95, 0x86, 0xad, 0xc9, 0xb0, 0xa7, 0xed, 0x29, 0x85, 0x5b,
0x51, 0x26, 0xda, 0x1f, 0x17, 0x01, 0x25, 0x31, 0x4e, 0x7c, 0xda, 0x3a, 0x4b, 0x60, 0xb0, 0x09,
0x4b, 0xf9, 0x08, 0x28, 0x0a, 0xfb, 0x50, 0x2e, 0xfe, 0x51, 0xc5, 0x2a, 0x45, 0xd5, 0x95, 0xc5,
0xd7, 0x62, 0x83, 0xc8, 0x03, 0xba, 0x9b, 0x13, 0x4b, 0xf5, 0xb2, 0x4d, 0xfc, 0x41, 0xf6, 0xaa,
0x23, 0xd7, 0xb0, 0xd7, 0x95, 0xc6, 0x2b, 0xb7, 0xe5, 0xa9, 0xf7, 0x1c, 0xa5, 0x50, 0xb3, 0x72,
0x91, 0x50, 0x73, 0xfe, 0xfb, 0x8d, 0x3f, 0x2b, 0xc0, 0x62, 0x4c, 0xc8, 0x0b, 0x31, 0x69, 0xfa,
0xc1, 0xf8, 0x53, 0xe6, 0xca, 0xc7, 0x6a, 0xae, 0x7c, 0xeb, 0xdc, 0x70, 0x7f, 0x56, 0xa6, 0xcc,
0x4f, 0xd9, 0x4f, 0x61, 0x41, 0x14, 0x6e, 0x73, 0x86, 0x62, 0x96, 0x84, 0x7a, 0x19, 0xca, 0xd4,
0x2e, 0x45, 0x55, 0x37, 0xfe, 0xc1, 0x49, 0x9a, 0xbe, 0xf8, 0x2a, 0x6c, 0x45, 0x53, 0xba, 0xf7,
0xaa, 0xff, 0x87, 0x06, 0x70, 0x70, 0xe6, 0x0d, 0xee, 0x70, 0x25, 0x7d, 0x15, 0x4a, 0xd3, 0xae,
0x4b, 0xd1, 0xd1, 0x4c, 0xb6, 0xd8, 0xc8, 0x19, 0x98, 0x2b, 0x95, 0x0c, 0x8a, 0xd9, 0x92, 0xc1,
0xa4, 0x64, 0x7f, 0xb2, 0x29, 0xfb, 0x16, 0x94, 0x68, 0xa0, 0x27, 0xae, 0x1b, 0xcd, 0x74, 0xe0,
0xc9, 0x26, 0xe8, 0x9f, 0x15, 0xe0, 0x1a, 0xc5, 0xfe, 0xc9, 0x44, 0x85, 0xb3, 0xb0, 0x26, 0x65,
0x2d, 0x8b, 0xb2, 0xb5, 0x7c, 0x1d, 0x16, 0x78, 0xba, 0x1f, 0xc5, 0x37, 0x37, 0x27, 0xd1, 0x9a,
0x73, 0xc6, 0x88, 0x86, 0xcf, 0x9b, 0x33, 0x4a, 0x87, 0xad, 0x95, 0xf9, 0x0e, 0x5b, 0x17, 0xb2,
0x45, 0xc1, 0x14, 0xd3, 0xaa, 0xb2, 0x8d, 0x7f, 0x08, 0x4d, 0x23, 0x2d, 0x78, 0x08, 0x41, 0x29,
0x75, 0xbb, 0x91, 0xfd, 0x66, 0x69, 0x9e, 0x39, 0x32, 0x07, 0x76, 0x78, 0xc6, 0xc8, 0x59, 0x36,
0xe2, 0x6f, 0xb5, 0x94, 0xeb, 0xff, 0xab, 0xc1, 0xd5, 0xe8, 0x50, 0x4f, 0xe8, 0xd0, 0xe5, 0x39,
0xba, 0x05, 0x2b, 0x42, 0x61, 0x32, 0x9a, 0xc3, 0x83, 0xb9, 0x25, 0xde, 0x26, 0x6f, 0x63, 0x0b,
0x56, 0x42, 0x33, 0x18, 0xe2, 0x30, 0x3b, 0x87, 0xf3, 0x7b, 0x89, 0x77, 0xca, 0x73, 0x66, 0x39,
0x54, 0x7d, 0x86, 0x5f, 0xc8, 0x11, 0xa4, 0x15, 0x2a, 0x00, 0xde, 0xd8, 0x15, 0xbb, 0xd4, 0x4f,
0xe1, 0x3a, 0xbf, 0x5f, 0x7c, 0x28, 0x63, 0x34, 0x57, 0x4d, 0x5d, 0xb9, 0xef, 0x8c, 0xc5, 0xf8,
0x23, 0x0d, 0x6e, 0x4c, 0x80, 0x3c, 0x4f, 0x36, 0xf1, 0x9e, 0x12, 0xfa, 0x84, 0xdc, 0x4f, 0x82,
0xcb, 0x6f, 0xb2, 0xc9, 0x48, 0x7e, 0x56, 0x82, 0xc5, 0xdc, 0xa0, 0x0b, 0xcb, 0xdc, 0xcb, 0x80,
0x28, 0x13, 0xe2, 0x47, 0x70, 0x2c, 0x9d, 0x16, 0xae, 0xa9, 0xe3, 0x8d, 0xdd, 0xf8, 0x01, 0x1c,
0xcd, 0xa8, 0x91, 0xcd, 0x47, 0xf3, 0x8a, 0x7a, 0xcc, 0xb9, 0xd2, 0xe4, 0xb7, 0x0e, 0x39, 0x04,
0x37, 0xf6, 0xc6, 0x2e, 0x2f, 0xbe, 0x0b, 0x2e, 0x73, 0x77, 0x43, 0x41, 0x49, 0xcd, 0xe8, 0x08,
0x16, 0xd9, 0x75, 0xad, 0x71, 0x38, 0xf4, 0x69, 0x40, 0xcf, 0xf0, 0xe2, 0x4e, 0xed, 0x3b, 0x33,
0x43, 0xfa, 0x40, 0xcc, 0xa6, 0xc8, 0x8b, 0x98, 0xde, 0x93, 0x5b, 0x23, 0x38, 0xb6, 0x37, 0xf0,
0xdd, 0x18, 0x4e, 0xe5, 0x82, 0x70, 0x76, 0xc5, 0x6c, 0x19, 0x4e, 0xba, 0xb5, 0xb7, 0x0d, 0x2b,
0xca, 0xad, 0x4f, 0x73, 0xa3, 0xe5, 0x74, 0x7e, 0x70, 0x17, 0x96, 0x55, 0xbb, 0xba, 0xc4, 0x1a,
0x39, 0x8c, 0x2f, 0xb2, 0x86, 0xfe, 0x67, 0x05, 0x68, 0xee, 0x60, 0x07, 0x87, 0xf8, 0xe9, 0x9e,
0x79, 0xe6, 0x0e, 0x70, 0x8b, 0xf9, 0x03, 0xdc, 0xdc, 0x69, 0x74, 0x49, 0x71, 0x1a, 0x7d, 0x23,
0x3e, 0x84, 0xa7, 0xab, 0x94, 0x65, 0x0f, 0x6d, 0xa1, 0x37, 0xa0, 0x31, 0x0a, 0x6c, 0xd7, 0x0c,
0xce, 0xfa, 0x8f, 0xf0, 0x19, 0x11, 0x4e, 0xa3, 0xab, 0x74, 0x3b, 0xbb, 0x3b, 0xc4, 0xa8, 0x8b,
0xd1, 0xef, 0xe2, 0x33, 0x76, 0xc0, 0x1f, 0x27, 0x1b, 0xfc, 0x2a, 0x56, 0xc9, 0x48, 0xb5, 0xac,
0xaf, 0x42, 0x2d, 0xbe, 0xf1, 0x82, 0xaa, 0x50, 0xba, 0x37, 0x76, 0x9c, 0xce, 0x15, 0x54, 0x83,
0x32, 0x4b, 0x47, 0x3a, 0xda, 0xfa, 0xaf, 0x40, 0x2d, 0x3e, 0xb5, 0x47, 0x75, 0x58, 0x78, 0xe8,
0xbd, 0xeb, 0xf9, 0xa7, 0x5e, 0xe7, 0x0a, 0x5a, 0x80, 0xe2, 0x1d, 0xc7, 0xe9, 0x68, 0xa8, 0x09,
0xb5, 0x83, 0x30, 0xc0, 0x26, 0xe5, 0x59, 0xa7, 0x80, 0x5a, 0x00, 0xef, 0xd8, 0x24, 0xf4, 0x03,
0x7b, 0x60, 0x3a, 0x9d, 0xe2, 0xfa, 0xa7, 0xd0, 0x92, 0x8b, 0xb8, 0xa8, 0x01, 0xd5, 0x3d, 0x3f,
0x7c, 0xfb, 0x13, 0x9b, 0x84, 0x9d, 0x2b, 0x74, 0xfc, 0x9e, 0x1f, 0xee, 0x07, 0x98, 0x60, 0x2f,
0xec, 0x68, 0x08, 0xa0, 0xf2, 0x81, 0xb7, 0x63, 0x93, 0x47, 0x9d, 0x02, 0x5a, 0x12, 0xe7, 0x33,
0xa6, 0xb3, 0x2b, 0x2a, 0xa3, 0x9d, 0x22, 0x9d, 0x1e, 0x7f, 0x95, 0x50, 0x07, 0x1a, 0xf1, 0x90,
0xfb, 0xfb, 0x0f, 0x3b, 0x65, 0x8a, 0x3d, 0xff, 0x59, 0x59, 0xb7, 0xa0, 0x93, 0x3d, 0x57, 0xa4,
0x6b, 0xf2, 0x4d, 0xc4, 0x4d, 0x9d, 0x2b, 0x74, 0x67, 0xe2, 0x60, 0xb7, 0xa3, 0xa1, 0x36, 0xd4,
0x53, 0xc7, 0xa4, 0x9d, 0x02, 0x6d, 0xb8, 0x1f, 0x8c, 0x06, 0x42, 0xa0, 0x38, 0x0a, 0x54, 0x3a,
0x77, 0x28, 0x25, 0x4a, 0xeb, 0x77, 0xa1, 0x1a, 0x85, 0xfc, 0x74, 0xa8, 0x20, 0x11, 0xfd, 0xec,
0x5c, 0x41, 0x8b, 0xd0, 0x94, 0x5e, 0x55, 0x75, 0x34, 0x84, 0xa0, 0x25, 0xbf, 0x7b, 0xec, 0x14,
0xd6, 0xb7, 0x00, 0x92, 0xd0, 0x99, 0xa2, 0xb3, 0xeb, 0x9d, 0x98, 0x8e, 0x6d, 0x71, 0xdc, 0x68,
0x17, 0xa5, 0x2e, 0xa3, 0x0e, 0x57, 0xd4, 0x4e, 0x61, 0x7d, 0x1d, 0xaa, 0x51, 0x38, 0x48, 0xdb,
0x0d, 0xec, 0xfa, 0x27, 0x98, 0x73, 0xe6, 0x00, 0x53, 0x52, 0xd6, 0xa0, 0x7c, 0xc7, 0xc5, 0x9e,
0xd5, 0x29, 0x6c, 0xfd, 0xfb, 0x12, 0x00, 0x3f, 0x15, 0xf4, 0xfd, 0xc0, 0x42, 0x0e, 0xbb, 0x1d,
0xb0, 0xed, 0xbb, 0x23, 0xdf, 0x8b, 0x8e, 0x2c, 0x08, 0xda, 0xc8, 0xa4, 0xea, 0xfc, 0x23, 0x3f,
0x50, 0x10, 0xa2, 0xf7, 0x9c, 0x72, 0x7c, 0x66, 0xb0, 0x7e, 0x05, 0xb9, 0x0c, 0x1a, 0x4d, 0x6e,
0x1f, 0xd8, 0x83, 0x47, 0xf1, 0x51, 0xe2, 0xe4, 0xc7, 0x87, 0x99, 0xa1, 0x11, 0xbc, 0x5b, 0x4a,
0x78, 0x07, 0x61, 0x60, 0x7b, 0xc3, 0xc8, 0xff, 0xe9, 0x57, 0xd0, 0xe3, 0xcc, 0xd3, 0xc7, 0x08,
0xe0, 0xd6, 0x2c, 0xaf, 0x1d, 0x2f, 0x07, 0xd2, 0x81, 0x76, 0xe6, 0x8d, 0x39, 0x5a, 0x57, 0x3f,
0x45, 0x51, 0xbd, 0x87, 0xef, 0xbd, 0x34, 0xd3, 0xd8, 0x18, 0x9a, 0x0d, 0x2d, 0xf9, 0x71, 0x34,
0xfa, 0xda, 0xa4, 0x05, 0x72, 0x8f, 0xe1, 0x7a, 0xeb, 0xb3, 0x0c, 0x8d, 0x41, 0x7d, 0xc4, 0x65,
0x75, 0x1a, 0x28, 0xe5, 0xc3, 0xc1, 0xde, 0x79, 0xa1, 0x87, 0x7e, 0x05, 0xfd, 0x88, 0x46, 0x09,
0x99, 0x27, 0x7b, 0xe8, 0x65, 0xb5, 0x67, 0x53, 0xbf, 0xec, 0x9b, 0x06, 0xe1, 0xa3, 0xac, 0xa6,
0x4d, 0xc6, 0x3e, 0xf7, 0x88, 0x77, 0x76, 0xec, 0x53, 0xcb, 0x9f, 0x87, 0xfd, 0x85, 0x21, 0x38,
0x3c, 0x61, 0x52, 0x3c, 0x16, 0xca, 0x8a, 0x72, 0x92, 0xaf, 0x4c, 0x7e, 0x59, 0x34, 0x0d, 0xda,
0x98, 0x29, 0x69, 0xf6, 0x38, 0xfc, 0x95, 0x09, 0x85, 0x76, 0xf5, 0x2b, 0xc5, 0xde, 0xc6, 0xac,
0xc3, 0xd3, 0xb2, 0x2c, 0x3f, 0x84, 0x53, 0xb3, 0x48, 0xf9, 0x78, 0x4f, 0x2d, 0xcb, 0xea, 0x77,
0x75, 0xfa, 0x15, 0xf4, 0x40, 0xb2, 0xeb, 0xe8, 0x85, 0x49, 0xa2, 0x20, 0xdf, 0x8f, 0x99, 0x46,
0xb7, 0x5f, 0x07, 0xc4, 0x35, 0xd5, 0x3b, 0xb2, 0x87, 0xe3, 0xc0, 0xe4, 0x62, 0x3c, 0xc9, 0xb8,
0xe5, 0x87, 0x46, 0x60, 0xbe, 0x7e, 0x81, 0x19, 0xf1, 0x96, 0xfa, 0x00, 0xf7, 0x71, 0xf8, 0x3e,
0x0e, 0x03, 0x7b, 0x40, 0xb2, 0x3b, 0x4a, 0xec, 0xb7, 0x18, 0x10, 0x81, 0x7a, 0x71, 0xea, 0xb8,
0x18, 0xc0, 0x21, 0xd4, 0xef, 0xd3, 0x0c, 0x8a, 0x45, 0x85, 0x04, 0x4d, 0x9c, 0x19, 0x8d, 0x88,
0x40, 0xac, 0x4d, 0x1f, 0x98, 0x36, 0x9e, 0x99, 0x47, 0x81, 0x68, 0x22, 0x63, 0xf3, 0x4f, 0x15,
0xd5, 0xc6, 0x73, 0xc2, 0x2b, 0x43, 0xbe, 0x23, 0x76, 0xd8, 0xf3, 0x0e, 0x36, 0x9d, 0xf0, 0x78,
0xc2, 0x8e, 0x52, 0x23, 0xce, 0xdf, 0x91, 0x34, 0x30, 0x86, 0x81, 0x61, 0x89, 0x6b, 0xa1, 0x9c,
0x7a, 0x6e, 0xaa, 0x97, 0xc8, 0x8f, 0x9c, 0x51, 0xf4, 0x4c, 0x58, 0xdc, 0x09, 0xfc, 0x91, 0x0c,
0xe4, 0x15, 0x25, 0x90, 0xdc, 0xb8, 0x19, 0x41, 0x7c, 0x1f, 0x1a, 0x51, 0x86, 0xcf, 0x72, 0x12,
0x35, 0x15, 0xd2, 0x43, 0x66, 0x5c, 0xf8, 0x63, 0x68, 0x67, 0x4a, 0x07, 0x6a, 0xa6, 0xab, 0xeb,
0x0b, 0xd3, 0x56, 0x3f, 0x05, 0xc4, 0x5e, 0x7a, 0x4a, 0xaf, 0xcc, 0x27, 0xc4, 0x37, 0xf9, 0x81,
0x11, 0x90, 0xcd, 0x99, 0xc7, 0xc7, 0x9c, 0xff, 0x0d, 0x58, 0x51, 0xa6, 0xe7, 0x59, 0x83, 0x20,
0x2e, 0xc4, 0x9e, 0x53, 0x43, 0xc8, 0x1a, 0x84, 0x73, 0x67, 0x44, 0xf0, 0xb7, 0xfe, 0xb5, 0x0d,
0x35, 0x16, 0xe7, 0x31, 0x6e, 0xfd, 0x32, 0xcc, 0x7b, 0xb2, 0x61, 0xde, 0xc7, 0xd0, 0xce, 0xbc,
0x31, 0x54, 0x0b, 0xad, 0xfa, 0x21, 0xe2, 0x0c, 0xd1, 0x8a, 0xfc, 0x3c, 0x4f, 0xed, 0x0a, 0x95,
0x4f, 0xf8, 0xa6, 0xad, 0xfd, 0x21, 0x7f, 0x9e, 0x1b, 0xdf, 0x52, 0x78, 0x71, 0x62, 0xf1, 0x5e,
0xbe, 0xd8, 0xfa, 0xf9, 0x47, 0x41, 0x5f, 0xee, 0x08, 0xf4, 0x63, 0x68, 0x67, 0x9e, 0x8e, 0xa8,
0x25, 0x46, 0xfd, 0xbe, 0x64, 0xda, 0xea, 0xbf, 0xc0, 0xe0, 0xc9, 0x82, 0x25, 0xc5, 0x4d, 0x7d,
0xb4, 0x31, 0x29, 0x10, 0x55, 0x5f, 0xe9, 0x9f, 0xbe, 0xa1, 0xa6, 0xa4, 0xa6, 0x59, 0x7f, 0x93,
0x20, 0x99, 0xfd, 0x7b, 0x9a, 0xde, 0xcb, 0xb3, 0xfd, 0x97, 0x4d, 0xbc, 0xa1, 0x03, 0xa8, 0xf0,
0x07, 0x25, 0xe8, 0x59, 0xf5, 0x21, 0x46, 0xea, 0xb1, 0x49, 0x6f, 0xda, 0x93, 0x14, 0x32, 0x76,
0x42, 0xc2, 0x16, 0x2d, 0x33, 0xeb, 0x8b, 0x94, 0x55, 0xfd, 0xf4, 0xcb, 0x8e, 0xde, 0xf4, 0xc7,
0x1c, 0xd1, 0xa2, 0xff, 0xbf, 0x23, 0xcc, 0x4f, 0xd8, 0xd3, 0x81, 0xec, 0xe5, 0x18, 0xb4, 0x71,
0xb1, 0x1b, 0x3e, 0xbd, 0xcd, 0x99, 0xc7, 0xc7, 0x90, 0x7f, 0x08, 0x9d, 0xec, 0x81, 0x14, 0x7a,
0x69, 0x92, 0x3c, 0xab, 0x60, 0x4e, 0x11, 0xe6, 0xef, 0x41, 0x85, 0x57, 0x22, 0xd5, 0x12, 0x26,
0x55, 0x29, 0xa7, 0xac, 0x75, 0xf7, 0x1b, 0x1f, 0x6d, 0x0d, 0xed, 0xf0, 0x78, 0x7c, 0x48, 0x7b,
0x36, 0xf9, 0xd0, 0x57, 0x6c, 0x5f, 0xfc, 0xda, 0x8c, 0x78, 0xb9, 0xc9, 0x66, 0x6f, 0x32, 0x00,
0xa3, 0xc3, 0xc3, 0x0a, 0xfb, 0xbc, 0xfd, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x25, 0x7f, 0x72,
0x5e, 0x1c, 0x50, 0x00, 0x00,
// 4599 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3c, 0x4b, 0x6f, 0x24, 0x49,
0x5a, 0x9d, 0xf5, 0xb0, 0xab, 0xbe, 0x7a, 0x3a, 0x6c, 0x77, 0xd7, 0xd6, 0x76, 0xf7, 0x78, 0xb2,
0xe7, 0xe1, 0xf5, 0xcc, 0xd8, 0xbd, 0xee, 0xdd, 0xd9, 0xde, 0x9d, 0x59, 0x0d, 0xdd, 0xf6, 0x74,
0x8f, 0x77, 0x7a, 0x3c, 0x26, 0xdd, 0xdd, 0x8b, 0x46, 0xb3, 0x5b, 0x9b, 0xae, 0x0c, 0x97, 0x53,
0x9d, 0x8f, 0xea, 0x8c, 0x2c, 0xbb, 0x3d, 0x48, 0x9c, 0xb8, 0xb0, 0x02, 0x04, 0x27, 0x38, 0x20,
0x0e, 0x20, 0xa4, 0x05, 0xc1, 0x0d, 0x24, 0x0e, 0x1c, 0x38, 0x01, 0x02, 0xf1, 0xb8, 0x20, 0xfe,
0x00, 0x1c, 0x90, 0x40, 0x9c, 0x56, 0x68, 0x6e, 0x28, 0x1e, 0xf9, 0x88, 0xcc, 0x28, 0x57, 0xd9,
0xd5, 0xb3, 0x33, 0x83, 0xf6, 0x56, 0xf9, 0xc5, 0xe3, 0xfb, 0xe2, 0x7b, 0xc5, 0xf7, 0x7d, 0x11,
0x51, 0xb0, 0xf0, 0x74, 0x84, 0x83, 0xd3, 0x5e, 0xdf, 0xf7, 0x03, 0x6b, 0x7d, 0x18, 0xf8, 0xa1,
0x8f, 0x90, 0x6b, 0x3b, 0xc7, 0x23, 0xc2, 0xbf, 0xd6, 0x59, 0x7b, 0xb7, 0xde, 0xf7, 0x5d, 0xd7,
0xf7, 0x38, 0xac, 0x5b, 0x4f, 0xf7, 0xe8, 0x36, 0x6d, 0x2f, 0xc4, 0x81, 0x67, 0x3a, 0x51, 0x2b,
0xe9, 0x1f, 0x61, 0xd7, 0x14, 0x5f, 0x55, 0x97, 0x0c, 0xc4, 0xcf, 0xb6, 0x65, 0x86, 0x66, 0x1a,
0x55, 0x77, 0xc1, 0xf6, 0x2c, 0xfc, 0x2c, 0x0d, 0xd2, 0x7f, 0x55, 0x83, 0xcb, 0xfb, 0x47, 0xfe,
0xc9, 0x96, 0xef, 0x38, 0xb8, 0x1f, 0xda, 0xbe, 0x47, 0x0c, 0xfc, 0x74, 0x84, 0x49, 0x88, 0x6e,
0x42, 0xe9, 0xc0, 0x24, 0xb8, 0xa3, 0xad, 0x68, 0xab, 0xb5, 0xcd, 0xab, 0xeb, 0x12, 0x9d, 0x82,
0xc0, 0x0f, 0xc8, 0xe0, 0xae, 0x49, 0xb0, 0xc1, 0x7a, 0x22, 0x04, 0x25, 0xeb, 0x60, 0x67, 0xbb,
0x53, 0x58, 0xd1, 0x56, 0x8b, 0x06, 0xfb, 0x8d, 0x5e, 0x82, 0x46, 0x3f, 0x9e, 0x7b, 0x67, 0x9b,
0x74, 0x8a, 0x2b, 0xc5, 0xd5, 0xa2, 0x21, 0x03, 0xf5, 0x1f, 0x17, 0xe0, 0x4a, 0x8e, 0x0c, 0x32,
0xf4, 0x3d, 0x82, 0xd1, 0x2d, 0x98, 0x23, 0xa1, 0x19, 0x8e, 0x88, 0xa0, 0xe4, 0xab, 0x4a, 0x4a,
0xf6, 0x59, 0x17, 0x43, 0x74, 0xcd, 0xa3, 0x2d, 0x28, 0xd0, 0xa2, 0xaf, 0xc3, 0x92, 0xed, 0x7d,
0x80, 0x5d, 0x3f, 0x38, 0xed, 0x0d, 0x71, 0xd0, 0xc7, 0x5e, 0x68, 0x0e, 0x70, 0x44, 0xe3, 0x62,
0xd4, 0xb6, 0x97, 0x34, 0xa1, 0x37, 0xe1, 0x0a, 0x97, 0x21, 0xc1, 0xc1, 0xb1, 0xdd, 0xc7, 0x3d,
0xf3, 0xd8, 0xb4, 0x1d, 0xf3, 0xc0, 0xc1, 0x9d, 0xd2, 0x4a, 0x71, 0xb5, 0x62, 0x2c, 0xb3, 0xe6,
0x7d, 0xde, 0x7a, 0x27, 0x6a, 0x44, 0x5f, 0x83, 0x76, 0x80, 0x0f, 0x03, 0x4c, 0x8e, 0x7a, 0xc3,
0xc0, 0x1f, 0x04, 0x98, 0x90, 0x4e, 0x99, 0xa1, 0x69, 0x09, 0xf8, 0x9e, 0x00, 0xeb, 0x7f, 0xa4,
0xc1, 0x32, 0x65, 0xc6, 0x9e, 0x19, 0x84, 0xf6, 0x67, 0x20, 0x12, 0x1d, 0xea, 0x69, 0x36, 0x74,
0x8a, 0xac, 0x4d, 0x82, 0xd1, 0x3e, 0xc3, 0x08, 0x3d, 0x65, 0x5f, 0x89, 0x91, 0x2a, 0xc1, 0xf4,
0x7f, 0x16, 0xba, 0x93, 0xa6, 0x73, 0x16, 0x99, 0x65, 0x71, 0x16, 0xf2, 0x38, 0x2f, 0x22, 0x31,
0x15, 0xe7, 0x4b, 0x6a, 0xce, 0xff, 0x63, 0x11, 0x96, 0x1f, 0xf8, 0xa6, 0x95, 0xa8, 0xe1, 0xcf,
0x9e, 0xf3, 0xdf, 0x85, 0x39, 0x6e, 0xd1, 0x9d, 0x12, 0xc3, 0xf5, 0xb2, 0x8c, 0x4b, 0x58, 0x7b,
0x42, 0xe1, 0x3e, 0x03, 0x18, 0x62, 0x10, 0x7a, 0x19, 0x9a, 0x01, 0x1e, 0x3a, 0x76, 0xdf, 0xec,
0x79, 0x23, 0xf7, 0x00, 0x07, 0x9d, 0xf2, 0x8a, 0xb6, 0x5a, 0x36, 0x1a, 0x02, 0xba, 0xcb, 0x80,
0xe8, 0x47, 0xd0, 0x38, 0xb4, 0xb1, 0x63, 0xf5, 0x98, 0x4b, 0xd8, 0xd9, 0xee, 0xcc, 0xad, 0x14,
0x57, 0x6b, 0x9b, 0x6f, 0xad, 0xe7, 0xbd, 0xd1, 0xba, 0x92, 0x23, 0xeb, 0xf7, 0xe8, 0xf0, 0x1d,
0x3e, 0xfa, 0x5d, 0x2f, 0x0c, 0x4e, 0x8d, 0xfa, 0x61, 0x0a, 0x84, 0x3a, 0x30, 0x2f, 0xd8, 0xdb,
0x99, 0x5f, 0xd1, 0x56, 0x2b, 0x46, 0xf4, 0x89, 0x5e, 0x85, 0x56, 0x80, 0x89, 0x3f, 0x0a, 0xfa,
0xb8, 0x37, 0x08, 0xfc, 0xd1, 0x90, 0x74, 0x2a, 0x2b, 0xc5, 0xd5, 0xaa, 0xd1, 0x8c, 0xc0, 0xf7,
0x19, 0xb4, 0xfb, 0x0e, 0x2c, 0xe4, 0xb0, 0xa0, 0x36, 0x14, 0x9f, 0xe0, 0x53, 0x26, 0x88, 0xa2,
0x41, 0x7f, 0xa2, 0x25, 0x28, 0x1f, 0x9b, 0xce, 0x08, 0x0b, 0x56, 0xf3, 0x8f, 0xef, 0x14, 0x6e,
0x6b, 0xfa, 0xef, 0x69, 0xd0, 0x31, 0xb0, 0x83, 0x4d, 0x82, 0x3f, 0x4f, 0x91, 0x5e, 0x86, 0x39,
0xcf, 0xb7, 0xf0, 0xce, 0x36, 0x13, 0x69, 0xd1, 0x10, 0x5f, 0xfa, 0xa7, 0x1a, 0x2c, 0xdd, 0xc7,
0x21, 0x35, 0x03, 0x9b, 0x84, 0x76, 0x3f, 0xb6, 0xf3, 0xef, 0x42, 0x31, 0xc0, 0x4f, 0x05, 0x65,
0xaf, 0xc9, 0x94, 0xc5, 0xee, 0x5f, 0x35, 0xd2, 0xa0, 0xe3, 0xd0, 0x8b, 0x50, 0xb7, 0x5c, 0xa7,
0xd7, 0x3f, 0x32, 0x3d, 0x0f, 0x3b, 0xdc, 0x90, 0xaa, 0x46, 0xcd, 0x72, 0x9d, 0x2d, 0x01, 0x42,
0xd7, 0x01, 0x08, 0x1e, 0xb8, 0xd8, 0x0b, 0x13, 0x9f, 0x9c, 0x82, 0xa0, 0x35, 0x58, 0x38, 0x0c,
0x7c, 0xb7, 0x47, 0x8e, 0xcc, 0xc0, 0xea, 0x39, 0xd8, 0xb4, 0x70, 0xc0, 0xa8, 0xaf, 0x18, 0x2d,
0xda, 0xb0, 0x4f, 0xe1, 0x0f, 0x18, 0x18, 0xdd, 0x82, 0x32, 0xe9, 0xfb, 0x43, 0xcc, 0x34, 0xad,
0xb9, 0x79, 0x4d, 0xa5, 0x43, 0xdb, 0x66, 0x68, 0xee, 0xd3, 0x4e, 0x06, 0xef, 0xab, 0xff, 0x65,
0x89, 0x9b, 0xda, 0x17, 0xdc, 0xc9, 0xa5, 0xcc, 0xb1, 0xfc, 0x7c, 0xcc, 0x71, 0x6e, 0x2a, 0x73,
0x9c, 0x3f, 0xdb, 0x1c, 0x73, 0x5c, 0x3b, 0x8f, 0x39, 0x56, 0x26, 0x9a, 0x63, 0x55, 0x65, 0x8e,
0xe8, 0x5d, 0x68, 0xf1, 0x00, 0xc2, 0xf6, 0x0e, 0xfd, 0x9e, 0x63, 0x93, 0xb0, 0x03, 0x8c, 0xcc,
0x6b, 0x59, 0x0d, 0xb5, 0xf0, 0xb3, 0x75, 0x8e, 0xd8, 0x3b, 0xf4, 0x8d, 0x86, 0x1d, 0xfd, 0x7c,
0x60, 0x93, 0x70, 0x76, 0xab, 0xfe, 0xeb, 0xc4, 0xaa, 0xbf, 0xe8, 0xda, 0x93, 0x58, 0x7e, 0x59,
0xb2, 0xfc, 0x3f, 0xd6, 0xe0, 0x2b, 0xf7, 0x71, 0x18, 0x93, 0x4f, 0x0d, 0x19, 0x7f, 0x41, 0xb7,
0xf9, 0x3f, 0xd3, 0xa0, 0xab, 0xa2, 0x75, 0x96, 0xad, 0xfe, 0x23, 0xb8, 0x1c, 0xe3, 0xe8, 0x59,
0x98, 0xf4, 0x03, 0x7b, 0xc8, 0xc4, 0xc8, 0x7c, 0x55, 0x6d, 0xf3, 0x86, 0x4a, 0xf1, 0xb3, 0x14,
0x2c, 0xc7, 0x53, 0x6c, 0xa7, 0x66, 0xd0, 0x7f, 0x43, 0x83, 0x65, 0xea, 0x1b, 0x85, 0x33, 0xa3,
0x1a, 0x78, 0x61, 0xbe, 0xca, 0x6e, 0xb2, 0x90, 0x73, 0x93, 0x53, 0xf0, 0x98, 0x85, 0xd8, 0x59,
0x7a, 0x66, 0xe1, 0xdd, 0x37, 0xa1, 0x4c, 0x0d, 0x30, 0x62, 0xd5, 0x0b, 0x2a, 0x56, 0xa5, 0x91,
0xf1, 0xde, 0xba, 0xc7, 0xa9, 0x48, 0xfc, 0xf6, 0x0c, 0xea, 0x96, 0x5d, 0x76, 0x41, 0xb1, 0xec,
0x5f, 0xd7, 0xe0, 0x4a, 0x0e, 0xe1, 0x2c, 0xeb, 0x7e, 0x1b, 0xe6, 0xd8, 0x6e, 0x14, 0x2d, 0xfc,
0x25, 0xe5, 0xc2, 0x53, 0xe8, 0xa8, 0xb7, 0x31, 0xc4, 0x18, 0xdd, 0x87, 0x76, 0xb6, 0x8d, 0xee,
0x93, 0x62, 0x8f, 0xec, 0x79, 0xa6, 0xcb, 0x19, 0x50, 0x35, 0x6a, 0x02, 0xb6, 0x6b, 0xba, 0x18,
0x7d, 0x05, 0x2a, 0xd4, 0x64, 0x7b, 0xb6, 0x15, 0x89, 0x7f, 0x9e, 0x99, 0xb0, 0x45, 0xd0, 0x35,
0x00, 0xd6, 0x64, 0x5a, 0x56, 0xc0, 0xb7, 0xd0, 0xaa, 0x51, 0xa5, 0x90, 0x3b, 0x14, 0xa0, 0xff,
0xae, 0x06, 0xd7, 0xf7, 0x4f, 0xbd, 0xfe, 0x2e, 0x3e, 0xd9, 0x0a, 0xb0, 0x19, 0xe2, 0xc4, 0x69,
0x7f, 0xa6, 0x8c, 0x47, 0x2b, 0x50, 0x4b, 0xd9, 0xaf, 0x50, 0xc9, 0x34, 0x48, 0xff, 0x6d, 0x0d,
0xea, 0x74, 0x17, 0xf9, 0x00, 0x87, 0x26, 0x55, 0x11, 0xf4, 0x6d, 0xa8, 0x3a, 0xbe, 0x69, 0xf5,
0xc2, 0xd3, 0x21, 0xa7, 0xa6, 0x99, 0xa5, 0x26, 0xd9, 0x7a, 0x1e, 0x9e, 0x0e, 0xb1, 0x51, 0x71,
0xc4, 0xaf, 0xa9, 0x28, 0xca, 0x7a, 0x99, 0xa2, 0xc2, 0xcb, 0xfc, 0x4d, 0x19, 0x2e, 0x7f, 0xdf,
0x0c, 0xfb, 0x47, 0xdb, 0x6e, 0x14, 0xa4, 0x5c, 0x9c, 0x4d, 0x89, 0xdb, 0x2d, 0xa4, 0xdd, 0xee,
0x73, 0x73, 0xeb, 0xb1, 0x09, 0x96, 0x55, 0x26, 0x48, 0xf3, 0xee, 0xf5, 0xc7, 0x42, 0x8b, 0x52,
0x26, 0x98, 0x8a, 0x25, 0xe6, 0x2e, 0x12, 0x4b, 0x6c, 0x41, 0x03, 0x3f, 0xeb, 0x3b, 0x23, 0xaa,
0x8e, 0x0c, 0x3b, 0x0f, 0x12, 0xae, 0x2b, 0xb0, 0xa7, 0xed, 0xbf, 0x2e, 0x06, 0xed, 0x08, 0x1a,
0xb8, 0xa8, 0x5d, 0x1c, 0x9a, 0x2c, 0x12, 0xa8, 0x6d, 0xae, 0x8c, 0x13, 0x75, 0xa4, 0x1f, 0x5c,
0xdc, 0xf4, 0x0b, 0x5d, 0x85, 0xaa, 0x88, 0x5c, 0x76, 0xb6, 0x3b, 0x55, 0xc6, 0xbe, 0x04, 0x80,
0x4c, 0x68, 0x08, 0xe7, 0x28, 0x28, 0xe4, 0xf1, 0xc1, 0xdb, 0x2a, 0x04, 0x6a, 0x61, 0xa7, 0x29,
0x27, 0x22, 0x8e, 0x21, 0x29, 0x10, 0x4d, 0xec, 0xfd, 0xc3, 0x43, 0xc7, 0xf6, 0xf0, 0x2e, 0x97,
0x70, 0x8d, 0x11, 0x21, 0x03, 0x69, 0xb4, 0x73, 0x8c, 0x03, 0x62, 0xfb, 0x5e, 0xa7, 0xce, 0xda,
0xa3, 0xcf, 0x6e, 0x0f, 0x16, 0x72, 0x28, 0x14, 0xd1, 0xc7, 0x37, 0xd2, 0xd1, 0xc7, 0x64, 0x1e,
0xa7, 0xa2, 0x93, 0x9f, 0x68, 0xb0, 0xfc, 0xc8, 0x23, 0xa3, 0x83, 0x78, 0x6d, 0x9f, 0x8f, 0x1e,
0x67, 0x9d, 0x5b, 0x29, 0xe7, 0xdc, 0xf4, 0xbf, 0x2f, 0x43, 0x4b, 0xac, 0x82, 0x8a, 0x9b, 0xb9,
0x82, 0xab, 0x50, 0x8d, 0xf7, 0x37, 0xc1, 0x90, 0x04, 0x90, 0xf5, 0x2d, 0x85, 0x9c, 0x6f, 0x99,
0x8a, 0xb4, 0x28, 0x5a, 0x29, 0xa5, 0xa2, 0x95, 0x6b, 0x00, 0x87, 0xce, 0x88, 0x1c, 0xf5, 0x42,
0xdb, 0xc5, 0x22, 0x5a, 0xaa, 0x32, 0xc8, 0x43, 0xdb, 0xc5, 0xe8, 0x0e, 0xd4, 0x0f, 0x6c, 0xcf,
0xf1, 0x07, 0xbd, 0xa1, 0x19, 0x1e, 0x11, 0x91, 0xae, 0xaa, 0xc4, 0xc2, 0x62, 0xcb, 0xbb, 0xac,
0xaf, 0x51, 0xe3, 0x63, 0xf6, 0xe8, 0x10, 0x74, 0x1d, 0x6a, 0xde, 0xc8, 0xed, 0xf9, 0x87, 0xbd,
0xc0, 0x3f, 0x21, 0x2c, 0x29, 0x2d, 0x1a, 0x55, 0x6f, 0xe4, 0x7e, 0x78, 0x68, 0xf8, 0x27, 0x74,
0x7f, 0xa9, 0xd2, 0x9d, 0x86, 0x38, 0xfe, 0x80, 0x27, 0xa4, 0x93, 0xe7, 0x4f, 0x06, 0xd0, 0xd1,
0x16, 0x76, 0x42, 0x93, 0x8d, 0xae, 0x4e, 0x37, 0x3a, 0x1e, 0x80, 0x5e, 0x81, 0x66, 0xdf, 0x77,
0x87, 0x26, 0xe3, 0xd0, 0xbd, 0xc0, 0x77, 0x99, 0xe5, 0x14, 0x8d, 0x0c, 0x14, 0x6d, 0x41, 0x2d,
0x09, 0xc1, 0x49, 0xa7, 0xc6, 0xf0, 0xe8, 0x2a, 0xf3, 0x4a, 0x85, 0xd8, 0x54, 0x41, 0x21, 0x8e,
0xc1, 0x09, 0xd5, 0x8c, 0xc8, 0x4a, 0x89, 0xfd, 0x09, 0x16, 0x16, 0x52, 0x13, 0xb0, 0x7d, 0xfb,
0x13, 0x4c, 0xd3, 0x16, 0xdb, 0x23, 0x38, 0x08, 0xa3, 0x24, 0xb2, 0xd3, 0x60, 0xea, 0xd3, 0xe0,
0x50, 0xa1, 0xd8, 0x68, 0x1b, 0x9a, 0x24, 0x34, 0x83, 0xb0, 0x37, 0xf4, 0x09, 0x53, 0x80, 0x4e,
0x93, 0xe9, 0x76, 0x26, 0x21, 0x70, 0xc9, 0x80, 0x2a, 0xf6, 0x9e, 0xe8, 0x64, 0x34, 0xd8, 0xa0,
0xe8, 0x93, 0xce, 0xc2, 0x38, 0x91, 0xcc, 0xd2, 0x9a, 0x6a, 0x16, 0x36, 0x28, 0xfa, 0xd4, 0xff,
0xa7, 0x00, 0x4d, 0x79, 0xd1, 0xd4, 0x0b, 0xf0, 0x1c, 0x28, 0xd2, 0xe4, 0xe8, 0x93, 0xb2, 0x00,
0x7b, 0xe6, 0x81, 0x83, 0x79, 0xc2, 0xc5, 0x14, 0xb9, 0x62, 0xd4, 0x38, 0x8c, 0x4d, 0x40, 0x15,
0x92, 0xb3, 0x9a, 0x59, 0x4f, 0x91, 0x2d, 0xbf, 0xca, 0x20, 0x2c, 0x30, 0xe8, 0xc0, 0x7c, 0x94,
0xab, 0x71, 0x35, 0x8e, 0x3e, 0x69, 0xcb, 0xc1, 0xc8, 0x66, 0x58, 0xb9, 0x1a, 0x47, 0x9f, 0x68,
0x1b, 0xea, 0x7c, 0xca, 0xa1, 0x19, 0x98, 0x6e, 0xa4, 0xc4, 0x2f, 0x2a, 0x1d, 0xc1, 0xfb, 0xf8,
0xf4, 0x31, 0xf5, 0x29, 0x7b, 0xa6, 0x1d, 0x18, 0x5c, 0xe8, 0x7b, 0x6c, 0x14, 0x5a, 0x85, 0x36,
0x9f, 0xe5, 0xd0, 0x76, 0xb0, 0x30, 0x87, 0x79, 0x9e, 0xb0, 0x31, 0xf8, 0x3d, 0xdb, 0xc1, 0x5c,
0xe3, 0xe3, 0x25, 0x30, 0x31, 0x57, 0xb8, 0xc2, 0x33, 0x08, 0x13, 0xf2, 0x0d, 0xe0, 0x99, 0x59,
0x2f, 0x72, 0x95, 0xdc, 0x9f, 0x73, 0x1a, 0x1f, 0x73, 0x18, 0x0b, 0x80, 0x46, 0x2e, 0x37, 0x19,
0xe0, 0xcb, 0xf1, 0x46, 0x2e, 0x35, 0x18, 0xfd, 0x1f, 0x4a, 0xb0, 0x48, 0xfd, 0x86, 0x70, 0x21,
0x33, 0xec, 0xd7, 0xd7, 0x00, 0x2c, 0x12, 0xf6, 0x24, 0x5f, 0x57, 0xb5, 0x48, 0x28, 0xbc, 0xf9,
0xb7, 0xa3, 0xed, 0xb6, 0x38, 0x3e, 0x39, 0xc8, 0xf8, 0xb1, 0xfc, 0x96, 0x7b, 0xa1, 0x6a, 0xda,
0x0d, 0x68, 0x88, 0xcc, 0x58, 0x4a, 0xe3, 0xea, 0x1c, 0xb8, 0xab, 0xf6, 0xc6, 0x73, 0xca, 0xaa,
0x5e, 0x6a, 0xdb, 0x9d, 0x9f, 0x6d, 0xdb, 0xad, 0x64, 0xb7, 0xdd, 0x7b, 0xd0, 0x92, 0x0d, 0x28,
0xf2, 0x40, 0x13, 0x2c, 0xa8, 0x29, 0x59, 0x10, 0x49, 0xef, 0x9a, 0x20, 0xed, 0x9a, 0x94, 0x0f,
0x1e, 0xc6, 0x56, 0x2f, 0x0c, 0x4c, 0x8f, 0x1c, 0xe2, 0x80, 0xed, 0xba, 0x15, 0xa3, 0x4e, 0x81,
0x0f, 0x05, 0x0c, 0xbd, 0x0d, 0xc0, 0xd6, 0xc8, 0x8b, 0x41, 0xf5, 0xf1, 0xc5, 0x20, 0xa6, 0x34,
0xac, 0x18, 0xc4, 0x98, 0xc2, 0x7e, 0xea, 0xff, 0x54, 0x80, 0xcb, 0x22, 0xab, 0x9f, 0x5d, 0xa1,
0xc6, 0x6d, 0x9c, 0xd1, 0xce, 0x53, 0x3c, 0x23, 0x4f, 0x2e, 0x4d, 0x11, 0x14, 0x96, 0x15, 0x41,
0xa1, 0x9c, 0x2b, 0xce, 0xe5, 0x72, 0xc5, 0xb8, 0x4c, 0x36, 0x3f, 0x7d, 0x99, 0x0c, 0x2d, 0x41,
0x99, 0x25, 0x30, 0x4c, 0xe8, 0x55, 0x83, 0x7f, 0x4c, 0x25, 0x0e, 0xfd, 0x77, 0x0a, 0xd0, 0xd8,
0xc7, 0x66, 0xd0, 0x3f, 0x8a, 0xf8, 0xf8, 0x66, 0xba, 0xac, 0xf8, 0xd2, 0x98, 0xb2, 0xa2, 0x34,
0xe4, 0x4b, 0x53, 0x4f, 0xa4, 0x08, 0x42, 0x3f, 0x34, 0x63, 0x2a, 0x7b, 0xde, 0xc8, 0x15, 0xb5,
0xb6, 0x16, 0x6b, 0x10, 0xa4, 0xee, 0x8e, 0x5c, 0xfd, 0xbf, 0x34, 0xa8, 0xff, 0x22, 0x9d, 0x26,
0x62, 0xcc, 0xed, 0x34, 0x63, 0x5e, 0x19, 0xc3, 0x18, 0x03, 0x87, 0x81, 0x8d, 0x8f, 0xf1, 0x97,
0xae, 0xd4, 0xfa, 0xb7, 0x1a, 0x74, 0x69, 0x26, 0x6a, 0x70, 0x87, 0x31, 0xbb, 0x75, 0xdd, 0x80,
0xc6, 0xb1, 0x14, 0x5b, 0x16, 0x98, 0x72, 0xd6, 0x8f, 0xd3, 0x99, 0xb3, 0x01, 0xed, 0xa8, 0xf2,
0x29, 0x16, 0x1b, 0xf9, 0xef, 0x57, 0x55, 0x54, 0x67, 0x88, 0x63, 0xfe, 0xaf, 0x15, 0xc8, 0x40,
0xfd, 0x37, 0x35, 0x58, 0x54, 0x74, 0x44, 0x57, 0x60, 0x5e, 0x64, 0xe9, 0x62, 0xa3, 0xe7, 0xf6,
0x6e, 0x51, 0xf1, 0x24, 0x75, 0x26, 0xdb, 0xca, 0x07, 0xac, 0x16, 0x7a, 0x01, 0x6a, 0x71, 0xce,
0x62, 0xe5, 0xe4, 0x63, 0x11, 0xd4, 0x85, 0x8a, 0x70, 0x83, 0x51, 0x32, 0x18, 0x7f, 0xeb, 0x4f,
0x00, 0xdd, 0xc7, 0xc9, 0xa6, 0x33, 0x0b, 0x47, 0x13, 0x7f, 0x93, 0x10, 0x9a, 0x76, 0x42, 0x96,
0xfe, 0xef, 0x1a, 0x2c, 0x4a, 0xd8, 0x66, 0xa9, 0xa6, 0x24, 0x1b, 0x63, 0xe1, 0x22, 0x1b, 0xa3,
0x54, 0x31, 0x28, 0x9e, 0xab, 0x62, 0x70, 0x1d, 0x20, 0xe6, 0x7f, 0xc4, 0xd1, 0x14, 0x44, 0xff,
0x2b, 0x0d, 0x2e, 0xbf, 0x67, 0x7a, 0x96, 0x7f, 0x78, 0x38, 0xbb, 0xaa, 0x6e, 0x81, 0x94, 0x3e,
0x4e, 0x5b, 0x33, 0x93, 0x73, 0xce, 0xd7, 0x60, 0x21, 0xe0, 0x3b, 0x93, 0x25, 0xeb, 0x72, 0xd1,
0x68, 0x47, 0x0d, 0xb1, 0x8e, 0xfe, 0x69, 0x01, 0x10, 0x5d, 0xf5, 0x5d, 0xd3, 0x31, 0xbd, 0x3e,
0xbe, 0x38, 0xe9, 0x2f, 0x43, 0x53, 0x8a, 0x3d, 0xe2, 0x33, 0xec, 0x74, 0xf0, 0x41, 0xd0, 0xfb,
0xd0, 0x3c, 0xe0, 0xa8, 0x7a, 0x01, 0x36, 0x89, 0xef, 0x09, 0x71, 0x28, 0xcb, 0x63, 0x0f, 0x03,
0x7b, 0x30, 0xc0, 0xc1, 0x96, 0xef, 0x59, 0x22, 0x88, 0x3e, 0x88, 0xc8, 0xa4, 0x43, 0xa9, 0x31,
0x24, 0x81, 0x58, 0x2c, 0x9c, 0x38, 0x12, 0x63, 0xac, 0x20, 0xd8, 0x74, 0x12, 0x46, 0x24, 0xbb,
0x61, 0x9b, 0x37, 0xec, 0x8f, 0xaf, 0x8e, 0x2a, 0x02, 0x23, 0xfd, 0xcf, 0x35, 0x40, 0x71, 0xa6,
0xcc, 0x6a, 0x02, 0xcc, 0xa2, 0xb3, 0x43, 0x35, 0xc5, 0xa6, 0x7c, 0x15, 0xaa, 0x56, 0x34, 0x52,
0xb8, 0xa0, 0x04, 0xc0, 0xf6, 0x48, 0x46, 0x74, 0x8f, 0x6a, 0x1e, 0xb6, 0xa2, 0x4c, 0x94, 0x03,
0x1f, 0x30, 0x98, 0x1c, 0x57, 0x95, 0xb2, 0x71, 0x55, 0xba, 0xf8, 0x57, 0x96, 0x8a, 0x7f, 0xfa,
0x4f, 0x0a, 0xd0, 0x66, 0x5b, 0xc8, 0x56, 0x52, 0xe6, 0x99, 0x8a, 0xe8, 0x1b, 0xd0, 0x10, 0x77,
0x40, 0x24, 0xc2, 0xeb, 0x4f, 0x53, 0x93, 0xa1, 0x9b, 0xb0, 0xc4, 0x3b, 0x05, 0x98, 0x8c, 0x9c,
0x24, 0x09, 0xe3, 0x59, 0x08, 0x7a, 0xca, 0xf7, 0x2e, 0xda, 0x14, 0x8d, 0x78, 0x04, 0x97, 0x07,
0x8e, 0x7f, 0x60, 0x3a, 0x3d, 0x59, 0x3c, 0x5c, 0x86, 0x53, 0x68, 0xfc, 0x12, 0x1f, 0xbe, 0x9f,
0x96, 0x21, 0x41, 0x77, 0xa1, 0x41, 0x30, 0x7e, 0x92, 0x64, 0x66, 0xe5, 0x69, 0x32, 0xb3, 0x3a,
0x1d, 0x13, 0x27, 0x66, 0xbf, 0xaf, 0x41, 0x2b, 0x53, 0xba, 0xcf, 0xd6, 0x11, 0xb4, 0x7c, 0x1d,
0xe1, 0x36, 0x94, 0xa9, 0xa7, 0xe2, 0x7b, 0x4b, 0x53, 0x9d, 0xe3, 0xca, 0xb3, 0x1a, 0x7c, 0x00,
0xda, 0x80, 0x45, 0xc5, 0x15, 0x01, 0x21, 0x7e, 0x94, 0xbf, 0x21, 0xa0, 0xff, 0xb4, 0x04, 0xb5,
0x14, 0x2b, 0x26, 0x94, 0x40, 0x9e, 0x4b, 0x09, 0x76, 0xdc, 0x91, 0x30, 0x55, 0x39, 0x17, 0xbb,
0x3c, 0x61, 0x13, 0xd9, 0xa3, 0x8b, 0x5d, 0x96, 0xae, 0xa5, 0x33, 0xb1, 0x39, 0x29, 0x13, 0xcb,
0xe4, 0xaa, 0xf3, 0x67, 0xe4, 0xaa, 0x15, 0x39, 0x57, 0x95, 0x4c, 0xa8, 0x9a, 0x35, 0xa1, 0x69,
0xab, 0x12, 0x37, 0x61, 0xb1, 0xcf, 0x4b, 0xdc, 0x77, 0x4f, 0xb7, 0xe2, 0x26, 0x11, 0x94, 0xaa,
0x9a, 0xd0, 0xbd, 0xa4, 0x50, 0xc8, 0xa5, 0xcc, 0xb3, 0x05, 0x75, 0x2a, 0x2c, 0x64, 0xc3, 0x85,
0x1c, 0x79, 0x66, 0xf6, 0x95, 0xad, 0x87, 0x34, 0x2e, 0x54, 0x0f, 0x79, 0x01, 0x6a, 0x51, 0xa4,
0x42, 0x2d, 0xbd, 0xc9, 0x9d, 0x5e, 0xe4, 0x06, 0x2c, 0x22, 0xf9, 0x81, 0x96, 0x7c, 0x08, 0x90,
0x2d, 0x24, 0xb4, 0xf3, 0x85, 0x84, 0x2b, 0x30, 0x6f, 0x93, 0xde, 0xa1, 0xf9, 0x04, 0x77, 0x16,
0x58, 0xeb, 0x9c, 0x4d, 0xee, 0x99, 0x4f, 0xb0, 0xfe, 0x2f, 0x45, 0x68, 0x26, 0x1b, 0xec, 0xd4,
0x1e, 0x64, 0x9a, 0x6b, 0x32, 0xbb, 0xd0, 0x4e, 0xe2, 0x1e, 0xc6, 0xe1, 0x33, 0x93, 0xe7, 0xec,
0xc9, 0x5a, 0x6b, 0x98, 0xb1, 0x57, 0x69, 0xbb, 0x2f, 0x9d, 0x6b, 0xbb, 0x9f, 0xf1, 0x00, 0xfd,
0x16, 0x2c, 0xc7, 0x7b, 0xaf, 0xb4, 0x6c, 0x9e, 0x60, 0x2d, 0x45, 0x8d, 0x7b, 0xe9, 0xe5, 0x8f,
0x71, 0x01, 0xf3, 0xe3, 0x5c, 0x40, 0x56, 0x05, 0x2a, 0x39, 0x15, 0xc8, 0x9f, 0xe3, 0x57, 0x15,
0xe7, 0xf8, 0xfa, 0x23, 0x58, 0x64, 0xb5, 0x5f, 0xd2, 0x0f, 0xec, 0x03, 0x1c, 0xa7, 0x00, 0xd3,
0x88, 0xb5, 0x0b, 0x95, 0x4c, 0x16, 0x11, 0x7f, 0xeb, 0x3f, 0xd6, 0xe0, 0x72, 0x7e, 0x5e, 0xa6,
0x31, 0x89, 0x23, 0xd1, 0x24, 0x47, 0xf2, 0x4b, 0xb0, 0x98, 0x8a, 0x28, 0xa5, 0x99, 0xc7, 0x44,
0xe0, 0x0a, 0xc2, 0x0d, 0x94, 0xcc, 0x11, 0xc1, 0xf4, 0x9f, 0x6a, 0x71, 0x09, 0x9d, 0xc2, 0x06,
0xec, 0x60, 0x81, 0xee, 0x6b, 0xbe, 0xe7, 0xd8, 0x5e, 0x5c, 0x29, 0x11, 0x6b, 0xe4, 0x40, 0x51,
0x29, 0x79, 0x0f, 0x5a, 0xa2, 0x53, 0xbc, 0x3d, 0x4d, 0x19, 0x90, 0x35, 0xf9, 0xb8, 0x78, 0x63,
0x7a, 0x19, 0x9a, 0xa2, 0xe2, 0x1f, 0xe1, 0x2b, 0xaa, 0xce, 0x01, 0xbe, 0x07, 0xed, 0xa8, 0xdb,
0x79, 0x37, 0xc4, 0x96, 0x18, 0x18, 0x07, 0x76, 0xbf, 0xa6, 0x41, 0x47, 0xde, 0x1e, 0x53, 0xcb,
0x3f, 0x7f, 0x78, 0xf7, 0x96, 0x7c, 0x8c, 0xfb, 0xf2, 0x19, 0xf4, 0x24, 0x78, 0xa2, 0xc3, 0xdc,
0xdf, 0x2a, 0xb0, 0x33, 0x79, 0x9a, 0xea, 0x6d, 0xdb, 0x24, 0x0c, 0xec, 0x83, 0xd1, 0x6c, 0x07,
0x8b, 0x26, 0xd4, 0xfa, 0x47, 0xb8, 0xff, 0x64, 0xe8, 0xdb, 0x89, 0x54, 0xde, 0x51, 0xd1, 0x34,
0x1e, 0xed, 0xfa, 0x56, 0x32, 0x03, 0x3f, 0xba, 0x49, 0xcf, 0xd9, 0xfd, 0x01, 0xb4, 0xb3, 0x1d,
0xd2, 0x07, 0x2f, 0x55, 0x7e, 0xf0, 0x72, 0x4b, 0x3e, 0x78, 0x99, 0x10, 0x69, 0xa4, 0xce, 0x5d,
0xfe, 0xa2, 0x00, 0x5f, 0x55, 0xd2, 0x36, 0x4b, 0x96, 0x34, 0xae, 0x8e, 0x74, 0x17, 0x2a, 0x99,
0xa4, 0xf6, 0x95, 0x33, 0xe4, 0x27, 0x6a, 0xa9, 0xbc, 0xa6, 0x47, 0x92, 0xd8, 0x2a, 0x31, 0xf8,
0xd2, 0xf8, 0x39, 0x84, 0xdd, 0x49, 0x73, 0x44, 0xe3, 0xd0, 0x1d, 0xa8, 0xf3, 0x82, 0x41, 0xef,
0xd8, 0xc6, 0x27, 0xd1, 0x79, 0xe4, 0x75, 0xa5, 0x6b, 0x66, 0xfd, 0x1e, 0xdb, 0xf8, 0xc4, 0xa8,
0x39, 0xf1, 0x6f, 0xa2, 0xff, 0x77, 0x11, 0x20, 0x69, 0xa3, 0xd9, 0x59, 0x62, 0xf3, 0xc2, 0x88,
0x53, 0x10, 0x1a, 0x4b, 0xc8, 0x91, 0x6b, 0xf4, 0x89, 0x8c, 0xe4, 0x58, 0xc1, 0xb2, 0x49, 0x28,
0xf8, 0xb2, 0x71, 0x36, 0x2d, 0x11, 0x8b, 0xa8, 0xc8, 0x84, 0xce, 0x90, 0x04, 0x82, 0xde, 0x00,
0x34, 0x08, 0xfc, 0x13, 0xdb, 0x1b, 0xa4, 0xf3, 0x0d, 0x9e, 0x96, 0x2c, 0x88, 0x96, 0x54, 0xc2,
0xf1, 0x43, 0x68, 0x67, 0xba, 0x47, 0x2c, 0xb9, 0x35, 0x81, 0x8c, 0xfb, 0xd2, 0x5c, 0x42, 0x7d,
0x5b, 0x32, 0x06, 0xd2, 0xed, 0x41, 0x3b, 0x4b, 0xaf, 0xe2, 0xec, 0xf0, 0x9b, 0xb2, 0x0a, 0x9f,
0xe5, 0x69, 0xe8, 0x34, 0x29, 0x25, 0xee, 0x9a, 0xb0, 0xa4, 0xa2, 0x44, 0x81, 0xe4, 0xc2, 0x76,
0xf2, 0x4e, 0x1c, 0xec, 0x32, 0x0e, 0x8f, 0xdb, 0x3f, 0x52, 0xb5, 0xe0, 0x82, 0x54, 0x0b, 0xd6,
0xff, 0x4e, 0x03, 0x94, 0x57, 0x6c, 0xd4, 0x84, 0x42, 0x3c, 0x49, 0x61, 0x67, 0x3b, 0xa3, 0x48,
0x85, 0x9c, 0x22, 0x5d, 0x85, 0x6a, 0xbc, 0x9f, 0x0b, 0xe7, 0x9d, 0x00, 0xd2, 0x6a, 0x56, 0x92,
0xd5, 0x2c, 0x45, 0x58, 0x59, 0x2e, 0x52, 0xdf, 0x84, 0x25, 0xc7, 0x24, 0x61, 0x8f, 0xd7, 0xc2,
0x43, 0xdb, 0xc5, 0x24, 0x34, 0xdd, 0x21, 0x0b, 0x96, 0x4b, 0x06, 0xa2, 0x6d, 0xdb, 0xb4, 0xe9,
0x61, 0xd4, 0xa2, 0x1f, 0x01, 0xca, 0x9b, 0x57, 0x1a, 0xb7, 0x26, 0xe3, 0x9e, 0xb4, 0xa6, 0x14,
0x6d, 0x45, 0x99, 0x69, 0x7f, 0x58, 0x04, 0x94, 0xc4, 0x38, 0xf1, 0x69, 0xeb, 0x34, 0x81, 0xc1,
0x06, 0x2c, 0xe6, 0x23, 0xa0, 0x28, 0xec, 0x43, 0xb9, 0xf8, 0x47, 0x15, 0xab, 0x14, 0x55, 0x77,
0x0e, 0xdf, 0x8c, 0x1d, 0x22, 0x0f, 0xe8, 0xae, 0x8f, 0x2d, 0xd5, 0xcb, 0x3e, 0xf1, 0x07, 0xd9,
0xbb, 0x8a, 0xdc, 0xc2, 0x6e, 0x2b, 0x9d, 0x57, 0x6e, 0xc9, 0x13, 0x2f, 0x2a, 0x4a, 0xa1, 0xe6,
0xdc, 0x79, 0x42, 0xcd, 0xd9, 0x6f, 0x16, 0xfe, 0x5b, 0x01, 0x16, 0x62, 0x46, 0x9e, 0x4b, 0x48,
0x93, 0x0f, 0xc6, 0x3f, 0x63, 0xa9, 0x7c, 0xac, 0x96, 0xca, 0xb7, 0xce, 0x0c, 0xf7, 0xa7, 0x15,
0xca, 0xec, 0x9c, 0xfd, 0x04, 0xe6, 0x45, 0xe1, 0x36, 0xe7, 0x28, 0xa6, 0x49, 0xa8, 0x97, 0xa0,
0x4c, 0xfd, 0x52, 0x54, 0x75, 0xe3, 0x1f, 0x9c, 0xa5, 0xe9, 0x9b, 0xab, 0xc2, 0x57, 0x34, 0xa4,
0x8b, 0xab, 0xfa, 0x7f, 0x6a, 0x00, 0xfb, 0xa7, 0x5e, 0xff, 0x0e, 0x37, 0xd2, 0x9b, 0x50, 0x9a,
0x74, 0xcf, 0x89, 0xf6, 0x66, 0xba, 0xc5, 0x7a, 0x4e, 0x21, 0x5c, 0xa9, 0x64, 0x50, 0xcc, 0x96,
0x0c, 0xc6, 0x25, 0xfb, 0xe3, 0x5d, 0xd9, 0xb7, 0xa0, 0x44, 0x03, 0x3d, 0x71, 0x4f, 0x68, 0xaa,
0x03, 0x4f, 0x36, 0x40, 0xff, 0xb4, 0x00, 0x57, 0x28, 0xf5, 0xcf, 0x27, 0x2a, 0x9c, 0x46, 0x34,
0x29, 0x6f, 0x59, 0x94, 0xbd, 0xe5, 0x6d, 0x98, 0xe7, 0xe9, 0x7e, 0x14, 0xdf, 0x5c, 0x1f, 0xc7,
0x6b, 0x2e, 0x19, 0x23, 0xea, 0x3e, 0x6b, 0xce, 0x28, 0x1d, 0xb6, 0xce, 0xcd, 0x76, 0xd8, 0x3a,
0x9f, 0x2d, 0x0a, 0xa6, 0x84, 0x56, 0x91, 0x7d, 0xfc, 0x23, 0x68, 0x18, 0x69, 0xc5, 0x43, 0x08,
0x4a, 0xa9, 0x7b, 0x85, 0xec, 0x37, 0x4b, 0xf3, 0xcc, 0xa1, 0xd9, 0xb7, 0xc3, 0x53, 0xc6, 0xce,
0xb2, 0x11, 0x7f, 0xab, 0xb5, 0x5c, 0xff, 0x5f, 0x0d, 0x2e, 0x47, 0x87, 0x7a, 0xc2, 0x86, 0x2e,
0x2e, 0xd1, 0x4d, 0x58, 0x16, 0x06, 0x93, 0xb1, 0x1c, 0x1e, 0xcc, 0x2d, 0x72, 0x98, 0xbc, 0x8c,
0x4d, 0x58, 0x0e, 0xcd, 0x60, 0x80, 0xc3, 0xec, 0x18, 0x2e, 0xef, 0x45, 0xde, 0x28, 0x8f, 0x99,
0xe6, 0x50, 0xf5, 0x05, 0x7e, 0x21, 0x47, 0xb0, 0x56, 0x98, 0x00, 0x78, 0x23, 0x57, 0xac, 0x52,
0x3f, 0x81, 0xab, 0xfc, 0x66, 0xef, 0x81, 0x4c, 0xd1, 0x4c, 0x35, 0x75, 0xe5, 0xba, 0x33, 0x1e,
0xe3, 0x0f, 0x34, 0xb8, 0x36, 0x06, 0xf3, 0x2c, 0xd9, 0xc4, 0x03, 0x25, 0xf6, 0x31, 0xb9, 0x9f,
0x84, 0x97, 0xdf, 0xa3, 0x97, 0x89, 0xfc, 0xb4, 0x04, 0x0b, 0xb9, 0x4e, 0xe7, 0xd6, 0xb9, 0xd7,
0x01, 0x51, 0x21, 0xc4, 0xaf, 0xd8, 0x58, 0x3a, 0x2d, 0xb6, 0xa6, 0xb6, 0x37, 0x72, 0xe3, 0x17,
0x6c, 0x34, 0xa3, 0x46, 0x36, 0xef, 0xcd, 0x2b, 0xea, 0xb1, 0xe4, 0x4a, 0xe3, 0x1f, 0x2b, 0xe4,
0x08, 0x5c, 0xdf, 0x1d, 0xb9, 0xbc, 0xf8, 0x2e, 0xa4, 0xcc, 0xb7, 0x1b, 0x8a, 0x4a, 0x02, 0xa3,
0x43, 0x58, 0x60, 0xd7, 0xb5, 0x46, 0xe1, 0xc0, 0xa7, 0x01, 0x3d, 0xa3, 0x8b, 0x6f, 0x6a, 0xdf,
0x99, 0x1a, 0xd3, 0x87, 0x62, 0x34, 0x25, 0x5e, 0xc4, 0xf4, 0x9e, 0x0c, 0x8d, 0xf0, 0xd8, 0x5e,
0xdf, 0x77, 0x63, 0x3c, 0x73, 0xe7, 0xc4, 0xb3, 0x23, 0x46, 0xcb, 0x78, 0xd2, 0xd0, 0xee, 0x16,
0x2c, 0x2b, 0x97, 0x3e, 0x69, 0x1b, 0x2d, 0xa7, 0xf3, 0x83, 0xbb, 0xb0, 0xa4, 0x5a, 0xd5, 0x05,
0xe6, 0xc8, 0x51, 0x7c, 0x9e, 0x39, 0xf4, 0x3f, 0x29, 0x40, 0x63, 0x1b, 0x3b, 0x38, 0xc4, 0x9f,
0xed, 0x99, 0x67, 0xee, 0x00, 0xb7, 0x98, 0x3f, 0xc0, 0xcd, 0x9d, 0x46, 0x97, 0x14, 0xa7, 0xd1,
0xd7, 0xe2, 0x43, 0x78, 0x3a, 0x4b, 0x59, 0xde, 0xa1, 0x2d, 0xf4, 0x16, 0xd4, 0x87, 0x81, 0xed,
0x9a, 0xc1, 0x69, 0xef, 0x09, 0x3e, 0x25, 0x62, 0xd3, 0xe8, 0x28, 0xb7, 0x9d, 0x9d, 0x6d, 0x62,
0xd4, 0x44, 0xef, 0xf7, 0xf1, 0x29, 0x3b, 0xe0, 0x8f, 0x93, 0x0d, 0x7e, 0x15, 0xab, 0x64, 0xa4,
0x20, 0x6b, 0x2b, 0x50, 0x8d, 0x6f, 0xbc, 0xa0, 0x0a, 0x94, 0xee, 0x8d, 0x1c, 0xa7, 0x7d, 0x09,
0x55, 0xa1, 0xcc, 0xd2, 0x91, 0xb6, 0xb6, 0xf6, 0x0b, 0x50, 0x8d, 0x4f, 0xed, 0x51, 0x0d, 0xe6,
0x1f, 0x79, 0xef, 0x7b, 0xfe, 0x89, 0xd7, 0xbe, 0x84, 0xe6, 0xa1, 0x78, 0xc7, 0x71, 0xda, 0x1a,
0x6a, 0x40, 0x75, 0x3f, 0x0c, 0xb0, 0x49, 0x65, 0xd6, 0x2e, 0xa0, 0x26, 0xc0, 0x7b, 0x36, 0x09,
0xfd, 0xc0, 0xee, 0x9b, 0x4e, 0xbb, 0xb8, 0xf6, 0x09, 0x34, 0xe5, 0x22, 0x2e, 0xaa, 0x43, 0x65,
0xd7, 0x0f, 0xdf, 0x7d, 0x66, 0x93, 0xb0, 0x7d, 0x89, 0xf6, 0xdf, 0xf5, 0xc3, 0xbd, 0x00, 0x13,
0xec, 0x85, 0x6d, 0x0d, 0x01, 0xcc, 0x7d, 0xe8, 0x6d, 0xdb, 0xe4, 0x49, 0xbb, 0x80, 0x16, 0xc5,
0xf9, 0x8c, 0xe9, 0xec, 0x88, 0xca, 0x68, 0xbb, 0x48, 0x87, 0xc7, 0x5f, 0x25, 0xd4, 0x86, 0x7a,
0xdc, 0xe5, 0xfe, 0xde, 0xa3, 0x76, 0x99, 0x52, 0xcf, 0x7f, 0xce, 0xad, 0x59, 0xd0, 0xce, 0x9e,
0x2b, 0xd2, 0x39, 0xf9, 0x22, 0x62, 0x50, 0xfb, 0x12, 0x5d, 0x99, 0x38, 0xd8, 0x6d, 0x6b, 0xa8,
0x05, 0xb5, 0xd4, 0x31, 0x69, 0xbb, 0x40, 0x01, 0xf7, 0x83, 0x61, 0x5f, 0x28, 0x14, 0x27, 0x81,
0x6a, 0xe7, 0x36, 0xe5, 0x44, 0x69, 0xed, 0x2e, 0x54, 0xa2, 0x90, 0x9f, 0x76, 0x15, 0x2c, 0xa2,
0x9f, 0xed, 0x4b, 0x68, 0x01, 0x1a, 0xd2, 0xb3, 0xa8, 0xb6, 0x86, 0x10, 0x34, 0xe5, 0x87, 0x8b,
0xed, 0xc2, 0xda, 0x26, 0x40, 0x12, 0x3a, 0x53, 0x72, 0x76, 0xbc, 0x63, 0xd3, 0xb1, 0x2d, 0x4e,
0x1b, 0x6d, 0xa2, 0xdc, 0x65, 0xdc, 0xe1, 0x86, 0xda, 0x2e, 0xac, 0xad, 0x41, 0x25, 0x0a, 0x07,
0x29, 0xdc, 0xc0, 0xae, 0x7f, 0x8c, 0xb9, 0x64, 0xf6, 0x31, 0x65, 0x65, 0x15, 0xca, 0x77, 0x5c,
0xec, 0x59, 0xed, 0xc2, 0xe6, 0x7f, 0x2c, 0x02, 0xf0, 0x53, 0x41, 0xdf, 0x0f, 0x2c, 0xe4, 0xb0,
0xdb, 0x01, 0x5b, 0xbe, 0x3b, 0xf4, 0xbd, 0xe8, 0xc8, 0x82, 0xa0, 0xf5, 0x4c, 0xaa, 0xce, 0x3f,
0xf2, 0x1d, 0x05, 0x23, 0xba, 0x2f, 0x29, 0xfb, 0x67, 0x3a, 0xeb, 0x97, 0x90, 0xcb, 0xb0, 0xd1,
0xe4, 0xf6, 0xa1, 0xdd, 0x7f, 0x12, 0x1f, 0x25, 0x8e, 0x7f, 0x3d, 0x98, 0xe9, 0x1a, 0xe1, 0xbb,
0xa1, 0xc4, 0xb7, 0x1f, 0x06, 0xb6, 0x37, 0x88, 0xf6, 0x3f, 0xfd, 0x12, 0x7a, 0x9a, 0x79, 0xbb,
0x18, 0x21, 0xdc, 0x9c, 0xe6, 0xb9, 0xe2, 0xc5, 0x50, 0x3a, 0xd0, 0xca, 0x3c, 0x12, 0x47, 0x6b,
0xea, 0x47, 0x20, 0xaa, 0x07, 0xed, 0xdd, 0xd7, 0xa6, 0xea, 0x1b, 0x63, 0xb3, 0xa1, 0x29, 0xbf,
0x6e, 0x46, 0x5f, 0x1b, 0x37, 0x41, 0xee, 0x19, 0x5a, 0x77, 0x6d, 0x9a, 0xae, 0x31, 0xaa, 0x8f,
0xb8, 0xae, 0x4e, 0x42, 0xa5, 0x7c, 0xf9, 0xd7, 0x3d, 0x2b, 0xf4, 0xd0, 0x2f, 0xa1, 0x1f, 0xd1,
0x28, 0x21, 0xf3, 0x58, 0x0e, 0xbd, 0xae, 0xde, 0xd9, 0xd4, 0x6f, 0xea, 0x26, 0x61, 0xf8, 0x28,
0x6b, 0x69, 0xe3, 0xa9, 0xcf, 0xbd, 0xc2, 0x9d, 0x9e, 0xfa, 0xd4, 0xf4, 0x67, 0x51, 0x7f, 0x6e,
0x0c, 0x0e, 0x4f, 0x98, 0x14, 0xcf, 0x74, 0xb2, 0xaa, 0x9c, 0xe4, 0x2b, 0xe3, 0xdf, 0xf4, 0x4c,
0xc2, 0x36, 0x62, 0x46, 0x9a, 0x3d, 0x0e, 0x7f, 0x63, 0x4c, 0xa1, 0x5d, 0xfd, 0x3e, 0xb0, 0xbb,
0x3e, 0x6d, 0xf7, 0xb4, 0x2e, 0xcb, 0x4f, 0xd0, 0xd4, 0x22, 0x52, 0x3e, 0x9b, 0x53, 0xeb, 0xb2,
0xfa, 0x45, 0x9b, 0x7e, 0x09, 0x3d, 0x94, 0xfc, 0x3a, 0x7a, 0x65, 0x9c, 0x2a, 0xc8, 0xf7, 0x63,
0x26, 0xf1, 0xed, 0x97, 0x01, 0x71, 0x4b, 0xf5, 0x0e, 0xed, 0xc1, 0x28, 0x30, 0xb9, 0x1a, 0x8f,
0x73, 0x6e, 0xf9, 0xae, 0x11, 0x9a, 0xaf, 0x9f, 0x63, 0x44, 0xbc, 0xa4, 0x1e, 0xc0, 0x7d, 0x1c,
0x7e, 0x80, 0xc3, 0xc0, 0xee, 0x93, 0xec, 0x8a, 0x12, 0xff, 0x2d, 0x3a, 0x44, 0xa8, 0x5e, 0x9d,
0xd8, 0x2f, 0x46, 0x70, 0x00, 0xb5, 0xfb, 0x34, 0x83, 0x62, 0x51, 0x21, 0x41, 0x63, 0x47, 0x46,
0x3d, 0x22, 0x14, 0xab, 0x93, 0x3b, 0xa6, 0x9d, 0x67, 0xe6, 0x39, 0x1e, 0x1a, 0x2b, 0xd8, 0xfc,
0x23, 0x41, 0xb5, 0xf3, 0x1c, 0xf3, 0xbe, 0x8f, 0xaf, 0x88, 0x1d, 0xf6, 0xbc, 0x87, 0x4d, 0x27,
0x3c, 0x1a, 0xb3, 0xa2, 0x54, 0x8f, 0xb3, 0x57, 0x24, 0x75, 0x8c, 0x71, 0x60, 0x58, 0xe4, 0x56,
0x28, 0xa7, 0x9e, 0x1b, 0xea, 0x29, 0xf2, 0x3d, 0xa7, 0x54, 0x3d, 0x13, 0x16, 0xb6, 0x03, 0x7f,
0x28, 0x23, 0x79, 0x43, 0x89, 0x24, 0xd7, 0x6f, 0x4a, 0x14, 0xdf, 0x87, 0x7a, 0x94, 0xe1, 0xb3,
0x9c, 0x44, 0xcd, 0x85, 0x74, 0x97, 0x29, 0x27, 0xfe, 0x18, 0x5a, 0x99, 0xd2, 0x81, 0x5a, 0xe8,
0xea, 0xfa, 0xc2, 0xa4, 0xd9, 0x4f, 0x00, 0xb1, 0x37, 0x96, 0xf2, 0x33, 0x71, 0x75, 0x7c, 0x93,
0xef, 0x18, 0x21, 0xd9, 0x98, 0xba, 0x7f, 0x2c, 0xf9, 0x5f, 0x81, 0x65, 0x65, 0x7a, 0x9e, 0x75,
0x08, 0xe2, 0x42, 0xec, 0x19, 0x35, 0x84, 0xac, 0x43, 0x38, 0x73, 0x44, 0x84, 0x7f, 0xf3, 0x5f,
0x5b, 0x50, 0x65, 0x71, 0x1e, 0x93, 0xd6, 0xcf, 0xc3, 0xbc, 0xe7, 0x1b, 0xe6, 0x7d, 0x0c, 0xad,
0xcc, 0xe3, 0x40, 0xb5, 0xd2, 0xaa, 0x5f, 0x10, 0x4e, 0x11, 0xad, 0xc8, 0xcf, 0xf3, 0xd4, 0x5b,
0xa1, 0xf2, 0x09, 0xdf, 0xa4, 0xb9, 0x1f, 0xf3, 0x77, 0xb5, 0xf1, 0x2d, 0x85, 0x57, 0xc7, 0x16,
0xef, 0xe5, 0x8b, 0xad, 0x9f, 0x7f, 0x14, 0xf4, 0xe5, 0x8e, 0x40, 0x3f, 0x86, 0x56, 0xe6, 0xe9,
0x88, 0x5a, 0x63, 0xd4, 0xef, 0x4b, 0x26, 0xcd, 0xfe, 0x33, 0x0c, 0x9e, 0x2c, 0x58, 0x54, 0xdc,
0xd4, 0x47, 0xeb, 0xe3, 0x02, 0x51, 0xf5, 0x95, 0xfe, 0xc9, 0x0b, 0x6a, 0x48, 0x66, 0x9a, 0xdd,
0x6f, 0x12, 0x22, 0xb3, 0xff, 0x2f, 0xd3, 0x7d, 0x7d, 0xba, 0x3f, 0xa3, 0x89, 0x17, 0xb4, 0x0f,
0x73, 0xfc, 0x41, 0x09, 0x7a, 0x51, 0x7d, 0x88, 0x91, 0x7a, 0x6c, 0xd2, 0x9d, 0xf4, 0x24, 0x85,
0x8c, 0x9c, 0x90, 0xb0, 0x49, 0xcb, 0xcc, 0xfb, 0x22, 0x65, 0x55, 0x3f, 0xfd, 0xb2, 0xa3, 0x3b,
0xf9, 0x31, 0x47, 0x34, 0xe9, 0xff, 0xef, 0x08, 0xf3, 0x19, 0x7b, 0x3a, 0x90, 0xbd, 0x1c, 0x83,
0xd6, 0xcf, 0x77, 0xc3, 0xa7, 0xbb, 0x31, 0x75, 0xff, 0x18, 0xf3, 0x0f, 0xa1, 0x9d, 0x3d, 0x90,
0x42, 0xaf, 0x8d, 0xd3, 0x67, 0x15, 0xce, 0x09, 0xca, 0xfc, 0x3d, 0x98, 0xe3, 0x95, 0x48, 0xb5,
0x86, 0x49, 0x55, 0xca, 0x09, 0x73, 0xdd, 0xfd, 0xc6, 0x47, 0x9b, 0x03, 0x3b, 0x3c, 0x1a, 0x1d,
0xd0, 0x96, 0x0d, 0xde, 0xf5, 0x0d, 0xdb, 0x17, 0xbf, 0x36, 0x22, 0x59, 0x6e, 0xb0, 0xd1, 0x1b,
0x0c, 0xc1, 0xf0, 0xe0, 0x60, 0x8e, 0x7d, 0xde, 0xfa, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x65,
0x0a, 0x38, 0xc2, 0xdd, 0x4f, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

79
internal/querycoordv2/job/job_load.go
View File

@ -42,10 +42,10 @@ type LoadCollectionJob struct {
dist *meta.DistributionManager
meta *meta.Meta
broker meta.Broker
cluster session.Cluster
targetMgr *meta.TargetManager
targetObserver *observers.TargetObserver
broker meta.Broker
nodeMgr *session.NodeManager
}
@ -54,10 +54,10 @@ func NewLoadCollectionJob(
req *querypb.LoadCollectionRequest,
dist *meta.DistributionManager,
meta *meta.Meta,
broker meta.Broker,
cluster session.Cluster,
targetMgr *meta.TargetManager,
targetObserver *observers.TargetObserver,
broker meta.Broker,
nodeMgr *session.NodeManager,
) *LoadCollectionJob {
return &LoadCollectionJob{
@ -66,10 +66,10 @@ func NewLoadCollectionJob(
undo: NewUndoList(ctx, meta, cluster, targetMgr, targetObserver),
dist: dist,
meta: meta,
broker: broker,
cluster: cluster,
targetMgr: targetMgr,
targetObserver: targetObserver,
broker: broker,
nodeMgr: nodeMgr,
}
}
@ -131,22 +131,6 @@ func (job *LoadCollectionJob) Execute() error {
job.undo.LackPartitions = lackPartitionIDs
log.Info("find partitions to load", zap.Int64s("partitions", lackPartitionIDs))
// 2. loadPartitions on QueryNodes
err = loadPartitions(job.ctx, job.meta, job.cluster, nil, false, req.GetCollectionID(), lackPartitionIDs...)
if err != nil {
return err
}
job.undo.PartitionsLoaded = true
// 3. update next target
_, err = job.targetObserver.UpdateNextTarget(req.GetCollectionID(), partitionIDs...)
if err != nil {
msg := "failed to update next target"
log.Error(msg, zap.Error(err))
return utils.WrapError(msg, err)
}
job.undo.TargetUpdated = true
colExisted := job.meta.CollectionManager.Exist(req.GetCollectionID())
if !colExisted {
// Clear stale replicas, https://github.com/milvus-io/milvus/issues/20444
@ -158,7 +142,7 @@ func (job *LoadCollectionJob) Execute() error {
}
}
// 4. create replica if not exist
// 2. create replica if not exist
replicas := job.meta.ReplicaManager.GetByCollection(req.GetCollectionID())
if len(replicas) == 0 {
replicas, err = utils.SpawnReplicasWithRG(job.meta, req.GetCollectionID(), req.GetResourceGroups(), req.GetReplicaNumber())
@ -174,6 +158,21 @@ func (job *LoadCollectionJob) Execute() error {
job.undo.NewReplicaCreated = true
}
// 3. loadPartitions on QueryNodes
err = loadPartitions(job.ctx, job.meta, job.cluster, job.broker, req.GetCollectionID(), lackPartitionIDs...)
if err != nil {
return err
}
// 4. update next target
_, err = job.targetObserver.UpdateNextTarget(req.GetCollectionID(), partitionIDs...)
if err != nil {
msg := "failed to update next target"
log.Error(msg, zap.Error(err))
return utils.WrapError(msg, err)
}
job.undo.TargetUpdated = true
// 5. put collection/partitions meta
partitions := lo.Map(lackPartitionIDs, func(partID int64, _ int) *meta.Partition {
return &meta.Partition{
@ -221,10 +220,10 @@ type LoadPartitionJob struct {
dist *meta.DistributionManager
meta *meta.Meta
broker meta.Broker
cluster session.Cluster
targetMgr *meta.TargetManager
targetObserver *observers.TargetObserver
broker meta.Broker
nodeMgr *session.NodeManager
}
@ -233,10 +232,10 @@ func NewLoadPartitionJob(
req *querypb.LoadPartitionsRequest,
dist *meta.DistributionManager,
meta *meta.Meta,
broker meta.Broker,
cluster session.Cluster,
targetMgr *meta.TargetManager,
targetObserver *observers.TargetObserver,
broker meta.Broker,
nodeMgr *session.NodeManager,
) *LoadPartitionJob {
return &LoadPartitionJob{
@ -245,10 +244,10 @@ func NewLoadPartitionJob(
undo: NewUndoList(ctx, meta, cluster, targetMgr, targetObserver),
dist: dist,
meta: meta,
broker: broker,
cluster: cluster,
targetMgr: targetMgr,
targetObserver: targetObserver,
broker: broker,
nodeMgr: nodeMgr,
}
}
@ -305,22 +304,7 @@ func (job *LoadPartitionJob) Execute() error {
job.undo.LackPartitions = lackPartitionIDs
log.Info("find partitions to load", zap.Int64s("partitions", lackPartitionIDs))
// 2. loadPartitions on QueryNodes
err := loadPartitions(job.ctx, job.meta, job.cluster, nil, false, req.GetCollectionID(), lackPartitionIDs...)
if err != nil {
return err
}
job.undo.PartitionsLoaded = true
// 3. update next target
_, err = job.targetObserver.UpdateNextTarget(req.GetCollectionID(), append(loadedPartitionIDs, lackPartitionIDs...)...)
if err != nil {
msg := "failed to update next target"
log.Error(msg, zap.Error(err))
return utils.WrapError(msg, err)
}
job.undo.TargetUpdated = true
var err error
if !job.meta.CollectionManager.Exist(req.GetCollectionID()) {
// Clear stale replicas, https://github.com/milvus-io/milvus/issues/20444
err = job.meta.ReplicaManager.RemoveCollection(req.GetCollectionID())
@ -331,7 +315,7 @@ func (job *LoadPartitionJob) Execute() error {
}
}
// 4. create replica if not exist
// 2. create replica if not exist
replicas := job.meta.ReplicaManager.GetByCollection(req.GetCollectionID())
if len(replicas) == 0 {
replicas, err = utils.SpawnReplicasWithRG(job.meta, req.GetCollectionID(), req.GetResourceGroups(), req.GetReplicaNumber())
@ -347,6 +331,21 @@ func (job *LoadPartitionJob) Execute() error {
job.undo.NewReplicaCreated = true
}
// 3. loadPartitions on QueryNodes
err = loadPartitions(job.ctx, job.meta, job.cluster, job.broker, req.GetCollectionID(), lackPartitionIDs...)
if err != nil {
return err
}
// 4. update next target
_, err = job.targetObserver.UpdateNextTarget(req.GetCollectionID(), append(loadedPartitionIDs, lackPartitionIDs...)...)
if err != nil {
msg := "failed to update next target"
log.Error(msg, zap.Error(err))
return utils.WrapError(msg, err)
}
job.undo.TargetUpdated = true
// 5. put collection/partitions meta
partitions := lo.Map(lackPartitionIDs, func(partID int64, _ int) *meta.Partition {
return &meta.Partition{

26
internal/querycoordv2/job/job_release.go
View File

@ -36,6 +36,8 @@ type ReleaseCollectionJob struct {
req *querypb.ReleaseCollectionRequest
dist *meta.DistributionManager
meta *meta.Meta
broker meta.Broker
cluster session.Cluster
targetMgr *meta.TargetManager
targetObserver *observers.TargetObserver
}
@ -44,6 +46,8 @@ func NewReleaseCollectionJob(ctx context.Context,
req *querypb.ReleaseCollectionRequest,
dist *meta.DistributionManager,
meta *meta.Meta,
broker meta.Broker,
cluster session.Cluster,
targetMgr *meta.TargetManager,
targetObserver *observers.TargetObserver,
) *ReleaseCollectionJob {
@ -52,6 +56,8 @@ func NewReleaseCollectionJob(ctx context.Context,
req: req,
dist: dist,
meta: meta,
broker: broker,
cluster: cluster,
targetMgr: targetMgr,
targetObserver: targetObserver,
}
@ -66,7 +72,11 @@ func (job *ReleaseCollectionJob) Execute() error {
return nil
}
lenPartitions := len(job.meta.CollectionManager.GetPartitionsByCollection(req.GetCollectionID()))
loadedPartitions := job.meta.CollectionManager.GetPartitionsByCollection(req.GetCollectionID())
toRelease := lo.Map(loadedPartitions, func(partition *meta.Partition, _ int) int64 {
return partition.GetPartitionID()
})
releasePartitions(job.ctx, job.meta, job.cluster, req.GetCollectionID(), toRelease...)
err := job.meta.CollectionManager.RemoveCollection(req.GetCollectionID())
if err != nil {
@ -85,7 +95,7 @@ func (job *ReleaseCollectionJob) Execute() error {
job.targetObserver.ReleaseCollection(req.GetCollectionID())
waitCollectionReleased(job.dist, req.GetCollectionID())
metrics.QueryCoordNumCollections.WithLabelValues().Dec()
metrics.QueryCoordNumPartitions.WithLabelValues().Sub(float64(lenPartitions))
metrics.QueryCoordNumPartitions.WithLabelValues().Sub(float64(len(toRelease)))
metrics.QueryCoordReleaseCount.WithLabelValues(metrics.TotalLabel).Inc()
metrics.QueryCoordReleaseCount.WithLabelValues(metrics.SuccessLabel).Inc()
return nil
@ -98,6 +108,7 @@ type ReleasePartitionJob struct {
req *querypb.ReleasePartitionsRequest
dist *meta.DistributionManager
meta *meta.Meta
broker meta.Broker
cluster session.Cluster
targetMgr *meta.TargetManager
targetObserver *observers.TargetObserver
@ -107,6 +118,7 @@ func NewReleasePartitionJob(ctx context.Context,
req *querypb.ReleasePartitionsRequest,
dist *meta.DistributionManager,
meta *meta.Meta,
broker meta.Broker,
cluster session.Cluster,
targetMgr *meta.TargetManager,
targetObserver *observers.TargetObserver,
@ -116,6 +128,7 @@ func NewReleasePartitionJob(ctx context.Context,
req: req,
dist: dist,
meta: meta,
broker: broker,
cluster: cluster,
targetMgr: targetMgr,
targetObserver: targetObserver,
@ -143,6 +156,7 @@ func (job *ReleasePartitionJob) Execute() error {
log.Warn("releasing partition(s) not loaded")
return nil
}
releasePartitions(job.ctx, job.meta, job.cluster, req.GetCollectionID(), toRelease...)
// If all partitions are released and LoadType is LoadPartition, clear all
if len(toRelease) == len(loadedPartitions) &&
@ -163,14 +177,8 @@ func (job *ReleasePartitionJob) Execute() error {
metrics.QueryCoordNumCollections.WithLabelValues().Dec()
waitCollectionReleased(job.dist, req.GetCollectionID())
} else {
err := releasePartitions(job.ctx, job.meta, job.cluster, false, req.GetCollectionID(), toRelease...)
err := job.meta.CollectionManager.RemovePartition(toRelease...)
if err != nil {
loadPartitions(job.ctx, job.meta, job.cluster, nil, true, req.GetCollectionID(), toRelease...)
return err
}
err = job.meta.CollectionManager.RemovePartition(toRelease...)
if err != nil {
loadPartitions(job.ctx, job.meta, job.cluster, nil, true, req.GetCollectionID(), toRelease...)
msg := "failed to release partitions from store"
log.Warn(msg, zap.Error(err))
return utils.WrapError(msg, err)

12
internal/querycoordv2/job/job_sync.go
View File

@ -20,7 +20,6 @@ import (
"context"
"time"
"github.com/cockroachdb/errors"
"go.uber.org/zap"
"github.com/milvus-io/milvus/internal/proto/querypb"
@ -35,6 +34,7 @@ type SyncNewCreatedPartitionJob struct {
req *querypb.SyncNewCreatedPartitionRequest
meta *meta.Meta
cluster session.Cluster
broker meta.Broker
}
func NewSyncNewCreatedPartitionJob(
@ -42,12 +42,14 @@ func NewSyncNewCreatedPartitionJob(
req *querypb.SyncNewCreatedPartitionRequest,
meta *meta.Meta,
cluster session.Cluster,
broker meta.Broker,
) *SyncNewCreatedPartitionJob {
return &SyncNewCreatedPartitionJob{
BaseJob: NewBaseJob(ctx, req.Base.GetMsgID(), req.GetCollectionID()),
req: req,
meta: meta,
cluster: cluster,
broker: broker,
}
}
@ -72,7 +74,7 @@ func (job *SyncNewCreatedPartitionJob) Execute() error {
zap.Int64("partitionID", req.GetPartitionID()),
)
err := loadPartitions(job.ctx, job.meta, job.cluster, req.GetSchema(), false, req.GetCollectionID(), req.GetPartitionID())
err := loadPartitions(job.ctx, job.meta, job.cluster, job.broker, req.GetCollectionID(), req.GetPartitionID())
if err != nil {
return err
}
@ -95,9 +97,3 @@ func (job *SyncNewCreatedPartitionJob) Execute() error {
return nil
}
func (job *SyncNewCreatedPartitionJob) PostExecute() {
if job.Error() != nil && !errors.Is(job.Error(), ErrPartitionNotInTarget) {
releasePartitions(job.ctx, job.meta, job.cluster, true, job.req.GetCollectionID(), job.req.GetPartitionID())
}
}

228
internal/querycoordv2/job/job_test.go
View File

@ -18,6 +18,7 @@ package job
import (
"context"
"fmt"
"testing"
"github.com/cockroachdb/errors"
@ -120,6 +121,11 @@ func (suite *JobSuite) SetupSuite() {
suite.broker.EXPECT().GetRecoveryInfoV2(mock.Anything, collection).Return(vChannels, segmentBinlogs, nil)
}
suite.broker.EXPECT().GetCollectionSchema(mock.Anything, mock.Anything).
Return(nil, nil)
suite.broker.EXPECT().DescribeIndex(mock.Anything, mock.Anything).
Return(nil, nil)
suite.cluster = session.NewMockCluster(suite.T())
suite.cluster.EXPECT().
LoadPartitions(mock.Anything, mock.Anything, mock.Anything).
@ -203,10 +209,10 @@ func (suite *JobSuite) TestLoadCollection() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -230,10 +236,10 @@ func (suite *JobSuite) TestLoadCollection() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -255,10 +261,10 @@ func (suite *JobSuite) TestLoadCollection() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -282,10 +288,10 @@ func (suite *JobSuite) TestLoadCollection() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -308,10 +314,10 @@ func (suite *JobSuite) TestLoadCollection() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -329,10 +335,10 @@ func (suite *JobSuite) TestLoadCollection() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -358,10 +364,10 @@ func (suite *JobSuite) TestLoadCollectionWithReplicas() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -390,10 +396,10 @@ func (suite *JobSuite) TestLoadCollectionWithDiffIndex() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -420,10 +426,10 @@ func (suite *JobSuite) TestLoadCollectionWithDiffIndex() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -451,10 +457,10 @@ func (suite *JobSuite) TestLoadPartition() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -481,10 +487,10 @@ func (suite *JobSuite) TestLoadPartition() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -508,10 +514,10 @@ func (suite *JobSuite) TestLoadPartition() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -535,10 +541,10 @@ func (suite *JobSuite) TestLoadPartition() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -561,10 +567,10 @@ func (suite *JobSuite) TestLoadPartition() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -577,7 +583,6 @@ func (suite *JobSuite) TestLoadPartition() {
suite.meta.ResourceManager.AddResourceGroup("rg3")
// test load 3 replica in 1 rg, should pass rg check
suite.broker.EXPECT().GetRecoveryInfoV2(mock.Anything, int64(999)).Return(nil, nil, nil)
req := &querypb.LoadPartitionsRequest{
CollectionID: 999,
PartitionIDs: []int64{888},
@ -589,10 +594,10 @@ func (suite *JobSuite) TestLoadPartition() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -600,7 +605,6 @@ func (suite *JobSuite) TestLoadPartition() {
suite.Contains(err.Error(), meta.ErrNodeNotEnough.Error())
// test load 3 replica in 3 rg, should pass rg check
suite.broker.EXPECT().GetRecoveryInfoV2(mock.Anything, int64(999)).Return(nil, nil, nil)
req = &querypb.LoadPartitionsRequest{
CollectionID: 999,
PartitionIDs: []int64{888},
@ -612,10 +616,10 @@ func (suite *JobSuite) TestLoadPartition() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -639,10 +643,10 @@ func (suite *JobSuite) TestDynamicLoad() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
return job
@ -657,10 +661,10 @@ func (suite *JobSuite) TestDynamicLoad() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
return job
@ -756,10 +760,10 @@ func (suite *JobSuite) TestLoadPartitionWithReplicas() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -789,10 +793,10 @@ func (suite *JobSuite) TestLoadPartitionWithDiffIndex() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -821,10 +825,10 @@ func (suite *JobSuite) TestLoadPartitionWithDiffIndex() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -848,6 +852,8 @@ func (suite *JobSuite) TestReleaseCollection() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
)
@ -867,6 +873,8 @@ func (suite *JobSuite) TestReleaseCollection() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
)
@ -893,6 +901,7 @@ func (suite *JobSuite) TestReleasePartition() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
@ -914,6 +923,7 @@ func (suite *JobSuite) TestReleasePartition() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
@ -937,6 +947,7 @@ func (suite *JobSuite) TestReleasePartition() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
@ -968,6 +979,7 @@ func (suite *JobSuite) TestDynamicRelease() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
@ -983,6 +995,8 @@ func (suite *JobSuite) TestDynamicRelease() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
)
@ -1076,10 +1090,10 @@ func (suite *JobSuite) TestLoadCollectionStoreFailed() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -1120,10 +1134,10 @@ func (suite *JobSuite) TestLoadPartitionStoreFailed() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -1147,10 +1161,10 @@ func (suite *JobSuite) TestLoadCreateReplicaFailed() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -1159,6 +1173,159 @@ func (suite *JobSuite) TestLoadCreateReplicaFailed() {
}
}
func (suite *JobSuite) TestCallLoadPartitionFailed() {
// call LoadPartitions failed at get index info
getIndexErr := fmt.Errorf("mock get index error")
suite.broker.ExpectedCalls = lo.Filter(suite.broker.ExpectedCalls, func(call *mock.Call, _ int) bool {
return call.Method != "DescribeIndex"
})
for _, collection := range suite.collections {
suite.broker.EXPECT().DescribeIndex(mock.Anything, collection).Return(nil, getIndexErr)
loadCollectionReq := &querypb.LoadCollectionRequest{
CollectionID: collection,
}
loadCollectionJob := NewLoadCollectionJob(
context.Background(),
loadCollectionReq,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.nodeMgr,
)
suite.scheduler.Add(loadCollectionJob)
err := loadCollectionJob.Wait()
suite.T().Logf("%s", err)
suite.ErrorIs(err, getIndexErr)
loadPartitionReq := &querypb.LoadPartitionsRequest{
CollectionID: collection,
PartitionIDs: suite.partitions[collection],
}
loadPartitionJob := NewLoadPartitionJob(
context.Background(),
loadPartitionReq,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.nodeMgr,
)
suite.scheduler.Add(loadPartitionJob)
err = loadPartitionJob.Wait()
suite.ErrorIs(err, getIndexErr)
}
// call LoadPartitions failed at get schema
getSchemaErr := fmt.Errorf("mock get schema error")
suite.broker.ExpectedCalls = lo.Filter(suite.broker.ExpectedCalls, func(call *mock.Call, _ int) bool {
return call.Method != "GetCollectionSchema"
})
for _, collection := range suite.collections {
suite.broker.EXPECT().GetCollectionSchema(mock.Anything, collection).Return(nil, getSchemaErr)
loadCollectionReq := &querypb.LoadCollectionRequest{
CollectionID: collection,
}
loadCollectionJob := NewLoadCollectionJob(
context.Background(),
loadCollectionReq,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.nodeMgr,
)
suite.scheduler.Add(loadCollectionJob)
err := loadCollectionJob.Wait()
suite.ErrorIs(err, getSchemaErr)
loadPartitionReq := &querypb.LoadPartitionsRequest{
CollectionID: collection,
PartitionIDs: suite.partitions[collection],
}
loadPartitionJob := NewLoadPartitionJob(
context.Background(),
loadPartitionReq,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.nodeMgr,
)
suite.scheduler.Add(loadPartitionJob)
err = loadPartitionJob.Wait()
suite.ErrorIs(err, getSchemaErr)
}
suite.broker.ExpectedCalls = lo.Filter(suite.broker.ExpectedCalls, func(call *mock.Call, _ int) bool {
return call.Method != "DescribeIndex" && call.Method != "GetCollectionSchema"
})
suite.broker.EXPECT().GetCollectionSchema(mock.Anything, mock.Anything).Return(nil, nil)
suite.broker.EXPECT().DescribeIndex(mock.Anything, mock.Anything).Return(nil, nil)
}
func (suite *JobSuite) TestCallReleasePartitionFailed() {
ctx := context.Background()
suite.loadAll()
releasePartitionErr := fmt.Errorf("mock release partitions error")
suite.cluster.ExpectedCalls = lo.Filter(suite.cluster.ExpectedCalls, func(call *mock.Call, _ int) bool {
return call.Method != "ReleasePartitions"
})
suite.cluster.EXPECT().ReleasePartitions(mock.Anything, mock.Anything, mock.Anything).
Return(nil, releasePartitionErr)
for _, collection := range suite.collections {
releaseCollectionReq := &querypb.ReleaseCollectionRequest{
CollectionID: collection,
}
releaseCollectionJob := NewReleaseCollectionJob(
ctx,
releaseCollectionReq,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
)
suite.scheduler.Add(releaseCollectionJob)
err := releaseCollectionJob.Wait()
suite.NoError(err)
releasePartitionReq := &querypb.ReleasePartitionsRequest{
CollectionID: collection,
PartitionIDs: suite.partitions[collection],
}
releasePartitionJob := NewReleasePartitionJob(
ctx,
releasePartitionReq,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
)
suite.scheduler.Add(releasePartitionJob)
err = releasePartitionJob.Wait()
suite.NoError(err)
}
suite.cluster.ExpectedCalls = lo.Filter(suite.cluster.ExpectedCalls, func(call *mock.Call, _ int) bool {
return call.Method != "ReleasePartitions"
})
suite.cluster.EXPECT().ReleasePartitions(mock.Anything, mock.Anything, mock.Anything).
Return(utils.WrapStatus(commonpb.ErrorCode_Success, ""), nil)
}
func (suite *JobSuite) TestSyncNewCreatedPartition() {
newPartition := int64(999)
@ -1173,6 +1340,7 @@ func (suite *JobSuite) TestSyncNewCreatedPartition() {
req,
suite.meta,
suite.cluster,
suite.broker,
)
suite.scheduler.Add(job)
err := job.Wait()
@ -1191,6 +1359,7 @@ func (suite *JobSuite) TestSyncNewCreatedPartition() {
req,
suite.meta,
suite.cluster,
suite.broker,
)
suite.scheduler.Add(job)
err = job.Wait()
@ -1206,6 +1375,7 @@ func (suite *JobSuite) TestSyncNewCreatedPartition() {
req,
suite.meta,
suite.cluster,
suite.broker,
)
suite.scheduler.Add(job)
err = job.Wait()
@ -1224,10 +1394,10 @@ func (suite *JobSuite) loadAll() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -1248,10 +1418,10 @@ func (suite *JobSuite) loadAll() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.scheduler.Add(job)
@ -1277,6 +1447,8 @@ func (suite *JobSuite) releaseAll() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
)

8
internal/querycoordv2/job/undo.go
View File

@ -25,7 +25,6 @@ import (
)
type UndoList struct {
PartitionsLoaded bool // indicates if partitions loaded in QueryNodes during loading
TargetUpdated bool // indicates if target updated during loading
NewReplicaCreated bool // indicates if created new replicas during loading
@ -51,8 +50,8 @@ func NewUndoList(ctx context.Context, meta *meta.Meta,
}
func (u *UndoList) RollBack() {
if u.PartitionsLoaded {
releasePartitions(u.ctx, u.meta, u.cluster, true, u.CollectionID, u.LackPartitions...)
if u.NewReplicaCreated {
u.meta.ReplicaManager.RemoveCollection(u.CollectionID)
}
if u.TargetUpdated {
if !u.meta.CollectionManager.Exist(u.CollectionID) {
@ -62,7 +61,4 @@ func (u *UndoList) RollBack() {
u.targetMgr.RemovePartition(u.CollectionID, u.LackPartitions...)
}
}
if u.NewReplicaCreated {
u.meta.ReplicaManager.RemoveCollection(u.CollectionID)
}
}

51
internal/querycoordv2/job/utils.go
View File

@ -18,16 +18,17 @@ package job
import (
"context"
"fmt"
"time"
"github.com/samber/lo"
"go.uber.org/zap"
"github.com/milvus-io/milvus-proto/go-api/commonpb"
"github.com/milvus-io/milvus-proto/go-api/schemapb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/querycoordv2/meta"
"github.com/milvus-io/milvus/internal/querycoordv2/session"
"github.com/milvus-io/milvus/pkg/log"
"github.com/milvus-io/milvus/pkg/util/merr"
"github.com/milvus-io/milvus/pkg/util/typeutil"
)
@ -60,30 +61,39 @@ func waitCollectionReleased(dist *meta.DistributionManager, collection int64, pa
func loadPartitions(ctx context.Context,
meta *meta.Meta,
cluster session.Cluster,
schema *schemapb.CollectionSchema,
ignoreErr bool,
broker meta.Broker,
collection int64,
partitions ...int64) error {
schema, err := broker.GetCollectionSchema(ctx, collection)
if err != nil {
return err
}
indexes, err := broker.DescribeIndex(ctx, collection)
if err != nil {
return err
}
replicas := meta.ReplicaManager.GetByCollection(collection)
loadReq := &querypb.LoadPartitionsRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_LoadPartitions,
},
CollectionID: collection,
PartitionIDs: partitions,
Schema: schema,
CollectionID: collection,
PartitionIDs: partitions,
Schema: schema,
IndexInfoList: indexes,
}
for _, replica := range replicas {
for _, node := range replica.GetNodes() {
status, err := cluster.LoadPartitions(ctx, node, loadReq)
if ignoreErr {
continue
}
// There is no need to rollback LoadPartitions as the load job will fail
// and the Delegator will not be created,
// resulting in search and query requests failing due to the absence of Delegator.
if err != nil {
return err
}
if status.GetErrorCode() != commonpb.ErrorCode_Success {
return fmt.Errorf("QueryNode failed to loadPartition, nodeID=%d, err=%s", node, status.GetReason())
if !merr.Ok(status) {
return merr.Error(status)
}
}
}
@ -93,9 +103,9 @@ func loadPartitions(ctx context.Context,
func releasePartitions(ctx context.Context,
meta *meta.Meta,
cluster session.Cluster,
ignoreErr bool,
collection int64,
partitions ...int64) error {
partitions ...int64) {
log := log.Ctx(ctx).With(zap.Int64("collection", collection), zap.Int64s("partitions", partitions))
replicas := meta.ReplicaManager.GetByCollection(collection)
releaseReq := &querypb.ReleasePartitionsRequest{
Base: &commonpb.MsgBase{
@ -107,16 +117,15 @@ func releasePartitions(ctx context.Context,
for _, replica := range replicas {
for _, node := range replica.GetNodes() {
status, err := cluster.ReleasePartitions(ctx, node, releaseReq)
if ignoreErr {
// Ignore error as the Delegator will be removed from the query node,
// causing search and query requests to fail due to the absence of Delegator.
if err != nil {
log.Warn("failed to ReleasePartitions", zap.Int64("node", node), zap.Error(err))
continue
}
if err != nil {
return err
}
if status.GetErrorCode() != commonpb.ErrorCode_Success {
return fmt.Errorf("QueryNode failed to releasePartitions, nodeID=%d, err=%s", node, status.GetReason())
if !merr.Ok(status) {
log.Warn("failed to ReleasePartitions", zap.Int64("node", node), zap.Error(merr.Error(status)))
}
}
}
return nil
}

9
internal/querycoordv2/services.go
View File

@ -234,10 +234,10 @@ func (s *Server) LoadCollection(ctx context.Context, req *querypb.LoadCollection
req,
s.dist,
s.meta,
s.broker,
s.cluster,
s.targetMgr,
s.targetObserver,
s.broker,
s.nodeMgr,
)
s.jobScheduler.Add(loadJob)
@ -272,6 +272,8 @@ func (s *Server) ReleaseCollection(ctx context.Context, req *querypb.ReleaseColl
req,
s.dist,
s.meta,
s.broker,
s.cluster,
s.targetMgr,
s.targetObserver,
)
@ -331,10 +333,10 @@ func (s *Server) LoadPartitions(ctx context.Context, req *querypb.LoadPartitions
req,
s.dist,
s.meta,
s.broker,
s.cluster,
s.targetMgr,
s.targetObserver,
s.broker,
s.nodeMgr,
)
s.jobScheduler.Add(loadJob)
@ -394,6 +396,7 @@ func (s *Server) ReleasePartitions(ctx context.Context, req *querypb.ReleasePart
req,
s.dist,
s.meta,
s.broker,
s.cluster,
s.targetMgr,
s.targetObserver,
@ -536,7 +539,7 @@ func (s *Server) SyncNewCreatedPartition(ctx context.Context, req *querypb.SyncN
return merr.Status(err), nil
}
syncJob := job.NewSyncNewCreatedPartitionJob(ctx, req, s.meta, s.cluster)
syncJob := job.NewSyncNewCreatedPartitionJob(ctx, req, s.meta, s.cluster, s.broker)
s.jobScheduler.Add(syncJob)
err := syncJob.Wait()
if err != nil && !errors.Is(err, job.ErrPartitionNotInTarget) {

21
internal/querycoordv2/services_test.go
View File

@ -317,6 +317,7 @@ func (suite *ServiceSuite) TestLoadCollection() {
// Test load all collections
for _, collection := range suite.collections {
suite.expectGetRecoverInfo(collection)
suite.expectLoadPartitions()
req := &querypb.LoadCollectionRequest{
CollectionID: collection,
@ -777,6 +778,7 @@ func (suite *ServiceSuite) TestLoadPartition() {
// Test load all partitions
for _, collection := range suite.collections {
suite.expectLoadPartitions()
suite.expectGetRecoverInfo(collection)
req := &querypb.LoadPartitionsRequest{
@ -824,8 +826,6 @@ func (suite *ServiceSuite) TestLoadPartition() {
}
// Test load with more partitions
suite.cluster.EXPECT().LoadPartitions(mock.Anything, mock.Anything, mock.Anything).
Return(utils.WrapStatus(commonpb.ErrorCode_Success, ""), nil)
for _, collection := range suite.collections {
if suite.loadTypes[collection] != querypb.LoadType_LoadPartition {
continue
@ -874,6 +874,9 @@ func (suite *ServiceSuite) TestReleaseCollection() {
ctx := context.Background()
server := suite.server
suite.cluster.EXPECT().ReleasePartitions(mock.Anything, mock.Anything, mock.Anything).
Return(merr.Status(nil), nil)
// Test release all collections
for _, collection := range suite.collections {
req := &querypb.ReleaseCollectionRequest{
@ -1563,6 +1566,7 @@ func (suite *ServiceSuite) TestHandleNodeUp() {
func (suite *ServiceSuite) loadAll() {
ctx := context.Background()
for _, collection := range suite.collections {
suite.expectLoadPartitions()
suite.expectGetRecoverInfo(collection)
if suite.loadTypes[collection] == querypb.LoadType_LoadCollection {
req := &querypb.LoadCollectionRequest{
@ -1574,10 +1578,10 @@ func (suite *ServiceSuite) loadAll() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.jobScheduler.Add(job)
@ -1598,10 +1602,10 @@ func (suite *ServiceSuite) loadAll() {
req,
suite.dist,
suite.meta,
suite.broker,
suite.cluster,
suite.targetMgr,
suite.targetObserver,
suite.broker,
suite.nodeMgr,
)
suite.jobScheduler.Add(job)
@ -1697,6 +1701,15 @@ func (suite *ServiceSuite) expectGetRecoverInfo(collection int64) {
Return(vChannels, segmentBinlogs, nil)
}
func (suite *ServiceSuite) expectLoadPartitions() {
suite.broker.EXPECT().GetCollectionSchema(mock.Anything, mock.Anything).
Return(nil, nil)
suite.broker.EXPECT().DescribeIndex(mock.Anything, mock.Anything).
Return(nil, nil)
suite.cluster.EXPECT().LoadPartitions(mock.Anything, mock.Anything, mock.Anything).
Return(utils.WrapStatus(commonpb.ErrorCode_Success, ""), nil)
}
func (suite *ServiceSuite) getAllSegments(collection int64) []int64 {
allSegments := make([]int64, 0)
for _, segments := range suite.segments[collection] {

8
internal/querycoordv2/task/task_test.go
View File

@ -31,7 +31,6 @@ import (
"github.com/milvus-io/milvus/internal/kv"
etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/querycoordv2/meta"
. "github.com/milvus-io/milvus/internal/querycoordv2/params"
@ -186,13 +185,6 @@ func (suite *TaskSuite) TestSubscribeChannelTask() {
Return(&schemapb.CollectionSchema{
Name: "TestSubscribeChannelTask",
}, nil)
suite.broker.EXPECT().DescribeIndex(mock.Anything, suite.collection).Return([]*indexpb.IndexInfo{
{
CollectionID: suite.collection,
TypeParams: []*commonpb.KeyValuePair{},
IndexParams: []*commonpb.KeyValuePair{},
},
}, nil)
for channel, segment := range suite.growingSegments {
suite.broker.EXPECT().GetSegmentInfo(mock.Anything, segment).
Return(&datapb.GetSegmentInfoResponse{Infos: []*datapb.SegmentInfo{

18
internal/querycoordv2/task/utils.go
View File

@ -20,15 +20,12 @@ import (
"context"
"time"
"go.uber.org/zap"
"github.com/milvus-io/milvus-proto/go-api/commonpb"
"github.com/milvus-io/milvus-proto/go-api/msgpb"
"github.com/milvus-io/milvus-proto/go-api/schemapb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/querycoordv2/meta"
"github.com/milvus-io/milvus/pkg/log"
"github.com/milvus-io/milvus/pkg/util/commonpbutil"
"github.com/milvus-io/milvus/pkg/util/typeutil"
)
@ -93,8 +90,8 @@ func packLoadSegmentRequest(
commonpbutil.WithMsgID(task.ID()),
),
Infos: []*querypb.SegmentLoadInfo{loadInfo},
Schema: schema,
LoadMeta: loadMeta,
Schema: schema, // assign it for compatibility of rolling upgrade from 2.2.x to 2.3
LoadMeta: loadMeta, // assign it for compatibility of rolling upgrade from 2.2.x to 2.3
CollectionID: task.CollectionID(),
ReplicaID: task.ReplicaID(),
DeltaPositions: []*msgpb.MsgPosition{loadInfo.GetDeltaPosition()}, // assign it for compatibility of rolling upgrade from 2.2.x to 2.3
@ -143,8 +140,8 @@ func packSubChannelRequest(
NodeID: action.Node(),
CollectionID: task.CollectionID(),
Infos: []*datapb.VchannelInfo{channel.VchannelInfo},
Schema: schema,
LoadMeta: loadMeta,
Schema: schema, // assign it for compatibility of rolling upgrade from 2.2.x to 2.3
LoadMeta: loadMeta, // assign it for compatibility of rolling upgrade from 2.2.x to 2.3
ReplicaID: task.ReplicaID(),
Version: time.Now().UnixNano(),
}
@ -155,13 +152,6 @@ func fillSubChannelRequest(
req *querypb.WatchDmChannelsRequest,
broker meta.Broker,
) error {
indexes, err := broker.DescribeIndex(ctx, req.GetCollectionID())
if err != nil {
log.Warn("fail to get index meta when fillSubChannelRequest",
zap.Int64("collectionId", req.GetCollectionID()))
} else {
req.IndexInfoList = indexes
}
segmentIDs := typeutil.NewUniqueSet()
for _, vchannel := range req.GetInfos() {
segmentIDs.Insert(vchannel.GetFlushedSegmentIds()...)

4
internal/querynodev2/segments/collection.go
View File

@ -26,6 +26,8 @@ import "C"
import (
"github.com/milvus-io/milvus/internal/proto/segcorepb"
"github.com/milvus-io/milvus/pkg/log"
"go.uber.org/zap"
"sync"
"unsafe"
@ -106,11 +108,13 @@ func (c *Collection) AddPartition(partitions ...int64) {
for i := range partitions {
c.partitions.Insert(partitions[i])
}
log.Info("add partitions", zap.Int64("collection", c.ID()), zap.Int64s("partitions", partitions))
}
// removePartitionID removes the partition id from partition id list of collection
func (c *Collection) RemovePartition(partitionID int64) {
c.partitions.Remove(partitionID)
log.Info("remove partition", zap.Int64("collection", c.ID()), zap.Int64("partition", partitionID))
}
// getLoadType get the loadType of collection, which is loadTypeCollection or loadTypePartition

56
internal/querynodev2/services.go
View File

@ -220,32 +220,6 @@ func (node *QueryNode) WatchDmChannels(ctx context.Context, req *querypb.WatchDm
log.Info("channel already subscribed")
return util.SuccessStatus(), nil
}
fieldIndexMetas := make([]*segcorepb.FieldIndexMeta, 0)
for _, info := range req.GetIndexInfoList() {
fieldIndexMetas = append(fieldIndexMetas, &segcorepb.FieldIndexMeta{
CollectionID: info.GetCollectionID(),
FieldID: info.GetFieldID(),
IndexName: info.GetIndexName(),
TypeParams: info.GetTypeParams(),
IndexParams: info.GetIndexParams(),
IsAutoIndex: info.GetIsAutoIndex(),
UserIndexParams: info.GetUserIndexParams(),
})
}
sizePerRecord, err := typeutil.EstimateSizePerRecord(req.Schema)
maxIndexRecordPerSegment := int64(0)
if err != nil || sizePerRecord == 0 {
log.Warn("failed to transfer segment size to collection, because failed to estimate size per record", zap.Error(err))
} else {
threshold := paramtable.Get().DataCoordCfg.SegmentMaxSize.GetAsFloat() * 1024 * 1024
proportion := paramtable.Get().DataCoordCfg.SegmentSealProportion.GetAsFloat()
maxIndexRecordPerSegment = int64(threshold * proportion / float64(sizePerRecord))
}
node.manager.Collection.Put(req.GetCollectionID(), req.GetSchema(), &segcorepb.CollectionIndexMeta{
IndexMetas: fieldIndexMetas,
MaxIndexRowCount: maxIndexRecordPerSegment,
}, req.GetLoadMeta())
delegator, err := delegator.NewShardDelegator(req.GetCollectionID(), req.GetReplicaID(), channel.GetChannelName(), req.GetVersion(),
node.clusterManager, node.manager, node.tSafeManager, node.loader, node.factory, channel.GetSeekPosition().GetTimestamp())
if err != nil {
@ -387,7 +361,31 @@ func (node *QueryNode) LoadPartitions(ctx context.Context, req *querypb.LoadPart
if req.GetSchema() == nil {
return merr.Status(merr.WrapErrCollectionNotLoaded(req.GetCollectionID(), "failed to load partitions")), nil
}
node.manager.Collection.Put(req.GetCollectionID(), req.GetSchema(), nil, &querypb.LoadMetaInfo{
fieldIndexMetas := make([]*segcorepb.FieldIndexMeta, 0)
for _, info := range req.GetIndexInfoList() {
fieldIndexMetas = append(fieldIndexMetas, &segcorepb.FieldIndexMeta{
CollectionID: info.GetCollectionID(),
FieldID: info.GetFieldID(),
IndexName: info.GetIndexName(),
TypeParams: info.GetTypeParams(),
IndexParams: info.GetIndexParams(),
IsAutoIndex: info.GetIsAutoIndex(),
UserIndexParams: info.GetUserIndexParams(),
})
}
sizePerRecord, err := typeutil.EstimateSizePerRecord(req.Schema)
maxIndexRecordPerSegment := int64(0)
if err != nil || sizePerRecord == 0 {
log.Warn("failed to transfer segment size to collection, because failed to estimate size per record", zap.Error(err))
} else {
threshold := paramtable.Get().DataCoordCfg.SegmentMaxSize.GetAsFloat() * 1024 * 1024
proportion := paramtable.Get().DataCoordCfg.SegmentSealProportion.GetAsFloat()
maxIndexRecordPerSegment = int64(threshold * proportion / float64(sizePerRecord))
}
node.manager.Collection.Put(req.GetCollectionID(), req.GetSchema(), &segcorepb.CollectionIndexMeta{
IndexMetas: fieldIndexMetas,
MaxIndexRowCount: maxIndexRecordPerSegment,
}, &querypb.LoadMetaInfo{
CollectionID: req.GetCollectionID(),
PartitionIDs: req.GetPartitionIDs(),
LoadType: querypb.LoadType_LoadCollection, // TODO: dyh, remove loadType in querynode
@ -430,8 +428,6 @@ func (node *QueryNode) LoadSegments(ctx context.Context, req *querypb.LoadSegmen
return node.loadDeltaLogs(ctx, req), nil
}
node.manager.Collection.Put(req.GetCollectionID(), req.GetSchema(), nil, req.GetLoadMeta())
// Delegates request to workers
if req.GetNeedTransfer() {
delegator, ok := node.delegators.Get(segment.GetInsertChannel())
@ -1060,8 +1056,6 @@ func (node *QueryNode) SyncDistribution(ctx context.Context, req *querypb.SyncDi
commonpbutil.WithMsgID(req.Base.GetMsgID()),
),
Infos: infos,
Schema: req.GetSchema(),
LoadMeta: req.GetLoadMeta(),
CollectionID: req.GetCollectionID(),
ReplicaID: req.GetReplicaID(),
DstNodeID: nodeID,

41
internal/querynodev2/services_test.go
View File

@ -124,6 +124,15 @@ func (suite *ServiceSuite) SetupTest() {
// start node
err = suite.node.Start()
suite.NoError(err)
// init collection
schema := segments.GenTestCollectionSchema(suite.collectionName, schemapb.DataType_Int64)
LoadMeta := &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: suite.collectionID,
PartitionIDs: suite.partitionIDs,
}
suite.node.manager.Collection.Put(suite.collectionID, schema, nil, LoadMeta)
}
func (suite *ServiceSuite) TearDownTest() {
@ -223,7 +232,6 @@ func (suite *ServiceSuite) TestWatchDmChannelsInt64() {
ctx := context.Background()
// data
schema := segments.GenTestCollectionSchema(suite.collectionName, schemapb.DataType_Int64)
req := &querypb.WatchDmChannelsRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_WatchDmChannels,
@ -233,7 +241,6 @@ func (suite *ServiceSuite) TestWatchDmChannelsInt64() {
NodeID: suite.node.session.ServerID,
CollectionID: suite.collectionID,
PartitionIDs: suite.partitionIDs,
Schema: schema,
Infos: []*datapb.VchannelInfo{
{
CollectionID: suite.collectionID,
@ -243,11 +250,6 @@ func (suite *ServiceSuite) TestWatchDmChannelsInt64() {
DroppedSegmentIds: suite.droppedSegmentIDs,
},
},
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: suite.collectionID,
PartitionIDs: suite.partitionIDs,
},
}
// mocks
@ -272,7 +274,6 @@ func (suite *ServiceSuite) TestWatchDmChannelsVarchar() {
ctx := context.Background()
// data
schema := segments.GenTestCollectionSchema(suite.collectionName, schemapb.DataType_VarChar)
req := &querypb.WatchDmChannelsRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_WatchDmChannels,
@ -282,7 +283,6 @@ func (suite *ServiceSuite) TestWatchDmChannelsVarchar() {
NodeID: suite.node.session.ServerID,
CollectionID: suite.collectionID,
PartitionIDs: suite.partitionIDs,
Schema: schema,
Infos: []*datapb.VchannelInfo{
{
CollectionID: suite.collectionID,
@ -292,11 +292,6 @@ func (suite *ServiceSuite) TestWatchDmChannelsVarchar() {
DroppedSegmentIds: suite.droppedSegmentIDs,
},
},
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: suite.collectionID,
PartitionIDs: suite.partitionIDs,
},
}
// mocks
@ -321,7 +316,6 @@ func (suite *ServiceSuite) TestWatchDmChannels_Failed() {
ctx := context.Background()
// data
schema := segments.GenTestCollectionSchema(suite.collectionName, schemapb.DataType_Int64)
req := &querypb.WatchDmChannelsRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_WatchDmChannels,
@ -331,7 +325,6 @@ func (suite *ServiceSuite) TestWatchDmChannels_Failed() {
NodeID: suite.node.session.ServerID,
CollectionID: suite.collectionID,
PartitionIDs: suite.partitionIDs,
Schema: schema,
Infos: []*datapb.VchannelInfo{
{
CollectionID: suite.collectionID,
@ -476,7 +469,6 @@ func (suite *ServiceSuite) TestLoadSegments_Int64() {
},
CollectionID: suite.collectionID,
DstNodeID: suite.node.session.ServerID,
Schema: schema,
Infos: suite.genSegmentLoadInfos(schema),
DeltaPositions: []*msgpb.MsgPosition{{Timestamp: 20000}},
NeedTransfer: true,
@ -493,6 +485,13 @@ func (suite *ServiceSuite) TestLoadSegments_VarChar() {
suite.TestWatchDmChannelsVarchar()
// data
schema := segments.GenTestCollectionSchema(suite.collectionName, schemapb.DataType_VarChar)
LoadMeta := &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: suite.collectionID,
PartitionIDs: suite.partitionIDs,
}
suite.node.manager.Collection = segments.NewCollectionManager()
suite.node.manager.Collection.Put(suite.collectionID, schema, nil, LoadMeta)
req := &querypb.LoadSegmentsRequest{
Base: &commonpb.MsgBase{
MsgID: rand.Int63(),
@ -500,7 +499,6 @@ func (suite *ServiceSuite) TestLoadSegments_VarChar() {
},
CollectionID: suite.collectionID,
DstNodeID: suite.node.session.ServerID,
Schema: schema,
Infos: suite.genSegmentLoadInfos(schema),
DeltaPositions: []*msgpb.MsgPosition{{Timestamp: 20000}},
NeedTransfer: true,
@ -524,7 +522,6 @@ func (suite *ServiceSuite) TestLoadDeltaInt64() {
},
CollectionID: suite.collectionID,
DstNodeID: suite.node.session.ServerID,
Schema: schema,
Infos: suite.genSegmentLoadInfos(schema),
NeedTransfer: true,
LoadScope: querypb.LoadScope_Delta,
@ -548,7 +545,6 @@ func (suite *ServiceSuite) TestLoadDeltaVarchar() {
},
CollectionID: suite.collectionID,
DstNodeID: suite.node.session.ServerID,
Schema: schema,
Infos: suite.genSegmentLoadInfos(schema),
NeedTransfer: true,
LoadScope: querypb.LoadScope_Delta,
@ -571,7 +567,6 @@ func (suite *ServiceSuite) TestLoadSegments_Failed() {
},
CollectionID: suite.collectionID,
DstNodeID: suite.node.session.ServerID,
Schema: schema,
Infos: suite.genSegmentLoadInfos(schema),
NeedTransfer: true,
}
@ -613,7 +608,6 @@ func (suite *ServiceSuite) TestLoadSegments_Transfer() {
},
CollectionID: suite.collectionID,
DstNodeID: suite.node.session.ServerID,
Schema: schema,
Infos: suite.genSegmentLoadInfos(schema),
NeedTransfer: true,
}
@ -634,7 +628,6 @@ func (suite *ServiceSuite) TestLoadSegments_Transfer() {
},
CollectionID: suite.collectionID,
DstNodeID: suite.node.session.ServerID,
Schema: schema,
Infos: suite.genSegmentLoadInfos(schema),
NeedTransfer: true,
}
@ -660,7 +653,6 @@ func (suite *ServiceSuite) TestLoadSegments_Transfer() {
},
CollectionID: suite.collectionID,
DstNodeID: suite.node.session.ServerID,
Schema: schema,
Infos: suite.genSegmentLoadInfos(schema),
NeedTransfer: true,
}
@ -1425,6 +1417,7 @@ func (suite *ServiceSuite) TestLoadPartition() {
suite.node.UpdateStateCode(commonpb.StateCode_Healthy)
// collection not exist and schema is nil
suite.node.manager.Collection = segments.NewCollectionManager()
status, err = suite.node.LoadPartitions(ctx, req)
suite.NoError(err)
suite.Equal(commonpb.ErrorCode_UnexpectedError, status.GetErrorCode())

11
internal/rootcoord/broker.go
View File

@ -121,21 +121,10 @@ func (b *ServerBroker) ReleasePartitions(ctx context.Context, collectionID Uniqu
func (b *ServerBroker) SyncNewCreatedPartition(ctx context.Context, collectionID UniqueID, partitionID UniqueID) error {
log := log.Ctx(ctx).With(zap.Int64("collection", collectionID), zap.Int64("partitionID", partitionID))
log.Info("begin to sync new partition")
collection, err := b.s.meta.GetCollectionByID(ctx, collectionID, typeutil.MaxTimestamp, false)
if err != nil {
return err
}
schema := &schemapb.CollectionSchema{
Name: collection.Name,
Description: collection.Description,
AutoID: collection.AutoID,
Fields: model.MarshalFieldModels(collection.Fields),
}
resp, err := b.s.queryCoord.SyncNewCreatedPartition(ctx, &querypb.SyncNewCreatedPartitionRequest{
Base: commonpbutil.NewMsgBase(commonpbutil.WithMsgType(commonpb.MsgType_ReleasePartitions)),
CollectionID: collectionID,
PartitionID: partitionID,
Schema: schema,
})
if err != nil {
return err