From 2e5f5ffaddae755c9fbce0cfeb5ad92f735cf0d1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sybren=20A=2E=20St=C3=BCvel?= Date: Wed, 4 Jan 2023 01:08:08 +0100 Subject: [PATCH] OAPI: regenerate code --- addon/flamenco/manager/api/jobs_api.py | 126 +++++++ addon/flamenco/manager/api_client.py | 6 +- addon/flamenco/manager/docs/JobsApi.md | 66 ++++ addon/flamenco/manager_README.md | 11 +- internal/worker/mocks/client.gen.go | 20 ++ pkg/api/openapi_client.gen.go | 109 ++++++ pkg/api/openapi_server.gen.go | 20 ++ pkg/api/openapi_spec.gen.go | 387 +++++++++++---------- web/app/src/manager-api/manager/JobsApi.js | 46 +++ 9 files changed, 590 insertions(+), 201 deletions(-) diff --git a/addon/flamenco/manager/api/jobs_api.py b/addon/flamenco/manager/api/jobs_api.py index f9743e7d..94402a2d 100644 --- a/addon/flamenco/manager/api/jobs_api.py +++ b/addon/flamenco/manager/api/jobs_api.py @@ -49,6 +49,55 @@ class JobsApi(object): if api_client is None: api_client = ApiClient() self.api_client = api_client + self.delete_job_endpoint = _Endpoint( + settings={ + 'response_type': None, + 'auth': [], + 'endpoint_path': '/api/v3/jobs/{job_id}', + 'operation_id': 'delete_job', + 'http_method': 'DELETE', + 'servers': None, + }, + params_map={ + 'all': [ + 'job_id', + ], + 'required': [ + 'job_id', + ], + 'nullable': [ + ], + 'enum': [ + ], + 'validation': [ + ] + }, + root_map={ + 'validations': { + }, + 'allowed_values': { + }, + 'openapi_types': { + 'job_id': + (str,), + }, + 'attribute_map': { + 'job_id': 'job_id', + }, + 'location_map': { + 'job_id': 'path', + }, + 'collection_format_map': { + } + }, + headers_map={ + 'accept': [ + 'application/json' + ], + 'content_type': [], + }, + api_client=api_client + ) self.fetch_global_last_rendered_info_endpoint = _Endpoint( settings={ 'response_type': (JobLastRenderedImageInfo,), @@ -900,6 +949,83 @@ class JobsApi(object): api_client=api_client ) + def delete_job( + self, + job_id, + **kwargs + ): + """Request deletion this job, including its tasks and any log files. The actual deletion may happen in the background. No job files will be deleted (yet). # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + + >>> thread = api.delete_job(job_id, async_req=True) + >>> result = thread.get() + + Args: + job_id (str): + + Keyword Args: + _return_http_data_only (bool): response data without head status + code and headers. Default is True. + _preload_content (bool): if False, the urllib3.HTTPResponse object + will be returned without reading/decoding response data. + Default is True. + _request_timeout (int/float/tuple): timeout setting for this request. If + one number provided, it will be total request timeout. It can also + be a pair (tuple) of (connection, read) timeouts. + Default is None. + _check_input_type (bool): specifies if type checking + should be done one the data sent to the server. + Default is True. + _check_return_type (bool): specifies if type checking + should be done one the data received from the server. + Default is True. + _spec_property_naming (bool): True if the variable names in the input data + are serialized names, as specified in the OpenAPI document. + False if the variable names in the input data + are pythonic names, e.g. snake case (default) + _content_type (str/None): force body content-type. + Default is None and content-type will be predicted by allowed + content-types and body. + _host_index (int/None): specifies the index of the server + that we want to use. + Default is read from the configuration. + async_req (bool): execute request asynchronously + + Returns: + None + If the method is called asynchronously, returns the request + thread. + """ + kwargs['async_req'] = kwargs.get( + 'async_req', False + ) + kwargs['_return_http_data_only'] = kwargs.get( + '_return_http_data_only', True + ) + kwargs['_preload_content'] = kwargs.get( + '_preload_content', True + ) + kwargs['_request_timeout'] = kwargs.get( + '_request_timeout', None + ) + kwargs['_check_input_type'] = kwargs.get( + '_check_input_type', True + ) + kwargs['_check_return_type'] = kwargs.get( + '_check_return_type', True + ) + kwargs['_spec_property_naming'] = kwargs.get( + '_spec_property_naming', False + ) + kwargs['_content_type'] = kwargs.get( + '_content_type') + kwargs['_host_index'] = kwargs.get('_host_index') + kwargs['job_id'] = \ + job_id + return self.delete_job_endpoint.call_with_http_info(**kwargs) + def fetch_global_last_rendered_info( self, **kwargs diff --git a/addon/flamenco/manager/api_client.py b/addon/flamenco/manager/api_client.py index 21d11a4f..c2a8bb2c 100644 --- a/addon/flamenco/manager/api_client.py +++ b/addon/flamenco/manager/api_client.py @@ -774,10 +774,10 @@ class Endpoint(object): Example: api_instance = JobsApi() - api_instance.fetch_global_last_rendered_info # this is an instance of the class Endpoint - api_instance.fetch_global_last_rendered_info() # this invokes api_instance.fetch_global_last_rendered_info.__call__() + api_instance.delete_job # this is an instance of the class Endpoint + api_instance.delete_job() # this invokes api_instance.delete_job.__call__() which then invokes the callable functions stored in that endpoint at - api_instance.fetch_global_last_rendered_info.callable or self.callable in this class + api_instance.delete_job.callable or self.callable in this class """ return self.callable(self, *args, **kwargs) diff --git a/addon/flamenco/manager/docs/JobsApi.md b/addon/flamenco/manager/docs/JobsApi.md index a988806a..9b80569d 100644 --- a/addon/flamenco/manager/docs/JobsApi.md +++ b/addon/flamenco/manager/docs/JobsApi.md @@ -4,6 +4,7 @@ All URIs are relative to *http://localhost* Method | HTTP request | Description ------------- | ------------- | ------------- +[**delete_job**](JobsApi.md#delete_job) | **DELETE** /api/v3/jobs/{job_id} | Request deletion this job, including its tasks and any log files. The actual deletion may happen in the background. No job files will be deleted (yet). [**fetch_global_last_rendered_info**](JobsApi.md#fetch_global_last_rendered_info) | **GET** /api/v3/jobs/last-rendered | Get the URL that serves the last-rendered images. [**fetch_job**](JobsApi.md#fetch_job) | **GET** /api/v3/jobs/{job_id} | Fetch info about the job. [**fetch_job_blocklist**](JobsApi.md#fetch_job_blocklist) | **GET** /api/v3/jobs/{job_id}/blocklist | Fetch the list of workers that are blocked from doing certain task types on this job. @@ -23,6 +24,71 @@ Method | HTTP request | Description [**submit_job_check**](JobsApi.md#submit_job_check) | **POST** /api/v3/jobs/check | Submit a new job for Flamenco Manager to check. +# **delete_job** +> delete_job(job_id) + +Request deletion this job, including its tasks and any log files. The actual deletion may happen in the background. No job files will be deleted (yet). + +### Example + + +```python +import time +import flamenco.manager +from flamenco.manager.api import jobs_api +from flamenco.manager.model.error import Error +from pprint import pprint +# Defining the host is optional and defaults to http://localhost +# See configuration.py for a list of all supported configuration parameters. +configuration = flamenco.manager.Configuration( + host = "http://localhost" +) + + +# Enter a context with an instance of the API client +with flamenco.manager.ApiClient() as api_client: + # Create an instance of the API class + api_instance = jobs_api.JobsApi(api_client) + job_id = "job_id_example" # str | + + # example passing only required values which don't have defaults set + try: + # Request deletion this job, including its tasks and any log files. The actual deletion may happen in the background. No job files will be deleted (yet). + api_instance.delete_job(job_id) + except flamenco.manager.ApiException as e: + print("Exception when calling JobsApi->delete_job: %s\n" % e) +``` + + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **job_id** | **str**| | + +### Return type + +void (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + + +### HTTP response details + +| Status code | Description | Response headers | +|-------------|-------------|------------------| +**204** | Default response, deletion has been triggered. | - | +**0** | Unexpected error. | - | + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + # **fetch_global_last_rendered_info** > JobLastRenderedImageInfo fetch_global_last_rendered_info() diff --git a/addon/flamenco/manager_README.md b/addon/flamenco/manager_README.md index abc8bee9..d6d8b0c6 100644 --- a/addon/flamenco/manager_README.md +++ b/addon/flamenco/manager_README.md @@ -59,13 +59,13 @@ configuration = flamenco.manager.Configuration( with flamenco.manager.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = jobs_api.JobsApi(api_client) - + job_id = "job_id_example" # str | + try: - # Get the URL that serves the last-rendered images. - api_response = api_instance.fetch_global_last_rendered_info() - pprint(api_response) + # Request deletion this job, including its tasks and any log files. The actual deletion may happen in the background. No job files will be deleted (yet). + api_instance.delete_job(job_id) except flamenco.manager.ApiException as e: - print("Exception when calling JobsApi->fetch_global_last_rendered_info: %s\n" % e) + print("Exception when calling JobsApi->delete_job: %s\n" % e) ``` ## Documentation for API Endpoints @@ -74,6 +74,7 @@ All URIs are relative to *http://localhost* Class | Method | HTTP request | Description ------------ | ------------- | ------------- | ------------- +*JobsApi* | [**delete_job**](flamenco\manager\docs/JobsApi.md#delete_job) | **DELETE** /api/v3/jobs/{job_id} | Request deletion this job, including its tasks and any log files. The actual deletion may happen in the background. No job files will be deleted (yet). *JobsApi* | [**fetch_global_last_rendered_info**](flamenco\manager\docs/JobsApi.md#fetch_global_last_rendered_info) | **GET** /api/v3/jobs/last-rendered | Get the URL that serves the last-rendered images. *JobsApi* | [**fetch_job**](flamenco\manager\docs/JobsApi.md#fetch_job) | **GET** /api/v3/jobs/{job_id} | Fetch info about the job. *JobsApi* | [**fetch_job_blocklist**](flamenco\manager\docs/JobsApi.md#fetch_job_blocklist) | **GET** /api/v3/jobs/{job_id}/blocklist | Fetch the list of workers that are blocked from doing certain task types on this job. diff --git a/internal/worker/mocks/client.gen.go b/internal/worker/mocks/client.gen.go index a113ca43..bac4fcc8 100644 --- a/internal/worker/mocks/client.gen.go +++ b/internal/worker/mocks/client.gen.go @@ -116,6 +116,26 @@ func (mr *MockFlamencoClientMockRecorder) CheckSharedStoragePathWithResponse(arg return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckSharedStoragePathWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).CheckSharedStoragePathWithResponse), varargs...) } +// DeleteJobWithResponse mocks base method. +func (m *MockFlamencoClient) DeleteJobWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.DeleteJobResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteJobWithResponse", varargs...) + ret0, _ := ret[0].(*api.DeleteJobResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteJobWithResponse indicates an expected call of DeleteJobWithResponse. +func (mr *MockFlamencoClientMockRecorder) DeleteJobWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteJobWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).DeleteJobWithResponse), varargs...) +} + // DeleteWorkerWithResponse mocks base method. func (m *MockFlamencoClient) DeleteWorkerWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.DeleteWorkerResponse, error) { m.ctrl.T.Helper() diff --git a/pkg/api/openapi_client.gen.go b/pkg/api/openapi_client.gen.go index 925196f6..cc4ffc4c 100644 --- a/pkg/api/openapi_client.gen.go +++ b/pkg/api/openapi_client.gen.go @@ -146,6 +146,9 @@ type ClientInterface interface { // GetJobTypes request GetJobTypes(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + // DeleteJob request + DeleteJob(ctx context.Context, jobId string, reqEditors ...RequestEditorFn) (*http.Response, error) + // FetchJob request FetchJob(ctx context.Context, jobId string, reqEditors ...RequestEditorFn) (*http.Response, error) @@ -504,6 +507,18 @@ func (c *Client) GetJobTypes(ctx context.Context, reqEditors ...RequestEditorFn) return c.Client.Do(req) } +func (c *Client) DeleteJob(ctx context.Context, jobId string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewDeleteJobRequest(c.Server, jobId) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + func (c *Client) FetchJob(ctx context.Context, jobId string, reqEditors ...RequestEditorFn) (*http.Response, error) { req, err := NewFetchJobRequest(c.Server, jobId) if err != nil { @@ -1511,6 +1526,40 @@ func NewGetJobTypesRequest(server string) (*http.Request, error) { return req, nil } +// NewDeleteJobRequest generates requests for DeleteJob +func NewDeleteJobRequest(server string, jobId string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "job_id", runtime.ParamLocationPath, jobId) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/v3/jobs/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("DELETE", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + // NewFetchJobRequest generates requests for FetchJob func NewFetchJobRequest(server string, jobId string) (*http.Request, error) { var err error @@ -2788,6 +2837,9 @@ type ClientWithResponsesInterface interface { // GetJobTypes request GetJobTypesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetJobTypesResponse, error) + // DeleteJob request + DeleteJobWithResponse(ctx context.Context, jobId string, reqEditors ...RequestEditorFn) (*DeleteJobResponse, error) + // FetchJob request FetchJobWithResponse(ctx context.Context, jobId string, reqEditors ...RequestEditorFn) (*FetchJobResponse, error) @@ -3224,6 +3276,28 @@ func (r GetJobTypesResponse) StatusCode() int { return 0 } +type DeleteJobResponse struct { + Body []byte + HTTPResponse *http.Response + JSONDefault *Error +} + +// Status returns HTTPResponse.Status +func (r DeleteJobResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r DeleteJobResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + type FetchJobResponse struct { Body []byte HTTPResponse *http.Response @@ -4100,6 +4174,15 @@ func (c *ClientWithResponses) GetJobTypesWithResponse(ctx context.Context, reqEd return ParseGetJobTypesResponse(rsp) } +// DeleteJobWithResponse request returning *DeleteJobResponse +func (c *ClientWithResponses) DeleteJobWithResponse(ctx context.Context, jobId string, reqEditors ...RequestEditorFn) (*DeleteJobResponse, error) { + rsp, err := c.DeleteJob(ctx, jobId, reqEditors...) + if err != nil { + return nil, err + } + return ParseDeleteJobResponse(rsp) +} + // FetchJobWithResponse request returning *FetchJobResponse func (c *ClientWithResponses) FetchJobWithResponse(ctx context.Context, jobId string, reqEditors ...RequestEditorFn) (*FetchJobResponse, error) { rsp, err := c.FetchJob(ctx, jobId, reqEditors...) @@ -4897,6 +4980,32 @@ func ParseGetJobTypesResponse(rsp *http.Response) (*GetJobTypesResponse, error) return response, nil } +// ParseDeleteJobResponse parses an HTTP response from a DeleteJobWithResponse call +func ParseDeleteJobResponse(rsp *http.Response) (*DeleteJobResponse, error) { + bodyBytes, err := ioutil.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &DeleteJobResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && true: + var dest Error + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSONDefault = &dest + + } + + return response, nil +} + // ParseFetchJobResponse parses an HTTP response from a FetchJobWithResponse call func ParseFetchJobResponse(rsp *http.Response) (*FetchJobResponse, error) { bodyBytes, err := ioutil.ReadAll(rsp.Body) diff --git a/pkg/api/openapi_server.gen.go b/pkg/api/openapi_server.gen.go index 6e855bf2..99704517 100644 --- a/pkg/api/openapi_server.gen.go +++ b/pkg/api/openapi_server.gen.go @@ -55,6 +55,9 @@ type ServerInterface interface { // Get list of job types and their parameters. // (GET /api/v3/jobs/types) GetJobTypes(ctx echo.Context) error + // Request deletion this job, including its tasks and any log files. The actual deletion may happen in the background. No job files will be deleted (yet). + // (DELETE /api/v3/jobs/{job_id}) + DeleteJob(ctx echo.Context, jobId string) error // Fetch info about the job. // (GET /api/v3/jobs/{job_id}) FetchJob(ctx echo.Context, jobId string) error @@ -319,6 +322,22 @@ func (w *ServerInterfaceWrapper) GetJobTypes(ctx echo.Context) error { return err } +// DeleteJob converts echo context to params. +func (w *ServerInterfaceWrapper) DeleteJob(ctx echo.Context) error { + var err error + // ------------- Path parameter "job_id" ------------- + var jobId string + + err = runtime.BindStyledParameterWithLocation("simple", false, "job_id", runtime.ParamLocationPath, ctx.Param("job_id"), &jobId) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter job_id: %s", err)) + } + + // Invoke the callback with all the unmarshalled arguments + err = w.Handler.DeleteJob(ctx, jobId) + return err +} + // FetchJob converts echo context to params. func (w *ServerInterfaceWrapper) FetchJob(ctx echo.Context) error { var err error @@ -854,6 +873,7 @@ func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL router.POST(baseURL+"/api/v3/jobs/query", wrapper.QueryJobs) router.GET(baseURL+"/api/v3/jobs/type/:typeName", wrapper.GetJobType) router.GET(baseURL+"/api/v3/jobs/types", wrapper.GetJobTypes) + router.DELETE(baseURL+"/api/v3/jobs/:job_id", wrapper.DeleteJob) router.GET(baseURL+"/api/v3/jobs/:job_id", wrapper.FetchJob) router.DELETE(baseURL+"/api/v3/jobs/:job_id/blocklist", wrapper.RemoveJobBlocklist) router.GET(baseURL+"/api/v3/jobs/:job_id/blocklist", wrapper.FetchJobBlocklist) diff --git a/pkg/api/openapi_spec.gen.go b/pkg/api/openapi_spec.gen.go index 4191b899..da76caf3 100644 --- a/pkg/api/openapi_spec.gen.go +++ b/pkg/api/openapi_spec.gen.go @@ -18,199 +18,200 @@ import ( // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+x923IcN5bgryBqNkJ2bFWRInWx1C+rliybbsniilR7N5oOEpWJqoKYBWQDSJaqFYqY", - "j9g/2Z2Ifdh52h/w/NEEzgGQyExkXSiRoj3TD26qMhOXg4Nzv3wcZHJRSsGE0YOnHwc6m7MFhT+fac1n", - "guWnVF/af+dMZ4qXhksxeNp4SrgmlBj7F9WEG/tvxTLGr1hOJiti5oz8ItUlU+PBcFAqWTJlOINZMrlY", - "UJHD39ywBfzxXxSbDp4O/mmvXtyeW9nec/xg8Gk4MKuSDZ4OqFJ0Zf/9Xk7s1+5nbRQXM/f7eam4VNys", - "ohe4MGzGlH8Df018Lugi/WD9mNpQU23cjoXfCb5pd0T1Zf9Cqorn9sFUqgU1g6f4w7D94qfhQLG/V1yx", - "fPD0b/4lCxy3l7C2aAstKEUgiVc1rM/r1zCvnLxnmbELfHZFeUEnBftJTk6YMXY5Hcw54WJWMKLxOZFT", - "QslPckLsaDqBIHPJM/yzOc4vcybIjF8xMSQFX3ADeHZFC57b/1ZMEyPtb5oRN8iYvBHFilTarpEsuZkT", - "BBpMbucOKNgBfhvZcjalVWG66zqdM+Ie4jqInsulcIshlWaKLO3ac2aYWnAB88+59iAZ4/DRmOkpwi97", - "RsrC8NJNxEU9kcVHNaUZg0FZzo3dOo7o1j+lhWbDLnDNnCm7aFoUcknsp+2FEjo19p05I+/lhMypJhPG", - "BNHVZMGNYfmY/CKrIid8URYrkrOC4WdFQdgHrnFAqi81mUqFQ7+XkyGhIrcERC5KXth3uBmfiRrRJ1IW", - "jArY0RUtuvA5Xpm5FIR9KBXTmksA/oQR+3ZFDcstjKTKcYP+HBjspHl0YV3hbIZd1Lhkq+4ajnImDJ9y", - "ptwgAeWHZFFpY9dTCf73ChHRHdp7dxGS89iLQdUscReeiRVhH4yihKpZtbAUxuPbpFyN7Yd6fCIX7Bjv", - "1uqbb0lmj6HSLLdvZopRw3Cr7v6tojXUV7ymLDugEF8sWM6pYcWKKGaHIhS2mrMpF9x+MLSEAKa3Uw4B", - "JrIybkVUGZ5VBVXhHHrwQVcTTz7XUd0EoTpxX4arvvMIp+7zK665u2Q7jvBX+yUvLAFuU3GLY25lW1Le", - "kxoULQJcTUb2CUIccc6DlTyvlGLCFCsiLamkflxA4ohY6jG5+PHZyY/fvzh/efTq+/PjZ6c/XqAgkHPF", - "MiPVipTUzMl/JRdng71/gv+dDS4ILUsmcpbjETJRLez+prxg5/b9wXCQc+X/hJ8d05pTPWf5ef3mr4k7", - "0ncuXRrqIBDtPrqYyCGoJkcv/JWBbVvC8efCrl+Nyc+SCKYtOdFGVZmpFNPkG+AQekhyntmpqOJMf0uo", - "YkRXZSmVaW/dLX5ohYfDA7vpQlIzGAJeb7vJCHXimxmQcZjinkYCy2hSOHLhvrl4SmixpCsNL43JBdB1", - "oKcXTxE94GtHut4dIS8HgDoOoMg3Bb9khHqgEZrnIym+HZOLJZukhlmySc21AOsWVNAZs0RtSCaVIUIa", - "ZKBuFmRLgMdjcjHnec7sAgW7YgqG/lMblx1ptCtFJmNfBOCAAGtnF7Ro0hp/WjVAcaYBEB0Hl8FwsGST", - "jWeWxkgvBNV4gsIz1+Q1gEAhZ+QGKCJdWL6VkJiYoQmx60eq5/GNBy5DjjokQBPHrQo6YQXJ5lTM2BCX", - "YUcmS174n8fk1P7MNfIRKerDD2yXCV0py1koCmhBOGhOau9HVQI7poY1yHsNQ1jSbjK6n2Br/SIlw3bE", - "vxZxdgQKlxfNOcSz2ESwLTokmPorro2nUEBy+xGjiwRefL/exk8bnLBn1/UUqQ26C39Mzfz5nGWXb5l2", - "4nJLvqeVTlyGF/W/LAyW85UXBczcItw3QppvHZ1OCktclFWPdA6PECOXVKMOYTFvykWOs3gSnxxYn+O0", - "SZUERZ45Cwt1rEQqS7fGSaEFmFlypTBIWOhUViJPrknLSmUbJY7oSE7wg/aRItDcisKw8Z6H7sA2HPlL", - "LvL6xLfCvx6ESahe3X1YqhcLElRrmXFqkCTb3ZwzcXVF1cAhRr8A4e0LnfNwD4hiVqsAEZsSjcqs04qB", - "3n1gWWXYJrtHv1EhUPbosYdxmu5En6SO5XulpOru5wcmmOIZYfYxUUyXUmiWstDkCVT/8fT0mKAZgdg3", - "gvgeBiJHlpVmRZWjvoWXYlVImhMtEasDAHG1DdhaJRGWxgUaPLgU4zPx3E72cP8wcB0QBUBzo4ZOqGb2", - "yaTSK8udGIGF+kU55iWFoVwQSu69ZUatRs+sHnsPX50zCnqhXR4XOc+oYdppuss5z+bE8AWqivYomDYk", - "o8IKjYoZxa3S+1JaldmLJW5ArkFwsWhCrXDsefk97fiefTcrOBMGuKAkWi6YVQxnRDGqpQA6AuIU+4CX", - "h9OCTGh2KadT5JjBMuRFya5ZasG0prMU7rWQC869fj+FWS8LumAik39lSjtDBftAFyXSRkTxwf+UlfJ8", - "ytKUuVTmyn8wOBzvjybM0PuD4SDx6+jho9HsweNH99lh/niUc2VWXhPe4i4150q80P+sBQz/YmtMJ3ik", - "YPMTGiNpUbyZDp7+bT3tO/FCkf3q07DNI2lm+FUQ7dewSZTbtCH+CyuTebtKknOg4p8id/YByHB8wbSh", - "izLGLyukjeyTJIdMDPfu3dELv8KfwBS5wYq5rQHVimnBflqVeXo3p34Tdg0AIXx1vOWm2nzSLtiDrp42", - "MqyGI/v106+IDX8uZHZZcG36Jb0lMAvtaKNiQDHA/sZykjEFVAvs7CgPSkvDdMkyPuWZP+KtmG28nu+F", - "UasUn+2+1JHe1huscT/nW1mtw9s9t7l1AvXQsX265yK+otq8BZmB5UcLOmNHYiq7x/C9kNVsHvMb0D9p", - "RJZLzjKrP85Q0Mv5dMqUfYbLBKub/ZpQMpfajBQrqOFXjLx7+8oTeYt+I+WWQ7hdz5icSsuW0I6A6vTb", - "V0P7k+U/ghpGzgYfLXf7tPdRimC70dV0yj8w/elsgBygeTz2gybsVZG8am6YhrC2wQTeOhCYKhqp5yhe", - "M0Mtowayludg+6PFcROp2hO3jJ1qwo2iakUWbjAP/TF5LRVIY2XBPsRWGceiFzJnBapPlZU8yAUdT8bZ", - "hb1o9YFbwF4ysH9G7KxUEvbxdHBSKm4Yean4bG6l5UozNWYLygu76tVEMfHfJk6DkGrm33D88AReICfm", - "//+/K1ZEcG3A6dh5Yp6Dot29eLHvaUE/8IWVfu/v7w8HCy7wX/td9t86szBIz2GdRMpz+rCMqljPt4F6", - "e8kcSCJqECKzx4DupLJgxv3t8J9LMZpSjm+EP0qrd9g//l6xCv6gKpvzq+hPNKPh8CMnncFj+Lti+Lyy", - "BzOKZ0sqAmEPfUeAUllaccNnkfvAScpoNvki3K51loHzuGX1HamRqpcAuodAAYMxb+jEXi/swV2qNFjR", - "FFvIKzAfIaVjObH6l0ahXLDMCo9qlSJNek4XVJxnVtWTlTlPCQ33nrun5OjFvUjaB87r5esTGIj4gRqu", - "pDF5xnOrhuBK/Sfh3dpUHbSI93KC/mu7s5xMlVyErSfNUj0X+JTqS31SLRZUrVJO0EVZ8ClnOSkc80dH", - "mIf6mDxHLQU1IXhYmz/tT/6QGLU6CdWXXdUNvtpaAQdXtFvwFrafXhKv/3vFcM8R9QQP7eDpQ6tQ1Byg", - "j6Z+Gg7APXc+WYELuy1f/er/OueiQVoCbXBk49eOsuAW8rGmk/fTatJn86mXvLBK46TmU0PPdV4d/eX7", - "mukkHW1yOtWsudD91EJrOH3cwXutt6TsfTuKbbe77Co6tfaVeMtMpQSa6i16oX+eetLJnSIDW9hFzo2i", - "K9oY3Y+9fdZKwPttLxQqc9e8SE5jfi7FlM8qRX0kQHM9XL/kSpu3lVhnjUQbveV4HIVOS+im9sPamOHm", - "I6oSurbrB984yEyUTNmSTKklmXpInGtHSDECd76Vg7N4vcAMiFRBdwnm/onlxYQtSmNJr33LzBk4gqoi", - "F/cMmbBeFy/Q++/BHJKvt8E61gCrMIoKPWWKPDs+Aj+lN3enbbIaWeErmdF0DMaLwDqAL1muYy8FzOU+", - "Hm/UI9uztHc3jA94DZb8lSruTdJtBDk3S7mkCR70RrDRkq7IlfsYnTAWbgupDdg0pb2PDE1V4MG0bMtK", - "N2VBM3DJIYO8+GiF208XTsXhCsMnvOgwB5+vkwoo8TFjwfBOvZmUnC5lYk200NJPmnd8f0FKYW75ZUGN", - "1XhGQTXGYA5g626QySosug/R4KPNmqgzwtaA9l9ucV7Pqpwz0TRgOyOA0xp0UjZtDaPXcal1FKqNPh0e", - "9pqWpYUxnLI/FGK3DHEdJkSLcIzdSmx49RfGyreVEMlosKNgYl1GFxdhQBZ0RS4ZKy1REl54S4s6i848", - "3QOtBfYe6Rsl/bdBcVizWm++juV6ElSOoEYuHV4fGUfbUHKeM3KBjyx3YhfEbsWZ2+KAJLw+dhKA90za", - "/wr2wTjPLRLpC8urL4bkogmEC/L63cmpVXsvIECnB9Fb6NwCZIBaH4xSWB58OEfeCddSXp3Da/3Farlo", - "EsPfuk/xq7n+QGNh+WaO4jx32zns3rKZZduK5Uh/u5Ckea6Y1jvGxTr6m75pcmqWVLE113AT1fol3ByU", - "64Jb/DxYAvVu4vBnRdY6BuBBFUfXekAMBxnGVcEKBxEUelafOq0TllWKm1Xw57Uo4LaOnXUenRNmqvKZ", - "1lwbKgwKnylXaCzkyYmV7byuDHKXHYWEYbrU2lnHvgdfKd0iWK7fOfy1BLXuFpLwBHHOmzESdgAGur8z", - "mnC48lZ8Ovnx2cHDR3jtdbUYEs3/AcFnk5VhGgWynGm7PFK4RXkna9e60bJkwmzgk0LyM6jDMMcziULo", - "4Ong8OFk/8GT+9nB48n+4eFhfn86efBwmu0//u4JvX+Q0f1Hk/v5owf7+cHDR08ef7c/+W7/cc4e7j/I", - "H+8fPGH7diD+DzZ4ev/BwQNwauFshZzNuJjFUz06nDw+yB4dTp48OHgwze8fTp4cPt6fTh7t7z96sv/d", - "fnZI7z98fP9xNj2k+YMHB48OH07uf/c4e0S/e/Jw//GTeqqDx5+6Or+HyHGS2tpfI+nRK0KOX8eRsX4c", - "4OcgTTrrvrPst01RQMOpDkoRxkhFk4zJkSCyyJkizqWovWXfjQXzWg7wvtLoGDgL2yFHL84GaBTy2rEb", - "hfDglaa4CtDVLpy9ZaSLaranMybYyFKvPQxEHh29uOiJvHIos6Xii2t/yQt2UrJsow6Mgw+bx7T5NtXc", - "P2V/tc/QmtY6lVSKwTXQw3n/2ogBirMDfe0dMnMqyNIz8yAmDi1yxINCeIKLmKM+PLy+xuQ0ki4+H/l6", - "rJmNIIDtjiQcdZfAORWMeqmLIuV1tMotOqLDaUmx5S+V9XhoyqhH9CtO2tjnNLHCJqmNx0yOAXTmY9cy", - "xpo0erDR+2JX48Yb9gu7TQD/ws289qxsBWqvhGdAziY9oB86MXVIclYykUNqjgAND8WZP/jZbCt7RsfR", - "44fpnGpstV53vB2HWSUuhVwKCDAoJM1RH7MH1tC76v3jYG9xNZAF4vS0awseIGg0YNcrS9yQ0HArAsIt", - "sLf+w2+eFwaqpbkanhaI2ZSo6DPPUobxUTrbhGxed6aurNzxEoYKgSaAaJaTuNfsb+yDC94Lcn0cJHhb", - "OFBfzHAfbgYt4onCdfvCuBKR78/FGkyjbBKOtjcXz39XnvulCOFaoqdYfrJJc2uzEg2f1RyL5lYodjpd", - "FAhFnVWVnFX7+wePgj3YSWeVtpjfMTQb6QZMzIXCVLgHToC6p5vujpSbm0YW3h0sscEw/Gk4KCIA7Whr", - "uQVXSevUi1pDDltvGEKaa0pih8wumTl685OcvAPHbzKFTTMTcoeHRFspW14xRfzX3tkAST5gs9Rj8tIK", - "OWwJ/sWhVYfYFZeVPkdcvUD5e1KTvtSJfqHoRm89aw70M13EeXnpLNDGonfygMZRQyFH7GHSr6zYVDE9", - "Pw8xBGst4VHwstOb3fcYvYC7uacxjqF2L8KxYY6X1i4kU3tXDvwT3IQ0m0Ms9hXPK4rBEGQJs8yYYAqt", - "45IsqFj5QVzGb6loZnhGi15v4u5A7M/P3zX69DOCTxMhpy5DP8rhb57hursWR0j2XTp35FLVR54IZQyJ", - "APbiWW3XrTSdorRlaKiZV4uJgAC7jQeVDvZMJS/VwaP4V5hkHaQs6enPzD9hAnyLgQrhpdBWEb/Y09G3", - "F4RdgWkA0p2NdGmOXnaL3rQPLTAdZo/Jcz8mZmfOmImfo0EIHFD2nvj74P9dyJlGZ7tgzGWslAXPuClW", - "ftoJQ1IJ7l77aDUMG8moi9EI79oxpMDIqW+MhPU0pp56lHkvJ9+CRmFft6/c03Y9BFxpFvdT9FaWG0WR", - "xNG88Q61bRO6U4P4NDjvHugn+pinYWQTKnukEvUPVnwYb2YNLUSV5bq87/Vbj3TJsAwIgKz/lVQj+0CR", - "kCCoIZfcnuh0JxiEmNCi+ElOIGC+KH4Jnm/H+qi+LOQMH8bXeu2qT6m+fCVnfVTs1F0Cks0rcekkB4hB", - "CHdWSbkgOUMGl+NDl6dklwS3lV5JntuPc9x0k/uk8NjupOtJsYsISOSWNiav6SpkKS2qwvASUn8EQ/Mw", - "+2CS/klPy9ai6il6oHbDwppK2m2sw0Q7/DZi2ylAsl9uA2B0BDcXB3k9yS1Oo9k5aWU7sA134WqbRUDn", - "LfxcGbBZZOg639ymaBNYs3Osrs2uWYOJSE62wUV8cx02uoAUj48J5ILqNiw/p0mPBIq7yDeZqaON3bhW", - "TnIDjL9YmpXz6W+Bs/bczjVjKR2c1kGCXMfrte/7LNcoDX27tW9G/aVf/ecifyda4DO+Os9CLsC2Hzfi", - "ZW7yKu2QzbjhdvlxkpcrzlRMlrConclRrQcj6yD6pvFwm3Dwz0+xcQ8Of/tf5N/++bd/+e1ff/s/v/3L", - "v/3zb//3t3/97X/HShNow3F0tJvlPFvkg6eDj+6fn8BdWYnLc7QfHto9GatsntMq59LHT095wZzbew/1", - "pD093XsvJxrdr/cPDscwZHzIxz//YP9Z6sHTgwfDwVTRhaUxg/uj+/uD4QDULH0u1fkVz5m0ajv8MhgO", - "ZGXKymCJHPbBMOHyacelC+WCrbi3uuvCmcLK9tLgcrV8OuMpKc3a8VyBJqwMc15brgYFF9WHCKMhynTk", - "QO30y27ab4w5G3TCkHW2bTm/DcaRGEE22Q38q3WsylbWhjpNpwdqnXBeFPvFjOiVNmxRpwi6b1vVWiB9", - "J5MzwTXrmkPdy86YA3EEhVwyNcqoZiHMwE3hF+VCws/wQM8GQ3I2WHKRy6XGf+RULbnAv2XJxETn9h/M", - "ZGNyEqaSi5IaHkr0/SDvaXKhKgEa4g9v3pxc/ImoSpALiIeUBcm5NpBHAwHIVv+kIa2mlBoK9oRFWu79", - "THt7MS2I3dGwsQ9yNkBtXJ0NvDPfVRpEX6qXNqFUUKks37Ya/tmgaR32450NatgvpLaaNij8l4wYps1e", - "zibVzFUg0oRRzaHWj9PTfb4VRpvyjOQygxpvkP9bFI2dJdWCPoOV/eF8+3JBQ5LJkscOoYt20ZixHe0i", - "lJDrFhw6df/yEMRycCwn3JmNppwVOckl0+KeIQtqMvBnEZqZihZhpE4gzSmWrgOjim7XIQI8kkUe5aw0", - "axe2y0CFWobeenUmjhoLtNLcApnbsPZtQ+mJVUm19hrIVrHjXctd4sKnuHG6Nuup1yWxGivkZmjv/fGh", - "Jr5axpDwMRuTCZtKxeoQ7yjEf7ybIvUlK7reRHUCzAw7n6zOfaT9LglyTqhOrHVLpW8H/RDEciOrbL5R", - "XEQ1RayCgG7/Lw/VH3zM/G7C+dcveHtT5Rx8sYFdTnzbEhBt9TVVazeuqBsu04bius6ulc7ctb8SOsGK", - "mQzsW6DZRmarzzLApyNrLKGB4JCWAWvYiBbpYkpkp9o4c6WK9MTv3r4i1PiaPNHshBvNimmIwpNLUUia", - "bxM9X5u5wilixQTYf9+p7J7qHpLaQ76qllMzaue6p8yc9YR3KS89vtXXSEyPU4+7SmWlDWHd2hw1umNJ", - "FNmoI1n7G0EUHPf4cbc20t0lYnhdy9qWFMnP1HdS60zr+Cz4diFpFCmoPSAcGdUSxDwXogFeKaBYcGJQ", - "FgsrqUFJ0mdWyg2nB9FJssRktz8R6WwMrRf4TEjFcvINyDfSZwteeHrrbMZCGsIUdVlZoW5SW4K1y/p2", - "k1G5m19ZcOFKIDt/OUQB39MkC3V2MTnSLs3HbiG5Jm+umFoqbhjKtVxWGsyHIirv5AufJMWHlMPhlZw5", - "R0KgAejT8AK5L89rFw2nAhMyqgreUxDRNEjgDlQiiVx1JlLL1YRIpBiEVGcM9CNQZLnAjFIcJxGoui6J", - "6fOowJpL5idNXaJ6j9uVB3P2xFCboZPkW55He2xJBsfEPevYhdcGE21nXOgf6/OTsoxTbjZDBtSgrShe", - "BKlGVFJU3y2ZjvXp104VIleCo8mNPLGrT/nVNhW/uji7q27SRpH1wYV+9H7kxNTAvrID10z9Y5nCkhZf", - "HFvaMgfO1Aw8S02xpoCfgyifiTc9lQ2fHR9Bl4Uon++8rmGol3Q2Y2pU8b7Jn/7NW5etSDhdlGzmSp6P", - "6prXg+FgwXWWqGTSX/aws5ibh7i/aGkgd1a0BuAFY+WJVXmrVJ4tPCbaPfeRn6jl+CICJ4YqA3EmTOTo", - "vArsF9grRzcTxJXldNVUI8LYXCOfZWPyrCwLzpwDD5130n7IwaxykdOVPpfT8yVjlxeQSQHvNH+3L0PB", - "i/GZSKwQRBZBDh6M5rJS5Mcfn75+XddSwRLkNQbGIw+eDhaSmIpAiCoEV+TnIBQ+Hdz/7un+PuYDO53E", - "OSa0XYF/a/+JfauDYM1JuukmNGMjzUqqMExiKUcFg6Lvvhieg7plG3YsIHiMXfaAmXxzNlhINA6bytuF", - "vx2T76FMyIJRocnZgF0xtbLj+ZJ3HUSt9x9xdgBoT1K3B83HdIBgANTm4do8KIw9bEKzMW604jX3wlDD", - "+lQ+551UceWC7b2bSYUtGmyrReUtGhmC6emSXrIucl3HDbt9hHnjuzgMykId82hwXcMB1Zak2EOAvOrh", - "wDDtXpHTqZWVk3p4v483UdkI6wQjsaq1IVc1os6xsj9euIiWhMKqzwv6j9X6OO5mQQrnvkEVI27DAkSq", - "NoGjPFCrJU4L02TKBdfzljF75/DZbU5xGPa35jz7TAR/pppna8Sxa2v/Xy8y4kvVRvhicQuRMNEExF9r", - "Z2CoEQggcZjOta/fcj0rxWaZwbtBttOmmnXuPl7XKJoOKE5oCqfoisF+eY1yRzCIdmUdrMyziIX/c1ql", - "EizfaaagAA/XcQjR0YshKanWS6ly/wjFYFdnyQo5XoeuZXuLmAAYuNj2GtU7nRtTDj59gmYKaHSGmMTM", - "RDJwOPFTRhfOXIpf6qd7e1Mf88HlXre4EIZzkpdULVz0M6ScDIaDgmfMZcG5eX44fnV12Bl/uVyOZ6Ia", - "SzXbc9/ovVlZjA7H+2MmxnOzwAqr3BSN1S5CPfJaYL8/3h+DFCRLJmjJsQ75eN/lccLJ7NGS710d7mXt", - "smwzVGxCHZ+jHErsm2b9NosymEIHox3s73uoWknfYrAVNDGDZu+9s+Ii3m6ZQNScDw6vCXRhsboIqXyI", - "gp6u2hWjN7NZ4WPa6TZi6ExjMRFDQTepx/he5KXkLrFj5lrFdQYMRxEG/TRMg3cPXKt7XlXqA/ZLLvI/", - "h6Icx5h5e2PgTve6SMD7paxEXaMDZODQXaTZRvCLrAuLwyTWcRK6CSwtg18qCZ0GGyf3krvYfKnIQipG", - "nr868r0t0GAIcQiaLClEMIA05beTQopS6sRJQQGHxFEBq/mzzFdfDBqtQlQJsPiuHlI5ezN4v7H4kkSn", - "PmZD3TweNQrbdFf6c/PiDnGRGHYARzrlgt09nPorLTgY/WmMTddBphaeOs/BVT2+7zFWH+RGooJpnqMo", - "MGsNyjbSVr8q1h7fGn7+h0BMzO6tMbKZ/LuB3e0wTi8yQkGLbaWIl1j94rOOfIdq7p+GjbFWdFE0x2rL", - "xZsQpH0Qb6FvzhVLCx5dOWHtaTzLMqZD89NUNdrEkCE4T0hDcGP3wK/0pmTi2fGRT6krCrlEyfrCNwnc", - "c5KkO9ALUtLs0h72meg/bs1MVY6or4/WT3ZO6BVLlmS7GcKTnCrJNGOwWtpNrxC9W0j5IBHj30IGiAhc", - "sgktS2+uyK2KNK2Kok4i9o1grVx590jJu9qt3VMawPc0RibHoWCX3eGKTCuBfUIL6E6xAb0tQqQwu7fy", - "Xj8ONjjf3kefrf9p76N3mnxaR5IazLDZhMwq4NzCzpW/cSpcVA+gVpydNXoXFadbI8Fq8YkJI+dP/4Rt", - "6vXrDTLTdN2L3Smm19JaRSqKRr2MRtvQuFKG/dKZBHyhDIucoUoGmvp21O/WLafRQ6G3eEY/qoag9N2x", - "tK6Q/J8Yeo0N6M9AzrqyStt8QN5p38KUtRoDb8hKQDIaiis3WgVj07xUADOZUF1Xv5soudSN8PzrY3y9", - "x91x3LcS6OH8EACOtURuhNU3Os51DxmaEUuXPNJBz5vUONYsCIzrlZXwkHe6qH0rqrkQq6hCiAZoP7h/", - "cPMywmmgqCE9AVol55L5ro8+jaH5QjKJgWtIoylWJK9YqzNkRrN51O8ah4L7ICUpJDarvk3xCB4QX1K4", - "SQkQxwj1JXdgoe07EvVMjWUf7IvRGO6nZk4Hc5eyc6lQtd/iaoFe+3XvVxYtYd31epDOtdzxQoTsG+hV", - "C/2G5lag/PnNKWa7YG1BH0Jbp4iYuaxm8/+8UL+XCwVoteE6AfaHfduRwJQGxV6W3J64qRtt8cQ1axT/", - "6TfLM5PNfyjkhDZKeEAaw81ykb5CQFsINMP0lTv1dY18ehrcHipWyZ6OPXIRdIKcU4OlGHVfHSW94fje", - "QNV17AJWR8LPANA9y2md3999m640mYQ+SK44y01QyLpTWErrbteyxfgs6AuFKZ7j2xZKGo2h+rEIoBoZ", - "Q10WCrY6gqRUPrUkDKgOkDHXjwk+HN8ZWgP3NmTRWsBvh5B1664pdAuDDj0iJ1pC4E0XDS3F3fto//sz", - "XbC12pxLMt1Kl/MD3hnVqp0q2ysV4LM26XAxjoFHYfdwTWpIbDifKEWs2TQYM3OT56K3OA09uEWgJRXS", - "8FLYjU4AMEJl1z4ZpCAot7Y1EOupAtsN43VB+BGDQj6tZ46o5G3G6JCS1o/Pm0JWfv06ehv3Ffja5KXF", - "vXyT8vU6AH4kchIFSfdBfm/S7LpdMExcah7DW2j22ejRfZsHciO8td5KSr6uyoJp8s3SFT4KPcW/dXUz", - "G+1PwWrih9vSzO9jHmmWsRKS5JkwijOncYC24Sa5XZ73TrAPJZYcgIDPrjcKWtr61bpi2/aSRyBI4Oja", - "+/118OrmLvpa5AJBdw2CWdl3Jg3CM0pSh9t/l1ABaRTI530N+v0eAE1yCZFOyT799Q7X8xd0XwZUi6up", - "9vOXXVSxtmKEetgfASl/5/pe86ivofslB210w+5HIM1MnM/cYzgDme+4Thr+nbPIVo/9HjuUYEviYTO+", - "nqnOT+TD8pdUB8aIRrWDg758fd9R0i/Bhyng9yHI6SsTzTXIGiSBegsODE1n5EYErQPg16HnSUhu/30j", - "Z6PGQw9qNpM9wHUGa7kmmp40hrsOkjYX5DAVzIrhsH2GiQ7dKYLk/ztB4+Ymd0HiUEt/LXs+hbf+GDwZ", - "9hKSLdKyIsKYMx3XWtAdyeeOiYXUrRsqRECTg3rVDWzYRt5L79gjEbbM2PPds/aw6tAaQthsOnlDDq7m", - "JCkbbtxiyjsliOvAd3um22TTwFRQm2+cB/12XXe/yLmGNHD/yc0jYFgJLRSj+cpVcHNE+MGtuN8UI0v7", - "Hzw98LmKGURukAvdgmjdhwrqL2K3QQKgBKu9FM44dmtXuGpd4dYNfo49PWndWhEDS/RqUXBx6XpdIYI6", - "CKBD1aAL1QGlsuygKCKLBjaOwiwv11HHFdbLaFGgn5HryHVdEwcEajvczy2IEh1fJlhMo9UrVYyupRlx", - "t7BtKUd8sjdKRVId67YlKF+BliQbtqXWG0qMQ3FRCSJSfBDDOEPevuM6nOEW79aVgYaAdTfVGAauzSRG", - "uJZSGe0uPp4UVWFjGxH+GYZYU++eD2yjPWDoSeVd/tjYDldRkx14VxteFPUSurcEht376Jseftr7CL/w", - "f6xxR8X9z6RiPpakJbRt3c7SQiYh4flXd/JiDTvzRjX6fCe4UJ4vMavf/Taz1t1Nf73xi9fpebelcedO", - "XaI4Tb/uzZfs0tiIS4zuyzriHTDyPzYyDlOKqiMqvNm7zPXKztmUKRJaP/piv4VLUTgbHOx/dzYIiFVX", - "j4OiMOAzMZUSLK+7O+D2dJDjMEgr9NrsHDjmmdBCSxxDywWTghFWaBinLhqXWiZgCwBwzijm0DkQ/o8R", - "TjN6TsXohd3n6B0MMEjAMOrsl4KhVHzGBS1gTjv+mBxNXVW6QsZV7EJPUm6igtmupyiPqTYUmgt9iqkg", - "lMMbUBcbesVvsbc3bmGjl25hg42e/m3kGZkZZkbaKEYXTQoRVOsJF/Z+DzdnQj3HOXSrkfE1bDVeDO2a", - "aQ72v9v0ukPHBiI6koMhfo+TIyj3uVUHMABvwsySOWR34Ix86d7B7mt3T0MjZqk6dCeIzh6XQdl5mCj9", - "3GgzuOHW+htY3xyHeKWSmauJN2H2wzD/ZNW4dyhRXPReoafEntmFK/whjJ/Am+JuOXxwAwcCzuACCPv5", - "DvlZQjqT6/LXeAj3cypVxifFimSFdJUzfzw9PSaZFIJBOpOvSC2hMo0jvK6ajG6cFyPsA80M0XTBnCRp", - "pK/kTnJZWSEPP9DjM+FPFWPr8TbVXQoSJ0AmMl/1stI4ictOUWsXXbDEkiNYbPY+uoLBGyI8XO+oLYKW", - "Qv3hu2nRc4UWk8ZoLBkkpvKOWuualbDX2OQSX6w5+T1XZnX96fvC3X8UJPD7WYcLUIrb40NPkEhbYoIP", - "51QTAdVnyYqZu4VOsVe3U/Uc4xwXDItn4N43OBVc6nPLlRs6AW5APONaom5EvlP74t1BPsM+mL2yoFzs", - "mEp+2gbOHwWvolgTqg2ZsmXU73Eed0vdinrFn4TxfOnntVi1naM1quR8q1j15S2QnXr6f3hfK7LAP4Cz", - "FcukQ5DOgq7QDM+mU5YZL9ZCGyAcgWqyZEXh3vcWeOjIxKhL7ZxXCyo0xpWCcApuuStOu+mmY1fDTYNd", - "Fwo3+huFQWJwsep7dUG40IbRvFUYIqqq15vDHGpT3xhL98HMfqpr1w0LUdGNDmF17u/6PNvnUY/pSrvC", - "isEEbFwuF2qTxYrQerqEhI7HMFrMzF5UTLufU9bdh28MzFFF8ASE/wLquF9rfwB7VDPcw7LeazpSzH/q", - "cbah+acKsHWBt/fRVSV02k5fLPUL+D3Uhd/MG8KwX1jm2Fx7ZOgLIoZuX64H610MSK7J3tKVuT4C6qVY", - "JheL0LIBjJEZxCOAJcRVF+l0nHWVq12F2wugkmjKa76EvhNXv3NItJEl4VaTV9qMyTOxQtEKX4uLXMbd", - "bUOvN2x301TGW7i76YJ+VZz60qQghQ++auqWORPLUOB2IzGwRCRnBpoMhSP2Ctp2N38b8dAx724x2ds+", - "ui8vLK4pkHsXpMY7ItD1IuB2Yp3H6B2QsmCsHOmoacAmKtLsMvBHIinNnW1Trg+s/422Cusi4lnMNIVM", - "fXk30bBXl70DGHFjlGoTMvgA9/YpXtsnFdo6BJkKa0r8LuiTZZBSxV3KQmH8BJq39D2sqs3UqG4t2ccf", - "8cUgz9zc+Te6+PTLGsCXcFG3Gk7lIcHyfnGoo3feHWeaX77zpy1DL6wGnnV4YH0kViWrv9QJpLLy9EhO", - "p2uMcXwm3kyng20u6N2Dpat9DyS2UfX+b1BIvwbba6ouY52CauK7c2wA+HNaFOjW9dqvkaRw9gpfM8Uq", - "xNBt+55iZAZ5fG74ce+piA2HIm70arsp+i91aI9/mze626vmd3Glt0bDZ5WZM2Gwl5SrQG2xwfuc+7Sx", - "z8ZJjNgwEmZAT1OjnyavDzyJscZlDCQF4+jUBl8bOWClXjGoexD1CaRCkv4v7jZW7Y4hPhQ2tPtRGF4m", - "Vj1A6EWFUVY3bUqTsESDp5vWqcNEKa0lsEnc6vUk1N8x5XFU3Z2bt9eBMyPz0S9gD7Bko2A5FsbACFNH", - "UUZN55FHF+gFxUUd2eioDFOjQma0AAJHC/2lqdoVa+ym0ils9U1Ae/isk8ddgM3NlaFxhs3e+BfXgDoU", - "MuwjVz9L51Sq49dDhvYvtd3jwf7hFyzqjSjWi5jHTPmaii+Y4Eg6XaJT2jSJvkbH8lzzPsCoIdEyJCgX", - "hVyiLdiBxW1d8dncECGXztN5eLsMxl8kKiB4Fx0kVgqH1WEILqT2zCQ0a3IhbHjhdry0zv1Cw/gRNDbd", - "JsApr3CqdLnLpKux/7pEzbv/AF57t5O+6+hko6gp3PWtGm6srps+dUvqYDjdbPvlMMnXRNHSBb6Gseu8", - "/ts2mHwmc4oK4GM3cbMqeQZO2rj3eankTDGth1CotGBYGV8qMqW8qBTbyGE8X9FM5A1HiAW3H90SMisa", - "bb4pewu6GvGRqvr976/pyplSKvGHiN57TVd/Yax86zry/bHUM4yQcWJMneYRScyRazNiUKoSZI9cMlZ6", - "V2fch7/E/gxQX1dYgq4JJejKjGXS4M9I+Td7ELkj0YOyF62stSbXrn8L1JaVKSszKpXMq2ydoG+J5Rt4", - "+di/eyeYAxSw2XtfstmuaRdD920pZl8rY+Ngy4wNkP5cLoKvjvng/v2bv2ivmJiZechy/lNcEznnOXbC", - "sVSWEgeCkfsEE3DcSg9vfqXHdAWB+VCQmSpXyfbB/Ye34UYI/czJa5ZzSk5XpfOYAYoRxCgvTE5CXknd", - "3yCOrnlw8OR2amf7RDfklEA6JDS9XJGpvdiukYLLmzBzJY0poBMxK6a/K8kDE1osoBdSG6JYhmk+oQ4W", - "7BflgSithQNwqtJHqtSOECZ0pVgINgPp3Z2y/fKeJjmfMY19AltnTJ6HNCOIwzn++QeA80/H3/9AHCrZ", - "QcuCCpGOg1kn8Jh5tZgIygu9Vyp2xdnSkyWusPqXp/YEqb8XgwCi6spTc+yhujeIjFBtYnXUDDLp1Bj3", - "mBLYAUTzdTMGf5ITbyYFGe3vFVPcol9dyH/YquU5btS30YlBnx0fNSufxyYyuVhUAsVNyERM9Q9rOHAT", - "EzhseB3WRKAJWG/fEaz5bLdh74qShV9RZzJwOiZyYjHPKMwCfKJOknIQDNXY38tJKP0Qz+Hymj79+unf", - "AwAA//+Tnnpa2OcAAA==", + "H4sIAAAAAAAC/+x923IcN5bgryBqNkJ2bFWREnWx1C+rliybbsniilR7N5oOEpWJqoKYBWQDSJaqFYyY", + "j9g/2Z2Ifdh52h/w/NEEzgGQyExkXSiRoj3TD26qMhOXg4Nzv3waZHJRSsGE0YNnnwY6m7MFhT+fa81n", + "guUnVF/Yf+dMZ4qXhksxeNZ4SrgmlBj7F9WEG/tvxTLGL1lOJiti5oz8ItUFU+PBcFAqWTJlOINZMrlY", + "UJHD39ywBfzxXxSbDp4N/mmvXtyeW9neC/xgcDUcmFXJBs8GVCm6sv/+ICf2a/ezNoqLmfv9rFRcKm5W", + "0QtcGDZjyr+BvyY+F3SRfrB+TG2oqTZux8LvGN+0O6L6on8hVcVz+2Aq1YKawTP8Ydh+8Wo4UOzvFVcs", + "Hzz7m3/JAsftJawt2kILShFI4lUN6/P6NcwrJx9YZuwCn19SXtBJwX6Sk2NmjF1OB3OOuZgVjGh8TuSU", + "UPKTnBA7mk4gyFzyDP9sjvPLnAky45dMDEnBF9wAnl3Sguf2vxXTxEj7m2bEDTImb0WxIpW2ayRLbuYE", + "gQaT27kDCnaA30a2nE1pVZjuuk7mjLiHuA6i53Ip3GJIpZkiS7v2nBmmFlzA/HOuPUjGOHw0ZnqK8Mue", + "kbIwvHQTcVFPZPFRTWnGYFCWc2O3jiO69U9podmwC1wzZ8oumhaFXBL7aXuhhE6NfWfOyAc5IXOqyYQx", + "QXQ1WXBjWD4mv8iqyAlflMWK5Kxg+FlREPaRaxyQ6gtNplLh0B/kZEioyC0BkYuSF/Ydbsanokb0iZQF", + "owJ2dEmLLnyOVmYuBWEfS8W05hKAP2HEvl1Rw3ILI6ly3KA/BwY7aR5dWFc4m2EXNS7YqruGw5wJw6ec", + "KTdIQPkhWVTa2PVUgv+9QkR0h/bBXYTkPPZiUDVL3IXnYkXYR6MooWpWLSyF8fg2KVdj+6EeH8sFO8K7", + "tfrmW5LZY6g0y+2bmWLUMNyqu3+raA31Fa8pyw4oxBcLlnNqWLEiitmhCIWt5mzKBbcfDC0hgOntlEOA", + "iayMWxFVhmdVQVU4hx580NXEk891VDdBqI7dl+Gq7zzCifv8kmvuLtmOI/zVfskLS4DbVNzimFvZlpT3", + "uAZFiwBXk5F9ghBHnPNgJS8qpZgwxYpISyqpHxeQOCKWekzOf3x+/OP3L89eHb7+/uzo+cmP5ygI5Fyx", + "zEi1IiU1c/JfyfnpYO+f4H+ng3NCy5KJnOV4hExUC7u/KS/YmX1/MBzkXPk/4WfHtOZUz1l+Vr/5a+KO", + "9J1Ll4Y6CES7jy4mcgiqyeFLf2Vg25Zw/Lmw61dj8rMkgmlLTrRRVWYqxTT5BjiEHpKcZ3YqqjjT3xKq", + "GNFVWUpl2lt3ix9a4eHggd10IakZDAGvt91khDrxzQzIOExxTyOBZTQpHDl335w/I7RY0pWGl8bkHOg6", + "0NPzZ4ge8LUjXe8PkZcDQB0HUOSbgl8wQj3QCM3zkRTfjsn5kk1SwyzZpOZagHULKuiMWaI2JJPKECEN", + "MlA3C7IlwOMxOZ/zPGd2gYJdMgVD/6mNy4402pUik7EvAnBAgLWzC1o0aY0/rRqgONMAiI6Dy2A4WLLJ", + "xjNLY6QXgmo8QeGZa/IGQKCQM3IDFJEuLN9KSEzM0ITY9SPV8/jGA5chhx0SoInjVgWdsIJkcypmbIjL", + "sCOTJS/8z2NyYn/mGvmIFPXhB7bLhK6U5SwUBbQgHDQntfejKoEdU8Ma5L2GISxpNxndT7C1fpGSYTvi", + "X4s4OwKFy4vmHOJZbCLYFh0STP0118ZTKCC5/YjRRQIvvl9v4ycNTtiz63qK1AbdhT+iZv5izrKLd0w7", + "cbkl39NKJy7Dy/pfFgbL+cqLAmZuEe4bIc23jk4nhSUuyqpHOodHiJFLqlGHsJg35SLHWTyJTw6sz3Da", + "pEqCIs+chYU6ViKVpVvjpNACzCy5UhgkLHQqK5En16RlpbKNEkd0JMf4QftIEWhuRWHYeM9Dd2AbjvwV", + "F3l94lvhXw/CJFSv7j4s1YsFCaq1zDg1SJLtbs6YuLykauAQo1+A8PaFznm4B0Qxq1WAiE2JRmXWacVA", + "7z6yrDJsk92j36gQKHv02MM4TXeiT1LH8r1SUnX38wMTTPGMMPuYKKZLKTRLWWjyBKr/eHJyRNCMQOwb", + "QXwPA5FDy0qzospR38JLsSokzYmWiNUBgLjaBmytkghL4wINHlyK8al4YSd7tH8QuA6IAqC5UUMnVDP7", + "ZFLpleVOjMBC/aIc85LCUC4IJffeMaNWo+dWj72Hr84ZBb3QLo+LnGfUMO003eWcZ3Ni+AJVRXsUTBuS", + "UWGFRsWM4lbpfSWtyuzFEjcg1yC4WDShVjj2vPyednzPvpsVnAkDXFASLRfMKoYzohjVUgAdAXGKfcTL", + "w2lBJjS7kNMpcsxgGfKiZNcstWBa01kK91rIBedev5/CrFcFXTCRyb8ypZ2hgn2kixJpI6L44H/KSnk+", + "ZWnKXCpz6T8YHIz3RxNm6P3BcJD4dfTo8Wj28Mnj++wgfzLKuTIrrwlvcZeacyVe6H/WAoZ/sTWmEzxS", + "sPkJjZG0KN5OB8/+tp72HXuhyH51NWzzSJoZfhlE+zVsEuU2bYj/wspk3q6S5Byo+KfInX0AMhxfMG3o", + "oozxywppI/skySETw71/f/jSr/AnMEVusGJua0C1Ylqwn1Zlnt7Nid+EXQNACF8db7mpNp+0C/agq6eN", + "DKvhyH69+hWx4c+FzC4Krk2/pLcEZqEdbVQMKAbY31hOMqaAaoGdHeVBaWmYLlnGpzzzR7wVs43X870w", + "apXis92XOtLbeoM17udsK6t1eLvnNrdOoB46tk/3XMTXVJt3IDOw/HBBZ+xQTGX3GL4XsprNY34D+ieN", + "yHLJWWb1xxkKejmfTpmyz3CZYHWzXxNK5lKbkWIFNfySkffvXnsib9FvpNxyCLfrGZMTadkS2hFQnX73", + "emh/svxHUMPI6eCT5W5Xe5+kCLYbXU2n/CPTV6cD5ADN47EfNGGviuRVc8M0hLUNJvDWgcBU0Ug9R/GG", + "GWoZNZC1PAfbHy2OmkjVnrhl7FQTbhRVK7Jwg3noj8kbqUAaKwv2MbbKOBa9kDkrUH2qrORBzul4Ms7O", + "7UWrD9wC9oKB/TNiZ6WSsI9ng+NSccPIK8VncystV5qpMVtQXthVryaKif82cRqEVDP/huOHx/ACOTb/", + "//9dsiKCawNOR84T8wIU7e7Fi31PC/qRL6z0e39/fzhYcIH/2u+y/9aZhUF6Dus4Up7Th2VUxXq+DdTb", + "S+ZAElGDEJk9BnQnlQUz7m+H/1yK0ZRyfCP8UVq9w/7x94pV8AdV2ZxfRn+iGQ2HHznpDB7D3xXD55U9", + "mFE8W1IRCHvoOwKUytKKGz6L3AdOUkazyRfhdq2zDJzHLavvSI1UvQTQPQQKGIx5Qyf2emEP7lKlwYqm", + "2EJegvkIKR3LidW/NArlgmVWeFSrFGnSc7qg4iyzqp6szFlKaLj3wj0lhy/vRdI+cF4vXx/DQMQP1HAl", + "jclznls1BFfqPwnv1qbqoEV8kBP0X9ud5WSq5CJsPWmW6rnAJ1Rf6ONqsaBqlXKCLsqCTznLSeGYPzrC", + "PNTH5AVqKagJwcPa/Gl/8ofEqNVJqL7oqm7w1dYKOLii3YK3sP30knj93yuGe46oJ3hoB88eWYWi5gB9", + "NPVqOAD33NlkBS7stnz1q//rjIsGaQm0wZGNXzvKglvIp5pO3k+rSZ/Np17xwiqNk5pPDT3XeX34l+9r", + "ppN0tMnpVLPmQvdTC63h9GkH77XekrL37Si23e6yq+jU2lfiHTOVEmiqt+iF/nnqSSd3igxsYRc5N4qu", + "aGN0P/b2WSsB77e9UKjMXfMiOY35hRRTPqsU9ZEAzfVw/Yorbd5VYp01Em30luNxFDotoZvaD2tjhpuP", + "qEro2q4ffOMgM1EyZUsypZZk6iFxrh0hxQjc+VYOzuL1AjMgUgXdJZj7J5YXE7YojSW99i0zZ+AIqopc", + "3DNkwnpdvEDvvwdzSL7eButYA6zCKCr0lCny/OgQ/JTe3J22yWpkha9lRtMxGC8D6wC+ZLmOvRQwl/t4", + "vFGPbM/S3t0wPuA1WPJXqrg3SbcR5Mws5ZImeNBbwUZLuiKX7mN0wli4LaQ2YNOU9j4yNFWBB9OyLSvd", + "lAXNwCWHDPL8kxVur86disMVhk940WEOPl8nFVDiY8aC4Z16Myk5WcrEmmihpZ807/j+gpTC3PLLghqr", + "8YyCaozBHMDW3SCTVVh0H6LBR5s1UWeErQHtv9zivJ5XOWeiacB2RgCnNeikbNoaRq/jUusoVBt9Ojzs", + "DS1LC2M4ZX8oxG4Z4jpMiBbhGLuV2PDqL4yV7yohktFgh8HEuowuLsKALOiKXDBWWqIkvPCWFnUWnXm6", + "B1oL7D3SN0r674LisGa13nwdy/UkqBxBjVw6vD40jrah5Dxn5BwfWe7EzondijO3xQFJeH3sJADvmbT/", + "FeyjcZ5bJNLnllefD8l5Ewjn5M374xOr9p5DgE4PorfQuQXIALU+GKWwPPhwDr0TrqW8OofX+ovVctEk", + "hr91n+JXc/2BxsLyzRzFee62c9i9YzPLthXLkf52IUnzXDGtd4yLdfQ3fdPk1CypYmuu4Saq9Uu4OSjX", + "Bbf4WbAE6t3E4c+KrHUMwIMqjq71gBgOMoyrghUOIij0rD51WscsqxQ3q+DPa1HAbR076zw6x8xU5XOt", + "uTZUGBQ+U67QWMiTEyvbeV0Z5C47CgnDdKm1s459D75SukWwXL9z+GsJat0tJOEJ4pw3YyTsAAx0f2c0", + "4XDlrfh0/OPzB48e47XX1WJINP8HBJ9NVoZpFMhypu3ySOEW5Z2sXetGy5IJs4FPCsnPoA7DHM8kCqGD", + "Z4ODR5P9h0/vZw+eTPYPDg7y+9PJw0fTbP/Jd0/p/QcZ3X88uZ8/frifP3j0+OmT7/Yn3+0/ydmj/Yf5", + "k/0HT9m+HYj/gw2e3X/44CE4tXC2Qs5mXMziqR4fTJ48yB4fTJ4+fPBwmt8/mDw9eLI/nTze33/8dP+7", + "/eyA3n/05P6TbHpA84cPHzw+eDS5/92T7DH97umj/SdP66kePLnq6vweIkdJamt/jaRHrwg5fh1Hxvpx", + "gJ+DNOms+86y3zZFAQ2nOihFGCMVTTImh4LIImeKOJei9pZ9NxbMaznAh0qjY+A0bIccvjwdoFHIa8du", + "FMKDV5riKkBXO3f2lpEuqtmezphgI0u99jAQeXT48rwn8sqhzJaKL679FS/YccmyjTowDj5sHtPm21Rz", + "/5T91T5Da1rrVFIpBtdAD+f9ayMGKM4O9LV3yMypIEvPzIOYOLTIEQ8K4QkuYo768PD6GpOTSLr4fOTr", + "sWY2ggC2O5Jw1F0C51Qw6qUuipTX0Sq36IgOpyXFlr9U1uOhKaMe0a84aWOf08QKm6Q2HjM5BtCZT13L", + "GGvS6MFG74tdjRtv2C/sNgH8Czfz2rOyFai9Ep4BOZv0gH7oxNQhyVnJRA6pOQI0PBRn/uBns63sGR1H", + "jx+mc6qx1Xrd8XYcZpW4EHIpIMCgkDRHfcweWEPvqvePg73D1UAWiNPTri14gKDRgF2vLHFDQsOtCAi3", + "wN76D795XhioluZqeFogZlOios88SxnGR+lsE7J53Zm6tHLHKxgqBJoAollO4l6zv7GPLngvyPVxkOBt", + "4UB9McN9uBm0iCcK1+0L40pEvj8XazCNskk42t5cPP9dee6XIoRriZ5i+fEmza3NSjR8VnMsmluh2Ol0", + "USAUdVZVclrt7z94HOzBTjqrtMX8jqHZSDdgYi4UpsI9cALUPd10d6Tc3DSy8O5giQ2G4avhoIgAtKOt", + "5RZcJa1TL2oNOWy9YQhprimJHTK7YObw7U9y8h4cv8kUNs1MyB0eEm2lbHnJFPFfe2cDJPmAzVKPySsr", + "5LAl+BeHVh1il1xW+gxx9Rzl70lN+lIn+oWiG731rDnQz3QR5+Wls0Abi97JAxpHDYUcsUdJv7JiU8X0", + "/CzEEKy1hEfBy05vdt9j9ALu5p7GOIbavQjHhjleWruQTO1dOfBPcBPSbA6x2Jc8rygGQ5AlzDJjgim0", + "jkuyoGLlB3EZv6WimeEZLXq9ibsDsT8/f9fo088IPk2EnLoM/SiHv3mG6+5aHCHZd+nckUtVH3kilDEk", + "AtiLZ7Vdt9J0itKWoaFmXi0mAgLsNh5UOtgzlbxUB4/iX2GSdZCypKc/M/+YCfAtBiqEl0JbRfx8T0ff", + "nhN2CaYBSHc20qU5etktetM+tMB0mD0mL/yYmJ05YyZ+jgYhcEDZe+Lvg/93IWcane2CMZexUhY846ZY", + "+WknDEkluHvto9UwbCSjLkYjvGvHkAIjp74xEtbTmHrqUeaDnHwLGoV93b5yT9v1EHClWdxP0VtZbhRF", + "Ekfz1jvUtk3oTg3i0+C8e6Cf6GOehpFNqOyRStQ/WPFhvJk1tBBVluvyvtdvPdIlwzIgALL+V1KN7ANF", + "QoKghlxwe6LTnWAQYkKL4ic5gYD5ovgleL4d66P6opAzfBhf67WrPqH64rWc9VGxE3cJSDavxIWTHCAG", + "IdxZJeWC5AwZXI4PXZ6SXRLcVnopeW4/znHTTe6TwmO7k64nxS4iIJFb2pi8oauQpbSoCsNLSP0RDM3D", + "7KNJ+ic9LVuLqifogdoNC2sqabexDhPt8NuIbScAyX65DYDREdxcHOT1JLc4jWbnpJXtwDbchattFgGd", + "t/BzZcBmkaHrfHObok1gzc6xuja7Zg0mIjnZBhfxzXXY6AJSPD4mkAuq27D8jCY9EijuIt9kpo42duNa", + "OckNMP5iaVbOp78FztpzO9OMpXRwWgcJch2v177vs1yjNPTt1r4Z9Zd+9Z+L/J1ogc/46iwLuQDbftyI", + "l7nJq7RDNuOG2+XHSV6uOFMxWcKidiZHtR6MrIPom8bDbcLBPz/Fxj04+O1/kX/759/+5bd//e3//PYv", + "//bPv/3f3/71t/8dK02gDcfR0W6Ws2yRD54NPrl/XoG7shIXZ2g/PLB7MlbZPKNVzqWPn57ygjm39x7q", + "SXt6uvdBTjS6X+8/OBjDkPEhH/38g/1nqQfPHjwcDqaKLiyNGdwf3d8fDAegZukzqc4uec6kVdvhl8Fw", + "ICtTVgZL5LCPhgmXTzsuXSgXbMW91V0XzhRWtpcGl6vl0xlPSWnWjucKNGFlmLPacjUouKg+RhgNUaYj", + "B2qnX3bTfmPM2aAThqyzbcv5bTCOxAiyyW7gX61jVbayNtRpOj1Q64TzotgvZkSvtGGLOkXQfduq1gLp", + "O5mcCa5Z1xzqXnbGHIgjKOSSqVFGNQthBm4KvygXEn6KB3o6GJLTwZKLXC41/iOnaskF/i1LJiY6t/9g", + "JhuT4zCVXJTU8FCi7wd5T5NzVQnQEH94+/b4/E9EVYKcQzykLEjOtYE8GghAtvonDWk1pdRQsCcs0nLv", + "59rbi2lB7I6GjX2Q0wFq4+p04J35rtIg+lK9tAmlgkpl+bbV8E8HTeuwH+90UMN+IbXVtEHhv2DEMG32", + "cjapZq4CkSaMag61fpye7vOtMNqUZySXGdR4g/zfomjsLKkW9Bms7A9n25cLGpJMljx2CJ23i8aM7Wjn", + "oYRct+DQifuXhyCWg2M54c5sNOWsyEkumRb3DFlQk4E/i9DMVLQII3UCaU6wdB0YVXS7DhHgkSzyKGel", + "WbuwXQYq1DL01qtTcdhYoJXmFsjchrVvG0pPrEqqtddAtood71ruEhc+xY3TtVlPvC6J1VghN0N7748P", + "NfHVMoaEj9mYTNhUKlaHeEch/uPdFKkvWdH1JqoTYGbY2WR15iPtd0mQc0J1Yq1bKn076IcglhtZZfON", + "4iKqKWIVBHT7f3mo/uBj5ncTzr9+wdubKufgiw3scuLbloBoq6+pWrtxRd1wmTYU13V2rXTmrv2V0AlW", + "zGRg3wLNNjJbfZYBPh1ZYwkNBIe0DFjDRrRIF1MiO9XGmStVpCd+/+41ocbX5IlmJ9xoVkxDFJ5cikLS", + "fJvo+drMFU4RKybA/vtOZfdU95DUHvJVtZyaUTvXPWXmrCe8S3np8a2+RmJ6nHrcVSorbQjr1uao0R1L", + "oshGHcna3wii4LjHj7u1ke4uEcPrWta2pEh+pr6TWmdax2fBtwtJo0hB7QHhyKiWIOa5EA3wSgHFghOD", + "slhYSQ1Kkj63Um44PYhOkiUmu/2JSGdjaL3AZ0IqlpNvQL6RPlvw3NNbZzMW0hCmqMvKCnWT2hKsXda3", + "m4zK3fzKggtXAtn5yyEK+J4mWaizi8mRdmk+dgvJNXl7ydRSccNQruWy0mA+FFF5J1/4JCk+pBwOr+XM", + "ORICDUCfhhfIfXleu2g4FZiQUVXwnoKIpkECd6ASSeSqM5FariZEIsUgpDpjoB+BIssFZpTiOIlA1XVJ", + "TJ9HBdZcMj9p6hLVe9yuPJizJ4baDJ0k3/Is2mNLMjgi7lnHLrw2mGg740L/WJ+flGWccrMZMqAGbUXx", + "Ikg1opKi+m7JdKyrXztViFwJjiY38sSuPuXX21T86uLsrrpJG0XWBxf60fuRE1MD+8oOXDP1j2UKS1p8", + "cWxpyxw4UzPwLDXFmgJ+DqJ8Jt72VDZ8fnQIXRaifL6zuoahXtLZjKlRxfsmf/Y3b122IuF0UbKZK3k+", + "qmteD4aDBddZopJJf9nDzmJuHuL+oqWB3FnRGoAXjJXHVuWtUnm28Jho99xHfqKW44sIHBuqDMSZMJGj", + "8yqwX2CvHN1MEFeW01VTjQhjc418lo3J87IsOHMOPHTeSfshB7PKeU5X+kxOz5aMXZxDJgW80/zdvgwF", + "L8anIrFCEFkEefBwNJeVIj/++OzNm7qWCpYgrzEwHnnwbLCQxFQEQlQhuCI/A6Hw2eD+d8/29zEf2Okk", + "zjGh7Qr8W/tP7VsdBGtO0k03oRkbaVZShWESSzkqGBR998XwHNQt27BjAcFj7KIHzOSb08FConHYVN4u", + "/O2YfA9lQhaMCk1OB+ySqZUdz5e86yBqvf+IswNAe5K6PWg+pQMEA6A2D9fmQWHsYROajXGjFa+5F4Ya", + "1qfyOe+kiisXbO/dTCps0WBbLSpv0cgQTE+X9IJ1kes6btjtI8wb38VhUBbqmEeD6xoOqLYkxR4C5FUP", + "B4Zp94qcTq2snNTD+328icpGWCcYiVWtDbmqEXWOlf3x3EW0JBRWfVbQf6zWx3E3C1I49w2qGHEbFiBS", + "tQkc5YFaLXFamCZTLriet4zZO4fPbnOKw7C/NefZZyL4M9U8WyOOXVv7/3qREV+qNsIXi1uIhIkmIP5a", + "OwNDjUAAicN0rn39lutZKTbLDN4Nsp021axz9+m6RtF0QHFCUzhBVwz2y2uUO4JBtCvrYGWeRSz8n9Eq", + "lWD5XjMFBXi4jkOIDl8OSUm1XkqV+0coBrs6S1bI8Tp0LdtbxATAwMW216je6dyYcnB1Bc0U0OgMMYmZ", + "iWTgcOInjC6cuRS/1M/29qY+5oPLvW5xIQznJK+oWrjoZ0g5GQwHBc+Yy4Jz8/xw9PryoDP+crkcz0Q1", + "lmq2577Re7OyGB2M98dMjOdmgRVWuSkaq12EeuS1wH5/vD8GKUiWTNCSYx3y8b7L44ST2aMl37s82Mva", + "ZdlmqNiEOj6HOZTYN836bRZlMIUORnuwv++haiV9i8FW0MQMmr0PzoqLeLtlAlFzPji8JtCFxeoipPIh", + "Cnq6aleM3sxmhY9pp9uIoTONxUQMBd2kHuN7kZeSu8SOmWsV1xkwHEUY9GqYBu8euFb3vKrUB+xXXOR/", + "DkU5jjDz9sbAne51kYD3K1mJukYHyMChu0izjeAXWRcWh0ms4zh0E1haBr9UEjoNNk7uFXex+VKRhVSM", + "vHh96HtboMEQ4hA0WVKIYABpym8nhRSl1ImTggIOiaMCVvNnma++GDRahagSYPFdPaRy9mbwfmPxJYlO", + "fcyGunk8ahS26a705+bFHeIiMewAjnTKBbt7OPVXWnAw+tMYm66DTC08dZ6Dy3p832OsPsiNRAXTPEdR", + "YNYalG2krX5VrD26Nfz8D4GYmN1bY2Qz+XcDu9thnF5khIIW20oRr7D6xWcd+Q7V3K+GjbFWdFE0x2rL", + "xZsQpH0Q76BvziVLCx5dOWHtaTzPMqZD89NUNdrEkCE4T0hDcGP3wK/0tmTi+dGhT6krCrlEyfrcNwnc", + "c5KkO9BzUtLswh72qeg/bs1MVY6or4/WT3aO6SVLlmS7GcKTnCrJNGOwWtpNLxG9W0j5MBHj30IGiAhc", + "sgktS2+uyK2KNK2Kok4i9o1grVx590jJ+9qt3VMawPc0RibHoWCX3eGKTCuBfUIL6E6xAb0tQqQwu7fy", + "Xj8ONjjf3iefrX+198k7Ta7WkaQGM2w2IbMKOLewc+VvnAoX1QOoFWdnjd5FxenWSLBafGLCyPnTP2Gb", + "ev16g8w0Xfdid4rptbRWkYqiUS+j0TY0rpRhv3QmAV8owyJnqJKBpr4d9bt1y2n0UOgtntGPqiEofXcs", + "rSsk/yeGXmMD+jOQs66s0jYfkPfatzBlrcbAG7ISkIyG4sqNVsHYNC8VwEwmVNfV7yZKLnUjPP/6GF/v", + "cXcc960Eejg/BIBjLZEbYfWNjnPdQ4ZmxNIlj3TQ8yY1jjULAuN6ZSU85J0uat+Kai7EKqoQogHaD+8/", + "uHkZ4SRQ1JCeAK2Sc8l810efxtB8IZnEwDWk0RQrkles1Rkyo9k86neNQ8F9kJIUEptV36Z4BA+ILync", + "pASIY4T6kjuw0PYdiXqmxrIP9sVoDPdTM6eDuUvZuVSo2m9xtUCv/br3K4uWsO56PUznWu54IUL2DfSq", + "hX5DcytQ/vz2BLNdsLagD6GtU0TMXFaz+X9eqN/LhQK02nCdAPvDvu1IYEqDYi9Lbk/c1I22eOKaNYr/", + "9JvlmcnmPxRyQhslPCCN4Wa5SF8hoC0EmmH6yp34ukY+PQ1uDxWrZE/HHrkIOkHOqcFSjLqvjpLecHxv", + "oeo6dgGrI+FnAOie5bTO7+++TVeaTEIfJFec5SYoZN0pLKV1t2vZYnwW9IXCFM/xbQsljcZQ/VgEUI2M", + "oS4LBVsdQVIqn1oSBlQHyJjrxwQfju8MrYF7G7JoLeC3Q8i6ddcUuoVBhx6REy0h8KaLhpbi7n2y//2Z", + "Lthabc4lmW6ly/kB74xq1U6V7ZUK8FmbdLgYx8CjsHu4JjUkNpxPlCLWbBqMmbnJc9FbnIYe3CLQkgpp", + "eCnsRicAGKGya58MUhCUW9saiPVUge2G8bog/IRBIVd1fZguIF/C76jobcbqkJbWj9ObwlZ+3Ua4fIkk", + "KKJjsH5LjENqtFF8NrMM5naJ1nvBPpaYMw4Re113AkbbhQX7aoRDwkVWVDnKM64WJbY2sxxczrC+MkrJ", + "Lt08DLKgqxBG5+wINLuYKVmJfEx+lqGniA6ZNK6gD/lmxcy3TRtDwKx+kemrYsStaPPc12VsM52WTONb", + "16/XDPEjkZModL7vPu5Nmr3Y0zfzHbSAbXRuv80DuRGJq95KSuuqSou/3yxdOazQaf5bV0210RQX7oAf", + "bkvnj7+bNMtYCaUTmDCKM6eHAllxk9w1ogKNjv1qXQl2e+cjEOx6v78OXt3cRV+LXKD+rEEwqxHNpEF4", + "RqUL4PbfJVRAGgVaWzOJq66m7/cAaJJLiH9zHVDDlnVzh+ulDnRqB1SLa+z2Sx27KOhtdRm18z8CUv7O", + "rQDNo76GRSA5aKNHej8CaWbiLPcecypoAkd1KvnvnEX6nbhcmx7rpGBL4mEzvp4B10/kkzWWVAfGiKbW", + "Bw/6qjj4PqN+CT54Bb8PoW9fmWiuQdYgCdRbcGBouqg3ImidFrEOPY9DyYPfN3I2Kn/0oGYzBQgcqrCW", + "a6LpcWO46yBpc0EOU8HYHA7b5x3p0LMkSP6/EzRubnIXJA4dFtay5xN464/Bk2EvIQUnLSsijDnTcQUO", + "3ZF87phYSN26oW4ItL6oV93Ahm3kvfSOPRJhI5U931NtD2tRrSGEzVakN+T2bE6SsuzHjce8q4q4voy3", + "Z9BPtpJMhTr6dorQhdn1fIxcrkgD95/ePAKGldBCMZqvXF0/R4Qf3opTVjGytP/B0wNPvJhBPA851y2I", + "1t3JoCon9qAkAErw5UjhTKa3doWr1hVu3eAX2OmV1g03MdxIrxYFFxeuAxoiqIMAutkNmgwdUCrLDooi", + "smhgOzHM/XN9lly5xYwWBXqfuY4CGmrigEBtB4G6BVGi48sEi2k0AKaK0bU0I+4hty3liE/2RqlIqo/h", + "tgTlK9CSZBu/1HpD4XkoOStBRIoPYhjXTbDvuL53zjx9p64MtImse+zGMHDNRzHuuZTKaHfx8aSoChvb", + "iPDPMfCe+qCNwDbaA4ZOZT4QBNsd4ipqsgPvasOLol5C95bAsHuffCvMq71P8Av/xxonZdwVTyrmI4xa", + "QtvWTU4tZBISnn91J9/msDNvVLnR9wcMRRsTs/rdbzNr3fP21xu/eJ1OiFsad+7UJYqLN9QdG5O9Oxue", + "pOi+rCPeASP/YyPjMKWoOqLCmx3tXAf1nE2ZIqEhqC8BXbjEldPBg/3vTgcBseqaglAqCHwmplKC5XXP", + "D9yeDnIchu6FDqydA8fsI1poiWNouWBSMMIKDePUpQRTywRsAQDOGcXMSgfC/zHCaUYvqBi9tPscvYcB", + "BgkYRv0eUzCUis+4oAXMaccfk8Opq1VYyLi2YehUy01URt11muUx1Ybyg6F7NRWEcngDqqXPOIbmbdrb", + "W7ew0Su3sMHG+I9t5BmZGWZG2ihGF00KEVTrCRf2fg8358e9wDl0q731NWw1Xgztmmke7H+36XWHjg1E", + "dCQHAz+fJEdQ7nOrDmBY5oSZJXPI7sAZRVj4sAvvYp+G9txSdehOEJ09LoOy8yhRELzRfHLDrfU3sL45", + "DvFKJTNXKXHC7Idh/smqce9QojjvvULPiD2zc1cOBqhLDI7bDirdwIGAM7iw0n6+Q36WkOTmej82HsL9", + "nEqV8UmxIlkhXT3VH09OjkgmhWCQ5ObrlEuoV+QIr6sxpBvnxQj7SDNDNF0wJ0ka6ev7k1xWVsjDD/T4", + "VPhTxYwLvE1174rECZCJzFe9rDRO7bNT1NpFFyyx5AgWm71Proz01XqjnusotkUoW6hKfTcteq78ZtIY", + "jYWkxFTeUWtdsz76Gptc4os1J7/niu+uP31fzv2PggR+P+twAQq0e3zoCRJpS0zw4ZxqIqAmMVkxc7fQ", + "KfbqdmrhY/TrgmFJFdz7BqeCS4hvuXJDf8gNiGdco9yNyHdiX7w7yGfYR7NXFpSLHQsMnLSB80fBqyjW", + "hGpDpmwZdQGdxz10t6Je8SdhPF8QfC1Wbedojep73ypWfXkLZKfLwh/e14os8A/gbMXi+RCkg0G7l4yw", + "6ZRlxou10BwKR6CaLFlRuPe9BR76dDHqEn7n1YIKjXGlIJyCW+6S024S8thV9tNg14Vynv5GYZAYXKz6", + "Xp0TLrRhNG+VC4lqLfZmtoeK5TfG0n2Iu5/q2tXkQqx8o29cnRG+Pvv6RdR5vNKu3GYwARuX4YfaZLEi", + "tJ4uIaHjMYwWM7MXlVjv55R1T+obA3NUJz4B4b+AOu7X2p/WEFWS97Cs95qOFPOfepxtaP6psnxd4O19", + "crUqt8pyCN0CNvOGMOzN5zp06le5Mpkh0cEF8t/FgOSa7C1d8fNDoF6KZXKxCI08wBiZQTwCWEJczZlO", + "H2JXz9zVPT4HKommvOZL6DtxVV2HRBtZEm41eaXNmDwXKxSt8LW49Gnc8zh0AMQmSE1lvIW7my7oV8Wp", + "L00KUvjga+lumTOxDGWPNxIDS0RyZqD1VDhir6Btd/O3EQ8d8+6WGL7to/vywuKassl3QWq8IwJdLwJu", + "J9Z5jN4BKQvGypGOWklsoiLN3hN/JJLS3Nk2RRzB+t9otrEuIp7FTFPI1Jd3Ew17ddk7gBE3Rqk2IYMP", + "cG+f4rV9UqHZR5CpsNLI74I+WQYpVdy7LrRLSKB5S9/DWutMjeqGo338EV8M8szNnX+jt1O/rAF8CRd1", + "q+FUHhIs7xeHOnrn3XGm+eU7f9oydEhr4FmHB9ZHYlWy+kudQCorT4/kdLrGGMdn4u10Otjmgt49WLqO", + "CEBiG70Q/gbtFWqwvaHqItYpqCa+Z8sGgL+gRYFuXa/9GkkKZ6/wlXSsQgw92O8pRmaQx+eGH/eeithw", + "KOJGr7abov9SL5ihOTX0Vm90t4PR7+JKb42GzyszZ8JghzFXl9xig/c592ljn42TGLFhJMyAnqZGl1Ve", + "H3gSY43LGEgKxtGpDb42csBKvWJQd6bqE0iFJP1f3G2s2h1DfChsaAKlMLxMrHqA0IsKo6xu5ZUmYYm2", + "XzetU4eJUlpLYJO41etJqL9jyuOoujs3b68DZ0bmo1/AHmDJRsFyLIyBEaaOooyaziOPLtAhjIs6stFR", + "GaZGhcxoAQSOFvpLU7VL1thNpVPY6lvD9vBZJ4+7AJubK07kDJu98S+uLXkob9lHrn6WvhhNiF8PGdq/", + "1HaPh/sHX7DUO6JYL2IeMeUrbb5kgiPpdIlOadMk+hody3MtHQGjhkTLkKBcFHKJtmAHFrd1xWdzQ4Rc", + "Ok/nwe0yGH+RqIDgXXSQWCkcVochuJDaM5PQwsuFsOGF2/HSOvcLDeNH0Nh0mwCnvMKp0kVQk67G/usS", + "tXT/A3jt3U76rqOTjaJWgde3arixum761C2pg+F0sxmcwyRfE0VLF/gaxq7z+m/bYPKZzClqi4A95s2q", + "5Bk4aeOO+KWSM8W0HkL5Wqy3BdxnSnlRKbaRw3i+opnIG44QC24/OpQuY4ptvil7C7oa8ZGq+v3vb+jK", + "mVIq8YeI3ntDV39hrHzn+jT+sdQzjJBxYkyd5hFJzJFrM2JQqhJkj1wwVnpXZx0pQ96W2LUDqi4LS9A1", + "oQRdmbFMGvwZKf9mDyJ3JHpQ9qKVtdbEdR2+sx61ZWXKyoxKJfMqWyfoW2L5Fl4+8u/eCeYABWz2PpRs", + "tmvaxdB9W4rZ18rYeLBlxgZIfy4XwddMfXj//s1ftNdMzMw8ZDn/Ka6UnfMc+yNZKkuJA8HIfYIJOG6l", + "Bze/0iO6gsB8KNNNlatv/PD+o9twI4Qu9+QNyzklJ6vSecwAxQhilBcmJyGvpO56EUfXPHzw9HYqqvtE", + "N+SUQDoktEJdkam92K69hsubMHMljSmgPzUrpr8ryQMTWiygF1IboliGaT6hDhbsF+WBKK2FA3Cq0keq", + "1I4QJnSlWAg2A+ndnbL98p4mOZ8xjd0jW2dMXoQ0I4jDOfr5B4DzT0ff/0AcKtlBy4IKkY6DWSfwmHm1", + "mAjKC71XKnbJ2dKTJa6w+pen9gSpvxeDAKLq0lNz7Ky7N4iMUG1iddgMMulUnveYEtgBRPN1MwZ/khNv", + "JgUZ7e8VU9yiX93eYdiq5Tlu1LfRiUGfHx026+HHJjK5WFQCxU3IREx1lWs4cBMTOGx4E9ZEoDVcbzca", + "rARut2HvipKFX1FnMnA6JnJiMc8ozAJ8ok6SchAMNfo/yEko/RDP4fKarn69+vcAAAD//+WFDsju6QAA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/web/app/src/manager-api/manager/JobsApi.js b/web/app/src/manager-api/manager/JobsApi.js index 69edde05..b300f15b 100644 --- a/web/app/src/manager-api/manager/JobsApi.js +++ b/web/app/src/manager-api/manager/JobsApi.js @@ -49,6 +49,52 @@ export default class JobsApi { + /** + * Request deletion this job, including its tasks and any log files. The actual deletion may happen in the background. No job files will be deleted (yet). + * @param {String} jobId + * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing HTTP response + */ + deleteJobWithHttpInfo(jobId) { + let postBody = null; + // verify the required parameter 'jobId' is set + if (jobId === undefined || jobId === null) { + throw new Error("Missing the required parameter 'jobId' when calling deleteJob"); + } + + let pathParams = { + 'job_id': jobId + }; + let queryParams = { + }; + let headerParams = { + }; + let formParams = { + }; + + let authNames = []; + let contentTypes = []; + let accepts = ['application/json']; + let returnType = null; + return this.apiClient.callApi( + '/api/v3/jobs/{job_id}', 'DELETE', + pathParams, queryParams, headerParams, formParams, postBody, + authNames, contentTypes, accepts, returnType, null + ); + } + + /** + * Request deletion this job, including its tasks and any log files. The actual deletion may happen in the background. No job files will be deleted (yet). + * @param {String} jobId + * @return {Promise} a {@link https://www.promisejs.org/|Promise} + */ + deleteJob(jobId) { + return this.deleteJobWithHttpInfo(jobId) + .then(function(response_and_data) { + return response_and_data.data; + }); + } + + /** * Get the URL that serves the last-rendered images. * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/JobLastRenderedImageInfo} and HTTP response