From d26b563a8bea07332072b83a6432b66fdfb8d788 Mon Sep 17 00:00:00 2001 From: "yihao.dai" Date: Mon, 4 Dec 2023 19:56:35 +0800 Subject: [PATCH] feat: Define import API and metadata (#28731) Define the new rpc and metadata for ImportV2. see also: https://github.com/milvus-io/milvus/issues/28521 --------- Signed-off-by: bigsheeper --- internal/datacoord/mock_test.go | 20 + internal/datanode/services.go | 20 + .../distributed/datanode/client/client.go | 30 + internal/distributed/datanode/service.go | 20 + internal/distributed/datanode/service_test.go | 20 + internal/mocks/mock_datanode.go | 345 ++- internal/mocks/mock_datanode_client.go | 440 +++- internal/proto/data_coord.proto | 128 ++ internal/proto/datapb/data_coord.pb.go | 1952 ++++++++++++++--- internal/util/mock/grpc_datanode_client.go | 20 + 10 files changed, 2589 insertions(+), 406 deletions(-) diff --git a/internal/datacoord/mock_test.go b/internal/datacoord/mock_test.go index 685e49ff6e..e7d5e309e2 100644 --- a/internal/datacoord/mock_test.go +++ b/internal/datacoord/mock_test.go @@ -295,6 +295,26 @@ func (c *mockDataNodeClient) CheckChannelOperationProgress(ctx context.Context, return &datapb.ChannelOperationProgressResponse{Status: merr.Success()}, nil } +func (c *mockDataNodeClient) PreImport(ctx context.Context, req *datapb.PreImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil +} + +func (c *mockDataNodeClient) ImportV2(ctx context.Context, req *datapb.ImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil +} + +func (c *mockDataNodeClient) QueryPreImport(ctx context.Context, req *datapb.QueryPreImportRequest, opts ...grpc.CallOption) (*datapb.QueryPreImportResponse, error) { + return &datapb.QueryPreImportResponse{Status: merr.Success()}, nil +} + +func (c *mockDataNodeClient) QueryImport(ctx context.Context, req *datapb.QueryImportRequest, opts ...grpc.CallOption) (*datapb.QueryImportResponse, error) { + return &datapb.QueryImportResponse{Status: merr.Success()}, nil +} + +func (c *mockDataNodeClient) DropImport(ctx context.Context, req *datapb.DropImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil +} + func (c *mockDataNodeClient) Stop() error { c.state = commonpb.StateCode_Abnormal return nil diff --git a/internal/datanode/services.go b/internal/datanode/services.go index 2399209120..6fb89175b8 100644 --- a/internal/datanode/services.go +++ b/internal/datanode/services.go @@ -943,3 +943,23 @@ func logDupFlush(cID, segID int64) { zap.Int64("collectionID", cID), zap.Int64("segmentID", segID)) } + +func (node *DataNode) PreImport(ctx context.Context, req *datapb.PreImportRequest) (*commonpb.Status, error) { + return nil, merr.ErrServiceUnimplemented +} + +func (node *DataNode) ImportV2(ctx context.Context, req *datapb.ImportRequest) (*commonpb.Status, error) { + return nil, merr.ErrServiceUnimplemented +} + +func (node *DataNode) QueryPreImport(ctx context.Context, req *datapb.QueryPreImportRequest) (*datapb.QueryPreImportResponse, error) { + return nil, merr.ErrServiceUnimplemented +} + +func (node *DataNode) QueryImport(ctx context.Context, req *datapb.QueryImportRequest) (*datapb.QueryImportResponse, error) { + return nil, merr.ErrServiceUnimplemented +} + +func (node *DataNode) DropImport(ctx context.Context, req *datapb.DropImportRequest) (*commonpb.Status, error) { + return nil, merr.ErrServiceUnimplemented +} diff --git a/internal/distributed/datanode/client/client.go b/internal/distributed/datanode/client/client.go index e217fb54dc..f94dbe3e86 100644 --- a/internal/distributed/datanode/client/client.go +++ b/internal/distributed/datanode/client/client.go @@ -244,3 +244,33 @@ func (c *Client) CheckChannelOperationProgress(ctx context.Context, req *datapb. return client.CheckChannelOperationProgress(ctx, req) }) } + +func (c *Client) PreImport(ctx context.Context, req *datapb.PreImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return wrapGrpcCall(ctx, c, func(client datapb.DataNodeClient) (*commonpb.Status, error) { + return client.PreImport(ctx, req) + }) +} + +func (c *Client) ImportV2(ctx context.Context, req *datapb.ImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return wrapGrpcCall(ctx, c, func(client datapb.DataNodeClient) (*commonpb.Status, error) { + return client.ImportV2(ctx, req) + }) +} + +func (c *Client) QueryPreImport(ctx context.Context, req *datapb.QueryPreImportRequest, opts ...grpc.CallOption) (*datapb.QueryPreImportResponse, error) { + return wrapGrpcCall(ctx, c, func(client datapb.DataNodeClient) (*datapb.QueryPreImportResponse, error) { + return client.QueryPreImport(ctx, req) + }) +} + +func (c *Client) QueryImport(ctx context.Context, req *datapb.QueryImportRequest, opts ...grpc.CallOption) (*datapb.QueryImportResponse, error) { + return wrapGrpcCall(ctx, c, func(client datapb.DataNodeClient) (*datapb.QueryImportResponse, error) { + return client.QueryImport(ctx, req) + }) +} + +func (c *Client) DropImport(ctx context.Context, req *datapb.DropImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return wrapGrpcCall(ctx, c, func(client datapb.DataNodeClient) (*commonpb.Status, error) { + return client.DropImport(ctx, req) + }) +} diff --git a/internal/distributed/datanode/service.go b/internal/distributed/datanode/service.go index ded08780cc..81504253f4 100644 --- a/internal/distributed/datanode/service.go +++ b/internal/distributed/datanode/service.go @@ -379,3 +379,23 @@ func (s *Server) NotifyChannelOperation(ctx context.Context, req *datapb.Channel func (s *Server) CheckChannelOperationProgress(ctx context.Context, req *datapb.ChannelWatchInfo) (*datapb.ChannelOperationProgressResponse, error) { return s.datanode.CheckChannelOperationProgress(ctx, req) } + +func (s *Server) PreImport(ctx context.Context, req *datapb.PreImportRequest) (*commonpb.Status, error) { + return s.datanode.PreImport(ctx, req) +} + +func (s *Server) ImportV2(ctx context.Context, req *datapb.ImportRequest) (*commonpb.Status, error) { + return s.datanode.ImportV2(ctx, req) +} + +func (s *Server) QueryPreImport(ctx context.Context, req *datapb.QueryPreImportRequest) (*datapb.QueryPreImportResponse, error) { + return s.datanode.QueryPreImport(ctx, req) +} + +func (s *Server) QueryImport(ctx context.Context, req *datapb.QueryImportRequest) (*datapb.QueryImportResponse, error) { + return s.datanode.QueryImport(ctx, req) +} + +func (s *Server) DropImport(ctx context.Context, req *datapb.DropImportRequest) (*commonpb.Status, error) { + return s.datanode.DropImport(ctx, req) +} diff --git a/internal/distributed/datanode/service_test.go b/internal/distributed/datanode/service_test.go index b64d658c8a..ba4d5de241 100644 --- a/internal/distributed/datanode/service_test.go +++ b/internal/distributed/datanode/service_test.go @@ -162,6 +162,26 @@ func (m *MockDataNode) CheckChannelOperationProgress(ctx context.Context, req *d return &datapb.ChannelOperationProgressResponse{}, m.err } +func (m *MockDataNode) PreImport(ctx context.Context, req *datapb.PreImportRequest) (*commonpb.Status, error) { + return m.status, m.err +} + +func (m *MockDataNode) ImportV2(ctx context.Context, req *datapb.ImportRequest) (*commonpb.Status, error) { + return m.status, m.err +} + +func (m *MockDataNode) QueryPreImport(ctx context.Context, req *datapb.QueryPreImportRequest) (*datapb.QueryPreImportResponse, error) { + return &datapb.QueryPreImportResponse{}, m.err +} + +func (m *MockDataNode) QueryImport(ctx context.Context, req *datapb.QueryImportRequest) (*datapb.QueryImportResponse, error) { + return &datapb.QueryImportResponse{}, m.err +} + +func (m *MockDataNode) DropImport(ctx context.Context, req *datapb.DropImportRequest) (*commonpb.Status, error) { + return m.status, m.err +} + // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// type mockDataCoord struct { types.DataCoordClient diff --git a/internal/mocks/mock_datanode.go b/internal/mocks/mock_datanode.go index 64d298a137..e5cd90d444 100644 --- a/internal/mocks/mock_datanode.go +++ b/internal/mocks/mock_datanode.go @@ -64,8 +64,8 @@ type MockDataNode_AddImportSegment_Call struct { } // AddImportSegment is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.AddImportSegmentRequest +// - _a0 context.Context +// - _a1 *datapb.AddImportSegmentRequest func (_e *MockDataNode_Expecter) AddImportSegment(_a0 interface{}, _a1 interface{}) *MockDataNode_AddImportSegment_Call { return &MockDataNode_AddImportSegment_Call{Call: _e.mock.On("AddImportSegment", _a0, _a1)} } @@ -119,8 +119,8 @@ type MockDataNode_CheckChannelOperationProgress_Call struct { } // CheckChannelOperationProgress is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.ChannelWatchInfo +// - _a0 context.Context +// - _a1 *datapb.ChannelWatchInfo func (_e *MockDataNode_Expecter) CheckChannelOperationProgress(_a0 interface{}, _a1 interface{}) *MockDataNode_CheckChannelOperationProgress_Call { return &MockDataNode_CheckChannelOperationProgress_Call{Call: _e.mock.On("CheckChannelOperationProgress", _a0, _a1)} } @@ -174,8 +174,8 @@ type MockDataNode_Compaction_Call struct { } // Compaction is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.CompactionPlan +// - _a0 context.Context +// - _a1 *datapb.CompactionPlan func (_e *MockDataNode_Expecter) Compaction(_a0 interface{}, _a1 interface{}) *MockDataNode_Compaction_Call { return &MockDataNode_Compaction_Call{Call: _e.mock.On("Compaction", _a0, _a1)} } @@ -197,6 +197,61 @@ func (_c *MockDataNode_Compaction_Call) RunAndReturn(run func(context.Context, * return _c } +// DropImport provides a mock function with given fields: _a0, _a1 +func (_m *MockDataNode) DropImport(_a0 context.Context, _a1 *datapb.DropImportRequest) (*commonpb.Status, error) { + ret := _m.Called(_a0, _a1) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropImportRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropImportRequest) *commonpb.Status); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.DropImportRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataNode_DropImport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropImport' +type MockDataNode_DropImport_Call struct { + *mock.Call +} + +// DropImport is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *datapb.DropImportRequest +func (_e *MockDataNode_Expecter) DropImport(_a0 interface{}, _a1 interface{}) *MockDataNode_DropImport_Call { + return &MockDataNode_DropImport_Call{Call: _e.mock.On("DropImport", _a0, _a1)} +} + +func (_c *MockDataNode_DropImport_Call) Run(run func(_a0 context.Context, _a1 *datapb.DropImportRequest)) *MockDataNode_DropImport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.DropImportRequest)) + }) + return _c +} + +func (_c *MockDataNode_DropImport_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataNode_DropImport_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataNode_DropImport_Call) RunAndReturn(run func(context.Context, *datapb.DropImportRequest) (*commonpb.Status, error)) *MockDataNode_DropImport_Call { + _c.Call.Return(run) + return _c +} + // FlushChannels provides a mock function with given fields: _a0, _a1 func (_m *MockDataNode) FlushChannels(_a0 context.Context, _a1 *datapb.FlushChannelsRequest) (*commonpb.Status, error) { ret := _m.Called(_a0, _a1) @@ -229,8 +284,8 @@ type MockDataNode_FlushChannels_Call struct { } // FlushChannels is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.FlushChannelsRequest +// - _a0 context.Context +// - _a1 *datapb.FlushChannelsRequest func (_e *MockDataNode_Expecter) FlushChannels(_a0 interface{}, _a1 interface{}) *MockDataNode_FlushChannels_Call { return &MockDataNode_FlushChannels_Call{Call: _e.mock.On("FlushChannels", _a0, _a1)} } @@ -284,8 +339,8 @@ type MockDataNode_FlushSegments_Call struct { } // FlushSegments is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.FlushSegmentsRequest +// - _a0 context.Context +// - _a1 *datapb.FlushSegmentsRequest func (_e *MockDataNode_Expecter) FlushSegments(_a0 interface{}, _a1 interface{}) *MockDataNode_FlushSegments_Call { return &MockDataNode_FlushSegments_Call{Call: _e.mock.On("FlushSegments", _a0, _a1)} } @@ -380,8 +435,8 @@ type MockDataNode_GetCompactionState_Call struct { } // GetCompactionState is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.CompactionStateRequest +// - _a0 context.Context +// - _a1 *datapb.CompactionStateRequest func (_e *MockDataNode_Expecter) GetCompactionState(_a0 interface{}, _a1 interface{}) *MockDataNode_GetCompactionState_Call { return &MockDataNode_GetCompactionState_Call{Call: _e.mock.On("GetCompactionState", _a0, _a1)} } @@ -435,8 +490,8 @@ type MockDataNode_GetComponentStates_Call struct { } // GetComponentStates is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *milvuspb.GetComponentStatesRequest +// - _a0 context.Context +// - _a1 *milvuspb.GetComponentStatesRequest func (_e *MockDataNode_Expecter) GetComponentStates(_a0 interface{}, _a1 interface{}) *MockDataNode_GetComponentStates_Call { return &MockDataNode_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", _a0, _a1)} } @@ -490,8 +545,8 @@ type MockDataNode_GetMetrics_Call struct { } // GetMetrics is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *milvuspb.GetMetricsRequest +// - _a0 context.Context +// - _a1 *milvuspb.GetMetricsRequest func (_e *MockDataNode_Expecter) GetMetrics(_a0 interface{}, _a1 interface{}) *MockDataNode_GetMetrics_Call { return &MockDataNode_GetMetrics_Call{Call: _e.mock.On("GetMetrics", _a0, _a1)} } @@ -586,8 +641,8 @@ type MockDataNode_GetStatisticsChannel_Call struct { } // GetStatisticsChannel is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *internalpb.GetStatisticsChannelRequest +// - _a0 context.Context +// - _a1 *internalpb.GetStatisticsChannelRequest func (_e *MockDataNode_Expecter) GetStatisticsChannel(_a0 interface{}, _a1 interface{}) *MockDataNode_GetStatisticsChannel_Call { return &MockDataNode_GetStatisticsChannel_Call{Call: _e.mock.On("GetStatisticsChannel", _a0, _a1)} } @@ -641,8 +696,8 @@ type MockDataNode_Import_Call struct { } // Import is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.ImportTaskRequest +// - _a0 context.Context +// - _a1 *datapb.ImportTaskRequest func (_e *MockDataNode_Expecter) Import(_a0 interface{}, _a1 interface{}) *MockDataNode_Import_Call { return &MockDataNode_Import_Call{Call: _e.mock.On("Import", _a0, _a1)} } @@ -664,6 +719,61 @@ func (_c *MockDataNode_Import_Call) RunAndReturn(run func(context.Context, *data return _c } +// ImportV2 provides a mock function with given fields: _a0, _a1 +func (_m *MockDataNode) ImportV2(_a0 context.Context, _a1 *datapb.ImportRequest) (*commonpb.Status, error) { + ret := _m.Called(_a0, _a1) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.ImportRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.ImportRequest) *commonpb.Status); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.ImportRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataNode_ImportV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportV2' +type MockDataNode_ImportV2_Call struct { + *mock.Call +} + +// ImportV2 is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *datapb.ImportRequest +func (_e *MockDataNode_Expecter) ImportV2(_a0 interface{}, _a1 interface{}) *MockDataNode_ImportV2_Call { + return &MockDataNode_ImportV2_Call{Call: _e.mock.On("ImportV2", _a0, _a1)} +} + +func (_c *MockDataNode_ImportV2_Call) Run(run func(_a0 context.Context, _a1 *datapb.ImportRequest)) *MockDataNode_ImportV2_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.ImportRequest)) + }) + return _c +} + +func (_c *MockDataNode_ImportV2_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataNode_ImportV2_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataNode_ImportV2_Call) RunAndReturn(run func(context.Context, *datapb.ImportRequest) (*commonpb.Status, error)) *MockDataNode_ImportV2_Call { + _c.Call.Return(run) + return _c +} + // Init provides a mock function with given fields: func (_m *MockDataNode) Init() error { ret := _m.Called() @@ -737,8 +847,8 @@ type MockDataNode_NotifyChannelOperation_Call struct { } // NotifyChannelOperation is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.ChannelOperationsRequest +// - _a0 context.Context +// - _a1 *datapb.ChannelOperationsRequest func (_e *MockDataNode_Expecter) NotifyChannelOperation(_a0 interface{}, _a1 interface{}) *MockDataNode_NotifyChannelOperation_Call { return &MockDataNode_NotifyChannelOperation_Call{Call: _e.mock.On("NotifyChannelOperation", _a0, _a1)} } @@ -760,6 +870,171 @@ func (_c *MockDataNode_NotifyChannelOperation_Call) RunAndReturn(run func(contex return _c } +// PreImport provides a mock function with given fields: _a0, _a1 +func (_m *MockDataNode) PreImport(_a0 context.Context, _a1 *datapb.PreImportRequest) (*commonpb.Status, error) { + ret := _m.Called(_a0, _a1) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.PreImportRequest) (*commonpb.Status, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.PreImportRequest) *commonpb.Status); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.PreImportRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataNode_PreImport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PreImport' +type MockDataNode_PreImport_Call struct { + *mock.Call +} + +// PreImport is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *datapb.PreImportRequest +func (_e *MockDataNode_Expecter) PreImport(_a0 interface{}, _a1 interface{}) *MockDataNode_PreImport_Call { + return &MockDataNode_PreImport_Call{Call: _e.mock.On("PreImport", _a0, _a1)} +} + +func (_c *MockDataNode_PreImport_Call) Run(run func(_a0 context.Context, _a1 *datapb.PreImportRequest)) *MockDataNode_PreImport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.PreImportRequest)) + }) + return _c +} + +func (_c *MockDataNode_PreImport_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataNode_PreImport_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataNode_PreImport_Call) RunAndReturn(run func(context.Context, *datapb.PreImportRequest) (*commonpb.Status, error)) *MockDataNode_PreImport_Call { + _c.Call.Return(run) + return _c +} + +// QueryImport provides a mock function with given fields: _a0, _a1 +func (_m *MockDataNode) QueryImport(_a0 context.Context, _a1 *datapb.QueryImportRequest) (*datapb.QueryImportResponse, error) { + ret := _m.Called(_a0, _a1) + + var r0 *datapb.QueryImportResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.QueryImportRequest) (*datapb.QueryImportResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.QueryImportRequest) *datapb.QueryImportResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.QueryImportResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.QueryImportRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataNode_QueryImport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryImport' +type MockDataNode_QueryImport_Call struct { + *mock.Call +} + +// QueryImport is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *datapb.QueryImportRequest +func (_e *MockDataNode_Expecter) QueryImport(_a0 interface{}, _a1 interface{}) *MockDataNode_QueryImport_Call { + return &MockDataNode_QueryImport_Call{Call: _e.mock.On("QueryImport", _a0, _a1)} +} + +func (_c *MockDataNode_QueryImport_Call) Run(run func(_a0 context.Context, _a1 *datapb.QueryImportRequest)) *MockDataNode_QueryImport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.QueryImportRequest)) + }) + return _c +} + +func (_c *MockDataNode_QueryImport_Call) Return(_a0 *datapb.QueryImportResponse, _a1 error) *MockDataNode_QueryImport_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataNode_QueryImport_Call) RunAndReturn(run func(context.Context, *datapb.QueryImportRequest) (*datapb.QueryImportResponse, error)) *MockDataNode_QueryImport_Call { + _c.Call.Return(run) + return _c +} + +// QueryPreImport provides a mock function with given fields: _a0, _a1 +func (_m *MockDataNode) QueryPreImport(_a0 context.Context, _a1 *datapb.QueryPreImportRequest) (*datapb.QueryPreImportResponse, error) { + ret := _m.Called(_a0, _a1) + + var r0 *datapb.QueryPreImportResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.QueryPreImportRequest) (*datapb.QueryPreImportResponse, error)); ok { + return rf(_a0, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.QueryPreImportRequest) *datapb.QueryPreImportResponse); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.QueryPreImportResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.QueryPreImportRequest) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataNode_QueryPreImport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryPreImport' +type MockDataNode_QueryPreImport_Call struct { + *mock.Call +} + +// QueryPreImport is a helper method to define mock.On call +// - _a0 context.Context +// - _a1 *datapb.QueryPreImportRequest +func (_e *MockDataNode_Expecter) QueryPreImport(_a0 interface{}, _a1 interface{}) *MockDataNode_QueryPreImport_Call { + return &MockDataNode_QueryPreImport_Call{Call: _e.mock.On("QueryPreImport", _a0, _a1)} +} + +func (_c *MockDataNode_QueryPreImport_Call) Run(run func(_a0 context.Context, _a1 *datapb.QueryPreImportRequest)) *MockDataNode_QueryPreImport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*datapb.QueryPreImportRequest)) + }) + return _c +} + +func (_c *MockDataNode_QueryPreImport_Call) Return(_a0 *datapb.QueryPreImportResponse, _a1 error) *MockDataNode_QueryPreImport_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataNode_QueryPreImport_Call) RunAndReturn(run func(context.Context, *datapb.QueryPreImportRequest) (*datapb.QueryPreImportResponse, error)) *MockDataNode_QueryPreImport_Call { + _c.Call.Return(run) + return _c +} + // Register provides a mock function with given fields: func (_m *MockDataNode) Register() error { ret := _m.Called() @@ -833,8 +1108,8 @@ type MockDataNode_ResendSegmentStats_Call struct { } // ResendSegmentStats is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.ResendSegmentStatsRequest +// - _a0 context.Context +// - _a1 *datapb.ResendSegmentStatsRequest func (_e *MockDataNode_Expecter) ResendSegmentStats(_a0 interface{}, _a1 interface{}) *MockDataNode_ResendSegmentStats_Call { return &MockDataNode_ResendSegmentStats_Call{Call: _e.mock.On("ResendSegmentStats", _a0, _a1)} } @@ -867,7 +1142,7 @@ type MockDataNode_SetAddress_Call struct { } // SetAddress is a helper method to define mock.On call -// - address string +// - address string func (_e *MockDataNode_Expecter) SetAddress(address interface{}) *MockDataNode_SetAddress_Call { return &MockDataNode_SetAddress_Call{Call: _e.mock.On("SetAddress", address)} } @@ -909,7 +1184,7 @@ type MockDataNode_SetDataCoordClient_Call struct { } // SetDataCoordClient is a helper method to define mock.On call -// - dataCoord types.DataCoordClient +// - dataCoord types.DataCoordClient func (_e *MockDataNode_Expecter) SetDataCoordClient(dataCoord interface{}) *MockDataNode_SetDataCoordClient_Call { return &MockDataNode_SetDataCoordClient_Call{Call: _e.mock.On("SetDataCoordClient", dataCoord)} } @@ -942,7 +1217,7 @@ type MockDataNode_SetEtcdClient_Call struct { } // SetEtcdClient is a helper method to define mock.On call -// - etcdClient *clientv3.Client +// - etcdClient *clientv3.Client func (_e *MockDataNode_Expecter) SetEtcdClient(etcdClient interface{}) *MockDataNode_SetEtcdClient_Call { return &MockDataNode_SetEtcdClient_Call{Call: _e.mock.On("SetEtcdClient", etcdClient)} } @@ -984,7 +1259,7 @@ type MockDataNode_SetRootCoordClient_Call struct { } // SetRootCoordClient is a helper method to define mock.On call -// - rootCoord types.RootCoordClient +// - rootCoord types.RootCoordClient func (_e *MockDataNode_Expecter) SetRootCoordClient(rootCoord interface{}) *MockDataNode_SetRootCoordClient_Call { return &MockDataNode_SetRootCoordClient_Call{Call: _e.mock.On("SetRootCoordClient", rootCoord)} } @@ -1038,8 +1313,8 @@ type MockDataNode_ShowConfigurations_Call struct { } // ShowConfigurations is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *internalpb.ShowConfigurationsRequest +// - _a0 context.Context +// - _a1 *internalpb.ShowConfigurationsRequest func (_e *MockDataNode_Expecter) ShowConfigurations(_a0 interface{}, _a1 interface{}) *MockDataNode_ShowConfigurations_Call { return &MockDataNode_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", _a0, _a1)} } @@ -1175,8 +1450,8 @@ type MockDataNode_SyncSegments_Call struct { } // SyncSegments is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.SyncSegmentsRequest +// - _a0 context.Context +// - _a1 *datapb.SyncSegmentsRequest func (_e *MockDataNode_Expecter) SyncSegments(_a0 interface{}, _a1 interface{}) *MockDataNode_SyncSegments_Call { return &MockDataNode_SyncSegments_Call{Call: _e.mock.On("SyncSegments", _a0, _a1)} } @@ -1209,7 +1484,7 @@ type MockDataNode_UpdateStateCode_Call struct { } // UpdateStateCode is a helper method to define mock.On call -// - stateCode commonpb.StateCode +// - stateCode commonpb.StateCode func (_e *MockDataNode_Expecter) UpdateStateCode(stateCode interface{}) *MockDataNode_UpdateStateCode_Call { return &MockDataNode_UpdateStateCode_Call{Call: _e.mock.On("UpdateStateCode", stateCode)} } @@ -1263,8 +1538,8 @@ type MockDataNode_WatchDmChannels_Call struct { } // WatchDmChannels is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 *datapb.WatchDmChannelsRequest +// - _a0 context.Context +// - _a1 *datapb.WatchDmChannelsRequest func (_e *MockDataNode_Expecter) WatchDmChannels(_a0 interface{}, _a1 interface{}) *MockDataNode_WatchDmChannels_Call { return &MockDataNode_WatchDmChannels_Call{Call: _e.mock.On("WatchDmChannels", _a0, _a1)} } diff --git a/internal/mocks/mock_datanode_client.go b/internal/mocks/mock_datanode_client.go index 76131bacf7..c0db2cb6e2 100644 --- a/internal/mocks/mock_datanode_client.go +++ b/internal/mocks/mock_datanode_client.go @@ -70,9 +70,9 @@ type MockDataNodeClient_AddImportSegment_Call struct { } // AddImportSegment is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.AddImportSegmentRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.AddImportSegmentRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) AddImportSegment(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_AddImportSegment_Call { return &MockDataNodeClient_AddImportSegment_Call{Call: _e.mock.On("AddImportSegment", append([]interface{}{ctx, in}, opts...)...)} @@ -140,9 +140,9 @@ type MockDataNodeClient_CheckChannelOperationProgress_Call struct { } // CheckChannelOperationProgress is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.ChannelWatchInfo -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.ChannelWatchInfo +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) CheckChannelOperationProgress(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_CheckChannelOperationProgress_Call { return &MockDataNodeClient_CheckChannelOperationProgress_Call{Call: _e.mock.On("CheckChannelOperationProgress", append([]interface{}{ctx, in}, opts...)...)} @@ -251,9 +251,9 @@ type MockDataNodeClient_Compaction_Call struct { } // Compaction is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.CompactionPlan -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.CompactionPlan +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) Compaction(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_Compaction_Call { return &MockDataNodeClient_Compaction_Call{Call: _e.mock.On("Compaction", append([]interface{}{ctx, in}, opts...)...)} @@ -282,6 +282,76 @@ func (_c *MockDataNodeClient_Compaction_Call) RunAndReturn(run func(context.Cont return _c } +// DropImport provides a mock function with given fields: ctx, in, opts +func (_m *MockDataNodeClient) DropImport(ctx context.Context, in *datapb.DropImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropImportRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.DropImportRequest, ...grpc.CallOption) *commonpb.Status); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.DropImportRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataNodeClient_DropImport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropImport' +type MockDataNodeClient_DropImport_Call struct { + *mock.Call +} + +// DropImport is a helper method to define mock.On call +// - ctx context.Context +// - in *datapb.DropImportRequest +// - opts ...grpc.CallOption +func (_e *MockDataNodeClient_Expecter) DropImport(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_DropImport_Call { + return &MockDataNodeClient_DropImport_Call{Call: _e.mock.On("DropImport", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockDataNodeClient_DropImport_Call) Run(run func(ctx context.Context, in *datapb.DropImportRequest, opts ...grpc.CallOption)) *MockDataNodeClient_DropImport_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*datapb.DropImportRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockDataNodeClient_DropImport_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataNodeClient_DropImport_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataNodeClient_DropImport_Call) RunAndReturn(run func(context.Context, *datapb.DropImportRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockDataNodeClient_DropImport_Call { + _c.Call.Return(run) + return _c +} + // FlushChannels provides a mock function with given fields: ctx, in, opts func (_m *MockDataNodeClient) FlushChannels(ctx context.Context, in *datapb.FlushChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { _va := make([]interface{}, len(opts)) @@ -321,9 +391,9 @@ type MockDataNodeClient_FlushChannels_Call struct { } // FlushChannels is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.FlushChannelsRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.FlushChannelsRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) FlushChannels(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_FlushChannels_Call { return &MockDataNodeClient_FlushChannels_Call{Call: _e.mock.On("FlushChannels", append([]interface{}{ctx, in}, opts...)...)} @@ -391,9 +461,9 @@ type MockDataNodeClient_FlushSegments_Call struct { } // FlushSegments is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.FlushSegmentsRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.FlushSegmentsRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) FlushSegments(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_FlushSegments_Call { return &MockDataNodeClient_FlushSegments_Call{Call: _e.mock.On("FlushSegments", append([]interface{}{ctx, in}, opts...)...)} @@ -461,9 +531,9 @@ type MockDataNodeClient_GetCompactionState_Call struct { } // GetCompactionState is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.CompactionStateRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.CompactionStateRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) GetCompactionState(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_GetCompactionState_Call { return &MockDataNodeClient_GetCompactionState_Call{Call: _e.mock.On("GetCompactionState", append([]interface{}{ctx, in}, opts...)...)} @@ -531,9 +601,9 @@ type MockDataNodeClient_GetComponentStates_Call struct { } // GetComponentStates is a helper method to define mock.On call -// - ctx context.Context -// - in *milvuspb.GetComponentStatesRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *milvuspb.GetComponentStatesRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) GetComponentStates(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_GetComponentStates_Call { return &MockDataNodeClient_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", append([]interface{}{ctx, in}, opts...)...)} @@ -601,9 +671,9 @@ type MockDataNodeClient_GetMetrics_Call struct { } // GetMetrics is a helper method to define mock.On call -// - ctx context.Context -// - in *milvuspb.GetMetricsRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *milvuspb.GetMetricsRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) GetMetrics(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_GetMetrics_Call { return &MockDataNodeClient_GetMetrics_Call{Call: _e.mock.On("GetMetrics", append([]interface{}{ctx, in}, opts...)...)} @@ -671,9 +741,9 @@ type MockDataNodeClient_GetStatisticsChannel_Call struct { } // GetStatisticsChannel is a helper method to define mock.On call -// - ctx context.Context -// - in *internalpb.GetStatisticsChannelRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *internalpb.GetStatisticsChannelRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) GetStatisticsChannel(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_GetStatisticsChannel_Call { return &MockDataNodeClient_GetStatisticsChannel_Call{Call: _e.mock.On("GetStatisticsChannel", append([]interface{}{ctx, in}, opts...)...)} @@ -741,9 +811,9 @@ type MockDataNodeClient_Import_Call struct { } // Import is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.ImportTaskRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.ImportTaskRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) Import(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_Import_Call { return &MockDataNodeClient_Import_Call{Call: _e.mock.On("Import", append([]interface{}{ctx, in}, opts...)...)} @@ -772,6 +842,76 @@ func (_c *MockDataNodeClient_Import_Call) RunAndReturn(run func(context.Context, return _c } +// ImportV2 provides a mock function with given fields: ctx, in, opts +func (_m *MockDataNodeClient) ImportV2(ctx context.Context, in *datapb.ImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.ImportRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.ImportRequest, ...grpc.CallOption) *commonpb.Status); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.ImportRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataNodeClient_ImportV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ImportV2' +type MockDataNodeClient_ImportV2_Call struct { + *mock.Call +} + +// ImportV2 is a helper method to define mock.On call +// - ctx context.Context +// - in *datapb.ImportRequest +// - opts ...grpc.CallOption +func (_e *MockDataNodeClient_Expecter) ImportV2(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_ImportV2_Call { + return &MockDataNodeClient_ImportV2_Call{Call: _e.mock.On("ImportV2", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockDataNodeClient_ImportV2_Call) Run(run func(ctx context.Context, in *datapb.ImportRequest, opts ...grpc.CallOption)) *MockDataNodeClient_ImportV2_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*datapb.ImportRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockDataNodeClient_ImportV2_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataNodeClient_ImportV2_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataNodeClient_ImportV2_Call) RunAndReturn(run func(context.Context, *datapb.ImportRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockDataNodeClient_ImportV2_Call { + _c.Call.Return(run) + return _c +} + // NotifyChannelOperation provides a mock function with given fields: ctx, in, opts func (_m *MockDataNodeClient) NotifyChannelOperation(ctx context.Context, in *datapb.ChannelOperationsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { _va := make([]interface{}, len(opts)) @@ -811,9 +951,9 @@ type MockDataNodeClient_NotifyChannelOperation_Call struct { } // NotifyChannelOperation is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.ChannelOperationsRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.ChannelOperationsRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) NotifyChannelOperation(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_NotifyChannelOperation_Call { return &MockDataNodeClient_NotifyChannelOperation_Call{Call: _e.mock.On("NotifyChannelOperation", append([]interface{}{ctx, in}, opts...)...)} @@ -842,6 +982,216 @@ func (_c *MockDataNodeClient_NotifyChannelOperation_Call) RunAndReturn(run func( return _c } +// PreImport provides a mock function with given fields: ctx, in, opts +func (_m *MockDataNodeClient) PreImport(ctx context.Context, in *datapb.PreImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *commonpb.Status + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.PreImportRequest, ...grpc.CallOption) (*commonpb.Status, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.PreImportRequest, ...grpc.CallOption) *commonpb.Status); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*commonpb.Status) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.PreImportRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataNodeClient_PreImport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PreImport' +type MockDataNodeClient_PreImport_Call struct { + *mock.Call +} + +// PreImport is a helper method to define mock.On call +// - ctx context.Context +// - in *datapb.PreImportRequest +// - opts ...grpc.CallOption +func (_e *MockDataNodeClient_Expecter) PreImport(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_PreImport_Call { + return &MockDataNodeClient_PreImport_Call{Call: _e.mock.On("PreImport", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockDataNodeClient_PreImport_Call) Run(run func(ctx context.Context, in *datapb.PreImportRequest, opts ...grpc.CallOption)) *MockDataNodeClient_PreImport_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*datapb.PreImportRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockDataNodeClient_PreImport_Call) Return(_a0 *commonpb.Status, _a1 error) *MockDataNodeClient_PreImport_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataNodeClient_PreImport_Call) RunAndReturn(run func(context.Context, *datapb.PreImportRequest, ...grpc.CallOption) (*commonpb.Status, error)) *MockDataNodeClient_PreImport_Call { + _c.Call.Return(run) + return _c +} + +// QueryImport provides a mock function with given fields: ctx, in, opts +func (_m *MockDataNodeClient) QueryImport(ctx context.Context, in *datapb.QueryImportRequest, opts ...grpc.CallOption) (*datapb.QueryImportResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *datapb.QueryImportResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.QueryImportRequest, ...grpc.CallOption) (*datapb.QueryImportResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.QueryImportRequest, ...grpc.CallOption) *datapb.QueryImportResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.QueryImportResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.QueryImportRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataNodeClient_QueryImport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryImport' +type MockDataNodeClient_QueryImport_Call struct { + *mock.Call +} + +// QueryImport is a helper method to define mock.On call +// - ctx context.Context +// - in *datapb.QueryImportRequest +// - opts ...grpc.CallOption +func (_e *MockDataNodeClient_Expecter) QueryImport(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_QueryImport_Call { + return &MockDataNodeClient_QueryImport_Call{Call: _e.mock.On("QueryImport", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockDataNodeClient_QueryImport_Call) Run(run func(ctx context.Context, in *datapb.QueryImportRequest, opts ...grpc.CallOption)) *MockDataNodeClient_QueryImport_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*datapb.QueryImportRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockDataNodeClient_QueryImport_Call) Return(_a0 *datapb.QueryImportResponse, _a1 error) *MockDataNodeClient_QueryImport_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataNodeClient_QueryImport_Call) RunAndReturn(run func(context.Context, *datapb.QueryImportRequest, ...grpc.CallOption) (*datapb.QueryImportResponse, error)) *MockDataNodeClient_QueryImport_Call { + _c.Call.Return(run) + return _c +} + +// QueryPreImport provides a mock function with given fields: ctx, in, opts +func (_m *MockDataNodeClient) QueryPreImport(ctx context.Context, in *datapb.QueryPreImportRequest, opts ...grpc.CallOption) (*datapb.QueryPreImportResponse, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, in) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *datapb.QueryPreImportResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *datapb.QueryPreImportRequest, ...grpc.CallOption) (*datapb.QueryPreImportResponse, error)); ok { + return rf(ctx, in, opts...) + } + if rf, ok := ret.Get(0).(func(context.Context, *datapb.QueryPreImportRequest, ...grpc.CallOption) *datapb.QueryPreImportResponse); ok { + r0 = rf(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*datapb.QueryPreImportResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *datapb.QueryPreImportRequest, ...grpc.CallOption) error); ok { + r1 = rf(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDataNodeClient_QueryPreImport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryPreImport' +type MockDataNodeClient_QueryPreImport_Call struct { + *mock.Call +} + +// QueryPreImport is a helper method to define mock.On call +// - ctx context.Context +// - in *datapb.QueryPreImportRequest +// - opts ...grpc.CallOption +func (_e *MockDataNodeClient_Expecter) QueryPreImport(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_QueryPreImport_Call { + return &MockDataNodeClient_QueryPreImport_Call{Call: _e.mock.On("QueryPreImport", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockDataNodeClient_QueryPreImport_Call) Run(run func(ctx context.Context, in *datapb.QueryPreImportRequest, opts ...grpc.CallOption)) *MockDataNodeClient_QueryPreImport_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]grpc.CallOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(grpc.CallOption) + } + } + run(args[0].(context.Context), args[1].(*datapb.QueryPreImportRequest), variadicArgs...) + }) + return _c +} + +func (_c *MockDataNodeClient_QueryPreImport_Call) Return(_a0 *datapb.QueryPreImportResponse, _a1 error) *MockDataNodeClient_QueryPreImport_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDataNodeClient_QueryPreImport_Call) RunAndReturn(run func(context.Context, *datapb.QueryPreImportRequest, ...grpc.CallOption) (*datapb.QueryPreImportResponse, error)) *MockDataNodeClient_QueryPreImport_Call { + _c.Call.Return(run) + return _c +} + // ResendSegmentStats provides a mock function with given fields: ctx, in, opts func (_m *MockDataNodeClient) ResendSegmentStats(ctx context.Context, in *datapb.ResendSegmentStatsRequest, opts ...grpc.CallOption) (*datapb.ResendSegmentStatsResponse, error) { _va := make([]interface{}, len(opts)) @@ -881,9 +1231,9 @@ type MockDataNodeClient_ResendSegmentStats_Call struct { } // ResendSegmentStats is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.ResendSegmentStatsRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.ResendSegmentStatsRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) ResendSegmentStats(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_ResendSegmentStats_Call { return &MockDataNodeClient_ResendSegmentStats_Call{Call: _e.mock.On("ResendSegmentStats", append([]interface{}{ctx, in}, opts...)...)} @@ -951,9 +1301,9 @@ type MockDataNodeClient_ShowConfigurations_Call struct { } // ShowConfigurations is a helper method to define mock.On call -// - ctx context.Context -// - in *internalpb.ShowConfigurationsRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *internalpb.ShowConfigurationsRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) ShowConfigurations(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_ShowConfigurations_Call { return &MockDataNodeClient_ShowConfigurations_Call{Call: _e.mock.On("ShowConfigurations", append([]interface{}{ctx, in}, opts...)...)} @@ -1021,9 +1371,9 @@ type MockDataNodeClient_SyncSegments_Call struct { } // SyncSegments is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.SyncSegmentsRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.SyncSegmentsRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) SyncSegments(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_SyncSegments_Call { return &MockDataNodeClient_SyncSegments_Call{Call: _e.mock.On("SyncSegments", append([]interface{}{ctx, in}, opts...)...)} @@ -1091,9 +1441,9 @@ type MockDataNodeClient_WatchDmChannels_Call struct { } // WatchDmChannels is a helper method to define mock.On call -// - ctx context.Context -// - in *datapb.WatchDmChannelsRequest -// - opts ...grpc.CallOption +// - ctx context.Context +// - in *datapb.WatchDmChannelsRequest +// - opts ...grpc.CallOption func (_e *MockDataNodeClient_Expecter) WatchDmChannels(ctx interface{}, in interface{}, opts ...interface{}) *MockDataNodeClient_WatchDmChannels_Call { return &MockDataNodeClient_WatchDmChannels_Call{Call: _e.mock.On("WatchDmChannels", append([]interface{}{ctx, in}, opts...)...)} diff --git a/internal/proto/data_coord.proto b/internal/proto/data_coord.proto index 1de1b79f97..b70ab1b761 100644 --- a/internal/proto/data_coord.proto +++ b/internal/proto/data_coord.proto @@ -119,6 +119,13 @@ service DataNode { rpc FlushChannels(FlushChannelsRequest) returns(common.Status) {} rpc NotifyChannelOperation(ChannelOperationsRequest) returns(common.Status) {} rpc CheckChannelOperationProgress(ChannelWatchInfo) returns(ChannelOperationProgressResponse) {} + + // import v2 + rpc PreImport(PreImportRequest) returns(common.Status) {} + rpc ImportV2(ImportRequest) returns(common.Status) {} + rpc QueryPreImport(QueryPreImportRequest) returns(QueryPreImportResponse) {} + rpc QueryImport(QueryImportRequest) returns(QueryImportResponse) {} + rpc DropImport(DropImportRequest) returns(common.Status) {} } message FlushRequest { @@ -737,3 +744,124 @@ message ChannelOperationProgressResponse { ChannelWatchState state = 3; int32 progress = 4; } + +enum ImportState { + None = 0; + Pending = 1; + InProgress = 2; + Failed = 3; + Completed = 4; +} + +message ColumnBasedFile { + repeated string files = 1; +} + +message ImportFile { + oneof file { + string row_based_file = 1; + ColumnBasedFile column_based_file = 2; + } +} + +message PreImportRequest { + string clusterID = 1; + int64 requestID = 2; + int64 taskID = 3; + int64 collectionID = 4; + int64 partitionID = 5; + schema.CollectionSchema schema = 6; + repeated ImportFile import_files = 7; +} + +message autoIDRange { + int64 begin = 1; + int64 end = 2; +} + +message ImportRequest { + string clusterID = 1; + int64 requestID = 2; + int64 taskID = 3; + int64 collectionID = 4; + int64 partitionID = 5; + schema.CollectionSchema schema = 6; + repeated ImportFile import_files = 7; + map autoID_ranges = 8; + map segment_channels = 9; +} + +message QueryPreImportRequest { + string clusterID = 1; + int64 requestID = 2; + int64 taskID = 3; +} + +message ImportFileStats { + ImportFile import_file = 1; + int64 file_size = 2; + int64 total_rows = 3; + map channel_rows = 4; +} + +message QueryPreImportResponse { + common.Status status = 1; + int64 taskID = 2; + ImportState state = 3; + string reason = 4; + int64 slots = 5; + repeated ImportFileStats file_stats = 6; +} + +message QueryImportRequest { + string clusterID = 1; + int64 requestID = 2; + int64 taskID = 3; +} + +message ImportSegmentInfo { + int64 segmentID = 1; + int64 total_rows = 2; + int64 imported_rows = 3; + repeated FieldBinlog binlogs = 4; + repeated FieldBinlog statslogs = 5; + repeated index.IndexFilePathInfo index_infos = 6; +} + +message QueryImportResponse { + common.Status status = 1; + int64 taskID = 2; + ImportState state = 3; + string reason = 4; + int64 slots = 5; + repeated ImportSegmentInfo import_segments_info = 6; +} + +message DropImportRequest { + string clusterID = 1; + int64 requestID = 2; + int64 taskID = 3; +} + +message PreImportTask { + int64 requestID = 1; + int64 taskID = 2; + int64 collectionID = 3; + int64 partitionID = 4; + int64 nodeID = 5; + ImportState state = 6; + string reason = 7; + repeated ImportFileStats file_stats = 8; +} + +message ImportTaskV2 { + int64 requestID = 1; + int64 taskID = 2; + int64 collectionID = 3; + int64 partitionID = 4; + repeated int64 segmentIDs = 5; + int64 nodeID = 6; + ImportState state = 7; + string reason = 8; + repeated ImportFile files = 9; +} diff --git a/internal/proto/datapb/data_coord.pb.go b/internal/proto/datapb/data_coord.pb.go index bda72935e6..50590ac92d 100644 --- a/internal/proto/datapb/data_coord.pb.go +++ b/internal/proto/datapb/data_coord.pb.go @@ -173,6 +173,40 @@ func (CompactionType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_82cd95f524594f49, []int{3} } +type ImportState int32 + +const ( + ImportState_None ImportState = 0 + ImportState_Pending ImportState = 1 + ImportState_InProgress ImportState = 2 + ImportState_Failed ImportState = 3 + ImportState_Completed ImportState = 4 +) + +var ImportState_name = map[int32]string{ + 0: "None", + 1: "Pending", + 2: "InProgress", + 3: "Failed", + 4: "Completed", +} + +var ImportState_value = map[string]int32{ + "None": 0, + "Pending": 1, + "InProgress": 2, + "Failed": 3, + "Completed": 4, +} + +func (x ImportState) String() string { + return proto.EnumName(ImportState_name, int32(x)) +} + +func (ImportState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{4} +} + // TODO: import google/protobuf/empty.proto type Empty struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` @@ -5368,11 +5402,1031 @@ func (m *ChannelOperationProgressResponse) GetProgress() int32 { return 0 } +type ColumnBasedFile struct { + Files []string `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ColumnBasedFile) Reset() { *m = ColumnBasedFile{} } +func (m *ColumnBasedFile) String() string { return proto.CompactTextString(m) } +func (*ColumnBasedFile) ProtoMessage() {} +func (*ColumnBasedFile) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{81} +} + +func (m *ColumnBasedFile) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ColumnBasedFile.Unmarshal(m, b) +} +func (m *ColumnBasedFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ColumnBasedFile.Marshal(b, m, deterministic) +} +func (m *ColumnBasedFile) XXX_Merge(src proto.Message) { + xxx_messageInfo_ColumnBasedFile.Merge(m, src) +} +func (m *ColumnBasedFile) XXX_Size() int { + return xxx_messageInfo_ColumnBasedFile.Size(m) +} +func (m *ColumnBasedFile) XXX_DiscardUnknown() { + xxx_messageInfo_ColumnBasedFile.DiscardUnknown(m) +} + +var xxx_messageInfo_ColumnBasedFile proto.InternalMessageInfo + +func (m *ColumnBasedFile) GetFiles() []string { + if m != nil { + return m.Files + } + return nil +} + +type ImportFile struct { + // Types that are valid to be assigned to File: + // *ImportFile_RowBasedFile + // *ImportFile_ColumnBasedFile + File isImportFile_File `protobuf_oneof:"file"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ImportFile) Reset() { *m = ImportFile{} } +func (m *ImportFile) String() string { return proto.CompactTextString(m) } +func (*ImportFile) ProtoMessage() {} +func (*ImportFile) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{82} +} + +func (m *ImportFile) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ImportFile.Unmarshal(m, b) +} +func (m *ImportFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ImportFile.Marshal(b, m, deterministic) +} +func (m *ImportFile) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImportFile.Merge(m, src) +} +func (m *ImportFile) XXX_Size() int { + return xxx_messageInfo_ImportFile.Size(m) +} +func (m *ImportFile) XXX_DiscardUnknown() { + xxx_messageInfo_ImportFile.DiscardUnknown(m) +} + +var xxx_messageInfo_ImportFile proto.InternalMessageInfo + +type isImportFile_File interface { + isImportFile_File() +} + +type ImportFile_RowBasedFile struct { + RowBasedFile string `protobuf:"bytes,1,opt,name=row_based_file,json=rowBasedFile,proto3,oneof"` +} + +type ImportFile_ColumnBasedFile struct { + ColumnBasedFile *ColumnBasedFile `protobuf:"bytes,2,opt,name=column_based_file,json=columnBasedFile,proto3,oneof"` +} + +func (*ImportFile_RowBasedFile) isImportFile_File() {} + +func (*ImportFile_ColumnBasedFile) isImportFile_File() {} + +func (m *ImportFile) GetFile() isImportFile_File { + if m != nil { + return m.File + } + return nil +} + +func (m *ImportFile) GetRowBasedFile() string { + if x, ok := m.GetFile().(*ImportFile_RowBasedFile); ok { + return x.RowBasedFile + } + return "" +} + +func (m *ImportFile) GetColumnBasedFile() *ColumnBasedFile { + if x, ok := m.GetFile().(*ImportFile_ColumnBasedFile); ok { + return x.ColumnBasedFile + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ImportFile) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ImportFile_RowBasedFile)(nil), + (*ImportFile_ColumnBasedFile)(nil), + } +} + +type PreImportRequest struct { + ClusterID string `protobuf:"bytes,1,opt,name=clusterID,proto3" json:"clusterID,omitempty"` + RequestID int64 `protobuf:"varint,2,opt,name=requestID,proto3" json:"requestID,omitempty"` + TaskID int64 `protobuf:"varint,3,opt,name=taskID,proto3" json:"taskID,omitempty"` + CollectionID int64 `protobuf:"varint,4,opt,name=collectionID,proto3" json:"collectionID,omitempty"` + PartitionID int64 `protobuf:"varint,5,opt,name=partitionID,proto3" json:"partitionID,omitempty"` + Schema *schemapb.CollectionSchema `protobuf:"bytes,6,opt,name=schema,proto3" json:"schema,omitempty"` + ImportFiles []*ImportFile `protobuf:"bytes,7,rep,name=import_files,json=importFiles,proto3" json:"import_files,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PreImportRequest) Reset() { *m = PreImportRequest{} } +func (m *PreImportRequest) String() string { return proto.CompactTextString(m) } +func (*PreImportRequest) ProtoMessage() {} +func (*PreImportRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{83} +} + +func (m *PreImportRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PreImportRequest.Unmarshal(m, b) +} +func (m *PreImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PreImportRequest.Marshal(b, m, deterministic) +} +func (m *PreImportRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PreImportRequest.Merge(m, src) +} +func (m *PreImportRequest) XXX_Size() int { + return xxx_messageInfo_PreImportRequest.Size(m) +} +func (m *PreImportRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PreImportRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_PreImportRequest proto.InternalMessageInfo + +func (m *PreImportRequest) GetClusterID() string { + if m != nil { + return m.ClusterID + } + return "" +} + +func (m *PreImportRequest) GetRequestID() int64 { + if m != nil { + return m.RequestID + } + return 0 +} + +func (m *PreImportRequest) GetTaskID() int64 { + if m != nil { + return m.TaskID + } + return 0 +} + +func (m *PreImportRequest) GetCollectionID() int64 { + if m != nil { + return m.CollectionID + } + return 0 +} + +func (m *PreImportRequest) GetPartitionID() int64 { + if m != nil { + return m.PartitionID + } + return 0 +} + +func (m *PreImportRequest) GetSchema() *schemapb.CollectionSchema { + if m != nil { + return m.Schema + } + return nil +} + +func (m *PreImportRequest) GetImportFiles() []*ImportFile { + if m != nil { + return m.ImportFiles + } + return nil +} + +type AutoIDRange struct { + Begin int64 `protobuf:"varint,1,opt,name=begin,proto3" json:"begin,omitempty"` + End int64 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AutoIDRange) Reset() { *m = AutoIDRange{} } +func (m *AutoIDRange) String() string { return proto.CompactTextString(m) } +func (*AutoIDRange) ProtoMessage() {} +func (*AutoIDRange) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{84} +} + +func (m *AutoIDRange) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AutoIDRange.Unmarshal(m, b) +} +func (m *AutoIDRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AutoIDRange.Marshal(b, m, deterministic) +} +func (m *AutoIDRange) XXX_Merge(src proto.Message) { + xxx_messageInfo_AutoIDRange.Merge(m, src) +} +func (m *AutoIDRange) XXX_Size() int { + return xxx_messageInfo_AutoIDRange.Size(m) +} +func (m *AutoIDRange) XXX_DiscardUnknown() { + xxx_messageInfo_AutoIDRange.DiscardUnknown(m) +} + +var xxx_messageInfo_AutoIDRange proto.InternalMessageInfo + +func (m *AutoIDRange) GetBegin() int64 { + if m != nil { + return m.Begin + } + return 0 +} + +func (m *AutoIDRange) GetEnd() int64 { + if m != nil { + return m.End + } + return 0 +} + +type ImportRequest struct { + ClusterID string `protobuf:"bytes,1,opt,name=clusterID,proto3" json:"clusterID,omitempty"` + RequestID int64 `protobuf:"varint,2,opt,name=requestID,proto3" json:"requestID,omitempty"` + TaskID int64 `protobuf:"varint,3,opt,name=taskID,proto3" json:"taskID,omitempty"` + CollectionID int64 `protobuf:"varint,4,opt,name=collectionID,proto3" json:"collectionID,omitempty"` + PartitionID int64 `protobuf:"varint,5,opt,name=partitionID,proto3" json:"partitionID,omitempty"` + Schema *schemapb.CollectionSchema `protobuf:"bytes,6,opt,name=schema,proto3" json:"schema,omitempty"` + ImportFiles []*ImportFile `protobuf:"bytes,7,rep,name=import_files,json=importFiles,proto3" json:"import_files,omitempty"` + AutoIDRanges map[int64]*AutoIDRange `protobuf:"bytes,8,rep,name=autoID_ranges,json=autoIDRanges,proto3" json:"autoID_ranges,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + SegmentChannels map[int64]string `protobuf:"bytes,9,rep,name=segment_channels,json=segmentChannels,proto3" json:"segment_channels,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ImportRequest) Reset() { *m = ImportRequest{} } +func (m *ImportRequest) String() string { return proto.CompactTextString(m) } +func (*ImportRequest) ProtoMessage() {} +func (*ImportRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{85} +} + +func (m *ImportRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ImportRequest.Unmarshal(m, b) +} +func (m *ImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ImportRequest.Marshal(b, m, deterministic) +} +func (m *ImportRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImportRequest.Merge(m, src) +} +func (m *ImportRequest) XXX_Size() int { + return xxx_messageInfo_ImportRequest.Size(m) +} +func (m *ImportRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ImportRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ImportRequest proto.InternalMessageInfo + +func (m *ImportRequest) GetClusterID() string { + if m != nil { + return m.ClusterID + } + return "" +} + +func (m *ImportRequest) GetRequestID() int64 { + if m != nil { + return m.RequestID + } + return 0 +} + +func (m *ImportRequest) GetTaskID() int64 { + if m != nil { + return m.TaskID + } + return 0 +} + +func (m *ImportRequest) GetCollectionID() int64 { + if m != nil { + return m.CollectionID + } + return 0 +} + +func (m *ImportRequest) GetPartitionID() int64 { + if m != nil { + return m.PartitionID + } + return 0 +} + +func (m *ImportRequest) GetSchema() *schemapb.CollectionSchema { + if m != nil { + return m.Schema + } + return nil +} + +func (m *ImportRequest) GetImportFiles() []*ImportFile { + if m != nil { + return m.ImportFiles + } + return nil +} + +func (m *ImportRequest) GetAutoIDRanges() map[int64]*AutoIDRange { + if m != nil { + return m.AutoIDRanges + } + return nil +} + +func (m *ImportRequest) GetSegmentChannels() map[int64]string { + if m != nil { + return m.SegmentChannels + } + return nil +} + +type QueryPreImportRequest struct { + ClusterID string `protobuf:"bytes,1,opt,name=clusterID,proto3" json:"clusterID,omitempty"` + RequestID int64 `protobuf:"varint,2,opt,name=requestID,proto3" json:"requestID,omitempty"` + TaskID int64 `protobuf:"varint,3,opt,name=taskID,proto3" json:"taskID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QueryPreImportRequest) Reset() { *m = QueryPreImportRequest{} } +func (m *QueryPreImportRequest) String() string { return proto.CompactTextString(m) } +func (*QueryPreImportRequest) ProtoMessage() {} +func (*QueryPreImportRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{86} +} + +func (m *QueryPreImportRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QueryPreImportRequest.Unmarshal(m, b) +} +func (m *QueryPreImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QueryPreImportRequest.Marshal(b, m, deterministic) +} +func (m *QueryPreImportRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryPreImportRequest.Merge(m, src) +} +func (m *QueryPreImportRequest) XXX_Size() int { + return xxx_messageInfo_QueryPreImportRequest.Size(m) +} +func (m *QueryPreImportRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryPreImportRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryPreImportRequest proto.InternalMessageInfo + +func (m *QueryPreImportRequest) GetClusterID() string { + if m != nil { + return m.ClusterID + } + return "" +} + +func (m *QueryPreImportRequest) GetRequestID() int64 { + if m != nil { + return m.RequestID + } + return 0 +} + +func (m *QueryPreImportRequest) GetTaskID() int64 { + if m != nil { + return m.TaskID + } + return 0 +} + +type ImportFileStats struct { + ImportFile *ImportFile `protobuf:"bytes,1,opt,name=import_file,json=importFile,proto3" json:"import_file,omitempty"` + FileSize int64 `protobuf:"varint,2,opt,name=file_size,json=fileSize,proto3" json:"file_size,omitempty"` + TotalRows int64 `protobuf:"varint,3,opt,name=total_rows,json=totalRows,proto3" json:"total_rows,omitempty"` + ChannelRows map[string]int64 `protobuf:"bytes,4,rep,name=channel_rows,json=channelRows,proto3" json:"channel_rows,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ImportFileStats) Reset() { *m = ImportFileStats{} } +func (m *ImportFileStats) String() string { return proto.CompactTextString(m) } +func (*ImportFileStats) ProtoMessage() {} +func (*ImportFileStats) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{87} +} + +func (m *ImportFileStats) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ImportFileStats.Unmarshal(m, b) +} +func (m *ImportFileStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ImportFileStats.Marshal(b, m, deterministic) +} +func (m *ImportFileStats) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImportFileStats.Merge(m, src) +} +func (m *ImportFileStats) XXX_Size() int { + return xxx_messageInfo_ImportFileStats.Size(m) +} +func (m *ImportFileStats) XXX_DiscardUnknown() { + xxx_messageInfo_ImportFileStats.DiscardUnknown(m) +} + +var xxx_messageInfo_ImportFileStats proto.InternalMessageInfo + +func (m *ImportFileStats) GetImportFile() *ImportFile { + if m != nil { + return m.ImportFile + } + return nil +} + +func (m *ImportFileStats) GetFileSize() int64 { + if m != nil { + return m.FileSize + } + return 0 +} + +func (m *ImportFileStats) GetTotalRows() int64 { + if m != nil { + return m.TotalRows + } + return 0 +} + +func (m *ImportFileStats) GetChannelRows() map[string]int64 { + if m != nil { + return m.ChannelRows + } + return nil +} + +type QueryPreImportResponse struct { + Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + TaskID int64 `protobuf:"varint,2,opt,name=taskID,proto3" json:"taskID,omitempty"` + State ImportState `protobuf:"varint,3,opt,name=state,proto3,enum=milvus.proto.data.ImportState" json:"state,omitempty"` + Reason string `protobuf:"bytes,4,opt,name=reason,proto3" json:"reason,omitempty"` + Slots int64 `protobuf:"varint,5,opt,name=slots,proto3" json:"slots,omitempty"` + FileStats []*ImportFileStats `protobuf:"bytes,6,rep,name=file_stats,json=fileStats,proto3" json:"file_stats,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QueryPreImportResponse) Reset() { *m = QueryPreImportResponse{} } +func (m *QueryPreImportResponse) String() string { return proto.CompactTextString(m) } +func (*QueryPreImportResponse) ProtoMessage() {} +func (*QueryPreImportResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{88} +} + +func (m *QueryPreImportResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QueryPreImportResponse.Unmarshal(m, b) +} +func (m *QueryPreImportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QueryPreImportResponse.Marshal(b, m, deterministic) +} +func (m *QueryPreImportResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryPreImportResponse.Merge(m, src) +} +func (m *QueryPreImportResponse) XXX_Size() int { + return xxx_messageInfo_QueryPreImportResponse.Size(m) +} +func (m *QueryPreImportResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryPreImportResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryPreImportResponse proto.InternalMessageInfo + +func (m *QueryPreImportResponse) GetStatus() *commonpb.Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *QueryPreImportResponse) GetTaskID() int64 { + if m != nil { + return m.TaskID + } + return 0 +} + +func (m *QueryPreImportResponse) GetState() ImportState { + if m != nil { + return m.State + } + return ImportState_None +} + +func (m *QueryPreImportResponse) GetReason() string { + if m != nil { + return m.Reason + } + return "" +} + +func (m *QueryPreImportResponse) GetSlots() int64 { + if m != nil { + return m.Slots + } + return 0 +} + +func (m *QueryPreImportResponse) GetFileStats() []*ImportFileStats { + if m != nil { + return m.FileStats + } + return nil +} + +type QueryImportRequest struct { + ClusterID string `protobuf:"bytes,1,opt,name=clusterID,proto3" json:"clusterID,omitempty"` + RequestID int64 `protobuf:"varint,2,opt,name=requestID,proto3" json:"requestID,omitempty"` + TaskID int64 `protobuf:"varint,3,opt,name=taskID,proto3" json:"taskID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QueryImportRequest) Reset() { *m = QueryImportRequest{} } +func (m *QueryImportRequest) String() string { return proto.CompactTextString(m) } +func (*QueryImportRequest) ProtoMessage() {} +func (*QueryImportRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{89} +} + +func (m *QueryImportRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QueryImportRequest.Unmarshal(m, b) +} +func (m *QueryImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QueryImportRequest.Marshal(b, m, deterministic) +} +func (m *QueryImportRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryImportRequest.Merge(m, src) +} +func (m *QueryImportRequest) XXX_Size() int { + return xxx_messageInfo_QueryImportRequest.Size(m) +} +func (m *QueryImportRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryImportRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryImportRequest proto.InternalMessageInfo + +func (m *QueryImportRequest) GetClusterID() string { + if m != nil { + return m.ClusterID + } + return "" +} + +func (m *QueryImportRequest) GetRequestID() int64 { + if m != nil { + return m.RequestID + } + return 0 +} + +func (m *QueryImportRequest) GetTaskID() int64 { + if m != nil { + return m.TaskID + } + return 0 +} + +type ImportSegmentInfo struct { + SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"` + TotalRows int64 `protobuf:"varint,2,opt,name=total_rows,json=totalRows,proto3" json:"total_rows,omitempty"` + ImportedRows int64 `protobuf:"varint,3,opt,name=imported_rows,json=importedRows,proto3" json:"imported_rows,omitempty"` + Binlogs []*FieldBinlog `protobuf:"bytes,4,rep,name=binlogs,proto3" json:"binlogs,omitempty"` + Statslogs []*FieldBinlog `protobuf:"bytes,5,rep,name=statslogs,proto3" json:"statslogs,omitempty"` + IndexInfos []*indexpb.IndexFilePathInfo `protobuf:"bytes,6,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ImportSegmentInfo) Reset() { *m = ImportSegmentInfo{} } +func (m *ImportSegmentInfo) String() string { return proto.CompactTextString(m) } +func (*ImportSegmentInfo) ProtoMessage() {} +func (*ImportSegmentInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{90} +} + +func (m *ImportSegmentInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ImportSegmentInfo.Unmarshal(m, b) +} +func (m *ImportSegmentInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ImportSegmentInfo.Marshal(b, m, deterministic) +} +func (m *ImportSegmentInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImportSegmentInfo.Merge(m, src) +} +func (m *ImportSegmentInfo) XXX_Size() int { + return xxx_messageInfo_ImportSegmentInfo.Size(m) +} +func (m *ImportSegmentInfo) XXX_DiscardUnknown() { + xxx_messageInfo_ImportSegmentInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_ImportSegmentInfo proto.InternalMessageInfo + +func (m *ImportSegmentInfo) GetSegmentID() int64 { + if m != nil { + return m.SegmentID + } + return 0 +} + +func (m *ImportSegmentInfo) GetTotalRows() int64 { + if m != nil { + return m.TotalRows + } + return 0 +} + +func (m *ImportSegmentInfo) GetImportedRows() int64 { + if m != nil { + return m.ImportedRows + } + return 0 +} + +func (m *ImportSegmentInfo) GetBinlogs() []*FieldBinlog { + if m != nil { + return m.Binlogs + } + return nil +} + +func (m *ImportSegmentInfo) GetStatslogs() []*FieldBinlog { + if m != nil { + return m.Statslogs + } + return nil +} + +func (m *ImportSegmentInfo) GetIndexInfos() []*indexpb.IndexFilePathInfo { + if m != nil { + return m.IndexInfos + } + return nil +} + +type QueryImportResponse struct { + Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + TaskID int64 `protobuf:"varint,2,opt,name=taskID,proto3" json:"taskID,omitempty"` + State ImportState `protobuf:"varint,3,opt,name=state,proto3,enum=milvus.proto.data.ImportState" json:"state,omitempty"` + Reason string `protobuf:"bytes,4,opt,name=reason,proto3" json:"reason,omitempty"` + Slots int64 `protobuf:"varint,5,opt,name=slots,proto3" json:"slots,omitempty"` + ImportSegmentsInfo []*ImportSegmentInfo `protobuf:"bytes,6,rep,name=import_segments_info,json=importSegmentsInfo,proto3" json:"import_segments_info,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QueryImportResponse) Reset() { *m = QueryImportResponse{} } +func (m *QueryImportResponse) String() string { return proto.CompactTextString(m) } +func (*QueryImportResponse) ProtoMessage() {} +func (*QueryImportResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{91} +} + +func (m *QueryImportResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QueryImportResponse.Unmarshal(m, b) +} +func (m *QueryImportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QueryImportResponse.Marshal(b, m, deterministic) +} +func (m *QueryImportResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryImportResponse.Merge(m, src) +} +func (m *QueryImportResponse) XXX_Size() int { + return xxx_messageInfo_QueryImportResponse.Size(m) +} +func (m *QueryImportResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryImportResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryImportResponse proto.InternalMessageInfo + +func (m *QueryImportResponse) GetStatus() *commonpb.Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *QueryImportResponse) GetTaskID() int64 { + if m != nil { + return m.TaskID + } + return 0 +} + +func (m *QueryImportResponse) GetState() ImportState { + if m != nil { + return m.State + } + return ImportState_None +} + +func (m *QueryImportResponse) GetReason() string { + if m != nil { + return m.Reason + } + return "" +} + +func (m *QueryImportResponse) GetSlots() int64 { + if m != nil { + return m.Slots + } + return 0 +} + +func (m *QueryImportResponse) GetImportSegmentsInfo() []*ImportSegmentInfo { + if m != nil { + return m.ImportSegmentsInfo + } + return nil +} + +type DropImportRequest struct { + ClusterID string `protobuf:"bytes,1,opt,name=clusterID,proto3" json:"clusterID,omitempty"` + RequestID int64 `protobuf:"varint,2,opt,name=requestID,proto3" json:"requestID,omitempty"` + TaskID int64 `protobuf:"varint,3,opt,name=taskID,proto3" json:"taskID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DropImportRequest) Reset() { *m = DropImportRequest{} } +func (m *DropImportRequest) String() string { return proto.CompactTextString(m) } +func (*DropImportRequest) ProtoMessage() {} +func (*DropImportRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{92} +} + +func (m *DropImportRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DropImportRequest.Unmarshal(m, b) +} +func (m *DropImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DropImportRequest.Marshal(b, m, deterministic) +} +func (m *DropImportRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DropImportRequest.Merge(m, src) +} +func (m *DropImportRequest) XXX_Size() int { + return xxx_messageInfo_DropImportRequest.Size(m) +} +func (m *DropImportRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DropImportRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DropImportRequest proto.InternalMessageInfo + +func (m *DropImportRequest) GetClusterID() string { + if m != nil { + return m.ClusterID + } + return "" +} + +func (m *DropImportRequest) GetRequestID() int64 { + if m != nil { + return m.RequestID + } + return 0 +} + +func (m *DropImportRequest) GetTaskID() int64 { + if m != nil { + return m.TaskID + } + return 0 +} + +type PreImportTask struct { + RequestID int64 `protobuf:"varint,1,opt,name=requestID,proto3" json:"requestID,omitempty"` + TaskID int64 `protobuf:"varint,2,opt,name=taskID,proto3" json:"taskID,omitempty"` + CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"` + PartitionID int64 `protobuf:"varint,4,opt,name=partitionID,proto3" json:"partitionID,omitempty"` + NodeID int64 `protobuf:"varint,5,opt,name=nodeID,proto3" json:"nodeID,omitempty"` + State ImportState `protobuf:"varint,6,opt,name=state,proto3,enum=milvus.proto.data.ImportState" json:"state,omitempty"` + Reason string `protobuf:"bytes,7,opt,name=reason,proto3" json:"reason,omitempty"` + FileStats []*ImportFileStats `protobuf:"bytes,8,rep,name=file_stats,json=fileStats,proto3" json:"file_stats,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PreImportTask) Reset() { *m = PreImportTask{} } +func (m *PreImportTask) String() string { return proto.CompactTextString(m) } +func (*PreImportTask) ProtoMessage() {} +func (*PreImportTask) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{93} +} + +func (m *PreImportTask) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PreImportTask.Unmarshal(m, b) +} +func (m *PreImportTask) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PreImportTask.Marshal(b, m, deterministic) +} +func (m *PreImportTask) XXX_Merge(src proto.Message) { + xxx_messageInfo_PreImportTask.Merge(m, src) +} +func (m *PreImportTask) XXX_Size() int { + return xxx_messageInfo_PreImportTask.Size(m) +} +func (m *PreImportTask) XXX_DiscardUnknown() { + xxx_messageInfo_PreImportTask.DiscardUnknown(m) +} + +var xxx_messageInfo_PreImportTask proto.InternalMessageInfo + +func (m *PreImportTask) GetRequestID() int64 { + if m != nil { + return m.RequestID + } + return 0 +} + +func (m *PreImportTask) GetTaskID() int64 { + if m != nil { + return m.TaskID + } + return 0 +} + +func (m *PreImportTask) GetCollectionID() int64 { + if m != nil { + return m.CollectionID + } + return 0 +} + +func (m *PreImportTask) GetPartitionID() int64 { + if m != nil { + return m.PartitionID + } + return 0 +} + +func (m *PreImportTask) GetNodeID() int64 { + if m != nil { + return m.NodeID + } + return 0 +} + +func (m *PreImportTask) GetState() ImportState { + if m != nil { + return m.State + } + return ImportState_None +} + +func (m *PreImportTask) GetReason() string { + if m != nil { + return m.Reason + } + return "" +} + +func (m *PreImportTask) GetFileStats() []*ImportFileStats { + if m != nil { + return m.FileStats + } + return nil +} + +type ImportTaskV2 struct { + RequestID int64 `protobuf:"varint,1,opt,name=requestID,proto3" json:"requestID,omitempty"` + TaskID int64 `protobuf:"varint,2,opt,name=taskID,proto3" json:"taskID,omitempty"` + CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"` + PartitionID int64 `protobuf:"varint,4,opt,name=partitionID,proto3" json:"partitionID,omitempty"` + SegmentIDs []int64 `protobuf:"varint,5,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"` + NodeID int64 `protobuf:"varint,6,opt,name=nodeID,proto3" json:"nodeID,omitempty"` + State ImportState `protobuf:"varint,7,opt,name=state,proto3,enum=milvus.proto.data.ImportState" json:"state,omitempty"` + Reason string `protobuf:"bytes,8,opt,name=reason,proto3" json:"reason,omitempty"` + Files []*ImportFile `protobuf:"bytes,9,rep,name=files,proto3" json:"files,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ImportTaskV2) Reset() { *m = ImportTaskV2{} } +func (m *ImportTaskV2) String() string { return proto.CompactTextString(m) } +func (*ImportTaskV2) ProtoMessage() {} +func (*ImportTaskV2) Descriptor() ([]byte, []int) { + return fileDescriptor_82cd95f524594f49, []int{94} +} + +func (m *ImportTaskV2) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ImportTaskV2.Unmarshal(m, b) +} +func (m *ImportTaskV2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ImportTaskV2.Marshal(b, m, deterministic) +} +func (m *ImportTaskV2) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImportTaskV2.Merge(m, src) +} +func (m *ImportTaskV2) XXX_Size() int { + return xxx_messageInfo_ImportTaskV2.Size(m) +} +func (m *ImportTaskV2) XXX_DiscardUnknown() { + xxx_messageInfo_ImportTaskV2.DiscardUnknown(m) +} + +var xxx_messageInfo_ImportTaskV2 proto.InternalMessageInfo + +func (m *ImportTaskV2) GetRequestID() int64 { + if m != nil { + return m.RequestID + } + return 0 +} + +func (m *ImportTaskV2) GetTaskID() int64 { + if m != nil { + return m.TaskID + } + return 0 +} + +func (m *ImportTaskV2) GetCollectionID() int64 { + if m != nil { + return m.CollectionID + } + return 0 +} + +func (m *ImportTaskV2) GetPartitionID() int64 { + if m != nil { + return m.PartitionID + } + return 0 +} + +func (m *ImportTaskV2) GetSegmentIDs() []int64 { + if m != nil { + return m.SegmentIDs + } + return nil +} + +func (m *ImportTaskV2) GetNodeID() int64 { + if m != nil { + return m.NodeID + } + return 0 +} + +func (m *ImportTaskV2) GetState() ImportState { + if m != nil { + return m.State + } + return ImportState_None +} + +func (m *ImportTaskV2) GetReason() string { + if m != nil { + return m.Reason + } + return "" +} + +func (m *ImportTaskV2) GetFiles() []*ImportFile { + if m != nil { + return m.Files + } + return nil +} + func init() { proto.RegisterEnum("milvus.proto.data.SegmentType", SegmentType_name, SegmentType_value) proto.RegisterEnum("milvus.proto.data.SegmentLevel", SegmentLevel_name, SegmentLevel_value) proto.RegisterEnum("milvus.proto.data.ChannelWatchState", ChannelWatchState_name, ChannelWatchState_value) proto.RegisterEnum("milvus.proto.data.CompactionType", CompactionType_name, CompactionType_value) + proto.RegisterEnum("milvus.proto.data.ImportState", ImportState_name, ImportState_value) proto.RegisterType((*Empty)(nil), "milvus.proto.data.Empty") proto.RegisterType((*FlushRequest)(nil), "milvus.proto.data.FlushRequest") proto.RegisterType((*FlushResponse)(nil), "milvus.proto.data.FlushResponse") @@ -5455,337 +6509,401 @@ func init() { proto.RegisterType((*GetFlushStateRequest)(nil), "milvus.proto.data.GetFlushStateRequest") proto.RegisterType((*ChannelOperationsRequest)(nil), "milvus.proto.data.ChannelOperationsRequest") proto.RegisterType((*ChannelOperationProgressResponse)(nil), "milvus.proto.data.ChannelOperationProgressResponse") + proto.RegisterType((*ColumnBasedFile)(nil), "milvus.proto.data.ColumnBasedFile") + proto.RegisterType((*ImportFile)(nil), "milvus.proto.data.ImportFile") + proto.RegisterType((*PreImportRequest)(nil), "milvus.proto.data.PreImportRequest") + proto.RegisterType((*AutoIDRange)(nil), "milvus.proto.data.autoIDRange") + proto.RegisterType((*ImportRequest)(nil), "milvus.proto.data.ImportRequest") + proto.RegisterMapType((map[int64]*AutoIDRange)(nil), "milvus.proto.data.ImportRequest.AutoIDRangesEntry") + proto.RegisterMapType((map[int64]string)(nil), "milvus.proto.data.ImportRequest.SegmentChannelsEntry") + proto.RegisterType((*QueryPreImportRequest)(nil), "milvus.proto.data.QueryPreImportRequest") + proto.RegisterType((*ImportFileStats)(nil), "milvus.proto.data.ImportFileStats") + proto.RegisterMapType((map[string]int64)(nil), "milvus.proto.data.ImportFileStats.ChannelRowsEntry") + proto.RegisterType((*QueryPreImportResponse)(nil), "milvus.proto.data.QueryPreImportResponse") + proto.RegisterType((*QueryImportRequest)(nil), "milvus.proto.data.QueryImportRequest") + proto.RegisterType((*ImportSegmentInfo)(nil), "milvus.proto.data.ImportSegmentInfo") + proto.RegisterType((*QueryImportResponse)(nil), "milvus.proto.data.QueryImportResponse") + proto.RegisterType((*DropImportRequest)(nil), "milvus.proto.data.DropImportRequest") + proto.RegisterType((*PreImportTask)(nil), "milvus.proto.data.PreImportTask") + proto.RegisterType((*ImportTaskV2)(nil), "milvus.proto.data.ImportTaskV2") } func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) } var fileDescriptor_82cd95f524594f49 = []byte{ - // 5188 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7c, 0x5b, 0x6f, 0x1c, 0x47, - 0x76, 0xb0, 0x7a, 0x6e, 0x9c, 0x39, 0x33, 0x1c, 0x0e, 0x4b, 0x34, 0x35, 0x1a, 0x59, 0x17, 0xb7, - 0x25, 0x8b, 0xd6, 0xda, 0x92, 0x4c, 0x7d, 0x8b, 0xf5, 0x65, 0xed, 0xb5, 0x48, 0x5a, 0xf2, 0x7c, - 0x21, 0x65, 0x6e, 0x93, 0x92, 0x03, 0x6f, 0x80, 0x41, 0x73, 0xba, 0x38, 0x6c, 0xb3, 0xa7, 0x7b, - 0xdc, 0xdd, 0x43, 0x8a, 0x0e, 0x90, 0xf5, 0x26, 0x4e, 0x90, 0x1b, 0x72, 0x41, 0x92, 0x87, 0xbc, - 0x04, 0x41, 0x1e, 0x82, 0xdc, 0xf6, 0x29, 0x09, 0x16, 0x08, 0x02, 0x2c, 0x92, 0x00, 0xc1, 0x06, - 0x79, 0xc8, 0x4b, 0x1e, 0x92, 0x87, 0xfc, 0x81, 0xbc, 0x05, 0xf9, 0x03, 0x41, 0x5d, 0xba, 0xfa, - 0x56, 0x3d, 0xd3, 0xe4, 0x48, 0x36, 0x90, 0x3c, 0x91, 0x5d, 0x7d, 0xaa, 0xea, 0xd4, 0xa9, 0x73, - 0x3f, 0xa7, 0x07, 0x5a, 0x86, 0xee, 0xeb, 0xbd, 0xbe, 0xe3, 0xb8, 0xc6, 0xed, 0x91, 0xeb, 0xf8, - 0x0e, 0x5a, 0x1c, 0x9a, 0xd6, 0xd1, 0xd8, 0x63, 0x4f, 0xb7, 0xc9, 0xeb, 0x4e, 0xa3, 0xef, 0x0c, - 0x87, 0x8e, 0xcd, 0x86, 0x3a, 0x4d, 0xd3, 0xf6, 0xb1, 0x6b, 0xeb, 0x16, 0x7f, 0x6e, 0x44, 0x27, - 0x74, 0x1a, 0x5e, 0xff, 0x00, 0x0f, 0x75, 0xfe, 0x54, 0x1b, 0x7a, 0x03, 0xfe, 0xef, 0xa2, 0x69, - 0x1b, 0xf8, 0x69, 0x74, 0x2b, 0x75, 0x0e, 0xca, 0x1f, 0x0c, 0x47, 0xfe, 0x89, 0xfa, 0x57, 0x0a, - 0x34, 0x1e, 0x58, 0x63, 0xef, 0x40, 0xc3, 0x9f, 0x8d, 0xb1, 0xe7, 0xa3, 0xbb, 0x50, 0xda, 0xd3, - 0x3d, 0xdc, 0x56, 0xae, 0x29, 0x2b, 0xf5, 0xd5, 0x17, 0x6f, 0xc7, 0x70, 0xe2, 0xd8, 0x6c, 0x79, - 0x83, 0x35, 0xdd, 0xc3, 0x1a, 0x85, 0x44, 0x08, 0x4a, 0xc6, 0x5e, 0x77, 0xa3, 0x5d, 0xb8, 0xa6, - 0xac, 0x14, 0x35, 0xfa, 0x3f, 0xba, 0x02, 0xe0, 0xe1, 0xc1, 0x10, 0xdb, 0x7e, 0x77, 0xc3, 0x6b, - 0x17, 0xaf, 0x15, 0x57, 0x8a, 0x5a, 0x64, 0x04, 0xa9, 0xd0, 0xe8, 0x3b, 0x96, 0x85, 0xfb, 0xbe, - 0xe9, 0xd8, 0xdd, 0x8d, 0x76, 0x89, 0xce, 0x8d, 0x8d, 0xa1, 0x0e, 0x54, 0x4d, 0xaf, 0x3b, 0x1c, - 0x39, 0xae, 0xdf, 0x2e, 0x5f, 0x53, 0x56, 0xaa, 0x9a, 0x78, 0x56, 0x7f, 0x50, 0x80, 0x79, 0x8e, - 0xb6, 0x37, 0x72, 0x6c, 0x0f, 0xa3, 0x7b, 0x50, 0xf1, 0x7c, 0xdd, 0x1f, 0x7b, 0x1c, 0xf3, 0x4b, - 0x52, 0xcc, 0x77, 0x28, 0x88, 0xc6, 0x41, 0xa5, 0xa8, 0x27, 0x51, 0x2b, 0x4a, 0x50, 0x8b, 0x1f, - 0xaf, 0x94, 0x3a, 0xde, 0x0a, 0x2c, 0xec, 0x13, 0xec, 0x76, 0x42, 0xa0, 0x32, 0x05, 0x4a, 0x0e, - 0x93, 0x95, 0x7c, 0x73, 0x88, 0x3f, 0xda, 0xdf, 0xc1, 0xba, 0xd5, 0xae, 0xd0, 0xbd, 0x22, 0x23, - 0xe8, 0x22, 0x54, 0xe9, 0x94, 0x9e, 0xef, 0xb5, 0xe7, 0xae, 0x29, 0x2b, 0x25, 0x6d, 0x8e, 0x3e, - 0xef, 0x7a, 0xea, 0xf7, 0x61, 0x89, 0x92, 0x60, 0xfd, 0x40, 0xb7, 0x6d, 0x6c, 0x79, 0x67, 0xbf, - 0xc1, 0xe8, 0x26, 0x85, 0xd8, 0x26, 0xe4, 0x12, 0xfa, 0x7c, 0x7d, 0x7a, 0x8d, 0x35, 0x4d, 0x3c, - 0xab, 0xbf, 0x5c, 0x80, 0x96, 0x38, 0x4a, 0xb0, 0xfb, 0x12, 0x94, 0xfb, 0xce, 0xd8, 0xf6, 0xe9, - 0xf6, 0xf3, 0x1a, 0x7b, 0x40, 0x2f, 0x41, 0x83, 0x4f, 0xeb, 0xd9, 0xfa, 0x10, 0xd3, 0x5d, 0x6a, - 0x5a, 0x9d, 0x8f, 0x3d, 0xd2, 0x87, 0x38, 0x17, 0xdd, 0xaf, 0x41, 0x7d, 0xa4, 0xbb, 0xbe, 0x19, - 0xe3, 0x9a, 0xe8, 0xd0, 0x24, 0xa6, 0x21, 0x3b, 0x98, 0xf4, 0xbf, 0x5d, 0xdd, 0x3b, 0xec, 0x6e, - 0x70, 0x6a, 0xc7, 0xc6, 0xd0, 0x37, 0xa1, 0x6c, 0xe1, 0x23, 0x6c, 0x51, 0x62, 0x37, 0x57, 0xaf, - 0xde, 0x4e, 0xc9, 0xe4, 0x6d, 0x7e, 0xe4, 0x4d, 0x02, 0xa6, 0x31, 0x68, 0xf5, 0x0f, 0x15, 0x58, - 0xbe, 0xef, 0x79, 0xe6, 0xc0, 0x4e, 0x11, 0x64, 0x19, 0x2a, 0xb6, 0x63, 0xe0, 0xee, 0x06, 0xa5, - 0x48, 0x51, 0xe3, 0x4f, 0xe8, 0x12, 0xd4, 0x46, 0x18, 0xbb, 0x3d, 0xd7, 0xb1, 0x02, 0x7a, 0x54, - 0xc9, 0x80, 0xe6, 0x58, 0x18, 0x7d, 0x17, 0x16, 0xbd, 0xc4, 0x42, 0x8c, 0xfe, 0xf5, 0xd5, 0x97, - 0xb3, 0x51, 0x12, 0xb0, 0x5a, 0x7a, 0xb6, 0xfa, 0x45, 0x01, 0xce, 0x0b, 0x38, 0x86, 0x2b, 0xf9, - 0x9f, 0x5c, 0x98, 0x87, 0x07, 0x02, 0x3d, 0xf6, 0x90, 0xe7, 0xc2, 0xc4, 0x4d, 0x17, 0xa3, 0x37, - 0x9d, 0x47, 0xb2, 0x13, 0xd7, 0x58, 0x4e, 0x5f, 0xe3, 0x55, 0xa8, 0xe3, 0xa7, 0x23, 0xd3, 0xc5, - 0x3d, 0x22, 0x0b, 0xf4, 0xa6, 0x4a, 0x1a, 0xb0, 0xa1, 0x5d, 0x73, 0x18, 0x15, 0xf7, 0xb9, 0xdc, - 0xe2, 0xae, 0xfe, 0x91, 0x02, 0x17, 0x52, 0xb7, 0xc4, 0xf5, 0x87, 0x06, 0x2d, 0x7a, 0xf2, 0x90, - 0x32, 0x44, 0x93, 0x10, 0x82, 0xbf, 0x32, 0x89, 0xe0, 0x21, 0xb8, 0x96, 0x9a, 0x1f, 0x41, 0xb2, - 0x90, 0x1f, 0xc9, 0x43, 0xb8, 0xf0, 0x10, 0xfb, 0x7c, 0x03, 0xf2, 0x0e, 0xcf, 0x20, 0xd9, 0x71, - 0x45, 0x55, 0x48, 0x2a, 0x2a, 0xf5, 0x8f, 0x43, 0x11, 0xa6, 0x5b, 0x75, 0xed, 0x7d, 0x07, 0xbd, - 0x08, 0x35, 0x01, 0xc2, 0xb9, 0x22, 0x1c, 0x40, 0xdf, 0x82, 0x32, 0xc1, 0x94, 0xb1, 0x44, 0x73, - 0xf5, 0x25, 0xf9, 0x99, 0x22, 0x6b, 0x6a, 0x0c, 0x1e, 0x6d, 0x40, 0xd3, 0xf3, 0x75, 0xd7, 0xef, - 0x8d, 0x1c, 0x8f, 0xde, 0x33, 0x65, 0x9c, 0xfa, 0xea, 0xe5, 0xf8, 0x0a, 0xc4, 0x6e, 0x6d, 0x79, - 0x83, 0x6d, 0x0e, 0xa4, 0xcd, 0xd3, 0x49, 0xc1, 0x23, 0x7a, 0x1f, 0x1a, 0xd8, 0x36, 0xc2, 0x35, - 0x4a, 0x79, 0xd6, 0xa8, 0x63, 0xdb, 0x10, 0x2b, 0x84, 0xb7, 0x52, 0xce, 0x7f, 0x2b, 0xbf, 0xae, - 0x40, 0x3b, 0x7d, 0x2d, 0xb3, 0xd8, 0x9e, 0x77, 0xd8, 0x24, 0xcc, 0xae, 0x65, 0xa2, 0x5c, 0x8b, - 0xab, 0xd1, 0xf8, 0x14, 0xf5, 0xf7, 0x14, 0x78, 0x21, 0x44, 0x87, 0xbe, 0x7a, 0x5e, 0x3c, 0x82, - 0x6e, 0x41, 0xcb, 0xb4, 0xfb, 0xd6, 0xd8, 0xc0, 0x8f, 0xed, 0x0f, 0xb1, 0x6e, 0xf9, 0x07, 0x27, - 0xf4, 0xe6, 0xaa, 0x5a, 0x6a, 0x5c, 0xfd, 0xf7, 0x02, 0x2c, 0x27, 0xf1, 0x9a, 0x85, 0x48, 0xff, - 0x0f, 0xca, 0xa6, 0xbd, 0xef, 0x04, 0x34, 0xba, 0x32, 0x41, 0x14, 0xc9, 0x5e, 0x0c, 0x18, 0x39, - 0x80, 0x02, 0xe5, 0xd5, 0x3f, 0xc0, 0xfd, 0xc3, 0x91, 0x63, 0x52, 0x35, 0x45, 0x96, 0x78, 0x5f, - 0xb2, 0x84, 0x1c, 0xe3, 0xdb, 0xdc, 0xb0, 0xae, 0x8b, 0x25, 0x3e, 0xb0, 0x7d, 0xf7, 0x44, 0x5b, - 0xec, 0x27, 0xc7, 0x3b, 0x7d, 0x58, 0x96, 0x03, 0xa3, 0x16, 0x14, 0x0f, 0xf1, 0x09, 0x3d, 0x72, - 0x4d, 0x23, 0xff, 0xa2, 0x7b, 0x50, 0x3e, 0xd2, 0xad, 0x31, 0xe6, 0x3a, 0x61, 0x0a, 0xe7, 0x32, - 0xd8, 0xb7, 0x0b, 0x6f, 0x2a, 0xea, 0x10, 0x2e, 0x3d, 0xc4, 0x7e, 0xd7, 0xf6, 0xb0, 0xeb, 0xaf, - 0x99, 0xb6, 0xe5, 0x0c, 0xb6, 0x75, 0xff, 0x60, 0x06, 0xe5, 0x10, 0x93, 0xf3, 0x42, 0x42, 0xce, - 0xd5, 0x3f, 0x51, 0xe0, 0x45, 0xf9, 0x7e, 0xfc, 0x42, 0x3b, 0x50, 0xdd, 0x37, 0xb1, 0x65, 0x10, - 0xae, 0x51, 0x28, 0xd7, 0x88, 0x67, 0xa2, 0x24, 0x46, 0x04, 0x98, 0xdf, 0x5b, 0x42, 0x49, 0x08, - 0x37, 0x76, 0xc7, 0x77, 0x4d, 0x7b, 0xb0, 0x69, 0x7a, 0xbe, 0xc6, 0xe0, 0x23, 0x5c, 0x52, 0xcc, - 0x2f, 0x9c, 0xbf, 0xaa, 0xc0, 0x95, 0x87, 0xd8, 0x5f, 0x17, 0x36, 0x86, 0xbc, 0x37, 0x3d, 0xdf, - 0xec, 0x7b, 0xcf, 0xd6, 0xad, 0xcd, 0xe1, 0xa3, 0xa8, 0xbf, 0xa9, 0xc0, 0xd5, 0x4c, 0x64, 0x38, - 0xe9, 0xb8, 0x0e, 0x0d, 0x2c, 0x8c, 0x5c, 0x87, 0xfe, 0x14, 0x3e, 0x79, 0x42, 0x2e, 0x7f, 0x5b, - 0x37, 0x5d, 0xa6, 0x43, 0xcf, 0x68, 0x51, 0x7e, 0xa8, 0xc0, 0xe5, 0x87, 0xd8, 0xdf, 0x0e, 0xec, - 0xeb, 0xd7, 0x48, 0x1d, 0x02, 0x13, 0xb1, 0xf3, 0x81, 0xef, 0x1c, 0x1b, 0x53, 0x7f, 0x83, 0x5d, - 0xa7, 0x14, 0xdf, 0xaf, 0x85, 0x80, 0x57, 0xa8, 0x24, 0x44, 0x54, 0x04, 0x17, 0x76, 0x4e, 0x3e, - 0xf5, 0xcb, 0x32, 0x34, 0x9e, 0x70, 0xad, 0x40, 0x2d, 0x68, 0x92, 0x12, 0x8a, 0xdc, 0x09, 0x8a, - 0x78, 0x53, 0x32, 0x07, 0x6b, 0x0d, 0xe6, 0x3d, 0x8c, 0x0f, 0x4f, 0x69, 0x2f, 0x1b, 0x64, 0x8e, - 0x30, 0x76, 0x9b, 0xb0, 0x38, 0xb6, 0xa9, 0x33, 0x8f, 0x0d, 0x7e, 0x00, 0x46, 0xf4, 0xe9, 0xca, - 0x34, 0x3d, 0x11, 0x7d, 0xc8, 0xe3, 0x9a, 0xc8, 0x5a, 0xe5, 0x5c, 0x6b, 0x25, 0xa7, 0xa1, 0x2e, - 0xb4, 0x0c, 0xd7, 0x19, 0x8d, 0xb0, 0xd1, 0xf3, 0x82, 0xa5, 0x2a, 0xf9, 0x96, 0xe2, 0xf3, 0xc4, - 0x52, 0x77, 0xe1, 0x7c, 0x12, 0xd3, 0xae, 0x41, 0xfc, 0x42, 0xc2, 0x59, 0xb2, 0x57, 0xe8, 0x35, - 0x58, 0x4c, 0xc3, 0x57, 0x29, 0x7c, 0xfa, 0x05, 0x7a, 0x1d, 0x50, 0x02, 0x55, 0x02, 0x5e, 0x63, - 0xe0, 0x71, 0x64, 0x38, 0x38, 0x8d, 0xb7, 0xe3, 0xe0, 0xc0, 0xc0, 0xf9, 0x9b, 0x08, 0x78, 0x97, - 0x58, 0xd7, 0x18, 0xb8, 0xd7, 0xae, 0xe7, 0x23, 0x44, 0x7c, 0x31, 0x4f, 0xfd, 0x15, 0x05, 0x96, - 0x3f, 0xd6, 0xfd, 0xfe, 0xc1, 0xc6, 0x70, 0xf6, 0x98, 0xf0, 0x5d, 0xa8, 0x1d, 0x89, 0xc8, 0x8f, - 0x69, 0x71, 0x59, 0x30, 0x14, 0x65, 0x7b, 0x2d, 0x9c, 0xa1, 0xfe, 0xbd, 0xc2, 0xa3, 0xd3, 0x00, - 0xbb, 0xaf, 0x5e, 0xd5, 0x4c, 0x0b, 0xd2, 0x13, 0x02, 0x58, 0x4e, 0x09, 0xa0, 0xfa, 0x14, 0x80, - 0xa3, 0xbf, 0xe5, 0x0d, 0xce, 0x80, 0xf9, 0x9b, 0x30, 0xc7, 0xf7, 0xe3, 0xda, 0x66, 0xda, 0x95, - 0x06, 0xe0, 0xea, 0x1f, 0xcc, 0x41, 0x3d, 0xf2, 0x02, 0x35, 0xa1, 0x20, 0xd4, 0x48, 0x41, 0x72, - 0xfe, 0xc2, 0xf4, 0x28, 0xab, 0x98, 0x8e, 0xb2, 0x6e, 0x40, 0xd3, 0xa4, 0xe6, 0xbd, 0xc7, 0x4f, - 0x4d, 0xbd, 0xe9, 0x9a, 0x36, 0xcf, 0x46, 0x39, 0x13, 0xa1, 0x2b, 0x50, 0xb7, 0xc7, 0xc3, 0x9e, - 0xb3, 0xdf, 0x73, 0x9d, 0x63, 0x8f, 0x87, 0x6b, 0x35, 0x7b, 0x3c, 0xfc, 0x68, 0x5f, 0x73, 0x8e, - 0xbd, 0x30, 0x22, 0xa8, 0x9c, 0x32, 0x22, 0xb8, 0x02, 0xf5, 0xa1, 0xfe, 0x94, 0xac, 0xda, 0xb3, - 0xc7, 0x43, 0x1a, 0xc9, 0x15, 0xb5, 0xda, 0x50, 0x7f, 0xaa, 0x39, 0xc7, 0x8f, 0xc6, 0x43, 0xb4, - 0x02, 0x2d, 0x4b, 0xf7, 0xfc, 0x5e, 0x34, 0x14, 0xac, 0xd2, 0x50, 0xb0, 0x49, 0xc6, 0x3f, 0x08, - 0xc3, 0xc1, 0x74, 0x6c, 0x51, 0x3b, 0x5b, 0x6c, 0x61, 0x0c, 0xad, 0x70, 0x0d, 0xc8, 0x15, 0x5b, - 0x18, 0x43, 0x4b, 0xac, 0xf0, 0x26, 0xcc, 0xed, 0x51, 0x57, 0x69, 0x92, 0x10, 0x3f, 0x20, 0x5e, - 0x12, 0xf3, 0xa8, 0xb4, 0x00, 0x1c, 0x7d, 0x1b, 0x6a, 0xd4, 0x42, 0xd1, 0xb9, 0x8d, 0x5c, 0x73, - 0xc3, 0x09, 0x64, 0xb6, 0x81, 0x2d, 0x5f, 0xa7, 0xb3, 0xe7, 0xf3, 0xcd, 0x16, 0x13, 0x88, 0x06, - 0xed, 0xbb, 0x58, 0xf7, 0xb1, 0xb1, 0x76, 0xb2, 0xee, 0x0c, 0x47, 0x3a, 0x65, 0xa1, 0x76, 0x93, - 0x3a, 0xf9, 0xb2, 0x57, 0xe8, 0x15, 0x68, 0xf6, 0xc5, 0xd3, 0x03, 0xd7, 0x19, 0xb6, 0x17, 0xa8, - 0x7c, 0x25, 0x46, 0xd1, 0x65, 0x80, 0x40, 0x77, 0xea, 0x7e, 0xbb, 0x45, 0xef, 0xae, 0xc6, 0x47, - 0xee, 0xd3, 0xb4, 0x90, 0xe9, 0xf5, 0x58, 0x02, 0xc6, 0xb4, 0x07, 0xed, 0x45, 0xba, 0x63, 0x3d, - 0xc8, 0xd8, 0x98, 0xf6, 0x00, 0x5d, 0x80, 0x39, 0xd3, 0xeb, 0xed, 0xeb, 0x87, 0xb8, 0x8d, 0xe8, - 0xdb, 0x8a, 0xe9, 0x3d, 0xd0, 0x0f, 0xa9, 0xf7, 0xca, 0x37, 0xc3, 0x46, 0xfb, 0x3c, 0x7d, 0x15, - 0x0e, 0x84, 0x79, 0x9c, 0xa5, 0xd3, 0xe4, 0x71, 0xd0, 0x4d, 0x58, 0xf0, 0x7c, 0xc7, 0xd5, 0x07, - 0xb8, 0x77, 0x84, 0x5d, 0x8f, 0x50, 0xe1, 0x05, 0xca, 0x95, 0x4d, 0x3e, 0xfc, 0x84, 0x8d, 0xaa, - 0x9f, 0xc3, 0x52, 0xc8, 0xd1, 0x11, 0x16, 0x4a, 0x33, 0xa2, 0x72, 0x06, 0x46, 0x9c, 0xec, 0x99, - 0xff, 0x57, 0x19, 0x96, 0x77, 0xf4, 0x23, 0xfc, 0xfc, 0x83, 0x80, 0x5c, 0x7a, 0x76, 0x13, 0x16, - 0xa9, 0xdf, 0xbf, 0x1a, 0xc1, 0x67, 0x82, 0x8b, 0x11, 0xe5, 0xc1, 0xf4, 0x44, 0xf4, 0x1d, 0xa2, - 0x95, 0x71, 0xff, 0x70, 0x9b, 0xc4, 0x50, 0x81, 0x7b, 0x71, 0x59, 0xb2, 0xce, 0xba, 0x80, 0xd2, - 0xa2, 0x33, 0xd0, 0x36, 0xb9, 0xc2, 0xe8, 0x0d, 0x04, 0x8e, 0xc5, 0xcd, 0x89, 0x01, 0x76, 0x48, - 0x7d, 0xad, 0x19, 0xbb, 0x0c, 0x0f, 0xb5, 0x61, 0x8e, 0x7b, 0x05, 0x54, 0x45, 0x55, 0xb5, 0xe0, - 0x11, 0x6d, 0xc3, 0x79, 0x76, 0x82, 0x1d, 0x2e, 0x89, 0xec, 0xf0, 0xd5, 0x5c, 0x87, 0x97, 0x4d, - 0x8d, 0x0b, 0x72, 0xed, 0xb4, 0x82, 0xdc, 0x86, 0x39, 0x2e, 0x5c, 0x54, 0x77, 0x55, 0xb5, 0xe0, - 0x91, 0x5c, 0x73, 0x28, 0x66, 0x75, 0x26, 0x2d, 0x62, 0x80, 0xcc, 0x0b, 0x2c, 0x40, 0x83, 0x5a, - 0x80, 0xe0, 0x91, 0xaa, 0x25, 0x3c, 0xe8, 0x31, 0x59, 0x9a, 0xcf, 0x27, 0x4b, 0x55, 0x0f, 0x0f, - 0xe8, 0x7f, 0x49, 0x13, 0xd4, 0x4c, 0x9b, 0xa0, 0x57, 0x20, 0x21, 0x59, 0xed, 0x05, 0xa9, 0xbc, - 0xfd, 0xa2, 0x02, 0x10, 0xde, 0xf8, 0x94, 0x14, 0xd5, 0x5b, 0x50, 0x15, 0xe2, 0x97, 0x2b, 0xca, - 0x16, 0xe0, 0x49, 0x5b, 0x57, 0x4c, 0xd8, 0x3a, 0xf5, 0x9f, 0x15, 0x68, 0x6c, 0x10, 0x7a, 0x6f, - 0x3a, 0x03, 0x6a, 0x99, 0x6f, 0x40, 0xd3, 0xc5, 0x7d, 0xc7, 0x35, 0x7a, 0xd8, 0xf6, 0x5d, 0x13, - 0xb3, 0xf4, 0x46, 0x49, 0x9b, 0x67, 0xa3, 0x1f, 0xb0, 0x41, 0x02, 0x46, 0xcc, 0x97, 0xe7, 0xeb, - 0xc3, 0x51, 0x6f, 0x9f, 0x28, 0x4c, 0x96, 0x68, 0x9f, 0x17, 0xa3, 0x54, 0x5f, 0xbe, 0x04, 0x8d, - 0x10, 0xcc, 0x77, 0xe8, 0xfe, 0x25, 0xad, 0x2e, 0xc6, 0x76, 0x1d, 0x74, 0x1d, 0x9a, 0xf4, 0xc2, - 0x7b, 0x96, 0x33, 0xe8, 0x91, 0xa0, 0x99, 0x1b, 0xed, 0x86, 0xc1, 0xd1, 0x22, 0x8c, 0x14, 0x87, - 0xf2, 0xcc, 0xcf, 0x31, 0x37, 0xdb, 0x02, 0x6a, 0xc7, 0xfc, 0x1c, 0xab, 0xbf, 0xa0, 0xc0, 0x3c, - 0xb7, 0xf2, 0x3b, 0xa2, 0x22, 0x42, 0xf3, 0xbd, 0x2c, 0x61, 0x41, 0xff, 0x47, 0x6f, 0xc7, 0x33, - 0x7e, 0xd7, 0xa5, 0xc2, 0x48, 0x17, 0xa1, 0xde, 0x67, 0xcc, 0xc4, 0xe7, 0x89, 0x98, 0xbf, 0x20, - 0x34, 0xd5, 0x7d, 0xfd, 0x91, 0x63, 0xb0, 0x04, 0x64, 0x1b, 0xe6, 0x74, 0xc3, 0x70, 0xb1, 0xe7, - 0x71, 0x3c, 0x82, 0x47, 0xf2, 0x26, 0xd0, 0xcb, 0x4c, 0x57, 0x05, 0x8f, 0xe8, 0xdb, 0x89, 0x42, - 0x45, 0x7d, 0xf5, 0x5a, 0x36, 0x9e, 0x3c, 0xbe, 0x0b, 0x4b, 0x19, 0x7f, 0x5d, 0x80, 0x26, 0xe7, - 0xe1, 0x35, 0x6e, 0x90, 0x27, 0xb3, 0xd8, 0x1a, 0x34, 0xf6, 0x43, 0x19, 0x9c, 0x94, 0x9f, 0x8a, - 0x8a, 0x6a, 0x6c, 0xce, 0x34, 0x5e, 0x8b, 0xbb, 0x04, 0xa5, 0x99, 0x5c, 0x82, 0xf2, 0x69, 0x35, - 0x49, 0xda, 0x35, 0xac, 0x48, 0x5c, 0x43, 0xf5, 0x67, 0xa0, 0x1e, 0x59, 0x80, 0x6a, 0x4a, 0x96, - 0x02, 0xe2, 0x14, 0x0b, 0x1e, 0xd1, 0xbd, 0xd0, 0x31, 0x62, 0xa4, 0xba, 0x28, 0xc1, 0x25, 0xe1, - 0x13, 0xa9, 0x3f, 0x56, 0xa0, 0xc2, 0x57, 0xbe, 0x0a, 0x75, 0x2e, 0x5f, 0xd4, 0x55, 0x64, 0xab, - 0x03, 0x1f, 0x22, 0xbe, 0xe2, 0xb3, 0x13, 0xb0, 0x8b, 0x50, 0x4d, 0x88, 0xd6, 0x1c, 0x57, 0xcf, - 0xc1, 0xab, 0x88, 0x3c, 0x91, 0x57, 0x44, 0x94, 0xd0, 0x12, 0x94, 0x2d, 0x67, 0x20, 0xaa, 0x4a, - 0xec, 0x41, 0xfd, 0x89, 0x42, 0xb3, 0xf9, 0x1a, 0xee, 0x3b, 0x47, 0xd8, 0x3d, 0x99, 0x3d, 0x21, - 0xfa, 0x4e, 0x84, 0xcd, 0x73, 0x46, 0x65, 0x62, 0x02, 0x7a, 0x27, 0xbc, 0x84, 0xa2, 0x2c, 0x6f, - 0x12, 0x55, 0xe5, 0x9c, 0x49, 0xc3, 0xcb, 0xf8, 0x2d, 0x85, 0xa6, 0x76, 0xe3, 0x47, 0x39, 0xab, - 0xd7, 0xf1, 0x4c, 0xe2, 0x17, 0xf5, 0x9f, 0x14, 0xb8, 0x98, 0x41, 0xdd, 0x27, 0xab, 0x5f, 0x03, - 0x7d, 0xdf, 0x86, 0xaa, 0x88, 0xe1, 0x8b, 0xb9, 0x62, 0x78, 0x01, 0xaf, 0xfe, 0x2e, 0x2b, 0x30, - 0x48, 0xc8, 0xfb, 0x64, 0xf5, 0x39, 0x11, 0x38, 0x99, 0x8b, 0x2b, 0x4a, 0x72, 0x71, 0xff, 0xa2, - 0x40, 0x27, 0xcc, 0x7d, 0x79, 0x6b, 0x27, 0xb3, 0x56, 0xa4, 0x9e, 0x4d, 0xe4, 0xfa, 0x96, 0x28, - 0x9e, 0x10, 0xbd, 0x98, 0x2b, 0xe6, 0x0c, 0x4a, 0x27, 0x36, 0x4d, 0xa3, 0xa7, 0x0f, 0x34, 0x8b, - 0x54, 0x76, 0x22, 0x17, 0xcf, 0x0a, 0x28, 0xe1, 0xc5, 0xfe, 0x98, 0x31, 0xe9, 0x83, 0x78, 0x02, - 0xec, 0xeb, 0x26, 0x60, 0xb4, 0xa8, 0x73, 0xc0, 0x8b, 0x3a, 0xa5, 0x44, 0x51, 0x87, 0x8f, 0xab, - 0x43, 0xca, 0x02, 0xa9, 0x03, 0x3c, 0x2f, 0x82, 0xfd, 0x92, 0x02, 0x6d, 0xbe, 0x0b, 0xeb, 0x6f, - 0x70, 0x86, 0x23, 0x0b, 0xfb, 0xd8, 0xf8, 0xaa, 0x93, 0x30, 0x7f, 0x51, 0x80, 0x56, 0xd4, 0xb1, - 0xa1, 0xbe, 0xc9, 0x37, 0xa1, 0x4c, 0xb3, 0x5c, 0x1c, 0x83, 0xa9, 0xda, 0x81, 0x41, 0x13, 0xcb, - 0x48, 0xa3, 0x8a, 0x5d, 0x2f, 0x70, 0x5c, 0xf8, 0x63, 0xe8, 0x5d, 0x15, 0x4f, 0xef, 0x5d, 0xbd, - 0x08, 0x35, 0x62, 0xb9, 0x9c, 0x31, 0x59, 0x97, 0x55, 0xda, 0xc3, 0x01, 0xf4, 0x2e, 0x54, 0x58, - 0x4b, 0x10, 0x2f, 0x74, 0xde, 0x88, 0x2f, 0xcd, 0xdb, 0x85, 0x22, 0x85, 0x0a, 0x3a, 0xa0, 0xf1, - 0x49, 0xe4, 0x8e, 0x46, 0xae, 0x33, 0xa0, 0x6e, 0x18, 0x31, 0x6a, 0x65, 0x4d, 0x3c, 0x13, 0x37, - 0xd1, 0x19, 0x75, 0x37, 0x78, 0xca, 0x86, 0xfe, 0xaf, 0xfe, 0x7f, 0x58, 0x0e, 0x33, 0x04, 0x0c, - 0xcd, 0xb3, 0x32, 0xb9, 0xfa, 0x77, 0x05, 0x38, 0xbf, 0x73, 0x62, 0xf7, 0x93, 0xe2, 0xb2, 0x0c, - 0x95, 0x91, 0xa5, 0x87, 0x29, 0x75, 0xfe, 0x44, 0xdb, 0x15, 0x82, 0xd8, 0x9f, 0x98, 0x75, 0x46, - 0xe3, 0xba, 0x18, 0xdb, 0x75, 0xa6, 0x7a, 0x5b, 0x37, 0x44, 0x4a, 0x03, 0x1b, 0xcc, 0x81, 0x60, - 0x29, 0xc3, 0x79, 0x31, 0x4a, 0x1d, 0x88, 0x77, 0x01, 0xa8, 0x8f, 0xd5, 0x3b, 0x8d, 0x5f, 0x45, - 0x67, 0x6c, 0x12, 0xbf, 0x2a, 0xd9, 0x57, 0x51, 0x49, 0xa7, 0xfd, 0x5f, 0x8a, 0xa8, 0xe5, 0x9e, - 0x69, 0x70, 0x1a, 0x47, 0xa4, 0xd7, 0x40, 0x2f, 0xc3, 0x7c, 0x28, 0xef, 0x04, 0xa6, 0x9a, 0x52, - 0x02, 0x86, 0xfa, 0x9f, 0x05, 0x68, 0x47, 0x2e, 0xe4, 0xab, 0xf6, 0x6e, 0x33, 0x62, 0xe3, 0xe2, - 0x33, 0x8a, 0x8d, 0x4b, 0xb3, 0x7b, 0xb4, 0x65, 0x59, 0xb2, 0x53, 0x24, 0x8e, 0x2a, 0xa7, 0x6a, - 0x00, 0xfa, 0x41, 0x11, 0x9a, 0x21, 0xb1, 0xb7, 0x2d, 0xdd, 0xce, 0xe4, 0xd5, 0x1d, 0x68, 0x7a, - 0xb1, 0xcb, 0xe0, 0xe4, 0xfd, 0x86, 0x4c, 0xf2, 0x33, 0xee, 0x4f, 0x4b, 0x2c, 0x81, 0x2e, 0x53, - 0xb6, 0x74, 0x7d, 0x96, 0x24, 0x65, 0x5e, 0x6d, 0x8d, 0xa9, 0x18, 0x73, 0x88, 0xd1, 0x6b, 0x80, - 0xb8, 0x5e, 0xe8, 0x99, 0x76, 0xcf, 0xc3, 0x7d, 0xc7, 0x36, 0x98, 0xc6, 0x28, 0x6b, 0x2d, 0xfe, - 0xa6, 0x6b, 0xef, 0xb0, 0x71, 0xf4, 0x4d, 0x28, 0xf9, 0x27, 0x23, 0xe6, 0xe2, 0x36, 0xa5, 0x4e, - 0x62, 0x88, 0xd7, 0xee, 0xc9, 0x08, 0x6b, 0x14, 0x3c, 0xe8, 0x65, 0xf3, 0x5d, 0x3d, 0xa0, 0x5f, - 0x49, 0x8b, 0x8c, 0x44, 0xb3, 0x0c, 0x73, 0xf1, 0x2c, 0x03, 0x95, 0x3d, 0xc1, 0xcf, 0xbe, 0x6f, - 0x71, 0x86, 0x8e, 0x70, 0xf9, 0xae, 0x6f, 0x91, 0x43, 0xfa, 0x8e, 0xaf, 0x5b, 0x4c, 0x82, 0x6b, - 0x5c, 0xdf, 0x91, 0x11, 0x1a, 0x9b, 0xff, 0x6b, 0x01, 0x16, 0x53, 0x04, 0xcb, 0xbc, 0x86, 0xc9, - 0x89, 0xaf, 0x69, 0xda, 0xe2, 0x3b, 0x50, 0xe7, 0xdc, 0x74, 0x0a, 0x6e, 0x04, 0x36, 0x65, 0x73, - 0x82, 0x78, 0x94, 0x9f, 0x91, 0x78, 0x54, 0xce, 0x90, 0x3a, 0x92, 0x5f, 0x8e, 0xfa, 0x8f, 0x0a, - 0x2c, 0xc5, 0x59, 0x5b, 0xc3, 0xde, 0xd8, 0xca, 0xa6, 0xec, 0xe4, 0x7c, 0x01, 0xd7, 0xf7, 0x49, - 0x53, 0xc1, 0x2d, 0xda, 0xfb, 0x29, 0x17, 0xfa, 0x7a, 0x1e, 0xb1, 0x08, 0xdd, 0x87, 0xe8, 0x41, - 0x4a, 0xf1, 0x83, 0xfc, 0xb6, 0x02, 0x17, 0x52, 0x16, 0x6a, 0x16, 0x2f, 0xe6, 0x3e, 0xcc, 0xb9, - 0x94, 0x14, 0x81, 0x08, 0xdf, 0x9c, 0x88, 0x6b, 0x48, 0x3a, 0x2d, 0x98, 0xa7, 0xee, 0xc0, 0x72, - 0xe0, 0xeb, 0x84, 0xf7, 0xb2, 0x85, 0x7d, 0x7d, 0x42, 0x2c, 0x7d, 0x15, 0xea, 0x2c, 0x28, 0x63, - 0x31, 0x2a, 0xab, 0x1c, 0xc3, 0x9e, 0x48, 0xa2, 0xaa, 0xbf, 0x53, 0x80, 0x25, 0xea, 0x2c, 0x24, - 0xcb, 0x80, 0x79, 0xea, 0xd2, 0xaa, 0xb0, 0x50, 0xc4, 0x1a, 0xb1, 0x93, 0xd5, 0xb4, 0xd8, 0x18, - 0xea, 0xa6, 0x73, 0xac, 0xd2, 0x9c, 0x4b, 0x58, 0x88, 0xdf, 0xd0, 0x7d, 0x9d, 0xd6, 0xe1, 0x93, - 0xc9, 0xd5, 0xd0, 0x49, 0x29, 0x9d, 0xc5, 0x49, 0x79, 0x15, 0x5a, 0xac, 0x3e, 0xd1, 0x13, 0x21, - 0x3c, 0x55, 0x5b, 0x25, 0x6d, 0x81, 0x8d, 0xef, 0x06, 0xc3, 0xea, 0x26, 0xbc, 0x90, 0x20, 0xca, - 0x0c, 0x77, 0xaf, 0xfe, 0xa9, 0x42, 0x6e, 0x2e, 0xd6, 0x10, 0x76, 0x76, 0x9f, 0xfe, 0xb2, 0x28, - 0x55, 0x12, 0x63, 0x9e, 0x50, 0x46, 0x06, 0x7a, 0x0f, 0x6a, 0x36, 0x3e, 0xee, 0x45, 0xdd, 0xc4, - 0x1c, 0x01, 0x4f, 0xd5, 0xc6, 0xc7, 0xf4, 0x3f, 0xf5, 0x11, 0x5c, 0x48, 0xa1, 0x3a, 0xcb, 0xd9, - 0xff, 0x46, 0x81, 0x8b, 0x1b, 0xae, 0x33, 0x7a, 0x62, 0xba, 0xfe, 0x58, 0xb7, 0xe2, 0xdd, 0x10, - 0x67, 0x38, 0x7e, 0x8e, 0x66, 0xd3, 0x0f, 0x53, 0x7a, 0xe1, 0x35, 0x89, 0xac, 0xa5, 0x91, 0x4a, - 0xe9, 0x07, 0xf5, 0x3f, 0x8a, 0x32, 0xe4, 0x03, 0x6b, 0x31, 0xd9, 0x2f, 0xca, 0x13, 0x7b, 0x49, - 0xcb, 0x21, 0xc5, 0xb3, 0x96, 0x43, 0x32, 0xcc, 0x44, 0xe9, 0x19, 0x99, 0x89, 0x53, 0xe7, 0x05, - 0xd7, 0x21, 0x5e, 0xaa, 0xa2, 0x66, 0xfe, 0xb4, 0xe5, 0xad, 0x77, 0x01, 0xc2, 0x8a, 0x0d, 0x6f, - 0xe0, 0x9d, 0xb2, 0x42, 0x64, 0x02, 0xb9, 0x23, 0x61, 0x88, 0xb9, 0xa3, 0x10, 0xc9, 0xd0, 0x7f, - 0x17, 0x3a, 0x32, 0xde, 0x9c, 0x85, 0xdf, 0xff, 0xad, 0x00, 0xd0, 0x15, 0x5d, 0xe2, 0x67, 0xb3, - 0x15, 0x29, 0x97, 0x3d, 0xcd, 0x3b, 0x46, 0xca, 0xf5, 0x2f, 0xca, 0x5d, 0xff, 0x88, 0xac, 0x30, - 0x56, 0x48, 0xea, 0xe7, 0x4b, 0x50, 0x73, 0x9d, 0xe3, 0x1e, 0x11, 0x2e, 0x23, 0x68, 0x83, 0x77, - 0x9d, 0x63, 0x22, 0x72, 0x06, 0xba, 0x00, 0x73, 0xbe, 0xee, 0x1d, 0x92, 0xf5, 0x59, 0xae, 0xb2, - 0x42, 0x1e, 0xbb, 0x06, 0x5a, 0x82, 0xf2, 0xbe, 0x69, 0x61, 0xd6, 0x3a, 0x53, 0xd3, 0xd8, 0x03, - 0xfa, 0x56, 0xd0, 0x82, 0x59, 0xcd, 0xdd, 0x6a, 0xc5, 0xba, 0x30, 0x5f, 0x86, 0x79, 0xc2, 0x49, - 0x04, 0x09, 0x26, 0xd6, 0x2d, 0x5e, 0xa7, 0xe0, 0x83, 0xb4, 0xc5, 0xe2, 0x27, 0x0a, 0x2c, 0x84, - 0xa4, 0xa5, 0xba, 0x89, 0xa8, 0x3b, 0xaa, 0xea, 0xd6, 0x1d, 0x83, 0x69, 0x91, 0x66, 0x86, 0x5d, - 0x61, 0x13, 0x99, 0x42, 0x0b, 0xa7, 0x4c, 0x4a, 0x2e, 0x90, 0xc3, 0x13, 0xca, 0x98, 0x46, 0x90, - 0xee, 0xaa, 0xb8, 0xce, 0x71, 0xd7, 0x10, 0x24, 0x63, 0x1d, 0xed, 0x2c, 0x94, 0x26, 0x24, 0x5b, - 0xa7, 0x4d, 0xed, 0x2f, 0xc3, 0x3c, 0x76, 0x5d, 0xc7, 0xed, 0x0d, 0xb1, 0xe7, 0xe9, 0x83, 0xa0, - 0x59, 0xa4, 0x41, 0x07, 0xb7, 0xd8, 0x98, 0xfa, 0xb7, 0x25, 0x68, 0x86, 0x47, 0x09, 0xda, 0x36, - 0x4c, 0x23, 0x68, 0xdb, 0x30, 0xc9, 0xfd, 0x82, 0xcb, 0xb4, 0xa4, 0xe0, 0x80, 0xb5, 0x42, 0x5b, - 0xd1, 0x6a, 0x7c, 0xb4, 0x6b, 0x10, 0xe3, 0x4e, 0x08, 0x64, 0x3b, 0x06, 0x0e, 0x39, 0x00, 0x82, - 0x21, 0x59, 0xec, 0x57, 0xca, 0xc1, 0x48, 0xe5, 0x1c, 0x8c, 0x54, 0x91, 0x30, 0xd2, 0x32, 0x54, - 0xf6, 0xc6, 0xfd, 0x43, 0xec, 0x73, 0xa7, 0x90, 0x3f, 0xc5, 0x19, 0xac, 0x9a, 0x60, 0x30, 0xc1, - 0x47, 0xb5, 0x28, 0x1f, 0x5d, 0x82, 0x5a, 0x60, 0xa9, 0x3d, 0x5a, 0x9d, 0x2c, 0x6a, 0x55, 0x6e, - 0xa2, 0x3d, 0xf4, 0x66, 0xe0, 0x32, 0xd6, 0xa9, 0x44, 0xa9, 0x12, 0x85, 0x94, 0xe0, 0x92, 0xc0, - 0x61, 0xbc, 0x09, 0x0b, 0x11, 0x72, 0x50, 0x3e, 0x63, 0x25, 0xcc, 0x48, 0x44, 0x41, 0x2d, 0xc8, - 0x0d, 0x68, 0x86, 0x24, 0xa1, 0x70, 0xf3, 0x2c, 0xfe, 0x13, 0xa3, 0x14, 0x4c, 0xb0, 0x7b, 0xf3, - 0x94, 0xec, 0x7e, 0x11, 0xaa, 0x3c, 0x02, 0xf3, 0x78, 0x0d, 0x53, 0xa4, 0x78, 0x72, 0x49, 0xc2, - 0xa7, 0x80, 0xc2, 0x23, 0xce, 0xe6, 0x97, 0x26, 0x78, 0xa8, 0x90, 0xe4, 0x21, 0xf5, 0xcf, 0x14, - 0x58, 0x8c, 0x6e, 0x76, 0x56, 0xc3, 0xfd, 0x1e, 0xd4, 0x59, 0x11, 0xb9, 0x47, 0x54, 0x88, 0xbc, - 0xd6, 0x9a, 0xb8, 0x3c, 0x0d, 0xc2, 0xef, 0x6d, 0x08, 0x61, 0x8e, 0x1d, 0xf7, 0xd0, 0xb4, 0x07, - 0x3d, 0x82, 0x99, 0x48, 0x41, 0xf3, 0xc1, 0x47, 0x64, 0x4c, 0xfd, 0x35, 0x05, 0xae, 0x3c, 0x1e, - 0x19, 0xba, 0x8f, 0x23, 0x1e, 0xcc, 0xac, 0xfd, 0xab, 0xa2, 0x81, 0xb4, 0x30, 0xe1, 0x9a, 0x23, - 0xfb, 0x79, 0xbc, 0x81, 0x94, 0xf8, 0x7d, 0x1c, 0x9b, 0x54, 0xc7, 0xf7, 0xd9, 0xb1, 0xe9, 0x40, - 0xf5, 0x88, 0x2f, 0x17, 0x7c, 0x0a, 0x14, 0x3c, 0xc7, 0x8a, 0xd9, 0xc5, 0x53, 0x15, 0xb3, 0xd5, - 0x2d, 0xb8, 0xa8, 0x61, 0x0f, 0xdb, 0x46, 0xec, 0x20, 0x67, 0x4e, 0xca, 0x8d, 0xa0, 0x23, 0x5b, - 0x6e, 0x16, 0x4e, 0x65, 0x8e, 0x6f, 0xcf, 0x25, 0xcb, 0xfa, 0x5c, 0x59, 0x13, 0x7f, 0x8b, 0xee, - 0xe3, 0xab, 0x7f, 0x5e, 0x80, 0x0b, 0xf7, 0x0d, 0x83, 0xeb, 0x79, 0xee, 0xca, 0x3d, 0x2f, 0x2f, - 0x3b, 0xe9, 0x85, 0x16, 0xd3, 0x5e, 0xe8, 0xb3, 0xd2, 0xbd, 0xdc, 0x0a, 0xd9, 0xe3, 0x61, 0x60, - 0x82, 0x5d, 0xd6, 0xf1, 0xf6, 0x0e, 0x2f, 0xf9, 0xf6, 0x2c, 0x67, 0x40, 0xcd, 0xf0, 0x74, 0xe7, - 0xac, 0x1a, 0x24, 0x17, 0xd5, 0x11, 0xb4, 0xd3, 0xc4, 0x9a, 0x51, 0x8f, 0x04, 0x14, 0x19, 0x39, - 0x2c, 0x71, 0xdd, 0x20, 0x9e, 0x18, 0x1d, 0xda, 0x76, 0x3c, 0xf5, 0xbf, 0x0b, 0xd0, 0xde, 0xd1, - 0x8f, 0xf0, 0xff, 0x9d, 0x0b, 0xfa, 0x04, 0x96, 0x3c, 0xfd, 0x08, 0xf7, 0x22, 0x01, 0x78, 0xcf, - 0xc5, 0x9f, 0x71, 0x27, 0xf6, 0x55, 0x59, 0xb6, 0x50, 0xda, 0xa9, 0xa5, 0x2d, 0x7a, 0xb1, 0x71, - 0x0d, 0x7f, 0x86, 0x5e, 0x81, 0x85, 0x68, 0xfb, 0x61, 0x90, 0xd7, 0x6d, 0x68, 0xf3, 0x91, 0x16, - 0xc3, 0xae, 0xa1, 0x7e, 0x06, 0x2f, 0x3e, 0xb6, 0x3d, 0xec, 0x77, 0xc3, 0x36, 0xb9, 0x19, 0xe3, - 0xcf, 0xab, 0x50, 0x0f, 0x09, 0x9f, 0xfa, 0x06, 0xc8, 0xf0, 0x54, 0x07, 0x3a, 0x5b, 0xba, 0x7b, - 0x18, 0xa4, 0xe3, 0x37, 0x58, 0x57, 0xd1, 0x73, 0xdc, 0x70, 0x5f, 0xf4, 0xd7, 0x69, 0x78, 0x1f, - 0xbb, 0xd8, 0xee, 0xe3, 0x4d, 0xa7, 0x7f, 0x48, 0x1c, 0x12, 0x9f, 0x7d, 0xbd, 0xa9, 0x44, 0x7c, - 0xd7, 0x8d, 0xc8, 0x57, 0x96, 0x85, 0xd8, 0x57, 0x96, 0x53, 0x3e, 0x44, 0x56, 0x7f, 0x58, 0x80, - 0xe5, 0xfb, 0x96, 0x8f, 0xdd, 0x30, 0xc3, 0x70, 0x9a, 0x64, 0x49, 0x98, 0xbd, 0x28, 0x9c, 0x25, - 0x7b, 0x91, 0xa3, 0x02, 0x2b, 0xcb, 0xb5, 0x94, 0xce, 0x98, 0x6b, 0xb9, 0x0f, 0x30, 0x72, 0x9d, - 0x11, 0x76, 0x7d, 0x13, 0x07, 0xb1, 0x5f, 0x0e, 0x07, 0x27, 0x32, 0x49, 0xfd, 0x04, 0x5a, 0x0f, - 0xfb, 0xeb, 0x8e, 0xbd, 0x6f, 0xba, 0xc3, 0x80, 0x50, 0x29, 0xa1, 0x53, 0x72, 0x08, 0x5d, 0x21, - 0x25, 0x74, 0xaa, 0x09, 0x8b, 0x91, 0xb5, 0x67, 0x54, 0x5c, 0x83, 0x7e, 0x6f, 0xdf, 0xb4, 0x4d, - 0xda, 0xb5, 0x57, 0xa0, 0x0e, 0x2a, 0x0c, 0xfa, 0x0f, 0xf8, 0x88, 0xfa, 0xa5, 0x02, 0x97, 0x34, - 0x4c, 0x84, 0x27, 0x68, 0x3c, 0xda, 0xf5, 0xb7, 0xbc, 0xc1, 0x0c, 0x0e, 0xc5, 0x3d, 0x28, 0x0d, - 0xbd, 0x41, 0x46, 0xd3, 0x00, 0x31, 0xd1, 0xb1, 0x8d, 0x34, 0x0a, 0xac, 0xfe, 0x48, 0x81, 0xa5, - 0xa0, 0xb4, 0x1a, 0x13, 0xe1, 0x38, 0xdb, 0x2a, 0xa9, 0xde, 0xf5, 0x09, 0x5f, 0x6c, 0x5f, 0x80, - 0x39, 0x63, 0x2f, 0xaa, 0x20, 0x2b, 0xc6, 0x1e, 0xd5, 0x8d, 0x12, 0x4f, 0xb9, 0x24, 0xf5, 0x94, - 0x93, 0x8c, 0x5f, 0x96, 0xf4, 0x6c, 0x3d, 0x86, 0x36, 0x77, 0x50, 0x3e, 0x1a, 0x61, 0x57, 0xa7, - 0xfc, 0x15, 0x20, 0xff, 0x56, 0xe0, 0x42, 0x2b, 0x99, 0x1f, 0x36, 0x26, 0xcb, 0xaa, 0xdc, 0x89, - 0x56, 0xff, 0x41, 0x81, 0x6b, 0xc9, 0x75, 0xb7, 0x79, 0xd1, 0x71, 0xe6, 0x4f, 0xfd, 0x69, 0xc5, - 0xb2, 0x10, 0x56, 0x2c, 0x67, 0x2a, 0xbd, 0x46, 0xab, 0xa3, 0xa5, 0x78, 0x75, 0xf4, 0xd6, 0x7b, - 0xa2, 0x79, 0x7f, 0xf7, 0x64, 0x84, 0xd1, 0x1c, 0x14, 0x1f, 0xe1, 0xe3, 0xd6, 0x39, 0x04, 0x50, - 0x79, 0xe4, 0xb8, 0x43, 0xdd, 0x6a, 0x29, 0xa8, 0x0e, 0x73, 0xbc, 0xa2, 0xde, 0x2a, 0xa0, 0x79, - 0xa8, 0xad, 0x07, 0x55, 0xc6, 0x56, 0xf1, 0xd6, 0x2d, 0x68, 0x44, 0x6b, 0x4c, 0x64, 0xde, 0x26, - 0x1e, 0xe8, 0xfd, 0x93, 0xd6, 0x39, 0x54, 0x81, 0xc2, 0xe6, 0xdd, 0x96, 0x42, 0xff, 0xbe, 0xd1, - 0x2a, 0xdc, 0xfa, 0x7d, 0x05, 0x16, 0x53, 0x48, 0xa2, 0x26, 0xc0, 0x63, 0xbb, 0xcf, 0x0b, 0xe7, - 0xad, 0x73, 0xa8, 0x01, 0xd5, 0xa0, 0x8c, 0xce, 0xf6, 0xde, 0x75, 0x28, 0x74, 0xab, 0x80, 0x5a, - 0xd0, 0x60, 0x13, 0xc7, 0xfd, 0x3e, 0xf6, 0xbc, 0x56, 0x51, 0x8c, 0x3c, 0xd0, 0x4d, 0x6b, 0xec, - 0xe2, 0x56, 0x89, 0xe0, 0xb7, 0xeb, 0x68, 0xd8, 0xc2, 0xba, 0x87, 0x5b, 0x65, 0x84, 0xa0, 0xc9, - 0x1f, 0x82, 0x49, 0x95, 0xc8, 0x58, 0x30, 0x6d, 0xee, 0xd6, 0x5f, 0x2a, 0xd1, 0xa2, 0x18, 0xa5, - 0xc5, 0x05, 0x38, 0xff, 0xd8, 0x36, 0xf0, 0xbe, 0x69, 0x63, 0x23, 0x7c, 0xd5, 0x3a, 0x87, 0xce, - 0xc3, 0xc2, 0x16, 0x76, 0x07, 0x38, 0x32, 0x58, 0x40, 0x8b, 0x30, 0xbf, 0x65, 0x3e, 0x8d, 0x0c, - 0x15, 0xd1, 0x12, 0xb4, 0x76, 0x4c, 0x7b, 0x60, 0x45, 0x01, 0x4b, 0x74, 0xb6, 0x69, 0x3b, 0x6e, - 0x64, 0xb0, 0x4c, 0x07, 0xf5, 0x4f, 0x63, 0x83, 0x15, 0xd4, 0x81, 0x65, 0x4a, 0xd4, 0xbb, 0x1b, - 0x98, 0x50, 0x23, 0xf2, 0x6e, 0x4e, 0x2d, 0x55, 0x95, 0x96, 0xb2, 0xfa, 0xa3, 0x1b, 0x50, 0x23, - 0xc2, 0xba, 0xee, 0x38, 0xae, 0x81, 0x2c, 0x40, 0xf4, 0x6b, 0xbe, 0xe1, 0xc8, 0xb1, 0xc5, 0x97, - 0xbf, 0xe8, 0x76, 0x42, 0xbe, 0xd9, 0x43, 0x1a, 0x90, 0x8b, 0x44, 0xe7, 0xba, 0x14, 0x3e, 0x01, - 0xac, 0x9e, 0x43, 0x43, 0xba, 0xdb, 0xae, 0x39, 0xc4, 0xbb, 0x66, 0xff, 0x30, 0x08, 0x01, 0xee, - 0x66, 0x7c, 0x3e, 0x99, 0x06, 0x0d, 0xf6, 0x7b, 0x59, 0xba, 0x1f, 0xfb, 0xdc, 0x32, 0x90, 0x23, - 0xf5, 0x1c, 0xfa, 0x8c, 0xaa, 0x9f, 0x30, 0x9e, 0x0a, 0x36, 0x5c, 0xcd, 0xde, 0x30, 0x05, 0x7c, - 0xca, 0x2d, 0x37, 0xa1, 0x4c, 0xf9, 0x1e, 0xc9, 0x2a, 0xab, 0xd1, 0x5f, 0x22, 0xe9, 0x5c, 0xcb, - 0x06, 0x10, 0xab, 0x7d, 0x0a, 0x0b, 0x89, 0x0f, 0xfa, 0x91, 0xcc, 0x07, 0x93, 0xff, 0x34, 0x43, - 0xe7, 0x56, 0x1e, 0x50, 0xb1, 0xd7, 0x00, 0x9a, 0xf1, 0xaf, 0x00, 0xd1, 0x4a, 0x8e, 0x6f, 0x89, - 0xd9, 0x4e, 0xaf, 0xe6, 0xfe, 0xea, 0x98, 0x32, 0x41, 0x2b, 0xf9, 0xa9, 0x39, 0xba, 0x35, 0x71, - 0x81, 0x38, 0xb3, 0x7d, 0x23, 0x17, 0xac, 0xd8, 0xee, 0x84, 0x32, 0x41, 0xea, 0x3b, 0xdf, 0x24, - 0x8f, 0x07, 0xcb, 0x64, 0x7d, 0x80, 0xdc, 0xb9, 0x93, 0x1b, 0x5e, 0x6c, 0xfd, 0xf3, 0xac, 0x3d, - 0x52, 0xf6, 0xad, 0x2c, 0x7a, 0x43, 0xbe, 0xdc, 0x84, 0x8f, 0x7c, 0x3b, 0xab, 0xa7, 0x99, 0x22, - 0x90, 0xf8, 0x3e, 0xed, 0x6b, 0x94, 0x7c, 0x6d, 0x9a, 0x94, 0xbb, 0x60, 0xbd, 0xec, 0x0f, 0x69, - 0x3b, 0x6f, 0x9c, 0x62, 0x86, 0x40, 0xc0, 0x49, 0x7e, 0xcb, 0x1f, 0x88, 0xe1, 0x9d, 0xa9, 0x5c, - 0x73, 0x36, 0x19, 0xfc, 0x1e, 0x2c, 0x24, 0xa2, 0x12, 0x94, 0x3f, 0x72, 0xe9, 0x4c, 0x32, 0xb7, - 0x4c, 0x24, 0x13, 0x7d, 0x8c, 0x28, 0x83, 0xfb, 0x25, 0xbd, 0x8e, 0x9d, 0x5b, 0x79, 0x40, 0xc5, - 0x41, 0x46, 0xb0, 0x98, 0x78, 0xf9, 0x64, 0x15, 0x7d, 0x23, 0xf7, 0x6e, 0x4f, 0x56, 0x3b, 0xaf, - 0xe5, 0xdf, 0xef, 0xc9, 0xaa, 0x7a, 0x0e, 0x79, 0x54, 0x41, 0x27, 0x7a, 0xe1, 0x50, 0xc6, 0x2a, - 0xf2, 0x9e, 0xbf, 0xce, 0xeb, 0x39, 0xa1, 0xc5, 0x31, 0x8f, 0xe0, 0xbc, 0xa4, 0x65, 0x11, 0xbd, - 0x3e, 0x91, 0x3d, 0x92, 0xbd, 0x9a, 0x9d, 0xdb, 0x79, 0xc1, 0x23, 0xe6, 0xa1, 0x15, 0xe0, 0x75, - 0xdf, 0xb2, 0x98, 0x67, 0xf1, 0x5a, 0x96, 0xe5, 0x8b, 0x81, 0x65, 0x1c, 0x35, 0x13, 0x5a, 0x6c, - 0xf9, 0xb3, 0x80, 0x76, 0x0e, 0x9c, 0x63, 0x1a, 0x05, 0x0c, 0xc6, 0xdc, 0xb1, 0xcc, 0x34, 0x80, - 0x69, 0xd0, 0x0c, 0x41, 0x9c, 0x38, 0x43, 0x6c, 0xde, 0x03, 0x78, 0x88, 0xfd, 0x2d, 0xec, 0xbb, - 0x44, 0xfa, 0x5f, 0xc9, 0xc2, 0x9d, 0x03, 0x04, 0x5b, 0xdd, 0x9c, 0x0a, 0x17, 0x25, 0xe8, 0x96, - 0x6e, 0x8f, 0x75, 0x2b, 0xf2, 0x29, 0x9d, 0x9c, 0xa0, 0x49, 0xb0, 0xc9, 0x04, 0x4d, 0x43, 0x8b, - 0x2d, 0x8f, 0x85, 0xff, 0x12, 0x69, 0x7b, 0x98, 0xec, 0xbf, 0xa4, 0x3b, 0xf8, 0x92, 0xba, 0x7d, - 0x02, 0xbc, 0xd8, 0xf8, 0x0b, 0x85, 0x36, 0xda, 0x26, 0x00, 0x3e, 0x36, 0xfd, 0x83, 0x6d, 0x4b, - 0xb7, 0xbd, 0x3c, 0x28, 0x50, 0xc0, 0x53, 0xa0, 0xc0, 0xe1, 0x05, 0x0a, 0x06, 0xcc, 0xc7, 0x2a, - 0xfe, 0x48, 0xd6, 0x9f, 0x21, 0x6b, 0x94, 0xe8, 0xac, 0x4c, 0x07, 0x14, 0xbb, 0xec, 0xc3, 0x7c, - 0x2c, 0x86, 0x93, 0xee, 0x22, 0x8b, 0xf2, 0x92, 0xca, 0x2e, 0x21, 0x1d, 0x49, 0x82, 0x7a, 0x80, - 0xd2, 0x85, 0x4d, 0x94, 0xaf, 0x0c, 0x3e, 0x49, 0xf5, 0x64, 0x57, 0x4b, 0x99, 0x36, 0x4f, 0xb4, - 0x0e, 0xc8, 0x4d, 0x85, 0xb4, 0x13, 0x42, 0xaa, 0xcd, 0x33, 0x3a, 0x11, 0xd4, 0x73, 0xe8, 0x63, - 0xa8, 0xf0, 0x5f, 0xea, 0xba, 0x3e, 0xb9, 0x84, 0xc0, 0x57, 0xbf, 0x31, 0x05, 0x4a, 0x2c, 0x7c, - 0x08, 0x17, 0x32, 0x0a, 0x08, 0x52, 0x2f, 0x63, 0x72, 0xb1, 0x61, 0x9a, 0xfd, 0x13, 0x9b, 0xa5, - 0xea, 0x03, 0x13, 0x36, 0xcb, 0xaa, 0x25, 0x4c, 0xdb, 0xac, 0x07, 0x8b, 0xa9, 0xfc, 0xab, 0xd4, - 0x00, 0x66, 0x65, 0x69, 0xa7, 0x6d, 0x30, 0x80, 0x17, 0xa4, 0xb9, 0x46, 0xa9, 0x6f, 0x32, 0x29, - 0x2b, 0x39, 0x6d, 0xa3, 0x3e, 0x9c, 0x97, 0x64, 0x18, 0xa5, 0x36, 0x2e, 0x3b, 0x13, 0x39, 0x6d, - 0x93, 0x7d, 0xe8, 0xac, 0xb9, 0x8e, 0x6e, 0xf4, 0x75, 0xcf, 0xa7, 0x59, 0x3f, 0x12, 0x84, 0x06, - 0xce, 0xa1, 0x3c, 0x72, 0x90, 0xe6, 0x06, 0xa7, 0xed, 0xb3, 0x07, 0x75, 0x7a, 0x95, 0xec, 0x67, - 0x91, 0x90, 0xdc, 0x42, 0x44, 0x20, 0x32, 0xd4, 0x8e, 0x0c, 0x50, 0x30, 0xf5, 0x2e, 0xd4, 0xd7, - 0x69, 0xf9, 0xb4, 0x6b, 0x1b, 0xf8, 0x69, 0xd2, 0x5a, 0xd1, 0xdf, 0x86, 0xb8, 0x1d, 0x01, 0xc8, - 0x4d, 0xa1, 0x79, 0xea, 0xb3, 0x1b, 0xf8, 0x29, 0xbb, 0xe7, 0x15, 0xd9, 0xba, 0x31, 0x90, 0x8c, - 0x18, 0x47, 0x0a, 0x19, 0xb1, 0xf3, 0x4b, 0x51, 0x4f, 0x56, 0x6c, 0x77, 0x27, 0x63, 0x91, 0x14, - 0x64, 0xb0, 0xeb, 0xdd, 0xfc, 0x13, 0xa2, 0x76, 0x21, 0xc0, 0xab, 0x4b, 0x6b, 0xb7, 0x37, 0x27, - 0xa1, 0x1e, 0x75, 0x4f, 0x57, 0xa6, 0x03, 0x8a, 0x5d, 0xb6, 0xa1, 0x46, 0xb8, 0x93, 0x5d, 0xcf, - 0x75, 0xd9, 0x44, 0xf1, 0x3a, 0xff, 0xe5, 0x6c, 0x60, 0xaf, 0xef, 0x9a, 0x7b, 0xfc, 0xd2, 0xa5, - 0xe8, 0xc4, 0x40, 0x26, 0x5e, 0x4e, 0x02, 0x52, 0x60, 0x3e, 0xa6, 0x3e, 0x83, 0x20, 0x1d, 0x57, - 0x95, 0xaf, 0x4f, 0xbb, 0xdf, 0xb8, 0x9a, 0xbc, 0x9d, 0x17, 0x5c, 0x6c, 0xfb, 0x73, 0x34, 0x0e, - 0xa2, 0xef, 0xd7, 0xc6, 0xa6, 0x65, 0x04, 0x89, 0x3f, 0x74, 0x77, 0xd2, 0x52, 0x31, 0xd0, 0x4c, - 0xf7, 0x6f, 0xc2, 0x0c, 0xb1, 0xff, 0x4f, 0x43, 0x4d, 0xe4, 0x9f, 0x91, 0x2c, 0x6b, 0x99, 0xcc, - 0x7c, 0x77, 0xae, 0x4f, 0x06, 0x12, 0x2b, 0x63, 0x58, 0x92, 0x65, 0x9b, 0xa5, 0x21, 0xf6, 0x84, - 0xb4, 0xf4, 0x14, 0xfe, 0x58, 0xfd, 0xb2, 0x01, 0xd5, 0x60, 0xe2, 0x57, 0x9c, 0xb8, 0xfa, 0x1a, - 0x32, 0x49, 0xdf, 0x83, 0x85, 0xc4, 0xaf, 0xdd, 0x48, 0x35, 0xb8, 0xfc, 0x17, 0x71, 0xa6, 0x89, - 0xda, 0xc7, 0xfc, 0xf7, 0x65, 0x45, 0x88, 0x77, 0x33, 0x2b, 0x1b, 0x95, 0x8c, 0xee, 0xa6, 0x2c, - 0xfc, 0xbf, 0x3b, 0xc0, 0x79, 0x04, 0x10, 0x09, 0x6d, 0x5e, 0x9a, 0xda, 0x0e, 0x3d, 0x8d, 0x5a, - 0x43, 0x69, 0xf4, 0xf2, 0xea, 0xe4, 0x96, 0xf0, 0x69, 0x1e, 0x68, 0x76, 0xcc, 0xf2, 0x18, 0x1a, - 0xd1, 0xaf, 0x8e, 0x90, 0xf4, 0xa7, 0x3f, 0xd3, 0x9f, 0x25, 0x4d, 0x3b, 0xc5, 0xd6, 0x29, 0x1d, - 0xdb, 0x29, 0xcb, 0x79, 0x80, 0xd2, 0x7d, 0x18, 0xd2, 0x40, 0x20, 0xb3, 0xfb, 0x43, 0x1a, 0x08, - 0x64, 0x37, 0x77, 0xb0, 0xa4, 0x64, 0xb2, 0xb9, 0x40, 0x9a, 0x94, 0xcc, 0x68, 0xd7, 0x90, 0x26, - 0x25, 0xb3, 0xba, 0x15, 0x22, 0xf2, 0x37, 0x31, 0x74, 0x93, 0xfd, 0xfc, 0xf1, 0x34, 0xe2, 0x19, - 0xb0, 0xfc, 0xc8, 0xf1, 0xcd, 0xfd, 0x93, 0x64, 0x99, 0x49, 0xea, 0x36, 0x67, 0xd5, 0xb8, 0xa6, - 0x4b, 0xf9, 0x65, 0xea, 0xb5, 0x65, 0xd5, 0xb2, 0x50, 0x9e, 0xa2, 0x58, 0xe7, 0x5e, 0x0e, 0x8c, - 0xd2, 0x76, 0x6c, 0xed, 0xde, 0x27, 0x6f, 0x0c, 0x4c, 0xff, 0x60, 0xbc, 0x47, 0xd0, 0xba, 0xc3, - 0x96, 0x78, 0xdd, 0x74, 0xf8, 0x7f, 0x77, 0x02, 0x55, 0x71, 0x87, 0xae, 0x7a, 0x87, 0xac, 0x3a, - 0xda, 0xdb, 0xab, 0xd0, 0xa7, 0x7b, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0x92, 0xf7, 0x3e, 0x4d, - 0x97, 0x5c, 0x00, 0x00, + // 5949 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3d, 0x5b, 0x93, 0x1c, 0xd7, + 0x59, 0xea, 0xb9, 0xed, 0xcc, 0x37, 0x97, 0x9d, 0x3d, 0x5a, 0xaf, 0xc6, 0x23, 0x4b, 0x96, 0xdb, + 0xba, 0x59, 0xb1, 0x25, 0x79, 0x65, 0x57, 0x9c, 0x38, 0x76, 0xac, 0xdd, 0xb5, 0xec, 0x25, 0x5a, + 0x79, 0xdd, 0xbb, 0x5a, 0x53, 0x09, 0xc5, 0xd0, 0x3b, 0x7d, 0x76, 0xd4, 0xd9, 0x99, 0xee, 0x71, + 0x77, 0x8f, 0xa4, 0x0d, 0x55, 0x24, 0x81, 0x40, 0x41, 0x48, 0x05, 0x28, 0xe0, 0x81, 0x97, 0x14, + 0x45, 0x15, 0x14, 0xb7, 0x3c, 0x91, 0x54, 0xaa, 0x28, 0x8a, 0x14, 0x50, 0x50, 0xa1, 0x78, 0xe0, + 0x85, 0x07, 0x78, 0xe0, 0x0f, 0xf0, 0x46, 0xf1, 0x07, 0xa8, 0x73, 0xe9, 0xd3, 0xa7, 0xbb, 0x4f, + 0xcf, 0xf4, 0xee, 0x48, 0x76, 0x71, 0x79, 0x91, 0xa6, 0x4f, 0x7f, 0xe7, 0xf6, 0xdd, 0xbf, 0xef, + 0x7c, 0xa7, 0x17, 0xda, 0x96, 0x19, 0x98, 0xbd, 0xbe, 0xeb, 0x7a, 0xd6, 0xf5, 0xb1, 0xe7, 0x06, + 0x2e, 0x5a, 0x1a, 0xd9, 0xc3, 0x87, 0x13, 0x9f, 0x3d, 0x5d, 0x27, 0xaf, 0xbb, 0x8d, 0xbe, 0x3b, + 0x1a, 0xb9, 0x0e, 0x6b, 0xea, 0xb6, 0x6c, 0x27, 0xc0, 0x9e, 0x63, 0x0e, 0xf9, 0x73, 0x43, 0xee, + 0xd0, 0x6d, 0xf8, 0xfd, 0x07, 0x78, 0x64, 0xf2, 0xa7, 0xda, 0xc8, 0x1f, 0xf0, 0x9f, 0x4b, 0xb6, + 0x63, 0xe1, 0xc7, 0xf2, 0x54, 0xfa, 0x02, 0x94, 0xdf, 0x1d, 0x8d, 0x83, 0x23, 0xfd, 0x07, 0x1a, + 0x34, 0xee, 0x0c, 0x27, 0xfe, 0x03, 0x03, 0x7f, 0x3c, 0xc1, 0x7e, 0x80, 0x6e, 0x42, 0x69, 0xdf, + 0xf4, 0x71, 0x47, 0xbb, 0xa0, 0x5d, 0xad, 0xaf, 0x3e, 0x77, 0x3d, 0xb6, 0x26, 0xbe, 0x9a, 0x2d, + 0x7f, 0xb0, 0x66, 0xfa, 0xd8, 0xa0, 0x90, 0x08, 0x41, 0xc9, 0xda, 0xdf, 0xdc, 0xe8, 0x14, 0x2e, + 0x68, 0x57, 0x8b, 0x06, 0xfd, 0x8d, 0xce, 0x03, 0xf8, 0x78, 0x30, 0xc2, 0x4e, 0xb0, 0xb9, 0xe1, + 0x77, 0x8a, 0x17, 0x8a, 0x57, 0x8b, 0x86, 0xd4, 0x82, 0x74, 0x68, 0xf4, 0xdd, 0xe1, 0x10, 0xf7, + 0x03, 0xdb, 0x75, 0x36, 0x37, 0x3a, 0x25, 0xda, 0x37, 0xd6, 0x86, 0xba, 0x50, 0xb5, 0xfd, 0xcd, + 0xd1, 0xd8, 0xf5, 0x82, 0x4e, 0xf9, 0x82, 0x76, 0xb5, 0x6a, 0x88, 0x67, 0xfd, 0x9b, 0x05, 0x68, + 0xf2, 0x65, 0xfb, 0x63, 0xd7, 0xf1, 0x31, 0xba, 0x05, 0x15, 0x3f, 0x30, 0x83, 0x89, 0xcf, 0x57, + 0x7e, 0x56, 0xb9, 0xf2, 0x1d, 0x0a, 0x62, 0x70, 0x50, 0xe5, 0xd2, 0x93, 0x4b, 0x2b, 0x2a, 0x96, + 0x16, 0xdf, 0x5e, 0x29, 0xb5, 0xbd, 0xab, 0xb0, 0x78, 0x40, 0x56, 0xb7, 0x13, 0x01, 0x95, 0x29, + 0x50, 0xb2, 0x99, 0x8c, 0x14, 0xd8, 0x23, 0xfc, 0xc1, 0xc1, 0x0e, 0x36, 0x87, 0x9d, 0x0a, 0x9d, + 0x4b, 0x6a, 0x41, 0xcf, 0x42, 0x95, 0x76, 0xe9, 0x05, 0x7e, 0x67, 0xe1, 0x82, 0x76, 0xb5, 0x64, + 0x2c, 0xd0, 0xe7, 0x5d, 0x5f, 0xff, 0x3a, 0x2c, 0x53, 0x14, 0xac, 0x3f, 0x30, 0x1d, 0x07, 0x0f, + 0xfd, 0x93, 0x53, 0x50, 0x9e, 0xa4, 0x10, 0x9b, 0x84, 0x10, 0xa1, 0xcf, 0xc7, 0xa7, 0x64, 0xac, + 0x19, 0xe2, 0x59, 0xff, 0xd5, 0x02, 0xb4, 0xc5, 0x56, 0xc2, 0xd9, 0x97, 0xa1, 0xdc, 0x77, 0x27, + 0x4e, 0x40, 0xa7, 0x6f, 0x1a, 0xec, 0x01, 0xbd, 0x00, 0x0d, 0xde, 0xad, 0xe7, 0x98, 0x23, 0x4c, + 0x67, 0xa9, 0x19, 0x75, 0xde, 0x76, 0xcf, 0x1c, 0xe1, 0x5c, 0x78, 0xbf, 0x00, 0xf5, 0xb1, 0xe9, + 0x05, 0x76, 0x8c, 0x6b, 0xe4, 0xa6, 0x69, 0x4c, 0x43, 0x66, 0xb0, 0xe9, 0xaf, 0x5d, 0xd3, 0x3f, + 0xdc, 0xdc, 0xe0, 0xd8, 0x8e, 0xb5, 0xa1, 0xd7, 0xa1, 0x3c, 0xc4, 0x0f, 0xf1, 0x90, 0x22, 0xbb, + 0xb5, 0xfa, 0xfc, 0xf5, 0x94, 0x4c, 0x5e, 0xe7, 0x5b, 0xbe, 0x4b, 0xc0, 0x0c, 0x06, 0xad, 0xff, + 0xbe, 0x06, 0x2b, 0xb7, 0x7d, 0xdf, 0x1e, 0x38, 0x29, 0x84, 0xac, 0x40, 0xc5, 0x71, 0x2d, 0xbc, + 0xb9, 0x41, 0x31, 0x52, 0x34, 0xf8, 0x13, 0x3a, 0x0b, 0xb5, 0x31, 0xc6, 0x5e, 0xcf, 0x73, 0x87, + 0x21, 0x3e, 0xaa, 0xa4, 0xc1, 0x70, 0x87, 0x18, 0x7d, 0x08, 0x4b, 0x7e, 0x62, 0x20, 0x86, 0xff, + 0xfa, 0xea, 0x8b, 0xd9, 0x4b, 0x12, 0xb0, 0x46, 0xba, 0xb7, 0xfe, 0x8d, 0x02, 0x9c, 0x16, 0x70, + 0x6c, 0xad, 0xe4, 0x37, 0x21, 0x98, 0x8f, 0x07, 0x62, 0x79, 0xec, 0x21, 0x0f, 0xc1, 0x04, 0xa5, + 0x8b, 0x32, 0xa5, 0xf3, 0x48, 0x76, 0x82, 0x8c, 0xe5, 0x34, 0x19, 0x9f, 0x87, 0x3a, 0x7e, 0x3c, + 0xb6, 0x3d, 0xdc, 0x23, 0xb2, 0x40, 0x29, 0x55, 0x32, 0x80, 0x35, 0xed, 0xda, 0x23, 0x59, 0xdc, + 0x17, 0x72, 0x8b, 0xbb, 0xfe, 0x07, 0x1a, 0x9c, 0x49, 0x51, 0x89, 0xeb, 0x0f, 0x03, 0xda, 0x74, + 0xe7, 0x11, 0x66, 0x88, 0x26, 0x21, 0x08, 0xbf, 0x3c, 0x0d, 0xe1, 0x11, 0xb8, 0x91, 0xea, 0x2f, + 0x2d, 0xb2, 0x90, 0x7f, 0x91, 0x87, 0x70, 0xe6, 0x3d, 0x1c, 0xf0, 0x09, 0xc8, 0x3b, 0x3c, 0x87, + 0x64, 0xc7, 0x15, 0x55, 0x21, 0xa9, 0xa8, 0xf4, 0x3f, 0x8a, 0x44, 0x98, 0x4e, 0xb5, 0xe9, 0x1c, + 0xb8, 0xe8, 0x39, 0xa8, 0x09, 0x10, 0xce, 0x15, 0x51, 0x03, 0xfa, 0x2c, 0x94, 0xc9, 0x4a, 0x19, + 0x4b, 0xb4, 0x56, 0x5f, 0x50, 0xef, 0x49, 0x1a, 0xd3, 0x60, 0xf0, 0x68, 0x03, 0x5a, 0x7e, 0x60, + 0x7a, 0x41, 0x6f, 0xec, 0xfa, 0x94, 0xce, 0x94, 0x71, 0xea, 0xab, 0xe7, 0xe2, 0x23, 0x10, 0xbb, + 0xb5, 0xe5, 0x0f, 0xb6, 0x39, 0x90, 0xd1, 0xa4, 0x9d, 0xc2, 0x47, 0xf4, 0x0e, 0x34, 0xb0, 0x63, + 0x45, 0x63, 0x94, 0xf2, 0x8c, 0x51, 0xc7, 0x8e, 0x25, 0x46, 0x88, 0xa8, 0x52, 0xce, 0x4f, 0x95, + 0xef, 0x68, 0xd0, 0x49, 0x93, 0x65, 0x1e, 0xdb, 0xf3, 0x26, 0xeb, 0x84, 0x19, 0x59, 0xa6, 0xca, + 0xb5, 0x20, 0x8d, 0xc1, 0xbb, 0xe8, 0xbf, 0xab, 0xc1, 0x33, 0xd1, 0x72, 0xe8, 0xab, 0xa7, 0xc5, + 0x23, 0xe8, 0x1a, 0xb4, 0x6d, 0xa7, 0x3f, 0x9c, 0x58, 0xf8, 0xbe, 0xf3, 0x3e, 0x36, 0x87, 0xc1, + 0x83, 0x23, 0x4a, 0xb9, 0xaa, 0x91, 0x6a, 0xd7, 0xff, 0xad, 0x00, 0x2b, 0xc9, 0x75, 0xcd, 0x83, + 0xa4, 0xd7, 0xa0, 0x6c, 0x3b, 0x07, 0x6e, 0x88, 0xa3, 0xf3, 0x53, 0x44, 0x91, 0xcc, 0xc5, 0x80, + 0x91, 0x0b, 0x28, 0x54, 0x5e, 0xfd, 0x07, 0xb8, 0x7f, 0x38, 0x76, 0x6d, 0xaa, 0xa6, 0xc8, 0x10, + 0xef, 0x28, 0x86, 0x50, 0xaf, 0xf8, 0x3a, 0x37, 0xac, 0xeb, 0x62, 0x88, 0x77, 0x9d, 0xc0, 0x3b, + 0x32, 0x96, 0xfa, 0xc9, 0xf6, 0x6e, 0x1f, 0x56, 0xd4, 0xc0, 0xa8, 0x0d, 0xc5, 0x43, 0x7c, 0x44, + 0xb7, 0x5c, 0x33, 0xc8, 0x4f, 0x74, 0x0b, 0xca, 0x0f, 0xcd, 0xe1, 0x04, 0x73, 0x9d, 0x30, 0x83, + 0x73, 0x19, 0xec, 0xe7, 0x0b, 0x6f, 0x68, 0xfa, 0x08, 0xce, 0xbe, 0x87, 0x83, 0x4d, 0xc7, 0xc7, + 0x5e, 0xb0, 0x66, 0x3b, 0x43, 0x77, 0xb0, 0x6d, 0x06, 0x0f, 0xe6, 0x50, 0x0e, 0x31, 0x39, 0x2f, + 0x24, 0xe4, 0x5c, 0xff, 0x63, 0x0d, 0x9e, 0x53, 0xcf, 0xc7, 0x09, 0xda, 0x85, 0xea, 0x81, 0x8d, + 0x87, 0x16, 0xe1, 0x1a, 0x8d, 0x72, 0x8d, 0x78, 0x26, 0x4a, 0x62, 0x4c, 0x80, 0x39, 0xdd, 0x12, + 0x4a, 0x42, 0xb8, 0xb1, 0x3b, 0x81, 0x67, 0x3b, 0x83, 0xbb, 0xb6, 0x1f, 0x18, 0x0c, 0x5e, 0xe2, + 0x92, 0x62, 0x7e, 0xe1, 0xfc, 0xb6, 0x06, 0xe7, 0xdf, 0xc3, 0xc1, 0xba, 0xb0, 0x31, 0xe4, 0xbd, + 0xed, 0x07, 0x76, 0xdf, 0x7f, 0xb2, 0x6e, 0x6d, 0x0e, 0x1f, 0x45, 0xff, 0x0d, 0x0d, 0x9e, 0xcf, + 0x5c, 0x0c, 0x47, 0x1d, 0xd7, 0xa1, 0xa1, 0x85, 0x51, 0xeb, 0xd0, 0x2f, 0xe1, 0xa3, 0x3d, 0x42, + 0xfc, 0x6d, 0xd3, 0xf6, 0x98, 0x0e, 0x3d, 0xa1, 0x45, 0xf9, 0xbe, 0x06, 0xe7, 0xde, 0xc3, 0xc1, + 0x76, 0x68, 0x5f, 0x3f, 0x45, 0xec, 0x10, 0x18, 0xc9, 0xce, 0x87, 0xbe, 0x73, 0xac, 0x4d, 0xff, + 0x2e, 0x23, 0xa7, 0x72, 0xbd, 0x9f, 0x0a, 0x02, 0xcf, 0x53, 0x49, 0x90, 0x54, 0x04, 0x17, 0x76, + 0x8e, 0x3e, 0xfd, 0x5b, 0x65, 0x68, 0xec, 0x71, 0xad, 0x40, 0x2d, 0x68, 0x12, 0x13, 0x9a, 0xda, + 0x09, 0x92, 0xbc, 0x29, 0x95, 0x83, 0xb5, 0x06, 0x4d, 0x1f, 0xe3, 0xc3, 0x63, 0xda, 0xcb, 0x06, + 0xe9, 0x23, 0x8c, 0xdd, 0x5d, 0x58, 0x9a, 0x38, 0xd4, 0x99, 0xc7, 0x16, 0xdf, 0x00, 0x43, 0xfa, + 0x6c, 0x65, 0x9a, 0xee, 0x88, 0xde, 0xe7, 0x71, 0x8d, 0x34, 0x56, 0x39, 0xd7, 0x58, 0xc9, 0x6e, + 0x68, 0x13, 0xda, 0x96, 0xe7, 0x8e, 0xc7, 0xd8, 0xea, 0xf9, 0xe1, 0x50, 0x95, 0x7c, 0x43, 0xf1, + 0x7e, 0x62, 0xa8, 0x9b, 0x70, 0x3a, 0xb9, 0xd2, 0x4d, 0x8b, 0xf8, 0x85, 0x84, 0xb3, 0x54, 0xaf, + 0xd0, 0xcb, 0xb0, 0x94, 0x86, 0xaf, 0x52, 0xf8, 0xf4, 0x0b, 0xf4, 0x0a, 0xa0, 0xc4, 0x52, 0x09, + 0x78, 0x8d, 0x81, 0xc7, 0x17, 0xc3, 0xc1, 0x69, 0xbc, 0x1d, 0x07, 0x07, 0x06, 0xce, 0xdf, 0x48, + 0xe0, 0x9b, 0xc4, 0xba, 0xc6, 0xc0, 0xfd, 0x4e, 0x3d, 0x1f, 0x22, 0xe2, 0x83, 0xf9, 0xfa, 0xaf, + 0x69, 0xb0, 0xf2, 0x91, 0x19, 0xf4, 0x1f, 0x6c, 0x8c, 0xe6, 0x8f, 0x09, 0xdf, 0x82, 0xda, 0x43, + 0x11, 0xf9, 0x31, 0x2d, 0xae, 0x0a, 0x86, 0x64, 0xb6, 0x37, 0xa2, 0x1e, 0xfa, 0xdf, 0x6a, 0x3c, + 0x3a, 0x0d, 0x57, 0xf7, 0xc9, 0xab, 0x9a, 0x59, 0x41, 0x7a, 0x42, 0x00, 0xcb, 0x29, 0x01, 0xd4, + 0x1f, 0x03, 0xf0, 0xe5, 0x6f, 0xf9, 0x83, 0x13, 0xac, 0xfc, 0x0d, 0x58, 0xe0, 0xf3, 0x71, 0x6d, + 0x33, 0x8b, 0xa4, 0x21, 0xb8, 0xfe, 0xbd, 0x05, 0xa8, 0x4b, 0x2f, 0x50, 0x0b, 0x0a, 0x42, 0x8d, + 0x14, 0x14, 0xfb, 0x2f, 0xcc, 0x8e, 0xb2, 0x8a, 0xe9, 0x28, 0xeb, 0x12, 0xb4, 0x6c, 0x6a, 0xde, + 0x7b, 0x7c, 0xd7, 0xd4, 0x9b, 0xae, 0x19, 0x4d, 0xd6, 0xca, 0x99, 0x08, 0x9d, 0x87, 0xba, 0x33, + 0x19, 0xf5, 0xdc, 0x83, 0x9e, 0xe7, 0x3e, 0xf2, 0x79, 0xb8, 0x56, 0x73, 0x26, 0xa3, 0x0f, 0x0e, + 0x0c, 0xf7, 0x91, 0x1f, 0x45, 0x04, 0x95, 0x63, 0x46, 0x04, 0xe7, 0xa1, 0x3e, 0x32, 0x1f, 0x93, + 0x51, 0x7b, 0xce, 0x64, 0x44, 0x23, 0xb9, 0xa2, 0x51, 0x1b, 0x99, 0x8f, 0x0d, 0xf7, 0xd1, 0xbd, + 0xc9, 0x08, 0x5d, 0x85, 0xf6, 0xd0, 0xf4, 0x83, 0x9e, 0x1c, 0x0a, 0x56, 0x69, 0x28, 0xd8, 0x22, + 0xed, 0xef, 0x46, 0xe1, 0x60, 0x3a, 0xb6, 0xa8, 0x9d, 0x2c, 0xb6, 0xb0, 0x46, 0xc3, 0x68, 0x0c, + 0xc8, 0x15, 0x5b, 0x58, 0xa3, 0xa1, 0x18, 0xe1, 0x0d, 0x58, 0xd8, 0xa7, 0xae, 0xd2, 0x34, 0x21, + 0xbe, 0x43, 0xbc, 0x24, 0xe6, 0x51, 0x19, 0x21, 0x38, 0xfa, 0x02, 0xd4, 0xa8, 0x85, 0xa2, 0x7d, + 0x1b, 0xb9, 0xfa, 0x46, 0x1d, 0x48, 0x6f, 0x0b, 0x0f, 0x03, 0x93, 0xf6, 0x6e, 0xe6, 0xeb, 0x2d, + 0x3a, 0x10, 0x0d, 0xda, 0xf7, 0xb0, 0x19, 0x60, 0x6b, 0xed, 0x68, 0xdd, 0x1d, 0x8d, 0x4d, 0xca, + 0x42, 0x9d, 0x16, 0x75, 0xf2, 0x55, 0xaf, 0xd0, 0x65, 0x68, 0xf5, 0xc5, 0xd3, 0x1d, 0xcf, 0x1d, + 0x75, 0x16, 0xa9, 0x7c, 0x25, 0x5a, 0xd1, 0x39, 0x80, 0x50, 0x77, 0x9a, 0x41, 0xa7, 0x4d, 0x69, + 0x57, 0xe3, 0x2d, 0xb7, 0x69, 0x5a, 0xc8, 0xf6, 0x7b, 0x2c, 0x01, 0x63, 0x3b, 0x83, 0xce, 0x12, + 0x9d, 0xb1, 0x1e, 0x66, 0x6c, 0x6c, 0x67, 0x80, 0xce, 0xc0, 0x82, 0xed, 0xf7, 0x0e, 0xcc, 0x43, + 0xdc, 0x41, 0xf4, 0x6d, 0xc5, 0xf6, 0xef, 0x98, 0x87, 0xd4, 0x7b, 0xe5, 0x93, 0x61, 0xab, 0x73, + 0x9a, 0xbe, 0x8a, 0x1a, 0xa2, 0x3c, 0xce, 0xf2, 0x71, 0xf2, 0x38, 0xe8, 0x0a, 0x2c, 0xfa, 0x81, + 0xeb, 0x99, 0x03, 0xdc, 0x7b, 0x88, 0x3d, 0x9f, 0x60, 0xe1, 0x19, 0xca, 0x95, 0x2d, 0xde, 0xbc, + 0xc7, 0x5a, 0xf5, 0xaf, 0xc1, 0x72, 0xc4, 0xd1, 0x12, 0x0b, 0xa5, 0x19, 0x51, 0x3b, 0x01, 0x23, + 0x4e, 0xf7, 0xcc, 0xff, 0xb3, 0x0c, 0x2b, 0x3b, 0xe6, 0x43, 0xfc, 0xf4, 0x83, 0x80, 0x5c, 0x7a, + 0xf6, 0x2e, 0x2c, 0x51, 0xbf, 0x7f, 0x55, 0x5a, 0xcf, 0x14, 0x17, 0x43, 0xe6, 0xc1, 0x74, 0x47, + 0xf4, 0x45, 0xa2, 0x95, 0x71, 0xff, 0x70, 0x9b, 0xc4, 0x50, 0xa1, 0x7b, 0x71, 0x4e, 0x31, 0xce, + 0xba, 0x80, 0x32, 0xe4, 0x1e, 0x68, 0x9b, 0x90, 0x50, 0xa6, 0x40, 0xe8, 0x58, 0x5c, 0x99, 0x1a, + 0x60, 0x47, 0xd8, 0x37, 0x5a, 0x31, 0x62, 0xf8, 0xa8, 0x03, 0x0b, 0xdc, 0x2b, 0xa0, 0x2a, 0xaa, + 0x6a, 0x84, 0x8f, 0x68, 0x1b, 0x4e, 0xb3, 0x1d, 0xec, 0x70, 0x49, 0x64, 0x9b, 0xaf, 0xe6, 0xda, + 0xbc, 0xaa, 0x6b, 0x5c, 0x90, 0x6b, 0xc7, 0x15, 0xe4, 0x0e, 0x2c, 0x70, 0xe1, 0xa2, 0xba, 0xab, + 0x6a, 0x84, 0x8f, 0x84, 0xcc, 0x91, 0x98, 0xd5, 0x99, 0xb4, 0x88, 0x06, 0xd2, 0x2f, 0xb4, 0x00, + 0x0d, 0x6a, 0x01, 0xc2, 0x47, 0xaa, 0x96, 0xf0, 0xa0, 0xc7, 0x64, 0xa9, 0x99, 0x4f, 0x96, 0xaa, + 0x3e, 0x1e, 0xd0, 0x5f, 0x49, 0x13, 0xd4, 0x4a, 0x9b, 0xa0, 0xcb, 0x90, 0x90, 0xac, 0xce, 0xa2, + 0x52, 0xde, 0x7e, 0x59, 0x03, 0x88, 0x28, 0x3e, 0x23, 0x45, 0xf5, 0x39, 0xa8, 0x0a, 0xf1, 0xcb, + 0x15, 0x65, 0x0b, 0xf0, 0xa4, 0xad, 0x2b, 0x26, 0x6c, 0x9d, 0xfe, 0x4f, 0x1a, 0x34, 0x36, 0x08, + 0xbe, 0xef, 0xba, 0x03, 0x6a, 0x99, 0x2f, 0x41, 0xcb, 0xc3, 0x7d, 0xd7, 0xb3, 0x7a, 0xd8, 0x09, + 0x3c, 0x1b, 0xb3, 0xf4, 0x46, 0xc9, 0x68, 0xb2, 0xd6, 0x77, 0x59, 0x23, 0x01, 0x23, 0xe6, 0xcb, + 0x0f, 0xcc, 0xd1, 0xb8, 0x77, 0x40, 0x14, 0x26, 0x4b, 0xb4, 0x37, 0x45, 0x2b, 0xd5, 0x97, 0x2f, + 0x40, 0x23, 0x02, 0x0b, 0x5c, 0x3a, 0x7f, 0xc9, 0xa8, 0x8b, 0xb6, 0x5d, 0x17, 0x5d, 0x84, 0x16, + 0x25, 0x78, 0x6f, 0xe8, 0x0e, 0x7a, 0x24, 0x68, 0xe6, 0x46, 0xbb, 0x61, 0xf1, 0x65, 0x11, 0x46, + 0x8a, 0x43, 0xf9, 0xf6, 0xd7, 0x30, 0x37, 0xdb, 0x02, 0x6a, 0xc7, 0xfe, 0x1a, 0xd6, 0x7f, 0x49, + 0x83, 0x26, 0xb7, 0xf2, 0x3b, 0xe2, 0x44, 0x84, 0xe6, 0x7b, 0x59, 0xc2, 0x82, 0xfe, 0x46, 0x9f, + 0x8f, 0x67, 0xfc, 0x2e, 0x2a, 0x85, 0x91, 0x0e, 0x42, 0xbd, 0xcf, 0x98, 0x89, 0xcf, 0x13, 0x31, + 0x7f, 0x83, 0xe0, 0xd4, 0x0c, 0xcc, 0x7b, 0xae, 0xc5, 0x12, 0x90, 0x1d, 0x58, 0x30, 0x2d, 0xcb, + 0xc3, 0xbe, 0xcf, 0xd7, 0x11, 0x3e, 0x92, 0x37, 0xa1, 0x5e, 0x66, 0xba, 0x2a, 0x7c, 0x44, 0x5f, + 0x48, 0x1c, 0x54, 0xd4, 0x57, 0x2f, 0x64, 0xaf, 0x93, 0xc7, 0x77, 0xd1, 0x51, 0xc6, 0x0f, 0x0b, + 0xd0, 0xe2, 0x3c, 0xbc, 0xc6, 0x0d, 0xf2, 0x74, 0x16, 0x5b, 0x83, 0xc6, 0x41, 0x24, 0x83, 0xd3, + 0xf2, 0x53, 0xb2, 0xa8, 0xc6, 0xfa, 0xcc, 0xe2, 0xb5, 0xb8, 0x4b, 0x50, 0x9a, 0xcb, 0x25, 0x28, + 0x1f, 0x57, 0x93, 0xa4, 0x5d, 0xc3, 0x8a, 0xc2, 0x35, 0xd4, 0x7f, 0x06, 0xea, 0xd2, 0x00, 0x54, + 0x53, 0xb2, 0x14, 0x10, 0xc7, 0x58, 0xf8, 0x88, 0x6e, 0x45, 0x8e, 0x11, 0x43, 0xd5, 0xb3, 0x8a, + 0xb5, 0x24, 0x7c, 0x22, 0xfd, 0xc7, 0x1a, 0x54, 0xf8, 0xc8, 0xcf, 0x43, 0x9d, 0xcb, 0x17, 0x75, + 0x15, 0xd9, 0xe8, 0xc0, 0x9b, 0x88, 0xaf, 0xf8, 0xe4, 0x04, 0xec, 0x59, 0xa8, 0x26, 0x44, 0x6b, + 0x81, 0xab, 0xe7, 0xf0, 0x95, 0x24, 0x4f, 0xe4, 0x15, 0x11, 0x25, 0xb4, 0x0c, 0xe5, 0xa1, 0x3b, + 0x10, 0xa7, 0x4a, 0xec, 0x41, 0xff, 0x89, 0x46, 0xb3, 0xf9, 0x06, 0xee, 0xbb, 0x0f, 0xb1, 0x77, + 0x34, 0x7f, 0x42, 0xf4, 0x4d, 0x89, 0xcd, 0x73, 0x46, 0x65, 0xa2, 0x03, 0x7a, 0x33, 0x22, 0x42, + 0x51, 0x95, 0x37, 0x91, 0x55, 0x39, 0x67, 0xd2, 0x88, 0x18, 0xbf, 0xa9, 0xd1, 0xd4, 0x6e, 0x7c, + 0x2b, 0x27, 0xf5, 0x3a, 0x9e, 0x48, 0xfc, 0xa2, 0xff, 0xa3, 0x06, 0xcf, 0x66, 0x60, 0x77, 0x6f, + 0xf5, 0x53, 0xc0, 0xef, 0xe7, 0xa1, 0x2a, 0x62, 0xf8, 0x62, 0xae, 0x18, 0x5e, 0xc0, 0xeb, 0xbf, + 0xc3, 0x0e, 0x18, 0x14, 0xe8, 0xdd, 0x5b, 0x7d, 0x4a, 0x08, 0x4e, 0xe6, 0xe2, 0x8a, 0x8a, 0x5c, + 0xdc, 0x3f, 0x6b, 0xd0, 0x8d, 0x72, 0x5f, 0xfe, 0xda, 0xd1, 0xbc, 0x27, 0x52, 0x4f, 0x26, 0x72, + 0xfd, 0x9c, 0x38, 0x3c, 0x21, 0x7a, 0x31, 0x57, 0xcc, 0x19, 0x1e, 0x9d, 0x38, 0x34, 0x8d, 0x9e, + 0xde, 0xd0, 0x3c, 0x52, 0xd9, 0x95, 0x08, 0xcf, 0x0e, 0x50, 0x22, 0xc2, 0xfe, 0x98, 0x31, 0xe9, + 0x9d, 0x78, 0x02, 0xec, 0xd3, 0x46, 0xa0, 0x7c, 0xa8, 0xf3, 0x80, 0x1f, 0xea, 0x94, 0x12, 0x87, + 0x3a, 0xbc, 0x5d, 0x1f, 0x51, 0x16, 0x48, 0x6d, 0xe0, 0x69, 0x21, 0xec, 0x57, 0x34, 0xe8, 0xf0, + 0x59, 0x58, 0x7d, 0x83, 0x3b, 0x1a, 0x0f, 0x71, 0x80, 0xad, 0x4f, 0x3a, 0x09, 0xf3, 0xe7, 0x05, + 0x68, 0xcb, 0x8e, 0x0d, 0xf5, 0x4d, 0x5e, 0x87, 0x32, 0xcd, 0x72, 0xf1, 0x15, 0xcc, 0xd4, 0x0e, + 0x0c, 0x9a, 0x58, 0x46, 0x1a, 0x55, 0xec, 0xfa, 0xa1, 0xe3, 0xc2, 0x1f, 0x23, 0xef, 0xaa, 0x78, + 0x7c, 0xef, 0xea, 0x39, 0xa8, 0x11, 0xcb, 0xe5, 0x4e, 0xc8, 0xb8, 0xec, 0xa4, 0x3d, 0x6a, 0x40, + 0x6f, 0x41, 0x85, 0x95, 0x04, 0xf1, 0x83, 0xce, 0x4b, 0xf1, 0xa1, 0x79, 0xb9, 0x90, 0x74, 0x50, + 0x41, 0x1b, 0x0c, 0xde, 0x89, 0xd0, 0x68, 0xec, 0xb9, 0x03, 0xea, 0x86, 0x11, 0xa3, 0x56, 0x36, + 0xc4, 0x33, 0x71, 0x13, 0xdd, 0xf1, 0xe6, 0x06, 0x4f, 0xd9, 0xd0, 0xdf, 0xfa, 0x4f, 0xc1, 0x4a, + 0x94, 0x21, 0x60, 0xcb, 0x3c, 0x29, 0x93, 0xeb, 0x7f, 0x53, 0x80, 0xd3, 0x3b, 0x47, 0x4e, 0x3f, + 0x29, 0x2e, 0x2b, 0x50, 0x19, 0x0f, 0xcd, 0x28, 0xa5, 0xce, 0x9f, 0x68, 0xb9, 0x42, 0x18, 0xfb, + 0x13, 0xb3, 0xce, 0x70, 0x5c, 0x17, 0x6d, 0xbb, 0xee, 0x4c, 0x6f, 0xeb, 0x92, 0x48, 0x69, 0x60, + 0x8b, 0x39, 0x10, 0x2c, 0x65, 0xd8, 0x14, 0xad, 0xd4, 0x81, 0x78, 0x0b, 0x80, 0xfa, 0x58, 0xbd, + 0xe3, 0xf8, 0x55, 0xb4, 0xc7, 0x5d, 0xe2, 0x57, 0x25, 0xeb, 0x2a, 0x2a, 0xe9, 0xb4, 0xff, 0x0b, + 0x92, 0x5a, 0xee, 0xd9, 0x16, 0xc7, 0xb1, 0x24, 0xbd, 0x16, 0x7a, 0x11, 0x9a, 0x91, 0xbc, 0x13, + 0x98, 0x6a, 0x4a, 0x09, 0x58, 0xfa, 0x7f, 0x14, 0xa0, 0x23, 0x11, 0xe4, 0x93, 0xf6, 0x6e, 0x33, + 0x62, 0xe3, 0xe2, 0x13, 0x8a, 0x8d, 0x4b, 0xf3, 0x7b, 0xb4, 0x65, 0x55, 0xb2, 0x53, 0x24, 0x8e, + 0x2a, 0xc7, 0x2a, 0x00, 0xfa, 0x66, 0x11, 0x5a, 0x11, 0xb2, 0xb7, 0x87, 0xa6, 0x93, 0xc9, 0xab, + 0x3b, 0xd0, 0xf2, 0x63, 0xc4, 0xe0, 0xe8, 0xfd, 0x8c, 0x4a, 0xf2, 0x33, 0xe8, 0x67, 0x24, 0x86, + 0x40, 0xe7, 0x28, 0x5b, 0x7a, 0x01, 0x4b, 0x92, 0x32, 0xaf, 0xb6, 0xc6, 0x54, 0x8c, 0x3d, 0xc2, + 0xe8, 0x65, 0x40, 0x5c, 0x2f, 0xf4, 0x6c, 0xa7, 0xe7, 0xe3, 0xbe, 0xeb, 0x58, 0x4c, 0x63, 0x94, + 0x8d, 0x36, 0x7f, 0xb3, 0xe9, 0xec, 0xb0, 0x76, 0xf4, 0x3a, 0x94, 0x82, 0xa3, 0x31, 0x73, 0x71, + 0x5b, 0x4a, 0x27, 0x31, 0x5a, 0xd7, 0xee, 0xd1, 0x18, 0x1b, 0x14, 0x3c, 0xac, 0x65, 0x0b, 0x3c, + 0x33, 0xc4, 0x5f, 0xc9, 0x90, 0x5a, 0xe4, 0x2c, 0xc3, 0x42, 0x3c, 0xcb, 0x40, 0x65, 0x4f, 0xf0, + 0x73, 0x10, 0x0c, 0x39, 0x43, 0x4b, 0x5c, 0xbe, 0x1b, 0x0c, 0xc9, 0x26, 0x03, 0x37, 0x30, 0x87, + 0x4c, 0x82, 0x6b, 0x5c, 0xdf, 0x91, 0x16, 0x1a, 0x9b, 0xff, 0x4b, 0x01, 0x96, 0x52, 0x08, 0xcb, + 0x24, 0xc3, 0xf4, 0xc4, 0xd7, 0x2c, 0x6d, 0xf1, 0x45, 0xa8, 0x73, 0x6e, 0x3a, 0x06, 0x37, 0x02, + 0xeb, 0x72, 0x77, 0x8a, 0x78, 0x94, 0x9f, 0x90, 0x78, 0x54, 0x4e, 0x90, 0x3a, 0x52, 0x13, 0x47, + 0xff, 0x07, 0x0d, 0x96, 0xe3, 0xac, 0x6d, 0x60, 0x7f, 0x32, 0xcc, 0xc6, 0xec, 0xf4, 0x7c, 0x01, + 0xd7, 0xf7, 0x49, 0x53, 0xc1, 0x2d, 0xda, 0x3b, 0x29, 0x17, 0xfa, 0x62, 0x1e, 0xb1, 0x88, 0xdc, + 0x07, 0x79, 0x23, 0xa5, 0xf8, 0x46, 0x7e, 0x4b, 0x83, 0x33, 0x29, 0x0b, 0x35, 0x8f, 0x17, 0x73, + 0x1b, 0x16, 0x3c, 0x8a, 0x8a, 0x50, 0x84, 0xaf, 0x4c, 0x5d, 0x6b, 0x84, 0x3a, 0x23, 0xec, 0xa7, + 0xef, 0xc0, 0x4a, 0xe8, 0xeb, 0x44, 0x74, 0xd9, 0xc2, 0x81, 0x39, 0x25, 0x96, 0x7e, 0x1e, 0xea, + 0x2c, 0x28, 0x63, 0x31, 0x2a, 0x3b, 0x39, 0x86, 0x7d, 0x91, 0x44, 0xd5, 0x7f, 0xbb, 0x00, 0xcb, + 0xd4, 0x59, 0x48, 0x1e, 0x03, 0xe6, 0x39, 0x97, 0xd6, 0x85, 0x85, 0x22, 0xd6, 0x88, 0xed, 0xac, + 0x66, 0xc4, 0xda, 0xd0, 0x66, 0x3a, 0xc7, 0xaa, 0xcc, 0xb9, 0x44, 0x07, 0xf1, 0x1b, 0x66, 0x60, + 0xd2, 0x73, 0xf8, 0x64, 0x72, 0x35, 0x72, 0x52, 0x4a, 0x27, 0x71, 0x52, 0x5e, 0x82, 0x36, 0x3b, + 0x9f, 0xe8, 0x89, 0x10, 0x9e, 0xaa, 0xad, 0x92, 0xb1, 0xc8, 0xda, 0x77, 0xc3, 0x66, 0xfd, 0x2e, + 0x3c, 0x93, 0x40, 0xca, 0x1c, 0xb4, 0xd7, 0xff, 0x44, 0x23, 0x94, 0x8b, 0x15, 0x84, 0x9d, 0xdc, + 0xa7, 0x3f, 0x27, 0x8e, 0x2a, 0x89, 0x31, 0x4f, 0x28, 0x23, 0x0b, 0xbd, 0x0d, 0x35, 0x07, 0x3f, + 0xea, 0xc9, 0x6e, 0x62, 0x8e, 0x80, 0xa7, 0xea, 0xe0, 0x47, 0xf4, 0x97, 0x7e, 0x0f, 0xce, 0xa4, + 0x96, 0x3a, 0xcf, 0xde, 0xff, 0x52, 0x83, 0x67, 0x37, 0x3c, 0x77, 0xbc, 0x67, 0x7b, 0xc1, 0xc4, + 0x1c, 0xc6, 0xab, 0x21, 0x4e, 0xb0, 0xfd, 0x1c, 0xc5, 0xa6, 0xef, 0xa7, 0xf4, 0xc2, 0xcb, 0x0a, + 0x59, 0x4b, 0x2f, 0x2a, 0xa5, 0x1f, 0xf4, 0x7f, 0x2f, 0xaa, 0x16, 0x1f, 0x5a, 0x8b, 0xe9, 0x7e, + 0x51, 0x9e, 0xd8, 0x4b, 0x79, 0x1c, 0x52, 0x3c, 0xe9, 0x71, 0x48, 0x86, 0x99, 0x28, 0x3d, 0x21, + 0x33, 0x71, 0xec, 0xbc, 0xe0, 0x3a, 0xc4, 0x8f, 0xaa, 0xa8, 0x99, 0x3f, 0xee, 0xf1, 0xd6, 0x5b, + 0x00, 0xd1, 0x89, 0x0d, 0x2f, 0xe0, 0x9d, 0x31, 0x82, 0xd4, 0x81, 0xd0, 0x48, 0x18, 0x62, 0xee, + 0x28, 0x48, 0x19, 0xfa, 0x0f, 0xa1, 0xab, 0xe2, 0xcd, 0x79, 0xf8, 0xfd, 0x5f, 0x0b, 0x00, 0x9b, + 0xa2, 0x4a, 0xfc, 0x64, 0xb6, 0x22, 0xe5, 0xb2, 0xa7, 0x79, 0xc7, 0x4a, 0xb9, 0xfe, 0x45, 0xb5, + 0xeb, 0x2f, 0xc9, 0x0a, 0x63, 0x85, 0xa4, 0x7e, 0x3e, 0x0b, 0x35, 0xcf, 0x7d, 0xd4, 0x23, 0xc2, + 0x65, 0x85, 0x65, 0xf0, 0x9e, 0xfb, 0x88, 0x88, 0x9c, 0x85, 0xce, 0xc0, 0x42, 0x60, 0xfa, 0x87, + 0x64, 0x7c, 0x96, 0xab, 0xac, 0x90, 0xc7, 0x4d, 0x0b, 0x2d, 0x43, 0xf9, 0xc0, 0x1e, 0x62, 0x56, + 0x3a, 0x53, 0x33, 0xd8, 0x03, 0xfa, 0x6c, 0x58, 0x82, 0x59, 0xcd, 0x5d, 0x6a, 0xc5, 0xaa, 0x30, + 0x5f, 0x84, 0x26, 0xe1, 0x24, 0xb2, 0x08, 0x26, 0xd6, 0x6d, 0x7e, 0x4e, 0xc1, 0x1b, 0x69, 0x89, + 0xc5, 0x4f, 0x34, 0x58, 0x8c, 0x50, 0x4b, 0x75, 0x13, 0x51, 0x77, 0x54, 0xd5, 0xad, 0xbb, 0x16, + 0xd3, 0x22, 0xad, 0x0c, 0xbb, 0xc2, 0x3a, 0x32, 0x85, 0x16, 0x75, 0x99, 0x96, 0x5c, 0x20, 0x9b, + 0x27, 0x98, 0xb1, 0xad, 0x30, 0xdd, 0x55, 0xf1, 0xdc, 0x47, 0x9b, 0x96, 0x40, 0x19, 0xab, 0x68, + 0x67, 0xa1, 0x34, 0x41, 0xd9, 0x3a, 0x2d, 0x6a, 0x7f, 0x11, 0x9a, 0xd8, 0xf3, 0x5c, 0xaf, 0x37, + 0xc2, 0xbe, 0x6f, 0x0e, 0xc2, 0x62, 0x91, 0x06, 0x6d, 0xdc, 0x62, 0x6d, 0xfa, 0x5f, 0x95, 0xa0, + 0x15, 0x6d, 0x25, 0x2c, 0xdb, 0xb0, 0xad, 0xb0, 0x6c, 0xc3, 0x26, 0xf4, 0x05, 0x8f, 0x69, 0x49, + 0xc1, 0x01, 0x6b, 0x85, 0x8e, 0x66, 0xd4, 0x78, 0xeb, 0xa6, 0x45, 0x8c, 0x3b, 0x41, 0x90, 0xe3, + 0x5a, 0x38, 0xe2, 0x00, 0x08, 0x9b, 0x54, 0xb1, 0x5f, 0x29, 0x07, 0x23, 0x95, 0x73, 0x30, 0x52, + 0x45, 0xc1, 0x48, 0x2b, 0x50, 0xd9, 0x9f, 0xf4, 0x0f, 0x71, 0xc0, 0x9d, 0x42, 0xfe, 0x14, 0x67, + 0xb0, 0x6a, 0x82, 0xc1, 0x04, 0x1f, 0xd5, 0x64, 0x3e, 0x3a, 0x0b, 0xb5, 0xd0, 0x52, 0xfb, 0xf4, + 0x74, 0xb2, 0x68, 0x54, 0xb9, 0x89, 0xf6, 0xd1, 0x1b, 0xa1, 0xcb, 0x58, 0xa7, 0x12, 0xa5, 0x2b, + 0x14, 0x52, 0x82, 0x4b, 0x42, 0x87, 0xf1, 0x0a, 0x2c, 0x4a, 0xe8, 0xa0, 0x7c, 0xc6, 0x8e, 0x30, + 0xa5, 0x88, 0x82, 0x5a, 0x90, 0x4b, 0xd0, 0x8a, 0x50, 0x42, 0xe1, 0x9a, 0x2c, 0xfe, 0x13, 0xad, + 0x14, 0x4c, 0xb0, 0x7b, 0xeb, 0x98, 0xec, 0xfe, 0x2c, 0x54, 0x79, 0x04, 0xe6, 0xf3, 0x33, 0x4c, + 0x91, 0xe2, 0xc9, 0x25, 0x09, 0x5f, 0x05, 0x14, 0x6d, 0x71, 0x3e, 0xbf, 0x34, 0xc1, 0x43, 0x85, + 0x24, 0x0f, 0xe9, 0x7f, 0xaa, 0xc1, 0x92, 0x3c, 0xd9, 0x49, 0x0d, 0xf7, 0xdb, 0x50, 0x67, 0x87, + 0xc8, 0x3d, 0xa2, 0x42, 0xd4, 0x67, 0xad, 0x09, 0xe2, 0x19, 0x10, 0xdd, 0xb7, 0x21, 0x88, 0x79, + 0xe4, 0x7a, 0x87, 0xb6, 0x33, 0xe8, 0x91, 0x95, 0x89, 0x14, 0x34, 0x6f, 0xbc, 0x47, 0xda, 0xf4, + 0x5f, 0xd7, 0xe0, 0xfc, 0xfd, 0xb1, 0x65, 0x06, 0x58, 0xf2, 0x60, 0xe6, 0xad, 0x5f, 0x15, 0x05, + 0xa4, 0x85, 0x29, 0x64, 0x96, 0xe6, 0xf3, 0x79, 0x01, 0x29, 0xf1, 0xfb, 0xf8, 0x6a, 0x52, 0x15, + 0xdf, 0x27, 0x5f, 0x4d, 0x17, 0xaa, 0x0f, 0xf9, 0x70, 0xe1, 0x55, 0xa0, 0xf0, 0x39, 0x76, 0x98, + 0x5d, 0x3c, 0xd6, 0x61, 0xb6, 0xbe, 0x05, 0xcf, 0x1a, 0xd8, 0xc7, 0x8e, 0x15, 0xdb, 0xc8, 0x89, + 0x93, 0x72, 0x63, 0xe8, 0xaa, 0x86, 0x9b, 0x87, 0x53, 0x99, 0xe3, 0xdb, 0xf3, 0xc8, 0xb0, 0x01, + 0x57, 0xd6, 0xc4, 0xdf, 0xa2, 0xf3, 0x04, 0xfa, 0x9f, 0x15, 0xe0, 0xcc, 0x6d, 0xcb, 0xe2, 0x7a, + 0x9e, 0xbb, 0x72, 0x4f, 0xcb, 0xcb, 0x4e, 0x7a, 0xa1, 0xc5, 0xb4, 0x17, 0xfa, 0xa4, 0x74, 0x2f, + 0xb7, 0x42, 0xce, 0x64, 0x14, 0x9a, 0x60, 0x8f, 0x55, 0xbc, 0xbd, 0xc9, 0x8f, 0x7c, 0x7b, 0x43, + 0x77, 0x40, 0xcd, 0xf0, 0x6c, 0xe7, 0xac, 0x1a, 0x26, 0x17, 0xf5, 0x31, 0x74, 0xd2, 0xc8, 0x9a, + 0x53, 0x8f, 0x84, 0x18, 0x19, 0xbb, 0x2c, 0x71, 0xdd, 0x20, 0x9e, 0x18, 0x6d, 0xda, 0x76, 0x7d, + 0xfd, 0xbf, 0x0a, 0xd0, 0xd9, 0x31, 0x1f, 0xe2, 0xff, 0x3b, 0x04, 0xfa, 0x32, 0x2c, 0xfb, 0xe6, + 0x43, 0xdc, 0x93, 0x02, 0xf0, 0x9e, 0x87, 0x3f, 0xe6, 0x4e, 0xec, 0x4b, 0xaa, 0x6c, 0xa1, 0xb2, + 0x52, 0xcb, 0x58, 0xf2, 0x63, 0xed, 0x06, 0xfe, 0x18, 0x5d, 0x86, 0x45, 0xb9, 0xfc, 0x30, 0xcc, + 0xeb, 0x36, 0x8c, 0xa6, 0x54, 0x62, 0xb8, 0x69, 0xe9, 0x1f, 0xc3, 0x73, 0xf7, 0x1d, 0x1f, 0x07, + 0x9b, 0x51, 0x99, 0xdc, 0x9c, 0xf1, 0xe7, 0xf3, 0x50, 0x8f, 0x10, 0x9f, 0xba, 0x03, 0x64, 0xf9, + 0xba, 0x0b, 0xdd, 0x2d, 0xd3, 0x3b, 0x0c, 0xd3, 0xf1, 0x1b, 0xac, 0xaa, 0xe8, 0x29, 0x4e, 0x78, + 0x20, 0xea, 0xeb, 0x0c, 0x7c, 0x80, 0x3d, 0xec, 0xf4, 0xf1, 0x5d, 0xb7, 0x7f, 0x48, 0x1c, 0x92, + 0x80, 0xdd, 0xde, 0xd4, 0x24, 0xdf, 0x75, 0x43, 0xba, 0x65, 0x59, 0x88, 0xdd, 0xb2, 0x9c, 0x71, + 0x11, 0x59, 0xff, 0x7e, 0x01, 0x56, 0x6e, 0x0f, 0x03, 0xec, 0x45, 0x19, 0x86, 0xe3, 0x24, 0x4b, + 0xa2, 0xec, 0x45, 0xe1, 0x24, 0xd9, 0x8b, 0x1c, 0x27, 0xb0, 0xaa, 0x5c, 0x4b, 0xe9, 0x84, 0xb9, + 0x96, 0xdb, 0x00, 0x63, 0xcf, 0x1d, 0x63, 0x2f, 0xb0, 0x71, 0x18, 0xfb, 0xe5, 0x70, 0x70, 0xa4, + 0x4e, 0xfa, 0x97, 0xa1, 0xfd, 0x5e, 0x7f, 0xdd, 0x75, 0x0e, 0x6c, 0x6f, 0x14, 0x22, 0x2a, 0x25, + 0x74, 0x5a, 0x0e, 0xa1, 0x2b, 0xa4, 0x84, 0x4e, 0xb7, 0x61, 0x49, 0x1a, 0x7b, 0x4e, 0xc5, 0x35, + 0xe8, 0xf7, 0x0e, 0x6c, 0xc7, 0xa6, 0x55, 0x7b, 0x05, 0xea, 0xa0, 0xc2, 0xa0, 0x7f, 0x87, 0xb7, + 0xe8, 0xdf, 0xd2, 0xe0, 0xac, 0x81, 0x89, 0xf0, 0x84, 0x85, 0x47, 0xbb, 0xc1, 0x96, 0x3f, 0x98, + 0xc3, 0xa1, 0xb8, 0x05, 0xa5, 0x91, 0x3f, 0xc8, 0x28, 0x1a, 0x20, 0x26, 0x3a, 0x36, 0x91, 0x41, + 0x81, 0xf5, 0x1f, 0x69, 0xb0, 0x1c, 0x1e, 0xad, 0xc6, 0x44, 0x38, 0xce, 0xb6, 0x5a, 0xaa, 0x76, + 0x7d, 0xca, 0x8d, 0xed, 0x33, 0xb0, 0x60, 0xed, 0xcb, 0x0a, 0xb2, 0x62, 0xed, 0x53, 0xdd, 0xa8, + 0xf0, 0x94, 0x4b, 0x4a, 0x4f, 0x39, 0xc9, 0xf8, 0x65, 0x45, 0xcd, 0xd6, 0x7d, 0xe8, 0x70, 0x07, + 0xe5, 0x83, 0x31, 0xf6, 0x4c, 0xca, 0x5f, 0xe1, 0xe2, 0x3f, 0x17, 0xba, 0xd0, 0x5a, 0xe6, 0xc5, + 0xc6, 0xe4, 0xb1, 0x2a, 0x77, 0xa2, 0xf5, 0xbf, 0xd3, 0xe0, 0x42, 0x72, 0xdc, 0x6d, 0x7e, 0xe8, + 0x38, 0xf7, 0x55, 0x7f, 0x7a, 0x62, 0x59, 0x88, 0x4e, 0x2c, 0xe7, 0x3a, 0x7a, 0x95, 0x4f, 0x47, + 0x4b, 0xf1, 0xd3, 0x51, 0xfd, 0x0a, 0x2c, 0xae, 0xbb, 0xc3, 0xc9, 0xc8, 0xa1, 0xf1, 0xd0, 0x1d, + 0x7b, 0x88, 0xa3, 0x98, 0x48, 0x93, 0x62, 0x22, 0xfd, 0xbb, 0x5a, 0x98, 0x58, 0xa0, 0x40, 0x97, + 0xa1, 0x25, 0xa2, 0xaa, 0x1e, 0x81, 0x60, 0xe5, 0x6f, 0xef, 0x9f, 0x32, 0x1a, 0x61, 0x70, 0x45, + 0xe1, 0xb6, 0x61, 0xa9, 0x4f, 0xc7, 0x97, 0x41, 0x0b, 0x99, 0x91, 0x53, 0x62, 0x2d, 0xef, 0x9f, + 0x32, 0x16, 0xfb, 0xf1, 0xa6, 0xb5, 0x0a, 0x94, 0xc8, 0x20, 0x44, 0x1d, 0xb6, 0xb7, 0x3d, 0x6e, + 0xcf, 0x43, 0x7a, 0x3e, 0x07, 0xb5, 0xfe, 0x70, 0xe2, 0x07, 0xd8, 0xe3, 0x5a, 0xb0, 0x66, 0x44, + 0x0d, 0xe4, 0x6d, 0x18, 0xbd, 0x8a, 0x73, 0x14, 0xd1, 0x20, 0xe9, 0xeb, 0x62, 0x4c, 0x5f, 0x3f, + 0x99, 0x6b, 0xe2, 0x91, 0xfa, 0xad, 0x9c, 0x44, 0xfd, 0xbe, 0x13, 0x7e, 0x10, 0xa0, 0x17, 0xe5, + 0x3d, 0xa6, 0xc5, 0x2f, 0x04, 0x55, 0x06, 0x8f, 0x78, 0xee, 0x50, 0x02, 0xbe, 0x0e, 0x75, 0x73, + 0x12, 0xb8, 0x9b, 0x1b, 0x86, 0xe9, 0x0c, 0x28, 0x95, 0xf7, 0xf1, 0xc0, 0x76, 0xc2, 0xbb, 0xf4, + 0xf4, 0x01, 0xb5, 0xa1, 0x88, 0x9d, 0x50, 0xe3, 0x91, 0x9f, 0xfa, 0xb7, 0xcb, 0xd0, 0xfc, 0x7f, + 0x1c, 0xe7, 0xc3, 0x31, 0xfa, 0x08, 0x9a, 0x0c, 0xc7, 0x3d, 0x8f, 0x20, 0x39, 0x4c, 0x44, 0xad, + 0x66, 0x0e, 0xc1, 0x71, 0x7a, 0xfd, 0x76, 0x44, 0x19, 0x9f, 0x5d, 0xdd, 0x6d, 0x48, 0xc4, 0xf2, + 0xd1, 0xcf, 0xd1, 0x2b, 0xff, 0xd4, 0x09, 0x11, 0x35, 0x5f, 0xac, 0xe4, 0xfa, 0xf5, 0x99, 0x63, + 0x73, 0xe7, 0x24, 0x3c, 0x4b, 0x60, 0xc3, 0x2f, 0xfa, 0xf1, 0xd6, 0x6e, 0x0f, 0x96, 0x52, 0x8b, + 0x90, 0xaf, 0x04, 0x17, 0xd9, 0x95, 0xe0, 0xd7, 0xe2, 0x57, 0x82, 0x55, 0x1e, 0xbf, 0xb4, 0x70, + 0xe9, 0x4e, 0x70, 0x77, 0x4d, 0xb8, 0x49, 0xb1, 0x95, 0x28, 0xe6, 0x58, 0x96, 0xe7, 0xa8, 0xc9, + 0xf7, 0x8a, 0x0f, 0xe1, 0x99, 0x0f, 0x27, 0xd8, 0x3b, 0xfa, 0x24, 0xe4, 0x5e, 0xff, 0xc3, 0x42, + 0x98, 0xef, 0x23, 0xc4, 0xa5, 0x11, 0xa4, 0x94, 0x45, 0x10, 0x3a, 0x6f, 0x26, 0x87, 0x40, 0xc4, + 0x21, 0xe8, 0x2c, 0xd4, 0x48, 0x47, 0x56, 0x96, 0xc9, 0x56, 0x52, 0x25, 0x0d, 0xb4, 0x2e, 0x33, + 0x7e, 0x66, 0x5c, 0x4c, 0x9c, 0x19, 0xa3, 0xbd, 0x28, 0xa6, 0xa0, 0x00, 0xcc, 0xb5, 0xba, 0x35, + 0x75, 0x72, 0xba, 0xea, 0xd0, 0x32, 0x90, 0x51, 0x18, 0xf5, 0xc3, 0x40, 0x84, 0xb4, 0x74, 0xdf, + 0x16, 0xa5, 0x43, 0x02, 0x40, 0x71, 0x17, 0x3c, 0x46, 0x94, 0xa2, 0x4c, 0x94, 0xef, 0x14, 0x60, + 0x25, 0x49, 0x95, 0x79, 0xcc, 0x5f, 0x44, 0x8f, 0x42, 0x4c, 0x47, 0xbc, 0x16, 0x37, 0x81, 0xe7, + 0x33, 0x37, 0x1e, 0x33, 0x7e, 0x2b, 0x50, 0xf1, 0xb0, 0xe9, 0xf3, 0xcf, 0x2f, 0xd4, 0x0c, 0xfe, + 0x44, 0xbf, 0x25, 0x32, 0x74, 0x83, 0xf0, 0x8e, 0x18, 0x7b, 0x20, 0x6e, 0x27, 0xa3, 0x0f, 0x4d, + 0xb8, 0xb0, 0x93, 0x69, 0x7d, 0x36, 0x86, 0x0d, 0x4a, 0x55, 0xfa, 0x53, 0x7f, 0x00, 0x88, 0x62, + 0xe3, 0xe9, 0x33, 0xe8, 0x0f, 0x0b, 0x61, 0x6a, 0x4c, 0xbe, 0x7f, 0x37, 0xfd, 0x58, 0x28, 0xce, + 0x63, 0x85, 0x24, 0x8f, 0xbd, 0x08, 0x4d, 0xc6, 0xad, 0xd8, 0x92, 0xb9, 0xb0, 0x11, 0x36, 0x52, + 0x20, 0xe9, 0xe6, 0x58, 0x69, 0x8e, 0x9b, 0x63, 0xe5, 0xe3, 0x96, 0x89, 0xdf, 0x81, 0x3a, 0xfb, + 0x3c, 0x14, 0x73, 0xd9, 0x18, 0x75, 0x2e, 0x25, 0xef, 0xeb, 0x5b, 0xf8, 0xf1, 0xf5, 0x4d, 0xf2, + 0x2f, 0xa1, 0x0e, 0x89, 0x57, 0xa9, 0xd3, 0x06, 0xf4, 0xc5, 0x26, 0xf5, 0xdc, 0xbe, 0x57, 0x80, + 0xd3, 0x31, 0x12, 0xfd, 0x4f, 0xe5, 0xd6, 0x3d, 0x58, 0xe6, 0xda, 0x28, 0x3c, 0x34, 0xa0, 0xa8, + 0xe1, 0x98, 0xb9, 0x98, 0x3d, 0xa5, 0x54, 0x42, 0x88, 0x6c, 0xb9, 0xc9, 0x27, 0x6d, 0xfa, 0x00, + 0x96, 0x48, 0xd8, 0xfc, 0xf4, 0x39, 0xf8, 0x07, 0x05, 0x68, 0x0a, 0xad, 0x41, 0xd3, 0xac, 0xb1, + 0x71, 0xb4, 0xec, 0x71, 0x0a, 0x53, 0xdd, 0x87, 0x93, 0x7d, 0x90, 0x29, 0x0a, 0xcc, 0xcb, 0xb1, + 0xc0, 0xfc, 0xb5, 0xf8, 0xa5, 0xd1, 0x63, 0x93, 0x72, 0x21, 0x46, 0xca, 0xb8, 0x8a, 0xa9, 0x9e, + 0x44, 0xc5, 0xfc, 0x7d, 0x01, 0x1a, 0x11, 0xce, 0xf6, 0x56, 0x3f, 0x55, 0xac, 0xc5, 0xe3, 0xbf, + 0x72, 0x2a, 0xfe, 0x8b, 0xb0, 0x5a, 0x51, 0x63, 0x75, 0xe1, 0x64, 0x58, 0xad, 0xc6, 0xb0, 0x7a, + 0x4b, 0x3e, 0xc8, 0x99, 0x69, 0x92, 0x19, 0xec, 0xb5, 0xb7, 0xc5, 0xcd, 0xe5, 0xdd, 0xa3, 0x31, + 0x46, 0x0b, 0x50, 0xbc, 0x87, 0x1f, 0xb5, 0x4f, 0x21, 0x80, 0xca, 0x3d, 0xd7, 0x1b, 0x99, 0xc3, + 0xb6, 0x86, 0xea, 0xb0, 0xc0, 0xcb, 0x89, 0xdb, 0x05, 0xd4, 0x84, 0xda, 0x7a, 0x58, 0x62, 0xd9, + 0x2e, 0x5e, 0xbb, 0x06, 0x0d, 0xb9, 0xc0, 0x8e, 0xf4, 0xbb, 0x8b, 0x07, 0x66, 0xff, 0xa8, 0x7d, + 0x0a, 0x55, 0xa0, 0x70, 0xf7, 0x66, 0x5b, 0xa3, 0xff, 0xbf, 0xda, 0x2e, 0x5c, 0xfb, 0x3d, 0x0d, + 0x96, 0x52, 0x11, 0x1a, 0x6a, 0x01, 0xdc, 0x77, 0xfa, 0xbc, 0x6a, 0xb8, 0x7d, 0x0a, 0x35, 0xa0, + 0x1a, 0xd6, 0x10, 0xb3, 0xb9, 0x77, 0x5d, 0x0a, 0xdd, 0x2e, 0xa0, 0x36, 0x34, 0x58, 0xc7, 0x49, + 0xbf, 0x8f, 0x7d, 0xbf, 0x5d, 0x14, 0x2d, 0x77, 0x4c, 0x7b, 0x38, 0xf1, 0x70, 0xbb, 0x44, 0xd6, + 0xb7, 0xeb, 0x1a, 0x78, 0x88, 0x4d, 0x1f, 0xb7, 0xcb, 0x08, 0x41, 0x8b, 0x3f, 0x84, 0x9d, 0x2a, + 0x52, 0x5b, 0xd8, 0x6d, 0xe1, 0xda, 0x5f, 0x68, 0x72, 0x45, 0x20, 0xc5, 0xc5, 0x19, 0x38, 0x7d, + 0xdf, 0xb1, 0xf0, 0x81, 0xed, 0x60, 0x2b, 0x7a, 0xd5, 0x3e, 0x85, 0x4e, 0xc3, 0xe2, 0x16, 0xf6, + 0x06, 0x58, 0x6a, 0x2c, 0xa0, 0x25, 0x68, 0x6e, 0xd9, 0x8f, 0xa5, 0xa6, 0x22, 0x5a, 0x86, 0xf6, + 0x8e, 0xed, 0x0c, 0x86, 0x32, 0x60, 0x89, 0xf6, 0xb6, 0x1d, 0xd7, 0x93, 0x1a, 0xcb, 0xb4, 0xd1, + 0xfc, 0x6a, 0xac, 0xb1, 0x82, 0xba, 0xb0, 0x42, 0x91, 0x7a, 0x73, 0x03, 0x13, 0x6c, 0x48, 0xef, + 0x16, 0xf4, 0x52, 0x55, 0x6b, 0x6b, 0xd7, 0x3e, 0x80, 0xba, 0xc4, 0x20, 0xa8, 0x0a, 0xa5, 0x7b, + 0xae, 0x43, 0x90, 0x58, 0x87, 0x85, 0x6d, 0xec, 0x58, 0xb6, 0x33, 0x68, 0x6b, 0x04, 0xc3, 0x9b, + 0x22, 0x2e, 0x6f, 0x17, 0x08, 0x8d, 0xc8, 0xc6, 0x09, 0xfd, 0x42, 0x72, 0xd2, 0x8a, 0xed, 0x76, + 0x69, 0xf5, 0x47, 0x97, 0xa0, 0xb6, 0x61, 0x06, 0xe6, 0xba, 0xeb, 0x7a, 0x16, 0x1a, 0x02, 0xa2, + 0xdf, 0x46, 0x19, 0x8d, 0x5d, 0x47, 0x7c, 0x47, 0x09, 0x5d, 0x4f, 0x64, 0x4b, 0xd8, 0x43, 0x1a, + 0x90, 0x6b, 0xcd, 0xee, 0x45, 0x25, 0x7c, 0x02, 0x58, 0x3f, 0x85, 0x46, 0x74, 0xb6, 0x5d, 0x7b, + 0x84, 0x77, 0xed, 0xfe, 0x61, 0x78, 0xa0, 0x72, 0x33, 0xe3, 0x63, 0x34, 0x69, 0xd0, 0x70, 0xbe, + 0x17, 0x95, 0xf3, 0xb1, 0x8f, 0xd7, 0x84, 0x86, 0x4e, 0x3f, 0x85, 0x3e, 0xa6, 0xc9, 0x9c, 0xe8, + 0x74, 0x2a, 0x9c, 0x70, 0x35, 0x7b, 0xc2, 0x14, 0xf0, 0x31, 0xa7, 0xbc, 0x0b, 0x65, 0x2a, 0x48, + 0x48, 0x55, 0xa7, 0x2a, 0x7f, 0xd7, 0xb1, 0x7b, 0x21, 0x1b, 0x40, 0x8c, 0xf6, 0x55, 0x58, 0x4c, + 0x7c, 0x1e, 0x0d, 0xa9, 0x32, 0xda, 0xea, 0x0f, 0xdd, 0x75, 0xaf, 0xe5, 0x01, 0x15, 0x73, 0x0d, + 0xa0, 0x15, 0xff, 0xa6, 0x0a, 0xba, 0x9a, 0xe3, 0xcb, 0x4c, 0x6c, 0xa6, 0x97, 0x72, 0x7f, 0xc3, + 0x89, 0x32, 0x41, 0x3b, 0xf9, 0xe1, 0x2e, 0x74, 0x6d, 0xea, 0x00, 0x71, 0x66, 0xfb, 0x4c, 0x2e, + 0x58, 0x31, 0xdd, 0x11, 0x65, 0x82, 0xd4, 0x57, 0x93, 0x92, 0x3c, 0x1e, 0x0e, 0x93, 0xf5, 0x39, + 0xa7, 0xee, 0x8d, 0xdc, 0xf0, 0x62, 0xea, 0x5f, 0x64, 0x97, 0xcd, 0x54, 0x5f, 0x1e, 0x42, 0xaf, + 0xaa, 0x87, 0x9b, 0xf2, 0xc9, 0xa4, 0xee, 0xea, 0x71, 0xba, 0x88, 0x45, 0x7c, 0x9d, 0xde, 0x12, + 0x53, 0x7c, 0xbb, 0x27, 0x29, 0x77, 0xe1, 0x78, 0xd9, 0x9f, 0x25, 0xea, 0xbe, 0x7a, 0x8c, 0x1e, + 0x62, 0x01, 0x6e, 0xf2, 0xcb, 0x68, 0xa1, 0x18, 0xde, 0x98, 0xc9, 0x35, 0x27, 0x93, 0xc1, 0xaf, + 0xc0, 0x62, 0xe2, 0x8c, 0x07, 0xe5, 0x3f, 0x07, 0xea, 0x4e, 0xf3, 0x87, 0x99, 0x48, 0x26, 0x6e, + 0x85, 0xa1, 0x0c, 0xee, 0x57, 0xdc, 0x1c, 0xeb, 0x5e, 0xcb, 0x03, 0x2a, 0x36, 0x32, 0x86, 0xa5, + 0xc4, 0xcb, 0xbd, 0x55, 0xf4, 0x99, 0xdc, 0xb3, 0xed, 0xad, 0x76, 0x5f, 0xce, 0x3f, 0xdf, 0xde, + 0xaa, 0x7e, 0x0a, 0xf9, 0x54, 0x41, 0x27, 0x6e, 0x16, 0xa1, 0x8c, 0x51, 0xd4, 0x37, 0xa8, 0xba, + 0xaf, 0xe4, 0x84, 0x16, 0xdb, 0x7c, 0x08, 0xa7, 0x15, 0x17, 0xc0, 0xd0, 0x2b, 0x53, 0xd9, 0x23, + 0x79, 0xf3, 0xad, 0x7b, 0x3d, 0x2f, 0xb8, 0x64, 0x1e, 0xda, 0xe1, 0xba, 0x6e, 0x0f, 0x87, 0xcc, + 0xbe, 0xbe, 0x9c, 0x65, 0xf9, 0x62, 0x60, 0x19, 0x5b, 0xcd, 0x84, 0x16, 0x53, 0xfe, 0x3c, 0xa0, + 0x9d, 0x07, 0xee, 0x23, 0x7a, 0xa6, 0x32, 0x98, 0xf0, 0x34, 0x7d, 0xa6, 0x01, 0x4c, 0x83, 0x66, + 0x08, 0xe2, 0xd4, 0x1e, 0x62, 0xf2, 0x1e, 0xc0, 0x7b, 0x38, 0xd8, 0xc2, 0x81, 0x47, 0xa4, 0xff, + 0x72, 0xd6, 0xda, 0x39, 0x40, 0x38, 0xd5, 0x95, 0x99, 0x70, 0x32, 0x42, 0xb7, 0x4c, 0x67, 0x62, + 0x0e, 0xa5, 0x0f, 0x93, 0xa8, 0x11, 0x9a, 0x04, 0x9b, 0x8e, 0xd0, 0x34, 0xb4, 0x98, 0xf2, 0x91, + 0xf0, 0x5f, 0xa4, 0x22, 0xf2, 0xe9, 0xfe, 0x4b, 0xfa, 0x3e, 0x54, 0x52, 0xb7, 0x4f, 0x81, 0x17, + 0x13, 0x7f, 0x43, 0xa3, 0xd7, 0x16, 0x13, 0x00, 0x1f, 0xd9, 0xc1, 0x83, 0xed, 0xa1, 0xe9, 0xf8, + 0x79, 0x96, 0x40, 0x01, 0x8f, 0xb1, 0x04, 0x0e, 0x2f, 0x96, 0x60, 0x41, 0x33, 0x56, 0x3f, 0x8d, + 0x54, 0xd5, 0xee, 0xaa, 0xb2, 0xf3, 0xee, 0xd5, 0xd9, 0x80, 0x62, 0x96, 0x03, 0x68, 0xc6, 0x4e, + 0xc4, 0x94, 0xb3, 0xa8, 0xce, 0xcc, 0x92, 0xca, 0x2e, 0x21, 0x1d, 0x49, 0x84, 0xfa, 0x80, 0xd2, + 0x65, 0xa2, 0x28, 0x5f, 0x51, 0xf1, 0x34, 0xd5, 0x93, 0x5d, 0x7b, 0xca, 0xb4, 0x79, 0xa2, 0x10, + 0x5b, 0x6d, 0x2a, 0x94, 0x75, 0xe5, 0x4a, 0x6d, 0x9e, 0x51, 0xd7, 0xad, 0x9f, 0x42, 0x1f, 0x41, + 0x85, 0x7f, 0xf7, 0xf8, 0xe2, 0xf4, 0x82, 0x2c, 0x3e, 0xfa, 0xa5, 0x19, 0x50, 0x62, 0xe0, 0x43, + 0x38, 0x93, 0x51, 0x8e, 0xa5, 0xf4, 0x32, 0xa6, 0x97, 0x6e, 0xcd, 0xb2, 0x7f, 0x62, 0xb2, 0x54, + 0xb5, 0xd5, 0x94, 0xc9, 0xb2, 0x2a, 0xb3, 0x66, 0x4d, 0xd6, 0x83, 0xa5, 0x54, 0x35, 0x8b, 0xd2, + 0x00, 0x66, 0xd5, 0xbc, 0xcc, 0x9a, 0x60, 0x00, 0xcf, 0x28, 0x2b, 0x37, 0x94, 0xbe, 0xc9, 0xb4, + 0x1a, 0x8f, 0x59, 0x13, 0xf5, 0xe1, 0xb4, 0xa2, 0x5e, 0x43, 0x69, 0xe3, 0xb2, 0xeb, 0x3a, 0x66, + 0x4d, 0x72, 0x00, 0xdd, 0x35, 0xcf, 0x35, 0xad, 0xbe, 0xe9, 0x07, 0xb4, 0x86, 0x82, 0x44, 0xb5, + 0xa1, 0x73, 0xa8, 0x8e, 0x1c, 0x94, 0x95, 0x16, 0xb3, 0xe6, 0xd9, 0x87, 0x3a, 0x25, 0x25, 0xfb, + 0xc8, 0x2c, 0x52, 0x5b, 0x08, 0x09, 0x22, 0x43, 0xed, 0xa8, 0x00, 0x05, 0x53, 0xef, 0x42, 0x7d, + 0x9d, 0x16, 0xa3, 0xd2, 0x2c, 0x67, 0xd2, 0x5a, 0xb1, 0x04, 0xa8, 0x04, 0x90, 0x1b, 0x43, 0x4d, + 0xea, 0xb3, 0x5b, 0xf8, 0x31, 0xa3, 0xf3, 0x55, 0xd5, 0xb8, 0x31, 0x90, 0x8c, 0x18, 0x47, 0x09, + 0x29, 0xd9, 0xf9, 0x65, 0xd9, 0x93, 0x15, 0xd3, 0xdd, 0xc8, 0x18, 0x24, 0x05, 0x19, 0xce, 0x7a, + 0x33, 0x7f, 0x07, 0xd9, 0x2e, 0x84, 0xeb, 0xa2, 0xa9, 0xe0, 0x24, 0x81, 0xe2, 0x4b, 0x97, 0xdd, + 0xd3, 0xab, 0xb3, 0x01, 0xc5, 0x2c, 0xdb, 0x50, 0xa3, 0xe9, 0x53, 0x4a, 0x9e, 0x8b, 0xaa, 0x8e, + 0xe2, 0x75, 0x7e, 0xe2, 0x6c, 0x60, 0xbf, 0xef, 0xd9, 0xfb, 0x9c, 0xe8, 0xca, 0xe5, 0xc4, 0x40, + 0xa6, 0x12, 0x27, 0x01, 0x29, 0x56, 0x3e, 0xa1, 0x3e, 0x83, 0x40, 0x1d, 0x57, 0x95, 0xaf, 0xcc, + 0xa2, 0x6f, 0x5c, 0x4d, 0x5e, 0xcf, 0x0b, 0x2e, 0xa6, 0xfd, 0x05, 0x1a, 0x07, 0xd1, 0xf7, 0x6b, + 0x13, 0x7b, 0x68, 0x85, 0xe9, 0x1a, 0x74, 0x73, 0xda, 0x50, 0x31, 0xd0, 0x4c, 0xf7, 0x6f, 0x4a, + 0x0f, 0x31, 0xff, 0x4f, 0x43, 0x4d, 0x54, 0xf3, 0x20, 0x55, 0x0d, 0x48, 0xb2, 0x8e, 0xa8, 0x7b, + 0x71, 0x3a, 0x90, 0x18, 0x19, 0xc3, 0xb2, 0xaa, 0x76, 0x47, 0x19, 0x62, 0x4f, 0x29, 0xf2, 0x99, + 0xc1, 0x1f, 0xab, 0x7f, 0xbd, 0x08, 0xd5, 0xb0, 0xe3, 0x27, 0x9c, 0xb8, 0xfa, 0x14, 0x32, 0x49, + 0x5f, 0x81, 0xc5, 0xc4, 0xb7, 0x43, 0x95, 0x1a, 0x5c, 0xfd, 0x7d, 0xd1, 0x59, 0xa2, 0xf6, 0x11, + 0xff, 0x6b, 0x1d, 0x22, 0xc4, 0xbb, 0x92, 0x95, 0x8d, 0x4a, 0x46, 0x77, 0x33, 0x06, 0xfe, 0xdf, + 0x1d, 0xe0, 0xdc, 0x03, 0x90, 0x42, 0x9b, 0x17, 0x66, 0x5e, 0x2e, 0x9d, 0x85, 0xad, 0x91, 0x32, + 0x7a, 0x79, 0x69, 0xfa, 0x05, 0xdb, 0x59, 0x1e, 0x68, 0x76, 0xcc, 0x72, 0x1f, 0x1a, 0xf2, 0x37, + 0x1c, 0x90, 0xf2, 0x0f, 0x29, 0xa4, 0x3f, 0xf2, 0x30, 0x6b, 0x17, 0x5b, 0xc7, 0x74, 0x6c, 0x67, + 0x0c, 0xe7, 0x03, 0x4a, 0x57, 0xb5, 0x2b, 0x03, 0x81, 0xcc, 0x5a, 0x7a, 0x65, 0x20, 0x90, 0x5d, + 0x2a, 0xcf, 0x92, 0x92, 0xc9, 0x52, 0x6d, 0x65, 0x52, 0x32, 0xa3, 0xf8, 0x5d, 0x99, 0x94, 0xcc, + 0xaa, 0xfd, 0x96, 0xe4, 0x6f, 0x6a, 0xe8, 0xa6, 0xfa, 0x63, 0x32, 0xb3, 0x90, 0x67, 0xc1, 0xca, + 0x3d, 0x37, 0xb0, 0x0f, 0x8e, 0x92, 0x45, 0x7b, 0x4a, 0xb7, 0x39, 0xab, 0x62, 0x70, 0xb6, 0x94, + 0x9f, 0xa3, 0x5e, 0x5b, 0x56, 0x65, 0x20, 0xca, 0x53, 0x62, 0xd8, 0xbd, 0x95, 0x63, 0x45, 0x0a, + 0x3b, 0xf6, 0x01, 0xd4, 0xc4, 0x69, 0xaa, 0x72, 0xa2, 0x64, 0xdd, 0xcc, 0xac, 0xdd, 0x7c, 0x09, + 0xaa, 0x0c, 0x7e, 0x6f, 0x15, 0x5d, 0x98, 0x55, 0x68, 0x34, 0x3b, 0xa2, 0x68, 0xc5, 0xcb, 0x44, + 0x94, 0x69, 0x74, 0x65, 0x7d, 0x8f, 0x32, 0x8d, 0xae, 0xae, 0x39, 0xd1, 0x4f, 0xa1, 0x9f, 0x85, + 0xba, 0x74, 0xbc, 0x8f, 0x2e, 0x65, 0xf5, 0x8d, 0x4f, 0x71, 0x79, 0x16, 0x98, 0x18, 0xff, 0x43, + 0x80, 0xe8, 0x78, 0x5c, 0x29, 0xd9, 0xa9, 0xd3, 0xf3, 0x19, 0xb8, 0x59, 0xbb, 0xf5, 0xe5, 0x57, + 0x07, 0x76, 0xf0, 0x60, 0xb2, 0x4f, 0xde, 0xdc, 0x60, 0xa0, 0xaf, 0xd8, 0x2e, 0xff, 0x75, 0x23, + 0x54, 0xf2, 0x37, 0x68, 0xef, 0x1b, 0x64, 0x8e, 0xf1, 0xfe, 0x7e, 0x85, 0x3e, 0xdd, 0xfa, 0xef, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xaf, 0x2a, 0x22, 0x9f, 0x6b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -7446,6 +8564,12 @@ type DataNodeClient interface { FlushChannels(ctx context.Context, in *FlushChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) NotifyChannelOperation(ctx context.Context, in *ChannelOperationsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) CheckChannelOperationProgress(ctx context.Context, in *ChannelWatchInfo, opts ...grpc.CallOption) (*ChannelOperationProgressResponse, error) + // import v2 + PreImport(ctx context.Context, in *PreImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) + ImportV2(ctx context.Context, in *ImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) + QueryPreImport(ctx context.Context, in *QueryPreImportRequest, opts ...grpc.CallOption) (*QueryPreImportResponse, error) + QueryImport(ctx context.Context, in *QueryImportRequest, opts ...grpc.CallOption) (*QueryImportResponse, error) + DropImport(ctx context.Context, in *DropImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) } type dataNodeClient struct { @@ -7591,6 +8715,51 @@ func (c *dataNodeClient) CheckChannelOperationProgress(ctx context.Context, in * return out, nil } +func (c *dataNodeClient) PreImport(ctx context.Context, in *PreImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + out := new(commonpb.Status) + err := c.cc.Invoke(ctx, "/milvus.proto.data.DataNode/PreImport", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *dataNodeClient) ImportV2(ctx context.Context, in *ImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + out := new(commonpb.Status) + err := c.cc.Invoke(ctx, "/milvus.proto.data.DataNode/ImportV2", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *dataNodeClient) QueryPreImport(ctx context.Context, in *QueryPreImportRequest, opts ...grpc.CallOption) (*QueryPreImportResponse, error) { + out := new(QueryPreImportResponse) + err := c.cc.Invoke(ctx, "/milvus.proto.data.DataNode/QueryPreImport", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *dataNodeClient) QueryImport(ctx context.Context, in *QueryImportRequest, opts ...grpc.CallOption) (*QueryImportResponse, error) { + out := new(QueryImportResponse) + err := c.cc.Invoke(ctx, "/milvus.proto.data.DataNode/QueryImport", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *dataNodeClient) DropImport(ctx context.Context, in *DropImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + out := new(commonpb.Status) + err := c.cc.Invoke(ctx, "/milvus.proto.data.DataNode/DropImport", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // DataNodeServer is the server API for DataNode service. type DataNodeServer interface { GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) @@ -7611,6 +8780,12 @@ type DataNodeServer interface { FlushChannels(context.Context, *FlushChannelsRequest) (*commonpb.Status, error) NotifyChannelOperation(context.Context, *ChannelOperationsRequest) (*commonpb.Status, error) CheckChannelOperationProgress(context.Context, *ChannelWatchInfo) (*ChannelOperationProgressResponse, error) + // import v2 + PreImport(context.Context, *PreImportRequest) (*commonpb.Status, error) + ImportV2(context.Context, *ImportRequest) (*commonpb.Status, error) + QueryPreImport(context.Context, *QueryPreImportRequest) (*QueryPreImportResponse, error) + QueryImport(context.Context, *QueryImportRequest) (*QueryImportResponse, error) + DropImport(context.Context, *DropImportRequest) (*commonpb.Status, error) } // UnimplementedDataNodeServer can be embedded to have forward compatible implementations. @@ -7662,6 +8837,21 @@ func (*UnimplementedDataNodeServer) NotifyChannelOperation(ctx context.Context, func (*UnimplementedDataNodeServer) CheckChannelOperationProgress(ctx context.Context, req *ChannelWatchInfo) (*ChannelOperationProgressResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CheckChannelOperationProgress not implemented") } +func (*UnimplementedDataNodeServer) PreImport(ctx context.Context, req *PreImportRequest) (*commonpb.Status, error) { + return nil, status.Errorf(codes.Unimplemented, "method PreImport not implemented") +} +func (*UnimplementedDataNodeServer) ImportV2(ctx context.Context, req *ImportRequest) (*commonpb.Status, error) { + return nil, status.Errorf(codes.Unimplemented, "method ImportV2 not implemented") +} +func (*UnimplementedDataNodeServer) QueryPreImport(ctx context.Context, req *QueryPreImportRequest) (*QueryPreImportResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryPreImport not implemented") +} +func (*UnimplementedDataNodeServer) QueryImport(ctx context.Context, req *QueryImportRequest) (*QueryImportResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryImport not implemented") +} +func (*UnimplementedDataNodeServer) DropImport(ctx context.Context, req *DropImportRequest) (*commonpb.Status, error) { + return nil, status.Errorf(codes.Unimplemented, "method DropImport not implemented") +} func RegisterDataNodeServer(s *grpc.Server, srv DataNodeServer) { s.RegisterService(&_DataNode_serviceDesc, srv) @@ -7937,6 +9127,96 @@ func _DataNode_CheckChannelOperationProgress_Handler(srv interface{}, ctx contex return interceptor(ctx, in, info, handler) } +func _DataNode_PreImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PreImportRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DataNodeServer).PreImport(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.data.DataNode/PreImport", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DataNodeServer).PreImport(ctx, req.(*PreImportRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DataNode_ImportV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ImportRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DataNodeServer).ImportV2(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.data.DataNode/ImportV2", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DataNodeServer).ImportV2(ctx, req.(*ImportRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DataNode_QueryPreImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryPreImportRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DataNodeServer).QueryPreImport(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.data.DataNode/QueryPreImport", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DataNodeServer).QueryPreImport(ctx, req.(*QueryPreImportRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DataNode_QueryImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryImportRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DataNodeServer).QueryImport(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.data.DataNode/QueryImport", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DataNodeServer).QueryImport(ctx, req.(*QueryImportRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DataNode_DropImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DropImportRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DataNodeServer).DropImport(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.data.DataNode/DropImport", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DataNodeServer).DropImport(ctx, req.(*DropImportRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _DataNode_serviceDesc = grpc.ServiceDesc{ ServiceName: "milvus.proto.data.DataNode", HandlerType: (*DataNodeServer)(nil), @@ -8001,6 +9281,26 @@ var _DataNode_serviceDesc = grpc.ServiceDesc{ MethodName: "CheckChannelOperationProgress", Handler: _DataNode_CheckChannelOperationProgress_Handler, }, + { + MethodName: "PreImport", + Handler: _DataNode_PreImport_Handler, + }, + { + MethodName: "ImportV2", + Handler: _DataNode_ImportV2_Handler, + }, + { + MethodName: "QueryPreImport", + Handler: _DataNode_QueryPreImport_Handler, + }, + { + MethodName: "QueryImport", + Handler: _DataNode_QueryImport_Handler, + }, + { + MethodName: "DropImport", + Handler: _DataNode_DropImport_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "data_coord.proto", diff --git a/internal/util/mock/grpc_datanode_client.go b/internal/util/mock/grpc_datanode_client.go index 6d382dca7e..601c93bb5b 100644 --- a/internal/util/mock/grpc_datanode_client.go +++ b/internal/util/mock/grpc_datanode_client.go @@ -92,3 +92,23 @@ func (m *GrpcDataNodeClient) NotifyChannelOperation(ctx context.Context, in *dat func (m *GrpcDataNodeClient) CheckChannelOperationProgress(ctx context.Context, req *datapb.ChannelWatchInfo, opts ...grpc.CallOption) (*datapb.ChannelOperationProgressResponse, error) { return &datapb.ChannelOperationProgressResponse{}, m.Err } + +func (m *GrpcDataNodeClient) PreImport(ctx context.Context, req *datapb.PreImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{}, m.Err +} + +func (m *GrpcDataNodeClient) ImportV2(ctx context.Context, req *datapb.ImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{}, m.Err +} + +func (m *GrpcDataNodeClient) QueryPreImport(ctx context.Context, req *datapb.QueryPreImportRequest, opts ...grpc.CallOption) (*datapb.QueryPreImportResponse, error) { + return &datapb.QueryPreImportResponse{}, m.Err +} + +func (m *GrpcDataNodeClient) QueryImport(ctx context.Context, req *datapb.QueryImportRequest, opts ...grpc.CallOption) (*datapb.QueryImportResponse, error) { + return &datapb.QueryImportResponse{}, m.Err +} + +func (m *GrpcDataNodeClient) DropImport(ctx context.Context, req *datapb.DropImportRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { + return &commonpb.Status{}, m.Err +}