diff --git a/internal/proto/query_service.proto b/internal/proto/query_service.proto index 962b77c506..a9b2631bdb 100644 --- a/internal/proto/query_service.proto +++ b/internal/proto/query_service.proto @@ -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; -} - diff --git a/internal/proto/querypb/query_service.pb.go b/internal/proto/querypb/query_service.pb.go index 615b00a350..699c0cd84e 100644 --- a/internal/proto/querypb/query_service.pb.go +++ b/internal/proto/querypb/query_service.pb.go @@ -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. diff --git a/internal/querynode/collection_replica.go b/internal/querynode/collection_replica.go index f7037f6b10..00bc4ab1bf 100644 --- a/internal/querynode/collection_replica.go +++ b/internal/querynode/collection_replica.go @@ -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, diff --git a/internal/querynode/flow_graph_filter_dm_node.go b/internal/querynode/flow_graph_filter_dm_node.go index 12cec86503..a10cd82413 100644 --- a/internal/querynode/flow_graph_filter_dm_node.go +++ b/internal/querynode/flow_graph_filter_dm_node.go @@ -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)) diff --git a/internal/querynode/segment_loader.go b/internal/querynode/segment_loader.go index 21b351f4c6..b9a7d4e851 100644 --- a/internal/querynode/segment_loader.go +++ b/internal/querynode/segment_loader.go @@ -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() diff --git a/internal/querynode/task.go b/internal/querynode/task.go index dce09e4777..890e810f6e 100644 --- a/internal/querynode/task.go +++ b/internal/querynode/task.go @@ -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 { diff --git a/internal/queryservice/task.go b/internal/queryservice/task.go index 7760d6cb19..a2de58ea2d 100644 --- a/internal/queryservice/task.go +++ b/internal/queryservice/task.go @@ -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, } }