admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-01-07 19:31:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

use dataservice's getRecoveryInfo to get load and watch info (#5790)

Browse Source 
Signed-off-by: xige-16 <xi.ge@zilliz.com>
This commit is contained in:
xige-16 2021-06-16 11:09:56 +08:00 committed by GitHub
parent 587ccc0557
commit 97049ce293
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 205 additions and 578 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
internal/proto/query_service.proto
View File

@ -8,6 +8,7 @@ import "common.proto";
import "milvus.proto";
import "internal.proto";
import "schema.proto";
import "data_service.proto";
service QueryService {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
@ -196,9 +197,9 @@ message WatchDmChannelsRequest {
int64 nodeID = 2;
int64 collectionID = 3;
int64 partitionID = 4;
repeated VchannelInfo infos = 5;
repeated data.VchannelInfo infos = 5;
schema.CollectionSchema schema = 6;
repeated CheckPoint exclude_infos = 7;
repeated data.SegmentInfo exclude_infos = 7;
}
enum TriggerCondition {
@ -220,7 +221,7 @@ message SegmentLoadInfo {
int64 collectionID = 3;
int64 dbID = 4;
int64 flush_time = 5;
repeated FieldBinlog binlog_paths = 6;
repeated data.FieldBinlog binlog_paths = 6;
}
message LoadSegmentsRequest {
@ -288,41 +289,4 @@ message LoadBalanceSegments {
repeated LoadBalanceSegmentInfo infos = 2;
}
//--------------temp used, delete after data_service.proto update-----
message CheckPoint {
int64 segmentID = 1;
internal.MsgPosition position = 2;
int64 num_of_rows = 3;
}
message VchannelInfo {
int64 collectionID = 1;
string channelName = 2;
internal.MsgPosition seek_position = 3;
repeated CheckPoint checkPoints = 4;
repeated int64 flushedSegments = 5;
}
message SegmentBinlogs {
int64 segmentID = 1;
repeated FieldBinlog fieldBinlogs = 2;
}
message FieldBinlog{
int64 fieldID = 1;
repeated string binlogs = 2;
}
message GetRecoveryInfoResponse {
common.MsgBase base = 1;
repeated VchannelInfo channels = 2;
repeated SegmentBinlogs binlogs = 3;
}
message GetRecoveryInfoRequest {
common.MsgBase base = 1;
int64 collectionID = 2;
int64 partitionID = 3;
}

614
internal/proto/querypb/query_service.pb.go
View File

@ -8,6 +8,7 @@ import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
commonpb "github.com/milvus-io/milvus/internal/proto/commonpb"
datapb "github.com/milvus-io/milvus/internal/proto/datapb"
internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"
milvuspb "github.com/milvus-io/milvus/internal/proto/milvuspb"
schemapb "github.com/milvus-io/milvus/internal/proto/schemapb"
@ -1281,9 +1282,9 @@ type WatchDmChannelsRequest struct {
NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
PartitionID int64 `protobuf:"varint,4,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
Infos []*VchannelInfo `protobuf:"bytes,5,rep,name=infos,proto3" json:"infos,omitempty"`
Infos []*datapb.VchannelInfo `protobuf:"bytes,5,rep,name=infos,proto3" json:"infos,omitempty"`
Schema *schemapb.CollectionSchema `protobuf:"bytes,6,opt,name=schema,proto3" json:"schema,omitempty"`
ExcludeInfos []*CheckPoint `protobuf:"bytes,7,rep,name=exclude_infos,json=excludeInfos,proto3" json:"exclude_infos,omitempty"`
ExcludeInfos []*datapb.SegmentInfo `protobuf:"bytes,7,rep,name=exclude_infos,json=excludeInfos,proto3" json:"exclude_infos,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1342,7 +1343,7 @@ func (m *WatchDmChannelsRequest) GetPartitionID() int64 {
return 0
}
func (m *WatchDmChannelsRequest) GetInfos() []*VchannelInfo {
func (m *WatchDmChannelsRequest) GetInfos() []*datapb.VchannelInfo {
if m != nil {
return m.Infos
}
@ -1356,7 +1357,7 @@ func (m *WatchDmChannelsRequest) GetSchema() *schemapb.CollectionSchema {
return nil
}
func (m *WatchDmChannelsRequest) GetExcludeInfos() []*CheckPoint {
func (m *WatchDmChannelsRequest) GetExcludeInfos() []*datapb.SegmentInfo {
if m != nil {
return m.ExcludeInfos
}
@ -1365,15 +1366,15 @@ func (m *WatchDmChannelsRequest) GetExcludeInfos() []*CheckPoint {
//used for handoff task
type SegmentLoadInfo struct {
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
PartitionID int64 `protobuf:"varint,2,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
DbID int64 `protobuf:"varint,4,opt,name=dbID,proto3" json:"dbID,omitempty"`
FlushTime int64 `protobuf:"varint,5,opt,name=flush_time,json=flushTime,proto3" json:"flush_time,omitempty"`
BinlogPaths []*FieldBinlog `protobuf:"bytes,6,rep,name=binlog_paths,json=binlogPaths,proto3" json:"binlog_paths,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
PartitionID int64 `protobuf:"varint,2,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
DbID int64 `protobuf:"varint,4,opt,name=dbID,proto3" json:"dbID,omitempty"`
FlushTime int64 `protobuf:"varint,5,opt,name=flush_time,json=flushTime,proto3" json:"flush_time,omitempty"`
BinlogPaths []*datapb.FieldBinlog `protobuf:"bytes,6,rep,name=binlog_paths,json=binlogPaths,proto3" json:"binlog_paths,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SegmentLoadInfo) Reset() { *m = SegmentLoadInfo{} }
@ -1436,7 +1437,7 @@ func (m *SegmentLoadInfo) GetFlushTime() int64 {
return 0
}
func (m *SegmentLoadInfo) GetBinlogPaths() []*FieldBinlog {
func (m *SegmentLoadInfo) GetBinlogPaths() []*datapb.FieldBinlog {
if m != nil {
return m.BinlogPaths
}
@ -1947,337 +1948,6 @@ func (m *LoadBalanceSegments) GetInfos() []*LoadBalanceSegmentInfo {
return nil
}
//--------------temp used, delete after data_service.proto update-----
type CheckPoint struct {
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
Position *internalpb.MsgPosition `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"`
NumOfRows int64 `protobuf:"varint,3,opt,name=num_of_rows,json=numOfRows,proto3" json:"num_of_rows,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CheckPoint) Reset() { *m = CheckPoint{} }
func (m *CheckPoint) String() string { return proto.CompactTextString(m) }
func (*CheckPoint) ProtoMessage() {}
func (*CheckPoint) Descriptor() ([]byte, []int) {
return fileDescriptor_5fcb6756dc1afb8d, []int{30}
}
func (m *CheckPoint) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CheckPoint.Unmarshal(m, b)
}
func (m *CheckPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CheckPoint.Marshal(b, m, deterministic)
}
func (m *CheckPoint) XXX_Merge(src proto.Message) {
xxx_messageInfo_CheckPoint.Merge(m, src)
}
func (m *CheckPoint) XXX_Size() int {
return xxx_messageInfo_CheckPoint.Size(m)
}
func (m *CheckPoint) XXX_DiscardUnknown() {
xxx_messageInfo_CheckPoint.DiscardUnknown(m)
}
var xxx_messageInfo_CheckPoint proto.InternalMessageInfo
func (m *CheckPoint) GetSegmentID() int64 {
if m != nil {
return m.SegmentID
}
return 0
}
func (m *CheckPoint) GetPosition() *internalpb.MsgPosition {
if m != nil {
return m.Position
}
return nil
}
func (m *CheckPoint) GetNumOfRows() int64 {
if m != nil {
return m.NumOfRows
}
return 0
}
type VchannelInfo struct {
CollectionID int64 `protobuf:"varint,1,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
ChannelName string `protobuf:"bytes,2,opt,name=channelName,proto3" json:"channelName,omitempty"`
SeekPosition *internalpb.MsgPosition `protobuf:"bytes,3,opt,name=seek_position,json=seekPosition,proto3" json:"seek_position,omitempty"`
CheckPoints []*CheckPoint `protobuf:"bytes,4,rep,name=checkPoints,proto3" json:"checkPoints,omitempty"`
FlushedSegments []int64 `protobuf:"varint,5,rep,packed,name=flushedSegments,proto3" json:"flushedSegments,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *VchannelInfo) Reset() { *m = VchannelInfo{} }
func (m *VchannelInfo) String() string { return proto.CompactTextString(m) }
func (*VchannelInfo) ProtoMessage() {}
func (*VchannelInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_5fcb6756dc1afb8d, []int{31}
}
func (m *VchannelInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_VchannelInfo.Unmarshal(m, b)
}
func (m *VchannelInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_VchannelInfo.Marshal(b, m, deterministic)
}
func (m *VchannelInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_VchannelInfo.Merge(m, src)
}
func (m *VchannelInfo) XXX_Size() int {
return xxx_messageInfo_VchannelInfo.Size(m)
}
func (m *VchannelInfo) XXX_DiscardUnknown() {
xxx_messageInfo_VchannelInfo.DiscardUnknown(m)
}
var xxx_messageInfo_VchannelInfo proto.InternalMessageInfo
func (m *VchannelInfo) GetCollectionID() int64 {
if m != nil {
return m.CollectionID
}
return 0
}
func (m *VchannelInfo) GetChannelName() string {
if m != nil {
return m.ChannelName
}
return ""
}
func (m *VchannelInfo) GetSeekPosition() *internalpb.MsgPosition {
if m != nil {
return m.SeekPosition
}
return nil
}
func (m *VchannelInfo) GetCheckPoints() []*CheckPoint {
if m != nil {
return m.CheckPoints
}
return nil
}
func (m *VchannelInfo) GetFlushedSegments() []int64 {
if m != nil {
return m.FlushedSegments
}
return nil
}
type SegmentBinlogs struct {
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
FieldBinlogs []*FieldBinlog `protobuf:"bytes,2,rep,name=fieldBinlogs,proto3" json:"fieldBinlogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SegmentBinlogs) Reset() { *m = SegmentBinlogs{} }
func (m *SegmentBinlogs) String() string { return proto.CompactTextString(m) }
func (*SegmentBinlogs) ProtoMessage() {}
func (*SegmentBinlogs) Descriptor() ([]byte, []int) {
return fileDescriptor_5fcb6756dc1afb8d, []int{32}
}
func (m *SegmentBinlogs) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SegmentBinlogs.Unmarshal(m, b)
}
func (m *SegmentBinlogs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SegmentBinlogs.Marshal(b, m, deterministic)
}
func (m *SegmentBinlogs) XXX_Merge(src proto.Message) {
xxx_messageInfo_SegmentBinlogs.Merge(m, src)
}
func (m *SegmentBinlogs) XXX_Size() int {
return xxx_messageInfo_SegmentBinlogs.Size(m)
}
func (m *SegmentBinlogs) XXX_DiscardUnknown() {
xxx_messageInfo_SegmentBinlogs.DiscardUnknown(m)
}
var xxx_messageInfo_SegmentBinlogs proto.InternalMessageInfo
func (m *SegmentBinlogs) GetSegmentID() int64 {
if m != nil {
return m.SegmentID
}
return 0
}
func (m *SegmentBinlogs) GetFieldBinlogs() []*FieldBinlog {
if m != nil {
return m.FieldBinlogs
}
return nil
}
type FieldBinlog struct {
FieldID int64 `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"`
Binlogs []string `protobuf:"bytes,2,rep,name=binlogs,proto3" json:"binlogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FieldBinlog) Reset() { *m = FieldBinlog{} }
func (m *FieldBinlog) String() string { return proto.CompactTextString(m) }
func (*FieldBinlog) ProtoMessage() {}
func (*FieldBinlog) Descriptor() ([]byte, []int) {
return fileDescriptor_5fcb6756dc1afb8d, []int{33}
}
func (m *FieldBinlog) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FieldBinlog.Unmarshal(m, b)
}
func (m *FieldBinlog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FieldBinlog.Marshal(b, m, deterministic)
}
func (m *FieldBinlog) XXX_Merge(src proto.Message) {
xxx_messageInfo_FieldBinlog.Merge(m, src)
}
func (m *FieldBinlog) XXX_Size() int {
return xxx_messageInfo_FieldBinlog.Size(m)
}
func (m *FieldBinlog) XXX_DiscardUnknown() {
xxx_messageInfo_FieldBinlog.DiscardUnknown(m)
}
var xxx_messageInfo_FieldBinlog proto.InternalMessageInfo
func (m *FieldBinlog) GetFieldID() int64 {
if m != nil {
return m.FieldID
}
return 0
}
func (m *FieldBinlog) GetBinlogs() []string {
if m != nil {
return m.Binlogs
}
return nil
}
type GetRecoveryInfoResponse struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
Channels []*VchannelInfo `protobuf:"bytes,2,rep,name=channels,proto3" json:"channels,omitempty"`
Binlogs []*SegmentBinlogs `protobuf:"bytes,3,rep,name=binlogs,proto3" json:"binlogs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetRecoveryInfoResponse) Reset() { *m = GetRecoveryInfoResponse{} }
func (m *GetRecoveryInfoResponse) String() string { return proto.CompactTextString(m) }
func (*GetRecoveryInfoResponse) ProtoMessage() {}
func (*GetRecoveryInfoResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_5fcb6756dc1afb8d, []int{34}
}
func (m *GetRecoveryInfoResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetRecoveryInfoResponse.Unmarshal(m, b)
}
func (m *GetRecoveryInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetRecoveryInfoResponse.Marshal(b, m, deterministic)
}
func (m *GetRecoveryInfoResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetRecoveryInfoResponse.Merge(m, src)
}
func (m *GetRecoveryInfoResponse) XXX_Size() int {
return xxx_messageInfo_GetRecoveryInfoResponse.Size(m)
}
func (m *GetRecoveryInfoResponse) XXX_DiscardUnknown() {
xxx_messageInfo_GetRecoveryInfoResponse.DiscardUnknown(m)
}
var xxx_messageInfo_GetRecoveryInfoResponse proto.InternalMessageInfo
func (m *GetRecoveryInfoResponse) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *GetRecoveryInfoResponse) GetChannels() []*VchannelInfo {
if m != nil {
return m.Channels
}
return nil
}
func (m *GetRecoveryInfoResponse) GetBinlogs() []*SegmentBinlogs {
if m != nil {
return m.Binlogs
}
return nil
}
type GetRecoveryInfoRequest 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"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetRecoveryInfoRequest) Reset() { *m = GetRecoveryInfoRequest{} }
func (m *GetRecoveryInfoRequest) String() string { return proto.CompactTextString(m) }
func (*GetRecoveryInfoRequest) ProtoMessage() {}
func (*GetRecoveryInfoRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_5fcb6756dc1afb8d, []int{35}
}
func (m *GetRecoveryInfoRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetRecoveryInfoRequest.Unmarshal(m, b)
}
func (m *GetRecoveryInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetRecoveryInfoRequest.Marshal(b, m, deterministic)
}
func (m *GetRecoveryInfoRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetRecoveryInfoRequest.Merge(m, src)
}
func (m *GetRecoveryInfoRequest) XXX_Size() int {
return xxx_messageInfo_GetRecoveryInfoRequest.Size(m)
}
func (m *GetRecoveryInfoRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetRecoveryInfoRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetRecoveryInfoRequest proto.InternalMessageInfo
func (m *GetRecoveryInfoRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *GetRecoveryInfoRequest) GetCollectionID() int64 {
if m != nil {
return m.CollectionID
}
return 0
}
func (m *GetRecoveryInfoRequest) GetPartitionID() int64 {
if m != nil {
return m.PartitionID
}
return 0
}
func init() {
proto.RegisterEnum("milvus.proto.query.PartitionState", PartitionState_name, PartitionState_value)
proto.RegisterEnum("milvus.proto.query.TriggerCondition", TriggerCondition_name, TriggerCondition_value)
@ -2312,148 +1982,128 @@ func init() {
proto.RegisterType((*HandoffSegments)(nil), "milvus.proto.query.HandoffSegments")
proto.RegisterType((*LoadBalanceSegmentInfo)(nil), "milvus.proto.query.LoadBalanceSegmentInfo")
proto.RegisterType((*LoadBalanceSegments)(nil), "milvus.proto.query.LoadBalanceSegments")
proto.RegisterType((*CheckPoint)(nil), "milvus.proto.query.CheckPoint")
proto.RegisterType((*VchannelInfo)(nil), "milvus.proto.query.VchannelInfo")
proto.RegisterType((*SegmentBinlogs)(nil), "milvus.proto.query.SegmentBinlogs")
proto.RegisterType((*FieldBinlog)(nil), "milvus.proto.query.FieldBinlog")
proto.RegisterType((*GetRecoveryInfoResponse)(nil), "milvus.proto.query.GetRecoveryInfoResponse")
proto.RegisterType((*GetRecoveryInfoRequest)(nil), "milvus.proto.query.GetRecoveryInfoRequest")
}
func init() { proto.RegisterFile("query_service.proto", fileDescriptor_5fcb6756dc1afb8d) }
var fileDescriptor_5fcb6756dc1afb8d = []byte{
// 2067 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x73, 0x1c, 0x47,
0x15, 0xd7, 0xec, 0xae, 0x3e, 0xf6, 0xed, 0xec, 0x47, 0xda, 0xb6, 0xb2, 0x5e, 0x62, 0xc7, 0x19,
0x27, 0xc4, 0x51, 0x88, 0x9c, 0x52, 0x42, 0x8a, 0x54, 0x05, 0x88, 0xa5, 0x8d, 0xc5, 0x42, 0x2c,
0x8b, 0x91, 0x09, 0x55, 0x2e, 0x17, 0xcb, 0x68, 0xa6, 0xb5, 0x3b, 0xe5, 0x99, 0xe9, 0xd5, 0xf4,
0xac, 0x64, 0xfb, 0x00, 0x45, 0x15, 0x97, 0x70, 0x81, 0x0b, 0x27, 0x4e, 0x5c, 0x28, 0x38, 0xf0,
0x3f, 0x70, 0xe3, 0xaf, 0x00, 0x8a, 0x2a, 0x1f, 0xb9, 0x72, 0xa7, 0xfa, 0x63, 0x66, 0xe7, 0xa3,
0x57, 0xbb, 0x92, 0xec, 0xd8, 0x45, 0xe5, 0x36, 0xfd, 0xfa, 0x75, 0xbf, 0xcf, 0xfe, 0xf5, 0x9b,
0xd7, 0x70, 0xe1, 0x70, 0x8c, 0xc3, 0xc7, 0x7d, 0x8a, 0xc3, 0x23, 0xd7, 0xc6, 0xeb, 0xa3, 0x90,
0x44, 0x04, 0x21, 0xdf, 0xf5, 0x8e, 0xc6, 0x54, 0x8c, 0xd6, 0x39, 0x47, 0x47, 0xb7, 0x89, 0xef,
0x93, 0x40, 0xd0, 0x3a, 0x7a, 0x9a, 0xa3, 0xd3, 0x70, 0x83, 0x08, 0x87, 0x81, 0xe5, 0xc5, 0xb3,
0xd4, 0x1e, 0x62, 0xdf, 0x12, 0x23, 0xe3, 0x97, 0x70, 0xc1, 0xc4, 0x03, 0x97, 0x46, 0x38, 0xdc,
0x21, 0x0e, 0x36, 0xf1, 0xe1, 0x18, 0xd3, 0x08, 0xbd, 0x0f, 0x95, 0x7d, 0x8b, 0xe2, 0xb6, 0x76,
0x4d, 0xbb, 0x51, 0xdb, 0x78, 0x6d, 0x3d, 0x23, 0x53, 0x0a, 0xbb, 0x43, 0x07, 0x9b, 0x16, 0xc5,
0x26, 0xe7, 0x44, 0x1f, 0xc1, 0xb2, 0xe5, 0x38, 0x21, 0xa6, 0xb4, 0x5d, 0x3a, 0x61, 0xd1, 0x2d,
0xc1, 0x63, 0xc6, 0xcc, 0xc6, 0x6f, 0x35, 0xb8, 0x98, 0xd5, 0x80, 0x8e, 0x48, 0x40, 0x31, 0xfa,
0x00, 0x96, 0x68, 0x64, 0x45, 0x63, 0x2a, 0x95, 0xf8, 0x86, 0x72, 0xbf, 0x3d, 0xce, 0x62, 0x4a,
0x56, 0xb4, 0x09, 0x35, 0x37, 0x70, 0xa3, 0xfe, 0xc8, 0x0a, 0x2d, 0x3f, 0xd6, 0xe4, 0x8d, 0xec,
0xca, 0xc4, 0x1f, 0xbd, 0xc0, 0x8d, 0x76, 0x39, 0xa3, 0x09, 0x6e, 0xf2, 0x6d, 0xfc, 0x0c, 0x56,
0xf7, 0x86, 0xe4, 0x78, 0x8b, 0x78, 0x1e, 0xb6, 0x23, 0x97, 0x04, 0xf4, 0xec, 0x5e, 0x41, 0x50,
0x71, 0xf6, 0x7b, 0x5d, 0xae, 0x48, 0xd9, 0xe4, 0xdf, 0x46, 0x04, 0xaf, 0x16, 0xf6, 0x3f, 0x8f,
0xcd, 0x6f, 0x42, 0xdd, 0x4e, 0xf6, 0xea, 0x75, 0x99, 0xd5, 0xe5, 0x1b, 0x65, 0x33, 0x4b, 0x34,
0x7e, 0xa5, 0xc1, 0x25, 0x26, 0x76, 0xd7, 0x0a, 0x23, 0xf7, 0xd9, 0x5b, 0x85, 0x0c, 0xd0, 0xd3,
0x02, 0xdb, 0x65, 0x3e, 0x97, 0xa1, 0x19, 0x87, 0xc2, 0xb3, 0x69, 0x15, 0xce, 0x63, 0xb8, 0x01,
0xfa, 0x28, 0xde, 0x6a, 0x62, 0x77, 0x86, 0x66, 0xfc, 0x4d, 0x83, 0x4b, 0x9f, 0x13, 0xcb, 0x99,
0x78, 0xfb, 0x2b, 0x37, 0x1b, 0x7d, 0x17, 0x96, 0xc4, 0x99, 0x6b, 0x57, 0xb8, 0xac, 0xb7, 0xb2,
0xb2, 0xe4, 0x79, 0x9c, 0x68, 0xb8, 0xc7, 0x09, 0xa6, 0x5c, 0x64, 0xfc, 0x5a, 0x83, 0xb6, 0x89,
0x3d, 0x6c, 0x51, 0xfc, 0x02, 0xad, 0x30, 0x9e, 0x4a, 0x4f, 0xbe, 0xc0, 0x04, 0x2a, 0x44, 0xbc,
0x52, 0x8c, 0x78, 0xca, 0xdb, 0x8b, 0x67, 0xf1, 0xf6, 0x9f, 0x27, 0xde, 0x7e, 0xc9, 0x2d, 0x35,
0xbe, 0x0f, 0x97, 0xb7, 0x42, 0x6c, 0x45, 0xf8, 0xc7, 0xec, 0x12, 0xd8, 0x1a, 0x5a, 0x41, 0x80,
0xbd, 0x58, 0xd5, 0xbc, 0x10, 0x4d, 0x11, 0xd2, 0x3f, 0x6a, 0xd0, 0x51, 0xed, 0x70, 0x9e, 0x43,
0xf9, 0x36, 0x34, 0x43, 0xa1, 0x42, 0xdf, 0x16, 0xfb, 0x71, 0xdb, 0xab, 0x66, 0x43, 0x92, 0xa5,
0x14, 0xf4, 0x16, 0x34, 0x42, 0x4c, 0xc7, 0xde, 0x84, 0xaf, 0xcc, 0xf9, 0xea, 0x82, 0x2a, 0xd9,
0x8c, 0xbf, 0x68, 0x70, 0x79, 0x1b, 0x47, 0x49, 0x2c, 0x98, 0x38, 0xfc, 0x92, 0x06, 0xc4, 0x87,
0x66, 0x4e, 0x4f, 0x74, 0x0d, 0x6a, 0x29, 0x16, 0x19, 0x85, 0x34, 0x09, 0x7d, 0x07, 0x16, 0x99,
0xeb, 0x30, 0xd7, 0xa8, 0xb1, 0x61, 0xac, 0x17, 0xef, 0xf7, 0xf5, 0xec, 0xae, 0xa6, 0x58, 0x60,
0xfc, 0x55, 0x83, 0x8e, 0xca, 0x35, 0xe7, 0x09, 0xdf, 0x7d, 0x58, 0x4d, 0x94, 0xeb, 0x3b, 0x98,
0xda, 0xa1, 0x3b, 0xe2, 0x47, 0x80, 0xa3, 0x6b, 0x6d, 0xe3, 0xfa, 0x6c, 0xf5, 0xa8, 0x79, 0x29,
0xd9, 0xa2, 0x9b, 0xda, 0xc1, 0x70, 0xe1, 0xd2, 0x36, 0x8e, 0xf6, 0xf0, 0xc0, 0xc7, 0x41, 0xd4,
0x0b, 0x0e, 0xc8, 0xd9, 0xa3, 0x78, 0x15, 0x80, 0xca, 0x7d, 0x12, 0xe0, 0x4f, 0x51, 0x8c, 0x7f,
0x94, 0xa0, 0x96, 0x12, 0x84, 0x5e, 0x83, 0x6a, 0x32, 0x2b, 0x83, 0x30, 0x21, 0x14, 0xe2, 0x5f,
0x52, 0xc4, 0x3f, 0x17, 0xc8, 0x72, 0x31, 0x90, 0xab, 0xb0, 0x14, 0x10, 0x07, 0xf7, 0xba, 0x1c,
0xe6, 0xcb, 0xa6, 0x1c, 0xa1, 0xcb, 0xb0, 0xe2, 0x63, 0xbf, 0x4f, 0xdd, 0x27, 0x98, 0x43, 0x52,
0xd9, 0x5c, 0xf6, 0xb1, 0xbf, 0xe7, 0x3e, 0xc1, 0x6c, 0x2a, 0x18, 0xfb, 0xfd, 0x90, 0x1c, 0xd3,
0xf6, 0x92, 0x98, 0x0a, 0xc6, 0xbe, 0x49, 0x8e, 0x29, 0xba, 0x02, 0xe0, 0x06, 0x0e, 0x7e, 0xd4,
0x0f, 0x2c, 0x1f, 0xb7, 0x97, 0xf9, 0xd1, 0xa8, 0x72, 0xca, 0x8e, 0xe5, 0x63, 0xd4, 0x86, 0x65,
0x3e, 0xe8, 0x75, 0xdb, 0x2b, 0x62, 0xa1, 0x1c, 0x32, 0x53, 0xe5, 0x81, 0xea, 0x75, 0xdb, 0x55,
0xb1, 0x2e, 0x21, 0xa0, 0xcf, 0xa0, 0x2e, 0xed, 0xee, 0x8b, 0xac, 0x03, 0x9e, 0x75, 0xd7, 0x54,
0x61, 0x95, 0x0e, 0x14, 0x39, 0xa7, 0xd3, 0xd4, 0x88, 0xdd, 0x49, 0xab, 0xf9, 0x58, 0x9e, 0x27,
0xed, 0xbe, 0x0d, 0x8b, 0x6e, 0x70, 0x40, 0xe2, 0x2c, 0x7b, 0xfd, 0x04, 0x75, 0xb8, 0x30, 0xc1,
0x6d, 0xfc, 0x53, 0x83, 0xd5, 0x5b, 0x8e, 0xa3, 0xc2, 0xbf, 0xd3, 0xe7, 0xd4, 0x24, 0x7e, 0xa5,
0x4c, 0xfc, 0xe6, 0x41, 0x87, 0x77, 0xe1, 0x95, 0x1c, 0xea, 0xc9, 0x34, 0xa8, 0x9a, 0xad, 0x2c,
0xee, 0xf5, 0xba, 0xe8, 0x1d, 0x68, 0x65, 0x91, 0xaf, 0xd7, 0xe5, 0x89, 0x51, 0x35, 0x9b, 0x19,
0xec, 0xeb, 0x75, 0x8d, 0x7f, 0x6b, 0x70, 0xd9, 0xc4, 0x3e, 0x39, 0xc2, 0xff, 0xbf, 0x36, 0x3e,
0x2d, 0xc1, 0xea, 0x4f, 0xad, 0xc8, 0x1e, 0x76, 0x7d, 0x49, 0xa4, 0x2f, 0xc6, 0xc0, 0xdc, 0x11,
0xaf, 0x14, 0x8f, 0xf8, 0x47, 0x71, 0x9a, 0x2e, 0xf2, 0x34, 0x55, 0x9e, 0x9a, 0x2f, 0x62, 0x83,
0x27, 0x79, 0x9a, 0xaa, 0x49, 0x96, 0xce, 0x50, 0x93, 0xa0, 0x2d, 0xa8, 0xe3, 0x47, 0xb6, 0x37,
0x76, 0x70, 0x5f, 0x88, 0x5f, 0xe6, 0xe2, 0xaf, 0xaa, 0xc4, 0x6f, 0x0d, 0xb1, 0xfd, 0x70, 0x97,
0xb8, 0x41, 0x64, 0xea, 0x72, 0x51, 0x8f, 0x9f, 0x95, 0xff, 0x68, 0xd0, 0x94, 0x47, 0x88, 0x95,
0x71, 0x73, 0xc0, 0x62, 0xce, 0x1f, 0xa5, 0xa2, 0x3f, 0xe6, 0xf1, 0x6a, 0x7c, 0xe1, 0x56, 0x52,
0x17, 0xee, 0x15, 0x80, 0x03, 0x6f, 0x4c, 0x87, 0xfd, 0xc8, 0xf5, 0x63, 0x50, 0xac, 0x72, 0xca,
0x3d, 0xd7, 0xc7, 0x68, 0x13, 0xf4, 0x7d, 0x37, 0xf0, 0xc8, 0xa0, 0x3f, 0xb2, 0xa2, 0x21, 0x83,
0xc6, 0xa9, 0xa0, 0x70, 0xdb, 0xc5, 0x9e, 0xb3, 0xc9, 0x99, 0xcd, 0x9a, 0x58, 0xb4, 0xcb, 0xd6,
0x18, 0x7f, 0x2a, 0xc1, 0x05, 0x66, 0xa7, 0x34, 0xf9, 0x39, 0xa4, 0xd4, 0xc7, 0x71, 0x32, 0x94,
0xa7, 0xdf, 0x8c, 0x39, 0x87, 0x17, 0xf3, 0xe1, 0x2c, 0x7f, 0x04, 0xe8, 0x47, 0xd0, 0xf0, 0x88,
0xe5, 0xf4, 0x6d, 0x12, 0x38, 0x3c, 0x14, 0xdc, 0x85, 0x8d, 0x8d, 0x37, 0x55, 0x2a, 0xdc, 0x0b,
0xdd, 0xc1, 0x00, 0x87, 0x5b, 0x31, 0xaf, 0x59, 0xf7, 0xf8, 0xff, 0x90, 0x1c, 0x72, 0x0c, 0x95,
0x05, 0xef, 0xf3, 0xf3, 0x55, 0x9c, 0x04, 0xe5, 0x13, 0xaa, 0xae, 0xca, 0x1c, 0x55, 0xd7, 0xa2,
0xa2, 0xe0, 0xcf, 0xd6, 0x02, 0x4b, 0x85, 0x5a, 0xe0, 0x1e, 0xd4, 0x13, 0x64, 0xe1, 0x59, 0x7f,
0x1d, 0xea, 0x42, 0xad, 0x3e, 0xf3, 0x04, 0x76, 0xe2, 0xda, 0x58, 0x10, 0x3f, 0xe7, 0x34, 0xb6,
0x6b, 0x82, 0x5c, 0xe2, 0x5a, 0xaa, 0x9a, 0x29, 0x8a, 0xf1, 0x7b, 0x0d, 0x5a, 0x69, 0x4c, 0xe6,
0x3b, 0xcf, 0x51, 0x74, 0xb3, 0x02, 0x59, 0xb4, 0x75, 0x26, 0xc0, 0x28, 0x0b, 0xe4, 0xc3, 0xf4,
0x76, 0x5d, 0xf4, 0x21, 0xac, 0x0a, 0xc6, 0x02, 0x90, 0x8a, 0x42, 0xf9, 0x22, 0x9f, 0x35, 0x73,
0x68, 0xfa, 0x2f, 0x0d, 0x1a, 0x93, 0xc4, 0x99, 0x5b, 0xab, 0x39, 0xfe, 0xa5, 0xd1, 0x6d, 0xa8,
0x4b, 0x1d, 0xfa, 0xe9, 0xc4, 0x7f, 0x43, 0x95, 0x75, 0x19, 0x8f, 0x9b, 0x7a, 0x0a, 0x13, 0xcf,
0x8b, 0x86, 0xc6, 0x2f, 0xa0, 0xf9, 0x03, 0x2b, 0x70, 0xc8, 0xc1, 0x41, 0x9c, 0xaf, 0x67, 0x48,
0xd4, 0x8f, 0xb3, 0x05, 0xc7, 0x29, 0x0e, 0xaf, 0xf1, 0x87, 0x12, 0xac, 0x32, 0xda, 0xa6, 0xe5,
0x59, 0x81, 0x8d, 0xe7, 0x2f, 0x33, 0x9f, 0x0d, 0x9e, 0x5e, 0x87, 0x3a, 0x25, 0xe3, 0xd0, 0xc6,
0xfd, 0x4c, 0xb5, 0xa9, 0x0b, 0xe2, 0x8e, 0x38, 0x6f, 0x57, 0x00, 0x1c, 0x1a, 0xc5, 0x1c, 0x12,
0x60, 0x1d, 0x1a, 0xc9, 0xe9, 0xd7, 0xa1, 0x26, 0xf7, 0x70, 0x48, 0x80, 0x79, 0x18, 0x56, 0x4c,
0x10, 0xa4, 0x2e, 0x09, 0x78, 0x61, 0xca, 0xd6, 0xf3, 0xd9, 0x65, 0x3e, 0xbb, 0xec, 0xd0, 0x88,
0x4f, 0x5d, 0x01, 0x38, 0xb2, 0x3c, 0xd7, 0xe1, 0x39, 0xc0, 0x8b, 0xcf, 0x15, 0xb3, 0xca, 0x29,
0xcc, 0x05, 0xc6, 0x97, 0x9a, 0xc0, 0xdd, 0xac, 0x77, 0xce, 0x12, 0xa2, 0x4f, 0xb3, 0x21, 0x5a,
0x53, 0x85, 0x48, 0x1d, 0x87, 0x38, 0x52, 0xbf, 0xd1, 0x00, 0x26, 0xf7, 0xe1, 0x8c, 0xe8, 0x7c,
0x0f, 0x56, 0x46, 0x84, 0x0a, 0x38, 0x15, 0x7d, 0x43, 0x63, 0x4a, 0xdf, 0xf0, 0x0e, 0x1d, 0xec,
0x4a, 0x4e, 0x33, 0x59, 0x83, 0xae, 0x42, 0x8d, 0xd5, 0xf2, 0xe4, 0x40, 0x94, 0xf3, 0x22, 0x74,
0xd5, 0x60, 0xec, 0xdf, 0x3d, 0x60, 0x05, 0xbd, 0xf1, 0x65, 0x09, 0xf4, 0x74, 0x6d, 0x30, 0xd7,
0xb1, 0xbc, 0x06, 0x35, 0xb9, 0x84, 0x55, 0xfd, 0x12, 0x28, 0xd2, 0x24, 0xb4, 0xcd, 0x0a, 0x7a,
0xfc, 0xb0, 0x9f, 0xe8, 0x5e, 0x9e, 0x5b, 0x77, 0x9d, 0x2d, 0x8c, 0x47, 0xe8, 0x53, 0x26, 0x2a,
0xf6, 0x95, 0xf8, 0xbf, 0x9d, 0x5d, 0x62, 0xa4, 0x97, 0xa0, 0x1b, 0xd0, 0xe4, 0x77, 0x38, 0x4e,
0x2e, 0x5d, 0x89, 0xd7, 0x79, 0xb2, 0x41, 0xa1, 0x21, 0xbf, 0xc5, 0xd5, 0x4d, 0x67, 0xc4, 0x66,
0x0b, 0xf4, 0x83, 0xc9, 0x45, 0x7f, 0xe2, 0x5f, 0x42, 0xba, 0x20, 0xc8, 0x2c, 0x32, 0x6e, 0x41,
0x2d, 0x35, 0xc9, 0xfe, 0xa0, 0xf8, 0x74, 0x22, 0x2f, 0x1e, 0xb2, 0x99, 0xfd, 0x94, 0xa0, 0xaa,
0x19, 0x0f, 0x8d, 0xbf, 0x6b, 0xf0, 0xea, 0x36, 0x8e, 0x4c, 0x6c, 0x93, 0x23, 0x1c, 0x3e, 0xce,
0xfc, 0xf7, 0x9c, 0x3e, 0xc1, 0x3f, 0x81, 0x15, 0x19, 0xc9, 0xd8, 0xa2, 0xd9, 0x05, 0x65, 0xb2,
0x02, 0x7d, 0x32, 0xd1, 0x52, 0xe0, 0xb0, 0x71, 0x02, 0x86, 0x49, 0x1f, 0x4c, 0x2c, 0xf9, 0x9d,
0xf8, 0x81, 0xcb, 0x5a, 0x72, 0xd6, 0x5b, 0xff, 0x99, 0xfc, 0x3f, 0xaf, 0x3d, 0x81, 0x46, 0xb6,
0x91, 0x80, 0x74, 0x58, 0xd9, 0x21, 0xd1, 0x67, 0x8f, 0x5c, 0x1a, 0xb5, 0x16, 0x50, 0x03, 0x60,
0x87, 0x44, 0xbb, 0x21, 0xa6, 0x38, 0x88, 0x5a, 0x1a, 0x02, 0x58, 0xba, 0x1b, 0x74, 0x5d, 0xfa,
0xb0, 0x55, 0x42, 0x17, 0x64, 0xe7, 0xc5, 0xf2, 0x7a, 0xc1, 0x1d, 0xec, 0x93, 0xf0, 0x71, 0xab,
0xcc, 0x96, 0x27, 0xa3, 0x0a, 0x6a, 0x81, 0x9e, 0xb0, 0x6c, 0xef, 0xfe, 0xa4, 0xb5, 0x88, 0xaa,
0xb0, 0x28, 0x3e, 0x97, 0xd6, 0xee, 0x42, 0x2b, 0x5f, 0x27, 0xa1, 0x1a, 0x2c, 0x0f, 0xc5, 0x3d,
0xd3, 0x5a, 0x40, 0x4d, 0xa8, 0x79, 0x13, 0xac, 0x69, 0x69, 0x8c, 0x30, 0x08, 0x47, 0xb6, 0x74,
0x5a, 0xab, 0xc4, 0xa4, 0x31, 0xb8, 0xed, 0x92, 0xe3, 0xa0, 0x55, 0x5e, 0xfb, 0x21, 0xe8, 0xe9,
0xdf, 0x67, 0xb4, 0x02, 0x95, 0x1d, 0x12, 0xe0, 0xd6, 0x02, 0xdb, 0x76, 0x3b, 0x24, 0xc7, 0x6e,
0x30, 0x10, 0x36, 0xdc, 0x0e, 0xc9, 0x13, 0x1c, 0xb4, 0x4a, 0x6c, 0x82, 0x62, 0xcb, 0x63, 0x13,
0x65, 0x36, 0xc1, 0x06, 0xd8, 0x69, 0x55, 0x36, 0xfe, 0x0b, 0xa0, 0xf3, 0x52, 0x63, 0x4f, 0x3c,
0x04, 0xa1, 0x11, 0xa0, 0x6d, 0x1c, 0x6d, 0x11, 0x7f, 0x44, 0x82, 0x58, 0x02, 0x45, 0xef, 0x4f,
0x39, 0xf2, 0x45, 0x56, 0xa9, 0x74, 0xe7, 0x9b, 0x53, 0x56, 0xe4, 0xd8, 0x8d, 0x05, 0xe4, 0x73,
0x89, 0xac, 0x38, 0xbf, 0xe7, 0xda, 0x0f, 0xe3, 0x16, 0xde, 0x09, 0x12, 0x73, 0xac, 0xb1, 0xc4,
0xdc, 0x3d, 0x2b, 0x07, 0x7b, 0x51, 0xe8, 0x06, 0x83, 0xf8, 0x24, 0x19, 0x0b, 0xe8, 0x10, 0x2e,
0x6e, 0x63, 0x2e, 0xdd, 0xa5, 0x91, 0x6b, 0xd3, 0x58, 0xe0, 0xc6, 0x74, 0x81, 0x05, 0xe6, 0x53,
0x8a, 0xb4, 0x41, 0x4f, 0x3f, 0x43, 0xa1, 0xb7, 0x55, 0xa7, 0x49, 0xf1, 0x54, 0xd6, 0xb9, 0x31,
0x9b, 0x31, 0x11, 0xe2, 0x41, 0x33, 0xf7, 0xf4, 0x83, 0x94, 0xd7, 0x9a, 0xfa, 0xfd, 0xa9, 0xf3,
0xee, 0x5c, 0xbc, 0x89, 0x34, 0x17, 0x1a, 0xd9, 0xe7, 0x16, 0xf4, 0xce, 0xb4, 0x0d, 0x0a, 0xad,
0xee, 0xce, 0xda, 0x3c, 0xac, 0x89, 0xa8, 0xfb, 0xd0, 0xc8, 0xbe, 0x0d, 0xa8, 0x45, 0x29, 0xdf,
0x0f, 0x3a, 0x27, 0x75, 0x88, 0x8c, 0x05, 0xf4, 0x73, 0x78, 0xa5, 0xd0, 0x90, 0x47, 0xdf, 0x52,
0x7b, 0x5d, 0xdd, 0xb7, 0x9f, 0x25, 0x41, 0x6a, 0x3f, 0xf1, 0xe2, 0x74, 0xed, 0x0b, 0x2f, 0x30,
0xf3, 0x6b, 0x9f, 0xda, 0xfe, 0x24, 0xed, 0x4f, 0x2d, 0x61, 0x0c, 0xa8, 0xd8, 0xc4, 0x47, 0xef,
0x29, 0x6f, 0xee, 0x69, 0xcf, 0x05, 0x9d, 0xf5, 0x79, 0xd9, 0x93, 0x90, 0x8f, 0x39, 0x24, 0xe4,
0xfb, 0xdd, 0x4a, 0xb1, 0x53, 0xfb, 0xf7, 0x6a, 0xb1, 0xd3, 0x7b, 0xda, 0x22, 0xa9, 0xb3, 0x8d,
0x47, 0x75, 0xac, 0x94, 0x8d, 0x66, 0x75, 0x52, 0xab, 0xfb, 0x98, 0xc6, 0xc2, 0xc6, 0xd3, 0x15,
0xa8, 0x72, 0xe3, 0x39, 0x20, 0x7c, 0x0d, 0xba, 0xcf, 0x1e, 0x74, 0x1f, 0x40, 0x33, 0xd7, 0xbe,
0x55, 0xe3, 0xa1, 0xba, 0xc7, 0x3b, 0xeb, 0x60, 0xec, 0x03, 0x2a, 0xf6, 0x4e, 0xd5, 0x19, 0x3a,
0xb5, 0xc7, 0x3a, 0x4b, 0xc6, 0x03, 0x68, 0xe6, 0x7a, 0x97, 0x6a, 0x0b, 0xd4, 0x0d, 0xce, 0x59,
0xbb, 0x7f, 0x01, 0x7a, 0xba, 0x87, 0xa5, 0xbe, 0x94, 0x14, 0x5d, 0xae, 0x17, 0x0f, 0x4a, 0xcf,
0x1f, 0xb4, 0x1f, 0x40, 0x33, 0xd7, 0xb6, 0x52, 0x7b, 0x5e, 0xdd, 0xdb, 0x9a, 0xb5, 0xfb, 0x57,
0x07, 0x33, 0x9b, 0x1f, 0xde, 0xdf, 0x18, 0xb8, 0xd1, 0x70, 0xbc, 0xcf, 0x94, 0xb8, 0x29, 0x56,
0xbe, 0xe7, 0x12, 0xf9, 0x75, 0x33, 0x3e, 0x6f, 0x37, 0xf9, 0x66, 0x37, 0xf9, 0x66, 0xa3, 0xfd,
0xfd, 0x25, 0x3e, 0xfc, 0xe0, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc4, 0x8a, 0x21, 0x1a, 0x24,
0x24, 0x00, 0x00,
// 1845 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcd, 0x73, 0x1c, 0x47,
0x15, 0xd7, 0xec, 0xae, 0x56, 0xda, 0xb7, 0x5f, 0x93, 0xb6, 0x2d, 0xd6, 0x4b, 0x9c, 0x38, 0xe3,
0x84, 0x38, 0x0a, 0x91, 0x53, 0x4a, 0xa0, 0xc8, 0x81, 0x02, 0x4b, 0x1b, 0x8b, 0x85, 0x44, 0x11,
0x23, 0x13, 0xaa, 0x5c, 0x2e, 0x96, 0xd1, 0x4c, 0x6b, 0x77, 0x2a, 0x33, 0xdd, 0xab, 0xe9, 0x5e,
0xcb, 0xf1, 0x01, 0x8a, 0x2a, 0x2e, 0x9c, 0x38, 0x71, 0xe2, 0xc4, 0x85, 0x82, 0x03, 0xff, 0x03,
0xff, 0x08, 0x50, 0x14, 0xb9, 0x71, 0xe6, 0x4e, 0x4d, 0x77, 0xcf, 0xec, 0x7c, 0xf4, 0x4a, 0x6b,
0xc9, 0x8e, 0x53, 0x14, 0xb7, 0xe9, 0xd7, 0xaf, 0xdf, 0x77, 0xff, 0xe6, 0xf5, 0x83, 0x2b, 0x27,
0x33, 0x1c, 0x7d, 0x3e, 0x62, 0x38, 0x7a, 0xe4, 0xbb, 0x78, 0x6b, 0x1a, 0x51, 0x4e, 0x11, 0x0a,
0xfd, 0xe0, 0xd1, 0x8c, 0xc9, 0xd5, 0x96, 0xe0, 0xe8, 0xb7, 0x5c, 0x1a, 0x86, 0x94, 0x48, 0x5a,
0xbf, 0x95, 0xe5, 0xe8, 0x77, 0x7c, 0xc2, 0x71, 0x44, 0x9c, 0x20, 0xd9, 0x65, 0xee, 0x04, 0x87,
0x8e, 0x5a, 0x21, 0xcf, 0xe1, 0x4e, 0x5e, 0x83, 0xf5, 0x4b, 0xb8, 0x62, 0xe3, 0xb1, 0xcf, 0x38,
0x8e, 0xf6, 0xa9, 0x87, 0x6d, 0x7c, 0x32, 0xc3, 0x8c, 0xa3, 0x77, 0xa1, 0x76, 0xe4, 0x30, 0xdc,
0x33, 0x6e, 0x1a, 0xb7, 0x9b, 0xdb, 0x2f, 0x6f, 0xe5, 0xec, 0x50, 0x06, 0x7c, 0xcc, 0xc6, 0x3b,
0x0e, 0xc3, 0xb6, 0xe0, 0x44, 0xdf, 0x86, 0x35, 0xc7, 0xf3, 0x22, 0xcc, 0x58, 0xaf, 0x72, 0xc6,
0xa1, 0xbb, 0x92, 0xc7, 0x4e, 0x98, 0xad, 0xdf, 0x1a, 0x70, 0x35, 0x6f, 0x01, 0x9b, 0x52, 0xc2,
0x30, 0x7a, 0x0f, 0xea, 0x8c, 0x3b, 0x7c, 0xc6, 0x94, 0x11, 0x5f, 0xd7, 0xca, 0x3b, 0x14, 0x2c,
0xb6, 0x62, 0x45, 0x3b, 0xd0, 0xf4, 0x89, 0xcf, 0x47, 0x53, 0x27, 0x72, 0xc2, 0xc4, 0x92, 0xd7,
0xf2, 0x27, 0xd3, 0x18, 0x0d, 0x89, 0xcf, 0x0f, 0x04, 0xa3, 0x0d, 0x7e, 0xfa, 0x6d, 0xfd, 0x0c,
0x36, 0x0e, 0x27, 0xf4, 0x74, 0x97, 0x06, 0x01, 0x76, 0xb9, 0x4f, 0x09, 0xbb, 0x78, 0x54, 0x10,
0xd4, 0xbc, 0xa3, 0xe1, 0x40, 0x18, 0x52, 0xb5, 0xc5, 0xb7, 0xc5, 0xe1, 0x6b, 0x25, 0xf9, 0x97,
0xf1, 0xf9, 0x75, 0x68, 0xbb, 0xa9, 0xac, 0xe1, 0x20, 0xf6, 0xba, 0x7a, 0xbb, 0x6a, 0xe7, 0x89,
0xd6, 0xaf, 0x0c, 0xb8, 0x16, 0xab, 0x3d, 0x70, 0x22, 0xee, 0x3f, 0x7b, 0xaf, 0x90, 0x05, 0xad,
0xac, 0xc2, 0x5e, 0x55, 0xec, 0xe5, 0x68, 0xd6, 0x89, 0x8c, 0x6c, 0xd6, 0x84, 0xcb, 0x38, 0x6e,
0x41, 0x6b, 0x9a, 0x88, 0x9a, 0xfb, 0x9d, 0xa3, 0x59, 0x7f, 0x35, 0xe0, 0xda, 0x47, 0xd4, 0xf1,
0xe6, 0xd1, 0xfe, 0xd2, 0xdd, 0x46, 0xdf, 0x85, 0xba, 0xbc, 0x87, 0xbd, 0x9a, 0xd0, 0xf5, 0x46,
0x5e, 0x97, 0xba, 0xa3, 0x73, 0x0b, 0x0f, 0x05, 0xc1, 0x56, 0x87, 0xac, 0x5f, 0x1b, 0xd0, 0xb3,
0x71, 0x80, 0x1d, 0x86, 0x5f, 0xa0, 0x17, 0xd6, 0x17, 0x2a, 0x92, 0x2f, 0xb0, 0x80, 0x4a, 0x19,
0xaf, 0x95, 0x33, 0x9e, 0x89, 0xf6, 0xea, 0x45, 0xa2, 0xfd, 0xa7, 0x79, 0xb4, 0xbf, 0xe2, 0x9e,
0x5a, 0xdf, 0x83, 0xeb, 0xbb, 0x11, 0x76, 0x38, 0xfe, 0x71, 0xfc, 0x63, 0xd8, 0x9d, 0x38, 0x84,
0xe0, 0x20, 0x31, 0xb5, 0xa8, 0xc4, 0xd0, 0xa4, 0xf4, 0x0f, 0x06, 0xf4, 0x75, 0x12, 0x2e, 0x73,
0x29, 0xdf, 0x84, 0x6e, 0x24, 0x4d, 0x18, 0xb9, 0x52, 0x9e, 0xf0, 0xbd, 0x61, 0x77, 0x14, 0x59,
0x69, 0x41, 0x6f, 0x40, 0x27, 0xc2, 0x6c, 0x16, 0xcc, 0xf9, 0xaa, 0x82, 0xaf, 0x2d, 0xa9, 0x8a,
0xcd, 0xfa, 0xb3, 0x01, 0xd7, 0xf7, 0x30, 0x4f, 0x73, 0x11, 0xab, 0xc3, 0x5f, 0xd1, 0x84, 0x84,
0xd0, 0x2d, 0xd8, 0x89, 0x6e, 0x42, 0x33, 0xc3, 0xa2, 0xb2, 0x90, 0x25, 0xa1, 0xef, 0xc0, 0x6a,
0x1c, 0x3a, 0x2c, 0x2c, 0xea, 0x6c, 0x5b, 0x5b, 0xe5, 0x7f, 0xfe, 0x56, 0x5e, 0xaa, 0x2d, 0x0f,
0x58, 0x7f, 0x31, 0xa0, 0xaf, 0x0b, 0xcd, 0x65, 0xd2, 0xf7, 0x00, 0x36, 0x52, 0xe3, 0x46, 0x1e,
0x66, 0x6e, 0xe4, 0x4f, 0xc5, 0x15, 0x10, 0xe8, 0xda, 0xdc, 0xbe, 0x75, 0xbe, 0x79, 0xcc, 0xbe,
0x96, 0x8a, 0x18, 0x64, 0x24, 0x58, 0x3e, 0x5c, 0xdb, 0xc3, 0xfc, 0x10, 0x8f, 0x43, 0x4c, 0xf8,
0x90, 0x1c, 0xd3, 0x8b, 0x67, 0xf1, 0x15, 0x00, 0xa6, 0xe4, 0xa4, 0xc0, 0x9f, 0xa1, 0x58, 0x7f,
0xab, 0x40, 0x33, 0xa3, 0x08, 0xbd, 0x0c, 0x8d, 0x74, 0x57, 0x25, 0x61, 0x4e, 0x28, 0xe5, 0xbf,
0xa2, 0xc9, 0x7f, 0x21, 0x91, 0xd5, 0x72, 0x22, 0x37, 0xa0, 0x4e, 0xa8, 0x87, 0x87, 0x03, 0x01,
0xf3, 0x55, 0x5b, 0xad, 0xd0, 0x75, 0x58, 0x0f, 0x71, 0x38, 0x62, 0xfe, 0x13, 0x2c, 0x20, 0xa9,
0x6a, 0xaf, 0x85, 0x38, 0x3c, 0xf4, 0x9f, 0xe0, 0x78, 0x8b, 0xcc, 0xc2, 0x51, 0x44, 0x4f, 0x59,
0xaf, 0x2e, 0xb7, 0xc8, 0x2c, 0xb4, 0xe9, 0x29, 0x43, 0x37, 0x00, 0x7c, 0xe2, 0xe1, 0xc7, 0x23,
0xe2, 0x84, 0xb8, 0xb7, 0x26, 0xae, 0x46, 0x43, 0x50, 0xf6, 0x9d, 0x10, 0xa3, 0x1e, 0xac, 0x89,
0xc5, 0x70, 0xd0, 0x5b, 0x97, 0x07, 0xd5, 0x32, 0x76, 0x55, 0x5d, 0xa8, 0xe1, 0xa0, 0xd7, 0x90,
0xe7, 0x52, 0x02, 0xfa, 0x10, 0xda, 0xca, 0xef, 0x91, 0xac, 0x3a, 0x10, 0x55, 0x77, 0x53, 0x97,
0x56, 0x15, 0x40, 0x59, 0x73, 0x2d, 0x96, 0x59, 0xc5, 0xff, 0xa4, 0x8d, 0x62, 0x2e, 0x2f, 0x53,
0x76, 0xdf, 0x82, 0x55, 0x9f, 0x1c, 0xd3, 0xa4, 0xca, 0x5e, 0x3d, 0xc3, 0x1c, 0xa1, 0x4c, 0x72,
0x5b, 0x7f, 0x37, 0x60, 0xe3, 0xae, 0xe7, 0xe9, 0xf0, 0xef, 0xe9, 0x6b, 0x6a, 0x9e, 0xbf, 0x4a,
0x2e, 0x7f, 0xcb, 0xa0, 0xc3, 0xdb, 0xf0, 0x52, 0x01, 0xf5, 0x54, 0x19, 0x34, 0x6c, 0x33, 0x8f,
0x7b, 0xc3, 0x01, 0x7a, 0x0b, 0xcc, 0x3c, 0xf2, 0x0d, 0x07, 0xa2, 0x30, 0x1a, 0x76, 0x37, 0x87,
0x7d, 0xc3, 0x81, 0xf5, 0x4f, 0x03, 0xae, 0xdb, 0x38, 0xa4, 0x8f, 0xf0, 0xff, 0xae, 0x8f, 0xff,
0xaa, 0xc0, 0xc6, 0x4f, 0x1d, 0xee, 0x4e, 0x06, 0xa1, 0x22, 0xb2, 0x17, 0xe3, 0x60, 0xe1, 0x8a,
0xd7, 0xca, 0x57, 0x3c, 0x2d, 0xd3, 0x55, 0x5d, 0x99, 0xc6, 0xcf, 0xab, 0xad, 0x4f, 0x13, 0x7f,
0xe7, 0x65, 0x9a, 0x69, 0x49, 0xea, 0x17, 0x68, 0x49, 0xd0, 0x2e, 0xb4, 0xf1, 0x63, 0x37, 0x98,
0x79, 0x78, 0x24, 0xb5, 0xaf, 0x09, 0xed, 0xaf, 0x68, 0xb4, 0x67, 0xef, 0x48, 0x4b, 0x1d, 0x1a,
0x8a, 0xab, 0xf2, 0x6f, 0x03, 0xba, 0x6a, 0x37, 0xee, 0xe2, 0x96, 0x40, 0xc5, 0x42, 0x38, 0x2a,
0xe5, 0x70, 0x2c, 0x13, 0xd4, 0xe4, 0x7f, 0x5b, 0xcb, 0xfc, 0x6f, 0x6f, 0x00, 0x1c, 0x07, 0x33,
0x36, 0x19, 0x71, 0x3f, 0x4c, 0x30, 0xb1, 0x21, 0x28, 0xf7, 0xfd, 0x10, 0xa3, 0xbb, 0xd0, 0x3a,
0xf2, 0x49, 0x40, 0xc7, 0xa3, 0xa9, 0xc3, 0x27, 0x31, 0x32, 0x2e, 0x72, 0xf7, 0x9e, 0x8f, 0x03,
0x6f, 0x47, 0xf0, 0xda, 0x4d, 0x79, 0xe6, 0x20, 0x3e, 0x62, 0xfd, 0xb1, 0x02, 0x57, 0x62, 0x37,
0x95, 0xc7, 0xcf, 0xa1, 0xa0, 0x3e, 0x48, 0x4a, 0xa1, 0xba, 0xf8, 0xbf, 0x58, 0x88, 0x77, 0xb9,
0x1c, 0x2e, 0xf2, 0x1e, 0x40, 0x3f, 0x82, 0x4e, 0x40, 0x1d, 0x6f, 0xe4, 0x52, 0xe2, 0x89, 0x4c,
0x88, 0x08, 0x76, 0xb6, 0x5f, 0xd7, 0x99, 0x70, 0x3f, 0xf2, 0xc7, 0x63, 0x1c, 0xed, 0x26, 0xbc,
0x76, 0x3b, 0x10, 0xaf, 0x21, 0xb5, 0x14, 0x08, 0xaa, 0xda, 0xdd, 0xe7, 0x17, 0xab, 0xa4, 0x06,
0xaa, 0x67, 0xf4, 0x5c, 0xb5, 0x25, 0x7a, 0xae, 0x55, 0x4d, 0xbb, 0x9f, 0xef, 0x04, 0xea, 0xa5,
0x4e, 0xe0, 0x3e, 0xb4, 0x53, 0x5c, 0x11, 0x45, 0x7f, 0x0b, 0xda, 0xd2, 0xac, 0x51, 0x1c, 0x09,
0xec, 0x25, 0x9d, 0xb1, 0x24, 0x7e, 0x24, 0x68, 0xb1, 0xd4, 0x14, 0xb7, 0xe4, 0x4f, 0xa9, 0x61,
0x67, 0x28, 0xd6, 0xef, 0x0c, 0x30, 0xb3, 0x88, 0x2c, 0x24, 0x2f, 0xd1, 0x72, 0xc7, 0xed, 0xb1,
0x1c, 0xf4, 0xcc, 0x61, 0x51, 0xb5, 0xc7, 0x27, 0x59, 0x71, 0x03, 0xf4, 0x3e, 0x6c, 0x48, 0xc6,
0x12, 0x8c, 0xca, 0x36, 0xf9, 0xaa, 0xd8, 0xb5, 0x0b, 0x58, 0xfa, 0x0f, 0x03, 0x3a, 0xf3, 0xc2,
0x59, 0xda, 0xaa, 0x25, 0x5e, 0xd2, 0xe8, 0x1e, 0xb4, 0x95, 0x0d, 0xa3, 0x6c, 0xe1, 0xbf, 0xa6,
0xab, 0xba, 0x5c, 0xc4, 0xed, 0x56, 0x06, 0x12, 0x2f, 0x0b, 0x86, 0xd6, 0x2f, 0xa0, 0xfb, 0x03,
0x87, 0x78, 0xf4, 0xf8, 0x38, 0xa9, 0xd7, 0x0b, 0x14, 0xea, 0x07, 0xf9, 0x76, 0xe3, 0x29, 0x2e,
0xaf, 0xf5, 0xfb, 0x0a, 0x6c, 0xc4, 0xb4, 0x1d, 0x27, 0x70, 0x88, 0x8b, 0x97, 0x6f, 0x32, 0x9f,
0x0d, 0x9c, 0xde, 0x82, 0x36, 0xa3, 0xb3, 0xc8, 0xc5, 0xa3, 0x5c, 0xaf, 0xd9, 0x92, 0xc4, 0x7d,
0x79, 0xdf, 0x6e, 0x00, 0x78, 0x8c, 0x27, 0x1c, 0x0a, 0x5f, 0x3d, 0xc6, 0xd5, 0xf6, 0xab, 0xd0,
0x54, 0x32, 0x3c, 0x4a, 0xb0, 0x48, 0xc3, 0xba, 0x0d, 0x92, 0x34, 0xa0, 0x44, 0xb4, 0xa5, 0xf1,
0x79, 0xb1, 0xbb, 0x26, 0x76, 0xd7, 0x3c, 0xc6, 0xc5, 0xd6, 0x0d, 0x80, 0x47, 0x4e, 0xe0, 0x7b,
0xa2, 0x06, 0x44, 0xeb, 0xb9, 0x6e, 0x37, 0x04, 0x25, 0x0e, 0x81, 0xf5, 0x1b, 0x43, 0xe2, 0x6e,
0x3e, 0x3a, 0x17, 0x49, 0xd1, 0xf7, 0xf3, 0x29, 0xda, 0xd4, 0xa5, 0x48, 0x9f, 0x07, 0x95, 0xa9,
0xcd, 0x27, 0xd0, 0xc9, 0x3f, 0x4c, 0x50, 0x0b, 0xd6, 0xf7, 0x29, 0xff, 0xf0, 0xb1, 0xcf, 0xb8,
0xb9, 0x82, 0x3a, 0x00, 0xfb, 0x94, 0x1f, 0x44, 0x98, 0x61, 0xc2, 0x4d, 0x03, 0x01, 0xd4, 0x3f,
0x21, 0x03, 0x9f, 0x7d, 0x66, 0x56, 0xd0, 0x15, 0xf5, 0x92, 0x73, 0x82, 0x21, 0xf9, 0x18, 0x87,
0x34, 0xfa, 0xdc, 0xac, 0xc6, 0xc7, 0xd3, 0x55, 0x0d, 0x99, 0xd0, 0x4a, 0x59, 0xf6, 0x0e, 0x7e,
0x62, 0xae, 0xa2, 0x06, 0xac, 0xca, 0xcf, 0xfa, 0xe6, 0x27, 0x60, 0x16, 0x91, 0x17, 0x35, 0x61,
0x6d, 0x22, 0x2b, 0xd7, 0x5c, 0x41, 0x5d, 0x68, 0x06, 0x73, 0xeb, 0x4d, 0x23, 0x26, 0x8c, 0xa3,
0xa9, 0xab, 0xc0, 0xd7, 0xac, 0xc4, 0xda, 0xe2, 0x04, 0x0e, 0xe8, 0x29, 0x31, 0xab, 0x9b, 0x3f,
0x84, 0x56, 0xb6, 0x1d, 0x47, 0xeb, 0x50, 0xdb, 0xa7, 0x04, 0x9b, 0x2b, 0xb1, 0xd8, 0xbd, 0x88,
0x9e, 0xfa, 0x64, 0x2c, 0x7d, 0xb8, 0x17, 0xd1, 0x27, 0x98, 0x98, 0x95, 0x78, 0x83, 0x61, 0x27,
0x88, 0x37, 0xaa, 0xf1, 0x46, 0xbc, 0xc0, 0x9e, 0x59, 0xdb, 0xfe, 0x0f, 0x40, 0x4b, 0x80, 0xd7,
0xa1, 0x1c, 0x05, 0xa3, 0x29, 0xa0, 0x3d, 0xcc, 0x77, 0x69, 0x38, 0xa5, 0x24, 0xd1, 0xc0, 0xd0,
0xbb, 0x0b, 0xc6, 0xa6, 0x65, 0x56, 0x65, 0x74, 0xff, 0x1b, 0x0b, 0x4e, 0x14, 0xd8, 0xad, 0x15,
0x14, 0x0a, 0x8d, 0xf1, 0xdf, 0xfe, 0xbe, 0xef, 0x7e, 0x96, 0x8c, 0x04, 0xce, 0xd0, 0x58, 0x60,
0x4d, 0x34, 0x16, 0x6e, 0xae, 0x5a, 0x1c, 0xf2, 0xc8, 0x27, 0xe3, 0xe4, 0x45, 0x62, 0xad, 0xa0,
0x13, 0xb8, 0x1a, 0xbf, 0x56, 0xb8, 0xc3, 0x7d, 0xc6, 0x7d, 0x97, 0x25, 0x0a, 0xb7, 0x17, 0x2b,
0x2c, 0x31, 0x3f, 0xa5, 0x4a, 0x17, 0x5a, 0xd9, 0xb1, 0x36, 0x7a, 0x53, 0x57, 0xc0, 0x9a, 0xd1,
0x7b, 0xff, 0xf6, 0xf9, 0x8c, 0xa9, 0x92, 0x00, 0xba, 0x85, 0x51, 0x32, 0xd2, 0x5e, 0x14, 0xfd,
0x3c, 0xbb, 0xff, 0xf6, 0x52, 0xbc, 0xa9, 0x36, 0x1f, 0x3a, 0xf9, 0xf1, 0x2d, 0x7a, 0x6b, 0x91,
0x80, 0xd2, 0xe8, 0xac, 0xbf, 0xb9, 0x0c, 0x6b, 0xaa, 0xea, 0x01, 0x74, 0xf2, 0xb3, 0x46, 0xbd,
0x2a, 0xed, 0x3c, 0xb2, 0x7f, 0xd6, 0x8b, 0xd3, 0x5a, 0x41, 0x3f, 0x87, 0x97, 0x4a, 0x03, 0x3e,
0xf4, 0x4d, 0x7d, 0xd4, 0xf5, 0x73, 0xc0, 0xf3, 0x34, 0x28, 0xeb, 0xe7, 0x51, 0x5c, 0x6c, 0x7d,
0x69, 0xa2, 0xbb, 0xbc, 0xf5, 0x19, 0xf1, 0x67, 0x59, 0xff, 0xd4, 0x1a, 0x66, 0x80, 0xca, 0x43,
0x41, 0xf4, 0x8e, 0x4e, 0xc5, 0xc2, 0xf1, 0x63, 0x7f, 0x6b, 0x59, 0xf6, 0x34, 0xe5, 0x33, 0x01,
0x09, 0xc5, 0xf9, 0x99, 0x56, 0xed, 0xc2, 0x79, 0xa0, 0x5e, 0xed, 0xe2, 0x19, 0x99, 0x2c, 0xea,
0xfc, 0x20, 0x43, 0x9f, 0x2b, 0xed, 0xe0, 0x4a, 0x5f, 0xd4, 0xfa, 0xb9, 0x88, 0xb5, 0xb2, 0xfd,
0xc5, 0x3a, 0x34, 0x84, 0xf3, 0x02, 0x10, 0xfe, 0x0f, 0xba, 0xcf, 0x1e, 0x74, 0x1f, 0x42, 0xb7,
0x30, 0x0e, 0xd2, 0xe3, 0xa1, 0x7e, 0x66, 0x74, 0xde, 0xc5, 0x38, 0x02, 0x54, 0x9e, 0xc5, 0xe8,
0x2b, 0x74, 0xe1, 0xcc, 0xe6, 0x3c, 0x1d, 0x0f, 0xa1, 0x5b, 0x98, 0x85, 0xe8, 0x3d, 0xd0, 0x0f,
0x4c, 0xce, 0x93, 0xfe, 0x29, 0xb4, 0xb2, 0xaf, 0x62, 0xfd, 0x4f, 0x49, 0xf3, 0x6e, 0x7e, 0xf1,
0xa0, 0xf4, 0xfc, 0x41, 0xfb, 0x21, 0x74, 0x0b, 0x0f, 0x61, 0x7d, 0xe4, 0xf5, 0xaf, 0xe5, 0xf3,
0xa4, 0x7f, 0x79, 0x30, 0xb3, 0xf3, 0xfe, 0x83, 0xed, 0xb1, 0xcf, 0x27, 0xb3, 0xa3, 0xd8, 0x88,
0x3b, 0xf2, 0xe4, 0x3b, 0x3e, 0x55, 0x5f, 0x77, 0x92, 0xfb, 0x76, 0x47, 0x08, 0xbb, 0x23, 0x84,
0x4d, 0x8f, 0x8e, 0xea, 0x62, 0xf9, 0xde, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xde, 0x2e, 0x8d,
0xea, 0x88, 0x20, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

16
internal/querynode/collection_replica.go
View File

@ -25,7 +25,7 @@ import "C"
import (
"errors"
"fmt"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"strconv"
"sync"
@ -76,8 +76,8 @@ type ReplicaInterface interface {
// excluded segments
initExcludedSegments(collectionID UniqueID)
removeExcludedSegments(collectionID UniqueID)
addExcludedSegments(collectionID UniqueID, segmentInfos []*querypb.CheckPoint) error
getExcludedSegments(collectionID UniqueID) ([]*querypb.CheckPoint, error)
addExcludedSegments(collectionID UniqueID, segmentInfos []*datapb.SegmentInfo) error
getExcludedSegments(collectionID UniqueID) ([]*datapb.SegmentInfo, error)
getSegmentsBySegmentType(segType segmentType) ([]UniqueID, []UniqueID, []UniqueID)
replaceGrowingSegmentBySealedSegment(segment *Segment) error
@ -91,7 +91,7 @@ type collectionReplica struct {
partitions map[UniqueID]*Partition
segments map[UniqueID]*Segment
excludedSegments map[UniqueID][]*querypb.CheckPoint // map[collectionID]segmentIDs
excludedSegments map[UniqueID][]*datapb.SegmentInfo // map[collectionID]segmentIDs
}
//----------------------------------------------------------------------------------------------------- collection
@ -505,7 +505,7 @@ func (colReplica *collectionReplica) initExcludedSegments(collectionID UniqueID)
colReplica.mu.Lock()
defer colReplica.mu.Unlock()
colReplica.excludedSegments[collectionID] = make([]*querypb.CheckPoint, 0)
colReplica.excludedSegments[collectionID] = make([]*datapb.SegmentInfo, 0)
}
func (colReplica *collectionReplica) removeExcludedSegments(collectionID UniqueID) {
@ -515,7 +515,7 @@ func (colReplica *collectionReplica) removeExcludedSegments(collectionID UniqueI
delete(colReplica.excludedSegments, collectionID)
}
func (colReplica *collectionReplica) addExcludedSegments(collectionID UniqueID, segmentInfos []*querypb.CheckPoint) error {
func (colReplica *collectionReplica) addExcludedSegments(collectionID UniqueID, segmentInfos []*datapb.SegmentInfo) error {
colReplica.mu.Lock()
defer colReplica.mu.Unlock()
@ -527,7 +527,7 @@ func (colReplica *collectionReplica) addExcludedSegments(collectionID UniqueID,
return nil
}
func (colReplica *collectionReplica) getExcludedSegments(collectionID UniqueID) ([]*querypb.CheckPoint, error) {
func (colReplica *collectionReplica) getExcludedSegments(collectionID UniqueID) ([]*datapb.SegmentInfo, error) {
colReplica.mu.RLock()
defer colReplica.mu.RUnlock()
@ -555,7 +555,7 @@ func newCollectionReplica() ReplicaInterface {
collections := make(map[UniqueID]*Collection)
partitions := make(map[UniqueID]*Partition)
segments := make(map[UniqueID]*Segment)
excludedSegments := make(map[UniqueID][]*querypb.CheckPoint)
excludedSegments := make(map[UniqueID][]*datapb.SegmentInfo)
var replica ReplicaInterface = &collectionReplica{
collections: collections,

2
internal/querynode/flow_graph_filter_dm_node.go
View File

@ -133,7 +133,7 @@ func (fdmNode *filterDmNode) filterInvalidInsertMessage(msg *msgstream.InsertMsg
return nil
}
for _, segmentInfo := range excludedSegments {
if msg.SegmentID == segmentInfo.SegmentID && msg.EndTs() < segmentInfo.Position.Timestamp {
if msg.SegmentID == segmentInfo.ID && msg.EndTs() < segmentInfo.DmlPosition.Timestamp {
log.Debug("filter invalid insert message, segments are excluded segments",
zap.Any("collectionID", msg.CollectionID),
zap.Any("partitionID", msg.PartitionID))

10
internal/querynode/segment_loader.go
View File

@ -109,7 +109,7 @@ func (loader *segmentLoader) loadSegment(req *queryPb.LoadSegmentsRequest, onSer
func (loader *segmentLoader) loadSegmentInternal(collectionID UniqueID,
segment *Segment,
binlogPaths []*queryPb.FieldBinlog) error {
binlogPaths []*datapb.FieldBinlog) error {
vectorFieldIDs, err := loader.historicalReplica.getVecFieldIDsByCollectionID(collectionID)
if err != nil {
@ -164,8 +164,8 @@ func (loader *segmentLoader) GetSegmentStates(segmentID UniqueID) (*datapb.GetSe
return statesResponse, nil
}
func (loader *segmentLoader) filterOutVectorFields(binlogPaths []*queryPb.FieldBinlog,
vectorFields []int64) []*queryPb.FieldBinlog {
func (loader *segmentLoader) filterOutVectorFields(binlogPaths []*datapb.FieldBinlog,
vectorFields []int64) []*datapb.FieldBinlog {
containsFunc := func(s []int64, e int64) bool {
for _, a := range s {
@ -175,7 +175,7 @@ func (loader *segmentLoader) filterOutVectorFields(binlogPaths []*queryPb.FieldB
}
return false
}
targetFields := make([]*queryPb.FieldBinlog, 0)
targetFields := make([]*datapb.FieldBinlog, 0)
for _, path := range binlogPaths {
if !containsFunc(vectorFields, path.FieldID) {
targetFields = append(targetFields, path)
@ -184,7 +184,7 @@ func (loader *segmentLoader) filterOutVectorFields(binlogPaths []*queryPb.FieldB
return targetFields
}
func (loader *segmentLoader) loadSegmentFieldsData(segment *Segment, binlogPaths []*queryPb.FieldBinlog) error {
func (loader *segmentLoader) loadSegmentFieldsData(segment *Segment, binlogPaths []*datapb.FieldBinlog) error {
iCodec := storage.InsertCodec{}
defer func() {
err := iCodec.Close()

5
internal/querynode/task.go
View File

@ -23,6 +23,7 @@ import (
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
queryPb "github.com/milvus-io/milvus/internal/proto/querypb"
@ -214,9 +215,9 @@ func (w *watchDmChannelsTask) Execute(ctx context.Context) error {
log.Debug("watchDMChannel, group channels done", zap.Any("collectionID", collectionID))
// add check points info
checkPointInfos := make([]*queryPb.CheckPoint, 0)
checkPointInfos := make([]*datapb.SegmentInfo, 0)
for _, info := range w.req.Infos {
checkPointInfos = append(checkPointInfos, info.CheckPoints...)
checkPointInfos = append(checkPointInfos, info.UnflushedSegments...)
}
err = w.node.streaming.replica.addExcludedSegments(collectionID, checkPointInfos)
if err != nil {

92
internal/queryservice/task.go
View File

@ -143,12 +143,13 @@ func (lct *LoadCollectionTask) Execute(ctx context.Context) error {
partitionIDs := showPartitionResponse.PartitionIDs
log.Debug("partitionIDs", zap.Int64s("partitionIDs", partitionIDs))
for _, partitionID := range partitionIDs {
getRecoveryInfoRequest := &querypb.GetRecoveryInfoRequest{
getRecoveryInfoRequest := &datapb.GetRecoveryInfoRequest{
Base: lct.Base,
CollectionID: collectionID,
PartitionID: partitionID,
}
recoveryInfo, err := mockGetRecoveryInfoFromDataService(lct.ctx, lct.masterService, lct.dataService, getRecoveryInfoRequest)
//recoveryInfo, err := mockGetRecoveryInfoFromDataService(lct.ctx, lct.masterService, lct.dataService, getRecoveryInfoRequest)
recoveryInfo, err := lct.dataService.GetRecoveryInfo(lct.ctx, getRecoveryInfoRequest)
if err != nil {
status.Reason = err.Error()
lct.result = status
@ -161,7 +162,7 @@ func (lct *LoadCollectionTask) Execute(ctx context.Context) error {
SegmentID: segmentBingLog.SegmentID,
PartitionID: partitionID,
CollectionID: collectionID,
BinlogPaths: make([]*querypb.FieldBinlog, 0),
BinlogPaths: make([]*datapb.FieldBinlog, 0),
}
segmentLoadInfo.BinlogPaths = append(segmentLoadInfo.BinlogPaths, segmentBingLog.FieldBinlogs...)
segmentsToLoad = append(segmentsToLoad, segmentID)
@ -174,7 +175,7 @@ func (lct *LoadCollectionTask) Execute(ctx context.Context) error {
watchRequest := &querypb.WatchDmChannelsRequest{
Base: lct.Base,
CollectionID: collectionID,
Infos: []*querypb.VchannelInfo{info},
Infos: []*datapb.VchannelInfo{info},
Schema: lct.Schema,
}
watchRequests[channel] = watchRequest
@ -183,7 +184,7 @@ func (lct *LoadCollectionTask) Execute(ctx context.Context) error {
}
oldInfo := watchRequests[channel].Infos[0]
newInfo := mergeVChannelInfo(oldInfo, info)
watchRequests[channel].Infos = []*querypb.VchannelInfo{newInfo}
watchRequests[channel].Infos = []*datapb.VchannelInfo{newInfo}
}
}
@ -404,12 +405,13 @@ func (lpt *LoadPartitionTask) Execute(ctx context.Context) error {
channelsToWatch := make([]string, 0)
watchRequests := make([]*querypb.WatchDmChannelsRequest, 0)
for _, partitionID := range partitionIDs {
getRecoveryInfoRequest := &querypb.GetRecoveryInfoRequest{
getRecoveryInfoRequest := &datapb.GetRecoveryInfoRequest{
Base: lpt.Base,
CollectionID: collectionID,
PartitionID: partitionID,
}
recoveryInfo, err := mockGetRecoveryInfoFromDataService(lpt.ctx, lpt.masterService, lpt.dataService, getRecoveryInfoRequest)
//recoveryInfo, err := mockGetRecoveryInfoFromDataService(lpt.ctx, lpt.masterService, lpt.dataService, getRecoveryInfoRequest)
recoveryInfo, err := lpt.dataService.GetRecoveryInfo(lpt.ctx, getRecoveryInfoRequest)
if err != nil {
status.Reason = err.Error()
lpt.result = status
@ -422,7 +424,7 @@ func (lpt *LoadPartitionTask) Execute(ctx context.Context) error {
SegmentID: segmentID,
PartitionID: partitionID,
CollectionID: collectionID,
BinlogPaths: make([]*querypb.FieldBinlog, 0),
BinlogPaths: make([]*datapb.FieldBinlog, 0),
}
segmentLoadInfo.BinlogPaths = append(segmentLoadInfo.BinlogPaths, segmentBingLog.FieldBinlogs...)
segmentsToLoad = append(segmentsToLoad, segmentID)
@ -435,7 +437,7 @@ func (lpt *LoadPartitionTask) Execute(ctx context.Context) error {
Base: lpt.Base,
CollectionID: collectionID,
PartitionID: partitionID,
Infos: []*querypb.VchannelInfo{info},
Infos: []*datapb.VchannelInfo{info},
Schema: lpt.Schema,
}
channelsToWatch = append(channelsToWatch, channel)
@ -777,6 +779,7 @@ func (aqt *WatchQueryChannelTask) Execute(ctx context.Context) error {
zap.String("queryResultChannel", aqt.ResultChannelID))
return nil
}
func (aqt *WatchQueryChannelTask) PostExecute(ctx context.Context) error {
log.Debug("WatchQueryChannelTask postExecute done",
zap.Int64("collectionID", aqt.CollectionID),
@ -788,7 +791,7 @@ func (aqt *WatchQueryChannelTask) PostExecute(ctx context.Context) error {
func mockGetRecoveryInfoFromDataService(ctx context.Context,
master types.MasterService,
dataService types.DataService,
req *querypb.GetRecoveryInfoRequest) (*querypb.GetRecoveryInfoResponse, error) {
req *datapb.GetRecoveryInfoRequest) (*datapb.GetRecoveryInfoResponse, error) {
segmentIDs := make([]UniqueID, 0)
showSegmentRequest := &milvuspb.ShowSegmentsRequest{
Base: &commonpb.MsgBase{
@ -827,17 +830,17 @@ func mockGetRecoveryInfoFromDataService(ctx context.Context,
channel2Segments[channelName] = append(channel2Segments[channelName], segmentID)
}
}
channelInfos := make([]*querypb.VchannelInfo, 0)
segmentBinlogs := make([]*querypb.SegmentBinlogs, 0)
channelInfos := make([]*datapb.VchannelInfo, 0)
segmentBinlogs := make([]*datapb.SegmentBinlogs, 0)
for channel, segmentIDs := range channel2Segments {
channelInfo := &querypb.VchannelInfo{
channelInfo := &datapb.VchannelInfo{
CollectionID: req.CollectionID,
ChannelName: channel,
SeekPosition: &internalpb.MsgPosition{
ChannelName: channel,
},
CheckPoints: make([]*querypb.CheckPoint, 0),
FlushedSegments: make([]UniqueID, 0),
UnflushedSegments: make([]*datapb.SegmentInfo, 0),
FlushedSegments: make([]UniqueID, 0),
}
sort.Slice(segmentIDs, func(i, j int) bool {
return segmentIDs[i] < segmentIDs[j]
@ -849,22 +852,22 @@ func mockGetRecoveryInfoFromDataService(ctx context.Context,
continue
}
if segmentStates[id].StartPosition != nil {
checkpoint := &querypb.CheckPoint{
SegmentID: id,
Position: segmentStates[id].StartPosition,
checkpoint := &datapb.SegmentInfo{
ID: id,
DmlPosition: segmentStates[id].StartPosition,
}
channelInfo.CheckPoints = append(channelInfo.CheckPoints, checkpoint)
if checkpoint.Position.Timestamp < channelInfo.SeekPosition.Timestamp || channelInfo.SeekPosition.Timestamp == 0 {
channelInfo.SeekPosition = checkpoint.Position
channelInfo.UnflushedSegments = append(channelInfo.UnflushedSegments, checkpoint)
if checkpoint.DmlPosition.Timestamp < channelInfo.SeekPosition.Timestamp || channelInfo.SeekPosition.Timestamp == 0 {
channelInfo.SeekPosition = checkpoint.DmlPosition
}
}
}
channelInfos = append(channelInfos, channelInfo)
for _, id := range channelInfo.FlushedSegments {
segmentBinlog := &querypb.SegmentBinlogs{
segmentBinlog := &datapb.SegmentBinlogs{
SegmentID: id,
FieldBinlogs: make([]*querypb.FieldBinlog, 0),
FieldBinlogs: make([]*datapb.FieldBinlog, 0),
}
insertBinlogPathRequest := &datapb.GetInsertBinlogPathsRequest{
SegmentID: id,
@ -882,7 +885,7 @@ func mockGetRecoveryInfoFromDataService(ctx context.Context,
if len(pathResponse.Paths[index].Values) == 0 {
continue
}
fieldBingLog := &querypb.FieldBinlog{
fieldBingLog := &datapb.FieldBinlog{
FieldID: fieldID,
Binlogs: pathResponse.Paths[index].Values,
}
@ -911,7 +914,7 @@ func mockGetRecoveryInfoFromDataService(ctx context.Context,
return nil, err
}
for _, channel := range desColRsp.VirtualChannelNames {
channelInfo := &querypb.VchannelInfo{
channelInfo := &datapb.VchannelInfo{
CollectionID: req.CollectionID,
ChannelName: channel,
}
@ -919,8 +922,10 @@ func mockGetRecoveryInfoFromDataService(ctx context.Context,
}
}
return &querypb.GetRecoveryInfoResponse{
Base: req.Base,
return &datapb.GetRecoveryInfoResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
Channels: channelInfos,
Binlogs: segmentBinlogs,
}, nil
@ -1015,28 +1020,35 @@ func shuffleSegmentsToQueryNode(segmentIDs []UniqueID, cluster *queryNodeCluster
}
}
func mergeVChannelInfo(info1 *querypb.VchannelInfo, info2 *querypb.VchannelInfo) *querypb.VchannelInfo {
func mergeVChannelInfo(info1 *datapb.VchannelInfo, info2 *datapb.VchannelInfo) *datapb.VchannelInfo {
collectionID := info1.CollectionID
channelName := info1.ChannelName
seekPosition := info1.SeekPosition
if info1.SeekPosition.Timestamp > info2.SeekPosition.Timestamp {
seekPosition = info2.SeekPosition
var seekPosition *internalpb.MsgPosition
if info1.SeekPosition == nil || info2.SeekPosition == nil {
seekPosition = &internalpb.MsgPosition{
ChannelName: channelName,
}
} else {
seekPosition = info1.SeekPosition
if info1.SeekPosition.Timestamp > info2.SeekPosition.Timestamp {
seekPosition = info2.SeekPosition
}
}
checkPoints := make([]*querypb.CheckPoint, 0)
checkPoints = append(checkPoints, info1.CheckPoints...)
checkPoints = append(checkPoints, info2.CheckPoints...)
checkPoints := make([]*datapb.SegmentInfo, 0)
checkPoints = append(checkPoints, info1.UnflushedSegments...)
checkPoints = append(checkPoints, info2.UnflushedSegments...)
flushedSegments := make([]UniqueID, 0)
flushedSegments = append(flushedSegments, info1.FlushedSegments...)
flushedSegments = append(flushedSegments, info2.FlushedSegments...)
return &querypb.VchannelInfo{
CollectionID: collectionID,
ChannelName: channelName,
SeekPosition: seekPosition,
CheckPoints: checkPoints,
FlushedSegments: flushedSegments,
return &datapb.VchannelInfo{
CollectionID: collectionID,
ChannelName: channelName,
SeekPosition: seekPosition,
UnflushedSegments: checkPoints,
FlushedSegments: flushedSegments,
}
}