From b6823a176ec6ea552af26cfa6f39e44357c1ff30 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Tue, 13 Feb 2024 13:17:52 +0100 Subject: [PATCH 01/18] Removed results unwrapping from workflows --- .../complier/runtime_input_validator.py | 8 +- .../complier/steps_executors/auxiliary.py | 96 +++++------------- .../complier/steps_executors/models.py | 99 ++++--------------- .../complier/steps_executors/utils.py | 4 +- .../steps_executors/test_auxiliary.py | 86 ---------------- .../compiler/test_runtime_input_validator.py | 19 ++-- .../unit_tests/http/test_client.py | 48 ++++++--- .../http/utils/test_postprocessing.py | 5 +- 8 files changed, 100 insertions(+), 265 deletions(-) diff --git a/inference/enterprise/workflows/complier/runtime_input_validator.py b/inference/enterprise/workflows/complier/runtime_input_validator.py index 5e89dfa0b..ed79024ce 100644 --- a/inference/enterprise/workflows/complier/runtime_input_validator.py +++ b/inference/enterprise/workflows/complier/runtime_input_validator.py @@ -127,9 +127,11 @@ def assembly_input_images( for i, image in enumerate(runtime_parameters[definition.name]) ] else: - runtime_parameters[definition.name] = assembly_input_image( - parameter=input_node, image=runtime_parameters[definition.name] - ) + runtime_parameters[definition.name] = [ + assembly_input_image( + parameter=input_node, image=runtime_parameters[definition.name] + ) + ] return runtime_parameters diff --git a/inference/enterprise/workflows/complier/steps_executors/auxiliary.py b/inference/enterprise/workflows/complier/steps_executors/auxiliary.py index 9592269d7..de64c7845 100644 --- a/inference/enterprise/workflows/complier/steps_executors/auxiliary.py +++ b/inference/enterprise/workflows/complier/steps_executors/auxiliary.py @@ -91,9 +91,6 @@ async def run_crop_step( runtime_parameters=runtime_parameters, outputs_lookup=outputs_lookup, ) - if not issubclass(type(image), list): - image = [image] - detections = [detections] decoded_images = [load_image(e) for e in image] decoded_images = [ i[0] if i[1] is True else i[0][:, :, ::-1] for i in decoded_images @@ -187,30 +184,15 @@ async def run_detection_filter( ) filter_callable = build_filter_callable(definition=step.filter_definition) result_detections, result_parent_id = [], [] - nested = False for prediction in predictions: - if issubclass(type(prediction), list): - nested = True # assuming that we either have all nested or none - filtered_predictions = [ - deepcopy(p) for p in prediction if filter_callable(p) - ] - result_detections.append(filtered_predictions) - result_parent_id.append([p[PARENT_ID_KEY] for p in filtered_predictions]) - elif filter_callable(prediction): - result_detections.append(deepcopy(prediction)) - result_parent_id.append(prediction[PARENT_ID_KEY]) + filtered_predictions = [deepcopy(p) for p in prediction if filter_callable(p)] + result_detections.append(filtered_predictions) + result_parent_id.append([p[PARENT_ID_KEY] for p in filtered_predictions]) step_selector = construct_step_selector(step_name=step.name) - if nested: - outputs_lookup[step_selector] = [ - {"predictions": d, PARENT_ID_KEY: p, "image": i} - for d, p, i in zip(result_detections, result_parent_id, images_meta) - ] - else: - outputs_lookup[step_selector] = { - "predictions": result_detections, - PARENT_ID_KEY: result_parent_id, - "image": images_meta, - } + outputs_lookup[step_selector] = [ + {"predictions": d, PARENT_ID_KEY: p, "image": i} + for d, p, i in zip(result_detections, result_parent_id, images_meta) + ] return None, outputs_lookup @@ -263,35 +245,18 @@ async def run_detection_offset_step( outputs_lookup=outputs_lookup, ) result_detections, result_parent_id = [], [] - nested = False for detection in detections: - if issubclass(type(detection), list): - nested = True # assuming that we either have all nested or none - offset_detections = [ - offset_detection(detection=d, offset_x=offset_x, offset_y=offset_y) - for d in detection - ] - result_detections.append(offset_detections) - result_parent_id.append([d[PARENT_ID_KEY] for d in offset_detections]) - else: - result_detections.append( - offset_detection( - detection=detection, offset_x=offset_x, offset_y=offset_y - ) - ) - result_parent_id.append(detection[PARENT_ID_KEY]) - step_selector = construct_step_selector(step_name=step.name) - if nested: - outputs_lookup[step_selector] = [ - {"predictions": d, PARENT_ID_KEY: p, "image": i} - for d, p, i in zip(result_detections, result_parent_id, images_meta) + offset_detections = [ + offset_detection(detection=d, offset_x=offset_x, offset_y=offset_y) + for d in detection ] - else: - outputs_lookup[step_selector] = { - "predictions": result_detections, - PARENT_ID_KEY: result_parent_id, - "image": images_meta, - } + result_detections.append(offset_detections) + result_parent_id.append([d[PARENT_ID_KEY] for d in offset_detections]) + step_selector = construct_step_selector(step_name=step.name) + outputs_lookup[step_selector] = [ + {"predictions": d, PARENT_ID_KEY: p, "image": i} + for d, p, i in zip(result_detections, result_parent_id, images_meta) + ] return None, outputs_lookup @@ -319,9 +284,6 @@ async def run_static_crop_step( runtime_parameters=runtime_parameters, outputs_lookup=outputs_lookup, ) - - if not issubclass(type(image), list): - image = [image] decoded_images = [load_image(e) for e in image] decoded_images = [ i[0] if i[1] is True else i[0][:, :, ::-1] for i in decoded_images @@ -418,6 +380,7 @@ async def run_detections_consensus_step( outputs_lookup=outputs_lookup, ) all_predictions = [resolve_parameter_closure(p) for p in step.predictions] + # all_predictions has shape (n_consensus_input, bs, img_predictions) if len(all_predictions) < 1: raise ExecutionGraphError( f"Consensus step requires at least one source of predictions." @@ -432,19 +395,16 @@ async def run_detections_consensus_step( ) images_meta = resolve_parameter_closure(images_meta_selector) batch_size = batch_sizes[0] - if batch_size == 1: - all_predictions = [[e] for e in all_predictions] - images_meta = [images_meta] results = [] for batch_index in range(batch_size): - batch_predictions = [e[batch_index] for e in all_predictions] + batch_element_predictions = [e[batch_index] for e in all_predictions] ( parent_id, object_present, presence_confidence, consensus_detections, ) = resolve_batch_consensus( - predictions=batch_predictions, + predictions=batch_element_predictions, required_votes=resolve_parameter_closure(step.required_votes), class_aware=resolve_parameter_closure(step.class_aware), iou_threshold=resolve_parameter_closure(step.iou_threshold), @@ -464,14 +424,12 @@ async def run_detections_consensus_step( "image": images_meta[batch_index], } ) - if batch_size == 1: - results = results[0] outputs_lookup[construct_step_selector(step_name=step.name)] = results return None, outputs_lookup def get_and_validate_batch_sizes( - all_predictions: List[Union[List[dict], List[List[dict]]]], + all_predictions: List[List[List[dict]]], step_name: str, ) -> List[int]: batch_sizes = get_predictions_batch_sizes(all_predictions=all_predictions) @@ -482,16 +440,8 @@ def get_and_validate_batch_sizes( return batch_sizes -def get_predictions_batch_sizes( - all_predictions: List[Union[List[dict], List[List[dict]]]] -) -> List[int]: - return [get_batch_size(predictions=predictions) for predictions in all_predictions] - - -def get_batch_size(predictions: Union[List[dict], List[List[dict]]]) -> int: - if len(predictions) == 0 or issubclass(type(predictions[0]), dict): - return 1 - return len(predictions) +def get_predictions_batch_sizes(all_predictions: List[List[List[dict]]]) -> List[int]: + return [len(predictions) for predictions in all_predictions] def all_batch_sizes_equal(batch_sizes: List[int]) -> bool: diff --git a/inference/enterprise/workflows/complier/steps_executors/models.py b/inference/enterprise/workflows/complier/steps_executors/models.py index d1594ba14..1d056d70b 100644 --- a/inference/enterprise/workflows/complier/steps_executors/models.py +++ b/inference/enterprise/workflows/complier/steps_executors/models.py @@ -93,8 +93,6 @@ async def run_roboflow_model_step( outputs_lookup=outputs_lookup, api_key=api_key, ) - if issubclass(type(image), list) and len(image) == 1: - image = image[0] if step.type in {"ClassificationModel", "MultiLabelClassificationModel"}: serialised_result = attach_parent_info( image=image, results=serialised_result, nested_key=None @@ -110,14 +108,14 @@ async def run_roboflow_model_step( async def get_roboflow_model_predictions_locally( - image: Union[dict, List[dict]], + image: List[dict], model_id: str, step: RoboflowModel, runtime_parameters: Dict[str, Any], outputs_lookup: OutputsLookup, model_manager: ModelManager, api_key: Optional[str], -) -> Union[dict, List[dict]]: +) -> List[dict]: request_constructor = MODEL_TYPE2REQUEST_CONSTRUCTOR[step.type] request = request_constructor( step=step, @@ -134,9 +132,7 @@ async def get_roboflow_model_predictions_locally( if issubclass(type(result), list): serialised_result = [e.dict(by_alias=True, exclude_none=True) for e in result] else: - serialised_result = result.dict(by_alias=True, exclude_none=True) - if issubclass(type(serialised_result), list) and len(serialised_result) == 1: - serialised_result = serialised_result[0] + serialised_result = [result.dict(by_alias=True, exclude_none=True)] return serialised_result @@ -252,13 +248,13 @@ def construct_keypoints_detection_request( async def get_roboflow_model_predictions_from_remote_api( - image: Union[dict, List[dict]], + image: List[dict], model_id: str, step: RoboflowModel, runtime_parameters: Dict[str, Any], outputs_lookup: OutputsLookup, api_key: Optional[str], -) -> Union[dict, List[dict]]: +) -> List[dict]: api_url = resolve_model_api_url(step=step) client = InferenceHTTPClient( api_url=api_url, @@ -272,50 +268,16 @@ async def get_roboflow_model_predictions_from_remote_api( outputs_lookup=outputs_lookup, ) client.configure(inference_configuration=configuration) - if issubclass(type(image), dict): - inference_input = image["value"] - else: - inference_input = [i["value"] for i in image] + inference_input = [i["value"] for i in image] results = await client.infer_async( inference_input=inference_input, model_id=model_id, ) - # just for now, until we have hosted inference deployed with new version - return _inject_detection_id_if_remote_api_does_not_provide_one( - results=results, - step_type=step.type, - ) - - -def _inject_detection_id_if_remote_api_does_not_provide_one( - results: Union[List[dict], dict], - step_type: str, -) -> Union[List[dict], dict]: - if step_type not in { - "ObjectDetectionModel", - "InstanceSegmentationModel", - "KeypointsDetectionModel", - }: - return results - if issubclass(type(results), dict): - results["predictions"] = _inject_detection_id_to_predictions( - predictions=results["predictions"] - ) - return results - for result in results: - result["predictions"] = _inject_detection_id_to_predictions( - predictions=result["predictions"] - ) + if not issubclass(type(results), list): + return [results] return results -def _inject_detection_id_to_predictions(predictions: List[dict]) -> List[dict]: - for prediction in predictions: - if DETECTION_ID_KEY not in prediction: - prediction[DETECTION_ID_KEY] = str(uuid4()) - return predictions - - def construct_http_client_configuration_for_classification_step( step: Union[ClassificationModel, MultiLabelClassificationModel], runtime_parameters: Dict[str, Any], @@ -428,8 +390,6 @@ async def run_ocr_model_step( runtime_parameters=runtime_parameters, outputs_lookup=outputs_lookup, ) - if not issubclass(type(image), list): - image = [image] if step_execution_mode is StepExecutionMode.LOCAL: serialised_result = await get_ocr_predictions_locally( image=image, @@ -442,9 +402,6 @@ async def run_ocr_model_step( image=image, api_key=api_key, ) - if len(serialised_result) == 1: - serialised_result = serialised_result[0] - image = image[0] serialised_result = attach_parent_info( image=image, results=serialised_result, @@ -520,8 +477,6 @@ async def run_clip_comparison_step( runtime_parameters=runtime_parameters, outputs_lookup=outputs_lookup, ) - if not issubclass(type(image), list): - image = [image] if step_execution_mode is StepExecutionMode.LOCAL: serialised_result = await get_clip_comparison_locally( image=image, @@ -536,9 +491,6 @@ async def run_clip_comparison_step( text=text, api_key=api_key, ) - if len(serialised_result) == 1: - serialised_result = serialised_result[0] - image = image[0] serialised_result = attach_parent_info( image=image, results=serialised_result, @@ -622,20 +574,16 @@ def load_core_model( def attach_parent_info( - image: Union[Dict[str, Any], List[Dict[str, Any]]], - results: Union[Dict[str, Any], List[Dict[str, Any]]], + image: List[Dict[str, Any]], + results: List[Dict[str, Any]], nested_key: Optional[str] = "predictions", -) -> Union[Dict[str, Any], List[Dict[str, Any]]]: - if issubclass(type(image), list): - return [ - attach_parent_info_to_image_detections( - image=i, predictions=p, nested_key=nested_key - ) - for i, p in zip(image, results) - ] - return attach_parent_info_to_image_detections( - image=image, predictions=results, nested_key=nested_key - ) +) -> List[Dict[str, Any]]: + return [ + attach_parent_info_to_image_detections( + image=i, predictions=p, nested_key=nested_key + ) + for i, p in zip(image, results) + ] def attach_parent_info_to_image_detections( @@ -652,18 +600,11 @@ def attach_parent_info_to_image_detections( def anchor_detections_in_parent_coordinates( - image: Union[Dict[str, Any], List[Dict[str, Any]]], - serialised_result: Union[Dict[str, Any], List[Dict[str, Any]]], + image: List[Dict[str, Any]], + serialised_result: List[Dict[str, Any]], image_metadata_key: str = "image", detections_key: str = "predictions", -) -> Union[Dict[str, Any], List[Dict[str, Any]]]: - if issubclass(type(image), dict): - return anchor_image_detections_in_parent_coordinates( - image=image, - serialised_result=serialised_result, - image_metadata_key=image_metadata_key, - detections_key=detections_key, - ) +) -> List[Dict[str, Any]]: return [ anchor_image_detections_in_parent_coordinates( image=i, diff --git a/inference/enterprise/workflows/complier/steps_executors/utils.py b/inference/enterprise/workflows/complier/steps_executors/utils.py index f9f6d314f..6b336b063 100644 --- a/inference/enterprise/workflows/complier/steps_executors/utils.py +++ b/inference/enterprise/workflows/complier/steps_executors/utils.py @@ -1,5 +1,7 @@ from typing import Any, Dict, Generator, Iterable, List, TypeVar, Union +import numpy as np + from inference.enterprise.workflows.complier.steps_executors.types import OutputsLookup from inference.enterprise.workflows.complier.utils import ( get_step_selector_from_its_output, @@ -34,7 +36,7 @@ def get_image( ], runtime_parameters: Dict[str, Any], outputs_lookup: OutputsLookup, -) -> Any: +) -> List[Dict[str, Union[str, np.ndarray]]]: if is_input_selector(selector_or_value=step.image): return runtime_parameters[get_last_selector_chunk(selector=step.image)] if is_step_output_selector(selector_or_value=step.image): diff --git a/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py b/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py index 81bcc67be..cd78eac1e 100644 --- a/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py +++ b/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py @@ -134,92 +134,6 @@ async def test_run_condition_step() -> None: assert next_step == "$steps.step_2" -@pytest.mark.asyncio -async def test_run_detection_filter_step_when_single_image_detections_given() -> None: - # given - step = DetectionFilter.parse_obj( - { - "type": "DetectionFilter", - "name": "step_2", - "predictions": "$steps.step_1.predictions", - "filter_definition": { - "type": "CompoundDetectionFilterDefinition", - "left": { - "type": "DetectionFilterDefinition", - "field_name": "class_name", - "operator": "equal", - "reference_value": "car", - }, - "operator": "and", - "right": { - "type": "DetectionFilterDefinition", - "field_name": "confidence", - "operator": "greater_or_equal_than", - "reference_value": 0.5, - }, - }, - } - ) - detections = [ - { - "x": 10, - "y": 10, - "width": 20, - "height": 20, - "parent_id": "p1", - "detection_id": "one", - "class_name": "car", - "confidence": 0.2, - }, - { - "x": 10, - "y": 10, - "width": 20, - "height": 20, - "parent_id": "p2", - "detection_id": "two", - "class_name": "car", - "confidence": 0.5, - }, - ] - - # when - next_step, outputs_lookup = await run_detection_filter( - step=step, - runtime_parameters={}, - outputs_lookup={ - "$steps.step_1": { - "predictions": detections, - "image": {"height": 100, "width": 100}, - } - }, - model_manager=MagicMock(), - api_key=None, - ) - - # then - assert next_step is None, "Next step should not be set here" - assert outputs_lookup["$steps.step_2"]["predictions"] == [ - { - "x": 10, - "y": 10, - "width": 20, - "height": 20, - "parent_id": "p2", - "detection_id": "two", - "class_name": "car", - "confidence": 0.5, - }, - ], "Only second prediction should survive" - assert outputs_lookup["$steps.step_2"]["parent_id"] == [ - "p2" - ], "Only second prediction should mark parent_id" - assert outputs_lookup["$steps.step_2"]["image"] == { - "height": 100, - "width": 100, - }, "image metadata must be copied from input" - - @pytest.mark.asyncio async def test_run_detection_filter_step_when_batch_detections_given() -> None: # given diff --git a/tests/inference/unit_tests/enterprise/workflows/compiler/test_runtime_input_validator.py b/tests/inference/unit_tests/enterprise/workflows/compiler/test_runtime_input_validator.py index 50c1df6bb..aeb78748d 100644 --- a/tests/inference/unit_tests/enterprise/workflows/compiler/test_runtime_input_validator.py +++ b/tests/inference/unit_tests/enterprise/workflows/compiler/test_runtime_input_validator.py @@ -144,20 +144,23 @@ def test_assembly_input_images_when_images_provided_as_single_elements() -> None ) # then - assert result["one"] == { - "type": "url", - "value": "https://some.com/image.jpg", - "parent_id": "$inputs.one", - }, "parent_id expected to be added" + assert result["one"] == [ + { + "type": "url", + "value": "https://some.com/image.jpg", + "parent_id": "$inputs.one", + } + ], "parent_id expected to be added" assert result["some"] == "value", "Value must not be touched by function" + assert len(result["two"]) == 1, "Image must be wrapped with list" assert ( - result["two"]["type"] == "numpy_object" + result["two"][0]["type"] == "numpy_object" ), "numpy array must be packed in dict with type definition" assert ( - result["two"]["value"] == np.zeros((192, 168, 3), dtype=np.uint8) + result["two"][0]["value"] == np.zeros((192, 168, 3), dtype=np.uint8) ).all(), "Image cannot be mutated" assert ( - result["two"]["parent_id"] == "$inputs.two" + result["two"][0]["parent_id"] == "$inputs.two" ), "parent_id expected to be added and match input identifier" diff --git a/tests/inference_sdk/unit_tests/http/test_client.py b/tests/inference_sdk/unit_tests/http/test_client.py index 686aa836e..394c5c92e 100644 --- a/tests/inference_sdk/unit_tests/http/test_client.py +++ b/tests/inference_sdk/unit_tests/http/test_client.py @@ -472,7 +472,9 @@ def test_client_unload_single_model_when_successful_response_expected_against_al assert requests_mock.last_request.json() == { "model_id": "coco/3", } - assert http_client.selected_model is None, "Even when alias is in use - selected model should be emptied" + assert ( + http_client.selected_model is None + ), "Even when alias is in use - selected model should be emptied" @pytest.mark.asyncio @@ -532,7 +534,9 @@ async def test_client_unload_single_model_async_when_successful_response_expecte }, headers=DEFAULT_HEADERS, ) - assert http_client.selected_model is None, "Even when alias is in use - selected model should be emptied" + assert ( + http_client.selected_model is None + ), "Even when alias is in use - selected model should be emptied" def test_client_unload_single_model_when_error_occurs(requests_mock: Mocker) -> None: @@ -659,7 +663,9 @@ async def test_client_load_model_async_when_successful_response_expected() -> No @pytest.mark.asyncio -async def test_client_load_model_async_when_successful_response_expected_against_alias() -> None: +async def test_client_load_model_async_when_successful_response_expected_against_alias() -> ( + None +): # given api_url = "http://some.com" http_client = InferenceHTTPClient(api_key="my-api-key", api_url=api_url) @@ -667,7 +673,9 @@ async def test_client_load_model_async_when_successful_response_expected_against with aioresponses() as m: m.post( f"{api_url}/model/add", - payload={"models": [{"model_id": "coco/3", "task_type": "object-detection"}]}, + payload={ + "models": [{"model_id": "coco/3", "task_type": "object-detection"}] + }, ) # when @@ -1000,7 +1008,9 @@ async def test_get_model_description_async_when_model_was_loaded_already() -> No @pytest.mark.asyncio -async def test_get_model_description_async_when_model_was_loaded_already_and_alias_was_resolved() -> None: +async def test_get_model_description_async_when_model_was_loaded_already_and_alias_was_resolved() -> ( + None +): # given api_url = "http://some.com" http_client = InferenceHTTPClient(api_key="my-api-key", api_url=api_url) @@ -1008,13 +1018,17 @@ async def test_get_model_description_async_when_model_was_loaded_already_and_ali with aioresponses() as m: m.get( f"{api_url}/model/registry", - payload={"models": [{"model_id": "coco/3", "task_type": "object-detection"}]}, + payload={ + "models": [{"model_id": "coco/3", "task_type": "object-detection"}] + }, ) # when result = await http_client.get_model_description_async(model_id="yolov8n-640") # then - assert result == ModelDescription(model_id="coco/3", task_type="object-detection") + assert result == ModelDescription( + model_id="coco/3", task_type="object-detection" + ) def test_get_model_description_when_model_was_not_loaded_before_and_successful_load( @@ -1105,14 +1119,18 @@ async def test_get_model_description_async_when_model_was_not_loaded_before_and_ ) m.post( f"{api_url}/model/add", - payload={"models": [{"model_id": "coco/3", "task_type": "object-detection"}]}, + payload={ + "models": [{"model_id": "coco/3", "task_type": "object-detection"}] + }, ) # when result = await http_client.get_model_description_async(model_id="yolov8n-640") # then - assert result == ModelDescription(model_id="coco/3", task_type="object-detection") + assert result == ModelDescription( + model_id="coco/3", task_type="object-detection" + ) def test_get_model_description_when_model_was_not_loaded_before_and_unsuccessful_load( @@ -1268,7 +1286,8 @@ def test_infer_from_api_v0_when_request_succeed_for_object_detection_with_batch_ # when result = http_client.infer_from_api_v0( - inference_input=["https://some/image.jpg"] * 2, model_id=model_id_to_use, + inference_input=["https://some/image.jpg"] * 2, + model_id=model_id_to_use, ) # then @@ -1363,7 +1382,8 @@ async def test_infer_from_api_v0_async_when_request_succeed_for_object_detection # when result = await http_client.infer_from_api_v0_async( - inference_input="https://some/image.jpg", model_id=model_id_to_use, + inference_input="https://some/image.jpg", + model_id=model_id_to_use, ) # then assert result == [ @@ -1710,7 +1730,8 @@ def test_infer_from_api_v1_when_request_succeed_for_object_detection_with_batch_ # when result = http_client.infer_from_api_v1( - inference_input="https://some/image.jpg", model_id=model_id_to_use, + inference_input="https://some/image.jpg", + model_id=model_id_to_use, ) # then assert result == [ @@ -1825,7 +1846,8 @@ async def test_infer_from_api_v1_async_when_request_succeed_for_object_detection # when result = await http_client.infer_from_api_v1_async( - inference_input="https://some/image.jpg", model_id=model_id_to_use, + inference_input="https://some/image.jpg", + model_id=model_id_to_use, ) # then assert result == [ diff --git a/tests/inference_sdk/unit_tests/http/utils/test_postprocessing.py b/tests/inference_sdk/unit_tests/http/utils/test_postprocessing.py index dc03de15e..6d45e4903 100644 --- a/tests/inference_sdk/unit_tests/http/utils/test_postprocessing.py +++ b/tests/inference_sdk/unit_tests/http/utils/test_postprocessing.py @@ -10,7 +10,7 @@ from PIL import Image, ImageChops from requests import Response -from inference_sdk.http.entities import VisualisationResponseFormat, ModelDescription +from inference_sdk.http.entities import ModelDescription, VisualisationResponseFormat from inference_sdk.http.utils import post_processing from inference_sdk.http.utils.post_processing import ( adjust_bbox_coordinates_to_client_scaling_factor, @@ -22,9 +22,10 @@ combine_gaze_detections, decode_workflow_output_image, decode_workflow_outputs, + filter_model_descriptions, is_workflow_image, response_contains_jpeg_image, - transform_base64_visualisation, filter_model_descriptions, + transform_base64_visualisation, ) From 3b26b2be77ee8bbee5b9f9a5102acc8d994bf61b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Tue, 13 Feb 2024 13:59:28 +0100 Subject: [PATCH 02/18] Make Tiny cache default option --- inference/core/env.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/inference/core/env.py b/inference/core/env.py index 110e983e2..6bb53d57d 100644 --- a/inference/core/env.py +++ b/inference/core/env.py @@ -59,7 +59,7 @@ GAZE_MAX_BATCH_SIZE = int(os.getenv("GAZE_MAX_BATCH_SIZE", 8)) # If true, this will store a non-verbose version of the inference request and repsonse in the cache -TINY_CACHE = str2bool(os.getenv("TINY_CACHE", False)) +TINY_CACHE = str2bool(os.getenv("TINY_CACHE", True)) # Maximum batch size for CLIP, default is 8 CLIP_MAX_BATCH_SIZE = int(os.getenv("CLIP_MAX_BATCH_SIZE", 8)) From c2af81e4f4d24e05a8658f787628a336f4fe3e52 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Tue, 13 Feb 2024 17:40:11 +0100 Subject: [PATCH 03/18] Add draft implementation of the active learning block --- docker/config/cpu_http.py | 2 + inference/core/interfaces/http/http_api.py | 14 ++ .../enterprise/workflows/complier/core.py | 16 ++ .../workflows/complier/execution_engine.py | 25 +++ .../workflows/complier/graph_parser.py | 22 --- .../active_learning_middlewares.py | 86 ++++++++++ .../complier/steps_executors/auxiliary.py | 72 ++++++++- .../complier/steps_executors/utils.py | 2 + .../enterprise/workflows/entities/steps.py | 147 ++++++++++++++++++ .../entities/workflows_specification.py | 2 + .../steps_executors/test_auxiliary.py | 3 + .../workflows/compiler/test_graph_parser.py | 49 ++---- 12 files changed, 372 insertions(+), 68 deletions(-) create mode 100644 inference/enterprise/workflows/complier/steps_executors/active_learning_middlewares.py diff --git a/docker/config/cpu_http.py b/docker/config/cpu_http.py index 862dce75e..2de4d1706 100644 --- a/docker/config/cpu_http.py +++ b/docker/config/cpu_http.py @@ -10,6 +10,8 @@ from prometheus_fastapi_instrumentator import Instrumentator from inference.core.env import MAX_ACTIVE_MODELS, ACTIVE_LEARNING_ENABLED, LAMBDA +from inference.enterprise.workflows.complier.steps_executors.active_learning_middlewares import \ + BackgroundTaskWorkflowsActiveLearningMiddleware from inference.models.utils import ROBOFLOW_MODEL_TYPES model_registry = RoboflowModelRegistry(ROBOFLOW_MODEL_TYPES) diff --git a/inference/core/interfaces/http/http_api.py b/inference/core/interfaces/http/http_api.py index ff6ffbc08..647edbc2c 100644 --- a/inference/core/interfaces/http/http_api.py +++ b/inference/core/interfaces/http/http_api.py @@ -12,6 +12,7 @@ from fastapi_cprofile.profiler import CProfileMiddleware from inference.core import logger +from inference.core.cache import cache from inference.core.devices.utils import GLOBAL_INFERENCE_SERVER_ID from inference.core.entities.requests.clip import ( ClipCompareRequest, @@ -126,6 +127,9 @@ from inference.core.utils.notebooks import start_notebook from inference.enterprise.workflows.complier.core import compile_and_execute_async from inference.enterprise.workflows.complier.entities import StepExecutionMode +from inference.enterprise.workflows.complier.steps_executors.active_learning_middlewares import ( + WorkflowsActiveLearningMiddleware, +) from inference.enterprise.workflows.errors import ( ExecutionEngineError, RuntimePayloadError, @@ -296,6 +300,9 @@ async def count_errors(request: Request, call_next): self.app = app self.model_manager = model_manager + self.workflows_active_learning_middleware = WorkflowsActiveLearningMiddleware( + cache=cache, + ) async def process_inference_request( inference_request: InferenceRequest, **kwargs @@ -320,6 +327,7 @@ async def process_inference_request( async def process_workflow_inference_request( workflow_request: WorkflowInferenceRequest, workflow_specification: dict, + background_tasks: Optional[BackgroundTasks], ) -> WorkflowInferenceResponse: step_execution_mode = StepExecutionMode(WORKFLOWS_STEP_EXECUTION_MODE) result = await compile_and_execute_async( @@ -329,6 +337,8 @@ async def process_workflow_inference_request( api_key=workflow_request.api_key, max_concurrent_steps=WORKFLOWS_MAX_CONCURRENT_STEPS, step_execution_mode=step_execution_mode, + active_learning_middleware=self.workflows_active_learning_middleware, + background_tasks=background_tasks, ) outputs = serialise_workflow_result( result=result, @@ -656,6 +666,7 @@ async def infer_from_predefined_workflow( workspace_name: str, workflow_name: str, workflow_request: WorkflowInferenceRequest, + background_tasks: BackgroundTasks, ) -> WorkflowInferenceResponse: workflow_specification = get_workflow_specification( api_key=workflow_request.api_key, @@ -665,6 +676,7 @@ async def infer_from_predefined_workflow( return await process_workflow_inference_request( workflow_request=workflow_request, workflow_specification=workflow_specification, + background_tasks=background_tasks if not LAMBDA else None, ) @app.post( @@ -676,6 +688,7 @@ async def infer_from_predefined_workflow( @with_route_exceptions async def infer_from_workflow( workflow_request: WorkflowSpecificationInferenceRequest, + background_tasks: BackgroundTasks, ) -> WorkflowInferenceResponse: workflow_specification = { "specification": workflow_request.specification @@ -683,6 +696,7 @@ async def infer_from_workflow( return await process_workflow_inference_request( workflow_request=workflow_request, workflow_specification=workflow_specification, + background_tasks=background_tasks if not LAMBDA else None, ) if CORE_MODELS_ENABLED: diff --git a/inference/enterprise/workflows/complier/core.py b/inference/enterprise/workflows/complier/core.py index 1e5b656c9..913280fc9 100644 --- a/inference/enterprise/workflows/complier/core.py +++ b/inference/enterprise/workflows/complier/core.py @@ -2,6 +2,9 @@ from asyncio import AbstractEventLoop from typing import Any, Dict, Optional +from fastapi import BackgroundTasks + +from inference.core.cache import cache from inference.core.env import API_KEY, MAX_ACTIVE_MODELS from inference.core.managers.base import ModelManager from inference.core.managers.decorators.fixed_size_cache import WithFixedSizeCache @@ -9,6 +12,9 @@ from inference.enterprise.workflows.complier.entities import StepExecutionMode from inference.enterprise.workflows.complier.execution_engine import execute_graph from inference.enterprise.workflows.complier.graph_parser import prepare_execution_graph +from inference.enterprise.workflows.complier.steps_executors.active_learning_middlewares import ( + WorkflowsActiveLearningMiddleware, +) from inference.enterprise.workflows.complier.validator import ( validate_workflow_specification, ) @@ -25,6 +31,8 @@ def compile_and_execute( api_key: Optional[str] = None, model_manager: Optional[ModelManager] = None, loop: Optional[AbstractEventLoop] = None, + active_learning_middleware: Optional[WorkflowsActiveLearningMiddleware] = None, + background_tasks: Optional[BackgroundTasks] = None, max_concurrent_steps: int = 1, step_execution_mode: StepExecutionMode = StepExecutionMode.LOCAL, ) -> dict: @@ -36,6 +44,8 @@ def compile_and_execute( runtime_parameters=runtime_parameters, model_manager=model_manager, api_key=api_key, + active_learning_middleware=active_learning_middleware, + background_tasks=background_tasks, max_concurrent_steps=max_concurrent_steps, step_execution_mode=step_execution_mode, ) @@ -47,6 +57,8 @@ async def compile_and_execute_async( runtime_parameters: Dict[str, Any], model_manager: Optional[ModelManager] = None, api_key: Optional[str] = None, + active_learning_middleware: Optional[WorkflowsActiveLearningMiddleware] = None, + background_tasks: Optional[BackgroundTasks] = None, max_concurrent_steps: int = 1, step_execution_mode: StepExecutionMode = StepExecutionMode.LOCAL, ) -> dict: @@ -56,6 +68,8 @@ async def compile_and_execute_async( model_registry = RoboflowModelRegistry(ROBOFLOW_MODEL_TYPES) model_manager = ModelManager(model_registry=model_registry) model_manager = WithFixedSizeCache(model_manager, max_size=MAX_ACTIVE_MODELS) + if active_learning_middleware is None: + active_learning_middleware = WorkflowsActiveLearningMiddleware(cache=cache) parsed_workflow_specification = WorkflowSpecification.parse_obj( workflow_specification ) @@ -73,6 +87,8 @@ async def compile_and_execute_async( execution_graph=execution_graph, runtime_parameters=runtime_parameters, model_manager=model_manager, + active_learning_middleware=active_learning_middleware, + background_tasks=background_tasks, api_key=api_key, max_concurrent_steps=max_concurrent_steps, step_execution_mode=step_execution_mode, diff --git a/inference/enterprise/workflows/complier/execution_engine.py b/inference/enterprise/workflows/complier/execution_engine.py index 7f95b0786..bb0003615 100644 --- a/inference/enterprise/workflows/complier/execution_engine.py +++ b/inference/enterprise/workflows/complier/execution_engine.py @@ -3,6 +3,7 @@ from typing import Any, Dict, List, Optional, Set import networkx as nx +from fastapi import BackgroundTasks from networkx import DiGraph from inference.core import logger @@ -15,7 +16,11 @@ from inference.enterprise.workflows.complier.runtime_input_validator import ( prepare_runtime_parameters, ) +from inference.enterprise.workflows.complier.steps_executors.active_learning_middlewares import ( + WorkflowsActiveLearningMiddleware, +) from inference.enterprise.workflows.complier.steps_executors.auxiliary import ( + run_active_learning_data_collector, run_condition_step, run_crop_step, run_detection_filter, @@ -61,6 +66,7 @@ "RelativeStaticCrop": run_static_crop_step, "ClipComparison": run_clip_comparison_step, "DetectionsConsensus": run_detections_consensus_step, + "ActiveLearningDataCollector": run_active_learning_data_collector, } @@ -68,6 +74,8 @@ async def execute_graph( execution_graph: DiGraph, runtime_parameters: Dict[str, Any], model_manager: ModelManager, + active_learning_middleware: WorkflowsActiveLearningMiddleware, + background_tasks: Optional[BackgroundTasks] = None, api_key: Optional[str] = None, max_concurrent_steps: int = 1, step_execution_mode: StepExecutionMode = StepExecutionMode.LOCAL, @@ -101,6 +109,8 @@ async def execute_graph( model_manager=model_manager, api_key=api_key, step_execution_mode=step_execution_mode, + active_learning_middleware=active_learning_middleware, + background_tasks=background_tasks, ) return construct_response( execution_graph=execution_graph, outputs_lookup=outputs_lookup @@ -116,6 +126,8 @@ async def execute_steps( model_manager: ModelManager, api_key: Optional[str], step_execution_mode: StepExecutionMode, + active_learning_middleware: WorkflowsActiveLearningMiddleware, + background_tasks: Optional[BackgroundTasks], ) -> Set[str]: """outputs_lookup is mutated while execution, only independent steps may be run together""" logger.info(f"Executing steps: {steps}. Execution mode: {step_execution_mode}") @@ -132,6 +144,8 @@ async def execute_steps( model_manager=model_manager, api_key=api_key, step_execution_mode=step_execution_mode, + active_learning_middleware=active_learning_middleware, + background_tasks=background_tasks, ) for step in steps_batch ] @@ -149,6 +163,8 @@ async def safe_execute_step( model_manager: ModelManager, api_key: Optional[str], step_execution_mode: StepExecutionMode, + active_learning_middleware: WorkflowsActiveLearningMiddleware, + background_tasks: Optional[BackgroundTasks], ) -> Set[str]: try: return await execute_step( @@ -159,6 +175,8 @@ async def safe_execute_step( model_manager=model_manager, api_key=api_key, step_execution_mode=step_execution_mode, + active_learning_middleware=active_learning_middleware, + background_tasks=background_tasks, ) except Exception as error: raise ExecutionEngineError( @@ -176,11 +194,17 @@ async def execute_step( model_manager: ModelManager, api_key: Optional[str], step_execution_mode: StepExecutionMode, + active_learning_middleware: WorkflowsActiveLearningMiddleware, + background_tasks: Optional[BackgroundTasks], ) -> Set[str]: logger.info(f"started execution of: {step} - {datetime.now().isoformat()}") nodes_to_discard = set() step_definition = execution_graph.nodes[step]["definition"] executor = STEP_TYPE2EXECUTOR_MAPPING[step_definition.type] + additional_args = {} + if step_definition.type == "ActiveLearningDataCollector": + additional_args["active_learning_middleware"] = active_learning_middleware + additional_args["background_tasks"] = background_tasks next_step, outputs_lookup = await executor( step=step_definition, runtime_parameters=runtime_parameters, @@ -188,6 +212,7 @@ async def execute_step( model_manager=model_manager, api_key=api_key, step_execution_mode=step_execution_mode, + **additional_args, ) if is_condition_step(execution_graph=execution_graph, node=step): if execution_graph.nodes[step]["definition"].step_if_true == next_step: diff --git a/inference/enterprise/workflows/complier/graph_parser.py b/inference/enterprise/workflows/complier/graph_parser.py index 4650a7f55..2dc2f9558 100644 --- a/inference/enterprise/workflows/complier/graph_parser.py +++ b/inference/enterprise/workflows/complier/graph_parser.py @@ -39,7 +39,6 @@ def prepare_execution_graph(workflow_specification: WorkflowSpecificationV1) -> execution_graph = construct_graph(workflow_specification=workflow_specification) if not nx.is_directed_acyclic_graph(execution_graph): raise NotAcyclicGraphError(f"Detected cycle in execution graph.") - verify_each_node_reach_at_least_one_output(execution_graph=execution_graph) verify_each_node_step_has_parent_in_the_same_branch(execution_graph=execution_graph) verify_that_steps_are_connected_with_compatible_inputs( execution_graph=execution_graph @@ -189,27 +188,6 @@ def verify_edge_is_created_between_existing_nodes( ) -def verify_each_node_reach_at_least_one_output( - execution_graph: DiGraph, -) -> None: - all_nodes = set(execution_graph.nodes()) - output_nodes = get_nodes_of_specific_kind( - execution_graph=execution_graph, kind=OUTPUT_NODE_KIND - ) - nodes_reaching_output = ( - get_nodes_that_are_reachable_from_pointed_ones_in_reversed_graph( - execution_graph=execution_graph, - pointed_nodes=output_nodes, - ) - ) - nodes_not_reaching_output = all_nodes.difference(nodes_reaching_output) - if len(nodes_not_reaching_output) > 0: - raise NodesNotReachingOutputError( - f"Detected {len(nodes_not_reaching_output)} nodes not reaching any of output node:" - f"{nodes_not_reaching_output}." - ) - - def get_nodes_that_are_reachable_from_pointed_ones_in_reversed_graph( execution_graph: DiGraph, pointed_nodes: Set[str], diff --git a/inference/enterprise/workflows/complier/steps_executors/active_learning_middlewares.py b/inference/enterprise/workflows/complier/steps_executors/active_learning_middlewares.py new file mode 100644 index 000000000..98aa10ab0 --- /dev/null +++ b/inference/enterprise/workflows/complier/steps_executors/active_learning_middlewares.py @@ -0,0 +1,86 @@ +from typing import Dict, List, Optional + +from fastapi import BackgroundTasks + +from inference.core import logger +from inference.core.active_learning.middlewares import ActiveLearningMiddleware +from inference.core.cache.base import BaseCache +from inference.core.env import DISABLE_PREPROC_AUTO_ORIENT + + +class WorkflowsActiveLearningMiddleware: + + def __init__( + self, + cache: BaseCache, + middlewares: Optional[Dict[str, ActiveLearningMiddleware]] = None, + ): + self._cache = cache + self._middlewares = middlewares if middlewares is not None else {} + + def register( + self, + dataset_name: str, + images: List[dict], + predictions: List[dict], + api_key: Optional[str], + prediction_type: str, + active_learning_disabled_for_request: bool, + background_tasks: Optional[BackgroundTasks] = None, + ) -> None: + model_id = f"{dataset_name}/workflows" + if api_key is None or active_learning_disabled_for_request: + return None + if background_tasks is None: + self._register( + model_id=model_id, + images=images, + predictions=predictions, + api_key=api_key, + prediction_type=prediction_type, + ) + return None + background_tasks.add_task( + self._register, + model_id=model_id, + images=images, + predictions=predictions, + api_key=api_key, + prediction_type=prediction_type, + ) + + def _register( + self, + model_id: str, + images: List[dict], + predictions: List[dict], + api_key: str, + prediction_type: str, + ) -> None: + try: + self._ensure_middleware_initialised(model_id=model_id, api_key=api_key) + self._middlewares[model_id].register_batch( + inference_inputs=images, + predictions=predictions, + prediction_type=prediction_type, + disable_preproc_auto_orient=DISABLE_PREPROC_AUTO_ORIENT, + ) + except Exception as error: + # Error handling to be decided + logger.warning( + f"Error in datapoint registration for Active Learning. Details: {error}. " + f"Error is suppressed in favour of normal operations of API." + ) + + def _ensure_middleware_initialised( + self, + model_id: str, + api_key: str, + ) -> None: + if model_id in self._middlewares: + return None + self._middlewares[model_id] = ActiveLearningMiddleware.init( + api_key=api_key, + model_id=model_id, + cache=self._cache, + ) diff --git a/inference/enterprise/workflows/complier/steps_executors/auxiliary.py b/inference/enterprise/workflows/complier/steps_executors/auxiliary.py index de64c7845..a446df3fe 100644 --- a/inference/enterprise/workflows/complier/steps_executors/auxiliary.py +++ b/inference/enterprise/workflows/complier/steps_executors/auxiliary.py @@ -7,10 +7,14 @@ from uuid import uuid4 import numpy as np +from fastapi import BackgroundTasks from inference.core.managers.base import ModelManager from inference.core.utils.image_utils import ImageType, load_image from inference.enterprise.workflows.complier.entities import StepExecutionMode +from inference.enterprise.workflows.complier.steps_executors.active_learning_middlewares import ( + WorkflowsActiveLearningMiddleware, +) from inference.enterprise.workflows.complier.steps_executors.constants import ( CENTER_X_KEY, CENTER_Y_KEY, @@ -37,6 +41,7 @@ ) from inference.enterprise.workflows.entities.steps import ( AbsoluteStaticCrop, + ActiveLearningDataCollector, AggregationMode, BinaryOperator, CompoundDetectionFilterDefinition, @@ -49,6 +54,7 @@ Operator, RelativeStaticCrop, ) +from inference.enterprise.workflows.entities.validators import get_last_selector_chunk from inference.enterprise.workflows.errors import ExecutionGraphError OPERATORS = { @@ -79,7 +85,7 @@ async def run_crop_step( outputs_lookup: OutputsLookup, model_manager: ModelManager, api_key: Optional[str], - step_execution_mode: StepExecutionMode = StepExecutionMode.LOCAL, + step_execution_mode: StepExecutionMode, ) -> Tuple[NextStepReference, OutputsLookup]: image = get_image( step=step, @@ -143,7 +149,7 @@ async def run_condition_step( outputs_lookup: OutputsLookup, model_manager: ModelManager, api_key: Optional[str], - step_execution_mode: StepExecutionMode = StepExecutionMode.LOCAL, + step_execution_mode: StepExecutionMode, ) -> Tuple[NextStepReference, OutputsLookup]: left_value = resolve_parameter( selector_or_value=step.left, @@ -166,7 +172,7 @@ async def run_detection_filter( outputs_lookup: OutputsLookup, model_manager: ModelManager, api_key: Optional[str], - step_execution_mode: StepExecutionMode = StepExecutionMode.LOCAL, + step_execution_mode: StepExecutionMode, ) -> Tuple[NextStepReference, OutputsLookup]: predictions = resolve_parameter( selector_or_value=step.predictions, @@ -218,7 +224,7 @@ async def run_detection_offset_step( outputs_lookup: OutputsLookup, model_manager: ModelManager, api_key: Optional[str], - step_execution_mode: StepExecutionMode = StepExecutionMode.LOCAL, + step_execution_mode: StepExecutionMode, ) -> Tuple[NextStepReference, OutputsLookup]: detections = resolve_parameter( selector_or_value=step.predictions, @@ -277,7 +283,7 @@ async def run_static_crop_step( outputs_lookup: OutputsLookup, model_manager: ModelManager, api_key: Optional[str], - step_execution_mode: StepExecutionMode = StepExecutionMode.LOCAL, + step_execution_mode: StepExecutionMode, ) -> Tuple[NextStepReference, OutputsLookup]: image = get_image( step=step, @@ -372,7 +378,7 @@ async def run_detections_consensus_step( outputs_lookup: OutputsLookup, model_manager: ModelManager, api_key: Optional[str], - step_execution_mode: StepExecutionMode = StepExecutionMode.LOCAL, + step_execution_mode: StepExecutionMode, ) -> Tuple[NextStepReference, OutputsLookup]: resolve_parameter_closure = partial( resolve_parameter, @@ -821,3 +827,57 @@ def aggregate_field_values( ) -> float: values = [d[field] for d in detections] return AGGREGATION_MODE2FIELD_AGGREGATOR[aggregation_mode](values) + + +async def run_active_learning_data_collector( + step: ActiveLearningDataCollector, + runtime_parameters: Dict[str, Any], + outputs_lookup: OutputsLookup, + model_manager: ModelManager, + api_key: Optional[str], + step_execution_mode: StepExecutionMode, + active_learning_middleware: WorkflowsActiveLearningMiddleware, + background_tasks: Optional[BackgroundTasks], +) -> Tuple[NextStepReference, OutputsLookup]: + resolve_parameter_closure = partial( + resolve_parameter, + runtime_parameters=runtime_parameters, + outputs_lookup=outputs_lookup, + ) + image = get_image( + step=step, + runtime_parameters=runtime_parameters, + outputs_lookup=outputs_lookup, + ) + images_meta_selector = construct_selector_pointing_step_output( + selector=step.predictions, + new_output="image", + ) + images_meta = resolve_parameter_closure(images_meta_selector) + predictions = resolve_parameter_closure(step.predictions) + predictions_output_name = get_last_selector_chunk(step.predictions) + target_dataset = resolve_parameter_closure(step.target_dataset) + target_dataset_api_key = resolve_parameter_closure(step.target_dataset_api_key) + disable_active_learning = resolve_parameter_closure(step.disable_active_learning) + active_learning_compatible_predictions = [ + {"image": image_meta, predictions_output_name: prediction} + for image_meta, prediction in zip(images_meta, predictions) + ] + active_learning_middleware.register( + # this should actually be asyncio, but that requires a lot of backend components redesign + dataset_name=target_dataset, + images=image, + predictions=active_learning_compatible_predictions, + api_key=target_dataset_api_key or api_key, + active_learning_disabled_for_request=disable_active_learning, + prediction_type=( + "classification" if predictions_output_name == "top" else "object-detection" + ), + # This is quick and dirty assumption - that shall work as samplers are suited to distinguish + # between cls and non-cls predictions and at this stage, we do also only recognise those 2 + # states - to further divide between tasks, each prediction step should provide output metadata + # that can be referred using `step.predictions` with output name replaced to `task_type` or sth + # similar + background_tasks=background_tasks, + ) + return None, outputs_lookup diff --git a/inference/enterprise/workflows/complier/steps_executors/utils.py b/inference/enterprise/workflows/complier/steps_executors/utils.py index 6b336b063..b79839a32 100644 --- a/inference/enterprise/workflows/complier/steps_executors/utils.py +++ b/inference/enterprise/workflows/complier/steps_executors/utils.py @@ -10,6 +10,7 @@ ) from inference.enterprise.workflows.entities.steps import ( AbsoluteStaticCrop, + ActiveLearningDataCollector, ClipComparison, Crop, OCRModel, @@ -33,6 +34,7 @@ def get_image( AbsoluteStaticCrop, RelativeStaticCrop, ClipComparison, + ActiveLearningDataCollector, ], runtime_parameters: Dict[str, Any], outputs_lookup: OutputsLookup, diff --git a/inference/enterprise/workflows/entities/steps.py b/inference/enterprise/workflows/entities/steps.py index f4c93575e..01ee8840c 100644 --- a/inference/enterprise/workflows/entities/steps.py +++ b/inference/enterprise/workflows/entities/steps.py @@ -6,6 +6,7 @@ from inference.enterprise.workflows.entities.base import GraphNone from inference.enterprise.workflows.entities.validators import ( + get_last_selector_chunk, is_selector, validate_field_has_given_type, validate_field_is_empty_or_selector_or_list_of_string, @@ -1121,3 +1122,149 @@ def _validate_required_objects_binding(self, value: Any) -> None: field_name=f"required_objects[{k}]", error=VariableTypeError, ) + + +ACTIVE_LEARNING_DATA_COLLECTOR_ELIGIBLE_SELECTORS = { + "ObjectDetectionModel": "predictions", + "KeypointsDetectionModel": "predictions", + "InstanceSegmentationModel": "predictions", + "DetectionFilter": "predictions", + "DetectionsConsensus": "predictions", + "DetectionOffset": "predictions", + "ClassificationModel": "top", +} + + +class ActiveLearningDataCollector(BaseModel, StepInterface): + type: Literal["ActiveLearningDataCollector"] + name: str + image: str + predictions: str + target_dataset: str + target_dataset_api_key: Optional[str] = Field(default=None) + disable_active_learning: Union[bool, str] = Field(default=False) + + @classmethod + @field_validator("image") + def image_must_only_hold_selectors(cls, value: Any) -> Union[str, List[str]]: + validate_image_is_valid_selector(value=value) + return value + + @classmethod + @field_validator("predictions") + def predictions_must_hold_selector(cls, value: Any) -> str: + if not is_selector(selector_or_value=value): + raise ValueError("`predictions` field can only contain selector values") + return value + + @classmethod + @field_validator("target_dataset") + def validate_target_dataset_field(cls, value: Any) -> Union[str, bool]: + validate_field_is_selector_or_has_given_type( + value=value, field_name="target_dataset", allowed_types=[bool] + ) + return value + + @classmethod + @field_validator("target_dataset") + def validate_target_dataset_api_key_field(cls, value: Any) -> Union[str, bool]: + validate_field_is_selector_or_has_given_type( + value=value, + field_name="target_dataset_api_key", + allowed_types=[bool, type(None)], + ) + return value + + @classmethod + @field_validator("disable_active_learning") + def validate_boolean_flags_or_selectors(cls, value: Any) -> Union[str, bool]: + validate_field_is_selector_or_has_given_type( + value=value, field_name="class_aware", allowed_types=[bool] + ) + return value + + def get_type(self) -> str: + return self.type + + def get_input_names(self) -> Set[str]: + return { + "image", + "predictions", + "target_dataset", + "target_dataset_api_key", + "disable_active_learning", + } + + def get_output_names(self) -> Set[str]: + return set() + + def validate_field_selector( + self, field_name: str, input_step: GraphNone, index: Optional[int] = None + ) -> None: + selector = getattr(self, field_name) + if not is_selector(selector_or_value=selector): + raise ExecutionGraphError( + f"Attempted to validate selector value for field {field_name}, but field is not selector." + ) + if field_name == "predictions": + input_step_type = input_step.get_type() + expected_last_selector_chunk = ( + ACTIVE_LEARNING_DATA_COLLECTOR_ELIGIBLE_SELECTORS.get(input_step_type) + ) + if expected_last_selector_chunk is None: + raise ExecutionGraphError( + f"Attempted to validate predictions selector of {self.name} step, but input step of type: " + f"{input_step_type} does match by type." + ) + if get_last_selector_chunk(selector) != expected_last_selector_chunk: + raise ExecutionGraphError( + f"It is only allowed to refer to {input_step_type} step output named {expected_last_selector_chunk}. " + f"Reference that was found: {selector}" + ) + input_step_image = getattr(input_step, "image", self.image) + if input_step_image != self.image: + raise ExecutionGraphError( + f"ActiveLearningDataCollector step refers to input step that uses reference to different image. " + f"ActiveLearningDataCollector step image: {self.image}. Input step (of type {input_step_image}) " + f"uses {input_step_image}." + ) + validate_selector_holds_image( + step_type=self.type, + field_name=field_name, + input_step=input_step, + ) + validate_selector_is_inference_parameter( + step_type=self.type, + field_name=field_name, + input_step=input_step, + applicable_fields={ + "target_dataset", + "target_dataset_api_key", + "disable_active_learning", + }, + ) + + def validate_field_binding(self, field_name: str, value: Any) -> None: + if field_name == "image": + validate_image_biding(value=value) + elif field_name in {"disable_active_learning"}: + validate_field_has_given_type( + field_name=field_name, + allowed_types=[bool], + value=value, + error=VariableTypeError, + ) + elif field_name in {"target_dataset"}: + validate_field_has_given_type( + field_name=field_name, + allowed_types=[str], + value=value, + error=VariableTypeError, + ) + elif field_name in {"target_dataset_api_key"}: + validate_field_has_given_type( + field_name=field_name, + allowed_types=[str, type(None)], + value=value, + error=VariableTypeError, + ) diff --git a/inference/enterprise/workflows/entities/workflows_specification.py b/inference/enterprise/workflows/entities/workflows_specification.py index 4cfad3ab4..6adc51145 100644 --- a/inference/enterprise/workflows/entities/workflows_specification.py +++ b/inference/enterprise/workflows/entities/workflows_specification.py @@ -9,6 +9,7 @@ from inference.enterprise.workflows.entities.outputs import JsonField from inference.enterprise.workflows.entities.steps import ( AbsoluteStaticCrop, + ActiveLearningDataCollector, ClassificationModel, ClipComparison, Condition, @@ -43,6 +44,7 @@ RelativeStaticCrop, AbsoluteStaticCrop, DetectionsConsensus, + ActiveLearningDataCollector, ], Field(discriminator="type"), ] diff --git a/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py b/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py index cd78eac1e..d5538b6e8 100644 --- a/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py +++ b/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py @@ -4,6 +4,7 @@ import numpy as np import pytest +from inference.enterprise.workflows.complier.entities import StepExecutionMode from inference.enterprise.workflows.complier.steps_executors import auxiliary from inference.enterprise.workflows.complier.steps_executors.auxiliary import ( aggregate_field_values, @@ -125,6 +126,7 @@ async def test_run_condition_step() -> None: outputs_lookup={"$steps.step_0": {"top": "cat"}}, model_manager=MagicMock(), api_key=None, + step_execution_mode=StepExecutionMode.LOCAL, ) # then @@ -219,6 +221,7 @@ async def test_run_detection_filter_step_when_batch_detections_given() -> None: }, model_manager=MagicMock(), api_key=None, + step_execution_mode=StepExecutionMode.LOCAL, ) # then diff --git a/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py b/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py index 83f68e17e..1f5e33a17 100644 --- a/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py +++ b/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py @@ -8,7 +8,6 @@ construct_graph, get_nodes_that_are_reachable_from_pointed_ones_in_reversed_graph, prepare_execution_graph, - verify_each_node_reach_at_least_one_output, ) from inference.enterprise.workflows.constants import ( INPUT_NODE_KIND, @@ -320,43 +319,6 @@ def test_construct_graph_when_detections_consensus_block_is_used() -> None: assert len(result.edges) == 5, "10 edges in total should be created" -def test_verify_each_node_reach_at_least_one_output_when_graph_is_valid() -> None: - # given - execution_graph = nx.DiGraph() - execution_graph.add_node("a", kind=INPUT_NODE_KIND) - execution_graph.add_node("b", kind=INPUT_NODE_KIND) - execution_graph.add_node("c", kind=STEP_NODE_KIND) - execution_graph.add_node("d", kind=STEP_NODE_KIND) - execution_graph.add_node("e", kind=OUTPUT_NODE_KIND) - execution_graph.add_node("f", kind=OUTPUT_NODE_KIND) - execution_graph.add_edge("a", "c") - execution_graph.add_edge("b", "d") - execution_graph.add_edge("c", "e") - execution_graph.add_edge("d", "f") - - # when - verify_each_node_reach_at_least_one_output(execution_graph=execution_graph) - - # then - no error raised - - -def test_verify_each_node_reach_at_least_one_output_when_graph_is_invalid() -> None: - # given - execution_graph = nx.DiGraph() - execution_graph.add_node("a", kind=INPUT_NODE_KIND) - execution_graph.add_node("b", kind=INPUT_NODE_KIND) - execution_graph.add_node("c", kind=STEP_NODE_KIND) - execution_graph.add_node("d", kind=STEP_NODE_KIND) - execution_graph.add_node("e", kind=OUTPUT_NODE_KIND) - execution_graph.add_edge("a", "c") - execution_graph.add_edge("b", "d") - execution_graph.add_edge("c", "e") - - # when - with pytest.raises(NodesNotReachingOutputError): - verify_each_node_reach_at_least_one_output(execution_graph=execution_graph) - - def test_get_nodes_that_are_reachable_from_pointed_ones_in_reversed_graph() -> None: # given execution_graph = nx.DiGraph() @@ -496,8 +458,15 @@ def test_prepare_execution_graph_when_graph_node_does_not_reach_output() -> None ) # when - with pytest.raises(NodesNotReachingOutputError): - _ = prepare_execution_graph(workflow_specification=workflow_specification) + execution_graph = prepare_execution_graph(workflow_specification=workflow_specification) + + # then + assert len(execution_graph.edges) == 4, "4 edges are expected to be created" + assert execution_graph.has_edge("$inputs.image", "$steps.step_1"), "Input must be connected to step_1" + assert execution_graph.has_edge("$inputs.image", "$steps.step_2"), "Input must be connected to step_2" + assert execution_graph.has_edge("$steps.step_1", "$steps.step_2"), "step_1 must be connected to step_2" + assert execution_graph.has_edge("$steps.step_1", "$outputs.predictions"), "step_1 output must be connected to output" + def test_prepare_execution_graph_when_graph_when_there_is_a_collapse_of_condition_branch() -> ( From 89a39a796442ab4a1d08575680be2281efe5f36f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Tue, 13 Feb 2024 19:43:05 +0100 Subject: [PATCH 04/18] Add extension to output prediction type from model steps and steps that transform predictions --- .../complier/steps_executors/auxiliary.py | 56 +++++++++++++++---- .../complier/steps_executors/models.py | 31 +++++++++- .../enterprise/workflows/entities/steps.py | 11 ++-- .../steps_executors/test_auxiliary.py | 3 + .../workflows/compiler/test_utils.py | 1 + 5 files changed, 84 insertions(+), 18 deletions(-) diff --git a/inference/enterprise/workflows/complier/steps_executors/auxiliary.py b/inference/enterprise/workflows/complier/steps_executors/auxiliary.py index a446df3fe..1d6ad1019 100644 --- a/inference/enterprise/workflows/complier/steps_executors/auxiliary.py +++ b/inference/enterprise/workflows/complier/steps_executors/auxiliary.py @@ -188,6 +188,15 @@ async def run_detection_filter( runtime_parameters=runtime_parameters, outputs_lookup=outputs_lookup, ) + prediction_type_selector = construct_selector_pointing_step_output( + selector=step.predictions, + new_output="prediction_type", + ) + predictions_type = resolve_parameter( + selector_or_value=prediction_type_selector, + runtime_parameters=runtime_parameters, + outputs_lookup=outputs_lookup, + ) filter_callable = build_filter_callable(definition=step.filter_definition) result_detections, result_parent_id = [], [] for prediction in predictions: @@ -196,8 +205,10 @@ async def run_detection_filter( result_parent_id.append([p[PARENT_ID_KEY] for p in filtered_predictions]) step_selector = construct_step_selector(step_name=step.name) outputs_lookup[step_selector] = [ - {"predictions": d, PARENT_ID_KEY: p, "image": i} - for d, p, i in zip(result_detections, result_parent_id, images_meta) + {"predictions": d, PARENT_ID_KEY: p, "image": i, "prediction_type": pt} + for d, p, i, pt in zip( + result_detections, result_parent_id, images_meta, predictions_type + ) ] return None, outputs_lookup @@ -240,6 +251,15 @@ async def run_detection_offset_step( runtime_parameters=runtime_parameters, outputs_lookup=outputs_lookup, ) + prediction_type_selector = construct_selector_pointing_step_output( + selector=step.predictions, + new_output="prediction_type", + ) + predictions_type = resolve_parameter( + selector_or_value=prediction_type_selector, + runtime_parameters=runtime_parameters, + outputs_lookup=outputs_lookup, + ) offset_x = resolve_parameter( selector_or_value=step.offset_x, runtime_parameters=runtime_parameters, @@ -260,8 +280,10 @@ async def run_detection_offset_step( result_parent_id.append([d[PARENT_ID_KEY] for d in offset_detections]) step_selector = construct_step_selector(step_name=step.name) outputs_lookup[step_selector] = [ - {"predictions": d, PARENT_ID_KEY: p, "image": i} - for d, p, i in zip(result_detections, result_parent_id, images_meta) + {"predictions": d, PARENT_ID_KEY: p, "image": i, "prediction_type": pt} + for d, p, i, pt in zip( + result_detections, result_parent_id, images_meta, predictions_type + ) ] return None, outputs_lookup @@ -428,6 +450,7 @@ async def run_detections_consensus_step( "object_present": object_present, "presence_confidence": presence_confidence, "image": images_meta[batch_index], + "prediction_type": "object-detection", } ) outputs_lookup[construct_step_selector(step_name=step.name)] = results @@ -854,6 +877,22 @@ async def run_active_learning_data_collector( new_output="image", ) images_meta = resolve_parameter_closure(images_meta_selector) + prediction_type_selector = construct_selector_pointing_step_output( + selector=step.predictions, + new_output="prediction_type", + ) + predictions_type = resolve_parameter( + selector_or_value=prediction_type_selector, + runtime_parameters=runtime_parameters, + outputs_lookup=outputs_lookup, + ) + prediction_type = set(predictions_type) + if len(prediction_type) > 1: + raise ExecutionGraphError( + f"Active Learning data collection step requires only single prediction " + f"type to be part of ingest. Detected: {prediction_type}." + ) + prediction_type = next(iter(prediction_type)) predictions = resolve_parameter_closure(step.predictions) predictions_output_name = get_last_selector_chunk(step.predictions) target_dataset = resolve_parameter_closure(step.target_dataset) @@ -870,14 +909,7 @@ async def run_active_learning_data_collector( predictions=active_learning_compatible_predictions, api_key=target_dataset_api_key or api_key, active_learning_disabled_for_request=disable_active_learning, - prediction_type=( - "classification" if predictions_output_name == "top" else "object-detection" - ), - # This is quick and dirty assumption - that shall work as samplers are suited to distinguish - # between cls and non-cls predictions and at this stage, we do also only recognise those 2 - # states - to further divide between tasks, each prediction step should provide output metadata - # that can be referred using `step.predictions` with output name replaced to `task_type` or sth - # similar + prediction_type=prediction_type, background_tasks=background_tasks, ) return None, outputs_lookup diff --git a/inference/enterprise/workflows/complier/steps_executors/models.py b/inference/enterprise/workflows/complier/steps_executors/models.py index 1d056d70b..9f795a686 100644 --- a/inference/enterprise/workflows/complier/steps_executors/models.py +++ b/inference/enterprise/workflows/complier/steps_executors/models.py @@ -27,7 +27,6 @@ from inference.enterprise.workflows.complier.steps_executors.constants import ( CENTER_X_KEY, CENTER_Y_KEY, - DETECTION_ID_KEY, ORIGIN_COORDINATES_KEY, ORIGIN_SIZE_KEY, PARENT_COORDINATES_SUFFIX, @@ -55,6 +54,14 @@ ) from inference_sdk import InferenceConfiguration, InferenceHTTPClient +MODEL_TYPE2PREDICTION_TYPE = { + "ClassificationModel": "classification", + "MultiLabelClassificationModel": "classification", + "ObjectDetectionModel": "object-detection", + "InstanceSegmentationModel": "instance-segmentation", + "KeypointsDetectionModel": "keypoint-detection", +} + async def run_roboflow_model_step( step: RoboflowModel, @@ -93,6 +100,10 @@ async def run_roboflow_model_step( outputs_lookup=outputs_lookup, api_key=api_key, ) + serialised_result = attach_prediction_type_info( + results=serialised_result, + prediction_type=MODEL_TYPE2PREDICTION_TYPE[step.get_type()], + ) if step.type in {"ClassificationModel", "MultiLabelClassificationModel"}: serialised_result = attach_parent_info( image=image, results=serialised_result, nested_key=None @@ -407,6 +418,10 @@ async def run_ocr_model_step( results=serialised_result, nested_key=None, ) + serialised_result = attach_prediction_type_info( + results=serialised_result, + prediction_type="ocr", + ) outputs_lookup[construct_step_selector(step_name=step.name)] = serialised_result return None, outputs_lookup @@ -496,6 +511,10 @@ async def run_clip_comparison_step( results=serialised_result, nested_key=None, ) + serialised_result = attach_prediction_type_info( + results=serialised_result, + prediction_type="embeddings-comparison", + ) outputs_lookup[construct_step_selector(step_name=step.name)] = serialised_result return None, outputs_lookup @@ -573,6 +592,16 @@ def load_core_model( return core_model_id +def attach_prediction_type_info( + results: List[Dict[str, Any]], + prediction_type: str, + key: str = "prediction_type", +) -> List[Dict[str, Any]]: + for result in results: + result[key] = prediction_type + return results + + def attach_parent_info( image: List[Dict[str, Any]], results: List[Dict[str, Any]], diff --git a/inference/enterprise/workflows/entities/steps.py b/inference/enterprise/workflows/entities/steps.py index 01ee8840c..438cfa254 100644 --- a/inference/enterprise/workflows/entities/steps.py +++ b/inference/enterprise/workflows/entities/steps.py @@ -105,7 +105,7 @@ def get_input_names(self) -> Set[str]: return {"image", "model_id", "disable_active_learning"} def get_output_names(self) -> Set[str]: - return set() + return {"prediction_type"} def validate_field_selector( self, field_name: str, input_step: GraphNone, index: Optional[int] = None @@ -489,7 +489,7 @@ def get_input_names(self) -> Set[str]: return {"image"} def get_output_names(self) -> Set[str]: - return {"result", "parent_id"} + return {"result", "parent_id", "prediction_type"} class Crop(BaseModel, StepInterface): @@ -624,7 +624,7 @@ def get_input_names(self) -> Set[str]: return {"predictions"} def get_output_names(self) -> Set[str]: - return {"predictions", "parent_id", "image"} + return {"predictions", "parent_id", "image", "prediction_type"} def validate_field_selector( self, field_name: str, input_step: GraphNone, index: Optional[int] = None @@ -660,7 +660,7 @@ def get_input_names(self) -> Set[str]: return {"predictions", "offset_x", "offset_y"} def get_output_names(self) -> Set[str]: - return {"predictions", "parent_id", "image"} + return {"predictions", "parent_id", "image", "predictions_type"} def validate_field_selector( self, field_name: str, input_step: GraphNone, index: Optional[int] = None @@ -890,7 +890,7 @@ def get_input_names(self) -> Set[str]: return {"image", "text"} def get_output_names(self) -> Set[str]: - return {"similarity", "parent_id"} + return {"similarity", "parent_id", "predictions_type"} class AggregationMode(Enum): @@ -1013,6 +1013,7 @@ def get_output_names(self) -> Set[str]: "image", "object_present", "presence_confidence", + "predictions_type", } def validate_field_selector( diff --git a/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py b/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py index d5538b6e8..1202157eb 100644 --- a/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py +++ b/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py @@ -217,6 +217,7 @@ async def test_run_detection_filter_step_when_batch_detections_given() -> None: "$steps.step_1": { "predictions": detections, "image": [{"height": 100, "width": 100}] * 2, + "prediction_type": ["object-detection"] * 2 } }, model_manager=MagicMock(), @@ -226,6 +227,8 @@ async def test_run_detection_filter_step_when_batch_detections_given() -> None: # then assert next_step is None, "Next step should not be set here" + assert outputs_lookup["$steps.step_2"][0]["prediction_type"] == "object-detection", "Prediction type must be preserved" + assert outputs_lookup["$steps.step_2"][1]["prediction_type"] == "object-detection", "Prediction type must be preserved" assert outputs_lookup["$steps.step_2"][0]["predictions"] == [ { "x": 10, diff --git a/tests/inference/unit_tests/enterprise/workflows/compiler/test_utils.py b/tests/inference/unit_tests/enterprise/workflows/compiler/test_utils.py index 8e30ce9f3..185b8f436 100644 --- a/tests/inference/unit_tests/enterprise/workflows/compiler/test_utils.py +++ b/tests/inference/unit_tests/enterprise/workflows/compiler/test_utils.py @@ -262,6 +262,7 @@ def test_get_steps_output_selectors() -> None: "$steps.my_model.image", "$steps.my_model.predictions", "$steps.my_model.parent_id", + "$steps.my_model.prediction_type", }, "Each step output must be prefixed with $steps. and name of step. Crop step defines `crops` and `parent_id` outputs, object detection defines `image`, `predictions` and `parent_id`" From 134eb87322942fb19400724f6bb173d8fdc652da Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 10:53:00 +0100 Subject: [PATCH 05/18] Bring back validation of dangling nodes --- .../workflows/complier/graph_parser.py | 39 ++++++ .../workflows/compiler/test_graph_parser.py | 116 +++++++++++++++++- 2 files changed, 150 insertions(+), 5 deletions(-) diff --git a/inference/enterprise/workflows/complier/graph_parser.py b/inference/enterprise/workflows/complier/graph_parser.py index 2dc2f9558..f3bfead98 100644 --- a/inference/enterprise/workflows/complier/graph_parser.py +++ b/inference/enterprise/workflows/complier/graph_parser.py @@ -39,6 +39,7 @@ def prepare_execution_graph(workflow_specification: WorkflowSpecificationV1) -> execution_graph = construct_graph(workflow_specification=workflow_specification) if not nx.is_directed_acyclic_graph(execution_graph): raise NotAcyclicGraphError(f"Detected cycle in execution graph.") + verify_each_node_reach_at_least_one_output(execution_graph=execution_graph) verify_each_node_step_has_parent_in_the_same_branch(execution_graph=execution_graph) verify_that_steps_are_connected_with_compatible_inputs( execution_graph=execution_graph @@ -188,6 +189,44 @@ def verify_edge_is_created_between_existing_nodes( ) +def verify_each_node_reach_at_least_one_output( + execution_graph: DiGraph, +) -> None: + all_nodes = set(execution_graph.nodes()) + output_nodes = get_nodes_of_specific_kind( + execution_graph=execution_graph, kind=OUTPUT_NODE_KIND + ) + nodes_without_outputs = get_nodes_that_do_not_produce_outputs( + execution_graph=execution_graph + ) + nodes_that_must_be_reached = output_nodes.union(nodes_without_outputs) + nodes_reaching_output = ( + get_nodes_that_are_reachable_from_pointed_ones_in_reversed_graph( + execution_graph=execution_graph, + pointed_nodes=nodes_that_must_be_reached, + ) + ) + nodes_not_reaching_output = all_nodes.difference(nodes_reaching_output) + if len(nodes_not_reaching_output) > 0: + raise NodesNotReachingOutputError( + f"Detected {len(nodes_not_reaching_output)} nodes not reaching any of output node:" + f"{nodes_not_reaching_output}." + ) + + +def get_nodes_that_do_not_produce_outputs(execution_graph: DiGraph) -> Set[str]: + # assumption is that nodes without outputs will produce some side effect and shall be + # treated as output nodes while checking if there is no dangling steps in graph + step_nodes = get_nodes_of_specific_kind( + execution_graph=execution_graph, kind=STEP_NODE_KIND + ) + return { + step_node + for step_node in step_nodes + if len(execution_graph.nodes[step_node]["definition"].get_output_names()) == 0 + } + + def get_nodes_that_are_reachable_from_pointed_ones_in_reversed_graph( execution_graph: DiGraph, pointed_nodes: Set[str], diff --git a/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py b/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py index 1f5e33a17..dd76b0bc9 100644 --- a/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py +++ b/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py @@ -7,7 +7,7 @@ add_steps_nodes_for_graph, construct_graph, get_nodes_that_are_reachable_from_pointed_ones_in_reversed_graph, - prepare_execution_graph, + prepare_execution_graph, verify_each_node_reach_at_least_one_output, ) from inference.enterprise.workflows.constants import ( INPUT_NODE_KIND, @@ -19,7 +19,7 @@ InferenceParameter, ) from inference.enterprise.workflows.entities.outputs import JsonField -from inference.enterprise.workflows.entities.steps import Crop, ObjectDetectionModel +from inference.enterprise.workflows.entities.steps import Crop, ObjectDetectionModel, ActiveLearningDataCollector from inference.enterprise.workflows.entities.workflows_specification import ( WorkflowSpecificationV1, ) @@ -319,6 +319,111 @@ def test_construct_graph_when_detections_consensus_block_is_used() -> None: assert len(result.edges) == 5, "10 edges in total should be created" +def test_verify_each_node_reach_at_least_one_output_when_all_steps_are_connected_to_inputs_and_outputs() -> None: + # given + example_step = Crop( + type="Crop", + name="my_crop", + image="$inputs.image", + detections="$steps.detect_2.predictions", + ) + execution_graph = nx.DiGraph() + execution_graph.add_node("a", kind=INPUT_NODE_KIND) + execution_graph.add_node("b", kind=INPUT_NODE_KIND) + execution_graph.add_node("c", kind=STEP_NODE_KIND, definition=example_step) + execution_graph.add_node("d", kind=STEP_NODE_KIND, definition=example_step) + execution_graph.add_node("e", kind=OUTPUT_NODE_KIND) + execution_graph.add_node("f", kind=OUTPUT_NODE_KIND) + execution_graph.add_edge("a", "c") + execution_graph.add_edge("b", "d") + execution_graph.add_edge("c", "e") + execution_graph.add_edge("d", "f") + + # when + verify_each_node_reach_at_least_one_output(execution_graph=execution_graph) + + # then - no error raised + + +def test_verify_each_node_reach_at_least_one_output_when_there_is_step_with_outputs_defined_not_connected_to_output_node() -> None: + # given + example_step = Crop( + type="Crop", + name="my_crop", + image="$inputs.image", + detections="$steps.detect_2.predictions", + ) + execution_graph = nx.DiGraph() + execution_graph.add_node("a", kind=INPUT_NODE_KIND) + execution_graph.add_node("b", kind=INPUT_NODE_KIND) + execution_graph.add_node("c", kind=STEP_NODE_KIND, definition=example_step) + execution_graph.add_node("d", kind=STEP_NODE_KIND, definition=example_step) + execution_graph.add_node("e", kind=OUTPUT_NODE_KIND) + execution_graph.add_edge("a", "c") + execution_graph.add_edge("b", "d") + execution_graph.add_edge("c", "e") + + # when + with pytest.raises(NodesNotReachingOutputError): + verify_each_node_reach_at_least_one_output(execution_graph=execution_graph) + + +def test_verify_each_node_reach_at_least_one_output_when_there_is_input_node_not_used() -> None: + # given + example_step = Crop( + type="Crop", + name="my_crop", + image="$inputs.image", + detections="$steps.detect_2.predictions", + ) + execution_graph = nx.DiGraph() + execution_graph.add_node("a", kind=INPUT_NODE_KIND) + execution_graph.add_node("b", kind=INPUT_NODE_KIND) + execution_graph.add_node("c", kind=STEP_NODE_KIND, definition=example_step) + execution_graph.add_node("d", kind=STEP_NODE_KIND, definition=example_step) + execution_graph.add_node("e", kind=OUTPUT_NODE_KIND) + execution_graph.add_edge("a", "c") + execution_graph.add_edge("a", "d") + execution_graph.add_edge("c", "e") + execution_graph.add_edge("d", "f") + + # when + with pytest.raises(NodesNotReachingOutputError): + verify_each_node_reach_at_least_one_output(execution_graph=execution_graph) + + +def test_verify_each_node_reach_at_least_one_output_when_there_is_a_step_executing_side_effect_not_connected_to_output() -> None: + # given + example_step = Crop( + type="Crop", + name="my_crop", + image="$inputs.image", + detections="$steps.detect_2.predictions", + ) + side_effect_step = ActiveLearningDataCollector( + type="ActiveLearningDataCollector", + name="al_block", + image="$inputs.image", + predictions="$steps.detect.predictions", + target_dataset="some", + ) + execution_graph = nx.DiGraph() + execution_graph.add_node("a", kind=INPUT_NODE_KIND) + execution_graph.add_node("b", kind=INPUT_NODE_KIND) # this one is not used + execution_graph.add_node("c", kind=STEP_NODE_KIND, definition=example_step) + execution_graph.add_node("d", kind=STEP_NODE_KIND, definition=side_effect_step) + execution_graph.add_node("e", kind=OUTPUT_NODE_KIND) + execution_graph.add_node("f", kind=OUTPUT_NODE_KIND) + execution_graph.add_edge("a", "c") + execution_graph.add_edge("b", "d") + execution_graph.add_edge("c", "e") + + # when + verify_each_node_reach_at_least_one_output(execution_graph=execution_graph) + + # then - no error raised + + def test_get_nodes_that_are_reachable_from_pointed_ones_in_reversed_graph() -> None: # given execution_graph = nx.DiGraph() @@ -425,7 +530,7 @@ def test_prepare_execution_graph_when_graph_is_not_acyclic() -> None: _ = prepare_execution_graph(workflow_specification=workflow_specification) -def test_prepare_execution_graph_when_graph_node_does_not_reach_output() -> None: +def test_prepare_execution_graph_when_graph_node_with_side_effect_step_does_not_reach_output() -> None: # given workflow_specification = WorkflowSpecificationV1.parse_obj( { @@ -441,10 +546,11 @@ def test_prepare_execution_graph_when_graph_node_does_not_reach_output() -> None "model_id": "vehicle-classification-eapcd/2", }, { - "type": "Crop", + "type": "ActiveLearningDataCollector", "name": "step_2", "image": "$inputs.image", - "detections": "$steps.step_1.predictions", + "predictions": "$steps.step_1.predictions", + "target_dataset": "some", }, ], "outputs": [ From b2efc389be2f35ef4ce97be6116443aea72a2392 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 10:56:09 +0100 Subject: [PATCH 06/18] Bump rc version --- inference/core/version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/inference/core/version.py b/inference/core/version.py index 785a770d0..96fa1cace 100644 --- a/inference/core/version.py +++ b/inference/core/version.py @@ -1,4 +1,4 @@ -__version__ = "0.9.10" +__version__ = "0.9.11rc1" if __name__ == "__main__": From 83eed51f8012f04c7eb5adead3d509cb0442d9f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 11:58:04 +0100 Subject: [PATCH 07/18] Add tests for validation of al data collector step definition --- .../enterprise/workflows/entities/steps.py | 18 +- .../steps_executors/test_auxiliary.py | 10 +- .../workflows/compiler/test_graph_parser.py | 50 +- .../workflows/entities/test_steps.py | 592 ++++++++++++++++++ 4 files changed, 645 insertions(+), 25 deletions(-) diff --git a/inference/enterprise/workflows/entities/steps.py b/inference/enterprise/workflows/entities/steps.py index 438cfa254..e3019a84a 100644 --- a/inference/enterprise/workflows/entities/steps.py +++ b/inference/enterprise/workflows/entities/steps.py @@ -1145,29 +1145,29 @@ class ActiveLearningDataCollector(BaseModel, StepInterface): target_dataset_api_key: Optional[str] = Field(default=None) disable_active_learning: Union[bool, str] = Field(default=False) - @classmethod @field_validator("image") + @classmethod def image_must_only_hold_selectors(cls, value: Any) -> Union[str, List[str]]: validate_image_is_valid_selector(value=value) return value - @classmethod @field_validator("predictions") + @classmethod def predictions_must_hold_selector(cls, value: Any) -> str: if not is_selector(selector_or_value=value): raise ValueError("`predictions` field can only contain selector values") return value - @classmethod @field_validator("target_dataset") - def validate_target_dataset_field(cls, value: Any) -> Union[str, bool]: + @classmethod + def validate_target_dataset_field(cls, value: Any) -> str: validate_field_is_selector_or_has_given_type( - value=value, field_name="target_dataset", allowed_types=[bool] + value=value, field_name="target_dataset", allowed_types=[str] ) return value + @field_validator("target_dataset_api_key") @classmethod - @field_validator("target_dataset") def validate_target_dataset_api_key_field(cls, value: Any) -> Union[str, bool]: validate_field_is_selector_or_has_given_type( value=value, @@ -1176,11 +1176,11 @@ def validate_target_dataset_api_key_field(cls, value: Any) -> Union[str, bool]: ) return value - @classmethod @field_validator("disable_active_learning") + @classmethod def validate_boolean_flags_or_selectors(cls, value: Any) -> Union[str, bool]: validate_field_is_selector_or_has_given_type( - value=value, field_name="class_aware", allowed_types=[bool] + value=value, field_name="disable_active_learning", allowed_types=[bool] ) return value @@ -1265,7 +1265,7 @@ def validate_field_binding(self, field_name: str, value: Any) -> None: elif field_name in {"target_dataset_api_key"}: validate_field_has_given_type( field_name=field_name, - allowed_types=[str, type(None)], + allowed_types=[str], value=value, error=VariableTypeError, ) diff --git a/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py b/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py index 1202157eb..eed644660 100644 --- a/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py +++ b/tests/inference/unit_tests/enterprise/workflows/compiler/steps_executors/test_auxiliary.py @@ -217,7 +217,7 @@ async def test_run_detection_filter_step_when_batch_detections_given() -> None: "$steps.step_1": { "predictions": detections, "image": [{"height": 100, "width": 100}] * 2, - "prediction_type": ["object-detection"] * 2 + "prediction_type": ["object-detection"] * 2, } }, model_manager=MagicMock(), @@ -227,8 +227,12 @@ async def test_run_detection_filter_step_when_batch_detections_given() -> None: # then assert next_step is None, "Next step should not be set here" - assert outputs_lookup["$steps.step_2"][0]["prediction_type"] == "object-detection", "Prediction type must be preserved" - assert outputs_lookup["$steps.step_2"][1]["prediction_type"] == "object-detection", "Prediction type must be preserved" + assert ( + outputs_lookup["$steps.step_2"][0]["prediction_type"] == "object-detection" + ), "Prediction type must be preserved" + assert ( + outputs_lookup["$steps.step_2"][1]["prediction_type"] == "object-detection" + ), "Prediction type must be preserved" assert outputs_lookup["$steps.step_2"][0]["predictions"] == [ { "x": 10, diff --git a/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py b/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py index dd76b0bc9..71e4d70c4 100644 --- a/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py +++ b/tests/inference/unit_tests/enterprise/workflows/compiler/test_graph_parser.py @@ -7,7 +7,8 @@ add_steps_nodes_for_graph, construct_graph, get_nodes_that_are_reachable_from_pointed_ones_in_reversed_graph, - prepare_execution_graph, verify_each_node_reach_at_least_one_output, + prepare_execution_graph, + verify_each_node_reach_at_least_one_output, ) from inference.enterprise.workflows.constants import ( INPUT_NODE_KIND, @@ -19,7 +20,11 @@ InferenceParameter, ) from inference.enterprise.workflows.entities.outputs import JsonField -from inference.enterprise.workflows.entities.steps import Crop, ObjectDetectionModel, ActiveLearningDataCollector +from inference.enterprise.workflows.entities.steps import ( + ActiveLearningDataCollector, + Crop, + ObjectDetectionModel, +) from inference.enterprise.workflows.entities.workflows_specification import ( WorkflowSpecificationV1, ) @@ -319,7 +324,9 @@ def test_construct_graph_when_detections_consensus_block_is_used() -> None: assert len(result.edges) == 5, "10 edges in total should be created" -def test_verify_each_node_reach_at_least_one_output_when_all_steps_are_connected_to_inputs_and_outputs() -> None: +def test_verify_each_node_reach_at_least_one_output_when_all_steps_are_connected_to_inputs_and_outputs() -> ( + None +): # given example_step = Crop( type="Crop", @@ -345,7 +352,9 @@ def test_verify_each_node_reach_at_least_one_output_when_all_steps_are_connected # then - no error raised -def test_verify_each_node_reach_at_least_one_output_when_there_is_step_with_outputs_defined_not_connected_to_output_node() -> None: +def test_verify_each_node_reach_at_least_one_output_when_there_is_step_with_outputs_defined_not_connected_to_output_node() -> ( + None +): # given example_step = Crop( type="Crop", @@ -368,7 +377,9 @@ def test_verify_each_node_reach_at_least_one_output_when_there_is_step_with_outp verify_each_node_reach_at_least_one_output(execution_graph=execution_graph) -def test_verify_each_node_reach_at_least_one_output_when_there_is_input_node_not_used() -> None: +def test_verify_each_node_reach_at_least_one_output_when_there_is_input_node_not_used() -> ( + None +): # given example_step = Crop( type="Crop", @@ -392,7 +403,9 @@ def test_verify_each_node_reach_at_least_one_output_when_there_is_input_node_not verify_each_node_reach_at_least_one_output(execution_graph=execution_graph) -def test_verify_each_node_reach_at_least_one_output_when_there_is_a_step_executing_side_effect_not_connected_to_output() -> None: +def test_verify_each_node_reach_at_least_one_output_when_there_is_a_step_executing_side_effect_not_connected_to_output() -> ( + None +): # given example_step = Crop( type="Crop", @@ -530,7 +543,9 @@ def test_prepare_execution_graph_when_graph_is_not_acyclic() -> None: _ = prepare_execution_graph(workflow_specification=workflow_specification) -def test_prepare_execution_graph_when_graph_node_with_side_effect_step_does_not_reach_output() -> None: +def test_prepare_execution_graph_when_graph_node_with_side_effect_step_does_not_reach_output() -> ( + None +): # given workflow_specification = WorkflowSpecificationV1.parse_obj( { @@ -564,15 +579,24 @@ def test_prepare_execution_graph_when_graph_node_with_side_effect_step_does_not_ ) # when - execution_graph = prepare_execution_graph(workflow_specification=workflow_specification) + execution_graph = prepare_execution_graph( + workflow_specification=workflow_specification + ) # then assert len(execution_graph.edges) == 4, "4 edges are expected to be created" - assert execution_graph.has_edge("$inputs.image", "$steps.step_1"), "Input must be connected to step_1" - assert execution_graph.has_edge("$inputs.image", "$steps.step_2"), "Input must be connected to step_2" - assert execution_graph.has_edge("$steps.step_1", "$steps.step_2"), "step_1 must be connected to step_2" - assert execution_graph.has_edge("$steps.step_1", "$outputs.predictions"), "step_1 output must be connected to output" - + assert execution_graph.has_edge( + "$inputs.image", "$steps.step_1" + ), "Input must be connected to step_1" + assert execution_graph.has_edge( + "$inputs.image", "$steps.step_2" + ), "Input must be connected to step_2" + assert execution_graph.has_edge( + "$steps.step_1", "$steps.step_2" + ), "step_1 must be connected to step_2" + assert execution_graph.has_edge( + "$steps.step_1", "$outputs.predictions" + ), "step_1 output must be connected to output" def test_prepare_execution_graph_when_graph_when_there_is_a_collapse_of_condition_branch() -> ( diff --git a/tests/inference/unit_tests/enterprise/workflows/entities/test_steps.py b/tests/inference/unit_tests/enterprise/workflows/entities/test_steps.py index db068c877..49a30e684 100644 --- a/tests/inference/unit_tests/enterprise/workflows/entities/test_steps.py +++ b/tests/inference/unit_tests/enterprise/workflows/entities/test_steps.py @@ -9,6 +9,7 @@ InferenceParameter, ) from inference.enterprise.workflows.entities.steps import ( + ActiveLearningDataCollector, AggregationMode, ClassificationModel, Condition, @@ -2329,3 +2330,594 @@ def test_detections_consensus_validate_field_binding_for_required_objects_when_v ) # then - no error + + +def test_validate_al_data_collector_when_valid_input_given() -> None: + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + } + + # when + _ = ActiveLearningDataCollector.parse_obj(specification) + + # then NO ERROR is raised + + +@pytest.mark.parametrize("image_selector", [1, None, "some", 1.3, True]) +def test_validate_al_data_collector_image_field_when_field_does_not_hold_selector( + image_selector: Any, +) -> None: + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": image_selector, + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + } + + # when + with pytest.raises(ValidationError): + _ = ActiveLearningDataCollector.parse_obj(specification) + + +@pytest.mark.parametrize("predictions_selector", [1, None, "some", 1.3, True]) +def test_validate_al_data_collector_predictions_field_when_field_does_not_hold_selector( + predictions_selector: Any, +) -> None: + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": predictions_selector, + "target_dataset": "some", + } + + # when + with pytest.raises(ValidationError): + _ = ActiveLearningDataCollector.parse_obj(specification) + + +@pytest.mark.parametrize("target_dataset", [1, None, 1.3, True]) +def test_validate_al_data_collector_target_dataset_field_when_field_contains_invalid_value( + target_dataset: Any, +) -> None: + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": target_dataset, + } + + # when + with pytest.raises(ValidationError): + _ = ActiveLearningDataCollector.parse_obj(specification) + + +@pytest.mark.parametrize("target_dataset_api_key", [1, 1.3, True]) +def test_validate_al_data_collector_target_dataset_api_key_field_when_field_contains_invalid_value( + target_dataset_api_key: Any, +) -> None: + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + "target_dataset_api_key": target_dataset_api_key, + } + + # when + with pytest.raises(ValidationError): + _ = ActiveLearningDataCollector.parse_obj(specification) + + +@pytest.mark.parametrize("disable_active_learning", ["some", 1.3]) +def test_validate_al_data_collector_disable_active_learning_field_when_field_contains_invalid_value( + disable_active_learning: Any, +) -> None: + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + "disable_active_learning": disable_active_learning, + } + + # when + with pytest.raises(ValidationError): + _ = ActiveLearningDataCollector.parse_obj(specification) + + +def test_al_data_collector_validate_field_selector_when_field_does_not_hold_selector() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(ExecutionGraphError): + step.validate_field_selector( + field_name="target_dataset", + input_step=ObjectDetectionModel( + type="ObjectDetectionModel", + name="some", + image="$inputs.image", + model_id="some/1", + ), + ) + + +def test_al_data_collector_validate_field_selector_when_prediction_field_refers_to_invalid_step() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(ExecutionGraphError): + step.validate_field_selector( + field_name="predictions", + input_step=Crop( + type="Crop", + name="some", + image="$inputs.image", + detections="$steps.detection.predictions", + ), + ) + + +def test_al_data_collector_validate_field_selector_when_prediction_field_refers_to_invalid_output_of_detection_step() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.image", + "target_dataset": "some", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(ExecutionGraphError): + step.validate_field_selector( + field_name="predictions", + input_step=ObjectDetectionModel( + type="ObjectDetectionModel", + name="some", + image="$inputs.image", + model_id="some/1", + ), + ) + + +def test_al_data_collector_validate_field_selector_when_prediction_field_refers_to_invalid_output_of_classification_step() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(ExecutionGraphError): + step.validate_field_selector( + field_name="predictions", + input_step=ClassificationModel( + type="ClassificationModel", + name="some", + image="$inputs.image", + model_id="some/1", + ), + ) + + +def test_al_data_collector_validate_field_selector_when_prediction_field_refers_to_valid_output_of_classification_step() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.top", + "target_dataset": "some", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + step.validate_field_selector( + field_name="predictions", + input_step=ClassificationModel( + type="ClassificationModel", + name="some", + image="$inputs.image", + model_id="some/1", + ), + ) + + # then - NO ERROR + + +def test_al_data_collector_validate_field_selector_when_prediction_field_refers_to_step_bounded_in_different_image() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(ExecutionGraphError): + step.validate_field_selector( + field_name="predictions", + input_step=ObjectDetectionModel( + type="ObjectDetectionModel", + name="some", + image="$inputs.image2", + model_id="some/1", + ), + ) + + +def test_al_data_collector_validate_field_selector_when_prediction_field_refers_to_step_which_cannot_be_verified_against_image_ref_correctness() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + step.validate_field_selector( + field_name="predictions", + input_step=DetectionFilter( + type="DetectionFilter", + name="detection", + predictions="$steps.det.predictions", + filter_definition=DetectionFilterDefinition( + type="DetectionFilterDefinition", + field_name="confidence", + operator="greater_than", + reference_value=0.3, + ), + ), + ) + + # then - NO ERROR + + +def test_al_data_collector_validate_field_selector_when_image_field_does_not_refer_image() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(ExecutionGraphError): + step.validate_field_selector( + field_name="image", + input_step=ObjectDetectionModel( + type="ObjectDetectionModel", + name="some", + image="$inputs.image2", + model_id="some/1", + ), + ) + + +def test_al_data_collector_validate_field_selector_when_image_field_refers_image() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + step.validate_field_selector( + field_name="image", + input_step=InferenceImage( + type="InferenceImage", + name="some", + ), + ) + + # then - NO ERROR + + +@pytest.mark.parametrize( + "field_name", + ["target_dataset", "target_dataset_api_key", "disable_active_learning"], +) +def test_al_data_collector_validate_fields_that_can_only_accept_inference_parameter_when_invalid_input_is_provided( + field_name: str, +) -> None: + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(ExecutionGraphError): + step.validate_field_selector( + field_name=field_name, + input_step=InferenceImage( + type="InferenceImage", + name="some", + ), + ) + + +@pytest.mark.parametrize( + "field_name", + ["target_dataset", "target_dataset_api_key", "disable_active_learning"], +) +def test_al_data_collector_validate_fields_that_can_only_accept_inference_parameter_when_valid_input_is_provided( + field_name: str, +) -> None: + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "$inputs.some", + "target_dataset_api_key": "$inputs.other", + "disable_active_learning": "$inputs.value", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + step.validate_field_selector( + field_name=field_name, + input_step=InferenceParameter( + type="InferenceParameter", + name="some", + ), + ) + + # then - NO ERROR + + +def test_al_data_collector_validate_image_binding_when_provided_value_is_valid() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "$inputs.some", + "target_dataset_api_key": "$inputs.other", + "disable_active_learning": "$inputs.value", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + step.validate_field_binding( + field_name="image", value={"type": "url", "value": "https://some.com/image.jpg"} + ) + + # then - NO ERROR + + +def test_al_data_collector_validate_image_binding_when_provided_value_is_invalid() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "$inputs.some", + "target_dataset_api_key": "$inputs.other", + "disable_active_learning": "$inputs.value", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(VariableTypeError): + step.validate_field_binding(field_name="image", value="invalid") + + +def test_al_data_collector_validate_disable_al_flag_binding_when_provided_value_is_valid() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "$inputs.some", + "target_dataset_api_key": "$inputs.other", + "disable_active_learning": "$inputs.value", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + step.validate_field_binding( + field_name="disable_active_learning", + value=True, + ) + + # then - NO ERROR + + +def test_al_data_collector_validate_disable_al_flag_binding_when_provided_value_is_invalid() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "$inputs.some", + "target_dataset_api_key": "$inputs.other", + "disable_active_learning": "$inputs.value", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(VariableTypeError): + step.validate_field_binding( + field_name="disable_active_learning", + value="some", + ) + + +def test_al_data_collector_validate_target_dataset_binding_when_provided_value_is_valid() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "$inputs.some", + "target_dataset_api_key": "$inputs.other", + "disable_active_learning": "$inputs.value", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + step.validate_field_binding( + field_name="target_dataset", + value="some", + ) + + # then - NO ERROR + + +def test_al_data_collector_validate_target_dataset_binding_when_provided_value_is_invalid() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "$inputs.some", + "target_dataset_api_key": "$inputs.other", + "disable_active_learning": "$inputs.value", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(VariableTypeError): + step.validate_field_binding( + field_name="target_dataset", + value=None, + ) + + +def test_al_data_collector_validate_target_dataset_api_key_binding_when_provided_value_is_valid() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "$inputs.some", + "target_dataset_api_key": "$inputs.other", + "disable_active_learning": "$inputs.value", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + step.validate_field_binding( + field_name="target_dataset_api_key", + value="some", + ) + + # then - NO ERROR + + +def test_al_data_collector_validate_target_dataset_api_key_binding_when_provided_value_is_invalid() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "$inputs.some", + "target_dataset_api_key": "$inputs.other", + "disable_active_learning": "$inputs.value", + } + step = ActiveLearningDataCollector.parse_obj(specification) + + # when + with pytest.raises(VariableTypeError): + step.validate_field_binding( + field_name="target_dataset_api_key", + value=None, + ) From cc34098ae9be5c16d39d5659606d5cd47db9e6c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 12:53:11 +0100 Subject: [PATCH 08/18] Add possibility to define AL config at the level of AL workflow steps --- .../enterprise/workflows/entities/steps.py | 105 ++++++++++- .../workflows/entities/test_steps.py | 171 +++++++++++++++++- 2 files changed, 271 insertions(+), 5 deletions(-) diff --git a/inference/enterprise/workflows/entities/steps.py b/inference/enterprise/workflows/entities/steps.py index e3019a84a..7f1380a40 100644 --- a/inference/enterprise/workflows/entities/steps.py +++ b/inference/enterprise/workflows/entities/steps.py @@ -1,8 +1,16 @@ from abc import ABCMeta, abstractmethod from enum import Enum -from typing import Annotated, Any, Dict, List, Literal, Optional, Set, Union - -from pydantic import BaseModel, ConfigDict, Field, field_validator +from typing import Annotated, Any, Dict, List, Literal, Optional, Set, Tuple, Union + +from pydantic import ( + BaseModel, + ConfigDict, + Field, + NonNegativeInt, + PositiveInt, + confloat, + field_validator, +) from inference.enterprise.workflows.entities.base import GraphNone from inference.enterprise.workflows.entities.validators import ( @@ -1136,6 +1144,94 @@ def _validate_required_objects_binding(self, value: Any) -> None: } +class DisabledActiveLearningConfiguration(BaseModel): + enabled: bool + + +class LimitDefinition(BaseModel): + type: Literal["minutely", "hourly", "daily"] + value: PositiveInt + + +class RandomSamplingConfig(BaseModel): + type: Literal["random"] + name: str + traffic_percentage: confloat(ge=0.0, le=1.0) + tags: List[str] = Field(default_factory=lambda: []) + limits: List[LimitDefinition] = Field(default_factory=lambda: []) + + +class CloseToThresholdSampling(BaseModel): + type: Literal["close_to_threshold"] + name: str + probability: confloat(ge=0.0, le=1.0) + threshold: confloat(ge=0.0, le=1.0) + epsilon: confloat(ge=0.0, le=1.0) + max_batch_images: Optional[int] = Field(default=None) + only_top_classes: bool = Field(default=True) + minimum_objects_close_to_threshold: int = Field(default=1) + selected_class_names: Optional[List[str]] = Field(default=None) + tags: List[str] = Field(default_factory=lambda: []) + limits: List[LimitDefinition] = Field(default_factory=lambda: []) + + +class ClassesBasedSampling(BaseModel): + type: Literal["classes_based"] + name: str + probability: confloat(ge=0.0, le=1.0) + selected_class_names: List[str] + tags: List[str] = Field(default_factory=lambda: []) + limits: List[LimitDefinition] = Field(default_factory=lambda: []) + + +class DetectionsBasedSampling(BaseModel): + type: Literal["detections_number_based"] + name: str + probability: confloat(ge=0.0, le=1.0) + more_than: Optional[NonNegativeInt] + less_than: Optional[NonNegativeInt] + selected_class_names: Optional[List[str]] = Field(default=None) + tags: List[str] = Field(default_factory=lambda: []) + limits: List[LimitDefinition] = Field(default_factory=lambda: []) + + +class ActiveLearningBatchingStrategy(BaseModel): + batches_name_prefix: str + recreation_interval: Literal["never", "daily", "weekly", "monthly"] + max_batch_images: Optional[int] = Field(default=None) + + +ActiveLearningStrategyType = Annotated[ + Union[ + RandomSamplingConfig, + CloseToThresholdSampling, + ClassesBasedSampling, + DetectionsBasedSampling, + ], + Field(discriminator="type"), +] + + +class EnabledActiveLearningConfiguration(BaseModel): + enabled: bool + persist_predictions: bool + sampling_strategies: List[ActiveLearningStrategyType] + batching_strategy: ActiveLearningBatchingStrategy + tags: List[str] = Field(default_factory=lambda: []) + max_image_size: Optional[Tuple[PositiveInt, PositiveInt]] = Field(default=None) + jpeg_compression_level: int = Field(default=95) + + @field_validator("jpeg_compression_level") + @classmethod + def validate_json_compression_level(cls, value: Any): + validate_field_has_given_type( + field_name="jpeg_compression_level", allowed_types=[int], value=value + ) + if value <= 0 or value > 100: + raise ValueError("`jpeg_compression_level` must be in range [1, 100]") + return value + + class ActiveLearningDataCollector(BaseModel, StepInterface): type: Literal["ActiveLearningDataCollector"] name: str @@ -1144,6 +1240,9 @@ class ActiveLearningDataCollector(BaseModel, StepInterface): target_dataset: str target_dataset_api_key: Optional[str] = Field(default=None) disable_active_learning: Union[bool, str] = Field(default=False) + active_learning_configuration: Optional[ + Union[EnabledActiveLearningConfiguration, DisabledActiveLearningConfiguration] + ] = Field(default=None) @field_validator("image") @classmethod diff --git a/tests/inference/unit_tests/enterprise/workflows/entities/test_steps.py b/tests/inference/unit_tests/enterprise/workflows/entities/test_steps.py index 49a30e684..67b31f6bf 100644 --- a/tests/inference/unit_tests/enterprise/workflows/entities/test_steps.py +++ b/tests/inference/unit_tests/enterprise/workflows/entities/test_steps.py @@ -9,21 +9,29 @@ InferenceParameter, ) from inference.enterprise.workflows.entities.steps import ( + ActiveLearningBatchingStrategy, ActiveLearningDataCollector, AggregationMode, + ClassesBasedSampling, ClassificationModel, + CloseToThresholdSampling, Condition, Crop, DetectionFilter, DetectionFilterDefinition, DetectionOffset, + DetectionsBasedSampling, DetectionsConsensus, + DisabledActiveLearningConfiguration, + EnabledActiveLearningConfiguration, InstanceSegmentationModel, KeypointsDetectionModel, + LimitDefinition, MultiLabelClassificationModel, ObjectDetectionModel, OCRModel, Operator, + RandomSamplingConfig, ) from inference.enterprise.workflows.errors import ( ExecutionGraphError, @@ -2343,9 +2351,168 @@ def test_validate_al_data_collector_when_valid_input_given() -> None: } # when - _ = ActiveLearningDataCollector.parse_obj(specification) + result = ActiveLearningDataCollector.parse_obj(specification) - # then NO ERROR is raised + # then + assert result == ActiveLearningDataCollector( + type="ActiveLearningDataCollector", + name="some", + image="$inputs.image", + predictions="$steps.detection.predictions", + target_dataset="some", + target_dataset_api_key=None, + disable_active_learning=False, + active_learning_configuration=None, + ) + + +def test_validate_al_data_collector_when_valid_input_with_disabled_al_config_given() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + "active_learning_configuration": {"enabled": False}, + } + + # when + result = ActiveLearningDataCollector.parse_obj(specification) + + # then + assert result == ActiveLearningDataCollector( + type="ActiveLearningDataCollector", + name="some", + image="$inputs.image", + predictions="$steps.detection.predictions", + target_dataset="some", + target_dataset_api_key=None, + disable_active_learning=False, + active_learning_configuration=DisabledActiveLearningConfiguration( + enabled=False + ), + ) + + +def test_validate_al_data_collector_when_valid_input_with_enabled_al_config_given() -> ( + None +): + # given + specification = { + "type": "ActiveLearningDataCollector", + "name": "some", + "image": "$inputs.image", + "predictions": "$steps.detection.predictions", + "target_dataset": "some", + "active_learning_configuration": { + "enabled": True, + "persist_predictions": True, + "sampling_strategies": [ + { + "type": "random", + "name": "a", + "traffic_percentage": 0.6, + "limits": [{"type": "daily", "value": 100}], + }, + { + "type": "close_to_threshold", + "name": "b", + "probability": 0.7, + "threshold": 0.5, + "epsilon": 0.25, + "tags": ["some"], + "limits": [{"type": "daily", "value": 200}], + }, + { + "type": "classes_based", + "name": "c", + "probability": 0.8, + "selected_class_names": ["a", "b", "c"], + "limits": [{"type": "daily", "value": 300}], + }, + { + "type": "detections_number_based", + "name": "d", + "probability": 0.9, + "more_than": 3, + "less_than": 5, + "limits": [{"type": "daily", "value": 400}], + }, + ], + "batching_strategy": { + "batches_name_prefix": "my_batches", + "recreation_interval": "monthly", + }, + }, + } + + # when + result = ActiveLearningDataCollector.parse_obj(specification) + + # then + assert result == ActiveLearningDataCollector( + type="ActiveLearningDataCollector", + name="some", + image="$inputs.image", + predictions="$steps.detection.predictions", + target_dataset="some", + target_dataset_api_key=None, + disable_active_learning=False, + active_learning_configuration=EnabledActiveLearningConfiguration( + enabled=True, + persist_predictions=True, + sampling_strategies=[ + RandomSamplingConfig( + type="random", + name="a", + traffic_percentage=0.6, + tags=[], + limits=[LimitDefinition(type="daily", value=100)], + ), + CloseToThresholdSampling( + type="close_to_threshold", + name="b", + probability=0.7, + threshold=0.5, + epsilon=0.25, + max_batch_images=None, + only_top_classes=True, + minimum_objects_close_to_threshold=1, + selected_class_names=None, + tags=["some"], + limits=[LimitDefinition(type="daily", value=200)], + ), + ClassesBasedSampling( + type="classes_based", + name="c", + probability=0.8, + selected_class_names=["a", "b", "c"], + tags=[], + limits=[LimitDefinition(type="daily", value=300)], + ), + DetectionsBasedSampling( + type="detections_number_based", + name="d", + probability=0.9, + more_than=3, + less_than=5, + selected_class_names=None, + tags=[], + limits=[LimitDefinition(type="daily", value=400)], + ), + ], + batching_strategy=ActiveLearningBatchingStrategy( + batches_name_prefix="my_batches", + recreation_interval="monthly", + ), + tags=[], + max_image_size=None, + jpeg_compression_level=95, + ), + ) @pytest.mark.parametrize("image_selector", [1, None, "some", 1.3, True]) From 8746357979773424626da618f008b4b2483d45ae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 13:23:50 +0100 Subject: [PATCH 09/18] Connect AL configuration stated at step level to the middleware --- .../core/active_learning/configuration.py | 65 +++++++++++++++---- inference/core/active_learning/middlewares.py | 38 +++++++++++ .../active_learning_middlewares.py | 47 ++++++++++++-- .../complier/steps_executors/auxiliary.py | 1 + 4 files changed, 130 insertions(+), 21 deletions(-) diff --git a/inference/core/active_learning/configuration.py b/inference/core/active_learning/configuration.py index 3e79a0581..86274cf39 100644 --- a/inference/core/active_learning/configuration.py +++ b/inference/core/active_learning/configuration.py @@ -58,23 +58,37 @@ def prepare_active_learning_configuration( f"project: {project_metadata.dataset_id} of type: {project_metadata.dataset_type}. " f"AL configuration: {project_metadata.active_learning_configuration}" ) - sampling_methods = initialize_sampling_methods( - sampling_strategies_configs=project_metadata.active_learning_configuration[ - "sampling_strategies" - ], + return initialise_active_learning_configuration( + project_metadata=project_metadata, ) - target_workspace_id = project_metadata.active_learning_configuration.get( - "target_workspace", project_metadata.workspace_id + + +def prepare_active_learning_configuration_inplace( + api_key: str, + model_id: str, + active_learning_configuration: Optional[dict], +) -> Optional[ActiveLearningConfiguration]: + if ( + active_learning_configuration is None + or active_learning_configuration.get("enabled", False) is False + ): + return None + dataset_id, version_id = get_model_id_chunks(model_id=model_id) + workspace_id = get_roboflow_workspace(api_key=api_key) + dataset_type = get_roboflow_dataset_type( + api_key=api_key, + workspace_id=workspace_id, + dataset_id=dataset_id, ) - target_dataset_id = project_metadata.active_learning_configuration.get( - "target_project", project_metadata.dataset_id + project_metadata = RoboflowProjectMetadata( + dataset_id=dataset_id, + version_id=version_id, + workspace_id=workspace_id, + dataset_type=dataset_type, + active_learning_configuration=active_learning_configuration, ) - return ActiveLearningConfiguration.init( - roboflow_api_configuration=project_metadata.active_learning_configuration, - sampling_methods=sampling_methods, - workspace_id=target_workspace_id, - dataset_id=target_dataset_id, - model_id=model_id, + return initialise_active_learning_configuration( + project_metadata=project_metadata, ) @@ -145,6 +159,29 @@ def parse_cached_roboflow_project_metadata( ) from error +def initialise_active_learning_configuration( + project_metadata: RoboflowProjectMetadata, +) -> ActiveLearningConfiguration: + sampling_methods = initialize_sampling_methods( + sampling_strategies_configs=project_metadata.active_learning_configuration[ + "sampling_strategies" + ], + ) + target_workspace_id = project_metadata.active_learning_configuration.get( + "target_workspace", project_metadata.workspace_id + ) + target_dataset_id = project_metadata.active_learning_configuration.get( + "target_project", project_metadata.dataset_id + ) + return ActiveLearningConfiguration.init( + roboflow_api_configuration=project_metadata.active_learning_configuration, + sampling_methods=sampling_methods, + workspace_id=target_workspace_id, + dataset_id=target_dataset_id, + model_id=f"{project_metadata.dataset_id}/{project_metadata.version_id}", + ) + + def initialize_sampling_methods( sampling_strategies_configs: List[Dict[str, Any]] ) -> List[SamplingMethod]: diff --git a/inference/core/active_learning/middlewares.py b/inference/core/active_learning/middlewares.py index c6984c603..695d64c4d 100644 --- a/inference/core/active_learning/middlewares.py +++ b/inference/core/active_learning/middlewares.py @@ -8,6 +8,7 @@ from inference.core.active_learning.batching import generate_batch_name from inference.core.active_learning.configuration import ( prepare_active_learning_configuration, + prepare_active_learning_configuration_inplace, ) from inference.core.active_learning.core import ( execute_datapoint_registration, @@ -72,6 +73,21 @@ def init( cache=cache, ) + @classmethod + def init_from_config( + cls, api_key: str, model_id: str, cache: BaseCache, config: Optional[dict] + ) -> "ActiveLearningMiddleware": + configuration = prepare_active_learning_configuration_inplace( + api_key=api_key, + model_id=model_id, + active_learning_configuration=config, + ) + return cls( + api_key=api_key, + configuration=configuration, + cache=cache, + ) + def __init__( self, api_key: str, @@ -178,6 +194,28 @@ def init( task_queue=task_queue, ) + @classmethod + def init_from_config( + cls, + api_key: str, + model_id: str, + cache: BaseCache, + config: Optional[dict], + max_queue_size: int = MAX_REGISTRATION_QUEUE_SIZE, + ) -> "ThreadingActiveLearningMiddleware": + configuration = prepare_active_learning_configuration_inplace( + api_key=api_key, + model_id=model_id, + active_learning_configuration=config, + ) + task_queue = Queue(max_queue_size) + return cls( + api_key=api_key, + configuration=configuration, + cache=cache, + task_queue=task_queue, + ) + def __init__( self, api_key: str, diff --git a/inference/enterprise/workflows/complier/steps_executors/active_learning_middlewares.py b/inference/enterprise/workflows/complier/steps_executors/active_learning_middlewares.py index 98aa10ab0..200b7118d 100644 --- a/inference/enterprise/workflows/complier/steps_executors/active_learning_middlewares.py +++ b/inference/enterprise/workflows/complier/steps_executors/active_learning_middlewares.py @@ -1,4 +1,4 @@ -from typing import Dict, List, Optional +from typing import Dict, List, Optional, Union from fastapi import BackgroundTasks @@ -6,6 +6,10 @@ from inference.core.active_learning.middlewares import ActiveLearningMiddleware from inference.core.cache.base import BaseCache from inference.core.env import DISABLE_PREPROC_AUTO_ORIENT +from inference.enterprise.workflows.entities.steps import ( + DisabledActiveLearningConfiguration, + EnabledActiveLearningConfiguration, +) class WorkflowsActiveLearningMiddleware: @@ -27,6 +31,11 @@ def register( prediction_type: str, active_learning_disabled_for_request: bool, background_tasks: Optional[BackgroundTasks] = None, + active_learning_configuration: Optional[ + Union[ + EnabledActiveLearningConfiguration, DisabledActiveLearningConfiguration + ] + ] = None, ) -> None: model_id = f"{dataset_name}/workflows" if api_key is None or active_learning_disabled_for_request: @@ -38,6 +47,7 @@ def register( predictions=predictions, api_key=api_key, prediction_type=prediction_type, + active_learning_configuration=active_learning_configuration, ) return None background_tasks.add_task( @@ -47,6 +57,7 @@ def register( predictions=predictions, api_key=api_key, prediction_type=prediction_type, + active_learning_configuration=active_learning_configuration, ) def _register( @@ -56,9 +67,18 @@ def _register( predictions: List[dict], api_key: str, prediction_type: str, + active_learning_configuration: Optional[ + Union[ + EnabledActiveLearningConfiguration, DisabledActiveLearningConfiguration + ] + ], ) -> None: try: - self._ensure_middleware_initialised(model_id=model_id, api_key=api_key) + self._ensure_middleware_initialised( + model_id=model_id, + api_key=api_key, + active_learning_configuration=active_learning_configuration, + ) self._middlewares[model_id].register_batch( inference_inputs=images, predictions=predictions, @@ -76,11 +96,24 @@ def _ensure_middleware_initialised( self, model_id: str, api_key: str, + active_learning_configuration: Optional[ + Union[ + EnabledActiveLearningConfiguration, DisabledActiveLearningConfiguration + ] + ], ) -> None: if model_id in self._middlewares: return None - self._middlewares[model_id] = ActiveLearningMiddleware.init( - api_key=api_key, - model_id=model_id, - cache=self._cache, - ) + if active_learning_configuration is not None: + self._middlewares[model_id] = ActiveLearningMiddleware.init_from_config( + api_key=api_key, + model_id=model_id, + cache=self._cache, + config=active_learning_configuration.dict(), + ) + else: + self._middlewares[model_id] = ActiveLearningMiddleware.init( + api_key=api_key, + model_id=model_id, + cache=self._cache, + ) diff --git a/inference/enterprise/workflows/complier/steps_executors/auxiliary.py b/inference/enterprise/workflows/complier/steps_executors/auxiliary.py index 1d6ad1019..d6a791fa7 100644 --- a/inference/enterprise/workflows/complier/steps_executors/auxiliary.py +++ b/inference/enterprise/workflows/complier/steps_executors/auxiliary.py @@ -911,5 +911,6 @@ async def run_active_learning_data_collector( active_learning_disabled_for_request=disable_active_learning, prediction_type=prediction_type, background_tasks=background_tasks, + active_learning_configuration=step.active_learning_configuration, ) return None, outputs_lookup From ecfc67a214762f2eb0690e7520540a6e3fe8a271 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 13:38:25 +0100 Subject: [PATCH 10/18] Fix issue spotted in initial testing --- inference/enterprise/workflows/entities/steps.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/inference/enterprise/workflows/entities/steps.py b/inference/enterprise/workflows/entities/steps.py index 7f1380a40..c0643d0d0 100644 --- a/inference/enterprise/workflows/entities/steps.py +++ b/inference/enterprise/workflows/entities/steps.py @@ -1147,6 +1147,15 @@ def _validate_required_objects_binding(self, value: Any) -> None: class DisabledActiveLearningConfiguration(BaseModel): enabled: bool + @field_validator("enabled") + @classmethod + def ensure_only_false_is_valid(cls, value: Any) -> bool: + if value is not False: + raise ValueError( + "One can only specify enabled=False in `DisabledActiveLearningConfiguration`" + ) + return value + class LimitDefinition(BaseModel): type: Literal["minutely", "hourly", "daily"] @@ -1223,7 +1232,7 @@ class EnabledActiveLearningConfiguration(BaseModel): @field_validator("jpeg_compression_level") @classmethod - def validate_json_compression_level(cls, value: Any): + def validate_json_compression_level(cls, value: Any) -> int: validate_field_has_given_type( field_name="jpeg_compression_level", allowed_types=[int], value=value ) From e66b9bf8de50306e3a169047da43c8e181150afa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 13:48:01 +0100 Subject: [PATCH 11/18] Fix problem with docker build --- docker/config/cpu_http.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/docker/config/cpu_http.py b/docker/config/cpu_http.py index 2de4d1706..862dce75e 100644 --- a/docker/config/cpu_http.py +++ b/docker/config/cpu_http.py @@ -10,8 +10,6 @@ from prometheus_fastapi_instrumentator import Instrumentator from inference.core.env import MAX_ACTIVE_MODELS, ACTIVE_LEARNING_ENABLED, LAMBDA -from inference.enterprise.workflows.complier.steps_executors.active_learning_middlewares import \ - BackgroundTaskWorkflowsActiveLearningMiddleware from inference.models.utils import ROBOFLOW_MODEL_TYPES model_registry = RoboflowModelRegistry(ROBOFLOW_MODEL_TYPES) From 99a7cf049ff3ae586707d9b899011cf5b7daeb91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 14:21:52 +0100 Subject: [PATCH 12/18] Bring back old build --- docker/publish/deploy_docker_image.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docker/publish/deploy_docker_image.sh b/docker/publish/deploy_docker_image.sh index e80a800ab..db7b7d47e 100755 --- a/docker/publish/deploy_docker_image.sh +++ b/docker/publish/deploy_docker_image.sh @@ -12,7 +12,7 @@ VERSION=`python inference/core/version.py` REPOSITORY=$1 DOCKERFILE=$2 -docker buildx build --platform linux/amd64 --pull -t $REPOSITORY:$VERSION -f $DOCKERFILE . --push +docker build --pull -t $REPOSITORY:$VERSION -f $DOCKERFILE . check_return_code $? "Docker build" docker tag $REPOSITORY:$VERSION $REPOSITORY:latest From efbae9e9f6cb21509dd481eff2ff675153ee8d2d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 14:24:22 +0100 Subject: [PATCH 13/18] Revert change --- docker/publish/deploy_docker_image.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docker/publish/deploy_docker_image.sh b/docker/publish/deploy_docker_image.sh index db7b7d47e..e80a800ab 100755 --- a/docker/publish/deploy_docker_image.sh +++ b/docker/publish/deploy_docker_image.sh @@ -12,7 +12,7 @@ VERSION=`python inference/core/version.py` REPOSITORY=$1 DOCKERFILE=$2 -docker build --pull -t $REPOSITORY:$VERSION -f $DOCKERFILE . +docker buildx build --platform linux/amd64 --pull -t $REPOSITORY:$VERSION -f $DOCKERFILE . --push check_return_code $? "Docker build" docker tag $REPOSITORY:$VERSION $REPOSITORY:latest From e2b7c92d6842bd4f2e58445de32ae2eeed93ffeb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 14:59:00 +0100 Subject: [PATCH 14/18] Update notebook example --- examples/notebooks/workflows.ipynb | 39 +++++++++++++++--------------- 1 file changed, 20 insertions(+), 19 deletions(-) diff --git a/examples/notebooks/workflows.ipynb b/examples/notebooks/workflows.ipynb index c27c63f0a..6ba7669cd 100644 --- a/examples/notebooks/workflows.ipynb +++ b/examples/notebooks/workflows.ipynb @@ -43,7 +43,7 @@ "Requirement already satisfied: scipy<2.0.0,>=1.10.0 in /usr/local/lib/python3.9/site-packages (from supervision==0.18.0) (1.12.0)\n", "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.9/site-packages (from matplotlib>=3.6.0->supervision==0.18.0) (1.2.0)\n", "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.9/site-packages (from matplotlib>=3.6.0->supervision==0.18.0) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/site-packages (from matplotlib>=3.6.0->supervision==0.18.0) (4.47.2)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/site-packages (from matplotlib>=3.6.0->supervision==0.18.0) (4.48.1)\n", "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.9/site-packages (from matplotlib>=3.6.0->supervision==0.18.0) (1.4.5)\n", "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.9/site-packages (from matplotlib>=3.6.0->supervision==0.18.0) (23.2)\n", "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.9/site-packages (from matplotlib>=3.6.0->supervision==0.18.0) (10.2.0)\n", @@ -81,16 +81,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2024-02-06 13:28:44-- https://media.roboflow.com/workflows_examples_images.zip\n", + "--2024-02-14 13:51:16-- https://media.roboflow.com/workflows_examples_images.zip\n", "Resolving media.roboflow.com (media.roboflow.com)... 34.110.133.209\n", "Connecting to media.roboflow.com (media.roboflow.com)|34.110.133.209|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 8229834 (7.8M) [application/zip]\n", "Saving to: ‘workflows_examples_images.zip’\n", "\n", - "workflows_examples_ 100%[===================>] 7.85M 18.8MB/s in 0.4s \n", + "workflows_examples_ 100%[===================>] 7.85M 10.7MB/s in 0.7s \n", "\n", - "2024-02-06 13:28:45 (18.8 MB/s) - ‘workflows_examples_images.zip’ saved [8229834/8229834]\n", + "2024-02-14 13:51:17 (10.7 MB/s) - ‘workflows_examples_images.zip’ saved [8229834/8229834]\n", "\n" ] } @@ -223,7 +223,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -363,7 +363,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAADKCAYAAACPHrslAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9ebRtV1Xn/1ndbs459973krwQSGhDLC2kgkaxo4kt4CgdoIIWpQbsQMSmLCibqh+NiopIVRyo2FWJAxscIjhw2CJSOhBLUUsRBQQl0gSSvO7ee87Zzep+f8y1932PhBAtMUTvHOMR3nnnnrvPbtaa8zu/3+9UOefMcRzHcRzHcRzHcRzHR1Hou/sAjuM4juM4juM4juM4PjiOE5TjOI7jOI7jOI7j+KiL4wTlOI7jOI7jOI7jOD7q4jhBOY7jOI7jOI7jOI6PujhOUI7jOI7jOI7jOI7joy6OE5TjOI7jOI7jOI7j+KiL4wTlOI7jOI7jOI7jOD7q4jhBOY7jOI7jOI7jOI6PujhOUI7jOI7jOI7jOI7joy6OE5TjOI57SCileN7znvfP+juf97znoZT6J/u8m266CaUUL3vZy/7JPvMjFQ94wANQSqGU4pnPfObdfTj3+PiVX/mV+XwqpfiTP/mTu/uQjuOjPI4TlOO4x8XLXvayixY6ay1XXnklT3nKU3jf+953dx/ecXyE4o1vfCPPe97zOH/+/D/b73zkIx/Jy1/+cm644Yb5tSnJ+t//+3/Pr/3+7/8+X/iFX8h973tfmqbhiiuu4LGPfSx/8Ad/cKeff/78eS6//HKUUrzyla+8y8d1yy238LSnPY0rr7ySpml4wAMewFd/9Vdf9J4pufzgP03T3O7zXvrSl/LEJz6R+93vfiileMpTnnKHv/f9738/3/7t385nfuZnsrOzc7vzcGE84AEPuCih/qRP+iRe/vKX83Vf93V3+Xsex7/usHf3ARzHcfxj47u+67t44AMfSN/3/J//83942ctexhve8Abe8pa33OEifE+Pruuw9l/vI/vGN76R5z//+TzlKU/hxIkT/yy/80EPehBf/uVf/mHf9zd/8zdorXn605/OFVdcwblz5/jZn/1ZHvWoR/Frv/ZrPPaxj73Dn3vOc57Ddrv9Bx3Te97zHj7jMz4DgKc//elceeWV3HzzzfzxH//xHb7/pS99KavVav67MeZ273nhC1/I4eEhD3/4w3n/+9//IX/329/+dl74whdyzTXX8NCHPpQ//MM/vMvHfdVVV/HlX/7lhBD4iZ/4ibv8c8fxrzf+9a52x3GPj8c97nF80id9EgBf8zVfw2WXXcYLX/hCXvOa1/CkJz3pbj66f/r4l5h0/UuJr/mar+FrvuZrLnrtGc94Bg960IO48cYb7zBBectb3sJLX/pSnvOc5/Cc5zznLv+upz3taVhredOb3sSll176Yd//JV/yJVx22WV3+p7f+73fm9GTC5OZD47rrruOM2fOcMkll/DKV76SJz7xiXf5uI/jOP6hcdziOY5/MfHIRz4SgL/927+96PW3ve1tfMmXfAmXXHIJTdPwSZ/0SbzmNa+53c+fP3+e//Sf/hMPeMADqOuaq666iq/8yq/k9OnT83tuvfVWvvqrv5p73eteNE3Dtddey8/8zM/c7rPOnDnDV3zFV7C7u8uJEye44YYb+Iu/+Ivb8S+e8pSnsFqteN/73sfjH/94VqsVp06d4lnPehYxxos+84M5KIeHh3zLt3zLfLyXX345n/u5n8uf/dmfXfRzf/RHf8RjH/tY9vb2WCwWPPrRj77D1sMb3vAGPvmTP5mmabj66qv58R//8Q99sj8orr/+ej7+4z+eP/3TP+XTP/3TaduWBz7wgfzYj/3Yh/3ZN7/5zTzlKU/hQQ960Nwe+aqv+irOnDkzv+d5z3sez372swF44AMfOLcrbrrppvk9P/uzP8t1111H27ZccsklfNmXfRnvec97Lvpd2+2Wt73tbRdd049ULBYLTp069SFbUt/8zd/ME57whPm+vSvxtre9jd/4jd/g2c9+Npdeeil93+O9v9OfyTlzcHDAnQ2uv//973+XuEY7Oztccskld/l4j+M4/l/iOEE5jn8xMW1WJ0+enF/7q7/6Kz71Uz+Vt771rXz7t387L37xi1kulzz+8Y/n1a9+9fy+9XrNIx/5SF7ykpfweZ/3efzQD/0QT3/603nb297Ge9/7XkBaLNdffz0vf/nL+Y//8T/yohe9iL29PZ7ylKfwQz/0Q/NnpZT4gi/4An7hF36BG264gRe84AW8//3vv4jHcGHEGHnMYx7DpZdeyg/+4A/y6Ec/mhe/+MUfFgZ/+tOfzktf+lK++Iu/mB/90R/lWc96Fm3b8ta3vnV+z+/+7u/yqEc9ioODA5773Ofyvd/7vZw/f57P+qzPuqgl8Jd/+Zd83ud9HrfeeivPe97zeOpTn8pzn/vci87Rh4tz587x+Z//+Vx33XX8wA/8AFdddRVf//Vfz//6X//rTn/uta99LX/3d3/HU5/6VF7ykpfwZV/2ZbziFa/g8z//8+dN9Yu+6Iv4D//hPwDwP/7H/+DlL385L3/5yzl16hQAL3jBC/jKr/xKrrnmGv77f//vfMu3fAuve93reNSjHnVRgvDHf/zHfNzHfRw//MM/fJe/1z8kDg4OOH36NG9729v4zu/8Tt7ylrfw2Z/92bd73y/90i/xxje+kR/4gR/4B33+7/zO7wBwr3vdi8/+7M+mbVvatuVxj3vcRcnahfGgBz2Ivb09dnZ2+PIv/3JuueWWf/D3Oo7juFsiH8dx3MPip3/6pzOQf+d3fiffdttt+T3veU9+5StfmU+dOpXrus7vec975vd+9md/dn7oQx+a+76fX0sp5U//9E/P11xzzfzac57znAzkV73qVbf7fSmlnHPON954Ywbyz/7sz87/No5j/rRP+7S8Wq3ywcFBzjnnX/7lX85AvvHGG+f3xRjzZ33WZ2Ug//RP//T8+g033JCB/F3f9V0X/c5P+IRPyNddd91FrwH5uc997vz3vb29/A3f8A0f8jyllPI111yTH/OYx8zfIeect9ttfuADH5g/93M/d37t8Y9/fG6aJv/93//9/Npf//VfZ2NMvivLxKMf/egM5Be/+MXza8Mw5Ic97GH58ssvz+M45pxzfte73nW7c7Ddbm/3eb/wC7+Qgfz7v//782svetGLMpDf9a53XfTem266KRtj8gte8IKLXv/Lv/zLbK296PXXv/71tzuPHyruf//75xtuuOHDvu/CeMxjHpOBDOSqqvLTnva03HXdRe/Zbrf5fve7X/6O7/iOi47pl37plz7s53/TN31TBvKll16aH/vYx+Zf/MVfzC960YvyarXKV199dd5sNvN7b7zxxvzMZz4z/9zP/Vx+5Stfmb/5m785W2vzNddck/f39z/k71gul3fpe//SL/1SBvLrX//6D/veC2N6ft/0pjf9g37uOP71xTGCchz32Picz/kcTp06xX3ve1++5Eu+hOVyyWte8xquuuoqAM6ePcvv/u7v8qQnPYnDw0NOnz7N6dOnOXPmDI95zGN4xzveMat+fvmXf5lrr72WJzzhCbf7PRP0/eu//utcccUVcyUP4Jzjm77pm1iv1/ze7/0eAL/5m7+Jc46v/dqvnd+nteYbvuEbPuR3efrTn37R3x/5yEfyd3/3d3f6/U+cOMEf/dEfcfPNN9/hv//5n/8573jHO3jyk5/MmTNn5u+/2Wz47M/+bH7/93+flBIxRn7rt36Lxz/+8dzvfvebf/7jPu7jeMxjHnOnx3BhWGt52tOeNv+9qiqe9rSnceutt/Knf/qnH/Ln2rad/3/f95w+fZpP/dRPBbhdu+qO4lWvehUpJZ70pCfN3/H06dNcccUVXHPNNbz+9a+f33v99deTc/6IybW///u/n9/+7d/mf/7P/8mnfuqnMo4jIYTbvcd7z3d+53f+gz9/vV4DcMUVV/Brv/ZrPOlJT+JZz3oWP/mTP8nf/u3f8vM///Pze7/5m7+Zl7zkJTz5yU/mi7/4i7nxxhv5mZ/5Gd7xjnfwoz/6o/9vX/Q4juOfIY4TlOO4x8aP/MiP8NrXvpZXvvKVfP7nfz6nT5+mruv539/5zneSc+b/+//+P06dOnXRn+c+97mAcEpAeCsf//Eff6e/7+///u+55ppr0Prix+bjPu7j5n+f/nvve9+bxWJx0fse/OAH3+HnNk0ztyqmOHnyJOfOnbvT4/mBH/gB3vKWt3Df+96Xhz/84Tzvec+7KKl5xzveAcANN9xwu+//Uz/1UwzDwP7+Prfddhtd13HNNdfc7nf8m3/zb+70GC6M+9znPiyXy4te+5iP+RiAD9l+AEkkv/mbv5l73etetG3LqVOneOADHwjA/v7+h/2973jHO8g5c80119zue771rW+dr/E/RzzsYQ/jcz/3c/mqr/oqXvva1/LHf/zHF0l2b7rpJl70ohfxghe84E7JqB8qpmTuSU960kX34ROf+ESstbzxjW+8059/8pOfzBVXXDG3io7jOD6a41jFcxz32Hj4wx8+q3ge//jH84hHPIInP/nJvP3tb2e1WpFSAuBZz3rWh0QCPlTS8M8ZdyT7vCvxpCc9iUc+8pG8+tWv5rd/+7d50YtexAtf+EJe9apX8bjHPW7+/i960Yt42MMedoefsVqtGIbhH3vo/yTxpCc9iTe+8Y08+9nP5mEPe9h87R772MfO3+HOIqWEUorf+I3fuMNz+Y9JBP4poqoqvvALv5Dv//7vp+s62rblOc95DldeeSXXX3/9nLR94AMfAOC2227jpptu4n73u9/tkuAp7nOf+wDCQbkwjDFceumlHzapBbjvfe/L2bNn/x++2XEcxz9PHCcox/EvIowxfN/3fR+f+ZmfyQ//8A/z7d/+7TzoQQ8CpA3zOZ/zOXf681dffTVvectb7vQ997///Xnzm99MSumiDeRtb3vb/O/Tf1//+tez3W4vQlHe+c53/qO+253Fve99b57xjGfwjGc8g1tvvZVP/MRP5AUveAGPe9zjuPrqqwHY3d290+9/6tQp2radEZcL4+1vf/tdPpabb76ZzWZzEYryN3/zN4CYdt1RnDt3jte97nU8//nPv0hqe0fH8qFUJldffTU5Zx74wAfOiM1HS3RdR86Zw8ND2rbl3e9+N+985zvne/PCeMYzngHIOflQPi/XXXcdwO0MCcdx5PTp07dD4j44cs7cdNNNfMInfMI/4tscx3H888Zxi+c4/sXE9ddfz8Mf/nBuvPFG+r7n8ssv5/rrr+fHf/zH79B86rbbbpv//xd/8RfzF3/xF3eoWslFSfL5n//5fOADH+AXf/EX538LIfCSl7yE1WrFox/9aAAe85jH4L3nJ3/yJ+f3pZT4kR/5kX+y7xpjvF374/LLL+c+97nPjIhcd911XH311fzgD/7gzF24MKbvb4zhMY95DL/yK7/Cu9/97vnf3/rWt/Jbv/Vbd/mYQggXSZPHceTHf/zHOXXq1LyxfnBMiEf+IAnsjTfeeLv3TonPB8t2v+iLvghjDM9//vNv9zk554vkyh8pmfEdtZHOnz/PL//yL3Pf+96Xyy+/HIDv+Z7v4dWvfvVFf777u78bgP/yX/4Lr371q2/XJrswrr/+ei6//HJ+7ud+jr7v59df9rKXEWPkcz/3c+fXLry/p3jpS1/Kbbfd9iGN447jOD6a4hhBOY5/UfHsZz+bJz7xibzsZS/j6U9/Oj/yIz/CIx7xCB760IfytV/7tTzoQQ/illtu4Q//8A9573vfy1/8xV/MPzcZT33VV30V1113HWfPnuU1r3kNP/ZjP8a1117L133d1/HjP/7jPOUpT+FP//RPecADHsArX/lK/uAP/oAbb7yRnZ0dQNpND3/4w/nP//k/8853vpOP/diP5TWvec0Mq/9TzLY5PDzkqquu4ku+5Eu49tprWa1W/M7v/A5vetObePGLXwwIMfenfuqneNzjHsdDHvIQnvrUp3LllVfyvve9j9e//vXs7u7yq7/6qwA8//nP5zd/8zd55CMfyTOe8Yw58XrIQx7Cm9/85rt0TPe5z3144QtfyE033cTHfMzH8Iu/+Iv8+Z//OT/xEz+Bc+4Of2Z3d5dHPepR/MAP/ADee6688kp++7d/m3e96123e++U5PzX//pf+bIv+zKcc3zBF3wBV199Nd/zPd/Dd3zHd3DTTTfx+Mc/np2dHd71rnfx6le/mq/7uq/jWc96FiAy48/8zM/kuc997j8pUfZxj3scV111FZ/yKZ/C5Zdfzrvf/W5++qd/mptvvvmihPYRj3jE7X52Qks++ZM/mcc//vF3+nvquuZFL3oRN9xwA4961KP4iq/4Ct797nfzQz/0QzzykY/ki77oi+b33v/+9+dLv/RLeehDH0rTNLzhDW/gFa94BQ972MMuIjMD/Oqv/ur8LHjvefOb38z3fM/3APCFX/iF/Lt/9+/m906v/9Vf/RUAL3/5y3nDG94AwH/7b//trpyu4ziOuxZ3l3zoOI7jHxt3JlOMMearr746X3311TmEkHPO+W//9m/zV37lV+YrrrgiO+fylVdemf/9v//3+ZWvfOVFP3vmzJn8zGc+M1955ZW5qqp81VVX5RtuuCGfPn16fs8tt9ySn/rUp+bLLrssV1WVH/rQh14kmZ3itttuy09+8pPzzs5O3tvby095ylPyH/zBH2Qgv+IVr5jfd8MNN+Tlcnm7n3/uc597O3kvF8hjh2HIz372s/O1116bd3Z28nK5zNdee23+0R/90dt91v/9v/83f9EXfVG+9NJLc13X+f73v39+0pOelF/3utdd9L7f+73fy9ddd12uqio/6EEPyj/2Yz92h8dxR/HoRz86P+QhD8l/8id/kj/t0z4tN02T73//++cf/uEfvuh9dyQzfu9735uf8IQn5BMnTuS9vb38xCc+Md988813KAf+7u/+7nzllVdmrfXtJMe//Mu/nB/xiEfk5XKZl8tl/tiP/dj8Dd/wDfntb3/7/J6PlMz4h3/4h/MjHvGIfNlll2VrbT516lT+gi/4gotk0h8q/iEy4yl+4Rd+IV977bW5rut8r3vdKz/zmc+cZe5TfM3XfE3+t//23+adnZ3snMsPfvCD87d927fd7n05H8nd7+jPB9/fH+p9d3U7OZYZH8ddDZXzndgLHsdxHMc/WfzKr/wKT3jCE3jDG94wz1L5lxLXX389p0+f/rA8nntSPOABD+DTPu3TeMlLXkLbtnfaejmODx/jOHJwcMArXvEKvvEbv5E3velNM8n9OI7jjuKYg3Icx/ERiK7rLvp7jJGXvOQl7O7u8omf+Il301Edxz80XvGKV3Dq1Cm+7du+7e4+lHt8/Pqv/zqnTp3iG7/xG+/uQzmOe0gcc1CO4zg+AvGN3/iNdF3Hp33apzEMA6961at44xvfyPd+7/deZEx2HB+98XM/93Nzonnf+973bj6ae358xmd8Bq997Wvnv/9DPHaO419nHLd4juM4PgLx8z//87z4xS/mne98J33f8+AHP5iv//qv55nPfObdfWgfkfiX2OI5juM4jrs37tYE5Ud+5Ed40YtexAc+8AGuvfZaXvKSl/Dwhz/87jqc4ziO4ziO4ziO4/goibuNg/KLv/iLfOu3fivPfe5z+bM/+zOuvfZaHvOYx/yz2lIfx3Ecx3Ecx3Ecx0dn3G0Iyqd8yqfwyZ/8yfPY85QS973vffnGb/xGvv3bv/3uOKTjOI7jOI7jOI7j+CiJu4UkO44jf/qnf8p3fMd3zK9prfmcz/kc/vAP//B27x+G4aJ5ISklzp49y6WXXvpPYnp1HMdxHMdxHMdxHB/5yGX0w33uc58POXNqirslQTl9+jQxxtsNvLrXve41zzW5ML7v+76P5z//+f9ch3ccx3Ecx3Ecx3EcH8F4z3vew1VXXXWn77lHyIy/4zu+g2/91m+d/76/v8/97nc/HrRcgMqgFHH0VK6idhbvPYlMVpAx1NbhlIEU0Rm0VmxDT5cCq1Mn2bv0EprVgrqpqFzFtt/S1C3d0LNYrBj8SFVVGGtwtiLFiFKgtME5ix8HFFA5R13X5JwZhoG6bklkxrEnhBFIqKwIIULWgGa7HdFaE2MgxRHfD2ijOXf+gJtvOcPhess4elJOaKXIGWJM5AzGKLTW5IycgxhJSTp28m8Gay3GGLwfCTGgy+taK0CRyYQQ0EpTV5VktOIJiTYOcib6ABpyTqAUuqBWMUYAlNaQMzlnlFagVXldoVCkJO/LpPn4IKOyfB+FfI9UTCqVUmilUUoRU5TvG+V355zJ04RbJddSaz0jaRdl5KV7mXNGTpGa/z2mTNaKDEQfySmjURijMFqhUWijUSqTciLliDHmaLpunv4jx5tzLveFnn+nq5wcJJkYAsaYMitGy/tTknN2AQo4fb7WZj6nWmmU1vK7ynedfj6mWK6zlnOdMzF4tDF4H0BptDJyuFmueIyRECLWaGI5BmM0Wiucc4QQCD7KOUpgrcZYU+618ntzmq+VolyvlCFneTYUmHLMKcf5O6Y0/bsBFPIjGaUNxlpyVsQY0FrTWoNTmUqBImCcxjmL1ooUIgrNdgxsB0/ISs4NGWsUYRzl3BlNTHJfTfdnzgq0IYRATJnRy2Wq6nJ/ZZkRFEIkRUCXe15BCAmlwVqDMXJOQohAxlkL5Xlivv7MwyW1NuV+mK61PBdaGZRWaK1QKhNjgowcewzlPGtyiigtv5OU5J4o94DRcjwxRmIMF9yH4KwjpzSPGxjGAXvB+4+ei4zWGu9Hua7lmlkr970xBmsNPgZiTNR1RUrl+5Z7PoSILefBWou1Cu8DVdvgvcdoRW0NOQbaqmK1WJD8iFEZ5wwqJ5w1aJ0JYWQYRzKZ5WpFzpmuH0BpQgyMIcqaoRQhRqwx8hxrgzaKoe+x1lI5xzh6KmvRClY7K1KIpBjRRlPXNX0/yGf6gLMO7+VZrlyFD4EkDyXeJ/w40NSKE7s1n3X9p3Lv+9yLP/u/f8Vb3/Fu1h3cdv6Q7dYTxowxhqq23Ps+l3K/+1/FX/zlX/G+955hHDSLxQ6ucmy2HdZalFKM44A1iiuvvDf3vuJetK3jxN4OTeVYbzb048gwemJMLBYNOWaa2rGoGzSZqnWAZme1x7YbOHvugJTh8HBNs1iw2llyuN6n70ecq2ials3mEKU1Qz+ws7ODVoqQ4rzObrstbVPTVA1D3xFDpGkc3gcy0PU9bduQglx/H0ZWiyXDMHLuzHn67RadZbp3HD3bruMtN71nHg1yZ3G3JCiXXXYZxhhuueWWi16/5ZZbuOKKK273/rquqev6dq+3rkIrys1jaasGpUDn8pAbhQ+ZGCKKRGUNlbVAwiZDbTT3udcVVKsFy70VdVuz3m64bHUZMUZOnDwBxtD3PYvFAucsSmm6rsM5hzUG5xzrg0OapqaqHMMwEEOU40qyKRkFg/cYIw+rVoa6qcgRqBMpZ1RdY1XF1kBKkHIkE2U9Kxt2TgmtDSnlstGVnYBpMclAnBfDnDPj6FEqkPPRw6wUxCgbTcqJRMaqzDB6lNJMH2Uic1Kk0SitJFlQZVMui21OmVQShxxAGVnoiJSHbpyHwsE0i0aRsiQCqiRZKcpmKYtySTYUkBUpKUmQYN4YpveGGMprihQjOUsylcvmJwu/KhuFwRhNShBLApBjhgxJTclKwholiV3wxJQlcTEXJhRyHuU45RyNY0KVc5NSIk2JSM7EkDDmwgRNNo9p45O/Z9nAAW2ynNcoG6ZS5f1aofR06RUhJLSOGKPneyKliFKSrBqriESCl+uvy8VNZdOOMYOiJIeJlHVJfEBhyERiguQj4i4PIR0lwlqDypmcIlopnDFYLfeKUpBTJCV5n9YKYy68/pTraUEZSRxQKGVIMZDJGA1GRVaLisWyYbvdYrQlZNkAg1OstwM5W4YhyXmwmpwdKUdCzIQgCRgASRGiXKcQJaEzzmKsJpPKPSYJRVXJdTXaoJQmplDuC1Xu/0RKCWc1tjxvKUWa2sklLYkkGbkvdMZoua9QkNJ84cmkOXWxJksySkZbhXWWnBI+gNEZrTM5lnPqLDFqck4Yo7BG/q7Q8304JWpTArJo25L4qpJkyPeYEhVJnKbrq0vCAZAJMchzZBSbzWb+d2MMwziScgKVy/OeCCFjncUYKcaUM2jjqFxNW9dU1mBdTY6exaLFaSmuhrGDlLGtw1rDGHpiAmvkWtRVhRkGhuBJKVHZcn2NpnYOYw2m3OtD37NcLmiqGq3AakVQmbqt8X7Ejx3kyM7OilTu1xQzISSyUjSuIivNGAI+RJq2YVFrFJG6cuzsLDl5cofFouHM/jlZzxQoo0nleTHW0CwbtJE1u6orcs54P+KcrOkxxjmpM0bT9x3b7QHOaYZe4YMnK8PoR7Q2KG2JcQSl2fY9q+WCmDL90OGjFAGqrBOXnrqUuq45ODxEa83e7i7OVXNxWjkpRhdtQ9f1VNaWAgfqumKxWDD0PXsn9iAnxmFAW0vf9/M62I8DTdNQ1xVD36OU4t73uYIzt51GpYxRmmgd2tkL9oE7j7slQamqiuuuu47Xve5183CslBKve93r/kE+Ear8yeXCKqXwwwBZYYxljIEYIzlHMorKaBQQk1R/q8WCyy65hPPbNU1dY6sKGzwf+5B/y80334z3Xh7oRQMp0W3FtKnbbIhVBYBzjnEc0Rq6bsvQ98QY8d6X31MuRJZqKYWI0ZqD8+fZ2zuJBmJOhOAFDSKhjaZtGrRWBO/RRpWNKs+oRZ6+h9IXbMbTTannDWiqeOVnFClNm/cF3GilCVk2GkU8QkNUkMUZUFEerJTTXDEZYwTliPECZCGjNVhnSnKgCSERYyKlsheXzVahZzTmg7na8vtzSbZkoY0xzn+PMZdrK8cafJDkVOuLPm/6r3yGnF9jBK1JZfMQNEtCl41s8BFTEqYMhJiJpRKWBDGW7wDGTq+p+XflrBm93GdpSjSYkpBy2hVEPuh7l3/TU8U/3+glscgZleS7GKPICcqlnjeZmCj3kiQWcsIl2csqo1CgkmyJBZGZruMwhnINDVAQJCDHJAhJSVinrColMNN1zIkYEuRcNvHp/MvPSIJNSRINSSliKElVLolPFJSnMhqrYWfRcMmy5tITK06c2OG2M2dpF0uqqmUMiZs+cAvnDjaMYyDjiEkzdh5njezgwJgjjIIYWasRgEKemZQhhUDOdk6i5DkJ87OrtMZpqCtBIqbkMJXrWVk3owzTPamUmhGKUcm9qlBYa0rSlkkxgMpzAjAt2JJYSPKtjZZkXGeq8n20Zk7qnROUdBxHQgg0TYMxch9NqMeUzIcQ5tfkPkn4guypgkIQ45yQK12e+YK6TclOSBHr7IyK+BTBaLQ1svmnSEiRpnJopWUtLDd2DBHnLK6gkSEEfBiorSb4keXuEk3CmJrKGcaxA5XRKuNjJGaARPKeVNYQBWilGYZBkixblfVIkWLCGItVsqZutxu0opyrGu8zMQWMsRijcK7m8HAjBQxJUJks75H7PWFKhZCSYvCeYRhZrnZomoZxGMjKEVMuCbgUQEPw9MOANoKW5SQIrTGSMIfgy7WX67nZbEgxsFw2nDt/npwTIco6qrRm0S4ZR0+OifV6g1YKbSw+COK0HTw5QdcNWOvYc26e6q1UZjtuqGqPUoqqtoII2oZ+6HCVJaXEctXSNKUoMIa6ksR7ve4ETSuJdswJV1VUQe7/mOU+tNailZFhmDmjMjhjGUOAN/81dyXuthbPt37rt3LDDTfwSZ/0STz84Q/nxhtvZLPZ8NSnPvUf9DkxykMGEMcww8rWWHSWSslqPeupU0p4L1W3DZHz585xfnPIcm8HlwLOOU6cOMGtt97KweEBTd2ggMP9A86eOSMPsykLXEps1rG0fizr9ZphGErVJIv5BJmvVgv29/dp6goFNKohpUBd1VjlGIMnh1Funm7DGAbIGR9i2RRTSa6OIPQJIYCCFChJJgTRiPNmC9Pil+cN/ShKmqeQDbZsKEp6OgWSnzIKuQEpm/a0IU6fn8uOnYEQpA2WUiKnUo8poEDP6gKoe/p+0+I5HePcTigwtLogmbkw8YhxOgfysKgpc2XuxEjLrxxDiGn+9xkuUtIikXM6Vfj56H1ZUAatKd/r6POn0zn9dzpnMWZyLueoZBqSQAmSktPRcU6HovTFraick1xPpjaV/ExVWWKUSpZ81G7TRmFVuU805ZrLppaUKvdHLHt3vqBqTkwY3JSIai689mpOmKYNb7oW05nQRst2kdOcQGltUMii6qxU7ABV7XBVzXq9ZduP+HEoaI5GZdkYKmPZWTZccnKHk3srdndX7OztorRDaQfa8q4PvJ+UpeWkjAWtSCHjo8eU7zYhECpLJleVilXaipJEOmfKuVVyTpFEyWiFtbagahqlbdnoIzlJGwtSudbTczkVEnL/OmelyEiJruvQWgqbupFWiLFWEqILEorKNZJ0REFtlLbzfa+1wRonyBMQw/ScjOSc5qQvl+8bYiCEUJ4hjfdSuFlnS6IiaJ20qqYwWCXnx3tf2oAG6ywac8HnqYLkyd+dc3OBNo5jQQgVOSLVtbPlOZP7pmlqDBZywDrLtu9wRhXEN0p7TRtUjNStY+ihH0Z8CNjKUVXVUftJGyrnSCmx7QZSStRNzYkTeyQf6LoeraWlo5QijIGcEjurHUAStBBkPSdmum1PP0riYIzFuHpuY41jZrFbzwVhXVW0ixbrHGlI0rrZ9KU1mwjZUzWWdtmSkXNqjSNnPSe0R2s0BSmXNXF9uAEtrWGUJodMjFv6bixJUUddV2jT04/lOzYNxli00TRtS9/3ALRtLYlzEsrAYrGQlp+xOOcKcliBUhweHLBcLGjbGlLGh8BmvWa1WGCt5cy5c4QQ2dnZxVU1fpQEmJxZLBbEGOm3A845jNZz0d77nrsad1uC8qVf+qXcdtttPOc5z+EDH/gAD3vYw/jN3/zN2xFn7yxSiuScSsWay0W3JYuWBd0agxEMW/aCsueoDClGzp85S9IKpw3DMLDXtjhjZ4tr6UV7qXYK7Gq0lChdt6VyFc5aYvCkEFBlQzLakgs/Yqqk2ralqSu897hKMw4jjWnIObFctlR2yeZwTYwJZ0ds6RlnMlGKFPl7PtoM5/2DAiMztUKO0Bb5mfxBmzIXfNi0U2aOtpt8dLK4APlIaf6lU2+d+WOPHrILWxlHH8C80M0pSnk4rRXu0IXJyIWVaCqol7XCrdClZz8lVxfkANNXoazP01sEdp3+O+ViOReuzNHpSciCjRJ4H5VJsWzgWf5rClVHOBhlgdHTdSntrrJhKVVaFUaq8VSqW8mLjpIurRRTeiiJWiJmhZ4RGvljtMK6qSUhSZr3cgxVJRyNcCGqRanCUbJRm7lHVI4fctagDGrmx0RSiIVjM50nOcFawYWXN+coiQsGrSHHcv7KBjrxIxSy0OccqSrHcrVAKRiDZ/SJ5BOKOLeGKmepa0NWmXW/YYierDRZGbadVNBnz+8zhoSrDZGMVomqFr6GMQpbGYwy6JTLszmhEEYSKjW1BSWhN9aANtJmzAlyIueItH0UdVURtGIYsiwiSp6flCeuibkogZO1QNqmxlmktRPLNZS2pHUWsHNLJsYIKmOsxtXtfP/HIHibLt+h23alhRoIpZDp+wFj7Hwdc0FuFeU4tCZrSUCnAkBaCkYQpQtaPRN6OH2PlJI8B9agtRHkYLEgkwuKrC9GOtW0vhw9xxPSPbU++2FAE6mdZvSenCNm2QCaYRA02jnFGOS7jP4IxQshYaw8h957WVedwznHblUxjp6h7zk4v09TKAJt25JSFJ7JOLJa7cxJ6pQYqCRrgjaW6AOuqqRNGwVpiT5CVmhlSEHWuqqqSsvfYDzUtaHrRtAKZSAkj7KCVmSExyR8qHRBS21qRedSJ6rC80i42uGsYxi8PEMJurFns9lCziX5smRV6AClyKrruqzVEYXwCStrSTnR9QOLRUtT18QobeLFomUYRqy17O3tYp20cbwf6bsOP44o55ha46vlCm0M6/V6LlybqqbvOrTWjONQuH2yv3Zdx1ha+Hcl7laS7DOf+cz/J+tvPw5C7KtqjLaQMqZUviklVC49/pjJMaKMxjiNMpZEwmoj/JHVAl0g6BwT0XvGfpAEoq7ZbjaMfqRtaqw2+OTJKbK7s8NyuaKpa3JMaKR9NVXPfd9jK4cxhq7flmmoQp4z1lDVFU3bkGIiBGkhmULIq11F0zQCt2UFwcsGk48QFKDwDaS/rEpSIa0R2cBTWSDStGFPWdocF27NF0YuG26plKf/uWDxmpKUi7IljrgZ8w9Ox5unZKsQ85RsdkpNx02pbMFaO7epjJk28dJ3V0fHrxRM9JYLk6WJ7DglDFor9AWvGXuEkuQkHApJKNTUHSloQfncwofJKUlFjSS4E1FR/pvnynzaiI5IyxQOR8RZgXjlvMi1y1nN33/aDCkV/HS+lVLEEFBAyh5thFthtAV8OQcJYzXaqFKdyUma94okSWzKiYmcLJuecD9mImyAZBU5Jumha1s2NTnnIV/cspNzJccbU4YkLpDSTjzasLebDusMm/WGruswRlNZhVnUbHIvC71KNDazWtUkAmf2z0orIGXW6452sSSExGbbM5JwjUG7mlAIklYZyEdIn1aAAaftXJnGmFAp0TQNVJpxTDMZOGaEG6WEr6aUILWkSAwjOQkCYkurIMbC77ogrHPCkQlBuDnWFQ4bpFwQ31L0NLWT+9NofAz03TifU+FvWLbbLcPojzb+lNAlAUzZY61DaU2MgxCfk9xDmuk+0jjr0KUVdSEKORUExliUOipqlJKfTtLMkmNOiTxK4tvUjZyX0oqd2ltTUaZzmv+/smZGWkgKZwR1mHh8SknB1zY1GXl+6mbJMA5EICZFxpByYBg9PkRaJ985+Ujf91SuQltBNIyxjKPnxMnSRo+B4D1+HAFpy01tL0nCdUEipVhbr9ekch0zgp6qQsS12qHIeB842D9g6C8rrWd5duWPkXVHgasMiUjXd9ja0DQ125DIKZb1VJV1QM3nz1pbuE9HLfSUM33XAwpjpH0WUyT4wGq5ZLPpOFwfctmpS8gZ+r5nd2eXYejleiiNH0ecFWTFOYvRiqqq2G63xBgYx5HtZi3tGWOgk+TTaI3KEENgPQzEmKhcTb/tGWMQ1DBFgvcM2uKHQZL5Qf7NlX3Rh3DH282HiHuEiudDRVvVQtwsMGq9mMhkQSoZVVQTKclDlgUpU8ZgsyF6zxBGnHMM2w5ViRKh6zpSjIzDQAgNdVNTO4fverq+QylJRE6cOCHJC4lFu6JpGtq2RSlVyLKB4AW6zSHSdR0hetq2YegE+hrDgKYQN0eBe9u25fxhhx/LhY+UaldjzKT+kHOglCzASUkLRl4rC7PRGCVVjc65kG8zF66lE2HxopgQCaUuWsiAskCWTL9A2RdWWRNHRKlYFq8jxcMEfcdY2hYKjDMoPW32wj2Q/nqc8RxBwkrVX+D4CVExWmMw87GpC9paU1U0b+4lMRLSoJorseijnL8slaagMaVHXJKNaQEWUUfhF0ztLaPnytx7L4oYo1HKklMkpijcg3xUXaZCpjUFlZiPOANKFvWMKDQyUdqUpd0A0sudzqc1prQtIilFrJWkXa5dYuLGpJI4pBjIpQJU6uj3SztJqjlboPWowaRMXVeEEAs0rBnGTKBwSoy0UI2Se8MoWVitsaScCXNVXRKilBkGT0Z+V1U5louWcRgwKtE2hntduuTSEyfx/ciZM2v6wbPpPRHYrjc4W6GcQ6tEYww+ZSy6kHSFFzMRHWMCdELpieBaCKMKtDniDCmdSckz+lhac2DK/atyIpS1hQzO1WDKPVGQKoHI5fpoo7GVIytJdmwhMfswFq6Do6osKQdR8KUMUR7muhGoPfg4P3spTTwrU9pzGl34YDFnRj8CHCEh5MJPEvKytVbu4RDwpR0zKQ5jzngfIcm5kaKnJCQl6XDV0TPsy4YZgrTKlTpq0xpjpEVAInpZe6c1w1qL1QqrJUFpmgZKgpABU1Uo6xh8lJZXhmEQpUg/BJSSlndG0ENK8hNipK4bdnd3ZN0OHhUSVdWQYmYY+0KSlqKxrlxJjqWq14XQi1b4kHBVjXVyv4eY2Nndpakbus2G9bpHZUXMiRRg7EdSSAVZVbR1zbof8D5KGzYFhmEkxhpjFMvFQtqtKRKiIGnaWJQyc/EkRNO6tGL1zDlLMbFa7RBCZLvtGPtxbstobWa+YAqZMRVRxjiKh1jK1FUlSpoYURkqaxmHAV8Ub3VVsT44mPkj58+fZ7FY0FQVRhuGrieMvtAkIjlmNtstrhB+Qwj40TOmAVO4R0ZL9yCnRNW2BY2akN0PH/foBKWpalnAUyYFkVROKEjICh8DCmnf6FLpTix0lPRmp566H0YUllgqnqauOX36NF0lCUPtHGEYqCoHWuDS7WbDwf6+tCdGkaH2fS9yw9Kvlx62oa532fRSPcYkD4OppAettcUpSw6e4OWGPtg/lIQmSH/bGOG5pJwhBoHQOaqGYUo2JBFRBSmZNucpw48pzzJlSW5EJjqDK1M1XDLulEIh45YNqJAqJ7JoIM8boZqqgbK5iVpGqnx5MKRilBaPyHKNkUUmFdXHxDOJUVFVZl74RO9ZECRtBIEgl95+LkiKmjfcXBborHKBPCUBsVZQBaUVCdm8a9fIYh5LpZjyLKmU6rlUWVn4TBT0TSOKGTlXkkhVtsJekEBJxR6w1pFSwHs1K0qOZKqFkKmnercs+CRiUvPrKSfqupE2ZkmkxlFY/CYbjLNF0ivES6lqjpLZnEClWJBHqealwjflnIo8PidwlcVoTQiKrKzcy5Utx5ExeiIBgrZTu65U/UpaALPSzHupQAuEjVJSOVcV1ipWy5bdnV0qI3LIvZ2GK+51KcvFkjOnzxEURGswrSHFDFlh6poYIqZwa4xKQvJEyKgpRnTWVMYSVCYqRVZiPWCsQdtCmEdUG2qS0aOorUO4G56UAilNV2V6RiYeVRKyqD4ihLu6IeWMH0e891BamjkmEhGrjVTf4yjtOKWorMD+gx+wxuG9p+9F+6yVwVrFZEsA0iLMKRJylOtXnskp+Z1DSTvIXkBmV0YXxEKuRT+O5bm9mPs1JUbGmKI6yuX8ytoQc2Lw48xLmXg6Pnh8HMTyoa4lYfAjyY/UdS2JWvSYnFEpYXLGJQ1GnsnBC2odU2IYeryX5AOTCD5ibSXJ/zgKSjAMjN6zWizoth1dt2Vvb4+mXqCV5vy5cxijqOqaMEIInhATm8NDmrahbho2262cJ1czhMC2H+W7ZgVa2iUxRmKQ6xfDVMgUZBOKRD7jnKNpFYfdgSRPKRRkYqBuHGajCNHL/ZSTFDFl/TRGkLQUY3kOIzGWln1Upa1Ukm4fC79JkLrJOmDRtJiCmDauoVtvCiellmesquj7Hm2kmMrA5adOzfeOUkoK762cx5wTYz/gBRKmtiLZDjlgSzEdYiCGgLMWozTOyH2dUyKFNKNQzjnaRUvXb+/yHn+PTlD6GAlRTvLox9K7RdaSFEqrB0Yli5YmY6fKSWtMVRGTp+s6zp49i2sbmnaB05Yr73Mf3vu+984ITN9thfU9CkzVVA0hBNpmQdM0NE3LwcEBOzvC5k5Jsl0fvFzEEDAbx+FmjSkogVFOZJFJ0Q+ebgh06y1nz+zjQ/GnUEJ81EYWxByTSKVzks1n8kwoSZNwTaQ9oyneGVOlX9o+pshilZpgXD1vYlqrOUlRSmGsxSTp3VttpcqGwm5PaFWOg4JglJ1q5mPk8l3NxN2YFkIFrniOGGA6hjxtqBmjE9YaUV2UHpX4tGSwQoRQRmGtIwRPVlL5z9B1kR4aaxG/F6lchfsh/hXBB5wz5BDBmtIOi4XIKN/He+nrhphn0rMoJRQxaaoim5s2KaXAFba+oDHTOZD+dS5tA2eFYzQW/oirahTSd4aMjwXuNXZWHrVNjXMVfS89XoVUKBqF1qKcSCkS/Fhg4qIASwIfKq3Q2bBYLPDBE0KRo0aR2zaVIRblgzFGjjdnfJFyA1KxVkaUCkm+iyoI09TOuJAfo9yFbQVh+FOaB21bUdeKuo6cunzFcmW45MQuJ/dOMAwjXT8y+ESIoIyj1hoffGmTCC/DOkfTCLdLKTAohlG8kAR5S5JYFsL8dLML1yUXHxFFDAltDFVV0/c9GVH8WG2obM0wjChlaJqGyjp8GNEhkPWE7gkSmJLIyq01sqlqQ0yRcRwwVlE5i9LIOtLWGGupmwo2MHrP2HvGIQqJUmn86AvqJ/fulFTCkQeP1gpjq/KaxpWWjVFKfp4j7gsckaqdMYSYCulXFamrEbVeyhiVCwKqCX0va2oQBM6WtlXbNsLTSpFMIKaA96BdRcxR/KgkqypAhaapHDurFYSEKMqkTeZTojGW4D1YR44wxMS295Aybdsy+IBS0vpKYcSgGboeawzLdomi+KR4D0YRgf2DQ7wXnszSONrdk4zDwLgdca5FaUs3BjIWHxMpCQKAiqT9NW3b4GxDa6zwTsJASp4QPZFYCjKxobCmeBUlSSyFrA3WgdSu0pYPxTfJGDnfxuSCTgslwWhKQaQZ/MjWd7TNEpXFeqOqqpnwK5y6XOwp5NkbfE/T1kW6LLSGwQ+EFNjb3WMYRdDRLhfS6sqZmBPGWeq6YndXPFHOnTnL0A9Q1zhX0CenC59OEKC6dqQs7SBynNV8wzBS17IfHhzuY6zBlnXvrsQ9OkHZhFEIbkogzZTjTK9QhSSU0fgk0tLaWrDi0eBjLN4Wlm7oOdg/4F47K4w2+H6grRtWy+VMulVzz05DP5ZeIKyWK+qS8U83y4UE267r5tdCioUXI8yuYTvQti2H60P29w/o+5Fu27G/f8hm08lGqJFF0kqPtDITWVZUESmpskloQVgSOLhQOcsk00VNxKw8JyfAjC5MEMp0s0/QrQh3cnmwCvJipCI202ZUNl2pkIUPI6ZNAj3GlNCVJCfDIHC0KDpyUSpM5DnZuCe1lbWZxlYY3cyEu1wQk1h6n8vVgn4Y6Ia+tCbke03w55SgiL+HnCuVFUFpPFmSDT35PWRynpCtogKxUm2OY2axqAlhaldlHKagQ5Ispjx5GYiJn1EK7wcgs1wuRN0w9HItbUnW0mT6Varg0qprKoeyR8TCSREiLUZbrlNpxaWMYlLeQMiRoR9ZLlckpLLNmZkQGMKIURrjBPrvtj3kTFM3hRgsC+PIQPCBpnLSskki19Va0/UdWStQIjfMWXgc1gnpYzInXK3qGc1JkxpGGZSS9k6MI4eHokg4eXKHpqo5feYM++fXnN3fCAcLQ/QJVxlWywXBj8QcqYyirsQMayxkZiFWusIvSBgjsvcQAtF72agLckcWJC8V2Xpt3ewz46wUEFoZqqrFuaa06mDsezGELG0bW1Vobei7biaaWutAabpebAiUPrpvdHkuldJ0/SCIX9aQNc42hTAulXrOosoKMZWWXSpSYMNEqgSR1Aonz83FSooF2TRlM7mgFTPzRmJCKTMT26blQBZSxTAO8zrhgyfFND9bOSXGcSQmQQVS9KIS0l7uMS0bUuUslbPkmBiHkWXToJVh02/kGdCZum1QSktCmqD3iW3XFyRXippulDbCRDwmCeF+uVixf7gPBPQQUNYwek9VVWXzBWNaqqZhSIlhO5CS/M5hjPjQo7BCdo6KmBQxqtI2lXVIKUUcI8TMohb0L6aIT54Ky2q1xFpHjPLZKYFRlqZZsFjUKJVoW0ddW/wAKlsmgcDovSRQqhLkN2dRapXvqU2DdbXcL9uOGCUBHgZR7SyXC6zTxCj8s7Zt6bqOnd2dGdmfJOvDOLDerFkul7jKiddTFDSuaRvZM4xmvT4khkC33aK1ZrNZzwVYiBGdM8PQM4xF3m0MMUTCKPtyWy/QZPrtlnaxQAN919F19wAVzz9F+BxJCBk2K0VWigsJYEZrMY1S0nu2zpQNU+NLr7ldtawqR1Ug467bcrhe0yxbFu2CmKRNFGJiu+0g52KOpeeNQxwp5bWzZ8/OUuMpYdlut6zXa1arFUZr1ocHOOfYrNecP5vZP1yz3nakmNlsthwertlshShnnCF5URlY69BmQjtK1WQ0QkIsklNVlARW+p+icgKVxFhKl6RsUoxcaGgmcVRdTuZfKYdCDq1Kf1nIYLPh1ETEVFP7R3gw4zhSVTXWWLq+o7Bksa6eCV45Q+OquU89tZKUcrMiRSmNzsXRMhZPl5zQyqG0uC+KH0RLjnk2IDJWKn6FOLkCxOCxzjF6QR3atpk3f6WEBGiNKX34o/Mg591Q1Q5thKyakkcx+bRkEqkY9okvRddtS8KkqCpHzgnvx3Jvmos8M1JOhFEcOie41dU1zsp3nFQKIfiSSKVZ3q6URhuLs44YPcGnmV9givePKajeOEpyOI4je7u7jMMImTl52m43GC0oAqpIHWPEKluqYOldx5zmzc46udcm3sJkqDeZfh0ZMgm5T6kJRYv03YjRSdo4oSfUED302y3nzu/Tj4mqXqIxMHFDkCrTOYcuChS5tybOTbzgXpRN2Vkxf/OpGI3pI6m4scXozAoSY63GqJphGEqLQzN0W3nejS6qn0QRXWMr2WBQSZLhIITGyfgwpizt56zmnd/p4pycRfG32QzE4IXwbw3GIPdKEg8neTynVqViMmxUSqO1yPqne1grQzKaGCLkNJN1Qwizm+yUxE8FhRCzJbHWWqMLxGqceGKMgxhyWaWE+1MQ1OADIYzS6izrkdEG6/TcZqxrcVSe1mZxEFWstxvqtpW1IozCaUuJ7lBECSmDcbW45mYxTxuKgkahCUlB0vTDSD+uqesFiYipag7XB6VNNBS7BSkUej8hx4a+Gzm9f4aQEqDRpirPkqwzKXopDFUmrLdUdiRHjYqZptohIw1FkKRQFWK7IBsVQy9FVhoG+j6TYxKCqtaFlB8LoqCJqawHpZAKIUAlrUbhqimUkuKibipUUdpIuw6ati73uqhZ9/b2MMbMJpnTubfWUtc1m25DjIGmbQnelwJsZLVccv7M2Vkqbo1BF8LthcmUUmp+rW1a2Y+jyO+bpiGM0t7cWe1weLgmhUg/iHVGa6u7vMffoxOUMQvJTiktRMsstbxsmhlbNkujkvTllLCmo8ooa/BDjxoG6qYptvhCRHv/zTezc2KXc2fOsunWLJq2LH4ZazVa21ky15WKCXXkBzBl7ev1mgu9PLbbDRNRawDOnz9H13Vs+oEhwTgG+m4gJnGQDAUmaxeS1aYkC46rbIHJjshGsmEbMlKNG2sZxqnSEmKiLrC90sLRmJKCzIW95zQjJ0qpAnOCNZUgA0Y2HR8iSpfFr1R2ShdejNYFuQBjE0ontC7niGmByOQwnVPKwiabaSitO62Le20IhJjJ2aDS9N7SjpLlm8oalHbE4MWd0kiyE6O0oVLyGGNo6uL9QJx7vjknnDtyfS0qaGaibhJ43RWL7pyCLLolubOm2JVXwr3o+0767VaxOdxQVZacbVnIQyG7yoaVUpqJuFUlZLNxFL+AiZsyJRaSkBhiCMTosXFK4ERFNPqe4D2VszhXXZSQqLJBWKNpmrrISzXBy/kla5q6Ktc34f1AinJM2omFfIpTq6A4k2Yx3aoah9AtJmM6uR8WC2ltdv22JLYUFcfkVJdJOkkLKCc2mw1GC5LS+57eR0FPYhAsVCuM0oxDj9YZV4nvyfQdtdZC5kwKP4aS4B6Zm1kriB+ZQmKWcyLnvTiuanGA1kaSoLoWNUUMHgWMZXBpyopcuDspxSM+jpJkNvrA6COLhSR6MQa8F9heOccYEuRI7cSZVHzlDGOIDP1ASkqIwMow+ji3r5Sa1CyyMUrSJwmlEBUFKaO4QEtntBiieT+vF9PzPXOVYpIfQlrEOUfZpJOglJUV9EzWB1mXUggoralqR8pyXxqrcWXERmWEw2WtZRgKX6XYLKSkMEGXr5AxzpBRxAzGVThjGfpe7rcs7UdtpUgIQRKjlAIqQaYma0fnQSnH+YO1GPVhQWt8yPT9wDD0tMsjOfXoAz5mlBV7+DjK+prSWLg7cjwhRnI/4ozGKotBsd521JVnvdmgtS1GlGIBnzadtLNKNqq18DL8OOJcg7FOkh8zybvlfU0jSYZCzllVV8X2X5RA8vxIO2lnIW3SyedHK0WIgXa1ROS94wWoqyDSs0cX0NaNrHFJnjuARdOyOVzPxmyzL4oRjkvXdfgQ5HyUAhxkmO84jgx+xBZlmXOO4mQo6p/R4/teOJbd0eDfDxf36ATFzxVoQqdpXoaSnh9CTq0qgysbptYaWxmU1uxdsjuf7KqpxeFPCR/i1ltv5Z1/97dsCu/k8PBQlBKVQympQKaKZKoOh3JDTHBazpm2XeD9UDTmBj+OsoFWrmSrC8I4FGJvnj0qcgqS1WtRQkhPURbP2lmUVoUfIU6fSk0S2Dz3NCf79YzBOkdMsXBVIJMKk98UBntRuyTpBcv/nyRwYmzlnJ1NkYgZFSfbd01dW2aWJPJfkRdWMyRoXalykVkrMYYCgU/8kuLFoo6UFqock8qTZLLYZuujeUAhRZEmKsSKfFYRTUZrQpIlC4nMVVWxZZdWmVZChsyqmGZpSrUyufFCzJHJUsYHkSkqZcVGPiZiEqKiePFI8qKNWJkvlk3Z9APGuJk4SDleMRU82rxDToW7ooVfROFLTTyAIEjFBNFT7NbTKPJSwYejJBglgXJGkDeLZhyDVJVasz44pG1btBIUKmfxSbBWnD5jTjijxZo6S/KeyXOCW1cOWzkh1JYNXTZIuf5S1bXcdls/3xc+eIhlTpQzM38ohhGyJsbEpusYUwA93XOlHZIy3g/UtaOpa0JpJ1g3kQT9vFGjRG5vrciolaY4Zh4teTlnttstoUiSU0pEPwr5O5S1RVu5d2ISvkGM9P0gLdVaCInD4FHi4U9fNuIL26lAcT7O832Vo7Tr+j7g/Yaqdlhn8X1Hv+2xVVN8kCQx1OXz5JZIKGNmQ0ZiwmjLpAqTtD0yeQ6ZQoyNURCCae1KSRJM2cjL/J4g/jNKieGa0Ya6SP5DDCyWC5pljVaKrpc2dN3UVAVpcUW5ZK0phmuCzMSQcK6S6+09Wot1uy3HZ6xmHD1LV7FYLdHGcLC/XxBXi1HQbXvW+z3dpmf0Az54lBaOGn0Up9kYqZqKzUEHJBaLJaOXGTtKOboxFuO5UgjlJAnw1NfjiDMWi/281rIejoyoDIuqoRsHsfkxljEmdEHV6qYqibyQ+qfWxyQZttYWEuuRyd2EOk9F2oSqijlghdJFPm8N3m9YrzecOHGCxWLBOAw0jQgQlLYi3bbC4THWslwsBDGUG55F08zCksnIs60bvBcpcVKK3d09tFbCHYmRYUpYqgpbWqd9cUwfBkk2JjQnpogfRtqmwSoraGMU1VEMgaEfZkf2uxL36AQlx0mgBknJxquzOvIZcZbVosI5eWpDlGqlampcVeFSLJJkXUiBWtCNYSCS2FkuadqGYeip6nqWafV9P2/WU79bac3BwQG7u7vz8XXDgDUag1Q+qvAtWt3QNg3ddkMKgco5tmPH6D0xCeckUqzkjSw3WiFW9Brq2lE3Fd6PDENPXTdl8zpyUfUhkIs/gnOKSjlGP0rBogWdyUkmfqhckA2ty2ycqeWhaKuqVE5HM3LEEEwWz7nNVDgnqchQc4H2g/dQrNBntU0xukulxTOb4ZXBdyCDF1UuTrZGEhWNoqld8QWQxdMaPTsJy3fXpOhlgZk3S5H/hbKIwGRuNrJYLlBKhikKQmRkZgrM1aUuTHtjhTcxDXUTDoWZW34pwc7uslT08j4fA0a7ud8vw8PqueUki5YkzaEXpcDUsjCFfxJTnEnL07Fba44cTXMW6bwVdU/wfnaklYW4eKckOabJVOvIbe2IbDlB0CEEcadUlA1L7hEfxEZ+DIHd3R2U1YyF1DuhJ9IzlwrdOXcENVvLctGSIoVjEYhaSIVkjXM1MSS60YMVEqS1ktBpCg/LWkRuKpyHXCrDqgy6jLGQUY0ts3jkPMSQi7W4mb+/vD+RRj8joDkjpjVJkLOESEp9VuX5syyWDq0Nm20HSgiLaGmHSIIim3XwnmHoAT2TEJWSjXiaazT2Q0GHDNZJ8i6LemAo1v85Z2xZY7KXdrJIN7MUTrXMnUkxCspXEBGxG4iElKhsjVEWUBgoBZmsBdZYatswG0rWTVEiQuUqovdCynSy7iib0VYcaUPwNE1N0zQo6e0WwqcoTlbLJcMwsLOzB2huvfVWlqsVSiHyX23YbteEELBNzXK5wlgrvlPLBW3TYozc0zllQhcZtv08gy3HjMIU6bMoy7abjhgFQevHMBdjPkVUSBgrUldR2hXE2dgyHFJI11orog/UVcWiqYlhJEQvUtsY2fZCQO36gfV6y2pHWj7D0NH38vtjMgzjwJg8261c4xiiIE26qFxSRKlqRvomFDulyOg9deVo62qWSVtrSuHtqCsrvDOVCTmxaBuWC2nVRmS/aOq6rMmTEkl8e5qmxjrLMAxYLaq4upqQVVPm3zWcPn1apOlexCRjQeEm2fokY66qin4YcNaKcWmUVk9V1xyc3eeWm9+PHz2KLCjmXYx7dIJCFsY+JSM1Sjas2pUqNcnwI21E7ZGAnd0Vi+WqtIMkpiRFKYFV61qqAIEvpZ9YVVVZ5NO8yI/jUR8wlUQFKNwLSWBy4XEYY2ibhr3dXZE7jyM95bi1mCj5KG2PkAM+pCIZlb7vNMBOKYGgFa4QJWucM3Om78pmZ8xkDmZE0aQ0tnAyRA5XfA3SpBpRxZJbMznzTn3JaQNzxUFQNhdZAGMUeackPcXZt3iKTGZrZvIJURfMr5mlkQmFFiVNRhYishjn5UxV1TRNxdj35JiKz4ggRKMfiupC+r9DPwgHI+ei5TdMZF9rDU3byJyQEKhrQ9+P5btKO0gqfn0RFK6UxtS29O/tjBJ4H0p7oCibSoug76U6mFsLZeNbLiVxGYZBqnglPhRHjp2Zqq4wpcKfesZTleucLS2fPLelhqEXBETLIDNjikJF5XLezdzeE9TEUFf1LLueyMgxTRJx2eiCDyUZQ8yXQpgJxORcuEMyP0RjCxmVeROmLIbjOIrs3rlSaWUm5+emqUoRoSEFxqFMx7UZU9cMWfxaRi8IY1tVKCUJEtM1dRZbSaIeQpwX8RgTzim0lt87tdFMtvSpnxdUGVJYULBYZtQYUWspYzHOiGIECtoo97EtEvyq8rLBO1N8lhJGw+g7hn4QDpwRxHOxqEX1o4XQnGKx869rjJruAUEAbWupqqZUudI23HYy0M5ZUUlpLRB8yoV7Qqap6tJO6VmualFqzaThCq3trBLTRpfiRpxXl8uloLzei3dSQU92d/bou47lYkHlKkIcCYx4P0KWDXNqw+QUOVyvcc6xWi3xPrC/f8ByuSJEaRtqI8kHKrPpOnI5b4Mf0cay7TpRNdUNi5Vj7Hv29zdMyhbhc1lCVVE7g/eJvvdi6ksuowdyacEVCwalSaX1jJLZQlLUiD+NKcmaVkXlhkw2z6WojFEmHO/u7YiBZ7elHzrOnutYrQzb7chm09O2y8JXMyhVfGJCxBZRwzh4Fk3F5PIL0grZ3d0pSb5saimKd5JSmcVCErSUZG6T0YrLLj1Z0JQBY3RJKKqCukQq52bfqG67paoroQo0MixwtVyiVWa7PqSqa5bLls1my3a7ZuJunT1zhqaVZGdTqAqhICazcVxKMim6ILIKZg+x1Wol60EUE73tdkv0UmhZd+FIhTuPe3SCojMz1K/yREIX3whCKGS/iph6Fu2Cqm2KqVamqaticiQMdlPY+UrlMvFYCJN+GBjGgVBVc0KSC0w69fkmyd60KE+8E2c0y7a94H2ZymliTnTDSM6KxXLFeLiRzDZIz13ssuU75iQMd6NEcibuq2UjykLTiyEUZOIIbdHOgErzxha8+HVMg7+mdpSPkckKHSCGRMiiypl6lxdW2MB8c84QZUE9xDMik1WxcVfT9N5YkplJ4WILCStgTcmmSzvHXAhTFsM9aaMk6gJ5u8qS4pHrIko2eNc4UulPT2ZUU9LoQ6ArDonCOaAkTsyeJxMj3vuJiFos0QvR0hczLJmEK0lo3VRoo2Zi6pRATeepmq2mj7xqpnunbdti1neE9Gjt5vd+sB/FOA4oRXGhzezu7l5EhFNKF5RLlEfymcVLRkWsqQTtQxLPlNMMveeiHJLhZ4MsYnoyIovYUmn6opyaHUkLUjYl5NN3SymXJC7OMvspYdUlWdZaX8BzEOJq0yzoBmlDCVFRNu2qstLLjpNEXpVKV+5baX3J9cxZuDer1Wrux9dOrk2K4juUkyJpTcqSWIupoKGu3TzPZRzG0hrNGG3p+44UE3UlaIJRYuzmfWDwY/mMwglxAtebMlfGR7lGRmWahagxnLXSwi2k6Kpy6GKBXhcofmo9XHLyBF3XUdWV3Kv9yO7uDijo+g7vxc7AGMN2u2W1WogkdBiZrNPl3so4J1brwtFhTnatdSXZFSftpq7ZbrekJG23W265BWUUXb8Wp9WcZtfuobRNUvGG2dvdE5Sk61guV7iqKsm6xjrDandFTJGYPE1do5QlJWlh1baRFqoxRB2xrmIcOrptTxhCadU7rK6Bke1WVFCTPxUKIkF4hUrM+DKlbYog6Ucyayk6pA2SZdwNaUYaghZiPXVDm+CSkydIO0sO9k/TbQ85PNxw621naBft3HadEvUpyQNk/VWGtl1gjcWPMoU858xll13GZivnd9G2ZJVmjuNmsxY7+laM3qYCJaXEYrGY14flUoiqVdUwuff2fT8fU99vqeoFe3oH70e6bc+ibbFO1pWUQmnj17O3TtdtieW5ndpT2+1Wnqe6xmo9F+ZaKbS15Z4/4mfKEF5JqJMSdHXi1t2VuEcnKBTOSS7My6xlkuYwSna/cJaqcqKuaCvQ0A+dcBUqSz9syaXCj9nMA8/FObEqfTxDypFhlD66sLWPLlhd13N/bqqKV6vVnDXObYKyUPoQSDGRlca4mqrO5IPNrJCQDo24WspiK0MAnRHUYapkU0rFzjzPm620eeTBmxxkj6DlQoZUR0P3UpKN/cLJs9YZ3LSYFwdU+Yw0b5yzK2U8sqxX5djEpTAX186iopmSSDX9mWYUaYw9YvcL/8PMTrHW6vmGttYKPyMnvIfJsVIWnFDcWi1N09ClItE2RmSwiAx9tVoxjiOHh4c0TTsrY9q2pW2bi4iEE1qUy/gErQ1ZqTK5WIiyVmlxIFaKHCPZuDkBEzSll5YZzEhCXdeSaGgKIXYU/kycZhAxn+epKskxiQcHxapruoYpSdtOG5ybRixIi83okgSOokKrq7osOn1BGCrauilmgEfoXxqFx+FcLYlfmQg+LepzO8nZ+fx4L/e1oBKT9DUx9MUteZBWY86ZylWkCF0ngzHJgaaWpLHrOoKXdoqZkmwj/7/vNvK9jCWkVMzCMior6qrFaF94J4qmaecEemrf+hCEXBnEXyRmiDmQkySXWSliFFfhED1hmFAZQ1t8HDBg6wqrxUq/qg1d8efYaeuZaF8VJEPOTwJtaBcLUVOUc51iZtG01K4mFLO9prRqZVaXwPpjEMVEXddsN9uSxGjW643MTRlHhjygsyb6JNbjxe9DqYH1do0pRpJam9LO9HMSo5SYHfb9WEi80zA9jTgaS8LabbdQ0N7bTp+j7IvSli7DEiVptHQhk+JWrPsHz3q9T4aZb9I0NUrXVI0lZUvGEcKIH8Vob+hhGMbCTfJUzhD8wPnz5wmDeGyorNFqZOgDQ/Bip62K3USZEd51Yn8/8W6mVrzKiml8bOHokkqxKp4kshDHnNDledp2HX7sseoydlYt97n3Fbz//Z7tduADH7iFyy67lJQT1gkyWNcVwTusTaBlxtAwjBjlqKzIh61zc5HSNJnd3R1JnGIxyNOaphWH3EXTkLMgSOv1AUrlgiB5VqsdLrv0lCQj7miOnPcDk5T/5MkTLBbi1bW3dyn7589S1ZMrtUZVllAco1353NGL4AA0+/v7nD17VojsxsxoybQ2ay2cQeNEwZhTxg+e5VTolEKXDCHMIvYPG/foBCVDGfwmm9BkXJZST2WdkPs0qCRqhOVqxZnzZ+n6jtVyQY5FhVDJeOxc5JXTzVxVlqquaUOL0mbmBPSDKEwmR8ZpzHld1+zv73N4eDhX09PGNKkYUAptDSdPLOi7ns22kwRDaYxKJMoAqSiTPI1RZWNSYv5Vfl+MWipfO5mEiSvq1IJRk9fKMJCzmhnZKLCl1zgNiDIFpRjHoej/J9v0VIjBcb7BnCvQOOLKOAwj3qeZZOysk0F6JSmaeCeTXDilyDimI4i6tAukujwy0dJa0Ith6IkhUjc1OSWcdQKxF9t3GR8g50oUJlLVKWOwlVwf772gR7lY7zuB9mcvh0JunZCSaXObIO8pYaiqirat6fotIQiaNo7jPEuEsjkBpQXo0ciAucmOWjYbBK41tphkpTkxEg6Ommf8OG1IBb2yxXgupkAKU6ukEQ+FbYcpJLXK2nkRiQXhy0lQD62FjGytjD031uLU0ZA35yqp8AqRUSlNyrGoFMrcopxLkk1JgiNVbdnd3ZUk3E8TYA1V1RCjGIuJkVNk6KVNU9WinvBe7PpBzy7HfhwxVua1SI4ZRXarKGoPSYzGJMPPcs6lHVSI0Vqz2WzJ+chk0NmabrsGF0srTTaJnIXIqLSmaSzOKWIlVuOLxQJbUKq2vpRLLrnkqHVVWfquZwye1c5SvEqSJCAnTp4ghsh2s5XkB5FFEzO7O7uQRFnljCN4QRPFfE1xuN2w3fTiE1SepYNzB4ylaIgpUduKg3MHrDdrQvC4umK51ASfGIdACJvSNs10W3GkNsayWKxmtEZagApXiVQ9p77cZ25GTNebjbS/nMOPnhQi1jakJJJgGcUgnAUZGijoY06WbvTkpFk0gqANfcBZTYye9998G8apcr4M2/WanBRK2zKCQQbNDX2PNYqM8LOcrfCjR2uHztLiiSEIIVk6OCIqKHxx72X0A5S1aFJrKbFrSDGjdJ6VjIkLhgZqURahNWMvSetmvcYZxYMf+m9QKnLzzTdx/vyh2M/3XVk3pIgU6/eEdRlnKypbH7X2nGXwYUblW6PZbMTCQS8WDP0WHwKr5aogj8Xc0TkxAs2CujVNw2WXXsYll1wiBbEzpFiGzC5livGJvR3hxYSRS0+eYBhHKmtZLZeM3peWd01dJOvr9Za+7wpCAwcH6zkRma0zNhvOnj3LYrGg73sxK61qVBT0smkaeTbGga7vGX2UMQfGkAng71qSco9OUFSp3IEZ9kUjEr8U8YP0r6vKoYFxHGjqiqpyMqQvC4egaRp8iKDNTHKdFBwZ2G7lYnXDgDOWYCJkQ4yecQwsFi1Kwbbr5IH1QuKbqqijqtzS94OQsZwoaRbLFXsh0o+eISRSIRxO5lum8B6y0pjKzmqiI0KiJDTTkMLZNl3JaHsddFmcjuR1cr6OlArZSHVTN/WMKkwsbms13su5c42ZLZ2nmTrzUL9CdhV/E3HxNRepTQohTxt88GUjjtLfdeKTYKdR7BfIY1MSb5G6qgr5TDazWGaAVE7MtPpxIIXImALWaCLT9FGp2mZiYc6zh8PkZeMLt6OtW5SSynkoiYf3UYbllQRHCktN3Yh/AEoxDCO7u3scrLdz1a21YXd3j1BcQDOK0QuhUCvN2PeoSoiXqRA+JYpp1nSNsoxeMFaVij8VopyQhbebrUiIMxiTUUkW3WxS+TlHUrLB5ghVXcsAtijuykqL6+aUeLTtAoCuC1LlKY0P4tgq50vQB5myKt4HFA5YDKnIMx1GO0IMs7TRFenzdruVSrAktDGJdDJsOyHY1Q2+7zEqiTRxmm5Mwji5ZyTRmzYaMezTWlCs6X4qHsrUdYt1Du+lBXTq8ktRSq5Fu1zQtrLAai2t08WiwZiMNUdI2NQ60VqxXLSs12vGYWC5WklFu90KwdwYadclSeTX63Os1/Jv225LinJ+c1Tsnz9gfbiWc1YQ2VDkxDHE0rMubeuci5uwwVUWjaZXvbjgxshitcPuCbEld03Lam+XaYMcw0jdak7unRCbAW1YrzeljSXKp67bMvaelDKVqwk+Mgw9TdNSOUGGRy/WAiRps3W9qMaMFcFBSgk/esASfCZ4Tyh+NOOYSDGz3XiMCSgD68MtrhKFYkyxELmFD6YorcXiaquVEn8TbchkYjbg5V5TKJS1RfkmowxSVijNbNk+oanGSuEVYyjDFDWpcFeUiRgt+IvwD8FUIhqIIRb5esXB+X0qAw9+4P158AOv4FdecwsxJm659QyXnboUYw7LeY1McntjLNZUHO5vufcVC2xdM6aILh4oSglKWlXCmdps11gjLcDNdkvbNoXzp2iaBbnsZavlLihRl/X9hhg9bbti7UequhZn3cUCaw2bzYZLLr2EcfSADAC1zkmr0QmXxPtAVTlOXXapdB5yZrvt5VwYzd7errS6h4Go4cSJPbHEKEj50A80rebE7h4xZs6ePUflih+TFSR04rHd1bhHJyhGyUDAUKr9qZ/qnLgw5ehLf3VktbMUIllBOpTWsFyIVKrAWa6qGP3A3t4efTdwcHBIVYssdRwGDs/vS6Ve2hfTgrvdJlz0Qv6aXWrFRKspGWdKciNJlQembcScZxikIky5DPITu3bP0URitEyP9UXaO4+St6aoNQAy22039wsHP6JC4WiQhfBVOCpCcpVKzOhpNLvCaEc2Mrdkquq1rslZYwosLrOBilFVYp5bRBI9lZhYiS+IKYt8CFJVx5SwbYMtQ+q8HwuMKvyciTMRQiCHOHuJTL4qEzdIvkOAPEmdFa707kNJ2tzEnygGUBe2XoZhxIdYlB6i508p0c8Ot01h+TNb409o3VBGwqcUi3rKcPbsWfYPD7FWyGiCRNRF2imDsigcnJhEoZFiEqVIThgFrqlKD19sQmKMJXEqg+jKwEXvZayAKeZspkjQY2kdVpUYWwXvJVmMnspVLNtloS3JUDBRT2xZLBZgTFGWCHFyGIbS4pr4TdM05GnUADNsHoMkx87IH0kaOsYoG5606sT1duhlWrddNiJTVJqAEDZNUYuFHIBA4zLJKoxTImV2krz03ZYYEkbLXB6VrRBWrcXsLqhrx2KxwLkK0Ay9J2eFrR3dKEiCNnaeK3PqssvYbmVk/YndXVLKbLZdsab38j5jcRY2mzW33na6IEtwdv88BweHbPqOEFNJGsXmPkRJkHO5r3MUlBG15r3p1tKKnQbFhfL/hdQ5RlECNVVVlGhCkNdW0y5aaZelojIDbFVRNS2Q6ceh+IVESAlXtbi6JiRFtz6UNt92W4zPJAmQeTmRbhiIQYz4us1AvxUnWLSRUSLFqj5FxTQROmVNzGO5B9OcZyuk9Z5iZMhebmMlw/hk28/EMMooBgXKuOL+XezvlEbZYgMvqz3ZGFAGpSLKyMwnZSAWYnjWQmwlKyKJbRwY0oh1Bj8OKCOWCcrIPayNFh8enUlBWv3WOYwTnmEMmTAm+rGncjV11bA9OGTsBnYWDfe58t7srloOtyPei/miytN4hSAcvCwzhOIIwzZSmZbFcolpFL4XY8RpCnhdiY9T24q8dxp6a52giN57zh+sZT0vknxrJ+sBmUXmfU/Xie/QtM7bfigtTUFR67YGrbGuQuHJSVAoTSJ5cUX2Y48yluVOS9UK+p9jpq1raiMDObfdFhUzCY1WmuWyJafEdtPT9wPrww2cEvRflVEbsjfc9T3+Hp2gFMLGTEqV/ju4tibHIBOvZ5g6MwZP4yQrFWhSLtrElxiKFFIdrum6noOD/aKIcZxoWmyZgjkELzr0thUiXanGc0pcesklxCi8CI2MJA/hqJLc29tjHHxBOyYo3ArTPWdiHhhjlGHdIhtClSmV3ocyYJC5BaGNYtrEJkb3BMtPPXmpwiIhZiat/0RkiiGV5E7Y25TkBChtnwsIowA5FVmkDLOTCeNpJpeKd4JU2ilGun5DmqYsI+iWLaZoorNPc/U+cQa01oQc5usqc0JSGRMgJFVrZZ5JnhKSC6Z6TmMHxnEUEvAFvBsAW1nxFdGGcQwoEs5qmbCbc9HzU9QiCqs0aF1mxIlUnJzZdmuqqmJ3byWtpF4IslYZVJJFSRfVgBgmCb/GVBXOViVZGqQlVdh8Rk18oIgr4w3EYVLLVVYJH4X0a101WWsRUqKunOwDRpELp6pqGoL3JKSaLV8BV1lcXZNRsxutnytnmc3RD4IioTLBC7coFUWUDLcTTxbtHFnL8YUoM4RQGltpfCczcbRSxBRwpWqklb71crEqpGRDZRvhZZzYY7exLHeWZCL3vf9VPOShDyH4wN+8/W84fdtpYsg442jqBW1dNvIUaeqGdrGQto12dN3AejMwZji9v8/+wQFdN7DptvTDwHq9KYhdz81G3EVzUtSt8HPW2y3WCneo67b4MEqyqDVZF7WVUkWl0tF1sllMDsN15ahsRUielDXOOLZDj3VVqWDNTGrURksBQ7kHlKZZrDAzkgLKVihjGXwn7E+lGDZbhpJgZpUZ14XYH8LR9N+c6Qs3IRRl0jTV1pYkIOZMDNAxMg4jeVpndOH7KFEzURBBEKv3ME6qjDJ4NB2tOxOyZbVFVxUhRbQzKBIphHnQqdFlKGEhy8cjWyRBirUkq5kg4ySUKqoqoLQbMUVEgCEpCHGk3anZ29kt3hwtTV0Ro5/bJVknFkvxsxHvp0wkUzUNWjvGrWe9v+bcrWdREepKkof14SGXXnI1TbvkA7eeE/+jQmy2xlJZMXAc1ShrXMyE0XN4cMAwDEKaLe3lmEQiPbWL27bFjyNj1zF59dSVK5OFa9aHh1RNw8mTl6A1bDaHLNoFSgtKn2KmqhvhacVI3SxQSglqVnhg1V4lE+4RrpvOCetqzh8ecKKuOXniBMpaun6QCc+uYgxSXCulOTxco42mqWsxu9NWUEoUXScJSgxZ+JS5eL0g62EuLdu7EvfoBGUyvJqYzJPhDQpcXaGNFZTAaM6dP2B3b5eYZLR4zHGWdOYsvU8DtO2yQHPQLkQqtSgEt6ZppDorpLm+71kul9JeiImTJ05S2ZrNsJkHEk5zL3Z2dghhRClNNBNc1wKazaYTFCVOE5ALv0WLzM0YcQxNIci8rdKPlAdXF/8QTdu2s8LGuck8DSZDZrJYcasybRYyMYjp1ER6TXEye9Mzz0Zf8DsEHo1lou40HTpgi+QxZ2GrkyeZqyEkX3gxZaKqVpDF6CvphB+8yGEzcz/UXWAFD0eEUVGeeJkKq0VSnnOR5RkZzEXSMnTNix/K1E+fmPtaS0WtgTAO+GEyJ5NBdDlE8YFAqpYhixmYqKcnfsqkALK0TcN6LRM6J2QtxVyMw6T6GYaBHFMhzhqqRgzS4jASs2LsxjmRkjRSEBJxZhRju1Qqqmkqb3H6RmuL1aCMxscgxnUx0fdDkT+2pcWn8EEG+sUg5Ov1WmahWGNpF0vqZlGGP0rbyAfZXEIc5fsmgftTEk6ALuqhlKRlmVLCFLflqq5YLBegRELstDyfGWjbZm6bKGWoXSVeJ8awsIa9xnLJJbsYB5/+GQ/noQ97KAfnz3P5bsPb3/YOuWbGUVuNucDbpbIV2lb0vWcYAqa2dOsNZ06f5wNnznHu3D7DONKNgxQkWhcLAfFxkWF2lm44IOZMSoptN5DRVM2CRi2BzDgMZdBgZgwRVYiwVS1Jfdu0xCiJ2aKVDWIcRxSaRpkyVVlMr8iJusiKVVZUrhbV2XagPil8j+1W7q9+DMItG4cypVi8KOTe0dKSDZ6kUjGu1IK65aIw0vKc+SBjFYzWZJVIWQaDpqzFpTXrMhA0I2YO5TlUmuIBAGgorc9Jaq7RRe4ta1eKAasMOQWyUmKJoMSbxVipvHMx8wrFMG2ybEcpkhL0yFaOrMWsssJglKEpfCkQI0PrnBjYaYV2R0XLzlLW8dpVLBcL+YymYrVaFVdui1ZiglnVVUGcIs7W6KR5x9vfwV+86S84c/NpGldh8PTbLZdffoq9vT1SejdH04gNJKitQ6uARmO1EgWaj6QQqazDKn10/ovfRbtYUk9zvVKCthG/LlfR1jWVtbNVRQiecfDs7i05eeIqpjle1bJmb2+P7banbVppnxZ01RoxRQzeM3Qduzs7GK2JfsQZ4ZfspGVxrxVumyi5hpl4b7QMELXaEWMgqMg4BnzsobQwUQajHU3d0NQtoZW5X4osSPvsv/Th4x6doMSiixd5rbhqFtMCjLVYZymJuBCRFivpvVUVVWFrG2vF2K1IKFGKqm6QIV89Vd2Uzb487CFSNXLzHx4ezq581jr6rieEJNMeS19ukuo2TSNVZ99jtC12wqL6cJVjtVqB0uwfHkhPu8CjRstDbLUhmlwmxU4JxJHqCI74JdLbjzMyJJ4QMpV40rPPXBRktsmUDFSVcHRSkn5sVVVsNhuUAmsUvtxc4jFSiJxlIZBR5gGFlgpHTSUQswWy0prKOYZRBi6aUr1b64rxU0AxyqJVqjZpVRSJsrGQhYdTVQ5FLq6GCQioIqsdyyhxVwhmE0IzEXeHYZAH0QjaJJWFzBjxvnh/OIed3HPJZfqvL6Rnh3WaFGEYhY+zaBeM40gIPVA8XtSRH4pWMpk2kYhZ5NEpC18hapGox6lFpg06ZnwWZdFk2z4n5WTGslnpyqFzIHlPjon10JfHwIgZVIhs/RajZV6PVkIg1VqzWKxmpEpri7EZV4bajaXVI3C4YbVs2dnZEVJhaffIOWpmhcQkO63rSkiujSsk20BlVbm3pEdf17XYusdEZZ0MLIwJQqSxDeN2y+WXn2BvUdMaMKuGVa1pDbSNeB3F8XBWGVWuEYgtKipr2D9/wMFhz/tu/gB/977bWA+RrhsYvJe2gDZkZfBRjldUbnLuY0z4IDNaFsvlPIF54i+kXMz0jMUhKKezNdZqnBOliS0eSPsHa5q6IWcYhm05T2kmxfbDKL18pQijl2sMpJg4OL+Wjb+0aodhEIVJ8tgoz67c34pYpMzagLbTvAY1E+i10rP83liHtvmC5D0VF2FEwlsUWjnJvTYlztKOFo4ZlLlbaEhKzNOKqaAzprR5jEh5MyStBAF2FdrI2AZyKu618kyJ22xJ/p3FVo66ranampgC6ICzlbTPXV1MHxHeUxEj2Koim0S7aCFDUzUYJfYFkhRD1dQsV8t5fc7FxsBYjSmy2Bgita256j5XsT5zyLmbz8gwzsJLObl3AqcNZCXEXoR/lUIkeiVO0NMGlIQTpFG0VU1TVXRxLOIDade3y1q6ACaTUoM/9PTDwMm9XSmYEpw/t88022uxaDHKcnBwONMBjNGcP7/PZrOhquSebRcLQbO3HePY0y4W1FXF7mrJ4b7MLNJW1qi2FpdgtCr3oST9uYLYR1JI1HXLyZMnWW/XLJYrlLa87/0fKEo9ii1ELuKMCmdlAnvygnL+q0lQBBU4IukYK9a61rq5shkGz3LVEDPsHx5y4uRJuqFHZ4TclWVKqI8yzEhpg02lch5HgheC7HIp9suj9xweHiLOszKfIvjAMPqi5hH9+6JtZwOsSd4ak3izTJMmZY7PJBO2rFYr9k6e4Oz5c9xyyy0CCc+mO8wD/iY7ezXNDSntlbqujyz4jdj9yymSyZpQ5hWlI+8TQWfMzGoX1UsofAlxihR4WWTKWilsXc8KFhDUYCLs1nVN7ZqLfGJ0Ic9Ow9uiD+SYihGSJpMKnyGiEKl0GIfZW2NGYi7Qzxtr8CEy9B2hWGaDKiMHjlxMrZHetfjMhJlUHYJU4EpbWZTKPSPrhQwFlLaHx4c0E12NranqRsjPg/i+LBc1VdXSDyObzYa6bmialpi8zCxCrM6dM9S1HOcYBA6dUJycEipFSFF69GU0QShTimUhlntLqYwtFbIYbWlqt5KRCQqapi1umpm6bhEjOknMmmaBLTJy51xZVITXEguFQJXzo/dEcrpoW/b2diBn9vZ2WLSN8CKKWqgbevwocP1ytSrkW/BxJMZxHlqZki8qkQpjxHchx8Rm2DLGzDiM+H5gt6np+4BzirPn9jl3bp+EbLAag8YUW+8WH0TpFqMM8YxoUtacP79m3Qfe/f5b+dub3sv+NhKyzKqqGpkynLJMsw1hnNVdzogyR2tH07T048i2GxnGeKSEQ4iiQjSmtFECQ+9nY7XJ+XRqh/hhjatc4c3Iie62naCJSjH0vUDhF5Dqq6qS623EOj+GJCTRGMkqC3qRxLJAKYVRZSBlSOgJwbSOydk2K0qrUgsPo1znmBNYVSYPWzSQo5yPC4evpsIzq+q6FEB6Gq0uVv1WpoZbY1m0LQbhgk2To7W1ZA1uWWOKH9Fq0bKsG2prZ0+rdiGyf1s7lBHunGsqaWE0MhPLWZnXk4vBnjUOY5yoLY0GU0YyJOEqGo48SqaWWkb4djJkM8jsIA1J5TIB3WOs48SJk5y6/HIhVB+sScnL9VKK3d0lChj6kRSzSN6VxQ+9SJnLhh0KKmutpd/2sgZmMZY7f/48V155JQeHIgnXWlPVNY33NG2LMZb98wc0tRQClROumyhsDhnGnpMn96ibhsPDDavVirZtGUfP/sEhtvxMU9dYLftRLH5HRitO7J0o7Wvo+5G2rones7O7Q4jQD4lkMidPXgoJ/DjQti1VI066KScW7ZLNpmO1WGKNYz8ckIHDg0POnzs785NMIf/S37V5PPfoBKVtJrdFh2urokzxxdGvuG2GwLi/T900VO2Cg/WGWCzVN9ueUB40V4kVvAzUEy7FWDbqTbfFR2G8G2OobE3OotpJZSGoq2pewCYPjco5cUYsMsWUZVPcbDZF6lcxjoHVqmL0SWZLGMXlpy6jcpb9/X3pIw9+nuVQAKLiniqyzVRUJhNCAAK1UhQSpnhWTFwTUiIWrkXTOPp+wIcRo0Ve2Pe9JFttJVXu0IuKovBDJu5EzkcTmy/kkFw4Y+LCf5uOUXTwUkX2fYdWpiAa1SyzbZqmJEvSshr9ZOal5/baZJ5mrSGkVKaSUnrfekYcpoUgeF/aZ9KCkVZFITEyjaUvyqsQkQGDkxy1DHwbBxRjSZgEsu3p5/bVarEQ342uZxx9ST41wY+QQlGglGQzZ8gRjaiDrFKsmlYkxhmqusVYK4ql8l5FRe0cTWVpakdTS3uiqhuRJLqK1WpXVD22wpaBc85VbLYd634g5CPb/c22Z73Z0HUdy6oiZllMKTM2dk+cwDnLzt4JGQRnDIvlkhRjMXdybLcb6qrMYjFivrbdbIQcHUeappY26+FWJp0GX1obBpRIX6OP1LUkIJuuJ/vMpZftMkTDrafXdJtA0y5Bt5hqSQgwJk00DdtxpB88xlQMXWR//zTnD7fsH3bcerZjpMa1htAXQqBPJCVy9JgHScS9uLzKQGbxAAGxTo8pM/gRM5YJ2Vk4BbbcbKrI+1NKQhzTospIRflktJgZqpQF5y3QvimOwkopUnFvjT7OMnhpM1iyFtL7NKbBVhafI2Py6FJoZIHVBEFM0ucPZPw4CNdNTfb2kjzOIzSMls27ILIaXYYbZ5wxMiTUWFxVUVWSnFdVJd/HaIZxAKPLhGIp+ionQydVTDSVk2SlkLxN69g9eYKErJukTGMslXVUtcNZV9ywy2Uw0r5xtcNUFmXlZyrnMNoKNwomvwlG7zHKgIqF0K3EDj8LP6Z1CygIMxmS1tTtgr7bQmlSKTLWOLRy1K6mWTouueQyFssVjHKNur5HK8297nUvYlCsD9fkmPFjLNwLUZoZYzFakLa2XdLWLavVDiLrTqIiUorVapdbT5/Bxsje3h5KKQ4PDhlHIZs7Vx05TxfuT0yJxrXYHGnahTxn1rC7s6IfBuwoo1OappktBHIubt0poU1NtpnFaoWmDAbVhuXuLpuuxzgr6F/TEMckfkHleej6nmEc8DGirKVqaoZhZNt3ZW1LxBg4f3CeGJOoZr1Hq8xwF5MTuIcnKMt2ibOOkGKxU45lcJlhDDL9tWktXb+mqluGIXC46UApdnZ26PriZTGMZKVxVYOojeXByxkh/4SEUlJpWOeIWQhPVTFW0qWS2RwcsLOzw6KuGX1PPwiasdlsirGakKwms6ymaUViqDWZEXSm6zratuGSkyeExR8Dt912WvqIpe0ifWTxfBGfBzVXBYIe6Lm1ME2zdK4qSdcols7keSGaTNhUGRQ4tVwEGTlyMwVmqHcs3iKutFMo5KeEmCVN6NQ030M2felTT22APCUtKOn36mmoWaSqiumbAmvdPD5gGpgXYoYkShVgTpykClVYLT4wsUigY0xYLRM2/eCLWigVXooiRFnEXeUgS9sIKAmKQiXQJPmTIzplnMoEIsRiua/BKDDIdNbd5YIwyvBAYzRtLQuAQlpXIimWBUScIjVGybiBqq5pFytsXZeZIE6GXhYXZKdhtWxYLlrICW1kVIIkVgpjakYfpW24f0A/SGWUjWXdSSvpcLths+6EqEvm5KXi8ZFRVHVNt92yWC5p24ZmtcQqManrh5Gh68llUGPTNGzWa0KMHB6uOXHihKjDigJru+1Ki7DBmoZkQOtILu0NkY+KIqNqLCpbzh0c0H3gHMtVhXrbTdSrkxiteOMb/5izZ/bZboVDElRg23UCcytDjJr1pme9Geh6L1N/lUZhZBYTRYkFxVzQFJKiEKVBWsapeHzUdSOgfpYBntEnUSIZgy3tREIQs8A8uS4L+pC1mpOCFI8sxKb5YWX4t6BbWdp9tq4KOiieI0P2QjB10saeuAYhl3EMkTLiwwlCk5MkO0k4ds7a0uI2GGekRSqDveaZZWayLsiiRFnUDct2QVPX1E7GfBgtg0VFuVZRNTU7uzvSTlGwWCzJhUDeNoKwLdoFBpGXxhTEWdhAvWwAafVGHyZFdZmtpY64Zkmef20NxtnZ6ygQGX3C6DIAVeliY69Bp9KKymUIq6BBOWR0VmSjCporqDsJ+s2Axs4utMqqshEXB+u2ZWdvRwblZXlt8OLEfNlllxURgyghY5BEQFH4fIXpO7mMT6T/yjliEo+mcRzZ3d3l8lOnxKoiRlHG1QURco6qFrlmLK3BSQWG0lRNS7NczgZ9GMO2H+R+cRZT1dRlCn1lZDDg3u4eJ/b2OH/uHKp0HkKKJGQIr3D3NCiDqzTKjtRGjOPEB0p4eUkrfBTDSG0VlRZelbaadtmw3q6pjJk5QdYYTOXg9Pm7tMffoxOUxor5mg/Sl8xxRJevlCNglRihKUVIik23LZVAxegjSjuqukVbaWVUtcF7qQon2aXYtydhVvfiRpnyyNAPtItWHGSLSsMX2CyEQEwerQTSu9CES9owkRDE1EdQFI+rHLvtDgcHMjNmfXiId1qaADmV9k5GaxmFPgyRXCbZznMYSp/ZGlnwYklqtJIWS1JS4U1IRgySsEzpxzCOaGVnR9CUfOllinmSjzJW3jpXWiKJUaaxAaCMyB5DCKQyi0Jr6XtPEmqlj+DeSR0UvDyQMpFW2jgycbSoaKyhH6YEp5DyfEAVsp4KgijllBm2YtGdbJpRilDQl6qqi89EoG5a7HTchWgdgydmeTibys5oVYoek8QrZW+3oW2q0lrUEI9M3bR2LJqWtl1w2WWn2FvtstluqKwgHaudJTozL7zGyvyjuqlpmhoU5f6raNsWpa0gZDGVKciBEEaMkrYPOTCNF0DJROLz5w9QukLpjvP7G/GvGAM+CgIxZuFLaSvTipvLWqmqYmRnd5fRi5KtbRfFB8ZT1zLm4XCzRoMoIqoaheHs2X2q2nBuf5/KOQ7Wa9bbfvZNESBP+Bj96LF2YBy9+IIk6PsBSQo0/aZnHAapiFNm7DuMyfz137yLN/3fvyaEwK23nQUkuTxYr/HJz2aNKYosVGtZ/OVerVFZEoQQxHBM6SOFiaB8WWS8qiQrAErPRE1lDSoXh2ZjZNBbhoi0EVQhlBd8U/xyFGin53vLp7I5lYfNKIsqbVEl/upgNd7AkEayzlQ7DZM3amVlJljTNGKomClS60RtKhaLpWyMBrLWsqlbMT/Umpk3VVU1rrLELM9cVQsnyVXCT3La0NQ1O4slTVVjkI2qKuMnBEVpZdJ15XCNzLcy0/BKcmlBiJxblbZk5eR4ej/MbSGdp4ndhc2fM6JjzoW/A5RzHJM88wlJWGISzoyxdibXTlb2GI3RlWAhBkiKrMsEVgzayHdNOaFSEkPMIgzAQB9GcfLWsuZaJzOTqrYBrYusWQaBtstlGcSXGPqRGBJN1aD0MAsWEpkxlLXP2tkUcmqoTs7HwzCK+20tc5Tq0kre9j2mrrFVxRg8tbUsXUXVNCitZA/TlmFc41wxrESsCXSwpJw4WG9LG3wypIMxBLq+Z1H2sRQDthJln4+RISVinvgkWYp2YLFsUUZGNowxsul6um5AA6vlir4b2W43pBO7rA8Oi3FknlvUi/pfSYKiUOSQyTGz6bdSrZQKOkWZM9INPUlnxnAOow0rYxlGz2bbl2RhI9KsnIuJ2tH8F2vFEG2yQJ84FxipjvpxFCjNyCyXybhJeBAZH/vZzKxtWzKRTbG/Xy5XR9W5MWJiZmUWCGUaaF05hl4qVa0MaCHpWWfKrloWv9LPFOmaGLIJ4VUIYNOI60yek4nZNTVKxZFSLA6tR1blILBfCGP5GeF9pKwoGAyj9+LGmXJh5Yt8WmVJXDJZFvBSkTB9dqkqhG8Sil+GK0OwRnKRTMuDMRJSFIQmCIdG+tXCPzJGqqeUZDQBiFQxay28E6CpxUzP1g1mIewcZ6WCnHrDkqROiZPYPlfO4gwsaumBLxY1y4UMInSln2qssNuNqrGmYm/vBCd292RKbCWzePw4ioV/jCXRVGSkrTf6gRBHUTnstihVUKcUsMYSUWQ/EvxY5mZ4mQukE/2w5eDgAB81227k/LkDXL3g/P6aw8OOrAwnTpykXSxp92paIw6ydV3NC6ZMIpXfr6Jms9lw9tw5meVS5r9sN9KeGbteNB0hslmvxa8hBw43Gxbtgs22o++F9R8LupcQntY4DPOGMpYEdBzD3J/XWhHGIC0rY4uvj7Qq69qRETmvNhV9sQToSkukspV4yyhQWrgYIURx3DSS6CujqesFqZBNJ9dhUTgczaNKBSmdZlWFwvkwdhq4Kb4RPmmZTlu8aFJpE4pLcOF3KUk+nBVOkxgFijmk8FWsoJXWEBVkI+MUtJGBipKUVLhK7sm2bahchUE2Wastbd1S2UpQt9VSkAYjU90rZ9EIedJYmdiuNMXEUBfTRzWjl0Rxsa6MFcQh5Hm0wtQmoMiOE1l4dU6s3U2cTZmwtqL3Y/Hr0SSdCWGgeGUjs5qSJEDayGynGAVRUQpdplCXEgIQPsk0fXlMUkxYLfeE1WYWSCQyIcfiTC2tHW0KOpINKUM/DMUgTlpEVVXRR0/VVNStIyLEUZEBhzJjQku7vMscHB6y2W6lHaNFoq+UZrVYUtcHBYEO6BBJWe7x0UvRe+LEHrq0iLMIGsW+YhA1li9zgLQ2bDZramcJ1mCiLuaaiOcLsN5uWKqMjzLlelG1bLabsmcFxkE8dijCq4wMIAwhctuZM2it2HY9m82andWKru9Jfc/hdssYIzvLHbbbDV3fs11vUTmzWC6IBMbgMUW6nFVmsVyyWLTUdcVyJVLpk5fs0W82VJVm0TbcdsstMKFXdyHu0QnK5DiacirtGI3Siu1GPA5aBU29wGfpeWtn2GwEuvfjiKvreROsKsell19CU6RZfV9GuBtLVanZjdBay1ASlr29PbE0D4FNt+HkyZPyM9aSUpB+sqUYjlkywq9I8WiIXkbhKpG1eT8WN8Ee5wx9L3Ny6qZCrDcmP5Gp8juSd5IBq8tiLFWcj4IiTJVw1/e4pp4Z6kqpQvATY7WqauRBKgMPrTVYp2fX0pQySheofJJ2F5OvFERdInI0IX/aIqOcKmJSLP3fyXqpghgxCHphi9TUgPi/ZC3Saq1wRhefC4c2jhgibVsXSVxRRZAxylDbikXpu1ZVzWqxKEPeqjLlWBx5jWZuZcm043pGM4yVHnHbiELGkGmaCogYIz4iKYSZlyPy1AaNoG/ZD4RxREdBj0Tep0llbpAuhiTDOMxwcSwwqyjIBpLPWN2SyPTDwDCM9OPA4AeGscfHgfXmkMP1IT4a6nrJMEZCXNMPEVc1GFvRJ8XYDaTzh6Dg4PAAX+5hpTWb4raZimIjlJlNXdex7bsZhbKFx2OVJodItxFjwKShG8VcbPTyOVoLodxoLd9XKeyUwJYBg8ZaxlEQoJiCJPrGoXJmCKNsZUpGFhjXlPsuMSYhw2pj0Uiy6EPEaIt1hhxlVEJV6RkddJUoDLSTewojjrvT6HppzSi0jqQEPgWZA1SJSiNGxTTqXinEJVkXgrkpLshalfEUpqi2VCE9MhPIRRLrWK6WkpBrR101MpbBabJVuNrRNo3M2kLWAOlgCG/MGUutG3aK+Z7RhsrVULgJ2hl0ZTHOCSExF9NHNQ1VPBqUOa0l0j6WTUwjUucUEj4PMsCzjO6QaeVWkmdrZWJwkjEZVV3NoyEmlaH3Hmu0tHdiKM+VIGbaGqySGVtZlfEUSorMUH5uUtBlFLlIkI211EUYIAmpeDJNfkqS9JSWc07oJKR3g+Xc6XOcO3OOMMr9PxWAYfQ0i5qHPPQhONOUuyYRU5BEqCq+S0oRM7z/1ts4f3BI2y6pa0sMgaEbMaYSJ1slbcBghdfkKkPwkW3X4WpZg402GFez3WyEaLpc8N73vY92uWAs6HPT1FKkFNSjH0asG2gXDd0wYK3itjNn6AsXb9MdYq2sydY4Dg832M2auqplmnsYi/eM2NUvimfQ4aZj04lqL+bE/sFhWdsjB/trLEJFIBWjTkTFF2Jgd2+XS6y4N4+9qMxOnNzFj57gR3LypBRYrJbsjrtl5tJdi3t0gjLEgUgqTHlN8pEQB0IMwuwPkVRUBCllhl7svdFS+fuhkN4U5KU4nN773vfm7LkzNEsh8603a7n5hpGd1Q7aR7puSyazXh8UL5QVi8XiIpt552pqK/4XpvgJhBAnpzGSUmw3nUiatcgbY4xoA8Zpkg9oW/qXCQYfxJxKGSwOk0GpRDaKqAI+yVAyhUZFGLMsHAaoVCpAsaIfPcbw/5P3Z7+Wbdl5H/ib3Wr23qeJ5t64fWbe7Bt2FsUkLdp0wUTJlCAI8kOVCkQ92Ab8V1gC/GTA8INh/wX2g1/8IhRQBcGqKpckW3Q6qWR2TDLz5s28/Y0+4pzdrGZ29TDGWifSKsDpQtVDghsI8mbEiTj77LXWnGOO8X2/jzxHGi+FT0YEmM4LH8MYJ4tZLgJjc4ZSl1j6pIpvEaw2zmOqtMWdSPYILjAOIn4NVmLBQ/DYxq+np2XDcr3Ej1vj2W42Yg93MoMPunk0bSCXqMJUYYucn5/R9S1N8PIQe493dm2Fb7peu2iJbb/F1Iozlq5paUIj4zGFuC1cmW7T6Wlo1vFZxppKMEG1MLIZpTQLB2TBeWMkG4eZWqUr1fVbrAs8P+wZZ9E8WB2L5Ryhij6pqt21iNuS0yjhf3PMTJMwZ2KSk944ThxPJ4ZhZJgG5jhzGk4Mw8yYKqkMQk7FSrFRDSjnotainBpxgczTvKLPx0EEf94H6dLEWU/6dnXIiaAX5CQr+iVTwEQpIEu1pKzPodaiPkjr2jvJJ8o5USxygjIi9msaD0XGkd7IiKHUTAhbNtsl+bqu1uApz1jvCH0gpkjTtszTrCPEsp4wm0ZAgdIRNfgg4tXnwzUGy+7sjFxEk+Gsx1hhsTgHuEq36anGUE2RsXAb8MGtgXdtENJrq7qo0DS0Tbu6Y5bxbbfp5bkqUiwHJ66aru3w2mFZBN3Vou4Tu4pafRAtlTFS6DlnaX1DnvM6Hkmp0DUNKCANZ0h6+HFqSfdWeCPeaCBlKto9kENNTDLalK6DsFxMLrQ+EEIQvpCT7qx3cp2slw6T9QIyJEPjGmKO1FkpzrlACAQbqJqpU2vBIHEUSd0oriIBl6VKJ64cOJ4OzEmQ+gVxFzrv2MbIrctLYIl90E5WhlxFWF9jASfYhGoq7fmGn/3k5/zpn/wpDz++z3wYCAqGm+bINJ744hff5vOfe4vtWUepEeNV12JEGO4bRyyZhOM4JoapsN2ds91smKfMaZhUS+ZJOVLqJHtTNtRisV50ebvdGSVVYRE5iVVZrq9Rjs319TXBS0cmhECqmTlJ99x5wzSNFHm82e+vmVPEekOpAoxz1uJtBI39wFnGaWIcBpwVWqz1DVeHE1fXB3a7nXQTjdPnUxK/ZUIQ2PVbcpc4Xu+hGLbtlmoqGTBBdEyn05Gub9htd+KmNYZTmvHestl1mGBodj3+r0pY4DzPRGbpnGCE6GGkHei8WEuldV5YI/eMFaFYKqQykyL02x6KjGLeeP11as30255PPv2EUWl+275nsV9SJOr67t27DMNpbd1KN0bfXClYH/6V97xk81xc3KIUaJuWYRiwfrFLyiKUs0DRxnFU5LyXzAkvYqyqJ7SlDWpNlSIiFkosxIpQGylEg+D/FbSWi+Q2xxJZsm5sNeR5osSkbWCDN6ppzxVTMsEU2iCnr4qwDprGYRqH3VhaH/BOWATTNLLdCuWzIjqZtvGEIBwCZ9UqqAjpvtvSq4MFs4yoGlISDQSmcHEheSPOSbdj0sC2oCnKi/hwCeRqQ+CwP9I2Ai7LKckCDIrmL2JZRcZPwzDhvGWaR4mfbzzjcMQhPJp5FqDcHKO0y/WkAmiBIoFv1jqen0SYOkwz1dyQOlMppDhTSuJ0lGIjpcwwTljvheAaE3OcGcdIzBLAVg36dQODilyrknRLqcQkFulhmDSNujBPsmgJOE0KjkqFqkLqJArCWmRTkw6KLE4yq9aml1Nrqt7DUVkXTSuMlFgiVvNQip7AJeVardGlyGhONQXWOdEqaVZS17XMk44TY9TrqIVUTlQj6mPnA5u+EZJo49kFWfBDlPfhtLshxUFYi6y2bWm7gHOGRoPrDKIrCL7VTojEUjSNl2dFRwW37t6m3/akLBlPIYRVdNoqQHEZETRNIxoXI+LqthUxqaI65Dk2wjUq2t1cQh2tsUIAtpVciwj3i4yDlha9ld4+NVecMdiulWKw6v1QlO9aLblmkm7gbdNK50ldiF4F5RiLDy0YQ+vlgOStxZZKjomm6WQTlzOgdMY0yM8aizNOMs9iphrtxLolR0e0ZTlnpmHi7Gyn44yqB55MSkKEttZivKNkCL4hpcKHH37Ihx99wPEk3YWU5dk5nU68+uorfPN3/zrn5ztSikSl71onAnMZncioLSlJ9RRnvv8XP+Lb3/kO0/URM2fyPEOR4Mxt33L1/BmPHz/itbdeU+hgVRGuY7s9o2lVt2ItKQmkb7PZEXzg+movesC+U2uwQQCSlRjlcLLfHyilqiTAE5SZYoxlmiYJZkxZQvbGiU0nydnWGKjCgWo7IWQPw8DF5SUVGZf3fUcq0q2eJkHz708H7ty+Q0qJ0DSMw6DC34RvWzDSzRuGQfhWVSIZYoxstzswEnxYUsVWgSiugmYnY8FsZJ+JORJCw24jIbxXV1crd8ZYQ5wTwzxxGoZfFiIL/IoXKDnnteIvyMkjZU3pjVbdMfkGiayitGIyjXc4b4k50mtCJLUynga8ulMa73nt1VfE0moswQea0GLsLfnwvZdWpObfLBbY1WbcNBwPh1U4a4xhu9utY5SSCzHOgk4vhbZrVgFszvKAJJ2TB+8oTtw7SW+mUiGWIlWslZNmKZWaVt6VnJxJmDnjbF1PrKFtZRFPhk0TdATjKFoNh+BxTv6+8ZZt37Lp5LSyzM8bLxoLg6i3BSXdiXgueM7Pz4R1sO0lPdWKKNRYsdk666l1KRoDpUiWDlVC6LzzHA7XElMQVf9jhGT4dP9kFbxWRJdijMzZJRCsaMDgTBOEaSFFhnyu4gaS4qJT0d80T2BFn5NypBwG6VKRSDGSc2F/OMkp0rfsDwdN4vWS41Mtw2lkmmamaVJ9RaJaxzBNzBo8uKTCOudkbDOOWOeJKXMaRxVey3Ocq56wrFyilMrNWM7J6dgaMKVqcdjJ18xRY+1Ff1CrFGi5SttbIHWS1uqCMjG0zW+sXOeqX4uR/KmqjhOciN0S0pXJNUFN2OIwzstpG0glYopuSl5IlMUukfaFWjRuoSbRKQXHtm+kLR+kC2SMwTVBUQAtbS9ur0X3II4nsfjLfSsF8na7oWmblR3knKFrGna7MyrQhFZcdE7C92oVJ5h3VkTRXijUo4KtrHIzQhOgFJyxBC1+FihjUjG46FDEQbeA+ULwmCpRDN5aUqk3lnzkcy5JFvqSC87LeEYHqdJNUQu+6CJmahb9RQWMd7hqlC8kdOHGKXdogSCJJEP2ByM0ZdH15FUrVUtljolpGBjLQElZM54EZFdVeCzPZKSYynEcmOZpva7jOEihPY6UXLm8dcmv//qvE1rL4XSlRt6FiC0i5IJkqnV9xw+/9wP+6f/rv+fTTz5knEbRV+Sq4EP44pe/yDe++lXOd1vtGsmBarEVO2dJSBhfNYbNxQXf/c73+P6P/pz7Tx6RjxNdtXTO0wax6Y/jiavnz9hfXwPijFoPPAU2vWboqOasImPPi4tzdrsdDx9cMc/TapRoW82l0jUP0JGqYZxGFov3otPDwH6/ZzidmFNk228Yx6KgxcRut5F9ZJaxaYxRcPh5XsftC9rC9710qGJe98mcxdV16/Yd5ihr6zAOq0D3dBr0oCpO0u12S1DWVUqFOEoCctd3TKNcE4phnCcGdQGmGImTFE+H62v6TSdCZmd49vy5Cmw3jCqz+GVev9IFiuBzdc3UpEvvHcXdCEFL0dOC0hbRtphVq24bvIhSgZIiD+5/Si4S9GSNhrT1HdM4K0NjGdckZTmInS1pdL21MuM+HI8a5X5DMAWhw7ahIc6zhOVlocxO87CScWMS7slud8bhNDOnp8QkmS0uyEKVAaoEShUquEApIiIlV0CIs1E3hyYYbp1vePWl2xgqbddJO/E00GCoqaz0R+8FJrfZdHhvaNqGW7fO2XSi2+g2G5pGxiqNEx5B6xohNjqLbwIY0d7UkoXQCSIeVE3CNI6kOiMYbctUR47HgdMoboer672q82WTmmNiUtLqMufOOTOOgwrupOCzzhGaQNf3NE2rJ+MO52cV0kpHIuv1y3mBlIlgtdaCcYZpGhjHE6lEck1y+siV0zARYwYch+Ogm6hTPLX+20uaadZ4gCIOqSo3JbUaZelUneuDQWIIUm1IUboROQsfpeSqhbajaVpcKCsEsKr6rRIxzjFF6eK0/UYXmAkoIubVcMRpjuQsdlfJAaoYFXZa5yBrupORMVHRrxNwhNxPsqlI69hWEcRmU/G+gq0y6rON6koEgGYc0s104mbruk4+n5jo245a4PL8AuetHCKaFucDbd/hQ5DCzYiLzHt5r2cXZ/TbzXooWNKrm0bgVE41Sq1ztD4wDiKO3G7OVpdFVQHhQuOsFGJMxJR46eU7VFAsvmhQUkxELW6XdeAmN0qKSRHAqvW/GNKsSdpIXo5zSvnNWYW6mUIBByEozbMiFQVi/0XHNZVKdVb0LjZgbBFxfCriOFJbb8mVXGWqLNBDS9u1UOHx48eUIs/V8TRIyF2FNEfJF4uJeZxIU+R4OFKLjOhiTCIynTWINSVO00BMM9Y56fAdT+rYkM/2q1/7Km9/7vPc6S6pVYXOqheUThVa+PQ8fX7Nn333B7z7059zPFwxTxPzPEmQaYXNbkOdRf9UYpGumWpQcsnaSYJqM9YF2o0IP7//wz/ng48+JuZE2zTsmo4yRp4/f87ZbouhiK2+38h1xutYVDb+tutElOwDVLmes/KpnBNnzjSOOOfY9P2qfbrJF9MMJCPhqsvI1bpGCpqmxcALfKdIjrKmyFhRRoZTlPDPnLPEH1iopnJ1dY11MA0VHwJtK7Esy+H4en9NKYKin6d5xVBM05XiJ6SwWoTiT589YxqFdVWruJwkCNGRS2I4DTjv2B+P7A/71Z0Z51myv3LmcDwS50ldmOJ6XdAVv+zrV7pAadoWU8V2C6yCNZFcy6uqdkI4JHKCsUYWt5SjgLlyZtN3pHnmcH1F27ekGBkHOQlst1suzs84Hk6cDseVorqQTnebLRMCnzEqWjvb7phTZLfdyhtR0eZimw1YQhBRaspRT4Ve2p/TICp722CN43SMhFDU2qsGHlXbp5QlC8RVMCJgtS5Q5oQLlmTgzq1zPvfWK3z1829xe9NxvHpOtRL8Nh5P9D6w7TaSChsCEpVTuLw8586d2+IaItO2Tk8qSnWtRuySCkCZ50l0KtyA1IAV6iZdhVmcK5Ns9HNaxG2WOSZSgVqMcCXU7bPZbpjjLKeLGCWMq2nFCVLkVJuTdLFIcHU40XSFUg6kIgJT+bdlo41zJE6TRMIn2ewlbTozLxAxqyGFtdK0N50XrCPOSa6DdatwuNYXc3REfEh11KgbF+K8kpm/I2mxhBNcdymFYi21SmfDWIt3YEulGEX+O7FC5lKIVQi/xskpPCGLZHUW37Y4I9oFimx8c0nCxlDSZgVskIVnQcVbb/TUWcDIpufQ070IIaSLEILYomsVF1QQsajX7kXbNHRtR6uai22/oe86jAMbHN4Hzi7Ohc5spTPZNg1kaEMjc/ZgxaKvpFCjNFIJLxTOiPNenELaiZDnvaxi8hsCaiZYD7myaTsMEh1RMDLkc5KNk4toxHLJ9H1DT8tJ14CFC5Fj0nlHlXRY69dieRGuy+cud4EEJhmCk66Y5NOolkvvl4V70bUN2UhKOEUTq5H2+DzJBgISCOdbD+q8OY2TPAtJwhJ98NS8hFQm7fY4fNPShpb333+f7333+wzjzNX1nnGepN2aClEPAU47lSlm5mGS8Dc9iaeoInkrVttY8uoKnDSjaBmFWWt59OAx19cHXnvjVfo8M4wHcTcGSblOagk/P9/xvX/5A37+s/clgDALN7j3UrxigDlzujpy/ewK9wUpIsbxiPGLoFbuDVRb5G3gO9/5M9796XurdmoaTxymhC9S/J1OB7abnnmeGcdBxJ0kcVeqsNh7T7fZatdHfs7j4UDbNGw2PbVmjsej7EPSeibFRCqOJnSUmtZiYXe20dGW0/iMxGk4sdCynXMcDgcabzU7yHI6iYuu6TdcPX9O3/eM40jTeuYUORz3otWLibOzMx2rnXEcTtRiJL4jZ6zzzHEmpcxms1lF8DJiOqyp79ZapjiTonSvdtstlMLxdBS7cak0bbN2DamFeUir1jIqRVwApp6u75VRZtecs1/m9StdoKzZD0ZJjjXjjF9ttqBAsFIgL1AfWXAdqrS3qrZX6miKEncd5yh+fCsdC+88TdCY8yDE1a7rOJ1Oq0J/ESCu0DCELyF5O82KfwfEJqp8knmeMR5skZafs2KFtk4gOFhVsVeZVaey5GQYal10BeJrNz4Qc6Y6w3bTcu/2BX/0N/8tXrtzAcOBuH9Of7Gl6zuqM8zTTFDE9dn2jE3XqcJfWqWbvqeayuF04Po0SBR9FSRyTgJCosB4mohzZB4nxnnGONFslJyZ5lmJiGVt60pQo1GEuSMXaUsvFmanegyswQ9ZOhkpcTye1oJzv99L56Kin4csCjIycZquK17+ahYCoxJ1kWJyIdcum9OszgBhZAhoKdVAqcvi4TGuwQe1XuoYApYMiiI9IWXN1FoUX290MzUv5A8h4r6SsdqOx4jQTa5txZRFW2FIJYnlmEq1CBhMO3TJVmisEIe9CNyMkc3RWRE6ztOIRQjMMef1lO/bgHV2TRrOWYSlXdOKu0RHKksbvW1lhGIwqrtoViv9ZrOh73vOtmdsN1tqKWzajq5pMd5ivFg+l1BO0VyJMFp2a4me99qhEcqvItlLUY3SC0m2xuuzpn+nFCEfVxWbIgh4EF2GdKtk416s7kZF7OMc8UFOr87pYcJZDEpiVqifFGXhF+7n9ZnXtWj5ZXSOv6xHS+e2VpReHXGhoVpHxpDqjdbncH3kdDwwDRPH41Gerxg5O9vx0ksv0XQtm7Md3jhc30CU9Wtx7Bhj8VY0MXmOWCppmvjuv/wOf/IvvsVJU2crYhu3VTLLhBskNOqS5bmSGAqj9FdJwE5ZQldzzSS1UnvkXrFWxLsxJp49ecb+WkirImaVCszoGMU6CWJ88OARP/jeD/now4+Zj0c8BYtENJha2XQbGZekQhpmaiwUL2uj1fWqqENu4T9dP73mz7/7I558+oh4mvDI+DhXg7dBhMpOBNbzPDNNYl8nZq3vpSgLTUPfb3R9kmf+6uqKoN1Bp2vHOI4cDvu1mM6T6LhC22BsJKVZxs1e7oOFoQQyRmqbhlkPT2fbCwGDFnEoHo9Htn0vYMeuY7/fy57n5WAZp1lZNY2M11RusL8+sj8c2J1J5IpkewkB/NatW2sQ5Xa7ZbPZ8OzZs9XZRYXQGGKaifPMOAxMejg3KdFtNtggQNFDPJHzzHa7o/Qygag5Kz5DOE6mGjb99pfe43+lC5SYEznKRakVco5ru3W5+FVzL6iKmU5R2/wT1luC+smfP7/i4vYlm34r7bUpr6eicRw1otyIYHPJlrBWv7e0rLqu43g8CkL8eBQbnfeEELi+uqLrJME1xsQwDITQEnxD17UMcdBEVnF0gGEcZvb7o44QIOVIayUAsersFZlaqYJdxKjFiM6xv7Xlj//P/yc+++pdPviLH/L44/e5te14+dVXuLy8YBxH5iTsiDglcY7MB3FFlMJpOCorIjPlxJRFEDdpZk7JRjQXw6Q2W8FQV2NElDWOqhwflXvBameUFFVp75aMpuw6EYXq6Cup8LWUjIoZJKFY5/bznFnC/1bQ2yhCVpRUWg2ixNeDrbEOG4IINoV2JdqOKkJrEzxN2xKzOHmEr1HFmVBFR1F147SIEG7ptCzwLGskP8QasE4SYgtATqSSSUa4LxRtgy95Igti3cBSTWcPxos+gyqfl7EGb3WskiLGO/qmX7NxjAL7Li8u2fS94ttF3LzrxPmUa1nD1Ta7LX3fi+XWe31mioiam1bHZl4KGuXTNBrr4KwjNBsdu/j1BNV1rWRBFfmcvHWCLvfqULGOOSaslU3RWatW5yT3ssLslkLZu2VBlx5VVWhggVWDIOFsOkaphZKKdnek64S30jXJWVD13lEsjDnKZ62iY+edwrekWyDWeadds5s4hyWnBljHuM4uqeCy7ljtvDhv15GusZVGE3OrMbSt2FpztRQqp8ORZ4+e8OH773P/k084HY7sr6/Xk/ytW7d49ZVXuHX3Ni/de4U7L91l08lYIXiPKZUmeOYkjidqJU4zlxfnzOPE/vk1w/7A/vrAHBPOhRXDbztLnmWMszionF7nnDNUcQRRhWdCVSJ1hZLEKt5YgYMFPQROp5Hj1X5F/HdqR05zwnfSZQPLD77/A977+fvMp1EEwaWAqVjVxuQ5sm0afIU4zlAkn8j7RnRMRg434hwLtK7hL3/6Mz786YdMVwN5nOm8w7ctJrLeh97JgSKXymkYdQTlxGVU5ACx2exoulayjIwkET979pxa6ioGlXs4iu5Iw1pzTuQ8Y0OD007FZqNRLFSWtOElTThoJtHSqSml4NuW3aZfqdeLtrHWyjiIUWCz25KiEGlzzkqn3ijUstB2HW0noX137twV8J6Sxy/OzzHImj1NI0HhosfjiQMHUkoCjuRm/RYjxIxTyndKiaYR+3lKklvVNtLRyVmuddQRkrd/RTooS3tMNh4RyK6JZygbxdwsINSq2gPZ+AIemz2hDRyHgdv+Lufn51wf9hyOR7DQNF5cNlhZSKoI0pbgqVVbUmSsUatUukGTcY+n43rKylkyHIo6hjabnmkUO5tXfYAxlqbtqczsD9c8v9pjbRBWRC6ULH74XESARZH/Xub6yRrcpqW7aPm3/+a/ze9886/x3/23/y3XDz7ijVdf4uLijFNMHB484vmTZxyHEVyg8Q2n0whV1Pci5JJRyzhPGO9I1XA4DYyTKLbnuXA8nJhHjZFvOkkPRjbt02lQRkJUaJacmLMWV6XKPN3qqMRaL6K/inYqjGSn5IKxauetVjQXKtaTAlAiyk0phEYEuKWWlWBrvZdihSpumFpWN4HRcUfRY6uxluoljC6XTHGOWrOo3mvRYlDItDjtssitBVV4FQu/YdnYU106NgaLiIRTirJxKzOjC2LF9c4JCCtnCJYaxGoaghQKzqujRme+zlk2mw2b/mZcYo2hDQKM69qWWmSj7NqG802PNUiid9sQmkbHSU43H7GYl5zoFIWuvXqWo33RnBlnrTY9nGpUAItadx2nw5HtZoO3jpqL5KYkGT0478VlZjVQLUmXyYUGSpGxUpYNCiOuH0kulyIul7qKPxdoX07CzPDWUYzFa4FTy831toAwBGVDXhDpVUdoZu28iLbIO/2esApgFzH8cvIF6fDUUmU8hhTgxkj43xKgl1JUfYoU57JueaquLacp8uD+Q374ve/z7k/e4enDx5z216RZIH1RuyNN0/AXXcudl17ilddf53Nvv81rr77KvZfvcLaSTZNs7NrR7XTt6pqOu7du0/qWmq7pfCsjr2CJ08S4P0nXMkiwYU5JYFxLt8taEZBnEc8bY1Tf5FiyscZpECdXkWiP1jum04kcI13TcjiNNCGA0/vVOt57732+9y+/w/PHTwSNbsSO34SGrFEarfe4UqlTJA4jJSZMI4eBUlDnjHJonOfTTx7wP/6zf8GzB0+Jx5maZKSb5gmqYa5SVDRVDpLOi9g95cxM0jVJNEmFigtBQ1WlY/340WNyziKiVjGytWLbXg5jzjlKNsQ5EhoBsl1cCAVcogGyYuvluVkciU3TyGc5jkJyjpFWnWJxEjGu1xiDkgtxEije4mK9uLhkHCc2m42MhloB+XnnOT8/l26X8youV6db2/LkyVOG4cSnn95nHAZMRZAR6sxb5A0CtiwcDge9L+XfsMbIKLJWTqdBDwxwdbqiKlCv5L8iGpSFLppqwRQNn1IFwNJilUJFcezGiZuhFBH6OY8Lnm4jGoeu6wlthz2dyKVoLLTc/FMUF0YbGkInp8dRRVFpJf9ZpS1KVdl2ki580Gq373thfJS6ZjPM80xNBhNESHW9PzJNE/v9iSdPnzOcZoxz5AohSGQ7iLND8OxC6QzWiai089Rg+Mpv/Rr/hz/+P/Ln//Sf8+iTT/jC669y75WX2I8nPvj0Y66vDuyfXHE4jBTEGjsOk87UYThJvswwjUxxlgWLQoyZrBOzUqRActaTc8GaSRYTMsE7YVfoCE6cCnXduP3Cn6mFVIQSaZ3He8OcM7FU2hDUvTIRnFvbtui/JeGCRiFQBWvlepac6PoNPint0Dsdv+jCUDUszlqKVYeDLhhYy5RH4Z1kcdu0ThwdUQPl2kYC+JxWJrIoSMsaKiH4NS14c77DqCXZNYGma5Xwm8XVpItS13Y4Y2ibFh/Enu67Br8Vt0nTiB3UeScjImsJwSt/o8FbL4K6xVEGWrglETE3rbIJKiUnsRgGyfqwTk/IMRKc/Fw5Rt3A5TRXorjJjBXmS46ZamWhXvJJjI6pSq2YwMr/iTHijKXxrbiCNLF5KdpKEk2G082uamdEYnQMOIHm5VKQXBz1VxgpEOUfYtWeGJnj0iiiP2VB8zsqJSWC2nFRWCFWClRXxa2UKMKFCYZcRUgteqpFYSQvcWnccE+MWcT3N+Od5fdljCcUV0l6TnilslYMnz58xDvv/Jwf//hd/vwHP+Dw9Bk2V9I8KYDQ0DhxUThrOVwfOVyf+Pjj+7z/8/f58pe/yNe+8mXefON17ty+JEdhcsxAzDJmOw0ju80G7xt5nzlLV9BbairYanW8KBo3VhOCFN5d29CEwDQJm8SUxbouY+ZcklBX5RPBZpjHgRx7asnUnEk1SXK3EbrvEqj64x/+OR/87Occnj/DVYOrwhnqm0AsgrLvuxabC3meKSrEbMKG/TzI/VAtzkLTdJRqeffd93j3nZ9RE3IYNU7QCe0ySharb9UoCJcDx9OJUiu+CWQyKaeVRtw2negAk2RyXT+/wiCjmVors2qEUpK4lLZt5VBpPL6xtK1s3tMkCezWGn1e5V5agkz3h8PKZopZcPStUsGHQQTNMo6acM5ycXlGTJFxEn2fMdINOh6P2nWR5Oy26bi+umZ/vWez2dI0UpQMw8A4juy2W55fXWl3P3B1tQdgGidKLut4aEkkX8JnlxDD4+HIkjy/ZKqJ2yiS54StciDItfDLvn6lC5SsGTWAzpKDtlarihYRGqPqD5wxKqQtq0DeuaBC1SKnnBjZH/bSsShZugdAnDOGyOwjTfLa4prWjolcNGlxL4jwc84ZxoGUM7vdjvPzc6ZpwhjLMM5rDsk4jjx9+Iz94cA4iV7jdJo4nmZSkZuBajTCQkBqVD29ZtGijOOAMQ1913L79Vf4gz/8t3j87DF/+q1v8ZmXX+GVl+5x/8ED/vLD93j//gOeP9+Tx0QaCllZGxYHOOGpFJntinjSgZmJ06gCqkDFsST9piTCViGyBiwJ56BRaJdVumbKZXU/SAdF4VB2CQaUa+n1xG5KoZQkC2GQE75VQWktGb8wFzTbwplKzjKeihEtMqWdr3IEORU5PXU7TXY1hlBFKGn1NNi0cn0NlV5x4YK+bzS3wxGchl9Zp2mggU3fqdtEujOha2n6XmbQQVw4bS9ZO40PIl7UsZCz9iYV2zl8cATNMDH6c4sGQnQhWa/NYu+U0YJ8jjmJ5sp7v6rmc7bYWvFdQ0wZHxpyVbHv+swsjiSdjOrJeVlS0qRk4IzosRbnmmcdfRmj7IiNWleNgt3kHKYOFYutC2LdUX0gJ1n8bs6XrDquJXCy1Cob5zIKM5VSkwbAyXuU8MtELbJhueDZGmCYieNEsAFvnaRb+0DSPB/ftlxNM1OOBA3IM+pCKipeLKozK4jzKS8Cd2c0E0hZJEhwpEy5hBjsvCZqB42j0NPuOE18//s/5E/+xbf59KOHDPs9QTs/Jum9W8UtmMcojKMh0W56bDV8+smn7K+vGQ8HbCm03uIbuwo8K2LfN9bQ9xvOzs/We6modouCFgytjkalixUaL4VHkq7pcTiu4nWjY8hCJEZZ/9CU5JIkt2y32cqoU8ee4rQSfoyAfOC9d3/Ouz95h/l0kmadkcPJME/EeZKoD2cYhhMuZULr1zDPVX+IXJe2FfzD6Tjwlz/5CcfTSD6Jk3CeJiYzgSug3J5gvGqC5H4YxkE6ik0gxSKJ0lU6R9vthuUgIwfMiLOeu3furp017yR4b+kyYKRo8E2jn7e49apaxwys1mQRIcs45Xg8suRLwY0xYZhm6VJrV7BpvBQPGt0QfGCOiWfPngHw8OFDzs7OMMbw8OHDdZ19eP8hxthVErG8/67rVm3VgtDo2pamlQ7v4jBa4l+OxyNNEDv//uo5TSNF2RiEMl0LDMcRWyCnRLB5hRn+Mq9f6QJlEb06o/PpddFQlblRO6QSFouRFr3xuvE6wUqnHKkqNtpfX7G/eo5xktibUhLyaM6EpqWUxDQt2oeCs26tnEvOAtpBLs6zZ88kzKlpmcfI3EamcWae5aaQrszM/nRkmAbthmRKlg1fd1TVKHhqUYa3KaBpmcL8iBA8pnFEm3j7a5/nN3/9a3z3n/8PTNPIvbe/xDQXPnz/IR+8/4iPHz/jen+itQ0l6T9XHUUwmnoiUpKlydK2rpm+38j7yCDQO1mUJZTPYGvF1IwxMgJAeSMy3lpcMaq3CA4dfKynlFKWEQfS9ZLhi5xki3Rjap7lxGFgzlIgLhwPXBF+BxaQ6+mMosm9OEG8Ml6Mt7jWYV2g6Tp8aPDKyTg/vxAIW4x4a9kEmes7hV4F52lCK7huY1W3Idk9ywK5dDus95JQ65xql7yOQaQT5Kyj8UEXhFkJu04XDNFLUKuIo5e0XBV+15KIaWZehXZ1/Xr5O17YP4APMtLJc4QiC65BgHYL68QGR6yJKY40VlhASyEpqdHiBujahlqN5OuUgm+95KPEtDqH0jhTnORaWSv3VE5F4GxNkIRZIy6NcZjBCDivawIxTlh3oz+RU7xVwOBNhxS0+FHwGVW0BLUKgM8XI3TjXLHjiY21jDHRmYLJhjhOIpTVOX+osEFO9845ijUMUQoTrLwPhyT2VhDmTk1Ikq3o3mrWxd45vQ91bJgTpipvBacjRU/J8L0/+yH//J/+Dzz99CnlEGmzXJuiERYyfhJnl6ijsxS1Rbo+pMKTx4/40V9IYZZq5PNvf4Zu05NjIrSdFK5V3DK3b9+l6Tqartc11GCK3Dsxaw5RkKA/DNQkRa3VcWiKWYonoKnCQVpyhsUBVmnPWyUDe6KdiIxgxO2TYyYl1tDNh5/e59En98nzTE0zuVZidRhbRfCvn+FcM613jCVzGI7MaaazO+3qScimRYTlx+PIhx/fJ5equq+KaTwxTnodZcNMGEqeaYPo53KUA48rfsVICDg7cvtiS9OA80nW+TlyOE5cXFxo2KSW4LaSchQzgzFUl4l5IidJU+8bdbXZZQQ+q3lCXGC77RnzlMSR5T01GaZBCOAxRQGtBelSWGsZxgHnPKEJkoOlxXdompuOh8LhWiUep35DnBOHw5GLi3OOmqIcQuDp02di+sBwvb+WTpDC+pzzyqTJ6xTAe880Cmq/5MQ8zsRJurJxnEWDOGjOHVZR+7/c61e6QLF6ApHF2KwVqcwAq2Z+eFX8m5WJYErWbAGIcdKWlGOaBmIcMaaKp90L9yMolbaUxXpm1qpTosjlxFprFUqwUftdEgDVknicUyZ4UVVLwnJeSbEGg7ceQ2KeI9MUSXNWC1eSm99J+z7lKJ0Bsa9I0eKsCDy7hq9//Stc9D3v/ugvCNbjmo73fvYuP/v5pzx8dE2cDY4Npga8BWOKRs5XwSUXKe4K8vM4a6TTVJagPhHEFfQQ5JyeYA1kPdEqIKzoCbcaq3wMcanMWWmP1pKrzOZ9kPToBfFfaqbbdqL5sAaHiLqCF8vukoYsIxcdlzTyoPrgRbjZSABhv+npulYiv4PY0QXRbeg3O7p+S9f37M7OadteeAdGUOGuCjV3uee89xh1Dhmk2Fiu/SJkWyYBQrjU9Gidz1WjkEGlLI5xkoLB6Z8ZUczkJKdbGS7cCDJLFtvr6qRAN2tdiCjK6cnSajYq3lt+HmMl02SKo454AkWjEUqtOAWgLeNEY4LkPQG2a5i14NdAAOI8YW3G4khTZBoGCZiscv+mXHCuoRo4jicZE2YhcU7TRKqJaRq4deuSL37pbc7Pt6R5XEWYyybqfSNdGqQ7VqpoBEQvIWnFItaWXmDIyJjves/x8IwHTx4xXh85Pn5OOk047Ua5rqM939Ge7Xj9i1+gaRsOpxO5kaIgZsmFskbug2LqDZRNCyb5v1auU5GwOuukMK6IpbbkQhtaKpIOnCq89/4H/Iv/8Vt88tEn2KHSZCcpv1TGnLFBOnGZKhTTYgSeViTiXsp8yYJ69Pix0ESDFPm/eetSQWTyTKcknJbd7lyEmt6T5igdkVrlmhlxO01TJNeyJhU3TSMRAGc9TZFxYd90NF54M/1GdA7FZKY4SkBgkdLl9uUF9169C07HfUFYIiG0PH/ylJ++8w7Xz64wmpGwHFa6vqdSmZOC+ysYClbHHjlLUKRLMqJyzogNPBSCamtANvWYIm3r2G3PMbYK6n+KGHTMHCPBOvKc1IAgo0TRq1coicvLLWfbhkc1Ymzl+nDk+fU1t+/exuqhSmIPPJttz5Orpwxz1LWskFJF9ediFXey3s3qchQti8e5wHa7Y8nrabywpprg2Ww6nDWw5M/hpCBsZdw9a7JzjHJdb9++jTGGzXYLtUpoJXB2eYl3nuvrA23b0nQdwzBot1Xu5nmaCaGlwmpzHsdxzWpbCppxHInzLIGq1RCNjMaLEaHzcDiuQbxLwf3Lvn6lC5TF974spPKhqZUzeBqcZmh4PbmLKKgis3SQGHJjZNM8HA4iVYH15u/7XiA6RjaTVueNS5fGB1GsG6Utru9rRqixJa/ZBMvMumll9p+KbuTBsj8cGIaJnCKiZwAZ58j/X4R+N5ko8n3E+iinqmAtrfe8+cqrHJ9d8/TBY149u8XTZ1d88MknfPzwIUPMuNBy3neYahlPA1VZG7kKlTUhJ1ZnRJ+wILitKaQiN1lR8XGqBVtk1FZ03l5zwmGEDwLIyUDeZmgCuWqwYHCaBNxJxPt2t2adBO0+hCbIGKPx+ODVRSIiTMnkOWcJcfR2IYkGOQX6RfwmG4IkHcs83RrU6lfxYbm+TgMOswpRnS5OWfQRy72iCzqgSgqxNy824UUHEmMkKjpaUn11nq+jqUVsmVISEqgW1ouoOuUkTiFjsEVpycaurALR1NT1fVUt1E1l7VotGomsI4IC4gAqiW7TE5N0HoZx0sTnSiELj6ZKwnQqldM0U9R1NI3i2ooxakrxwHF/IriGmgvTODIOR4aTzMBTyoxTYphGaQ2nxDBI5lBMiVwi0zzy1mfe5OJsy+X550WAqzoH9B4qtayLm7VWsOt6IMj6+VgjLpONb3DDyPTsOY8/+pDrB5/y/js/Fq7MECFJF8IYhw0eGs/Z5QWWwuWbb9Kf74RS6g04zzSLIN44Ed9Kh1au9/Ja7PNLBMUCICuooNZ4basX2r7h8aPH/A///H/kvZ+/xzTMbGkoeqixSjSuVHleNMU3U3CNw2SjpGyYp1G7GIbj/shP33kHHxx3793jpXv3pLOpLXxxIkpeTI6JOMVVs5RToWnl/fdtx/Zsh2s8bS9i9BijJCQ30j3c9hscopvqe+Gv+NbjG4ElpiSunc999rO8+eYbjPNEVKBlqQs8rjCPo2rXZD3OqWrxLoV0Y2TkvIzugxdEfJxn/T3VApnFtWnoXMPts3M+zR/jdGQtP6vFBilkcixS4FrpCgcrHceS8loE1pJlxJUjhgIm0zSOmMU1Os0j5+dn1FoZhiPWWnbbLU+ePdeRi7guS5FifdGXrfeLVUwE4gJdtBvTNNE0neQeqZ7FWug6T9+3zOPE6TSI7dpUFeQKCiM0jRbvcmgU59BGCosG0jxzPJ7YbXcYY7h//z5nFxe6ZkTOzs4YhmHlAzWqfxF7crN2fJbx7uII6hophoMPzOPMeBL3qxwkp/VQvxy0fpnXr3SBYrSltowNJKxPFPMLLjw0gb7XdEq7PJyWeZ7UPtXigl+DuMZxZLPtubu9iySJyrG276WFvXzAzrn1RiqlgLNcHw+Mw8C230jmQR0YpnFN0t1sNpRS2G57SX1NEpZ2OEa8t2y3vbA7ivr2DC/M7FnnjtZL6zrFKCd5KqRMYy0vn1/w5p2XcFMiHSfszvL+hx/z6eNnTAWMbzC+AWMZte2WSYLYrpFgAraVsUgpRdgRUU4uzkrlT6l4I6fY1od1puqspWsagtpRxcXSEJpOBYJWulhKRWz6BmOFONs1LX3XcXl+LoFgmw1nZ2dqE4bQt2zPdix0TlnIEl3fEZTDUUrB1KW7hYwtQCmTRfcTKShMlWxpKTSNWlwrjfeUVZMh94xTXYq0NYs6FiQRGpRGagrGSKrpwroB0bRY3UiWrWxR9y9zaKe2RSlIzXpvS+Gs7AwMFNmwpPBJcvJpGgYdMYoYWU9+uiEtrVijRRyIYNOFwPE0cOvyNj/96Xt89NF9uq4XbHXNnIYjU5zIWVxvaY4Mw4Q1RnDWuvhMw0CeR4JtsFhSTJQo+SjTNOimKNklc5wVNmbIuWJdwHlpUbdt4NZ2x3wY8VXGSWW5t2GljorCAbV7ojbtJG1ja6TLWQ2BwuHRQx79/D0+/PFPuH7yEFsEFeCRzsum79SS2cgmctjz43/5p9y7vuLrv/PbhLbjyTBC2wiePmtyuAglVkx/yfnm1K0OK2MMpkhnEiMQw7YRGFjTbZmmxL/80+/w7jvvQjLYIqJnF2TjLbYQWk8siWwyuYrFPsVIGxqxlVvHPI40Xgi70zxgnOPxoyf87Gfv8eZnfsbde6/gm04x63Xtqp1tdxIWasradQttILQB3wa++JUv8ZnPfYbq0IJJND9t17HZndF3HX4BwNkbeq8i/Ti/2NG0nYwGKzivn42zZO08Lc9B17ZC1x4lAVxghBkS6ybrrKUkYQw5Y5mnmZOyYaoW9HGONNp16Jxl13SYpIp+fb6sMeQ5YqqjbQJpHOl8Q02ZmpHA2WmG0muRJEWM83LYbYKjbT1prFxfX3F9/Zy+a8FKN3EYjrTNciA24IKAHauOKWtRF6fmRzkJXayInssHibxwagpIOZFrUbcNK1Rx0kNP2zaMk2SHWbtRHVyrhG0R1c7zzOPHT6SI8iKAHYeB4TRQC/R9z+Mnj9d4gq7bkHPm7OyMcRLXad/3K2l2KVYXR0/XdWy3W2oUQrg4DHXs/r/olix4hV/29StdoFjMytMICkNaAsJEH6H/rQhrIXGKWCu0DcYZOSGZqhTBkUV1P00Tlcput2MaZw1gi0xxBgNd15NLJo5RORxhnT0P00hOme3Zjt1uJ+9TNwhpjxWmWSzJoWnw3jFMJ3GjlIK1aJaDIcVlXqfEXOsxGJzVU48q/IsxlGlm4zwb42CMzIeBY3+gxMr18YhtWvrtGcM4Mxwn0jRjLGAlz8R6jwuW0ASMDQTf41zQDCKHdwjUzUoMeNO1uMbrSU4EWn3XrbPTpmlo2k7cUU2QcLbgqUY7Qc5IVL2eOi2w3WwJXk7PIcjpoVDJRh4krFm1JAv8zbcaqKYb+tKBqLUojM38Ala7lCIn6VoVV21Zkec6W6eIxmexMCaNPzfGrMKypQtilcMh6bByMjQ6wqt6Usw5yzy9Sl6SU1eIMVYDzsSKvXRflmRsrDJUiohenXZg0A5N0hM3+nPVIveDU/heQePRcwa1EjtjyXPkzuVtHj18zD/5x/8dH374KW3bczieyCUxp4khjrLgGBG0xiijxpLzOkpJMWJLxuGoSj/13uKMIaVp7eQ4E242G32/HhC+nMNVGPYHrh4/oWo3qmi30FiZzdu1cBS9R6koel/swMYZXC50tTJfX/PT73+fBz99l3S9pwkObJBo+yS5JNmOshnOg2yuMVON5Wc/+CHPr57x+le+xN3PfZZiHYN2q7JOVW90MLLxSIF6I9hfOizWGu18GXFuOE+/2fLRJ/f50Z//JddXR3HPVUeaE64Wqop2g5WOYeMd/fkW7yWh+bQ/Mo2ig+k3G4bDUUaBWgykmHjy7Bk/fvddvvDVr/LG69tVs5Nikg1ls6VrWsbjJIh8bczazvLlL36Jv/W3/za7yzOO44nQBvlsvYxNm34j95vyO6oWsMvaaozkz+RalQdkhNdjWIaRq/bCW0fXtDhjKZpR1jTCRVk+y6U70PoGj6OkrDoj0Wv54ok5sQbCYjF5ZhtazrqeeJzAWXzX4rwhDZMGEwZShlgSjRFX06SOli5uMApwi0kcSiKuB2qhbQNxGri+vubs7BWFL8I8j6Q0S8p627I/RY3skHt4OI3MKbPZbOWQkyNWAYNF3WnWieMvjlGC/OYJS+H8YsOtW+f0mw5jLNdXklPWdR2Xlxf0Wpi0oWG327E/HPFedCnGGPquZzidVhHs/vqartvI5MBZzs/P6bpewkl1Hd1stgzDib7bQLVCm3WB4AvBN4AlZ3EGBhXsZ+2SyvooI86FNCxBnX9FCpSiLWvDC12NImFquKTe7warZEPvZDPNJUsLMse1/QVVwUQa0e7sutEsD1zXdcSSV6CadZ5uI1j8tm3xPuJ9wFlHmmeatqXf9KuzZ1H3y6uqLbLS9x2n6cR0OAC6YeWo1XJZdQ8rB6Oyzt+XbkHwXhb8mKingTJMmJi4evacEDpC1xOMY3t2zjA+EVAd0qG++/JtXnr1NmfnPd221URWR9eds92esel39F1L6xeio7A0bPCEvsV5SSluQiA4EYgGVa3LwmhWR4ixZh3V5JrV+WDIKWGqCNdqEZunhIqJ00Y2PNVhGBhrVThQyzDMLBbQanTEp5TKqicxYG2JL4VBypmqo5yirpcF0YxRCyvKmdGR4FKcwItdDqHVeiP004U+mXLSmbJfSajee9wv/F0dF6JjC/tCsYGcsIou6NYIgG0ZK0gnwaw/G2UZDcpnLURQ0f3kZQxXxGFhDDTGcf30iocf3+fp/ccShKg/I1as2MumV4syDIzorUIIBCe6IB/EFTOOk6bwCgzPGmnR22pWQbfYcIVS6zQC3iOk03kYGfZHGuslJbUm/ZwXTZk4UpauikhUfhFnH6zBjJEnH33Mx++8Qz0csSmRneGUEvtx4tnVc6wTx8Juu8UbQ9sIq6VvZc7+8U8HhjjTbjZcvPE63hhsE8hGiM5y3TQrSg1FQh9e3pc+48h91LYNOUFohDj903d/xsOHjzkdTnS+xRpIxwNziZSaNXvIcuele9x+9Z4WKGIXf/L4CR+//zGP7j/EV8fZ+TklJsZpEF2C9QzDyHvvvc9PfvIT7t69K2Mn+TDlOdVf3kr3RKzq8nw0IfDaK/fY3b7g+f45eKEgi71dGDOlSu7PQjU24YYVU5QAnWulcQFUh5Wp+lxJkWuN5fzsnFvnF9JtUntuqXrokr6hdj81byhLmJ0QmBdjBOoGazEaKhic43y7I1iDNZXdtqeYyP5wxRRnEVHjaNuOOs94H+TfPg2MpyPUS3kWy6JtFLZQ0BFNzokpTkgYYKBtZTQcmgBHqWK7rmF/0gOsd7gQGMeZ/X7POI5CuOYF6rB2ma12yxcLr/OOXLJSZQWp37Ytl5eXYof3jtu3LpRnIiOis+2O02nAa1Dqdiv3zzjqmHWaCKHRfcsz57Qe0JfAzWmeKbXSdz2n40lcPk3LOE20TSNaMM3R8iHw5PFD1cvYNctrGKVjM7uZUiylSiH4y75+pQuUZf64jCNQtXvJsrA57+k3G6otAoJSTQJZKu9O83Gck3C88/NzIcBa2O12Yg/zHtPJCfvy8hLrHdf7I2fnZzy/umKz2RCawP56L9hfY+m7njTPGGfWFphRMW/f9dg4C+I+Jz2ZO7wLCJ1VRG/OOozJy6GXUrIKHWVPMrrx6CQDYyreGMara64+fUDAYAVWAhjarmMuEGcZCzkj7fC3Pv8Z/q3//R9w995tQivzWRc81raEpsd7uYG7psHWRNUkzIqEvrngyTULsdPIbLcg0LWbUaPRE1OmZuFlFOWRzOlmbGaQlr3BqNVVZthOvw/F6N93MqIxkkRLNQrcWuypGrMeGvnxrWzs4gYQLVGpFcqMt17GQGWW8Yi7iSmoKjEotWIWJ9jiv4X1xLz8mKJtkoVawvICVi3UFVbV/dKlkU3NygjPOCmIzA0Q6ebfRRtERjXhUtSkkvWULjENpRS8FjkLWClqoukyJqx6Txgq8zBCTGx8y63dOSZZpnliJONtkJOPMXqKBaudKXLFm4rVBN6SC9FKqrPvgzjd5glqWhN4TbX4ENQmnpnjiMvyrJa6OAIE8S3PitGOiQa2lSLjBvngWfD2i5Os6OZgp5l4dc1HP3mHw9OnbKxspoep8GQ48ex6z6BRDL1zPHryGG8MfRPw1nLeTmycxRXP4dFjru4/4Na9e4QQiFJFkqikFDWsdCmY6nonmEU3pjIVKQwzfb/D2MBxGPnpT3/K/nqPRQ8c84yzhr7rmOeJftvxuS9+gV//67/Jm1/4LP3FmZqzKlfPnvPeu+/xg+98j/sffUIcJqhFYIimUoM4e66urnn48CG1Fpq2J06TaCEUBOZ0PIMxmGrWbsXCvDidjuIQaRw2OIW1FZKOHZ21DNNE4z1NF0izaKasdsikM5i00yFfb+oSNXFjanDWCQHXSKc510yqRfULMi5enmvjHNM8st/vud5fy/rtLa46KXqyER6QlRBY7y0UGd+aAG3XgC2YKgtr0zXMOpYNXQs1M55O0qXxAoVcBMZd23N2dqbRBdJJm+dZeEebDY8eP2GaZyEwB0tIZu0aFSClvNqJF45V5SZtmLoUWxo02cq+VHIEoxlYfSejowrJLqwhceE570l5xttACC3b7Y6nz56z6bfMc2K/P8g1Nzd70TzPHA4HQisFSQiNWoXFmr3ofCT+QWCgy8+wHKgWN09KiTY0zNOMNZIpBjK6MlZCMouOuH7Z1692gQLrKaoYmUFXTbQ0eZmB6SlVFek1ix24KPmw60SfsrS9drvd6v1v25btdrtag0vJNLphW71YsWSCbZlSJNRKaFuOx6NgnxuNtG5bwUgbEVC1qeXq+sCcMt4FnBW3UddsyHlgnJIu0HZdlES1nanFi2C13hQnLLbyWplOJw7PnnN5tmXTBCFK6shoilIgkBLeW9p+y+/93u/w+7//u4TOEfMk0CrrpNJVTkHOGYzYFE0jQDCr6apzlKhtSc2Fvmkx1jAMAyJIdb94uaq4mZzT6xKznn7EbUJABWoyikA/NwF0ViiqSzA3WSEiK9ElzJmbBbAg5Fbka+c5CnyNqidCi1cqqW9a4a1YEadWU1faZ1n6LlX+axFBLguqKQVTbroiL0K6nLNEDZhbHuhShdC5/u9SxKJXq3Zd7PpZsehJlmJURx5WOTFLgnZ8gWp881nfnMRCCCuVN1graK2UaZznbLPleD3IaKWI6LlRHLVY6WFOYr9dkmIMIh4mZ5wPUjwuWqkqXc2oi5jg/8Xmbb1kucSUSHlebfhQMc5wHE8cTgcahSGWLMUmxmCr3vC6scm9Lx1HR6ABApaPPvqEj9/9Gbu+p/GOp8+f8unxyLOYiKZiNhs5HGRh5DROcqy64Glq4VzdKaf9keOTZ3RFIF3PUyTVTLVoINyNQH8ZX900r4VAuv4vI/fVbnvGzz54lw8+/Ig4z3hn8dWSEaqwsHgcn/nc5/gbv/83+PKvfZX2Yks2Au1yxrLperrQ0jcNf/69H/Lw0/vUmLnNLRlbkhniyOZsS9u0qh8pxHnEY+ibju2mZ4kAKFHAiF6zklKOSr2VbidGLjVagHsno4lBQZXVVapV5xKGxgdizPLzIMX4YmAomvq3pDk740X3pWLy6vSApA47a7WAy6LBcV4OEXOKymlpmNOgltaIwSkGAY0nUOR8TTjgjTdf43g88PFHn2KQTDTjHCXN6/MzTTL6wzmq8foMWpqmZ7s9Q8UFOOs5Hk+E0HBxeckHH90nxlnGWylRi9Puj4qZ51mJ3/rZa6ZYrgt4bdbCRfVloaOqOHXJ5gIEFxD1cGsc4zQSDnua4EnzhPcKWauGaZqFVr5o76yMhTddK+Grs4hYk3Y1jGFlzPSbDcfjUUIJm2YtRpZX0zQ3AmXA+0Yz2pKQo1Nis5FgxOdXV2oWABec6IJ+idevdIGyti1BT8R1VfkbI4vgFGdC2+B1Y60qysQYgnP0/VapfiJaFHWyVR94ZUE8N01gnGaxB6fEfr8XVsY0aRjejG0tp+NRsjDcjZBoufGXnJ2UCsfjiXGe6LoeisEUQ9v2nIaZFAXFLJW6UFKXzVAAR4vZsiiZUuy8tYgYzOVC3wS2247DFGlbUVdTZAyR40RNkd3lOW+99Tq3bp0xzEeK9qrjEpSlJ+ZSI9SC0VNJLYWw4PcXzY+VhNicq4SCLeyWWsUerLPpqjZCW6VjENwidowYfaCXTdW+ELK2XIu0dJhUWJazeOvRcVcpWefrHaf9gYefPODZ02dYIzyc0zAKLM4ZXnv9FV595RVKzDfwI8Bgl4mRtmGtjkrsKoS0LIWIPvjIZ2e8MAhiimIvlgsv12z591U7AeLQkId+cWyxXmsR7irOnWXzX0S5aAKvgtRUpGy1QJIJQ9GxWVY3ECtsrOSCbaXbJ/cHpDSrwBOd8VftwAlfyNqK8wayASPjVWHWFCiWXCIFg/EyEvONAOeKBjTKOTILobNG1ZraG/dYieJ48UoLLlJ0Lg4NY17A0Gt7omiXqwmeOs2YYeTh+x9Sp4hvPKd55MlwYDQQTWUqwvAQvL0VHo+FIUVMcBzmkVt9y65pGKfIp+9/xMc/+zn3vvgFQhOINWuyroAf9YKtm4fVjk3VcUZBxhW1VrVqi2vi6vmVbj6JYCo1R6Y4UVrHG2++zr/21/4aX/nKV+h3O6Y4k5dvZWVccPfubS7OdnRNwycffkLNRSjE3mGDJZXC+eUZr735Oo33TKdBDjgKX3NLKKSXjXJlnlBXbZPXDKSoThYQHcUiwLbW0ASBrsVZgHVUdfbZFw4XIPd6zgrXtDTOy1oVhCa7gC6LM2DlObLmxqnYBtkMZ42ZmJLYaKvhhbRpDR7NRfVtTjZ9KudnW1576x5/8G//Pg8e3uf/+n/5vzFcjxyHI21oZURTJCtLssBkNJyLaP/inLHG0zVbvJO08FoMV1fXq3UbWJ10KUW0qS+bsnU0TWA4jVxdXRHTjQtUv0CFuK1EsdTKMJwYhpGu8ZzfOscYI1lv3mhEgBTnfddRihRwVkdGTdNwGiaCb/CalzNNI5i6wthkfwr0fc+8AjQNFxfnq53Y6tq1EGKnaZLDTq1rJ2XZ44wxHIYT3XKt5llHuUryznIQk2f4r0CBsmwi8t8qMLJObk59QFLKuKaq6yPfMD5yIlZWDH0IohOYponQOKqY7gGtso10W4yGpWEkP8OFsBYozaL2nyPnmy2+8cQ403e9uA0qTNOsoiWHNUL5DKGlCS1zEqqrc0GsbWq9895JO9va9Qc2Swu5slIsixDeKFkWl6bxmGmWP88JUqbtWtqmkSLIFI0+nyg5YY1gsS2AqrUrhZriuijJSmk19t5ic171GUtImbGO4AOr9kSND7VIcWFYmAYqZMWAtgBB4G5WtUJ21YOY1S1TkI6IaDD0l2biWD3Z7J9f84Pvfo93f/Iun378KfMUAcug0fTdtuX3/43f47Ovv0XWuWhNmapsktXOXY3827o4VxYCp7YqK6t7zHqZWS+CN8qi2Pc3lFfQubGKuqmrkNSYumYCrfd0ls6gWyzPSPJy0Q1wEdM2jdAcFzt6ynmNBaha5NRSMO7mvdzoCqw4q9qAsYaohaJMz0QrZZ1l8Wcb0BGdFPwW4aRICnWgqLbI2sW1AJTCPCVs0a4ReXVdZaOUYG+Z8ywsD8I6xkGLW7MQgPX3qxFx+OpSqnD18AlPP30AqRBN4vlxzz7NTNaSKfjGE1wjHdEsRFHvPadpYoyRYA3HcWTTzpgKzx894fHH93nprc/gG7FRr+uLds1WDYG1q+YKZBxorf53yfR9S8qJ4+mkQZx6P1jl3tQMLvDaG2/w9uffpukEQ15sBa+OrCI2amcMoe/5whe/wJe++EUBB6ozTATGco/4xjOPI3GexH5vpdDr++4X7OmwjBClGzqMw5o11jYN1VgZ21oZt1gnXI6sY2qv93TOFVOl81JKWjVji0bQ4ShJ1oGaC66RzXa91sDl7Vt88ctfZJwmPvzgQ47Xe5xxkCVvqVYJEo1ZxuNyKJVurRQO0tFpO9FGpJw4Oz/jd//1b/I7v/vX+fGP/4I/uX3B4zlT9YDg2kCaZ2KcfoF27ZwRfboeGPtuS+Nb9sUwx8T11V6F8K2G70kCdts0xGLVAJHI2azBsbK8asdNQ20XoNri1FwyzMS16dZDbmhEN1I0LsVZR2hbeXZNxSOiXucCwxi5uLgUvV2K7A+GeR5lbBSjOLd8s64fGMPhIOG0McZVj7YG0xI1b0diUeZ5pu97rPUc9nuiWoordQ0uHYZh7SQvRpL0S3ZP4Fe8QFln9EufVU+pmYKr4iLZbHpwhpParhrvmbS1aqyIObfbLfvjnu3ZDq8bbNdvaLuWu3fucnV1BRipbI1U1dvdTl0vnnFS2JsPuK3F5MpwPLFpOokzL4aUC8ZI/obznkbHL20j4iqxv4lQtHGONEf8ktIKIliK0LVWE1etnnhuRg62ygUt08Cub9n0Lc+PJ/l6JyeeXKQQqSWr4FMwyTgr38NYjD7kKY54b2msknpr1U0BxlwI3uFdKx0V5zmejpziQW2xUhQ2QR7cmgsV0UgsiHpspZQlfVjsh07dVlZDpcwyNkAC5qzqL0rJWO8xVBEYKrjO+wClcv38mm/9ybf56OcfcjoMHA+nVSRbgW7bMB5HSVLNReBS6vaqOhasWkSt2g9kHl3JizZ1neljkM1WH+iFFLssImgnyKqroWJX7LScMNJ6D6e4dM1YRZc6spfNJ99kGsHNpp2LdEyCcxQVHFNFFNk0UkjnJMRKH7xoebzDNY5YM7Emgm+xTWCaBv2spC1v1HWUk3Q5Ftup9Vb4J7VSiixESXkl1llMEN1XzIXQhhtdgtEAMx09lVzkfXYNsWQBo+lmKJs/sHStWNwiMuZKMZE9eGPZP3vOeDyQ4kyqhtOUSDhSrpLFEhoudufsrw9cX12z63ru3r7DpzGK9sF6Hu2PbPsz+tAS08BpvydOI/3dS3xi7aKmNWpjKaKtjOhUo1BK1S5ixjm/DnyOx6MA0uKMr465VCBRvGV3ecFbn/8cZ7cuGVPEBPk3TTWqS0MIzV6YPecX5/K5FFbtlAEcFm8MBWXltI1s6kY25N12x6bvpXMYKrM6PZz35JTX8DnvvBTN1lIXTo92buUZ90L7XXVZlaWNXbKgG9aSTTsJpYh7a+H1NCGIDiwnus2G3/nt3+bf+dv/Du/9/H3+H//k/87HU+R0PGGQ+7XkSjGG0zgqrM6Q8o3+Z3F79duOWCach89//rN84fNvc77d8PKdO1yen7N/umee5N7z3jHNhQyaaZNpTYulUPT5b7yMXVx12CzRI9NpkNGgEsupBuMCPrTkYWJxhTon3fV7d2+v64bQn6UQGU4nwVaMI6fTQNt2bPqe0+EoIy497PRdh/eB0+m0FpfTNOGDo20D18+fYbDM8SgIP+u5urrGgMJHLafTkbYRjdn+sBdtSdfRti3nZ2d433DY72U807TMc2S72XIaBrFyty1n5+cc9nvB7w+DjN+cxeApMakuMTAcT5pVJ+/fWEucl7ym//XXr3SBYpxM5hfin2R1oMXCTcJm07fghO5qtYLbbjd6MTyhbZlyxAbPpjnjzp07a5pkwdD2G6y17Pd70Q7oCepwOKig1K6bwXGcKFm5EfrfTdPjQ0vbtWy2G1K+BrVe5SzpmdZC3wY435GijGpKSsScSYsOwchmnBGnikCqxO7nrcVbgy+FOA60wdI2kguRclmUtKQiosSlSs+pYk2QOSyFYsQ266whWKNaEYQGSiVbAahZE8ixMp9mhsOJJ48e8+mD+xzGE86KKC6EQNd0vHT7Drdv3Wa37eXC1UrrG2KZBZbkvCzAziBRs0sRIl0McYPY9WGXEDlp84utHLzafMkFVw0fv/8xzx49x2RHnqCxHXMUTLTxBnLl8uwSbyzVOiadja4jQt0EhRYqi98Cb7LWCip/cVHpzrN0Lwys9550nuTfy5i16PiFUZY6iVDI2Isncutl1JN0lNO6FutlgRTuiV11Kk7b6bUsAX3y/UpJDGNaPz9UwxOz6Cl813CKJ4Y0kRwUW8WVYTRzxTqhCVsnxbSOsxaeQ6GQaiG4QBsCdZJT9cXtW7z1xc9SvBwQjLFsNztZsPWatk0jPJu2486dO7z15ps03QLzk+pMslIsOZY180k+X6H4etNSY8SFRjtt4poZ4wzGAV66ixiCDZztzhhPI8FZdpsN57tz9ocDx2mkeodtOo5TxPrCrYsdp8NzHj78hFdfvq3wMIe1skmmlFRjI5obwd7L6VtcPdLVyLXQBk+qmXEYIGesNKmoppItZGPY3Dpnd+cS0zcUZOOs00xNGWNfEL2AnmoRmrORhyKnhAJkZLRkKqkWtZxLl8sYsfYG6yRXSoXoKYpQOVhP6wJBR7NDiYJYGCdO40AqSfgn3mIdNEEKTWcEvFhSWbt2cnvq+KtqgjRSpC/CWGugcZY2OO69dJtvfO3LfPaNN4jHE71z1DlSY8a3nlgyY5zocieMjpSlOMoZUwypJqx3xFy0MDTcvn3B17/+VV67d488Jm7tLjjb7pCASnkWUo7EkjnFmeeHA6lUts6TyNiSV8eoNZ7gWjahp5aB6ThggLOzLc4ahTwGqrHMSUaXzlkZYQfP4XAQ/lYn2TahWbqPiOEiBJydJHG5iJ5n03b0rehRhuMghokcBVlRhGs0zSO73VYy1VSYHueZYThwPBzZbDaSOuwamibQdZ1Ec/QRaxxtkOypruvlouXb8gzNE13fsdn0tN2NDqXUTL/tiTFyfbiWyYPzOG5Ix5KN1KqGUbPzbm7fX+r1K12grNbLpTloZXzgvdD0jLZ/J4VPWdVJOC+Y8IVPstiKl5n/fq8pjtOE989/oV1VirTcj0cJzXLBrxcDLNM0cbbbkZRD0ff9aukzpjKnSLfpmeKMC57jaY8xsN1uhfY3RY7H0zrHnmJiSklObVlapt7KiMpS8UHbKC+0Uo/HA8E7tjuxT4O0INtOoEZyerbMMbLfH0QvEiSQ0CAqeOzShkTyKUoB5wU57z0pwofvf8gHP32PBx/d5/4nn/Ds6ophFsy5ZD/IAnjnzm1eufcKb39WTjEXF+dC9fWBlm4dnWQdF1kjpzWKaGGctk6X6ykckMpN50xtxaasp437n37CcDwxDSPzONO1HSZAqmJbPjs7485Ld8FZ4pSEN1LVReTszejQ3IDyqi62y/hwjvPalr5p2b5A7TRmLQTXAK4k2S1LbLsQI8UOv34GyzjN3Ahv13tecywWYukaoldkhBickI2lNRx0HFLlBFyF/WK1axNTxnhPu+kIbcPuYisFvvf03QUiBanYKu3Zvu/ZduJaOxyOPHr4kMPhwHwUnoXVxYlc2G62/NZv/CZ/8Df/d+ynI2OKlFq5OD+XZ0FdDE1oVubNZrORbpMVYNa6AevPtxRyy32QS6aaSqPzeNH+pLVgS0m0RSY6vJUi4dblOd5b5mng4mxL13hKiuw00VzyhAo7Y3lpt6NWOOz3UlToZ1eyBKW5Rk7qS49gmcejhaB0DZak33yji5tGzUK62bwlRM6xO9txeXlLrJ9xUreaXYXaVCEF11rIVQTfqAbMWOVQVClSSpUupVGkbbBBRsIYzjZbutBqcrBkS+c80XYN8zjx9PFTPvf5tyFXjtcHPn5wnwePn/Dk+TPGWbLGNn1H2wVefuklXn7pZc7PLtYkd2cD/aaTjVnHs8bYdTQRbFj1VCklnLf0245f+/Vf4wtf+ALOGi7OBQhn9RCadC1MaomdxpFSMm3TYG1G0Prq+rOwOdty6+5tXrpzh1/7xq/Rd1sMEsmwaTfUXKUrrlTkRUs0TWKvXbAVVkfr3lm6vrtxpVTD06vnHI9Hzs536lSqYoowq3NBDhx6j8uSoutCLQyniYXrU2slxhmMYbfZUgucDidJIfdeSbOevuuI0RGbTBMa6SY7Q9d19G3AGEvOkJ5fY63h/Pwcay3n52dstgJV88sBaukQF1atYylw6/Ytaq10mw3G2XVPnOeZOUaePXtGzpnD8cAUZyqimWn1eV6S1Wd1AS26MowhdAGO8Zfa43+lC5Sai3IsltOkqOsFhW5VRCsLVS7LHB1xu0zTKhxMKhiSCjjx9OlTYQQsFNBaORwOAKScxLoMK9F0sY9GHdFsNhsOab+KiUDR+V6KoIU0Ki4i6SrkpA4Lbcc3TUO/OfDRJ5/qnFJTb/XUM88JKHjrienm5F6KFChiX4U0RyFtLiOdRTsBUGGeItYGvJdfi9gUhYyVIiewUkWl3fVb9ocTf/mjn/Ddb3+X+x98wnB1YB5G5hQZppFhPOGsaGBySjx5/JhPPvyYn73zU3727mf5+te/xuc//3kubp0JmdZKIN0y2ihORJkvgq+W+frieNGp/bpZLd2E4BtOxyPHwwkqHI8n2biM6B5CE8BUXr53j1t3b5OUZ5BzwrpGskeMdOfEui7cC2dF1b9ai3WclFNaFe5L5+PFa74wcBaK6zqy0muw3GNJXQlr98QsomItSNyNG0qKtGX+wwufk9x/TrsyS6SDs5LcumhPCsImAeka3b57m9fffI2X7r1Ev+mFdVES1mTOz884255LsWktm27DbrNlnmZ++IMf8qM//xE2GjJQZimqDfIMfPlLX+ZLn/8ih/nEXJI+p/IzmLWbJBv1UnBQReVjVQuEOndEV1yhZqxz+suSykwukWAtaYxCct70hNKSgWEaGJ4NIm41lavnzyglc+vWBY1CCK+urnh29ZxUi+TJpEwseRXOGwzBLxqfJVlZNsSlWF2e5+XeWIqUJUMppaQjVSlOvRZalJt7wRgpPhbHFVowW6vJz0a4yGiwX11MARUJ6XP1RrDojHb+LKUaaiz44DAZPJazfktrg4Qpytwa5z3zNPP40WMeP3jIJx98xEeffMx7H33E+x9/zKMnTzmOJyqFruvwQUI/zy/OeeXVV/nyl7/Ma6+9Rr/ZCP7cO6ZldLmMiWqVNcZAjInZRay3+OB55bVX+Mavf52zc0E8lJyoOgppQ0O1KtitUGuW0XS9GQNXPdSlIl2Buy/f5atf/xqfeestmrbjeDxycb4VR1KxeNsIakB1SNZId+B4PIjjxoqmzOgI1RrDbisZRplKpnAcjxRbubh1gfOGOE8iENdD7VJ8eBWYussLcs7s9wfiPIs13oqjKafErctLjvujjARTJsaJE4lx2nLr9gVnZxu2uw3D6cQ0Rum4+A7vneLsRwxWnVgSdNk0LeM0st1t6fuWWgvTlCiKuABIs6Ze54TzDV3b8vzqal3LjqcTbduqOxOGYVhp4aUU7aBZpkFiF3pFeKSUODs/Z46RcVrCOf+KaFCC9zhj1moQs1AbtY2oFkfnIFkB/Sz+e4elazvatiNQcUFwzUYXdyk8/Bo82LSSNyFtMgfIrD3GuIJt5jmy2WxExLTJWhHHVci4221YKKHWWoZhENtrWcinrEmp5xdnnF9eMKfEe+9/wGmYxcOPjEKcW/gfnnma1uj2WiWAUEYsHmeh7zuGKYtew1l9cGQhldCtissiyFxoqLVkqrN4JcViDSa0fPzpI/7sX/4ZP/r+X/Dg4/uMVyfImTKLULTxgWZ7vupEnPHUXDlc7znu9zx79pRnz57x+MkTvvHrX+PlV15a3S3WSNt+OX46H6hVTjc3uUt1fe+AOJgWp4t1+Cbw8MEjHjx8pCpzcTdAVeoquGD53Nuf4fadW8Qqn7cPHued8DsAxYUKYCpninYdFgaJD1aFgPLekz6MoumUohkrfAnZY8UeWbJsMMtJD1TbkrOKKhe7alVglV/vn6KnsIWlsmgalnvWoGLfKp9lyVUC1HIRO7ez8pkiIybnHE1o+frXv84bb75JRRT+qBYnzxM+eBoVMTojgLXGt3jreP7kKd/7zneJU8ThhSqqCZLOiLuAWiXUcJYE5TlKce6dCM3neVqvn4C5pGPlnddZ3k0BJpZsVh2EdA2rPmeJ3ltdGAvz8cgwDIzTKIuqB996nl8/4zAeuX3rDtYYpmHi4YMHpJJpuo5xnmiskQyiWnFaMLdtD1UsuFDXDojxakPFSkZLlBHq4uqq2iVY7L45iQW+5LIWiehp3TtHjonGeRxOUiopq1jbGkMRNTzBOhWWi249LaRbFd4aZORn9fMrtYjVW100fdPLeqEjklrlPmzalmEY+e//n/+UDz/4kGdXVzx8/JjDaWBOiVLBOsNkTsxpxnrLo67ho/c+5KP3P+Szb7/N5z//ed54601uORFolprXTlJVsFkFjDNkI0nJF3cu+NyXvsBbn31LNkldi4OT8eI8zRrUKoeXlCLjNDCOg7iWUtSIEIMxmWo83abnd373d7h96zbVQknCM9luz2hDJ/qzAouAZsl/mqZ5BSvGeca65dnNNK2n6UWndTokjuPIEEe22w3eWY37kAiKhe7bNi0lJwkkVOBnv+kFvJbkHklRXFBBQWfD6UROma7v1ARY18OtHQzH04nj8chms2XjResHwj3ynhe6U3ntusY4My2fWQXvgt6T6gL0Xmbnc+J0EmjjNE2cTieJRzg743g6CTdss5GiU0GnTdMQx5m+kcJEzBues/MLMJKm3vYbXR8Nzw9Pf6k9/le6QGm7TvQntSplVRTEdglTSxKdbdUl4IMEGjnkxjfVcNgfabpGbLIaJDiNk4h5tF1cqZJFMM+ySVgRGuEsTdtSSuHq6grvG1JKPHz4kPPd2XqiijEKhVZhN33fS3Gi7o+grIGofBLjJQH5/PySB48fKw5eT8jGkLMs1jVXouLeF6aBdDEGYo7sdluCRoyXIgwUp4TPqqLKcZqZU8ItRdLCFTGQaxbeYttgquPp1ZFv/+mf8e1/8S2Oz/fsn17DLHk8JUtbr1kWH2tIqgeqVGULGK6v97zz03d5+PAhT6+e8ru/903efPMNGZ/oz5EU614FfPEL3YmlXQw6jlex5Fp0Gcuz/YHjNDFnYQw0SrlsfKA60Vxc3rnEOrMq9kUEndaTz3I9ls/2xVMu5qY7Ug3MKd6g8BH+ha2LtkQonFFznFJO1FToNKdkHEfMkmNSJHvDYDSfY/nZPPKBiMgQj+K+69o5NEYs6NMUscHRtJ3qj5TB4uTZkDGaXQurysz2fMdmt0XSuqXQb5uGNM+q7VXKpw8E62h8w+2L29y6vMOm2zLuk9yLOVPSTS7K1dVzTscjyQl1tRSjWhCYUsKuJ0zpOEhbXX9eLURfLFBAsqCWojVXyaUCcQBNp3m1Xh9OJwlwBFrvyQGMd8rNKHz65CkWS+MCcy20XU/oGkEOUNb1oxRxmVnnVTckRZExN616qjwzy+8JBXXpjFSEYSQE3ia0bPpeYHlSFaydX2tkRNb4oKA9Jz9jtaSUiVWcF7WUG92Js/iuwbuGMU4rp6Su1m51/1XZi6mFgqHbbthstxgvI65qZLRnnMWWysP7D0mTHL5G7UI2PpBrJY5RnGVqx5/LTI6Znw8/5/nzKx4+eMg39nv+2m//NXZnO8Z51HVLkoyt95CqFBa1cOvubf7GH/wbvPrWG4Q2kGtinicMaAaNcDq8tRgrz7E4/KQg1MdXunPGaFFU8G3gdn9XyaZSHOVS6ZqGJjR4E1TjprlAL/BKYowSfpjFqRRTogTot1tC08gznTPHcWAYR3ZnMg48HvcEFySXapqVdxRE4Kv3yH6/p9ZKv+kYnp/WPSJ4OWyehpOKryvzHPFBAIpznGmSIx8l2HYaR3F/zjOYKvEUp+MKklvWylyk6ziPMyFI5+50HLh10dN1nSSKa7d4WUtzka5PKYXz8/O1UDk7O5MDY73pADdNIwBQNAJFc/ByTFyVq3V8FppmHQH+sq9f6QJFZn1m1QU4JzCooqfPUivjMOBykFZogTIluhAwIRC8J87CNmk3DcNpVKpfZRwmfTiEa3HYixr57GwnYW0xY8qS1is3dcmVtmlXn/kSYLeMgWKcubq64vLyEuec5PRYac9aHSkUXQSNXpqcRYTnnYyiFtseurCXKvqCAsRUKNUyxplcRXjbNB7vnKDq24bgG67070p1jTw8emoPSiM0BpxvKMbim5ZHT57xrW/9gD/99nd4+Okj0jARjxN9263anVqFQJmTLNilFoqpGp+un0cuHI5Hrvd7YpU4AmsNr73+msza1YlSqNSc11wpMXGYm19IkaAfhbyMIRZ49OwZT55fMcyzCHyLRMnHOuMay93Lu5yf71TzsRR9N4A0sa2qnZxKrmYdxQB448k5rgXnYg1cOiLrXF3FnMt9UIokXpsANWdscHSbdt2krXVKvy03SP26MGWkSzhp+qypSsNVZ1ApS2iafP9xGmUkaMReWxZ9j94ryz1Ta5aTvBF+hYmyMM3jJI4lXehyAZMLtVgMhVIs3rU0zQbqtV4howsbYCzWNUKP9VDmyjiPKhy9sY2vcDPtPIGc5BcLNtW8UAjIZhKaoLb6hDFrH4lqLRe3b9NtN0zX1wLyipk7Fxfs88RAJlWYSmGaI5t+S5xncgFbDa4aScQu4JGTfpoToe2wISiqXem/3lHtDbdnue7WgvVSzMj4JqueSe6P4BzbfiM5MDbKSKvKfVxSoXGBTdtzttlRaub59TOOxwNPnjxjf31N44N+QpL1dXH7FrtWTt39ZrN2RZ21tF1HipGcpdJLRcjMWIQC3Qbh/BjELVRkBGWyjJTjnCi5EmdhDXWhI9eyCti9F01aymldc0oqjKeBeZponOc3fus3RC/l5fBQamWcJkwRvZQ1jt3lBT4ELm7fggWZQFULvHyNUzJ1mkX7Y5GuyjTNcl9YRQDo6Uqs8UsatAYFWgtGRMybzRYwNKEhNGr518TkcRw0M03GjSlngUYazUhjOSxZhnFkvz+w2+4IwTEOA4fDXkSv2y3PDiPTNBC8o2vkENH3Hd5J4OGyLgLEadbudcEo4sEHu649YhdOcliwTmIagieXyvX+oA6/BHUmKCk4tA1N03B9fa3FyID3gc3WruRgWTrV4agH16Vru7y3hZtyOp1EM6eQtiUuwVtHMGI3TjGy6TerdVrGRh6vvKY5/nL6E/gVL1AWYNWLan8r6xjjLMmLMSXqJMAZ6ybIma5p6JqWp0+e0G43nDWBUuXvACpmi8KJ0Bb/gh4fpglqxrmAc3ZNM3YvnAY3mw3jaZDk0LYhzrO0xrzYO1PJxBS1anb4Rk4ISUcZtcBm01Bq0dBCeS1Y7awPziKsMmKGAwfGS9s850jfNjTe0XhH7cJqCVw6EqWKaDerlbTUIjwYFbJZTSo+TTN/9v0/53/61v/M4/sPIRdMLlAy1lRBb9WkVfwSWOdwGoK1dARyLeAWmmrhwYOHfOc73wEq/+Zmw71X7xHjzJyj6IvWxeYXdRk6dl9fBkNJhdC2XB2OfPLpA8Z5phRoupbGeUqNmCw5I6+8eo97r96j5kTVdqR8n7X2kY3beSkCsoxTip76cynrZr8UIUsh+mJWz4sC2WUeuyDGF93TpBZ15wOGStBr86JYdoEjgbRc27b9hTwLeQ7ks+k2G7FZX19jum4taKtZdB9mhZwZfW6KLsyCoamqU9KRIcI8wUiab64JsmGaE961tE2Ps15GR8XgfIO1olt6dvWMcZ4JThgLMu8uNyMv5H0txcei2Uo6dlg0IKsLxJq1eJN72EItYls0jnmeOL91ycWd25TTkX7u4LAnDoXjXG50PRWs81gbKCZBzdSUSGPFkPHO0BhD48Vuf3H3JbYXl+AavK3MeSanLB0+e3OP3jBRst6h8kscd4L4t0aSXpvgmYxsxl7R5iUXjvsDDz79FOcMjx8/4v0P3ufZs6c8fvSY66u9aD+cOKw22y0Xd2/z0qv3eOWN13n1tdewpmKyjLNzjKQ4/0IacSmVuWRs4/FtIFEotmKDFKUxRxmrVOlEVVQPZGSNiUmStI1VB1nR+6qKDmQ4SE7OB/N7kCTb6Ctf/yq2acRxsuRpVbGsd8HiNy2dM9RgGFNUEKQEE7atiOi7ruM0DkqxthjnmKeZeZrxriEpZ2rJbTJUUH3TTRiBghGLZbPdrFKAUgppmtcT/vL8gYwis6Yr55pp2iD5NdbjjONwdeB4feLuZ16j63vmKRLnxKbtVY/Beshtdhtqhd1uS9u1kuGl32ceJ/bX12sMRpwmGY14R9s2YA3X11d4L5KG4Bw5VeZYaftW1ikjOsGcikCeK2vUymazoes6ur4TnV8jBbQLDViHUznC/1I/t+TRLSaRRU+36Mau1R7tnByGSs4cD0cokKNowkq9MQ4MCjb9ZV+/0gXKGGex0sHKC1kWvyVHp+oNiNEbNEbGEOiaht35GX0v2Re3XrqtHvHTejJeNomlyl1uXMlaaHA+yENcq2waBU6D2M5SSuQoMdWLErwUsY5K5LxU/SlnpuMszq4orUXRJwSaRhataYzUCi7IolJrEY1IRVrcWTgrBRk5nOaRXDJn54LtRxHUJaX1tAFi+5pjZE6Rje1lHFFERxHahmoN1Tre/+gDvv/DP+fxoyfkmPClctb3zNpKhYL14Ky0Q6vSF5bxmGRFyKYoC0ARNHWOPHjwkO9/7/vce/llLi/OccFLd8EsAsmb6y3i3bKOAxY9ylJwBR+4f/99Pvn4E2qS2b0piD2zVLrQsN1suHv3DrvtVroKenKy2r1ZxnxLPkzMCVvt2gW5KT5u3tPSBVg6AiuETX8tD/taYL3QPWhbsRumJJHsyykGbqzKy6/lnlloti9+j+X7BOdkAdKiKJdC04Qbguyq99H3UfV9AwaxxjoV2Fb98It2aZZOWdZfMkqVBU5rHIyXyIRxSjx++gzjHNUYGSN6sfuupzb9mVbKcH3hczV1fZ5XmJ1+wTyOqi9TvYr3xCnSeo8Ljpdee4XrBw/om4acIuM0ctF1zMcjxUBrLLUkyjzhMPRtg8kZpkgTHNsmYFISl4jzbC8usG3LVArVOaxV2/Ky9rxwf8rnniTJVxd2li5UFp2INVaCJWMixYzzUqjUXHj86BHf++53+eSTj/nJOz/hww8/1DVpJqdCmqOOqy3GWTZnO85v3+Lea6/wla9+hc9+7rPcuX2b4ALTOMp4z5u1i7P8CsHRdC14J6PwuljKzSpojTnjRceLdZCNREnIKCwRVS+3OPKIMspz1ZLGmY/f/5AffPd7vHT3Lvdef1V/TiPdOy3QJRvLQuOZkoj5KQKM7JuGfrPDhwZjPUa5LN460a8sn5/zlMJ6GJKLcdMZeFFkPceJzsvhMixdCt/iUAZMzpIgHKVTKeGFCnE0hX675fLynLPtlvm0p8wz0zDhbEPXbrg6XWGNJc6R7XbLYUjkOYoLM0amaeR4PK7axLZtMcYwxyicEh3RHcdRdFHarUgpcjWc8A7u3L5FnCPPn+8JbUehivtqThS7FP8KrnNBf1Viyux2Z8LhibMUTjkz68+6HKC894zDwDjP8rUa4mhQcrUeENIsB6zlEJSmjLfCHDoeDmK9n6M8v7peTeNI+qtSoMzzvOZXoOK5tGgDamUYJ5og8zDBTAuUJ40ztc+88vpr7M7O+PTRI1ncg1gpjTGKvL9RYi/te+cchkJoAgXB5s+qTUkp03Uy8kg5qXB2ZhgGPTnLDb8UKLIoZ6ZZZufO6szV+jXDJWfJtHAuMBcllKoAStrLVoqwKiOeOUUOpxPjNLLZ9CJ2zAnvW7q24XAYVOviSQgALuUoNjBjiEnmmdZ7jG959OQp3/rT7/Cz996XILdcMKUwDqOk4noR4FWj7cB64zgpVSzN1sp4q+hpYSFUhhBIMfHwwUO+/73v8cq9l/ns25+VUY9qS3BW2+UvOB10zu9eyPmRRNGWZ0+e8fjhY8ZhpPWBYAw5zuJkqpXz7Ya333qLTdsKO6EKl9YZq2K1hAuyaObFmm7kMfkFPokz1AVIpcXBAmdb3ufiqFgKlBedSEtRtRQhBagKYDPGrM6g5WvHZVN2i7PkBt4k31DiGYy11FTYbESQXVMSXDdlzTax+jNgrQicc5EQRqNtdx0D5OV+QzoqtRRiSoTGa/tc5tsVVGMjxOOYC3OZmXMiloyzAaxljomFDSKfGzraWazDZR3XKqtWz77o7wvrZtGLmVrUbSSFfusDp2Hipdde4fmHH/Lko4/pg+flywvOEAHps+ORRdcUrCTHboLHZoPFcWvTce6D5FjNM83Fhnuvv45pgjiVqr7peiMsXQqo9f5EYjSWLt8NE0c0So0K8H0Ioo8zEmaaYuRqmvif/6f/GR8cT589ExS6fAAigi4aEpoN8zgxjRPXz6958Ol9njx4zKfvf8Rv/uZv8OYbb9AFT7KiaVvEsxi1RTunNFnH6ZRlrVHwnFCEDUOa8NVL92DWzpcKW42SY0VgK/d/4xuMachzIhUINvHBz97jO9/+U77Z/B73Xn+FOY3rSM+om6cayDpacN5DrqrL6tidn+FcUNClo2s9cxwxVcBoKSYB9a3cJOHdWCr2BRq4dNiFKeWChI82fbuKk5u2E1FsjGvw3U3RrCF3CJreO0VUYDHFcNqfMNXQNB0xP8Nax9nZGf7x8zVWwlTJ31qxFqr1iPrMt6EhpkiK6WY0ktJ6T7V9i6Eyx0ScZulSW+HeLEnDMSeGKMnuxghawjnPYX9gniPH4ch+f2QJJnRWxjyLRtIYw9XV1S+MLJf1OmtneJFUHI5H+qal70RPOc8T3gp0NOcs2kh1LyUdJaWYpKOSl7Hs//rrV7pAiSmulqW1VQxr+7pksa6iljbvhWKKCsjG08BwGpimif1+T9eL0n5WdP2SPbCccpfFc5omul6ETZvtdt1s5nkgbGTubpBxzlHdBCAt6oV9cdOhkc015sQcE9u+W+3L05RVAb9EjhvmFHFuOSfUNe3VWKhVYFHjJFkSrf48KRbR3Rg0I0Y31lJIWUZZCynUWod1iJjNBX728/d55yfvMg0RmwuNMSKejBFjCiUbMorVNkIl7ftOLIuj2ABlPiwnpFVMaiS+fI4jMSbee+8D3nnnp7zy2is0fUOOUboy2DXVeNkbil6LqvqRxVY7z5Enj56QpkiZI2XKlAQlRdoQSDVyfrbj5bt3CJq4GrPMp5f491wX4uFib/a/YBeO6QbtvRQrS/ty6bi9ONrxXlw4FXEJlCK0SqcL1KwaKEHd2/XU7Zxb3UtN06y5F4szLGihArIB5lSYRwk8EwCWBKW1bafvR2yzcgpK1JQwWlB55zBWoH7LxmvMsvEk3Y+zEmVRjVdR5b8QTUtJ1IKGMSKcnZyYU8QXGfGIZNOuc7TVxaQXVoqutGLyl0Ji2QCFyhtuijQ9mGQqzjdkIFtDv9lwcfcODz74gDLP5Fme4XtnF5AyV+NA2GwIviEOI70pdF2DqYWd9+y6Vm4y73jz7c9x+fJdbCMxAAVZpJd01gUMl+qN5ohiqFbWn5wz2UjXpGsDwXl22x19t6Ft9sx1XpH4zjsolSePHlHVSbWIEQ1G3V/mJtNJM69qhjjPfJze5/jsis56QoE33nwDXCXXpONqKaxSzgTjaZsgB7yaadtALvKsLe0w57zwpEoiTSOxZLxr6LYdOUl4aC3SnXRWmEl92zGcBsqcKNbx8NMH/GXzI15/6w0u71ziG7+OjoyOnGQBW7RlAjXLpYI1dG2n67kT+Nk8Cb6+CPBuGsb12QlL4rKi2c2LmrWqRY+TwnCr67ZTF0s2OsZRF9wyqq1amJRaZPylY/JSltgOy/XVNcEHttudpIcb0UdO4whL8ap6kJUvZeVAV6coYuycxbXTyNq33+85nU5i+zeGOc14C10bGIaTIC2MZZqTJjxPYpKY0upCbdu4dmpiitK91zXCe888javWZrfb4XRv89ptRYGPBdEbjeMonSbnREqh68NwOomoPIrLaNNvaDaBUbtAOSW5hv9f7PH2f/1LfvH1z/7ZP+Pv/J2/w2uvvYYxhn/0j/7RL/x5rZV/+A//Ia+++ip93/OHf/iHvPPOO7/wNU+fPuWP//iPOT8/5/Lykv/gP/gPVs7I/5bXUt2+OKd+UZsgmTlSRAdv5IfVD77mzDCcKKWw3W4UMSzjHdBTj7P0uy1N34GzEkzmLNvdmXrXK6ZUWh9UDOnwQU7e/a7XNqFlu93y8ssv473ncDghjgur7bSgFTkq/IrElJlTVlufikxrwlCQ3I5CqVn/rhWxoPgJKdkyRxgjWN8h6Z5FyJUGak2yMKh+ZY6ZlMr6wHnryEmIicfTyHvvvM/4dMCeMn7OxOPANA1kWygWWZjV0vzqG6/yO7/32/yNP/hd/vo3f4vf/4Pf4+vf+Covv3SHNgS23YbWt1grQVvzFCFDiZWrp3t+8IO/5MHDxzinJ/Qq0Cw5CKnADU/BkowQTxMRLPgmcH295+EnD6lzwWMhJ0oWSN+YZkLfcuelu5xfnEuRYx1VQwSX9ra1i51YxMMS2uhWZbpRkWbbtgqEkpYsWjgsM+VFCT+rgj3nzDBP6+ZtgwNnZYym3YFFeLucnl5MDl3EtquOAnFxGJ3HW7WeV4rQgpU2HNNMLuLmiXFmmsWSbl7QTJVaccFjnKEY4TsUC9VWxAAnuqKKuRFkZ2HKSDSEoeRISVGCKE2hOMtYMtGIONM7Q+OcaGeKRB6YWqhFaJ5tcLTB0beiDwva+XwReCefg5GOQ4lIjpPFVKs6F0cNLbHfcPmZzxEub3E9yCFk2wQuvOe17ZYv3r7NS7XyEpU3txveOD/n5c2Wt+6+zK3tjtA0jBTsrQve+LWvE+5cEo10SnLJkpjt5HPIOj4upYizKpc1eqBWdY5QNYpBnrOu74UQnMX2HoLHeyEO+9bTbnr6tiE4mfU7K93NYgwuNHSbDb5pMF5iOawxeBx5TDy9/5Dv/+mf8eff+T7P7z8hVEfvO/qmU+t04hRP+E7GxZKLVXFVXc1ZxkgVGamNKXEYJny/4bXPfIav/trX+ebv/Tb/+r/5TX7rm7/Gm198lYtXthQfSUwM4wFbK64IAM5EePLgCe+98zOunjyl9w3BWPl+WPkaJN7CWSvvxQlws1YIXaswzEwXArZI56ILDd5Y4jhKzlgpCnSTDpYUNVZzZMSKnQ1Uu4wbbxgwyya4CDhjihLoFyW9OlW55lSLbxy+kWLM4jEpwFzpgmfTLSTjQsoT1iZq0UybYphLZpgHIfqWSrAObyBYA7lgS6Vr2rW7IaMrDZksQucdx4lhmiXcz0KpkWk48fjRQ8bTgPeWaRoYhiPH457nz59yOFxDyUzDiZwiplbiNGJqxVtH37Zy3aeZYB1xmplOIlXIKRKnEW/gfLuhaxucFkpNcHr4c2y6lpIzfdevhfziog9NgwsCkAsurM/2L/P639xBOR6P/MZv/Ab//r//7/Pv/rv/7r/y5//pf/qf8l/8F/8F/9V/9V/xuc99jn/wD/4Bf/Nv/k1+9KMfCWMB+OM//mM+/fRT/sk/+SfEGPn3/r1/j//wP/wP+W/+m//mf9N7kXpb2SdakpsX/gx0jFIkh6MWEd81XhbVaRTrlOtEHLWc0hZLsLVuRQQvXY2iD3OMUVMkxbmS6o1I0gfPaTjhg2ez2XA6nfS92JUsK2pqr10aad+3jdPv3xOalmGYVZBpNUEVbSUbSkl494KFsEh6sDGW4TQxDDN37lxSisw+U5pZcmsM8gCkUogqNKNUvLGS3FErVMP9Tx7w/s/eJ48Jmw29bzkx6shJ9CfGwPnZji9/7St849e/wWc/+xahE4CZM47rp1f85C9/yo//4sfc/+QBmJE8ztoudGv3Y5pnPvjgI95//0M++/Zbok7P0voGbtDZLJoEjTcoCiPznkdPnvL48VOmYcIbhw3CUZmr6B+sc9y6fZvL27dx3pFUI2PcC0ySevMZv7g5vlh4VPgFHRHcANeWWe4Cf1r+3uK8YRV13wg+V62CLm7TNP3C9160L0sHb2H+iMbnRvtinbScF63Ii6DBhWOSdaN/0boroyQZZ6WU5NQubQzQ0UDl5vuBKPPbrqFtG6yTAgztdGWzOIukc+msJUc5SXp9hkqtwpeohilG2TTcogPy6xN8I5B9gQ+z5HoYI3EDRe4JjCE7RzKGs1fu8fnf+DVKSewfPsIYhzeOO+eXWGu4Pz+g1ULIOU+MmW3bE3NiLDOlaXjry1/i8rV7DBSK5ruAMDiMWdadqh0o5OBTq4ybzRJPAUXdQTFn4fJomnpBOjfOWk6nAwvTxayCZtEPAexPJ0qWTgxFCmnrHS7LvTnPs/CYvOeTjz/F4bi8uMU3+pZzf4ltdeRkzEqcbdogIze9H7zTDDDn1/s8pkTbt3zxy1/iK1/7Cq+89jJ3Xj7Hecc4DXzwwft8/PHH/PiHP+b66Z7pesBXj8ep8NlTc+Gj99/n/sdf4PLyguqEemuX50KL5RSTxHU4Dfyjsjvb3ejWnHR8ck40ITCcjhwPe/I8KytlwikwbAmsXHaD5RAQcyKWJEJT3+BdIKYZ5yuwdGJn6VIkOWAuh95S6goIjEn0L0bHYpuuo1Px+uFw0C61Jo+LMESeTwMxTlggRQFnOmOgiFMox8TpNKwcqdMwq77R0XUatpcyKS4OoIBz4KK/0ZLpISbO4gpaQZKl4IDGO46Hce0KB+fXA9EaENlK9106f5KnJoenssZo1CwZbwtctG0FMbGMpqSj6GWtLGXV9vjm/48Fyh/90R/xR3/0R/8f/6zWyn/+n//n/Ef/0X/E3/27fxeA//q//q+5d+8e/+gf/SP+/t//+/zFX/wF//gf/2O+/e1v89u//dsA/Jf/5X/J3/pbf4v/7D/7z3jttdf+lX93mqZ1QwC4vr4G0AYbCsO6mVfL4qpFi7bvRawm2oWubSlVwFGyuQugyIebU+WyGDpjGXNmu93KBYzpF3QC4yiip935GUFb8UtMtfdycRZdymazEQKfNasYaRn1zPO4LsJoZ2gcJ6ZxRvDQVUPnJHulbUUxnrIgsrOSJQW3H5nnhDVBq/BZbNF2ybQB5y02FxnXpIw3lrHIAty3cuJ6fP8hV0+fk6aZNEeK1JeaDB2hFu7cvs1v/Wu/yb/xb/4+b332LYL3ZJPlFJ8rty9vceviFndu3+Zb/9O3+fD9D5nGmSZ4YW2kWbKCtL347rs/49d/8xvcffk20STGccI5CVYUxX3WzaiKJbHCPCdOw8T7H37E8TAQ54yvleAaSoCMIZZMv9vx+mc+gw2erPqJAjcOh2VEiHQNXiwEVv6Kbq6YG6U7oAWtXa8nCFdiGdUYY9huNrJAzhF8XYsPo6e95fVi8bCMBJfff/HPbgiyeZ0nLwm1C8thGU8Cq1B2sRcuIwljpIhdMllWF5GV3Jm8tOFfeE9znNhsevqupesCRycW0tAEqNJ2dsZSYsZZz5xGMCL0zvPMOAt4MGjc/PL9muDlxJtfeA5fKKqWn3nV38huTsGAE6LtnGQccvftt4kl89E7PyU+uyYeT7jgOJ1ObDc7bfOLo+r59VNM0xApmE3Hl379a7z9jW+QrCNhSEtRZQVXL65A0co4Lx3QEvMaUXHzflmzekh1LV6Dc7oJGEW2C40TpJNAzozTRJ4HXSvERt0Ex3g6kZImyzoL1mHSwryoNN7z6PFjvv3tP4Xg+M3f+S12zTmJTNcJVAtr8V6YJK3qD6wTQrXcJyKy3mw7vvClL/LXvvnbfOWrX2Fz1oOVvKzQBO7cvs0bb7xB61re/cuf8vHwIbYYWhdw3jKnGVNmHj98xKNP7/P5tz/L5mwneh4pNzHWUfON6L2QMU66hZvNhtDIWAUdKQqMsDAOJ4bTUfQmzinzR4B0S+DnAuZUwZA8o0YgnZu+p2s7pnkkzQmcjCslKDXilcC8iKVyqWzbls1uI1oZJ8Xiog/z3hGTYOBv372jYyYtNiuUnAmNoAuc99JR025JSpKn47x0Y+d5ZhpHvMZgNN7Rdo3oZXxgoupYWdaPfrshpqxxKPIZ4CzeNYq4SJztttohl2Ikq2ZyHEY2282atxQaYWVZY/WAPgkoT04qNEEiE5YE9fE0Mplp3bsWKUMpdT0spZSEL6Yp1r/s6/+nGpSf//zn3L9/nz/8wz9cf+/i4oJvfvOb/Mmf/Al//+//ff7kT/6Ey8vLtTgB+MM//EOstXzrW9/i7/29v/ev/Lv/yX/yn/Af/8f/8b/y+3IONSr8eiH51LCIUvQcJmjvrKdjp5Xh4t6wVi6ED04FP/Pq867aWqulri39RcOyWIybphHM7ziStAuzYIHrCxdJNhDPNI2rglsKmgnvvcZoCxNlHCeuD3sRHVWxbVqW2aoQKZ3zgohXzoG0kKsi96WYcTZguMnAMIaVeGiNWGfjODJPk4r3LdY48pz45P0PScPENIykOLPP0k5tgieXRNs2fPHzb/P7v/d7vPXG65hamKYTWQWZtYhD5vLWBV//xtc4nQamcVQRWlZdRVK9hJyoHz98wtXza27fvQ1Gyad6crVGwslq1RC0nLHe4kLDcRx574OPGYaRql0Xa2Txtk7IwbuzM+69+io+BE7TIKm7KtTL5SYHZylGFrIkcFNIThNN2wjwS+e3cLNhWmt/QbNUXthcF8aL4WY06Z2OSBa6rHcKCUvruLFpmrUYsjpTXzdt/d5ei6kXuydLIbIIdZfNfTnhvNiVyS+cvhYbqLUyPqmmiitr+XNk9tx1DU2rsRIWkgY91lLJc2Q4HBkOA2SksLY39mlxL1SGYVi7V7moHqhIrtWLo9v/Zcdn6Qwl/fmqEfJoqYbsDWPOdF3L9rXXuFsr+ckznn/cEKeJ8XiUjSkX4jhjvCM7x2Qqd15/g1fe/hyf/9rXcLstyXv5c9UjLPbo5e1kfb5lcVaA4LI+6TOmCn4tIhOmFkKQkfCs2qLFJSVzo0Twjqb1DPPElCZCaAiNo5BoW491hTmO5Fn0F0t69CKuL7nyyf0H/OWPf8K9N1/j7Ysd3aYnlSR/Dviupdn0uOMgXd6EWIgXYbqFuy/d5bf+td/k177xNdmYg2eYTuRaaFrLrdt3xDI7ZfIY2T95TpkK3jjGKaqlNGOu4NGn9zld7bm4uMDYSilQ7cIeSnoWKMwxE3oPptJ1DcE7gneibSESWifuRGP+3+T9Sa902XrXi/5GNYuIWOVbZ7m3c9c1NsbXR4hjDroSTSQ69GiBhOQGooFE1+IT0KJJh69wLh2QzjnAvQaDjb339q535s7yrVcREbMY1W08Y8yIN22O09LRPTdFSKl8i/WuFTHnmGM8z//5F0zzWBLaJbwwJBltOmclZycLf4Qk6d8xBBrj6Jq2GEs2WC2InTNG3GZ9YNgPBXGw4shbxBi2aVmtN9imEbQgej765GPm6LFOnLC32x137t0tIYoNsy/+VlFgcLEVEKGFnmR/l1ybHV2/WpoMSRmWIlbGz4ZxHElO8oeUknPCFwUgKJrGMhffleC9yPXL2ssxMkwTztoF7cxR0uzXq5XELIgNLbfFN0XrItKOwhuSEF2/IMdjOTuWwMkg/lshlJTxsn/O04xKir5fFcHKZ3v9X1qgfPLJJwA8ePDglT9/8ODB8neffPIJ9+/ff/VNWMvl5eXyNZ9+/bN/9s/4J//knyy/v7m54c0331wY4KVGFeJO3T2UWtQ91gi8j08ohFh2enbCfp4Yhj0rd8Kql4e3Hjp1E/Tes+5XMgPMiEU10nG6goLM88zz588B2ZT69YrHjx/TNR2qLMiTkxNevHjGbhfLjX91A67jpQhMt3tubrY8efKMcRaUJCVhudsslbckIBdzrOCFvBhlj2xtQ2NbOtejEQ8DZ50UIUod/FCUIkwTw3ZHDBKNXsdk037PJx9+RPIzKXhSDvgcZbTSGJxuOb8456vf+hpvvP2GFAwhEFMgqUyOsth9kvd2cXnOt7/9TZ58/JhnT5+z3+2K6ZNA3jHLJr+9lRwd5xriJM6Y0l0Ld0OULsJCt9Yy50zT9dze7Pjg8ROBR0NC54RXsaAE4FrHg0cPOb+4WOS2QnAtB2pB4IyupnXyqveoPpSCaMyl+zmoaKp/Qo0+qGvHGFO8MlhY/K6Rea0PoYzLLFMQlZM2BkqxoxACq9CXxY+iFkz157bFrHCZfYeD4VxFR6rsefk1B2VJ5c1UL5eDnJqluKZ4T8TCWxLjvYhzRv6zpuRYedQs8lRlFPvrW3bXt6Qi+ZbJ4fFILdNWeL/kROk66ooHB99Yyh16gwABAABJREFU1vrBZ+RQFFaici6eRWj5t1lrZms4efQaNA27rgNnefbJY/qcaY2ELWrvwWjeePN17jx8yJtf+Qr9nUuSc9A0BC3eHFhLTrGo3GW0RMl3ClFk/OboPqRS5IkEM5d7wbJuq1suFL+RHOXzl3TqXEYHKQW0tZycbVivVpyfnIuSAnGvHsaB6+tb9rsB4wqhtDzHu92eX/z8F9x/8zXuvvmIOye9PJ8oaCx21ZGtxuvMGLygQGSSAgx0XccXvvg2X/7Klzi/PEdbiSqQz2+YZ0/bNfRdz6PXXsN/23P97Ir3fvYufvbLQeSsozGWZx8/5uXTZ7z59pugFGOaSvZXWeCqosRlPZCx1hQVosE4zTjJemx0w5wCu5Ku3NlO0sJJgsBoQ0RI30Y5rC0oljp4FlVkw1nHHLw0NFmQ93mUxky71VKMhsIJNM6BMUzBQ0p8+PHHBQFritmbnEl1TGyMJutE3zconbGNIW3F7XtBUDVcXV9xdna2nHN1tDXPXt5/keNrZbDGkVJmvVqTgZvtLTkrDAmVk3DBiurOaNknQgiMw57m9KwYsEnobdM07Ha7Rfpd94thGDBa0TgZFd/e3i7XzmrziiusrPvDJAA0jXNM3rPfDcyTl8ayELo/6+tzoeJp2/YVqLq+Yq7x3dX+6ZW1IUTCXCpF4iGsTElVvVrJ6CUruC1zw8U2/shl79P2vBLIt8PNMxlJta2baAqB65cvSSEwxnH5fpCW7rYeBkKKlM5hHGdubrYobZnmmZvbLS9eXJUuoHymihmpmnarCkQqhlXWmZKFIsZl69VaogCAtnGsVh3DNOCsK8ROqa7DONJoDU6Inc45fJpRREkmtqBdg25lE26bhnXf8q1vfINvfvfb2L4RwnExqMoFSq0GPZlESpF79+7xxpuv89Of/IzoIykNJFMSRaOM6ob9wO317SIbB+kMK3wr0eWy8bsSJpeV5vnLK6bZy2EYhHlfu36fAptmxd1799lsNsLH0cKhCSEsMHA9wOGguDlGVOpalOseF++UesDDAe1YxnWwFC2V5LpAzcaQs6Anx34n8+zxs5fupaxFOBRLC/+irKOKkCxclKUrLSZQ83z4HLAc/HBQ0mhVPCo4oCipwOK1CLBKC0qybKrFbTdLqJk2kviaCpJHzMTCb1JAjGkZ5wjqgBTFR5+tIjf1ID82rKufF478YOQhF9+RVLtlhOuCwitFc35B13XcefiQ1YMHjNstrTZC1DUG3TboxrE5P8eu13hjwVi0NUwpEcpzUjdhpQ4FYn0qq7oM8oLkLveKLHN+73GqYbWS+HrjDMof8+U0TTHsEyRhxLWON77wNl//xjd4eP8+D+/fZxondvstH370Ee+++16B9hO7/Z7GOIwyNEaM8569eMmffP8HfOFrX6K/2JB0JqvMEGaaVU8yiqASscRKJCXPS9M03Ll/l69/+5vcfXCPyU/kIJWEK+iyjEmFg3N6dsrbb7/NL1/7BU8+esIubGW/lY5R+H7bPXGOGGWE4B4DphHCvORENXLfEav/mhsmz03xO9Ki2kpKEXNkCh6fJSuLkpejdDXO0ygjvzamFLFK4edA03U05Vm2hSehtcWaWJDSeUmgVoXDgpLYCts2KCsEdxKLzUTfrRYeUkVBDkpnIVhP88jkJ5RRUDgxRpnyvoqDt1HL+s8glgrGEKNkCVmdmENiHkeMc0sEgzGqjF5Xy3tonMNos6CmbduSgse5Vsb+y/eOS8G/2+3QWsQd3s9st9uFrlCpDVVhWPly4zgu7tnzLNydeQpsC3dKUPNijxH+bwoLfPjwIQCPHz/m0aNHy58/fvyY733ve8vXPHny5JV/VxOE67//rC9drBxUJfApgVxzkhGD0grjDD4KdKoVaOfQRjNMIyfdKVmDa2TzUEmx2WwkynuallTk3XbHdrvFmHJY5OKid3NDKgup7dplPFQ/ky6zRTmo0tJR73Y7KDD5Mefl5uaGcfIoYxiGmf0wkjJYZ1jkSLAgRPJrwChULrPrlIRotduKq6RSpbvUQoorB4LKStKcYxJb85ggKUKOqAiQef31R0yzR7sW5Qy6VazXG/q24fz0jK99+cs8fP2hzGtbxzwLIiKHUfncSrwrhmng8vQOb775JmdnZ7x8cSVMdmuZ5yjBdsrix4n9diuS2QIdVCgfLWGHygiZkxgwhZj8y1+8S/BiqKSVoGnGiA13iIH1es3du5fC+ywbrSpVbJ2t1oOnHr61Az4eKTRty1ykezUkshahtQCtZOnVarUgA2TpHJpCypQixggRuHBHhIvkl9hzW5CY40Kpbij1fdWfWY2QRNJ9KCrmI6lyRaMqYlGVZLEgN/X7gSjgQjwk8aLUgm5Ugq8zusyhdeHQyNzfmZLcHBN+nCSQTpX1hipZUDL2qHEFi3Q3V9rPgRwMh/tysOYuUHlCrNO1WLQDpJhJaLHEz6C7Htd15M2as77jLAQxdSvSUtf3hJzZjnucNWjXEAsBNiKjRyH9FvfblKhJRouiKpe1qY6s+ZERRkVHRC4v5nKbzapI5zNt3zGNoqpY9SumacCXfJyvfPWrfPevfo+vf+MbnJ+d0Tcd8zSSFLz1zhc5v3sH4xwff/gxL59dQQSjDH3XMc+eYdjx5PFjPvjgA77569/GrRy32xtCiri+ITcKt+p4eHrCqu2grMeua/nyV77EO19+h36zYru7lXsGxCAKLpUokL5mvdrQ6o779x9wdnrB/mYgBnENdeuVBDN6z/OXV+XJU7RNJ9yeGLFIMGsIHm1kPJvJrNY9m82anBPTKAaUrivckEJorT5SWQO2+kIVnqB1YjcRxIPHGlMk15ZutaLtevw8M08BdjsZZ2rhfaUYyzs9oH9oxI1VQRKWLwmYxpmL84ti0hawxtG5RgzssggUVMlwQslaaRrxw6kih1A8hVQhrVsn+0NKBd0uz93sQxnvK4bdbiHDj9NIDv6o0RGfsGqZUfeZYRjp+sPeU9HhSvCvPKkYI+M4sd9vcWXPqrYJMQhHappGurYrRZ2XDLYQyFkRfGQaxkLkr02WeKMQP9uY5//SAuWLX/wiDx8+5N/+23+7FCQ3Nzf8/u//Pv/oH/0jAH77t3+bq6sr/st/+S/8xm/8BgD/7t/9O1JK/NZv/dZf6udZFCZTOo5i9KMgFfREZncCw+oiw9WNQVmDVhCSp12vJaOmEQfRmhgpenBbiGsCte/3++UwqnBY7Y73w37pZCuXpDLrvZ/Z79VCnB3HoYSe5aX6XK1WC+qgEwv5Twoc4SZAgRlTkAAoLTPXFGSjDBEaZKHdXL1E5Yh4lXh8mPDzJOOg8sSprPCjcAUqa170/glnLH/jd/46f/W3ZoJCUlutjG0kaEuSbcVNsqoyJBgwhao6geqsqRDm+/nZhYxASvURk8xTG6dIwaObhhQS0c8oJ8iQKrCr1BEi3RQZb8BlR5hmnn70CX67l0RNY9BknFH4YaaxlovzMx7ev18Mh+KiIMjq4Jxas2BSSguiUA/GYzl7HcfVLon6vfLB/6S+tBKWe46JEGQznkIq6i3pvCr8GoIUv9VdUoiKYUEPjn/OMadkeamDY2ZdK0I8LRbyBemJMbJarQCWgjpVNFIdbNtTKSLqIZxiBFNN7aQAahrJd3LWFT8eXVx8Ezolpu1eVBa9o2QQl83QoPTheh5GOBICFzlcx4qcHHNnKkqUy5y3Fja6wOW1iagFbrSGbCzq5AST5TCr/JVdFFKma85kBKCEZJxTSYJVYJJZ0FgxHRLk7rgY+fQYaiH5pkwMEattQVCFiyJ7QDEK1OIAXA8FZTKvv/kGv/3X/ye+8d1vsjk5kUPAz2BF7nrR3eG3Ln+bs/Nz/sP/8R9IMTPc7FBJEnU10qHPw8T77/2KF8+ecfnoLuS8yM/fePMN3nrrbVZdh9MiO3DW0bUtb7/9FueXl0xeeDpQDp8gydi5oKUxZmJIdF3Pw4evc3Z2wdOPnlIAsZK0m5h84NnLl6RCOLXWEYJ4JcUUUNosB1lSEIKnX/esNn0ZzYciRS6hnCG/IqBQyOipunuHEBaCsow0SwinUhKw2Db4FMhKwlljlCiOnCXPyPuDfUMuflPozPpkjbYGbY34QKXEze0t5+fnWNswjlPZN2S8Y3TZF1NiGMT35uX1FftxkCZai1dV9SuxZQRvSiMWoyQRRx0lPy2BQi/PtykE4WEcaZ0taxD87DG9FY5KjEzTTNsKirnb74ulhYzW6x4hKjrHNI2M40hVx1VuJbBwL4/5dsvYz3tmL87nuhgyxiCBpSmWZ8kcDC3/4jP+L/nabrf87Gc/W37/y1/+kj/6oz/i8vKSt956i3/8j/8x//yf/3O+/OUvLzLj1157jb/zd/4OAF//+tf523/7b/MP/sE/4F/+y3+J957f/d3f5e/9vb/35yp4/k/ffAZTAs1yFm6IzDRlBqyV+E00jSHFQNu0rLqO1ln6TtjbTWPZDrdMaaZpOvYlWyCGgDWW4MRwxjmpxGsnuiuV62q1kpuqLKnMwUMIbDYbbm9vF78M51zpCA/SrAq9WysITt145xJGmGKFxfOiqBAyXSUOlv8Kwz2lknWjFDc3LzE2o3XEWEGahJgnkKpS8v1UVoRJpIVBFcIoEWLizt1LznJi5z3deo0xkrZqtMGP09JNVm5LSkJ8QxVDPGrHq8o4JNL3PTlmWtcy6n3pUoRtn3JG5yxycChhgRIwZZVAlbHEhxtbouldw4vn19w+fc7+xTUqZbKWcEAVZYa/7jbcv3eHu3cuoYwoMpIwK4XPQWp5II6a5eFcTMLKva1GSMejlfpnx1+z3++Lf4FkWvR9L3PgcV4KjDrvBYVbCMFy2EmYWFzGTlUd9mlH2sWJtnIySuFyPDaqhVNdY59GY2qBX9epXGMpTJyTGAcfRPUkOSySxdK1bUE8iuTROUIc8VNAJZiGQZ4l5Woveij6yvNQ4WhRPBVCtH7Vabde6zp+hTICVAbXtfgCs+eCoDatOHOSBYmSVVbDRMWMTFXZZxRTMqPNQo5u+0ZIlaX7rg+c5pARFDkUp8evP0vsVRLf0LiSCm0XbgLIrL/K0vfDICPtVcs3v/1tvvqNr7M+ORFEGIVGnttAYppn1qs13/7e9xh2I9Nu4kWE25c3PH/+TMigzrGbJq6fP+f6xQvuPrikLy659+5c8v/8X/4mSktatiqKE2ekKbs8PwcFwzhI85aCyJ7Ls26sEf8ZwM+RVeO4f/8Rq9UJOWu6tkdlRQyJKUxko7nZ7Zh9gOYQJWIKh0g8ZGRMk7SMylojHKeMoE9ttybliE5KTAG9+M8oBJnSKpUwzDJsyxFjm1JIyUFpm4Zu1eO6VqJGpklyeFoJhNzPA/M0y1j5GK1Gxs39usc4CYxMs2KaPVdX1/SdmP9VDpcgoIaUpqX5PTlrCdHT99LE+hhJSQQbaFnvq9WKs7MzcWIuhnHjOKKUFMkqH7hj2iiGQZrEnDLzHBj0jMowTXMZC5Ukde8JQfbg7W7PPPtFXlz3s5zFtC2W8Y3RGmsFtTalWAulacy5qpEEEXJO1qbsFWHZcw7Pa+Fmqcxnff2lC5Q/+IM/4G/+zb+5/L6SV//+3//7/Kt/9a/4p//0n7Lb7fiH//AfcnV1xV//63+df/Nv/s3igQLwr//1v+Z3f/d3+Vt/62+htebv/t2/y7/4F//iL/tWWLc9BqnSK58gK4HxslZQ/u9WLdM0sznb0ChNYwzaKixOLL1jYHc1cHp6viAiuWz+Fepa9Su0EyMe7yVnoW1brBW32IuLC66ur9gXW/uc89KlWmvpuq7cqNoljYvFsBQNSb4mK0KcSckvHcjxYSQzQHeACrN0gsknMftREgb3/PlTtAJnNc5qjFHF/vwKpQ1d0zHqABwkqdkagThrd14snTWKyQ+kfZAoeOswGsIUBJ6vx5U20i2kkp0S/cKVMdZKUGIZa03TTAryfiXF86gaR5CaOc0L/K+NISWBl8XTQ9M2La11XD97wf7lDXE34LRmniZ0jmh78CR59PAhXdsyjwPWictnxiykOOEw1IwYtaRLU/gPyyGZSpZNOUDroX+MrFVyqkCibjk8Y5SsirZpxDJ+CccrkGpISyBX13U0riFEUfJ8uiuvZNb6CmUTOCALh4TvY35K/R51dnycG1Q3lJSkAKwKuQpBi4RW/E0os/227XAlTl7Wd3FULRlX8zTJaKdsTJoaPqcI4TASFOVVIboXUjgcpNzHxdXxK2RRR1SFk7YGlTXDMMph0vdkihW/tstZIzJh8SBCiflXSlnM1nRY4OwsCXdofUil1qogl1WKXq73p8c7i3qKSrQO2CKZvbg4LWnZgkypMuLT2tCvV9x/9ICvfPVrXN69S9aZ2c8EP6NBAiW1RjmLT4lVv+KrX/sq7//iPfbXW/x+Yk7y9RZQMTLcbnn59BnhC2+QdWYcRrQx3Lm4KMRaI4GB0yzJvRmU1WJNDjLSiVKYkAVpzeHIIDOrkpK7pm17SSEu1vzV6TXEyPXNLaP3rPqGMAy4rmH0I411y6iR0oDknFCm+GkohVWazjjmkCFIkxGmWczbsuRIxWLeh6L4VlV1ngSjKqCxHcY6bNuijXD+UJCmRCCJajLVVHlVoVtRC2loukY8aJzFk5n8zMuX1zy8dx9J39bFmVotxXuIHlXW8DxPKFNQEi1KvpRDKaiEqL45OWG335UGKcjoXSuMFtWRK5wQ6yzDsBc1oxUUbpzKc1eaj3me5XqWvevm9laetZK7pI0uja/k8tS9zlpbcoBmZh9E/WnkmRDDO1FpnZ2eFoXRVAoyeaaFg3jYK7VI2l7Zt/6i11+6QPmd3/mdZVH+eS+lFL/3e7/H7/3e7/13v+by8vIvbcr2572MKOGkj8kalcrFMIZsFEFDQFwqjXa0nSPHwJw8TXFw7Va9FDN6wBjoO4fWFlc2j6Z1rFY9q/VK9OKrNfthjzESZ149WXLOi+FZ8KLOSBwcQasTqXMtIYiPwXGUdY0vV2oWAzYy1mp8FDhUaS1hViEss+tYHFBjSIW4CCAkuGfPnhDSnrMzx+0OSB6jDNPgaXtLUomoMmPyTDnhc6JRTiR3WbrY2ctM1GSNjwmd6gxUHvQUZa5unXSGlcurtcB6NWo+5EBjO3CGZ1cvmaLHxyibrFHkKAZAIXms1jR9g3aWNMyy4AsxPuaqtZEu2dqW7BMvHj9jut2C9+JSaRRKWRkzaM1qtRZn464l5EkeSCBJmwVWQ8gL6lY9FOp9VQiBrSkF6ThNuNJ1HhNOF3nykRdKTHGBYQ/E5gPKccyzsNYcFFZGNow6euHoADz+WUuXnsSPw5SfUQP96td9+pk9HhXJxpEQ2k0xlgPKhGeBp3UZO/ppQptE1/acrE5wTY+zLd4PC9KkreVmv+V22OFjoNW9PA9ZUmHJQmzX1UyOzDjPQDWY+7OH/Z8nO5b7KChiLBwUay22rM9K3DOl6MxJPm+OAa0ynTWkrMTfCGidJcVASlL0GSt7hyrNwhxKkq/W5HDwx3mFI1OIu9I0iQIjF5VTMg3KOs5OzkQxlqWhMkox+Zm+6wkxsjk54d69u0XtJWR8Obwzc0r4Yi1ggJAi55cXvPHGa3z4y3fZKUXXNAQjaK1FM9xuuXnxsshFs/D3yBgrLUbIiTBHFGkZ6Y3TQFJihBgKmV8rTVK57BMyykMrrGskJgJAK/q+RyOHcbUDCEm4aHOcWdsTQf3QpFwIxqp6ZFSb+kRWEW2SWAVoxGmWeu1h3k/CmUtpUbmlVBx8Y5QzwYgNfiV3okVNIm68ElqaU6btehQKmxXZJ+ZhElQHiS4ISfx2XNugnUI5QWt3+4nr6x1vvtEQwoRVeRklK53BFATcKuboMVYxDKN4dSHKRKKQenMWV2xlDd1qTR4G9mPNNDPF+VaKQe8DTdMKUmgg+iTWEalEpEgnhTIU19mMcyJNbtsGoywRQQiTSiSVwch+7aw0i9oYrGpBlzydUrSJa3ojiGDfo1HEAMN+YJzmMv6TsbKMdSzV8k6k558NRflcqHj+e69UCIAahbMNXUm8jEkITDJ71PTWoPtG7OK1GGjpIo9smoYxeNF/x4B1TipcLRbo0zyJJJDC1o6ZkDwnJydcXV0BMuu/vr5evE0qUfLm9mapYmseT2Wli2xM5ojDNJFRrNpimKQ1bVNgV4Tcq1TtDmq3K+OUkCKpcBe0lYfSBznwtY6s1pacRnJe05hWhu9KvC2SSow5sY1e8mGsmNllFRe0hyxMfJs1qTh2hqLW0QqUMcsihJJdIc2wJC+rjMJh24btOPKDH/2IZy+upEOhdNTWLARd4wyr0w3ZyKYg3btknSgtOTNk0fVrFPMw8+7P32XY7TE5o5NA6CjNftzTdj0XlxfcvXsX6wwpCM+n5mvIQlILH0G4PvmgNEEV06giC091/MAyFvp0sVHJ0JV0VhVBx8VLSkfmb2UNWWtL53iwza8PuTpCEeDPFijGmAPX5EiyW5GbSpStRfGrnJpETJIvpAvc7r1nDhGjFNqW7jQJWlEl6kabUkAqjHE4E8tISpC4nBW7cWA/DpyZc7HJT/kVRMdYc/gsWg7LWCDyV7N6eOV6HX8GuQdyT+SgE6VBmCUkMiMHqkoeENXaNOwwWskhkKBtO0KSg8WWJichkHTOohAy1qK0xqcghPuj4uRYXVUP8mmSsNKQvJCQgXn2nHQb+n4lAXPWSXNBpu8aSZ52loePHnJ+ecHkxedDGY0youoISZ4cXfxZpkkSer/w9tv84k9/youPn5FUxDqL9zKeSjGw3+3kPZXxlSjK8uKwXa+3Pxo3A+RY/KR0KegX4Xv581LQxxxxjS0cihrn0eKTJ+vE5CfGeWTy0nigioigErsRPpFWBdnUoEzGNhpRZRfllzY0riEqwzTOzPOEVrL3hBBINVTR6FfWyvEa0gU5UEaCJ2VMBIbCGZpmhu1Oxk0xEhGrg9l7+vWKftWBSjLmSYrt7R5rLKenPX6WIkKQdHm2fAwkH1m7Fe2mZwxBRvdKUplzSJA81zfXXN6/y2qzYr8fsSGwNhrXt2gMKUTCLBYX4j5NQagNTdtKwKVryig0oK3GYgsSrFBG0XQO65wUDtGTMWhjcNrQuxXRi+OxMbK+UoKmEWuMaRqLTUMu5F3Ly5dXst8lEZ+EfDCwRJdYgNJAxCTFKvGzKXk+1wVKbfFEIVA9LIqTnZa8jKDlIXLGspv24gCIwF6t7pjmaYkN9yFgqyqjECadc0xx5vb2doF4QwjsysN+eXkpCZBZ5t7Ckh4OstJCJOy6bpFiqbJYQLq9jXX4eHCpFT+RhLOWcfQlu+tVh1utNCgpFupGUztRuSySdWOUKdp2CsGqHAzOyjhHKXbTwJzi4u4Yc17QkCqz00qR9HG3eOhyYjiE5NXFmJHDIitoux6tLe+/9yt+9vOf8+LlSxlJAT4HTJnlpxhZb9ZcXF5SfYFjLLH2ZT5dEQKBIB232x0ff/KJcIeSHKw5jnSrFWh5GM8vzjm/cybSwASizRBujISvHXgw1OTfJDyFqsyoB3u9Z7lUKEoddfNaL4hZ/TORzsq/qweZcFQOh2/lrQzDsNzjSkCrh3k6+vMKwX6abLZ46cTq/2IWfkf1OKkjy2UtlYNVkJSDBLmm1TpjMMowx8OYSgEY+dzVzKlcSXKKsvcY8bDw3jPNEyEG5hCIKr0yoqp8nZp35P0hwv24CFsOloIeLkVhnYUXmLo+CylKxo+4YipJbQ6RlDzXL58zDntOTjb0fSOkWZ+ZhxljHarrMEUim7OMfWrSrtZGxlHqEIXwaXJsla0vY79Qw+waWZNNQ1eakWoHDmLlHkLEtk6Ms8rnbttWQtdSDdmTtV99aXyMrJuWR6+9xmrVE6tbsRHEFa3wc+T66oZhGGlXnZDPi+9HLk6pKmVpSCLlmS9OqEpQoarCUkrGoDmVLKiy74hfiS32/KXIjyU6QR+eAT/L2FLBQgIX+LcWm4VOXZAq20pDidWEFLCuFaO0PONj4OrmWhpBKxEcOUnjpIoSiCTPRlJVTBBpnV7WhrUWHxO52gXkDCkyDvvSEEYEptHMfqLvOtrGoQudIiXJyDk9OeXunbt8+MEzQiENp0IG9uKYI869qw5utyXrSmMQE7gcE1c3Vzx++rh4KVnhDWZL2/SC0pfCQRLpjRRnWjLUmn7NkAU5lD3fiItzDJLdZix+ljHiPHkpMiJYI0q8qJJwEr2kW7dti9Gv5oJNpRgMSi/Pbm1mNVIQZ5WX54N6ZhRkP8RQVKmf7fW5LlBUEkmjrQZWWSCzrrGoxhFMYlIRkyHMMzqDLSRapcqBQYXP9CEGuhBIrbU41wKiXBApaEYbGMaR1WYtC8kKc3yz2YhxljX0ZYOpm1TXdWL9XWbXdSMFme+mKUs4YCECWmPo+o7ZRwg1S0aTQyBFkWoZazBJOiUxa5PKXVsrUssAfb8mZ2hcw3ZfNoZC6ERJnsh2GplSkAIkF4M7o4VAmspBm6RDAvGukL0tL0jAoZO3ZXMQwyiRtmY++ugT/uN/+H/z0Ycfy5w7SzEpG5TFGUfS8ODBQ+7euysHbU7i3lg8DCo/IZdrhjZ8/PQx2/0eX9VORjJ2QgrL/O/eo3usTlf4NDPHGXRausGcEe8UVFkDRaFjLbaQuTL5kDeTJem52tdrK2Zvx0iFK8qvZdyhDgdZLVCaxrwywqiFQt/3dCXjaRwlL6PKCA/FrX5lZHM8Zqi/l3smRk2VoDvPcyHbvToqErSncHFK8SIHvsFZK6qs8rVicCXkbWMtTdvKODTHkoYsnVVVdu32O0IQXtdcnHGPD/XjYq6aJFYOV+3gj7/+1QJFSM5aizN0DIHgxUSvtQ6jwJCIsyfNM22B8+f9LbvdDX1nUHmDNZYXz5+y2+05v7wLrSvXL2KMrDNRNSlilD1GH23Q9X3VTbwWeVJgBpwTS/AwB/zoCeszTs9OqWnpByRrFo+OVSsBjyFgrCnmfYeOUynhWPhZ4glsKQ/7sscYbfB4GmPF9l3LnjZNggBb2zBPkRgSVkuOkMoUE8Qs48u6PkrzUJuiVFATpVRxylXLyGiaR3QWbxzXOqbnU5FLZ6yyixw9+kD0BZ3M8hDmXJ/BWtjLPhmyeKVoZ3CdY7sbabUie0n4XTnFixcvxLE0C2KOkYNx9qHwoyCRsKXZyEmai8r/a11DmgM5xsVeYBpHtjc3ZQ1osasIAUgLcuasY1dyofa7Pet+xd3Lu3zw/lPh1DWdjJuUFHale8Z2jYzUSCWHKKGthEEO08iTp0/oVytW/apY7jvIMI4T4zTR9Stut1uUkqLw7OREsojmmf0wkGJiu9uxWq0wtmGapfHNjV72rRjkXBL1WCaEiWmeFouDtu3KzxuJ8WDeVvcdV7xVFsQ054UYa20lXWeaxsoemyJaW5SSYFL2/zfIjP9//dJkVE4ytogCC2Pk4hkr892oMk5rphBKYqb8nXMOZYx02krRNK0c6jmJYZBWYi/tBBXpO7lhw7BltVmx2WyWQ6Hv+6X7rRtOjZomQyhzz0RefDlWTmK0p3EkiD6T1WrFbhDfiFqVhxjLXLUYslF4DUUpo7VwJpQqjqtNgzEN3oukbbM+BYr9dRJIEiUHvLWWMXqpsDUoa0QFE46J1nkhD6YcZOyiZBZa7dFN6VbqKMznyDiNZSNVPH/6gu//0ff5/vf/lOvrG+kac5HOhlis0hXWNrz22kPxD4mhfP+jhxvhBWQFRrXMZD548oSdn5ljLAoLgWx9iDSdo1t1vPHm6xhnJf68zGJzSlgjXQoU51QjyqCYEk3toKGMy0xBTQ6M/oqOSFnIK0TmipYI/0GkjhU6r39fC5qKetRCpBolOeegOAinGAtp8KC6OR4rHEuR6yakyqgjxriYLR0rehYzOSVFK/FggpbLwSFjzRL3QF7Sc4MXmWotUIyuuSOHayOHbiidf10raoHiRZWml2t17MZb/6xuiPUavVLUIUihcw6lpR51xmCVxRnFPOxIZKb9njCO2M2akGTk5n2QsMwQMI3h9vol437g9PSUnDxKGXTOiObn6J6VMR358D4+TfrLBfG01hLm2mXKNez7npilcLVORjaHQNCCkiIFoCqH9TRNpSuVr0kpLCaEWtW1l+lsw2q1QWsJ2hzHUeS8XSPw+zAxzYV8n+qdKnb8hWyvUFjjZMQdkzwbSpV0bIPKCVU0/7mQpjV1XxJUJpZRrS+jrRpLkZKgrTUkTxd+S6womF6wVEBUOrMG17YymXYG1SRM4xi9J0TPWXMmjR1ZkrJVUeSV50Eho3FZf0LnN0oQ4b4XpMwUV9RYxrZOS6pyDJ6cIuhEDCL5T6kh5ECOgnCrgqLstjtijPR9hzVOco5KHEmMg3ivaHGVzsYQyMLnEDhKSLoKphBRw0jIEKKcb32ricPE1dU1U/CsUuJ6e4Mt++b+8RNIso/Ofk8seTzDfihKUAGEQ8hidZCCcIooDaWiEIKRVHQtkSLz7KVALs+ooDpl3ceEtVoK+Pq8G2lOakGutF4Ua+MkyJP3LYnMs5f7z3TGf74LlPLA5pJ1UenWOYkMSudMox2tbVDGMBNF+dF3ghJoLTPionF3ZbxjrByEs/dY17A5OWF7e0tOidVmxW6/o+s6bm+3MgJA0fWdJFwWi2YdNfM4LZt90zZl5i4z2qUiBYxW9KsVRml2w0RKO4F663w+i4+CqGT0Mn6qs4PqQBhDglbcMYfR4+fE6ck50xhoG5GBHnMWnHPkMOODl4MfiRsPMWIWiFcSWUUdZYuTRSlassj7DLKI99sd29st18OWYRoZxondduDnP/05v/zZu2xf3uJnTy6zSGsayMgDrRUXlxd88YtfwDjDHOYy5NFLFlFj5QFJClzfcbXf87MP3mPrJ1TrCGFm1bSEsrG4xrI5O+Hi7gWhWO67ppEgw5wxTUNOUsRKSql0y2glQ6CqAKik5Do3PYLzReJ/kMWCErWGtXRtcxjnLHPbRNu0xdsjL8VL2wgBNyaRuOtKPC7k6UqMPg77OzaQq/9fOhznyKUoeiUxGV7xHVlIsupwqColgXhhFu6LLimvZCVFN0p8I3Lm4vICVwyntBLTqhQj7arFEwnBM42yaSqhFC3vGw5S4qW4L1wPV2DgT8uj658dRmFybWOxam+MJnkvbrzjSAyeTz78kNZaTjcbstKc37lHd3qKa1vGWbKgxmkmZQlCiyHgjMKVoMQcI7Fk/Whdkrx9KB3hq+9HlITCi1Ol8ZmjqNFCjOgciDGw3vQ0TVvQQJHBTn4S9AiWcXDXdSJ3VomUEN5CFlNK7SxGGbIvqGrrWK82aC0NA7C4ASslEQBkmYxXPlROMpKyrkGpUjRnJSqZLN2uShIsJ6hYKZSRMZoqRUDKCasEwQhJ0pXFdRlmP0njpfMSVKc4NEFaFYNNnZcK93g9t30nhblSWGfZjQMUouY4TQzFl0OVQiOkzDBNgqoVDpvSFR0MGNuSc6RrTKVw0FjL7CPRBynGUK/c1zrSNkpjlGLdr2ldi9UWoxM+eCnQrIgjcnnWm6ZFqT2hGOjNIRJ8xrUr+vUJ020peFMm+YiP4pM07/cM00RjLLvdwDiIR8oUPPs4MhdFF4gfGEkMOq1DngWtiTkwzxM5q1cK/BglJbsaj8p41RVC+YGcvjnpODk5WWwRFu+kaSSFg/Cj7iMxeHzwdF0rpNgjpLdVDbaxKKMYxuEzn/Gf6wJF5cMGX2MBNbIppyERNCjdCKzpHMY1rNZrIkXaqcVzJGYYRoHotFaElEt3Jt3cbtiz3e9YdQK/T17cXpuuXYiHMUb2+z2tswv0a43l7PRUutCc0EkgtrZrsUaLy2LjFuRhHEdhvRftu3RmeWnaRWWilhFCynGB2YwVGa6PUdQ3WXN7uydljXMtTdsyBYn01kq4FtaIFLBaO9dMF6vNYmcO0vFS/k4hku4qGyXLJpxj5k/+8E/4wQ9+yO2wRTnDbjdwe71ld7sn+kiYpDgxutqxJ4zSWGWwWvHG66/z2muvlbluPUTNYpYUyQvhdAqRZ9fXvNxuGUIo0fUtMUg3Kh1c5PW3Xufu/TuMw0hWMtfumhWjn/ExM08T+/2MtQ7yCGRWXUNOCeds2dgSWh88Q+phfzxmkc9jD1B/rr4wIqmWetgsJFFnHUpnfEr4UB1Q4zKuqEVoiIc5b5UFD5MQaKt0vyIz9dc1C2ic50VBVouaiqJU87OUklh+kwnxIEXWSmOtQPAppEKELs+YEfG5sQajLK51YnPvJMTNB+nOYvDL2EUrGRtVdKdm8ciYTz5/48QsK8S4HAj1kDqWbh/GUoqcZX1qBWHywncoGSkqZ8IsBoVd1+FRaNeTNZyenILWRO8J80y3OSV6T1Iam2Cc9nINXFMUdEYyalImF3l85eEcEzCNMa9wUDIshM1K2jTGsF5vODndFG6akPJBUMkQDgZaKJGZiiqljDedkzGakj2wUqYkAZoFfUspk4jMMWCDKg7IlaCtC79IYbVlGMWK3PtAKp0/SqGDpt/0iN2lEBwrB8caabRQ8pzOc1gIs1NB2Mb9QFYlrE6LmMFUQ8ea7aQUMUWJ6dAyIrIlKVpry3q9oWnbRbJMls/ig8J1TUlvjzgjgXg+JlIMoMXbxhhNrhk95XqmlOh6SYP2IeCniRQDjbElmFUz7Ed2u4HutJfnsqjPXOO4vLzk/aYRhdMcuL65YTvuJK8oyJkxxrkc1BajnLy3MfH442dY23H37gOu8g6iNAExZ6bZiw2+gq5xFLE/lkRn19h5wlhNt+ohJ2IIdM4xDSPrizP8PBACBJ9pmk54TT4Soy77h6ydtrH0fSekcOfoihO6GMSpsueJArLrPNvtDq0V6/Wa0LUMux1VUlwtC7Q1EH0Rc6TlGUDJ3jB5CcZ0pbD5LK/PdYECukBUEodOOhArowec5IfEmJnCQGNXUIlhKIZhQrtOkj2tENSavqNxwsCXrlpmbU3b0q16+k7kkpVvUn1QKoQ+zzMnJycL4c97L8Y2StGte0xReOQcsY0DrRhHgV5DMc6RDIbD3H2ZA+fiBlo/Q5bZry3VaiDivYTQxQQhiGRNzN7EcltUMAiptoCzafbMuwGr5HolY/HpkD1UlQnya1MOz0TOsjGRMo8/esyf/OH3+elPfsp22uGjdNpZnN/ERdMHLJrG2UKoTLTOoXLm4vyCr3/tq6xXPcN+wGcP1lFEO1KkVDdHwDjL85dX7CYhOafZs3bNknORVGYOMw8e3C9qhlmY6rbhySfP+MGP/lS6Z2MYR09MMpbbrHq+991vc+/uhZCIs1hNK+Ve4Rkcc0eOxy31VYvM8kW05aHUhftS/74iacc5TU3TLJwoozTjfhDODVKA9G1XkIxDMnEd6dTitSYh1/d0QC0kL2gcR6rrcS6M/GPyqVIZVw3JQgmys4VPoyUPSXgIagmvkyweV8ZWAoNHP5e0UwVGYZIqM+mqfMml4xdflOWQ168e/K+QUPXBrC4XIpFWFm0zOQZRDgBWaWgkc2V1ekLQms1mzXacmKM0M9p1aAwP33qbNM/F1TPw4tlzDJo79+9BY0FJh56ToFi28C/Qh2cTyrgzs5jmLWtiAQeEW9H3HZvNBm2NBNVp2buss4UvIsnoTc5H5NjicjoMoBLONpKfVJDkaZzws6exDantGeYJA/jk8TEwzpOsCyXO2EpB17WQ4ad//BNut3sUWswQY2acJowzfO2bX+Py3oV8RqEbLfENuXzWkBInqxOG7cDNzS3TPBeUJBc+n2MKE0Yb2pIkDLIdg6BmBoNVGqNYxA8pJJxxONsRoijDxMwtCXfCJ+Yp4OdAt1kVHkRF0+va0cRy37q2IY6SPHx+fsZqs0JpQQxJMkbKIZJR7LYjw35kfSGRKJYim82a87OLojaS7XSYBiY/sTpZE4m8uHnJ+uxUuDFJVGR+DkQPL57ccO/+I84256zdOSrrMtITjg9Gsr7Wqw4DpORRZKZpLOjbipwCm/UKA2xvb2ldw8n6hN32ho8/fszN9RZjGlJSTBm61izE/BASUv8F1qsOUIz7nRQVSQs/LxVkcdiTkaJlmgaqDYEPM0ZbnGsOa9wI0h5iXEj9de8JMS6W++ZoTP4XvT7fBYpSy7wXZLMsNEEhchqLbVra1RqdA6ZtCt9DcXnnrjgxbk7wIbHebPB+YnNyQiqz97Zt0VoyDdqClIQQOGvPBc7O8hB770lZSELDMJSsHZGkOedo21ZyEaxdfC1ELSMkUGPl4EzWSWERE7e3WzmYlZiU1QAsMYc6UgmUQyIj80OlNT5kJp+YY2K92pAppmGl4KqbSwwBlTJx8kz7ARWLnBIIB7R1QZMOoyWZ/UPGGUPrWrZXtww3Oxosxkt3Nk6zyAjRYBI2FzdC4gItqyzS4e9++zv8+vf+Ck3j2Pl9UTLmxVwo61h4AWBcQ86Kd997j+vrG5FZSm4ztnEiA9WGew/u8eDhozJGssSU0Fnz3/7rH/O//e//B8M44dqelzc3CwJ3cX7K6WbN3fPvSSpzOnBDcvVhyQezNIFOi4uqMUu8QSWbaq0JRTIMpTCp896CiBybj9Xvufh3mOpuKh32OI0CrZaDSxRZEgo2juOSDTTPM7ZpljUcQliky3Cw05/neekko3/VsE2K0OrmapY5OWU9xFTUbkYM0nySex1CYA7S6aUg0K9FuAkH6P7Aw9HaoJDoAmOM5KWk8Aq/5njMc1ysyDYgid6NFenkPE2EacKTWG9W3Ll7j9X5Odk6dvMssmhlmOaINhGrRR3i+o4cPPNu4sXz52y6NVZpsjJ4ICIHqlkQkkNxVd9fNXeriJfWGoM0AxhZvyF4yWFpZOTqfRC4PXhQiUDkdrtlGAdO75yis2JOQYrzUtxaJ2tGa10OeVVsSTLBe25ubuj6Ht1o/BwJ6RBWWnNuQiFKPnn8Cf/x3//v/OpXH5FipnEdZNm/Nqcbmsaw2nyLdt0RUxQOWvH68Ig6xJWx0gcffMgnjx+DKmNkK/lfqVgGOOfo+tUic445kTVkYpGvCmkzk2hbh7GOvl1zujmjcR0qi9W7s40om0LCz6F8FiFh5uyXZyon2WOrLjHESIqBELzIlRtXDAiLB1I5P0KIDONISooysINc4ih6Rdf1cv2tY5r2bPdbbnY3mFaDhZvdDf3ZRlDHrDBYrFuzvxmYx4DOPScnF3RdS+s6+vUKVRyCbWsxVvhaOkeiH2gbODtdMw0D664np0DynovzM6ZpZLPeMA4zH32YmMYtRmWCz+x2I42VBPv63B7SxRW73XYhte52u5Iv5ri93Yq7s7W4ppOzJSLWGUrTlHF0LqjIMAwLL6ruOZVyEWPG+7k8H4YQ/Gc+4j/XBYrm4PZJ9akouTWu6VCNQRuLdY3M/M43ZKNpWpH9ZqBbrQmxkN+sESoLis3mhJwPSortbsc0jnKgFPZ9ne8fd7/9asVutyvSY0FaGiXz5+1Qjaw0betYrVYyXtEzrWvRLRjXStGFwl3dYGYj9MJiIFbVJqpwEWJKcjQbXXgA1UcjsNsP3H94RxRFFP6LNkxhAgSK1hlUSPhhRKUsiFOWA7SSQFN5vIWRLl2rbMgJHz2d6Vi1K9bdinW7ZndzK6TZqDDKoY2Vf5tE7haDQIAGQ2M0l+cXfPfb3+HOxSXPb5+Ke6QWvxaNJOimIr8kCbS83e/51bu/IsdIDlXdE2TunETW+OChKILqeEUpwzx6fvnz99jd7Li53ZLyNSFlbNMyzSPEwPMnz4QsZww5Hezoa6fwqkT3VRXOMekVZJMWlCIt0QamRL/XQqI6x9ZRTV1TzlqcsQt5NJcRzSsyYQQtsWVDnud5QWDGYQAlsCzwisIIWGTHZCFeV9mvKoX/wYq8kG9zKgcUBUEQn4t+1R+yoo78DWzZFKMX35CKKtSGQgq04k6qDu+tvo96/Y7l0Auxt3xdTKJoE68KDSFwfX3DzfUVjRUl3NnZOck1qLYhhFzSsTN924ESdVpKQu4W9CPTuoauaSQaXgFWLP21MRgFOcjPzvGgoqrvqSba1oJKF+Oxpm1wCHlfwaJ+UEoLYbYa2CUZF798+ZI79+/gWiH9DuMkZNiuwzpBhivJWSMOysN+oMq/Q/DiJ8TBIbg2G0YLUqG15vnTp3z80Uc8/eQxfg6CzBRp7svnjv+87ticrvnGd74h3kVl/zmM3yzWNux2e376s5+z2++FIKkNQRWJb0KQxLaVDCKQfaGgwDFLVktWGmcsSmesNoQ5EENGZS3vK3qSgr7VkgRckIkQ0oLKhJBkPFmeD4pqpxa61ZvKGo2zRkL6SjOoEFl39Ilp9MSYiRGUljDTrATB7tqufAZBHCKJYR5RVkYdPgb2w76M+ht2w0DnGlQ2xClw/eKW4DVNI2P25rZjc3rK2d0L5jQzz2IN0beO1mka47lzZ8Xl6X2sAj+MbMqIVxUp781N5v1fDSgVRR5MFDdh25DiTIhSTGolJGTvQ3nmFPv9QAjiayLFnoyjc4jEPMpzXMbEkJnKHkRJq26K6V191T3smGNWEehPk8r/z16f6wKlwkjivFmdPYvyQskMXOXCE+lbNusNUwr4GBmur3HOsRtGNicCxQ0lc+fq+grnLF3Xiq47HyLtc87YUmHHJKMTXQqTtngbuKaV+Z+TAMKua4v/iipzaKkkldYStV1aM9u0nK82aGMZ50DbPuNmu2caJ7FWLt0IOS+fvTrWxuKjElLAdi0hzCJxtEYe+CzFhygYPMZqYauHRBhGdre34lJr9SHcKQkxr4YVhtkv0l1BcbSoTIJnveqkqAmBHAV5kINNl3FSNZgSSWHOEjgmBFHHycmmdDqKOQSMaUtOTsYicPx+t6Xt12xO1vzqvfd4+eI5t89f0mpDQ2bcDSSrUDrTWsfdi3Muz0/lcCuE28kHurbDYMlTwlgHMdLl4hg6Ja6evmB7veXOnbOSz3KwWxeJqRyQMR6M02JJ56wIxvEhqk2VrEv+kp9nMnohpFb+UjX6W2zslVoUJCGE5fuknBcHyXmeUVpGkjVPo/I82rZlLATC4/TlcRwXPsqB5yRcomrwVN+7ePkcLM6J0vEqY0BLEdKuemIpYkPxFNJlnc3TzG63F+fMzqKyWOXnLCoVeQ9S6MUUF9Lu8UjqeIwWSkZWRWKcc6iU0daR5kCaZvLsGW+32JMNKSq69YZRJSKImi5W0zzN7Gdikuvu/YxSms3pOeY1TWN0UdQEVLQYZ5a9pTI8j3lIsg7E4txYIdCGGPFRnJdb1yzERLqiIjGCzKUUBEExGhUV+3HPs+fPeX18E92axdm4xmJYpURKb0FZR9usefe9n3G13bMbRaljtHiHdFZhNZxsNqxXK2lkUhaoPQthddOtaLUl50AcJMldK8U8jHz03vv88E++z737d7n74B4BMXnEWLRzYBzeR374/R/yh3/wX9ld3zDebHERnJID0WdJSL64FNRgGZEm4bQpEEScTEgRg4jKjG5Zb05kFKcd43AraiJtlmRoGUHm5XuJ6s4V5Z0qSkjhzClAZ0Fbu7Zl1Xa0xhHUXLR4YuQ5xlks470EnZIzc4qoKPdptepYrfrFj2Y37JjCyOW9c7IKggDmXGS6M01jmEbhwSmjGG4H8hxpO+HkzOOecdgC4go7+gFnM6sHd4h+Qreg/cCJO+W0a5ktnJ5sGMYBnxLXN1v2uytUnklpwocRspDrTSG4i8pNQ9RIi6jExTdFEhnjHFMQv6LGudKwKVQ0y9hMK1OQvEyORaWXRXJtCspf1WhVFKC1nM/W2IIyj5/5jP98FyhF7qatQbctzhUJZPCsVivGaU9Oopnd726xncW0jmm/Y46RjJCIhv2WrAzTPBcFQYNzlqbpyHkiF1mgKlkxtu3Qxfyqdk9t0y6qAq01J6fn4k4ZPNvdlrt3Tzg7O2MY9/hQuCk+0nYdXZcW/sx6c0LOiPQXFndRgBwDISspxvJBuVFJpcLOL2ZZKaBywipotcZqy36SIsZPHmMadCladMxCMEwJoxs44jKM40x1INRaPFKyEhfZXLJ/jJGxjdLSCRtj5PrmTMqhkCk1KVcfAi3ql1TGZH7i/Y8/oL9YYdsWlzWm6OdjjKTgsSbQrzu8hm0c+eX773H78hp/u0eNERVL+JoCrTKnfc/9ywv6xpGtZudHmnYlMKTWMsvG0BuHD5m8HzCAay3ayyZW5X9KCbYu9zoX86uaLlzHHSVEXh2Y6/WADSFQcQXvvZBhrV46ijrGgVe5LSEEsFZ8dmJcTOPQQioElpC94479mLhZ4dY6TqpIXyW3Vd5K9TCRf6aXewosELhCulqtRPxNGU82XYdpHNpZsWVPsiZ9iMw+SBJqhsa2RO/JSzlTQyvFMyFlSbXN6MKRONjxLxtd4TyA8ChQimka6W2DzonGGWLbMvc9Z6fnIrlPGt2Jo6vksQiJepjFGsBpKb4ldVbRtB1pFVHRYzV4P0lWjXXSbSeZ4Uu2j3qFI1Pvu5iUxWVPqKhRynIdQwysNitWqxZjQKskhoFa0JWb62vee+893v61L7A+W6OKFHS16hiHPX4esbYlZtAYorL85Ofv88EnT/FRCPCkwDhMaGfQjWHdr3DGVBkPMWcGP3O63vDGa6/x/KNnKC9hnNX3yJC5ffGSH//wRzRty1e+/lUuH9yjaSXPZgyJJ08/4aNffcAf/ac/4OkHH5Fnj4kSnZGj5Lb0XYvtHW+9+QarVc8UPVobWmMIySPGieXZEcBYFINGk7Qh24ZsJMzPZJHfagSdm8eZ6GsTEdFGnsUcBfGVaJ4yAlaGFDx+8OKjpS026zJulrUeS3NQGwAJUg0EMlYrtAWtBfkxVsjE4zxxc3vF5Z01xoq5mzWGprGkPEOJ4EhZ1rDOGUfGBA8pEnMg+ZlrpTi/OGNtLMP2mhsiq97Q9WfYmBieP8e2DX3naFVmN0/cbG94/vwlT548Zz/cgIoly0yTlWb2kcY1pdDStO0KHyNRi6Bb3MfjQuL2qTSZOhN8RMvWACWdWGsr41uVCEmc1hMQ50+ljSshhk9zxFppfIzJzPNnc5GFz3mB4lpJo0yUkDBnF2jzanuL9zMXJydM+5Gmb8kh4/GcnpwSyJiSHtv3K7Z7SRE9OTkpnaj8DEkjrrBygWwL3wAOcr3GtYvFeYX4QxB+wuXFxQLDtW1LJot8a5jZ7Xc0tkGh2O12cnDMM9vddom1rl15poxbssjgDq6fSvwJihdEVYKQoWt7WtcRQmaePMEHtBKL7ca1OCVeJNNuLzHqBe0ARUqRxsim7eeZHBPKCgKU62G2EJ7K6EkXa3SiPJSIQ+9cTayUzMzF6t8wRc/j50/59//xPzLmma9/55uY1hb4VvT4ruROkDLaWULIfPLhE9IYSHPE1qIMsax3xrA5WfPaa4/o+patl4OoKilOTk+LB0VmmAa0XFj5DBlp3ZKkusY0S4dbeBOVdFeRDeolUECR88GnIsWVWrxs6t/990zIqklZRU3qn8NBellHQfXQrgVKXXeVD0H5u+PRUf2+wCt8FVFvHYqrY5v5V8iqhf8knJYKGxtylAyqaZpkVOgEaktZoutjOsz4F7i3vOcFnVJqGU9xVKi9SkIuSrIkJEnjrChOtBZVCzJvv3v/Lt1qQ8yJefZyqFj5jD5IYnEt1OYYaOyhiBinSThl40jwI3OKrNtWSLfFxlvpQwH1aRLvskGXa1Y/B+pQgKYUuXfvLqdnG/pVW+z2Ha0Ta/jbqxt++uOf8Ppbb3B2ecZqs6ZrWyoPLSYpHpwVl9EP3v+I7//pn/Lk6bMyCtTLuHqePX3fcH5xvnyPOUjxNe5HNqcnvPb66/z8x79gGkchmE+TcNYUhJR5+vFj/mD+z7x4/oIvffUrXNy5W4L2PO/+4pf88ic/5+lHH5NCQMUkZoxWMU8z2ULreh7cvctXv/41MeqKnhiFsKuMqDBTLNdPSRdutMKniHYG2zVko0XtpDUpS8BhijOzn9mP1YW5OC1n2Qvk+5tiYmkWd2gxozQY51DFhVistLMowLRkq93c3Ij6LMpabZ0g9V0nXlnGlfiGELm+vuKrX3mTk9UK7+X5ccYWkr2Roj/JZpMKWqjKAL0xHaTEuNtzkzP9qpExzTThtSbFFdHPDHFGB8vF6QOsVTx99gk3+xEfIuM4Mc9B+Fw5EDKS4q0Uc05kqxinPf1qzX4aJUOtjlyURmEwzpBmiEEM/XKeiaV4TCFgbbOMhj0elHpl/6lNUN0HBYWv7tnFriH8D1Kg9JuNzLl0uQkx4oedaO1zJgAvX76knyZs3+KGAdM3rM5OaNc9t7e3uKbFWCHnzSGIJLh2aAW5cK5B64P0yji3SKWqrJOsFifM4023koUqj2GYRkCx2w1sb7eklPGThAv2fc/p6SnPX7wgFrvi6sMhfiTFaTHU7BvKmEj8KYwuZtRKgtmnUar/1jmmUZwSxdb96JDMmRwTYZwksCqBzjLCks/WgNLMQQKeNLrCBuWokFm4No6+X4MxxCJL1sYIbJ8LbGuEK6Mzkr6pLfM0sx32/OgnP8atGy4e3uXtL30BhZGiY/bSXZCwrsE2K569vOHZR0/JM/S2I0wDkOWhTBFtLffu3+Xhaw9KOnMpdhBnwzt3LzHOoJ3GTxOrpqUpNuMLZBwSBo1OmjnN5JKWWjNEyIcCRW6EZBAtyqsjXoLRenHXXay08+HwPT7EXl035VsfFSmHtWkXpc5xAQG8UrjWbr6+p0rerGtX1nexgz8qRo4P2+PfOysE3axkY9ZKsVmvaZwlBfnebePIWgqIROZ22DP5mS6XePn6PYsEYvl8y+gsLgXK8TUAFpm9UoppFt8UfaTMy1qB1ex3I9lY3MqJU3SRLSsDKczEkGj6lqhEXaAaMTcTfw8hUk7jyNOnj2k2K1Z375Qi11Tu3xEXKy/Xtl5355x4cpQQTV3QnlJekXJis15zdnZG09gi4xQ4Pha57fWLa376pz/m8uKCL375Hdq+L+opS7/p8TGTtObZ8+f8/n/6fT7++GPmecIh8Lo1FqcUwY+s12tef/0Nur4v3DmPbRt0I7k2p5dnnN+95OX1NTHOS2dtnRBgQXH74oof/vGf8NEHH7E5OUNpydK5vrrm+sVLwjDRaI0qqq+kFE3f4bNHWc391x5ydnHKNI0i3/cRHwO2cWhXTNqyoJUJWVuh5KN1fSsNmBEFT4zVOMwQY2K73ZETxeytuC4vz6o0FSCBo9ZolNVYnNx34bEKIqJLEVu8XMTsTooIo0T1GEKgLS604r8iY9XoPa1z3Du/ZL8LhHGSjJ8sI82sxBGb0mTKOEpjihP4ME4416BItK3GaWkkN+uWk82aVdeydhrChLaIcWaRaq+6QrL1oHXDOO2ZfSJr4cio4u9Da4XmkCJplvdtjVhd5CzottHiJRWC2PSL8RtFlJKXBmfxheLgV/TpBk2ebbmttZnneN/8C16f6wJlH73AlVkT55GYc+FOBEyF2kfPbr6F/R5uLc2mZ/Kee80jVv2K0Qeev3jByckpKSV2ux0558IFcHg/s9/vaRpxlW3aBtsIgnKcu1I3IXm8SoYLchPHcWSaKZb04qwZixGSxFlL59n3/TK7zzktRUSMh2RacT49vLRSB4JZSkvuRAiBF8+fA5mmdcSXI13b0FhLyFFMzypPIogPyvGhUD1PasqKKY6Qh4NXiqUYItlQrk1b8ncUISfiXEhSztB0jUD/BU2ogXkYcSO83e/58c9/zqOfvcn9Nx/SrXrm6FE2kyMY0zDNnqa3bF/uuXm+JQ4Rly0pKyFb5kQM4BrL2d1zzu5eCElQdj5iCDRWHnalkSwMK+OrcR4hidonxYDOWTJJcrGis3Z56GrK8HFhUZ+5ardfr1OMdSRwSD3OKZVx0MFyHg73rap36vc+5jnUw/BYnVMPxuN/Uz00jn9//HXHyE3OxfcnHRxd6+ZbXV3hgOAoEAh5ngnBc7LZCIpS4uLFZtwzhZncwDCNov7RwjGoHhjHXJ36Ho8VO3Ud1hwkpSQvZiEJI3EKYjAYiPNMyJHbq2seP/6Yd778VTH98yNt0+MnsVdvm5aUxDq8PoMZtZiOaQ2Tl87cOsd6tS4eLZFcRjCiDhHEpb7/5T2qgzFWvW5Gl9FKvdcpsD5Z8WvvfJFf/PIXjONAmCLDsMdYIVZP88TPf/wzrHXs9wN379/j7oP7+CI/nmPio4/e5/v/7Qf80e//IfPVIN5QSi9coZhlbNT1Pfcf3KPrO/bzTjh6OdN0Dc42PHz9Nd5654s8fvqMq/mlKNiKsVv0Avlra7h9fsXLJy9LY2eZZw9Z0VhLax2ttSSCmL81gmw5ZTi5OOUrX/sqJ2dnYgtQ1IhGiarDqAyYgjYApJIgLJEV2kqwX84Q5iD+VcUtOobAcLtbnlWn5BAWa/uCluQD7ykjI/Smcbh1C048Wip3SJRX8iyZUtgorWlMgypNULfqZT8nFw7YyDRMZJ9487VHvHi+45e/+hidaiCqlWJByRiKgsRqo2nbRoqAlGicFXv4lMS9O0oadWMMfdfiVFrUVzllxnFGodjvRl48u2GakgTIZl24OqLg0qkUg6ZY9hdJc5IOgRizkKqzFBfV+bftnEi0o1jVhxiIUVBXWe+v+jAdF+mHZ/rVvSwfPQd/0etzXaDcjHuqMUYS5p2EPymNUjKjTDGTtcy0W9vQdyvatme93pBU5ma3p1+tlm7IWgnvqgFr3gdWq9VidlX9BpQ+wPkpJUJMAh1mkV/O3tO1UvWnnAQCT1VeJXHkfd8LCTclYumuQwzs93v2+/2yUVeYTBUXSa0P1uosB0/pRstZFoLn6voKRaZtHEqlkpZqmEIhuVKspkmMfpbFqoXEqExJS00SrKeMLoQ+cTxUyENnG8c4zxjnuLhzCUrR9i2NFoZ5zsVLJCaG8pm0UszTBEoC1HIWB8YXL6/40Y9+wpu/9jbvfOUdIfKaVuK5jSH6jDMN77/7AePtCJ7lwU5FiYKSTfn1t96g35ywG7cCBc+BrCO2MThnabt2+Vofxaxr1fbkFJnGmegTJhu6piMGuacxyv2LUVCaVwsHyt+Fhe9x/LDC0dhHm6VIq91I7UBkRBmWccynX7WYWEZ76hCod5ygXEeCwJFM+lWTuVrghEKKs6Xorsjdp0MFhbUfF/loKp1l24q1deOsSKrLzw4poYJn8vMSyPnpcUj9jJXx78qI689DUFJKJcOFRfIv6cNWDKh8YBpG5hDFvyhVsmJRzWh7CJTMJUtGiyNpiLHIdRPOGrwxxTkzs9qshUdiJCYjCYFKrNGP7kFVLNSirimJsyHK85uzFKpVvWMaw71H9zm7OGM/7rmZb2QfCplOr3Auc/Pyhh/+8Q95+vQZb7z9Fnfv38O1DbZtefb8JT//+bt88uFjbp9f4zxoH0mq2NcjpmRYxWtvvMbde3eKXVkJkCQTs3AOLu5e8vrbb/KzX/yCcZDCjSiHpLNWiKYh4ZTFaFEx5RggSGSEVWL7Po2jJPl2LSFnZj9ydnHK62++wTtffod21cp6mOXeGFtF2AfiOUqI7mK7b8kqYLSsr8r5yjER8kzTWvw8M48jqhgeOm1JFhn7IaPoHKR4VkrUecoYslEEElHDmL0c6kmRtVg2eD8LZ6kip+SiNYembzGtw7YtyhjinNneDKis+dIXv8j+3szjJ89JiCV+MopwtKwFMZR4ADFIU3RtI41MiDTOYZRiHAb83OC0RYlHHavVKc51bHcDkgnZ8/zZJ2gaYopsdzPBZ4ZxIETkc5SGWTmH1ZbJTwuSKehvRQNl/BjLKHP20vDnIlhIKRdJfOVXqQWJrfvPch5TG48y7i1k/WPk5S96fa4LlMEX99OU0bksvJjJyQuRR2lSKhB7lMPbWcu663Ha4DnMon3wGKPp+16IqaVIOTk5WTadQ7eXGId58UoZp4mmWJXv93tRbLQNrWvKZh+keKgHVyjzx1zCzpQk1w7DgC/zub5fMfYz0+TFaj2KAZFKxRMjH6EZSlCDGAKUY0lUSQOZxHrdoQgYnTk77bnavWSc92JbrWAMnjF6yYfIUoGHElMvi7Z4rRS0yFpbJ0zlEI64puW1t97gm9/9Fkllul4KC2ct19fXfPDBh1xfX3FzdS0EPaeZp1CMvnSxqA48efKUn/305zx64xHrdScMf0FpMa7h5uaGTz56TPIRgxCxjDLEOJOVOGdeXN7nwaNHYCSDKRV7do0qJE8pjKxrCKX6r5kTWinmseTPZIkPqO6vr6QEc5DhAq+QJGvRsWTvHCEbIKjUMVm1HmzHYx1RlfiF13Q8MjoeAx3/m1CCASsPqoZ31fDBagJojFnWaf1ZYjCWX0Ew6vc+kHAlKVWrcvAVLtKq7+i7hrZtmH0gK4VWlka3hCzRCT6IUVg8KqxUWadCBJf1uxTe5XXM8QAWefahuJHi0WpD23XoHNmcnqBNPnJG1vh5RhsrqyBX3pAqpnO1ACrqkXIoXVxesF6vMH0nPig5k+YZypg0FRTs0ynRtZk5ns0nJW63KYuaKMeINpaT81MevP4aT1++YPSe1rbEELnd3kpx4yP72x0f+Y/4+MNPUEYkya7t2e72zJOHACZmGm1o24YwjkQltKqQI3fvP+DLX/sy53cucY2jVS0himPp7MX9tek73vriF/jmi+fst3uGYY9ShnkacbgFXZO1rYsYoOTWlM+TlSamiM8ZP0WShm7Vs7k85Xt/7Te4/9pDhnkq6EnJnckyoqak9GrbSlSAkgLJdQbPLJlIwZd8oEzTOcglmoHMOA7E4DFKOCLOOkIdISL+PcszWkY4kcwYJuzKQqMIPrELI61pAYVpDG3fCIKjxTQOVYQCGpS1KGNBGXLW7HcT8xi4f+eC5tGKf/e//XucFdPBm90O7VrEpFsKrBlP14i6EyUKVK1EaZNCwHYGlatiyTFPEe0suJakZBLQtOcMY2Q/Km5uA1dXe6YgLIDgS0OiDAbFyckGqywxZrZ5J5+Bgh4X52tXjBabxomYI3is0ZiittNGF7+aktSdjmM+DiPuup8dFyi1cXPOcnszfaYz/nNdoFQlg0G6I5PzQvK0SZwkQ5aAqil6ogV30tMF6XBudreMw4BrW3F11IqmsTRNQ9Mc8gSUUmw2G+Z5YhhEL9513eJPcXJywvX1Da5x3HtwH1+Mkpyxhcchm1ffdyg0UZcuLmVAvCRCkAJoGAf2+z3DMBygsgViV0dFUq1+D7HoMt4qZlgKdvsts5+4vHNGTBMZz3rdYiyk7Gn6hqQzcwqMYcaTaI0i+lzsiilJnPUlD/wyGqgqBWuwzvDWF9/g4u7FQoL1UQ7Mm+sb3n33XX717rv85Ec/5uMPPyp21p2Q2YKMpnKC589e8sMf/phvfPsbrPrXFtlqTFL0PP7kJU+fPCbGwBxm0jyhkMgD4yxdY7h7/744gFpDu1qRQyL5iDWi+W+aTiqeVMuWgw291rDb7Xj58ooH4wOmNJGdjG6slQ3OOlcQlQOEXx/KmlBbi5NazB1zOWpxeVxgHHcexwjDcSbJMWJzXKwcf92xz8CxPfyxT8ef18GIf8dh7HJcEH165FILIJAirbEO6wrXw6gyrzeYmJjCiPeiaDmWZR9/z0+nAB+v70+vd6UOPik1B0vm41q8M5zDrlZ0rVvktMpIhPw8C59BayuFbxZvmUr8zYkyzpTPIIaLCqdMcQ1VxWRPlWdRL9ezFn6Vh3ZMNrYVLVqeIiXqihg5vbjDN7/7XW72e16+vMGPwg0RCWemcx3kjN/PZclKFICzHUqbgwfMOBGVwa5XJCMIKBo62/P6m6/z5a9+udi6y6GjipR7nj1aJ2yr2Zxu+LV33uHq+RXjMHLz8gbjRIhgrMRfpFA+gcqCshYXYkF4W1E3Bs+cZrS1bC7W/Pbf+G2+9b1vESmNTymetLaCTKUkeUc5SsietqRUiOAxlEKk3N/OERGzuXEc2I072lGQA+PsYqOQRC2wFLFG1Tydwq2xRnhA5ye0m47udIVDXE77vseHwPmDO2zOTvB+KorRSOXHBKDdrAmId1WY9sxzIkXF5eUpRjk2m5bdix3WaTabFVPIYmqokcDEEJhIdG2DSogvSePISsj7tl0JwqQ123HGqDVgULbh46cjH3x8xc028tEnT7h6OTJHS7s6Zd7tGbd7KWCahqbrcMbgXEvfdIyjZ7XaMMSp7OfgjKOxzYLqzl5Izq1dFd5Phqzoux6ljITjlmKxmsBVp1jgFQsFVfyS6n4kiMvVn9mD/rzX57pAsRmsEmfHBoUpI45GO1rTkIrsNiKs95qnIpuKEIwu71zQrdesVj0oGPZ7lEYyB0JkmkbatiUlGb3knDk/P5cC5+Zm6eROz04XiNo1jURdayF01XHKMOwZx0kQlBCYJzECstaIG+Bmg3OOaZrY7XYyaojiz7fAwkYM1tIRRF6VETFGKGFr1gmT2zrD2194g//0+3+A0gHbahIzyiRsY/HR40n4JNCvKF0MKkYxcZNWsRD8XkUIXJWCxkjMHuM09x7cQZdC67wTX5izs1MePXrAm68/onGW3faWYbcr6JGD5EleEBs/eT756AkffvAxb7z+Gs61sgGXiv3F8+fc7m6Y/ERIvjj6svzfh8h6c4JpWrKxWNeRVWSeR4b9jMq2HESGFGTPUUX9oZVhmmaePnvO93/wA6YwolvN+uKEO3fviH9DyZiIKbzS2dfucokqyHkJfDMFmTlwUHKBS19FT46h0uNE42ODIyVt+CtE7OPupW4w1tqlkx9HWcM1fqH6m1Qe1VxtyctzdWyGdlwc5dKN5lxUFsYKsdhqjD0odKSoFa+MGKPkS/kgnjIg4ZRerksdpQqgcRib/tnC5FWuiiAwEsGgixx8nGYIAZMzjXE4pdnv97i+p+3X5BioGT9aHfF8lHgqGS1RD9kHtre37G5u6PsVyWiia9DF50h4bxSre72ga7XgPJZH13HbwRRP5NQoTdbQdR1v/dqv8eTFC37x3q/46P0P6Z1kyMTJY5VwZmbvy9hMgvtCMeTLOmGUkjFbFsWcR2zKlTFc3D3na9/6Gmd3zskqM86Ssu60K3dcFU6BB6158OABf/Wv/SbGWP74D/+Y7dUttze3xaBRoZyRhFzywqkp9m/s/Sj7rNWY1nF+95xv//p3+I3f+k1OL8/Y7bdQfGCE3CzmidWliExJGheOki2qQOss/XrF4EeGMMumrxXOdYI69BavEmOYWa9WqCR7WMx5ebZzzktqszQkEsPxhV/7AtfX1wzbPX3X0zQdm/WaGCP3Ht7n9bdeB4UUSlbWaciSX7U62bCfZsY5MI2R29sR7xMP759itOb8fMPTmx1d3zBsxcsqK1CpRA1Q3GK1RhUEpRbHPkSmecKVQnaMMF3vmYcZ78H7xJMX1yjnuL3ZEyNMXpGVRWlHv9ngVllCM4koaxlL0GM0mpPLS/oiJyYkVJYmfxj2WGcLb7CVlPOcUErQvFW/OqitongJNU5GpzWX7rjJkef5UMz3fS8hkp/1jP/MX/n/h69VYamrjCRpKk1MQSp9VRZ9cT41WrNeryUdVCtubq/ZTwNnF2/QtE0pYJCNNie8n4pJG8ucLaW4JALHGCV9NWfyPLPebGSEU9RAX/ziFzk/PeUXP/8Z4zCiVOZ2e0vwsah3xPRLMoDyMlOnbKDiPipVtSTYHjprjg/GwkOBAlOTy+w0k1XCNYpHbzzEOJjDnsu7d9l8tGIKgWn2RGTMM/l5yWcplw2VsvizJJbIdSgKoILsxOK5YrImJI/JGvHR0MvsUmsxY/vCF94mxcjN1RU/+8lP2N0MqJToXINXCZUyU0pMw8TTx8+JIWG7Dh9HIfVm+PiTj7jd3TDM+wK9yoOTshIFks4Mw8Tz51cErbi5viZOE9PtwDzMXF/f8otfvsvVi2uyz2gMzmgx0VJCSPYh8P/5T7/PD37yQzbnJ7z5xTf4zb/2m7z22sMChUrnIEhCWg7vXIifVWVSkY1jFGUpKgsKcMzxABY5Xh3x1Ncy1kBGkvVn1JluJde+gkqUQrLv+4WIXb9v7XZeybVZfDsOKcnHHBooZGwt5L5qYmesZNw0jTtkcSjJFmnblhAORnRJI+vXHObSdUxitF5UdMejs2PeSsoHZCglGUc6V+W3cri11tE1lusXz9lu99zrukK+lBNKCuzqwSJ8DXVUBJJiMY0TlMa4hjklUlFvGG0J00SIHm3NUmTVe1eLlIquHHOJUilkjbYoa5lipFmt+Mo3vsWHj58wzjPbq1vh05mS9ZIKhwLx4TCuFehfScHStA193zHudoxhJOmEcZazO2d8/bvf4Du//l1MY4lie7u83zTLwWONpCprrWlXPY9ef70oYhwfvPc+77/3K+ZJEnTnXQRXze7CUqhpJ4aRymTWpxvuP7zHN771DX7z//HXWJ+uZYxQSPX1Ool9vBYkxSqyKgrAUlhEYAqerut47fVH3Ll/F9P2gl5pxcXFOet1z3q95p2vfRm7agkqEzU4Z/HTJMR3rYopXY0HoaQWZ9548w1OT0+FSNytF4SwWkI01i5jZte0hHnER4/tWtYnpySl0K7FtR3zlEhBsTlZs1l3fPGdN/nlJ09RGsZ5RJmGhCKEGasrN4xln2iK+EJpTdc2TGFmN08kndBtz/524vr5lnGMaNszhox2osBJSTNFT2MyGEPbdLTakPd7CbU0Cq81ylpmIq1t6EyHzhL+mCZJ2W6ajn7VE0lYJ9SH6Geca4mNZArVkEyjDV3bAIJE+rIX1fHmgSiry3uUcfNfgiP7+S5QXAaTyhOsFCnLA4PShZAqzG8NKAv9qqdtG/bjiFYSCV9dK7u+ZZ7Fir5pGrTROOVom4Oc7OTkhBAC2+12KSJ86Wxubm+x1jJNE+M8c35+jsqZJ0+eMI0TMYlscZ4DvtibC7xqmeeJs7MT6bjToWP0QcyMjIF5LptlaWMP3bsqgXaFJKyLsiElfJgZ5z2np5dSqKXI3TvnOCeOqs61OGuY5iDadPkWC0+AClUXJKXGzSulSKWDz6TSPSeZrxKLTT3l0NSMo2RjNNbx6NFDfv03fp397ZZfje/jhygMcbTI+JIQ0T547wNur7dcXl4Qk7io7vd7Pv7oI6ZpxIcJY1UxBxKdvjbiNfDkyVP+1//1/4XuHC9fvmC83dPbhjB5xr04m077GWfskrRqjcXPvpAZ4er6lsGPfPzsMTf7W37tnXd48OA+KUWa1mGVQRUoWg5UvXTntbCo7rFV9VEPLa20KFqENXr4c6NptCSk+tn/Ga+dZQx0hL4ccx6OIxdq8VIPf1Gq5AU1qQXIMmJCSM/H46X63zFKI/C+Kgow+fuu69lsNiUqQmTdoviSzXb2k3j65EROlbCqFyUT/Flezaf/vBZzGpGvV1my0cIjEf8TJ+ikD0wpst8NDLu9mLuVA1/ga2k0TM7MfiYlQXOg5GQV1IsS+4BSkvhcPC0EpTSLHfyxeqo+F5Xfc1DivarqSVlyrzLiR/Pg0SO+/Z3vMI4DP/r+DxmudlgNykunaovZW8pClFc5i2SbSMqG/bCTtN5GiL+nd8741q9/m9/4a3+V8zvnQlwuzVp1+qxIEiBqPAtGST7Ngwf3yd/+Juenp7Rdy8cff8TLly/xhZ+W9MHWX1mDbS2ucdjW8frbb/Dd732Hb3zz69y5d4kPnnEeS1ErxpPWWHJSy/sRwmbpvLWMYuo4JujAvQf3+Rv/89/gdhByZw37W69XdE3D3bt3hJRtRdIvzWWmMbagwAVlVGJJEZMUKNoYLu9eAAplRGoOCp0zPnrqpmhckcdq4WOobHFdR0zVwlCx3Q+ElPF+outPePut11H/4Q+AXMIS0zKWPKAMCBcwy9gwxEgYB7RdM/u5GM05PvzkKU+fXDFP0LoTMBFtO5KQo0jRg9J0jcMqJfweq1nfu0S3VviFKRGyojl1rG2DC5k4erTJ2NYUhFHGg+Msrupt0zJOA0YbTjY9MSS6pmMqPjnOWsZhwLYWpTW32y0pReFuas12uyWmvHA7yTCNn41/Ap/zAkUrsTuWTkcOTSgs7AIBZ60waJp1T9O3rE82OB2Zidy5e5/GNTTGMQ0TSSv69Zq+l9TjlMQxdJj90vX60qlWGD1VnkEhhPoY0cD7773H++++K5vlODJNo2wyXqrXxrX4cYcfJ0IMvHh5xW6/J8TINM/CnSGCkc/hmuLip2S8AEpm4jmTYib6QpBVkLV4dd5ut+x2A+aewRV52aprWLeO3c1IQ0enGyatUVHjPeRkCF6gTKMFTcq62mJLwCBHh5gx4jgr70lm2tFUa3TKKEKUQdo61ifnfPnLX+dXP/+QZ59cs/Vbhmkq8iPJ+FA+M1xtmXYTWmk5OLWEwE37EeUTJsrsNBpJ2aVsaDprXjx5yYurG6JWzFGIdc5aTLHetspIoZdldp4VzD7ig3Qfwv1X5OJ8u9vumGfxuxkHT06xzGUlYybJjVmUCMfKmgPyIShUzFmCtxCiszFiPIUSW/TqhaGL8kbBMpapqAmZxVzt+DA85rPkIyQkpVTUWYl5v18Ij8coj8pVxWapUsCyH8sagIKGySgnIRywJlshApbno/KlchLiJCaWMc9AisWbIr+adArlcJc3X0ZIr/JenHXUgMqYKeNb4SbFOIvKIUu+SoqZ7XbAuZbNSpC1YXtLf+cCpQ1R5cVQUCUYh4nOaOZhZJxGsg90TUv78CFJa+aUMAqcE95CjKIay6Vo9yGIvPdIclxHs/L7SEJye3RBfEFiAbQ17Pe3nJyc8sW330TnSO8cv/jxz9i9vGF/vWUqsvecDhwwjIgBlIYQJ7JBCufGcnZ5zle//lV+63/6Dd54602SEU6Z1pocxZTCKDFz1GRykZfmqAkEtLWcnq0x5gGbk57L++c8ffqMDz78kE8+/pjb7RbvvWSTacOqX3FysuHs4pxHb7zGr73za7z1hbdYrXp8mMhK4kiyVoRc0CsMaJH+q0LQhIArSp2UJKKPCNoZ7pxf0HzzG8SytlHIGN3W8FMh1VZJf855GU/UdQMyGkKB1mKzYJRGnnhFChmnxNQNlYnq2BxRSLUaBcrSuhWrZiOIAmCdE/IoEDPk2dPnyKk1NNoRw0CMYA2gMznVvaIUTSGKLDxF1icb4jzLGleaqxcDu3Hi+nogJcvO7nGtols1ksFmDErJuHVQBtOfsOpbutM167sX3HnjEaf3LrCtGIKmyTNe3zI+u+L6/afYXaDJGj9PzEnUnHaSMSMp0RjZd042G3EmVobkI2H2xDmI4pHM3g8oJEspTJEpjEzDLIWmEfVQKGPWz/r6XBcomcMmocqcv6IAyohaY/KBqKFpW7Q2TH4iWkV/spbNxXvatiMXApwpkJn3vsDS4ghbD4EQAv2qF+OyDMH7sunkBTa32nDz8mpR+SiQHBsj6EKMaTGDygX9HcaBEGaub29lw9PiqxLJJJ+KDfcR5J5rd1lHByxz3JgiPirJQBlFzmsbR9iPKCQTJMfI7CfCLOFX437k9uaGRzyiQu9mua5l9p8OIX5VoqZ0SWE9KpaUkc4keV84PJ1Y2o8TzjacbM64e/ceqjiLaiMBf5IbCjmEAs/KrN9aK+OlLCZypsgSteDSC9oTghiBWWeZBy+qC1NMmkJZLFpJmuk0YguKEULxCUliipcRV9REwjSGECQ0UhW1UbUBF+jXHIqMdAizO0Yf5HsfkU/zgTsUU1r4RFVqbLuOpm0FETkyWXt13CLXZZ7npTPPWfx7fEEbjs3catdWVslSmCxQ7NGY6M++iveHqrN7UTalGInWkrIgaILiiceLtYY5zYi7bmA/DEQfsI1+pfCohX/lrhx/vuOXcESKOqmQ/2q37awl+Qip5LAYy8nZOcl7wjhhrEHNntuXL2hXElEf40wMov5rVKZVYpl//fwFzjnOzs/JxuIRx+qmbQU18OkVNVeqcmxYDsZamSwEZsGKhGNQnl2pqJMgQAX271cdb739Fn3Xcrpe86Mf/CkgMRR+nBfTLymwEjghjgYlP981DZeP7vKlL7/DN7/1Td586w10U8LwFulSMVjMAGnZf2pzk2IkhIwzCusMZ+cnnJye8MZbb/DOV77E48ePubm5Zp5nhv2ANWKhf3l5yfnlBZd377DerNHWMEyiIqzcv5CLThZZb9RnGErKeXlPqbwfrVFoKeQoLsPWoq2VgkspUpA91GpdeBJFrl7uTyzPlLbCyUmFP2SMKVy7GqJYngslCKU5HtXlBBpyabwymf1+z5NPHhPnGWLAqkSOnmnco/S5PLsh0BSzNde0+EnUgZXTASzfr8qqMzCNMuYMQLtasb0Z2I8TOcp+5bRhvVphClq0XnWk5BgGiAqUs5w+uMdXvvct7r7xiPPX7tOdbHCN5OWolMjDzOOfvMt/ffEfef7R+5hRvLeU0zSrRqIcciqRL0IQV6UA10rRNK5wCBVTks/VNuK6Pg4j436Ps5bTkxN2ux1Wi4tv27RLE/NZXp/rAiWUA6zyMnIh25Hl4qqc8UTpJp1If7WRSOtVv5LCIUb2+wGMZo6e3X5gmia6TmAsSZttSEkipWc/sxuEbNg4STutipx5niWwLwTpdjSk6AtUZsshKgTB3bTFh0DX94SUGMeBlCSavgamCVJT3Wnls1aFjBxYIMak0u1WFD6VDXAOJWPBGtq2I4ZryApnxahK5IIyJtnutozjKH4DjcPPJVBt6XTVYu+dshQRGSAESd40It/UGowS6LayLmuXEFPE5sxqs+LOnUuMKUGPSRFikTMreWincSocn1SUSUqSfY1U9kZZlJZxiTFKiHthKjN/8bIwukQDJOlunTFohNfDUtyl5cJVjgIKmk7ueT1kxmFivx84PV3j54nJj2UjtDJSjHJAVg7HYf76qjy4kmLrn/0ZVRYshYL3nhzjYsr2aTVPtcWvr0Xud/Q1x3K/WsVWi/vKkUgxLgTZg8S3cj+O1lT9vqqgKuU/Yy1N12CdGNrJxE2ho0D1OWS211vmacY1zSL/faU4OXrPVYJ8/NnqdTn2HtJaMqYkPiGRjFizazggGM6ymyb2w5ab7S137t9jtd7gY+Lm+gqN4qTvSQjKsr29YbM5QWlDv14zp0TISZJpnX2Vs1OulT5qGOo1W+5r/ayw7E1yvxNdMfqKKRHChHUt/XrF62++wapf8eD+A979xS/56P0PuXl5zbAfliwnGdfZIjl2dKuOh48e8J2/8h3e+dI7nJ6dolu3uKAe//BCdyUjI7JcgiBTilgn13D0E0ohfiZlXHByds5rr79OyoEQg8RmlHXSWCeZaEaXwltQI9eI2SUlqdga8UuJBWm2uppbsjRgKBZ/pgTM84jRRUkVpKFSWUj9deH6GGmbFtc0BLFTLby5TFCqqMvEOkAh/lgmJaxRIhcuCsmEEHRDbSTKOC5pU0bKIyEr3v35u/zwT/4Iogc/QQr4cc/N1Uu0fhO0ZrXecH5+CU+eLM1eruR6rcVVPwj30WrhaVhrGYdJsq2UYdpPeB/xY2ScPGfnF9y5cymk73I/e2vJ2ZC9xzt4+IU3+eZv/QZf+SvfxmwkJ8sUJWmKkc3pKad3G57+4gNeXr1kP+zpoqJtLD7O+FmQqHW/5vJCXLdjEOfb9WpN2wqPc3t1WxrPUfZlaxmmkXW/wijFNMke3rXtkhkmDeX/IAjKnMRtsELR1ZBJGc1c8w6Atu2Ywoxxlrv37jFEzzTP6GiY/EybMtv9HtM0GGsWl7y6WTtXiXUZawzTNIhzauMKvJgIJasmeo+fZ8m8UJkcA3MKWK1prBVzoxxxVjPNSWTOJX14GMYSex+FgKcBhEPgp4GchWldCzIWRAWM0VIZkwtPREKahqG6ZbYY05CzJmdNStKRdF3H7XQj4wpYNquckqAVJT05Z/FUUFrIjcLip3B41PKwoMQnoG6iXdeUEYHYVksei2xC2hiss8IXkslRGSMUW3+UdMchFEy/wNxJlBtaiYdCDTFUWaG1bJ4KhS2FUkpiOBVTFk4BWbJ4CtJQr6NtJMLAp8A4D7iSt5FzZipIRfCh8I9KnH2uMkspiI/RjPr67zmmHnNAjsmUx4XMsnnnvKxHraUgqmoqpTXzNC0y13qIHiMiVfUiI4p4GENk8QupRUPlSyxd/jK2KtyHcgBLEnX9koRxZpG2Fi61HCplxBpGL6z/ozyeFIujpn7Vz+W4qFte+XCNXlEjFddLyrpVBZGY5onVqsMozbDfS7HrPWma0auECoGrZ8+xSnP62iN0iqiUWfU9J+dnKKOLA67Gti253ONaFFYzuwWFyof7tkCZHNaAoBb56E+EqzMFL94mWqMQZZ0zhkePHnL38pKHDx/w/vvv8+zxM25ub5fP7b0gQ+v1ms3pCZd3L3jw6AEPX3vA5mRDJjP46YjwLM/gcnOUIKE5K9mnVCaEGaUbTCMBeM46FEr8dAQjo+1aMpaujD8E/fFoDgT+kGIhrCvmIBw94QdJMaYpDtRKYbVb0qFlj6gkfSn6dFE76abBaUee4zLSyUkMJKuNw7gfyOQluyukJKRso5lL4rHWBltDCUlEn/BJNh+txR9l8p6QApP3GGuLv1KSIngcufr4Kb/805/x0YcfLs7GTsN+GJnmgLEtMcL5+SXn55eE8JH4aOWDUaI2RYZbk5izImVVSMwNbbeS9zF5wizk21W35o3XX+fk9JRxmtmcnJDLtYwh02pLe9Lxrb/yXb7xm38Fd3nKSCTU8beRBiIqxRRCSUKOdKsV7AYZ02uRdJ+sT7lzccnJ+gSfpNj33hNDWsaMxhoaYzg9PSHMcqZabZjmkTmIStYYWaOVVOTLxOGzvj7XBUq0NaNEbJgFzlc0xacCLE5pQU9WDZFYPABk4YcY6FY9xhhOrXRNOWe6tmeap2WsA4mmsZycrEkpMRTpcd/15JhIQQoNVWaJt7e3xBgZ5pGYAtEHTNfg+pZ5TqBEzmuswvuASZa2a5j9hEW8Co7liSEKv0PJaFSkYepgmy6/yKX5V5AUKRuG0TPOsxzsOZNCYhhmpimIx0JXEAmlyDHh50mMy5KQ8mKYmedM3/X4GEEZkkJM7Iwt3Yh0GdH75T2kHAspN4gCYp7FFC3Uw84s3hgh1OyjGvQl3CJrC7/Ie3IpbEhJ+COqjOZcA6gi146EmMCAaxvx3Qjy72T2Lvba5SQBpXGtI/hImMWuH4QXELMkYAc/ydC4PE+SyaSZvS/GbnapqnQp2I6RkVoEVBOvY8JkPZCPlTzHypXFD6UUI0uAXi1iKAiikgMkpCSS14J66XJYzvO8OMnKZ3B/pkiqMuhasNTvL7kvh88C1atE3k8lM2prcG2DcVY2shggKFKO4vA7WyEzJylacs4klV/5vGQW2+1K7D0ek8XitVH9FaD4WZQRzzzPpVgyzGHG58wsUB9DCMQEXbdCK0sKEgTnx4modZEcO1zbctp19JsTshY0QEINE2iLs3qRZS8E6MyB05NLga/q8yj8JqNE1XYYswkRc/Yz2ojCLaXMNOzRxrFZrYobrOL1N1/n8vKS3W5XxnnFQLAYrXVdh3GO1abn7PxEIgQoY0MOhW2KgZxjWR+mhJdGQixGWlqhrBIOQkg4Y5m8L+PoXMjXiWkayTqV/qh6i5SMlmJmmXOWMWwWhMw2DTmLhNZ7T1JKrruxJGsISZRhSmuULURgVa+l8EhS1vgo70trg9NaVIez3NucE8N2R4olVgIlZnUKApkxBryXvTiOAXwUQr5W+ChNTSQze89+HpmDZz8KJ+nq+ophHglhIo0j22cvCLcTL59cQdC0/YZhf0NyPd40rE/OCeM1Xb8WPkpBaa01pGq4acperYSz4mMi5eKd5IRvFbwULmRNCJnN6Zr1aoMPM7Pf07bnNLbh9mYroxhnYbPm4aOH2K5hH2dM3zCPE0Y7Gm2WUVeMiabvZB9zFrvqaarIwWrazuGsZrffcrvbysi+KDrH4tFllKE3Pd5PEjJZELnNRs7JSnmQwr7Fx0goGUef9fW5LlC8opj2VFhVYtSDUaAtXddKeNPde2zOT9mcnjBME7qx4ieQM7YcIn2/kgo+BPqupW2c2HNnmTG7RoyoIJdMCLH4bmxD9JHzszP22x1+mgRJSdJVDtOA7VeolGlbMWp7+fKKlEM5uMQQagoyKhLL/CIjLfPbOFfXvkMHfexcKZuQ/KdUhbcdMeaSf6Mha7GX9mJNLXaIsuE7K5K8YbeDLNCrGF8JudZqwzh5piwjI7QiJ1UQhZmUIucnJ9I9ZykY/ewx5aDNSuNDJCP/7vrqhsdPnjKNE8EngZDLXLzC/sYUj4xcrPaVXJOmbQRxSgGbLVkJsuOjdJbaOYw94neQpBszLAFkmSxeDapyUIpPTtIYk5mmPabRJKK4hmpLSkEMm7qDi+4h4C7jiv2zzNwPMtNaDMCB9+HDjIzXdNl/c0EBBVauOTVw5D+ixQStjmXMUap0ykFiARqDCrnwMAyuaYQ7oyEjRaOEqx0KlBpmB4dC5Nhn5LiYSjljC2IVgl84IVqLA7P47zimuUQvKIFTgo/Mo4w/l+tG/jPFnPybT2ccHQoWVT7vok4qKNHxSxkhgrq2RZXi0qaWk8s7dMZgnZNNeQ6sTk5pnCNrg0dxenGHKQSB/K2keFeVBoqiDCmJ5GXf0LV4y6LU0DkfuEw5L+/Zz4ULZAyqsGStc1II13Rp54RHMftiXpax2nByshHb/XJdjteVtmLpL2POotIp420ZtcpIVik5HJUSFZTczySEU01BCFTJohKCaAypFFcKrSWU0ZbRiSprBwXGSCiide0RCgs6UZybneQHdR3GNlLAWotPGR8Tc4rkJM2JKQitH2ZyiLTWYNDMfiQl2SeUEu7KNI74YcJoRZgnpv1ACtL4TCEwBM+cIz4n9pNkK22vb5n3I/NuIM1hSVoXlZPYLeyGnXD/Smr0dtgXRSXoGHAJbDL4OUI2Mmfv1rizC8z6DOU6rp98zDyLbcTiZVTQ4ZqtlqGM2jPi8K8IMZOJWEfheUmycMjg2k4QYA3rzRoQx13nNMN+YrU+oVutUD5ghXUvUQVKCrrqJ0UMaEr6t9Eoo1ite3SODPOemAL73Q5dzDPnFAnDQM5qibjw3mMbzdXVCxrXlObLEJHnI8Z08MtqGtq+I+z39G0P5n8QBCU5U1jVimytkLysxq1alNGc3rng3sUlrZVI7ayEAe6aRuB/reg28uB3Xcc8e7quxRWr+tnP7HbCFQl7seuuhZBsnJppnpl2A/1qRYiR65tb5mmmcQ6NoXWdeIKEyDwFbm93nJ2dc7PdMWx3oDQxCYF0GgXu1caw6jfEJhFDJgdRGoAsboUmqfSK/LMgaPLKCGRYYq6bxkkeT4boE63piD5KNk4MRfGUCX6WRGMtMjyJcm/50Z/+KX/645+ym73I6ErSMYX4d+fOJd/97re5d+eO8DZiUfrUe5OEANk0HX275pP3P+bdX77PPHqssQv0l0ESjovhUtNIkXm7E3+Wpm0xTmOdwTaWMYzkGBbXVqNlVhqyl5GTVcQsDqbayMhIRTkUZ59AmVLsSSpr8B4fZfwUo8e1lvM7lzx69BoPH95FG4rF+2GEE2NJ5y0hcsfjik+TW5cxTebACygjpiUx1UhyrDGH0Y/k4xxcGoXYylKgHstyK/JQzQGFhFnHcfI9jxOOa+LuksvBgT8BwgVQhadQodlqXS3vTzZaIaoryThR0hHmHEGJrfkwTszey88pqqBllFNcWY1igdqPOSnAQjI9NnI7ZqjU0M1UkKQQJL3bOSekY9tgy7/PStFuNjxoGhkdKY1XmqbryOOeoIRHFYJwINrGQSHUZyVZJao8cIs/UCksq3pEGb2QvMVITvgNuSCFlLEslIILhbVuGbGScuG5qeK9pJfPK67HFTmVQyTmA4cLDgGQqZBjBUm0y3qpFuXKOioDWiStpoTmNWjEwIssnJXkRTDgGiNBdkn8VmqxppAwP1UceW2xnfeTePAMw0RA/E2wht1uYLffM8dILoFyjZGx+e76lt3tLXkOODR+HBmmgd20Z3uzlfszzaRpxiLItR9HgvcEHxmiZ06BKQbmFJmLx03jHA5NGGem/SBocpZCz1iNj565eLYoo9BGE6IXYzVt8OMgCI4tfMakGGPkb/zO/4xWkdx27MbA4yfPGW93bG+3wnlDCldbeHchJUIMGJC9SRdUCyRnKESUKs95CkuDlpAxf78SUzRttPjTzBPn5xecr9e8/OgTUm84fes1urYVRCbGxZ6AIgTo+06a9puJlEXwkQsi6lPidrcj+ohxDa4RW4z9foezTvxMYmK1WrFerQQx8YEhelJuWa1XrNdrtrstq/UaZSyua9DGovefvez4XBcoqs5RgVx4ENM8oXvHxekpzarDdg5tLNYa0Ir1eiWdldZEEmH2+FTC1bKMVG63E3mbl/A/8XeQDko6XUPX9bx8eUX0UqXe3m4x2gjCoERO6mNCfE5m2qYREzAfeXl9w+wjru0YxpHb7Z5hHAEtC790ot5Hbm/3S7ebUhY0gIN77KvEwkr8lKobK+ograGxUqD4KUjH4yNal6RdpYQ8Ok4Hdr0Sues0jnz/+z/gv/7hf+PmdmSYpqX6B4WxhocPH7Jqe05//YSz0xOGcYdzDfM0E4LAlE3To7Vjux348U9+wfvvf4yfM21BMqIqfhtJsmEu79yhX/VMfi6HWiQm+XnbYYtPs3BZjPAQrLU0Vrpj6xy2ceAkfDGmSNe14jisROZ5+/ya7FOpD8SOORU0olu1tGvLF774Nl/6ypd48Oghb7/9NptNT/BxIUjKdCcX23ThxACvHKIL5H3kleGcI3MIC6x/dlw4HPue1H93PAY6JpZWnsFxXtTis4ASrwolOUSxnHLVLwXKiOLP/VlQxxGqKJ6q9461TlZhITc3rYwalDFo69BRLQozkeJ6yWApJMpcO8gs3iPCHTGlYDtY8i+qIvXq9ay/1kWtcewF48tYTbg6AvljDRGRJSsEsUqFP2Ksk6I7BGIdx2hD08mfz/MsfImKEE2DmAQqu4ze6lglhIBtxPtmGWFpdbBESAd0TNRWCLE4Z8ZpQmcWM0hVxncpUyD26riqCpeKZQylShECYuaXqY615eJRisiiGkspMRdulyA5ghYJnwdyMqSQUFHyWUyGMEozk6ZJeE8xkJTHOCdhi8gzEKaZ7c2WsLvFzxPDPDPFSCCTjWHyAeMckw+8vL5iu9+zH4WEnoNwVPw4MQ8jOQTiNDPu9iQSPgvXhJjE7boQ4HMQknp1aPVkMJps5JrPwRNyEsKm0rRO1q/VCp0l+ybFhNOCZGUiIXnCHFDRY5tyuOaIimIFn3XHarPmnS9/lW995zvsti94/Y23eP/Dj3j27CWtNsVdWhQyKQYZkWtdmkhpbHTZv3RBFlKUUROFhyPKOGEQ+dkTfHGdLe6ukhuWyCnQasXu6TO2fo91hovTU2L24krbtlgnvDY/e5qu5fTsjPGjF6SQCUnsKVKU65iTWBvElGEOMuJWMlLV2ghElmVdOWNo2lbOWRRNkTSv9YZczom26QXZ/uwc2c93gSIVny4JkAKXO+sEFj09ZbXqZBxhMoFIzgGHkeq0uOvN84xPXm641tzc7happilz5uBrhocpEHPk5uaGaZyKMZNClYwOX+ZrWhvGaSqJq36Bh7uu4/GTJ+yHgRDFGdN7Cc2z1jCkCW0CyszEmBdVUD1wjLaL+qV20QeVSClOohwAWmuG3b4YT5UNLEmxIlVwy+yHxfhpnudy2AoaUBMrnz9/zsvnL5j2pbI34hsQcyZqz0fvfcAfmP9Mqx3f+MbXcF2x9SYgDbLFGMc4Bn78o5/xh3/4x+x2I6v+hDgNzGXmK90zrM9PuHvvLmeXF0zzxBw966bHx8Trb73B5sc/ZY4BZ3Uh6ULbNKy6FZ1r6foOt+pQrSUp6VxONxs66zhpe4iRH/zRD3j84RO22x1VkptSRDcdSQXOzs74nb/5P/PWF94URGfdMc+SXWGNLebc5ZDkQPw8Tg0+9vg45nEYowun89Wk4HovjxGEKmet32fpVo+QhipjlnWnX/laObCOuB4FVatft8iQj/ggh19XPxSzbKgVtdPFmE7QpsQwTmgtBeHoZ4x14imBRTtdCk3hzKiC7tQNenmvBRVJyyF+QKpEqaNfeQ+1kItRFHYLabV8jmM3yxAFIcvxgCjKmExhrANjZHSRBKFTJWg0piDZN4W7s9/t6PqWmCPDOC0p0NYYOXi0WvyRFGIJn2AhVGsjPABRlxWvpkKg1VrLmAcxWuzXwt9KUbKNSkRxKdgLSdwaYpSQxYUMm0u8RhYTeWMtRotPVIhzCSo0ZWwlYY6RmjqeiT7x/yXvT54ty9KzbvC32r33Obf1LjyajMwkGymTlOjUJQKsyoqSBmIETIEBI1lKZiAGGBgTBiCDsppi/AUyzDAD4zMoPjOKD4kCBHyfKECpVGZGdhEZjXu4+23P2c1qa/Cufa6HoCBETSqNIwulufu95557zt5rvet9n+f31LQjzoHxdk9Z4iECoKREjhPTsjDFQG6n/t04ibYgCdtk2Y/UZSaGmSVGYqmMy0JBCSvKSPjcEsNBgB5Ty4JCQ6lYrbFaUWIiLrP8m7HULCOs3jrCEqQjl2QsrDsL7bCTWnyGFHUZXSvoRNFKNClBGEkKeQ9rTTinW9cx4ShYMpiKJqJKAlMw1rDEjPGVN998hZ/7uZ9h6Ae+9vRtXnv0gP2Tb2Osb4ntUtjHlCTUsuq2Bth2eGgHniY4X9dtEfZXliWQQsIaRwqBEqJ09JeALorNMND7nrQEUlzIYaGUgNaF977+Fn0/cO/NV1FUYk2oIpiLPE04bzk9O+HdFKlLxlsjOIoqhybjPRSFOxx+Cqen55Rm9b937x7GGPq+I4aFWCK+kyImhMjtfuTho0dUYA5yQHHeszWbj73H/0AXKM5YBKwu7XvdZqMrKbHWKpHrCRRa9I7G4PzAHJaW7CgK5XEaKVnGHv1mIKbMOE2yyBlJIEYp5nkWAqzSbDdbQli4uryCUhmnCd0EnIrVeFIJyyzck1KIKSJnxtYGR+F9dzixKiNOC7XSQGMhtUTbVawmj9q0GetGdTAyNFEWUCVbSNrMco6Ky4KzlqEXke80J9mIaBk7tVCbjqTrB3JK3L9/n77roJ2gVBtLlSBQn6AS3/3GtxlcR+88r33ytYPeRrWF6OLiku9+9/v87//uP/Ctt75DmgKDNpRFaIlW2xYgptlsNrz55ptoq0lKije0iC4//ZlP82PXN0xLoHMW5zVGi/hy0w1srFjalLeowYGVTcNbS28M5/0WlQoqFHbXI1dX17KYt/c+xkjIE33fCbL6aEPMDqiUmjHGHpwqta5OhtZiL/W/KCaAjxQhQkUVyx7wX2RX/H9zs7wc/Lc+1yoYXX+OdZLw+vLzCKdn3dy5G0O8pJF5mfnwUUGsjIBov99aEKUkrWrVbDyFysnpKa7rGDYbMoZ+2DSAW8Y7zaPHj3jw8CHWOXFzrW4h+UVfmk/eFW4fGfUoDvqDlzso6++wdoSstRDjIcl5LSwAGUcYDr+rcdLxDHFpmiux/ZZVuIx83ZoQDTBsNixhBgX90LDrTSib2rivKU/kHs6CBdCtPS8i1uZCa/cGpR4oyLXSOo+rxke4MiWJYFW1TirKYJ0WjUDIKCWJxjnHwxiyFLHLGmsoORKWpQHAEvMiToslROZlYUmRcQnkmAlzpGYoITHe7Fn2E2UJ5BAJ00gJC9WoloKeBSrZ3CxxieRF7PFegTW6jTPlwCZ6rrvoDuc8KYcD6NEYe+isRaBq0+5vGZOrXFoatYhwrbIyAmmdudCK9wN3qMpITrdLLM4T2ZimyZKRudEZ53RjpyhUTXhnOT87Yhg6hr5jXmb2+xHXWZRVLLFw9uAxP/6TX+Yzn3zMv/qX/4ovff7THHvDxX7PydExX/vOd/n+u+8eAmNXCi/I9SBE4fzS/biO9TxGa1IJkpGEiN7n/UjZHiNaBkmDr3GPMbDtByiZq4sXHJ+dMl9FdtOe9062bO+f0N07ISoR1scYBMNhtJhEnKXGgmqFc9cPUMFri62Cj9hsNgfto+t72X+tI8bIPC+UFrmwxMjtuGO72TLQE1NknGZhzmhNmmSs93EfP9AFCvpOGR9zFqpfKXhjsM7jhg1KVxE4hshys2ezOWJ7pCRYbAnsp5kQI7txR4iziN2cpaAYx6nZZZW8qVWElrlpHlxrxS5LOOT2OCdVfW4VM+0ktwKZYpQ2t7UW5+/a5QeUt1LSpWhCxnlaUIcbVy4uowTfT1WHDc4aafFJy1zOZUZrbm/3KG3p+h5UIeUFaqbkgDEV51pYV05SoSc5fWknIzAUfPpTn+Jr//lrfHB7wTwHgd4pBUk0Dlpr5t3Et377m+gKn/rw9wjLYbOl7wfmZeFbb32br3/tm7z3zvuoIrbs2xgYrMF1Al5KKWC05fT8iAev3ifEWU6zRQvN1xru3T/jj/6xLzew2wp4qizLgkHRGXFwKaPBKkrTRkAlzQtVwdF2y4P79/FWTr2qto6GshjVCstUKUkgbihHTAmqoZS7jVU3KipKCuSiaTbJ5pyocqK3RoS1pdZGAv4oJfV3jm7WgkUIr80N1Hgj2ti7SIc1iVkBSFdDLN7Sxpdxguj4dJUxqLYOp++KKNFOSAdNcyfAlBe3dhJkjGOsUD4V3HUcjGYBTh8+4PjBOW+0RX8zbBiGjs3Q4Z3h9ddeZbPZSos3NXCW1MGARNkfdCVKybhISRevtEOENrLhNEmH/PvaJm8gqdKcHkabw/tc2/Noo7HOSyGgpQNonMcgn/+KOVemvbNFYiRCTnRW410nBYhqTqKqKEW1zaQVCc4TsxQnVluc9phm1y0lNQ7Gnb28lkznxY0mJFRw2lIQvYd0zCCMoR1QFDEVssr41t2NSYT51EJYFgFMxkhYArtlIaQoWTrzREkJVWEcdxK9ERNLaBqEKvyhaT+JFiYLjt8g/JEcE5SE1Rx0RqlWYimAYOxTA5d56yi1MJW75OwKYATV4IwcLUuKxGVCrdO9tRBOGWolK01ajRC1NsGvXJNTqEBpa3yj+8bSQggrqmZKSaKnM8JCyTliXYf1IrCPJqNVpO8dZ0c9Z0cDnYFH98/5PZ/6JK88fMjpyQlPnz7l7e9/XxwwVZGK4fzhK9wbLB9+9+v0ZccX3nxA2T3ltK/keeHdd99jHBubiYwsF4pYMjYlKeBpmh8tehNhL2W6biPr/xIhN7lBKYSwiFnAeuZxT3ZWdDXOSVr37Z6TYcvt7pr+wSnP332Pe68+4kFnSM6wiJVOBLdzxd87Z/P6I6bnlxLgWTL3Tk7Z3+xIc2DYHB1cmXMrzJWqzONEtP6grRK6sRyCtLKM+0kcj3MgLOEAzXPWYfifhIMSKSjrqLnNGWNAYyjLwrPra8YscbXLNDXwV5TQolyJ7RSyzp5DCuQss0IRw0oLtSAty9hOfaLaF06EMZLHIYK0hhWvzfaGbo4B6aho6wGwzfbqnMNaJ1a/mLFGvnaFvEmbO8ti3lgvqBbS1qx2JUuGjiotowQNa7ZMa41eX9+AMpzdu992lkwtkZwEla6dkY6AgtgKK+2bu0SJW+SNT7zOJz/5KT744ArXd1DEpnnIU0HhtGF3s+Orv/lVvv3d7/Dq66/TbzbEIq3bq4srCUFLYmHuvaEgKZ6lZJy3ZDSbo55Pf/aTnN8/w/o1eTrfZXVoLacdZGNYBcveW3kPtJYxW+sWlCREWdVmqtbbQ6KqqpWh69jtJulqKSRmXBnAEEKiFi2aJeQ9KvUOEqZaWN7alpWT2x351azdkNoC8Yw+YNJN63683AH4ncXKKk6kdQZFUyJ5SLRFQbWvq6WwTBPWy4aY1y5AY0AoMl4p6QApcQjIc7TCaL2p1DoQuqNcrrqQu8JFuie5lubs8QzHR/y+P/j7G9NDRh6dd3RO/tsMA9q1joFa7akyJlsfFYGeFfhIF6BSD4nDucpJTxwPWaiqVGrTEMkEvHVSa7lrHVrRq6WSSaXFDSgpClIS+iy1UhSoNiKpCkzv6JQnxkxYJjkJerl3ad0dbY1wUhC9mjLibMlZ9FfTKHoCpRoELAVKFTheWTOwchHGR4wsyySjzRQJMUHVLDEzT5EQsvA2UmCc9izzhDGKME/c3tyQQmCZA7WdxscYCClKMrnMEITXkxqdNgudNtZCUW3UpASKWEtBwvYsdhXm1kyktI2prUm1dbuCOFxKARYRXK76nNyw/kZJwGEpBd/5djnJWFnQ9pEwt/VXa9GCNLeQdQ5lgJKlWFcyOpMQV4PBoI2jZCTTzGh0FQeL1ZVSIltv2RxZKhIZsuk11mvOTzc8ON5w72jg/smWz336kzx++JBNt4Gq6B+d0utATJWCZQwFdOXF979NjpHXX3+F+5tC3n3I649O+Hf/5ht8+PwZru/wPuBqZbdksfYqLdqWegf9m6cZayUHKefEEiZyktDD1Umas4RYWuT+p5YDyTylxNJQF1N3y+7milAjvSq89R9/E+0t9z/5Om7oyUZT5gTOMTw8xz2+T7KKPhWmFy94fn2B1w479IxpERBby/LKYWYJC6Yo5riIBspZ4cZcXTe9Zcc8TaTUdCvaEMvCfr+XffswBfjvP36gC5SkVJu1ipccpaglM+337N99t01/CznJDG899YSY2zhETmqCQha+Q2lQGk2VWaaqlMZNUapBxDDNGiobn27WOPGJZ4yW02bXC/o3RM3QbySnJt+RPUNYq2u54EqMrTXZIF7KYK1swhXFSjZNTVOi2mZSam5q+9JGPM1erOVEGWMUzLE1lJWFYIVjUsoq8pQuRC6F3prDyEdpy/179/ns5z/H995+wvvvvMfU5s1D17dWOI0JkUkpst/teeubb4FSLCFSUFjjsAhaOsQqnS5nUTUzLTO2SAX++uuv8fkf+hz90B9GGhKwZ3BOhJBLg5JlrT+Su1GqdILKAZbWeBDt9KW1PnSvtJFug+868s2u4fYzIQVcL2j9cRopSHfB2nZsryCwO9ngXx7lSAdjHY/caSZWSJa8VnMgzr7838tgsgOptNbWLVCtOHqpUFMrGXOFg0lXotRCDnMrmhW6GrqmiUgtP2X9Gap1fqS4agBYuEPxryOgFfZGY9VAc6hINEHJCectn/rUmzgvWi2FJMY6Kzk/tbawunYC0wcIoegoqByub1I5jD1WnYvWWrQcyDhvTUOmyqGDCillliwF7+o8Mk1EKsFwtdVaFeetuGYqEBLaupbMLenefe9lrKtF96WU5LasjipiaJ0Z6UAIRXqFxwk1M4VMKbC7XYRpIcOLlpQeJdeqVHY3e8bdjuX2FpsitUoe1xIW6aIoyReaJ+GghJhYkgg1UxKKcy2yQZUso8Z1Y8hUQd2vGrbVKpwzeYkYrSXnKIlOZM1SMUqTmihft/+Tw0KhNDp3rTIWRTX6MeL+002ELB1YyUdyzpFKotTYPtcCSpxeBtBFkuBFp0QDwkGumX7YtKK4XedY6cI4R0kGqoip45LQ2lKUoTrJ6UlhwpBwuuCM4+ioo+9l01/iTNc7zs+P6a3i/smWB2fHbKzm3sbja2R/+Yx5kmT7Xle6zrKfF2qY0c5x3FuKU7z64BhTF+7dO+M73/oO33jrWxydnOB2IvJ33rFBMc4SvNf7vt0Xd/+JBnBNgi+CA2jrfIx3PKOXR72bzYaVtt33Hb2SgD5vHXlayLuJ6/ef8M5Xv47VlpPHD3GbDUUp5hrJuvL4029g3nyDF+++x/WyZxn3lDASQ0IXhSmajfLSUQsLKmS8MoeiVVsBnqawUJt+TMZBjnleSFm63TFGGSsu/5OEBS4EQXArhbJtvBJmqoaaRSAlgrgOquLm+hbnHUcnR6RcWJaA8UIqrSix2GmD7yzqsNHQNBBSrWulsNy5XEBOcjXXhl03Bw2MaYFk3vetSKoHj7go/jksHrVwEDoaY6FIEaV1FehQkgs2ldLCoYQ8WasUVVJQ1wPRUtD4qombqoj5rDkwK2JIjPsZqjgMSq1My9K6R6KDiSmivYg0P/O5z/D+B8959uxDYgpo1cvFmLP03FsLW1uDrmLbLUjWSVgCoSx01mOVxiNY5JQCWmU2Rz25FLqh4/Nf+Dyf/sxnyDXTcsWkiCoRhcI6d0iRTimRW7fh5aykdTEGDrOAmCJOG2KIhLYIaKPkpWtQun1mViLfp2VmDDPKyCxYJjkrcVU6R8LBaF017jZYmSkj45nVgqqyAL+g0Xh56WtXl9ZHC4IYo3hoWrGAUgfxpWqn3YN1GXECxSaqXnUTyxzAWNGZGBFi17WN3r4PJRoCrQylnYxVO0m/jHYXAWPBqLZR1CLaGyT3quucwPLa61NWgZXihwIY+T0EHV7FCdMcJ6tY1xhzuJfETSFjHPExQFENRqdF36SRArRUyFaTdEEhQD1dZZxgWudKmTtxblWVpZEuRUwtzreiNEtKjPsWqpiKCCnbdbzb7Q9aNcnhSVxdXVFrZZln9ru9nHRTYlkCyxSJs4xpKi+JoVNmniZqC/qMMaHigmfllzS0f7nDCRy6aUqTy8qxCcwxAPK72lY4lDlSakBZg5eEOhmjkclVbM26amoWbRXNGqyAmopg5tuYRSMHvxST6LBe6mhRVgQ0DaTWLO+qYg0475q1FXS1WG9RTdxrvQhF05LwpkdGoy3mw0n0CIAfesngMYreWbztmKcFp9q4NYsDZ54lX6kqRzKKbtNjjxy6Lmxc5ey44+H5EUolzs62OG/YbHreeONV7p0eYynUsPDKvXv0zuO1Yei3vHh+wdXNLd12w/b4hDlEnl5cMIXI9c0tT5885d5pz7Z3TOOOf/Grv8rl1Ui3OW0ho5aLm52kYbcun9YQFoFbrvdqrQXn5VCqtUGrQk6QYqXvO7RW3N7eiLV3u6EUzTRNDEMvbpucWHJEA/3QMy4T5WZEp8zTb3yHGgqf+KHPcv+1x2wfnJM3PfcePWBzesa8BJ7eXDBuLdpviNPIPCYImTouXN7MDNphYyHdjmyN53jYyASgCtfFNj3WMge0aTDOJAaTru+x6k6T+HEfP9AFiu3swUPeewkD9MVRlVjnnBO/9jiOxBA4PT9hGAa6zrPfj3Ka9g5U1/gDLdDLaFCFrvMy30QU4ssibStvHN51BypmCqkhiwveeTS6xbhnSRh1jtubW2iZD/klYRwxCiTsJTeDWEYzITab5boxKdWqaGkX51wOCG7FnbhR2igQU2ae5bR2dLxFa8lHODo+awGJ4iAqpaK0IcSVI6GaaFDEfqlk7j+8z4/9+B/k/ffe47d/67eZ0yinHyspyTVLgB4lY428tphSawGDa8VJjRnlreT9qEyMgTgltsdbvvClL/Kjv//3MRxtmIKg/Y21OIAinY/SFn9oIlLuSJiiHxBewSpcbLs5qtFCV4CYcdJFSSXJxqXXAsQQsrTFU87t1F8OiaxWWxQrNE9OpLSxT1WNQ1LqYXChkM5MrXcum5dHO7+TlfKytfhll85qbX7ZVrx+1oL7bz9P3RVrSil855omJa9ymRYFANb6l2Y7dxTcUot0QdbX85I2RGiv7Ue337AiAlFtxMVjlG3iVNgvI8ZofOdamrPQPetLSHytVDtVN0GqtTISOYwVZBQkBFHpluhVR5PrwYVSMYeMk5wraZklJfal9nipMjIKQcBdtNNoLtJpzLUyhUCYZ2KUbuA8ThilKTGxvx2Zx1Fa2O0kGBYRCdacDydIqthFl3nBWyGp5pyp5U67FKMAs6zS4hTUiqXByJyTzBpd5dCRYsY4i3O+HSAQ51JcULWK9bO9l5U7Rk6eo2QUrV2yVJoex4i9P5eWXaNE+AwSLaE4hGnWEikKtFU47XBakUr6iGOpNsCjt5Ju7YxGW8XRyTFhiSwxYIzm+OSImEV/UZquKi6JvtsQUyCnIF03DakIULPUTNWlaUNlDIcK5AKdc7jeo9Bsek9OMIdELJFORx6cHeN0x/FgeHC24ZUHJ2iVefjojKOjDef3zvjMZz4tduOcUDnTW0fvOpZxYdzP1Jg5HrYcnz8Q3dLG86njI2IRvMSrjx9xcnJCSpl/86//Le++/4TPfu6LhCRavm7wdItnt0TRYDTbvdxHbVSapQtSlaUqIaCnIvk7IaYGzXSH+zqlLOnaJXNzc90E1mKndsZQJtkblpsdfZXO2Ptfe4vx6obHn/oEb37ph+gf3uPB2Tn7mAi58uN/9I/ww1/6InF/y/MnH3B9ecl8s+fi/Q+5fX6Nsx3Huqc4j5riQYsZc5CC03SUUnnw4IEIxpsuSGnVNJTh0B372Hv8x/7K/z98DCc9Qz+w6QdOjk5a50LyMnIVQVFKmXvnZygU0zwTWgDd0Hs6RHykjEZXseCKkBEqGe9aciuVzhuc9uRssLaTCypLNkGtlaH3LHMgRpnBlZKxXoPKjOMs5FNjmJdZXBxFChWtNbb3Ahhr2SnicJBFv7Juai3Yr0ghsMTQsk3AurZpIl2U2ubAq5rg9vYGbZDI+wK+eyg2ZWswhRbiZKTTEYIsok5TrSShUhSd87z+xmv8oR/7A8zjyDvf+z77m1s635GnTCrCkMmtWAJwxh1O9UpLoZJbez+XJB0Xo+mHns/90Of4yZ/+SV79xGtUJRqB0lghCn3HgWgdBtO6PCVLO3/FY2OkYNBVOhWSIVJR+u5S19agrCVRCDmQayJXKcSwQtPEgDIyNnKdP1iu159pWmdBsRJk797vtbsh4lzdxKcyclrhaHCHuV+7E2u3Ajj8nqVVFUoL+Eu//PwvFxD1jp9Syl3OjnWuFTateELsmyVLuFqK6aBXkW6KpMKadeORVyOvocHjSsPOG2OwisOmjzJS+FlxLEBFe0ehspRC1W3E46wU661QN1bYKXIUgKykOMkVlgaRyxkUSU5lSxRN2TxDkbHKnJIE+5VCiFGKi+trlnEizTNhCSzz1GBxhXEcud3dUlsXSLQhiXmRbmqtVVwvOYumRmnIFavETZKi6LisbqOGkjFKnA0y5tXoAnqO2F7e7zgvMs7VoiEbtJaEZxQ1Bqx3d26pFBrlV0IBcxL3jSRUC1tDa8XRRuzvoosTzEFtwuP1/9ccKa3ArzUfgvNSLmKZr7KZrWnlSsl12nVdI1anw5jNGCWbuXH4rmO73dIP/kDgXuaZznt671jiwrDdtANXaoejIyoCTry+uhRitDV0vsIcMGrGKBHvK8UduNBLGGGuiporqutQqbLpOnrvscayzJGUYL+fSFHRO8PDE8/J9pjXXrnPo/snnJ70lBJIeSHsdizekqZFRPrzgimVaCw3eceHT59zeXHN5eUNR6fnBLVlONnSbwUiqVMAM+C6U15c3vDNt97j1//df6Kqjv7oCBUSw6ZH7UVfYpIQrNcFWuIG7g4d0OjEGVlXm51X9Gpihc5Zxjy73a51TjRd37Efd0Dl9PSUkgRU2TlPCgGTCi5JR+z7v/UNPnz3A26ub/iRP/yTPHjjhNN75wI61VBjIM570jSyTDNhmri9uOR73/w2z9/5gHIz0x0dsamGZTcxT3uKhm7Y4K0ksMeUmZdZRqg0iGLOzJeBeV7u3Hsf4/EDXaCcnm3xzjP4XvDmuTJNCw8f3ifnzDjCfj8LLCfKvLVzd3huVSvUTFoCqkJne4ySJE5IzOOCdQYoTDGIe0IpqIYYZJGIMeGMkxGKs8Qgi0pqYyPnxV6I1jKnToJOXwVyMhpIot53rs0XpeW+8iDWokU14V5tp1ARsq7EVtBWOi+yYehma04sYcZ7gzEyMtJGfqZBdBPeOiKwLDP7cZKNmYa0R0S3uSas83zhiz/cki43fOO3vyE5D9bIwqugxNjw+V5GVu3kX3KitiIrlUhIC1rD0fGWz3zu9/BH/uhP84Xf+8PYzsrJtgmSpau98iLuxiJA62rcAc3u8HHtodqoQjeRKUKlXuLC5njDcLwhPwU7eLS2bLzDeUvR8PCVh5yenVGbAI2CdFOq6BhSSmhlm86JA0lWWuYttBF9KCBorfcKh/fl0DVp7I6XuyVKCaW0FsFt11zY9IOMCfIdJ2T9PdcxXW2FmW3dPRDnTlgCxiqWZmNUpaHbc8W7/hAuKIJajVLC21Ht/a8Nv1+LzPmNal2iiozFRPFCUWJDLmu3phah+dZMpn1eQN0vlChCTXEnBOZ5bq8hUbTormKUtOxlmqkZyJU8BXa3O/Y3t5AzMSd28ywwsJKbjguWcSQti4RCpix5Ue39z7llgjQtz3rVrK/9cF2lRCwLaINB0Sgd2FLa+2Agidsl14JKciXm9hkaJXlSpRZc22jCkilrllbDz+cUUDpRaSNfLfeq6GyUFA3aMc17tDaYTj6TWGZhczQrfc6KEGILs0x3YYrt/nDWAvqgczNWaK8S6iiArvUGso1qbcxwuNSs1eLO2gxtzBq4f34s+q1lgk7hXKXWyLDpCMtE13UCSjQK+RALGs1mkATsFGaMXtA2oXXleNPRe8f9+/f4xOtvME4zMWW2J0do7+TAZDqckpHW0XaD0Qaq5mY3sdtNqFKJy8zQWT7x+mM++ebrGF1RqvDi4kPefe9dxilTL0c+eHopAYIpoyv01kPVXO8rWW85vndMqJr3X0zUqxllLphjYD+NXF3f8Pz5C54/v+Dy4pppHHnl8QP6YUPINxinsE7hvcGlSlVGmDjcdcTXDqrY5KV7H4Kk2HP4N7l3YpT7REY6Ig7OOeGcYXO0BQNGWZZpRgNd56BUpt0ev9mgQqLsJt76jf/MvJ/53I/+KF/6iR/HbWWP6fqebjNgqqwzlUKIE5957TX+47/9P/jgm28zZE2XNZsHD7i5vebi+pLh6AitLM+fXzBN8vpWftDtbsc4TYeD8263+9h7/A90gXK0HTDaYLViv7/BGss8jzx9+gGwhrXVlkArJ8dUNGipWOXkpFqLXItCPTa7rxELq2oJmDFHVG0R3gqWJTb4EtSacVEq4VgKaY6gpfuQQ0Q3kZ02CLxKG0qRDJhUVgqgZBgoY5nbDK9vs/91pluVbJKm5ZKoKvbK2giaahXqtnY47RQ4jnvOjrZsj3qmqcGIjGonMmnLzUGgcvO8yImtRaprpSXtsxSKgtPzU37kR79E5zuMMXzrm9/i+vpaSLSNPZHbDVVqE+fpKlZbJRqAEBcqcP/snC984Yf4sR//MT7/xR/GdiKky0382eou2XRfFqQqDgXB2nHIzY1QDwXNOuKRmX1dJSnaEGPi9P45X/jRL+E2g8S3K31IVz46OeYTb77BZz73WYa+J4YZbe8WdaCxTFpB1MY2tLFSbZ2Hg9unvQa9ckNap2/VkxhoBUw9aA7kvRIrrFWWogsxZXQbK71sS66lkhvXYT09S/do/SxEW2KcF5FyKlhlxfJeFVMIjZUim2FRkJe7bpJScuhbx6Cqig13pS/HstJzFSvjQoLBEnNYmMPCOI3MKTGFwP7mlv3Nrdi+YyKHxG634/b2lrAszCkxp4BYm+UEXWKBXMhLRueCLmKnNs29g9EUpVhCaN1KTS0ZahGRJkJKdtZTahEkQV4/T31gqBRbWUKkxqYNSqC1RZcq4XIt9dg5Q1YA0k0qK58mC5AxNyBcrQLcqlWeZy04N5styzLLwUrLgcH3FWszjx6cYo1QnI0zoAzLUknFovSGUhXaK/qWgr5qkqwRQOL19S3WuCai3JJiYppmdrs9vu9xLWSzlCq5XErhjMaofIBCai3jNmvNS6GprbPROiDr/QwRRebkZCtiTm2Ypplh6Oh7SZ6uJbEZepZFcPQi5pUU5MEqjoeOx2++xuMH57z26AEP7p3yidff4OT4jN1+4vLyhiUHlFOcnZ7R2w5dIU5Lc0UVjPHMsXB5tWMaAzll+s7z8P49+n5gt7vh+vqat999whQSpQ48eT5zsXtbTBFJqKzeekquXF/tSG2dvtxNXE0LcwhkKvtpL5j+xpGpBZYlcHZ8xFkuGG/AVLrBUFSiNieT0Krr4eC2sqzaEkCtqx5NDtG+jUpLySxLxjlJ07bWMs8ztWa22wHrROw8LSJn0KWiOjkcx2WSMWgpmAodmmWKfPc/fZUX7z9hurni9U++yfm9Yx7eO+Pew4cMxh20YqPODK885PaN1zG3M2UXGLDcPz3nu9+LpMsLduOey8sd+/3Ifr/HO8d+FKFtTpk1NLXWyjRNH3uP/4EuUHb7sc38RZCYC1jfcX2zo+8HnDWHboSghqN8eErhO0Op0p4vVYHWeC8naXGvyKI7Lw2UYxQxNJeNSc1eLNCknDL7Or/UrjOCvc9ycus6K04SZZo1TtrJJZcGLOIwSjJKFuVe+eawkYVfUnYzVWsJLayyuagqzqIQJYCu0tw7RTbJECPLMrN95QHD0DEvgX6w9INnSTKCEAKucBfmMItyXDS2cmHnglFWRHPA0cmWL3zxhznabDnaHPHtb3+H5y+eU8YRZQ2xJJYYyFk2Ct00EqlFyx+dnfDKK4/43Oc+y0/95E/w8NF90BVlNSkspCLIdlV0Q7CvMxsaeRQR7zXhhapi30a3XJSmPVkBbJkmOFbCRcmq0B1t+IM/8WN89od/SF6fkha4acjmfuiEkxATqsrYRKJT1KFTsxZDrAsMTUtRpduzwvdoXa/aBMyH8U+LaViDyWpzP8h5XlwfWhu882IjnkXz4Lv+kItT2wgL5Q/fJdJXJUyXKoWt7T1Yi/W9WNeVYZknyBLkR5XRk7FGBOQxiEixuV5qKY2IvLBMs/SzqkRLjMtEyq3TMQemSSBgKcsoclpmpiAdjikElv1ImmZMAacNJSbCJKPXVU+bqIfFvDRnm6qKEiKmKKySQm1Ny36Z0mprIi/iLCo1UTJUo6g5tMwaKDU1Po043WoOoiWJd/lGWaoyMHfMFqNE/1WzuG2E6isOlAPkTle8Mzgr64sfOtCKZQ4NG1BRauH+gw1GFbYbT9+d88ZrpxwdFT776Te5d++YlAXUtd9Hrm8yF1cL1p0Si+FqfyOhe6XgbEMPKE3NhbOzI+Y5sCzyO/VDj7GafvCYVriEEKlF7PmS+1IZtscsy8Q0TTjv6fsercU9qJSi8x6tFTEuhLDgvWe7PUIpxTTu2Q4bSmPnKKVZpolK5ez0jN1uYnd9g/NiDxaRs2M7DNw/uc8f/MLn+cynP8mj+2dsO4f3jpPzcyhg/IabfaSMBZ0hzpWY5Pn2tzdcXV+Rcubo7IyqHd/73nt88PSCod+gFMSwAJV5Hrm+vWGaJ5ac2Y+jaKIASiGHRAzhkOlVqkbSsSP7OTDn1r2uAjxbU3lX3ZmzltslY7xHe8O07Lkdb4hxRrLRxOIuALk1pVtEsuuYsJTS8n8kQFHcd0mMEOhDx0U2e0Pf9yitGMdRRmJaoZ0nLjPjNHN2ckLfd+RUWGLiZNiSUua47+hq4eqD9/nX/+v/g5N7R3RO8ce+/JM8/uk/wnB+nxoga03XGY78hscnpyz3H/J0fELJ8PziiidPn/P9d99nCoEnHz4XwF6IGOPYbjZM+5GUkphDWoikdf5j7/E/0AXKKh6apwVnO2oJkrZYlaRkRrGBxJAYxxHfZv/UKpHfuciJKyc0kPqBUkT70XUdKTenTRLQTMzNsmxXoaIorwXUtrIUAJUEyFWbdM/JbJFaSbk0O/I6HJA2bkXm4FbRFg0lugdEuGurJqsKjTJIyThjhGvfihHJiYlyos6yCeXmNOiHHt/JuMp7Q9c74iSFTD/02Fn87tM4HaBgVpUWA6BboCCgKksIOG/57Gc/w6bf8slPfpJvvvUWLy4ueHF1yTTNTNPUGAuy6XZdR9d1HJ+e8IlPfoLPff5zfP5zn+Pk6Eg6WlYRcwurWvNFVkCLUgfXgGgyGpRs3exbB0xrTVbIFl1aZHvb9CVfRU4mmUwIGdd3vHbympxuQUYfSrMEKTZTlMC5mlbxaG2uldalMqYJieWxshxUXcW7UlzVVcPRnqO2QlQ1J00uK55cNwS5hJTVLB2L3CBZRsnXz+N0sDE7J0VVVaoJChuYrJRD8OQ4TeSSGadAKYqSKnFauL64RDe0+TzOzPPcRoJRSKM5SPZHCMRlJoRATpF5GoWXo2CeF27GXbNGynWXU5brvHW7JG26EHWltGvZ5IpHk5SGJCMszRpyVzC0wL6aD2GWWqs2OEMAYqaNW1qRqABVitwTFMgRSKIvAJzXDWkujh0lH+qdHZk2jWtZJH3fifW4FlKOoveyDm9FwFqqpmixn3feizW2FqzVWG/oew8UhpOOQibGjNEOWMX4cHIycO/8iNdfe8SXvvgmx0eZk5OOGEdEQ1+4vBy52cOHzxZubitzUtgdXN/e0upfYgiM48LQ9xgLRhfOTrfMc2AYtoz7kRAEPgliM9aN0hqy8FUqiG4vxuZQkrFUilEORKfHrPEHq0jZGMns8W5gWYLwTVzP6UnPbneNd46lZXwNfY91hpxljBHjwjztUccbhu0xIReePn+B0ZX97hbf9WQ033n7fX77G99mXjIbN1BTJczSiQvzTMyB3bhnOD4mlMrzy1tCELu31qrZXyV0ICaxOS8psR8nrHeELPeWOrgvzYGlUgDnO0LKzCGilCalAsqilLCXYpB1yHauIfAtS5gwTrPZdqAkFiFlhdKd3PvNJh1iein0U+GcsFBqCYLOqHcaFaVkDDtNk6RbgwhkLcJPSRHdAl47bUhRuuJrvtPGWIZhYBxHwjSTVOLx/VNsrwlhx+7FBV/795Hf++p9Hn729xKmTLc9RqseVw1v3HvEdDbyzje+x8WzK/a3e77/7nt8/RvfwnYdSUkxNQxbNIp5WQitsx9CJKpM1/J8Pu7jB7pAqVWz380yAqii+9jvBFaj1xyEXLFW4FWSHJxlwZ9EDxKCnEqdNdzu9nIaspaLqxuxehlLiEDMOOvQxhByxClFCNIFsX4QXgFGipIqfAdtO7TRFOsoJCkYakRbjTUOV4BacUbYBK6THBlaRySmKDkVpYiotFZcPzSbYsJrS25V/KZZnm9vbyVfKCZCMUxTYNzLybDrOiqVzfaIk9MT9vMtfe+lYm+MDd2EmXpd9FfWSEEi6JW0pHNL/X31jcc8evyQNz71BpeXV3zw9AnXN9dc31xDkYVTacXp6Smvvvoq9+6fc+/+A87vnXO03RKXhapEmX/IYGnCy9XKWxX4vkOJUlIi3FsGC4BR0rGSw35BKUtVDQ6lxdK4chtiTA0zLhCkVDMxiG5mHgPWOpYWB6CU8Gmcd5ScWnBbbWMHDpAzCeuSjB5V5O80bSSCVD9ay6IENLePnLhjXNOYRbQsSDWFLm1cEiIpxMMoT5V6wKqvCdCVinKamFp8fExyOswCatvt9qIBkVYC0+3M9YUo9HNIbf5e2O12UpjEyLTMTeiKLO5ZHFq1iOU2JXGeyXUvp77Cym6RazGXLBRVBTRtUhHxlTidrBcXWkx0VhJXY3PWCMSwonORADJVSa37qZSEw5VVolFWsm4VC60GrQolRKyrDBtP53VzSiiolmUpdNag0Ril8c6Kfb9W4hKpWiztc1hwXuB2R5sNtRR67zjaDELnbbN66yxHR1vOz09RupJLZHskzhS/McxxIqWK7zeotlEoEjlNdK7y2U+9ylGvGbwQUL3VzGHiu997m2cXe15cBG53hlI2LNmgvHRFqPVwiHHeEMLC3FgbpQSUqizzxLjfsR9HliUw9BtJ2K0crmuUYZrGQ0BcalqH6j0phgbdcvjecbTdkHNisxnYbAZub24kgDRJ4T7HRAqRYbPBWcs4SkcmJ+lmdb5vVFJDQfHB82v+0f/6v2GNYpn3KFWZpj3jvBBSZYmFlBVhKejsqQXSIt29FCO5RnItZJ61TrVtnbVb6VQ06J9o0RSlLHdBjRRiKnin8dZLfIoWwrRpxorqHOO0CFhOaYyX2BGQwwNVxK+5ZE5Ojri8vOTq6qpptirO9mwGxxIDMWVBI5RKStL5G4ZBmDXlDhAqNx6HbhRILICMeOD25hbrrJCIe0PX+cN+tHJspBUpI5XjY3EtzuOOTd/jqmIfAh2J+8cnnB6fU+I9VAp8+L3vcoLjlYevUYymUui7Y+71x5QpMd0uPPvwkm996zvsxhHjPL7vSVGwHeM8C2W9lKZPFJZO13eUUmRv+JiPH+gCZZlk0y8pUwjtbwWmhJbTtm5tpZQSoWqxWGoNsTTxppyutTIyy8wScKeUpWhN0YbqWuJuyljvsdajtMKjUFUKmhACRWl639FtNvihx1qF9+JkySmxzIFxnNDKHCr1zveYUnEonLdUU5nTTHGFmirFQ98ARjEmrO/ovCctkTwH8GI77PuO8/NzLq4uefbsQ26eXxIRKNq8T3jbicMAwFi2x8fk9y/QTngltWG6rJPREq2VeRCoKkUohZqztNaNjKVsG6U8evUB9x+e88YnX2VaRm5urrFO1P3GOjabDWdn55Lp0zawmBNZN3trps1jxTmTa5ZWa7Pnrje7bh2ZUhIFCbLLChF05SJR7ko1YFMVsS3C5lYorJVCxas7JoexRnQAKJKSHKTCGnMv+O4qASpSHGm5FmpaQ79ah6QAVbXiREZ3yjSibW08F5CxU5ROWmxRCjEXxmWRXJQo4us4S/5Jjol5tyeME7o9T4pSuM7Lwm6/Z44z0zJLMZsK0zhLiN48C29j7fsUDVUTpoVeO/ISIRd66wBxwEAl1kJsox1NE0xK80oKhyrFq9dWNvXG4shktBFbdk5JMj9Q2FKwhgMVNDetQwiBFCKl7/EHgJcmk/HOio14njBWyymxiYSNE1dTXOaG0c5oDc4rvFdshg5rO+7f3/KZT7/B0FuePHmCMh03txGFx9mBEjNWaTqj6DrXxj7mIDYOKdD3PX1z5mkFzooteNhspc3foI3OaQkoJdNvjgUy1h1RySyp48OLK1Io7JYdIUHOMzmMbHrNB+895XTzCe4/fhXrNf1RxwdPnzAtT3n64Qum2XBzm0EVtsenzGlhd7tDa8kEm6aZGKR72m8GwrwIddR37HcTRRX20w7ve2xnDwnuIS+knHC2o6TC0Pdice7cwV1WaqUfBkJKHPmjg7Zls9mwLAvTHNlut+zHvdiG08LN7Q3qRtN1nnmaMUqJcFNruqFnnEZCke5ByZW0LCgleWYSp5QaTqGFNmagWlQJhCDCYums6dUtIDZd8YzhlYbmHmLlUylNrWKRzm00njNyEKnSoahKC3UaAEEM+N7RR482EuSYUkVTKakcojaUquQUCMvEPGmWOdAPjqE7QtcdOczimCpRhOq2x3vXND93iAildCMQS/Er/04LkTRQFb7BRXNMjaBtyDHTbztOTo9lxIJm0x+hcmW73dB3HVMQTVMsC5jK40fnbDvH/X7g9zx+HVUCZ6cnxBB4+t73McCDx69yfDRQw0zeT7z7ze/y4fef8J233uH55Q2xZgqaOYjA3jpP1w0tNiWy3WwOOspcMzFFttsNF88vPtYe/wNdoIz7hd73xCAsD+esIHlVaeOI0oBfWeZfAMaitJArlYXOSFR71+iiqrke/DCA91QrUDHvHZRCWCamcS8nqa5j6PtW3CTQopkQs0GlkNGdBJCZzuFq5choDOKyoAkPlao4JRyCTBP1+R7jj7DONm2MYQnCK9gMW3LMvHjyjBQiIUROTk7oh57PPvgsj155yFtf+zrz1Yu2QS3S4hs2LEHIhtvtEblULBqt5OIXAqhBK9scTmsrrp1aq4CamuOVnCqhlDaXV7jB0W07jsqGB688EEtkStSyElP1IRcltNdhnZxOBRHfyIlGobKIir1xbVGRk4qzVpTt7cZQzeWAEipwLaLlwSj5vZQIhrXWB+2F/J6rK0WYEAoJ7tJVlOzjbiIuC6oqiSKwVlKZlT7Y0GNILGk+aIokL0Ra7qWNGXLJLHER5H+JhDaSS61YnUMQncY8syyBaVlE/xEjYV6Ii2zglCqC0sa1iUvAOHsoUgqiG5GWAsSYG8uEpuFoXJUCporFN6gWjFfEgmidaeOMBKZpLVj5LNLaz6VAS+GuRbgwK02eWgRsCOgqQsqSBLtutIG4iFXaGLSqOKPoBk/pLN5IJokqSqLtnUXXgm3ESrSmaIV2DqU03nZoJQLaZtfCO03nDZvB8viVM155eMqXvvR5ft+PfIFvfuO3+M53vsPN7Yg1G8Kc2d3OeOPlGWqD3VnhFtGiK6ZG3qVWtHICUCyJziritMdq0XawKn9yoFLo7IZ5CYR5ot9suL6+4MkHT7ncTeynRU6ZTkFObAfD6R/9Cc7O73N67wG5RFzXcX3zPb7z3fd48WKHtsfkosklEq+uSFSsEd1RjJnt9oRd3jFsB0rJBDLGKLabY4b+mP1ecshilG7CZtg2G6toh5wVlkjXdYfiUWvNEhYePHhAP/Tsdntubm6FazMF3nv/KV3XsdvteHFxfefCah0XZaRrlUKQ+3ZlPymIORFyFuG3UnhtDlZvrcGIzA7v27glyWi6oEhNRG5W4X3r+JZ2HaSUUSFgrCUX6RxrrQXMabRo3LRo/WKO6OaQWUGZqxZNCg996OyWmjBa9CYpNv5UBecljBGEMYTS7MYR9EBuItvciN5Q6foeUyVoT4p00TNZZ+hoBwCtUU6hQ8tGa52MXBIkgTL2Xd9S7cXWWRpUUGtN5zucNmzb18QYONpuODo9Yp4nCplXzh9wuu057j1dO5B5pFvtvOfi+VO2JxvOH9xjngPf+MZv8X/8xr/ja998m+dXe7II/ei6rXSrc8M+OCEHV62ksG8mDm8sNeUm0v54jx/oAgVlRfxoHFSxfTonJ3TTCJayCUnmjPc91gqK2xjJC/Gdo3Ne4DZtfl61phoDncdtB1LjjvSuozjoWrt5nfWHZhsrUcKzahuNFFOkDVwy1vVsNh297VC5MvgOU8X6eny8pXMObRvd1CpMZ+mHAec9tiVf5lJRznG03fL2d9/m1955l8sXl9RaGcc9m+2Gx6++yunpCW+++QneTwtKLYzzQq2KRw9fwSjhnTjXkVLFFUF5aww50ToN6wZOk8gIOMlaTdGCfs8NSV2VaG+UkrA89J3OYo6LiOH06qhKkNWB8aK0bvZUaMo5VlYIyAIlSPd6eA0oLbRS1VDytJgDpGsiugTRFByAblXhjMfqpj1oIlujK87ISCI3HH1aEnGaCbO0kGNITFMQUuUyEYMA+MIiaPPcWr2SpzGx34kTJadEmGdSjoQUm3BYXAAlCnm45BWtXslFog+WRUaPuS3WOTf2SQWLZB4ZbQjL3LQ5LffHaHwxbdHWJCNgtnmaZfOVqkFGGkbyVdISMUagdSknxmmRz9OubqAKVa6DXIUmKu7zphgtpYl7JVLCaBm1GiXEWmdtSxKH3nlKKdjOt9FWxDuHNorNsGHT93S+azqxivGGebdjGvecnp6QkZb0sD3G+l5yknIVMbzrRHhKofeWYTA8unfMJz/xmE9/4hM8e/KUME188fOfwyjHO2+/y+WLG7rq6WxH46pJV9PoRlOuHJ8ccXw0iP4sBOkEaEXfia5CKU0KEeuMCGZTagUYXF9eUmvh3sOHTCHy/MU1IVYuLq4JKXN5dYNzguPvXzvnw2cv+PZ3vseHz9/j+cVz9uPE7X4kRkulYwmVUgSu57qBJSZ0O01P48g0L3i3oRTFOM6UIqOCdXNclsDZ2T3maWKeZ05Pz8m5sN+P1LojpYJShTxNjOPEssxUFCVnliAMk1ILu9vbA6NjnmfpmITY9EEcdH4hhoNQ3GrDsmRSzhjTXGpGk+sq0jdUNLGdwGuRa1cbDcpJDppxwjJSoJs1uraDjQFZ851pXZDmLWogsZXeW2s+jCbXjd2au/Xp4NDLWezrRT7TaWwjM9agUH2wodcWLZBLy/lC4buBORbSzY7rm518VtaignRPakg4XQ/i+jV3ajVLCDwvobUTs0YqoJMkvhfhFtmmARrHPdZoNudnjQWzYK0Ie3NNnJwctQLQNiu6Znt+htGares42xxzdtRTwoTrLYPzpCr6xlIj+9sbri+e8c1vvM0/+3/+b7z3wfe52V+TlALr23jRycFHJ3KWYN7jYYv2HlVpnfDE0ItjMjS7/8d5/EAXKEdHR4Ql0A8dtrXxrHO46rFOKLOpiRCHzQbv+6ZdaILEplDfz5LeaZAFIKZIKBnHAL3BdE5m5LWwPRq4d3LUOg+KrqmvVztpN/RstlucdygnG583lk03UFNm43u23UBnPbrZNWvJoEsDaUFs5Ea0YPRX5XZWCmUdz18854P33mO/v2WaRsISpCq3hhcvnmOs5tGjhyy3F6hZwgKt9bzyymOctcyjtMVTadwMZVqbk0MFziHIbd2s5PWoKmJEbTTK6sP4jCrx3JLUUQ60xFw1Rjsk0k2esSqNcVpC1lQFSjsNi55COjby3NZacrPkrXRTKMJUsU4+31RJsRLqwsrsEPGejEqE7ConjBhSg79BiFJIiAA6Mc8z425iv9uRU2lwqUgt0iHb7W7Z73cNbibPvcwzKYkeJKZ4wP+nECkpyXiHcijc1rRpjWokYtH+mIYIX+FtSitUzqhGmaTZ3auBqium6mZTrgetjUQ2iIajZHknOyXoelnQRKyWVMK4jpICulqEtpbFsmrAYCgliqUWESQ7bTFWRppr9pRWTUtlaPRPhe2dtJ01khatZBPdbraUnOmHgX7oqYgGyFgZkVKbswNFjDNGV+KyYZlnNtsNynumlCnGg/Y4N0gHL0rKr3Mi+CxxpqbIxbNn7C6f8e3f/iq9N3zyk6/yk//nH+d4s+U/Dv+Bb3ztG0z7mZSlM2L9IJuIVhgnNtkQJddp1WCYBtOiCrNof3vbrq3Gw6kCTYw5Yb1wgG73I0sqnJ0/ZIqKzt9yu7/EGEffe463MpqNCVK1XFwvzMFi/Rn3h0fYbs/2JDLOmd1+YZ4TLy6uiEnGLPubUcTcFfZhltFgiDIGDPFAMS6lcHl5w831jlorXfdM8Akt/yuESIiRnNtotXVXvHfc7HasrA6tNePtTta9Khu0tq69L5WY5Guc74lJIjiUFkCcta612jLGemHAIN01rTWmiquoFBkFWNuhtCHliDe2wSTnl5ABMrYtLe5jZbhIkGAb9cMhu8tay7Isog9sNmlnOhGp5zXFuzRXkzpoQJZlwbkOoyWJWLX1SUCKMpquVYjGIVZcv2FzdAI1SZgtLRy07Tm1VVAry0hrLd2TTpK2c6kydlPSuV9qEgYXWqIqCoduVeddC8AtQhu2RsTKudJ5z7jMbDc93nVYIWxw1Pc4rTgZBgbrKPNM7wwOzTLOArvUmXlOvPfuE7773Xf5f/+nr/HWW9/i4vqSoiu28xRjZX2ktnydSuc6yEIVJhcZCx4dNYmErFPOfvyy4we6QKEqhmHgaLOV/Jcsc0uNxjspUjAa7RwnJyeHU3eMEWsMm80giGgt6b+1SCbF9viIzfERsRa64y1FVfrOsR16AZEpfUj77JzHO9tcDFlGMg3lO02SAqkqbPqB3npKlPh4let6bEMrGfMYY4kxMAYktwTYx8jg7J3Wojl3cgp4J9h7o4WZcKsVXeclvttojk9PmfLMbpyJqXL/3gNOj4+pWazT64a5bujLPHN1dcUKCXs5BFEWGnXoeMhYpG1STWsiyPyWtwAY6zHGEkKULo1zsojXhneXpqVs11patdZaOu+JS5B05Sim3jXYLYUirfOc0M6zGyf2tyNxjpSUGfd7ljDLYlUL035iHieWaZE8o5SJS2SeJ+ZF/Pg5SwCc0Hxzow03W3muzSglqdaqAbEUipQaQKzedXTkPRFB6+oyYvXOFoHeeetIbSOxpomQYyVlSWZVzU5SWrHinWycNWXBga/25TZ6i/N86D5pY1rjQ4pm6ZgoSg7t9Cg5SakmnLFYWwQkliJeQ995vJdRqXRaZGYzdD3eeUpKbLfHDMNGtBldh2vvyTjt6AYPqrDpO+kKNpe41XJPVkULNRSisPeeeZlZ5gXTTpDbkxO2mw5F5eToCD8MRBS/8ZtfZUqR7fEJSjuJgnCraFzosbpRoq9fXLGMtzw4P+b+J97g3ul97p3do/OOL37xC9w8e861uWKcAyHK/ae1IuTEbtwTQkQboSBLUCdYY8gpsZ8WOu/wvQDMnJOTM6wn9z21aK5vdswhkJRmPwWWWLC+b53cjmHj2W57Hj16jc9+7lOk4pmXyO1tZT/eMk2Bm93EB0+f8fTZhYg5/cA4TsRcMNqyLDMxNAZOoW32RoroLOGdkr8kry5G0W+8uLhhu5XXX6v8fcortwdBq/u7a9q0dUe6ddLF6DfDQSchHCkOegNjDMbWRmAWQ8MhnqEdIlJKMpatVTRERjXnl8YY6XSv+pecM+M0NTced5b9JiDVWuP7Tu7llDHK4L1hWaTQ3HqH8441X6EUEZNb4xsaoGnuGsROMqHEgaKq/MCUckNJyP21MpjWxHUZTXWM08I4R5zJbV2wByu8c45UMzlmweYbKVqE81RASaEi62lGkt9qs7HTxkT6AIFUSphapYIywhmxxgoF2FnGWZw8g7O8+spDtn1HSZGiK2mpZCtjNG89KWZCXNCuI84zU8jsponduGccC91wwn5+H2V6UsmERQwhIc4iTK+K3jnJHMoZjVioVyREjBHnHMNwB/777z1+oAuUT775Os5IeFxnxbf/6NEjQlhwncd5xxwDvu85PT0DoBsGKjTUt2zmzlmcVVK9xsgwbOR7g2gHQo4cbQaskvGB9f6woWpECZ+ijJhKyagc2G6POO866prHVhUqRlSp9M4SayQszQamJf78MFNNkRwKBcVxv+He2X1iyfTbDXYYuHd2Tl4S77/zHlcvrghVTknLPHF1ecmjVx7i2+K/aMu8RFIueOc4OT5m2u+xdkPKmXGeiDkQ4kRaKpeXlyzLwuakx+LIJeGcFE5KG7qW7VKrLDLQ0pxrY2zmKiMyRZs3y7itVliW1CydcmKOWVrp07hntd6GeZZFZoncXF8zz4GwBGKtDcNfWOJCSJmiFfMi8fI5ZsbbkXEvyOeU46GLUXOjr+Yi6vuqWIKISJ2z5BRJITVwEq2bI/PnlXtQmm3ZaE1W6hBC53Rp0KlCyTKTleA9Ee7SXC3acOBUpCSCbl0l8Ze1VMuZTGnFhyz0KQRIUsQYpTG6RdbHJAr5Km1b3cIOvZeFq1da0p/biW+zOaYi6dJrVMCm63HWYFEcbQe8dwx9x8nxluPTDZujjr7v2e9HcRBYx+72ViBnwGbY0HeeEgPWalKKbLcD07RrC7gg3r1zWG1kHLEshBhwzuE64a648yMJG+w7VAXvLJ03nJ2ccHJ8jNKGXQi8/f13ePuDZ9QUWFJkmiNn5w+43d9ireFoO1DSwnhzJaO/XFiWzPX1ng+ePONbb32HL3zhC3TdhocPH7Hfj2yMo6+G/RzFpYWiYLCdw3UdGeFJ1KqxtscaCQW8neLh5Bxu9yKWNfK+TM2uPYUZpS1XN7eM00xGEVMiF8kKurkdGfcju/3IW9/6DpXCsszMS2CeE9MiaP9SAG2aa+mKFVYYo7isrBXrsrWWKSxo1TRVTeBaSmxuENFtAAyDw1phyOQs482VZP3y445wag+0YQygCqjawkJFPb12Jtf7BipKt+TtVRsGWC9dbN+7l8SuAiNb7bZKCdl6hcXVmlueiyIEgdPlktFKOuXWC1hs7UAureu13W5wXYfSsBv3B/ecMQ4LeNuEr1VCWJ1zWCssrIKgB3SDAZZyF0shmUp6bQnLRoyAIad5YZ4X7JFoLbx3qGbiWPUltuvlz1UyeFDS6ZEdxWGMpiotWUBVYZUmliiuudoE/Npgcsb3HcZ6Upb085PNllwy026P0wY1dKRlYeg6Tt94rZ2LZ6xXdL0lhoWYWxemSMf76cUNV7uZF9fX7PY7+v4IZSY223OmXEnjeOhepSyhsClmdiHS+66N0EUMH5blcG1N08S433/sPf4HukD52f/r/4Xe99RSGbqeruul2rSt8l+tnVqq4pDSoc2YUmwe/9AARBVUIc6azmpxH2jF6bDBeSt/ziJ6RIv2RGuxlhbV+A4tITenjNNgq8yBD1kUIVBzZmond4ldT01cKOMUrQxG2ya6qq07MjLHiO8cu5vA7c0t027H0He88cbrPH36Ifv9nlwK0zRxdXGJe3DeuhmaaRHlu7OObd/z7GqHORqoqnC9u0GbDuMsS4o8efoBFxcXDEevEpYg815lQNmmz2lzYyWzY1U1yxgJs8xGqZWlRFIVtsBuN2KMYb8bmcaJZV6EkxEF5hbDwv72toXMaa4uXzBPM8scmKdJxGVBFovamC5VCdwsawlNc84T50BJtUUTyHubY5QRBSJezVHYDkO/FqkSXVBjgrXdrCRfF1b9i8TGa5rwugjjoyoRbZYqrBQpYExbKLKkAqeWR6M1JcvilFsRdMjNWRkbRgpli4wdc5WR33Y4wjuH0YKI11qLHRa59rzzskHogusc2+0WaOmnRrgpw7ARZopdoxTEph4nWbQe3b/Hw/Nzhs7jnWPoHOiCcuJS2u12UnwqxclGEOrLvDB0lr4zmH7D0Hn2447OG4660ybudsQgpyYF1Ko4U8JH0Aas94dN1LQRVcqZaX+Ld5Y4L9xcXXF0csztLK6AFAK7m1vOzh+htXy/nNAMu90tzii0sZyenIt9umYurm6pqnI7RmLRPHtxxdOLGyKW3TSyn0bGJTKHBMYKz0hppqs9+/0k921VKK6Ypol5nlAKprDI4h4ipa5x8hHvOwnyqxVlDDe3N8QsWh7d2tu51HbdZJ49vxGBOAql5XfJuZJSYyspRUncCTmVamRjDl3OnKS0Uko+p4qsfbo58Q6dkZc6PSnnAwb/AJlrj7U7sD5e1miUBpVMWeI+ADS2QShz28TFki45QrH9XW0dPNGg+dYpUFpAc0pLp6JUEYMqTRt5JKRgl+f37boxFXHNGYFqxhaCKfBE6Wyt8ExqS4lvXcdVi2hbLpKhHjohuQXdCeo9Hzrdh65N07ytdFRlWpBpvXOmuWZbTzG2sZOhTEmeSshwBwGuZLAh94SVw5GMcgxKxVakNidMbv6ippvSVrrVN/s9fdfR9UdU5F4vuYm/q2aZFp49u+DxK69ysj1mmRMhR4pRVGOIRREzhAJ5znzznWe89/QFVRucM1Rncf0Jw+aUZbensx1znKHmQ0FprW2mjUVG/3FhzQvznZDHl2UhhsDHffxAFyiPHz7gaLtBY6iNyOqMpRs6YoyHMKbcuBHOaqyXoiGoQuctC4nOqYOLpOsc3oooVdsNxhmWsFBKYTv0MgrQGlwjo9bM0LWFtohDQ9UWqa0UOSYS7eZupMwUA9vjI7RRLJdX5FzofU9picCq2ecE4b/n+YtnpJK5uLxgP0/kAn3v+exnP4u1jrffeZff/M3fZLfbtVnzJUfbDqcq2lpSEYfH0BwH8dmMUYWqBNmsjWCic5j59re/x1e/+tvYoWN7siUWcUst0yLz31opuRBDIIfEMi7cXNwQx5kwC+RpzoFUpcV8e7sjzDPjXmbl8yRAMNXaskvrIklxk8WGjbRwS6ktwVNOh0ZJm1BbRdWKOUWUMyQtmS5WW0imzdwFErdqPFZ9TY2JYi1KgypZCLohHIByFUWuMsOnLdpVte4HQJtVV63BaFTJUDPemuZmSWjVRH5eFt5SVmqkOCtc5+VadW1RVjTGgoy4jDVooxn6TsY7SvROptGOV/eYMRbvnNhxtfBahqFHKdhsJLcnN97DsgS2m43g/I04Y5ZpQtXWRE6Rq6tLNJXN0LPZ9qQaW26GwrqOeZpxXu6P7WZLToIs32wGObkWATV12y1KK/bjwjzNgJKZec6EIM9ZlYwMp3mi73vJC5lGKWQohDBilWI7DHR9x/G9czZbgQI+u9qzpMSwOW5Awpb6jBwE5nnBa4NxvdCjC+zmzLPLHb/6//q3PP/wQ976xje5vrrkdjdycXVDiAVtHLlU5iAJsnMITOMiomwttFi5x2VMsEYylFIP4lDRIu0w1khoYc5NfyRar1rEAVWybHxaGUkGrpIEXBocUkB8pnUNZAxZChjjWjimHJBMG4OsIz/T4jFe1jesxcd6Ha7FxtoVUUqxhKXFUqh2qFKHzkmIgWkaxZnBHSTxkIlVOeQ/KXXHJ0k5tfDK0tg4fKQIok0/a6kUJeu3MeLeyik1W650aY6OjmSUMc6HIuQuvV3W4pKzjLiNbsGx9ZC7JgnO0omUMNbarstFupyNbbRi6K21WGNY5kXuPeeaJnAN1rxLHq/NFLC+7wph5iiCiKfFfUDXdcSSiFnG/OiXE+orSss4TBvdCi/LZrthnq8prfMsbCZxi6ZaSW2vKTVjamEJkRgi987POd6eEOapCf4N85S4vhlxviOhOek33M6RzhgWFEk5diHx9tP3+O7T58xZs9lsqSpzOU4cH5/y6NFjLq+/idOarKUTq9eRnrLMFeISDqTrVVcZluUjZOiP+/iBLlDiMjKTRR2MWNqsNZAjFlkMKdB5j0rN3tjw1Y6CI+M6izOKmATMZLVpgC0lia6q0RJLZgrLIfQuN44ACqZxZKXD1maFVVhyHElR5sArTyS0zJuQFmqpxBQYdxOpywzDgNFWmAYtyTTVIja2KCMhqzVH2y2vPHzE6ekZfb/h1ddex3vPb371q7y4uCCXzH6/56jv8F2PahkdQyfjAd2EqbnIya9mSBW08Vxc3PK//C//lG9+97u88vqrxFIYx1laz9NedBkxkZZIjYU4BcbrHWlJqCTD0GLK4WY22ggaXY7QB7GrRpHyHUV1tela5WTBUFpyhxBaI6GKgj1EqhOBbooBUxylJmGQaOlupBRbREBB08YtpbYRT2KZRYyr26aTY0Ar0RjcAeoEflWVPpw6S9uoXJsHa1VxDf9trZxaJMFTFh7nfUsiFauz4NilyPBOWsLaWpyXItI6y3a7FZJDmHHWivCzyunaaLGBOuekEeycFCy+o9TCsBlE36RES3J7e0NsacUhxHbCFeFn3/XkZi8VxHtkHvfoWtmNjvgkYOy6sWq871FKEVJhV6SI1ErxbB6pqWCNIuV4wHTvdjtCjG38pxmniTXvyKyWfiUsimmZWkfTEUNg2HZsTu+ha+Ho6Iijoy3FaHQ/QJ4JpXD7/AU5vWCeFmIMQkM2mpvrS3Y315Sc8MYIXVOBdZq3vvcOod3D8yhI91IVMWUqIvgNK/xOyd8vIaGNFI0qKVk7nHym8xzb5qIZl9AcaEb0V02bhS1gJJ3cWtFg5ZSx3UAMQUTwqw6jgu8cqkKIM8aI48FawzD0zR4v12ehMi+CD5DE4dyKDVqI35qULWvlupmvBcmqB1l1Ad6L2H/d+Ne0Y7HgSmfYWHGxiK7ESDdISychxULRco+IZsUfNnCt9UeLGdXcPrVK8ntexxwNMdC6yGFJOAtd3xOWgFKiOQytEw00sKTAF10n4x45oNylfa/6h7XbpJQ56O5SbeN56uFelS5HJdXURrnmIGzVSjWR7keLwZQKteaPSAWUSpwcH/HBk+umDxM6dCnNSZgBw6GQoiRyVhgrKAlrOqbxRl5nXJ2TMhlITdM2xwhWy2u3hlwFNb+72VP7CrkSGqdG6SpaplrZDJoHDzeklku1FLi8vuU77z7h7aeXFLfFbk/Yl4TVGV0qPZnTsxPOTk/kupyMiNRLORS16zXmnWNpiILVem6M3Cul/E+SZmzaWMWoSopyWrMajOmwRovVTkNntIwmdBUaJhVTC+RE3/lDe1mqbNWQ8VBiIivJcqlNJOmMxjtNksmMXKQoUgxNJycq7dvbPbvbW/o2TpBEYlngV/GXsw6fK9FJHtCyJLwzhCWRShbIWzvx9oOhG7p2CnAYZ3n44AHedwybDZthw34/ivVPGfa7PWfHx9gcSVFGGarpEkrOOGu5d3bCxfUL5nkiNzGXUooP3n/Ki6tLbOfwfU+IIqTJUToNWknkfEkFXRQeg86gsyy+WWWxTGsNplBmOUFoLbZKIccqUhDeQ0yZGrOAlFohUxpVURlxEZkmPnXayM8oohQvi2gqdFXkuLCkJMWQEoKk1uCcWF6VM6QgxZk1zRoaAs4qrJZwOWsszlpZtLu+tYVFNKfXozCV0+MjcooMfSdE2iQZHv1maPknA9vtVha7Vgwd4Hydl42wCheiKilclBEGyxwW+s6KSy0K3Gqd/2stOpbNdtsCufYSZdANLLMEQ/ZDxzjumZcJZy3ed5RcmcdJxgQxc3F7ARWGYeDy4oK+6yQTRBvpvMTYTvMZa3WzxCv2u4kUI33f0fsObTpySYScSElBrhjrsH5LtxH3llKK/kSC6UqzgDonAEOtFOO0J7STbM2a6zFg4oJVcHm7Zxr3ZAXKez68uOH55Z6YZdQYp8A0jnSdb9ydhXkaZUzXxnpGpFGygGrwvYUqG4xWiopoIpYkp7yqm30Uhd/0MlLR0o4Pi4RZGuHJk4oI6NcgSa0ltXzlb+QYQSlMGzeoKht+yqJ36XqhiAIygmuHmM42OmwRO6/vHEYZ5nESlpMROONanByKDiU6BGNbTtUaF9EeayQESFemUltxcNdROYxyyl1w5TD0HNx1WkYla6zBqm+RMEndxt9Fkp6zdEHXNTCm2P5dHETeCgxPnJAGarpLQ2+jINsOHUrJdZgbRdn7TkafuRBrboJdKdBfdvIcxKlNv9F1d6NO1Q6i6++WD90NEXav3YzSnlsribdYnXtar+Nu6YyBZP8sy8wwWHHZaNEBTWOQA8/6c0rGIt1SbWQspbVqSIlM15kmGRBBdIyCJNBWuvGoDCYSdxE3dPRHA27omVJmP8047dn6jqwbnFQrnl9cE4FHj8/53pPnnGwGnFIsy8wHH3zIi9s9ph+w/ZarcWYpM8NgqCEy7fccuZ7z81OurqTo6lqUgRDPK0fbjejsGvNlmmX90ivFveSXrsb//uMHukDJpaKtE498lsU+hCQzOCetxVQqKcmIRiM3cAgC7ImTzMMUYufNSOKoau38JURyrXjr6IeeFAqhZLSHuERScwM563DVtqyXgqnys3U1LOMiVjNvyCGzZIXXIuAtyPwPy2HundEYP8gHoxXWiXV38EZGA1Yz9Ju7LkOpbL3h9I1T/k9/5I9SU+Wb3/wmdthitIcUCfNEyZWCJSRDjIYHp/f51ONXefL+JSUmdJVCqyTQVVOuZxY1UeyeShYXTjHSYlbS5latnVkV1KLIlUb6rKQU8c6KBTJFoJDVSojUbVFWLJNEbxtVKFVmk0oJt6aUQqpZNse28KEqS1xIJeM6h1IVYsRozeC8OK0qFKTYMxZyjnjvWjErORHOe5QR++3Q92jEieKdw1k5NaGbIbhK5d93PdZYxv1eRosarBYC8DSNWOMO2qfaZv+p2Zi1NTKbtlJcWifZNZLVZNlsj6AqQoycbruWTg3VyMbrnCNbmY1nXZjmwG4/Nnu5l3ZvysQCOlfmWciVzvfsx4kwL/RenqtQOdoe46yh6zpOjo/wTRuR2jjz6ORYWtIxsYZfplw4PWvW8yKL0LIsWJ3b+zKSSmYKiTlo4rggRuhKTIlUC/tpZG7Ogtzge9pIsUqzai5hIua5JQMLHRRk3l6rkQBPpZsQVBa8gmKO4oJy3oqzJheKy+KSUprUDiciMNSs6dGp5fMYK6A/ZRRSSQkdVsaaMjIcOtcOJZVS5TWEKDA33wmt2XbNXVMCVMkfsV4WctGbWUqWMYOIm7N0U6OwgYQt1NYQbaSwy5WYF7RdQWdRLM1JwH1CYE6kJGOOVUdhjIyBVueMsaoVUQuoSt97VvbGKlK11hy+X8Yhd+na1lls645K3IUURErpFgmRhdsBgn/PsqmWUuhsd3BQrrblEAO+XWc5i7CiJOlcKLNmVWV817VxTz3ouSR8dB0ZCUdI3EPmruvZRlpSeEkMZ4zh0LWtVdb8UiQQde2eSvEjWsZpPx7Ezb7rG7tIOvZUMFYd1q0Vc5Cz2KSrqvQbh7odRSyvOpIqaFfxZrVCi5au63uqWp1CmVoi3hV6LxlX1SpylU5qbkyXohLVKJzpmXPhJi2cPjjHFfCuI80ZjGWcI93xFjVYcrfhKlcudnu43WPQ0s1Liqc3MyFNYPagDdpZrlOgUwqdC/N4ic6FzdBxfnLMEgIfPHmCqulwiI9LOLiynJegVWeN7BE5N+fVx3v8QBco1IrVSk4CzTWgVKUWyXyQTRls58RWerOnNlrp6see5kW0DUkWYuctzjcbaItJT1SWMcps2zqSNZQqOOQ5iNgor3HWzqJTkXZc61YorbmdA9O8yOY5LtQqm6PMYAu+aqzR7SRugSJtzRjBgCkGHRMYjZsjYQmEeUZXWJYoc3yl+cSbn2A3Sqx6N2wY5504XUJCHW2IuXL/wQPOjk94/dEDXjk/ZpqeU3MkJYMzEjVeattkS8GoSq0RVCUusoFVZCHXSpGLdJ1Ulfm1COyErZCTBHU5J9HhRac2U1/FYhI1YJ1hzdCRxauCkXZ2TU0QZ0BZixsMxpl2Aq+oWuic5Wh7hOs3gnuvib7vME4RlgnvjLwO4+hbJpFznt638MUsQk1r5ESTS2aaZOPZDL2IrOcF6xR9Z/BWEppXQFfn5TQeUkI3oJP3nqH3kitkoFs3N1VbN8g2jYFcs/tRQgrvnZ/jrbRPlZZTtaqSOaSUYthuRE+DBD3u9yO721tA5tdlFmu09xJehtJoIzyZkBLKSMGzzDO3u10bC9WWlZKbPkbGUzlL5s0yL5Qsp2Jxx0i45DyLULS0SPUpLMxzYF6W5kjS5OauiDmRq1hK4S6PSBwQa7hiizHIoZ0mhdFTakVFeb+pkp1VK+1ekZHW0uBgnetaUVKatb2KvqQKkr+2tUP+p3W3mlCTtqGmJr49WEiVpu/84fQXQkAZ3cYf/iAMzUXRdR2orqUCS/hbbiJsiaxY6HyPc5qlpaU77yRLKUow6VowKCUU0ZWxo5w9iGPX1wYyNpFOQSs0k3Qiuq5rSbcvd1HKoYsi9xqH75F8mDtx6TryCSGIODVnUuOqGCN5L6XFDFgrKIT1R63jL3EKSSdIaYmyWH+oMIAskvYbmj5BNDV34t6VRE0rHnwbfy1EEkPXo1QlxrvO3How8N7Lz1XyuZRShKTaOkPr6HUVq65jsRDC4f0rbfxTM4cuzB2MhVbMSaGttLjZpnnmpGxBcSiyrTGk3IwQFhFGK7F4G6sxqkMp4bmcnhyJPkxXvFPsY5KxWZUuIKkQ4kKN4DY9ORfmsFBU5fzefTauh1AINeF8R9WaJVeU99hhiz7pwSVxSKbKGCK300zZbojTIoVlyXRKU1NmKRVTMjplTBE0gYHDIf3s9ARxoS3kHNn0x4zjdGDPaC0p8asI+eM+flcFyi//8i/zD/7BP+DrX/86wzDwh//wH+Zv/a2/xQ/90A8dvmaeZ/7SX/pL/L2/9/dYloWf/dmf5e/8nb/DK6+8cviad955h5//+Z/nX/yLf8HR0RF/7s/9OX75l39ZgE2/i4cQNkVjoLTBtPYpNFBVhVAK11eX+L5nODtjiUHsXBXGJcrMexjotseUXNhHCeFbYhZugbWEWMjTXoqTVLi6GcU6pjWpKOISGMe9ECiNOrTtc8lyciyVJSVKFYDRmkg5j7OcZErFG7mx5mnC+55aRUGeS2ZJgVQi1rUWeSkSXIg44udJ+CUxRjbDRmLHK1zd7Jh3IyGf8/zymtOjDa88fsxnPvtZKpo3XnvIT/zBL+Hs13ny7AW7MRFKZElglIQr1pTbilMoapbFRXo/6CrMBTQYvRYoq2BPdAlGC2PAGsWmF2JkhTa2cHgnFsCSE85b+qET7UULi6tVycaMEf2K01gnLW7vnGQBKcno0e2qqMgsP9dETAFzcopG8NQ1F5QWmFpdAmFRdM7TeU+NlRLAbzY4raQg0gqrI10nvB2BWDn6fmjCxXxY2EppOO5mzew62ZhCmFFZTmPraSvGRezKDauuciLnhc1mQwhz0xeI9Q8gpZUYa6gpkWJkGAbmcaSkKOyYlMRavsipen193nn2tzfsdjs617Hb7VkR4eN+Jwv9vDS+RCU2ZkNsLqScmrgSsRKWph0qLbG41nIIlVTNZo2SzWcVFVrnsM4LMLiYwxzaWAlJSykeNqOUIpqKUraND+Q+d00wLGA629g4UhiUhtM3jcFQmpukc5Z5XtBGskJK67ytG9m6ea3uGm3k+Z1zch0aI6F5TThZigjEjTEY7w4L7vraQ5BNtmsjs/Xv169bT9irUFCs7u6gaykvabL6vhcxek5sWqbJCh/zTsLnnJOiV7ooEii33+/p+x7XMlvWx1qkrD/z4FZZwYblo9oN6S7oj2hIYAUMcnCzrEVMSrLh6QZQizU21450Klb8vVKqwc/EQhxCODBG1qLk7vXIa8otkLNkKWikoLtzgxizjrrE4ixsl3goUl7mtZiDruTueVe6sYzi9eFztFbYIt570eWku8+wSXyBVeMjLJppXpjGma7rkRDFQtf13O4miedQllwEaxBCFEeRgnma2Gxd08MpdEVIxspRGZlm2UuMVo0wvfJpKtcXl9hxxg89YQq8eu8hNiscitPjUzCGcZ6wWjOGBVU8xjtBEcSELpXBaolEWVK7XouM1mOhLAvj9RWqXR9rR3WcJjbbDZ3vuN1d0w8D1nk2m+0h8NN730bFll511Aoffvj8Y+3xv6uK4Nd+7df4yle+wo//+I+TUuKv/tW/ys/8zM/wta99rdkb4S/+xb/IP/kn/4S///f/Pqenp/zCL/wCf/JP/kn+9b/+14eb4+d+7ud4/Pgx/+bf/Bs++OAD/uyf/bM45/ibf/Nv/m5eDiVXlkXEdUYZUimH1NqCXHjRKHS/IRvN1TxLno1S+M4zjiMZzX4/oucFpYzMzMxICALS8r5DoRrTolBz5XYc6X1H3/mmARCMMkpOaNY78cOHiZQTc0gsKZNahLfCSB5LO1noCinEJtoToe80TaCKCAhzIpUoJ3G7zrIr5CJdmCp+/rDIKVcSbTOqZh6dbphS4T/856+S44Lvex49esg0T7z22gMePLzPvXtnfOOb3+Gt77zLi6sdc4SYRSiX20ldqI1FknibdkAbWaissZiNxjW4UpVxqkC/rMZbTecM20ECskybt8pJUxToqhaUqkIrVdJi19rKaElLps9+HClInH3JiVoXjKpYpXBaS3BXO1V2FkIOqA6GjXQLqpVL3hiDVVXm5FpL94cVylawtaKVwQ8C+Qsl46ycGPvOs99PjPtbfOeljaltO7WVgypf0OBZxKvDQMxJFugm2NUgI43UTtDO4a2BkiVNeNwfOgRaqxYgGD9yKp3n+WBHLlUxtuA8SSVeWiFeGXovTJlpxruOGCKrZXmaRrGPFykoW0tPNiXWhTvT+Q6UJHhrbTHOoU2VfKokHUSrNTnGJgR2OCWZSrWC804W68ZMkROzCE5rlc9UIFyaHAWCeOdGaXqRptVQrUW8bmgyn4+HrsAakaBVs5MqyWWRxa7F2beuwEFI2Vxl4zyBEs7NysTIWbKjpmVm6HqMteIGaf8Wo3Qw141wnufDZxUPWG8pDjabbetU5CYY14fNMzcbLnDYSKNSh2Ji/exjkk7qy12Orlvx89PBfbPGS3jvDu/d+rPWovruta0aNX0oxF5+742xzPOM1vVweJAxs4xIRO+R2winiU1bcU2FoR+k0CtZuhFtQ1+W2GzG5vBerN2g1XlU69ol0pSiKEXyc9YR1FqclYIYI4iH5xDc/Z3leC3y1+KMdo2vf2fa566bRTgEubZTvuuwrN0cY5pGpDThcGkulQohygjm5PgE7zv0WMV+Pktit27FjnO+FTxSXEkYpaF3VkaDCJxys+3JdSHN7V5r1NxcJEerVAhZ8AzjzZ7lZs/G9hz1G6ZZcBGxVnoKtx9MmP1zzl49ZzNsMGjOTk85Oz1r941wYMZxJIwzzInx+oq0HwnLXoTNqnB9fX3Q90jci2rcGrl2+r4XQnEIraCr7UD38VH3qn7E9/W7ezx79oxHjx7xa7/2a/yxP/bHuL6+5uHDh/zKr/wKf/pP/2kAvv71r/OFL3yBX//1X+enfuqn+Kf/9J/yJ/7En+D9998/dFX+7t/9u/zlv/yXefbsWWv3/rcfNzc3nJ6e8n//v/11hqGXkw5GhGe5tWeVCJv2OTLnJPQ6oyVYrVXwcrKTU+oUF0mnLpIGm5oOSSxzSZwrMVBCximLgkPuSq2ZJcxUCnOYJR1XwbjMLCmKV71oxjlK4aBaUGDLWdFVrMnTOMrctQox1Hor9jFz1+bVa3hglU15MwxsfMfRdssyTkzjxM31DU+fX+Cs4Q/83h/i8fkRLLf8/i9+lgenGz7x+iucnRxzfX2JdT1Kd3zw9BnfeOu7vP3eE95/8pzr3USIMh9NbQatuw7nPJuNkAAL0s3RSiih22ErZF4ljpa+8xglk5rBN+1KzeS4EOOC9Zr9dEPKEWukFWraaZMGhKfKBmRaC1wrydyoWTQum67DakUMi3R7ihR4/dBj27jO+U7eO2VwvqfrPF2n6Drdqvs2p9bSalZNKe98R8WxFBEQ7273xJS5uR2ZZ7mmSqnMITDOM/vrW+Z5Obi7fN/T9z2lFHa7W5YloLScslHgfUethdvmeCl5XVDlf2NOEqjYCp7duGdV/JdmnY8tFE3Q4hJ8My+LLNw5M88LR9ueoe+aiFbYJ6vtvTR7/tD3dE4spQf9gW0bXQHnOpTS7MeRimptebkfc2M/rCI/YwyqiZNf7hYoZVqHE2orgowx0kVsNs2VSOrNXXGwbkBa3835gdY1cQebaW0zQ9Ns1CUnfOcYx1HQ862D4byg11POMhLyfRupiNOiINCs1TVSSjng0p1zh9P1egqvtTI02unLHRXvPdM0scZqpJQYhk1zwhTh9zTYmjFGeCvUO1DYR/QTYlNNKUlhpVeGhiDkh2FAnEXzYUT6shjWrU6h9nvmnOn7/qCT+p3jlLUNv/6eK2RLG9P0IKXpTeR7bRuVpJgOxe/6SK2zV9p4bxg2LIt06UKMbVOzh9e1vob1uqlVLMLSGVetC8phBGYOVOu732Ut5qSoEFHzQQ/WCvy1K7b+/brZttxvUvtsxKXnD7iKWqRwAhljKa2IcaEU0b0db+Dzn/sEv+9Hv0Atmf/9N/4jLy4nXlwtzHMhZnBG1hnvuzb6ymwGx3brODnuONp0DF6u7WUpPL3Yc3G5J2RFjIWcKzVJAYVWWN9RjSGpfIhtGWwnDlctzrmiFRhDomA3FtcL5NRoy6YfeO21Vzk+Oubs7AylFbvbW2quzLuJ995+h2dPn5CXBW8sOcRWsEqHrbR7er1G53k+jL5Si4xY3+MQAre7mevrayG8/zce/z9pUK6vrwG4d+8eAL/xG79BjJE//sf/+OFrfviHf5g333zzUKD8+q//Oj/yIz/ykZHPz/7sz/LzP//z/NZv/RZ/4A/8gf/i5yztNLg+bm5uAHjv2aVYiJFTvGoW4ZyzWDVjYh9ntDcYe8s4T6RScK0NvnrsocqcvJZ2OhDRbIyJcZyoWRgNKQTpdkwBazTzPFNKas6fSIgLIS2glczbEetg12+oWPZjYF4CVBmdaKWgVKyCvuvkIm+dBN9IuMNwzNHREZvtpl0IAmOb9yOD95wcHXG82bDtN9yqK0wuJO8YvOPo5JiHDx+x6S3vPHmP337re3zq9YdNW1B48v57GNtxfHzO/Qfn/MTZGZ/6PRe89+QJF1c3vLi6lLZ+kgvNdwN903iU9ZTdKKo5i6K7lrXoSlgDlIJR4FQWy5yqGFVRROFv2AVcpessfbdhMwwodNMWyKnIux7T5spd1wk5UivunZ9xdnLC4B01ZbEW14LzTnItGkSp1jYCtA6lHSuGuyKtzDkEQYCj20YsgYraGAqOZ1cTz55dcHF5zdXVLUvI5Fx58eKKmDNLG9nlkNsNKKf5bklcXt0yTROXl5eH/IxxGqVr0IS4c0vMXZ06S5QMFZQITJ13pJxEsGpM67ykNt+W5OAlilJfKSU5Jt7ivAHlCClgkxB9fSf5N+tC3vmOnKKMWeqdLVOcBe0UTyLVxNBtGNSGZYltxNNOk1o1J1OSAtWILkwjwm/bxlqrk2Y9yYqwcdUH9IeNP6dMic12/xIwTIqQ/BLxtLQ08LVokQ6aavOHtXiQLkvrTJh1VCZLX4X2mS3tGu8ODpkVugX1YOGVYmoFat1tpLEJhtdNHj66ucuJ2x6KF9PZA7BL5C6rm+YuuG7doFeRtAhW2/e3olW0Th8dNa16ivWUfzc6auO4pu9YuzLrdbd+3dqZWD+nu/GlPxTIwEd+z9JYPTKWzHfFUREOUaE2MFtuYaIcCoS7UdMdJv/l12KMPXzOQskRLZQxrjFZ2qixdVHUQReyJnGbj+hp1jO5tfYjsgLnhDGT8t11JSBBJXwqbdC1iti6PU8uGWfuUAKqrdG1wMnJOWGZSCmLLmteKEXgcKuOSDbvIrk1JnJ83DH0kvtjjEZVWJCx3rAZcEUxzYn9Tg4rtnUday2SBK7l2jeIq3Fuo9RcBJFQlSargrpSh/dkZbd8b3t0QNEbLYd5Zy0lw/72lmUaycsi1mulD8+7dlpNA9at18TqiMqN4k37zOtLY8f/3uN/uEAppfAX/sJf4Kd/+qf50pe+BMCTJ0/w3nN2dvaRr33llVd48uTJ4WteLk7Wf1//7b/2+OVf/mX++l//6//F37+4GnFGZrTr3HH91UNq4Vcqk6sIM2O+a9EBHwl2o9Ym2GrumjZfjQ0ulosgu7XWGC2wtZOTLcsyU0pmGDrmYOhKh+sEu1yNBmXJWezFSi+UvIeqRAxKpcaEFVCHQLUasCinQIkGs9EYpShBnAvGaHplKFrTaU1eFq7HmT3Cfxhvb0gxY8kc9R3bzZYYJm7HyHtPLxn6Ad9dobTlxfWe58/exvme45MTWUByQhE5OtIo3TcBXIexhs55lhDZj9PhlC/ZPxBDuCtQqsZqh7WFFatey4Q/VhxvN5yebNn0HX5wbI56uk4KiuOj4wZSksVbFm5pORoj45RaBAeuFBxvtgxDT8mZuEgHa+1e1LYoShtWrMIZaQFf39wwhYVcCksIXF5e8/zFhWQnuQ6q4vr6mnlayAWu9gv7/czN7cj1zS0xyrhunObDSVZpKRzEkig3ZMzpYHVMLbsjl0KOUuBKZ102CmPtYVPIraVdqGgrp5OU8yG+AWQBlhaxk3DLOTT3kabXHu0kw6PzG9n4s2D9+863U7nCGenG1SJZUkabltYsHTvfeWoVsqQIQBPWyig1L+LgqNBCL0UnQq1YZbDOY5oWQTdtyyGLyMmIICVBlq8bxarhENihOvA8VnGjgKrurjvvPcsU0Fos/BQJ55QNUh0smyvFcm3Jp5zuTsDGtJA8GV2FsIjuyKyE0JWhoQ6bs0DDysHdshYEaxGxjtnWE7mIPiWOYF24RVy9BtStHQ9hcKwCVNGhiemhNDF2qQXTOlvrz1rZEi93P3IWkazwTT5aVKT0kkixfpQgu3YWhmEgxviRTtGqC1k1OGuOmQgqZfysjTp0UIQp0yz0qqWYpywso3rX4Xm5c7K+h+trerlbJp9B4RDO2v6jyOm9tjWc9tnQNk0Zb4kmUTebu2oj6rUgvxvdiGVYvleBal2xINbpw3vVNLLrz5XnUE0HBShLirnle5UWhaKpNJJzQdaAQwFtxWVoRDi/2fT0ncMZS6l7NluIZaYkIfkeithacJKjIcTdJLEnaDFxhIa/qKzRI21va9ezaWt2SonbdC2CctX4UDkDqmWYNV1Yc1mx7rci4Lk71MRw0KhIl5bD19ZaKEmKyY/7+B8uUL7yla/w1a9+lX/1r/7V/+hTfOzHX/krf4Vf+qVfOvz55uaGT3ziEzx7esHRdgtt4QhJUoCNNezHPdM0YztDponjGiF2WRZUFSHd4DtMqRKKViBOk2S4KC0jAefQSuxWqqXPmqEjJSNWMqNIFZy3dNuz1m4T6iBKYazn+npkt58onWZyAYNoDWqWwChnFNYqtOkZhg5jFJWCd57jTc/Ge5Z5JqTcWuSV034QxwmgaiEtC51RbM/PKKlwkgPaKsiJaZzZjYGb69v2Hgi+3qqeqj37ceH65n0eP37IF77wQxydHqE1aA3jtOf6+lqKglrYjSPGPGCz2WCszEyvLl9wc3PF/fNztpstyxwJS6QWhe96hmHAO8+9s1Pu3Tvj/v0TtpsBbTTOd0AFJXqamAT6FENmniM5Q4yS8zNOExcvJCtIaXhxIZvAfr9vKcORKUzEGNrf7RvKW3gVKUvQ4PXNjtvdxJwyaxT9NEnsQCkVilqlGHL6KZIkaoxrc+7UAFuy2YsrZA1Q1JLvU0qzja43sZxejDWNC9Aol0ajjBFdhZIncroVITWDkQ6FdfbuxKdEXKtjFOCVEjW9aTAtgwajKFGcI50TzYS81ow2Ytc1aKzhEDJmtMJvN6QQW/CmFInOStjZNO0xxovt1RpyllVai+qZouXEJxuUIiyLFDpNyGmckc2xSqZRWk+hKRGQ7KiVcqvaxjnP80HQGqOIImXTAYENCmNnjQIQ7YHMZvVLReCql6i5SK4UIuJd3RoS1Jnou+5AoJbiQB06DCJ87gRA107660P0NO5QaL0saJVC4q7TIo+7EL61SDEtRHFtg+ecGdp9sjT33Msb6no9zC2/yrkOrfVBfyKvxxw6LS8XNDlLR0RhyCGg1KrBsK1TFFpRxcGFobVYRqVYaLft+nra3xutDxohY83hfRABam0FRTm89pTEXryOCtYC6+VOTqt7D0XlWrSo1mFcv+9upJUPBYSM+l/e0GU0jpbvzS9pnaQrKe9NqYVVdl+VjB1f1qysGpeVAaNaJ0fgfpXb/cg0yzi18z1G7eWeV6p1ETOp6WNqrZhOrkFrLClnkSJkoenuxlFcc9PEHCsptUqrVVulEcpbJUCOGXR5aZzaBORa3ImmVlQ1xFIk+6zI8xktmUMhLrKGIFlhNTdYgGqgupf25lzaIcXIJECbtfO9dkzuXFm16ZZ+Fw2U/7EC5Rd+4Rf4x//4H/Mv/+W/5I033jj8/ePHjwkhcHV19ZEuytOnT3n8+PHha/79v//3H3m+p0+fHv7tv/bouk4Elb/j8f1vv03fhJZaSRsul4z1TmBK1qJUx3C0kZskBIxTbKwjh0qMMk+LQcL0rDF0RngjpVW7pVaGTc84TThj6PstsQQUBV3A+Z5xnqnIPHXJkTop5jCjqpJI9DEyT4FUxC5qnaazjk0nQtvj7cDx8YZu03N+7wzvLSAiWErBNxGwFBdtcU+JcXdLjoF5v+OD996lG4452R5xfXnFsdmgnCUuEy+eX3B1vWO/21GKYrM9AWU4P93y+LVPQk48ffoB11fXXD6/4I3XXuXe+SlG30WZ55y4urxkHPct40cx9B1KwfPtQEmv8Mbrr3J8csx+P7PfzYAh5UpF47ue4+MjOi+x6UsslCWjlkwIc2vxKm5udixLYL9buLy4Zbeb2I0TOctN//133mGaJUQsxEBMbeS1zIQQmcMkavso4qySmvq/CqclZWFtpFLJ0BYWOVXmRnh0VhwcOUorV9D0Wl5zqaClvSwJolLMCK6/olShkNvCJyFfzomuKqWmKREmPkop+qFvnZXW+q7mbgySEYhVliKhIiRc2qlF1SI0XQX90LUNsAURZsWyhBa81wmmPUfhyrRCqeYKbayQQwRjMN5DLQ3dLiNQEbUaliXBeops/0nardQAct2uJzyFSCzlfS8lt5gADq6TlBpdtXVF1o3XWUHY5iwi2pcpqaUU+qGHRorWSklMAaIfcbZp2JqAMDR3UIXD+DeHiHH2I0XE0G/wTj43pdRBn7Hb76mKgzZuBa7lnKn5TmuxdmikO1Lp+/4jYsyX9SRaNYR92xjXzTmXQi3p8Hzr2OrlkcTqgKltVLUKfUGcYc6Jc2h196yPtYt1eA1a3EnOytq63+8P77Nch7B2frzrm+ak4qzH9+33qpWS1s5EC9Zsur1a5fR+V0zI72xbJIBsYFL01zb6W4uTNRkd7oqOu3Fd/UghUqvcs6LnEEG93O/t6M4dyfZ3dmXWeAbFXfFxKFCoaG0ly625ddbRxMtanZeLTuk4FKiZcZqxznPv3n22w5aUnko3GCUAWaPRSqzLlYKzXj4za8ltjeq6jpgzU5M4xBSZ50xR9i6MtRZilsOgta4ZRuR6z6V1UwClKipLBpporUrrIGmUFmrwHGcBUVbACO275opZSxL5yA4dsdUSXkorkpTCuVaArZEg+e7aV0jBrxEMwsd5/K4KlForv/iLv8g//If/kF/91V/l05/+9Ef+/Q/9oT+Ec45//s//OX/qT/0pAL7xjW/wzjvv8OUvfxmAL3/5y/yNv/E3+PDDD3n06BEA/+yf/TNOTk744he/+Lt5OVw/u2DuOry3bLYD2yNJcSxUdCmoKoFP016ImkPXYZXCUIlEvOuwRfDM2hr80KONYQ6RqhTWeUq7SU43Z6ScGJdJqsBW9ccQub29FcyzUsJiaG3kHBPTtKBNJxdTWS26BWc8Z2fHPDg/5+z8hM1R32bGEidujcCxyBVVZKaoa6GmSq6Jo6Mt295zffGCOMupJBXJF1p5Aq89fpMnz57zztvvEJaEUp73n7xAK8P8yVeZ5nNKzmy94fGjV9CqsswLl88vGKxkwyzzjNGay6srnj9/wdH2CN87Ukksu1ECD1Oh855nTy5557vvcbubCKlSsuL6duJ2L/lBxprWOYiEZSIXCdLaj5IGO4fI9fUtYcmkWMVWlyq5IJZXbdjtx3ZCUocuhiwmBuscS5xlVFZELCbdTtkUqtYtSbaQakLplqGiNTVGEUkoRVWWWIVE7axFWy9zXi36GtaNoxSMk43TJAFvKeR0pTGkkkklSZCbVlQlsel9ZzG6CDPFSrcsF2mnV7XWpdLKNkjqsG1djBhb1klZQVxGfj8tCG7nXtr4Whuo5CRJslVOuHWlKTcbL3XNkmnt/yok35JlPu66vlFOtbgFFkHEi2gxN+sobbORoqaUxgTSa/Ri6xgoGQVZrTFt9FJKAdtyg4qkeK9W2FXwKbbp2Bb2dRSSm7tMteIjoZtltwJVyah3bTGvm4q1UiTrWtoI5k7nsWsb9Tpu2G63LE04rJQiTBO+CW5jiofo+LVrsm5WMl7xHxGbrhvq+mfpCsVDYcDv0EesG/a4zIfP2nnfRPeJUnRzSoSPFDSrxkQKMOmKSEGytPfVcxAYA+M4Hgql9TWu2pCXRzvr6zx04/LdUXjVlCgjp/rc7Lhrd6oUgfUtbYQk1zeHQkqpOwHvqmdYOzEv60fWTsnLX1sB8p3dXx6KtUD5nd2VO4eS/HnNjVkdRHLcV4expNB2ZT95WWO0fv/h84ND1yknAcrF5uYp66gDxRqu9/KYRNATCX2TOTsbBOq2BPqu5/jkjP18SQg75hApZLm4czqMmJqqpxUtqzZEQWMnpbwKyC1tToTRLd29CPxBV6HqGuOoWSQHWulDbpTS4jCScU67b1US3ZeSdTClfBCFKwSuqNYRoFI4pYRHtP94gYG/qwLlK1/5Cr/yK7/CP/pH/4jj4+ODZuT09JRhGDg9PeXP//k/zy/90i9x7949Tk5O+MVf/EW+/OUv81M/9VMA/MzP/Axf/OIX+TN/5s/wt//23+bJkyf8tb/21/jKV77yX+2S/LcevjNsty2bxCjJsTAdSwqYalBWo1vOSSgBhT9cELbr6K2VE3M3iBOiF2Fl2e0JuZARR4TreoiRGAMhBMK0sCKiU8ns9nthEnS+Vd+CWlZFscQFreUsuR9npnEkGMtewe76gg83A8PQ0XWOktOBcmitwRn7/2nv7GOkqs4//j3n3rmzsyy7iyz7Vt0FEUVECIW63appEzZaSqptjDEGE/A14BoxMca3WJomLSZN2lRD1lgVTDQS2xSqlpdSQHwJgiAoK/5WlBX4+XN3Vbow+zIz997z/P54zrkzA7QWtbs7M+eTbIC5l9nznDlz7nOeV92JVwf2gUv7V1VVo7n5PABAemgAFYly1EycgOGBE5g8pR51k8bhkyP/i8zQAP7Z1weV5uBeFQSgMEBfXw8y6ZNInqxDGDaiosyDCgKcU12J8kQcyc5D6Dz4MfwgE6X3Dg0Pw/cDDkp2HAShzxH8UiA9NAQ/wzVdTFOzUAmk/RCDwxkMDKZ0wKc5tQQIQ18HbulgRsVafBgaA4GDUAk2IXLtbu6CrE8WQgikggAucXColIQyVwCux/5X80ZECBR/MV2Xi9AJR8GFA0cqdotIh60RHAoER7sUMvrBEIhQ9+rg7B5TIls6An6Y1nEz/GA2TQWllBBKccEx4cB1PL1dKm1xYGUt8LlkPxR3Ug5JP8jA61RKodPGOR3TBKEJ5eiHj6N9yCFcl0/GQeBDQHAXY+03dnS1THPSNY7pUAc5c0t5Ngt7XhnSmRQHteoGZVxsis3soeJAc0BgaHgYROzWkjqwmYgtWDHP08qD0soN6YKI2SyLtE7jjMVc+IGJIeLGf2Vl5Uin0iAKYIr/AYTh1DBclwNzlRCAEnySV1yfRZLSG6nOslHZdGUOoIRuJAlAm+i5IzErmLxOud2F4zowHXodx4EKFdIpbh/vxLLBl+aUaNwrudlW2XRX3ZFWt6I1DzuT8WDcM8alxEGbXAHXrPls8z8TyBrmpBVD1+mQUdyJlCIq825iXVTICr2pGSIEu6DyM6WgFQtdqE6nKYehgkplYPramHtIn6CNRY1jQKT+U0WuDOMWMTE92dRd/X9AUfwQgJyTerYMvAmWZQuPDpAW2XgQfg8AyKZw84rXQbZ6v3EcByGMFYsfvBAC0sSXQLsoTIxVjhvKyGLUIRNXYTrIB0rg+IlBBAGQ8gmul4BKpyPXGit/WomQvCbIJ8jhAFKmIIXC+PECw57CP/95AieSQwh0TJ4eGCsdpLQ1VoLIuLLZdS1zFDMJrtHiujEExApDKNhKRYqDgjl3SbDiostm6P8Mk53n6No6vq6AKwTXo5LGVal/pHBgZkc6LpQITSBM1EfpP+GsFJSOjg4AwI9+9KO811evXo0lS5YAAH7/+99DSonrrrsur1CbwXEcvPLKK1i2bBlaW1sxbtw4LF68GL/61a/OZigAgOkzpkdpYULnoysAKhDcadbRQUIOnxxjiRhCP4PQZ1vkYCrFcSd+CN8f4H4sUmBwaBgBAF8ppH2fO+emhmA6VnL2jm5wpV+D4L4f/HDhIDs/ZKsGgMgNAF3/IBOGUBkfgwMDkAB0Wruu/6D0NilgkvWE4K+X57goL0+gt7cPnudi/LgEms9twLhxCcTdABdfPBVhOoWurv9Bf//nEIpQXlYGojRUkIFPhDDM4MvjKQwNnkRP7/9hfEU5XOlgXCKBslgMYeDzIqcAISmk9b99PxMVOwpVqJszuqw1C0Ao3vQ5i4otAUHIhgk35kXmUBNDEIShPv1LkJIgbd0QJlDWEToDQADSgYh5cMIQQjfokzqYjQhQguArLo0uHTZ3CvBJQoT8CYQg7WZR7DN1HLgC2uXCsR5KckwIpGAFN/LuEpQItTuBrVoQAtwajjexMo/THX3ty5aCLUtSpy37AbsFuKS3BIXgDUZKSGIrRBDqTAsna6Y3PvxYLIaYjOmoe07l5k2SrQggflCHAQFQUcyVBG9MmUyGU8b1ygqUilwEnhuDcNhCktapywKs7AwPpzg+hziIPDo9gTh2KuehyWsVeSftbIEyfRol/dlrhYVL/uv0e8Et5V3pIJ32dUBytoZMLOawAiOyvWIQSCjFSh90gLtSrHg54BObo4MGHelACm6Ml/IzUR+WMMypu5JzQiYgsiAIIVAWL2OZlGI3oM6EMWnJJqbEfGbmujnZ5xYIGxwczMtYgeDvu7FcGMU9N1smNzvFdbgmUTqV0f9H6JTeMgAyChYOA4VMhuNrMvAjy4QpjoYcaU+1VHBtFKOc6GJzpGBKyfO4TLE8FT2ogjDgwpI5imFuPAmQzdYxLh3zb8pxMZnPROjvuflss1lJuVlc2a7O3K4kqygScfCnWZNKd8Fmq5WCUia2R2mXkwSErjVj9niIvN8NaDcLshYrKfl7ODScxsfdxxD3PCSHAvghH7JMxqMKQ0gnxs0CwZXHCdwEcHA4gCAFP0yClMJQKo1MwActrj/DvXnicS9KR5eQAPH6l47LzxM9V9xvKNsLzHVjUMSHIFbuBKBdZ4RscUUTQyQUx+uQtn4QoNuAAKRE9GwyCmr0PQIrVFLIqJYPfxZf/Ww3nLWL56soKyvDqlWrsGrVqn95T3NzMzZs2HA2v/qM44gnyqKiQ57LxWJS6TSSqSEOPHSAwE8jo4Om1BeE1PAg4k4MyIRID3KPmjBUSKVSXB9CAn6gIGMeAvNhSYnBIe4Z43nZRlMmut9o+xyAx5ql67oIFacZA8ZPyk3pzDfNEfxgUTojg0in50WbE0XaPKBPE4JzzE+eTMJ1JCZUjUd6MAlHhKiqiOHjw91wSCGZHET/iUHEvHH8YCQu1+y4CTgO4DgKKgiQPDnAwYxCot9hM3wYcKMnaLcEd9FkmdMZH17c40JdwkEQEJSvy1aHQZQh4Hll7MeUgBQxSNeBn0rDVwEcL8adUQGQ1JHzjgBJgMAbLcf/cONFoSN2ZY4Jm7MDXG4YGHJsCP9uxad+mKZbbPrneAePu+kKPo3rt4OpucJfNC44xZkvPmIxN0pz5Gga0jG9RpEQkTlbkYSpMOmayqD6sGCCCwHuRxTodSwohNImUWPdYH1X6JOmA9fhk6/rcFO6TCatA7i9nM2c7xFSRH/3/UBnUUkECHUQMCtTAcLIikCKkArScONcytz3fSTGlevOsNp657qRAkrEXXAhuGKvq5Um389myUldbTSdzmjlgltLZE/SyMqqT9qsCPB3TnoyG7RM7DI1rgsIleMC4A1TSAeuyxkUSoXIaCsUSGqlWXEgqReHK12teKVRMT6mMyf4vcKMylFWCAg4IJotOIR4nC1h6YEBbQVxuL6NkAgCjj+QjuR6TGGgXQgOzMPNZP5I4SDlZxA18NQPct8PokMAuwb4u8e6XxT5idDsNYpjjdjKweUDXIdN90p/Xn4QIPRDyIQDKbIKj3lQCuP+MJYG/aAxsTEwin1eenHWLWJiM8IwBHn6fZUJIEX20BJynBfAMSvQjUCVDko1D1OpLULmdxoVHOC1qiirIEQ1XPRemvOUAFtLsunLQNaSluty47Ea651eV0rlxHFklSSTaQfkKCfm9xrlS7C7t7fncwgBpDMBhlIphLpTJis4RhZOm2YjkM6G0WP1Mya42EHMlfAzabgOx6hwnJHDFbCJwAqpAFHABxMhuBhoGHApCMq6Frmwo9Qd37MuNKljpoxrLubGsq7LID/zKoopEblWLehA6jA75wS9nrOKnOd5GBpK/Uf6xDcq1DZaHD58GFOnTh3tYVgsFovFYvkaHDt2LC/J5kwUZLNAUxju6NGjqKqqGuXRjA4m1frYsWNfWY2vGCl1+QE7B8gowvAAAAo1SURBVKUuP2DnoNTlBwpvDogIyWQSjY2NX3lvQSooxsxUVVVVEB/If5PKysqSnoNSlx+wc1Dq8gN2DkpdfqCw5uA/NSzIr77FYrFYLBaLZWSxCorFYrFYLJYxR0EqKPF4HCtWrDjruinFRKnPQanLD9g5KHX5ATsHpS4/UNxzUJBZPBaLxWKxWIqbgrSgWCwWi8ViKW6sgmKxWCwWi2XMYRUUi8VisVgsYw6roFgsFovFYhlzWAXFYrFYLBbLmKMgFZRVq1Zh8uTJKCsrQ0tLC3bv3j3aQ/pWeO211/DTn/4UjY2NEEJg/fr1edeJCL/4xS/Q0NCARCKBtrY2HDp0KO+e48ePY9GiRaisrER1dTVuvfVWDAwMjKAUX5+VK1fie9/7HsaPH4/a2lr87Gc/Q1dXV949qVQK7e3tmDhxIioqKnDdddeht7c3756jR49i4cKFKC8vR21tLe67776o5fpYp6OjA7NmzYqqQra2tmLjxo3R9WKX/1QeffRRCCFwzz33RK8V+xz88pe/jDr0mp/p06dH14tdfgD49NNPcdNNN2HixIlIJBK49NJLsWfPnuh6se+FkydPPm0NCCHQ3t4OoDTWAACACoy1a9eS53n0zDPP0Pvvv0+33347VVdXU29v72gP7RuzYcMGevjhh+kvf/kLAaB169blXX/00UepqqqK1q9fT++++y5dc801NGXKFBoeHo7u+fGPf0yzZ8+mt956i15//XW64IIL6MYbbxxhSb4eV199Na1evZo6Oztp//799JOf/ISamppoYGAgumfp0qV03nnn0datW2nPnj30/e9/n37wgx9E14MgoJkzZ1JbWxvt27ePNmzYQDU1NfTggw+OhkhnzUsvvUR/+9vf6MMPP6Suri566KGHKBaLUWdnJxEVv/y57N69myZPnkyzZs2i5cuXR68X+xysWLGCLrnkEvrss8+in88//zy6XuzyHz9+nJqbm2nJkiW0a9cuOnz4MG3evJk++uij6J5i3wv7+vryPv8tW7YQANq+fTsRFf8aMBScgnLZZZdRe3t79O8wDKmxsZFWrlw5iqP69jlVQVFKUX19Pf32t7+NXuvv76d4PE4vvPACEREdPHiQANDbb78d3bNx40YSQtCnn346YmP/tujr6yMAtGPHDiJieWOxGP3pT3+K7vnggw8IAO3cuZOIWMmTUlJPT090T0dHB1VWVlI6nR5ZAb4lJkyYQE899VRJyZ9MJmnatGm0ZcsW+uEPfxgpKKUwBytWrKDZs2ef8VopyH///ffTFVdc8S+vl+JeuHz5cpo6dSoppUpiDRgKysWTyWSwd+9etLW1Ra9JKdHW1oadO3eO4sj++3R3d6OnpydP9qqqKrS0tESy79y5E9XV1Zg3b150T1tbG6SU2LVr14iP+Zty4sQJANnu1Xv37oXv+3lzMH36dDQ1NeXNwaWXXoq6urronquvvhonT57E+++/P4Kj/+aEYYi1a9dicHAQra2tJSV/e3s7Fi5cmCcrUDpr4NChQ2hsbMT555+PRYsW4ejRowBKQ/6XXnoJ8+bNw/XXX4/a2lrMmTMHf/zjH6PrpbYXZjIZPPfcc7jlllsghCiJNWAoKAXliy++QBiGeZMOAHV1dejp6RmlUY0MRr5/J3tPTw9qa2vzrruui3POOafg5kcphXvuuQeXX345Zs6cCYDl8zwP1dXVefeeOgdnmiNzrRA4cOAAKioqEI/HsXTpUqxbtw4zZswoGfnXrl2Ld955BytXrjztWinMQUtLC9asWYNNmzaho6MD3d3duPLKK5FMJktC/sOHD6OjowPTpk3D5s2bsWzZMtx999149tlnAZTeXrh+/Xr09/djyZIlAErjO2BwR3sAFsuZaG9vR2dnJ954443RHsqIc9FFF2H//v04ceIE/vznP2Px4sXYsWPHaA9rRDh27BiWL1+OLVu2oKysbLSHMyosWLAg+vusWbPQ0tKC5uZmvPjii0gkEqM4spFBKYV58+bhN7/5DQBgzpw56OzsxBNPPIHFixeP8uhGnqeffhoLFixAY2PjaA9lxCkoC0pNTQ0cxzktWrm3txf19fWjNKqRwcj372Svr69HX19f3vUgCHD8+PGCmp+77roLr7zyCrZv345zzz03er2+vh6ZTAb9/f159586B2eaI3OtEPA8DxdccAHmzp2LlStXYvbs2fjDH/5QEvLv3bsXfX19+O53vwvXdeG6Lnbs2IHHHnsMruuirq6u6OfgVKqrq3HhhRfio48+Kok10NDQgBkzZuS9dvHFF0durlLaC48cOYJ//OMfuO2226LXSmENGApKQfE8D3PnzsXWrVuj15RS2Lp1K1pbW0dxZP99pkyZgvr6+jzZT548iV27dkWyt7a2or+/H3v37o3u2bZtG5RSaGlpGfExny1EhLvuugvr1q3Dtm3bMGXKlLzrc+fORSwWy5uDrq4uHD16NG8ODhw4kLc5bdmyBZWVladteoWCUgrpdLok5J8/fz4OHDiA/fv3Rz/z5s3DokWLor8X+xycysDAAD7++GM0NDSUxBq4/PLLTysv8OGHH6K5uRlAaeyFhtWrV6O2thYLFy6MXiuFNRAx2lG6Z8vatWspHo/TmjVr6ODBg3THHXdQdXV1XrRyoZJMJmnfvn20b98+AkC/+93vaN++fXTkyBEi4tS66upq+utf/0rvvfceXXvttWdMrZszZw7t2rWL3njjDZo2bVrBpNYtW7aMqqqq6NVXX81LsRsaGoruWbp0KTU1NdG2bdtoz5491NraSq2trdF1k1531VVX0f79+2nTpk00adKkgkmve+CBB2jHjh3U3d1N7733Hj3wwAMkhKC///3vRFT88p+J3CweouKfg3vvvZdeffVV6u7upjfffJPa2tqopqaG+vr6iKj45d+9eze5rku//vWv6dChQ/T8889TeXk5Pffcc9E9xb4XEnGGalNTE91///2nXSv2NWAoOAWFiOjxxx+npqYm8jyPLrvsMnrrrbdGe0jfCtu3bycAp/0sXryYiDi97pFHHqG6ujqKx+M0f/586urqynuPL7/8km688UaqqKigyspKuvnmmymZTI6CNGfPmWQHQKtXr47uGR4epjvvvJMmTJhA5eXl9POf/5w+++yzvPf55JNPaMGCBZRIJKimpobuvfde8n1/hKX5etxyyy3U3NxMnufRpEmTaP78+ZFyQlT88p+JUxWUYp+DG264gRoaGsjzPPrOd75DN9xwQ14NkGKXn4jo5ZdfppkzZ1I8Hqfp06fTk08+mXe92PdCIqLNmzcTgNPkIiqNNUBEJIiIRsV0Y7FYLBaLxfIvKKgYFIvFYrFYLKWBVVAsFovFYrGMOayCYrFYLBaLZcxhFRSLxWKxWCxjDqugWCwWi8ViGXNYBcVisVgsFsuYwyooFovFYrFYxhxWQbFYLBaLxTLmsAqKxWKxWCyWMYdVUCwWi8VisYw5rIJisVgsFotlzPH/+QRJj0oAsUcAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -791,7 +791,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 36, "id": "6ce81674-4cdc-4074-a39a-c61b1188076b", "metadata": {}, "outputs": [ @@ -807,10 +807,11 @@ } ], "source": [ - "annotator = sv.BoundingBoxAnnotator(thickness=20)\n", - "detections = sv.Detections.from_inference(detection_coco_and_plates)\n", - "plt.imshow(annotator.annotate(multiple_cars_image_2.copy(), detections)[:, :, ::-1])\n", - "plt.show()" + "for predictions, image in zip(detection_coco_and_plates[\"predictions\"], detection_coco_and_plates[\"image\"]):\n", + " annotator = sv.BoundingBoxAnnotator(thickness=20)\n", + " detections = sv.Detections.from_inference({\"predictions\": predictions, \"image\": image})\n", + " plt.imshow(annotator.annotate(multiple_cars_image_2.copy(), detections)[:, :, ::-1])\n", + " plt.show()" ] }, { @@ -826,7 +827,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 37, "id": "27e8f8c5-48d4-47d5-a542-2101112f51ae", "metadata": {}, "outputs": [], @@ -868,7 +869,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 38, "id": "2b3516fe-74eb-4fe7-8ebd-9e3001a7b2d8", "metadata": {}, "outputs": [], @@ -879,7 +880,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 39, "id": "b7e0bc65-f05f-4ea0-8ef7-72b1939192ae", "metadata": {}, "outputs": [ @@ -901,7 +902,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 40, "id": "c189c354-8ec7-47b3-8751-1aae6806b6e4", "metadata": {}, "outputs": [], @@ -914,7 +915,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 41, "id": "4d9fad4a-7c59-42dd-bbc1-ebe6839e6aa7", "metadata": {}, "outputs": [ @@ -948,7 +949,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 42, "id": "2094f57e-676d-4ec1-9d03-7a89301dd783", "metadata": {}, "outputs": [ @@ -970,7 +971,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 43, "id": "1bf96383-9908-4f2f-90f8-e13ca0162174", "metadata": {}, "outputs": [], @@ -983,7 +984,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 44, "id": "546a10ac-b24c-43df-9d46-db24199918e8", "metadata": {}, "outputs": [ From 69c88aa72e198295b42016f6f18bb425079e81ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 15:42:09 +0100 Subject: [PATCH 15/18] Add changed to enable persistence of AL predictions in workflows + tests --- inference/core/active_learning/core.py | 2 +- .../core/active_learning/test_core.py | 30 ++++++++++++++++++- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/inference/core/active_learning/core.py b/inference/core/active_learning/core.py index 35765e5a6..55a26596d 100644 --- a/inference/core/active_learning/core.py +++ b/inference/core/active_learning/core.py @@ -215,5 +215,5 @@ def is_prediction_registration_forbidden( roboflow_image_id is None or persist_predictions is False or prediction.get("is_stub", False) is True - or len(prediction.get("predictions", [])) == 0 + or (len(prediction.get("predictions", [])) == 0 and "top" not in prediction) ) diff --git a/tests/inference/unit_tests/core/active_learning/test_core.py b/tests/inference/unit_tests/core/active_learning/test_core.py index a5f81c4c8..2865252d1 100644 --- a/tests/inference/unit_tests/core/active_learning/test_core.py +++ b/tests/inference/unit_tests/core/active_learning/test_core.py @@ -739,7 +739,7 @@ def test_is_prediction_registration_forbidden_when_prediction_should_be_rejected ) # then - assert result is True + assert result is False def test_is_prediction_registration_forbidden_when_prediction_should_be_registered() -> ( @@ -754,3 +754,31 @@ def test_is_prediction_registration_forbidden_when_prediction_should_be_register # then assert result is False + + +def test_is_prediction_registration_forbidden_when_classification_output_only_with_top_category_provided() -> ( + None +): + # when + result = is_prediction_registration_forbidden( + prediction={"top": "cat"}, + persist_predictions=True, + roboflow_image_id="some+id", + ) + + # then + assert result is False + + +def test_is_prediction_registration_forbidden_when_detection_output_without_predictions_provided() -> ( + None +): + # when + result = is_prediction_registration_forbidden( + prediction={"predictions": []}, + persist_predictions=True, + roboflow_image_id="some+id", + ) + + # then + assert result is True From d60d007f12acf6f00af07f13922fc347ec75fdcd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 16:41:40 +0100 Subject: [PATCH 16/18] Add changes into docs --- inference/enterprise/workflows/README.md | 55 +++++++++++++++++++ .../enterprise/workflows/entities/steps.py | 2 +- 2 files changed, 56 insertions(+), 1 deletion(-) diff --git a/inference/enterprise/workflows/README.md b/inference/enterprise/workflows/README.md index 92d868fac..677738cf3 100644 --- a/inference/enterprise/workflows/README.md +++ b/inference/enterprise/workflows/README.md @@ -261,6 +261,7 @@ input parameter * `confidence` - confidence of prediction * `parent_id` - identifier of parent image / associated detection that helps to identify predictions with RoI in case of multi-step pipelines +* `prediction_type` - denoting `classification` model #### `MultiLabelClassificationModel` This step represents inference from multi-label classification model. @@ -281,6 +282,7 @@ input parameter * `predicted_classes` - top classes * `parent_id` - identifier of parent image / associated detection that helps to identify predictions with RoI in case of multi-step pipelines +* `prediction_type` - denoting `classification` model #### `ObjectDetectionModel` This step represents inference from object detection model. @@ -309,6 +311,7 @@ input parameter. Default: `0.3`. * `image` - size of input image, that `predictions` coordinates refers to * `parent_id` - identifier of parent image / associated detection that helps to identify predictions with RoI in case of multi-step pipelines +* `prediction_type` - denoting `object-detection` model #### `KeypointsDetectionModel` This step represents inference from keypoints detection model. @@ -339,6 +342,7 @@ input parameter * `image` - size of input image, that `predictions` coordinates refers to * `parent_id` - identifier of parent image / associated detection that helps to identify predictions with RoI in case of multi-step pipelines +* `prediction_type` - denoting `keypoint-detection` model #### `InstanceSegmentationModel` This step represents inference from instance segmentation model. @@ -370,6 +374,7 @@ input parameter * `image` - size of input image, that `predictions` coordinates refers to * `parent_id` - identifier of parent image / associated detection that helps to identify predictions with RoI in case of multi-step pipelines +* `prediction_type` - denoting `instance-segmentation` model #### `OCRModel` This step represents inference from OCR model. @@ -384,6 +389,7 @@ This step represents inference from OCR model. * `result` - details of predictions * `parent_id` - identifier of parent image / associated detection that helps to identify predictions with RoI in case of multi-step pipelines +* `prediction_type` - denoting `ocr` model #### `Crop` This step produces **dynamic** crops based on detections from detections-based model. @@ -466,6 +472,7 @@ This let user define recursive structure of filters. * `image` - size of input image, that `predictions` coordinates refers to * `parent_id` - identifier of parent image / associated detection that helps to identify predictions with RoI in case of multi-step pipelines +* `prediction_type` - denoting parent model type #### `DetectionOffset` This step is responsible for applying fixed offset on width and height of detections. @@ -484,6 +491,7 @@ This step is responsible for applying fixed offset on width and height of detect * `image` - size of input image, that `predictions` coordinates refers to * `parent_id` - identifier of parent image / associated detection that helps to identify predictions with RoI in case of multi-step pipelines +* `prediction_type` - denoting parent model type #### `AbsoluteStaticCrop` and `RelativeStaticCrop` @@ -596,6 +604,53 @@ of multi-step pipelines (can be `undefined` if all sources of predictions give n objects specified in config are present * `presence_confidence` - for each input image, for each present class - aggregated confidence indicating presence of objects +* `prediction_type` - denoting `object-detection` prediction (as this format is effective even if other detections +models are combined) + +#### `ActiveLearningDataCollector` +Step that is supposed to be a solution for anyone who wants to collect data and predictions that flow through the +`workflows`. The block is build on the foundations of Roboflow Active Learning capabilities implemented in +[`active_learning` module](../../core/active_learning/README.md) - so all the capabilities should be preserved. +There are **very important** considerations regarding collecting data with AL at the `workflows` level and in +scope of specific models. Read `important notes` section to discover nuances. +General use-cases for this block: +* grab data and predictions from single model / ensemble of models +* posting the data in different project that the origin of models used in `workflow` - in particular **one may now use +open models - like `yolov8n-640` and start sampling data to their own project!** +* defining multiple different sampling strategies for different `workflows` (step allows to provide custom config of AL +data collection - so you are not bounded to configuration of AL at the project level - and multiple instances of +configs can co-exist) + +##### Step parameters +* `type`: must be `ActiveLearningDataCollector` (required) +* `name`: must be unique within all steps - used as identifier (required) +* `image`: must be a reference to input of type `InferenceImage` or `crops` output from steps executing cropping ( +`Crop`, `AbsoluteStaticCrop`, `RelativeStaticCrop`) (required) +* `predictions` - selector pointing to outputs of detections models output of the detections model: [`ObjectDetectionModel`, +`KeypointsDetectionModel`, `InstanceSegmentationModel`, `DetectionFilter`, `DetectionsConsensus`] (then use `$steps..predictions`) +or outputs of classification [`ClassificationModel`] (then use `$steps..top`) (required) +* `target_dataset` - name of Roboflow dataset / project to be used as target for collected data (required) +* `target_dataset_api_key` - optional API key to be used for data registration. This may help in a scenario when data +are to be registered cross-workspaces. If not provided - the API key from a request would be used to register data ( +applicable for Universe models predictions to be saved in private workspaces and for models that were trained in the same +workspace (not necessarily within the same project)). +* `disable_active_learning` - boolean flag that can be also reference to input - to arbitrarily disable data collection +for specific request - overrides all AL config. (optional, default: `False`) +* `active_learning_configuration` - optional configuration of Active Learning data sampling in the exact format provided +in [`active_learning` docs](../../core/active_learning/README.md) + +##### Step outputs +No outputs are declared - step is supposed to cause side effect in form of data sampling and registration. + +##### Important notes +* this block is implemented in non-async way - which means that in certain cases it can block event loop causing +parallelization not feasible. This is not the case when running in `inference` HTTP container. At Roboflow +hosted platform - registration cannot be executed as background task - so its duration must be added into expected +latency +* **important :exclamation:** be careful in enabling / disabling AL at the level of steps - remember that when +predicting from each model, `inference` HTTP API tries to get Active Learning config from the project that model +belongs to and register datapoint. To prevent that from happening - model steps can be provided with +`disable_active_learning=True` parameter. Then the only place where AL registration happens is `ActiveLearningDataCollector`. ## Different modes of execution Workflows can be executed in `local` environment, or `remote` environment can be used. `local` means that model steps diff --git a/inference/enterprise/workflows/entities/steps.py b/inference/enterprise/workflows/entities/steps.py index c0643d0d0..f7baebff1 100644 --- a/inference/enterprise/workflows/entities/steps.py +++ b/inference/enterprise/workflows/entities/steps.py @@ -668,7 +668,7 @@ def get_input_names(self) -> Set[str]: return {"predictions", "offset_x", "offset_y"} def get_output_names(self) -> Set[str]: - return {"predictions", "parent_id", "image", "predictions_type"} + return {"predictions", "parent_id", "image", "prediction_type"} def validate_field_selector( self, field_name: str, input_step: GraphNone, index: Optional[int] = None From b227529efee2f637468a9f4a029805d1ace702b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 17:26:10 +0100 Subject: [PATCH 17/18] Add changes to notebook to illustrate AL usage: --- examples/notebooks/workflows.ipynb | 165 ++++++++++++++++++++++++++--- 1 file changed, 149 insertions(+), 16 deletions(-) diff --git a/examples/notebooks/workflows.ipynb b/examples/notebooks/workflows.ipynb index 6ba7669cd..0094409b7 100644 --- a/examples/notebooks/workflows.ipynb +++ b/examples/notebooks/workflows.ipynb @@ -81,16 +81,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2024-02-14 13:51:16-- https://media.roboflow.com/workflows_examples_images.zip\n", + "--2024-02-14 16:23:28-- https://media.roboflow.com/workflows_examples_images.zip\n", "Resolving media.roboflow.com (media.roboflow.com)... 34.110.133.209\n", "Connecting to media.roboflow.com (media.roboflow.com)|34.110.133.209|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 8229834 (7.8M) [application/zip]\n", "Saving to: ‘workflows_examples_images.zip’\n", "\n", - "workflows_examples_ 100%[===================>] 7.85M 10.7MB/s in 0.7s \n", + "workflows_examples_ 100%[===================>] 7.85M 19.2MB/s in 0.4s \n", "\n", - "2024-02-14 13:51:17 (10.7 MB/s) - ‘workflows_examples_images.zip’ saved [8229834/8229834]\n", + "2024-02-14 16:23:28 (19.2 MB/s) - ‘workflows_examples_images.zip’ saved [8229834/8229834]\n", "\n" ] } @@ -223,7 +223,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -738,7 +738,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 28, "id": "7d7c3db9-c690-4139-8584-2b150594a1a0", "metadata": {}, "outputs": [], @@ -748,7 +748,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 29, "id": "7a08d122-7959-474f-8857-503bbd4281df", "metadata": {}, "outputs": [ @@ -770,7 +770,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 30, "id": "d66a4b8e-8353-4a10-928a-24d00e70f13a", "metadata": {}, "outputs": [], @@ -791,7 +791,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 31, "id": "6ce81674-4cdc-4074-a39a-c61b1188076b", "metadata": {}, "outputs": [ @@ -827,7 +827,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 32, "id": "27e8f8c5-48d4-47d5-a542-2101112f51ae", "metadata": {}, "outputs": [], @@ -869,7 +869,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 33, "id": "2b3516fe-74eb-4fe7-8ebd-9e3001a7b2d8", "metadata": {}, "outputs": [], @@ -880,7 +880,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 34, "id": "b7e0bc65-f05f-4ea0-8ef7-72b1939192ae", "metadata": {}, "outputs": [ @@ -902,7 +902,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 35, "id": "c189c354-8ec7-47b3-8751-1aae6806b6e4", "metadata": {}, "outputs": [], @@ -915,7 +915,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 36, "id": "4d9fad4a-7c59-42dd-bbc1-ebe6839e6aa7", "metadata": {}, "outputs": [ @@ -949,7 +949,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 37, "id": "2094f57e-676d-4ec1-9d03-7a89301dd783", "metadata": {}, "outputs": [ @@ -971,7 +971,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 38, "id": "1bf96383-9908-4f2f-90f8-e13ca0162174", "metadata": {}, "outputs": [], @@ -984,7 +984,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 39, "id": "546a10ac-b24c-43df-9d46-db24199918e8", "metadata": {}, "outputs": [ @@ -1015,6 +1015,139 @@ " plt.imshow(crop[\"value\"][:, :, ::-1])\n", " plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "50f0cadf-906a-4c2b-b572-6e9e9193e98a", + "metadata": {}, + "source": [ + "## Introduce Active Learning block\n", + "\n", + "In this example, we present on how to introduce Active Learning data collection block to the workflow. You would need to have example object-detection project created in Roboflow app ([docs](https://docs.roboflow.com/datasets/create-a-project))." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "d49fed0c-62a9-480d-a8cc-8015317275e4", + "metadata": {}, + "outputs": [], + "source": [ + "YOUR_PROJECT_NAME = ... # place your project" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "abb130ea-361b-4bf7-9a7a-132692009dec", + "metadata": {}, + "outputs": [], + "source": [ + "ACTIVE_LEARNING_WORKFLOW = {\n", + " \"specification\": {\n", + " \"version\": \"1.0\",\n", + " \"inputs\": [\n", + " { \"type\": \"InferenceImage\", \"name\": \"image\" },\n", + " ],\n", + " \"steps\": [\n", + " {\n", + " \"type\": \"ObjectDetectionModel\", # definition of object detection model - generic detection based on COCO classes\n", + " \"name\": \"general_detection\",\n", + " \"image\": \"$inputs.image\", # linking input image into detection model\n", + " \"model_id\": \"yolov8n-640\", # pointing model to be used\n", + " \"disable_active_learning\": True, # we are disabling Active Learning for model \n", + " # (it is advised to do so, when ActiveLearningDataCollector is in use)\n", + " },\n", + " {\n", + " \"type\": \"ActiveLearningDataCollector\", # definition of data collector block\n", + " \"name\": \"active_learning_block\",\n", + " \"image\": \"$inputs.image\", # we need to point image that is reference point for predictions\n", + " \"predictions\": \"$steps.general_detection.predictions\", # we need to point `predictions` output from detection model\n", + " \"target_dataset\": YOUR_PROJECT_NAME,\n", + " \"active_learning_configuration\": { # this is standard AL data collection config - see: https://inference.roboflow.com/enterprise/active-learning/active_learning/\n", + " \"enabled\": True,\n", + " \"persist_predictions\": True,\n", + " \"sampling_strategies\": [\n", + " {\n", + " \"type\": \"random\",\n", + " \"name\": \"a\",\n", + " \"traffic_percentage\": 1.0,\n", + " \"limits\": [{\"type\": \"daily\", \"value\": 100}],\n", + " },\n", + " ],\n", + " \"batching_strategy\": {\n", + " \"batches_name_prefix\": \"al_in_workflows\",\n", + " \"recreation_interval\": \"daily\"\n", + " }\n", + " }\n", + " }\n", + " ],\n", + " \"outputs\": [\n", + " { \"type\": \"JsonField\", \"name\": \"predictions\", \"selector\": \"$steps.general_detection.predictions\" },\n", + " ] \n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "b41e5216-0759-426c-9e5e-cc668b955343", + "metadata": {}, + "outputs": [], + "source": [ + "al_results = CLIENT.infer_from_workflow(\n", + " specification=ACTIVE_LEARNING_WORKFLOW[\"specification\"],\n", + " images={\"image\": multiple_cars_image_2},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "20badcd1-7650-4ec3-b6bc-67c25fb74664", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'predictions': [[{'x': 2363.5,\n", + " 'y': 3634.0,\n", + " 'width': 1283.0,\n", + " 'height': 840.0,\n", + " 'confidence': 0.8711808919906616,\n", + " 'class': 'car',\n", + " 'class_id': 2,\n", + " 'detection_id': '8c5602f6-1c76-4d92-a729-db3a38cc9061',\n", + " 'parent_id': '$inputs.image'},\n", + " {'x': 3205.5,\n", + " 'y': 3682.0,\n", + " 'width': 493.0,\n", + " 'height': 746.0,\n", + " 'confidence': 0.7880513668060303,\n", + " 'class': 'car',\n", + " 'class_id': 2,\n", + " 'detection_id': 'ef9482d0-de3d-425e-a406-0a2018c03166',\n", + " 'parent_id': '$inputs.image'},\n", + " {'x': 1026.5,\n", + " 'y': 3615.0,\n", + " 'width': 1197.0,\n", + " 'height': 914.0,\n", + " 'confidence': 0.7465572953224182,\n", + " 'class': 'car',\n", + " 'class_id': 2,\n", + " 'detection_id': '7eaeefd0-1b31-4346-80c0-713f6fd7f44c',\n", + " 'parent_id': '$inputs.image'}]]}" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "al_results" + ] } ], "metadata": { From 85e2eadf0d0a32c53996b17c24fda076491c746b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20P=C4=99czek?= Date: Wed, 14 Feb 2024 17:30:50 +0100 Subject: [PATCH 18/18] Update dosc --- inference/enterprise/workflows/README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/inference/enterprise/workflows/README.md b/inference/enterprise/workflows/README.md index 677738cf3..c425fa268 100644 --- a/inference/enterprise/workflows/README.md +++ b/inference/enterprise/workflows/README.md @@ -651,6 +651,9 @@ latency predicting from each model, `inference` HTTP API tries to get Active Learning config from the project that model belongs to and register datapoint. To prevent that from happening - model steps can be provided with `disable_active_learning=True` parameter. Then the only place where AL registration happens is `ActiveLearningDataCollector`. +* **important :exclamation:** be careful with names of sampling strategies if you define Active Learning configuration - +you should keep them unique not only within a single config, but globally in project - otherwise limits accounting may +not work well ## Different modes of execution Workflows can be executed in `local` environment, or `remote` environment can be used. `local` means that model steps