From cb96314fe7885c1ed8cfb9e0b990a69a868495c7 Mon Sep 17 00:00:00 2001 From: "cai.zhang" Date: Tue, 14 Mar 2023 21:47:55 +0800 Subject: [PATCH] Support get segment info without binlog path (#22741) Signed-off-by: cai.zhang --- internal/datacoord/server_test.go | 99 ++ internal/datacoord/services.go | 33 + .../distributed/datacoord/client/client.go | 13 + .../datacoord/client/client_test.go | 3 + internal/distributed/datacoord/service.go | 4 + .../distributed/datacoord/service_test.go | 14 + internal/distributed/proxy/service_test.go | 4 + internal/indexcoord/handoff.go | 2 +- internal/indexcoord/index_coord.go | 8 +- internal/indexcoord/index_coord_mock.go | 5 + internal/indexcoord/index_coord_test.go | 44 +- internal/indexcoord/task.go | 2 +- internal/mocks/mock_datacoord.go | 181 ++-- internal/proto/data_coord.proto | 14 +- internal/proto/datapb/data_coord.pb.go | 849 ++++++++++-------- internal/types/types.go | 9 + internal/util/mock/grpc_datacoord_client.go | 5 +- 17 files changed, 856 insertions(+), 433 deletions(-) diff --git a/internal/datacoord/server_test.go b/internal/datacoord/server_test.go index 69827a738a..201ef4bc68 100644 --- a/internal/datacoord/server_test.go +++ b/internal/datacoord/server_test.go @@ -684,6 +684,105 @@ func TestGetSegmentInfo(t *testing.T) { }) } +func TestServer_ListSegmentsInfo(t *testing.T) { + t.Run("normal case", func(t *testing.T) { + svr := newTestServer(t, nil) + defer closeTestServer(t, svr) + + segInfo := &datapb.SegmentInfo{ + ID: 0, + State: commonpb.SegmentState_Flushed, + NumOfRows: 100, + Binlogs: []*datapb.FieldBinlog{ + { + FieldID: 1, + Binlogs: []*datapb.Binlog{ + { + EntriesNum: 20, + LogPath: metautil.BuildInsertLogPath("a", 0, 0, 0, 1, 801), + }, + { + EntriesNum: 20, + LogPath: metautil.BuildInsertLogPath("a", 0, 0, 0, 1, 802), + }, + { + EntriesNum: 20, + LogPath: metautil.BuildInsertLogPath("a", 0, 0, 0, 1, 803), + }, + }, + }, + }, + } + err := svr.meta.AddSegment(NewSegmentInfo(segInfo)) + assert.Nil(t, err) + + req := &datapb.ListSegmentsInfoRequest{ + SegmentIDs: []int64{0}, + } + resp, err := svr.ListSegmentsInfo(svr.ctx, req) + assert.Equal(t, 1, len(resp.GetInfos())) + // Check that # of rows is corrected from 100 to 60. + assert.EqualValues(t, 60, resp.GetInfos()[0].GetNumOfRows()) + assert.Nil(t, err) + assert.Equal(t, 0, len(resp.GetInfos()[0].GetBinlogs())) + assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode) + }) + t.Run("with wrong segment id", func(t *testing.T) { + svr := newTestServer(t, nil) + defer closeTestServer(t, svr) + + segInfo := &datapb.SegmentInfo{ + ID: 0, + State: commonpb.SegmentState_Flushed, + } + err := svr.meta.AddSegment(NewSegmentInfo(segInfo)) + assert.Nil(t, err) + + req := &datapb.ListSegmentsInfoRequest{ + SegmentIDs: []int64{0, 1}, + } + resp, err := svr.ListSegmentsInfo(svr.ctx, req) + assert.Nil(t, err) + assert.EqualValues(t, commonpb.ErrorCode_UnexpectedError, resp.Status.ErrorCode) + }) + t.Run("with closed server", func(t *testing.T) { + svr := newTestServer(t, nil) + closeTestServer(t, svr) + resp, err := svr.ListSegmentsInfo(context.Background(), &datapb.ListSegmentsInfoRequest{ + SegmentIDs: []int64{}, + }) + assert.Nil(t, err) + assert.Equal(t, commonpb.ErrorCode_NotReadyServe, resp.GetStatus().GetErrorCode()) + }) + t.Run("with dropped segment", func(t *testing.T) { + svr := newTestServer(t, nil) + defer closeTestServer(t, svr) + + segInfo := &datapb.SegmentInfo{ + ID: 0, + State: commonpb.SegmentState_Dropped, + } + err := svr.meta.AddSegment(NewSegmentInfo(segInfo)) + assert.Nil(t, err) + + req := &datapb.ListSegmentsInfoRequest{ + SegmentIDs: []int64{0}, + IncludeUnHealthy: false, + } + resp, err := svr.ListSegmentsInfo(svr.ctx, req) + assert.Nil(t, err) + assert.Equal(t, 0, len(resp.Infos)) + + req = &datapb.ListSegmentsInfoRequest{ + SegmentIDs: []int64{0}, + IncludeUnHealthy: true, + } + resp2, err := svr.ListSegmentsInfo(svr.ctx, req) + assert.Nil(t, err) + assert.Equal(t, 1, len(resp2.Infos)) + }) +} + func TestGetComponentStates(t *testing.T) { svr := &Server{} resp, err := svr.GetComponentStates(context.Background()) diff --git a/internal/datacoord/services.go b/internal/datacoord/services.go index f9977beed6..c01736f982 100644 --- a/internal/datacoord/services.go +++ b/internal/datacoord/services.go @@ -384,6 +384,39 @@ func (s *Server) GetSegmentInfo(ctx context.Context, req *datapb.GetSegmentInfoR return resp, nil } +func (s *Server) ListSegmentsInfo(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { + resp := &datapb.ListSegmentsInfoResponse{ + Status: &commonpb.Status{ + ErrorCode: commonpb.ErrorCode_UnexpectedError, + }, + } + if s.isClosed() { + setNotServingStatus(resp.Status, s.GetStateCode()) + return resp, nil + } + infos := make([]*datapb.SegmentInfo, 0, len(req.GetSegmentIDs())) + for _, id := range req.SegmentIDs { + var info *SegmentInfo + var clonedInfo *SegmentInfo + info = s.meta.GetSegment(id) + if info == nil || (!req.GetIncludeUnHealthy() && !isSegmentHealthy(info)) { + log.Warn("failed to get segment, this may have been cleaned", zap.Int64("segmentID", id)) + resp.Status.Reason = msgSegmentNotFound(id) + return resp, nil + } + clonedInfo = info.Clone() + segmentutil.ReCalcRowCount(info.SegmentInfo, clonedInfo.SegmentInfo) + // don't return binlog + clonedInfo.Binlogs = nil + clonedInfo.Statslogs = nil + clonedInfo.Deltalogs = nil + infos = append(infos, clonedInfo.SegmentInfo) + } + resp.Status.ErrorCode = commonpb.ErrorCode_Success + resp.Infos = infos + return resp, nil +} + // SaveBinlogPaths updates segment related binlog path // works for Checkpoints and Flush func (s *Server) SaveBinlogPaths(ctx context.Context, req *datapb.SaveBinlogPathsRequest) (*commonpb.Status, error) { diff --git a/internal/distributed/datacoord/client/client.go b/internal/distributed/datacoord/client/client.go index ff9ca3babe..ec1593e75f 100644 --- a/internal/distributed/datacoord/client/client.go +++ b/internal/distributed/datacoord/client/client.go @@ -809,3 +809,16 @@ func (c *Client) GcConfirm(ctx context.Context, req *datapb.GcConfirmRequest) (* } return ret.(*datapb.GcConfirmResponse), err } + +func (c *Client) ListSegmentsInfo(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { + ret, err := c.grpcClient.ReCall(ctx, func(client datapb.DataCoordClient) (any, error) { + if !funcutil.CheckCtxValid(ctx) { + return nil, ctx.Err() + } + return client.ListSegmentsInfo(ctx, req) + }) + if err != nil || ret == nil { + return nil, err + } + return ret.(*datapb.ListSegmentsInfoResponse), err +} diff --git a/internal/distributed/datacoord/client/client_test.go b/internal/distributed/datacoord/client/client_test.go index 1590b4999d..84a1b165ac 100644 --- a/internal/distributed/datacoord/client/client_test.go +++ b/internal/distributed/datacoord/client/client_test.go @@ -153,6 +153,9 @@ func Test_NewClient(t *testing.T) { r31, err := client.ShowConfigurations(ctx, nil) retCheck(retNotNil, r31, err) + r32, err := client.ListSegmentsInfo(ctx, nil) + retCheck(retNotNil, r32, err) + { ret, err := client.BroadcastAlteredCollection(ctx, nil) retCheck(retNotNil, ret, err) diff --git a/internal/distributed/datacoord/service.go b/internal/distributed/datacoord/service.go index 82451a5f19..9ff7c84b0d 100644 --- a/internal/distributed/datacoord/service.go +++ b/internal/distributed/datacoord/service.go @@ -422,3 +422,7 @@ func (s *Server) CheckHealth(ctx context.Context, req *milvuspb.CheckHealthReque func (s *Server) GcConfirm(ctx context.Context, request *datapb.GcConfirmRequest) (*datapb.GcConfirmResponse, error) { return s.dataCoord.GcConfirm(ctx, request) } + +func (s *Server) ListSegmentsInfo(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { + return s.dataCoord.ListSegmentsInfo(ctx, req) +} diff --git a/internal/distributed/datacoord/service_test.go b/internal/distributed/datacoord/service_test.go index e8dab3347a..e34b24b92b 100644 --- a/internal/distributed/datacoord/service_test.go +++ b/internal/distributed/datacoord/service_test.go @@ -71,6 +71,7 @@ type MockDataCoord struct { unsetIsImportingStateResp *commonpb.Status markSegmentsDroppedResp *commonpb.Status broadCastResp *commonpb.Status + listSegmentsInfoResp *datapb.ListSegmentsInfoResponse } func (m *MockDataCoord) Init() error { @@ -237,6 +238,10 @@ func (m *MockDataCoord) CheckHealth(ctx context.Context, req *milvuspb.CheckHeal }, nil } +func (m *MockDataCoord) ListSegmentsInfo(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { + return m.listSegmentsInfoResp, nil +} + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// func Test_NewServer(t *testing.T) { ctx := context.Background() @@ -557,6 +562,15 @@ func Test_NewServer(t *testing.T) { assert.NotNil(t, resp) }) + t.Run("list segments info", func(t *testing.T) { + server.dataCoord = &MockDataCoord{ + listSegmentsInfoResp: &datapb.ListSegmentsInfoResponse{}, + } + resp, err := server.ListSegmentsInfo(ctx, nil) + assert.Nil(t, err) + assert.NotNil(t, resp) + }) + t.Run("CheckHealth", func(t *testing.T) { server.dataCoord = &MockDataCoord{} ret, err := server.CheckHealth(ctx, nil) diff --git a/internal/distributed/proxy/service_test.go b/internal/distributed/proxy/service_test.go index 8362a794eb..39338513e8 100644 --- a/internal/distributed/proxy/service_test.go +++ b/internal/distributed/proxy/service_test.go @@ -652,6 +652,10 @@ func (m *MockDataCoord) GcConfirm(ctx context.Context, req *datapb.GcConfirmRequ return nil, nil } +func (m *MockDataCoord) ListSegmentsInfo(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { + return nil, nil +} + // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// type MockProxy struct { MockBase diff --git a/internal/indexcoord/handoff.go b/internal/indexcoord/handoff.go index 12d0c06fbc..1180ec6404 100644 --- a/internal/indexcoord/handoff.go +++ b/internal/indexcoord/handoff.go @@ -206,7 +206,7 @@ func (hd *handoff) process(segID UniqueID) { return } if state.state == commonpb.IndexState_Finished { - log.Ctx(hd.ctx).Debug("build index for segment success, write handoff event...", zap.Int64("segID", segID)) + log.Ctx(hd.ctx).Info("build index for segment success, write handoff event...", zap.Int64("segID", segID)) info, err := hd.ic.pullSegmentInfo(hd.ctx, segID) if err != nil { if errors.Is(err, ErrSegmentNotFound) { diff --git a/internal/indexcoord/index_coord.go b/internal/indexcoord/index_coord.go index fc8678850b..f6c9b5c106 100644 --- a/internal/indexcoord/index_coord.go +++ b/internal/indexcoord/index_coord.go @@ -684,8 +684,8 @@ func (i *IndexCoord) GetIndexBuildProgress(ctx context.Context, req *indexpb.Get }, err } - resp, err := i.dataCoordClient.GetSegmentInfo(ctx, &datapb.GetSegmentInfoRequest{ - SegmentIDs: flushSegments.Segments, + resp, err := i.dataCoordClient.ListSegmentsInfo(ctx, &datapb.ListSegmentsInfoRequest{ + SegmentIDs: flushSegments.GetSegments(), IncludeUnHealthy: true, }) if err != nil { @@ -890,8 +890,8 @@ func (i *IndexCoord) DescribeIndex(ctx context.Context, req *indexpb.DescribeInd return ret, nil } - resp, err := i.dataCoordClient.GetSegmentInfo(ctx, &datapb.GetSegmentInfoRequest{ - SegmentIDs: flushedSegmentR.Segments, + resp, err := i.dataCoordClient.ListSegmentsInfo(ctx, &datapb.ListSegmentsInfoRequest{ + SegmentIDs: flushedSegmentR.GetSegments(), IncludeUnHealthy: true, }) if err != nil { diff --git a/internal/indexcoord/index_coord_mock.go b/internal/indexcoord/index_coord_mock.go index dcde5144ba..acbba0a022 100644 --- a/internal/indexcoord/index_coord_mock.go +++ b/internal/indexcoord/index_coord_mock.go @@ -379,6 +379,7 @@ type DataCoordMock struct { CallGetFlushedSegment func(ctx context.Context, req *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error) CallAcquireSegmentLock func(ctx context.Context, req *datapb.AcquireSegmentLockRequest) (*commonpb.Status, error) CallReleaseSegmentLock func(ctx context.Context, req *datapb.ReleaseSegmentLockRequest) (*commonpb.Status, error) + CallListSegmentsInfo func(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) } func (dcm *DataCoordMock) Init() error { @@ -418,6 +419,10 @@ func (dcm *DataCoordMock) GetFlushedSegments(ctx context.Context, req *datapb.Ge return dcm.CallGetFlushedSegment(ctx, req) } +func (dcm *DataCoordMock) ListSegmentsInfo(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { + return dcm.CallListSegmentsInfo(ctx, req) +} + func NewDataCoordMock() *DataCoordMock { return &DataCoordMock{ CallInit: func() error { diff --git a/internal/indexcoord/index_coord_test.go b/internal/indexcoord/index_coord_test.go index fe8a55e912..72b94d1dc0 100644 --- a/internal/indexcoord/index_coord_test.go +++ b/internal/indexcoord/index_coord_test.go @@ -185,6 +185,40 @@ func testIndexCoord(t *testing.T) { ErrorCode: commonpb.ErrorCode_Success, }, nil }, + CallListSegmentsInfo: func(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { + segmentInfos := make([]*datapb.SegmentInfo, 0) + for _, segID := range req.SegmentIDs { + segmentInfos = append(segmentInfos, &datapb.SegmentInfo{ + ID: segID, + CollectionID: collID, + PartitionID: partID, + NumOfRows: 10240, + State: commonpb.SegmentState_Flushed, + StartPosition: &internalpb.MsgPosition{ + Timestamp: createTs, + }, + Binlogs: []*datapb.FieldBinlog{ + { + FieldID: fieldID, + Binlogs: []*datapb.Binlog{ + { + LogPath: "file1", + }, + { + LogPath: "file2", + }, + }, + }, + }, + }) + } + return &datapb.ListSegmentsInfoResponse{ + Status: &commonpb.Status{ + ErrorCode: commonpb.ErrorCode_Success, + }, + Infos: segmentInfos, + }, nil + }, } err = ic.SetDataCoord(dcm) assert.Nil(t, err) @@ -388,7 +422,7 @@ func testIndexCoord(t *testing.T) { dcm.CallGetFlushedSegment = getFlushedSegmentsMock([]int64{111, 222, 333}) dcm.SetFunc(func() { - dcm.CallGetSegmentInfo = func(ctx context.Context, req *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) { + dcm.CallListSegmentsInfo = func(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { return nil, errors.New("mock error") } }) @@ -397,8 +431,8 @@ func testIndexCoord(t *testing.T) { assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode) dcm.SetFunc(func() { - dcm.CallGetSegmentInfo = func(ctx context.Context, req *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) { - return &datapb.GetSegmentInfoResponse{ + dcm.CallListSegmentsInfo = func(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { + return &datapb.ListSegmentsInfoResponse{ Status: &commonpb.Status{ ErrorCode: commonpb.ErrorCode_UnexpectedError, Reason: "mock fail", @@ -411,8 +445,8 @@ func testIndexCoord(t *testing.T) { assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode) dcm.SetFunc(func() { - dcm.CallGetSegmentInfo = func(ctx context.Context, req *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) { - return &datapb.GetSegmentInfoResponse{ + dcm.CallListSegmentsInfo = func(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { + return &datapb.ListSegmentsInfoResponse{ Infos: []*datapb.SegmentInfo{ {ID: 222, State: commonpb.SegmentState_Flushed, NumOfRows: 2048}, {ID: 333, State: commonpb.SegmentState_Flushed, NumOfRows: 2048}, diff --git a/internal/indexcoord/task.go b/internal/indexcoord/task.go index 46f94acea0..ef56f85b48 100644 --- a/internal/indexcoord/task.go +++ b/internal/indexcoord/task.go @@ -221,7 +221,7 @@ func (cit *CreateIndexTask) Execute(ctx context.Context) error { log.Info("IndexCoord get flushed segment from DataCoord success", zap.Int64("collectionID", cit.req.CollectionID), zap.Int64s("flushed segments", flushedSegments.Segments)) - segmentsInfo, err := cit.dataCoordClient.GetSegmentInfo(cit.ctx, &datapb.GetSegmentInfoRequest{ + segmentsInfo, err := cit.dataCoordClient.ListSegmentsInfo(cit.ctx, &datapb.ListSegmentsInfoRequest{ SegmentIDs: flushedSegments.Segments, IncludeUnHealthy: true, }) diff --git a/internal/mocks/mock_datacoord.go b/internal/mocks/mock_datacoord.go index 4e811823bd..724a266317 100644 --- a/internal/mocks/mock_datacoord.go +++ b/internal/mocks/mock_datacoord.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.15.0. DO NOT EDIT. +// Code generated by mockery v2.16.0. DO NOT EDIT. package mocks @@ -58,8 +58,8 @@ type DataCoord_AcquireSegmentLock_Call struct { } // AcquireSegmentLock is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.AcquireSegmentLockRequest +// - ctx context.Context +// - req *datapb.AcquireSegmentLockRequest func (_e *DataCoord_Expecter) AcquireSegmentLock(ctx interface{}, req interface{}) *DataCoord_AcquireSegmentLock_Call { return &DataCoord_AcquireSegmentLock_Call{Call: _e.mock.On("AcquireSegmentLock", ctx, req)} } @@ -105,8 +105,8 @@ type DataCoord_AssignSegmentID_Call struct { } // AssignSegmentID is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.AssignSegmentIDRequest +// - ctx context.Context +// - req *datapb.AssignSegmentIDRequest func (_e *DataCoord_Expecter) AssignSegmentID(ctx interface{}, req interface{}) *DataCoord_AssignSegmentID_Call { return &DataCoord_AssignSegmentID_Call{Call: _e.mock.On("AssignSegmentID", ctx, req)} } @@ -152,8 +152,8 @@ type DataCoord_BroadcastAlteredCollection_Call struct { } // BroadcastAlteredCollection is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.AlterCollectionRequest +// - ctx context.Context +// - req *datapb.AlterCollectionRequest func (_e *DataCoord_Expecter) BroadcastAlteredCollection(ctx interface{}, req interface{}) *DataCoord_BroadcastAlteredCollection_Call { return &DataCoord_BroadcastAlteredCollection_Call{Call: _e.mock.On("BroadcastAlteredCollection", ctx, req)} } @@ -199,8 +199,8 @@ type DataCoord_CheckHealth_Call struct { } // CheckHealth is a helper method to define mock.On call -// - ctx context.Context -// - req *milvuspb.CheckHealthRequest +// - ctx context.Context +// - req *milvuspb.CheckHealthRequest func (_e *DataCoord_Expecter) CheckHealth(ctx interface{}, req interface{}) *DataCoord_CheckHealth_Call { return &DataCoord_CheckHealth_Call{Call: _e.mock.On("CheckHealth", ctx, req)} } @@ -246,8 +246,8 @@ type DataCoord_DropVirtualChannel_Call struct { } // DropVirtualChannel is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.DropVirtualChannelRequest +// - ctx context.Context +// - req *datapb.DropVirtualChannelRequest func (_e *DataCoord_Expecter) DropVirtualChannel(ctx interface{}, req interface{}) *DataCoord_DropVirtualChannel_Call { return &DataCoord_DropVirtualChannel_Call{Call: _e.mock.On("DropVirtualChannel", ctx, req)} } @@ -293,8 +293,8 @@ type DataCoord_Flush_Call struct { } // Flush is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.FlushRequest +// - ctx context.Context +// - req *datapb.FlushRequest func (_e *DataCoord_Expecter) Flush(ctx interface{}, req interface{}) *DataCoord_Flush_Call { return &DataCoord_Flush_Call{Call: _e.mock.On("Flush", ctx, req)} } @@ -340,8 +340,8 @@ type DataCoord_GcConfirm_Call struct { } // GcConfirm is a helper method to define mock.On call -// - ctx context.Context -// - request *datapb.GcConfirmRequest +// - ctx context.Context +// - request *datapb.GcConfirmRequest func (_e *DataCoord_Expecter) GcConfirm(ctx interface{}, request interface{}) *DataCoord_GcConfirm_Call { return &DataCoord_GcConfirm_Call{Call: _e.mock.On("GcConfirm", ctx, request)} } @@ -387,8 +387,8 @@ type DataCoord_GetCollectionStatistics_Call struct { } // GetCollectionStatistics is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.GetCollectionStatisticsRequest +// - ctx context.Context +// - req *datapb.GetCollectionStatisticsRequest func (_e *DataCoord_Expecter) GetCollectionStatistics(ctx interface{}, req interface{}) *DataCoord_GetCollectionStatistics_Call { return &DataCoord_GetCollectionStatistics_Call{Call: _e.mock.On("GetCollectionStatistics", ctx, req)} } @@ -434,8 +434,8 @@ type DataCoord_GetCompactionState_Call struct { } // GetCompactionState is a helper method to define mock.On call -// - ctx context.Context -// - req *milvuspb.GetCompactionStateRequest +// - ctx context.Context +// - req *milvuspb.GetCompactionStateRequest func (_e *DataCoord_Expecter) GetCompactionState(ctx interface{}, req interface{}) *DataCoord_GetCompactionState_Call { return &DataCoord_GetCompactionState_Call{Call: _e.mock.On("GetCompactionState", ctx, req)} } @@ -481,8 +481,8 @@ type DataCoord_GetCompactionStateWithPlans_Call struct { } // GetCompactionStateWithPlans is a helper method to define mock.On call -// - ctx context.Context -// - req *milvuspb.GetCompactionPlansRequest +// - ctx context.Context +// - req *milvuspb.GetCompactionPlansRequest func (_e *DataCoord_Expecter) GetCompactionStateWithPlans(ctx interface{}, req interface{}) *DataCoord_GetCompactionStateWithPlans_Call { return &DataCoord_GetCompactionStateWithPlans_Call{Call: _e.mock.On("GetCompactionStateWithPlans", ctx, req)} } @@ -528,7 +528,7 @@ type DataCoord_GetComponentStates_Call struct { } // GetComponentStates is a helper method to define mock.On call -// - ctx context.Context +// - ctx context.Context func (_e *DataCoord_Expecter) GetComponentStates(ctx interface{}) *DataCoord_GetComponentStates_Call { return &DataCoord_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", ctx)} } @@ -574,8 +574,8 @@ type DataCoord_GetFlushState_Call struct { } // GetFlushState is a helper method to define mock.On call -// - ctx context.Context -// - req *milvuspb.GetFlushStateRequest +// - ctx context.Context +// - req *milvuspb.GetFlushStateRequest func (_e *DataCoord_Expecter) GetFlushState(ctx interface{}, req interface{}) *DataCoord_GetFlushState_Call { return &DataCoord_GetFlushState_Call{Call: _e.mock.On("GetFlushState", ctx, req)} } @@ -621,8 +621,8 @@ type DataCoord_GetFlushedSegments_Call struct { } // GetFlushedSegments is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.GetFlushedSegmentsRequest +// - ctx context.Context +// - req *datapb.GetFlushedSegmentsRequest func (_e *DataCoord_Expecter) GetFlushedSegments(ctx interface{}, req interface{}) *DataCoord_GetFlushedSegments_Call { return &DataCoord_GetFlushedSegments_Call{Call: _e.mock.On("GetFlushedSegments", ctx, req)} } @@ -668,8 +668,8 @@ type DataCoord_GetInsertBinlogPaths_Call struct { } // GetInsertBinlogPaths is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.GetInsertBinlogPathsRequest +// - ctx context.Context +// - req *datapb.GetInsertBinlogPathsRequest func (_e *DataCoord_Expecter) GetInsertBinlogPaths(ctx interface{}, req interface{}) *DataCoord_GetInsertBinlogPaths_Call { return &DataCoord_GetInsertBinlogPaths_Call{Call: _e.mock.On("GetInsertBinlogPaths", ctx, req)} } @@ -715,8 +715,8 @@ type DataCoord_GetMetrics_Call struct { } // GetMetrics is a helper method to define mock.On call -// - ctx context.Context -// - req *milvuspb.GetMetricsRequest +// - ctx context.Context +// - req *milvuspb.GetMetricsRequest func (_e *DataCoord_Expecter) GetMetrics(ctx interface{}, req interface{}) *DataCoord_GetMetrics_Call { return &DataCoord_GetMetrics_Call{Call: _e.mock.On("GetMetrics", ctx, req)} } @@ -762,8 +762,8 @@ type DataCoord_GetPartitionStatistics_Call struct { } // GetPartitionStatistics is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.GetPartitionStatisticsRequest +// - ctx context.Context +// - req *datapb.GetPartitionStatisticsRequest func (_e *DataCoord_Expecter) GetPartitionStatistics(ctx interface{}, req interface{}) *DataCoord_GetPartitionStatistics_Call { return &DataCoord_GetPartitionStatistics_Call{Call: _e.mock.On("GetPartitionStatistics", ctx, req)} } @@ -809,8 +809,8 @@ type DataCoord_GetRecoveryInfo_Call struct { } // GetRecoveryInfo is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.GetRecoveryInfoRequest +// - ctx context.Context +// - req *datapb.GetRecoveryInfoRequest func (_e *DataCoord_Expecter) GetRecoveryInfo(ctx interface{}, req interface{}) *DataCoord_GetRecoveryInfo_Call { return &DataCoord_GetRecoveryInfo_Call{Call: _e.mock.On("GetRecoveryInfo", ctx, req)} } @@ -856,8 +856,8 @@ type DataCoord_GetSegmentInfo_Call struct { } // GetSegmentInfo is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.GetSegmentInfoRequest +// - ctx context.Context +// - req *datapb.GetSegmentInfoRequest func (_e *DataCoord_Expecter) GetSegmentInfo(ctx interface{}, req interface{}) *DataCoord_GetSegmentInfo_Call { return &DataCoord_GetSegmentInfo_Call{Call: _e.mock.On("GetSegmentInfo", ctx, req)} } @@ -903,7 +903,7 @@ type DataCoord_GetSegmentInfoChannel_Call struct { } // GetSegmentInfoChannel is a helper method to define mock.On call -// - ctx context.Context +// - ctx context.Context func (_e *DataCoord_Expecter) GetSegmentInfoChannel(ctx interface{}) *DataCoord_GetSegmentInfoChannel_Call { return &DataCoord_GetSegmentInfoChannel_Call{Call: _e.mock.On("GetSegmentInfoChannel", ctx)} } @@ -949,8 +949,8 @@ type DataCoord_GetSegmentStates_Call struct { } // GetSegmentStates is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.GetSegmentStatesRequest +// - ctx context.Context +// - req *datapb.GetSegmentStatesRequest func (_e *DataCoord_Expecter) GetSegmentStates(ctx interface{}, req interface{}) *DataCoord_GetSegmentStates_Call { return &DataCoord_GetSegmentStates_Call{Call: _e.mock.On("GetSegmentStates", ctx, req)} } @@ -996,8 +996,8 @@ type DataCoord_GetSegmentsByStates_Call struct { } // GetSegmentsByStates is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.GetSegmentsByStatesRequest +// - ctx context.Context +// - req *datapb.GetSegmentsByStatesRequest func (_e *DataCoord_Expecter) GetSegmentsByStates(ctx interface{}, req interface{}) *DataCoord_GetSegmentsByStates_Call { return &DataCoord_GetSegmentsByStates_Call{Call: _e.mock.On("GetSegmentsByStates", ctx, req)} } @@ -1043,7 +1043,7 @@ type DataCoord_GetStatisticsChannel_Call struct { } // GetStatisticsChannel is a helper method to define mock.On call -// - ctx context.Context +// - ctx context.Context func (_e *DataCoord_Expecter) GetStatisticsChannel(ctx interface{}) *DataCoord_GetStatisticsChannel_Call { return &DataCoord_GetStatisticsChannel_Call{Call: _e.mock.On("GetStatisticsChannel", ctx)} } @@ -1089,7 +1089,7 @@ type DataCoord_GetTimeTickChannel_Call struct { } // GetTimeTickChannel is a helper method to define mock.On call -// - ctx context.Context +// - ctx context.Context func (_e *DataCoord_Expecter) GetTimeTickChannel(ctx interface{}) *DataCoord_GetTimeTickChannel_Call { return &DataCoord_GetTimeTickChannel_Call{Call: _e.mock.On("GetTimeTickChannel", ctx)} } @@ -1135,8 +1135,8 @@ type DataCoord_Import_Call struct { } // Import is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.ImportTaskRequest +// - ctx context.Context +// - req *datapb.ImportTaskRequest func (_e *DataCoord_Expecter) Import(ctx interface{}, req interface{}) *DataCoord_Import_Call { return &DataCoord_Import_Call{Call: _e.mock.On("Import", ctx, req)} } @@ -1189,6 +1189,53 @@ func (_c *DataCoord_Init_Call) Return(_a0 error) *DataCoord_Init_Call { return _c } +// ListSegmentsInfo provides a mock function with given fields: ctx, req +func (_m *DataCoord) ListSegmentsInfo(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) { + ret := _m.Called(ctx, req) + + var r0 *datapb.ListSegmentsInfoResponse + if rf, ok := ret.Get(0).(func(context.Context, *datapb.ListSegmentsInfoRequest) *datapb.ListSegmentsInfoResponse); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.ListSegmentsInfoResponse) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *datapb.ListSegmentsInfoRequest) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// DataCoord_ListSegmentsInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSegmentsInfo' +type DataCoord_ListSegmentsInfo_Call struct { + *mock.Call +} + +// ListSegmentsInfo is a helper method to define mock.On call +// - ctx context.Context +// - req *datapb.ListSegmentsInfoRequest +func (_e *DataCoord_Expecter) ListSegmentsInfo(ctx interface{}, req interface{}) *DataCoord_ListSegmentsInfo_Call { + return &DataCoord_ListSegmentsInfo_Call{Call: _e.mock.On("ListSegmentsInfo", ctx, req)} +} + +func (_c *DataCoord_ListSegmentsInfo_Call) Run(run func(ctx context.Context, req *datapb.ListSegmentsInfoRequest)) *DataCoord_ListSegmentsInfo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.ListSegmentsInfoRequest)) + }) + return _c +} + +func (_c *DataCoord_ListSegmentsInfo_Call) Return(_a0 *datapb.ListSegmentsInfoResponse, _a1 error) *DataCoord_ListSegmentsInfo_Call { + _c.Call.Return(_a0, _a1) + return _c +} + // ManualCompaction provides a mock function with given fields: ctx, req func (_m *DataCoord) ManualCompaction(ctx context.Context, req *milvuspb.ManualCompactionRequest) (*milvuspb.ManualCompactionResponse, error) { ret := _m.Called(ctx, req) @@ -1218,8 +1265,8 @@ type DataCoord_ManualCompaction_Call struct { } // ManualCompaction is a helper method to define mock.On call -// - ctx context.Context -// - req *milvuspb.ManualCompactionRequest +// - ctx context.Context +// - req *milvuspb.ManualCompactionRequest func (_e *DataCoord_Expecter) ManualCompaction(ctx interface{}, req interface{}) *DataCoord_ManualCompaction_Call { return &DataCoord_ManualCompaction_Call{Call: _e.mock.On("ManualCompaction", ctx, req)} } @@ -1265,8 +1312,8 @@ type DataCoord_MarkSegmentsDropped_Call struct { } // MarkSegmentsDropped is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.MarkSegmentsDroppedRequest +// - ctx context.Context +// - req *datapb.MarkSegmentsDroppedRequest func (_e *DataCoord_Expecter) MarkSegmentsDropped(ctx interface{}, req interface{}) *DataCoord_MarkSegmentsDropped_Call { return &DataCoord_MarkSegmentsDropped_Call{Call: _e.mock.On("MarkSegmentsDropped", ctx, req)} } @@ -1348,8 +1395,8 @@ type DataCoord_ReleaseSegmentLock_Call struct { } // ReleaseSegmentLock is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.ReleaseSegmentLockRequest +// - ctx context.Context +// - req *datapb.ReleaseSegmentLockRequest func (_e *DataCoord_Expecter) ReleaseSegmentLock(ctx interface{}, req interface{}) *DataCoord_ReleaseSegmentLock_Call { return &DataCoord_ReleaseSegmentLock_Call{Call: _e.mock.On("ReleaseSegmentLock", ctx, req)} } @@ -1395,8 +1442,8 @@ type DataCoord_SaveBinlogPaths_Call struct { } // SaveBinlogPaths is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.SaveBinlogPathsRequest +// - ctx context.Context +// - req *datapb.SaveBinlogPathsRequest func (_e *DataCoord_Expecter) SaveBinlogPaths(ctx interface{}, req interface{}) *DataCoord_SaveBinlogPaths_Call { return &DataCoord_SaveBinlogPaths_Call{Call: _e.mock.On("SaveBinlogPaths", ctx, req)} } @@ -1442,8 +1489,8 @@ type DataCoord_SaveImportSegment_Call struct { } // SaveImportSegment is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.SaveImportSegmentRequest +// - ctx context.Context +// - req *datapb.SaveImportSegmentRequest func (_e *DataCoord_Expecter) SaveImportSegment(ctx interface{}, req interface{}) *DataCoord_SaveImportSegment_Call { return &DataCoord_SaveImportSegment_Call{Call: _e.mock.On("SaveImportSegment", ctx, req)} } @@ -1489,8 +1536,8 @@ type DataCoord_SetSegmentState_Call struct { } // SetSegmentState is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.SetSegmentStateRequest +// - ctx context.Context +// - req *datapb.SetSegmentStateRequest func (_e *DataCoord_Expecter) SetSegmentState(ctx interface{}, req interface{}) *DataCoord_SetSegmentState_Call { return &DataCoord_SetSegmentState_Call{Call: _e.mock.On("SetSegmentState", ctx, req)} } @@ -1536,8 +1583,8 @@ type DataCoord_ShowConfigurations_Call struct { } // ShowConfigurations is a helper method to define mock.On call -// - ctx context.Context -// - req *internalpb.ShowConfigurationsRequest +// - ctx context.Context +// - req *internalpb.ShowConfigurationsRequest func (_e *DataCoord_Expecter) ShowConfigurations(ctx interface{}, req interface{}) *DataCoord_ShowConfigurations_Call { return &DataCoord_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", ctx, req)} } @@ -1655,8 +1702,8 @@ type DataCoord_UnsetIsImportingState_Call struct { } // UnsetIsImportingState is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.UnsetIsImportingStateRequest +// - ctx context.Context +// - req *datapb.UnsetIsImportingStateRequest func (_e *DataCoord_Expecter) UnsetIsImportingState(ctx interface{}, req interface{}) *DataCoord_UnsetIsImportingState_Call { return &DataCoord_UnsetIsImportingState_Call{Call: _e.mock.On("UnsetIsImportingState", ctx, req)} } @@ -1702,8 +1749,8 @@ type DataCoord_UpdateChannelCheckpoint_Call struct { } // UpdateChannelCheckpoint is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.UpdateChannelCheckpointRequest +// - ctx context.Context +// - req *datapb.UpdateChannelCheckpointRequest func (_e *DataCoord_Expecter) UpdateChannelCheckpoint(ctx interface{}, req interface{}) *DataCoord_UpdateChannelCheckpoint_Call { return &DataCoord_UpdateChannelCheckpoint_Call{Call: _e.mock.On("UpdateChannelCheckpoint", ctx, req)} } @@ -1749,8 +1796,8 @@ type DataCoord_UpdateSegmentStatistics_Call struct { } // UpdateSegmentStatistics is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.UpdateSegmentStatisticsRequest +// - ctx context.Context +// - req *datapb.UpdateSegmentStatisticsRequest func (_e *DataCoord_Expecter) UpdateSegmentStatistics(ctx interface{}, req interface{}) *DataCoord_UpdateSegmentStatistics_Call { return &DataCoord_UpdateSegmentStatistics_Call{Call: _e.mock.On("UpdateSegmentStatistics", ctx, req)} } @@ -1796,8 +1843,8 @@ type DataCoord_WatchChannels_Call struct { } // WatchChannels is a helper method to define mock.On call -// - ctx context.Context -// - req *datapb.WatchChannelsRequest +// - ctx context.Context +// - req *datapb.WatchChannelsRequest func (_e *DataCoord_Expecter) WatchChannels(ctx interface{}, req interface{}) *DataCoord_WatchChannels_Call { return &DataCoord_WatchChannels_Call{Call: _e.mock.On("WatchChannels", ctx, req)} } diff --git a/internal/proto/data_coord.proto b/internal/proto/data_coord.proto index fb1863e263..19508d8766 100644 --- a/internal/proto/data_coord.proto +++ b/internal/proto/data_coord.proto @@ -31,6 +31,7 @@ service DataCoord { rpc GetSegmentInfo(GetSegmentInfoRequest) returns (GetSegmentInfoResponse) {} rpc GetSegmentStates(GetSegmentStatesRequest) returns (GetSegmentStatesResponse) {} rpc GetInsertBinlogPaths(GetInsertBinlogPathsRequest) returns (GetInsertBinlogPathsResponse) {} + rpc ListSegmentsInfo(ListSegmentsInfoRequest) returns (ListSegmentsInfoResponse) {} rpc GetCollectionStatistics(GetCollectionStatisticsRequest) returns (GetCollectionStatisticsResponse) {} rpc GetPartitionStatistics(GetPartitionStatisticsRequest) returns (GetPartitionStatisticsResponse) {} @@ -164,7 +165,7 @@ message GetSegmentStatesResponse { message GetSegmentInfoRequest { common.MsgBase base = 1; repeated int64 segmentIDs = 2; - bool includeUnHealthy =3; + bool includeUnHealthy = 3; } message GetSegmentInfoResponse { @@ -173,6 +174,17 @@ message GetSegmentInfoResponse { map channel_checkpoint = 3; } +message ListSegmentsInfoRequest { + common.MsgBase base = 1; + repeated int64 segmentIDs = 2; + bool includeUnHealthy = 3; +} + +message ListSegmentsInfoResponse { + common.Status status = 1; + repeated SegmentInfo infos = 2; +} + message GetInsertBinlogPathsRequest { common.MsgBase base = 1; int64 segmentID = 2; diff --git a/internal/proto/datapb/data_coord.pb.go b/internal/proto/datapb/data_coord.pb.go index a6283d4d85..8fcc10e6e6 100644 --- a/internal/proto/datapb/data_coord.pb.go +++ b/internal/proto/datapb/data_coord.pb.go @@ -855,6 +855,108 @@ func (m *GetSegmentInfoResponse) GetChannelCheckpoint() map[string]*internalpb.M return nil } +type ListSegmentsInfoRequest struct { + Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` + SegmentIDs []int64 `protobuf:"varint,2,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"` + IncludeUnHealthy bool `protobuf:"varint,3,opt,name=includeUnHealthy,proto3" json:"includeUnHealthy,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListSegmentsInfoRequest) Reset() { *m = ListSegmentsInfoRequest{} } +func (m *ListSegmentsInfoRequest) String() string { return proto.CompactTextString(m) } +func (*ListSegmentsInfoRequest) ProtoMessage() {} +func (*ListSegmentsInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{12} +} + +func (m *ListSegmentsInfoRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListSegmentsInfoRequest.Unmarshal(m, b) +} +func (m *ListSegmentsInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListSegmentsInfoRequest.Marshal(b, m, deterministic) +} +func (m *ListSegmentsInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListSegmentsInfoRequest.Merge(m, src) +} +func (m *ListSegmentsInfoRequest) XXX_Size() int { + return xxx_messageInfo_ListSegmentsInfoRequest.Size(m) +} +func (m *ListSegmentsInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ListSegmentsInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ListSegmentsInfoRequest proto.InternalMessageInfo + +func (m *ListSegmentsInfoRequest) GetBase() *commonpb.MsgBase { + if m != nil { + return m.Base + } + return nil +} + +func (m *ListSegmentsInfoRequest) GetSegmentIDs() []int64 { + if m != nil { + return m.SegmentIDs + } + return nil +} + +func (m *ListSegmentsInfoRequest) GetIncludeUnHealthy() bool { + if m != nil { + return m.IncludeUnHealthy + } + return false +} + +type ListSegmentsInfoResponse struct { + Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + Infos []*SegmentInfo `protobuf:"bytes,2,rep,name=infos,proto3" json:"infos,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListSegmentsInfoResponse) Reset() { *m = ListSegmentsInfoResponse{} } +func (m *ListSegmentsInfoResponse) String() string { return proto.CompactTextString(m) } +func (*ListSegmentsInfoResponse) ProtoMessage() {} +func (*ListSegmentsInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{13} +} + +func (m *ListSegmentsInfoResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListSegmentsInfoResponse.Unmarshal(m, b) +} +func (m *ListSegmentsInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListSegmentsInfoResponse.Marshal(b, m, deterministic) +} +func (m *ListSegmentsInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListSegmentsInfoResponse.Merge(m, src) +} +func (m *ListSegmentsInfoResponse) XXX_Size() int { + return xxx_messageInfo_ListSegmentsInfoResponse.Size(m) +} +func (m *ListSegmentsInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ListSegmentsInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ListSegmentsInfoResponse proto.InternalMessageInfo + +func (m *ListSegmentsInfoResponse) GetStatus() *commonpb.Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *ListSegmentsInfoResponse) GetInfos() []*SegmentInfo { + if m != nil { + return m.Infos + } + return nil +} + type GetInsertBinlogPathsRequest struct { Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` SegmentID int64 `protobuf:"varint,2,opt,name=segmentID,proto3" json:"segmentID,omitempty"` @@ -867,7 +969,7 @@ func (m *GetInsertBinlogPathsRequest) Reset() { *m = GetInsertBinlogPath func (m *GetInsertBinlogPathsRequest) String() string { return proto.CompactTextString(m) } func (*GetInsertBinlogPathsRequest) ProtoMessage() {} func (*GetInsertBinlogPathsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{12} + return fileDescriptor_82cd95f524594f49, []int{14} } func (m *GetInsertBinlogPathsRequest) XXX_Unmarshal(b []byte) error { @@ -915,7 +1017,7 @@ func (m *GetInsertBinlogPathsResponse) Reset() { *m = GetInsertBinlogPat func (m *GetInsertBinlogPathsResponse) String() string { return proto.CompactTextString(m) } func (*GetInsertBinlogPathsResponse) ProtoMessage() {} func (*GetInsertBinlogPathsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{13} + return fileDescriptor_82cd95f524594f49, []int{15} } func (m *GetInsertBinlogPathsResponse) XXX_Unmarshal(b []byte) error { @@ -970,7 +1072,7 @@ func (m *GetCollectionStatisticsRequest) Reset() { *m = GetCollectionSta func (m *GetCollectionStatisticsRequest) String() string { return proto.CompactTextString(m) } func (*GetCollectionStatisticsRequest) ProtoMessage() {} func (*GetCollectionStatisticsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{14} + return fileDescriptor_82cd95f524594f49, []int{16} } func (m *GetCollectionStatisticsRequest) XXX_Unmarshal(b []byte) error { @@ -1024,7 +1126,7 @@ func (m *GetCollectionStatisticsResponse) Reset() { *m = GetCollectionSt func (m *GetCollectionStatisticsResponse) String() string { return proto.CompactTextString(m) } func (*GetCollectionStatisticsResponse) ProtoMessage() {} func (*GetCollectionStatisticsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{15} + return fileDescriptor_82cd95f524594f49, []int{17} } func (m *GetCollectionStatisticsResponse) XXX_Unmarshal(b []byte) error { @@ -1073,7 +1175,7 @@ func (m *GetPartitionStatisticsRequest) Reset() { *m = GetPartitionStati func (m *GetPartitionStatisticsRequest) String() string { return proto.CompactTextString(m) } func (*GetPartitionStatisticsRequest) ProtoMessage() {} func (*GetPartitionStatisticsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{16} + return fileDescriptor_82cd95f524594f49, []int{18} } func (m *GetPartitionStatisticsRequest) XXX_Unmarshal(b []byte) error { @@ -1134,7 +1236,7 @@ func (m *GetPartitionStatisticsResponse) Reset() { *m = GetPartitionStat func (m *GetPartitionStatisticsResponse) String() string { return proto.CompactTextString(m) } func (*GetPartitionStatisticsResponse) ProtoMessage() {} func (*GetPartitionStatisticsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{17} + return fileDescriptor_82cd95f524594f49, []int{19} } func (m *GetPartitionStatisticsResponse) XXX_Unmarshal(b []byte) error { @@ -1179,7 +1281,7 @@ func (m *GetSegmentInfoChannelRequest) Reset() { *m = GetSegmentInfoChan func (m *GetSegmentInfoChannelRequest) String() string { return proto.CompactTextString(m) } func (*GetSegmentInfoChannelRequest) ProtoMessage() {} func (*GetSegmentInfoChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{18} + return fileDescriptor_82cd95f524594f49, []int{20} } func (m *GetSegmentInfoChannelRequest) XXX_Unmarshal(b []byte) error { @@ -1214,7 +1316,7 @@ func (m *AcquireSegmentLockRequest) Reset() { *m = AcquireSegmentLockReq func (m *AcquireSegmentLockRequest) String() string { return proto.CompactTextString(m) } func (*AcquireSegmentLockRequest) ProtoMessage() {} func (*AcquireSegmentLockRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{19} + return fileDescriptor_82cd95f524594f49, []int{21} } func (m *AcquireSegmentLockRequest) XXX_Unmarshal(b []byte) error { @@ -1277,7 +1379,7 @@ func (m *ReleaseSegmentLockRequest) Reset() { *m = ReleaseSegmentLockReq func (m *ReleaseSegmentLockRequest) String() string { return proto.CompactTextString(m) } func (*ReleaseSegmentLockRequest) ProtoMessage() {} func (*ReleaseSegmentLockRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{20} + return fileDescriptor_82cd95f524594f49, []int{22} } func (m *ReleaseSegmentLockRequest) XXX_Unmarshal(b []byte) error { @@ -1345,7 +1447,7 @@ 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_82cd95f524594f49, []int{21} + return fileDescriptor_82cd95f524594f49, []int{23} } func (m *VchannelInfo) XXX_Unmarshal(b []byte) error { @@ -1441,7 +1543,7 @@ func (m *WatchDmChannelsRequest) Reset() { *m = WatchDmChannelsRequest{} func (m *WatchDmChannelsRequest) String() string { return proto.CompactTextString(m) } func (*WatchDmChannelsRequest) ProtoMessage() {} func (*WatchDmChannelsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{22} + return fileDescriptor_82cd95f524594f49, []int{24} } func (m *WatchDmChannelsRequest) XXX_Unmarshal(b []byte) error { @@ -1490,7 +1592,7 @@ func (m *FlushSegmentsRequest) Reset() { *m = FlushSegmentsRequest{} } func (m *FlushSegmentsRequest) String() string { return proto.CompactTextString(m) } func (*FlushSegmentsRequest) ProtoMessage() {} func (*FlushSegmentsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{23} + return fileDescriptor_82cd95f524594f49, []int{25} } func (m *FlushSegmentsRequest) XXX_Unmarshal(b []byte) error { @@ -1551,7 +1653,7 @@ func (m *SegmentMsg) Reset() { *m = SegmentMsg{} } func (m *SegmentMsg) String() string { return proto.CompactTextString(m) } func (*SegmentMsg) ProtoMessage() {} func (*SegmentMsg) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{24} + return fileDescriptor_82cd95f524594f49, []int{26} } func (m *SegmentMsg) XXX_Unmarshal(b []byte) error { @@ -1619,7 +1721,7 @@ func (m *SegmentInfo) Reset() { *m = SegmentInfo{} } func (m *SegmentInfo) String() string { return proto.CompactTextString(m) } func (*SegmentInfo) ProtoMessage() {} func (*SegmentInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{25} + return fileDescriptor_82cd95f524594f49, []int{27} } func (m *SegmentInfo) XXX_Unmarshal(b []byte) error { @@ -1778,7 +1880,7 @@ func (m *SegmentStartPosition) Reset() { *m = SegmentStartPosition{} } func (m *SegmentStartPosition) String() string { return proto.CompactTextString(m) } func (*SegmentStartPosition) ProtoMessage() {} func (*SegmentStartPosition) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{26} + return fileDescriptor_82cd95f524594f49, []int{28} } func (m *SegmentStartPosition) XXX_Unmarshal(b []byte) error { @@ -1834,7 +1936,7 @@ func (m *SaveBinlogPathsRequest) Reset() { *m = SaveBinlogPathsRequest{} func (m *SaveBinlogPathsRequest) String() string { return proto.CompactTextString(m) } func (*SaveBinlogPathsRequest) ProtoMessage() {} func (*SaveBinlogPathsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{27} + return fileDescriptor_82cd95f524594f49, []int{29} } func (m *SaveBinlogPathsRequest) XXX_Unmarshal(b []byte) error { @@ -1945,7 +2047,7 @@ 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_82cd95f524594f49, []int{28} + return fileDescriptor_82cd95f524594f49, []int{30} } func (m *CheckPoint) XXX_Unmarshal(b []byte) error { @@ -2002,7 +2104,7 @@ func (m *DeltaLogInfo) Reset() { *m = DeltaLogInfo{} } func (m *DeltaLogInfo) String() string { return proto.CompactTextString(m) } func (*DeltaLogInfo) ProtoMessage() {} func (*DeltaLogInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{29} + return fileDescriptor_82cd95f524594f49, []int{31} } func (m *DeltaLogInfo) XXX_Unmarshal(b []byte) error { @@ -2072,7 +2174,7 @@ func (m *DataNodeTtMsg) Reset() { *m = DataNodeTtMsg{} } func (m *DataNodeTtMsg) String() string { return proto.CompactTextString(m) } func (*DataNodeTtMsg) ProtoMessage() {} func (*DataNodeTtMsg) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{30} + return fileDescriptor_82cd95f524594f49, []int{32} } func (m *DataNodeTtMsg) XXX_Unmarshal(b []byte) error { @@ -2133,7 +2235,7 @@ func (m *SegmentStats) Reset() { *m = SegmentStats{} } func (m *SegmentStats) String() string { return proto.CompactTextString(m) } func (*SegmentStats) ProtoMessage() {} func (*SegmentStats) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{31} + return fileDescriptor_82cd95f524594f49, []int{33} } func (m *SegmentStats) XXX_Unmarshal(b []byte) error { @@ -2181,7 +2283,7 @@ func (m *ChannelStatus) Reset() { *m = ChannelStatus{} } func (m *ChannelStatus) String() string { return proto.CompactTextString(m) } func (*ChannelStatus) ProtoMessage() {} func (*ChannelStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{32} + return fileDescriptor_82cd95f524594f49, []int{34} } func (m *ChannelStatus) XXX_Unmarshal(b []byte) error { @@ -2236,7 +2338,7 @@ func (m *DataNodeInfo) Reset() { *m = DataNodeInfo{} } func (m *DataNodeInfo) String() string { return proto.CompactTextString(m) } func (*DataNodeInfo) ProtoMessage() {} func (*DataNodeInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{33} + return fileDescriptor_82cd95f524594f49, []int{35} } func (m *DataNodeInfo) XXX_Unmarshal(b []byte) error { @@ -2294,7 +2396,7 @@ 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_82cd95f524594f49, []int{34} + return fileDescriptor_82cd95f524594f49, []int{36} } func (m *SegmentBinlogs) XXX_Unmarshal(b []byte) error { @@ -2369,7 +2471,7 @@ 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_82cd95f524594f49, []int{35} + return fileDescriptor_82cd95f524594f49, []int{37} } func (m *FieldBinlog) XXX_Unmarshal(b []byte) error { @@ -2421,7 +2523,7 @@ func (m *Binlog) Reset() { *m = Binlog{} } func (m *Binlog) String() string { return proto.CompactTextString(m) } func (*Binlog) ProtoMessage() {} func (*Binlog) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{36} + return fileDescriptor_82cd95f524594f49, []int{38} } func (m *Binlog) XXX_Unmarshal(b []byte) error { @@ -2497,7 +2599,7 @@ 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_82cd95f524594f49, []int{37} + return fileDescriptor_82cd95f524594f49, []int{39} } func (m *GetRecoveryInfoResponse) XXX_Unmarshal(b []byte) error { @@ -2552,7 +2654,7 @@ 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_82cd95f524594f49, []int{38} + return fileDescriptor_82cd95f524594f49, []int{40} } func (m *GetRecoveryInfoRequest) XXX_Unmarshal(b []byte) error { @@ -2608,7 +2710,7 @@ func (m *GetSegmentsByStatesRequest) Reset() { *m = GetSegmentsByStatesR func (m *GetSegmentsByStatesRequest) String() string { return proto.CompactTextString(m) } func (*GetSegmentsByStatesRequest) ProtoMessage() {} func (*GetSegmentsByStatesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{39} + return fileDescriptor_82cd95f524594f49, []int{41} } func (m *GetSegmentsByStatesRequest) XXX_Unmarshal(b []byte) error { @@ -2669,7 +2771,7 @@ func (m *GetSegmentsByStatesResponse) Reset() { *m = GetSegmentsByStates func (m *GetSegmentsByStatesResponse) String() string { return proto.CompactTextString(m) } func (*GetSegmentsByStatesResponse) ProtoMessage() {} func (*GetSegmentsByStatesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{40} + return fileDescriptor_82cd95f524594f49, []int{42} } func (m *GetSegmentsByStatesResponse) XXX_Unmarshal(b []byte) error { @@ -2719,7 +2821,7 @@ func (m *GetFlushedSegmentsRequest) Reset() { *m = GetFlushedSegmentsReq func (m *GetFlushedSegmentsRequest) String() string { return proto.CompactTextString(m) } func (*GetFlushedSegmentsRequest) ProtoMessage() {} func (*GetFlushedSegmentsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{41} + return fileDescriptor_82cd95f524594f49, []int{43} } func (m *GetFlushedSegmentsRequest) XXX_Unmarshal(b []byte) error { @@ -2787,7 +2889,7 @@ func (m *GetFlushedSegmentsResponse) Reset() { *m = GetFlushedSegmentsRe func (m *GetFlushedSegmentsResponse) String() string { return proto.CompactTextString(m) } func (*GetFlushedSegmentsResponse) ProtoMessage() {} func (*GetFlushedSegmentsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{42} + return fileDescriptor_82cd95f524594f49, []int{44} } func (m *GetFlushedSegmentsResponse) XXX_Unmarshal(b []byte) error { @@ -2834,7 +2936,7 @@ func (m *SegmentFlushCompletedMsg) Reset() { *m = SegmentFlushCompletedM func (m *SegmentFlushCompletedMsg) String() string { return proto.CompactTextString(m) } func (*SegmentFlushCompletedMsg) ProtoMessage() {} func (*SegmentFlushCompletedMsg) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{43} + return fileDescriptor_82cd95f524594f49, []int{45} } func (m *SegmentFlushCompletedMsg) XXX_Unmarshal(b []byte) error { @@ -2889,7 +2991,7 @@ func (m *ChannelWatchInfo) Reset() { *m = ChannelWatchInfo{} } func (m *ChannelWatchInfo) String() string { return proto.CompactTextString(m) } func (*ChannelWatchInfo) ProtoMessage() {} func (*ChannelWatchInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{44} + return fileDescriptor_82cd95f524594f49, []int{46} } func (m *ChannelWatchInfo) XXX_Unmarshal(b []byte) error { @@ -2963,7 +3065,7 @@ func (m *CompactionStateRequest) Reset() { *m = CompactionStateRequest{} func (m *CompactionStateRequest) String() string { return proto.CompactTextString(m) } func (*CompactionStateRequest) ProtoMessage() {} func (*CompactionStateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{45} + return fileDescriptor_82cd95f524594f49, []int{47} } func (m *CompactionStateRequest) XXX_Unmarshal(b []byte) error { @@ -3006,7 +3108,7 @@ func (m *SyncSegmentsRequest) Reset() { *m = SyncSegmentsRequest{} } func (m *SyncSegmentsRequest) String() string { return proto.CompactTextString(m) } func (*SyncSegmentsRequest) ProtoMessage() {} func (*SyncSegmentsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{46} + return fileDescriptor_82cd95f524594f49, []int{48} } func (m *SyncSegmentsRequest) XXX_Unmarshal(b []byte) error { @@ -3077,7 +3179,7 @@ func (m *CompactionSegmentBinlogs) Reset() { *m = CompactionSegmentBinlo func (m *CompactionSegmentBinlogs) String() string { return proto.CompactTextString(m) } func (*CompactionSegmentBinlogs) ProtoMessage() {} func (*CompactionSegmentBinlogs) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{47} + return fileDescriptor_82cd95f524594f49, []int{49} } func (m *CompactionSegmentBinlogs) XXX_Unmarshal(b []byte) error { @@ -3151,7 +3253,7 @@ func (m *CompactionPlan) Reset() { *m = CompactionPlan{} } func (m *CompactionPlan) String() string { return proto.CompactTextString(m) } func (*CompactionPlan) ProtoMessage() {} func (*CompactionPlan) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{48} + return fileDescriptor_82cd95f524594f49, []int{50} } func (m *CompactionPlan) XXX_Unmarshal(b []byte) error { @@ -3245,7 +3347,7 @@ func (m *CompactionResult) Reset() { *m = CompactionResult{} } func (m *CompactionResult) String() string { return proto.CompactTextString(m) } func (*CompactionResult) ProtoMessage() {} func (*CompactionResult) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{49} + return fileDescriptor_82cd95f524594f49, []int{51} } func (m *CompactionResult) XXX_Unmarshal(b []byte) error { @@ -3328,7 +3430,7 @@ func (m *CompactionStateResult) Reset() { *m = CompactionStateResult{} } func (m *CompactionStateResult) String() string { return proto.CompactTextString(m) } func (*CompactionStateResult) ProtoMessage() {} func (*CompactionStateResult) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{50} + return fileDescriptor_82cd95f524594f49, []int{52} } func (m *CompactionStateResult) XXX_Unmarshal(b []byte) error { @@ -3382,7 +3484,7 @@ func (m *CompactionStateResponse) Reset() { *m = CompactionStateResponse func (m *CompactionStateResponse) String() string { return proto.CompactTextString(m) } func (*CompactionStateResponse) ProtoMessage() {} func (*CompactionStateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{51} + return fileDescriptor_82cd95f524594f49, []int{53} } func (m *CompactionStateResponse) XXX_Unmarshal(b []byte) error { @@ -3430,7 +3532,7 @@ func (m *SegmentFieldBinlogMeta) Reset() { *m = SegmentFieldBinlogMeta{} func (m *SegmentFieldBinlogMeta) String() string { return proto.CompactTextString(m) } func (*SegmentFieldBinlogMeta) ProtoMessage() {} func (*SegmentFieldBinlogMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{52} + return fileDescriptor_82cd95f524594f49, []int{54} } func (m *SegmentFieldBinlogMeta) XXX_Unmarshal(b []byte) error { @@ -3479,7 +3581,7 @@ func (m *WatchChannelsRequest) Reset() { *m = WatchChannelsRequest{} } func (m *WatchChannelsRequest) String() string { return proto.CompactTextString(m) } func (*WatchChannelsRequest) ProtoMessage() {} func (*WatchChannelsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{53} + return fileDescriptor_82cd95f524594f49, []int{55} } func (m *WatchChannelsRequest) XXX_Unmarshal(b []byte) error { @@ -3539,7 +3641,7 @@ func (m *WatchChannelsResponse) Reset() { *m = WatchChannelsResponse{} } func (m *WatchChannelsResponse) String() string { return proto.CompactTextString(m) } func (*WatchChannelsResponse) ProtoMessage() {} func (*WatchChannelsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{54} + return fileDescriptor_82cd95f524594f49, []int{56} } func (m *WatchChannelsResponse) XXX_Unmarshal(b []byte) error { @@ -3580,7 +3682,7 @@ func (m *SetSegmentStateRequest) Reset() { *m = SetSegmentStateRequest{} func (m *SetSegmentStateRequest) String() string { return proto.CompactTextString(m) } func (*SetSegmentStateRequest) ProtoMessage() {} func (*SetSegmentStateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{55} + return fileDescriptor_82cd95f524594f49, []int{57} } func (m *SetSegmentStateRequest) XXX_Unmarshal(b []byte) error { @@ -3633,7 +3735,7 @@ func (m *SetSegmentStateResponse) Reset() { *m = SetSegmentStateResponse func (m *SetSegmentStateResponse) String() string { return proto.CompactTextString(m) } func (*SetSegmentStateResponse) ProtoMessage() {} func (*SetSegmentStateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{56} + return fileDescriptor_82cd95f524594f49, []int{58} } func (m *SetSegmentStateResponse) XXX_Unmarshal(b []byte) error { @@ -3674,7 +3776,7 @@ func (m *DropVirtualChannelRequest) Reset() { *m = DropVirtualChannelReq func (m *DropVirtualChannelRequest) String() string { return proto.CompactTextString(m) } func (*DropVirtualChannelRequest) ProtoMessage() {} func (*DropVirtualChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{57} + return fileDescriptor_82cd95f524594f49, []int{59} } func (m *DropVirtualChannelRequest) XXX_Unmarshal(b []byte) error { @@ -3734,7 +3836,7 @@ func (m *DropVirtualChannelSegment) Reset() { *m = DropVirtualChannelSeg func (m *DropVirtualChannelSegment) String() string { return proto.CompactTextString(m) } func (*DropVirtualChannelSegment) ProtoMessage() {} func (*DropVirtualChannelSegment) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{58} + return fileDescriptor_82cd95f524594f49, []int{60} } func (m *DropVirtualChannelSegment) XXX_Unmarshal(b []byte) error { @@ -3822,7 +3924,7 @@ func (m *DropVirtualChannelResponse) Reset() { *m = DropVirtualChannelRe func (m *DropVirtualChannelResponse) String() string { return proto.CompactTextString(m) } func (*DropVirtualChannelResponse) ProtoMessage() {} func (*DropVirtualChannelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{59} + return fileDescriptor_82cd95f524594f49, []int{61} } func (m *DropVirtualChannelResponse) XXX_Unmarshal(b []byte) error { @@ -3868,7 +3970,7 @@ func (m *ImportTask) Reset() { *m = ImportTask{} } func (m *ImportTask) String() string { return proto.CompactTextString(m) } func (*ImportTask) ProtoMessage() {} func (*ImportTask) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{60} + return fileDescriptor_82cd95f524594f49, []int{62} } func (m *ImportTask) XXX_Unmarshal(b []byte) error { @@ -3960,7 +4062,7 @@ func (m *ImportTaskState) Reset() { *m = ImportTaskState{} } func (m *ImportTaskState) String() string { return proto.CompactTextString(m) } func (*ImportTaskState) ProtoMessage() {} func (*ImportTaskState) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{61} + return fileDescriptor_82cd95f524594f49, []int{63} } func (m *ImportTaskState) XXX_Unmarshal(b []byte) error { @@ -4041,7 +4143,7 @@ func (m *ImportTaskInfo) Reset() { *m = ImportTaskInfo{} } func (m *ImportTaskInfo) String() string { return proto.CompactTextString(m) } func (*ImportTaskInfo) ProtoMessage() {} func (*ImportTaskInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{62} + return fileDescriptor_82cd95f524594f49, []int{64} } func (m *ImportTaskInfo) XXX_Unmarshal(b []byte) error { @@ -4180,7 +4282,7 @@ func (m *ImportTaskResponse) Reset() { *m = ImportTaskResponse{} } func (m *ImportTaskResponse) String() string { return proto.CompactTextString(m) } func (*ImportTaskResponse) ProtoMessage() {} func (*ImportTaskResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{63} + return fileDescriptor_82cd95f524594f49, []int{65} } func (m *ImportTaskResponse) XXX_Unmarshal(b []byte) error { @@ -4228,7 +4330,7 @@ func (m *ImportTaskRequest) Reset() { *m = ImportTaskRequest{} } func (m *ImportTaskRequest) String() string { return proto.CompactTextString(m) } func (*ImportTaskRequest) ProtoMessage() {} func (*ImportTaskRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{64} + return fileDescriptor_82cd95f524594f49, []int{66} } func (m *ImportTaskRequest) XXX_Unmarshal(b []byte) error { @@ -4282,7 +4384,7 @@ func (m *UpdateSegmentStatisticsRequest) Reset() { *m = UpdateSegmentSta func (m *UpdateSegmentStatisticsRequest) String() string { return proto.CompactTextString(m) } func (*UpdateSegmentStatisticsRequest) ProtoMessage() {} func (*UpdateSegmentStatisticsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{65} + return fileDescriptor_82cd95f524594f49, []int{67} } func (m *UpdateSegmentStatisticsRequest) XXX_Unmarshal(b []byte) error { @@ -4330,7 +4432,7 @@ func (m *UpdateChannelCheckpointRequest) Reset() { *m = UpdateChannelChe func (m *UpdateChannelCheckpointRequest) String() string { return proto.CompactTextString(m) } func (*UpdateChannelCheckpointRequest) ProtoMessage() {} func (*UpdateChannelCheckpointRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{66} + return fileDescriptor_82cd95f524594f49, []int{68} } func (m *UpdateChannelCheckpointRequest) XXX_Unmarshal(b []byte) error { @@ -4383,7 +4485,7 @@ func (m *ResendSegmentStatsRequest) Reset() { *m = ResendSegmentStatsReq func (m *ResendSegmentStatsRequest) String() string { return proto.CompactTextString(m) } func (*ResendSegmentStatsRequest) ProtoMessage() {} func (*ResendSegmentStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{67} + return fileDescriptor_82cd95f524594f49, []int{69} } func (m *ResendSegmentStatsRequest) XXX_Unmarshal(b []byte) error { @@ -4423,7 +4525,7 @@ func (m *ResendSegmentStatsResponse) Reset() { *m = ResendSegmentStatsRe func (m *ResendSegmentStatsResponse) String() string { return proto.CompactTextString(m) } func (*ResendSegmentStatsResponse) ProtoMessage() {} func (*ResendSegmentStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{68} + return fileDescriptor_82cd95f524594f49, []int{70} } func (m *ResendSegmentStatsResponse) XXX_Unmarshal(b []byte) error { @@ -4475,7 +4577,7 @@ func (m *AddImportSegmentRequest) Reset() { *m = AddImportSegmentRequest func (m *AddImportSegmentRequest) String() string { return proto.CompactTextString(m) } func (*AddImportSegmentRequest) ProtoMessage() {} func (*AddImportSegmentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{69} + return fileDescriptor_82cd95f524594f49, []int{71} } func (m *AddImportSegmentRequest) XXX_Unmarshal(b []byte) error { @@ -4557,7 +4659,7 @@ func (m *AddImportSegmentResponse) Reset() { *m = AddImportSegmentRespon func (m *AddImportSegmentResponse) String() string { return proto.CompactTextString(m) } func (*AddImportSegmentResponse) ProtoMessage() {} func (*AddImportSegmentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{70} + return fileDescriptor_82cd95f524594f49, []int{72} } func (m *AddImportSegmentResponse) XXX_Unmarshal(b []byte) error { @@ -4610,7 +4712,7 @@ func (m *SaveImportSegmentRequest) Reset() { *m = SaveImportSegmentReque func (m *SaveImportSegmentRequest) String() string { return proto.CompactTextString(m) } func (*SaveImportSegmentRequest) ProtoMessage() {} func (*SaveImportSegmentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{71} + return fileDescriptor_82cd95f524594f49, []int{73} } func (m *SaveImportSegmentRequest) XXX_Unmarshal(b []byte) error { @@ -4699,7 +4801,7 @@ func (m *UnsetIsImportingStateRequest) Reset() { *m = UnsetIsImportingSt func (m *UnsetIsImportingStateRequest) String() string { return proto.CompactTextString(m) } func (*UnsetIsImportingStateRequest) ProtoMessage() {} func (*UnsetIsImportingStateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{72} + return fileDescriptor_82cd95f524594f49, []int{74} } func (m *UnsetIsImportingStateRequest) XXX_Unmarshal(b []byte) error { @@ -4746,7 +4848,7 @@ func (m *MarkSegmentsDroppedRequest) Reset() { *m = MarkSegmentsDroppedR func (m *MarkSegmentsDroppedRequest) String() string { return proto.CompactTextString(m) } func (*MarkSegmentsDroppedRequest) ProtoMessage() {} func (*MarkSegmentsDroppedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{73} + return fileDescriptor_82cd95f524594f49, []int{75} } func (m *MarkSegmentsDroppedRequest) XXX_Unmarshal(b []byte) error { @@ -4794,7 +4896,7 @@ func (m *SegmentReferenceLock) Reset() { *m = SegmentReferenceLock{} } func (m *SegmentReferenceLock) String() string { return proto.CompactTextString(m) } func (*SegmentReferenceLock) ProtoMessage() {} func (*SegmentReferenceLock) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{74} + return fileDescriptor_82cd95f524594f49, []int{76} } func (m *SegmentReferenceLock) XXX_Unmarshal(b []byte) error { @@ -4851,7 +4953,7 @@ func (m *AlterCollectionRequest) Reset() { *m = AlterCollectionRequest{} func (m *AlterCollectionRequest) String() string { return proto.CompactTextString(m) } func (*AlterCollectionRequest) ProtoMessage() {} func (*AlterCollectionRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{75} + return fileDescriptor_82cd95f524594f49, []int{77} } func (m *AlterCollectionRequest) XXX_Unmarshal(b []byte) error { @@ -4919,7 +5021,7 @@ func (m *GcConfirmRequest) Reset() { *m = GcConfirmRequest{} } func (m *GcConfirmRequest) String() string { return proto.CompactTextString(m) } func (*GcConfirmRequest) ProtoMessage() {} func (*GcConfirmRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{76} + return fileDescriptor_82cd95f524594f49, []int{78} } func (m *GcConfirmRequest) XXX_Unmarshal(b []byte) error { @@ -4966,7 +5068,7 @@ func (m *GcConfirmResponse) Reset() { *m = GcConfirmResponse{} } func (m *GcConfirmResponse) String() string { return proto.CompactTextString(m) } func (*GcConfirmResponse) ProtoMessage() {} func (*GcConfirmResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_82cd95f524594f49, []int{77} + return fileDescriptor_82cd95f524594f49, []int{79} } func (m *GcConfirmResponse) XXX_Unmarshal(b []byte) error { @@ -5018,6 +5120,8 @@ func init() { proto.RegisterType((*GetSegmentInfoRequest)(nil), "milvus.proto.data.GetSegmentInfoRequest") proto.RegisterType((*GetSegmentInfoResponse)(nil), "milvus.proto.data.GetSegmentInfoResponse") proto.RegisterMapType((map[string]*internalpb.MsgPosition)(nil), "milvus.proto.data.GetSegmentInfoResponse.ChannelCheckpointEntry") + proto.RegisterType((*ListSegmentsInfoRequest)(nil), "milvus.proto.data.ListSegmentsInfoRequest") + proto.RegisterType((*ListSegmentsInfoResponse)(nil), "milvus.proto.data.ListSegmentsInfoResponse") proto.RegisterType((*GetInsertBinlogPathsRequest)(nil), "milvus.proto.data.GetInsertBinlogPathsRequest") proto.RegisterType((*GetInsertBinlogPathsResponse)(nil), "milvus.proto.data.GetInsertBinlogPathsResponse") proto.RegisterType((*GetCollectionStatisticsRequest)(nil), "milvus.proto.data.GetCollectionStatisticsRequest") @@ -5089,293 +5193,296 @@ func init() { func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) } var fileDescriptor_82cd95f524594f49 = []byte{ - // 4573 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x3c, 0x5b, 0x8f, 0x1b, 0x59, - 0x5a, 0x29, 0xdf, 0xda, 0xfe, 0xec, 0x76, 0xbb, 0x4f, 0x32, 0x1d, 0xc7, 0xb9, 0x4e, 0x25, 0x99, - 0xc9, 0x64, 0x32, 0xc9, 0x4c, 0x86, 0xd1, 0x86, 0xcd, 0xce, 0x2c, 0xe9, 0xee, 0x74, 0xc6, 0xd0, - 0xdd, 0xdb, 0x5b, 0xdd, 0x99, 0xa0, 0x59, 0x24, 0xab, 0xda, 0x75, 0xec, 0xae, 0x6d, 0xbb, 0xca, - 0xa9, 0x2a, 0x77, 0xa7, 0x97, 0x87, 0x1d, 0x81, 0x84, 0xb4, 0x08, 0xb1, 0x08, 0x09, 0x01, 0x0f, - 0x48, 0x88, 0xa7, 0x65, 0xd1, 0x22, 0xa4, 0x85, 0x17, 0x5e, 0x78, 0x1d, 0xc1, 0xc3, 0x08, 0x21, - 0xf1, 0x08, 0x82, 0x07, 0xe0, 0x9d, 0x3f, 0x80, 0xce, 0xa5, 0x4e, 0xdd, 0x4e, 0xd9, 0xd5, 0x76, - 0x32, 0x41, 0xf0, 0xe6, 0xf3, 0xd5, 0x77, 0xbe, 0x73, 0xfb, 0xee, 0xdf, 0x39, 0x86, 0x86, 0xa1, - 0x7b, 0x7a, 0xa7, 0x6b, 0xdb, 0x8e, 0x71, 0x77, 0xe4, 0xd8, 0x9e, 0x8d, 0x96, 0x87, 0xe6, 0xe0, - 0x68, 0xec, 0xb2, 0xd6, 0x5d, 0xf2, 0xb9, 0x55, 0xeb, 0xda, 0xc3, 0xa1, 0x6d, 0x31, 0x50, 0xab, - 0x6e, 0x5a, 0x1e, 0x76, 0x2c, 0x7d, 0xc0, 0xdb, 0xb5, 0x70, 0x87, 0x56, 0xcd, 0xed, 0x1e, 0xe0, - 0xa1, 0xce, 0x5a, 0xea, 0x02, 0x14, 0x1f, 0x0f, 0x47, 0xde, 0x89, 0xfa, 0xd7, 0x0a, 0xd4, 0x36, - 0x06, 0x63, 0xf7, 0x40, 0xc3, 0xcf, 0xc7, 0xd8, 0xf5, 0xd0, 0xfb, 0x50, 0xd8, 0xd7, 0x5d, 0xdc, - 0x54, 0xae, 0x29, 0xb7, 0xaa, 0xf7, 0x2f, 0xdd, 0x8d, 0x8c, 0xca, 0xc7, 0xdb, 0x72, 0xfb, 0xab, - 0xba, 0x8b, 0x35, 0x8a, 0x89, 0x10, 0x14, 0x8c, 0xfd, 0xf6, 0x7a, 0x33, 0x77, 0x4d, 0xb9, 0x95, - 0xd7, 0xe8, 0x6f, 0x74, 0x05, 0xc0, 0xc5, 0xfd, 0x21, 0xb6, 0xbc, 0xf6, 0xba, 0xdb, 0xcc, 0x5f, - 0xcb, 0xdf, 0xca, 0x6b, 0x21, 0x08, 0x52, 0xa1, 0xd6, 0xb5, 0x07, 0x03, 0xdc, 0xf5, 0x4c, 0xdb, - 0x6a, 0xaf, 0x37, 0x0b, 0xb4, 0x6f, 0x04, 0x86, 0x5a, 0x50, 0x36, 0xdd, 0xf6, 0x70, 0x64, 0x3b, - 0x5e, 0xb3, 0x78, 0x4d, 0xb9, 0x55, 0xd6, 0x44, 0x5b, 0xfd, 0x0f, 0x05, 0x16, 0xf9, 0xb4, 0xdd, - 0x91, 0x6d, 0xb9, 0x18, 0x7d, 0x08, 0x25, 0xd7, 0xd3, 0xbd, 0xb1, 0xcb, 0x67, 0x7e, 0x51, 0x3a, - 0xf3, 0x5d, 0x8a, 0xa2, 0x71, 0x54, 0xe9, 0xd4, 0xe3, 0x53, 0xcb, 0x4b, 0xa6, 0x16, 0x5d, 0x5e, - 0x21, 0xb1, 0xbc, 0x5b, 0xb0, 0xd4, 0x23, 0xb3, 0xdb, 0x0d, 0x90, 0x8a, 0x14, 0x29, 0x0e, 0x26, - 0x94, 0x3c, 0x73, 0x88, 0xbf, 0xd3, 0xdb, 0xc5, 0xfa, 0xa0, 0x59, 0xa2, 0x63, 0x85, 0x20, 0xea, - 0x3f, 0x2a, 0xd0, 0x10, 0xe8, 0xfe, 0x19, 0x9d, 0x83, 0x62, 0xd7, 0x1e, 0x5b, 0x1e, 0x5d, 0xea, - 0xa2, 0xc6, 0x1a, 0xe8, 0x4d, 0xa8, 0x75, 0x0f, 0x74, 0xcb, 0xc2, 0x83, 0x8e, 0xa5, 0x0f, 0x31, - 0x5d, 0x54, 0x45, 0xab, 0x72, 0xd8, 0xb6, 0x3e, 0xc4, 0x99, 0xd6, 0x76, 0x0d, 0xaa, 0x23, 0xdd, - 0xf1, 0xcc, 0xc8, 0xc9, 0x84, 0x41, 0x93, 0x0e, 0x86, 0x8c, 0x60, 0xd2, 0x5f, 0x7b, 0xba, 0x7b, - 0xd8, 0x5e, 0xe7, 0x2b, 0x8a, 0xc0, 0xd4, 0x3f, 0x55, 0x60, 0xe5, 0x91, 0xeb, 0x9a, 0x7d, 0x2b, - 0xb1, 0xb2, 0x15, 0x28, 0x59, 0xb6, 0x81, 0xdb, 0xeb, 0x74, 0x69, 0x79, 0x8d, 0xb7, 0xd0, 0x45, - 0xa8, 0x8c, 0x30, 0x76, 0x3a, 0x8e, 0x3d, 0xf0, 0x17, 0x56, 0x26, 0x00, 0xcd, 0x1e, 0x60, 0xf4, - 0x5d, 0x58, 0x76, 0x63, 0x84, 0x18, 0xcf, 0x55, 0xef, 0x5f, 0xbf, 0x9b, 0x90, 0x9a, 0xbb, 0xf1, - 0x41, 0xb5, 0x64, 0x6f, 0xf5, 0x8b, 0x1c, 0x9c, 0x15, 0x78, 0x6c, 0xae, 0xe4, 0x37, 0xd9, 0x79, - 0x17, 0xf7, 0xc5, 0xf4, 0x58, 0x23, 0xcb, 0xce, 0x8b, 0x23, 0xcb, 0x87, 0x8f, 0x2c, 0x8b, 0x18, - 0xc4, 0xce, 0xa3, 0x98, 0x3c, 0x8f, 0xab, 0x50, 0xc5, 0x2f, 0x46, 0xa6, 0x83, 0x3b, 0x84, 0x71, - 0xe8, 0x96, 0x17, 0x34, 0x60, 0xa0, 0x3d, 0x73, 0x18, 0x96, 0x8d, 0x85, 0xcc, 0xb2, 0xa1, 0xfe, - 0x99, 0x02, 0xe7, 0x13, 0xa7, 0xc4, 0x85, 0x4d, 0x83, 0x06, 0x5d, 0x79, 0xb0, 0x33, 0x44, 0xec, - 0xc8, 0x86, 0xbf, 0x35, 0x69, 0xc3, 0x03, 0x74, 0x2d, 0xd1, 0x3f, 0x34, 0xc9, 0x5c, 0xf6, 0x49, - 0x1e, 0xc2, 0xf9, 0x27, 0xd8, 0xe3, 0x03, 0x90, 0x6f, 0xd8, 0x9d, 0x5d, 0x91, 0x45, 0xa5, 0x3a, - 0x17, 0x97, 0x6a, 0xf5, 0xaf, 0x72, 0x42, 0x16, 0xe9, 0x50, 0x6d, 0xab, 0x67, 0xa3, 0x4b, 0x50, - 0x11, 0x28, 0x9c, 0x2b, 0x02, 0x00, 0xfa, 0x06, 0x14, 0xc9, 0x4c, 0x19, 0x4b, 0xd4, 0xef, 0xbf, - 0x29, 0x5f, 0x53, 0x88, 0xa6, 0xc6, 0xf0, 0x51, 0x1b, 0xea, 0xae, 0xa7, 0x3b, 0x5e, 0x67, 0x64, - 0xbb, 0xf4, 0x9c, 0x29, 0xe3, 0x54, 0xef, 0xab, 0x51, 0x0a, 0x42, 0xe5, 0x6f, 0xb9, 0xfd, 0x1d, - 0x8e, 0xa9, 0x2d, 0xd2, 0x9e, 0x7e, 0x13, 0x3d, 0x86, 0x1a, 0xb6, 0x8c, 0x80, 0x50, 0x21, 0x33, - 0xa1, 0x2a, 0xb6, 0x0c, 0x41, 0x26, 0x38, 0x9f, 0x62, 0xf6, 0xf3, 0xf9, 0x1d, 0x05, 0x9a, 0xc9, - 0x03, 0x9a, 0x47, 0x65, 0x3f, 0x64, 0x9d, 0x30, 0x3b, 0xa0, 0x89, 0x12, 0x2e, 0x0e, 0x49, 0xe3, - 0x5d, 0xd4, 0x3f, 0x50, 0xe0, 0x8d, 0x60, 0x3a, 0xf4, 0xd3, 0xab, 0xe2, 0x16, 0x74, 0x1b, 0x1a, - 0xa6, 0xd5, 0x1d, 0x8c, 0x0d, 0xfc, 0xd4, 0xfa, 0x14, 0xeb, 0x03, 0xef, 0xe0, 0x84, 0x9e, 0x61, - 0x59, 0x4b, 0xc0, 0xd5, 0x7f, 0xc9, 0xc1, 0x4a, 0x7c, 0x5e, 0xf3, 0x6c, 0xd2, 0x2f, 0x40, 0xd1, - 0xb4, 0x7a, 0xb6, 0xbf, 0x47, 0x57, 0x26, 0x08, 0x25, 0x19, 0x8b, 0x21, 0x23, 0x1b, 0x90, 0xaf, - 0xc6, 0xba, 0x07, 0xb8, 0x7b, 0x38, 0xb2, 0x4d, 0xaa, 0xb0, 0x08, 0x89, 0x5f, 0x92, 0x90, 0x90, - 0xcf, 0xf8, 0xee, 0x1a, 0xa3, 0xb1, 0x26, 0x48, 0x3c, 0xb6, 0x3c, 0xe7, 0x44, 0x5b, 0xee, 0xc6, - 0xe1, 0xad, 0x03, 0x58, 0x91, 0x23, 0xa3, 0x06, 0xe4, 0x0f, 0xf1, 0x09, 0x5d, 0x72, 0x45, 0x23, - 0x3f, 0xd1, 0x03, 0x28, 0x1e, 0xe9, 0x83, 0x31, 0xe6, 0xda, 0x21, 0x0b, 0xfb, 0xb2, 0x0e, 0xdf, - 0xcc, 0x3d, 0x50, 0xd4, 0x21, 0x5c, 0x7c, 0x82, 0xbd, 0xb6, 0xe5, 0x62, 0xc7, 0x5b, 0x35, 0xad, - 0x81, 0xdd, 0xdf, 0xd1, 0xbd, 0x83, 0x39, 0x74, 0x45, 0x44, 0xec, 0x73, 0x31, 0xb1, 0x57, 0x7f, - 0xa2, 0xc0, 0x25, 0xf9, 0x78, 0xfc, 0x54, 0x5b, 0x50, 0xee, 0x99, 0x78, 0x60, 0x10, 0xd6, 0x51, - 0x28, 0xeb, 0x88, 0x36, 0xd1, 0x19, 0x23, 0x82, 0xcc, 0x0f, 0xef, 0xcd, 0x94, 0x95, 0xee, 0x7a, - 0x8e, 0x69, 0xf5, 0x37, 0x4d, 0xd7, 0xd3, 0x18, 0x7e, 0x88, 0x55, 0xf2, 0xd9, 0x25, 0xf4, 0xb7, - 0x15, 0xb8, 0xf2, 0x04, 0x7b, 0x6b, 0xc2, 0xe4, 0x90, 0xef, 0xa6, 0xeb, 0x99, 0x5d, 0xf7, 0xe5, - 0xba, 0x84, 0x19, 0x7c, 0x0f, 0xf5, 0xc7, 0x0a, 0x5c, 0x4d, 0x9d, 0x0c, 0xdf, 0x3a, 0xae, 0x52, - 0x7d, 0x83, 0x23, 0x57, 0xa9, 0xbf, 0x82, 0x4f, 0x3e, 0x23, 0x87, 0xbf, 0xa3, 0x9b, 0x0e, 0x53, - 0xa9, 0x33, 0x1a, 0x98, 0x9f, 0x29, 0x70, 0xf9, 0x09, 0xf6, 0x76, 0x7c, 0x73, 0xfb, 0x1a, 0x77, - 0x87, 0xe0, 0x84, 0xcc, 0xbe, 0xef, 0x77, 0x46, 0x60, 0xea, 0xef, 0xb2, 0xe3, 0x94, 0xce, 0xf7, - 0xb5, 0x6c, 0xe0, 0x15, 0x2a, 0x09, 0x21, 0x3d, 0xc1, 0x25, 0x9e, 0x6f, 0x9f, 0xfa, 0x27, 0x0a, - 0x5c, 0x78, 0xd4, 0x7d, 0x3e, 0x36, 0x1d, 0xcc, 0x91, 0x36, 0xed, 0xee, 0xe1, 0xec, 0x9b, 0x1b, - 0x78, 0x90, 0xb9, 0x88, 0x07, 0x39, 0x2d, 0x22, 0x59, 0x81, 0x92, 0xc7, 0x5c, 0x56, 0xe6, 0x84, - 0xf1, 0x16, 0x9d, 0x9f, 0x86, 0x07, 0x58, 0x77, 0xff, 0x77, 0xce, 0xef, 0xc7, 0x05, 0xa8, 0x7d, - 0xc6, 0x55, 0x2b, 0x75, 0x48, 0xe2, 0x9c, 0xa4, 0xc8, 0x7d, 0xca, 0x90, 0x73, 0x2a, 0xf3, 0x57, - 0x9f, 0xc0, 0xa2, 0x8b, 0xf1, 0xe1, 0x2c, 0xee, 0x47, 0x8d, 0x74, 0x14, 0x6e, 0xc3, 0x26, 0x2c, - 0x8f, 0x2d, 0x1a, 0xf5, 0x60, 0x83, 0x6f, 0x20, 0xe3, 0xdc, 0xe9, 0x66, 0x29, 0xd9, 0x11, 0x7d, - 0xca, 0x03, 0xab, 0x10, 0xad, 0x62, 0x26, 0x5a, 0xf1, 0x6e, 0xa8, 0x0d, 0x0d, 0xc3, 0xb1, 0x47, - 0x23, 0x6c, 0x74, 0x5c, 0x9f, 0x54, 0x29, 0x1b, 0x29, 0xde, 0x4f, 0x90, 0x7a, 0x1f, 0xce, 0xc6, - 0x67, 0xda, 0x36, 0x88, 0xaf, 0x4d, 0xce, 0x50, 0xf6, 0x09, 0xdd, 0x81, 0xe5, 0x24, 0x7e, 0x99, - 0xe2, 0x27, 0x3f, 0xa0, 0xf7, 0x00, 0xc5, 0xa6, 0x4a, 0xd0, 0x2b, 0x0c, 0x3d, 0x3a, 0x99, 0xb6, - 0xe1, 0xaa, 0x3f, 0x52, 0x60, 0xe5, 0x99, 0xee, 0x75, 0x0f, 0xd6, 0x87, 0x5c, 0xd6, 0xe6, 0xd0, - 0x55, 0x1f, 0x43, 0xe5, 0x88, 0xf3, 0x85, 0x6f, 0x90, 0xae, 0x4a, 0xf6, 0x27, 0xcc, 0x81, 0x5a, - 0xd0, 0x83, 0x84, 0x7a, 0xe7, 0x36, 0x42, 0x21, 0xef, 0x6b, 0xd0, 0x9a, 0x53, 0x62, 0x75, 0xf5, - 0x05, 0x00, 0x9f, 0xdc, 0x96, 0xdb, 0x9f, 0x61, 0x5e, 0x0f, 0x60, 0x81, 0x53, 0xe3, 0x6a, 0x71, - 0x1a, 0xff, 0xf8, 0xe8, 0xea, 0x4f, 0x4b, 0x50, 0x0d, 0x7d, 0x40, 0x75, 0xc8, 0x09, 0x79, 0xcd, - 0x49, 0x56, 0x97, 0x9b, 0x1e, 0x1d, 0xe6, 0x93, 0xd1, 0xe1, 0x4d, 0xa8, 0x9b, 0xd4, 0x0f, 0xe9, - 0xf0, 0x53, 0xa1, 0x0a, 0xa4, 0xa2, 0x2d, 0x32, 0x28, 0x67, 0x11, 0x74, 0x05, 0xaa, 0xd6, 0x78, - 0xd8, 0xb1, 0x7b, 0x1d, 0xc7, 0x3e, 0x76, 0x79, 0x98, 0x59, 0xb1, 0xc6, 0xc3, 0xef, 0xf4, 0x34, - 0xfb, 0xd8, 0x0d, 0x22, 0x99, 0xd2, 0x29, 0x23, 0x99, 0x2b, 0x50, 0x1d, 0xea, 0x2f, 0x08, 0xd5, - 0x8e, 0x35, 0x1e, 0xd2, 0x08, 0x34, 0xaf, 0x55, 0x86, 0xfa, 0x0b, 0xcd, 0x3e, 0xde, 0x1e, 0x0f, - 0xd1, 0x2d, 0x68, 0x0c, 0x74, 0xd7, 0xeb, 0x84, 0x43, 0xd8, 0x32, 0x0d, 0x61, 0xeb, 0x04, 0xfe, - 0x38, 0x08, 0x63, 0x93, 0x31, 0x51, 0x65, 0x8e, 0x98, 0xc8, 0x18, 0x0e, 0x02, 0x42, 0x90, 0x3d, - 0x26, 0x32, 0x86, 0x03, 0x41, 0xe6, 0x01, 0x2c, 0xec, 0x53, 0xef, 0xce, 0x6d, 0x56, 0x53, 0x75, - 0xc7, 0x06, 0x71, 0xec, 0x98, 0x13, 0xa8, 0xf9, 0xe8, 0xe8, 0x5b, 0x50, 0xa1, 0x46, 0x95, 0xf6, - 0xad, 0x65, 0xea, 0x1b, 0x74, 0x20, 0xbd, 0x0d, 0x3c, 0xf0, 0x74, 0xda, 0x7b, 0x31, 0x5b, 0x6f, - 0xd1, 0x81, 0xe8, 0xab, 0xae, 0x83, 0x75, 0x0f, 0x1b, 0xab, 0x27, 0x6b, 0xf6, 0x70, 0xa4, 0x53, - 0x66, 0x6a, 0xd6, 0x69, 0x70, 0x22, 0xfb, 0x84, 0xde, 0x82, 0x7a, 0x57, 0xb4, 0x36, 0x1c, 0x7b, - 0xd8, 0x5c, 0xa2, 0x72, 0x14, 0x83, 0xa2, 0xcb, 0x00, 0xbe, 0xa6, 0xd2, 0xbd, 0x66, 0x83, 0x9e, - 0x62, 0x85, 0x43, 0x1e, 0xd1, 0x0c, 0x95, 0xe9, 0x76, 0x58, 0x2e, 0xc8, 0xb4, 0xfa, 0xcd, 0x65, - 0x3a, 0x62, 0xd5, 0x4f, 0x1e, 0x99, 0x56, 0x1f, 0x9d, 0x87, 0x05, 0xd3, 0xed, 0xf4, 0xf4, 0x43, - 0xdc, 0x44, 0xf4, 0x6b, 0xc9, 0x74, 0x37, 0xf4, 0x43, 0xac, 0xfe, 0x10, 0xce, 0x05, 0xdc, 0x15, - 0x3a, 0xc9, 0x24, 0x53, 0x28, 0xb3, 0x32, 0xc5, 0x64, 0x9f, 0xfe, 0xab, 0x02, 0xac, 0xec, 0xea, - 0x47, 0xf8, 0xd5, 0x87, 0x0f, 0x99, 0xd4, 0xda, 0x26, 0x2c, 0xd3, 0x88, 0xe1, 0x7e, 0x68, 0x3e, - 0x13, 0xec, 0x6a, 0x98, 0x15, 0x92, 0x1d, 0xd1, 0xb7, 0x89, 0x43, 0x80, 0xbb, 0x87, 0x3b, 0x24, - 0x04, 0xf3, 0x6d, 0xea, 0x65, 0x09, 0x9d, 0x35, 0x81, 0xa5, 0x85, 0x7b, 0xa0, 0x1d, 0x58, 0x8a, - 0x1e, 0x83, 0x6f, 0x4d, 0xdf, 0x9e, 0x18, 0x9f, 0x07, 0xbb, 0xaf, 0xd5, 0x23, 0x87, 0xe1, 0xa2, - 0x26, 0x2c, 0x70, 0x53, 0x48, 0x75, 0x46, 0x59, 0xf3, 0x9b, 0x68, 0x07, 0xce, 0xb2, 0x15, 0xec, - 0x72, 0x81, 0x60, 0x8b, 0x2f, 0x67, 0x5a, 0xbc, 0xac, 0x6b, 0x54, 0x9e, 0x2a, 0xa7, 0x95, 0xa7, - 0x26, 0x2c, 0x70, 0x1e, 0xa7, 0x7a, 0xa4, 0xac, 0xf9, 0x4d, 0x72, 0xcc, 0x01, 0xb7, 0x57, 0xe9, - 0xb7, 0x00, 0x40, 0x42, 0x2f, 0x08, 0xf6, 0x73, 0x4a, 0x26, 0xe9, 0x13, 0x28, 0x0b, 0x0e, 0xcf, - 0x1e, 0x02, 0x8b, 0x3e, 0x71, 0xfd, 0x9e, 0x8f, 0xe9, 0x77, 0xf5, 0x1f, 0x14, 0xa8, 0xad, 0x93, - 0x25, 0x6d, 0xda, 0x7d, 0x6a, 0x8d, 0x6e, 0x42, 0xdd, 0xc1, 0x5d, 0xdb, 0x31, 0x3a, 0xd8, 0xf2, - 0x1c, 0x13, 0xb3, 0x04, 0x44, 0x41, 0x5b, 0x64, 0xd0, 0xc7, 0x0c, 0x48, 0xd0, 0x88, 0xca, 0x76, - 0x3d, 0x7d, 0x38, 0xea, 0xf4, 0x88, 0x6a, 0xc8, 0x31, 0x34, 0x01, 0xa5, 0x9a, 0xe1, 0x4d, 0xa8, - 0x05, 0x68, 0x9e, 0x4d, 0xc7, 0x2f, 0x68, 0x55, 0x01, 0xdb, 0xb3, 0xd1, 0x0d, 0xa8, 0xd3, 0x3d, - 0xed, 0x0c, 0xec, 0x7e, 0x87, 0x44, 0xb4, 0xdc, 0x50, 0xd5, 0x0c, 0x3e, 0x2d, 0x72, 0x56, 0x51, - 0x2c, 0xd7, 0xfc, 0x01, 0xe6, 0xa6, 0x4a, 0x60, 0xed, 0x9a, 0x3f, 0xc0, 0xea, 0xdf, 0x2b, 0xb0, - 0xb8, 0xae, 0x7b, 0xfa, 0xb6, 0x6d, 0xe0, 0xbd, 0x19, 0x0d, 0x7b, 0x86, 0xac, 0xee, 0x25, 0xa8, - 0x88, 0x15, 0xf0, 0x25, 0x05, 0x00, 0xb4, 0x01, 0x75, 0xdf, 0xb5, 0xec, 0xb0, 0x88, 0xab, 0x90, - 0xea, 0x40, 0x85, 0x2c, 0xa7, 0xab, 0x2d, 0xfa, 0xdd, 0x68, 0x53, 0xdd, 0x80, 0x5a, 0xf8, 0x33, - 0x19, 0x75, 0x37, 0xce, 0x28, 0x02, 0x40, 0xb8, 0x71, 0x7b, 0x3c, 0x24, 0x67, 0xca, 0x15, 0x8b, - 0xdf, 0x54, 0x7f, 0x53, 0x81, 0x45, 0x6e, 0xee, 0x77, 0x45, 0xfd, 0x83, 0x2e, 0x8d, 0xe5, 0x59, - 0xe8, 0x6f, 0xf4, 0xcd, 0x68, 0xca, 0xf2, 0x86, 0x54, 0x09, 0x50, 0x22, 0xd4, 0xc9, 0x8c, 0xd8, - 0xfa, 0x2c, 0x31, 0xfe, 0x17, 0x84, 0xd1, 0xf8, 0xd1, 0x50, 0x46, 0x6b, 0xc2, 0x82, 0x6e, 0x18, - 0x0e, 0x76, 0x5d, 0x3e, 0x0f, 0xbf, 0x49, 0xbe, 0x1c, 0x61, 0xc7, 0xf5, 0x59, 0x3e, 0xaf, 0xf9, - 0x4d, 0xf4, 0x2d, 0x28, 0x0b, 0xaf, 0x94, 0x25, 0xa8, 0xae, 0xa5, 0xcf, 0x93, 0x47, 0xa4, 0xa2, - 0x87, 0xfa, 0x37, 0x39, 0xa8, 0xf3, 0x0d, 0x5b, 0xe5, 0xf6, 0x78, 0xb2, 0xf0, 0xad, 0x42, 0xad, - 0x17, 0xc8, 0xfe, 0xa4, 0xb4, 0x5a, 0x58, 0x45, 0x44, 0xfa, 0x4c, 0x13, 0xc0, 0xa8, 0x47, 0x50, - 0x98, 0xcb, 0x23, 0x28, 0x9e, 0x56, 0x83, 0x25, 0x7d, 0xc4, 0x92, 0xc4, 0x47, 0x54, 0x7f, 0x0d, - 0xaa, 0x21, 0x02, 0x54, 0x43, 0xb3, 0xa4, 0x15, 0xdf, 0x31, 0xbf, 0x89, 0x3e, 0x0c, 0xfc, 0x22, - 0xb6, 0x55, 0x17, 0x24, 0x73, 0x89, 0xb9, 0x44, 0xea, 0xdf, 0x29, 0x50, 0xe2, 0x94, 0xaf, 0x42, - 0x95, 0x2b, 0x1d, 0xea, 0x33, 0x32, 0xea, 0xc0, 0x41, 0xc4, 0x69, 0x7c, 0x79, 0x5a, 0xe7, 0x02, - 0x94, 0x63, 0xfa, 0x66, 0x81, 0x9b, 0x05, 0xff, 0x53, 0x48, 0xc9, 0x90, 0x4f, 0x44, 0xbf, 0xa0, - 0x73, 0x50, 0x1c, 0xd8, 0x7d, 0x51, 0xdf, 0x62, 0x0d, 0xf5, 0x4b, 0x85, 0x96, 0x23, 0x34, 0xdc, - 0xb5, 0x8f, 0xb0, 0x73, 0x32, 0x7f, 0x1e, 0xf7, 0x61, 0x88, 0xcd, 0x33, 0x06, 0x5f, 0xa2, 0x03, - 0x7a, 0x18, 0x1c, 0x42, 0x5e, 0x96, 0xe9, 0x09, 0xeb, 0x1d, 0xce, 0xa4, 0xc1, 0x61, 0xfc, 0x9e, - 0x42, 0x33, 0xd2, 0xd1, 0xa5, 0xcc, 0xea, 0xed, 0xbc, 0x94, 0x40, 0x46, 0xfd, 0x4a, 0x81, 0x56, - 0x90, 0x4a, 0x72, 0x57, 0x4f, 0xe6, 0xad, 0xf7, 0xbc, 0x9c, 0xf8, 0xea, 0x17, 0x45, 0x41, 0x82, - 0x08, 0x6d, 0xa6, 0xc8, 0xc8, 0x2f, 0x47, 0x58, 0x34, 0x2b, 0x9d, 0x5c, 0xd0, 0x3c, 0x2c, 0xd3, - 0x82, 0xb2, 0xc8, 0x67, 0xb0, 0xa2, 0x84, 0x68, 0xab, 0xff, 0xaa, 0xc0, 0x85, 0x27, 0xd8, 0xdb, - 0x88, 0xa6, 0x42, 0x5e, 0xf7, 0x06, 0x86, 0x0b, 0x25, 0x07, 0xbc, 0x50, 0x52, 0x88, 0x15, 0x4a, - 0x38, 0xdc, 0x2f, 0x97, 0xaf, 0xe2, 0x9e, 0xed, 0x30, 0xa1, 0x2c, 0x68, 0x21, 0x88, 0x3a, 0xa4, - 0x2c, 0x92, 0x58, 0xe0, 0xab, 0xda, 0xd0, 0xdf, 0x52, 0xa0, 0xc9, 0x47, 0xa1, 0x63, 0x92, 0x90, - 0x69, 0x80, 0x3d, 0x6c, 0x7c, 0xdd, 0xa9, 0x84, 0x3f, 0xca, 0x41, 0x23, 0x6c, 0x95, 0xa9, 0x61, - 0xfd, 0x08, 0x8a, 0x34, 0x13, 0xc3, 0x67, 0x30, 0x55, 0x75, 0x30, 0x6c, 0xa2, 0xd6, 0xa9, 0x2b, - 0xbe, 0x27, 0x1c, 0x08, 0xde, 0x0c, 0x5c, 0x83, 0xfc, 0xe9, 0x5d, 0x03, 0xee, 0x2a, 0xd9, 0x63, - 0x42, 0x97, 0xa5, 0x30, 0x03, 0x00, 0xfa, 0x18, 0x4a, 0xec, 0x7e, 0x0a, 0x2f, 0x2e, 0xde, 0x8c, - 0x92, 0xe6, 0x77, 0x57, 0x42, 0x75, 0x01, 0x0a, 0xd0, 0x78, 0x27, 0x72, 0x46, 0x23, 0xc7, 0xee, - 0x53, 0x1f, 0x82, 0x68, 0xe4, 0xa2, 0x26, 0xda, 0xea, 0x2f, 0xc3, 0x4a, 0x10, 0xc9, 0xb2, 0x29, - 0xcd, 0xca, 0xf0, 0xea, 0x3f, 0x2b, 0x70, 0x76, 0xf7, 0xc4, 0xea, 0xc6, 0x45, 0x67, 0x05, 0x4a, - 0xa3, 0x81, 0x1e, 0x64, 0x5b, 0x79, 0x8b, 0xba, 0x90, 0x6c, 0x6c, 0x6c, 0x10, 0xfb, 0xc3, 0xf6, - 0xb3, 0x2a, 0x60, 0x7b, 0xf6, 0x54, 0xb7, 0xe0, 0xa6, 0x08, 0xbd, 0xb1, 0xc1, 0x2c, 0x1d, 0x4b, - 0x61, 0x2d, 0x0a, 0x28, 0xb5, 0x74, 0x1f, 0x03, 0x50, 0x67, 0xa0, 0x73, 0x1a, 0x07, 0x80, 0xf6, - 0xd8, 0x24, 0xea, 0xfe, 0xe7, 0x39, 0x68, 0x86, 0x76, 0xe9, 0xeb, 0xf6, 0x8d, 0x52, 0x22, 0xba, - 0xfc, 0x4b, 0x8a, 0xe8, 0x0a, 0xf3, 0xfb, 0x43, 0x45, 0x99, 0x3f, 0xf4, 0xef, 0x39, 0xa8, 0x07, - 0xbb, 0xb6, 0x33, 0xd0, 0xad, 0x54, 0x4e, 0xd8, 0x15, 0xb1, 0x40, 0x74, 0x9f, 0xde, 0x95, 0xc9, - 0x50, 0xca, 0x41, 0x68, 0x31, 0x12, 0xe8, 0x32, 0x3d, 0x74, 0xc7, 0x63, 0x49, 0x33, 0x1e, 0x7f, - 0x30, 0x61, 0x35, 0x87, 0x18, 0xdd, 0x01, 0xc4, 0x25, 0xac, 0x63, 0x5a, 0x1d, 0x17, 0x77, 0x6d, - 0xcb, 0x60, 0xb2, 0x57, 0xd4, 0x1a, 0xfc, 0x4b, 0xdb, 0xda, 0x65, 0x70, 0xf4, 0x11, 0x14, 0xbc, - 0x93, 0x11, 0x53, 0xaa, 0x75, 0xa9, 0xaf, 0x10, 0xcc, 0x6b, 0xef, 0x64, 0x84, 0x35, 0x8a, 0xee, - 0x6b, 0x64, 0xcf, 0xd1, 0x8f, 0xb8, 0xdb, 0xc8, 0x35, 0x32, 0x83, 0x10, 0x6d, 0xe2, 0xef, 0xe1, - 0x02, 0x73, 0xaf, 0x78, 0x93, 0x71, 0xb6, 0x2f, 0xd0, 0x1d, 0xcf, 0x1b, 0xd0, 0xb4, 0x1f, 0xe5, - 0x6c, 0x1f, 0xba, 0xe7, 0x0d, 0xd4, 0x7f, 0x22, 0xaa, 0x4d, 0x8c, 0xac, 0x61, 0x77, 0x3c, 0x48, - 0x17, 0xb8, 0xc9, 0x79, 0x95, 0x69, 0xb2, 0xf6, 0x6d, 0xa8, 0xf2, 0x63, 0x3f, 0x05, 0xdb, 0x00, - 0xeb, 0xb2, 0x39, 0x81, 0x8f, 0x8b, 0x2f, 0x89, 0x8f, 0x4b, 0x33, 0x64, 0x26, 0xe4, 0x9b, 0xaf, - 0xfe, 0x44, 0x81, 0x37, 0x12, 0x6a, 0x71, 0xe2, 0xd6, 0x4e, 0x8e, 0x0b, 0xb9, 0xba, 0x8c, 0x93, - 0xe4, 0xca, 0xff, 0x21, 0x94, 0x1c, 0x4a, 0x9d, 0x97, 0x91, 0xae, 0x4f, 0xe4, 0x2e, 0x36, 0x11, - 0x8d, 0x77, 0x51, 0x7f, 0x5f, 0x81, 0xf3, 0xc9, 0xa9, 0xce, 0x61, 0xd1, 0x57, 0x61, 0x81, 0x91, - 0xf6, 0x85, 0xf0, 0xd6, 0x64, 0x21, 0x0c, 0x36, 0x47, 0xf3, 0x3b, 0xaa, 0xbb, 0xb0, 0xe2, 0x1b, - 0xfe, 0x60, 0xeb, 0xb7, 0xb0, 0xa7, 0x4f, 0x88, 0x8a, 0xae, 0x42, 0x95, 0xb9, 0xd7, 0x2c, 0xda, - 0x60, 0xf9, 0x04, 0xd8, 0x17, 0x69, 0x38, 0xf5, 0xbf, 0x14, 0x38, 0x47, 0x2d, 0x67, 0xbc, 0x6e, - 0x93, 0xa5, 0xa6, 0xa7, 0x8a, 0x74, 0xc5, 0xb6, 0x3e, 0xe4, 0xd7, 0x63, 0x2a, 0x5a, 0x04, 0x86, - 0xda, 0xc9, 0x2c, 0x9d, 0x34, 0x7a, 0x0e, 0x8a, 0xc0, 0x24, 0x52, 0xa7, 0x35, 0xe0, 0x78, 0x7a, - 0x2e, 0xb0, 0xd8, 0x85, 0x19, 0x2c, 0xb6, 0xba, 0x09, 0x6f, 0xc4, 0x56, 0x3a, 0xc7, 0x89, 0xaa, - 0x7f, 0xae, 0x90, 0xe3, 0x88, 0x5c, 0x33, 0x9a, 0xdd, 0xab, 0xbd, 0x2c, 0x0a, 0x46, 0x1d, 0xd3, - 0x88, 0x2b, 0x11, 0x03, 0x7d, 0x02, 0x15, 0x0b, 0x1f, 0x77, 0xc2, 0x8e, 0x50, 0x06, 0x97, 0xbf, - 0x6c, 0xe1, 0x63, 0xfa, 0x4b, 0xdd, 0x86, 0xf3, 0x89, 0xa9, 0xce, 0xb3, 0xf6, 0xbf, 0x55, 0xe0, - 0xc2, 0xba, 0x63, 0x8f, 0x3e, 0x33, 0x1d, 0x6f, 0xac, 0x0f, 0xa2, 0xe5, 0xf5, 0x57, 0x93, 0xf6, - 0xfa, 0x34, 0xe4, 0x12, 0x33, 0xfe, 0xb9, 0x23, 0x91, 0xa0, 0xe4, 0xa4, 0xf8, 0xa2, 0x43, 0x0e, - 0xf4, 0x7f, 0xe6, 0x65, 0x93, 0xe7, 0x78, 0x53, 0x1c, 0x8f, 0x2c, 0xd1, 0x87, 0x34, 0x4b, 0x9e, - 0x9f, 0x35, 0x4b, 0x9e, 0xa2, 0xde, 0x0b, 0x2f, 0x49, 0xbd, 0x9f, 0x3a, 0x6d, 0xf3, 0x29, 0x44, - 0x2b, 0x18, 0xd4, 0xfc, 0xce, 0x54, 0xfa, 0x58, 0x05, 0x08, 0xb2, 0xf9, 0xfc, 0x96, 0x68, 0x16, - 0x32, 0xa1, 0x5e, 0xe4, 0xb4, 0x84, 0x29, 0xe5, 0xa6, 0x3c, 0x94, 0x5f, 0xfe, 0x2e, 0xb4, 0x64, - 0x5c, 0x3a, 0x0f, 0xe7, 0xff, 0x3c, 0x07, 0xd0, 0x16, 0x17, 0x8b, 0x67, 0xb3, 0x05, 0xd7, 0x21, - 0xe4, 0x6e, 0x04, 0xf2, 0x1e, 0xe6, 0x22, 0x83, 0x88, 0x84, 0x08, 0x58, 0x09, 0x4e, 0x22, 0x88, - 0x35, 0x28, 0x9d, 0x90, 0xd4, 0x30, 0xa6, 0x88, 0xab, 0xdf, 0x8b, 0x50, 0x71, 0xec, 0xe3, 0x0e, - 0x11, 0x33, 0xc3, 0xbf, 0x39, 0xed, 0xd8, 0xc7, 0x44, 0xf8, 0x0c, 0x74, 0x1e, 0x16, 0x3c, 0xdd, - 0x3d, 0x24, 0xf4, 0x4b, 0xa1, 0x1b, 0x1e, 0x06, 0x3a, 0x07, 0xc5, 0x9e, 0x39, 0xc0, 0xec, 0x42, - 0x41, 0x45, 0x63, 0x0d, 0xf4, 0x0d, 0xff, 0x8a, 0x5f, 0x39, 0xf3, 0x2d, 0x1e, 0x8a, 0xaf, 0x7e, - 0xa9, 0xc0, 0x52, 0xb0, 0x6b, 0x54, 0x01, 0x11, 0x9d, 0x46, 0xf5, 0xd9, 0x9a, 0x6d, 0x30, 0x55, - 0x51, 0x4f, 0xb1, 0x08, 0xac, 0x23, 0xd3, 0x5a, 0x41, 0x97, 0x49, 0x31, 0x32, 0x59, 0x17, 0x59, - 0xb4, 0x69, 0xf8, 0xb7, 0x5a, 0x4a, 0x8e, 0x7d, 0xdc, 0x36, 0xc4, 0x6e, 0xb0, 0x6b, 0xd1, 0x2c, - 0x22, 0x24, 0xbb, 0xb1, 0x46, 0x6f, 0x46, 0x5f, 0x87, 0x45, 0xec, 0x38, 0xb6, 0xd3, 0x19, 0x62, - 0xd7, 0xd5, 0xfb, 0x98, 0x3b, 0xe0, 0x35, 0x0a, 0xdc, 0x62, 0x30, 0xf5, 0x0f, 0x0b, 0x50, 0x0f, - 0x96, 0xe2, 0xd7, 0xd0, 0x4d, 0xc3, 0xaf, 0xa1, 0x9b, 0xe4, 0xe8, 0xc0, 0x61, 0xaa, 0x50, 0x1c, - 0xee, 0x6a, 0xae, 0xa9, 0x68, 0x15, 0x0e, 0x6d, 0x1b, 0xc4, 0x2c, 0x13, 0x21, 0xb3, 0x6c, 0x03, - 0x07, 0x87, 0x0b, 0x3e, 0x88, 0x9f, 0x6d, 0x84, 0x47, 0x0a, 0x19, 0x78, 0xa4, 0x98, 0x81, 0x47, - 0x4a, 0x12, 0x1e, 0x59, 0x81, 0xd2, 0xfe, 0xb8, 0x7b, 0x88, 0x3d, 0xee, 0xb1, 0xf1, 0x56, 0x94, - 0x77, 0xca, 0x31, 0xde, 0x11, 0x2c, 0x52, 0x09, 0xb3, 0xc8, 0x45, 0xa8, 0xb0, 0x62, 0x6e, 0xc7, - 0x73, 0x69, 0x65, 0x2a, 0xaf, 0x95, 0x19, 0x60, 0xcf, 0x45, 0x0f, 0x7c, 0x77, 0xae, 0x2a, 0x13, - 0x76, 0xaa, 0x75, 0x62, 0x5c, 0xe2, 0x3b, 0x73, 0x6f, 0xc3, 0x52, 0x68, 0x3b, 0xa8, 0x8d, 0xa8, - 0xd1, 0xa9, 0x86, 0xdc, 0x79, 0x6a, 0x26, 0x6e, 0x42, 0x3d, 0xd8, 0x12, 0x8a, 0xb7, 0xc8, 0xa2, - 0x28, 0x01, 0xa5, 0x68, 0x82, 0x93, 0xeb, 0xa7, 0xe3, 0x64, 0x74, 0x01, 0xca, 0x3c, 0xfc, 0x71, - 0x9b, 0x4b, 0x91, 0x4c, 0x85, 0xfa, 0x7d, 0x40, 0xc1, 0xec, 0xe7, 0xf3, 0x16, 0x63, 0xec, 0x91, - 0x8b, 0xb3, 0x87, 0xfa, 0x53, 0x05, 0x96, 0xc3, 0x83, 0xcd, 0x6a, 0x78, 0x3f, 0x81, 0x2a, 0xab, - 0x0d, 0x76, 0x88, 0xe0, 0xf3, 0x0c, 0xd0, 0xe5, 0x89, 0xe7, 0xa2, 0x41, 0xf0, 0xb0, 0x82, 0xb0, - 0xd7, 0xb1, 0xed, 0x1c, 0x9a, 0x56, 0xbf, 0x43, 0x66, 0xe6, 0x8b, 0x5b, 0x8d, 0x03, 0xb7, 0x09, - 0x4c, 0xfd, 0x91, 0x02, 0x57, 0x9e, 0x8e, 0x0c, 0xdd, 0xc3, 0x21, 0x0f, 0x64, 0xde, 0x0b, 0x8d, - 0x1f, 0xf9, 0x37, 0x0a, 0x73, 0xd9, 0xea, 0x5b, 0x0c, 0x5b, 0xfd, 0x4b, 0x31, 0x97, 0xc4, 0x2d, - 0xe0, 0xd9, 0xe7, 0xd2, 0x82, 0xf2, 0x11, 0x27, 0xe7, 0x3f, 0x14, 0xf1, 0xdb, 0x91, 0x1a, 0x6a, - 0xfe, 0xf4, 0x35, 0x54, 0x75, 0x0b, 0x2e, 0x68, 0xd8, 0xc5, 0x96, 0x11, 0x59, 0xcd, 0xcc, 0xd9, - 0xa4, 0x11, 0xb4, 0x64, 0xe4, 0xe6, 0x61, 0x56, 0xe6, 0xbb, 0x76, 0x1c, 0x42, 0xd6, 0xe3, 0xaa, - 0x98, 0xb8, 0x4c, 0x74, 0x1c, 0x4f, 0xfd, 0x8b, 0x1c, 0x9c, 0x7f, 0x64, 0x18, 0x5c, 0x8b, 0x73, - 0x6f, 0xec, 0x55, 0x39, 0xca, 0x71, 0x47, 0x32, 0x9f, 0x74, 0x24, 0x5f, 0x96, 0x66, 0xe5, 0x36, - 0xc6, 0x1a, 0x0f, 0x7d, 0xdb, 0xe9, 0xb0, 0xcb, 0x45, 0x0f, 0x79, 0x51, 0x8d, 0x04, 0xf4, 0xd4, - 0x7e, 0x4e, 0xf7, 0xaf, 0xca, 0x7e, 0x56, 0x4c, 0x1d, 0x41, 0x33, 0xb9, 0x59, 0x73, 0xaa, 0x12, - 0x7f, 0x47, 0x46, 0x36, 0xcb, 0xae, 0xd6, 0x88, 0x0b, 0x45, 0x41, 0x3b, 0xb6, 0xab, 0xfe, 0x77, - 0x0e, 0x9a, 0xbb, 0xfa, 0x11, 0xfe, 0xff, 0x73, 0x40, 0x9f, 0xc3, 0x39, 0x57, 0x3f, 0xc2, 0x9d, - 0x50, 0x60, 0xdc, 0x71, 0xf0, 0x73, 0xee, 0x82, 0xbe, 0x23, 0xd3, 0x24, 0xd2, 0x3b, 0x38, 0xda, - 0xb2, 0x1b, 0x81, 0x6b, 0xf8, 0x39, 0x7a, 0x0b, 0x96, 0xc2, 0x97, 0xbc, 0xc8, 0xd4, 0xca, 0x74, - 0xcb, 0x17, 0x43, 0x77, 0xb8, 0xda, 0x86, 0xfa, 0x1c, 0x2e, 0x3d, 0xb5, 0x5c, 0xec, 0xb5, 0x83, - 0x7b, 0x48, 0x73, 0x86, 0x90, 0x57, 0xa1, 0x1a, 0x6c, 0x7c, 0xe2, 0x71, 0x88, 0xe1, 0xaa, 0x36, - 0xb4, 0xb6, 0x74, 0xe7, 0xd0, 0xcf, 0x23, 0xaf, 0xb3, 0xfb, 0x22, 0xaf, 0x70, 0xc0, 0x9e, 0xb8, - 0x3e, 0xa5, 0xe1, 0x1e, 0x76, 0xb0, 0xd5, 0xc5, 0x9b, 0x76, 0xf7, 0x30, 0x74, 0xad, 0x58, 0x09, - 0x5f, 0x2b, 0x9e, 0xf5, 0x9a, 0xb2, 0xfa, 0xb3, 0x1c, 0xac, 0x3c, 0x1a, 0x78, 0xd8, 0x09, 0x22, - 0xff, 0xd3, 0x24, 0x31, 0x82, 0xac, 0x42, 0x6e, 0x96, 0x3a, 0x40, 0xfc, 0x86, 0x7c, 0x3e, 0x79, - 0x43, 0x5e, 0x96, 0x03, 0x29, 0xcc, 0x98, 0x03, 0x79, 0x04, 0x30, 0x72, 0xec, 0x11, 0x76, 0x3c, - 0x13, 0xfb, 0xe1, 0x5b, 0x06, 0xf7, 0x25, 0xd4, 0x49, 0xfd, 0x1c, 0x1a, 0x4f, 0xba, 0x6b, 0xb6, - 0xd5, 0x33, 0x9d, 0xa1, 0xbf, 0x51, 0x09, 0xa1, 0x53, 0x32, 0x08, 0x5d, 0x2e, 0x21, 0x74, 0xaa, - 0x09, 0xcb, 0x21, 0xda, 0x73, 0x2a, 0xae, 0x7e, 0xb7, 0xd3, 0x33, 0x2d, 0x93, 0xde, 0xc7, 0xca, - 0x51, 0xf7, 0x13, 0xfa, 0xdd, 0x0d, 0x0e, 0xb9, 0xfd, 0x89, 0xb8, 0xc9, 0xba, 0x77, 0x32, 0xc2, - 0x68, 0x01, 0xf2, 0xdb, 0xf8, 0xb8, 0x71, 0x06, 0x01, 0x94, 0xb6, 0x6d, 0x67, 0xa8, 0x0f, 0x1a, - 0x0a, 0xaa, 0xc2, 0x02, 0x2f, 0xcc, 0x35, 0x72, 0x68, 0x11, 0x2a, 0x6b, 0x7e, 0x01, 0xa3, 0x91, - 0xbf, 0xfd, 0xc7, 0x0a, 0x2c, 0x27, 0x4a, 0x47, 0xa8, 0x0e, 0xf0, 0xd4, 0xea, 0xf2, 0x9a, 0x5a, - 0xe3, 0x0c, 0xaa, 0x41, 0xd9, 0xaf, 0xb0, 0x31, 0x7a, 0x7b, 0x36, 0xc5, 0x6e, 0xe4, 0x50, 0x03, - 0x6a, 0xac, 0xe3, 0xb8, 0xdb, 0xc5, 0xae, 0xdb, 0xc8, 0x0b, 0xc8, 0x86, 0x6e, 0x0e, 0xc6, 0x0e, - 0x6e, 0x14, 0xc8, 0x98, 0x7b, 0x36, 0xbf, 0xcb, 0xdf, 0x28, 0x22, 0x04, 0x75, 0xff, 0x62, 0x3f, - 0xef, 0x54, 0x0a, 0xc1, 0xfc, 0x6e, 0x0b, 0xb7, 0x9f, 0x85, 0x93, 0xfc, 0x74, 0x79, 0xe7, 0xe1, - 0xec, 0x53, 0xcb, 0xc0, 0x3d, 0xd3, 0xc2, 0x46, 0xf0, 0xa9, 0x71, 0x06, 0x9d, 0x85, 0xa5, 0x2d, - 0xec, 0xf4, 0x71, 0x08, 0x98, 0x43, 0xcb, 0xb0, 0xb8, 0x65, 0xbe, 0x08, 0x81, 0xf2, 0x6a, 0xa1, - 0xac, 0x34, 0x94, 0xfb, 0xff, 0x76, 0x19, 0x2a, 0x84, 0xb7, 0xd6, 0x6c, 0xdb, 0x31, 0xd0, 0x00, - 0x10, 0x7d, 0xfa, 0x32, 0x1c, 0xd9, 0x96, 0x78, 0x2b, 0x87, 0xee, 0x46, 0x8f, 0x87, 0x37, 0x92, - 0x88, 0x9c, 0x77, 0x5a, 0x37, 0xa4, 0xf8, 0x31, 0x64, 0xf5, 0x0c, 0x1a, 0xd2, 0xd1, 0xf6, 0xcc, - 0x21, 0xde, 0x33, 0xbb, 0x87, 0xbe, 0x83, 0xf4, 0x7e, 0x8a, 0x3b, 0x94, 0x44, 0xf5, 0xc7, 0xbb, - 0x2e, 0x1d, 0x8f, 0xbd, 0x4d, 0xf2, 0x79, 0x4e, 0x3d, 0x83, 0x9e, 0xc3, 0xb9, 0x27, 0x38, 0xe4, - 0x6b, 0xfa, 0x03, 0xde, 0x4f, 0x1f, 0x30, 0x81, 0x7c, 0xca, 0x21, 0x37, 0xa1, 0x48, 0xd9, 0x0d, - 0xc9, 0xdc, 0xd1, 0xf0, 0x93, 0xf7, 0xd6, 0xb5, 0x74, 0x04, 0x41, 0xed, 0xfb, 0xb0, 0x14, 0x7b, - 0x0c, 0x8b, 0x64, 0xc6, 0x49, 0xfe, 0xac, 0xb9, 0x75, 0x3b, 0x0b, 0xaa, 0x18, 0xab, 0x0f, 0xf5, - 0xe8, 0x93, 0x19, 0x74, 0x2b, 0xc3, 0xeb, 0x3b, 0x36, 0xd2, 0x3b, 0x99, 0xdf, 0xe9, 0x51, 0x26, - 0x68, 0xc4, 0x1f, 0x67, 0xa2, 0xdb, 0x13, 0x09, 0x44, 0x99, 0xed, 0xdd, 0x4c, 0xb8, 0x62, 0xb8, - 0x13, 0xca, 0x04, 0x89, 0x47, 0x71, 0x71, 0x1e, 0xf7, 0xc9, 0xa4, 0xbd, 0xd6, 0x6b, 0xdd, 0xcb, - 0x8c, 0x2f, 0x86, 0xfe, 0x0d, 0x76, 0x33, 0x47, 0xf6, 0xb0, 0x0c, 0x7d, 0x20, 0x27, 0x37, 0xe1, - 0x45, 0x5c, 0xeb, 0xfe, 0x69, 0xba, 0x88, 0x49, 0xfc, 0x90, 0x5e, 0xa9, 0x91, 0x3c, 0xcd, 0x8a, - 0xcb, 0x9d, 0x4f, 0x2f, 0xfd, 0xd5, 0x59, 0xeb, 0x83, 0x53, 0xf4, 0x10, 0x13, 0xb0, 0xe3, 0xaf, - 0x5f, 0x7d, 0x31, 0xbc, 0x37, 0x95, 0x6b, 0x66, 0x93, 0xc1, 0xef, 0xc1, 0x52, 0xcc, 0x5d, 0x43, - 0xd9, 0x5d, 0xba, 0xd6, 0x24, 0xd3, 0xc4, 0x44, 0x32, 0x76, 0x43, 0x09, 0xa5, 0x70, 0xbf, 0xe4, - 0x16, 0x53, 0xeb, 0x76, 0x16, 0x54, 0xb1, 0x10, 0x97, 0xaa, 0xcb, 0xd8, 0xbd, 0x12, 0x74, 0x47, - 0x4e, 0x43, 0x7e, 0xbf, 0xa6, 0xf5, 0x5e, 0x46, 0x6c, 0x31, 0xe8, 0x11, 0x9c, 0x95, 0x5c, 0x0f, - 0x42, 0xef, 0x4d, 0x3c, 0xac, 0xf8, 0xbd, 0xa8, 0xd6, 0xdd, 0xac, 0xe8, 0x62, 0xdc, 0x5f, 0x07, - 0xb4, 0x7b, 0x60, 0x1f, 0x53, 0xcf, 0xa1, 0x3f, 0x76, 0x74, 0xe6, 0xec, 0xa4, 0xd9, 0x86, 0x24, - 0x6a, 0x0a, 0x8f, 0x4e, 0xec, 0x21, 0x06, 0xef, 0x00, 0x3c, 0xc1, 0xde, 0x16, 0xf6, 0x1c, 0x22, - 0x18, 0x6f, 0xa5, 0x99, 0x3f, 0x8e, 0xe0, 0x0f, 0xf5, 0xf6, 0x54, 0xbc, 0x90, 0x29, 0x6a, 0x6c, - 0xe9, 0xd6, 0x58, 0x1f, 0x84, 0xde, 0x37, 0xdc, 0x91, 0x76, 0x8f, 0xa3, 0xa5, 0x1c, 0x64, 0x2a, - 0xb6, 0x18, 0xf2, 0x58, 0x98, 0xf6, 0x50, 0x45, 0x71, 0xb2, 0x69, 0x4f, 0x5e, 0x57, 0x89, 0xab, - 0xbd, 0x09, 0xf8, 0x62, 0xe0, 0x2f, 0x14, 0x7a, 0xc3, 0x2c, 0x86, 0xf0, 0xcc, 0xf4, 0x0e, 0x76, - 0x06, 0xba, 0xe5, 0x66, 0x99, 0x02, 0x45, 0x3c, 0xc5, 0x14, 0x38, 0xbe, 0x98, 0x82, 0x01, 0x8b, - 0x91, 0x42, 0x1f, 0x92, 0x3d, 0x08, 0x90, 0x15, 0x3d, 0x5b, 0xb7, 0xa6, 0x23, 0x8a, 0x51, 0x0e, - 0x60, 0xd1, 0x17, 0x25, 0xb6, 0xb9, 0xef, 0xa4, 0xcd, 0x34, 0xc0, 0x49, 0xd1, 0x04, 0x72, 0xd4, - 0xb0, 0x26, 0x48, 0xd6, 0x31, 0x50, 0xb6, 0xfa, 0xd7, 0x24, 0x4d, 0x90, 0x5e, 0x1c, 0x61, 0xaa, - 0x2e, 0x56, 0x33, 0x94, 0xeb, 0x51, 0x69, 0x09, 0x54, 0xaa, 0xea, 0x52, 0x4a, 0x90, 0xea, 0x19, - 0xf4, 0x0c, 0x4a, 0xfc, 0xbf, 0x5c, 0x6e, 0x4c, 0xce, 0x3d, 0x72, 0xea, 0x37, 0xa7, 0x60, 0x09, - 0xc2, 0x87, 0x70, 0x3e, 0x25, 0xf3, 0x28, 0x35, 0xc1, 0x93, 0xb3, 0x94, 0xd3, 0x8c, 0x83, 0x18, - 0x2c, 0x91, 0x5a, 0x9c, 0x30, 0x58, 0x5a, 0x1a, 0x72, 0xda, 0x60, 0x3a, 0xa0, 0xe4, 0x13, 0x66, - 0x29, 0x4f, 0xa4, 0xbe, 0x74, 0xce, 0x30, 0x44, 0xf2, 0x15, 0xb2, 0x74, 0x88, 0xd4, 0xc7, 0xca, - 0xd3, 0x86, 0xe8, 0xc0, 0x72, 0x22, 0xf7, 0x84, 0xde, 0x4d, 0x31, 0xd7, 0xb2, 0x0c, 0xd5, 0xb4, - 0x01, 0xfa, 0xf0, 0x86, 0x34, 0xcf, 0x22, 0x75, 0x3f, 0x26, 0x65, 0x64, 0xa6, 0x0d, 0xd4, 0x85, - 0xb3, 0x92, 0xec, 0x8a, 0xd4, 0x70, 0xa6, 0x67, 0x61, 0xa6, 0x0d, 0xd2, 0x83, 0xd6, 0xaa, 0x63, - 0xeb, 0x46, 0x57, 0x77, 0x3d, 0x9a, 0xf1, 0x20, 0xb1, 0xa0, 0xef, 0xff, 0xc9, 0x83, 0x03, 0x69, - 0x5e, 0x64, 0xda, 0x38, 0xfb, 0x50, 0xa5, 0x0c, 0xc9, 0xfe, 0x2b, 0x04, 0xc9, 0x2d, 0x5d, 0x08, - 0x23, 0x45, 0x7d, 0xca, 0x10, 0x85, 0x68, 0xfe, 0x2a, 0x54, 0x44, 0xa6, 0x00, 0xc9, 0x2e, 0xe7, - 0xc4, 0x73, 0x14, 0xad, 0x1b, 0x93, 0x91, 0x7c, 0xca, 0xf7, 0xbf, 0xac, 0x40, 0xd9, 0x7f, 0xed, - 0xf1, 0x35, 0x87, 0xb8, 0xaf, 0x21, 0xe6, 0xfc, 0x1e, 0x2c, 0xc5, 0x5e, 0x5e, 0x4b, 0x19, 0x41, - 0xfe, 0x3a, 0x7b, 0x1a, 0x23, 0x3c, 0xe3, 0x7f, 0x79, 0x26, 0xdc, 0xcf, 0xb7, 0xd3, 0xe2, 0xd6, - 0xb8, 0xe7, 0x39, 0x85, 0xf0, 0xff, 0x6d, 0x7f, 0x6f, 0x1b, 0x20, 0xe4, 0xe9, 0x4d, 0xbe, 0xd7, - 0x48, 0x9c, 0x97, 0x69, 0xbb, 0x35, 0x94, 0x3a, 0x73, 0xef, 0x64, 0xb9, 0x42, 0x96, 0x6e, 0x8e, - 0xd3, 0x5d, 0xb8, 0xa7, 0x50, 0x0b, 0xdf, 0x38, 0x46, 0xd2, 0x3f, 0xd8, 0x4a, 0x5e, 0x49, 0x9e, - 0xb6, 0x8a, 0xad, 0x53, 0x5a, 0xf9, 0x29, 0xe4, 0x5c, 0x62, 0x9e, 0xe2, 0xa5, 0xac, 0x14, 0xf3, - 0x94, 0x52, 0x40, 0x93, 0x7a, 0x45, 0xe9, 0xf5, 0x31, 0x96, 0xbe, 0x88, 0xd7, 0x67, 0xa4, 0xe9, - 0x8b, 0x94, 0x8a, 0x97, 0x34, 0x7d, 0x91, 0x56, 0xf0, 0x51, 0xcf, 0xac, 0x7e, 0xf8, 0xf9, 0x07, - 0x7d, 0xd3, 0x3b, 0x18, 0xef, 0x93, 0xd5, 0xdf, 0x63, 0x5d, 0xdf, 0x33, 0x6d, 0xfe, 0xeb, 0x9e, - 0xcf, 0xee, 0xf7, 0x28, 0xb5, 0x7b, 0x84, 0xda, 0x68, 0x7f, 0xbf, 0x44, 0x5b, 0x1f, 0xfe, 0x4f, - 0x00, 0x00, 0x00, 0xff, 0xff, 0xf1, 0xc9, 0x87, 0x10, 0xd0, 0x51, 0x00, 0x00, + // 4617 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7c, 0xcd, 0x6f, 0x1b, 0x49, + 0x76, 0xb8, 0x9b, 0x5f, 0x22, 0x1f, 0x29, 0x8a, 0x2a, 0x7b, 0x24, 0x9a, 0xfe, 0x9c, 0xb6, 0x3d, + 0xe3, 0xf1, 0x78, 0xec, 0x19, 0xcf, 0x6f, 0xb0, 0xfe, 0xad, 0x77, 0x66, 0x63, 0x49, 0x96, 0x87, + 0x89, 0xa4, 0xd5, 0xb6, 0xe4, 0x71, 0x30, 0x1b, 0x80, 0x68, 0xb3, 0x8b, 0x54, 0xaf, 0xc8, 0x6e, + 0xba, 0xbb, 0x29, 0x59, 0x9b, 0xc3, 0x0e, 0x12, 0x24, 0xc0, 0x06, 0x41, 0x36, 0x08, 0x10, 0x6c, + 0x72, 0x08, 0x10, 0xe4, 0xb4, 0xd9, 0x60, 0x83, 0x00, 0x9b, 0x5c, 0x72, 0xc9, 0x75, 0x90, 0x1c, + 0x36, 0x41, 0x80, 0x1c, 0x13, 0x20, 0x87, 0x24, 0xf7, 0xfc, 0x03, 0x41, 0x7d, 0x74, 0xf5, 0x57, + 0x35, 0xd9, 0x22, 0xed, 0xf1, 0x22, 0xb9, 0xb1, 0x5e, 0xbf, 0x7a, 0xf5, 0xaa, 0xea, 0x7d, 0x57, + 0x15, 0xa1, 0x61, 0xe8, 0x9e, 0xde, 0xe9, 0xda, 0xb6, 0x63, 0xdc, 0x19, 0x39, 0xb6, 0x67, 0xa3, + 0xe5, 0xa1, 0x39, 0x38, 0x1a, 0xbb, 0xac, 0x75, 0x87, 0x7c, 0x6e, 0xd5, 0xba, 0xf6, 0x70, 0x68, + 0x5b, 0x0c, 0xd4, 0xaa, 0x9b, 0x96, 0x87, 0x1d, 0x4b, 0x1f, 0xf0, 0x76, 0x2d, 0xdc, 0xa1, 0x55, + 0x73, 0xbb, 0x07, 0x78, 0xa8, 0xb3, 0x96, 0xba, 0x00, 0xc5, 0x47, 0xc3, 0x91, 0x77, 0xa2, 0xfe, + 0xb5, 0x02, 0xb5, 0xcd, 0xc1, 0xd8, 0x3d, 0xd0, 0xf0, 0xf3, 0x31, 0x76, 0x3d, 0xf4, 0x3e, 0x14, + 0x9e, 0xe9, 0x2e, 0x6e, 0x2a, 0x57, 0x95, 0x9b, 0xd5, 0x7b, 0x17, 0xef, 0x44, 0x46, 0xe5, 0xe3, + 0x6d, 0xbb, 0xfd, 0x35, 0xdd, 0xc5, 0x1a, 0xc5, 0x44, 0x08, 0x0a, 0xc6, 0xb3, 0xf6, 0x46, 0x33, + 0x77, 0x55, 0xb9, 0x99, 0xd7, 0xe8, 0x6f, 0x74, 0x19, 0xc0, 0xc5, 0xfd, 0x21, 0xb6, 0xbc, 0xf6, + 0x86, 0xdb, 0xcc, 0x5f, 0xcd, 0xdf, 0xcc, 0x6b, 0x21, 0x08, 0x52, 0xa1, 0xd6, 0xb5, 0x07, 0x03, + 0xdc, 0xf5, 0x4c, 0xdb, 0x6a, 0x6f, 0x34, 0x0b, 0xb4, 0x6f, 0x04, 0x86, 0x5a, 0x50, 0x36, 0xdd, + 0xf6, 0x70, 0x64, 0x3b, 0x5e, 0xb3, 0x78, 0x55, 0xb9, 0x59, 0xd6, 0x44, 0x5b, 0xfd, 0x0f, 0x05, + 0x16, 0x39, 0xdb, 0xee, 0xc8, 0xb6, 0x5c, 0x8c, 0x3e, 0x84, 0x92, 0xeb, 0xe9, 0xde, 0xd8, 0xe5, + 0x9c, 0x5f, 0x90, 0x72, 0xbe, 0x47, 0x51, 0x34, 0x8e, 0x2a, 0x65, 0x3d, 0xce, 0x5a, 0x5e, 0xc2, + 0x5a, 0x74, 0x7a, 0x85, 0xc4, 0xf4, 0x6e, 0xc2, 0x52, 0x8f, 0x70, 0xb7, 0x17, 0x20, 0x15, 0x29, + 0x52, 0x1c, 0x4c, 0x28, 0x79, 0xe6, 0x10, 0x7f, 0xab, 0xb7, 0x87, 0xf5, 0x41, 0xb3, 0x44, 0xc7, + 0x0a, 0x41, 0xd4, 0x7f, 0x52, 0xa0, 0x21, 0xd0, 0xfd, 0x3d, 0x3a, 0x07, 0xc5, 0xae, 0x3d, 0xb6, + 0x3c, 0x3a, 0xd5, 0x45, 0x8d, 0x35, 0xd0, 0x9b, 0x50, 0xeb, 0x1e, 0xe8, 0x96, 0x85, 0x07, 0x1d, + 0x4b, 0x1f, 0x62, 0x3a, 0xa9, 0x8a, 0x56, 0xe5, 0xb0, 0x1d, 0x7d, 0x88, 0x33, 0xcd, 0xed, 0x2a, + 0x54, 0x47, 0xba, 0xe3, 0x99, 0x91, 0x9d, 0x09, 0x83, 0x26, 0x6d, 0x0c, 0x19, 0xc1, 0xa4, 0xbf, + 0xf6, 0x75, 0xf7, 0xb0, 0xbd, 0xc1, 0x67, 0x14, 0x81, 0xa9, 0x7f, 0xaa, 0xc0, 0xca, 0x43, 0xd7, + 0x35, 0xfb, 0x56, 0x62, 0x66, 0x2b, 0x50, 0xb2, 0x6c, 0x03, 0xb7, 0x37, 0xe8, 0xd4, 0xf2, 0x1a, + 0x6f, 0xa1, 0x0b, 0x50, 0x19, 0x61, 0xec, 0x74, 0x1c, 0x7b, 0xe0, 0x4f, 0xac, 0x4c, 0x00, 0x9a, + 0x3d, 0xc0, 0xe8, 0xdb, 0xb0, 0xec, 0xc6, 0x08, 0x31, 0x99, 0xab, 0xde, 0xbb, 0x76, 0x27, 0xa1, + 0x35, 0x77, 0xe2, 0x83, 0x6a, 0xc9, 0xde, 0xea, 0x17, 0x39, 0x38, 0x2b, 0xf0, 0x18, 0xaf, 0xe4, + 0x37, 0x59, 0x79, 0x17, 0xf7, 0x05, 0x7b, 0xac, 0x91, 0x65, 0xe5, 0xc5, 0x96, 0xe5, 0xc3, 0x5b, + 0x96, 0x45, 0x0d, 0x62, 0xfb, 0x51, 0x4c, 0xee, 0xc7, 0x15, 0xa8, 0xe2, 0x17, 0x23, 0xd3, 0xc1, + 0x1d, 0x22, 0x38, 0x74, 0xc9, 0x0b, 0x1a, 0x30, 0xd0, 0xbe, 0x39, 0x0c, 0xeb, 0xc6, 0x42, 0x66, + 0xdd, 0x50, 0xff, 0x4c, 0x81, 0xd5, 0xc4, 0x2e, 0x71, 0x65, 0xd3, 0xa0, 0x41, 0x67, 0x1e, 0xac, + 0x0c, 0x51, 0x3b, 0xb2, 0xe0, 0x6f, 0x4d, 0x5a, 0xf0, 0x00, 0x5d, 0x4b, 0xf4, 0x0f, 0x31, 0x99, + 0xcb, 0xce, 0xe4, 0x21, 0xac, 0x3e, 0xc6, 0x1e, 0x1f, 0x80, 0x7c, 0xc3, 0xee, 0xec, 0x86, 0x2c, + 0xaa, 0xd5, 0xb9, 0xb8, 0x56, 0xab, 0x7f, 0x95, 0x13, 0xba, 0x48, 0x87, 0x6a, 0x5b, 0x3d, 0x1b, + 0x5d, 0x84, 0x8a, 0x40, 0xe1, 0x52, 0x11, 0x00, 0xd0, 0xd7, 0xa0, 0x48, 0x38, 0x65, 0x22, 0x51, + 0xbf, 0xf7, 0xa6, 0x7c, 0x4e, 0x21, 0x9a, 0x1a, 0xc3, 0x47, 0x6d, 0xa8, 0xbb, 0x9e, 0xee, 0x78, + 0x9d, 0x91, 0xed, 0xd2, 0x7d, 0xa6, 0x82, 0x53, 0xbd, 0xa7, 0x46, 0x29, 0x08, 0x93, 0xbf, 0xed, + 0xf6, 0x77, 0x39, 0xa6, 0xb6, 0x48, 0x7b, 0xfa, 0x4d, 0xf4, 0x08, 0x6a, 0xd8, 0x32, 0x02, 0x42, + 0x85, 0xcc, 0x84, 0xaa, 0xd8, 0x32, 0x04, 0x99, 0x60, 0x7f, 0x8a, 0xd9, 0xf7, 0xe7, 0x77, 0x15, + 0x68, 0x26, 0x37, 0x68, 0x1e, 0x93, 0xfd, 0x80, 0x75, 0xc2, 0x6c, 0x83, 0x26, 0x6a, 0xb8, 0xd8, + 0x24, 0x8d, 0x77, 0x51, 0xff, 0x50, 0x81, 0x37, 0x02, 0x76, 0xe8, 0xa7, 0x57, 0x25, 0x2d, 0xe8, + 0x16, 0x34, 0x4c, 0xab, 0x3b, 0x18, 0x1b, 0xf8, 0x89, 0xf5, 0x29, 0xd6, 0x07, 0xde, 0xc1, 0x09, + 0xdd, 0xc3, 0xb2, 0x96, 0x80, 0xab, 0xff, 0x9a, 0x83, 0x95, 0x38, 0x5f, 0xf3, 0x2c, 0xd2, 0xff, + 0x83, 0xa2, 0x69, 0xf5, 0x6c, 0x7f, 0x8d, 0x2e, 0x4f, 0x50, 0x4a, 0x32, 0x16, 0x43, 0x46, 0x36, + 0x20, 0xdf, 0x8c, 0x75, 0x0f, 0x70, 0xf7, 0x70, 0x64, 0x9b, 0xd4, 0x60, 0x11, 0x12, 0xbf, 0x24, + 0x21, 0x21, 0xe7, 0xf8, 0xce, 0x3a, 0xa3, 0xb1, 0x2e, 0x48, 0x3c, 0xb2, 0x3c, 0xe7, 0x44, 0x5b, + 0xee, 0xc6, 0xe1, 0xad, 0x03, 0x58, 0x91, 0x23, 0xa3, 0x06, 0xe4, 0x0f, 0xf1, 0x09, 0x9d, 0x72, + 0x45, 0x23, 0x3f, 0xd1, 0x7d, 0x28, 0x1e, 0xe9, 0x83, 0x31, 0xe6, 0xd6, 0x21, 0x8b, 0xf8, 0xb2, + 0x0e, 0x5f, 0xcf, 0xdd, 0x57, 0xd4, 0x1f, 0x29, 0xb0, 0xba, 0x65, 0xba, 0x3e, 0xbf, 0xee, 0x2f, + 0xce, 0xd6, 0xff, 0x96, 0x02, 0xcd, 0x24, 0x67, 0x5f, 0xf9, 0xe6, 0xab, 0x43, 0xb8, 0xf0, 0x18, + 0x7b, 0x6d, 0xcb, 0xc5, 0x8e, 0xb7, 0x66, 0x5a, 0x03, 0xbb, 0xbf, 0xab, 0x7b, 0x07, 0x73, 0x58, + 0xd3, 0x88, 0x61, 0xcc, 0xc5, 0x0c, 0xa3, 0xfa, 0x63, 0x05, 0x2e, 0xca, 0xc7, 0xe3, 0x53, 0x6f, + 0x41, 0xb9, 0x67, 0xe2, 0x81, 0x41, 0x56, 0x58, 0xa1, 0x2b, 0x2c, 0xda, 0xc4, 0xaa, 0x8e, 0x08, + 0x32, 0x9f, 0xe1, 0x9b, 0x29, 0xb2, 0xb0, 0xe7, 0x39, 0xa6, 0xd5, 0x27, 0x8b, 0xab, 0x31, 0xfc, + 0xd0, 0x7a, 0xe6, 0xb3, 0xdb, 0xb0, 0xdf, 0x51, 0xe0, 0xf2, 0x63, 0xec, 0xad, 0x0b, 0xa7, 0x4c, + 0xbe, 0x9b, 0xae, 0x67, 0x76, 0xdd, 0x97, 0x1b, 0x34, 0x67, 0x88, 0xce, 0xd4, 0x1f, 0x2a, 0x70, + 0x25, 0x95, 0x19, 0xbe, 0x74, 0xdc, 0xe9, 0xf8, 0x2e, 0x59, 0xee, 0x74, 0x7e, 0x05, 0x9f, 0x7c, + 0x46, 0xd4, 0x63, 0x57, 0x37, 0x1d, 0xe6, 0x74, 0x66, 0x74, 0xc1, 0x3f, 0x55, 0xe0, 0xd2, 0x63, + 0xec, 0xed, 0xfa, 0x01, 0xc9, 0x6b, 0x5c, 0x1d, 0x82, 0x13, 0x0a, 0x8c, 0xfc, 0xc8, 0x3c, 0x02, + 0x53, 0x7f, 0x8f, 0x6d, 0xa7, 0x94, 0xdf, 0xd7, 0xb2, 0x80, 0x97, 0xa9, 0x26, 0x84, 0x54, 0x92, + 0xdb, 0x44, 0xbe, 0x7c, 0xea, 0x9f, 0x28, 0x70, 0xfe, 0x61, 0xf7, 0xf9, 0xd8, 0x74, 0x30, 0x47, + 0xda, 0xb2, 0xbb, 0x87, 0xb3, 0x2f, 0x6e, 0x10, 0x63, 0xe7, 0x22, 0x31, 0xf6, 0xb4, 0x9c, 0x6d, + 0x05, 0x4a, 0x1e, 0x0b, 0xea, 0x59, 0x98, 0xca, 0x5b, 0x94, 0x3f, 0x0d, 0x0f, 0xb0, 0xee, 0xfe, + 0x62, 0xf2, 0xf7, 0xc3, 0x02, 0xd4, 0x3e, 0xe3, 0xce, 0x87, 0x86, 0x6c, 0x71, 0x49, 0x52, 0xe4, + 0x51, 0x77, 0x28, 0x7c, 0x97, 0x45, 0xf4, 0x8f, 0x61, 0xd1, 0xc5, 0xf8, 0x70, 0x96, 0x00, 0xad, + 0x46, 0x3a, 0x8a, 0xc0, 0x6a, 0x0b, 0x96, 0xc7, 0x16, 0xcd, 0x0b, 0xb1, 0xe1, 0x7b, 0x01, 0x2a, + 0xb9, 0xd3, 0x6d, 0x77, 0xb2, 0x23, 0xfa, 0x94, 0xa7, 0x9e, 0x21, 0x5a, 0xc5, 0x4c, 0xb4, 0xe2, + 0xdd, 0x50, 0x1b, 0x1a, 0x86, 0x63, 0x8f, 0x46, 0xd8, 0xe8, 0xb8, 0x3e, 0xa9, 0x52, 0x36, 0x52, + 0xbc, 0x9f, 0x20, 0xf5, 0x3e, 0x9c, 0x8d, 0x73, 0xda, 0x36, 0x48, 0x36, 0x42, 0xf6, 0x50, 0xf6, + 0x09, 0xdd, 0x86, 0xe5, 0x24, 0x7e, 0x99, 0xe2, 0x27, 0x3f, 0xa0, 0xf7, 0x00, 0xc5, 0x58, 0x25, + 0xe8, 0x15, 0x86, 0x1e, 0x65, 0xa6, 0x6d, 0xb8, 0xea, 0x0f, 0x14, 0x58, 0x79, 0xaa, 0x7b, 0xdd, + 0x83, 0x8d, 0x21, 0xd7, 0xb5, 0x39, 0x6c, 0xd5, 0xc7, 0x50, 0x39, 0xe2, 0x72, 0xe1, 0x3b, 0xa4, + 0x2b, 0x92, 0xf5, 0x09, 0x4b, 0xa0, 0x16, 0xf4, 0x20, 0xc9, 0xf0, 0xb9, 0xcd, 0x50, 0x51, 0xe0, + 0x35, 0x58, 0xcd, 0x29, 0xd5, 0x0c, 0xf5, 0x05, 0x00, 0x67, 0x6e, 0xdb, 0xed, 0xcf, 0xc0, 0xd7, + 0x7d, 0x58, 0xe0, 0xd4, 0xb8, 0x59, 0x9c, 0x26, 0x3f, 0x3e, 0xba, 0xfa, 0x93, 0x12, 0x54, 0x43, + 0x1f, 0x50, 0x1d, 0x72, 0x42, 0x5f, 0x73, 0x92, 0xd9, 0xe5, 0xa6, 0xe7, 0xcf, 0xf9, 0x64, 0xfe, + 0x7c, 0x03, 0xea, 0x26, 0x8d, 0x43, 0x3a, 0x7c, 0x57, 0xa8, 0x01, 0xa9, 0x68, 0x8b, 0x0c, 0xca, + 0x45, 0x04, 0x5d, 0x86, 0xaa, 0x35, 0x1e, 0x76, 0xec, 0x5e, 0xc7, 0xb1, 0x8f, 0x5d, 0x9e, 0x88, + 0x57, 0xac, 0xf1, 0xf0, 0x5b, 0x3d, 0xcd, 0x3e, 0x76, 0x83, 0x5c, 0xaf, 0x74, 0xca, 0x5c, 0xef, + 0x32, 0x54, 0x87, 0xfa, 0x0b, 0x42, 0xb5, 0x63, 0x8d, 0x87, 0x34, 0x47, 0xcf, 0x6b, 0x95, 0xa1, + 0xfe, 0x42, 0xb3, 0x8f, 0x77, 0xc6, 0x43, 0x74, 0x13, 0x1a, 0x03, 0xdd, 0xf5, 0x3a, 0xe1, 0x24, + 0xbf, 0x4c, 0x93, 0xfc, 0x3a, 0x81, 0x3f, 0x0a, 0x12, 0xfd, 0x64, 0xd6, 0x58, 0x99, 0x23, 0x6b, + 0x34, 0x86, 0x83, 0x80, 0x10, 0x64, 0xcf, 0x1a, 0x8d, 0xe1, 0x40, 0x90, 0xb9, 0x0f, 0x0b, 0xcf, + 0x68, 0x74, 0xe7, 0x36, 0xab, 0xa9, 0xb6, 0x63, 0x93, 0x04, 0x76, 0x2c, 0x08, 0xd4, 0x7c, 0x74, + 0xf4, 0x0d, 0xa8, 0x50, 0xa7, 0x4a, 0xfb, 0xd6, 0x32, 0xf5, 0x0d, 0x3a, 0x90, 0xde, 0x06, 0x1e, + 0x78, 0x3a, 0xed, 0xbd, 0x98, 0xad, 0xb7, 0xe8, 0x40, 0xec, 0x55, 0xd7, 0xc1, 0xba, 0x87, 0x8d, + 0xb5, 0x93, 0x75, 0x7b, 0x38, 0xd2, 0xa9, 0x30, 0x35, 0xeb, 0x34, 0x86, 0x97, 0x7d, 0x42, 0x6f, + 0x41, 0xbd, 0x2b, 0x5a, 0x9b, 0x8e, 0x3d, 0x6c, 0x2e, 0x51, 0x3d, 0x8a, 0x41, 0xd1, 0x25, 0x00, + 0xdf, 0x52, 0xe9, 0x5e, 0xb3, 0x41, 0x77, 0xb1, 0xc2, 0x21, 0x0f, 0x69, 0x0d, 0xcf, 0x74, 0x3b, + 0xac, 0x5a, 0x66, 0x5a, 0xfd, 0xe6, 0x32, 0x1d, 0xb1, 0xea, 0x97, 0xd7, 0x4c, 0xab, 0x8f, 0x56, + 0x61, 0xc1, 0x74, 0x3b, 0x3d, 0xfd, 0x10, 0x37, 0x11, 0xfd, 0x5a, 0x32, 0xdd, 0x4d, 0xfd, 0x10, + 0xab, 0xdf, 0x87, 0x73, 0x81, 0x74, 0x85, 0x76, 0x32, 0x29, 0x14, 0xca, 0xac, 0x42, 0x31, 0x39, + 0xa6, 0xff, 0x79, 0x01, 0x56, 0xf6, 0xf4, 0x23, 0xfc, 0xea, 0xd3, 0x87, 0x4c, 0x66, 0x6d, 0x0b, + 0x96, 0x69, 0xc6, 0x70, 0x2f, 0xc4, 0xcf, 0x04, 0xbf, 0x1a, 0x16, 0x85, 0x64, 0x47, 0xf4, 0x4d, + 0x12, 0x10, 0xe0, 0xee, 0xe1, 0x2e, 0x49, 0x52, 0x7d, 0x9f, 0x7a, 0x49, 0x42, 0x67, 0x5d, 0x60, + 0x69, 0xe1, 0x1e, 0x68, 0x17, 0x96, 0xa2, 0xdb, 0xe0, 0x7b, 0xd3, 0xb7, 0x27, 0x56, 0x30, 0x82, + 0xd5, 0xd7, 0xea, 0x91, 0xcd, 0x70, 0x51, 0x13, 0x16, 0xb8, 0x2b, 0xa4, 0x36, 0xa3, 0xac, 0xf9, + 0x4d, 0xb4, 0x0b, 0x67, 0xd9, 0x0c, 0xf6, 0xb8, 0x42, 0xb0, 0xc9, 0x97, 0x33, 0x4d, 0x5e, 0xd6, + 0x35, 0xaa, 0x4f, 0x95, 0xd3, 0xea, 0x53, 0x13, 0x16, 0xb8, 0x8c, 0x53, 0x3b, 0x52, 0xd6, 0xfc, + 0x26, 0xd9, 0xe6, 0x40, 0xda, 0xab, 0xf4, 0x5b, 0x00, 0x20, 0xa9, 0x17, 0x04, 0xeb, 0x39, 0xa5, + 0xd6, 0xf6, 0x09, 0x94, 0x85, 0x84, 0x67, 0x2f, 0x12, 0x88, 0x3e, 0x71, 0xfb, 0x9e, 0x8f, 0xd9, + 0x77, 0xf5, 0x1f, 0x14, 0xa8, 0x6d, 0x90, 0x29, 0x6d, 0xd9, 0x7d, 0xea, 0x8d, 0x6e, 0x40, 0xdd, + 0xc1, 0x5d, 0xdb, 0x31, 0x3a, 0xd8, 0xf2, 0x1c, 0x13, 0xb3, 0x2c, 0xbd, 0xa0, 0x2d, 0x32, 0xe8, + 0x23, 0x06, 0x24, 0x68, 0xc4, 0x64, 0xbb, 0x9e, 0x3e, 0x1c, 0x75, 0x7a, 0xc4, 0x34, 0xe4, 0x18, + 0x9a, 0x80, 0x52, 0xcb, 0xf0, 0x26, 0xd4, 0x02, 0x34, 0xcf, 0xa6, 0xe3, 0x17, 0xb4, 0xaa, 0x80, + 0xed, 0xdb, 0xe8, 0x3a, 0xd4, 0xe9, 0x9a, 0x76, 0x06, 0x76, 0xbf, 0x43, 0x32, 0x5a, 0xee, 0xa8, + 0x6a, 0x06, 0x67, 0x8b, 0xec, 0x55, 0x14, 0xcb, 0x35, 0xbf, 0x87, 0xb9, 0xab, 0x12, 0x58, 0x7b, + 0xe6, 0xf7, 0xb0, 0xfa, 0xf7, 0x0a, 0x2c, 0x6e, 0xe8, 0x9e, 0xbe, 0x63, 0x1b, 0x78, 0x7f, 0x46, + 0xc7, 0x9e, 0xa1, 0xee, 0x7d, 0x11, 0x2a, 0x62, 0x06, 0x7c, 0x4a, 0x01, 0x00, 0x6d, 0x42, 0xdd, + 0x0f, 0x2d, 0x3b, 0x2c, 0xe3, 0x2a, 0xa4, 0x06, 0x50, 0x21, 0xcf, 0xe9, 0x6a, 0x8b, 0x7e, 0x37, + 0xda, 0x54, 0x37, 0xa1, 0x16, 0xfe, 0x4c, 0x46, 0xdd, 0x8b, 0x0b, 0x8a, 0x00, 0x10, 0x69, 0xdc, + 0x19, 0x0f, 0xc9, 0x9e, 0x72, 0xc3, 0xe2, 0x37, 0xd5, 0xdf, 0x54, 0x60, 0x91, 0xbb, 0xfb, 0x3d, + 0x71, 0x42, 0x44, 0xa7, 0xc6, 0x2a, 0x51, 0xf4, 0x37, 0xfa, 0x7a, 0xb4, 0xa8, 0x7b, 0x5d, 0x6a, + 0x04, 0x28, 0x11, 0x1a, 0x64, 0x46, 0x7c, 0x7d, 0x96, 0x1c, 0xff, 0x0b, 0x22, 0x68, 0x7c, 0x6b, + 0xa8, 0xa0, 0x35, 0x61, 0x41, 0x37, 0x0c, 0x07, 0xbb, 0x2e, 0xe7, 0xc3, 0x6f, 0x92, 0x2f, 0x47, + 0xd8, 0x71, 0x7d, 0x91, 0xcf, 0x6b, 0x7e, 0x13, 0x7d, 0x03, 0xca, 0x22, 0x2a, 0x65, 0x25, 0xbc, + 0xab, 0xe9, 0x7c, 0xf2, 0x8c, 0x54, 0xf4, 0x50, 0xff, 0x26, 0x07, 0x75, 0xbe, 0x60, 0x6b, 0xdc, + 0x1f, 0x4f, 0x56, 0xbe, 0x35, 0xa8, 0xf5, 0x02, 0xdd, 0x9f, 0x54, 0x7b, 0x0a, 0x9b, 0x88, 0x48, + 0x9f, 0x69, 0x0a, 0x18, 0x8d, 0x08, 0x0a, 0x73, 0x45, 0x04, 0xc5, 0xd3, 0x5a, 0xb0, 0x64, 0x8c, + 0x58, 0x92, 0xc4, 0x88, 0xea, 0xaf, 0x41, 0x35, 0x44, 0x80, 0x5a, 0x68, 0x56, 0xb4, 0xe2, 0x2b, + 0xe6, 0x37, 0xd1, 0x87, 0x41, 0x5c, 0xc4, 0x96, 0xea, 0xbc, 0x84, 0x97, 0x58, 0x48, 0xa4, 0xfe, + 0x9d, 0x02, 0x25, 0x4e, 0xf9, 0x0a, 0x54, 0xb9, 0xd1, 0xa1, 0x31, 0x23, 0xa3, 0x0e, 0x1c, 0x44, + 0x82, 0xc6, 0x97, 0x67, 0x75, 0xce, 0x43, 0x39, 0x66, 0x6f, 0x16, 0xb8, 0x5b, 0xf0, 0x3f, 0x85, + 0x8c, 0x0c, 0xf9, 0x44, 0xec, 0x0b, 0x3a, 0x07, 0xc5, 0x81, 0xdd, 0x17, 0x27, 0x80, 0xac, 0xa1, + 0x7e, 0xa9, 0xd0, 0x03, 0x1b, 0x0d, 0x77, 0xed, 0x23, 0xec, 0x9c, 0xcc, 0x5f, 0xec, 0x7c, 0x10, + 0x12, 0xf3, 0x8c, 0xc9, 0x97, 0xe8, 0x80, 0x1e, 0x04, 0x9b, 0x90, 0x97, 0x55, 0x7a, 0xc2, 0x76, + 0x87, 0x0b, 0x69, 0xb0, 0x19, 0xbf, 0xaf, 0xd0, 0x9a, 0x7d, 0x74, 0x2a, 0xb3, 0x46, 0x3b, 0x2f, + 0x25, 0x91, 0x51, 0x7f, 0xae, 0x40, 0x2b, 0x28, 0x25, 0xb9, 0x6b, 0x27, 0xf3, 0x9e, 0x88, 0xbd, + 0x9c, 0xfc, 0xea, 0xff, 0x8b, 0x23, 0x1b, 0xa2, 0xb4, 0x99, 0x32, 0x23, 0xff, 0xc0, 0xc6, 0xa2, + 0x55, 0xe9, 0xe4, 0x84, 0xe6, 0x11, 0x99, 0x16, 0x94, 0x45, 0x3d, 0x83, 0xd5, 0xee, 0x45, 0x5b, + 0xfd, 0x37, 0x05, 0xce, 0x3f, 0xc6, 0xde, 0x66, 0xb4, 0x14, 0xf2, 0xba, 0x17, 0x30, 0x7c, 0x9e, + 0x70, 0xc0, 0xcf, 0x13, 0x0a, 0xb1, 0xf3, 0x04, 0x0e, 0xf7, 0x2f, 0x14, 0xac, 0xe1, 0x9e, 0xed, + 0x30, 0xa5, 0x2c, 0x68, 0x21, 0x88, 0x3a, 0xa4, 0x22, 0x92, 0x98, 0xe0, 0xab, 0x5a, 0xd0, 0xdf, + 0x56, 0xa0, 0xc9, 0x47, 0xa1, 0x63, 0x92, 0x94, 0x69, 0x80, 0x3d, 0x6c, 0x7c, 0xd5, 0xa5, 0x84, + 0x3f, 0xca, 0x41, 0x23, 0xec, 0x95, 0xa9, 0x63, 0xfd, 0x08, 0x8a, 0xb4, 0x12, 0xc3, 0x39, 0x98, + 0x6a, 0x3a, 0x18, 0x36, 0x31, 0xeb, 0x34, 0x14, 0xdf, 0x17, 0x01, 0x04, 0x6f, 0x06, 0xa1, 0x41, + 0xfe, 0xf4, 0xa1, 0x01, 0x0f, 0x95, 0xec, 0x31, 0xa1, 0xcb, 0x4a, 0x98, 0x01, 0x00, 0x7d, 0x0c, + 0x25, 0x76, 0x83, 0x87, 0x1f, 0xbf, 0xde, 0x88, 0x92, 0xe6, 0xb7, 0x7b, 0x42, 0xe7, 0x02, 0x14, + 0xa0, 0xf1, 0x4e, 0x64, 0x8f, 0x46, 0x8e, 0xdd, 0xa7, 0x31, 0x04, 0xb1, 0xc8, 0x45, 0x4d, 0xb4, + 0xd5, 0x5f, 0x86, 0x95, 0x20, 0x93, 0x65, 0x2c, 0xcd, 0x2a, 0xf0, 0xea, 0xbf, 0x28, 0x70, 0x76, + 0xef, 0xc4, 0xea, 0xc6, 0x55, 0x67, 0x05, 0x4a, 0xa3, 0x81, 0x1e, 0x54, 0x5b, 0x79, 0x8b, 0x86, + 0x90, 0x6c, 0x6c, 0x6c, 0x10, 0xff, 0xc3, 0xd6, 0xb3, 0x2a, 0x60, 0xfb, 0xf6, 0xd4, 0xb0, 0xe0, + 0x86, 0x48, 0xbd, 0xb1, 0xc1, 0x3c, 0x1d, 0x2b, 0x61, 0x2d, 0x0a, 0x28, 0xf5, 0x74, 0x1f, 0x03, + 0xd0, 0x60, 0xa0, 0x73, 0x9a, 0x00, 0x80, 0xf6, 0xd8, 0x22, 0xe6, 0xfe, 0x67, 0x39, 0x68, 0x86, + 0x56, 0xe9, 0xab, 0x8e, 0x8d, 0x52, 0x32, 0xba, 0xfc, 0x4b, 0xca, 0xe8, 0x0a, 0xf3, 0xc7, 0x43, + 0x45, 0x59, 0x3c, 0xf4, 0xef, 0x39, 0xa8, 0x07, 0xab, 0xb6, 0x3b, 0xd0, 0xad, 0x54, 0x49, 0xd8, + 0x13, 0xb9, 0x40, 0x74, 0x9d, 0xde, 0x95, 0xe9, 0x50, 0xca, 0x46, 0x68, 0x31, 0x12, 0xe8, 0x12, + 0xdd, 0x74, 0xc7, 0x63, 0x45, 0x33, 0x9e, 0x7f, 0x30, 0x65, 0x35, 0x87, 0x18, 0xdd, 0x06, 0xc4, + 0x35, 0xac, 0x63, 0x5a, 0x1d, 0x17, 0x77, 0x6d, 0xcb, 0x60, 0xba, 0x57, 0xd4, 0x1a, 0xfc, 0x4b, + 0xdb, 0xda, 0x63, 0x70, 0xf4, 0x11, 0x14, 0xbc, 0x93, 0x11, 0x33, 0xaa, 0x75, 0x69, 0xac, 0x10, + 0xf0, 0xb5, 0x7f, 0x32, 0xc2, 0x1a, 0x45, 0xf7, 0x2d, 0xb2, 0xe7, 0xe8, 0x47, 0x3c, 0x6c, 0xe4, + 0x16, 0x99, 0x41, 0x88, 0x35, 0xf1, 0xd7, 0x70, 0x81, 0x85, 0x57, 0xbc, 0xc9, 0x24, 0xdb, 0x57, + 0xe8, 0x8e, 0xe7, 0x0d, 0x68, 0xd9, 0x8f, 0x4a, 0xb6, 0x0f, 0xdd, 0xf7, 0x06, 0xea, 0x3f, 0x13, + 0xd3, 0x26, 0x46, 0xd6, 0xb0, 0x3b, 0x1e, 0xa4, 0x2b, 0xdc, 0xe4, 0xba, 0xca, 0x34, 0x5d, 0xfb, + 0x26, 0x54, 0xf9, 0xb6, 0x9f, 0x42, 0x6c, 0x80, 0x75, 0xd9, 0x9a, 0x20, 0xc7, 0xc5, 0x97, 0x24, + 0xc7, 0xa5, 0x19, 0x2a, 0x13, 0xf2, 0xc5, 0x57, 0x7f, 0xac, 0xc0, 0x1b, 0x09, 0xb3, 0x38, 0x71, + 0x69, 0x27, 0xe7, 0x85, 0xdc, 0x5c, 0xc6, 0x49, 0x72, 0xe3, 0xff, 0x00, 0x4a, 0x0e, 0xa5, 0xce, + 0x8f, 0x91, 0xae, 0x4d, 0x94, 0x2e, 0xc6, 0x88, 0xc6, 0xbb, 0xa8, 0x7f, 0xa0, 0xc0, 0x6a, 0x92, + 0xd5, 0x39, 0x3c, 0xfa, 0x1a, 0x2c, 0x30, 0xd2, 0xbe, 0x12, 0xde, 0x9c, 0xac, 0x84, 0xc1, 0xe2, + 0x68, 0x7e, 0x47, 0x75, 0x0f, 0x56, 0x7c, 0xc7, 0x1f, 0x2c, 0xfd, 0x36, 0xf6, 0xf4, 0x09, 0x59, + 0xd1, 0x15, 0xa8, 0xb2, 0xf0, 0x9a, 0x65, 0x1b, 0xac, 0x9e, 0x00, 0xcf, 0x44, 0x19, 0x4e, 0xfd, + 0x2f, 0x05, 0xce, 0x51, 0xcf, 0x19, 0x3f, 0xb7, 0xc9, 0x72, 0xa6, 0xa7, 0x8a, 0x72, 0xc5, 0x8e, + 0x3e, 0xe4, 0x17, 0x88, 0x2a, 0x5a, 0x04, 0x86, 0xda, 0xc9, 0x2a, 0x9d, 0x34, 0x7b, 0x0e, 0x0e, + 0x81, 0x49, 0xa6, 0x4e, 0xcf, 0x80, 0xe3, 0xe5, 0xb9, 0xc0, 0x63, 0x17, 0x66, 0xf0, 0xd8, 0xea, + 0x16, 0xbc, 0x11, 0x9b, 0xe9, 0x1c, 0x3b, 0xaa, 0xfe, 0xb9, 0x42, 0xb6, 0x23, 0x72, 0x11, 0x6b, + 0xf6, 0xa8, 0xf6, 0x92, 0x38, 0x30, 0xea, 0x98, 0x46, 0xdc, 0x88, 0x18, 0xe8, 0x13, 0xa8, 0x58, + 0xf8, 0xb8, 0x13, 0x0e, 0x84, 0x32, 0x84, 0xfc, 0x65, 0x0b, 0x1f, 0xd3, 0x5f, 0xea, 0x0e, 0xac, + 0x26, 0x58, 0x9d, 0x67, 0xee, 0x7f, 0xab, 0xc0, 0xf9, 0x0d, 0xc7, 0x1e, 0x7d, 0x66, 0x3a, 0xde, + 0x58, 0x1f, 0x44, 0x8f, 0xd7, 0x5f, 0x4d, 0xd9, 0xeb, 0xd3, 0x50, 0x48, 0xcc, 0xe4, 0xe7, 0xb6, + 0x44, 0x83, 0x92, 0x4c, 0xf1, 0x49, 0x87, 0x02, 0xe8, 0xff, 0xcc, 0xcb, 0x98, 0xe7, 0x78, 0x53, + 0x02, 0x8f, 0x2c, 0xd9, 0x87, 0xb4, 0x4a, 0x9e, 0x9f, 0xb5, 0x4a, 0x9e, 0x62, 0xde, 0x0b, 0x2f, + 0xc9, 0xbc, 0x9f, 0xba, 0x6c, 0xf3, 0x29, 0x44, 0x4f, 0x30, 0xa8, 0xfb, 0x9d, 0xe9, 0xe8, 0x63, + 0x0d, 0x20, 0xa8, 0xe6, 0xf3, 0x7b, 0xb4, 0x59, 0xc8, 0x84, 0x7a, 0x91, 0xdd, 0x12, 0xae, 0x94, + 0xbb, 0xf2, 0x50, 0x7d, 0xf9, 0xdb, 0xd0, 0x92, 0x49, 0xe9, 0x3c, 0x92, 0xff, 0xb3, 0x1c, 0x40, + 0x5b, 0x5c, 0xbd, 0x9e, 0xcd, 0x17, 0x5c, 0x83, 0x50, 0xb8, 0x11, 0xe8, 0x7b, 0x58, 0x8a, 0x0c, + 0xa2, 0x12, 0x22, 0x61, 0x25, 0x38, 0x89, 0x24, 0xd6, 0xa0, 0x74, 0x42, 0x5a, 0xc3, 0x84, 0x22, + 0x6e, 0x7e, 0x2f, 0x40, 0xc5, 0xb1, 0x8f, 0x3b, 0x44, 0xcd, 0x0c, 0xff, 0x6e, 0xb9, 0x63, 0x1f, + 0x13, 0xe5, 0x33, 0xd0, 0x2a, 0x2c, 0x78, 0xba, 0x7b, 0x48, 0xe8, 0x97, 0x42, 0x37, 0x3c, 0x0c, + 0x74, 0x0e, 0x8a, 0x3d, 0x73, 0x80, 0xd9, 0x85, 0x82, 0x8a, 0xc6, 0x1a, 0xe8, 0x6b, 0xfe, 0x3d, + 0xb8, 0x72, 0xe6, 0x5b, 0x3c, 0xec, 0x2a, 0xdc, 0x97, 0x0a, 0x2c, 0x05, 0xab, 0x46, 0x0d, 0x10, + 0xb1, 0x69, 0xd4, 0x9e, 0xad, 0xdb, 0x06, 0x33, 0x15, 0xf5, 0x14, 0x8f, 0xc0, 0x3a, 0x32, 0xab, + 0x15, 0x74, 0x99, 0x94, 0x23, 0x93, 0x79, 0x91, 0x49, 0x9b, 0x86, 0x7f, 0xab, 0xa5, 0xe4, 0xd8, + 0xc7, 0x6d, 0x43, 0xac, 0x06, 0xbb, 0x38, 0xce, 0x32, 0x42, 0xb2, 0x1a, 0xeb, 0xf4, 0xee, 0xf8, + 0x35, 0x58, 0xc4, 0x8e, 0x63, 0x3b, 0x9d, 0x21, 0x76, 0x5d, 0xbd, 0x8f, 0x79, 0x00, 0x5e, 0xa3, + 0xc0, 0x6d, 0x06, 0x53, 0x7f, 0x54, 0x80, 0x7a, 0x30, 0x15, 0xff, 0x0c, 0xdd, 0x34, 0xfc, 0x33, + 0x74, 0x93, 0x6c, 0x1d, 0x38, 0xcc, 0x14, 0x8a, 0xcd, 0x5d, 0xcb, 0x35, 0x15, 0xad, 0xc2, 0xa1, + 0x6d, 0x83, 0xb8, 0x65, 0xa2, 0x64, 0x96, 0x6d, 0xe0, 0x60, 0x73, 0xc1, 0x07, 0xf1, 0xbd, 0x8d, + 0xc8, 0x48, 0x21, 0x83, 0x8c, 0x14, 0x33, 0xc8, 0x48, 0x49, 0x22, 0x23, 0x2b, 0x50, 0x7a, 0x36, + 0xee, 0x1e, 0x62, 0x8f, 0x47, 0x6c, 0xbc, 0x15, 0x95, 0x9d, 0x72, 0x4c, 0x76, 0x84, 0x88, 0x54, + 0xc2, 0x22, 0x72, 0x01, 0x2a, 0xec, 0x30, 0xb7, 0xe3, 0xb9, 0xf4, 0x64, 0x2a, 0xaf, 0x95, 0x19, + 0x60, 0xdf, 0x45, 0xf7, 0xfd, 0x70, 0xae, 0x2a, 0x53, 0x76, 0x6a, 0x75, 0x62, 0x52, 0xe2, 0x07, + 0x73, 0x6f, 0xc3, 0x52, 0x68, 0x39, 0xa8, 0x8f, 0xa8, 0x51, 0x56, 0x43, 0xe1, 0x3c, 0x75, 0x13, + 0x37, 0xa0, 0x1e, 0x2c, 0x09, 0xc5, 0x5b, 0x64, 0x59, 0x94, 0x80, 0x52, 0x34, 0x21, 0xc9, 0xf5, + 0xd3, 0x49, 0x32, 0x3a, 0x0f, 0x65, 0x9e, 0xfe, 0xb8, 0xcd, 0xa5, 0x48, 0xa5, 0x42, 0xfd, 0x2e, + 0xa0, 0x80, 0xfb, 0xf9, 0xa2, 0xc5, 0x98, 0x78, 0xe4, 0xe2, 0xe2, 0xa1, 0xfe, 0x44, 0x81, 0xe5, + 0xf0, 0x60, 0xb3, 0x3a, 0xde, 0x4f, 0xa0, 0xca, 0xce, 0x06, 0x3b, 0x44, 0xf1, 0x79, 0x05, 0xe8, + 0xd2, 0xc4, 0x7d, 0xd1, 0x20, 0x78, 0x7a, 0x42, 0xc4, 0xeb, 0xd8, 0x76, 0x0e, 0x4d, 0xab, 0xdf, + 0x21, 0x9c, 0xf9, 0xea, 0x56, 0xe3, 0xc0, 0x1d, 0x02, 0x53, 0x7f, 0xa0, 0xc0, 0xe5, 0x27, 0x23, + 0x43, 0xf7, 0x70, 0x28, 0x02, 0x99, 0xf7, 0x42, 0xe3, 0x47, 0xfe, 0x8d, 0xc2, 0x5c, 0xb6, 0xf3, + 0x2d, 0x86, 0xad, 0xfe, 0xa5, 0xe0, 0x25, 0x71, 0x4f, 0x7a, 0x76, 0x5e, 0x5a, 0x50, 0x3e, 0xe2, + 0xe4, 0xfc, 0xa7, 0x34, 0x7e, 0x3b, 0x72, 0x86, 0x9a, 0x3f, 0xfd, 0x19, 0xaa, 0xba, 0x0d, 0xe7, + 0x35, 0xec, 0x62, 0xcb, 0x88, 0xcc, 0x66, 0xe6, 0x6a, 0xd2, 0x08, 0x5a, 0x32, 0x72, 0xf3, 0x08, + 0x2b, 0x8b, 0x5d, 0x3b, 0x0e, 0x21, 0xeb, 0x71, 0x53, 0x4c, 0x42, 0x26, 0x3a, 0x8e, 0xa7, 0xfe, + 0x45, 0x0e, 0x56, 0x1f, 0x1a, 0x06, 0xb7, 0xe2, 0x3c, 0x1a, 0x7b, 0x55, 0x81, 0x72, 0x3c, 0x90, + 0xcc, 0x27, 0x03, 0xc9, 0x97, 0x65, 0x59, 0xb9, 0x8f, 0xb1, 0xc6, 0x43, 0xdf, 0x77, 0x3a, 0xec, + 0x72, 0xd1, 0x03, 0x7e, 0xa8, 0x46, 0x12, 0x7a, 0xea, 0x3f, 0xa7, 0xc7, 0x57, 0x65, 0xbf, 0x2a, + 0xa6, 0x8e, 0xa0, 0x99, 0x5c, 0xac, 0x39, 0x4d, 0x89, 0xbf, 0x22, 0x23, 0x9b, 0x55, 0x57, 0x6b, + 0x24, 0x84, 0xa2, 0xa0, 0x5d, 0xdb, 0x55, 0xff, 0x3b, 0x07, 0xcd, 0x3d, 0xfd, 0x08, 0xff, 0xdf, + 0xd9, 0xa0, 0xcf, 0xe1, 0x9c, 0xab, 0x1f, 0xe1, 0x4e, 0x28, 0x31, 0xee, 0x38, 0xf8, 0x39, 0x0f, + 0x41, 0xdf, 0x91, 0x59, 0x12, 0xe9, 0x1d, 0x1c, 0x6d, 0xd9, 0x8d, 0xc0, 0x35, 0xfc, 0x1c, 0xbd, + 0x05, 0x4b, 0xe1, 0x4b, 0x5e, 0x84, 0xb5, 0x32, 0x5d, 0xf2, 0xc5, 0xd0, 0x1d, 0xae, 0xb6, 0xa1, + 0x3e, 0x87, 0x8b, 0x4f, 0x2c, 0x17, 0x7b, 0xed, 0xe0, 0x1e, 0xd2, 0x9c, 0x29, 0xe4, 0x15, 0xa8, + 0x06, 0x0b, 0x9f, 0x78, 0x43, 0x61, 0xb8, 0xaa, 0x0d, 0xad, 0x6d, 0xdd, 0x39, 0xf4, 0xeb, 0xc8, + 0x1b, 0xec, 0xbe, 0xc8, 0x2b, 0x1c, 0xb0, 0x27, 0xae, 0x4f, 0x69, 0xb8, 0x87, 0x1d, 0x6c, 0x75, + 0xf1, 0x96, 0xdd, 0x3d, 0x0c, 0x5d, 0x2b, 0x56, 0xc2, 0xd7, 0x8a, 0x67, 0xbd, 0xa6, 0xac, 0xfe, + 0x34, 0x07, 0x2b, 0x0f, 0x07, 0x1e, 0x76, 0x82, 0xcc, 0xff, 0x34, 0x45, 0x8c, 0xa0, 0xaa, 0x90, + 0x9b, 0xe5, 0x1c, 0x20, 0x7e, 0x43, 0x3e, 0x9f, 0xbc, 0x21, 0x2f, 0xab, 0x81, 0x14, 0x66, 0xac, + 0x81, 0x3c, 0x04, 0x18, 0x39, 0xf6, 0x08, 0x3b, 0x9e, 0x89, 0xfd, 0xf4, 0x2d, 0x43, 0xf8, 0x12, + 0xea, 0xa4, 0x7e, 0x0e, 0x8d, 0xc7, 0xdd, 0x75, 0xdb, 0xea, 0x99, 0xce, 0xd0, 0x5f, 0xa8, 0x84, + 0xd2, 0x29, 0x19, 0x94, 0x2e, 0x97, 0x50, 0x3a, 0xd5, 0x84, 0xe5, 0x10, 0xed, 0x39, 0x0d, 0x57, + 0xbf, 0xdb, 0xe9, 0x99, 0x96, 0x49, 0xef, 0x63, 0xe5, 0x68, 0xf8, 0x09, 0xfd, 0xee, 0x26, 0x87, + 0xdc, 0xfa, 0x44, 0xdc, 0x64, 0xdd, 0x3f, 0x19, 0x61, 0xb4, 0x00, 0xf9, 0x1d, 0x7c, 0xdc, 0x38, + 0x83, 0x00, 0x4a, 0x3b, 0xb6, 0x33, 0xd4, 0x07, 0x0d, 0x05, 0x55, 0x61, 0x81, 0x1f, 0xcc, 0x35, + 0x72, 0x68, 0x11, 0x2a, 0xeb, 0xfe, 0x01, 0x46, 0x23, 0x7f, 0xeb, 0x8f, 0x15, 0x58, 0x4e, 0x1c, + 0x1d, 0xa1, 0x3a, 0xc0, 0x13, 0xab, 0xcb, 0xcf, 0xd4, 0x1a, 0x67, 0x50, 0x0d, 0xca, 0xfe, 0x09, + 0x1b, 0xa3, 0xb7, 0x6f, 0x53, 0xec, 0x46, 0x0e, 0x35, 0xa0, 0xc6, 0x3a, 0x8e, 0xbb, 0x5d, 0xec, + 0xba, 0x8d, 0xbc, 0x80, 0x6c, 0xea, 0xe6, 0x60, 0xec, 0xe0, 0x46, 0x81, 0x8c, 0xb9, 0x6f, 0xf3, + 0xbb, 0xfc, 0x8d, 0x22, 0x42, 0x50, 0xf7, 0x2f, 0xf6, 0xf3, 0x4e, 0xa5, 0x10, 0xcc, 0xef, 0xb6, + 0x70, 0xeb, 0x69, 0xb8, 0xc8, 0x4f, 0xa7, 0xb7, 0x0a, 0x67, 0x9f, 0x58, 0x06, 0xee, 0x99, 0x16, + 0x36, 0x82, 0x4f, 0x8d, 0x33, 0xe8, 0x2c, 0x2c, 0x6d, 0x63, 0xa7, 0x8f, 0x43, 0xc0, 0x1c, 0x5a, + 0x86, 0xc5, 0x6d, 0xf3, 0x45, 0x08, 0x94, 0x57, 0x0b, 0x65, 0xa5, 0xa1, 0xdc, 0xfb, 0xc7, 0xcb, + 0x50, 0x21, 0xb2, 0xb5, 0x6e, 0xdb, 0x8e, 0x81, 0x06, 0x80, 0xe8, 0xd3, 0x97, 0xe1, 0xc8, 0xb6, + 0xc4, 0x6b, 0x42, 0x74, 0x27, 0xba, 0x3d, 0xbc, 0x91, 0x44, 0xe4, 0xb2, 0xd3, 0xba, 0x2e, 0xc5, + 0x8f, 0x21, 0xab, 0x67, 0xd0, 0x90, 0x8e, 0xb6, 0x6f, 0x0e, 0xf1, 0xbe, 0xd9, 0x3d, 0xf4, 0x03, + 0xa4, 0xf7, 0x53, 0xc2, 0xa1, 0x24, 0xaa, 0x3f, 0xde, 0x35, 0xe9, 0x78, 0xec, 0x6d, 0x92, 0x2f, + 0x73, 0xea, 0x19, 0xf4, 0x1c, 0xce, 0x3d, 0xc6, 0xa1, 0x58, 0xd3, 0x1f, 0xf0, 0x5e, 0xfa, 0x80, + 0x09, 0xe4, 0x53, 0x0e, 0xb9, 0x05, 0x45, 0x2a, 0x6e, 0x48, 0x16, 0x8e, 0x86, 0xff, 0x14, 0xa0, + 0x75, 0x35, 0x1d, 0x41, 0x50, 0xfb, 0x2e, 0x2c, 0xc5, 0x9e, 0x0b, 0x23, 0x99, 0x73, 0x92, 0x3f, + 0xfc, 0x6e, 0xdd, 0xca, 0x82, 0x2a, 0xc6, 0xea, 0x43, 0x3d, 0xfa, 0x64, 0x06, 0xdd, 0xcc, 0xf0, + 0x3e, 0x91, 0x8d, 0xf4, 0x4e, 0xe6, 0x97, 0x8c, 0x54, 0x08, 0x1a, 0xf1, 0xe7, 0xab, 0xe8, 0xd6, + 0x44, 0x02, 0x51, 0x61, 0x7b, 0x37, 0x13, 0xae, 0x18, 0xee, 0x84, 0x0a, 0x41, 0xe2, 0x51, 0x5c, + 0x5c, 0xc6, 0x7d, 0x32, 0x69, 0xaf, 0xf5, 0x5a, 0x77, 0x33, 0xe3, 0x87, 0x67, 0x1a, 0x7f, 0x86, + 0x28, 0x9d, 0x69, 0xca, 0x2b, 0x4a, 0xe9, 0x4c, 0xd3, 0xde, 0x35, 0xaa, 0x67, 0xd0, 0x6f, 0xb0, + 0x8b, 0x40, 0xb2, 0x77, 0x6c, 0xe8, 0x03, 0x39, 0xf7, 0x13, 0x1e, 0xe0, 0xb5, 0xee, 0x9d, 0xa6, + 0x8b, 0x60, 0xe2, 0xfb, 0xf4, 0x06, 0x8f, 0xe4, 0x25, 0x58, 0x5c, 0xcd, 0x7d, 0x7a, 0xe9, 0x8f, + 0xdc, 0x5a, 0x1f, 0x9c, 0xa2, 0x87, 0x60, 0xc0, 0x8e, 0x3f, 0x47, 0xf6, 0xb5, 0xfe, 0xee, 0x54, + 0x21, 0x9d, 0x4d, 0xe5, 0xbf, 0x03, 0x4b, 0xb1, 0xe8, 0x10, 0x65, 0x8f, 0x20, 0x5b, 0x93, 0x3c, + 0x21, 0xb3, 0x00, 0xb1, 0x0b, 0x51, 0x28, 0x45, 0xd9, 0x24, 0x97, 0xa6, 0x5a, 0xb7, 0xb2, 0xa0, + 0x8a, 0x89, 0xb8, 0xd4, 0x3a, 0xc7, 0xae, 0xb1, 0xa0, 0xdb, 0x72, 0x1a, 0xf2, 0xeb, 0x3c, 0xad, + 0xf7, 0x32, 0x62, 0x8b, 0x41, 0x8f, 0xe0, 0xac, 0xe4, 0x36, 0x12, 0x7a, 0x6f, 0xe2, 0x66, 0xc5, + 0xaf, 0x61, 0xb5, 0xee, 0x64, 0x45, 0x17, 0xe3, 0xfe, 0x3a, 0xa0, 0xbd, 0x03, 0xfb, 0x98, 0x06, + 0x2a, 0xfd, 0xb1, 0xa3, 0xb3, 0xd8, 0x2a, 0xcd, 0x15, 0x25, 0x51, 0x53, 0x64, 0x74, 0x62, 0x0f, + 0x31, 0x78, 0x07, 0xe0, 0x31, 0xf6, 0xb6, 0xb1, 0xe7, 0x10, 0xc5, 0x78, 0x2b, 0xcd, 0xdb, 0x72, + 0x04, 0x7f, 0xa8, 0xb7, 0xa7, 0xe2, 0x85, 0x3c, 0x5f, 0x63, 0x5b, 0xb7, 0xc6, 0xfa, 0x20, 0xf4, + 0x9c, 0xe2, 0xb6, 0xb4, 0x7b, 0x1c, 0x2d, 0x65, 0x23, 0x53, 0xb1, 0xc5, 0x90, 0xc7, 0x22, 0x92, + 0x08, 0x1d, 0x60, 0x4e, 0x8e, 0x24, 0x92, 0xb7, 0x63, 0xe2, 0x56, 0x76, 0x02, 0xbe, 0x18, 0xf8, + 0x0b, 0x85, 0x5e, 0x68, 0x8b, 0x21, 0x3c, 0x35, 0xbd, 0x83, 0xdd, 0x81, 0x6e, 0xb9, 0x59, 0x58, + 0xa0, 0x88, 0xa7, 0x60, 0x81, 0xe3, 0x0b, 0x16, 0x0c, 0x58, 0x8c, 0x9c, 0x2b, 0x22, 0xd9, 0xfb, + 0x03, 0xd9, 0x19, 0x6b, 0xeb, 0xe6, 0x74, 0x44, 0x31, 0xca, 0x01, 0x2c, 0xfa, 0xaa, 0xc4, 0x16, + 0xf7, 0x9d, 0x34, 0x4e, 0x03, 0x9c, 0x14, 0x4b, 0x20, 0x47, 0x0d, 0x5b, 0x82, 0xe4, 0xb1, 0x09, + 0xca, 0x76, 0xdc, 0x36, 0xc9, 0x12, 0xa4, 0x9f, 0xc5, 0x30, 0x53, 0x17, 0x3b, 0xa2, 0x94, 0xdb, + 0x51, 0xe9, 0x89, 0xab, 0xd4, 0xd4, 0xa5, 0x9c, 0x78, 0xaa, 0x67, 0xd0, 0x53, 0x28, 0xf1, 0x3f, + 0xd7, 0xb9, 0x3e, 0xb9, 0xd4, 0xc9, 0xa9, 0xdf, 0x98, 0x82, 0x25, 0x08, 0x1f, 0xc2, 0x6a, 0x4a, + 0xa1, 0x53, 0xea, 0x82, 0x27, 0x17, 0x45, 0xa7, 0x39, 0x07, 0x31, 0x58, 0xa2, 0x92, 0x39, 0x61, + 0xb0, 0xb4, 0xaa, 0xe7, 0xb4, 0xc1, 0x74, 0x40, 0xc9, 0x17, 0xd3, 0x52, 0x99, 0x48, 0x7d, 0x58, + 0x9d, 0x61, 0x88, 0xe4, 0xa3, 0x67, 0xe9, 0x10, 0xa9, 0x6f, 0xa3, 0xa7, 0x0d, 0xd1, 0x81, 0xe5, + 0x44, 0xa9, 0x0b, 0xbd, 0x9b, 0xe2, 0xae, 0x65, 0x05, 0xb1, 0x69, 0x03, 0xf4, 0xe1, 0x0d, 0x69, + 0x59, 0x47, 0x1a, 0x7e, 0x4c, 0x2a, 0x00, 0x4d, 0x1b, 0xa8, 0x0b, 0x67, 0x25, 0xc5, 0x1c, 0xa9, + 0xe3, 0x4c, 0x2f, 0xfa, 0x4c, 0x1b, 0xa4, 0x07, 0xad, 0x35, 0xc7, 0xd6, 0x8d, 0xae, 0xee, 0x7a, + 0xb4, 0xc0, 0x42, 0x52, 0x4f, 0x3f, 0xfe, 0x93, 0xe7, 0x22, 0xd2, 0x32, 0xcc, 0xb4, 0x71, 0x9e, + 0x41, 0x95, 0x0a, 0x24, 0xfb, 0x07, 0x0f, 0x24, 0xf7, 0x74, 0x21, 0x8c, 0x14, 0xf3, 0x29, 0x43, + 0x14, 0xaa, 0xf9, 0xab, 0x50, 0x11, 0x85, 0x09, 0x24, 0xbb, 0x0b, 0x14, 0x2f, 0x89, 0xb4, 0xae, + 0x4f, 0x46, 0xf2, 0x29, 0xdf, 0xfb, 0xb2, 0x02, 0x65, 0xff, 0x71, 0xc9, 0x57, 0x9c, 0x51, 0xbf, + 0x86, 0x14, 0xf7, 0x3b, 0xb0, 0x14, 0x7b, 0xe8, 0x2d, 0x15, 0x04, 0xf9, 0x63, 0xf0, 0x69, 0x82, + 0xf0, 0x94, 0xff, 0x07, 0x9d, 0x08, 0x3f, 0xdf, 0x4e, 0x4b, 0x93, 0xe3, 0x91, 0xe7, 0x14, 0xc2, + 0xff, 0xbb, 0xe3, 0xbd, 0x1d, 0x80, 0x50, 0xa4, 0x37, 0xf9, 0x1a, 0x25, 0x09, 0x5e, 0xa6, 0xad, + 0xd6, 0x50, 0x1a, 0xcc, 0xbd, 0x93, 0xe5, 0xc6, 0x5a, 0xba, 0x3b, 0x4e, 0x0f, 0xe1, 0x9e, 0x40, + 0x2d, 0x7c, 0xc1, 0x19, 0x49, 0xff, 0xf1, 0x2c, 0x79, 0x03, 0x7a, 0xda, 0x2c, 0xb6, 0x4f, 0xe9, + 0xe5, 0xa7, 0x90, 0x73, 0x89, 0x7b, 0x8a, 0x9f, 0x9c, 0xa5, 0xb8, 0xa7, 0x94, 0xf3, 0x3a, 0x69, + 0x54, 0x94, 0x7e, 0x1c, 0xc7, 0x6a, 0x08, 0xf1, 0xe3, 0x20, 0x69, 0x0d, 0x21, 0xe5, 0x80, 0x4d, + 0x5a, 0x43, 0x48, 0x3b, 0x5f, 0x52, 0xcf, 0xac, 0x7d, 0xf8, 0xf9, 0x07, 0x7d, 0xd3, 0x3b, 0x18, + 0x3f, 0x23, 0xb3, 0xbf, 0xcb, 0xba, 0xbe, 0x67, 0xda, 0xfc, 0xd7, 0x5d, 0x5f, 0xdc, 0xef, 0x52, + 0x6a, 0x77, 0x09, 0xb5, 0xd1, 0xb3, 0x67, 0x25, 0xda, 0xfa, 0xf0, 0x7f, 0x02, 0x00, 0x00, 0xff, + 0xff, 0x66, 0xa5, 0x64, 0x4d, 0x61, 0x53, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -5398,6 +5505,7 @@ type DataCoordClient interface { GetSegmentInfo(ctx context.Context, in *GetSegmentInfoRequest, opts ...grpc.CallOption) (*GetSegmentInfoResponse, error) GetSegmentStates(ctx context.Context, in *GetSegmentStatesRequest, opts ...grpc.CallOption) (*GetSegmentStatesResponse, error) GetInsertBinlogPaths(ctx context.Context, in *GetInsertBinlogPathsRequest, opts ...grpc.CallOption) (*GetInsertBinlogPathsResponse, error) + ListSegmentsInfo(ctx context.Context, in *ListSegmentsInfoRequest, opts ...grpc.CallOption) (*ListSegmentsInfoResponse, error) GetCollectionStatistics(ctx context.Context, in *GetCollectionStatisticsRequest, opts ...grpc.CallOption) (*GetCollectionStatisticsResponse, error) GetPartitionStatistics(ctx context.Context, in *GetPartitionStatisticsRequest, opts ...grpc.CallOption) (*GetPartitionStatisticsResponse, error) GetSegmentInfoChannel(ctx context.Context, in *GetSegmentInfoChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) @@ -5509,6 +5617,15 @@ func (c *dataCoordClient) GetInsertBinlogPaths(ctx context.Context, in *GetInser return out, nil } +func (c *dataCoordClient) ListSegmentsInfo(ctx context.Context, in *ListSegmentsInfoRequest, opts ...grpc.CallOption) (*ListSegmentsInfoResponse, error) { + out := new(ListSegmentsInfoResponse) + err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/ListSegmentsInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *dataCoordClient) GetCollectionStatistics(ctx context.Context, in *GetCollectionStatisticsRequest, opts ...grpc.CallOption) (*GetCollectionStatisticsResponse, error) { out := new(GetCollectionStatisticsResponse) err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/GetCollectionStatistics", in, out, opts...) @@ -5762,6 +5879,7 @@ type DataCoordServer interface { GetSegmentInfo(context.Context, *GetSegmentInfoRequest) (*GetSegmentInfoResponse, error) GetSegmentStates(context.Context, *GetSegmentStatesRequest) (*GetSegmentStatesResponse, error) GetInsertBinlogPaths(context.Context, *GetInsertBinlogPathsRequest) (*GetInsertBinlogPathsResponse, error) + ListSegmentsInfo(context.Context, *ListSegmentsInfoRequest) (*ListSegmentsInfoResponse, error) GetCollectionStatistics(context.Context, *GetCollectionStatisticsRequest) (*GetCollectionStatisticsResponse, error) GetPartitionStatistics(context.Context, *GetPartitionStatisticsRequest) (*GetPartitionStatisticsResponse, error) GetSegmentInfoChannel(context.Context, *GetSegmentInfoChannelRequest) (*milvuspb.StringResponse, error) @@ -5821,6 +5939,9 @@ func (*UnimplementedDataCoordServer) GetSegmentStates(ctx context.Context, req * func (*UnimplementedDataCoordServer) GetInsertBinlogPaths(ctx context.Context, req *GetInsertBinlogPathsRequest) (*GetInsertBinlogPathsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetInsertBinlogPaths not implemented") } +func (*UnimplementedDataCoordServer) ListSegmentsInfo(ctx context.Context, req *ListSegmentsInfoRequest) (*ListSegmentsInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListSegmentsInfo not implemented") +} func (*UnimplementedDataCoordServer) GetCollectionStatistics(ctx context.Context, req *GetCollectionStatisticsRequest) (*GetCollectionStatisticsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetCollectionStatistics not implemented") } @@ -6051,6 +6172,24 @@ func _DataCoord_GetInsertBinlogPaths_Handler(srv interface{}, ctx context.Contex return interceptor(ctx, in, info, handler) } +func _DataCoord_ListSegmentsInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListSegmentsInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DataCoordServer).ListSegmentsInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.data.DataCoord/ListSegmentsInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DataCoordServer).ListSegmentsInfo(ctx, req.(*ListSegmentsInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _DataCoord_GetCollectionStatistics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetCollectionStatisticsRequest) if err := dec(in); err != nil { @@ -6573,6 +6712,10 @@ var _DataCoord_serviceDesc = grpc.ServiceDesc{ MethodName: "GetInsertBinlogPaths", Handler: _DataCoord_GetInsertBinlogPaths_Handler, }, + { + MethodName: "ListSegmentsInfo", + Handler: _DataCoord_ListSegmentsInfo_Handler, + }, { MethodName: "GetCollectionStatistics", Handler: _DataCoord_GetCollectionStatistics_Handler, diff --git a/internal/types/types.go b/internal/types/types.go index b693aa1040..a06a63a159 100644 --- a/internal/types/types.go +++ b/internal/types/types.go @@ -227,6 +227,15 @@ type DataCoord interface { // error is returned only when some communication issue occurs GetSegmentInfo(ctx context.Context, req *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error) + // ListSegmentsInfo requests segment info without binlog path + // + // ctx is the context to control request deadline and cancellation + // req contains the list of segment ids to query + // + // response struct `ListSegmentsInfoResponse` contains the list of segment info + // error is returned only when some communication issue occurs + ListSegmentsInfo(ctx context.Context, req *datapb.ListSegmentsInfoRequest) (*datapb.ListSegmentsInfoResponse, error) + // GetRecoveryInfo request segment recovery info of collection/partition // // ctx is the context to control request deadline and cancellation diff --git a/internal/util/mock/grpc_datacoord_client.go b/internal/util/mock/grpc_datacoord_client.go index 91e0feefd6..c450bd7ebb 100644 --- a/internal/util/mock/grpc_datacoord_client.go +++ b/internal/util/mock/grpc_datacoord_client.go @@ -175,5 +175,8 @@ func (m *GrpcDataCoordClient) MarkSegmentsDropped(context.Context, *datapb.MarkS func (m *GrpcDataCoordClient) BroadcastAlteredCollection(ctx context.Context, in *datapb.AlterCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { return &commonpb.Status{}, m.Err - +} + +func (m *GrpcDataCoordClient) ListSegmentsInfo(ctx context.Context, req *datapb.ListSegmentsInfoRequest, opts ...grpc.CallOption) (*datapb.ListSegmentsInfoResponse, error) { + return &datapb.ListSegmentsInfoResponse{}, m.Err }