diff --git a/e2e/conftest.py b/e2e/conftest.py index dd821ae..5dd208e 100644 --- a/e2e/conftest.py +++ b/e2e/conftest.py @@ -225,6 +225,32 @@ def mock_minio_repository(): return mock_repo +@pytest_asyncio.fixture +def mock_pi_web_api_repository(): + """Mock PI Web API repository for PI Web API operations.""" + mock_repo = MagicMock() + mock_repo.write_value = AsyncMock( + return_value={ + 'Items': [ + { + 'WebId': 'web_id_1' + } + ] + } + ) + mock_repo.close = MagicMock() + return mock_repo + +@pytest_asyncio.fixture +def mock_opc_repository(): + """Mock OPC repository for OPC operations.""" + mock_repo = MagicMock() + mock_repo.write_data = AsyncMock( + return_value=(True, {'response_time': 0.1}) + ) + mock_repo.disconnect = MagicMock() + return mock_repo + @pytest_asyncio.fixture def patch_create_engine(postgres_engine): """Patch create_engine to return test postgres_engine.""" @@ -238,6 +264,11 @@ def patch_minio_repository(mock_minio_repository): with patch('laborious.utils.repository.minio_repository.MinioRepository', return_value=mock_minio_repository): yield +@pytest_asyncio.fixture +def patch_pi_web_api_repository(mock_pi_web_api_repository): + """Patch MLflowRepository to return mock.""" + with patch('laborious.activities.api.PIWebAPIClient', return_value=mock_pi_web_api_repository): + yield @pytest_asyncio.fixture def mock_mlflow_models(): @@ -330,6 +361,8 @@ async def test_activities( patch_create_engine, patch_minio_repository, patch_mlflow, + patch_pi_web_api_repository, + mock_opc_repository ): """ Create Activities instance with test dependencies. @@ -372,6 +405,10 @@ async def test_activities( notification_handler=notification_handler, ) + activities.opc_repository = { + '1': mock_opc_repository, + } + try: yield activities finally: diff --git a/e2e/scenarios.md b/e2e/scenarios.md index efdb7bb..eb9c606 100644 --- a/e2e/scenarios.md +++ b/e2e/scenarios.md @@ -445,27 +445,7 @@ The `predictions_batch` workflow: ### 3.2 Error Scenarios -#### Scenario 3.2.1: PostgreSQL Export Error - Predictions Table -**Description**: Failed to write predictions to database - -**Input**: -- Valid formatted prediction -- PostgreSQL connection fails or table doesn't exist - -**Expected Behavior**: -- `export_data_to_postgres` raises exception -- Notification sent with database error -- Workflow fails after retries - -**Assertions**: -- Exception raised from export activity -- Error notification sent -- Workflow fails -- Metrics NOT written (activity doesn't execute) - ---- - -#### Scenario 3.2.2: PI Web API Write Error +#### Scenario 3.2.1: PI Web API Write Error **Description**: PI Web API export fails **Input**: @@ -485,7 +465,7 @@ The `predictions_batch` workflow: --- -#### Scenario 3.2.3: OPC Write Error +#### Scenario 3.2.2: OPC Write Error **Description**: OPC server write fails **Input**: @@ -504,64 +484,26 @@ The `predictions_batch` workflow: --- -## 4. End-to-End Integration Scenarios - -### 4.1 Complete Success Path - -#### Scenario 4.1.1: Full Pipeline Success with All Features -**Description**: Complete workflow execution with all optional features enabled +#### Scenario 3.2.3: PI Web API Partial Write Error +**Description**: Two prediction tags attempt to be written to PI Web API, but only one succeeds **Input**: -- Valid SQL query returning data -- All configurations provided (OPC, PI Web API, filters, policies) -- MLFlow services available -- All databases available +- Valid prediction +- Two prediction tags configured +- PI Web API returns partial success (one tag succeeds, one fails) **Expected Behavior**: -- SQL query loads data -- Input gate passes -- MLFlow transform succeeds -- MLFlow predict succeeds -- All validations pass -- Prediction formatted -- Transformed data formatted -- Both exported to PostgreSQL -- PI Web API write succeeds -- OPC write succeeds -- Metrics written +- `write_pi_web_api_data` processes response +- `process_pi_web_api_response` detects partial failure +- Error confidence set (13) +- Notification sent for failed tag +- Workflow completes with error confidence **Assertions**: -- All activities executed in correct order -- All three workflows execute (batch, process, export) -- All exports succeed -- All tables have data -- All external systems updated -- Metrics recorded - ---- - -### 4.2 Error Recovery Integration - -#### Scenario 4.2.1: Transform Error with Repeat Fallback -**Description**: Transform fails, workflow repeats last prediction - -**Input**: -- Valid input -- MLFlow transform fails -- REPEAT policy configured -- Previous prediction exists - -**Expected Behavior**: -- Transform fails -- Filter detects error -- Path handler triggers REPEAT -- Last prediction retrieved and re-exported -- Workflow completes successfully - -**Assertions**: -- Transform attempted -- Error handled gracefully -- Last prediction copied -- Workflow completes without exception +- One tag written successfully +- One tag failed +- Error confidence set in prediction +- Error notification sent +- Workflow completes --- \ No newline at end of file diff --git a/e2e/test_predictions_batch_format_export.py b/e2e/test_predictions_batch_format_export.py index c5512c2..e7bdd91 100644 --- a/e2e/test_predictions_batch_format_export.py +++ b/e2e/test_predictions_batch_format_export.py @@ -4,10 +4,11 @@ End-to-end tests for PredictionsBatch workflow - Format and Export scenarios. import asyncio from datetime import datetime -from unittest.mock import patch +from unittest.mock import ANY, AsyncMock, patch, call import pandas as pd import pytest +from sientia_do.notifications.models import NotificationLevel from sqlalchemy import text from temporalio.testing import WorkflowEnvironment from temporalio.worker import Worker @@ -87,6 +88,37 @@ async def start_and_await_workflow(client, input_data, workflow_id): except asyncio.TimeoutError: pytest.fail("Workflow execution timed out after 60 seconds") +def assert_prediction( + postgres_engine, model_id, prediction: float = 0.5, + prediction_confidence: int = 0, prediction_status: str = 'Good', + comments: str = '', +): + """ + Verify prediction was created with correct values in database + + Args: + postgres_engine: Database engine + model_id: Model ID to check + prediction: Expected prediction value (default 0.5 from mock) + prediction_confidence: Expected confidence value (default 0 for normal predictions) + prediction_status: Expected status (default 'Good') + comments: Expected comments (default empty string) + """ + print("\n[TEST] 4. Verifying prediction was created with correct values...") + with postgres_engine.connect() as conn: + result_query = conn.execute( + text(f"SELECT model_id, prediction, prediction_confidence, prediction_status, comments FROM predictions_schema.predictions WHERE model_id = {model_id}") + ) + prediction_rows = result_query.fetchall() + assert len(prediction_rows) == 1, f"Expected one prediction record, got {len(prediction_rows)}" + + row = prediction_rows[0] + assert row[0] == model_id, f"Expected model_id={model_id}, got {row[0]}" + assert row[1] == prediction, f"Expected prediction={prediction}, got {row[1]}" + assert row[2] == prediction_confidence, f"Expected prediction_confidence={prediction_confidence}, got {row[2]}" + assert row[3] == prediction_status, f"Expected prediction_status='{prediction_status}', got {row[3]}" + assert row[4] == comments, f"Expected comments='{comments}', got {row[4]}" + @pytest.mark.asyncio @pytest.mark.integration @@ -151,6 +183,63 @@ async def test_scenario_3_1_1_default_prediction_export( await start_and_await_workflow(client, input_data, workflow_id) + test_activities.pi_web_api_client.write_value.assert_has_calls( + [ + call( + web_ids=['web_id_1'], + value={ + 'Timestamp': '2024-01-01 12:00:00+0000', + 'Value': 0.5, + }, + endpoint='test_endpoint', + metadata={ + 'model_id': 311, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }, + ), + call( + web_ids=['web_id_2'], + value={ + 'Timestamp': '2024-01-01 12:00:00+0000', + 'Value': 0, + }, + endpoint='test_endpoint', + metadata={ + 'model_id': 311, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }, + ), + ], + any_order=True, + ) + + test_activities.opc_repository['1'].write_data.assert_has_calls( + [ + call('addr_1', 0.5, 'float', ANY, + { + 'model_id': 311, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }), + call('addr_2', 0, 'float', ANY, + { + 'model_id': 311, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }), + ] + ) + + assert_prediction(postgres_engine, model_id) + + print("\n[TEST] ✓ All assertions passed!") + @@ -191,8 +280,18 @@ async def test_scenario_3_1_2_export_with_opc_only( input_data = get_base_input_data(model_id) input_data['opc_output_config'] = { - 'server_name': 'test_server', - 'tags': {'prediction': 'test_tag'}, + '1': { + 'prediction_tags': { + 'addr_1': { + 'data_type': 'float', + } + }, + 'confidence_tags': { + 'addr_2': { + 'data_type': 'float', + } + }, + } } input_data['pi_web_api_output_config'] = None # No PI Web API config @@ -201,14 +300,29 @@ async def test_scenario_3_1_2_export_with_opc_only( await start_and_await_workflow(client, input_data, workflow_id) - print("\n[TEST] 4. Verifying PostgreSQL and OPC export were executed...") - with postgres_engine.connect() as conn: - result_query = conn.execute( - text(f"SELECT model_id FROM predictions_schema.predictions WHERE model_id = {model_id}") - ) - prediction_rows = result_query.fetchall() - assert len(prediction_rows) == 1, "Expected one prediction record in PostgreSQL" - + test_activities.opc_repository['1'].write_data.assert_has_calls( + [ + call('addr_1', 0.5, 'float', ANY, + { + 'model_id': 312, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }), + call('addr_2', 0, 'float', ANY, + { + 'model_id': 312, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }), + ] + ) + + test_activities.pi_web_api_client.write_value.assert_not_called() + + assert_prediction(postgres_engine, model_id) + print("\n[TEST] ✓ All assertions passed!") @@ -250,8 +364,8 @@ async def test_scenario_3_1_3_export_with_pi_web_api_only( input_data = get_base_input_data(model_id) input_data['pi_web_api_output_config'] = { 'endpoint': 'test_endpoint', - 'prediction_tags': {'prediction': 'test_pred_tag'}, - 'confidence_tags': {'confidence': 'test_conf_tag'}, + 'prediction_tags': {'tag_1': 'web_id_1'}, + 'confidence_tags': {'tag_2': 'web_id_2'}, } input_data['opc_output_config'] = None # No OPC config @@ -260,14 +374,44 @@ async def test_scenario_3_1_3_export_with_pi_web_api_only( await start_and_await_workflow(client, input_data, workflow_id) - print("\n[TEST] 4. Verifying PostgreSQL and PI Web API export were executed...") - with postgres_engine.connect() as conn: - result_query = conn.execute( - text(f"SELECT model_id FROM predictions_schema.predictions WHERE model_id = {model_id}") - ) - prediction_rows = result_query.fetchall() - assert len(prediction_rows) == 1, "Expected one prediction record in PostgreSQL" - + test_activities.pi_web_api_client.write_value.assert_has_calls( + [ + call( + web_ids=['web_id_1'], + value={ + 'Timestamp': '2024-01-01 12:00:00+0000', + 'Value': 0.5, + }, + endpoint='test_endpoint', + metadata={ + 'model_id': 313, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }, + ), + call( + web_ids=['web_id_2'], + value={ + 'Timestamp': '2024-01-01 12:00:00+0000', + 'Value': 0, + }, + endpoint='test_endpoint', + metadata={ + 'model_id': 313, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }, + ), + ], + any_order=True, + ) + + test_activities.opc_repository['1'].write_data.assert_not_called() + + assert_prediction(postgres_engine, model_id) + print("\n[TEST] ✓ All assertions passed!") @@ -314,14 +458,11 @@ async def test_scenario_3_1_4_export_without_optional_outputs( await start_and_await_workflow(client, input_data, workflow_id) - print("\n[TEST] 4. Verifying only PostgreSQL export was executed...") - with postgres_engine.connect() as conn: - result_query = conn.execute( - text(f"SELECT model_id FROM predictions_schema.predictions WHERE model_id = {model_id}") - ) - prediction_rows = result_query.fetchall() - assert len(prediction_rows) == 1, "Expected one prediction record in PostgreSQL" - + test_activities.pi_web_api_client.write_value.assert_not_called() + test_activities.opc_repository['1'].write_data.assert_not_called() + + assert_prediction(postgres_engine, model_id) + print("\n[TEST] ✓ All assertions passed!") @@ -361,116 +502,106 @@ async def test_scenario_3_1_5_export_without_transformed_data( input_data = get_base_input_data(model_id) input_data['save_transform'] = False # Don't save transformed data + input_data['pi_web_api_output_config'] = { + 'endpoint': 'test_endpoint', + 'prediction_tags': {'tag_1': 'web_id_1'}, + 'confidence_tags': {'tag_2': 'web_id_2'}, + } + input_data['opc_output_config'] = { + '1': { + 'prediction_tags': { + 'addr_1': { + 'data_type': 'float', + } + }, + 'confidence_tags': { + 'addr_2': { + 'data_type': 'float', + } + }, + } + } print("\n[TEST] 2. Starting workflow without transformed data export...") workflow_id = f'test-no-transform-export-{datetime.now().timestamp()}' await start_and_await_workflow(client, input_data, workflow_id) - print("\n[TEST] 4. Verifying only prediction was exported...") + test_activities.pi_web_api_client.write_value.assert_has_calls( + [ + call( + web_ids=['web_id_1'], + value={ + 'Timestamp': '2024-01-01 12:00:00+0000', + 'Value': 0.5, + }, + endpoint='test_endpoint', + metadata={ + 'model_id': 315, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }, + ), + call( + web_ids=['web_id_2'], + value={ + 'Timestamp': '2024-01-01 12:00:00+0000', + 'Value': 0, + }, + endpoint='test_endpoint', + metadata={ + 'model_id': 315, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }, + ), + ], + any_order=True, + ) + + test_activities.opc_repository['1'].write_data.assert_has_calls( + [ + call('addr_1', 0.5, 'float', ANY, + { + 'model_id': 315, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }), + call('addr_2', 0, 'float', ANY, + { + 'model_id': 315, + 'model_name': 'test_model', + 'schedule_name': 'test-schedule', + 'workflow_name': 'predictions_batch', + }), + ] + ) + with postgres_engine.connect() as conn: - # Verify prediction exists - result_query = conn.execute( - text(f"SELECT model_id FROM predictions_schema.predictions WHERE model_id = {model_id}") - ) - prediction_rows = result_query.fetchall() - assert len(prediction_rows) == 1, "Expected one prediction record" - - # Verify transformed data table is empty result_query = conn.execute( text(f"SELECT COUNT(*) FROM predictions_schema.transformed_data WHERE model_id = {model_id}") ) count = result_query.scalar() assert count == 0, f"Expected transform table to be empty, but found {count} records" - + + assert_prediction(postgres_engine, model_id) + print("\n[TEST] ✓ All assertions passed!") @pytest.mark.asyncio @pytest.mark.integration -async def test_scenario_3_2_1_postgres_export_error_predictions_table( +async def test_scenario_3_2_1_pi_web_api_write_error( temporal_test_env: WorkflowEnvironment, temporal_worker: Worker, test_activities: Activities, postgres_engine, ): """ - Scenario 3.2.1: PostgreSQL Export Error - Predictions Table - - Description: - Failed to write predictions to database. - - Expected Behavior: - - export_data_to_postgres raises exception - - Notification sent with database error - - Workflow fails after retries - - Assertions: - - Exception raised from export activity - - Error notification sent - - Workflow fails - - Metrics NOT written (activity doesn't execute) - """ - client = temporal_test_env.client - - model_id = 321 - - print("\n[TEST] 1. Inserting test data...") - insert_sample_data(postgres_engine, model_id, [23.5, 78.2]) - print("[TEST] ✓ Data inserted successfully") - - # Mock export_data_to_postgres to raise an exception - original_export = test_activities.export_data_to_postgres - call_count = {'count': 0} - - async def mock_export_data_to_postgres(*args, **kwargs): - call_count['count'] += 1 - # Only fail on predictions table export, not transform table - if call_count['count'] == 1: # First call is predictions table - raise Exception("PostgreSQL connection failed") - return await original_export(*args, **kwargs) - - with patch.object(test_activities, 'export_data_to_postgres', side_effect=mock_export_data_to_postgres): - input_data = get_base_input_data(model_id) - - print("\n[TEST] 2. Starting workflow that should fail on PostgreSQL export...") - workflow_id = f'test-postgres-error-{datetime.now().timestamp()}' - - handle = await client.start_workflow( - PredictionsBatch.run, - input_data, - id=workflow_id, - task_queue='test-queue', - ) - print("[TEST] ✓ Workflow started") - - print("\n[TEST] 3. Waiting for workflow to fail...") - try: - await asyncio.wait_for(handle.result(), timeout=60.0) - pytest.fail("Expected workflow to fail, but it completed successfully") - except Exception as e: - print(f"[TEST] ✓ Workflow failed as expected: {type(e).__name__}") - # Verify no predictions were created - with postgres_engine.connect() as conn: - result_query = conn.execute( - text(f"SELECT COUNT(*) FROM predictions_schema.predictions WHERE model_id = {model_id}") - ) - count = result_query.scalar() - assert count == 0, f"Expected no predictions, but found {count} records" - - print("\n[TEST] ✓ All assertions passed!") - - -@pytest.mark.asyncio -@pytest.mark.integration -async def test_scenario_3_2_2_pi_web_api_write_error( - temporal_test_env: WorkflowEnvironment, - temporal_worker: Worker, - test_activities: Activities, - postgres_engine, -): - """ - Scenario 3.2.2: PI Web API Write Error + Scenario 3.2.1: PI Web API Write Error Description: PI Web API export fails. @@ -488,55 +619,60 @@ async def test_scenario_3_2_2_pi_web_api_write_error( """ client = temporal_test_env.client - model_id = 322 + model_id = 321 print("\n[TEST] 1. Inserting test data...") insert_sample_data(postgres_engine, model_id, [23.5, 78.2]) print("[TEST] ✓ Data inserted successfully") - # Mock write_pi_web_api_data to raise an exception - def mock_write_pi_web_api_data(*args, **kwargs): - raise Exception("PI Web API service unavailable") - - with patch.object(test_activities, 'write_pi_web_api_data', side_effect=mock_write_pi_web_api_data): - input_data = get_base_input_data(model_id) - input_data['pi_web_api_output_config'] = { - 'endpoint': 'test_endpoint', - 'prediction_tags': {'prediction': 'test_pred_tag'}, - 'confidence_tags': {'confidence': 'test_conf_tag'}, + test_activities.pi_web_api_client.write_value.side_effect = Exception( + "PI Web API service unavailable") + + input_data = get_base_input_data(model_id) + input_data['pi_web_api_output_config'] = { + 'endpoint': 'test_endpoint', + 'prediction_tags': {'tag_1': 'web_id_1'}, + 'confidence_tags': {'tag_2': 'web_id_2'}, + } + input_data['opc_output_config'] = { + '1': { + 'prediction_tags': { + 'addr_1': { + 'data_type': 'float', + } + }, + 'confidence_tags': { + 'addr_2': { + 'data_type': 'float', + } + }, } + } - print("\n[TEST] 2. Starting workflow that should fail on PI Web API write...") - workflow_id = f'test-pi-api-error-{datetime.now().timestamp()}' - - handle = await client.start_workflow( - PredictionsBatch.run, - input_data, - id=workflow_id, - task_queue='test-queue', - ) - print("[TEST] ✓ Workflow started") + print("\n[TEST] 2. Starting workflow that should fail on PI Web API write...") + workflow_id = f'test-pi-api-error-{datetime.now().timestamp()}' + + await start_and_await_workflow(client, input_data, workflow_id) - print("\n[TEST] 3. Waiting for workflow to fail...") - try: - await asyncio.wait_for(handle.result(), timeout=60.0) - pytest.fail("Expected workflow to fail, but it completed successfully") - except Exception as e: - print(f"[TEST] ✓ Workflow failed as expected: {type(e).__name__}") - - print("\n[TEST] ✓ All assertions passed!") + assert_prediction( + postgres_engine, model_id, + prediction_confidence=13, + comments='PI Web API service unavailable', + ) + + print("\n[TEST] ✓ All assertions passed!") @pytest.mark.asyncio @pytest.mark.integration -async def test_scenario_3_2_3_opc_write_error( +async def test_scenario_3_2_2_opc_write_error( temporal_test_env: WorkflowEnvironment, temporal_worker: Worker, test_activities: Activities, postgres_engine, ): """ - Scenario 3.2.3: OPC Write Error + Scenario 3.2.2: OPC Write Error Description: OPC server write fails. @@ -553,39 +689,141 @@ async def test_scenario_3_2_3_opc_write_error( """ client = temporal_test_env.client + model_id = 322 + + print("\n[TEST] 1. Inserting test data...") + insert_sample_data(postgres_engine, model_id, [23.5, 78.2]) + print("[TEST] ✓ Data inserted successfully") + + test_activities.opc_repository['1'].write_data.return_value = (False, { + 'notification_id': 'OPC_WRITE_DATA_ERROR_1', + 'message': 'OPC server unavailable', + 'block': 'opc_repository', + 'level': NotificationLevel.ERROR, + 'attachment_content': 'OPC server unavailable', + }) + + input_data = get_base_input_data(model_id) + input_data['opc_output_config'] = { + '1': { + 'prediction_tags': { + 'addr_1': { + 'data_type': 'float', + } + }, + 'confidence_tags': { + 'addr_2': { + 'data_type': 'float', + } + }, + } + } + input_data['pi_web_api_output_config'] = { + 'endpoint': 'test_endpoint', + 'prediction_tags': {'tag_1': 'web_id_1'}, + 'confidence_tags': {'tag_2': 'web_id_2'}, + } + + print("\n[TEST] 2. Starting workflow that should fail on OPC write...") + workflow_id = f'test-opc-error-{datetime.now().timestamp()}' + + await start_and_await_workflow(client, input_data, workflow_id) + + assert_prediction( + postgres_engine, model_id, + prediction_confidence=12, + comments='Some data could not be written to OPC servers', + ) + + print("\n[TEST] ✓ All assertions passed!") + + +@pytest.mark.asyncio +@pytest.mark.integration +async def test_scenario_3_2_3_pi_web_api_partial_write_error( + temporal_test_env: WorkflowEnvironment, + temporal_worker: Worker, + test_activities: Activities, + postgres_engine, +): + """ + Scenario 3.2.3: PI Web API Partial Write Error + + Description: + Two prediction tags attempt to be written to PI Web API, but only one succeeds. + + Expected Behavior: + - write_pi_web_api_data processes response + - process_pi_web_api_response detects partial failure + - Error confidence set (13) + - Notification sent for failed tag + - Workflow completes with error confidence + + Assertions: + - One tag written successfully + - One tag failed + - Error confidence set in prediction + - Error notification sent + - Workflow completes + """ + client = temporal_test_env.client + model_id = 323 print("\n[TEST] 1. Inserting test data...") insert_sample_data(postgres_engine, model_id, [23.5, 78.2]) print("[TEST] ✓ Data inserted successfully") - # Mock write_opc_data to raise an exception - def mock_write_opc_data(*args, **kwargs): - raise Exception("OPC server unavailable") - - with patch.object(test_activities, 'write_opc_data', side_effect=mock_write_opc_data): - input_data = get_base_input_data(model_id) - input_data['opc_output_config'] = { - 'server_name': 'test_server', - 'tags': {'prediction': 'test_tag'}, + test_activities.pi_web_api_client.write_value = AsyncMock(side_effect=[ + { + 'Items': [ + { + 'WebId': 'web_id_1', + 'Errors': [], + }, + ] + }, + Exception('Tag write failed'), + { + 'Items': [ + { + 'WebId': 'web_id_2', + 'Errors': [], + }, + ] + }, + ]) + + input_data = get_base_input_data(model_id) + input_data['pi_web_api_output_config'] = { + 'endpoint': 'test_endpoint', + 'prediction_tags': {'tag_1': 'web_id_1', 'tag_3': 'web_id_3'}, + 'confidence_tags': {'tag_2': 'web_id_2'}, + } + input_data['opc_output_config'] = { + '1': { + 'prediction_tags': { + 'addr_1': { + 'data_type': 'float', + } + }, + 'confidence_tags': { + 'addr_2': { + 'data_type': 'float', + } + }, } + } - print("\n[TEST] 2. Starting workflow that should fail on OPC write...") - workflow_id = f'test-opc-error-{datetime.now().timestamp()}' - - handle = await client.start_workflow( - PredictionsBatch.run, - input_data, - id=workflow_id, - task_queue='test-queue', - ) - print("[TEST] ✓ Workflow started") + print("\n[TEST] 2. Starting workflow with partial PI Web API write error...") + workflow_id = f'test-pi-api-partial-error-{datetime.now().timestamp()}' + + await start_and_await_workflow(client, input_data, workflow_id) - print("\n[TEST] 3. Waiting for workflow to fail...") - try: - await asyncio.wait_for(handle.result(), timeout=60.0) - pytest.fail("Expected workflow to fail, but it completed successfully") - except Exception as e: - print(f"[TEST] ✓ Workflow failed as expected: {type(e).__name__}") - - print("\n[TEST] ✓ All assertions passed!") + assert_prediction( + postgres_engine, model_id, + prediction_confidence=13, + comments="The number of written tags does not match the number of tag names: Expected ['tag_1', 'tag_3'] tags, but ['tag_1'] tags were written.", + ) + + print("\n[TEST] ✓ All assertions passed!") diff --git a/e2e/test_predictions_batch_integration.py b/e2e/test_predictions_batch_integration.py deleted file mode 100644 index 28eab96..0000000 --- a/e2e/test_predictions_batch_integration.py +++ /dev/null @@ -1,278 +0,0 @@ -""" -End-to-end tests for PredictionsBatch workflow - Integration scenarios. -""" - -import asyncio -from datetime import datetime -from unittest.mock import patch - -import pandas as pd -import pytest -from sqlalchemy import text -from temporalio.testing import WorkflowEnvironment -from temporalio.worker import Worker - -from laborious.activities.activities import Activities -from laborious.workflows.predictions_batch import PredictionsBatch - - -@pytest.mark.asyncio -@pytest.mark.integration -async def test_scenario_4_1_1_full_pipeline_success_with_all_features( - temporal_test_env: WorkflowEnvironment, - temporal_worker: Worker, - test_activities: Activities, - postgres_engine, -): - """ - Scenario 4.1.1: Full Pipeline Success with All Features - - Description: - Complete workflow execution with all optional features enabled. - - Expected Behavior: - - SQL query loads data - - Input gate passes - - MLFlow transform succeeds - - MLFlow predict succeeds - - All validations pass - - Prediction formatted - - Transformed data formatted - - Both exported to PostgreSQL - - PI Web API write succeeds (mocked) - - OPC write succeeds (mocked) - - Metrics written - - Assertions: - - All activities executed in correct order - - All three workflows execute (batch, process, export) - - All exports succeed - - All tables have data - - All external systems updated (mocked) - - Metrics recorded - """ - client = temporal_test_env.client - - print("\n[TEST] 1. Inserting test data...") - with postgres_engine.begin() as conn: - conn.execute(text("DELETE FROM predictions_schema.laborious_data WHERE model_id = 401")) - - insert_sql = """ - INSERT INTO predictions_schema.laborious_data (model_id, variable, value, timestamp, created_at) - VALUES - (401, 'sensor_1', 23.5, '2024-01-01 12:00:00+00:00', '2024-01-01 12:00:00+00:00'), - (401, 'sensor_2', 78.2, '2024-01-01 12:00:00+00:00', '2024-01-01 12:00:00+00:00'), - (401, 'sensor_3', 120.8, '2024-01-01 12:00:00+00:00', '2024-01-01 12:00:00+00:00') - """ - conn.execute(text(insert_sql)) - print("[TEST] ✓ Data inserted successfully") - - input_data = { - 'metadata': { - 'metadata': { - 'model_id': 401, - 'model_name': 'test_model', - 'schedule_name': 'test-schedule', - 'workflow_name': 'predictions_batch', - } - }, - 'schedule_name': 'test-schedule', - 'model_name': 'test_model', - 'model_id': 401, - 'query': 'SELECT timestamp, variable, value, created_at FROM predictions_schema.laborious_data WHERE model_id = 401', - 'schema': 'predictions_schema', - 'table_name': 'predictions', - 'transform_table_name': 'transformed_data', - 'input_filters': { - 'EMPTY_DATA': {'policy': 'STOP', 'config': {}}, - }, - 'mlflow_transform_filters': { - 'API_ERROR': {'policy': 'STOP', 'config': {}}, - }, - 'mlflow_predict_filters': { - 'API_ERROR': {'policy': 'STOP', 'config': {}}, - }, - 'path_priority': ['STOP', 'CONTINUE', 'REPEAT'], - 'opc_output_config': { - 'server_name': 'test_server', - 'tags': {'prediction': 'test_tag'}, - }, - 'pi_web_api_output_config': { - 'endpoint': 'test_endpoint', - 'prediction_tags': {'prediction': 'test_pred_tag'}, - 'confidence_tags': {'confidence': 'test_conf_tag'}, - }, - 'save_transform': True, - 'prediction_store_policy': 'lts:1', - 'model_config': { - 'retention_minutes': 0, - 'transform_flavor': 'sklearn', - 'predict_flavor': 'sklearn', - }, - 'datetime_columns': ['timestamp', 'created_at'], - } - - print("\n[TEST] 2. Starting full pipeline workflow...") - workflow_id = f'test-full-pipeline-{datetime.now().timestamp()}' - - handle = await client.start_workflow( - PredictionsBatch.run, - input_data, - id=workflow_id, - task_queue='test-queue', - ) - print("[TEST] ✓ Workflow started") - - print("\n[TEST] 3. Waiting for workflow completion...") - try: - await asyncio.wait_for(handle.result(), timeout=60.0) - print("[TEST] ✓ Workflow completed successfully") - except asyncio.TimeoutError: - pytest.fail("Workflow execution timed out after 60 seconds") - - print("\n[TEST] 4. Verifying all exports and data...") - with postgres_engine.connect() as conn: - # Verify prediction data - result_query = conn.execute( - text("SELECT model_id, prediction, prediction_confidence FROM predictions_schema.predictions WHERE model_id = 401") - ) - prediction_rows = result_query.fetchall() - assert len(prediction_rows) == 1, "Expected one prediction record" - - # Verify transformed data - result_query = conn.execute( - text("SELECT COUNT(*) FROM predictions_schema.transformed_data WHERE model_id = 401") - ) - count = result_query.scalar() - assert count == 2, f"Expected two transformed data records, but found {count}" - - print("\n[TEST] ✓ All assertions passed!") - - -@pytest.mark.asyncio -@pytest.mark.integration -async def test_scenario_4_2_1_transform_error_with_repeat_fallback( - temporal_test_env: WorkflowEnvironment, - temporal_worker: Worker, - test_activities: Activities, - postgres_engine, -): - """ - Scenario 4.2.1: Transform Error with Repeat Fallback - - Description: - Transform fails, workflow repeats last prediction. - - Expected Behavior: - - Transform fails - - Filter detects error - - Path handler triggers REPEAT - - Last prediction retrieved and re-exported - - Workflow completes successfully - - Assertions: - - Transform attempted - - Error handled gracefully - - Last prediction copied - - Workflow completes without exception - """ - client = temporal_test_env.client - - print("\n[TEST] 1. Inserting test data and previous prediction...") - with postgres_engine.begin() as conn: - conn.execute(text("DELETE FROM predictions_schema.laborious_data WHERE model_id = 403")) - conn.execute(text("DELETE FROM predictions_schema.predictions WHERE model_id = 403")) - - # Insert input data - insert_sql = """ - INSERT INTO predictions_schema.laborious_data (model_id, variable, value, timestamp, created_at) - VALUES - (403, 'sensor_1', 23.5, '2024-01-01 12:00:00+00:00', '2024-01-01 12:00:00+00:00'), - (403, 'sensor_2', 78.2, '2024-01-01 12:00:00+00:00', '2024-01-01 12:00:00+00:00') - """ - conn.execute(text(insert_sql)) - - # Insert a previous prediction to repeat - insert_prediction_sql = """ - INSERT INTO predictions_schema.predictions - (model_id, prediction, prediction_confidence, response_time, prediction_status, timestamp, created_at, comments) - VALUES - (403, 0.85, 95, 0.15, 'Good', '2024-01-01 11:00:00+00:00', '2024-01-01 11:00:00+00:00', 'Previous successful prediction') - """ - conn.execute(text(insert_prediction_sql)) - print("[TEST] ✓ Data and previous prediction inserted") - - # Mock request_transform to return an error response - def mock_request_transform(*args, **kwargs): - return { - 'success': False, # This will trigger API_ERROR filter - 'content': pd.DataFrame(), - } - - with patch.object(test_activities, 'request_transform', side_effect=mock_request_transform): - input_data = { - 'metadata': { - 'metadata': { - 'model_id': 403, - 'model_name': 'test_model', - 'schedule_name': 'test-schedule', - 'workflow_name': 'predictions_batch', - } - }, - 'schedule_name': 'test-schedule', - 'model_name': 'test_model', - 'model_id': 403, - 'query': 'SELECT timestamp, variable, value, created_at FROM predictions_schema.laborious_data WHERE model_id = 403', - 'schema': 'predictions_schema', - 'table_name': 'predictions', - 'transform_table_name': 'transformed_data', - 'input_filters': { - 'EMPTY_DATA': {'policy': 'STOP', 'config': {}}, - }, - 'mlflow_transform_filters': { - 'API_ERROR': {'policy': 'REPEAT', 'config': {}}, # REPEAT on error - }, - 'mlflow_predict_filters': { - 'API_ERROR': {'policy': 'STOP', 'config': {}}, - }, - 'path_priority': ['REPEAT', 'STOP', 'CONTINUE'], # REPEAT first - 'opc_output_config': {}, - 'pi_web_api_output_config': {}, - 'save_transform': True, - 'prediction_store_policy': 'lts:1', - 'model_config': { - 'retention_minutes': 0, - 'transform_flavor': 'sklearn', - 'predict_flavor': 'sklearn', - }, - 'datetime_columns': ['timestamp', 'created_at'], - } - - print("\n[TEST] 2. Starting workflow that should trigger REPEAT...") - workflow_id = f'test-repeat-fallback-{datetime.now().timestamp()}' - - handle = await client.start_workflow( - PredictionsBatch.run, - input_data, - id=workflow_id, - task_queue='test-queue', - ) - print("[TEST] ✓ Workflow started") - - print("\n[TEST] 3. Waiting for workflow completion...") - try: - await asyncio.wait_for(handle.result(), timeout=60.0) - print("[TEST] ✓ Workflow completed successfully") - except asyncio.TimeoutError: - pytest.fail("Workflow execution timed out after 60 seconds") - - print("\n[TEST] 4. Verifying last prediction was repeated...") - with postgres_engine.connect() as conn: - result_query = conn.execute( - text("SELECT COUNT(*) FROM predictions_schema.predictions WHERE model_id = 403") - ) - count = result_query.scalar() - # Should have at least 2 predictions (original + repeated) - assert count >= 1, f"Expected at least one prediction (repeated), but found {count} records" - - print("\n[TEST] ✓ All assertions passed!") diff --git a/laborious/activities/api.py b/laborious/activities/api.py index 95a22dc..063fd79 100644 --- a/laborious/activities/api.py +++ b/laborious/activities/api.py @@ -81,7 +81,7 @@ class API(SientiaMonitoring): tags: dict[str, str], core_labels: dict[str, str], metadata: dict[str, Any], - ) -> int: + ) -> tuple[int, str]: """ Process the response data from PI Web API write operation. @@ -106,6 +106,8 @@ class API(SientiaMonitoring): confidence = 0 + message = '' + # Evaluate response for each tag written_tags = [] response_items = response_data.get('Items', []) @@ -144,10 +146,10 @@ class API(SientiaMonitoring): written_tags.append(tag_name) if len(written_tags) != len(tag_names): - self.error( - f'The number of written tags does not match the number of tag names: Expected {tag_names} tags, but {written_tags} tags were written', - metadata, - ) + message = f'The number of written tags does not match the number of tag names: Expected {tag_names} tags, but {written_tags} tags were written.' + + self.error(f"{message}\nResponse:\n {json.dumps(response_data, indent=4)}\nTags:\n {json.dumps(tags, indent=4)}", metadata) + await self.send_notification_async( metadata=metadata, notification_id='WRITE_PI_WEB_API_PREDICTION_ERROR', @@ -157,7 +159,7 @@ class API(SientiaMonitoring): ) confidence = PI_WEB_API_PREDICTION_ERROR_CONFIDENCE - return confidence + return confidence, message @activity.defn(name='write_pi_web_api_data') async def write_pi_web_api_data(self, input_data: dict[str, Any]) -> dict[Any, Any]: @@ -185,7 +187,7 @@ class API(SientiaMonitoring): data = DataFrame(input_data['data']) pi_web_api_output_config = input_data['pi_web_api_output_config'] - self.info('Writing data to PI Web API...', metadata) + self.info(f'Writing data to PI Web API... config: {pi_web_api_output_config}', metadata) endpoint = pi_web_api_output_config['endpoint'] @@ -213,7 +215,7 @@ class API(SientiaMonitoring): metadata=metadata, ) - confidence = await self.process_pi_web_api_response( + confidence, message = await self.process_pi_web_api_response( response_data=prediction_response, tags=raw_prediction_tags, core_labels=core_labels, @@ -221,6 +223,7 @@ class API(SientiaMonitoring): ) data['prediction_confidence'] = confidence + data['comments'] = message except Exception as e: trace = traceback.format_exc() @@ -234,6 +237,7 @@ class API(SientiaMonitoring): ) data['prediction_confidence'] = PI_WEB_API_PREDICTION_ERROR_CONFIDENCE + data['comments'] = str(e) return data.to_dict() diff --git a/laborious/activities/opc.py b/laborious/activities/opc.py index c4abe95..da36793 100644 --- a/laborious/activities/opc.py +++ b/laborious/activities/opc.py @@ -352,10 +352,13 @@ class OPC(SientiaMonitoring): This allows downstream systems to handle data quality appropriately. """ + message = 'Some data could not be written to OPC servers' + if not success: data['prediction_confidence'] = OPC_WRITTING_ERROR_CONFIDENCE + data['comments'] = message self.debug( - f'Some data could not be written to OPC servers, setting confidence to {OPC_WRITTING_ERROR_CONFIDENCE}.', + f'{message}, setting confidence to {OPC_WRITTING_ERROR_CONFIDENCE}.', metadata, ) diff --git a/tests.ipynb b/tests.ipynb index 1803e21..6653567 100644 --- a/tests.ipynb +++ b/tests.ipynb @@ -764,6 +764,1056 @@ "\n", "data.shape[0]" ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d67d551f", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import shutil\n", + "import mlflow\n", + "from mlflow.tracking import MlflowClient\n", + "from rich.console import Console\n", + "import sys\n", + "\n", + "if \"src\" not in sys.path:\n", + " sys.path.insert(0, \"src\")\n", + "\n", + "console = Console()\n", + "\n", + "os.environ[\"MLFLOW_TRACKING_URI\"] = \"http://localhost:35785/\"\n", + "os.environ[\"MLFLOW_TRACKING_USERNAME\"] = \"aignosi\"\n", + "os.environ[\"MLFLOW_TRACKING_PASSWORD\"] = \"1L0FP50j3ncp123\"\n", + "\n", + "client = MlflowClient()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "98bdd6af", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CI-J3J01S1CI-J3P01T1ACI-J3P03S1CI-W3A05F1CI-W3A50A1CI-W3A50A2CI-W3A50A3CI-W3A50P1CI-W3A50T1CI-W3A55P1...CI-W3W01G1CI-W3W01P1CI-W3W01P2CI-W3W03I1CI-W3W03S1CI-W3_C3SCI-W3_CAOCI-W3_MACI-W3_MSCI-W3_PL
091.99121139.699982100.442688281.2935490.1358942.580241366.93277-0.200209405.9825-18.968868...818.09340-4.7438390.52107763.9267271796.5858262.1633263.704471.121042.505061020
191.99121139.699982100.442688281.2935490.1358942.580241366.93277-0.200209405.9825-18.968868...818.09340-4.9351490.52107763.9267271796.5858262.1633263.704471.121042.505061020
291.99121139.699982100.442688281.8197000.1358942.580241366.93277-0.200209405.9825-18.968868...770.03894-4.9351490.58071163.9267271796.5858262.1633263.704471.121042.505061020
\n", + "

3 rows × 39 columns

\n", + "
" + ], + "text/plain": [ + " CI-J3J01S1 CI-J3P01T1A CI-J3P03S1 CI-W3A05F1 CI-W3A50A1 CI-W3A50A2 \\\n", + "0 91.99121 139.699982 100.442688 281.293549 0.135894 2.580241 \n", + "1 91.99121 139.699982 100.442688 281.293549 0.135894 2.580241 \n", + "2 91.99121 139.699982 100.442688 281.819700 0.135894 2.580241 \n", + "\n", + " CI-W3A50A3 CI-W3A50P1 CI-W3A50T1 CI-W3A55P1 ... CI-W3W01G1 \\\n", + "0 366.93277 -0.200209 405.9825 -18.968868 ... 818.09340 \n", + "1 366.93277 -0.200209 405.9825 -18.968868 ... 818.09340 \n", + "2 366.93277 -0.200209 405.9825 -18.968868 ... 770.03894 \n", + "\n", + " CI-W3W01P1 CI-W3W01P2 CI-W3W03I1 CI-W3W03S1 CI-W3_C3S CI-W3_CAO \\\n", + "0 -4.743839 0.521077 63.926727 1796.58582 62.16332 63.70447 \n", + "1 -4.935149 0.521077 63.926727 1796.58582 62.16332 63.70447 \n", + "2 -4.935149 0.580711 63.926727 1796.58582 62.16332 63.70447 \n", + "\n", + " CI-W3_MA CI-W3_MS CI-W3_PL \n", + "0 1.12104 2.50506 1020 \n", + "1 1.12104 2.50506 1020 \n", + "2 1.12104 2.50506 1020 \n", + "\n", + "[3 rows x 39 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CI-J3J01S1CI-J3P01T1ACI-J3P03S1CI-W3A05F1CI-W3A50A1CI-W3A50A2CI-W3A50A3CI-W3A50P1CI-W3A50T1CI-W3A55P1...CI-W3W01P1CI-W3W01P2CI-W3W03I1CI-W3W03S1CI-W3_C3SCI-W3_CAOCI-W3_MACI-W3_MSCI-W3_PLtimestamp
091.99121139.699982100.442688281.2935490.1358942.580241366.93277-0.200209405.9825-18.968868...-4.7438390.52107763.9267271796.5858262.1633263.704471.121042.5050610202026-01-14 19:52:14
191.99121139.699982100.442688281.2935490.1358942.580241366.93277-0.200209405.9825-18.968868...-4.9351490.52107763.9267271796.5858262.1633263.704471.121042.5050610202026-01-14 19:52:17
291.99121139.699982100.442688281.8197000.1358942.580241366.93277-0.200209405.9825-18.968868...-4.9351490.58071163.9267271796.5858262.1633263.704471.121042.5050610202026-01-14 19:52:20
\n", + "

3 rows × 40 columns

\n", + "
" + ], + "text/plain": [ + " CI-J3J01S1 CI-J3P01T1A CI-J3P03S1 CI-W3A05F1 CI-W3A50A1 CI-W3A50A2 \\\n", + "0 91.99121 139.699982 100.442688 281.293549 0.135894 2.580241 \n", + "1 91.99121 139.699982 100.442688 281.293549 0.135894 2.580241 \n", + "2 91.99121 139.699982 100.442688 281.819700 0.135894 2.580241 \n", + "\n", + " CI-W3A50A3 CI-W3A50P1 CI-W3A50T1 CI-W3A55P1 ... CI-W3W01P1 \\\n", + "0 366.93277 -0.200209 405.9825 -18.968868 ... -4.743839 \n", + "1 366.93277 -0.200209 405.9825 -18.968868 ... -4.935149 \n", + "2 366.93277 -0.200209 405.9825 -18.968868 ... -4.935149 \n", + "\n", + " CI-W3W01P2 CI-W3W03I1 CI-W3W03S1 CI-W3_C3S CI-W3_CAO CI-W3_MA \\\n", + "0 0.521077 63.926727 1796.58582 62.16332 63.70447 1.12104 \n", + "1 0.521077 63.926727 1796.58582 62.16332 63.70447 1.12104 \n", + "2 0.580711 63.926727 1796.58582 62.16332 63.70447 1.12104 \n", + "\n", + " CI-W3_MS CI-W3_PL timestamp \n", + "0 2.50506 1020 2026-01-14 19:52:14 \n", + "1 2.50506 1020 2026-01-14 19:52:17 \n", + "2 2.50506 1020 2026-01-14 19:52:20 \n", + "\n", + "[3 rows x 40 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pandas import DataFrame, read_json\n", + "\n", + "# Load from data file (json)\n", + "data = read_json('data.json')\n", + "\n", + "column_order = [\n", + " 'CI-J3J01S1', 'CI-J3P01T1A', 'CI-J3P03S1', 'CI-W3A05F1',\n", + " 'CI-W3A50A1', 'CI-W3A50A2', 'CI-W3A50A3', 'CI-W3A50P1', 'CI-W3A50T1',\n", + " 'CI-W3A55P1', 'CI-W3A55T1', 'CI-W3A65_Cl', 'CI-W3A65_SO3', 'CI-W3A71P1',\n", + " 'CI-W3A71P2', 'CI-W3A71P3', 'CI-W3E01F1', 'CI-W3K01S1', 'CI-W3K01T1',\n", + " 'CI-W3K01T2', 'CI-W3K01T4', 'CI-W3K14P1', 'CI-W3P17S1', 'CI-W3V04P1',\n", + " 'CI-W3V04P3', 'CI-W3V21F1', 'CI-W3V21P1', 'CI-W3V30F1', 'CI-W3V33P1',\n", + " 'CI-W3W01G1', 'CI-W3W01P1', 'CI-W3W01P2', 'CI-W3W03I1', 'CI-W3W03S1',\n", + " 'CI-W3_C3S', 'CI-W3_CAO', 'CI-W3_MA', 'CI-W3_MS', 'CI-W3_PL']\n", + "\n", + "ordered_data = data[column_order]\n", + "\n", + "display(ordered_data.head(3))\n", + "display(data.head(3))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d7e73c30", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/grezewave/Documents/projects/sientia/sientia-dataops-laborious_temporal/venv/lib/python3.11/site-packages/mlflow/store/artifact/utils/models.py:32: FutureWarning: ``mlflow.tracking.client.MlflowClient.get_latest_versions`` is deprecated since 2.9.0. Model registry stages will be removed in a future major release. To learn more about the deprecation of model registry stages, see our migration guide here: https://mlflow.org/docs/2.10.1/model-registry.html#migrating-from-stages\n", + " latest = client.get_latest_versions(name, None if stage is None else [stage])\n", + "/home/grezewave/Documents/projects/sientia/sientia-dataops-laborious_temporal/venv/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "Downloading artifacts: 0%| | 0/20 [00:00[17:31:29] Model loaded from context pyfunc_wrappers.py:36\n", + "\n" + ], + "text/plain": [ + "\u001b[2;36m[17:31:29]\u001b[0m\u001b[2;36m \u001b[0m\u001b[32mModel loaded from context\u001b[0m \u001b]8;id=70872;file:///tmp/tmp7i9wovag/code/utils/mlflow/pyfunc_wrappers.py\u001b\\\u001b[2mpyfunc_wrappers.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=188021;file:///tmp/tmp7i9wovag/code/utils/mlflow/pyfunc_wrappers.py#36\u001b\\\u001b[2m36\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import mlflow\n", + "\n", + "model_name = \"vcm-o2-vanilla-ice\"\n", + "\n", + "model = mlflow.pyfunc.load_model(f'models:/{model_name}/production')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4e5bae06", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CI-W3W01A2
06.094787
15.987316
25.787229
35.780445
46.448903
55.631461
65.726437
75.669214
85.909435
95.845652
105.875139
116.048102
125.918375
135.859076
145.841918
156.265776
166.311982
176.792706
186.873636
\n", + "
" + ], + "text/plain": [ + " CI-W3W01A2\n", + "0 6.094787\n", + "1 5.987316\n", + "2 5.787229\n", + "3 5.780445\n", + "4 6.448903\n", + "5 5.631461\n", + "6 5.726437\n", + "7 5.669214\n", + "8 5.909435\n", + "9 5.845652\n", + "10 5.875139\n", + "11 6.048102\n", + "12 5.918375\n", + "13 5.859076\n", + "14 5.841918\n", + "15 6.265776\n", + "16 6.311982\n", + "17 6.792706\n", + "18 6.873636" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.predict(ordered_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cd1bfaa0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/grezewave/Documents/projects/sientia/sientia-dataops-laborious_temporal/venv/lib/python3.11/site-packages/mlflow/store/artifact/utils/models.py:32: FutureWarning: ``mlflow.tracking.client.MlflowClient.get_latest_versions`` is deprecated since 2.9.0. Model registry stages will be removed in a future major release. To learn more about the deprecation of model registry stages, see our migration guide here: https://mlflow.org/docs/2.10.1/model-registry.html#migrating-from-stages\n", + " latest = client.get_latest_versions(name, None if stage is None else [stage])\n", + "Downloading artifacts: 0%| | 0/20 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timestamp
02026-01-16 19:00:10+00:00
12026-01-16 18:29:56+00:00
22026-01-16 18:00:50+00:00
32026-01-16 17:30:17+00:00
\n", + "" + ], + "text/plain": [ + " timestamp\n", + "0 2026-01-16 19:00:10+00:00\n", + "1 2026-01-16 18:29:56+00:00\n", + "2 2026-01-16 18:00:50+00:00\n", + "3 2026-01-16 17:30:17+00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/grezewave/Documents/projects/sientia/sientia-dataops-laborious_temporal/venv/lib/python3.11/site-packages/sientia_do/observability/sientia_monitoring.py:80: RuntimeWarning: coroutine 'AsyncMockMixin._execute_mock_call' was never awaited\n", + " self.metrics_controller.start()\n", + "RuntimeWarning: Enable tracemalloc to get the object allocation traceback\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
predictionvaluetimestamp
2399346.265045550.5998542026-01-16 17:27:51+00:00
2397355.301300538.3166502026-01-16 17:27:53+00:00
2395354.891357532.5550542026-01-16 17:27:57+00:00
\n", + "
" + ], + "text/plain": [ + " prediction value timestamp\n", + "2399 346.265045 550.599854 2026-01-16 17:27:51+00:00\n", + "2397 355.301300 538.316650 2026-01-16 17:27:53+00:00\n", + "2395 354.891357 532.555054 2026-01-16 17:27:57+00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/grezewave/Documents/projects/sientia/sientia-dataops-laborious_temporal/venv/lib/python3.11/site-packages/sientia_do/observability/sientia_monitoring.py:80: RuntimeWarning: coroutine 'AsyncMockMixin._execute_mock_call' was never awaited\n", + " self.metrics_controller.start()\n", + "RuntimeWarning: Enable tracemalloc to get the object allocation traceback\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timestamp
02026-01-16 19:00:50+00:00
12026-01-16 18:30:35+00:00
22026-01-16 18:01:29+00:00
32026-01-16 17:29:55+00:00
\n", + "
" + ], + "text/plain": [ + " timestamp\n", + "0 2026-01-16 19:00:50+00:00\n", + "1 2026-01-16 18:30:35+00:00\n", + "2 2026-01-16 18:01:29+00:00\n", + "3 2026-01-16 17:29:55+00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/grezewave/Documents/projects/sientia/sientia-dataops-laborious_temporal/venv/lib/python3.11/site-packages/sientia_do/observability/sientia_monitoring.py:80: RuntimeWarning: coroutine 'AsyncMockMixin._execute_mock_call' was never awaited\n", + " self.metrics_controller.start()\n", + "RuntimeWarning: Enable tracemalloc to get the object allocation traceback\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
predictionvaluetimestamp
23986.0325446.1202982026-01-16 17:27:41+00:00
23966.0586836.0327482026-01-16 17:27:43+00:00
23946.3884635.9366642026-01-16 17:27:47+00:00
\n", + "
" + ], + "text/plain": [ + " prediction value timestamp\n", + "2398 6.032544 6.120298 2026-01-16 17:27:41+00:00\n", + "2396 6.058683 6.032748 2026-01-16 17:27:43+00:00\n", + "2394 6.388463 5.936664 2026-01-16 17:27:47+00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "period_hours = 2\n", + "\n", + "samples = 20*60*period_hours\n", + "retrain_samples = 2*period_hours\n", + "\n", + "query_nox = f\"\"\"\n", + "select p.prediction, ld.value, p.\"timestamp\" from sientia_data.predictions p\n", + "join sientia_data.laborious_data ld on p.\"timestamp\" = ld.\"timestamp\"\n", + "where p.model_id = '4' and variable='CI-W3W01A3' order by p.created_at desc limit {samples};\n", + "\"\"\"\n", + "\n", + "retrain_query = f\"\"\"\n", + "select \"timestamp\" from sientia_data.log_retrain lr where model_id = '4' order by lr.\"timestamp\" desc limit {retrain_samples};\n", + "\"\"\"\n", + "\n", + "retrain_data_nox = DataFrame(await postgres.load_custom_query(\n", + " {\n", + " \"query\": retrain_query,\n", + " \"metadata\": {},\n", + " }\n", + "))\n", + "\n", + "retrain_data_nox['timestamp'] = to_datetime(retrain_data_nox['timestamp'])\n", + "\n", + "display(retrain_data_nox)\n", + "\n", + "data_nox = DataFrame(await postgres.load_custom_query(\n", + " {\n", + " \"query\": query_nox,\n", + " \"metadata\": {},\n", + " \"datetime_columns\": [\"timestamp\"],\n", + " }\n", + "))\n", + "\n", + "data_nox.drop_duplicates(subset=['timestamp'], inplace=True, keep='first')\n", + "data_nox.sort_values(by='timestamp', inplace=True)\n", + "data_nox['timestamp'] = to_datetime(data_nox['timestamp'])\n", + "\n", + "display(data_nox.head(3))\n", + "\n", + "query_o2 = f\"\"\"\n", + "select p.prediction, ld.value, p.\"timestamp\" from sientia_data.predictions p\n", + "join sientia_data.laborious_data ld on p.\"timestamp\" = ld.\"timestamp\"\n", + "where p.model_id = '5' and variable='CI-W3W01A2' order by p.created_at desc limit {samples};\n", + "\"\"\"\n", + "\n", + "retrain_query_o2 = f\"\"\"\n", + "select \"timestamp\" from sientia_data.log_retrain lr where model_id = '5' order by lr.\"timestamp\" desc limit {retrain_samples};\n", + "\"\"\"\n", + "\n", + "retrain_data_o2 = DataFrame(await postgres.load_custom_query(\n", + " {\n", + " \"query\": retrain_query_o2,\n", + " \"metadata\": {},\n", + " }\n", + "))\n", + "\n", + "retrain_data_o2['timestamp'] = to_datetime(retrain_data_o2['timestamp'])\n", + "\n", + "display(retrain_data_o2)\n", + "\n", + "data_o2 = DataFrame(await postgres.load_custom_query(\n", + " {\n", + " \"query\": query_o2,\n", + " \"metadata\": {},\n", + " \"datetime_columns\": [\"timestamp\"],\n", + " }\n", + "))\n", + "\n", + "data_o2.drop_duplicates(subset=['timestamp'], inplace=True, keep='first')\n", + "data_o2.sort_values(by='timestamp', inplace=True)\n", + "data_o2['timestamp'] = to_datetime(data_o2['timestamp'])\n", + "\n", + "display(data_o2.head(3))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "7b82e5a7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAz8AAANECAYAAACesJFBAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd8FOXWx3+zPZveCwRC7x1ERBQQBcSOqIgg2BWuXe/1Xq+v7doLFuwFFHuvgHSlN+k9EEJCeq9b5/1j5pmdmZ3Zvskmeb6fT2B3+szOM/Oc55zzOwzLsiwoFAqFQqFQKBQKpZ2jae0DoFAoFAqFQqFQKJSWgBo/FAqFQqFQKBQKpUNAjR8KhUKhUCgUCoXSIaDGD4VCoVAoFAqFQukQUOOHQqFQKBQKhUKhdAio8UOhUCgUCoVCoVA6BNT4oVAoFAqFQqFQKB0CavxQKBQKhUKhUCiUDgE1figUCoVCoVAoFEqHgBo/FAqFQqFQKBQKpUNAjR8KhUKhtCqLFy8GwzAwmUwoLCx0mz9+/HgMHDhQMs1ms+H111/HqFGjEBsbi5iYGIwaNQqvv/46bDZbSx06hUKhUNoY1PihUCgUSkRgsVjw3HPPeV2uoaEBF154Ie655x5kZGTgueeew4svvoisrCzcc889uPDCC9HQ0NACR0yhUCiUtgY1figUCoUSEQwdOhTvv/8+zpw543G5+++/H+vXr8cbb7yBX375BfPnz8edd96Jn376CW+++SbWr1+PBx98sIWOmkKhUChtCWr8UCgUCiUi+Pe//w2Hw+HR+1NQUIAPP/wQEydOxIIFC9zmz58/HxMmTMAHH3yAgoICAMDHH38MhmHw0UcfSZZ95plnwDAMfv/999CeCIVCoVAiFmr8UCgUCiUi6NatG+bMmePR+7Ns2TI4HA7MmTNHdTtz5syB3W7H8uXLAQDz5s3DJZdcgvvvvx+nT58GAOzbtw9PPPEEbr75Zlx88cWhPxkKhUKhRCTU+KFQKBRKxPCf//wHdrsdzz//vOL8gwcPAgCGDBmiug0y79ChQ8K0999/H1qtFjfffDOsVituvPFGZGRk4JVXXgnh0VMoFAol0qHGD4VCoVAihu7du2P27Nl47733UFRU5Da/rq4OABAbG6u6DTKvtrZWmJaRkYFFixZh5cqVGDduHHbv3o2PPvoIcXFxIT4DCoVCoUQy1PihUCgUSkTx6KOPwm63K+b+EMOGGEFKqBlI1113HaZNm4Zt27bh1ltvxQUXXBDCo6ZQKBRKW4AaPxQKhUKJKLp3744bbrhB0fvTr18/AMDevXtV1yfz+vfvL5leUVGBHTt2AODC55xOZygPm0KhUChtAGr8UCgUCiXiIN4fee7P1KlTodVq8emnn6qu+8knn0Cn02HKlCmS6fPnz0ddXR2effZZbNiwAQsXLgzHoVMoFAolgqHGD4VCoVAijh49euCGG27Au+++i+LiYmF6dnY25s2bh1WrVuHtt992W++dd97BmjVrcPPNN6Nz587C9G+//RZfffUVnnvuOfzrX//Cddddh0cffRRHjx5tkfOhUCgUSmTAsCzLtvZBUCgUCqXjsnjxYsybNw/bt2/HyJEjhenHjx9H37594XA4MGDAAOzfvx8AUF9fj6lTp2LDhg247LLLBA/PihUr8NNPP+H888/Hb7/9hujoaABAaWkpBgwYgEGDBmH16tVgGAYVFRUYMGAAunfvjg0bNkCjoWOBFAqF0hGgT3sKhUKhRCQ9e/bEDTfc4DY9JiYGq1evxquvvorCwkI89NBDePDBB3H69GksXLgQK1euFAwfALjzzjthsViEYqcAkJycjPfeew+bN2/GSy+91GLnRKFQKJTWhXp+KBQKhUKhUCgUSoeAen4oFAqFQqFQKBRKh4AaPxQKhUKhUCgUCqVDQI0fCoVCoVAoFAqF0iGgxg+FQqFQKBQKhULpEFDjh0KhUCgUCoVCoXQIqPFDoVAoFAqFQqFQOgS61j6AQHA6nThz5gxiY2OFmg0UCoVCoVAoFAql48GyLOrq6pCVleW1aHWbNH7OnDmD7Ozs1j4MCoVCoVAoFAqFEiGcPn0anTt39rhMmzR+YmNjAXAnGBcX18pHQ6FQKBQKhUKhUFqL2tpaZGdnCzaCJ9qk8UNC3eLi4qjxQ6FQKBQKhUKhUHxKh6GCBxQKhUKhUCgUCqVDQI0fCoVCoVAoFAqF0iGgxg+FQqFQKBQKhULpELTJnB9fcTgcsNlsrX0YlBCh1+uh1Wpb+zAoFAqFQqFQKG2Udmn8sCyL4uJiVFdXt/ahUEJMQkICMjIyaH0nCoVCoVAoFIrftEvjhxg+aWlpMJvNtKPcDmBZFo2NjSgtLQUAZGZmtvIRUSgUCoVCoVDaGu3O+HE4HILhk5yc3NqHQwkhUVFRAIDS0lKkpaXREDgKhUKhUCgUil+0O8EDkuNjNptb+Ugo4YD8rjSXi0KhUCgUCoXiL+3O+CHQULf2Cf1dKRQKhUKhUCiB0m6NHwqFQqFQKBQKhUIRQ42fdk5eXh4YhsHu3btb+1AoFAqFQqFQKJRWhRo/FAqFQqFQKBQKpUNAjZ8Ixmq1tvYhUCgUCoVCoVAo7QZq/EQQ48ePx4IFC3DvvfciJSUFkydPxv79+zF16lTExMQgPT0ds2fPRnl5ubDO8uXLce655yIhIQHJycm45JJLkJub24pnQaFQKBQKhUKhRCYdwvhhWRaNVrvkr67Jgm27dmPbrt2oa7K4zQ/FH8uyfh/rkiVLYDAYsHHjRjz33HOYOHEihg0bhh07dmD58uUoKSnBNddcIyzf0NCA+++/Hzt27MDq1auh0Whw5ZVXwul0hvISUihhobGxETk5OcjJyUFjY2NrHw6F0m6gbYtCaR1o24t8/C5yWlhYiH/+859YtmwZGhsb0bNnT3z88ccYOXIkAGDu3LlYsmSJZJ3Jkydj+fLlwvfKykr84x//wC+//AKNRoPp06fjtddeQ0xMTJCno0yTzYH+j63wsERhWPZ78MnJMBv8u8S9evXCCy+8AAB4+umnMWzYMDzzzDPC/I8++gjZ2dk4evQoevfujenTp0vW/+ijj5CamoqDBw9i4MCBwZ8EhRJGWJbFqVOnhM8UCiU00LZFobQOtO1FPn71zKuqqjB27FhMmDABy5YtQ2pqKo4dO4bExETJclOmTMHHH38sfDcajZL5s2bNQlFREVauXAmbzYZ58+bhtttuw+effx7EqbQPRowYIXzes2cP1q5dq2gU5ubmonfv3jh27Bgee+wxbN26FeXl5YLHJz8/nxo/FAqFQqFQKBSKCL+Mn+effx7Z2dkSw6Zbt25uyxmNRmRkZChu49ChQ1i+fDm2b98ueIveeOMNXHzxxXjppZeQlZXlzyH5RJRei4NPTpZMczgc2LNnLwBgyJDB0Gq1Ydmvv0RHRwuf6+vrcemll+L55593Wy4zMxMAcOmll6Jr1654//33kZWVBafTiYEDB1KxBAqFQqFQKBQKRYZfxs/PP/+MyZMnY8aMGVi/fj06deqEu+66C7feeqtkuXXr1iEtLQ2JiYmYOHEinn76aSQnJwMANm/ejISEBMHwAYBJkyZBo9Fg69atuPLKK932a7FYYLFYhO+1tbV+nSTDMG7hZw4HA5OOAQCYDbqwGD/BMnz4cHz33XfIycmBTuf+U1VUVODIkSN4//33MW7cOADAhg0bWvowKRQKhUKhUCiUNoFfggcnTpzA22+/jV69emHFihW48847cffdd0tyfKZMmYJPPvkEq1evxvPPP4/169dj6tSpcDgcAIDi4mKkpaVJtqvT6ZCUlITi4mLF/T777LOIj48X/rKzs/09zzbJ/PnzUVlZiZkzZ2L79u3Izc3FihUrMG/ePDgcDiQmJiI5ORnvvfcejh8/jjVr1uD+++9v7cOmUCgUCoVCoVAiEr88P06nEyNHjhQS8IcNG4b9+/fjnXfewY033ggAuO6664TlBw0ahMGDB6NHjx5Yt24dLrjggoAO8pFHHpF06mtrazuEAZSVlYWNGzfin//8Jy666CJYLBZ07doVU6ZMgUajAcMw+PLLL3H33Xdj4MCB6NOnD15//XWMHz++tQ+dQqFQKBQKhUKJOPwyfjIzM9G/f3/JtH79+uG7775TXad79+5ISUnB8ePHccEFFyAjIwOlpaWSZex2OyorK1XzhIxGo5toQigwmUwh32YwrFu3zm1ar1698P3336uuM2nSJBw8eFAyTawukpOTQ9VGKBELwzDCM4VhmFY+Ggql/UDbFoXSOtC2F/n4ZfyMHTsWR44ckUw7evQounbtqrpOQUEBKioqhAT9MWPGoLq6Gjt37hSUzdasWQOn04nRo0f7e/wBo9VqqRoahdLKmM1mHDhwoLUPg0Jpd9C2RaG0DrTtRT5+5fzcd9992LJlC5555hkcP34cn3/+Od577z3Mnz8fAKdO9tBDD2HLli3Iy8vD6tWrcfnll6Nnz56YPJlTW+vXrx+mTJmCW2+9Fdu2bcPGjRuxYMECXHfddWFReqNQKBQKhUKhUCgUwE/jZ9SoUfjhhx/wxRdfYODAgXjqqaewcOFCzJo1CwDnTdm7dy8uu+wy9O7dGzfffDNGjBiBv/76SxK29tlnn6Fv37644IILcPHFF+Pcc8/Fe++9F9ozo1AoFAqFQqFQKBQRDNsGE0Jqa2sRHx+PmpoaxMXFSeY1Nzfj5MmT6Natm8ecHofDgUOHDgHgvFGRKHVNccfX35fSNmhsbMSoUaMAANu3b4fZbG7lI6JQ2ge0bVEorQNte62DJ9tAjl85P+2N5ubm1j4ECqVDw7KsINjRBsdhKJSIhbYtCiV4Suuase5IGZxOFpkJUTi/d6rXdWjbi3w6tPFDoVAoFAqFQqEo8c9v92LtkTLh+0/zx2JIdkLrHRAlJPiV80OhUCgUCoVCoXQETpQ3AAAMWg3/vb41D4cSIqjxQ6FQKBQKhUKh8BRUNeLeL//GmeomAEC/LC6H5O11uViyKa8Vj4wSCqjxQ6FQKBQKhUKh8HyxLR8/7j4Dm4OF2aDFOT2SAQBHS+rx+C8HUNdsa+UjpAQDNX46KDk5OVi4cKHwnWEY/Pjjj0FtMxTboFAoFAqFQmlN8ioaAQCXD83C17ePwd0Te+H1mcOQHG0AywJHS+pa+QgpwdChjR+DwQCDwdDahxERFBUVYerUqT4t+/jjj2Po0KFBbYPSumzOrcD3uwrgcLauEg3DMOjatSu6du0KhmFa9VgolPYEbVsUSuAUVHHhblMHZmJgp3hEGbS4bEgWBneOBwBMf3szqhutiuvSthf5dFi1N61Wi8GDB7f2YQSF1WoNmfGWkZEREdughJ/qRitmvr8FAGA26DBlYOv9bmazGXl5ea22fwolkth6ogKldRbhe0qMEWd3TwqoA0XbFoUSGI1WO/acrgYAZCdFSeZNGZghqL/tyKvCpP7pbuvTthf5dGjPT6Qxfvx4LFiwAAsWLEB8fDxSUlLw3//+V9CJz8nJwVNPPYU5c+YgLi4Ot912GwBgw4YNGDduHKKiopCdnY27774bDQ0NwnZLS0tx6aWXIioqCt26dcNnn33mtm95yFpBQQFmzpyJpKQkREdHY+TIkdi6dSsWL16MJ554Anv27AHDMGAYBosXL1bcxr59+zBx4kRERUUhOTkZt912G+rrXUopc+fOxRVXXIGXXnoJmZmZSE5Oxvz582Gz0VjacELUawDquqdQIoXteZW49r0t+McXfwt/M9/fgo3HK1r70CiUDsXWE5XC5+4pMZJ5147qgrE9ufyf01WNLXpclNDRMYwflgWsDS3/F0BxqyVLlkCn02Hbtm147bXX8Morr+CDDz4Q5r/00ksYMmQI/v77b/z3v/9Fbm4upkyZgunTp2Pv3r346quvsGHDBixYsEBYZ+7cuTh9+jTWrl2Lb7/9Fm+99RZKS0tVj6G+vh7nn38+CgsL8fPPP2PPnj14+OGH4XQ6ce211+KBBx7AgAEDUFRUhKKiIlx77bVu22hoaMDkyZORmJiI7du345tvvsGqVaskxwUAa9euRW5uLtauXYslS5Zg8eLFgjFFCQ9Lt5wSPp+upA9vCiUSICPNqbFGjOmejPQ4IwBgX2FNKx4VhdLxIEbNWd2SEGXQus3vn8kpvx0ppoOHbZWOEfZmawSeyWr5/f77DGCI9muV7OxsvPrqq2AYBn369MG+ffvw6quv4tZbbwUATJw4EQ888ICw/C233IJZs2bh3nvvBQD06tULr7/+Os4//3y8/fbbyM/Px7Jly7Bt2zaMGjUKAPDhhx+iX79+qsfw+eefo6ysDNu3b0dSUhIAoGfPnsL8mJgY6HQ6j2Fun3/+OZqbm/HJJ58gOpq7Bm+++SYuvfRSPP/880hP51zFiYmJePPNN6HVatG3b19MmzYNq1evFs6XEnp2nqoSPp+qaF3jp6mpCeeddx4A4M8//0RUVJSXNSiU9gnpSF07MhsPTu6DV1Yexeurj+H55Ydx7ahsJEX7F+JM2xaFEhhkUHBgVrzi/OwkMwDgy+2n8dDkPkiOMUrm07YX+XQM46cNcfbZZ0viu8eMGYOXX34ZDocDADBy5EjJ8nv27MHevXsloWwsy8LpdOLkyZM4evQodDodRowYIczv27cvEhISVI9h9+7dGDZsmGD4BMKhQ4cwZMgQwfABgLFjx8LpdOLIkSOC8TNgwABota6RlczMTOzbty/g/VI8w7IsykQ5BYeKauF0stBoWicp0+l0YseOHcJnCqUjUm+x45udBQCA7qncM7NfRqww/9udp3HbeT382iZtWxRKYJyu5MQO5Pk+hAl90gAcAAAcL613M35o24t8OobxozdzXhgRDocDe/bsAQAMGTJE0gEP6X5DjNiYALgQtdtvvx13332327JdunTB0aNH/d5HS45S6PV6yXeGYejDIozUWexotDok3x/8dg9euWZo6x0UhdLBOVHmyoUc2zMFAHBh/3R0SohCYXWT0BmjUCjhp6i2GQCQlaDcF8pOMmNQp3jsK6yRvE8pbYeOkfPDMFz4mezPqYuCUxelOC8kfwEo9GzdulXyfcuWLejVq5eqcTZ8+HAcPHgQPXv2dPszGAzo27cv7HY7du7cKaxz5MgRVFdXqx7D4MGDsXv3blRWVirONxgMgidKjX79+mHPnj0S4YWNGzdCo9GgT58+HtelhI+SGu6hHmfSYQgv2bnhWHlrHhKF0uGpa7YDAHqnxyA9zgQA0Gk1uHM85+35dMspFNVQA4hCaQnKeOMnLdaouoyZzwVqsNpb5JgooaVjGD9tiPz8fNx///04cuQIvvjiC7zxxhu45557VJf/5z//iU2bNmHBggXYvXs3jh07hp9++kkQFujTpw+mTJmC22+/HVu3bsXOnTtxyy23ePTuzJw5ExkZGbjiiiuwceNGnDhxAt999x02b94MgFOdO3nyJHbv3o3y8nJYLBa3bcyaNQsmkwk33ngj9u/fj7Vr1+If//gHZs+eLYS8UVqeYv6hnh5nwodzuRywsnoLrHbqbaNQWgti/MQYpcEYnRJdz+lZ70sHxigUSuhxOlmU1XN9mjR+IEKJaL6tNlqo56ctQo2fCGPOnDloamrCWWedhfnz5+Oee+4RJK2VGDx4MNavX4+jR49i3LhxGDZsGB577DFkZbkEHj7++GNkZWXh/PPPx1VXXYXbbrsNaWlpqts0GAz4448/kJaWhosvvhiDBg3Cc889J3ifpk+fjilTpmDChAlITU3FF1984bYNs9mMFStWoLKyEqNGjcLVV1+NCy64AG+++WYQV4cSLCW13EM9I96E5GgDDDoNWBb482hZKx8ZhdJxqbdwxk+sSRoGfE6PZFzI1xE5Ud4gLEehUMJDVaMVNgen1Jsao+75ISpwjdTz0ybpGDk/bQi9Xo+FCxfi7bffdpunVjRr1KhR+OOPP1S3mZGRgV9//VUybfbs2ZLvrEyWu2vXrvj2228Vt2c0GhXnybcxaNAgrFmzRvW4lCStFy5cqLo8JXhKRJ4fhmGg1zCwAlh+oFixWBuFQgk/dc1cbbMYk/SVbNRp8f6ckRj25B+oarQhv6IR/bPiWuMQKZQOwerDXBmQJH5wUI04fqCissHaIsdFCS0d2vOj0+mg01H7j9JxKBWMH25E664JnIQ5MYpag5SUFKSkpLTa/imU1qaeD3uLMym/j7rw0rr+FlWkbYtC8Y8CXubam5c1J5lrkydVykXQthfZdNiev1arxdChQ1v7MCiUFqWCH6VKjuaMn6HZCQCAv46Vo7C6CZ1U1G3CRXR0NMrKaMgdpWNTZ1HO+SFwIgg1wuCFL9C2RaH4T00T54W9dVw3j8t1S+GUd3/ZcwbXjOyMcb1ShXm07UU+HdrzE2msW7eOhn1RwkpVI2f8kIKJZEQZAP7328FWOSYKpaNTxQ9KJJiVC5kSBbjSOndxGQqFEjqqeeMnIcpzUeGeaTHC59kfbhMKo1LaBtT4oVA6EBX1XCcrkTd+spPMuHwoJ46xt6Cm1Y6LQunIVDVyHa5EVeOH89S2ZngqhdIRIJ6feLPe43LdU2Pw8BRX2Q5/Q1IprUuHNX6cTieOHDmCI0eO0KKalA4D8fwkR7s6WU9cNgAAUFDVJCm22BI0NTVh/PjxGD9+PJqaaB0TSseEtMtElQ5XWizn+SFqjb5A2xaF4j/V/EBEfJRn4wcA7hrfE6NyEiXrAbTttQU6bM4Py7Koq6sTPlMo7RWr3YlGqx1aDSMo0ySKjJ8EswE6DQO7k8XyA8W4a3zPFjs2p9OJ9evXC58plI4IMX7Uwt5S+WKLFQ2+Gz+0bVEo/lMrhL15N34AV5sVq77Rthf5dFjjh0LpCJTWNuOihX9KRqUAIEnWyZo+vDO+2nEaJ8saWvLwKBQKRB0uFc9PLK8CR4qhUiiU8FDtY9gbIYWvBVRG8/HaFB027I1C6QjsPl3tZvhE6bVCgTbCub04Sc5vdhagtI7mFVAoLYnFxo0OR+m1ivNJ8dN6avxQKGGDZVkh58eb4AEhM54LSS2uoe/NtgQ1fiiUdkxZPTcalSKqVJ0U7f5Q75XuUq55ecVRv/axI68S415Yg8d/PhDgUVIoHRuLnTN+1IoqxlDPD4USduotdjicXBqELzk/AJBBjB8qRtKmoMYPRUJOTg6V225HlNdxccgjuyYK01Ji3I2fPumxGNw5HgCQ76dk5+db83G6sgmLN+XB5qDxzRSKPzidLKx8uzGqGT98/R+rwwmL3dFix0ahdCSI18eg08Ck9617TD0/bRNq/LRxxo8fj3vvvTdk29u+fTtuu+22kG2P0rq8uorz4vRKj8G/pvbFxL5puPfC3m7LMQyDf07pCwDYfKICewuqfd5HuSjRk9Y6oFD8wyoaMDCqhL2Ji59S7w+FEh4EmesoPRiG8WkdYvwU1VBVt7ZEhzZ+NBoNNJrIvQRWq9X7Qj7Asizsdt9emKmpqTCbzd4XpEQ8tc2uXJ/hXRJxx/k98NHcUZjQJ01x+Ry+YjUAvLM+1+f9FIgMnpPl/gsmmM1mes9ROiwk3wdQ9/xoNQyi+Tw9f/J+aNuiUHyn2cZ5Vc0G5UEIJUgB4tpmOxosrrZJ215kE7k9/zCj1WoxfPhwDB8+HFqt7zd6OBk/fjwWLFiAe++9FykpKZg8eTL279+PqVOnIiYmBunp6Zg9ezbKy8sBAHPnzsX69evx2muvgWEYMAyDvLw8rFu3DgzDYNmyZRgxYgSMRiM2bNiA3NxcXH755UhPT0dMTAxGjRqFVatWSY5BHvbGMAw++OADXHnllTCbzejVqxd+/vnnlrws7Rqnk4XTGR6p9TPV3EiUUafBhL7KBo+YTglR+MdETub6hB+qb5WNgXt+oqOj0dDQgIaGBkRHR3tfgUJpZ5AwNg0D6DTqo82C6IHFN+OHti0KxT9I7p1e63vXONakFzyzJO+Htr3Ip0MZP+RmVPprbm72eVl50SqlZQJlyZIlMBgM2LhxI5577jlMnDgRw4YNw44dO7B8+XKUlJTgmmuuAQC89tprGDNmDG699VYUFRWhqKgI2dnZwrb+9a9/4bnnnsOhQ4cwePBg1NfX4+KLL8bq1avx999/Y8qUKbj00kuRn5/v8ZieeOIJXHPNNdi7dy8uvvhizJo1C5WVlQGfI4Ujt6weI/+3Cv0eW45l+4pCvn1i/PRMi/GypIvLh3YCABwursOitce9Ls+yrGS0q8FK8xEoFH8gHS6jTusx1IaIHog9uhQKJXRYifCIH8YPIBI9oHk/bQa/jZ/CwkLccMMNSE5ORlRUFAYNGoQdO3YI81mWxWOPPYbMzExERUVh0qRJOHbsmGQblZWVmDVrFuLi4pCQkICbb74Z9fXhrywfExOj+jd9+nTJsmlpaarLTp06VbJsTk6O2zKB0qtXL7zwwgvo06cPVq5ciWHDhuGZZ55B3759MWzYMHz00UdYu3Ytjh49ivj4eBgMBpjNZmRkZCAjI0PixXryySdx4YUXokePHkhKSsKQIUNw++23Y+DAgejVqxeeeuop9OjRw6snZ+7cuZg5cyZ69uyJZ555BvX19di2bVvA50jh2HqiEpUNVljsTqw7Uhby7Zfy1eCJW94Xuia73PS/7fVukFnsTtgcLs9Vo5XmI1Ao/iAYP14SrEmtHyp3TWkXWOqACCsASt5laqqLakhED3LXAOXeBw4prYtfv3BVVRXGjh0LvV6PZcuW4eDBg3j55ZeRmOhSknrhhRfw+uuv45133sHWrVsRHR2NyZMnSzwrs2bNwoEDB7By5Ur8+uuv+PPPP2mSPc+IESOEz3v27MHatWslRlXfvlxSem6u95yMkSNHSr7X19fjwQcfRL9+/ZCQkICYmBgcOnTIq+dn8ODBwufo6GjExcWhtLTUn9OiKFAnGsENx2hujZ+VqgHO3f/b3ecC8C2BUx6C02Dxz/PT3NyMadOmYdq0aW7eVwqlI0DC3tTyfQgktMZXwQPatigRS/Vp4NnOwNezW/tIJFi9SM6rQQYYG0uOA59eieY3z8W0CWfTthfB6Lwv4uL5559HdnY2Pv74Y2Fat27dhM8sy2LhwoV49NFHcfnllwMAPvnkE6Snp+PHH3/Eddddh0OHDmH58uXYvn270Dl/4403cPHFF+Oll15CVlZWKM5LEbF3yeFwYM+ePQCAIUOGwGCQyv966tzLRRLy8vJCdozi+ND6+npceumleP75592Wy8zM9GtbAPDggw9i5cqVeOmll9CzZ09ERUXh6quv9iqsoNdLO88Mw8AZYSM2bRFxJ4YYKqGEbDPOD+MHADonct6fqkYbDhXVol9mHADA7nCistGKtFiXJ0k+Cu2v58fhcOD3338XPlMoHQ1x2Jsnog3c69rXNkbblgq2JuDPF4E+04DOI7wvTwk9u5Zw/x/+tXWPQ4bV4dtAhBzi+Wms4qIlHNZG/L5uK/eZtr2IxK9f+Oeff8bIkSMxY8YMpKWlYdiwYXj//feF+SdPnkRxcTEmTZokTIuPj8fo0aOxefNmAMDmzZuRkJAg8UpMmjQJGo0GW7duDfZ8PBIdHS35i4qKQlRUFKKjo2EymTwuK1/P27KhYPjw4Thw4ABycnLQs2dPyR/Zh8Fg8Llxbdy4EXPnzsWVV16JQYMGISMjI6SGG8U/wu35eWsd5x2MM/k1xoE4kw5aPvF66ZZTwvS5H2/HWf9bjcPFtcI0N88PzfmhUPyCqL1563CR0WhxmCklAP56BfjrZeCDia19JB0XS/jTHALBGoDgAeDy/NTUK0RL7Psm6OOihB6/fuETJ07g7bffRq9evbBixQrceeeduPvuu7FkCWfFFxcXAwDS09Ml66WnpwvziouLkZYmVZ7S6XRISkoSlpFjsVhQW1sr+esIzJ8/H5WVlZg5cya2b9+O3NxcrFixAvPmzRMMnpycHGzduhV5eXkoLy/36JHp1asXvv/+e+zevRt79uzB9ddfTz04rYjY81PbFNo4fiLZCQBDuyT4tS7DMPjvtH4AgC0nKoTpG45zKoNfby8QpsmNH4uNGj8Uij+Qtuot50en5QYkaCHhICk50NpHQLHWuT6zkWPMByp4QAqHN5AQt+Serpk/3w1se19hLUpr4tcv7HQ6MXz4cDzzzDMYNmwYbrvtNtx666145513wnV8AIBnn30W8fHxwp9Y0aw9k5WVhY0bN8LhcOCiiy7CoEGDcO+99yIhIUEIvXvwwQeh1WrRv39/pKameszfeeWVV5CYmIhzzjkHl156KSZPnozhw4e31OlQZNSGMeytki88qtUwqnV9PHHlsM5gGCC3rAHvrs+VyHGLK1/Lw96abbRjRqH4A/H6xpk8h6eSDhk1fihtHquoJILd0nrHIcMaoOBBUrQRANDYyBs/OqN0gd8f5LyNlIjBr3iYzMxM9O/fXzKtX79++O677wAAGRkZAICSkhJJTkpJSQmGDh0qLCPPp7Hb7aisrBTWl/PII4/g/vvvF77X1ta2SwNo3bp1btOIt0aN3r17CyGFhJycHLAKoyk5OTlYs2aNZNr8+fMl3+VhcErbqa6uVj0eiu/Iw94cTlYINwuWinrO+EmJMfhcqVpMvFmPQZ3isbegBs8uO4zMBFeop0lUhV7u+Wmmnh8KxS/IIIg344eE4lhp2BulzSO6h631gN53RdJwQt5fJi9eWDlJ0bznx8IbchpRWx57H7B9IbD6SaC5Fpj0OBDAO5kSWvz6hceOHYsjR45Iph09ehRdu3YFwIkfZGRkYPXq1cL82tpabN26FWPGjAEAjBkzBtXV1di5c6ewzJo1a+B0OjF69GjF/RqNRsTFxUn+KJS2jtjzw7JAdaNn4Ql/qGjgHsJkRCoQnrhsgPD5592FwmenyCCu440fkq/QbKfGD4XiD7W81zfWS26ennp+QgQ1Hlsdm0gBzVKnvlwLQ0LRY70MRMghYW92KzF+RG15/MPAhU9xnzcuBH57IOIkvtss+78HTv4V0Kp+GT/33XcftmzZgmeeeQbHjx/H559/jvfee0/wHjAMg3vvvRdPP/00fv75Z+zbtw9z5sxBVlYWrrjiCgCcp2jKlCm49dZbsW3bNmzcuBELFizAddddF1alNwol0qiTiRxUhdD4IWFv5KEcCMO6JOKeC3oBAFYdcnlrxaFu5HNKDGdkWWjYG4XiF6TD5U2VUa/jRovt1PihtHVsokLw1sgRP6i3cO9kIivvK3EmPbQaBjrwg39a2fpj7wYuWQiAAXZ8CPx4B+Cg9bqCouwo8O08YMklAa3u1y88atQo/PDDD3jkkUfw5JNPolu3bli4cCFmzZolLPPwww+joaEBt912G6qrq3Huuedi+fLlEjW1zz77DAsWLMAFF1wAjUaD6dOn4/XXXw/oBAJFq9W61cGhUFoSeb2OyobQ5f2QsDfijg+UQZ3i3aaJQ92qm7j9pMYaUVjd5LfnJzo6WjG0ktJ2abY58NKKIyivt+CKYZ0wPoCcs46Erzk/eo1/am+0balAr0nrUHkCKN4P9JwEWEXGj817PbmWol7w/Phn/Gg0DJKiDdA1cAMT0VEm97Y3ch5gjAW+vw3Y+xV3Da7+yD0/iOIblSeCWt2/XxjAJZdcgksuUbe0GIbBk08+iSeffFJ1maSkJHz++ef+7ppCaTewLCsYEZ0SolBY3YTKhtAlfpJwNH8f4nIu6OfecRUbbWW13DF3STJj9+lqKnhAwcqDJfhgw0kAwN6CGmr8eIG0pxgfw96s1PNDCRaWBYr3Ack9AENoSnN4xG4FXh/GfZ78jFTwwBk5odLkneyv5wcAkqMN0DXw70aNyvqDruau99c3cjWOPr8GuO7zlvkN2hv24IrH+pfV1YagI17tk/byuzZaHXDwCmo5KVxR0VB6fpr4QohmQ3DGD8MwGNcrRTKtTuT5Ka1zGT8AFTygAAVVrpHcklpa3dwbviZZk7A3m50aP8HRPt4hQXHoF+DdccDiAEKGWBbY+BpwYr3v6zTXuD7XFUnD3pyRE/5FBiKiAzF+YgzQMSTszYMXt89UYNY3gD4aOLEO+PRKoKna/4PtqBz9A3hzFJAXWK4Pod0ZP3o9d9M1NjZ6XM7pdCI3Nxe5ubm01k0bgvyu5Hduq5ARJg0DZMVzSmqh9Pw08sVGo/Seq8b7gnzkXpyrRDq3XZI548ffnJ/m5mbMmDEDM2bMQHMz7Si3B4prXMZPg9WBJlr41iMW3pgx6Ty3VX+lrmnboqiy5wvu/zO7/F/3yO/AyseATy7zfR2xsQNIw97YyHk+CJ6fACImEswG6MC1zWY747ntdT8fmPMTYIoHTm/l8lbqy4I69g7D5zOA8qPA9g+C2kxww8IRiFarRUJCgiCnbTabFaV+HQ4HqqqqAHDy21pt8J1ESvhgWRaNjY0oLS1FQkJCm/+9iJFg0muRxIsShNTzw48mmw3BX6ebz+2G6cM7YU9BDW78aJsQF11a14xjpVyyalfe82N1OP2S7HY4HPj2228BAIsXLw76WCmtT1GN9GV/pKQOQ7MTWudg2gAuz4/ntiqovTl981zQtqVCOKIHagoA1gkkdAn9tsOB3hz4uuVH/V9HEubmlH1vWc9PaV0zFnz2t6CIGhelx0szhqBHagwaSLi4P56fpmogKgGxRh104NZ3QINvv/0KgIe2lz0KmPs75/kp3gd8PBWY8yMQ3znAM6P4Q7szfgBXvSF5PSExTqcT5eVcxfq8vDyhaCglsklISFCtB9WWsPDCAAadBsm8KEEo1d7IaHsojB+AG9Uix0lCA9YdcY1U9UyLET5b7U5EhWi/lLZHsSzU7dp3N+PI01Nb6WgiHwtv/Bi9FFYUjB8a9hYkITZ+HDbgVb4swD/zgKjE0G4/HOhdddvwx3+Bs+8E4nxU2w3EWBF7epw2wC4SOWjhnJ/vdhZiW16lbFoBHp7S13/Pz6ongA2vANd8glhTLzh4z4/HsDcxGQOBecuATy4HKo4BH03hPELJPXw9HUqAtEvjh2EYZGZmIi0tDTab8mh6Y2Mjpk2bBgDYtWsXzOYgRkIoLYJer2/zHh8CCXUx6jRINHNGRUVD6IwfEvbmbTTZH0gSKHlBEA/QmO7JSDC7VOWabQ5q/HRgiOfnymGd8MPfhbDYnWiw2AOKo+8ICGFvXtqqTsvn/FDBg8DJ3wIc+yO02xR37N8YATwcnApViyBOsN/0OvcXnQpM+A+nSuaJQIyVlY+5Pltk0tby7ZUf545n/CNAXKb/+1KippD73QddjeUHigEAt5/XHSyA9/48gcPFXK0hQXzE12fVhle4/5f9EzFDfkEDvAgeKJHSE7hpOWcAVeZyHqDZPwDpA7yvSwmYdv020mq1qp1lh8OBU6dOAeCKqIqluCmUcEM6PAadBsl82FuVj8aP1e7E2+tyYdJrcNt53RXDOl2en9A1caIcV2+xw+Fk0ciLKnRNNkOrYaDXMrA5WFrotANzuLgWZbwIxr8v7oeVB0tQb7GjuLYZPVJjvKzdMfFV8MCV80MT9gPmu1tCv02HaIC1sSL02w8FTgeg0QJVp4Dmaqnnh9BQBvx6r3fjR3y+LAsovH/cyN/k+myplR2bzJP05gjuf7sFuOpd79v2hXXPAH8vRdP2T7Hn9AMAgGtHZaOiwYr3/szF4aJaWO1O4b0ca/Qzp5jRIC5KBwup8+OP8QMACdmcAfTplUDJfuDji4Ebvgc6j/BvO+2cTbnlOCdE26KxXhRKK2AVPD9awfNT6aPxs+ZwCV5ddRTPLjuM7XlViss02ojaW+g8MOKR+0arHfUWqYFFErap3HXHZeWBEuFzcrQB6XFcDYuSGppwrwZpL0YvggdU6joEWBu8L+MvQUruhp0jy4Bns4HNbwGvDQbevyC42jpOkfHjawhc9mjX59oz0nlqggflR/w7Lk8c/h0AEFWyU5jULSUanWKADcZ7sMlyFRqLXfuLNvr73mRwxdBOLsEDZwBd65g0YO6vQOdRnIH6yWXAyeAUzdoN1flA1Sm8vtLDPcGyQOkhnzdJjR8KpRUQcn60GqEQaWF1E8763yr830/7BeNICbGU8Iky5erYgtpbCI0fo04jCBk0Wh1CcmgM/6Iw8iPXVO6640LyfeaNzYFGwyA9jvOol9RFeAexFSHPAq9S1zTsLXjkHe1QKL3aQ6fSGRa+uI5TW1vxCPfdaQPqitWX9yYIIQ5T89Xws9S5PssV5sTbE/8ejsCEEL7Ylo+xz63ByoOugRh5HtYlgzPBMAwSSragM8Plfpu/vpZbVK+FTutn15hhkBhtQHIU10armwP0zkYlArN/BLqdB1jrgc+uBo6uCGxb7QWHDVg4CHhtMHpHqwxesCyw71vgwwt93iw1fiiUVkDw/Ohdxg/A1c1ZsvkU5n68DTWNyvlq4top//p+H175w300pLaJWzc+KnSS4AzDIJo3puotdjRYpTURjILnhxo/HZU9BdUAXAIYGbzxU1wT+g7i4o0ncfmbG7BDlrzc1mi2+Zbzo+cFEew07C1w5PklzhAobDoi3PjRGtynNSlHDADgas94Qhz2VpELNPrQ/ppr1edJjCmRR8rTMXrgke/3obC6CW+sOeaaaE4SPkajCbEmPeB0wATXuRhquTSIQGSuSehfqplro1WWIIxqYwxw/TdA76mccfnl9cD+7wLfXltHZGCn1Kt4fliWyxPzgw5r/JjNZtTX16O+vp6KHVBaHCHnR6tBjFEnjOoSNuVW4Kq3NyK/wr1eVUmt9GX75trjEk8Ry7KoCYPxA7gMnUaLy/Nj5qeRkWuLH2pUtB22H5qsDuwv5Do56bGc0ZMez3t+wlDs9PFfDmJPQQ3eXHs85NtuKViWFTw/3tTe/K3zQ9uWAqzs2pUfA3YuDs4DFOlhb8ZY92nN1erLF+/1vL16kdfovfOBF7p5PwZ5no8YceicTXQtPa2jgl3UNiQ15zSu92A6U4Vri14AXu4LTYW7bHfnRIV8KK9w7+9kMzeA0ejQBNf29Cbg2k+BQTO46/PtzcDOJQEcVztA1GZjG/KUl9nyFhCf7ddmO6zxwzAMoqOjER0drZgwTqGEE5fnRwuGYYS8HwB45ZohyIw3IbesAVe8tRH7C2sk65KO5O3ndQcAOFkuZI7QaHUISdGhNn5IDlGD1Y4GPueHhL2RkWt/PD+0HbYfDhW7Oitje6YAEHt+QttBFN9jxAhvizRaHSBle8xeFKZ0fMiprzk/tG0pIE9Ef2cs8Ms9wNFlgW8z0sPejHHu0zx5VZqqPW+v8qT7NE8hak6nNOxNDqvi+bHUAnb/FFDzKlxhUeKICrGHb5JmJ4aW/Qw0lAJrnhaml+g4qe9uKSIlPF9huK50chT3f3kjG3zb0+qBK98DRswDwAK/3A1sejOwbbVlRMZPcnM+AGC/Mwf/7v6Na5k//gOc2ujXZjus8UOhtCakA0NGc8XGz3m9U/Hj/LEY2CkOlQ1WPPL9PrCiOOxSXk1rYt809E7nwotOV7o8RMTro9MwIRU8AFwSoA0WuyDQQGSuXcYPzUkAuFFINoQFFe0RnutxqIgzfsb1ShFyzRL5Dkh1U+hk3AGpse9jzc+IpKiGO49Yo86rvC4Je6M5P0FgileeXl+iPN0XIt74UfD8eDJwGiu4IqTNNe7zWBaoynOf3lwDFO4ECne5z7M1wmNtJYnnRybE0FAGf6iodz1niBopAMDhmj5Nu1VxXcbGvUMDUqXkDZwU3vOTX2PFsn1F/m9HjkYDXPIqMPYe7vsf/wHWPhueQr2Risgrm2krAABUsrEobpQZlZ68mQp0WOPHYrFg7ty5mDt3LiyWCH94UdodQmFDPlRsxsjOSDDrMWVABq+SZcKSeWch2qDFvsIarOBrE7AsK3h+0uNM6JLEudTf/8tVW4IYPwlmfchHfImyW4PVIRg/KdGcopcr7M13z097bYdbTlRg0ON/4KbF20OyvVUHSzDg/1bg7i/+Dsn2wsGxEk58o1+ma6Q5jo+fJ/UzQoVY9COUxYFbmjPVXFvOTPBeakEIe7P71vFpr23Lb6rzOYWz/d+pGypK3hFfEW8z0YcQsJZG6dw8hZQ1VgDvTwCe6+JuJDXXKK/73c3A+xO59WwyL6+3sEDx9ZMbP34apQ0ig6de7BEW5Sl1Y5SNEgOf/0O81f7BvWcTuFchmm3AdTfMweUzrg++7TEMMOkJYOJ/ue/rnwNW/LttGEBHVwAFO70v5wmRZ7ArOKXAGkSjvCG4d0qHNX7sdjuWLFmCJUuWwG5vu2ETFP/4aXchpr3+l8RT0hoQz4+R79DcMq47dj92Ed6ZPUIwWJJjjLj5XO5letdnu3DgTA3qLXZByS0tzog0/kEtDv0ho19ib1KoIBKgDRY7Khq4h3oSX6coEMGD9toOf9tbhCabA2uPlIVEAOK7XQWw2J34ec+ZiPUAneJDTsRhI3F82GVtcwgSy0UUVLnab7WKMEhbgKjjZcR7zzPQ+5nz017blt/s+Qoo3AF8exMX6qTET/OBRWdzHg9/EQseqMk2tyZKnh/CeQ8DOeOk0xorgbLD3OcTa6Xz1CSyxcvZZNfQm/Gz/F9A2RHl7fvp+SHlFwAIYdkAJJ6fOEb5HDS8dyoxOoBQcTLIyHuxspJiULt3FX7+9gucLvcQ8ufP9s97EJj6Avd9y1vAz/8IrOBsS1FTCHx+DfDBRKmhVrjLs9qgHFHYWxpTDQCwQo/y+uAGvTqs8UPpeLAsi3u+3I0DZ2qlSjCtADFgTF7C0m45rzvio/RwssCVb23CiTKugxlr0sFs0GHGiM4ApDkVpbyscBpfYyWUEMGD4ppmIa8oOZqEvRGp68jsnLck1U2uDnlpbfCj7uJRzJPlYahVEgJO8QMKxBsJuDw/tU3h8/xUN1rhbKOxb0SVMcnsvcNFpa4DRKmgpxx7M1B2CDj4o//bF3suWmM0fsdHwLGV6vM9GT9Om3selNjgqDjuvrw35LV/5J4gJX7jCo9Kcn4A/z0/oudkg0rYmxyrIQEAwCCIPFk+54ec+7ShruT7uz7bFbq8xNG3A1e8ze3v7085j5ufeVFBc3wVkLfB+3LiPK863ttWvI/zDr7cx/f9qRh41UG+U6jxQ+kw7D5dLXyWjAq1AiQMKNaLrGacSY+XZwwBwIkk/HmUezGR+ilZCdyLvaTOAgffAczjO8dpsYG47z1Dwt5O8yPv0QatkOtDipz6E/bWHrE7nPhlj6uQ37HS4Eb+mm0O/HWsXPi+cHXrGu5qlPG5aOmisJE4E9eRqGu2hTT/Sawe52RD71lqKWqF54Avxg/x/LRNQ6/V8EfOurHC/+2LPRtyNblwU5EL/HofVw9m5xJg9xfuuTqMh26e3col1oupF3nHKnKl8xw+XEu5p8cXNbyKXC4scfcX6sfiAxLjx2J3PXM8CDI0pwwEAGj4AqXxUQFETJBrzF8fk8E18Hi4uA73fLlbeD8HzdDrgRmLOQW7Az9wUtiBeCwDobYIWDodWDzNu6Evvu+IEX3yT//3qeJNDfZqUuOH0iE4eKYWV761SfheUK3ivm8h6kmnx0uSMwBM6p+O8X1SAQBLt3K1CNJ5r05KjBE6DQOHkxU6n6+v4R40abFh8PzwnioSNkhC3gBOuQ6gnp+/RUY2ALy7/oTygj6yOVfaIWuyRqZxSY5LXB2dhL05WVkMfpDIQ90aIvSaeIN4fuKivD8H/A17o/Aoddh1Kt4gX2rWyBF7fuSj1Jvf4jqoocZh5zwqVlGR61/uBn68g8u9EeMpFM9hdff8WETGU7lsoMUn40fm6fbF+Kk7w4Ul7v1SOt2fsDdLPZx1Lk+RkxW9izx4fkxmTuBAyxs/CT54Yd0hYW/89dG6rqlBp8GqQyV4btmhALarQv/Lgeu/5O7j4ys549dTLaVQUSG6H7wZ+uL7rpb3/AQiC6/g+THotHAGab5Q44fSIVgkqwVyorQ+pCPR/lJn4R6Svoz4AsCwbK5CNanx0z2Ff2BrGKTEcEZOaV0z6kQj4Bf0Sw/Z8RJI2Fs+b/wkR7sMLFfYW9vsiIYKuaxzsJoTFQ3SF3ddBHo5bA4n7PzIplnvevGb9FpBxYyoFIYCuchBpBqE3iAeqzifPD/cjWR3sm02zK9VUOr4GlTkjAMprCkJexN1CMuPASseAb6ZG/pwuHfHAS/1VlZkqzgu7QjLw9AmP+P67LC4Gz9iCndIDUJyLWM8vFsCMX7UsPoR4rtwIG7bNgUpcF0TYcDFg9FmMHH3QnBhb/xDnnhgRNf0masGAQDe/+skvtiW7/+21eg5CZj9PSdocWoj8MllgRnv/tDgikBwu6/kiI2WJv64AgnRUzCyTF5qovkCNX4oHQISpnXpkCxoGKDOYhc8Ja2Br2FvhFvP64aXZwzBU5cPwPPTB+HBi1wxs2Qb9c12kVFiwFndkhS3FQxkVJ8YYcmiWgpU6pqDdPKjyPXwo+irEtV8R58YuaFWTgsFjSLjI0qWx5bJFzotqg5drR+556ctGj/HSurw/a5CAD6GvYle+LZginJ2NJQU3nQqIcG+eDbcti8Oe3MoT/enE+8NpxMoPch5aApU1CRLD4qWFx3TP08BY+aLjlHB8+O2LZHHQvBseAgNC6Xx44/RyBuuozSHhUlCeKwHzw/xAhLBA+Jh9Q8GaKgA8v7ivmYMEuZMG5SJ+yb1BgD898f92Hi8XGkDgdH1HODGX4CoJODM38DHF/snJuAv3oyf4n1AKX/9xW2BGGWB3AtKxo9eCxbBjSpS44fSISCSsref111IyD5eVu9plbBCOrDeansQzAYdpo/ojNljcnDtqC6IF7nmY4icsMWO/ArO+MkWJZ2HEpLzQxAXkiMV6ps7eM4PEZzITuJeqs1BdsyJpHgXfnu1TZHn+SHGh1bDCB4KQiafl3amJnShpnLPj6SmRxvhHyLZ8uQY73kGBlGnjOb9+IGSQaP17bnr2/ZF96K4oyY2sJpCOCIvVlNb/aTyMsX73I/pkleBqATpcg6Le86PHHFoHbmWWj0w8yvAoCCm4JAZP74IHqgRgHqeHq5ngaDq6tH44dqeBk5cPCjD7/0B4Dw/x1dx+8kYBGQOkcy++4KeuHxoFuxOFncu3YncUPY9soYC85YBsZmcaMdHk5VrMYWCRg/GT3Mt8M65wFujOYNbyfPj6XdQQynsTa+Fkxo/gWE2m1FaWorS0lKYzeHpKFIiA5vDifJ67oGcGW8SipjllrWeahZxx8f46PnxhLjwKFHc6pocnntabqwlx4jD3vyXum6P7ZBIjXdO5M4nWGOwivdydE3mwjMi0fPTxP/mZr3WrbYUyT0LlafV4WSFWlakJkdTGwu1dDpZQbnxiqFZOL93qtd1xCPSvsidt8e2FRCkwyXuqKt6OwIwKtUED8SdtkCEFNTwxYtUst/9OBgFZVFfPD9i1S5i/Gj0QJ8pwCOngYuelm0zAMEDNcixb34LOLJMfTmRh8jAiIyfqkbOUyY3oqISgR4XcJ/TBwAAtAyLRdcPD+w4GcalaJY+0K3tMQyD56cPxvAuCahttuOmxdtR1RCAIaBGWl/gpuVAQlfO8PloKlB2NHTbJ0g8P7JrKs7PclilbSHUnh8d9fwEDMMwSE1NRWpqasgLQVIii3pRZzE+So+eabzxU9p6nh+iiEYMhmAgBkm9xY5TvOena5g8P/GyZFBJ2JuOFDn1PSSnPbZD8lLL4gtXBhuSRcLeiMey3mqPuJwP4nmRh7wBQCJ/z9SEyGNV02QT+joZ8aG5xi1NRYMVVocTDAO8OGOIT88BrYaBhqQW+GD8tMe2FRDEE3HWrUDWMODsu7jOu+KyAXRIxXkM4nBEpbCf6tNArUsJMiCsPry3xCpt5Dg0CvdY5mA/jR/+XEnYG8MAg66RLi8Pe9sjU3DzB9YBFOzgcqe+uE59OZEXQg+78KwsqGpy90QB3O90w3fAvfuB/lcKk5lAc7MYjatGkT5Kse2Z9Fq8N2ckOidG4VRFI25fuhPWIEOiJSTmcAZQal9OQOLjKcCZ3aHbPiCtk+Up58dhkxpHxGBXKzLsCQXvn4GGvVEo3iFeFpNeA51WI/L8tJ7xQx56hoDii6UQaeHCqibkV3IPmXCFvXWRbVccrkM6cJY2NgofaiobifHDh70FeT1I2Bv5TVmWC3GMJMg5Khk/CXyx3VCNdJKQt1iTTjD8/TG4IwEiipEWa/Qrx0DXFuWuf70PWDQ6tHkv/kC8FVGJwG3rgCnPqnf4A+mc+eL5aarikuEXDgRe6RdccUpfrqM41I90UsXnfOcm4ILHgLH3SKcryWKLjR+yLXHYoE6mKiq/hsdXKR+jJ6NLzwtSsE6gtlB9OYLIaNXDLgw81TXbhZylGlYkcuG0c4ZbQrZUkSZgqXLGVaNIr/7uTYkx4qO5oxBj1GHbyUr854d9oRVeissC5v4OZA7lvI1LLgXyt4Ru+yI1PTfjR3weTrvUaCG/TyDtS6GtmPQaGvYWKBaLBfPnz8f8+fNhsbRe4jsl/JBiZ6Sj1CONewi2pudHMH5CoFpCPFmHiuuQV07C3lTUjIKkU0KU5F2RFKTgQXtsh4LnJ54YP8EKHnAdmfQ4o5BXtfVECMNoQgARPIhS8GAQ6djqEHl+iCcsKdogXI+2VluqvIG711Ni/JOjJ4MlNh+MvYhpWzs+AsoOA4d/b539k46XuJOulvPjr+fH6ZDm87Bqnp8KV1hUIPsRI875IeijOeNu+Bz3fSuFvaUPAMY9wBWAFRshWoX7UexpIoaeWPDAm/GjhprcOOBS43M6fDNIRPu8VrtOaFdNVodw3XPZTNfy4o672CMWqPHDMC7Pj87kse31To/Fm9cPg4YBvtlZgHeCLIXgRnQycOPPQJdzAEst8OmVwPHVodl2vUhMQW78iL/Lw96IMR7CsDdQ4ycw7HY73nrrLbz11luw2yNrFJUSWkjYG5FpJjLRZ2qaQ1d52U9C6fnpxRs/fx4tQyFfvyhcOT8mvRZXDu0EvZZB99RoDOuSKJrnv9R1e2yHlQ1Sz4/V4QyqwB3xdCSaDYKHg6j6RQrE+DErhr1xHaXqxtB4fiobuBdpgtkAo97/UMtIoFr0m/oDEZPwpdZPRLStYDwcoYKEpYkT+0Pl+flyFnDwJ9H6Ta6CmvKcB7HB400m2BNKYW8DrwIePgn0mcZvX3TdyXFoVN414usiN2QAqefnFF8rL66TaH258eNjB1dpX8I2+XbBOn0zSESergGaU0jl8wwbbQ7Awl2velZkbImvv9jbFYznRxT25q3tje+Thscv43KNnl9+GMv3F7ktExSmeC6sr+ckzlj+4jrg0C/BbZNlPXt+xPe3POyNzAvE6Ff4TYxqYcKeDGoZHdb4oXQcBHEB3vhJjDYIuSony1snFIPE7IfC8zO4cwJ6pLo8PaO7JYWlwCnhlWuH4tj/LsaaB8ZLaiLQIozcudfyxjYJvQACD31jWdZl/EQbMG9sDgCgvD6EybIhwGPYG3+PyOWpfWHriQp8u7NAUDEExMagHkYdCbVsW/ccuRbyHDpvkDbmS85PRCCuQxNKhTV/kOepAKHL+TmqkIT/xbXc/+L8n8YK5VC0QFAKe9NHcd4H0pFXCr9TEjwApJ4PJYNE7Gkq42WMe10oWl/2DnN6aOcZg12f1WotAUBtAb8th29y17LfjXh+mq0OwMoZbw0Qqe+JPWOhMH4YqfHjC3PG5ODGMV0BAPd+tRv7ChRqNgWDwQxc9wVXENVhBb6+EdgdRP5VU5U0f0o+sCG+Lx1WWdgbv14g973CAAoxfpysyPsz6Bou58lHWulpRKG0HA0WUnnedbv3SI1BRUMljpfWY2Cn+BY9HpZlhZj9UBg/UQYtVt1/vrBNvZZplQRnko9gj7Bk/JaEdGoZxpWLBXBqZNE+ypqLsdidwu8aZ9IJL/XKhsgKEXSFvbmfo5Dz46fxc6ykDte+x8Wrd002Y/1DEwCIwt7MBqH9tBljgIdci8QAjR97W8n5aa52fQ6kwGEoEIwfUcdeKfkfCCwnQQ7JcRF3/poqZcZPiHN+SIebGCLifXsSPACkhqBS2JvTwRlyv94LnFjHTTMnqx+f2FgRX88LHgP6XQ68OYL7bvLw3s0eDZzeynt+/DN+aliz4FFttNkFz08jTDiI7uiPE0Cfi13rSoyfAH8XRuNS9DPE+Lzafy/pj7yKRqw/WoZbPtmOn+afK4i4hASdAZj+EWC4G9j9GfDjHZzn8Kxb/d9WfYn0u9yQ+XiKdJ5TIewtkPte4Tch4c5OMEJ9Joz/F6D3rppJoJ6fds7egmo88v0+PPztHqw8WOJ9hXZIvYVreGKZ5h5E8a0VRA/EHbVQGD8Ap+xk0Glg0GlaTdlJx0tRBRPi1dYhXomEKD30Wo0QBtZoCeylKi4eajboBI9lRYR5fjyFvSUIam9Wv5J7xaF9hVWuGkHisDfSftqayEa1cJ+EL+wtIhDn+Vjr1JcLJ+LaNAS12jZKymCBIpe6trvu4YCKqRKUjB8S7iN4flgu/K76tOs41EL9xNN1Cvcj6wROrAF2LXFN82S4iM+7udb1eey9UgNMXnMIAK56H5ixGBh2A79vWc7Prk+U9ykyfuoRJUQkNFkdwvWqZ014JOoxYMrzwBVvudZlZDk/Tt7g2vctl6/mC6zTVXA2a5hv64AbMHzj+mHonR6DkloLbl6yPfSh+FodcNmbwOg7uO+/Pwj89bL/2xGHdwLe1d6UBA8C8awprKPTaBBr1AWl+EaNn3bO/347hC+25ePrHQV46Ns9rX04rUJtE9dI40xizw8vetAaxo8oPyEUOT+RgpY3fjqy54fk+yTyRgoxuOssgXV2iIS0QaeBVsMIsexFNUHUzggDQtibQiw2GYW1OVg0+CFJXS/qBNidrNBuqiVhb20z54cYr74UNxXT5sLeTm91fba0ksAMMWgkYW9qOT9+Dip4UPZyk7oWF/sMRc6P+Bz0vLeAdOSdDuDLmZy6XOEO6Tw5Wi+CB06HK6SL4Mn4kXi8qrj/jXGc4SM+ZlOC+7qDZgADrnQdh1zw4Od/KBt/IuPHBKsw4MIZPy7Pj9WUApx9BycOQRB7furLgFf7Az/cAXx3M6dUWHJA/VwJxfu4/ZjihbpBvhJn0uPDG0chOdqAA2dqce9Xu0NfykCjAaY8B5z3MPd99ZPAyv/zzatGqC+Vfvdo/FiVc358ve9ZFtj/PafUp+ItSooxBFKVS6D99LwoiohzWqobbUHL7rZFqpu4hifOTxE8P6Utn/PTXo0f6vlxKb0l8R1+UsS2PsDCpKS9Eo9KTgpntJ8sbwitRGqQeKrzY9JrBA+NP3LXtbJrRgqZEgMzIdrgyvlpY8YPKfia6mdunr6tSV2LvdCtJnVN1N58yfnx0/NDPDjEU0FgWXep62N/uL57yovxhpX3iIoNEGKEiXN+xPsD1AUPvHl+nHZ3o0jJcBGWF513dT73f3xn7n+xx01sgADA1R+57hfiIWIdcCs8q+Q1E00zwery/NgcgmBDPRul3N7Exs+fL3DqcHu/dE3L3+y+jtv++Xus67nq4YUeyE4y4705I2DQabDyYAmeX37Y7214hWGAif8BLnyK+75xIfDbA9LwNE/IhTYkohqy38hN6trmmq62jpgTa4Fv5wFvnQ3s/FhxkTiTHqzYhPEz4qX99LwoAh/8dQJXvbURV721EaWyqurl9ZGVK9ASkOKK8SJlpZ58rZ+T5Q0t3lkno7Y6DQONpnVC1MIB8fy0mZCcMFDZKPX8xIoK0AaCEE7Ge1S6JJmh0zBosjlQXBs53h9PYW8MwwRU6FRuMJJCpmdquFHozDhTm5W6LuOfw6l+Sl3rdb5LXUcEYk9Ka9f5kXh+VDqoVXm+5yWwrMuIOfd+6Tynw13qetu70vm+Iu8kkusoNn50vOdHYjTIUBU88JLzwzrcjSJTnIfjFRs/edz/CV357Yu2kzXU9fn+Q8DA6aJj5d+LLOse9qTUyRXlFhlhE4yfRlHYWyOMyFLKpxFvb+9X7vOL9rpPU4LRcPLhATKiaxJevJoThHj3zxP4ant+wNvyyNi7gUsWAmCAHR8CP9zuWximvP2KDRmLLKTVF8+PpxA48TU/8IP7fIZBXJSOen4CISoqCidPnsTJkycRFeW7PF6k43SyeGH5EezKr8au/GoAXG2WTL7Rn65s8rB2+6SGD3sTe36yEqJg1GlgdThRUNWyssGhrPETSej4kUV/jMn21g5VPT9BGj8m3qjQazVCsVNS0ykS8BT2BrhyW6r8kLuua5a+kInnhyi/dUk2u6Su25jaW6CeH4MfOT8R0bbEnpRgatsEg10h7E0t5wcAlj3s+mypA5ZcBmx73305cedOKzMOHBbpiLq8No+vOT8/zQcWDpaq5pEReInnh+T8iMLe5KgKHngoWEq2JTeKPIX7ifdddpT7P6kbf8wJ0mUX7ADuP8wV5xQjPg95J1nJYyC6t3SME2Ytt47F7gRLpK4Rhcx4hXbAMPBYM6bYR+Nn9B1AZ07MIdC2d/nQTrjngl4AgP/8sB+bcst9XtcvRs4Dpn/A/fb7vuaU4GxeBtPkBo7YkBELmwAKam8Knh+le3Tts8Dn1wKV3msfcZ4f8e8WRs/P448/DoZhJH99+/YV5o8fP95t/h133CHZRn5+PqZNmwaz2Yy0tDQ89NBDrVKDQKPRICcnBzk5OdCouYPbIBUNVlgdTjAM8M4NI/De7BH4/q5zhLj7n/f4UC25nUFyBMTGj1bDoDvv/TnewsVObSGUuY4kdFr/c37aWzskyfhuOT8Bhr01KXhUSIc5kry4gtqbgucHEBU69UPxTW4wNlrtqG22CeFwnROj2mTYW6PVLpxbwGFvPrSxiGhbYs9PMHkuwaDo+fGgvLj9A9fnvz8DTq7nksTdtis6N53Mo2C3eFYO8+VasCzw91KgJh84IpLwtSmFvckFDxTagy85P/LzANw7qYzW3fty4ZPS4yaQnK/OI7n/xfdhYjcgpRcQJyo+ShB7sOTGjtK5yYzJKI3oe96fAIAG1qTe3jyFqjX4aICMvt21uSDa3r2TeuHSIVmwO1ncuXQXToQrL3nQ1cC1SznD9shvwOfXeM7Lcwt7swMNFZxHiOR2EWzNUuOfDECIp5HfkWWB5Y8Af74IrH8OOLpcKq6hCIM4kx7OlhQ8GDBgAIqKioS/DRs2SObfeuutkvkvvPCCMM/hcGDatGmwWq3YtGkTlixZgsWLF+Oxxx4L+AQoUor5ROjUGCOmDMzARQMykB5nQjc+wT+QWhttHdLRiDVJX3itJXpgCWGB00iio+f8sCyLJZvzAABJ0VxnP8bI/R982Jvr3iWKb+uPlgV6qCHHFfam3KkMpNCp3LhrtjkEI9Kg1cBs0LXJsLfyOu4amPQaiQKlLxA5+TYT9iapC9JK7x5/6vzIkYxeyyvai85H7jFx2DyH9Xi6FtZGoK5YKi0s7pwrhr3Jpa4V9q1m8IllqxXV3mTeF2Os+zJj7wFG3uRaHuA6taQukLi+z11bOFW37uOVjwfw3/Mju54mcN+NsILhi67mslmCJ94Nj/mTKh1s+Tqe5L/9gGEYvHj1YAzrkoCaJhtuXrIjZAWi3egzFbjhW0AfzRn5n14JNFUrLysPe2uqBl7uDbw2FGiQvYvsze5qbywrk2Dnf9eKXGDLW8Cap/06dC7sTfTbhDvnR6fTISMjQ/hLSUmRzDebzZL5cXGu2NA//vgDBw8exNKlSzF06FBMnToVTz31FBYtWgSr1f8fN5jkfavVioceeggPPfRQQPuOVIpIPLwstvWKoVxF5tMtHOIVCSiNngNcrR+g5UUP2mvYm6D25kfOT3tqh59tzRcMv17pXAchNkjBAyUhAWJgrD4UOdL1riKnyvd0IJ6fUxXSZ1Wj1SG0ZXI9zEHmVLUGQr5PrNFvWXp/wt4iom2J67zIjYeWQkntzVOBTTHi8K66M7Ltis7HzfixeM7rUZvHstwI/KsDgBPrXdPFYUVKxo8vnh8170ZCF9dncXhbNF8zRZ68rmD8VNRbsCGXH/0n5/bWGK4TDLgEDwAgrR8w+BrPnVXB8+NUMH4Uzk3mSdM4LIgz6WCAa/pJNhMxRpVr4LG+j4phJP8NRfV9gm17Jr0W780eiU4JUThZ3oA7lu6UCCWFlG7nATf+zIUkFmwDFl/Cqd7JkXuFSg7w3p9SV3gjwd4svX/BC4Ao5fzYA8td7ZxobrmwNwA4duwYsrKy0L17d8yaNQv5+dKkrM8++wwpKSkYOHAgHnnkETQ2ul5gmzdvxqBBg5Ceni5Mmzx5Mmpra3HggLqcoMViQW1treQPAMrrAg/7sNlseOmll/DSSy/BZms/3hCSBC0vlJWdxD0cO2LOD/G0mGT5CK1V68fabj0//uf8tJd2uLegGk/+chAAcOu4bhjfm+s4xATZOSchXnGikM3LhnLx8doIEsvwVOQUCKzQKcntIQZkg8XhNpBB5gUaVtgaCPk+foodAGK1N+8doVZvW06HNF+i1Tw//H7FXg1xZ1yJ/d9z/4tzdWqLpMuQ82E07l6VhYOAre9CFbWwt8KdQN5f3PyDP7qmn97u+kyMH6NIdEBJ6loOo/K+Se4p2o4oP2Xwta5tibdHjCIRX+8owLEy7lrZ7HbOe1V2SHm7viAYcQpqb3Ljx2F3P9/aM5hu3Iq5Wle4oA1awRPvkZTesv2pvM/kBpPImAtF20uNNeKjuaMQY9Rhy4lKPPrjvvApfHYeCcz9DYhOA0r2cQVLawqky5A6XSRvSxz2eWqjdNnaM8Cez6XTHFZl4yeQwrIMg9lnd205wYPRo0dj8eLFWL58Od5++22cPHkS48aNQ10dd1Guv/56LF26FGvXrsUjjzyCTz/9FDfc4JKALC4ulhg+AITvxcXFqvt99tlnER8fL/xlZ2cDAKy+SvR1IEj9D3liX3YiN4JV02RDbXPb7WQGgjBaLDd+WinszdpOc360ZFS6g4W9VTdacefSXbA6nLiofzr+fXE/YUQ/JsjOeY2oaCqhWzJ33zb6UTMn3HhSewNEnp8m30ZBrXYn6niDsW8GN9Jc2WB184QFq6bXGog9P/7iqvPTBtqYvCBlq+X8KIS9JWS7L9fvUtfnb+cBn1wuDQFqkNU5IUaVRq9sWJza4D5Nvq6cbe+5Posllvd+CRTw9XqEnJ8E13y3Iqd+eH5M8cD1XwPXfS41qIgng5Up1ykU8Txd1QgH35202WxAU6XyvnyFnIfT6S7FLD6Ww78Dz3ZyV2kr2Y//s7yMB/TfcscEHVhoEK3m+SF0PRfof7n6/sT4o9gXIH0yYvHG9cOgYTgD870/vQsBBEzGQOCm5UB8NlBxHPhoCle/qKHCldsDuIrTivN8imQ1JGtlXlKAM6aq8lzfyXX1dB0HzVCdpdEw0Ijv6XCGvU2dOhUzZszA4MGDMXnyZPz++++orq7G119/DQC47bbbMHnyZAwaNAizZs3CJ598gh9++AG5ubl+HZScRx55BDU1NcLf6dOnAfgXXtNRIDk/cs9PtFEnJPwXVUeORG5LQFSi5J6f7ikxYBhuNLrSj/ojwdJew946Ys6P08ni/q/3oLC6CV2TzXhxxhBJKJPL8xPYgEM1Lw1NjAcAMPGhZU02R8TU+nGFvampvfFS1z56fsTGTA5v7JXXW9Bok3t+uO22Sc9PEMZPm3j3Hf5N+r01wt6cTpfRJTZ+4jq5L3vZm9LvJ9YBx1a4vsuLPIqNKj87XooJ3fVlUllfeRL5wR+BqlNAKedhVgx78yR17UmhrfdkoO80qYFk5I2fk39KjcCJj0pWbbY58PnWfJfxY7dxRV0JYxao71cNieCBh7C3L2dyYVNHl0uXKd4n+Wpjue15zbGLTZcagICHEMWWGXya0CcNj13SHwDw3PLDWHFA3VEQNMk9gHnLgKQeQM1p4J1zgRe7c3+kHRGjW2zg1pyWbkeu/gYAi0ZJv5N3l6fcOCXpdRHBlAoJqveVkJCA3r174/jx44rzR48eDQDC/IyMDJSUSOPUyfeMjAzV/RiNRsTFxUn+AMBmj4wXf6TAsix++JtTc5Pn/IinkToZHYVmwfiR3u5RBi06JXAvjZZUfGuvYW9akfETKZ3ycPP2+lysOVwKg06Dt2YNlygKAqKcnwA9EyRMLEFUo4p4MFk2clTOBI+MmtQ1ETzwsc4Pkbk2G7RIj+OeW2V1FjcvbrBFZFsDV9ibgrKWFwy6CK2lxbLA8n8D2z90TZPn1bRG2Js4NEds/Mg7uICycSAe0SYCBA4bpwAmGFVeOtSJ3dyn7f/Ofdrfn3iWA0/oCnwx0/VdXGtHnvPjdLiLOohyUnxCnNvz3c3c/51GAOYkyWLk3UkKThoKNgMr/8vNNKcAkx73b7+AK3yPdcJr2JsSsgR8C4gAjTfjJ9M9hFHusWRZIHcN8IfUCAwnN56Tw4V5scC9X+7G/sIa7ysFSkI25wHqco77vO4TRJ6favf5xFhRE00Qs+19bkDBk0dYSYADAMnv0UqU9FqwyGl9fT1yc3ORmakgVQhg9+7dACDMHzNmDPbt24fSUtcIysqVKxEXF4f+/fv7vX9rpL0AWpkykTrSwE7xbvOz+I5+R/L8OJ2s0EFU6pgJogctGPrWXsPe9KIHUUfw/mzKLcfLfxwBADx1+QAMyHJvc4LnJ8DOebVC2Jv4Pm6KkNA3X6Wufa3zQzw5MUYdUmK4F2B5vcj44UUfiHFpdTiDEsBpSUr5vMyUWLUXuzokry7iwt7O7AK2LAJ+ux8oP87V65DnAfha2yaUqBk/SkU6PdX+AVzehSWXAi/2AEr5nBZvynEpvTgjQI54gMjpAHbwlezVcnMaK4BSUW60OI9GXueHdbobm76IPIg7okrGksKx1fIDGg6+8xlVtofzmgFAal/v11UJsRHni+CBHFlNGhu454R8cMqNmHT345V7eI4u51TRdi52Tbt5lfdjCgKGYfB/l/bHuF4paLI5cPOS7UKUT1iISQNuWgb8X7Xr77EqYM6Prvtd7pkEXPlgSp4fOeueAT69ynPYm87kUZa+xcLeHnzwQaxfvx55eXnYtGkTrrzySmi1WsycORO5ubl46qmnsHPnTuTl5eHnn3/GnDlzcN5552HwYE7m8KKLLkL//v0xe/Zs7NmzBytWrMCjjz6K+fPnw2j0PwTAHmkvgFaGSKhqGFenXgzx/BR1IM9Ps0gCV6lj5lJ8a3nPj769eX60roePP7V+2iIltc24+4u/4WSBq0d0xjUjFXII4BIq8CfRXwzxGIklWnVajeA1bIyQDn+zLBxNDjF+/A17izXphJpJtc02V9gbbwBGi6S1G9pI3k9BFff87ZzoIQxJBX8ED1oUcSz/e+dz9Trk8retkfPjj+fHW+ep9DBnsJBcnN2f8dv10qF22IBZ3wBRidLpYinro8u50CFzMtBljHS5rmO5/9c9K50uDgmSS10rKWgpGD8sy+L11cdwx6c7sXjjSen1UjR+3Ns38eZGQWFgw5zoPs0XPIW9+ZJrIzN+rNDhrG5JglS8KpmD3XOj5PvLU8jlyh7lPi3E6LQaLJo1HL3SYlBSa8Etn2wXPO5hg2Fcf+TeIsaIOLSREM0b+b54fgBOXKFEXewMWoNHo10c9uZvtIlfva+CggLMnDkTffr0wTXXXIPk5GRs2bIFqampMBgMWLVqFS666CL07dsXDzzwAKZPn45ffvnFdR5aLX799VdotVqMGTMGN9xwA+bMmYMnn3zSw17VsVHBAwmkLkavNAUdfrg8P4VVHcj4EVV+N+kUjJ+0lhc9aK+eH53oQdSePT82hxMLPt+F8nor+mbE4qnLB6pKFhNFr0ALkjZalI0KYshHgufH5nDCxg9EmdXU3qJcYW++vKQEz49JL3h3apvsgoFj5hOXtRoGet7obguRACzLIr+SS1jvkhSA8UPC3iIk3FFAbPzIiyESWtP40eikBTZ9lbqWbMsC2ETvTvLZU8FUADixFug0HHhQlh7QXOv6TIQOhs2WHpvWAMSqpASIjS7ymXhMlMLnFAQPTpQ34JWVR7H8QDGe+PUgbFaR0aR0XgrbqOGNn3hG4XeXG3y+IqnzIw97U39+kNwe+T1oZXXonOhBcW7mV8BFTwPdzvce9pbSy9ORh5U4kx4fzR2FpGgD9hfW4r6vdsPZ0u9acg8E6/khLHtIfZ7OBBgU+rP8+1ZcQPbZ5Ufw/PLDPu/WrwprX375peq87OxsrF+/XnU+oWvXrvj999/92a0qwYx+RUVFYf/+/cLn9kC5FxUh4vn5/u9CvDRjSFDJYm0FInZg0GkUz9cV9tZytX7aq+CBWHrZV89PW2yHL644gu15VYg16vD2DSNUQ70AV1tstDpQb7H7XdSy0cZ39mXFQ6P0WtQ02SLC+BGrzpm81PlxOFnUW+yCUIEapEMVZ9Ihjl+2ttkmhM0linKgjDotbA47LLYIMwgUqGq0Cc8kkm/oDwY/PD8t2rbExo8arRn2ppWFGPorUEAQd+pIDSP5ttWQ5wbZ+HdOwQ4+TIzhCoUuf8S1jC5KffvpA12fyfkoeGY8cbrSJeXNsoDN2gyhZWoU2rJC2Nvaw1wagxEKxq2/eUbyfbOsX2FvjTAiHo1AubTujA06yTPDjT5TAEzh9y03fuSS1t7f2+Fse9lJZrw3ewSuf38rVhwowQsrjuBfU/uGdB8eIdfHrjCITowfXz0/3mAdQHQyUFugOJsR5fn8vPsMzlgUDDIV2nTvyxqE4IFGo8GAAQMwYMAAifXYliGJtCRGXs7o7q4KxOUNgddIakuQxOlYlU5nT77Wz+mqxhbLGSDGj7G9hb2JOhS+qlG1tXa4fH+xIDf64ozB6JbieQQ52qhDNG8ckVwPf1Ar0Eu+N4Q77MEHSLvRahhVEQ+TXisIjvhS6LSYD83NiDMJoYN1zXZUN3DrJorU74w6kgcT+cYPyf2K0msDGvwQwt58GFxo0bZVdYr7Xyy/TEjlO2atIXhgJ8ZPAHknSnx3q+uzUDw1wG1bG7nj+4lXQxtyHZDYVWok6Yzqxk9sOnDXFuA+UdiQDx1zMRuPl0u+13SawH1IG+Cz5+evY9w2zFB4vvlb34cgrvMjz7nxYPzUQ3l/VugkzwyPePP8+BB2F+62NzInCS9czaWTvLM+F1/vOO1ljRDiydMZzfcx5b/Z7X8BFzzm/76sDcCV76HGJFdnJMa+69peMiTLr01Hfm/DA21C7rMFIZ6fFJXieZ0SopDBKyd1FNEDImFN8gbkJEcbEB+lB8sCJ8tbxvvTXj0/Gg0D4vxpj2FveeUNeOgbTv3plnO7YcpAZaEXOeTeq/FR6UyMWv2c2AhSOROOUa9VDf8DRKFvPhg/Z0i9soQol+enyYZKIgAhGsUl7agteH6Iseq13ogKgvETqWFvCV3c5xEVtRaoi+KG4PlReCdO/9B92rVLPW9PXLuHeH68hb2JGX6j67OtEdjwClcM1JwCTH6G356ok643efZSpfWTFmxVq+WjwhfbpJ3moi7TgBu+B2YsVvYiyYwrlmVh59MPUgwK7Tpg40cU9ia/bzxITDezyu95G3SqfQA33H5PlpNMZ1muM95CEtfeuGJYJ9w9kStQ+58f9mHLiYqW2bGn+92uImiTORjoc7H/+7LUAWl98f6wH7DF2c99vqht3DXBv3DENt37CibszWq14vHHH8fjjz8Oq7XlaryEk1Le80OkYZUg9X8+23qqRY6ptSEdLbVRH4ZhWrzYqa2d5vwAEBJKfQ17ayvtsNnmwJ2f7UKdxY6RXRPxTz/CDEhSvr9FSVmWFUKk5KF1xBsSCQWLSdKtyUP4H+AKfbvm3c1eq5UXC8WaTYiL4q6f3ckK+YrSsDfe+LFHRqfEE42C8eNf+COB5Df58u5rsbblsLmqwY+62X0+6ZBHUtgbAAy6Guh1kXSakiqbGiSpnnh+bvwFuHwR8GgpMPoO5XUufQ1I5jqsKNwF/PkS93nq8y4JabEnSRclzTMiyI+bIPf8ZAwGrvoAmL/dbVGHk3WLdqhvtgM9LwBSeyt3cmUGUZ3FLuT7JemVjB//89oASAUP3KSm1e/9Xc5esOvc9+k17E2yb4Xzrj4FfHY18EwWUOG9bmVLtb37LuyNSwZnwuZgccfSnS0zgOvR85PqPm3I9dz/voaHiuFzt7iadkqDAK5pSWaDatSTEm269xWM0oXNZsMTTzyBJ554gqtI3A4gHYa0OHXlPDJifLCoVnWZ9gTx/CR4ePC5FN9axvNjcbRPtTfA/0KnbaUdPvbTfhwqqkVytAFvXj/cr9+OjPL7W+un2eYUcnvlOT9ib0hr403pjUAS/JtsDizdko/DxXWqy1bw7TY52oAovVYIHTxWyq0jlqw18kImkVLzyBP1goBFoMYPyfnx3r5arG3VFHCdVK0RGDYHuOYT6XzSWW2NsDdSfFEtNE1ukKmFjUUluU8jeQ3EU9PtPGDYDVyomtgbI9k+w9XrAYC/XuKuSe8pwMDprmU0srA3JeW2SU+obF/WBpO6AYNncMaMjPJ6C+xOFhoGGN4lAYDsGaXkRZJNq6zn2mm0QYsoKITSh8XzQ+4n9/beBCN2zdjqNl0Lp6RQtEeUOvevDwWO83LWW9+Vzjv3PrfFW6rtMQyDl2YMwdDsBFQ32nDz4u1CeYRQ88nmPMz/fBf+LlR/bmP07dLvKX04gx8AkroDPS4A+l8OXPQ/33aaNQwA3FMSGPewNzAMXrp6iG/bRRs3fsrqInekuDXwxfPzj4mca5DkB7V3qoUEafUHX4+0lq31017D3gCX6EHESfEGwdfbT+PrHQXQMMDrM4cJ3lNfIaP8/g7WiJeX16gi3pC6CAp7UytwSuiTIVXtOeZBXp6026RoAxiGQSYvDkA6/eKwMaO+DXl+iHR5kGFvEZXfVM1HESR25RLV+0yTzhc6qy18r5YdAb6ew33WqQwIyo0fpQ7/dZ8rq8MRwQIlw8qToiExCBxWTslq2ivS0Dbx9vRRyqFEaqPvshC5ZmOy6kDUmWrOo5QeZxIGE7waPzLjioShJkYbsCPnVvfl/Sw86VqN5Pwo1Csi95NCwr0DGsTEJrhN18OOpIDD3uTHxp9Tn2nA9V8DE/7j23bDhEmvxXtzRqBTQhROlDfgzqW7Qv7+La+34LGfDuC3vUVYfcbDdTTFAcPnuL53G+cqVMowwOzvucGRcxYAc39T3ka384HzHgKmPCd4UJttTnmpW9c2RYzspjBIoUKb7n2V1nWMvBVfYFkWJXxCtSfjh4y+ltZZ2mVehpwGvmPmKcykZwsXOhWMn3bo+SGj8M1tIP/CFw6eqcV/f+JUe+6/sDfG9vQjLIZHECew+Nc5Jx2RKL1WoqQHQKKA1tp4K3BK6JUuNX6OezB+qmQe20yZwSluz8Y2lfMTrOcnAgcXSL5PYg73v1zVjBgCjhY2fg784Pqs5vmJkYXpKOXXxGZ6FhJQ3LaHd6vYkLrwCSBelswtzvlR8/yo5fbIpn+8vQxTFv6peL+IQ0tj+OeJJIdQKedHlrxPPD9J0QYUdr4EBazs+RhoqCM5j+ZqIE9WLJcYPwrhgA5oOEXNlD6S6To4hJxDn/etCn+PmOKB3pNDJ6YRBGmxJnxw40hEG7TYfKIC//1xv991bzxxVOSl/8oxAaySUdubV8vTi+5vnYeBQrUwuBt/BiY+Cpx9pzBooS5Gxah89k6b7n2VBVg7oz1Sb7ELnZA0FalrgFOCYxjufXT3F3+31OG1GqTRmDyMSos9Py2hmd+ePT9RvNRxcxsYhfdGbbMNd322Exa7ExP6pOKu8T0D2k6gnp+SWu75phTGSiSzPXl+1hwuwfY8hUJ0IcbXsLc+bsaPcviE3eFELX9exGMrH9ARe5naUtgbqVMUqOABeWZEVIFvufEjp9XC3sTeFJWO1uRngV6Tgeu/4VdR6vDrPHeINUqeHw/3Iql903UsMGKe+3xxZzo61SWsID8mJWTH38CacKy0XrG2n1hUhDxPvHt+ZMaPyEMbH6XHo7abpMsr1RvyBfF+CndI55FwN1sj5Nih5QZhMgZKpscaPPeLJHgzZoiB7Ke4RLjplxmHN64fBg0DfLn9ND7462TItn20xPWsLkMCamJ6uC9EwtsMopwrNY8r4JfR2GxzyAwuEvYmmuanfH2b7n3RsDcXZ3j1tlijzqOXQ6fVCJ2Q9UfLQjo6EImQDpFSgVNCdmIU9FoGzTYnztSEvwAsCVkxtkPjxyR4ftq28cOyLB76Zg/yKhrRKSEKr147NOC6WETwoF7k+Wmw2LHqYAmW7y8W8tLkFHvw5JJQL6tKh39/YQ1uWrwD17y7OSCVOX9whb159mZ0T42WSIOreX5IxXiGceX2JMsSWcXPOEMbEjwgdYrEOUv+oNNEYNiboPTWVXk+CfNqrABOuyfeB8TJv1zy2r6gpPYGAHGZwKyvgd68gIBinosO6DTCw7YVfsths12f5apyo28Hxt7DTVeSQRYbNnGdVDw/asaPdHuN4J4dSgPFRXzYW1a8yaUeKTF+vAsekGdXktmABLMe65xD8Y+ERa4FYtKVj9MbngwLL54fs0HL5V6J6BKv9/35LT5vpSKtQuHcyDJ+AGBi33Q8Oq0/AOCZZYfwx4HikGz3qOxZXRytoLxGxA7EIhc6DzlfSoMGKjSp9ScCrdeFNm78VKl0Gjoih4s5AYNe6d6Liv04fywA7kHX3nN/SCecdBaV0Gk1yEkmim/hFz1o356f9mH8fPDXSaw4UAK9lsFbs4Z7FMzwBumoi0NKHvvpAG75ZAfuWLoTdyzdqbgeqQuUoWD8kJBJi0on+O/T1QA4D29JAPWF/MHXsDe9VoM/7jsPy+8dB4CTllcqV0DyfeJMekE9MFkWry/2Mgl1ftqA54fkZabG+pc3RojMsDeS85OjPD9rGJfQzzqB724GmmuC21/hLmDJJcBrgz0vp5ZH43EdFWNkyvPq6ygZCdEpwKNlwGNVnKqcmKTuwIVPcoaXEmKvUXxn4CyFXBofw94aeOOntNb9PU9KY6TFmlQ8yQodS9H2C6ubsL+Q+y2J5wcA9lg7cXlSZ88HBl6lfJze8FSslfXi+dFrgR4Tgdk/umb4E34nLsx64y/A2XcpL+ePxHkLMm9sDmaN7gKWBe75crfwGwXDMd7zQ7xnDWJJcUYL9LzQdW+Iwzo9en58f6dynh8lOmjYW1sY6WspDp7hjJ/+WXFelzXptUKH6tVVR70s3bYheQAmL4aGS/Et/Hk/tnas9mZqBzk/2/Mq8dzywwCAxy7pjyHZCUFtL4MPWyusdr2sxWEEewuqFcMtSUx+ukLYm17nud7LYZGao5pnKVQIYW9eBA8A7p7vnRYLs0ELm4PFqUr3DkylQiHT5GjXNYg16iRhrCR/pjYCxB+8QTqhPofgyBB+94gyfvK4/9WMn/P/CVzyKlcDqPoU8Ov9ngUBvFGoPFjgEV87Wophb1queGP22f5tW2dQ9ux4o/Sg63O384AhM7kikdNeFh2Tb56fJpa7z5Tyo4mXJ9akUw57syq8C/nrU9dsw0WvrMeve4sAAEkxBkFNrabJBvSdBkx5JnDviCfDghg/VveBSkajc3l4ekxwzYjN8H3fGYM4Nb0bvuM+T3lWWp9J2FnkeX4ATgHu8csGYFyvFDTZHLhlyY6gBsBYlsXREu5eOKcHV8S0Sfx+f+AIMOsb13eJ58dTzo8/YW+y5x2jEPbmJ22699UcxEifyWTCtm3bsG3bNphMgY3CRRIHeONnQFa8T8t352vblCiMCLUniIHsKecHALomcw22sDr8YW+Wdix4QGq9NPlY0ybS2mFZnQXzP9sFh5PF5UOzcMPZKqE8ftCV9yruyKvCQ9/swUPf7MEJkbhGs82paARIwt4s0o6IS/JY+Rl4qsK1vXBJnxJILpM3zw9Bo2GEwYZjJe4drCqRghQhVWQsZCZI7xMyry14scvqgzN+DEKRU+/GQ4u0reYaoInPK0sUtRViCN21latfY4oHpn/EdRj3fwvs+SLwfYo7TR6NKFHHyNMItGQVD2Fop7d4P55QIDam0vpxHbzMwdKOpJpRIeuQW8APDDS5DwyQwYJYk95l/IgFVDIGK0h8c9c7t6wBDVYHDFoNzu6ehEsGZUlqjwWdO+vR+HFwv/viaW6zDFpZZ/jyRUDaAGDS477vm2GAc+8Fek4K+Bhb+72m12rw5vXD0TMtBsW1zbhlyQ6f38lySussqGmyQathcFY3zvixWEX3iTFWaoSIjR+9+rnvKfI9ysY954fQQXN+LDZnwDkrWq0Wo0aNwqhRo6DVRqYF7yssywp1e/pnevf8AMCt53UHABTVtG/FPDJi4CnsDWjZcK32HPZGPGy+Ch5EUjt0OFnc8+XfKK2zoGdaDJ65chCYIEaWCCQUtaLBim92FuCbnQVosDqg1TCCd2PCS+uQxxeoK6uz4M01x7CbD10bd+Yj4NlOwNEVwjaFUC8V46dBJK5Q1dhCOT8+Gj8A0MuDvLxLnt7VCcxOcr1QM+KlceTEkGgLAjikLlOgYZTejF4xLdK2SMibOZnrBBHu3AzcsxdIExUDzh4FTPg39/m3B4Hy44HtU5y/o1QAVHEdX2u8qOT8eFwnxOFPFz3NdbzVpIA97VP2vMqO5tpmvcX9GUBC3GJMOsTwOT8SRUqtDrhjg3QlvrAriZAY1DkeX942Bl2SzYIHlmVDkJPmyWNUe0Y15DFFI3ueDLsBuGsT0PWc4I5H6T3gwasXCe+1+Cg9PrpxFBLNeuwrrMF9X+0OyCglUQpdk83I4geebDbRgJp8YMHg3fPjcLK45+sDPh+De79MyfPj37s6MoMW/aC0zoLr39+CwuomZMSZ8PXtY5DmQeq5PVJc24zKBiu0GsatloYaWXwH4lBRLfIrGtElOcBKzBGOoPbmQfAAcHmGWiJci7wY2qXxo/fP8xNJvLryKDblVsBs0OKdG4Z7FA7xh86JZnx440ghdIDQPysOe09X4+WVXOjp1pMVyEmJxqK1x7F4U56wXJ9Db3Affr0PuJ8LidF78QCIr39VmD0//oS9EYjC4jFR+B+hmjfWEkSiAJ0SXAaPfD9tyfNTL9T5CVLqWqHAY6sg1PjJkU43mAGDgtf03PuAE+uAvL+A724Cbl7lqgPiK2LvTHONtLMlWU702eewN6VOLv9bjb4T2Pq2+/xQe36Se3AhV57w0fg5k3EBUNcoEVshEIMo1qQTLlWdvBCzvGPL52v97/dDAIAsUbvUi7wuVofTa7SFRzwZlD/crjorlQk+v0URpZDOCA17E9Ml2Yz35ozErPe3YvmBYrz0xxE8PKWv9xVFkPdW77RY4VlrFxs/8jaj9672VtFgQZUFgLyrPmKu4vJNvnh+/KTN977WHC5FblkDmm1O5FU0YpuP0q5WqxUvvvgiXnzxRVitbVs44UAh5/XpmRrj8wOnq8jYWX+0NCzHFQkIam9erou/HotgCLnnh2WBnxYAm94IzfaCgEgQ+yo7HCntcM3hEry5lhuJfm76YPRM820QwVcu6JeOO8f3kPyd3zsV/7igF64blQ2Ae8k02xy8F5fFhD6p+L9L+7s2IioS6U3wQOz5aZB3aEJMIJ6fnrzxc1zB80OUfcTbM+g0GNuTC7m4eLA0UZyIIbQFARwiehG48eN72FuLtC1v+T5yNFrgqvc4Fa2iPcDqJ/zfp7i45aFfPCzoLnX97vpcjHx6Fc763yp8vjVfYRUPnp9+lyrvxg/VqqAQR7n44G16yjYLnTI4tbV6hWcA8fzEGl2eHzcPkdxobK4By7LCO4zkgACAXuQJUctF9JkAc4WSUOt9oUAYfQfXMR99p2uah98gUt5rADAqJwnPTR8EAHhrXS6+2XHar/XJAFXv9BikxnDGjEOp8C5BInig7IgoqbHAJvO9/M6OwT0NcxWjuVQHpTuq1DXAeS7E+CrrarPZ8PDDD+Phhx+Gzdb6hQKDQQh580HsgGDSazGbz2fYXximB0YE4IvaGzef77S3hOcn1Dk/eX8Bf38K/PEo0Bj+ui6eMPHX2dfwwUhoh6crG3HfV3sAAHPGdMVlQ7JadP8kJ+jDDScx8ulV2HayAl/o/4e3q+/AvLNEibpWVx6PN8EDsefH3+Kq/hJU2Ftpg9vLjrzo5AMWn940Grv+e6Hb70M8dOE28oLF4WQFwy7QOj/+hL21SNvy1/gBgLgsLhcDADa/CRxf5d8+baJQ7WUP+bYO31FduvUUyustKK2z4KvtSsaPUs4P/1upeY9ao8ilD16HMiSiWwrXzuplxZCdTlYS9haroEgJQNHzs+NUlWBMXTnMVaBVo2FEaoRhzPkBgGTlmmtF5t7B7VcNfRRXx2boTNc0DwZaJLzXxFw1vDMWTOCu2b9/2IetJyp8XpeEvfVKj0VSNFcnUgsPzx8fBA9KapvdjJ96hwE/7T7jFqbNsqz7oLRg6HRgz88W2Y+oZvzsK6jB/M924ZYlO/DyH0faVX2bA2c4V+8AP4wfwJWL8NWO034VYHQ6WTzxywHM+3gbfuPVXiIV0miMXsPeWqhWSE0B7HbuWofM8yOWjn1J5eF/4Efg9DbX96o8YOu7Ia+6TjpnEVWHxAMWuwPzP9+FmiYbhmQn4D/TFOoXhJkJfVORxHsv6i12DGZOYIz2IEw1uZysL8FaBzRVAfAuedwgqykUTnwtciqmc6IZDMN5eSpkHhuL0Gal7UOjYYTrJCZaSakqAhF74wINqSS/uy/ta0tueUD78AtvNX7U6DsNGMVLOP9wB1DvR/SBXZbno/YuF48EG2PgdLKCgiKgIvbjKedHzchpKeNHfD4+qMjlR/UTFNjkbaOiwQqHkwXDACkxRpHnxy7tG+mMwDl3C18djdWY8c5mANx68gEKf4xzj3gz7gbNcJu029kd27qqh8SFBHHdooxB4d1XiLn/wt6YNigTNgeL25fuFHJMPcGyrCBK0zs9FjqtBolmA3Tw0E/yIefn9/1FsEF27/B14s7IRKcsdmdQ4pBqtHnjh8QjkqRXNePntdVH8du+Iqw6VII31hxvEUnjlsJfsQPCpH6uhkyksn1hd0E1Pt6Yh7VHyvAMH/sbqdQLijaeOxskJyisnp/93wOvDsA/mt8FEIDnp6YQWP0Ul/ApRhQOBafNXQK09BDwzY3AhxfyyziB14YAyx4GDv3k50l4Rst3zhy+jvwpVS9vQZ769SD2FtQgwazHouuHeTWSw0HfjDjs+u+FmDKA8/J0YUQdwc1vShc+xo2SexI8cIo8DIC00x0OfC1yKsag0yCdr3VTIKs+r+b5USNW1nE7XdmIx38+gH99t1fy998f9yvmGLUUxAjVa5mACxz707l8fY1LUGD7Sd9Hev3CW40fT1z0FJDWH2go4wwgX/OYbDKRHqUaLtZG4Mzfru/x2dh/pkbikSirt8AhTwD3pPYm9vxIlNdawfPjgT2X/I5rLf9FvTlbpX6PS0Y/NcYIvVYjGOM2B+sesnzRU8JHrc3Vfv4x0d37Qu5PX8OeVfFm3Mk61UejR2CG9XEkJiWrrBAiYjOA8Y8AEx8F+l4S3n2FGI2GwUszhmBI53hUN9pw05LtqPEihlNU04w6ix06DSMUqE6KNkAHD+8UvTjsTdlberqyEQADh8gAMhm4ZZ/ny0wQyL3LKoW1dVSpazE5/A9TWa8ciyjv3BeHufBfS1HTZMPpSq7z4E/YG8AlK07smwbAZUD5Qqno2hXXNisWKowEWNbl2vdm/JCwuLDm/PDx7Vc5OdUunz0/TiewYSHwan/gr5eA72+TzZcd87PZwBsjXUZQ5UnXPIcd+ElUtK3siB8n4B0S9233VVXmyHLX5xZO4v7x70Is3ZIPhgEWXjsUnRNbV/SDSDsz4nJuZ3ZLF+JHpl25H+7XTF4NOxLD3gCgUyKXLF0oM34sRKTES6gqgXTcnCxnOL37Zy4Wb8rDl9tPS/4+3XIKC1cd8+sYQwkxfqKNuoBVBA1CnR/P7YtlWRwXCWzc/ukuv0JdfMLpVBc88AV9FHD1R1xHNnc1sOUt39aTe34cCgMovz0gzQeK74xvdhRwu9Uy0DBcGGKFXCHQU86P2PgRS0BrI0s3qjKmF7ay/RCl1woJ6qUyMZCiGu4aZvKCBdEG1zkoelB5hb1GQwoAYNqgTNx4To7bYiHz/HhDHI4XlYTnU5+HDTqkxARejNpnxv8LOO+hoDrerUWUQYv3bxyJrHgTTpQ14K7Pd3r8rUjIW7eUaOHZE23UQecp7E1NgESE4KQQtanoKO43/etYOY6LnBNkWZ1GfL0Vwt46Ws4PoTtv/JTLHmY//F2Avv9dhjP8SMewLgkA3B8GbRWS89QpISog+dS+vDqcUr0NNcpEBqbDyWLVocgUTGiyOYROeJzJ8+icqzhnGDuKMt+tz8bP0eXAqv9zfc/7y/U5d600NArg6iBUHAPeHguUyOQkv7lRWmPDGVqvgJZ/QNl9NWSsopF4kZRzuDlaUodHvt8HAPjHhJ4Y3yetxfatxsS+aTDqNK4ifQDQKOuw8iE2Bg+eH3mYWySGvQFAZ2L8iIq/Ar6HqhLMeq3w3quz2JBbyhn9lw7JwkOT++ChyX1w9YjOAIB8hXpKLQVRsfP2LPIE6Vw6nKxH2dp1R8skyl1NNgfmfrzdLUw8KOqKAIeVMw7iOnlfXom0fsDkZ7jPqx6XemvU8MXzs+dz6fekHqho4N75Vw7rJBgFboOgimFvJOdH9LtFJbg+m1O8H3MLIgiGiIqZVzZYJSHdJNQ0hR9w0WoYRPPt1y3vBwBuWQn0mIifBiwEoD6YaPASjhsyJLlI4kHOyPLCRSJpsSZ8cOMoRBu02Hi8Ao/9dEA1DUQc8kYw67X42DGF+9LrIveVxDk/Kv0AofC2qE2NyHG1I5LKAQA1TdyyWq8iGB3U+OkmGD9Sz8/3uwqFMIqxPZOF4nptQRbVF0hxU3+9PgTyEvCnCny57NrdsXRn8EXNwgAp7KbVMF47ZkY/VcoCw3WN4tDge9gbGV0V47AD1fnAp1cAWxYpr1d1Enj7HCB/k2va4V+ly8g710FCchLsvoa9iY2vTa8FV/ndR+otdtyxdCeabA6c2zMF90wKU5Ksn1zYPx0Hn5yCV2aIaljIR7X5UWght0rhfpWH/oY7F0YocuqntC2Rr5aHvVmEsDff2odGwwgj12f9bzU28x38ued0xfwJPTF/Qk/MG5sDANhXWIP9hWGSw/UCeTcFMzqtE8kJq8ldO50sblmyQzJtLF/tfd7H27E5N0RtnuT7xHcOzvsx8iYuhMhpA7692a2grxvNst/Pl9DZtL4o5XN8zu+dJhgFbnk/nkJrxJ4fcX2h/pd7338LQsROTAYtEsx6YaCkVHSupN5UvEhOXpz340bmEGD2D8jTc6FuamqFghBLuI0frRHoPoH7PPIm1PKCDoGqKHY0+mfF4fWZw8AwwBfb8vHhhpOKy7nEDmKEadFGLdY7h+DnCSuA6xSKFWu0rgGB1D7C5OOl9Ziy8E889M0el6iByPiJNhlxw9ldAAD3fLkbBVXcQJXg+RH3l0ibDML71qbvFJ2GEZxvRDpV7vk5XMz9eIvnjcJ5vVLx8kouzOfTLXnCMtPf3gidUVo4r61AYnf9FTsgkEKC/tQCOcJf0yHZCdjDF2Isrm2WaP5HAnXNojoGXhoJicFX8vywLIv9hbWwOhwY3DlB6Hj6jahf/y/dFzBoLgb+egU4vRW48CkgOoUTJeh1oXQEsk5BVOKXe4BBV/u2X08S2A3lQEUukNQ9JG588oDyOexNHLJXtAc4sRboMTHo41CDZVk88v0+nChrQEacCa9dN1TwVkUCWg3jOd79538A9+4TDGel8Ce58dMY5ppLoQ57I54ff+qEyD1g8VF6yWhllqgw6hWLNmLTIxORFtuy9eCI5yE5Rrn2hS+IB0xsDhZKfb2Suma3XJY3Zw7Dfd8fxp9Hy3DT4u34aO4ojOkRZH5EIEpvSjAMcNkbnNenMpfLRbzCQwhcQ5n0u1LYm5gR8wC4oj1SY418LcAafLThJC7sL0pi95RoLzZ+Bl3NhSKPvh0wJ6muElJ8HBhqFNXdYhgGqTFGFFY3obzeIhQLJsZCnNj4MepQAovHwRLiTVTzsLgGZcI8iKUzAtd+CuRvAbqdj/odG/jjatNd2hblgn7p+M/F/fD0b4fwv98PISc5GpPEbQHA0VJ3z08UP9BUrk1XH/S47wDnFTa6jKYVB4pxuLhO6JMDgEacE6QzYFyvVCzdwqkwrjlcijljckTGDwO4OXkDD3tr03fKQ5N7Y2N+E4Z3TURfPtm/ot4KlmXBMAwqG6yCh2dUThI0Ggb9M+MBAJXNQPpMzt1+qLQZjKb15QiD4ezugb3ISJ6Br54fi92B5QeKAQBXD++E2iYbTpY3IK+8IeKMn1qR8eONGDWpTwCfb8vHf37YDwC4aWw3PCauveIXrhfCpdrN0Bz4wlXnoiKXe4lX5wNXvA0Mvd61WrWCLv/upZyRFCyHf+X+xiwAJv8v6M2RuFxf88BMOg3W3mjmP4MzBsNo/Hyy+RR+2XMGOg2DRbOGBdURDRueOjkNZcC+b2DseQ0AzlAgzzsCeVkYdRpY7M4IDnvjfvfCamXBA39EAZ6+fCAe/m6v8P3PhydIOmiJ0QY8NLkPXlxxBHYni6PF9S1v/ITA8yMeeLHZnYDC7Xuqghsx7ZoWj0/WrgUAJMRG473ZI3Dbpzvx59EyzFu8DR/PPSs4AyiYfB855iSu/s+SS4Hdn3HPALXBnUaZit2xlZx6XJyKRL1Gh135VcivbISGAXKSzUjkVdDcwiCVBA8I4rC3tP7Av8+0rMy1ybcBzmbZYAR5/4lz/0hUhMT44duLYtgbj1geWwlDi+X8mABjrPAO9DW3t6UwmUxYy7c9k6llnzP+cPO53XCivAGfb83H3V/+jW/vOEeIIuLyBl01fghCeKSn94rexP2JqJYNsMcYdWCMca7BXa0Bkwdk4ML+6Vh5sARnqrmBffLb6pQGBTuq52fW2Tm48yLuhyIvYKvDidomO+LNesELlGDWC0mxFw/KwI/zx/I/xNmtctyhJiXGiIGd4gNal7wEqr2ofhDErvML+2dgzeFSnCxvwPt/ncA5PSMr9pmMSIuTOdVI5jskDVYHmqwOySg28W4BwO7TVYEfkKh2QSGbgp7HRCFoFaJE7GMrpcZPDZeoi5h0oL7ENf2bGwM/Fjmb3wyt8eOj50fLODE+RwfkjONG8fL+AvK3Al1GB30scv7Or8LTvx0EADxycT+M6NpCI7Z+4+XaOR0w888zluVCNcVeEtKWOyVE4UR5Q1jD3mwOp+B9Mvuh9gZIw97EBpyrNpfvxlSPNJfC0Pg+qZJwHsL8CT2x81QV1hwuxcsrj6C4tlnIBWoJiHc9kNxMglbDJes7WfUOJunQ56TGYvx4VzvSaoH3Zo/A7Z/uxHreAPpo7iic0yPA53aoPD+EnHOBcQ8Cf74A/Hof0Hmk8rYbZGF7vz8IrPg38N8y92UBsBotnuVVSa8e0RlpcSbcdl53fL2jwD3iwVNegdjzo9GqKlmFjb6XAAOvBjqP8rhYk03qOXUpvrne8WSAJE5kLMQYvXdqldYT02Jhb6KcH5ZlhWOOlJwfrVaL8ePHt/ZheIVhGDxx2QDkVzRiw/Fy3LxkO36aPxZpcSYUVjehweqAXssItegAICOeM2rkHntPsCyL9/+ShtYlRusBs2jwhW9fo3ISsfJgCd5Zn4u7L+gpGO1aRcEDeJmmTps2fsSY9FrEmnSoa7ajrL4Z8Wa9ENcqTjBlGAZDsxNa6SgjD9JJEEJlLPWArRGIUU4AJ8ulxxmREW8SRk/lUpqRgDCC7EMnKsaoE0bKxeEBgDQn4bQfDd4No8t1zICFRq/idTj5J5coSEY6anjPz6hbgbVP+7avW9cC708I/FgDREvC3nzN+WH50ciErlxH5+9Pgb9eBmZ9HdLjqmywYv5nu2BzsLh4UAZu4nNA2iT6KEl+TYPFLjF+SBvNTDDhRHkDLHYn7A6nNGY6RIiV5UwG/7ZPjJ96i10YsAJcOQv+5BAN6pSA83unIr+yEdef1UV1ub4ZsVhzuBR/51djX0ENLh2S2WLy5o38SzzYvAS9lntOqdX6yec9P+JnGMGk1+Ld2SNwx9KdWHeED4G7cVRgA1eB1vjxxPn/BE6u50KBv7sFmLfM3bvSpFDI2SEyYmQCCIW1NmzPq4JJr8F9F3L5fWl8zk+j1YFmm8PVfnz1/HhaLlxotMDVH3pdTCx4ALi8NGIBDBIVES8LewOkRpIcovRKcoXlEMEDpVzEkCIyfuosdiHMMxgxkY6KXqvBolnDcdVbG5Fb1oBbP9mBL28bI+T7dE+JkXicSX79iXLfRbKOKJQYSIo2SkNG+d+UpLAAwC97zgg5pRrFcHB52Jvv4ZbtRvAA4DTrAaCsjnsQ1igk9RFsNhsWLVqERYsWRUQF3taCvPiFF+lrQ4CXeqkWnSOjyglRnJV+zShu5LSkLvKkw5uFl4D325xhGKSQ+0eWNyY2fsrqLEEowrkaZjpTBabujPJijeVA8R7us90K1HFhhuLkQa+I1Yh8JQRS03pfPD8VucCyfwJFe2Fb8X9YtM2KRcv2wzZ6AdepOLYCKNqrvr6fOJ0s7v1qN87UNKNbSjSenz44YKnhFsFbbL+tEVoNIwgCyHN6SJhbepwr7KAhTHk/xFDRahi/61ZFGbRCCFiBSPGtmn9uJ/rhITHoNFhy01lY++B4XMTXS1LizvE98NxVgxCl18LuZP0avQyWhgCFIeQYvAwwnOI9P53j9IrvOJNei3duGIEJfVLRbHPipiXbsfF4AAVRQ+35AbgcgukfAMZ4oGA7sO5Z6XyW5QbnPGGRdrTKGrh79KL+Gcjkc79ijTpBnEUS8u0p50fsFfJWhLMVEQYP+MEI4g0RD1AKA8MS44cURFV/VpA0ArWQ0RYrcq11GT8k7zk+Su933mG4aGv9y/goPT6aOwqJZj32FNTggW9240gxn++TEStZloiGbc+rwqDHV2BHnsJghIyiavf+YZJZD0Qluibwnp/xvdMEJdBDRXXC+00xNzeI13i7Mn5IAm1eBSd1SuQclYwfq9WKBQsWYMGCBbBafU/2b28QJRiHk+VGT0g89alNistX87KDZJSWPARLai2qcomthdz9740UfjRLrGbncLJuFYfl6lQ+I7o+CUwDmOJ96sseX839X1sAgOVinBPUR7QldDsfMCX4f3zVeUDxfv/XI7Csb1LXn14JbH0HeHccrA5gwbJmLHjvT1hjs4EBV3LLbHgl8OOQ8eba4/jzaBlMeg3evmF4xIRGBAwv9UvCOeXGD7nv46P0QgevMUyFThtFXppADEq54pvTyQqx4SQkN5TEmvS47qwu6JrMeUWueXdziylVkk5ptDG4DprOi5xwCSlgGa1TfceZ9Fq8M1tkAC320wCyNrpCcENp/ADcc+6y17jPf73CecIJdh8G2ZqrJV8brNx1yox3ddgZhhGMa6nx42OXyKvsbutBDBtizCjls9YoRMWQsDe1HEGbw4lKvm2mxSl7fvQehFhCisjzQ97P4t+3tWmL/cuuydF4d/ZI6LUMft9XjLfWcUWSe4s8MQCn/JbDPz/rmu1Yvr/Y67ZL+cFx8TM9Pc4k9fzwxo9Gw+BeXoF18aY87DjFpRpoxZ4fxXdNB5W6Blw1aw7ztW+O8qoSPVKjVdfp6IhrzdjEBT5V5ENdnh/e+OEfgla70+e8oZZCKJboY1hLKj8KXV5vxfHSevy2twhf7zgNu5OFXsugCx9G4o8yngQ145BRGFEkxg8RO4jvLAmb88h1nwOmAHLAXh8GvDPWNaLrD8dWAS90Q698LlzNrXK6GCXpbsK593P/H/gRKD+uvpyP/HWsDK+uOgoAePqKQeibEZgqYsvipePAF3kko5xyw0Yc9mI2kGTn8Bg/TQEqvREE0QPe+KlttoHcOsHkxnjjrG7cS7e83ooT5Q1h248YwfPjQw6iJ7yNrhNVuaRoz8ajUccZQBP7psFi99MAqs7nNxIvHb0NFQOuBIbNBsByRZ1Jno/Nh4Gnemnuj8VKhCakHfYkJbEfT0qLAHe+ANBppPfjaCXKSQ0f/n0WJ0hYu97Ptc1E8ECU8+NJ6hqcUUVeYWpeWSJSYglnsXBAYvwU8cZ+JBk/bZWzuiXhuau4UgvEU9grXdrvMOq0WHX/+Xh0Wj8ALkU4TxCP4aR+6bhvUm/MPCsbt53XXVYs2HVPje7mmk5yrpVVWQN3/bQr46cfr/hGpPQOFddKplPc0YvqRlisIoNHXkWbh4wYJfAWvFGnFV4ikRb61uxnvRDycsyraMBlb27A/M93CYUwsxKiBFEEf2oiSWC543nHfol0eqIoZr7PVO7/01u5ehYk3yc+W5pwq0bXczl5SY0WGP+Iy5PiDwU7vC8j57PpQFMV+hx9F0AQCa8ZA4HeUwGwwIZXA9sGT1FNE+75cjdYFph5VnaLJrcHBelhdB0LDL7Off6mNwBbk6rnp1lk/BBlngYPoSzB0GTjXpD+Kr0RiLeeeH5I/YcYo873IsAB8PilA4Tt51e2jPEjeH6CDM3xNrpOnk/J0d6VDI06Ld6+YbjEANpwzAcDSAh56xK+SvdTnweSe3FqUD8v4EPevBg/RXuBfbJ8wWauHyDPUyHvLb8Gsx44BDyUC0QHKRMeRip545e8z1y5PO5hb/GKYW/Kxg95zpj0GtXyAGQQpCmUYbb9LnPPKxMbP8TzE2Fqs22V6SM6Y/6EHsJ3sdIbQafVCLnzxxTyeeQQmfn0OBPumdQLz141GN1TY6SCB6LfNDvJjAUTekq2oZjzw8hzfnynXRk/JJ6X5GzklXOxwXLLleJCHKdvt4hiqVU9P+6KRcLIUoSJHgidQB87G+RlsTm3Ao1WB0x6Dc7qloSzuyfhgYv6uGoiBWr88CP665xDsZwZx01K6w/EiiRaU3oBST04IYCTf7qU3hKyffPmiOUlx/8LmP6R8nJzfwdS+yrPcwb+4opq5kJhPAoeeAstGfcA9//eL5Vlvn3Aandi/me7UNlgxYCsOPzfpQMC2k6roo8CRsx1n95UBWx5W7iv5V4dsTeGiH2EKwa/MQBxAjEk7K2wWlrQTilUOZRoNAwu6MuJuhBp6HBD8q7MQXp+DB4UtewOp2BAkjIG3iAG0AW8AXTzku3465iycppAOPJ95Biigas/4gZ9jvwObP/Ac9jbD3cA747jlhNxysGNIss9P+T6VNR7eJ7rZB1qQzRXjy2CIedDjDu54EGzzSEU85bm/PBqbyrv8Sab9/vXLHijQzzYcudGoNdFru8613vuDO/5yaKen5DxwIV9cOf4HrhpbDdB4EBOFz70rbi22WtpC6IS7BYuKQl7kz7zR+ZIPcre6/F1YOMnMdol28yyrGAEpakok1C42GdBm79ZNKqmklRKQtvEnROSU9MUsBBAeCDFEn1VcyIjg/v4CvDDshPx9e1j8OVtY3DZkCxB4pE8bP2G9/ywLIOXDHcCE/4DzPoGiMt0LaM1AD0ncZ+PrxKFvXXh6jzM/tHzPnSyF4BGA2hkHcnb/wRyxnKV1ZU49DPw5Sy38BF/8Ch4YPTiic0eBXQ7D3DagU2vB7T/55Ydxq78asSadHh71gi/Cma2PqJrZ3QfdQMAFO0ROhrydicuOko8u7YwqS8FH/ZGjB/u2dPId9CCzYvxBTJYVlwbPo91daMVb6w+hheWH8ZxPjwkUC8ZwVNBZpLnqmH8E4ww6rR464bhmNSPM4BuWbIDfx710P5DWePHE5mDgQuf5D6v+A9QuJP7HJ0GZA2XLrtHVm2+0wjgrNvxmfV8AO6en2RfPD8PHAr40FsLcj7E+JELHhClN4YBYgy+h735MtARpVf2RgeNMRbIGOT6riB4kBlPPT+hQqNh8M8pffHYpf1VczmTzAYwDOeQrfTiPSU5P6nyunqSsDfpvH6ZcRDbO8r9OBr2BgCSBMbu//5dkFuUj/hQpJAOksTz01QtXejUZuCtMUgt3wZA+mIN22hPkDRZSdibf54fQo5sxCObz0/4aXdhYAfEhzM5wcCpjwbOf5jL5REX55MYP2uAGj62PiGb+7/HBOCxSmD4HNc6ovpB0Cu8AG5dI/2ewcX0qnn3hMKny//FfReLF9gtgNV7mJBHwQNfwveI92fXJ6rKg2r8vq8IH23kagq8cs1QYYSqzSDkhjHSPK++onDJlN4iD4DU0BTn/JBlLGHy/DQFWOCUIA97qxeMn/BXYSCjkGW1Ku0gBCzdcgovrzyKt9blCtOSfPTIqEEGnpRyLMl1zIyP8mGkVIpRp8WiWSID6BMPBlBLeH4Io+/gRv0dFuBXPidQHwVke6kFljUctsnPIbeJe46rhb2V13v4/cORzxRGnE5WCPcmbVIuYU0KnMYaddCI7hESRqtu/JCcNfW2LgzIhFRghX++saJnmFjwoIaEvVHPT0ui02qEAYTyOnXjp9nmwK78agBePD+yulnpcSZ8ctNoPDqtH968fpjg3ADgCnFrqbC3xx9/HAzDSP769nWFzjQ3N2P+/PlITk5GTEwMpk+fjpKSEsk28vPzMW3aNJjNZqSlpeGhhx6C3R6ahpISY0QfPsSN9B+Gd0mIGPnDFsHiu/Y6gXSQ7FaR50emmIPPrwFKD+LhkgcBuEZsAdfDMHAJ6PBAOsC+5/xIG19XWae5Wwr3/VRFI0oCGS0mnh9IK7VLwt60Bs4rozVwhg/Jv4nPdi2j0QKTngCyhnFFAReIcnQyh7rvN3MwkCYK+yIPCSVDSUzpIWDdc8CTicCHFwEHfgCeTgPeGMmFXnnAY9ib04f23u18LqnY3gxsecv78jwnyurx8LecTPYd5/fAhf3TfV43IjGIjB9x3HtshlDxWh7+JM75EZLjw+T5CVXYW3WjDQ0Wu1+FiYOFRASU1oXP+JErQ+o0jGL9HX/wlKtSUMXLXCcGNgpu1Gnx1qwRmNQvHVZPBpBQ4ycnoP34BcMAl7/FFXm28vkF+ihOFtsTOqMQAqbVMIJIDyGDl4IvCtSTH4E0i4QGyHtZLuwg1PiRqSl68/w0Wb0PdESFcyBUxfghgwC+5LhRQgsZMF66VV3EaD8fSQMAveUpKGLPj4J8/Lm9UnDLuO64ZHAWGEVzJXDPj99vmAEDBmDVqlWuDehcm7jvvvvw22+/4ZtvvkF8fDwWLFiAq666Chs3bgQAOBwOTJs2DRkZGdi0aROKioowZ84c6PV6PPPMMwGfBEGrYfDb3edKEtLVvD5GoxG//vqr8Lld8PE04NQG4KoPgMEzfF7NoNMgC+VgKkQj+rJaCfIwOLFhEDZXdxCIZbeJopQ3UmQjg3L1mAl9XYVfT1U0Ij5KjzuX7oRWw2DRrOE+hNcRz49Gmswt9/wYooGu5wAn1rmue4LI+AG4EZPb1rm+37KaU4gbfbuXYxAxdBbn4TmxTnl+6QHuD+AEGE5v5T7XneEKkV6kXnDVY9gb67pPjDrg15lRwKBrpe2QYTjvz5czgW0fAGPv8ToK22R14M6lu1BvseOsbkl48KLeHpePXPhrxzDSsLfRtwNbFgnLGHTKkseCxLtB6wppDZfnRwh7C8xYiTXpER+lR02TDacqGkWen/APWKUKxk/4Or9yr8LN47oFvc0EJYlmHjIokxlvCvgdZ9Bp8Nas4bjrs11YdagEt3yyA+/PGYnze6dyC7Bsy3p+ACAmFbjyHU4mH+Dz4eYBfy9VH4jRRwnXPyXGIPFyAK4E+b88CDxMWfgn7E4WZoMWT1w2AMO6RLYnSCw0QFROyXusqKYZLMsqylwDQCwveKCmDCkvnqqEEAUSioFQvZl7//W4gPsuzkUVRTv4YpS1NO2yf+kBT+U/yLwRXRPdy0yI3+ne6nd5Jcw5PzqdDhkZGcJfSgqX/FdTU4MPP/wQr7zyCiZOnIgRI0bg448/xqZNm7BlyxYAwB9//IGDBw9i6dKlGDp0KKZOnYqnnnoKixYtCpkWuk6rQVqcSfiTP/DE5zFt2jRMmzZNYsC1WUoPc4YPAHx/i1+rmrQs/jTei64rb3VNlFXJlteNEcfXqiVetybiBO+LBvg2+i83lLNk6jFGnRZn5XAjFSW1zdhyogJrj5Rh1aFS7Mjz7AkBIBm5EqvsSYwf4volD3yAEwiIFeUFKdF5JDD+n+7V0F07d59kMANzfpJ6hXwlf4v0u0zEwKPUteglptMwmNZbj2ljB7i3w95TOEEIax1nAHmAZVn858d9OFJSh5QYI96cOQw6P4tuRh4MN8J5xdvAxS9xqoD9LuNmsayq6heJ7RcrpoXL8yOEvQWRU0Xa2efbTgmhNS3h+SGhu+GU6C+TJdOPCEHnOSlaPeyNhDTFR+mDescRA+jC/pwH6NZPdmDdET78tKGc76gw7oMy4aTHRG4QBOC8QMk9gAeOqi+vMwkSu0qDoJ34MCmHk8XOU8rP78PFdTheWo+9BTX4ZmdBcMffArhq22mEvk96nAkMwz0DKhqsrgKnso5otBfBg0YfjAxzKNXe/rETuOYTV4i32PPDRy+wLOt3Pb+WoN31L1Ug9Xjqm9Wfoaf5osuKwgli7628zylHEtbWwmFvAHDs2DFkZWWhe/fumDVrFvLzuZyEnTt3wmazYdKkScKyffv2RZcuXbB582YAwObNmzFo0CCkp7s6o5MnT0ZtbS0OHDjg76FQxDSqj155I1rrgI6RdY7koUkipbExuiMuz0XtGVza9BNi0Bh48U8PNFjseHbZITz87R7h75nfD6m65gkk7hnwvc5PnEknMUqU6gakxrlCZc6IqhaTBu4R/uHt5vkRGzZkRKvnJNH8LA9GTQjwpXCgHIdssELmsvboaVAKe1MqGqjRuHJ/trzlMaTzy+2n8f2uQmgY4M3rhyEtrg3Hf8vrQQ29HjiLH5gQPeD1Kl6dynoidWwIu+eHdKSCydEh4Wc1TXZBktvcAp4fIXemKXzGDymY/OGNI7H83nEhCcNULM7JQ/I6QlHI16DTYNH1w3ERbwDd9ulOzgAiXp+4TpLwoxZh4mPAVe8DU57jvnt6LuqjBNEjeb4P4KpUDwCH+NqASlw6hBucKg1jblioaFIIQzXoNILxt+5ImWKNH0AU9ma1KxYs90XcJEqQ3w/BQGhcFtD/cte7QUGF1CIa1OlQ6Q0RQpyXUEnA5fnJVovAGbMA6DwK6D05gCNoIcGD0aNHY/HixVi+fDnefvttnDx5EuPGjUNdXR2Ki4thMBiQkJAgWSc9PR3FxVwF2OLiYonhQ+aTeWpYLBbU1tZK/oLFZrNh8eLFWLx4MWy2yCrOGRCS5HX/bogojULHyGHj6sy8OQpY9YQk/OYm3TLXch9ehIvyX8VDuq/CUizwt71FeHf9CXy9o0D4e+/PE/h+l+dROFLglGFkXhYPMAwDRnTt0hU60Omx3LTTlY3470/7hen5Phk/rv8kOT8xojbB16RAWj9XLlC4R1crc5Wn37tPqrAjxi7reMmMF8WcH4cNWDpdYmzZHCwW77Zi8bKdyu2w/xVAYjegqRLYtUTxUPYX1uD/fuYGTx6a3Bdnd4/cGhy+IQp7c4OfxrKKSm7NNocgaZscYwy75ycUBQavGcnd34VVjYL3uCUED0itMqvdGZZ8RZZlhbCr3umx6JsRp6qc5A+C5L5Czg/x+sWadCF5xxl0Grx5/XBMHuAygA4e3MMfSFfPK4cDrQ4YfA2QxIcPerqeXjw/DMPg+tFdALiKMLrtTsNgMh85UOZJGCFCUAtNI7Wlft9XpFjjB3CFvbGscgg7Can0JCBlEpQIw/C8Yd2PSdxuTWGsC+Yv7a5/qYIgo67iLXQ6Waw7ynmMVfMQJ/8PuGVVCAZSwuj5mTp1KmbMmIHBgwdj8uTJ+P3331FdXY2vv/7a+8pB8OyzzyI+Pl74y84OvjNotVoxb948zJs3L2Qhd62KOEdn8LV+rWrWKXRUnTZgx8dA+VFgwytA+kBhlpFxAj/cCexcLBThHKM5iBNl/osteCOPz0MalZOIh6f0wXl83PmBQs8GMBkRMum0fnU4xOFyeoWwKdKAF2/Kk4R2+Wb8iDw/4m2LXb8NfHIxwwA9J3Kf41swtERMQhfg1nXAv4uA678GkroD4//NzXPIOgIyz49iXZkDP3Ly3ZLlgHk/NWPeM58pt0OtDjj3Pu7zpjfcFOpqGm2487OdsNqdmNQvHbef192PE2yDCPcyq+j5Id4AvZbhPZm88eNJgCIIikKgtETW3ZVfjf1nuOTYcNf5AbiwQKKIFo7Qt3qLXXgOhVJx1JPgQa1g/OhD9o6TG0ArNvC5fy2V7xMo+iihLp2awh6R3v1lzxnF+Z0SogRRjrIwSqKHCuKdMcm8ILNGc4ZqVaN62JtJrxGkhZVG8okcfScPxURJ6JklHIMtrPs2ibFn0GoiKsy53fUvVSD3UK2K9/w/P+5DCe8xDVboRYKS2pufBHW3JCQkoHfv3jh+/DgyMjJgtVpRXV0tWaakpAQZGRkAgIyMDDf1N/KdLKPEI488gpqaGuHv9OnACh+2aywiY8BbEUkZURqFUc8T64BV/+f6LnKDn83uBvZ8DvxyjzCtjE1ASW2zors8UN7/84QgEXth/3TcNb4nrhvFGQLf7SrAiKdWYukWZZWRZlHssz+QnJ4uKg1VrQH7ViWcFf5VrV4vLjw69j4u9+es23zYdgjQGoHss7nPl7zKT9NxuUG9JwN3/w304sPxPHh+GDgFz5uE+hL3ab4w5DrOC1ZXBOz+XJjsdLJ44JvdOF3ZhOykKLw8Y4hqjl+bQix17YbY88MbPyIjnBg/iWYDV8MrzJ4fEvoZTI2NvhkuBaAtJyoBAGmx4Q9bZBhGFPoW+g4K8SbEGHUhDckhxTmrGhRyfoSwt9B6zvRalwGUxXIjuSfskV3sEzqT16K5RGr9RHmDcO3EpMUaBRWxcIZHhopGFen54V25XLPSWotwnnGya8IwjCCLrWT8kPAlTwJCgvETDuVXhbA3kp9EQ95ahyReIbfB6lD0nm/nc6H1WgaDO/tQpN0T3gydcOf8iKmvr0dubi4yMzMxYsQI6PV6rF69Wph/5MgR5OfnY8yYMQCAMWPGYN++fSgtddXtWLlyJeLi4tC/f3/V/RiNRsTFxUn+KDLEnh+nDw9ph40bhbfUw6T1oWMkytNQusXKEA+bgxWqmPtCs82Bmxdvx0Wvrsd/ftgnmXe6shH/+91VYK4XL5E4KicJMUYd7E4WFQ1WfL1D2RAmbndfC5wSnr5yIOaNzcGb1w9TnJ+dJO3kDe+SAACot/hw3oLUtcbdq3TnZi6pffA1rmkpPYHZ33NFP1sCgxm4/kvghu+A4TcqL0MKkbnl/LjOxwC78shfc437NF/QGYFz/sF93rgQcHD34rt/nsCqQ6Uw6DR4e9YIN+nWNo/Sw1zJ8yO61iRsjHRiwmn8OJysEAqTFYTnx2zQCYMahJYqTE1G/kvCkM9RzudeySX0gyWRv8+Vc35cYW+hhhhAQ2OqAQCLdjuw5nCAAxotgT5KEICQd/QJlwx25Vsq5W0mxxgEIYBGq8OzkEsE0GhRDnsj7ams3uLRICS5YkqiB4W88dPJg4y6pwK8QaMQ9kbaLS1k3zrEGnVCFItSvawSPix62T3nhUmQQkEEwUf8Mn4efPBBrF+/Hnl5edi0aROuvPJKaLVazJw5E/Hx8bj55ptx//33Y+3atdi5cyfmzZuHMWPG4OyzudHkiy66CP3798fs2bOxZ88erFixAo8++ijmz5/fIeQAw4rE+PGQbFh+HNj+AfD9rVz+xdezEeWL8SN68Ojhvv0qJgEAsCOv0tcjxpYTFVh9uBRHS+rx2dZ8Sdz1QVEC6pvXD8P5vbhwt9RYIzY9MhHvzxkJwPVAlkPqHfjr+emdHov/u3QABndOUJyfkxwt5AoAwLk9udHPRl+U7lgPnp/0/lxSu1Lif7gx8oMJ3c7jpCd7TlI/DhKXKw97Ey1vhBV2Jwu7PPRNLp/uDyNuBMzJXLL1ge+xObcCL644DAB44rIBGNgpyFGliMJTB0sh50d0nYWYf34kNFyCB6V1zdieVwm7k4WGUajc7SdyJSClfLtwQDy5+RWhz1ckIYGhPhfi+WmyuY+2VjUQsYvwvE/1Wg16GzlxnZOOFNzx6S6sPtTKBpC4+K8YkecnTsUYNBt0GMKPSCsJ9iRFGyX5Zw0hLd4ZeshghFzggXy32p3CecoFDwCR4pvsfWa1O1HMb9tTDamwhr3JFGcBVxvLCCLnkBI4DMMgmR/cqZApWzZY7EL+aWh+Hy9qb37i1/BQQUEBZs6ciYqKCqSmpuLcc8/Fli1bkJrKdUxfffVVaDQaTJ8+HRaLBZMnT8Zbb7kKFGq1Wvz666+48847MWbMGERHR+PGG2/Ek08+GfAJUHjEHUs1ycDcNa46CaJpps6zvG/fS2FKG38rLd9fjPF90jwuS5AXl6u32JEaa4TV7sTtn+4EAFw1rBMuGZwlWS7OpMdZ3bjwtIoGKxqtdphl0rgW3vMT6tEGk16LP+49D8dL65EUY4DF5sTra477JvMtyvlRyicKK57CEW9ZDez+zCUj6wmiriQPexNhBHf/WR1OaRy2ODTTXwzRwNl3Amuehn39S7i7OgFOFrhqeCc3r0Gbx1PYm4LnR5zPI695IXh+Qmj87CuowWWLNgiHmR5nCjre/pIhWfjzWBmqGmzonxWHXmkx3lcKAaRemU85e35CPAlyyfxgiTXqoNMwsDtZVDVahZBDlmVR0cANSnDhKGHogNqtYGoKAQC9+w7ErkNW3Ll0F96+YTgu6NdKBYWvXQp8OQs48pt0ekIX1DZzuTxqnh+AC+PaU1CjOJCWEmOAUacRrneDxe6WKxNJCDl4sjBUk16LOJMOtc12HCvhcnOVzkMt7O39v07w29EgWSV/iswHwuT5GfcAULwPGDJTmESMvZYaLKG4kxJjRFFNs/DsIZzhc8RijTrhvgoKTwJAqvPV8euIvvzyS4/zTSYTFi1ahEWLFqku07VrV/z+++/+7JbiC+KOpZqhsuJRxckmJbU3OQrxtmJGZMcBuZ6LXckpqpYuSwwIsfdoVLckKBEfpUesUYc6ix1nqpvQM01aOZg8fI1hcLWSGlIAcLyUe5F4k97mcHl+jC2tTNNjAlB2yOXlEZPaG7jwCd+2o1Xx/Dhc529kbADLGaBm8Xsy0LA3wqhbwW58DbqKIxhq3YzTGRPwvysGhURBq+2gkPOj4PkhRj/xDoUy7O3PY2VgWa6jE2vS44azg1f96pQQhc9uOTsER+cfJLfvVEXojZ+X/uBq0ASjhKcEwzBIMBtQXm9BZYPL+Klttgs1n5KjDXBYw5CgX3MaAAvoovDUrImo+2oPfttXhDuW7sQ7N4xoHQOIYZSVopK6o6aJywn1JKBBwriUPT9c7lyMSYfqRhsXDtbKTuajJXX4avtpN8+62ajDngLuGat0z6XFmVDbXC88I5SuCfFyycPe9pyuBsC1F0/PWxJm3hwOz485CbjxZ8mkKl6oJDnEoaUU3yHXvlzm+SHP1C7JIRQ6IIRA8KD9Vl/qaPji+SFKYjJMSoIHcrwYP1lx3IN0w/FyFNU0+ZQAfUbB8wMAJ/kQlESzHteOVB/V75QYhcPFdThdpWD88GFv4TYySOhAvcUOp5P1nHAv8fy0cId94qOcelufqcFth3QyWCd3Twg1GFz3XKzGCjgUQh+CNX6iErA5+Sqcc2YJ7tb/hOjr72+nia4epK4lnh/us7gTJC9ESGpchWokNresHi+uOAIAuOeC3rhzfI+QbLe16BImz4/YE0xCY0NJUrQe5fUWiUpdRb1LYMGk10IhJSh4SI2fxBzodVosvG4oAAgG0G3ndYfZoAPDABP7pqFvRgvl58rDdGd+CTCMK8TLg7eGhHF9uT0fj10qzT1O5sM5ow288RMBhbz/99shrD+q/C4nKAnzpMUahcE6QFkBj+SKycP7SBj6E5cNdFtHDPH8OPiw53ArsKkp11FaDhJiK8/5IUq9XUNm/HjrM4XR89OeMBqNgkR3u8g38innRzn0yeiT58fzQz/Z7Hr5bD1RiSuGdfK6SeKiJ5DRpjy+XtAVwzp5NCY688aPUrgCETyQJ36GGjJ65mS5ZGOPSfeinJ8WD3sjYWPBohW9MBvKgdh04PR2vuI7R6a2DoccgMUu63ArhL0ZdcDXV0cBZ9/ptR2uPFiCf504GxuMX2AQkwvU7QDSJgR1Om0PJc+PUtgb92gnxmFTiIyf+77aLXwekNX2hWdI4T213EExH/x1Am+vy0WCWY+P5o5C12SFiuU8pCNg0mswpkfo604pFTolYgckvyUs7ziR8QNwzzGxAbRoratm2A+7CrHy/vNDs19vyKT20WcqDp5xPW/UpK4BCL9jo9WBvPIG5IjmpfDreVJBa2mIIXL96C7C8R0sqsWqQy4hqe4p/8/eeYdJUWVt/O3cMz2JYZgEQxTJWcBRUVAEFVnjqiwKrnF3YRXTuny65jXtumZd14RZ1+yaUFQQFQUJEiVJFIYhTeqZzvX9UX0rdVXnVN3n9zzzTHd1ddXtrr5177nnnPeE/jaVC5JqeWHsc0rrtjR3eAUjcmBN+D4vDTN3+QIoSrXx4wqv5pcpcm5+GYaKYvWcH5bWEE4dMHHSFPaWS5jNZvz2t7/NdDOSRyTjZ8OHmp6fZBg/VkMAZ43oindX/irUA4jE3qBMrtHAGw9stYm5S3uGmVwAQJegHK6aykhH8FhKyc9kYzObUGg1od3jR1OHJ4Lxw9TeDFlVkyAmpOElb0zni5M9O1G2S42J9/BE4/kxGw347SALcM7ZgFn7drTzYDuu/e8qtKIUq6vOxNjG/wKLH+DD+XKNcPlZqjk/2mFvhULF9cSNH7fPL0wozz+qLiUejXTDxEtao/Dcvrp0Jw46PTjo9OCrnxtx8bG9NPcVld5sKQnLVKv141Jc+5SMcYLxI4Y6WkxGPHzBcAyrK8WWxjZ4/RzeXfkrfjnghNcfSM9Cj4pAyx7JOBTO+DlWYpxu3NcqM36YlC/z8DdnWO767eW7BWGgm04bIISpLdzYKBg/BoN6qJF0Bd5sNGgIHoQaeazPd+tUEFFRU1q/zuX1JyfXIwyCoEWWGT85N78MQ4WG5yfp+Viy+2iG6/wQWUSksLc3tEUNbAbFxKjnuNCdVGQmZQT8gqs9mrwfjuOwJ+j56RsMWWM3XBbKEakwIKta3aEysWOTvVR7fgCgjNUKiVgokXl+DLDotR6NUTKY7V4GfPp/IbuUm3jjNSTPxBVG8KDbUZovubx+/PGV5Wh1+TCyexlGnP83wGgBti8Gdi2Nqfn6IEzYm4ram/R7Voa9FVj5W7xaH4mV137YCV+AQ4ndjHvPGZITNZWkktBtEZS89kvksNVkpqWwiUAyi5tKKSsMrfXD8ixSkeco0BSsq6YocGo2GXHF8X1w/7nD8K/zhsFuMcIf4HD+U0uwcGNj6HGSjUpfYYtpx0TwvJlNRkwJSl4zoR0G87AxL0mk655qHl+4BQAfEi5VoRtYUyLcD4Z0LVUt8SA1fjoXWVWN8uLgMaVhm8zTFMnrAwBGo1hbLCWiBwoEKfMUSLsT0cG8bq2KPLHG4P2yqiRNnq901vnRMz6fD2+++SbefPNN+HyZd2UnTKx1fiTYlDk/nVXi+Ld9Hf4gAT+6BVWNpJ6f//64C7NeXREyADZ3eIXQtCODRQ7ZKk6kwnSMQpv2qrZS8jeVCBORSIVOgyv6AT17fpQ3mO9DxU1YDllI2JurKWRfX4DDm1V/wZvvfqDZD2//3zqs29OCcocVj08fCWvn7nzhU4D3/uQTEs8PW+GXTjKYx5MZ/QUW1kcSv8d9tZH3HFcUp8abkQlsZpOwWq1W24TR4fELsq0ArzIZjlQbP+UO/t6o5vkpCOZdpGSMU4S9qWEwGDC0axkAYMXOJjy5cKvmvkmj/XDIJraY5ojC+zBMowAjyyXRSupON8wAf/D84bLtlSV2fHndeLxy2Vi8dOlY1fdOHFCFqcNqMbZXOa6b1E91nyJ7qODBk0GDa2CUYa72oPGTErlrBVoFWzNNzs0vw8DmWMoxpiHpSnwR1N5iJG/NZbfbjfPO4wtKtrW1wRwm5EYXSPMp/IrOdmBL2LdaDYqblDGOG0nAJ6jm/HqYX/n3+QP4y1urAQCrdjbh27+eKOzOKsN3dlhRG1SmORQcWKI2foKdTq32glLyN5WwAcMZqdCpYPxkQPAgmXQ9Cvj1R82X7UFPIpMbBwB4nELYnxR33TicdwWvQqjWD99avhuvLd0FgwF4+ILhYtz6cdfw8tybPuXlT6uHJPihsohwUtcSz0+hSj6P0ugvFAamxFdh2aLG9RoTJ71SZDfjkNMTsnIppbFVLs6ijG9XcqCVf71LcWpUqNRyfpRhbykZ46IwfgDgqYtG4e0Vu3HXRxuw81A7/MF6UMk0mv0BDibmfWw/EPI6m8AXR2H8/P7YXnjsyy1oUfwGWAI/Ez445AwNsU4X7R6xbsqoHp1CXq8rL1QVOmA4bGY8Ok29eLd0HwDCeVpcXsHgG9E99Jxq2C0mtLh8afL8ZKfgQc7NL8OgNsZwnFgAu6o4BTLkSbiP6HT5mZDBceFzfnYuCfv2EM+PMY6OGvChq8Tzw3GcLD56T3OHrDq2tDiZUCTL6YE/wOFQcDWzLEJ8cbaEvdmEWiqRjB+W8wNx0NYjF74d9uUCE/P8SIydYG2QEAzat6CfG1pw83trAADXTDwS44KFbgHw3smBZ/KPF/8rYpN1iaraG3vASVbcxN+dMuyN/U90IsJxHHYHFzUGRBH+oifYfSZcSJO0AHOkfYHUe346qXibU1XbTKDjsJi3V9Y9fPscVpwVFL3Z2+xCn//7GCPu/BznPbUEN7+3Bi8u2Y7vfzkYdxjZbR+sQ5//+xiXvxhchFHJk3PG4PmxmIw4Z1S3kO3MWCsP/kakYYbp5q3luwHwfTpVuTRFirC3jQ3ivOL4vtHl+NmEWj+p9fwEApxgpGWb4EE+oZZX2tLhE8b/ymSFvYVVP42d3DVH8wnlqroy7E1lVUzK6B3PyDeY4vhZcH7UlPEWvssbwFcbG9G9XBQs4Dje4GHKH2zQqyiyoVySMLf9oBMeXwB2izFicUDW6Zxhw95S/xNnYTPuSDd7wfgx6jfsDZArvqlgM/ADkjTs7edNP6O/6t7q30Ory4s/vrwCLm8AJxzZBbMnHBG607jrgHXvAOveBSbcBFSo7JNzSD0//G9bavx3KIx+NQMpHg45PcJkprYstwoKVjhs+GW/M6RIn5RGhfGj3JfjOFz1+ios2crfa5kHIXVhb6HGjyh2kaJ7y+Fgvo+jklePjEC5w4pRPTph+Q4+JK2p3Yul2w5h6bZDsv0qiqw4sqpY8leEvlXFYSe0ry/bCYBXgHT7/LCpKJmyiXFRlPkg3cN4TQRvmjKUN40w4YEAx6Us7JTlwLGQwZ+D+T4n9a+M+pxMXj/V31Wr2yfYvMWU85MxBM+PJCy4qcMjvJaaxZjEf//0i8kFpF4fADi4BWjZC5TwSZxobQj79s7OzfINcXp+pEmWP2w7FDJ4Nba6BeOnTTIwCZ6fNg82BG+2/apLInpHhLCfDIe9sZUujz/SSldQ8ICDfgUPAMAUfpWNCWhIPT8rNu1QN35UPD8cx+Evb63GtgNO1Jba8dD5w9WT66sHA0eewoe+ffsgcIZ2cWVdES7sTZLzU6gSa60Me2NGUKKCB0zEpLLYpppMrWeYVOuB1jDGTzCE44jKImxpbAvJ+dnf6sb/ftoj22YwAMPqypLb2CCdHCqCB8z4SdX1iTLkjWEwGPDWH+rR3OEFx/He/037WrFpXxs272vFxn2t2HWoAwfaPDjQdhDfbT0oe391iR19q4pwZFUx+lUVo2/QKDIbDTKvwv5WN7qpeH5YGGO0XpKzR3TjJc9VInqtgnc/jBJjimHex1tOH5SycziscuOH9fueKtLZWgiGYoo9PyzkzWY2ps7bSUREGIck0QUsBSAar2v0kOeHUKI0fgDg8bHA3J2AzwP88O/Yjhcm5+c/vim4wvxR6AvBIqhXntAbTy36BS6PPyREQDoBY271IqtZMJJaXF5hlXBwFMmVhTbtXJt2ReJ3KonV8xOAUd9hbxGMYzvz/Ei+j5ZWLaW30O/huW+345O1DbCYDHh8+khhoqfKuOt54+en14ET/gqUaRfFzQ2Y50f8bauFvbHX1OSw4+GVH/hVf5bXl0sw70y4ZPb9wTC2/tXF2NLYhqZ2r6yIIyvY3KXYhpeDCeedHBZUpiLeHbzaF6AUPEix2luMxg/AG0BMEKaTw4pBtXJhAafbhy2Nbdi0rxWbG9uwsaEVm/e1Yk+zCw0t/N/izeEjFxpb3eimkk/IjIUuUXrfSgstuPn0gRLjR7w3CcZPBj0/7DdYWZw69aziYO4MMyyYoEBZDGFltjSpvWWr2EG+IQhPSeZhHd70lBohwYN8R834cQdjs5c8FvvxwkxuPVo/mQCTnORvRO0ef4j6mXSS1hbsKEV2s/Celg4vvgkOdMdGUUNEbeWbkU61N7YSHnGCmckip8nEYOCLCmrIn1sFz49kUu7UMH4UKzfLdxzCPR9vAADcPGVg5CTbutG8NPv2xcB3jwKn3R/lh8hmwkhdq3h+3L6AkPytLHLKfme+QGIr1uuCITfFWZZYnAxE40fb88MkdXt2dsBg4Lvy4XYvugQnonuDYhDdOhWgX1C9MpWwBYF2jx8urx92iwkuX4rzHFVq/CSKw2bGsLqyEA9Zi8uLzUEP0aZ9bUGPUWtI+CHAJHVDf99CwnVpjAZo5UCgcT3Q7zRhk7CIkAYFMy2YZ7IihcZPJ4dYtkGatxuLgSGGCKba80My19lAoUWc/7AFIbYgXZjMtAPpeJiEsE/61eQCTOnNYAxV1Nryhfx57Uhgz4rwxwuT8+PlNF4LnleqQKWseyM1Utrc/GsOm1kottbi8qHF1QaDIXJtBum5VKWu0xj2Zo1W2lPi+THrWe0N4EPfNFZBbQb+2rLvIxDg4GpvA9QuhSTs7UCbG7NeWQlfgMPUYbWYUR/lJGvcdbzxs+IF4PgbgKIukd+jCyKpvYl9sSNYUFBp9DNVQX+AA8dxMDTv5gtCltSqntHrD4DjxN80g02Crjy+dyIfKCuJRsaYKUoW283oVGjFIacHB51uwfhhnp/a0vR4xoptZlhMBnj9HA46PehaViB401N2z9Oo8ZMKSuwWjOrRKUTVrKndg0372nDI6cYTC7di9e5m3gOgEvbGjJ/qWKV2L3oXWPs2MPx3wiYx7C0zxg/HcYLnp0sqjZ+gl84XFBMQjZ/op4p2S3o9PyR2kFmkoW0tLh/KHVZhrudI9fyLwt5ix2q14vnnnxce6xrm+SkoDxU38AdXyjr1AtoPAqfcCzw3Kfzxwnp+NG40wYl9gaT2SDjPD1sZKLaZQ2Qqa0sLhFCJcISrXp9OtTfR+Il0sxc9P2ajjj0/QNjfiBV+dDPsxxE71wCBG9Di8sMacKsaP1azCc8//zwCAQ5z392AhhYX+nRx4N6zh0Sf1Nt7PNB1FPDrcuD7J4CJt8b3mbIFlYmcgKzOj/gb6vDwxo/ydy8V1vB2tMH60GD+yS2HeCNIws6D7Zjy6GIEAhzeuLIeg7uKIUpsElQd6yq6DojG8yMYFjYzOjt44+eQxFhinp+aNH0/BoMBlcV2/NrUgX0tLnQtKxDDvIKT46SPcXGEvSWbskIrxvQqBwB8uHovVu9uDl4beZ8JBDgcDi6+lYcLm1WjuBqonyXbZMuw56e5wwtvMN+ooih18xW7xYQCi4lfvHR6sTdo1McSvskiIVJu/MThlUoXOTW/jIDVbERZoQVN7V4caHMHjZ9URN5QnZ+kYLFYcPHFF2e6GcmBGT+FasZP0Pty6v1AnwmiVGk4wuT8WKEh9cmMH4k35rDC8yOtGi0tQGe3mGA1G4WBJdqVHIck7I1TKOCkN+wtyoFRqvam55wfIKzxYzH48LV1DoybOeCnOrR0PwuFBvWJpcViwsUXXYx/fbYR3325BQUWE/594ajYEiUNBt778/rvgGXPAMdeDRSUxfiBsokwYW8Sz4/BYBD6DVuRZhOOQoXnBwD8TK0L4MNUFcbPok2NQpL4j9sPCcaPP8AJ23NxlTU64ycYpmszCZNpqejBgg37AAA1ERQqk0lViY03foIT1EaF8ZPUMS7gB5p4hbVMGj9SmJBBm8snXzAoqpZ54R22xMcAa7T3+Dhwef04/6klsFlMmDXhCBzftyJk4Yf9NksLLCkXHOlUaEFHsx8HnG7sOsTL24dTwlPCBIBSHfbWnKU1foAcm19GQZciG5ravdjf6saRVcWCAq8jZWq7VOeHAOSeHyWs5o/JzIcqKSY8mHhb6HvCTGxZSFMInLzGBB/2pu35UbrTpTewaCdYLNEuwIXeaJW5D6kkqoFRMjhzQG6EvWlghRdGQ/Dz7vgWLR1umKGxCmgw4KuNjXjkS74Q773nDEHfqjhyJo48lY/Vd7cAy56O/f16QeL5AeQr0hzHiUIfQeNH6mH0d2iJTvBskNT0kBZ7bJHU68pF46eLxPjhNLxuLOyt0CpVp+QnpI0tLmw/yE8Su6bR+GFeOFZJnRViTUlCfMuvQYPZAhTXJP/4cSAYPx6F8fOnJbLCv8lQv0ul8bPm12b8tLsZS7cdwsznluLsJ7/Dt1vki5jMsE2l14fBoi5W7DgMr5+D2WiIWHZCinQOkErYPSqWkDwiNbAFF+Z9Zgq8hUlYeBBIcp2fvDV+fD4fPvroI3z00Ufw+bQre+sCqedHCfP8MG+O0qsT8MNvVqzqmLUHz6/8w9VfCA4+hZLCoyznh3UMqfHDJg6dgzV+pDewaCdY0pA2Zeib4PlJa9hbdMZPAAZ9Cx4AYQ3kQr9EgGPVK+g/bxB6GtTl1tvcflx651No37oMvxtdizOGd42zPUbguGv5x0ue4Gtf6ZVwUtcSzw8gn5S5fQEwXQNlzg8ABFwS40dlki8taNjqEg2epqDxU2g16f93qwIzZlzegGY9JKZk5LCaBc8Pq1XGDB8AGN8vfflmVSVy46cpqK7JxBCSOsYxr2FZ99AFtAzhkHp+pGFvheXC/d9qNqrL5MdIKnN+tu3n71WdHVbYzEas3NmE6c/8gE37xP6oDGlMJazo710fbRDOGYs6aWG6jJ+O7M35yan5ZRR0Di4gMW94W4wy85kg90ayKHG73Tj99NNx+umnw+3WDnfQBUzwoEBFGYsVPGUr9cpJa2FnbD7tDfk2i/oqzxWea+CCxspTQG5sdEhyfthqqFTw4KBQ5JQ/ntTz06NzdC52k9Eg3JS9ikGJGSK2VBX8kyCovYVdFZR6fgw5EPamPeA4fE2y52afE5NMy1X33XnIhW2v3IL9b92O6yf2SaxNg87iQ3I6DgHLX0jsWNlABLU3QK5CJY2xZ/3QYBD7SMAlVYUMNX62HxANRqakBAANwbCqqlgTx3WCw2YWvi+t0DdpGC1bsGH3MDYxHd2zU1rrjbBE/sYW3mMliDIEJxxJHeOyIN9HCSts6XT7Qox5ZbHfRBHKGaTA87P1QBsA4PShNVh84wRhvGT9DpAaP6nvg0rlvc4xepvUpI9TgSB1nYVhbzk1v4wCprjHFs2aUmKYqqm9kecnv2Gen+Lq0Nf8wUmMUcP4GXEhfFXDcLnnWnGbhvHjhxEBrZ9MMOxNuhrHPD+i8cPfDL3+gPAaW0WVJi0OqIlc44fBJnZSKV9/gIM/+NyahpXqqAQPJCp8ARj0H/YWZvW3wHs46sO0SVbaE45lN5mB467hH3/3KODT66ATTpZaw/PjF70WFpPcs2gWjB/tsLdWl1eWw9Ii8fzsbU5vMn8mEAqdahg/UiEJNhk8JBg/Yo2fdCJ4fppdcHlFr19hKlZbs9D4EcYaFcEDV5I9/6kMe2Oen14VDlQW21FZwv+OpIaWoPQWZc2iRDh3VDfZ83JHbOdkubhOlRIUyUSQus5Cz0++IdaH4q8Jm98l1fihsDciBCHsTaU2jj84oRE8P5LBoO9kwGSBzWxEI1cmbrcUACeFKmb5YUTAoPjJlAaLSnIBgONQc/AHVKAZh9o9wkSitowfpJnnh3UMg0GML66VTKyGdJMXwgsHm9j5JZW3pQOUUrI3FdhjDHsDDPpXe1PL+Qka1nZf+NwSKdsOdiSrRTzDpvE5Ca17gJ9eS+6x00W4sDeF50c6KdNSOGSGECf1/ChWyvc0uWTP5cYP/1pNmmScMwETPdjfqi53LcSwWyWCB0G1NyaRXZGGiakUNkne1+oSBGQAMewoqaSgxk+isIlVc0eo1LUryYI30kUGrbywePkl6HHt3aUIQGiRUI7j8NSiXwCIRnoqUcq1V8SolieUoMhjz0++IZYr4a9Jc8pDEsnzQwBi2JutGLjoPf6xlb+RhoS9qRSKspqNaOQkIXNmOzBO4gkKEoARRqnxNOkuXkUO4I2fjZ+g7K1zscB2PThO9MawZEmmmMRco0U2s+C5ufbkIzH31P7494Uj0Sc4CESD6PkRDQ+p8ZOOHIUCSZ6TJjnn+VG5qf12XsyHSe40Any+2jF/5h9/85Do+cwZFJ4fkzgpE5Xe5Cv/wm/NLTVK5d+81NgBxCLEgOjhSMfEK1OIoWyhnh+O4zTC3vh9M1VvhLWjqd0rLCwVWk1JyXEJIY01fqKF5abwqqKKsLfg9UpWGKLNxB9HOq4lA3+Aw46DoucHED3gbDFNWi9vbK/I9e8SpcBqkgl3VMYY7sruP6n3/MReg4hIDczzowx7i6ZkSfSQ54dQwjw/tmKgczBvgqm8KcPeZPA/HIvJiAOQeFu86qvxfhhhlK74Gy1ikUouAGz6BABQZhBzB8xGg1AjgBkHbJWyWBKeUVlix5Un9MEpg2NTEhJCeiSrcdKkVEsajAymJuSKKedH511PLexNTW0wApphlIkw6mK+LYe3AevfS/7xU04YqetoPD9Wdc+PcJ9QoVVh/LRLPAktWSwpmyy6sLA3Fc+PUkhCGfaWqeTeTsHJf1O7R5Aij0kiPhayMOyNFeQ87PSEFO0Vc36Sc3+R5o4ms37N7sPt8Po5WM1GweCwW+Rh1GwV3WY2hhR9TRXHHSFGkUSbg8tg0uJhFwNV2HbAibOe+BZ3frg+qv2zWfAg32A5PyzsrUUwfrL32uh8BkYAkBs/LKeHqbwJnh+1QVGcQHmlJZ/KuqueJgAjTNK8DKNJYvz4oWaZlxVaBblDthLEBuriJEymTEEjQroax4wfq9kYfaHMBGCTTVc+eX7Uwt7CqARqUQj1MKOEsDqAo//EP178ABBIfpx+eohN7U2QuVaGvTFPgEdUJVOGCQmTZ0mdLoYQXpLDk4xwtX6kk7gCixj2drjdC58/gNagoVhkT6/xw1ZVA5yYHJ+SiuruNsC5n3+chcZPU4cX3NRHeLn7Ge8DSIHnx2wU1h1indSHg4W89ersEDx2gufHy9+3mPHTOdZirQlwXF/R+Imlxg8g9fzE9j29vnQnVu5swrPfbIvKwBSkrnN4UUYvsLGBjRWszEnKcn5I8CBKPO3AkseBg1sz3ZLUIIS9lYgeHs7PT3CUUtdS2g8CECdQp7jvhfeCN4Au/VRP4+eMsFokxzFZeIlhgJ/cK/OBwK9OskJXbNBgE61kTBaY58enkvNjS5MsLxtgXVEKHnAwwKJ7z4/i93Tu82Fr/2hRZ9iXpAYpGHM5YC0GGtcDmz5NzTlSRbicAmWdHyEXwS+ElSqLOpqD/SAgO64y7I3vk1Wl8vw8QOyvJWme3KeTiiLtsDc2kWZCEp0KrcJlONzuzZjnx2o2CsbOok28cZKSumYs5M1eBtijz8dMNWxV2R/g0GKrBn73OtB7PADx91ycpN+swWAQcqm05NDj4Zf9LN/HIWwTcn6C44mgnJXUEKLwnDywClOG1GDqsFqM7hmbR5/df9qjDHtr9/iw/YAT6/aIYbnSguhquLx+IYIkm70L+YKo9uZDIMAJBntZqhfMEljczt3RTMqyZ4DP/wbM/z/gtmYAgNVqxWOPPSY81jXM82MvkXt4/N7QnB8pzb8CEPMGfua6w91rIrR+rn4YUWCxACw32myXeH44hfHDATCgk8MqJEAyzw+7aSUjRIPl/PgDocZPOsQOADFMIXzOjyLsTe+eH6lq4DnPAoPPBho3xHyYXcZaPPjwH2ExGZPbDwvKgDGXAd88CCz+J9Dv1IRulOklTNibsIs858fr4+B086ttyjhr9lsLcNoeMBb2VlVsxy/7neqenxxeYWWhbGphb0ohCZPRgE6FVhxyerB4837BYOqUxskpg91VXvmBN1CkssRJG+OyMOQN4BedzEYDfAEOHR6/bJVZCLspSN41KbCa4PT4k1q/ZltQ5prl+wBiiJ3S81OaxtwWu8WEx6ePjOu9BRYmQR75e3K6fTj+/q9kSpPsvZ3DpP7uC9a2sluMWRn2llPzyyhgY0OLy4s2j08IE05utEByx+/8MH4aQ2NILRYLZs2alYHGJBmOUw97AwCfRMFJur2gE9BxGKgaCEAuB+3xBQCN6KUAFJ4fqbS2wvNzTPdCOANWXHpcrxD1F7aqU5SE6r9sYudTMX7SVZCxIJqibgrPj+7r/EiNbJb/Y4p8k/eZHdjnteMqz2ycYlqGN+1n4bOrzktNG4/+E/D9k8Cvy4Fti4RVYV2jkfPj9gfQHAw1KFdMwpmXUe74UQ97qw56fty+AHz+AMwmo0RSNneHCzaBalVZcWaLGlKvCuu+X/7ciL1BpTymaplOZh7TE08u3CpMNqS1mJI2xrECp1lm/AD879/n8YdIUAthN0n0ChSohIQmiuj5EWf6doXgweGgYZBMQy6VxOL52XmoXTB8im1mof9FEktg6pS1pQVpCW2PlZyZX0aJKHjgE4ot2y3GFNY9o7C36JAW/0yyTGXG8blEcQNbsTwcSSpcIJ2YXvYFMPaPwNRHAABGozgZD1fHwA8jbFbJ8Yuq5YIHklCaV2cMxvuzj8PkQdXCpKHd6wfHcYLnJxlhIqqeH396PT9sUGQrdeqI7eNzfnTe9aS/M0P0xk/TsTfhWPcjWM71w999F8KgVpsqWRRVAiNn8o8XP5C68ySbcFLXipwfaZHTQ8FBp8whn/CJnh/tsDfB8yOZPLP+ygosxlrvQ08ICxgqk64OFdnkP44/AgCwdb9TmLBlQgp8hKIgZXUqCtFmqecHEEPElDXWUlFnpNAiD99OBttYzo+a5yf4mfY0BetsZcC4jgdhvPf4EYigjMfmAj07F2LN7ZPRMyiuECnsjX0n1Tlce0xPsIUxf4DDnmBduKQb60m2cXU+A4sSFW+I3+/HwoULsXDhQvj9qdWjTymCgpMBsDjk4W1eSYKzdHvnPsCp9wKlXYVNbBLl9Yc3fgqkBkVRpWj8BPxyY0uiLMUED/wBDm5fQLixJSPszRxG6jptYW/BlTqPPyAzwmTkctgb+w1EIXhQWmiXrdSVFhhT2w+P+TPf1m1fA7uWJf/4qSSKom5sldXp9gmr3crwKyHnR9q1NTw/FUVWYUGhw+NHc4dXmPzncpFTexjvrZqQxPCg0bFhL5+nUGI3p05pLQzKwqpVkmuUtDEuC2v8MJSy0IxU1BkRPT/JkXBu9/iEGlp9ZDk/wRzS4GLar8GJvlR+OpuR5hyGzYOFaPyw/F954VptmNHYU2I0ZhM5M7+MkoJgCCoA7DrEzzvTEo5IOT8RkMryepyApQAulwsTJkwAALS1tcHhyM5OFBFZyJtRPqmRhb2F/yFazUZ0eP1hC3UGYISnoAvQ6wT+fAWdxFV/LgB42kLbBcBhNcNg4JvW6vJJwt4S//kZDWE8P+kKe5OsCLu8fvVJEKfw/ORk2Fvkm53FbEZVsR0NwZjtEjNS2w/L6oBhFwArX+a9P797PbnHTwnhVkvlnh+W33O43aNZb8YiyMGHy/kRE8RL7GYcbvfikNMj/GzLHdYUhjBknnC1usSwN/HzKyeiyVCujIfeFfLEiCqJMZS0MS6bPT8Wdc9Pa5IFDwDx+icr54dN4MsdVlmeXqHCyGrQWZFhu9kkjPdOtz+sCAcTCym28f2HiSNFyhf6JZgr1TtLjZ+cmV9GicFgQHFw3Nh1mDfWk2/8kNpb7DDFMyBsrQtdIi1wCvA/CmboMGlbg1FUZdNAKpkrYJav9PphRKHNDMz8ALjgFf5c0rA3qZSuxBAyGQ1CQlxTu0cooJgUz0+YnJ90eX5skvNoDowhOT8673pqnp8owt5gNKFbJ3EQV4ZopYRjrwFg4OtQNaxN/fkSJVzYmyLnR6z14hVVFBX9Sgx7k51Etg8Leyu2W1AdnGQ1tLiwPyj9XFmcuyFvgOjVcamErqqFvVUW22Q1xC4YXZfiFqpTWmjBOIkscdLDgDguKwucMoSwN8V169Ao+JsIBUlWe2P5Pr0UE3iWJM68V2xRQy+qZkajQfJdhffgMG91seD5kYsjaaGmkkdkFva7bQwubBYmIac7IlTkNAI+iXyp1DuRC0g9Pwy2As8+axSTUqta2NvM/8n28cMYOpjIjB+xuKnSyOwkqcadzLA3VufHryJ1nS7Pj8FgiELxTTrZNKSl+GpKUc35iWKCbDDKjJ9O6RjQK44ABp3JP/7mX6k/X7JQ/Ymoe34OOT3ChEFp/LCQVk7q+dEIeyu2m1EbnEDvbXIJK7O5XOMHEFfbPX5e6EGKUu0N4Cd40pX4cUd2SUMr1Tm6d2fhcdJzftr28REEBiNQmhkDLxxC2JvimrE6McqaV4nAFtPChYbHAvP8KL0XpQrjJ1NS6olQGKUHh3kJugbHBDYniJTzw/IQa3USCpgPMAO2MXhtktn3ACgMncTnT3li/EjCv6QT9FxAzfhhq/LBOj7R1GYQPD/SG3vdGKBA1PgPwCjzcgCQS123NYjbD/0i262TQwzPESdpSVB7M4Z6frxpFjwApCvH4T0/fs4Aqyk9xVdTijTEjXmxjFFcT4MJZ4zoispiG7qWFeDE/lWpaZ+Scdfx/9e9q4N6X9HX+REKPbZ7JHV+NIyfMMnHrZKCgSxvZF+LS/QI6WjiFQ/SkD6l91Yt7A2Qrzr3iLEQZDKZPKga3csLMWlgVUgOUMKwkLeSbnHV8Uo1kTw/BdbkjQEsd05aUy4RftkflLnuEt74yVQR3USIVvGN5YfUdeL7jxj2pv0+f4DDIaZsmcbCr0R4WHQPkyFPuvGTZPTTmxJB6vlx55jnx6UIewPiM35MKmFvgEy+2g9jaKI+m4y5msQQPICvqVRQDvQ6HijtKkzSDjs9Yp2fJIQkZEOdH4CfcB5u96pK5QIQVtq5XPD6AHJDh/1GojHojCZM6FeJpTdNBAA4nWlajKgeAvSdDGyez9f+OeOx9Jw3ISKrvUmLy2mGvQk5P9qTNrYg4bCZRNlnlw/F9uTnTmQjNrNRyFPo8PplOTxqYW8AcNvUQfig+x4Mqi0RFncywRGVRfj6LxNSc/AsFjsAtHN+mMGazDw1s8pYkwii50eetyUYP+1emTqqnhYgBM9PhBDBXYeDxk9w8UDw/IR5X1O7JBcxA7W1CHWY8cM8P7akGz/JnTclNDu89957YTAYMGfOHGHb+PHjYTAYZH9/+MMfZO/buXMnpkyZgsLCQlRWVuKGG26Az5ccBRVVZJ6fXMv5CRP2Jhg/ZREPYzEHpa6VLn2J8ROAMTRXhU2CpYYP470/AA8OBDhOmKS1uZMreKCm9uZOs+ABIF+BVyXo+QnAAEsajbKUoRb2JsGnta5iyOBnP/56/v9PrwPNuzPXjkiEk+NXeH7EyYJ2v2KeH9mcTXEOtnJuM5sEQ6fV5UWLS3+rzvFgMIh5Ci6PVtib/DvoWeHAVSf1xUkD0uS9zARZXOMH0FZ7S0XOD1to8wYSD3vjOE4zb0Xq+XF6/EJXzZSoRjw4BAGR8PO63cGwt7pyPnytSKJeqcXSbYcA8CHTui8ZkUOwcWN/qsLepAh6BxnI+Vm2bBmeeuopDB06NOS1yy+/HHv37hX+7r//fuE1v9+PKVOmwOPx4LvvvsMLL7yAefPm4ZZbbom3KZHxSyakORf2Fsbz4zzA/0/E8yNZ4fdzxlBvSjST2ZY9KJBo/7MY5uTk/GSH54clox52ekNflIQE5oTYAaAIe5Pc5GpHAAC+Ljld/X3RhMaliroxQM9xQMALfPdo5toRkeBvWfXGLvf8sFCsNpdPmPA5FOGkker8cBwnSNLaLEZhhbnV5RPVmHQ08YoXNlFudcv7MJvAKcPe8oIsVnoDpHV+FMaPSp5WojCPvT8JYW8H2jxodftgMAA9OstDJllEhC/ACQVOTUYxr1QPMC9puJyfVpdXqMfEwt4Ko5C6Xh+Ul09msVkicZR5ockMOQUQfjyMg7hmn21tbZg+fTqefvpp3HXXXSGvFxYWorpavXjhZ599hvXr12PBggWoqqrC8OHDceedd+LGG2/EbbfdBqs1BW5MqecnGPZmsVgEo8xi0fHALnh+JAaOEPYWg/GjpvYGhIa9KSWaozF+3K0S+U4/2tw+lMCJXouvAcZcCBxxUuRjaBAu58eS6KrQryuA8t5AQVnEXTtJJIdD+OxmYAkfZsXBAGtOhL2pqL0BvEjGunex6pduOHHte6HvU3iJ0t4Px10LbF8MLH8BGHc9UJS5RPXIRFZ7UwsvUXppmLHNaXiUPP6AsLpst5gEQ6fN7RNyfvSUbB0vZYUWHGhzC7kWDK2wt2wnKX1LL8aPJE/L6w8I40EyjR+TylgTLyzfp1unAsF7xZD+zlgdoGK7WVd5og5hsVPbiGHhUcU2sUYW+98exmja08R/J1ce3zspbU0FOTO/jAFlaLTdnIb7Zbo9P7NmzcKUKVMwceJE1ddfeeUVVFRUYPDgwZg7dy7a20UJ5CVLlmDIkCGoqhJDBSZPnoyWlhasW7dO9XhutxstLS2yP02k+T1q24Jhb1arFTfccANuuOGG1Bhc6SJc2FvH4eBr8phiNTSLnCrD3pQGhdL4qRzI1/+R4nGKNRI8Pjg9ftxreRolm94BXj4beOp44JdF6g3770zg+SmKCo0igtqbZEDyCcZPAoPFipeApycAn9wY1e7M86OcOAEQDB8gmPOTE2FvUuNHcpOzFQMjZ6C8c6XG++Q3xLT3w94TgNqRgK8D+OHJ1J8vHsLOrRSeH4WXx24xhkymWD/gpH1IYghJV83tkrC3Pc0dQrXuqmSriGUh0lwLKWwVWm+en6T0rSw3fgpUVMWkghX2ZAoeBMcaXxLC3n7RyPcB+IVItqi34yC/n96k5gsFyepwnp9QJcmiKKSu9wSLviqFIrKJnJlfxkBZiOcnlTk/GVB7e/3117FixQrcc889qq//7ne/w8svv4yvvvoKc+fOxUsvvYQLL7xQeL2hoUFm+AAQnjc0NECNe+65B6WlpcJfXZ2G5OahbcA9dcD/5si356vam5e/SUQjQWzT8vxIfmR+tWR9pfFjssoU4viDtqHKvwe9DHtxuN0Lf4DDaaal4ut7fwLeuiS0UX4fsP49YMc3wMEtqu1W8/x4gmEJIeIMkVj7NvDfGfxv5IPZ/LbV0RXFLNPy/LCY+SABGBL3SGUD0rA3Fe9fbbmGwa2SH5RWDAZR+W3p00BHU0abExa1VS2l50exsl1WEDrQRgp7YwqFBgNvKDEvzy/7nVi2jV9AUYbm5CJlBeoLGAfb+D7duUhfE9CE8bqA1r384yw1fsRcUvGasXwRs9GQ1LxPtbEmXpjYgbLGD4NNHHcc5BeOK4v1tfggeH7ChK+1dLDaYuJCWjS1lPa18vO5fFiQ0RPKGmPpKYqdprC3Xbt24eqrr8bnn38Ou139h3fFFVcIj4cMGYKamhqcdNJJ2Lp1K/r06RNXI+fOnYtrr71WeN7S0qJuAH33KOB3A8ufB6Y+JG5XUXvz+/1YsWIFAGDkyJEwmfS1qiegavwEJ6beoMctColSNiEPETyQTJL8MIZO3JWTWbMNCChuXG9fhgudjbjQBsxsfl+9AQEv/77NnwE9j+M/j1dSNFXjM5iEOGyx3b54w96YAVY5MLb3QV7HSMbHN8iecrli/Eg9Pyo5TLXlxSHb1PbNSD/sdxrQZQCwfwOw7BlRCCFrCDe5knt+zCY+D48tWqhV1RbD3tRXrJnYAV+Z3YAh3cQwWXY/YDH5uYxSYphxKJh30VlnsroJ963mXQA4wFoEFHaOuHsmKJaoHTKYsdrJYU1qqJgpiTk/LOytj4b3otBqQqvLh+069/yEM2Kk8voMiyAnru1dY57ZTlms9JYz88sYqC6V11xKbZ2fMNuiJKZZ2PLly9HY2IiRI0fCbDbDbDZj0aJFeOSRR2A2m+H3h/7Qx44dCwDYsoVfua+ursa+fftk+7DnWnlCNpsNJSUlsj9VzBo3CJnnh7/puFwujBkzBmPGjIHL5VJ/X7YTCAAHNvKPpaFmpuDE1BO98aOZ8yNZLQ6o5vwonpttgFlxU3I2Cg/dbQdxrkklxK3uaGDNm8BrFwD/Ccq2RmH8qK3GscdxGxmtDYBVMnlnHrQwaKq9bV8se1pkcOVgzk/oTa5rp+g8Pxnph0Yjn/sDAN8/kX3eYKHPRfb8AKKyEqBu/LC+Lcv54UI9PyyhutBqxvh+8lwotePmGiz8pknp+WHGT1H2TrbUSLhvsZC3sh4JTTJSSZEt1PhJlbGaTM/PL4LnR/0+yXL5GoI5P5mUUo+HomD7W1wqYeBBWD5hSYE4loj1BtW/Y47jhMWJsnQUyI6TnJhfxkiNwvNTnvT7peQeJNyP0uT5Oemkk7BmzRrZtt///vfo378/brzxRlXrdtWqVQCAmpoaAEB9fT3+/ve/o7GxEZWVfF7A559/jpKSEgwcGPuKuwyTxpcty/nJoTo/v3zFFxO1FgN9JHUeQsLeIv8IrXF7fpRhbzbApH3DO9jmweuWp0JfMFuBjZ8Ed9rM/5caPxrJ2mpJqCxvKcRQixbOz4tEMFn0w9uBygFh38JuxE1Kz095H2CfvM/knOdHJeytTGuwzqTam5RBZwNf/Z2/titeBI7+Y6ZbFEoUam+AfHVVqbgDSOr8BNTD3ljOjzRXqLNDXEgyGKArpal4EfMSxe8zEOCEUNa8K6iY5fk+gKhCKK2vdtDJj/fJNlaTlfPj9QewMxjOppS5ZrBVc2Z46y3frLaM9wLsOsTPQZZuO4RHv9wsW1xtaGFiDqGen5Dc4yDtHr8w1ufDgoyeKFEoglY40uCtTGBRJibjp7i4GIMHD5Ztczgc6Ny5MwYPHoytW7fi1VdfxWmnnYbOnTtj9erVuOaaa3D88ccLktiTJk3CwIEDcdFFF+H+++9HQ0MDbr75ZsyaNQs2WwJfFscB3z4Uum3PCsDVLG7LpSKnS//D/x8xPXzYmzGKsLfgiovXpzAylJ6fSDk/ZpsYiqdCh9sNqF1mnwcok4QycpzouQKEOjlKbEK7pWFvYkhQCN4OPg+nsr9mGxHw8wYQY9cPfHuqtI3zMsHzIxo/zR1eNLRZ0U+xb04YP1pS10E0w00ynfPDMJmBY+cAH84Bvn0EOOrSUI9lxghX5yd0n7+dPhA3v7cWAFBbFhqOLPQDjQUEpecHACokE0eHVUVp6tflwPr3gRNuBKzZm3gcCyxGXVows8Mr1llRDu45jw6MnyJJTSoGC3srT/LkK1lFTncf7oAvwMFuMaJaI2+FGTsH2oI1U3Rm/PSs4MNkmWDDvxdtxeLNB1T3leYTRjJ+mFfWajKmto4METPKBbKke8plY1Dinuik6pdarVYsWLAADz30EJxOJ+rq6nDOOefg5ptvFvYxmUz48MMP8cc//hH19fVwOByYOXMm7rjjjsRO3rxL/vyZiUD/KcCC2+Tbc8Xzc2gbsGk+/3j05fLXTErPTxRhb4LnRztGNyrPj9mmXvA0SJ2hUf0FnwuwSGJGPW3ycDNN4ydYmFAyYWErcxY1z8+Xd/Hqa+e/DAyYqt6WgB8ISBI1/3c17+m4ejVQ2lX1LWLOjxj29vGavahp8aGf4h6dG2pv4QUPtN+XRQPW8N8Bi+4DWvcAP70GjJqZ6RYpiM7z07OzaHz06BxqiLB+IMv5kYW9hXp+KiTJ/aqrzk+fyP/3eYBT79X8BHqCDd7s+wDkymG2XOi3saAH44cV+ZV4fpjym1J6N1HMwsQ8MeOH5fv0qiiCUSM6gXlwWTif3ib67J60p9kFl9ePjQ38guiciX1xRKUY6ldgMeG4vhXCczYP8YYIL/GwfJ+SAouupL/zAeX1SI+nPM11fqQsXLhQeFxXV4dFizQkiyX06NEDH3/8caKnltOyV/589zL+T0m2xffHy7JnAHDAEROBiiPkr7GQJH8w3C+KsDdttTdl2Jvix6aczJpsck+bgt6Gveov+D1yr0BHE+CVXCst48fC6jyIr3vDeX72B3OkVrwUxvjxyY0ftq1ph6bxwzw/7R4/3D4/bGYTdhxsR3fIj7Mr0CVHcn4k1yoWb062eH4A3lA/5s/A/P8DvnkQGD5dXDjIJBoeGgCqOT9Sydd+VaFCE6wfaKm9qdWxka7ahS1GvOsH7dd0BvP8uCQGj7RYZsomWz9/DHx9P3DWf4AuR6bmHPHAlCo79chsO8LADFapXDv7PSe7zkiyPD/bBJlrbY9pt07y5HG9hb2VO6wotpnR6vbh2W+24degPPU5I7uhrlxbPMVi5r9jrZwf5gnTm/hIPpJ8tbfk3n9zZymrdU90++VC2Ju7jZ+8A8CYK0NfV0pbx6D2FrKqJZkwcTAKcc8CIZ4fa3zGj8/NG0AMV5PC86N+M1T1/ISr88PEL7Z+qS1zzPnV6wpJw/AUlNjNQv5RU7sX1/53Ff69aCvMBr5dWyc8iZGuf2Oi5x85GPYWi+cnyz77yJm8NPvhbbyselYQ/K2HzfkRt3QtK8CzM4/CA78dhmOPCFXlEur8aAgesEKEDpvU+Ing+WGE8fLqDTZZlhk/6Shw+vo0YM9K4N0rIu+bLjhOF54fdv+XLn65hGuW3HtNsoqcRpK5BoDuCgOB1TPSCwaDAT2Dn+/VH3YK27uWFWi9BUDksDdWGLWyRF/qd0SSYWNjuoucZiXNv0a3H0ti1zOr3wDczUB5b97zo6RIUWAyBrU3dxjPD6BSOyfE+LGHDS0cYNih/oLfIxp0AG+YeCJ7fuzhPD9qIQXM+Al4RYEFJWqeHyDs5zIYDEICZmOLG++s4H+P1qDnp6a8CHBUwA0rhteVaR5HN8Qb9pZNnh+ALwDMxA4W/0uzmG5miE7tDQBOGlCFc0Z1U/VOmNXC3iSwMKECizjBkq6sOsJNvFy5Y/zY1MLeJJ6flBMmVzLtdBwWx8qy7pltSxhswrglGqyC8ZPka8YWEcLJMEfDvmCif20YQ0Bp/CjreekBlsvDvD43nTZAM8yPYY1g/OwPGj9ddCb9nS8w4ae68vBGblyEWwyMA30tJ4SjXT2ZLoQOvmifxWLBrbfeKjzWDRzHF2cE+FwftZX0EkVoVjRqb5phb3KiyvkJwzGm9eov7Fsrfx7i+YmU8yM1foKeH7MR2PQZ8OE1wKn3AQNO5wv3Mda/BwyfFnrQQEDD+AkfMllWaMEhpwc/N4gTwqE1hcA+oNBeiG9vnIBWlxeVuVCcLYLUtfb75PtmRT8cczkvetC4Dtg8H+h3ambawQgX9qaS8xMJFvbGaai9qXl+pCu0VaVhfq/ZNGFPEDZZdvlCPT9pUbszmnmZfYMJKOoSef8IJNS3Dm/j/xfXyHMxswxRpEIl7C3JBoNJUHtLzPPDVM6qwngvlLl7egt7A0I9W9FIU0fy/OjF+MmKcS0DPHzBCLy1fDcuHJumBZN0qb1lNRqTY1U+vwXWk+/AbbfdlrLmpIxtX/PFGS0OXuVNjZJa+XNz5Mm25k1HMcmKaPxYNeq7xEpHk0LqOpLnRyp4EKzzYzQCr/6W3/jZzbzxI635tPVLPkTPLhZ15M/lj8v44Wv9OPHS97x3q1eFAyYueByTGQVWk+5UezSR5sYk4PmxWq2Z74cFnYDRl/JqkV//EzjylOyoaxK2qFv0E7DIYW983ymUeHg6Oax49fKx2NTQilOH1Ggf3Be5BpZeEHN+Qj0/hekIO/I4gQf6AY5K4LqNCYeIJtS3dBDyBoieH5fXD47jYDAYhGuWbOMnWTk/Dc38BL4qzCJYiOcnXN5dljKoVl6PUfmZ1GD3Kq+fE66nFFY3qKwgu3N+smJcywAnHNkFJxyZ+MKNOmpqbxT2Fpvx8+3DqWtHqmHy1sMuCJ20M+rGyp/3ODbiYbU9P4qwt5Aip0rjxwFMeYB/PPCMiOfVxNUENEjq48Th+ZGF6B3exudKMePHZOVD7dRC3wI+udQ1I4JSIFN8W72bz3ly2ExiHlMU3jddIQ17i0XBLZvU3qTUz+IXCX79kV9gyCjJ9fywBQtO4z3OoOdHubp8TJ8KXHxsr7CTNADyOmo6RvAiqOX8pCPsiCmWOhszb1RKC5xmMez+H+DERS82FiT7mrHxJBHPj9cfEOoQVYfxqBZYTZg1oQ/6VRXj1MHVIYaEHjh5YDWemD4Sd545GP+5aBTG9CqP+B6pEqqaql5bUP2uyJal4wihG3LI+InthhQIBLBu3TqsW7cOgayK8w9D005gY1Alb0yY5NguR4pCCCffCRRXRTy0TavIqeJ7DVlNUzN+Rl8G/HVXqAR3LDT/CqyU5ADF4vmRqr0VijKa2PSpaPwcOZn/v+690INuWaDepohhb3IDZ/aEvoA/WH8iilpLuiKasLfJd/P/z3hcsq/895I1/bCoEhg5g3+8+IHMtQOQ9LnkeH7EOj/S71ei9hZcKXfE4pWULrC0H4r+fVmMKHUdqvZmT7fHVir+EicJ9S1B6a1nwu1IJTZJOCILfXN5UiNSIQgeJJDzs7/VDY7jPRzlheEXxG6Y3B/zrzkeT144SpciOSajAacNqcFFR/fApEHVUaklWk1S4yf0e2YLNUVJljFPNlkzruUS0t9PEgQPsvsXFAvSSbrBpL5yL6Gjo0Mo2NrW1gaHQweF+pY9w09gep0QvkgnAJx2P/8XJUxiUivWluFQrrgojR9L8Hu0lyRW/PDARvnzCJ4facy3rM6P9Hew83sx52fYNGDD/4CtX/Chb9ZQieAQwqjYAUCZouL0sLpS0fiJQnRCV8ikrjUG5vpZwFGXyFXyFPtmVT885irgx+eAbYuA3T8C3Y7KXFuACGpvMXh+jOHD3pjgQUyhNVLjNwZDLJthRUybO8SCmSzMpjjdYUe+xI2fhPqWzsLeAH4BrMhmTlmeljkJOT8s36ey2B4x+T8fkRp5Hl8Ayjq1rYLnJ7vH06wa13IaCnuDbADOkYrjMrwdwIoX+cdjVeStE8RqCjUieOQ3+kKLYhKg5vkRHieQ/6Os26RhzKqt1srq/AQk7zu0VfT81AwHKo4Mhr59qp7jE9Km8HLqnRS1B6qK7byqHJB7xo90Yh4uN8FSkB35M9FQVgcMvYB/nFHvT2x1fiJhVg17Ex8zpayYinhqGFJ6piKYRO30+AURiMNO3ghJT8E+Cf4MhxLqxPgxGAwhSqWpEjwwJ0HtrbGFpJrDYTIawGxCtYXYNjczfnJn3Z6IFqrzo47UM2CJnFinO9a8ySvVlXXnE7KTjGbOj2JiExJKEM74sYUxfk65L3yDgqp8Wu1gqAk1MM+P2WQQPS8A0H5QNEYsBcDAM/nH698Tt4eDxeRrUCEpDHn60Bp+ZS9Xc36k1z2S4IFs3yw3hI6bA8DAh5fuW5fhxiTH88MmbZyGwcT6jjUW40dGbhg/DqtJWEw50Mr320Pt/H/lwkbK8UdxP0rZuX1A827+cRYXOGXYFMZPU3tqkuKV54mHlqBXsVOEkLd8ho3pat+zmPNDxk9+Q3V+RKSTAWuOGT8cB/wQFDoYfVlKksZFlRVtz4/VZAydICnbIvP8hPHAGU3A6Q8Bx12j/rqrSdEM9QHHopKE6vVJ1N6kHp29P4mPzXZg0Jn84y0LQo0tNVrC15KSVq4eVBsUo/AHz2/MsZu1zKCJ8HuUGUdZbvxU9BV/F4v/lfrz7fgOeGgIsGm+uC2cYROP2hvzzGl4a5in1BKTuljueX4MBoMgobs/WEn+sJOfrJZHIdObVDIpItGym/e0m2xAUXXm2hElokofr/jWJBisyb1mNpUiuLEihFFmec5KJmHCK2rfs9Otj5wfIgUkeeE0d4wf6WBsybGwt51LgH1rAHMBMOKilJwimjo/qgmkylX/Tr0kBw3j+TEYgaN+D0y4Wf11qSQ1oGn8CHHYfulkjt/XZjZoe3TMNqByINC5L++d2fA/7bYyItQ0kUp5CkW+8sHzE8kYlyUq6uCWc9y1/P917wAHt6b2XC+eyQuZvHqeZGPwt5yknB/B86MheCDWxYphcNEIodM7FUVB4ydYT+SQM1OenwwaP0LIW4+E5bbTAfMCtLp8aHX7hIWwZHtXBHGdRDw/Qc8FGT/aMFl5FuLGCAQ4tHnI80NIIc+PfHKca56fH57i/w89DyiMLBcZD8ylH07tTVUNSjmZdXQWHxtNwPi56idk18tkjm5CrGX8qHis2OCkqYZptPBtMxjEVf41b4Xud+zV8ud+j+jJUaFrWQEmDqhCv6piHNungv/ucjbnJ4awN5kYSZZ7fgCgZijQdxL/m/v2odSeK+wkN4V1fiQIxk9MilK55/kBROPnAPP8tGcq5yeDYW86yfdhlBaIQhVNQU9dgcWU9JwftTpQsdIqeH5ybDxIIsywYfXHGO1ev3CrIeMxH1FTe4v/aDlk/Eg9PyrGT3EtMOEm/nHvCelpUzJo/lX0SqRA6IAh5M6EETxQ9/xIfn02lbpD4/+qfkKpEIEpiuRPzbC30JwflsBtN2oMUtKK5Szv59cfQ/c76bbQbV6F3LW3Q5ioGAwGPDPzKMy/5nh+pVgacpfTxk+kSYZ0cqwD4wcAxl3P/1/1Gt8H00lYYyIOz0+0YW+xGD856vkRwt6Unp9052hkMuxNJzV+GMz4aWr3oKmDv15lKQhTFHJ+Egh7Y2plJWT8aFIYXLVUen5YyJvJaIhNnIXIYUjqWuH5kYS9XfwxsPJl4KS/AVu+4LeZrLBYLLj+en6CY7Fk8Y3ox+f4+OsexwFVg1J2GmsUnp+IdRPMMSjYSA0DszVyUT/NsDemwMPxbd21FDZvCwA7rEbJpGzCzcBXd4W2s2oQ0PkI4OAWcVv1ED68UC3kw9MuFpdt2gk8cQzQ+wTggldC95Wu3uZanZ9Ywt6kixEKz2XW9sPuY/k+t+Mb4LtHgVPvTX8bwnrJklfkVPT8xDKQ5L7nh+O4DHp+Ejd+4u5bOqnxw5B6fpi3QFmwNxkInh9fIsYP5fxEQvT8yI2fVonYQTQ1gzJJ1o5rekbtmlOdH0A2GE95ACiuBgrKgZ7H8n+ALGTEarXiH//4R9pbGRNeF7B8Hv94bJiipknAGkZhRbmPJuYIleClyLwiURhNL0wFTrwZOP4G2WbB8xMIhigtuA3Pojtm4i+wGSWDVJ8TJcaPxPNjMPDen8X/5J/bSoA/fKPdDq+kZs3atwFPK/Dzh8Dt5UDP44Dpb/HGHCAvVJhzOT/SOj8RbkAmC/DnFby3TyGCkdX98PjrgJe+4fvg8dcDjoqIb0kO0QgeRE+ksDeW50eeH9Hzc6DNjTa3T/CKpd3zk4Swt7j7lo7D3joE4yf5UxvmbfD6OfgDnFD0NBZaKecnIsxwbXPLjUw9yVxn9biWEyRu/OaO75B5BibczBs+Ux4ATrxJvo9BJfwjm1n3DtB+ACjpBvSbktJTqYWPAZB9VxEnR5YYjB9p3R6p0VRcq/2eL+8K2cRyfux+J7DgNgBAf8NOfGC7GTaDZAIhbZvSQ8XyfoBQoQUlUuNn3bviY87PF8eUFmfNl7C3aOjcB+hyZGrakip6TwBqR/Beye+fTNFJVG7i0dyfYhI8CB/2xhLEKecH6BKUq9/f6haU3gospshe72STDWFvOjF+SgpEwQPm+UnF9ZLmELnj9P4wtTcKe9PGwTw/GmFvZDgSySCHjJ9wCkkMFi8fQCAQwPbt27F9+3YEAvEnMKYMjhOFDkZfwgsDpBCbptqbROo6UpytVtjb0X8K3SbN+TFLVlUjFahVCA6wfIbZRrlgQZWhCXZPUL7aYJJ7l5RGWtVgyfEjVFb3BI0fn0cunc2QGjzsWEazPhL9Y6F6CFDaHag7OqHDZHU/NBiAcdfxj5c+DbiaU3OOWF6Lp8ipUa3Oj4raWyxhbzlk8EgRw948Qo2ftIe8AZHvQ1EQV99ytQAdh/jHOqjxA4heng5JcdpUhL1J80ziFT0Qcn4KaAKvBbt2SsED9t05dOD5yepxTa/IVGPZY1J7gygPG+YjSSYOHR0d6NWrF3r16oWOjgj5Jplg9zJg7yp+0j7y4pSfjhk2AU5RwVoyyYk77O3kO4CRM+TbtMLeIin1KWrtsAnbZeZPQna1tjcEj2+RG4/KdhoMouT2xNvDn58JHrAJghKpUccMJWmYXa5gtgJXrQQu+TShw2R9P+w3BejSH3A3A8ueScEJ1G7eyRU8sETw/HjjCXvLVc+PRPDgsDM19WJkHNisvr1xQ8KHjqtvNQXzfQo7A7bihNuQDphHpsPrR0dQjKAgyUpvAO9BZQsJ8Xp+xLA38vxooRWF0uFNnWGbbLJ+XMsVqMgpYvT86GCwZl6fIefK5aNThHTi4/WrrxBH9vxoGD8mC3D6w6KyGhAqeCCcJExtICBkssBCelYGjgg9bVvQ+DGa5Tk3au0cdx1w6QKgfrZ8u1LuetVr/P/2g+rtkxo/zkb+f1EX9X31jikHPVpKjEax7s+SJ0SDNllEc7+Ken91WGio1n3PQ2pvAszz0+H1Y/dh/lqnNN/nM406Z5s/5/+ne6zSWcgbIBo6HV6/kPOTqjDFROSuOY4jwYMoYPchaeFyAOjw8N95siXMCb0Qpu5dHOSg8ROd5yeraW0A1r/HPx6TWqEDhtSw0Sp0GnfYG8BPIs97QXyu5fmRKoPZSkKPs+ZN+SmDK3GHOHGVcg/HK4oZXE3BcyuNH5V2Go1A3ejQ8MKJtwM3bAV6jgue/7/A/k3AMyeHHgMA9q0FHh4GvHkx0LaP3+aoVN+X0AeDz+Flf9sPACteTPLBY835icPzEwwNNUK9yKkvQJ4fhsNmFibTm/a1AUhx2FtHk/r2AxuBr/8B/GtA6gvtStGh8cM8AXzYW+rU3gBxIcGnzI0N4vUH8MmavViwfh8Cism7yxsQFhbJ86MNi+ZQzkNSGdJI6A0SPBARpJBzwPPz4/O8cVA3FqgdnpZTmo0GwTZ0+yXei1gED6JRe+s2mv8/9HzJ+zRyfgpVPF5bv5A9ZW0yg2/z4RGz8Eughn+xI5jzYzTLBQci1qWRYDDwKl9SKezHx4TW+2F8dC0/gVj3LtCyh99WRMaPrjGZgePm8I+/e4TP90oHycr5UcvlUQ17o5wfQAx927ivFUCKPT9anjy/hxd4ad0LzL9JfZ9UoLMaP4B62Fsq1N4ASWmFgPrv/90Vv+KPr6zAZS/+iC9/bpS9xrw+RoNGwXACgNTzIzd+XCkMaSR0QJKlrnPH+EEUYW968Pz4PMDy5/nHafL6AHyBTjHWNt6wtygkq3//KXD9ZnnNIqnRJDV+1Ay/9oOA5KZoChptzPhxduoHJ4I5NmxV1WSR19mJVJdGjcHnSJ5Ivp8u/bXfQ8ZP7jDsd0BRNZ9ztvr15B031rC3OBZwWL81aNz34ipyqiGekAtUBBXfNgeNn5R6fqK5jps+SZ/6mw49PwUSz09LB29gpEoOmQns+Pzq123dHlEUZcv+NtlrLZJ8n2yvU5NJxILr8u84lUp+hF4h40f0/EQT9pbNq5br3+fDpYqqgYFnpPXUNpOK4ltMggdRJPabzKHGwI7vxMfSsDfmJZLCBQAWzsbeYjTCbOBvjJ6AEU4EjSmtsLdYZZoBvsaQGiNnAEdMVH+teTf/n8Le9I/FDhzzZ/7xNw/Kc7sSIsawtzjV3owGpfHDBU/FCYWNY8v5kT7O4vtpHDDPz+F2fiKdWrW3KL+7VCgNqqGzAqeA6Alwef1obOWNRHYNk40Q9qai4MVxHF5YskN4vr9VbrBSvk90MA+0UvAg1SGNRLajovZGnh9IBmCdh70tZfLWl6a9NoxVU+5a/rom8Sb2eyQrZDaJ4EGhRlFJFs62+r/Amxejh2k/TMF8Bi9nhJMLGj/M82M0y7098Xh+LAXAaf8M3X70n4ALXlM3cJgyHXl+coNRFwMFnYBDv4g5eYkSq9R1HPcwg8GAAotJfmcMvl/q5Y24uCEjlz0/8olzaj0/WSSDGwiIam86Mn6EnB+vH42tfJ22ylQZP2HC3n5uaJU9Vxo/LaT0FhXMu+YNyZmisDdCSfzGTw4tQcQmeGA2m/GnP/H1Z8zmLPkafl3BS1ybrPxEK82wOgbsJsMTw+SovE98Jz7pVuCLoMS01OAxW4HZy4HHRsn37zgM7P4ReOdyAMBpxgKYgyvxHs4ohr05D/D/TRaFRnycNr/SE9XnRP64ZitQ1l1Ud2NQ2FtEsrIfamErAsb+EVh4N7D4X8Cgs5Ogdhej1HWcobt2iwkGT6jB0iGppRF3OEk2LybFgdL4SWnOT7TfXRzfccx9q3Uvn2tkMAElXWM+X6Zgv9s2lw/+4IS5sjiGgtsxYNYqBg5gT5Nc0ljL81NCnp+wWMws7E3d81OQonyuZKKrcU0vJDlUNHeuihD2Fp3nx2az4fHHH095s2Ji6X/4/4POysiE2S4JHxCQhr1peX4m3w3s/B4YdkF8Jx59qWj8SOv8GC1AeW/xeadewOFtQPsh4KAoeV1g8MEEMeytjXl+9q3h/ytzkWIRPJBSWC5/Lq2DoeZNYp4fCnvTJCv7YTjGXsGLHuxbC2yaD/Q7RXtfjot8w1Z7PawXOz7vNW/8hG5vD9bOsJgMkT27qm0Ecs3zowyZSnvYm9kO+FzAESfzAi9cQH2/CMTctwSxg7qUF9VOJszL0+r2odXN/547F6XmmjHPj1/F88NC7iwmA7x+Dk3B/CMG1fiJDqtGaGEqazglG92Na7qD1N5E9C513bYfWPs2/3jMlRlpgo0ZPz51SVzNnID6WcD5L8UfpieTtFbEdRqNwJy1fEFNVnG84zBwaJv4dkMA5mDYm4cz4vvAAPnxlblI8YS9AaHqc1LjJ5xBlat1fvKRgk68sQ4Ai/8ZaoT4PMBX9/Ayxff1AH56I8IBYwx7i/MeZrMYYTCEylM73fFOKHJT6hpQ8fykssip2nc39WFg0l3AOc8graHaOgx5A3hjQqmeVlaYmmsmSl2rGD8tvPHTt5IfF1pCjB/y/EQDC3vzKL7jDsr5yXNI7U2daGKnmWHEceA4Dvv378f+/fvBZcPgvWIeH3LQdRTQbVTE3VOB3aIW9iZii2VlOBakP2Cpehq7XmV1vAeoIOh56TjEe4CCFJj8Ms/Pj1x/LC08XjyORRECEW/Ym1SMAQBspeLjcAYVeX40ybp+GA31s/nV+d3LgO2L5a999wiw6F5eptjVDLwbQbFR9ead3Do/AGA3m1QFD9iEwhGrOlYeeX5SGvam9t0V1/DiGgVlCS3Yxdy3dKj0xqgqFe/xFpMhZd4BQe1NxfOzt5kPe+tXzRs/Te1yV6vo+SHjJxzaYW/896eHIqe6HNf0hHBfJOMHUUldCxOHANrb21FZWYnKykq0tye5anus+L3Asmf5xxny+gD8BAnQDntL6U37si+As5/maxsxlEZKQSf+f/shUUkNQIEpIAgeuAP8NW60dhffp6w/FG/Ym8Egvz7MAwCEToKlWAu1X8tzsqofRktRJTDiIv7x4gfkr23/JsaDxSh1ze5vfg/Qui/qs7CFDSVsQhF7vk/uen66SDw/xXZzjBLgMaL23cnGsPg9PzH3LR3W+GFUl4j3+NKC1ElJW8IUOd1xkP+Oh3TlF8WcHr8sN4h5gijsLTwWQVRCGfbGP9eD1LUux7Vsh+r8aKDnsLcN/+OTTR1dgEFnZqwZbILk9qqHvaX0pt3tKGDoeXyYG0N5LVnOTcdhwCsml9qNAaHOj9vPv6fFVi2+T2n8GBP42Z92P3DLYeCvO4HOUQg8VPSL/1xE9nLsVbyK4C8Lgd3Lxe0KGfaIhM35UX0D/2/7YuCBI4EDm8PsK2K3KDw/wXOwJGJHrEnEOez5qSgWPT2pzfcB1L87FUnXdHzHOvb8KI2fVGEKTsyVSmQAsPMQP8kd3FWMCPjfT3uEx8zzU1JAnp9wsMUGZdib28ffq+ypikAh8orc+RXpWeqaCR2M+n10hUJTRIFEMlQgXZ4fNZQTQ2nYW8AnbLabAkKdH3cgGLpnk+TnWBQ5P/F6fhhGI2AvjbwfAFzwSmLnIrKTsu7A0PP5x29MBx4bA/yzH7BnZYwHUvzG2w8B/qBKVDQrXWveiuosIcYP5MYPeX5ECq1mIYcktSFv0PD8SIflNI5ZOqzxw5CGvZWl8Jqxiblfpc7PIScf5iY1xDbuE+WvSeo6OljYm9K7xhZlbToIeyNSgYpHPFNhb/feey8MBgPmzJkjbHO5XJg1axY6d+6MoqIinHPOOdi3Tx6esXPnTkyZMgWFhYWorKzEDTfcAJ/Ph8TQqedn72pg5xJ+FfmoSzLaFLb62+ZWvxZpN34qjpQ/Z2Fva98WldSg8PwEw9481k7i+0LU3tJk85d1Byr6pudcRPo57hq+37buBQ5sBNoa1PdbdL/2MaT37rb9wP29gOXzVF5UewN4VbAosFuMqnV+nMGwt5iTiHPY8wMAFcG8n4x4fgwZ8Px42sXfrw6NH6nBIX2cbJjam1fhlfAHOGHR0GEz4S+n8B7/g21i3g8VOY0Oi/AdK4wf5vnRCOEl8pAEwt7i7oXLli3DU089haFDh8q2X3PNNfjoo4/w5ptvorS0FLNnz8bZZ5+Nb7/9FgDg9/sxZcoUVFdX47vvvsPevXsxY8YMWCwW3H333XF/kFilrrMGVtR0wG+AkpqMNoWtSMmNH/G7Koo1KTpeZv/Ih7aVdZdvV0pNB7EZxZwfV9Dz47NJjZ+g58dWCribgX6nJr3JqhhphS+nqejL56o17+I9gfZSwOIIrUv11d+BkTOB4iqVg0juV9u/jnxO5f1Navy4WoB3/wAMPhsYcq5sN4vJqPD88LCCxrGLmeSu5wfgFd92HGxPg+dHbWNycn5iomkn/99WIi4y6YgqqfFTmjrjx2Rknh/59WC5cwAvHlLh4I3nA21irZ/mDqb2RuNCOATBA4WB6Qp6flhuMpFnhCv6HQdxzWbb2towffp0PP3007jrrruE7c3NzXj22Wfx6quv4sQTTwQAPP/88xgwYAC+//57HH300fjss8+wfv16LFiwAFVVVRg+fDjuvPNO3HjjjbjttttgtcY52ESV88Ney5LBuv2QGLYyNnNCB4yi4IoUW6HSej3laHlLNAZlq8EveH5cfgMADj67ZF+mxHbVCmD/RqDnsUlsbBiMtMKX89QO5/8iwakrKMpu6EpJ9mhWtaTGz7cPARs/4v8iGj/8Y7a6GnNSf457fpjoQXkqZYyaN58AAQAASURBVK4BZI3nR8j36ZH0YoLpoEZi8NSk0PjREjxg4aNGA7+QwOoMST0/zBBSqgkSclgxdbdCdZZ5fmzk+SHYPSrdggezZs3ClClTMHHiRNn25cuXw+v1yrb3798f3bt3x5IlSwAAS5YswZAhQ1BVJa6CTp48GS0tLVi3bl08zeERpK6jqJsRjSx2OljxAj95qR4qVznLEMVBz06bSz3sLeak6GRToO75sRp8guen1c1PEiwOifHDlOEcFekzfAAyfvKV818GTlWEuvnVFxRk9ytlbprq7krPj6SKPMvZUHLoF5RxTaphb8zzE1OBU/4AMe6vL44MyhUfUVmU2hNlS86PTmv8MAZ3LcXUYbWo790Zpw1JXQSF2aTulXAGoyUcNjMMBoNQK+pg0ODx+QM4GMwJIuMnPCz/UFpv0B/ghO+cPD/5SnIXZWKenb3++utYsWIFli1bFvJaQ0MDrFYrysrKZNurqqrQ0NAg7CM1fNjr7DU13G433G5xkG9paVHZKxapaw5msxkzZ84EAJjNGZik+n2ivPXYK7NitY3FIkvD3jw9jod1x9fYFqhCj0wnGmqEvVkgen6a3BwAA8ocNqBmGLD3J6DvpDQ2UkK8xVTziIz3w1QwYCr//5O/iNsCGjmN0n4f8nuJws0vVXvzS+qK+H2AyQx89jfgu0dwM4BVCFUnZJ4fayKenxy0g2ZN6IPx/bpgWLeyFJ8pdWpvMfUtHSu9AbwK26PTRqT8PCznRxn2xooFswVC5vk50OYBx3E46PSA4/h2lqc6lFLnsBpNrAYZIHp9AH14fnJyXMs0SZ4jx3RVdu3ahauvvhqff/457PbUuZaV3HPPPbj99tvD7yTk/IQLexN2hs1mw7x585LQujjZ9AmfK1DYGRh8buT90wALa2uReH4OTHocrz9xO943jMciY4YNNA2FNQvnEYqcNrkDAEy83Okln/GSwL1OSGMjJZDnJyIZ74fpIhrPj3IfZXFeIHQA+PVH/n8gAOxaKm5v+IkvDPzdI5KdQ0PVmJxs7LVscjvszWY2YWT3NOS+pLDOT0x9S8c1ftKJIHigUHsThENs/MSdeX48/gBa3T7sb3UHt1thzPQ4muVIVWc5joPBYBDyfQC+b2Y7eTOu6ZiYRrzly5ejsbERI0eOhNlshtlsxqJFi/DII4/AbDajqqoKHo8HTU1Nsvft27cP1dV83ZXq6uoQ9Tf2nO2jZO7cuWhubhb+du3aFbpTTFLXkT5pGvghKHQwcqb6JCcDsFUr6YqL09wJj/jPRrNVLVk7zWh4UmoP/QBrUOq6qYO/uGUFVv577XsyYM7QSpuGp4rIQ6Lx/Cj3saqFXKnc33xuwN0iV5t7+kTgvp6y3cyQTNiC90DB8xNr2JvM85MNN1S9Em3OT4oRPD+90nM+nWIO5vz4tcLegmOo3WISBIIOtnkkxg+FvEWiQBJhwowe5vmxmAxCrSUi38hgkdOTTjoJa9aswapVq4S/o446CtOnTxceWywWfPHFF8J7Nm7ciJ07d6K+vh4AUF9fjzVr1qCxsVHY5/PPP0dJSQkGDhyoel6bzYaSkhLZXyixSV1zHAen0wmn0wku3YP3vvW8R8JgAkZfmt5zh4EpPkldzEy+szDTIW+Maa8D1mLNlw+7+JtlWWGGFXWqhwJTHshsG3RARvthOgnE4fmxqfzOS7qGbnO3ynN/NLDDE7KN5fyQ5ydDqP7mk+P5ibpvcZyua/ykE3NQ7U1Z5PRwO993peOOGPrmRlMH3/dSrh6YA9glcw02/9Cb0lvejGuZQpjLp0ntrbi4GIMHD5Ztczgc6Ny5s7D90ksvxbXXXovy8nKUlJTgz3/+M+rr63H00UcDACZNmoSBAwfioosuwv3334+GhgbcfPPNmDVrFmy2BFZFopG6ZoYRx6G9vR1FRfzKaltbGxwOR/znjhVW1LT/FKC0W/rOGwFWPEzqYmZeIHvMRRBTRL9Tget+Bu7pKkpXS2h2823PaC0FcwHwh8WZO7+OyGg/TCf+aDw/CuPHqvJddDuKl4Bn0sQA4GqOKsTSbpAaP3K1N6spxkFEZvvQ4B4/kTw/YfaLQNR9y3kA8Dr5k5XVxXyefEJYIFQokTW1hxo3nR1W7DjYjoNtbrR08P2/pIBCoSNhMhpgNRvh8QUE40dvSm95M66lE7W5vTn+qKmk/5IefPBBnH766TjnnHNw/PHHo7q6Gu+8847wuslkwocffgiTyYT6+npceOGFmDFjBu64447ETixIXUcT9pZBtbeOw8DqN/jHWSBvLUXN89POPD/ZYvwAgK0I+Ms24Jq1IS+1BuePsVesTyKaq/xEXiH10miFvck8P1GEvRkMoblvUs+PvQy4YqHqmQohkcXmFMZPQmpvZPzETQo9P1HDQt5KakMLQhMyCoOhbO0eufFzWDB+RM8PC3E70ObBOyv5otylBVTjJxqUogdsQVYP+T5EGqmfBVQPASbeFvNbE16GWLhwoey53W7H448/jscff1zzPT169MDHH3+c6KnlRJPzk66aCeFY+QrgbQcqBwE90ii7HAWscrJbIjHpCt58CrIl7I2hkU/j5fh2ZrS9mhNdIq+4YiHwz2DNKmYQu9uAXxYCfU4ErIURPD8aMstKL4+7RcyHM9uB2hF8gV3F8QoQ6vlxxx32Jj0UGT/xE0HqOh1jls6V3tIJWwQMNX74vtbJIfH8FImFTjfs4RVqSwso7C0aCiwmNHd44RLC3vTl+SFSgcqiUEEZ8Idv4jpaDv2SYpO6zggBvxjyNvaKrJC3lsJWVVwSlz67yduzzfjRwAe+nYWZrklEEEWVQNUQ/jHL53nvD8Ab04GPbwjdPyTnR8P4MSj6otTzw8Q9VMIBCgyhOT/eeNXecrzIadqIpPYmCdVOGU3b+f9k/ESkUFAiky9wNXcEc34KpJ4fvi9u3e+EJ+hhvWwcCUpEg1TxDRAXafSS80NkP7lj/EQldZ1hz8/mz/hicvYyYMh5mWlDGGwSzw9L0uvIxrC3MATAxwunXRFm9OXpPR+hD5hHJhBcUNjwP/7/qpeDO4Tx/GhIu4csmrQ28MWSAdHoiRS+xMLeklHklDw/CRBt2FsKQ7XJ8xM1LKKA1fVhCBESknGShb2t2HEYAFBZbCO1tyixh4S9kecn70mysyA3fkkdTTFKXWdosBbkrS/iQ16yDOb54ThxRZjddLIu7E0TQ2YMtVPuSf85iezHFFwJVssDe3aSPERSmfNTFKW8/KFfJMZPcHIVUQCB1flJQpFT8vzEj6rnJ91hb0GlN6rxE5FClXIQgOiZkOakMLW3X5s6AAA9OmffmJ+tKMMLyfNDyEiCIaT/2KDPbwG+fVh8Htbzw17LwGC9fxPwy1cADMDoy9J//iiwSVZ/XT4/rGajcPMp0FEYWUYMNRMlshIqGIO/C7Uip7t+kD9XGkgada1CFngO/QL0OIZ/zDw/0po/YWCCBxZzrIMJeX6SQ+qKnEYNeX6iRpiUK8LemEiQXeKZ6OyQe3m6l5PiV7QUWOQh+OT5IRKRtVZDPzNaLaSGDxBd2BsXgMlkwrnnnguAV6BLOSzXp9+pWTvISI0ftzcA2MWwt6z1/Jz7PPDW72WbMqr0RsRE2vthujEFb7HRiGB4XZH3AUJXvVwtYs6PKcqwGi5BwQPy/CQH1XA2tSKnsX/HUfUtnwdo4ZXIsnVcyia0BA/U1Mi6FMvFDbqXk+cnWoSwN5bzw4yfmMNzM0POj2sZhzw/oRR0CvOiuIpmt9vx5ptvpqVJcLUAP73GPx5zRXrOGQcGgwE2sxFuX0BYyeoQPD9ZetMZfDbQbTTwkFh/Si/5SQTS2w8zgTEG4+eru+I7h6dNIngQbU5B0PgJTipiDychz09SUE35SY7nJ6q+1byLN8DMBbxABxEWIRE/JOwtdHLeq6IIJw+swtpfm1FaYMGUodXpa6jOUX7PbcEcqyKbPiIscn5cywRJTuPWt/ET8Iduc1Ro758pwYNVr/ITlIp+QO/x6T13jNgtJrh9AcHNzG4+Wa2eVlaHWWVP4McGfvWtyJbFbSXyi3Bhb+G4MlyRXMUo4HHy9xdAveibvQxwNcm3cSynj+8zMXtLyeBJEhnO+RFC3npknfpoNsKEQVi4KEPI+ZGEZZmMBjw946j0NS6HKAh+j8zz0+Li759UJJZIFlm6nB8l3vbQbYWdw7whA4IHgYAY8jbm8qwfYJjhwFZa2M0n26WunaV9sQ987Z9yB9VSILKEcIIH4agZGv2+zv3Ax9fzjy0qxo+tRPOtLpVcheigsLekkOkip5TvExMsPNTjUxg/VIQzqShzflqZ8WPXh+eHSAVq4cDxo2/jx9Mhf24w8aucWkhW0ZxOJwwGAwwGA5xOZ6paCGz9Eji0lZ+ADJuWuvMkiWJ70Phx8WE6epG6riktEB53KsyQ8RMu34xQJW39MFMopa6jIewCDlRyfprEx9ZgUvV5L4nbVCWzg1L2Hhauk4Dnh7xACRCpzk/8np+o+lZTUOmNjJ+oYKqITA2VEf8iAqGGXRH21tLBz0dKCvRh/OT8uJYD6LunKj0/nB8wRiN4kLomhbA0KG894kLtooVZhOj54VdahJyfLPf8XH1SX+FxcaZWh4z6uDETaSTasLduY4AZ7/Ohsee/HH7fcMHPLOyt53HiNquKypQQ9hZanyQ6yPOTFCIVOSXPT1ahGfZGnp+kwuYb7cqwNzuFveUtSY6a0vcvydcReR8ZaSgYJ+XgVmDz58hmeWslRcGbS4vC85PtYW+VxWKid8YUYUxWwO/OzLmJ7EQa9rZ5gfo+vY4HfvcmH7I2e2nkY0YzCJgk3k+1ULggLlY/I9b+TZ6fJBEh7C1tOT89U3P8HIOFvfkCHAIBDkajARzHqQoeEPHDFjBbOryy/xlb2CSyjHxXe/MqjJ8Z74ffP92CB8ue4c/VdxLQuU96zpkggucnaPy0e/QR9mY0GnD9pCOxcON+nDuqW2YaYdJ3dyJSgBD25gNeOSf09bOfBoaeF+NBw9z4mSEiNX7URBDAwecPCLkLsXt2yfOTFKL2/KTo/Mz4oQKnUWExidfG4w/AbjTB6+cQCF4f8vwkh7JgeFtz0Ohh8xASM8pnyPMjwoyfLgOAP34XPuQNQFoFD9xtwMpg+MqYK1N/viQh5Py4eeMn/rCY9DP7xL6YfWLfyDumCgp7I5QIYW8qUte1I+IwfFSOLxVTYF5tadFdNeOH44Q+Doj9Pmpknp/Y3kpIieT5CbdfgnQcBlzN/ONOZPxEg7QeltcfgN1iEpLxAcBhy/5xUg+UFcqNH6HeYLaW3CB0h75/SSznx1IQheGD9Hp+Vr8OuFuA8j5AnxNTf74kwdzKbGLEbuy04hIFJjJ+CAXsN8EKSUqJdxFG6hkIMWw4cZ9eJ/A5RHVjVA/DkognWtfCsvnTGBtBnp+koOr5kY5lKVywOxwUO3BUqueFESHIjR/+mhxu9wDg81HMsRYLJlQpDXp+mtrlucfZHn5PpBBVIZj40XdPZZ4fS7SVk9Pk+eE44Acmb31FdIZZlsCMnFaXDxzH4XDw5pMxBTU9YSvOdAuIbIMVOV3xgsqLcd6HCsrEx2ZFv5TmM854H/jTEsCqJrTCocXlhQ0ePGO8G3h9GtB+KPo2yGwfMn7iJ3VqbxGhfJ+YMRkNMBn5a8JED4QxkkosJA0tz09W1xskUgyFvYkw48capfEjrKhxMJlMOO200wAAJlOSVxN+WQgc2MhPOob/LrnHTjGi2psPLS4f/MFgZnYzIsJwzjPA678DJtyU6ZbohpT2w2zAGOYWG6/wilQK2+uSv9b/dPGxwcDL/6stDrXsRUvxYHQ1HBC3te0DCsvjaBAZP3GTwjo/EfuWtMApETVWkxEdAb+QL3fYyXt+aIEwebB6Pi0uLziO043qLCPnx7VME25cjZLcMH4sBeH3YwhS1wHY7XZ89NFHqWkXK2o6bBpg1y4wmI0UCXV+vGgKuvMLrSZyN0dD9RBgzppMt0JXpLQfZgPhQiHjzRErkBgoXkkNiaIq4IiJofurqb299wdUDLoaPQySCVvbPqByQJSNILW35BAh7C0Bz0/EvkU1fuLCYjKgwyt6fpqE6AhaIEwWhcFFWI4DWt0++IKLsHoxfnJ+XMsEUo+4KfGFBp0bPyznJ9p45TSEvR3eDmz8hH885orUnSdFFEs8P4doRYsgEiPcClW3o+I7ppZyZNej1GOhNRaHjlz3MK43S1b9W/dF3waOcn6SQibr/FDYW1ywWj+eoPHD8mOLSIY5aRRKjJyDbR7hsZ0EDwggKcaPvn9J8Xp+UjlYM3nr3hOALkem7jwpgnl+Wl0+4aYesxIUQRA8Wt6dmuHA+LnxHXPoBcDwC4EzHpdvZyv5SuydNA81yCh5j3N/DI0gz09yyGCdHzJ+4oKJHnh9/DUR8lF04pXQA0ajQSivcaCNr51nMhpgJUGJPCa5nh99/5JizfmRrKI5nU44HA44HA44nc7wb4sWTzuw4iX+8Vj9yFtLYWpvrS4fKawQKScl/TCbUKv9NO564MpFcebXBI955uPAiAvl2w9uVd8/2vMwT3o0kOcnOaTQ8xO2bwX8QNNO/jHV+IkJZvwwz0+7h18k1EM5CD3BxA0OtPLGT4HFBEMSVL7SQc6Pa5kmCcq6+l7S97Gwt2gFD+SraO3tMQz20bDmv4CriR9M+k5K7rHThFTwQFRYoZs6kTqS3g+zCTXPz7ALUnOuU+9T3x6t8eOJZZAmgyc5pC7nBwjTt1p+5QvvGi1ASW1cx85XhLA3HzN+aJxMBUU2Ew60AbsO87/hEp1FoOT0uJYJZCUebAkfTueen6DSUTZIXYfIW+vzRigtcko3dYJIELWcn2jDdGNl1Ez17baS6NRx4vX8UNhb/Kh+dWnI+WE1fsq663asyhSO4HjIPD56UyLTC8zzs2lfGwCga6cU3TcJ/ZH3YW9spTJqz0/w46ZisN7xLdC4jm+LMhxFRzDPjz/ACYIHBaStTxDxoRb2Zk7BIG4v037NYJArxGkRi/FDRU6TRIbq/FC+T9w4JNERgOj5obC35OKw8d/npn2tAICuZWT85DfSnJ/Ew970bfwwz0/UdX5SmDz6w1P8/6Hny4sQ6oxCq0n4mvYLsbb6/pkQRMZQC3uzqRUdTRB7afjXowl985DnJ+1kSu2NavzETZGG8UMFOJNLZTEv0b96dzMA8vwQEkz5HvYm5PzE2CmSPZA07wZ+Dmq661DeWorBYBBu7o2tvHFJN3WCiBNluNmFbyclXlng3Of5HMPzXgi/H3l+spQE1N487XxBbXdr7Kclz0/cCMaPKxj25uX/U3h4cqkrly9q15LnJ7+hOj8SBKnrKOv8pMrzs+xZgPMDPccBVQOTe+wMUGK3oNXlEz0/dFMniPhQuuerhiT3+IPP5v8iEZXnJwbBA/L8JIdEPD8L7wa+e5Qfdy7+MLbzUoHTuGHlIJxBz0+bm3JjU0F3hfFDYW95jnQhMe/V3mKt8yMZSIxGI0444QQAgNGYgAPM2wEsn8c/1qm8tRK2srWvRZSYJIhUkLR+mK0oPT9JuGnHRTSKXuT5yQCRPD8sTzUQuttPb/D/ty8GfO4Qj2LYvkWen7hhOT+tQeOnoZmfh1SV2DPWplykulT+e9aT8ZPz41omkEYvkOcnOFhbY/f8FBQUYOHChYm3Ye3bQMchoLQOOPLUxI+XBbCVLTHsjYwfIjUkrR9mK0rjJxrVtVRQXB15H58n8j4M8vwkB1XPj1TqWtgx9H3tB8XnBzYB1XKvombfcreJBW2pxk/MsMVBp9sHrz+AxmCERE0ZGT/JhOX8MPQU9pbz41omKJAU6yapayZ1HWWnCLeKFg8cJwodjL5UXdlJh7Cbu8vLf08U9kYQcaL09GTK+LGVCA8Xd7scOP6G0H1iui+S5ycpqH3nqmFvin28HXyoNcPnjv6cLOTNXqZrcZ5MwSIhOry84cNxgMVkQIUjibl8BCpLxO+z2G4WPG5EnmIrFh/nvdpbe3D1Ko6wt6Sw6wegYTVgtgMjNWps6JAiRTEx8vwQRJwo1d4yFfY2fDp+7nwyrvLMxheVvwfqZ4fuI51MR4I8P0kiTsEDZYhiLIbrYcr3SQQ7M348fhwOloMod1hhNBrCvY2Ikc4OG4qDBs+A6pIIexM5j13yG1BTUY2R3DCli6II6QBkA4nT6UTPnj0BANu3b4fDEWXonBTm9RlybvRV1HVAsWKFhXJ+iFSRlH6YzWSL58daiK+G3IcPfv0Z57h86kZY3J4fIm4ihb1pLdgpxSlUrp1m36J8n4QosPLXx+3zo7nDCwAoLcjQokYOYzIa8O6sY7F6dxOOO6Ii082JiZwf1zJBxZFA16P40jZJCHvTv/Ez4DfR1/lRDCQHDhyI/7wte4ENH/CPx+SG0AGjSGn8kNQ1kUIS6ofZTtUg+XND5laHZSpVaitngRg8P1LI85MAcRY5jcL4ATT6FtX4SYgCieeHjJ/UckRlEY6oTEFdtDSQ0+NaJjCagMsW8I+TMI7GFPb25JNPYujQoSgpKUFJSQnq6+vxySefCK+PHz8eBoNB9veHP/xBdoydO3diypQpKCwsRGVlJW644Qb4fL74P8HpD0W/bzKlrn98Dgj4gO71QM3QxI+XRVDYG0EkCUf2rFgWBSumt7l9CBhUFjTizoUk4yduVA3HKKSuEwp7287/J89PXNiCxo/L50dTOxk/BJE2DIakLSDGtKTfrVs33Hvvvejbty84jsMLL7yAM844AytXrsSgQfwK5+WXX4477rhDeE9hoeiV8fv9mDJlCqqrq/Hdd99h7969mDFjBiwWC+6+++7YW3/qPwBH5xjekKScH58bWP48/1jnRU3V6FQolxGsKiYVG4KIm/NfAd6YnulWoMjGT9Da3D64/AGE+MujzflR3j/J85MA8Xp+2hSHicH4oRo/CaHu+UlcepcgiPQRk/EzdepU2fO///3vePLJJ/H9998Lxk9hYSGqq9VzcD777DOsX78eCxYsQFVVFYYPH44777wTN954I2677TZYrTHeQGJdVU2W2tu693ip0OJaYMDUiLvrDWlxMYMBqColFRuCiJu+k4DaESFSxOnGIfH8tHv8KsZPlEYMGTvJI+6cnzg9PxxHnp8EYYIHLm8AB9p4lb1yB3l+CEJPxK325vf78frrr8PpdKK+vl7Y/sorr6CiogKDBw/G3Llz0d4u3qSXLFmCIUOGoKqqStg2efJktLS0YN26dZrncrvdaGlpkf0BAEwxTsqTFfa2lMlbX5I59aYUUicxfiqKbLCZKeyNIOLGbAWuWAj85tGMNqOYeX5cPnR4VLw8Uef8KO+fZAzFT5LU3qK9dm37AJ+LN7BK66JtJCGhQDB+/Nh5iL8O0jGTIIjsJ+ZM9jVr1qC+vh4ulwtFRUV49913MXDgQADA7373O/To0QO1tbVYvXo1brzxRmzcuBHvvPMOAKChoUFm+AAQnjc0NGie85577sHtt9+u0vpYw7GSECu4eznw63K+wuzIixM/XhbSrZMoHd6pMPeMO4LIR5jnx+n2ocOrMlmOxXsQ7jmRGKp1fiKFvUV5DZjXp6RbTi7cpQOp8bOLjB+C0CUxGz/9+vXDqlWr0NzcjLfeegszZ87EokWLMHDgQFxxhZj/MmTIENTU1OCkk07C1q1b0adPn7gbOXfuXFx77bXC85aWFtTV1fErqrEgGVSMBgOOOuoo/rExBgcY8/oMPgco6hLb+XWC3WLCxcf0xOfr9+Gycb0z3RwihzEajfH1QyJmmJBJm8fHK74pibrOD3l+koKWwRJVzk/ksDfVviXU+CGlt3hhRb/bvX5sP8ir7nUn44eQQONa9hOz8WO1WnHEEUcAAEaNGoVly5bh4YcfxlNPPRWy79ixYwEAW7ZsQZ8+fVBdXY2lS5fK9tm3bx8AaOYJAYDNZoPNphLiloDnp8Bux7Jly2J7e1sjsJb3YuWi0IGU234zCLf9ZlDkHQkiAQoKCmLvh0RcsLA3jgN+berACOUO0YZOkecnOURUepM8D1F7iyx1rdq3KN8nYToVWmA0AAGOz/sBgK5l0RZaJ/IBGteyn4RN0kAgALfbrfraqlWrAAA1NTUAgPr6eqxZswaNjY3CPp9//jlKSkqE0LmYSMDzE9dq5fJ5QMALdBsNdB0Z+/sJgiAyhN1iBCtCv3lfG/ycYqIdtRAMeX6SQwSlN9nz+Or8hEA1fhLGbDKiS7G4GFtdYhdEEAiC0AcxeX7mzp2LU089Fd27d0drayteffVVLFy4EPPnz8fWrVvx6quv4rTTTkPnzp2xevVqXHPNNTj++OMxdChfB2fSpEkYOHAgLrroItx///1oaGjAzTffjFmzZql7diJhL4ttf+nAwgUAxHDD8nuBZc/yj3OsqClBELmPwWBAkc2MFpcPWxrbEIARJki8PZTzk14S8fzEq/YmGD+9otufUKWqxI59Lfyib105eX0IQm/E5PlpbGzEjBkz0K9fP5x00klYtmwZ5s+fj5NPPhlWqxULFizApEmT0L9/f1x33XU455xz8L///U94v8lkwocffgiTyYT6+npceOGFmDFjhqwuUEwUlsf4BnFgaXc60bNnT/Ts2VOmSKfJ+veBtgagqAoYeEaM5yUIQo329vbY+iGREEU2fr1r3Z5mBJS3f/L8pJlIMtdIyPOj2reoxk9SqCoRQ+6lXiCCAGhc0wMxeX6effZZzdfq6uqwaNGiiMfo0aMHPv7441hOmzwknh+OC2DHjh3Bx1EM3kv/w/8f9fvYw+0IglCF47jY+iGRECxZe/vBdgRsCi8D5fykF9UaP/Hm/IReu5C+5XUBLXv4F8n4SYhqifFTWkCqeYQcGteynzyToZCGvcXwg9yzCtj1A2A0A0f9PumtIgiCSAe9uxQJj/3K27+vAwhE4/0hz09yiCLsLQG1txCad/HHsTiAws5RtpFQo7pUNH5K7GT8EITeyC/jJ17BA+b1GXgmUKytSkcQBJHNnDuqm/A4oFb37IM/Rz4IeX6Sg6rnR2NIDsn5UXp+orgGUqW3EA8TEQvSWngVRRT2RhB6I7+Mn3g8P84DwJq3+MdjSeiAIAj90qlQDNkNyfkBgFUvR3EU8vwkh1jU3hREIXUdAslcJ41JA6tx5Qm98ftje+IcyYICQRD6IOY6P7pGuqoWbXLvihcAvxuoGc5LXBMEQeiUcocYoqPq+YnE/o3Atq/l28jzEx8Jqb0FjR+TjR+fyPhJKwVWE+aeOiDTzSAIIk7yzPiJMezN7wOWPcc/HnslhQoQBKFrKopsMBj4uXRIzk80PD5GZaPKvXT3csB1GOg2Bvjq78DQ84Cuo2I/X06TSJ2fYM6PrQhoj9X4oRo/BEHkN/ll/EhW1QyAUFjVoGXUbPwIaNkNFFYAg85OQ/sIIr8wGAyR+yGRNMoKrbjnrCH4ccdhOLbYAPX61Inz8tmAq4mvxeZqAn58HvhbY4Q35RlR5fxEUHuzFQPtB1WV+kL61mGSuSaIdEDjWvaTX8aP5EdYWFiAdevWhd//ByZvfTFgsYfdlSCI2CksLIzcD4mkcsGY7rhgTHfgAUtsxo9WeJvadleT/L8/VVaWnklE7U1i/ACqnh9Z3+I4qvFDEGmCxrXshwQPtGhYC+z4BjCYgKMuSW2zCIIg0o3RpL7d71Pf7mmL7rjR1gvKd9TGIHezYoOK58fvBfwe/rFV2/iR0XEYcLfwj8u6x9xUgiCIXCK/jJ9Ycn6YvPWAqUBp15Q1iSAIIiNohWNoeWmcB9S3Kyfxfm/8bconosnTEcLgJN+xVOY6jOdHxuFt/P+iasBSEH5fgiCIHCfPjB/x47Y7nRg0aBAGDRqE9nZFwbj2Q8Dq//KPSd6aIFJGe3u7dj8kUotBw/Pj0zB+2g9pHEhh/AQSMH68HXmkHif5nMOmqe/CDFSpceMN9hODCTDbQl8PIutbezbyGynkjSBSDo1r2U9+5fxIwt64QADr16/nHysH25Uv89XOq4YA3evT2UCCyCs4jtPuh0Rq0SqoyUKqAKBhDbDsWWD8XD6xXo1keH7aDwGbPwPenw2MuBDo0h9Y8jhw4VtAl36xH08PSL+3ir4aO6mEvTGlN2uRGLqo0ndkfYvEDggibdC4lv3kl/ETTdhbwA8se5p/PPYKkrcmCCI30cr5YZ4fjxP493H847Z9wOBzNA6k9Pxo5Axp0bIH+JekZsry58XHr54HXLmYD9UyWULfmysM+A3wxR1iDg9DTfCA5V5ZC0UDNlLYW9NO/j8ZPwRBEPkW9haF4MGmT/mBoqATMOS36WkXQRBEuonk+fnhKXHb9m/5kDQ1EvH8+DzAC7/Rfv3wduDeOuCJoyOfV29I21/eB5i1FLhqpWInFc8PC3uzSI2fCCITpPRGEAQhkF/GjwyNgZMN+CNnUGIoQRC5S6Scn0NbxW0BnzjpDiEBz8/S/wAHN0fe7+AWICDxbnz8F+D2MmDb4ujPlXVIvjeDgQ/vK+oi30XV8xMUPLA6ovf8HGaeHypwShAEkYfGj0bROABo/BnYtogfUEZflt5mEQRBpBNNz4+bz8EplUgiGwxylTEpynuplvHTske+b9t+YNF90bdXKgO9NLhI9cLpwGc3A15X8NwBuZGUzXAK40cVtZwfqfHDcn4ifOaWX/n/5PkhCILIQ+NHa8AHRHnrfqdRLQSCIHIbo8a98NtHgPt7AT+9Km7jAtF7frTC3v41AFj2jPj8yzv42jM1w4ExV0Ru784fgsdXGFffPQosvIfP13zqeODZk3USEhdFG9U8P+w6xOL54fyAycZLXRMEQeQ5+SV4APCDCQcYwKFHjx7BTQbA1Qz89Dq/TzQDMUEQCWMwGOT9kEgfWgtB69/j/x/eLm7ztvOiB2qEeH7C5Px8fD3vXXceAHYu4bedej+wZUHk9r52PnDTPr5gp5K1bwOjLgb2reGfdxwGdn4P/PQaMOUBoKgy8vET4fAOYMd3QP8pgL0kuvcI31sUv3s1z4+lUF0Kmx2V9S2fCwZDOx/ypmXwEgSRNGhcy37yz/gJDjSFBXZs375d3LzkCcDrBLoMAHodn5mmEUSeUVhYKO+HRPrQyvnRYsWLGi/EKHiw4X/i4+OuAbqPBXb9ELrflAf48OPbSsVtzkbgx+dD923eBSy4VXz+4hlAw2r+ccdh4OIPw7cpEfZvBP47A9j/M1+v56x/R/nG4PcWbnKUQM6P0LeWzwP+dzVQRvk+BJEOaFzLfvLP+FEbTAIBkrcmCCK/CBcCHAvR5vwoGXc9cOLN/OOiqtDXux/D/z/hr8Cie/nHzgPAN/9SP97698XHzPABgL2rQ/cF+HZzAV7ye/WbfLuHqxQbbf6V36+sLvS1/RuBx8eIzzd/Dix+gFfGG/9/2p6WFS8Ce1YFn4QbbyQ5Pw1reU8W+76tDj7Uj72uBfPgUb4PQRAEgHw0ftQSSLcsAA79AthLgaHnZ6ZZBEEQ6USrzo+SIyaGD0tb/AD/f8hveSOmtSHyMSfdBRzzZ/G5tJBprxP4QqdVA/nnE+YCP3/Eh7S17QPMBXwR6mhxdFbf/uJvgNZ9wCWfAu8EBW4ObgFqRwADTuefu1qAfx/LP56zhi8s2rAaWPwv4KRbeONHSvsBvl4PAPQ5EehxTOh5/T7gA8lnj8bzE/CJ7WBYCkUvEDOCnAd4o0iqVEoFTgmCIGTkXwBwcDDp6OjA6NGjMXr0aHR88wT/2oiL+IGDIIi0IOuHHTFMaInEidbzM/DM8K+7W/iQswcHAi+dCfz3ovD79zoeqJ8t39alP2/UmKzA794Ahp4nf50ZMK9dIBo+VUOia7+1KHQbxwHbvgYObAQ2fiJuX/xPvv07vuOff/8EHzbXcZgPzXtmIi+qsP494NGRooqaGs+fCqx7N3R7m9I4jMLzs+QJlc/lEA1YLgBs/RL4Rx++MCwkfeuGt9Hh5cj4IYg0QeNa9pN/np/ggB/w+/Hjjz/yj7dsBKwkb00Q6SYQCIj9UC8SxbmCvTT861VDgMPbgG5H8bksP70W+Zjbw9TdmXwPLzww8MxQb4fFDly1AoBBvb5aoYr35qwngW8e5L0eQ84Fmnfzym9Kg8Tn5sPQWvYAnfvw26R5SYe3yffnAsDblwFnPgF8/Q9x+5IngF9/lO/76V+1Py8AvHkxUHEkcGCT+Lmbd8v3icbz07wz9DWrQxR/8HuAl87iH2/7GnjtdwhM/Y/Yt7hiqvFDEGmCxrXsJ/+MH2io4xw5GSjvlf7mEARBZIJT7+cn4kf/CdizUqydw7hyEX+fNFmASX/njZIRFwLzb+KV2roeFWoMaHHFQj6cLBwltdqvFVaEbivrDpz7nHzb0X/k67U9MVbc5usAnp3Eh6v9/lOgbixvLDAOKYwfgDegXjwTAAcYLbyC3dYvwrdf6/t4Mhj6du7zwOCzQ42faDw/algKRe/dpvny1zZ+BJzmkW8jwQOCIAgAeRz2FqJQRPLWBEHkE2V1wB8W80n+p90P3Lhd/rrRxBs+AB92dvqDQNdRwG/nAee/Asz8AOheH/4coy4GLv8ysuETCTXPj01DUrqyPzBEEjbndYkCCM+fAnw4R278KD0/3Y/hDR5wgKMLMP3NyO076Vbg2KvD77NlAZ/v8/al8u1Rqb2BN3aGXyg+txaJxs/+DaHvlRalLSyPXoKbIAgix8k/40dN8KC8D9B7QmaaQxAEkQ0UdAKuWATAAAyfrr1fcTUvCGB1ANPfkr824wNRue2Ik4GpD/MGU6IoRQuqh4Y3Gk77BzDq9/xjn0v+2ooX+CKujINb5a+PuJA39IprgDP/DVT0jdy+fqcCA6aG32fVK8DGj0O3q+UkCUg+Y7fRfHif8L7C8N+BR1KUlrw+BEEQAvkX9mZQMX6OuoSKvxEEQdQOB67fpO5pUcOmmLj3PoFXRVv+Av84WSjbMz5Crk1BGXD8DcDy53lBhnC4muTPh13Ae71GBoUbpB4UNYqqgMoB/ONBZ6mLHDDUxCD6n6a9v9S46Xkcrx5ncfA16aRhbwAw4Sbgq7+Lz6XtLlWR6SYIgshT8nDGHxxMtn8tbhr628w0hSAIItsoqoxeBlsNs42vlyaVr06UbpJaOn/6Aeg/JfJ71IQTIjH5ntDPbikETDbt90gNizMeB6a9Ht25eo4D7GV8HSMtpN6bURfz3+1x1/DetG5HyY2fsu7y93rJ80MQBKFG/nl+rA7A3QwseRIVhQbAbAdsxZluFUHkLRUVKsnshH4wWeU5NKmgtCtw2ZdA614+pycazPbYzvHbF9RD1wwGwO8Wn3ev55VBWe6O1MiyOvgQuEhMex3oO4lXorMWau/H1NwA3igFgBNu4P8AeQRDzTBgygPAR9fxzz1tqCi28sp2pPRGEGmFxrXsJv+Mn+JqoHUPHK7d2H9DMTB7OeCg2j4EkQkcDgf279+f6WYQidBzXGQltGTQLcbcIbMdvKefi7Qn70EZeEb4HBrGJZ/y/5nxE029pIJOoiFTO1I0kMIZPgAf6rbzO2DkTPXXWX6VvZSvlVQ5AFj1KvDrcjgsHPb/fQhwcDNQm0QvHEEQYaFxLfvJP+OnpBbYs4J/3OckoOKIzLaHIAhCz5z5BO9tyLY6aUYjL1rQuifyviNnRmf4qJ4nwjA65goABlFKfOYH0R97/F95eewKDeNl9GV88dK6MWL7LUGDyt0KNO3gH5PnhyAIQiD/cn6Ka8THY6/MXDsIgiBygeJq4IJXgD5ZqJipzINRY8yVfM2jcBx5Cv+/n0qukVp+1MUf80I6f93JK89JCavupnLsygHagjxmKy+Y4JCE2LDitf+7mg9HNJiAkm7Rn5MgCCLHicn4efLJJzF06FCUlJSgpKQE9fX1+OSTT4TXXS4XZs2ahc6dO6OoqAjnnHMO9u3bJzvGzp07MWXKFBQWFqKyshI33HADfD5fcj5NNJTwxk+HowfGX3EPxo8fj46OjvSdnyAIgY6ODowfP576IZEawhk/Jd2AWUv5Gkdma/jjnPkkcMp9wG8eje4cPY/l5bKZISIlXg9TtARD4TranRg/z4nxL3nQ4fGm9pwEQQjQuJb9xBT21q1bN9x7773o27cvOI7DCy+8gDPOOAMrV67EoEGDcM011+Cjjz7Cm2++idLSUsyePRtnn302vv32WwCA3+/HlClTUF1dje+++w579+7FjBkzYLFYcPfdd6fkA4Yw5LfALwsRGPkHLPrL6QCAQCCQnnMTBCEjEAhg0aJFwmOCSCrHzAbW/Ff9tWvXRX+cwnLg6D/It13wGl+7Z8JNURwgiryjZBE0fgIcsGiHH4CT+hZBpBEa17IfA8dxCd2Vy8vL8Y9//APnnnsuunTpgldffRXnnssXYvv5558xYMAALFmyBEcffTQ++eQTnH766dizZw+qqvgb9L///W/ceOON2L9/P6zWCKtvQVpaWlBaWorm5maUlMRXtdrpdKKoiA8/aGtrg4NEDwgi7VA/JFLO4R3A2reBL26Xb7+tOX1t+Oh6YNnT6Tnvj88DH86B08Oh6J5WANS3CCKd0LiWGWKxDeLO+fH7/Xj99dfhdDpRX1+P5cuXw+v1YuLEicI+/fv3R/fu3bFkyRIAwJIlSzBkyBDB8AGAyZMno6WlBevWxbAKRxAEQRDR0KkHX3y0Zpi4TUtAIGWk0fNTNSh95yIIgtAhMau9rVmzBvX19XC5XCgqKsK7776LgQMHYtWqVbBarSgrK5PtX1VVhYaGBgBAQ0ODzPBhr7PXtHC73XC7xToLLS0RKnYTBEEQBKO8F3Dl10DjBuDbh4ET/pLe88dTcDVeuo3m1esadwJ4P33nJQiC0AkxGz/9+vXDqlWr0NzcjLfeegszZ84UYhtTxT333IPbb7898o4EQRAEoUXlAOCsf6f/vMfOAbZ8AQyblvpzGQzAbx4BnE7g8hiU5QiCIPKEmMPerFYrjjjiCIwaNQr33HMPhg0bhocffhjV1dXweDxoamqS7b9v3z5UV1cDAKqrq0PU39hzto8ac+fORXNzs/C3a9euWJtNEARBEJnBUQH8aQlw7FWZbglBEETek3Cdn0AgALfbjVGjRsFiseCLL8RK3xs3bsTOnTtRX18PAKivr8eaNWvQ2Ngo7PP555+jpKQEAwcO1DyHzWYT5LXZXzIoLCxEYWGECtsEQaQU6ocEkRqobxFEZqC+l93EFPY2d+5cnHrqqejevTtaW1vx6quvYuHChZg/fz5KS0tx6aWX4tprr0V5eTlKSkrw5z//GfX19Tj66KMBAJMmTcLAgQNx0UUX4f7770dDQwNuvvlmzJo1CzabLSUfUAuHwwGn05nWcxIEIYf6IUGkBupbBJEZqO9lPzEZP42NjZgxYwb27t2L0tJSDB06FPPnz8fJJ58MAHjwwQdhNBpxzjnnwO12Y/LkyXjiiSeE95tMJnz44Yf44x//iPr6ejgcDsycORN33HFHcj8VQRAEQRAEQRCEgoTr/GSCZNT5IQiCIAiCIAhC/6Slzo/ecblcmDJlCqZMmQKXy5Xp5hBEXkL9kCBSA/UtgsgM1Peyn7z1/FAFXoLIPNQPCSI1UN8iiMxAfS8zkOeHIAiCIAiCIAhCARk/BEEQBEEQBEHkBWT8EARBEARBEASRF5DxQxAEQRAEQRBEXkDGD0EQBEEQBEEQeQEZPwRBEARBEARB5AXmTDcgUzgcDuhQ5ZsgcgrqhwSRGqhvEURmoL6X/ZDnhyAIgiAIgiCIvICMH4IgCIIgCIIg8gIyfgiCIAiCIAiCyAvI+CEIgiAIgiAIIi8g44cgCIIgCIIgiLyAjB+CIAiCIAiCIPICMn4IgiAIgiAIgsgLyPghCIIgCIIgCCIvIOOHIAiCIAiCIIi8gIwfgiAIgiAIgiDyAjJ+CIIgCIIgCILIC8j4IQiCIAiCIAgiLyDjhyAIgiAIgiCIvICMH4IgCIIgCIIg8gJzphsQDxzHAQBaWloy3BKCIAiCIAiCIDIJswmYjRAOXRo/ra2tAIC6uroMt4QgCIIgCIIgiGygtbUVpaWlYfcxcNGYSFlGIBDAnj17UFxcDIPBEPP7W1paUFdXh127dqGkpCQFLSRSBV07/ULXTp/QddMvdO30C107/ULXLjNwHIfW1lbU1tbCaAyf1aNLz4/RaES3bt0SPk5JSQn9MHUKXTv9QtdOn9B10y907fQLXTv9Qtcu/UTy+DBI8IAgCIIgCIIgiLyAjB+CIAiCIAiCIPKCvDR+bDYbbr31Vthstkw3hYgRunb6ha6dPqHrpl/o2ukXunb6ha5d9qNLwQOCIAiCIAiCIIhYyUvPD0EQBEEQBEEQ+QcZPwRBEARBEARB5AVk/BAEQRAEQRAEkReQ8UMQBEEQBEEQRF6QcePn66+/xtSpU1FbWwuDwYD33ntPdb8NGzbgN7/5DUpLS+FwODB69Gjs3LlT87jr1q3DOeecg549e8JgMOChhx4K2Ye9pvybNWuW5nE3btyICRMmoKqqCna7Hb1798bNN98Mr9cr2+/NN99E//79YbfbMWTIEHz88cdRfR96Qm/XTsqWLVtQXFyMsrIy2fZ58+aFHNNut0d1TD2RyWvn9/vxt7/9Db169UJBQQH69OmDO++8E5G0V3bu3IkpU6agsLAQlZWVuOGGG+Dz+WT7LFy4ECNHjoTNZsMRRxyBefPmRfoqdIUer9tVV12FUaNGwWazYfjw4SGvb9++XbUvf//992GPqzf0du0OHjyIU045BbW1tbDZbKirq8Ps2bPR0tIi2y/X+xygv2sn5eDBg+jWrRsMBgOampqE7QsXLlTtdw0NDVEdVy9k8tq1trZizpw56NGjBwoKCnDMMcdg2bJlEdtMY13qybjx43Q6MWzYMDz++OOa+2zduhXHHXcc+vfvj4ULF2L16tX429/+FnZS2t7ejt69e+Pee+9FdXW16j7Lli3D3r17hb/PP/8cAPDb3/5W87gWiwUzZszAZ599ho0bN+Khhx7C008/jVtvvVXY57vvvsO0adNw6aWXYuXKlTjzzDNx5plnYu3atZG+Dl2ht2vH8Hq9mDZtGsaNG6f6eklJiezYO3bsiHhMvZHJa3fffffhySefxGOPPYYNGzbgvvvuw/33349HH31U87h+vx9TpkyBx+PBd999hxdeeAHz5s3DLbfcIuyzbds2TJkyBRMmTMCqVaswZ84cXHbZZZg/f34U34g+0Nt1Y1xyySU4//zzw+6zYMECWb8bNWpUxOPqCb1dO6PRiDPOOAMffPABNm3ahHnz5mHBggX4wx/+IOyTD30O0N+1k3LppZdi6NChmq9v3LhR1u8qKyujOq5eyOS1u+yyy/D555/jpZdewpo1azBp0iRMnDgRv/76q+ZxaaxLE1wWAYB79913Q7aff/753IUXXhj3cXv06ME9+OCDEfe7+uqruT59+nCBQCCm419zzTXccccdJzw/77zzuClTpsj2GTt2LHfllVfGdFw9oadr95e//IW78MILueeff54rLS2Vvaa2LddJ97WbMmUKd8kll8i2nX322dz06dM1j/Xxxx9zRqORa2hoELY9+eSTXElJCed2uzmO46/roEGDQj7D5MmT4/4M2YwerpuUW2+9lRs2bFjI9m3btnEAuJUrV8bRWn2it2vHePjhh7lu3boJz/Otz3Gcvq7dE088wZ1wwgncF198wQHgDh8+LLz21VdfhWzLddJ57drb2zmTycR9+OGHsu0jR47kbrrpJs1j0ViXHjLu+YlEIBDARx99hCOPPBKTJ09GZWUlxo4dq+m6jBePx4OXX34Zl1xyCQwGg7D94osvxvjx4zXft2XLFnz66ac44YQThG1LlizBxIkTZftNnjwZS5YsSWqbs51svHZffvkl3nzzzbCrQG1tbejRowfq6upwxhlnYN26dUltrx5I5bU75phj8MUXX2DTpk0AgJ9++gnffPMNTj31VGGf2267DT179hSeL1myBEOGDEFVVZWwbfLkyWhpaRGuD/W77LtusfCb3/wGlZWVOO644/DBBx8k3F69ke3Xbs+ePXjnnXdorFMhG6/d+vXrcccdd+DFF1+E0ag91Rs+fDhqampw8skn49tvv024vXojVdfO5/PB7/eHeI8KCgrwzTffCM9prMsMWW/8NDY2oq2tDffeey9OOeUUfPbZZzjrrLNw9tlnY9GiRUk7z3vvvYempiZcfPHFsu01NTXo3r17yP7HHHMM7HY7+vbti3HjxuGOO+4QXmtoaJD9cAGgqqoq52JpI5Ft1+7gwYO4+OKLMW/ePJSUlKgeq1+/fnjuuefw/vvv4+WXX0YgEMAxxxyD3bt3J629eiCV1+6vf/0rLrjgAvTv3x8WiwUjRozAnDlzMH36dGGfiooK9OnTR3iu1afYa+H2aWlpQUdHR0Jt1gvZdt2ioaioCA888ADefPNNfPTRRzjuuONw5pln5p0BlK3Xbtq0aSgsLETXrl1RUlKCZ555RniN+hxPtl07t9uNadOm4R//+Ifq/AXgx8d///vfePvtt/H222+jrq4O48ePx4oVKxJqr95I1bUrLi5GfX097rzzTuzZswd+vx8vv/wylixZgr179wr70ViXITLtepICFZfkr7/+ygHgpk2bJts+depU7oILLojquNGETk2aNIk7/fTTo27rzp07uXXr1nGvvvoq17VrV+6+++4TXrNYLNyrr74q2//xxx/nKisroz6+3tDDtTvrrLO4G2+8UXgeTYibx+Ph+vTpw918883RNFeXpPvavfbaa1y3bt241157jVu9ejX34osvcuXl5dy8efM0j3X55ZdzkyZNkm1zOp0cAO7jjz/mOI7j+vbty919992yfT766CMOANfe3h5Vm/WEHq6bFK2wNzUuuugiWShxrqGna7d3715uw4YN3Pvvv88NHDiQ++Mf/yi8lm99juP0ce2uueYa7vzzzxeeRxvidvzxxycU/pXtpPvabdmyhTv++OM5AJzJZOJGjx7NTZ8+nevfv7/msWisSw/mtFpacVBRUQGz2YyBAwfKtg8YMEDmOkyEHTt2YMGCBXjnnXeifk9dXR0AYODAgfD7/bjiiitw3XXXwWQyobq6Gvv27ZPtv2/fPs2kuFwl267dl19+iQ8++AD//Oc/AQAcxyEQCMBsNuM///kPLrnkkpD3sJW2LVu2JKW9eiGV1+6GG24QVjMBYMiQIdixYwfuuecezJw5U/U91dXVWLp0qWwb62OsX2n1u5KSEhQUFCTUZr2QbdctXsaOHSuImOQL2XrtqqurUV1djf79+6O8vBzjxo3D3/72N9TU1FCfC5Jt1+7LL7/EmjVr8NZbbwGAoAxXUVGBm266Cbfffrvq+8aMGZO0sVkvpPLa9enTB4sWLYLT6URLSwtqampw/vnno3fv3prvobEuPWR92JvVasXo0aOxceNG2fZNmzahR48eSTnH888/j8rKSkyZMiWu9wcCAXi9XgQCAQBAfX09vvjiC9k+n3/+Oerr6xNuq57Itmu3ZMkSrFq1Svi74447UFxcjFWrVuGss85SfY/f78eaNWtQU1OTlPbqhVReu/b29pAYdJPJJPQfNerr67FmzRo0NjYK2z7//HOUlJQIgxb1u+y7bvGyatUq6nNBsunasf3dbjcA6nOMbLt2b7/9Nn766SdhrGOhiosXLw5bDoL6nUgy5ykOhwM1NTU4fPgw5s+fjzPOOENzXxrr0kSmXU+tra3cypUruZUrV3IAuH/961/cypUruR07dgj7vPPOO5zFYuH+85//cJs3b+YeffRRzmQycYsXL9Y8rtvtFo5bU1PDXX/99dzKlSu5zZs3y/bz+/1c9+7dZeFQUv76179yF110kfD85Zdf5t544w1u/fr13NatW7k33niDq62tlSmvfPvtt5zZbOb++c9/chs2bOBuvfVWzmKxcGvWrIn3a8pK9HbtlKiFvd1+++3c/Pnzua1bt3LLly/nLrjgAs5ut3Pr1q2L4hvRD5m8djNnzuS6du3Kffjhh9y2bdu4d955h6uoqOD+8pe/CPs8+uij3Iknnig89/l83ODBg7lJkyZxq1at4j799FOuS5cu3Ny5c4V9fvnlF66wsJC74YYbuA0bNnCPP/44ZzKZuE8//TRZX1vG0dt14ziO27x5M7dy5Uruyiuv5I488kjhPEy5aN68edyrr77KbdiwgduwYQP397//nTMajdxzzz2XrK8tK9Dbtfvoo4+45557jluzZg23bds27sMPP+QGDBjAHXvsscI++dDnOE5/106JWtjbgw8+yL333nvc5s2buTVr1nBXX301ZzQauQULFsT5LWUnmbx2n376KffJJ59wv/zyC/fZZ59xw4YN48aOHct5PB5hHxrrMkPGjR/WKZV/M2fOlO337LPPckcccQRnt9u5YcOGce+9917Y4zL5VOXfCSecINtv/vz5HABu48aNqseZOXOm7D2vv/46N3LkSK6oqIhzOBzcwIEDubvvvpvr6OiQve+///0vd+SRR3JWq5UbNGgQ99FHH0X9negFvV07JWrGz5w5c7ju3btzVquVq6qq4k477TRuxYoVYdurRzJ57VpaWrirr76a6969O2e327nevXtzN910kzAZ5jg+P6RHjx6yY2/fvp079dRTuYKCAq6iooK77rrrOK/XG/K5hg8fzlmtVq53797c888/H8/Xk7Xo8bqdcMIJqsfetm0bx3G88TNgwACusLCQKykp4caMGcO9+eabiXxNWYnert2XX37J1dfXc6WlpZzdbuf69u3L3XjjjSF5I7ne5zhOf9dOq/3Sa3ffffdxffr04ex2O1deXs6NHz+e+/LLL2P5WnRBJq/dG2+8wfXu3ZuzWq1cdXU1N2vWLK6pqUl2HBrrMoOB46IsE0wQBEEQBEEQBKFjsj7nhyAIgiAIgiAIIhmQ8UMQBEEQBEEQRF5Axg9BEARBEARBEHkBGT8EQRAEQRAEQeQFZPwQBEEQBEEQBJEXkPFDEARBEARBEEReQMYPQRAEQRAEQRB5ARk/BEEQBEEQBEHkBWT8EARBEARBEASRF5DxQxAEQRAEQRBEXkDGD0EQBEEQBEEQeQEZPwRBEARBEARB5AVk/BAEQRAEQRAEkReQ8UMQBEEQBEEQRF5Axg9BEARBEARBEHkBGT8EQRAEQRAEQeQFZPwQBEEQBEEQBJEXkPFDEARBEARBEEReQMYPQRAEQRAEQRB5ARk/BEEQBEEQBEHkBWT8EARBEARBEASRF5DxQxAEQRAEQRBEXkDGD0EQBEEQBEEQeQEZPwRBEARBEARB5AVk/BAEQRAEQRAEkReQ8UMQBEEQBEEQRF5Axg9BEARBEARBEHkBGT8EQRBEVrNu3TpceOGF6Nq1K2w2G2prazF9+nSsW7dOtt+yZcswe/ZsDBo0CA6HA927d8d5552HTZs2ZajlBEEQRLZh4DiOy3QjCIIgCEKNd955B9OmTUN5eTkuvfRS9OrVC9u3b8ezzz6LgwcP4vXXX8dZZ50FADj33HPx7bff4re//S2GDh2KhoYGPPbYY2hra8P333+PwYMHZ/jTEARBEJmGjB+CIAgiK9m6dSuGDh2K7t274+uvv0aXLl2E1w4cOIBx48Zh165dWL16NXr37o3vvvsORx11FKxWq7Df5s2bMWTIEJx77rl4+eWXM/ExCIIgiCyCwt4IgiCIrOQf//gH2tvb8Z///Edm+ABARUUFnnrqKTidTtx///0AgGOOOUZm+ABA3759MWjQIGzYsCFt7SYIgiCyF/L8EARBEFlJ165dYbVasW3bNs19evXqBZ/Ph127dqm+znEc6urqMGjQIMyfPz9VTSUIgiB0Anl+CIIgiKyjubkZe/bswbBhw8LuN3ToUOzevRutra2qr7/yyiv49ddfcf7556eimQRBEITOIOOHIAiCyDqYMVNcXBx2P/Z6S0tLyGs///wzZs2ahfr6esycOTP5jSQIgiB0Bxk/BEEQRNbBjBotjw5Dy0hqaGjAlClTUFpairfeegsmkyk1DSUIgiB0BeX8EARBEFlJbW0t7HY7fvnlF819evXqBa/Xi927dwvbmpubMX78eOzcuROLFy/GwIED09FcgiAIQgeQ54cgCILISk4//XRs27YN33zzjerrixcvxvbt23H66acL21wuF6ZOnYpNmzbhww8/JMOHIAiCkEGeH4IgCCIr2bx5M4YNG4ZevXrh66+/RufOnYXXDh06hHHjxmH79u1YvXo1+vTpA7/fj7PPPhsff/wx3n//fZx22mkZbD1BEASRjZDxQxAEQWQtb775JqZPn46Kigpceuml6NWrF7Zv345nn30WBw4cwGuvvYazzz4bADBnzhw8/PDDmDp1Ks4777yQY1144YXpbj5BEASRZZDxQxAEQWQ1a9aswT333IOFCxfiwIED6Ny5MyZMmID/+7//w+DBg4X9xo8fj0WLFmkeh4Y7giAIgowfgiAIgiAIgiDyAhI8IAiCIAiCIAgiLyDjhyAIgiAIgiCIvICMH4IgCIIgCIIg8gIyfgiCIAiCIAiCyAvI+CEIgiAIgiAIIi8g44cgCIIgCIIgiLzAnOkGxEMgEMCePXtQXFwMg8GQ6eYQBEEQBEEQBJEhOI5Da2sramtrYTSG9+3o0vjZs2cP6urqMt0MgiAIgiAIgiCyhF27dqFbt25h99Gl8VNcXAyA/4AlJSUZbg1BEARBEARBEJmipaUFdXV1go0QDl0aPyzUraSkhIwfgiAIgiAIgiCiSodJuuDB119/jalTp6K2thYGgwHvvfee7HWO43DLLbegpqYGBQUFmDhxIjZv3pzsZhAEQRAEQRAEQchIuvHjdDoxbNgwPP7446qv33///XjkkUfw73//Gz/88AMcDgcmT54Ml8uV7KYQBEEQBEEQBEEIJD3s7dRTT8Wpp56q+hrHcXjooYdw880344wzzgAAvPjii6iqqsJ7772HCy64INnNIQiCIAiCIAiCAJDmnJ9t27ahoaEBEydOFLaVlpZi7NixWLJkiabx43a74Xa7hectLS1Rnc/v98Pr9SbWaCJrsFgsMJlMmW4GQRAEQRAEoVPSavw0NDQAAKqqqmTbq6qqhNfUuOeee3D77bdHfR6O49DQ0ICmpqa42klkL2VlZaiurqb6TgRBEARBEETM6ELtbe7cubj22muF50zOTgtm+FRWVqKwsJAmyjkAx3Fob29HY2MjAKCmpibDLSIIgiAIgiD0RlqNn+rqagDAvn37ZJPXffv2Yfjw4Zrvs9lssNlsUZ3D7/cLhk/nzp0Tai+RXRQUFAAAGhsbUVlZSSFwBEEQBEEQREwkXe0tHL169UJ1dTW++OILYVtLSwt++OEH1NfXJ+UcLMensLAwKccjsgt2XSmXiyAIgiAIgoiVpHt+2trasGXLFuH5tm3bsGrVKpSXl6N79+6YM2cO7rrrLvTt2xe9evXC3/72N9TW1uLMM89Majso1C03oetKEARBEARBxEvSjZ8ff/wREyZMEJ6zXJ2ZM2di3rx5+Mtf/gKn04krrrgCTU1NOO644/Dpp5/CbrcnuykEQRAEQRAEQRACBo7juEw3IlZaWlpQWlqK5uZmlJSUyF5zuVzYtm0bevXqRQYVgO3bt6NXr15YuXJl2LwqvUDXlyAIgiAIgpASzjZQktacH4IgCIIgCIIgiExBxk8W4/F4Mt0EgiAIgiAIgsgZyPjJIsaPH4/Zs2djzpw5qKiowOTJk7F27VqceuqpKCoqQlVVFS666CIcOHBAeM+nn36K4447DmVlZejcuTNOP/10bN26NYOfgiAIgiAIgiCyk7wwfjiOQ7vHJ/y1drixdMUqLF2xCq0dbtlryfyLJ53qhRdegNVqxbfffot7770XJ554IkaMGIEff/wRn376Kfbt24fzzjtP2N/pdOLaa6/Fjz/+iC+++AJGoxFnnXUWAoFAMr9Cgkgb7e3t6NmzJ3r27In29vZMN4cgcgbqWwSRGajvZRdpLXKaKTq8fgy8Zb7Gq7+m7Lzr75iMQmtsX3Hfvn1x//33AwDuuusujBgxAnfffbfw+nPPPYe6ujps2rQJRx55JM455xzZ+5977jl06dIF69evx+DBgxP/EASRZjiOw44dO4THBEEkB+pbBJEZqO9lF3nh+dETo0aNEh7/9NNP+Oqrr1BUVCT89e/fHwCE0LbNmzdj2rRp6N27N0pKStCzZ08AwM6dO9PedoIgCIIgCILIZvLC81NgMWH9HZOF536/Hz/9tBoAMGzYUJhMppSdN1YcDofwuK2tDVOnTsV9990Xsl9NTQ0AYOrUqejRoweefvpp1NbWIhAIYPDgwSSWQBAEQRAEQRAK8sL4MRgMsvAzv98Au9kAACi0mlNm/CTKyJEj8fbbb6Nnz54wm0Mv1cGDB7Fx40Y8/fTTGDduHADgm2++SXczCYIgCIIgCEIXUNhbFjNr1iwcOnQI06ZNw7Jly7B161bMnz8fv//97+H3+9GpUyd07twZ//nPf7BlyxZ8+eWXuPbaazPdbIIgCIIgCILISsj4yWJqa2vx7bffwu/3Y9KkSRgyZAjmzJmDsrIyGI1GGI1GvP7661i+fDkGDx6Ma665Bv/4xz8y3WyCIAiCIAiCyEryIuxNDbvdnukmhLBw4cKQbX379sU777yj+Z6JEydi/fr1sm1SJZGePXuSsgihKwwGAwYOHCg8JggiOVDfIojMQH0vu8hL48dkMpEMNEFkKYWFhVi3bl2mm0EQOQf1LYLIDNT3sgsKeyMIgiAIgiAIIi8g44cgCIIgCIIgiLwgL40fv9+PtWvXYu3atfD7/ZluDkEQEtrb2zFo0CAMGjQI7e3tmW4OQeQM1LcIIjNQ38su8jLnBwBcLlemm0DkINsPONHm9mFw19JMN0W3cBwniHiQWAdBJA/qWwSRGajvZRd5a/wQRLLx+QMY/8+FAIDv556E6tLsUxQkCIIgCILIZ/Iy7I0gUsHaPS3C4592N2WuIQRBEARBEIQqZPwQRJLY1NAqPN66vy2DLSEIgiAIgiDUIOOHIJLEr00dwuPmDm8GW0IQBEEQBEGoQcZPntKzZ0889NBDwnODwYD33nsvoWMm4xh6Zm+zaPy0u0lFkCAIgiAIItvIW8EDq9Wa6SZkFXv37kWnTp2i2ve2227De++9h1WrVsV9jFzkYJtHeOx0+zLYEn1jMBjQo0cP4TFBEMmB+hZBZAbqe9lFXho/JpMJQ4cOzXQzEsbj8STNiKuurs6KY+gZjz8gPHZ6yPiJl8LCQmzfvj3TzSCInIP6FkFkBup72QWFvWUR48ePx+zZszF79myUlpaioqICf/vb3wRN+J49e+LOO+/EjBkzUFJSgiuuuAIA8M0332DcuHEoKChAXV0drrrqKjidTuG4jY2NmDp1KgoKCtCrVy+88sorIedWhqzt3r0b06ZNQ3l5ORwOB4466ij88MMPmDdvHm6//Xb89NNPMBgMMBgMmDdvnuox1qxZgxNPPBEFBQXo3LkzrrjiCrS1iUIAF198Mc4880z885//RE1NDTp37oxZs2bB69VnvozHJxo/7R4KeyMIgiAIgsg28sPzw3GANwMVdS2FQIzuzRdeeAGXXnopli5dih9//BFXXHEFunfvjssvvxwA8M9//hO33HILbr31VgDA1q1bccopp+Cuu+7Cc889h/379wsG1PPPPw+ANzL27NmDr776ChaLBVdddRUaGxs129DW1oYTTjgBXbt2xQcffIDq6mqsWLECgUAA559/PtauXYtPP/0UCxYsAACUloYW9HQ6nZg8eTLq6+uxbNkyNDY24rLLLsPs2bMFYwkAvvrqK9TU1OCrr77Cli1bcP7552P48OHC59UTXqnnh8LeCIIgCIIgso78MH687cDdtek/7//tAayOmN5SV1eHBx98EAaDAf369cOaNWvw4IMPCsbAiSeeiOuuu07Y/7LLLsP06dMxZ84cAEDfvn3xyCOP4IQTTsCTTz6JnTt34pNPPsHSpUsxevRoAMCzzz6LAQMGaLbh1Vdfxf79+7Fs2TKUl5cDAI444gjh9aKiIpjN5rBhbq+++ipcLhdefPFFOBz8d/DYY49h6tSpuO+++1BVVQUA6NSpEx577DGYTCb0798fU6ZMwRdffKFL40ca9kaen/jp6OjA8ccfDwD4+uuvUVBQkOEWEURuQH2LIDID9b3sIj+MHx1x9NFHy5Lh6uvr8cADD8Dv5yfTRx11lGz/n376CatXr5aFsnEch0AggG3btmHTpk0wm80YNWqU8Hr//v1RVlam2YZVq1ZhxIgRguETDxs2bMCwYcMEwwcAjj32WAQCAWzcuFEwfgYNGgSTySTsU1NTgzVr1sR93kzi9XHCY8r5iZ9AIIAff/xReEwQRHKgvkUQmYH6XnaRH8aPpZD3wgTx+/346aefAADDhg2TTb6Tft4kIzUmAD5E7corr8RVV10Vsm/37t2xadOmmM+RzhUJi8Uie24wGHR7Y5CGvZHUNUEQBEEQRPaRH8aPwSAPP/P7ETAHJ/hWB5Aq4ycOfvjhB9nz77//Hn379tU00EaOHIn169fLwtKk9O/fHz6fD8uXLxfC3jZu3IimpibNNgwdOhTPPPMMDh06pOr9sVqtgidKiwEDBmDevHlwOp2Cwfbtt9/CaDSiX79+Yd+rV9w+UnsjCIIgCILIZkjtLcvYuXMnrr32WmzcuBGvvfYaHn30UVx99dWa+99444347rvvMHv2bKxatQqbN2/G+++/j9mzZwMA+vXrh1NOOQVXXnklfvjhByxfvhyXXXZZWO/OtGnTUF1djTPPPBPffvstfvnlF7z99ttYsmQJAF51btu2bVi1ahUOHDgAt9sdcozp06fDbrdj5syZWLt2Lb766iv8+c9/xkUXXSSEvOUaUs+PyxuAP8CF2ZsgCIIgCIJIN2T8ZBkzZsxAR0cHxowZg1mzZuHqq68WJK3VGDp0KBYtWoRNmzZh3LhxGDFiBG655RbU1ooCD88//zxqa2txwgkn4Oyzz8YVV1yByspKzWNarVZ89tlnqKysxGmnnYYhQ4bg3nvvFbxP55xzDk455RRMmDABXbp0wWuvvRZyjMLCQsyfPx+HDh3C6NGjce655+Kkk07CY489lsC3k91IBQ8AoJ28PwRBEARBEFmFgWNFZHRES0sLSktL0dzcjJKSEtlrLpcL27ZtQ69evWC321Xf7/f7sXLlSgDAiBEjUpfzEyPjx4/H8OHD8dBDD2W6KVlLNNc3Uwy65VM4JSpvP/zfSagqya426gGn04mioiIAfE6bMs+NIIj4oL5FEJmB+l7qCWcbKMmI56e1tRVz5sxBjx49UFBQgGOOOQbLli1LaxvMZjPM5vxIeSLSg9LzQ7V+4qeiogIVFRWZbgZB5BzUtwgiM1Dfyx4yMvu/7LLLsHbtWrz00kuora3Fyy+/jIkTJ2L9+vXo2rVrys9vMpkwfPjwlJ+HyB84joPXzztRLSYDvH6Oav3EicPhwP79+zPdDILIOahvEURmoL6XXaTd+Ono6MDbb7+N999/Xyj4dNttt+F///sfnnzySdx1113pblLWsHDhwkw3gYgTZvgAQGmBFQfa3OT5IQiCIAiCyDLSHvbm8/ng9/tD8jUKCgrwzTffpLs5BJEUpCFvRTY+h0xqEBEEQRAEQRCZJ+3GT3FxMerr63HnnXdiz5498Pv9ePnll7FkyRLs3btX9T1utxstLS2yv0QIBALYuHEjNm7cqNuCmkR24ZXU+HHYeIeqJ0ItJEKdjo4OjB8/HuPHj0dHR0emm0MQOQP1LYLIDNT3souM5Py89NJLuOSSS9C1a1eYTCaMHDkS06ZNw/Lly1X3v+eee3D77bcn7fwcx6G1tVV4TBCJwjw/JqMBdgvv+fH46LcVD4FAAIsWLRIeEwSRHKhvEURmoL6XXWRE7a1Pnz5YtGgR2trasGvXLixduhRerxe9e/dW3X/u3Llobm4W/nbt2pXmFhNEeDxBz4/FZIDVxHcrpfobQRAEQRBEruHT2Xwno0VOHQ4HampqcPjwYcyfPx9nnHGG6n42mw0lJSWyP4LIJrzBjm81GWE1B40fn75uBgRBEARBELHw5c/7MPDW+XjzR/04JjJi/MyfPx+ffvoptm3bhs8//xwTJkxA//798fvf/z4TzSGIhGFeHqvZCEvQ8+PV2UoIQRAEQRBELFwy70d4fAHc8NbqTDclajJi/DQ3N2PWrFno378/ZsyYgeOOOw7z58+HxWLJRHMICT179sRDDz2U6WboDq+P1fgxwkaeH4IgCIIgiKwkI4IH5513Hs4777xMnDrnGD9+PIYPH540g2XZsmVwOBxJOVY+wZTdeM+PAQB5fgiCIAiCILKNjBg/2YDRmNF0p6jweDywWq0JH4fjOPj9fpjNkS93ly5dEj5fPuKReH5Yzo+bPD9xU1hYmOkmEEROQn2LIDJDLvY9t08s6WE2GjLYktjIfgsgBTB57ZEjR8JkMmW6OQLjx4/H7NmzMWfOHFRUVGDy5MlY+//sXXd401b3fuVtZyckzLA3lFk6oAM66aQLOuigu1/p+L7u9vd17/l175bS3dI9aaEFyihl771DCGQPx9vW74+rK13JkkdiJ3ai93nyRJZlWbZ17z3nvOe8Z8MGnHbaacjMzETHjh1x2WWXobKyEgAwbdo0LFiwAC+99BI4jgPHcdizZw/mz58PjuPw66+/YvTo0bBarVi0aBF27tyJSZMmoWPHjsjMzMSYMWMwd+5c2TUo0944jsO7776Lc889Fw6HA/369cMPP/zQkl9LWsDHCB7Qmh897a1pyMjIQGNjIxobG3UWUoeOBEIfWzp0tA7a6tiraPCK29T2SQekz5UmAPTGU/vzeDwxH6tsUKV2TFMxc+ZMWCwWLF68GE899RROOOEEjBw5EitWrMDs2bNx6NAhMWXwpZdewtFHH41rr70WZWVlKCsrQ3FxsXiue+65B0899RQ2b96MYcOGwel04vTTT8cff/yB1atXY+LEiTjrrLOwb9++iNf08MMPY8qUKVi3bh1OP/10TJ06FdXV1U3+jG0RtMmp2SQxP3ramw4dOnTo0KGjreJQvWQ7u/1BBEPp0d+wXaW9ZWZmaj53+umn4+effxYfFxUVweVyqR57/PHHY/78+eLjnj17imwMRVObp/br1w/PPPMMAOCxxx7DyJEj8cQTT4jPv//++yguLsa2bdvQv39/WCwWOBwOdOrUKexcjzzyCE4++WTxcX5+PoYPHy4+fvTRR/Htt9/ihx9+wE033aR5TdOmTcPFF18MAHjiiSfw8ssvY9myZZg4cWKTPmNbBHV0rLrUtQ4dOnTo0KGjHaCsTk4cOL0B5NhTX7ysXTE/6YDRo0eL22vXrsW8efOQmZkp/g0cOBAAsHPnzqjnOvzww2WPnU4n7rjjDgwaNAi5ubnIzMzE5s2bozI/w4YNE7czMjKQnZ2N8vLyeD5WmwdNezObpCanOvPTNHg8Hpxxxhk444wzwhhZHTp0NB362NKho3WQTmOP53l8v6YUy/dEz/DZerBB9tjpDSTrshKKdsX8OJ1OAEAwGMTatWsBAMOHD4fRaAyr/Ylk3CvFEvbs2ZOwa2RzQZ1OJ8466yw8/fTTYcd17tw5rnMBwB133IE5c+bgueeeQ9++fWG323HBBRfA5/NFPI9SgpzjOIRCumHPgrI8ZqNBdH50wYOmIRgM4pdffhG3dejQkRjoY0uHjtZBOo29hdsrcevna1CYZcXy/zsp4rGbDtTLHjd4/ADsSby6xKBdOT/UGQgGg7Db7eI+NdGDeArSklW8NmrUKHz99dfo2bOnplKbxWKJeSAtXrwY06ZNw7nnnguAOFeJdNzaM1jBA7uF3E9uf2pPcDp06NChQ4cOHSze+otkFlU0eFHr8iHXoa06vLPCKXvs9KQH86OnvaUwpk+fjurqalx88cVYvnw5du7cid9++w1XXnml6PD07NkT//zzD/bs2YPKysqIjEy/fv3wzTffYM2aNVi7di0uueQSncFJEFjBgwwrcVQb04T+1aFDhw4dOnTo2FBah8U7qsTHe6vUa98palx+AIDNTNyJhjSxe3TnJ4XRpUsXLF68GMFgEKeccgoOO+ww/Pvf/0Zubq6YenfHHXfAaDRi8ODBKCwsjFi/88ILLyAvLw9jx47FWWedhVNPPRWjRo1qqY/TpuFjBA8k50dnfnTo0KFDhw4d6YG3/9ole7y3Wtv5CYZ41HuI89Mtj/QwShfmp12lvaU6WAU5CsrWaKF///74+++/Zft69uypqjbXs2dP/Pnnn7J906dPlz1WpsGpnae2tlbzetor/EGpyWmGkPbm8qXHJKBDhw4dOnToaN8oqXbh5/VlAIAhXbKx8UA99lVpt26pc/tBTcRueXbsKHemjeCBzvzo0JEAUMEDC5P2li6TgA4dOnTo0KGjfeO9RbsRDPE4tl8HnDqEtE+JlPZW6yJiWVlWE/KEuiCd+dGhox1BlLo2GpBhIcPK5dPT3nTo0KFDhw4dqY1alw9fLC8BAFx3XG9UNxLHJlLaG633yXGYkSkEfdOl5qddOj9GozGsB44OHc2BJHjAwWElaW+64EHTkJGR0eQmwTp06NCGPrZ06GgdpPrY+3jpXrj9QQzunI1j+nbAmpJaAMDeCGlvlPnJc1iQaRMyXtKE+dHT3nToSABYwQMaAWn0BVN6stOhQ4cOHTp0tG94/EF8sGQPAOD643uD4zj0KCAtXA7Ve+HRaNtRKzA/uQzz4/T6k3/BCUCbdX50o7NtIlV/Vz+T9uYQBA+CIV5vdKpDhw4dOnToSFl8s6oUlU4fuubacfphnQEAeQ4zsgQ2Z59G6luNwPzkOiziselS69zmnB+z2QwAcLm08xRDoRB27tyJnTt36n1u0gz0d6W/c6rAywgeOCxSNqme+hY/PB4PJk+ejMmTJ8Pj8bT25ejQ0Wagjy0dOloHqTr2QiEe7y4k8tZXHdMLZiNxCwj7Q+SrtUQPKPPDOkoNaZL21uZqfoxGI3Jzc1FeXg4AcDgc4DhOdkwwGERNTQ0AoFOnTjAajS1+nTriA8/zcLlcKC8vR25ubsr9ZqzUtdHAwW42wu0PwuULoqCVry3dEAwG8dVXXwEAPvjgg9a9GB062hD0saVDR+sgVcfenM2HsKuyEdk2Ey4aUyx7rkd+BjaU1mvW/dS5BcEDuxmZVhKQThfmp805PwBxaACIDpASoVAIlZWVAEhfG9owVEfqIzc3V/x9Uwl+hvkBgAwrcX4a9V4/OnTo0KFDh44UBG1qeulRPcQ2HRTdozA/bqEWyGExSTU/OvPTeuA4Dp07d0ZRURH8/vDiK5fLhTPOOAMAsGrVKjgcjpa+RB1NgNlsTjnGh4IKHlgEypikvvn0tDcdOnTo0KFDR8phxZ5qrNxbA4vRgGnjeoY93yNfcH40an6o82M3G9Ku5qdNOj8URqNR1VgOBoPYu3cvAMBqtcJms7X0peloYxAFD0wkxZJGUBq9eq8fHTp06NChQ0dq4S2B9TlvVFcUZYXbwVTxbZ9G2pvbF878pEvNj57vpUNHAiAKHgjOdoag+ObS09506NChQ4cOHSmEnRVOzN18CABwzbG9VY+hggf7a9wIBMPFwajaW47DLKrcunyBlFXlZaE7Pzp0JACS1DVhfhyi5r3O/OhIDfy49oCo6qNDhw4dOtov3l24CzwPnDSoI/oWZaoe0ynbBovJgECIR1lduEJddSNxfgoyLLALzk+IR1q0+NCdHx06EgCfQvAg06ozPzpSB/5gCDd/thqP/bwZuyu1O3br0KFDh462jfIGD75eWQoAuOF4ddYHAAwGDsV5dgDAHpXUt2oncX7yMiyyFh80HS6V0S6dH4fDAafTCafTqYsd6EgI/KqCB3rNT1Ogj8/EY1eFtHDpIhztF/rY0qGjdZBKY2/mkj3wBUMY1T0Xh/fMj3hsT6HuR6n45guE0CCsJQUZFhgNHKxC8DcdVG7btOCBFjiOQ0ZGRmtfho42BNrnR5S6Fihg3dCMH/r4TDx2VzrF7XRR49GReOhjS4eO1kGqjL1GbwAfL90HALjuuD5Rj6dy1/sUim+03sdo4JBtIz1+HBYjvIGQzvzo0NFeQNPeaHdkUe1NEQEJhXjdIdLR4mBrz9KlD4MOHTp06Egsvlhegjq3H706ZODkwR2jHi/KXSvS3qpoypvDDINBqHUWMl5cuvOTmvB6vZg2bRqmTZsGr9fb2pejow3AF1R3flyKtLebP1+NMY/PxUGV4kEdBPr4TDzcjBOuMz/tF/rY0qGjdZAKY88fDOG9RbsBANcc2wtGwWmJhB4aaW+U+clzWMR9dlHxTXd+UhKBQAAzZ87EzJkzEQjohoCO5kMpeEBlH50K5ufndWVw+YL4etX+lr3ANII+PhMPdjFq0J2fdgt9bOnQ0TpIhbH3y/oylNa60SHTgvNHdYvpNWzaGythXdFAHLgOmVZxnyONWny0S+dHh45EQyl4QJkfNsXIG5AM0FgiLjp0JAoy58fjb8Ur0aFDhw4dLQ2e5/HWAtLq4Iqje8JmNsb0um55dhg4soZUOCXGqrTWDQDokmsX9zl05keHjvYFJfPTIZNQwVWN0mRRXi9tqzUM06EjWfD49ZofHTp06GivWLyjCpvK6mE3G3HpUT1ifp3VZETnHOLg7GNS3w4Izk/XXJu4j9b86IIHOnS0A4RCPAIhQgfTJqeFmWRCYB2e/TVucbtKaA6mQ0dLgI3E6TU/OnTo0NG+8NZfOwEAF44pRl6GJcrRcvQooKIH4c4Py/zQmp90kLrWnR8dOpoJf0hicSjzU5RN8mDLG7yoc5E0o60H68XjKp2686Oj5SBPe0v9hUmHDh06dCQGGw/UYeH2ShgNHK4+plfcrxedn2rW+SGiTbK0N3N42pvLF8DFby/Fa/N2NOnakwXd+dGho5mgKW+ApPZWkGEBLet5Yc5WbC6rx9Jd1eJxNTrzo6MF4fZLDo/u/OjQoUNH+8E7f5Fan9MP64zi/PgbrEqKb0TuuqbRh62HGgDInR9a68ymvf2y/iD+3lWFZ3/bKku/bm20ivMTDAZx//33o1evXrDb7ejTpw8effRRmZKEDh3pAtrgFJAED0xGAyaN6AoAmPn3Xpz20kLM3nhQPI51mHToSDbcsrQ3XfBAhw4dOtoDSmvd+HFdGQDg+uN6N+kcUq8fwvy8OHeb+FwXpuZHTeqabbOwam9Nk94/GTC1xps+/fTTeOONNzBz5kwMGTIEK1aswJVXXomcnBzccsstSX9/h8OB8vJycVuHjuaAOjImAyc2+wKAB84cjF0VThxgevpQeUg2VU6HHPr4TDz0tDcdgD62dOhoLbTW2Ht/0W4EQzzG9inA0K45TTqHUu563tYKAMBFY4pFkQOATXuT1piNB6R0f7buubXRKs7PkiVLMGnSJJxxxhkAgJ49e+Kzzz7DsmXLWuT9OY5DYWFhi7yXjrYPv6LBKUVehgXf33SMbN+8LeW48oPlCAR1llML+vhMPNx+XfBAhz62dOhoLbTG2Ktz+fHZsn0AgOuP79Pk89C0t+pGH8obvNgn1P7cd8Yg2XFqzM9f2yrEbdoYNRXQKmlvY8eOxR9//IFt2wh1tnbtWixatAinnXaa6vFerxf19fWyPx06UgW+oFzmOhJMghqcX5e61tGCYBcjv55yqUOHDh1tHh//sxcuXxADO2XhuH4dmnyeTKtJbN+xqYzY3xwHZFnl/Allgeh64/EHZZkvNa7USbluFebnnnvuQX19PQYOHAij0YhgMIjHH38cU6dOVT3+ySefxMMPP9z8N/a7gZlnwdvlaNz2Myk+f+GFF2C1WqO8UIcObUjMT/TGpSYDcZCoNLaOcHi9Xtx2220A9PGZKLA1Pz6ddWy30MeWDh2tg5Yee95AEB8s2QMAuO643uC45jVW757vQKXTh82C85NhMYWdM8NKmB8qsFOrcHZq2zvz8+WXX+KTTz7Bp59+ilWrVmHmzJl47rnnMHPmTNXj7733XtTV1Yl/JSUlTXvjDd8A+5cjsOglvP7663j99dcRCOgpIDqaB5rCRh2bSKAOkt7kVBuBQEAfnwkGm/bmC6SO4o6OloU+tnToaB209Nj7bnUpKhq86Jxjw1nDuzT7fDT17dN/SBodTXFjYRdqfhq9ZI35bk2p7PlUSntrFebnzjvvxD333IOLLroIAHDYYYdh7969ePLJJ3HFFVeEHW+1WhPjJYdSh3LT0XYQFFgcoyEG5keoC/Lr0XcdLQi2AFW/93To0KGj7SIU4vGWIG991bheYfXITUFXQdKaihY4VJwfmvZGMw1YsQMgnAlqTbQK8+NyuWBQRMmNRiNCyVbA4vS2RjoSj4Bw35piSHsz6zU/OloYoRAPj1+63/R7T4cOHTraLv7YUo5dFY3Isplw0RHFCTnnhWPk56EsDwuHkPbmEtLeymqJo3SR8NpUcn5ahfk566yz8Pjjj6N79+4YMmQIVq9ejRdeeAFXXXVVct9Yd350JAE07S0W5odGYPSaHx0tBbeisVwgxCMU4mWy7Dp06NCho23g7b92AgCmHtkDWTZzQs5ZnO9AYZZVbNdRIAggsKBskEtIezsgOD9DuuYAy0v0tLdXXnkF999/P2688UaUl5ejS5cuuP766/HAAw8k941150dHEkDT3swx1PyYDDrzo6NloXR+ANJnymoIj9zp0KFDh470xcq9NVi+pwZmI4crx/VM6LkHdsoSnZ+iLFvY8w6zpPYWCIZwsJ4ovQ3vRvoLVTX6EAiGxPT/1kSrOD9ZWVl48cUX8eKLL7bsG+vOj44kwB9HzY/I/Oh1FzpaCDT/2sABlHD0B3lYW2X216FDhw4dyQJlfc4Z0RUds8MdlOZgQMcsLNxeCQAoyg6vw6ciCG5/EGV1HoR4kuo/uHM2LEYDfMEQyuo8KM5v/QbL7cMb8LuB5e8B9aXhzx3a1PLXo6NNIRhHzY/e50dHS4P2XMi2S+kPeq8fHTp06Ghb2FXhxO+bDgEg8taJRo8CyWlRY36o1DUA7KpsBAB0zrHDZDSgax4RTCipcSX8upqC9hH7m/8ksPgl8aHdDOy+NZNs/3QjcMMCwNL6nqiO9IQkdR1fzQ/P883W3m+LsNvt2L17t7ito3mgSm8ZFhMaPAEEQ7zYmFdH+4I+tnToaB20xNh7d9Fu8Dxw4sAi9OuYlfDzUwcGADqpsEo2k+T87K5wyo4rzndgd2Uj9le7gT4Jv7S40T6cn22/yx4aOA49cwWjs3obMPse4OyXW+HCdLQF0JqfmPr8MMcEQnxMjVHbGwwGA3r27Nnal9FmQGt+HBYjzEaOOD8689MuoY8tHTpaB8kee5VOL75auR9AclgfABjbpwPOGdEFgRCP8QMKw543GDjYzUa4/UFUOEltUJaNuBnFguO0rzo1mJ/2kfamFV3vPQEAB6yaCWz4ukUvSUfbQTw1P2xqnF73o6MlQGt+iPND+0zpzo8OHfHil/VlGHT/bMzfWt7al6JDhwwfLtkDXyCE4cW5OKJXflLew2Y24sWLRuLVS0YhQ6NolKa+VTYQZTeHcByt89lUVq/6upZG+3B+Al7ZQ1+Qx52/e3Dnz9XwHXUr2fnjv4Hq3S1/bTrSHk2p+QGI4paOcPh8Ptx5552488474fOljjRmuoLW/NjMRlj0JrvtGvrYah5u/GQV3P4gps1Y3tqXoiPNkMyx5/IF8OHSvQCA64/r3arp9FT0gDI/mYIzVJxHnJ8/t5SnRPCt7Ts/XidQvVO2yx8Envvbh+e+XAj/2NuA4qMAbz3w9dVAMHWaMOlID8RV88OmvekGqCr8fj+ee+45PPfcc/D79fHYXLDMj8WkMz/tGfrYageY9yQw96HWvgodCiRz7H25vAS1Lj96FDhw6pBOCT13vKBy11QS22Ehj4/p10E8prqx9QMvbd/5qdoe+XmjCTj/XcCWA5SuBP58tGWuS0ebQUBMe4s+nAwGTkyP0w1QHS0BqebHJKa96YIHOnS0QfhcwIKngEX/AxoOtvbV6GgBBIIhvLuIZC1dc2zvmNLvkwkHTXsTmJ8MgQnKsZuR6yCKo3Xu2J2/XRVOPPrTprheEwvavvPjUymuMihyFXOLgUmvke3FLwE75ib/unS0GQRCsTM/AGAUKOkQrzM/OpIPmvZmFwQPAF3qWoeO5iKQkgEEZk0JeFrvMnS0GH7dcBD7a9zIz7Bg8uhurX05cNC0N4H5YWuDcoR2C/VxODInPL8A7y3ajRfnbkvgVbYH58fbEL6v/8TwfYPOAsZcQ7a/vQFoOJTc69LRZhAMxl7zA0j6G1QlToeOZMItSF3LBQ/0e0+HjngQUszXTm+gla4kAtiAmh5ca/PgeR5vCU1NLz+6B2xmY5RXJB92Ie2NBoUdKs5PrCxOIzPGSmvcibpEAO3B+dn0ffg+JfNDccrjQMehQGMF8O11gF6QriMGxM38CMfpt5eOloDI/Jilmh9fMNial6RDR9rBq2BLGzyp6Pyw16g7P20df++swobSetjMBlx+dM/WvhwAEvNDkW1ruvOzmVGGK8i0JODqJLR952f3X+S/nZH+s2WrH2u2ARe8D5gdwK75wOIXk311OtoA4qn5AaS0t6AemdPRAqA1P3aG+fEF9HtPh4544PEHIz5OCayaKW3r60ubx1t/7QIATDm8GPkZiXUOmgoqdU2R65Cuq0C4xlh7/Ww5KGVu6TU/8SIoyFxP/kDa12Oc9vGFA4DTniHbfz4GlCxL2qXpaBug6WuxNiylaW96zY+OloC8z48utqFDR1PgCSidnxQcQ7//V9rW15c2jc1l9ViwrQIGDrjmmOQ0NW0KaNobRZ4gcgAAR/YuAAD8ta0ipnNtZZyfWldinR+N/K82BCpdndWJpLVV7YB9xHnYsGEDAMBut4e/ZuSlhPnZ8BXw1dXADQsBe26LXbKO9AKVrI5VZUVKe9MXJzXY7fbI41NHXJAED0x6k9N2Dn1sNR00iEDhDaQg8yODvr6kEhI99t4RWJ/ThnZG9wJHs8+XKOQyzg4A5DHMz9GC87NqXy1CIR4Gxmaqc/tx4ycrcbBOEupgt3XnJ16EhLxcgwkYexPZBDBkyBDt13AccOb/gNIVQM0e4IebgSkfSiF7HToYBGiT0zidHz3tTR0GgyHy+NQRF1x+qebHqvf5adfQx1bToWR6UpL5YcGn+PW1MyRy7B2odeOHtQcAANcdlzqsDxBem5PHpON1y7PDZOAQCPH4aOleXDG2J35adwD7ql3YfsiJxTuqNM+b6LS3tu/8UObHaI58nBK2bFL/894pwOYfgJUzgMOvSvz16Uh7xFvzY+B0wQMdLQc1tTefrvamQ0dcUKa9pTzzE0pBQQYdCcGMxbsRCPE4qnc+hhfntvblyFCQYRW3zUZO7PMDACajAR0yrThY78HqfTUY3SMPN326Wvb6M4d1xmVH9RAf+4M8Ln3vH935iRsh4QszSM6Pz+fDE088AQC47777YLFoFIp1HQ2c9BDJo519L1B8FNBxcJIvWEe6wStEAK3mOJ0fnflRRczjU0dMcDPMj5j2pvf5aZfQx1bT4fGlQc0PC935SSkkauzVuf34bFkJAOD64/ok7PoSBZb5yXVYwCkyph6ZNATXfbQS28udKBGEDwqzrBjfvxAOixHXH98HXXKltMCaRh8AIi3vD4bENay5aDvOz5wHgGAAmPiEtC8Ukqhfhvnx+/14+OGHAQB33nln5JvwqOnArgXAjjnAV1cC184DLKmTX6mj9cEal7FATHvTa35UEdf41BEVfkHZzWIy6DU/7Rz62Go60o/5SfHra2dI1Nj79J99cHoD6N8xE+MHFCbyEhOCAibNLc8RnnHVv2MWAGBHuRPlQiPUUd1z8ezk4arny7ZL56hz+9Eh06p6XLxoG2pvfjew+CVg6WtAbYm0P8TQZFq9faLBYADOeQPI7ARUbAFm39O8a9XR5sCmFcUCmh2nMz86WgJ+pibNYiKOt09nfnToiAtpV/OjOz9tDt5AEDMW7wYAXHts7zBWJRVQwDgnDku43V2c74DFZIA3EMKyPdUAgKIsm+b5jAZO7BWUSNGDtuH8sPSus1zaDjJfVLw1PywyC4Hz3gbAER39DV83/Vw62hwo8xNrd2U97U1HS4KqEZqMOvOjQ0dTkXZqb3yKX5+OuPH9mgMob/CiY7YVk0Z0be3LUQXb1FTNxjEaOPQpzAQA/LyuDADQr2NmxHPSXkF1bl+iLrMNOD+rPwb+fk167KqUtmXMTzOcHwDofTxw7O1k+8d/ExU4HToAuIUIYMxpb7TJqW5/6kgA/th8SMydVkNAuNHMRi664AHPA4c2An6P+vM6dLRTpEWfHxZ6zU+bQijEi/LWV43rBYspNc13lo3SCvD2LsyQPR4gpMJpgcpn68wPBc8D308H5j8p7ft0CvDx+eS5IDP4m8P8UIwXRA+89cBXV8mZJR3tFvGnvek1PzoSg9kbynD1zBU457XFmsdQR8dsNIgLpibzs/Eb4I2xwBeXJvxadehIZyidnZRnfvS0tzaF+dvKsb3ciUyrCRcf2b21Lyciegh9h47oWaD6fLdceZ+jgZ2yI54vx647P3Jo6djvmAv4nIBL0AznjInp0WM0Aee/A9hygNKVwJ+PNv+cOtIeYtpbrM6PcCvyetqbjmbix7UkbaCq0afZNJf2oWKZH03n5zehQ/yOOYm9UB1Nx/qvgG2/t/ZVtHso6+R05kdHS+LNBYT1ueTI7si2JSCYn0S8eelo3DVxAG4+oa/q80p57hwVYQQWUtqb5Pwo01DjRXo7P5EiG/uWAq8fSbYTwfpQ5HYHzn6VbC9+CdjxR+LOrSMt4RIGoSPOmh+9yamO5oJlD8vq1VPVxJofjsPIQ19jFLdN3flpOAQ0HEjKdbYKlOx/OqJ8C/D11cCnk/XGYK0M5Zjx+FOMWVHeH3qT0zaDNSW1WLa7GmYjhyvH9Wzty4mKQZ2zceP4vrIGpyxOG9pJ3O6qYIHUkGMXBA8E5+fPLYcw5MHZ+EAQf2gK0tv5iVTQ9+dj0nZOsewpm82GZcuWYdmyZbDZtFUmNDH4bGDMNWT72+uJ0aCj3YL2f7DHyPzoUteR0ezx2Y4QYO6hSkE2VAlqtNlrNmPCjqfwjfUh2LwqnbQ3/5CUa2w1fHMd8MJAwF3T2lfSdGybLW27q5t9On1sNR1K5sebaoqJIUVKkM78pBSaM/be/msnAODs4V3ROSe6s5Dq4DgO711xOLrnO/DyxSOjHp9rF5gfFxE8+O+3GxDigYd+3CQdVLUTWPpmzNeQ3n1+IjE/JubmOv1Z2VNGoxFjxoxp3nuf8hiw92+gfCPw7XXApd9KGsY62hXoIhhrASJ1fnTiRx0JGZ/tBGzdQYNH3dihzo/FJzkBR1d+A2CC/MDGioRfX4tj2TvEibvoM2D9l2Tfhq+lYFWyULENyOkKWDKiHxsPVs2UthvKgIwOzTqdPraaDp+C+fGmGvOjrEHWnZ+UQlPH3p7KRszecBAAcN1xvRN9Wa2GEwd1xImDOsZ0rCh4IDA/2XYzDtQpMh1eOxKIQw0uva31SMyPI1/a7nlM4t/bbAcmzwDMDmDXfGDJS4l/Dx1pARp9N8Xo/HJc+2Z+AsEQ/tlVhZ0Vzta+lLQHG32u94QXg4ZCPOhtZuIlYyjbXx52LAJtQOHtlzuA3X8B/7wh7TMmuZHnvqXAa2OAmWcn9ryrPgKqd0mP9QyDVgVlfrKsJGaccsxPUGH46YIHbQLvLtqFEA+MH1CIAZ0iq6K1VSgFD9hGpyIjq2Q+oyC9nZ+IzI/w5RQNCav58fl8ePbZZ/Hss8/C52uGbnjhAOC0Z8j2H48CJcuafi4daQtWSjgW0MPaa83PG/N34sK3l+LE5xeoSjQnbHy2A7AGWIOK8+Nn6gCMIa/qtohVH0nbttyEXF/M2PQ9ULlDvs/XCPz+X2D/ivjP18ik9SXb+dn4LflfuiJxdG7AC8x5QL7PpZKqGCf0sdV0UOYnS+hjkno1P4HIj3W0Kpoy9qqcXsxasR9A22J94gUVPKDMD9tTcV+ENg+RkN7OT6SFxttA/nccHPaU3+/HXXfdhbvuugt+fzOl80ZeCgw9n7BQX10NuGubdz4daQc/ZX6M8aa9tU/nZ8uhBnF7d2Vj2PMJHZ9tHGwdQr073NgJMP18TCGf6jYAwpawNSUB9fqhpKB0JfDl5cD3N8r3L3gGWPIK8O6J8Z9TxvwkWRkpnzFKWKYmVmydDVRuBwLMb8L+Hvl9yP8EMHP62Go66FjLFqLQKc/86IIHKYWmjL0P/94LbyCEYd1ycHRvddnoNgmeJzU8B1YDkNqI0PpqNtCnZkPEgrZb8+OpJ/8NSf6IHAec+T+ygNfsAX68FZj8QWKktXWkBUTmxxDbb8618yan1U5pkVZL1dIRO+Q1P+HfJev8GBi2JyuoEAE4tEn+OOAm6lEtUcdIGR+nIq2rfFP4sU1BcxtcRwUz7rf8DIy7JfaXbp8DfHah9DivF3DMv0k6NQD0Oh6w5wHVO9tGWmIaw5/qzI9e89Om4PYF8eHfewAQ1odrTzblnAeAJS+T7St+hNU0FIC03rH1rVXOpgXq0pz5iTD5eFvI+QFI358L3ifvtek7YOUHyX9PHSkBtqbCGKPzY2znUtfVjYzzo8JW6IgdXj9b8xP+XbJF2sagtEj09W4So2oAAE5lKWgpY7uepHXAn6T3S/YaEHBL2566+F77yQXyxzW7SQDNL5zT7CD1pYC0T0erQKz5saUq86N0flLMOdMRF2atLEGNy4/ifDsmDukU/QVtCbvmSdszz4LVRJgfOuYavNK93tQAano7P5EGN017awnnBwC6jgZOeohsz74nPJKqo02ClRqONe2NBtPba9pbtUtnfhKFaIIHbINTTpnKtoBRwVSLKvqblksdN+qF3kKxOls1eyVmPxYkO/2H/V6DPtJbqLlje/OP5L/ZJtWvtmQqoo4wSM5PijE/9F7Tpa7bDIIhHu8uJD1srjmmd8y2RVrCXQO8cwLw7knSvK5w5K1m8vnH+ZcAB1bLmJ+mBlDT+xuNxPzUl5L/LeX8AMBR04G+J5FF/KurAF8LGQ86Wg0BpqA8VsED2uQ01E6dH7ZLc71bd36aAzbtLVLNj8lgCHcu2PlTjflxNb+vTEyIx/mp3gW8NAx47QhpX81e4IMzgY3fqb8m2UYgy8gcXAc82wd4e3z0yHuk8b9jDvlvdgAmgfkJ6MxPayJM8CCQAs7P7HuB5/oBtftUan5S4PqaiN82HsTLf2wP663UXjB7w0Hsq3Yhz2HG5MO7tfblJBcrZ5Kykf3LgaeKgVUfynuzOQpgNRkwhNuN50LPAW+Ph8vLrHvpxPz07NkTHMeF/U2fPj2+E8US0WtJ58dgAM55E8jsCFRsBn67t+XeW0erwM8WlMcpdd0efR+e52ULWp3u/DQLUdXeBIPNZOTCmQNXFUnRddeoz6WuykReqjZooCrgiT4otgpNPxvKpH2L/gfsWQjMukL9Ncl2ftjvdfdCwFMLlK2J7jzGwuSYbIT9URy/6UA9nF49st+SEAUPaNqbPwUM86Wvk/5c395AGEcWaZr2FgrxuP6jlXhhzjb8tO5Aa19Oi4PnebGp6WVH94TDkt6l+VFRtlb++Ieb5XOn3w2ryYg+nDTns+ncTQ2gtorzs3z5cpSVlYl/c+aQKNfkyZPjO1Eszo+xhW+czELgvLcBcMSw2PBNy76/jhZFgBmEphhrfuhh7bHND+ssAkCVU5fbbSqUjqRazQ9NyzQbDeHMwf7lpL7kh5sBn0rPpcaWcn4YA0fLIeB5oHSV5CixUGOtWCTK+VHWVFCw3ysbbQ96yXXvX0G+47r9ivPF4PyY7VLDboFhWltSi9NfXoi7vlob4YU6Eg2J+SHOT8qkvQHA3sUqfX7S0zl2+qTr3lXRNCWvdMbSXdVYu78OVpMBVxzdo7UvJ/mgNY0s2BROvwtWI4cQ1O2rpgZQW8WlLCwslD1+6qmn0KdPHxx//PHxnSgWWVEV5sdms2HevHnidsLRezxw7G3AwueJcdF1FJDXM/Hvo6PVQRuVGjjAELPzk95pb6EQj0veXYq9VS68eeloDC/Ojfm1foXEXaWKUkvSx2cbgUcReVaLgFHnyGRQYX4oNv+ozpC3BPMT8JLItfjYLTEd7GK34Blg/hPq57BGafyXCCNw4QvA/KeAq38DuoyUP6f1vfo9wIeTgN0LhOvMBk59nHldDI4/6/wIaYGltcQJ2nGgGlj3JdBlFNChb0wfoy2OrQ2lddhcVo8LRndLqiIWnbuy7SnU5DSzE+A8SLaVEfQ0ZX7Yeo6D9W1H4TDWsUdZnwtGd0MB08yzzUJLJMbRQVyDLJwfQYarMSGAgOC+qAX9YkGr82k+nw8ff/wxbrvttvgnrq+uBKxRXqOyqBuNRowfPz6+94oX4+8F9iwCSv4h/X+ump38fhM6Whzx9vgBJOYnXQUPyhu8WLqL0NK/bzoYl/OjzOFWc35aZHy2Abh8ARgQwk3G73C8cS1muCYBOEF2jIz5ObRR+2S0UScAdDsC2L9M3ig0WWDT1wBtR0LN8aFS3N6G8OdkxyXA+fnjYfL/59uBa/+UP6elwvbbfZLjA4QLSMRS42SySZFR4XhqhF/g/AT45lsgowi4c3v0c6Ftjq0zX1kEgDRCPHlwx6S9D527Mq2S88PzfOtKEFsypO21n8qfS1Pmh03fVWuCna6IZextO9SAeVsrwHHANce2k6amXg3xmn6niPe0lfcixDg/dvjQQJ2fdEp7Y/Hdd9+htrYW06ZN0zzG6/Wivr5e9qeKgn7AZd8CF38u7Ut6jwcNGM3A+e8SGezSFcCfj7XOdehIKuLt8UNAmZ8kXFALgK01cPnCo4t7KhuxeEelLCWQIpz50dPemgqXL4iTDStwm/krjDZsx0vc82hU1IGI96eRI2lj0XD5D0DPccIbtADzU6/I6Y9Hzpmm+XhqIx+XSCNQKWLjqtZ2vrb/Jn9Me/eIr43h+zXbJbU3QQo8GOJhgR9X4Xuyv7FcqvfYMRfYOU/lRG0TbADpzy2HIhzZfFDnh63BCLb2JM6mWR5cr/1cGmDl3hq8u3AXymqloEBbYn5iwdt/kWymiUM6oVeHjChHtxE4y8n/y76T7+88XCQvTCEvWBPLBilIllaCByzee+89nHbaaejSpYvmMU8++SRycnLEv+LiYu0T9jkByO0uPVZhW/x+P1577TW89tprye1yndsdOPtVsr34RWDHH8l7Lx2tAlrD0jTmJxlXlHywzo9b4fy4fAGc+uJfmPruP/hiRUnYa5WpIk5vACGFAdFi4zNdsORVYNa0sIJmtz+IYk5KGTNyPBpXfQk83RPYsxgAc38aOLE2ZarvXrihkU7R/SiSbgC0TM1PnaKGh2VDohlv9Nja8PtMhkSm//iZGgRXNfBML0mZTQvdBGU6tiYj4COKcNFgtjNqb+TzBoI8zjT8DRPHjKWAmzhHH58PfHSOpthCWxtbMuXIJqa/xAo6ljKsRnFfoNWdnwipd2mW9nbZe//gsZ8347nft4r7ahrbTnAs2tg7WOfB92vIfHjdce2E9QEk9j+rs3x/0UApYOR3I8Mo3c82Trovmlrz06rOz969ezF37lxcc801EY+79957UVdXJ/6VlGgtdsJEZJLyKRc6u+KK95fhn11SCofP58NNN92Em266CT5fkgfX4LOBw68m299eDzQkNzqlo2VBpa5jFTsA0r/mpzEC87O3yiU6ODvLw4tVadEw+325FYXDLTo+0wG//x9JS9s2W7bb5QtCeQcV/fYvot428yxgyasIBMjC4DBIC8SaUF/sNWjIp5qsQIbg/LgqgaVvAsvfTdQnCYdSwIB1ftSanp7C1MxUbCGMOtusVQ3JYn72r4jtNf1OIf/ZlL6a3bG91mRn1N6o8xPCNJOCVfJ75AyUBsvX1sZWWZ10j9S5kuvM0Xktg2F+fCrsdosilCDnx+eSywu3MFy+gLiWbDwgZfbUewKqGQQpA29DzN9ztLE3Y/Fu+IM8juiZj5Hd8xJ9pS2DUCi+Fgl+t1Tzk6Vo5JpTLBN7YZ0fO3ywCAFnjz/UpHukVZ2fGTNmoKioCGeccUbE46xWK7Kzs2V/EWGXbpxrFliwYFsFHvt5cyIuuWk49XGgaIggSXl95AlLR1pB7KMSY48fIP2bnMrT3uSG5YFaKW1JLSJD095y7Gaxr2ajLz1z01sE7D3ikzuTLl8A+ZxGyhUfBH7/PxTsIqlRGUbpO/bCjD+5o7XfkzI/FduA2XeTOpd40tHiQVjaG+PwKNXp+p0KjL1JYkLePxX469nw5o5KaDk/m38C1s2K73pdleQ9Adk6o4mOQwGThWyzanG1+2J7P7MtTO0tt2Ydhhl2w8szWQ0Bt5yVitW5SnOw+f6Hkpwi5RP6+jgsDPMTbG3mJ4LhTe/72fcCn0/Vtjv8btI764UhgLNC/Zgko7JB2xFP2XYI9WXAk92AGac1+1QNHj8+/YfMCSnB+uxZBLw6hvSrjMdO+epKwoZHC0hR0HnQZCclIp2HS89ld5HqHf1u5Fik+9cOL/IzLOJjtnF6rGg15ycUCmHGjBm44oorYDIlSHeB/kiOfGDq18DVc+AF+YJYo6zFYbYDk2eQH3jXPGDJS613LToSCpr2EGuPH0Dq89PaGRNNRSTmh3WM1BYtmjdvNRngMBMjgm1YpkMB1uExGGVPeXwBTDf9EPHlWeWEnXBw5LfgOSMCMGEmdzZw8iPAVb+rvEiIwDUwjkmyUmjCmB9mnlYyP/Zc8t8UpwKSmvMTCgJfTAW+uUbKOY8VtH5zx9zox5psgJE6PwzzU7tXcaBG8MTskAwAITJfVLkUAPBHaCS8JiEQ6PfIHVSluEIbhbcFe4bRtDeb2QijwFwraxhbDJ564KPzwgVDWPBB4vAsfR3Y8hNwQKPmr/4ACcz6G4FDG4BtvyUv2KGB8gZtx7WmCYZti2CTUHNX8k+zT/XZsn1o8AbQtygTJwwsavb5moxQiPRNm3kWULkN2PB1fOUam74j/5e8GtvxtBVMZiHAccAJD0jPme2M2IsbuRbJYLJzPmTZTGJj+fX76+Dl4/MjWs35mTt3Lvbt24errroqOW/Q7ySgWOoC3mqTFEXhAOD0Z8j2n48BJctb93p0JASygnI1VO0kURQG6Z72xjo4yhoe9nGFipIbdX7MJgMcgmqSzvxEACsDqnBAvO4oKmcALG6SZkvT3niBRfDzBmDcrUD3I6WDMwWlrGyV+sumpI59cz3w5jGRJZ2VzA+bGqZkfqyCoR+r82PJJP/VHDfW6XLXxnY+Fj4XsOCp6MfJnB/me1DKu953APi/g8Ax/wl/fdEQsl27F2isRFEtiaouCw2E30DFEFzylLwWNl5bC2yvnaYWPscKmuJmMRnEtN1WsyuWvAzsjGKUhoJyJS0th5jd//104NMpwO//bf41xoFIwjfOVA2OResvFiN8gRDeX7QHAHDdsb1jbpmRcLhrSEBo7kOklozWzs97nBALjVXAgmdJRsAfjwJfXAZU7lA/14avyPPRUuBWfUj+FwhS/X1PBI67E5j8AXlMnR9vA6Y0SmqGn1seQx9DKTIEG2JtSS2CkAcHo6HVnJ9TTjkFPM+jf//+CTyrtjGpbK7YKhh5GTD0fGJIfH1V0xZdHSmFiIIHQT/wyijggzOAGinSS6e2dGV+WIPDG1AY5Izzs7vCGZbaJxoQRgMyhPQRpWiCDgaskayQBPW7pMc1JnnvNAqDwDbYqfNjJMayLEf6iOvJ/zNeIP/teYBR4WA0hflZ9zlRoNqzUPsY6vxQR8Ufgfmhsr4qzk9JSOXz9xBU6+Y9Hi7z/Rrj9CmbQ8YCVsI6EsyM88M6gV5FU1mLwPD0PEbxegeQUSA5fq5qdKwl/VyWhwbAA3puj9yI9YXX27VFsPONxx8Km48ShWCIF5XdzEaDWG/QamlvStuBUzH8QgH5/KF1T7BjjgYFmlPnx/OEmYoDTq92cCWlmsmySJDE+Q9rD+BgvQdFWVZMGqkt/JVUHFgDvHU8sPUXMl+d+SJwzZ9k/jmwitSbfj8dmPcY8NoYYOFzwOYfgFdHa59z8w/Aohe0n9/yi5RdMOhs8p/jgBP+Cww5lzymKc7L3kZmSH5PTfV8gXONizHOsB6rS2phRHz3SaurvTUbR90obSsMLVZFqtULEwHyw575P9LwtHYfaYCaptF/HQQRBQ9KlknbTKQ53fv8sIEEr6LRplcWiQ2gRlGELDI/RoMoGduoOz/aYGWclQaPhzA/jYYs+I3qsqicwKTYIWd+ZBK9pz4B3LwKGHSm8CKOpA6zaJZogMZ9HvQDTkEAJl/Ic4/E/FDlH0bQhuIACqQHHYcSBiWfyZ1/U+FUyBwFhSOiBuV7/n5/9NfQ16kxP+x7nveOtG2U8tgBSGIHtJHr/mWwBp1w8jZs4bvDzQvHl64EZp4pva4dMj+AvEFmIsEyPBaTQazxbPWMEgrK2rIIBSPPHxRajFCwid/lr3cBTxXHLggChEn0AxAdzJRoJquGBDA/PM/jHUHeetq4nrCa4mMvEnABwMoPgPdOIcxybnfg6t+Bw68kqWhHXEeOm/c4sO1X9XNECrREcoKXvCJtW9TXL5H52TU/7KljPfPxoP9FfGJ5EptKymFqd86PsncCA9bhCYZ40RliI82r99WgosHbcoaoLQc4/32iX77pO2DVzJZ5Xx1JAVvDEga26JgpdqZpb2nq+8gWfGVQQblQVTfKU9+o42QxGUTJWFeEqF+7x3f/krYb5cXInI8sLB6DA35zpurLuRAxuO0G4TsWFhMZE240AQV95C9UGuHxOj+x3NwNBwHw5L1yhPYFkWp+6EJI/zNYEBwmPZj6FXDSQ/IaKT6krWalZGHUkKnIw6+KrakoTDZG8ECF+TnpIWDYFGm/8nunkU/q/Hw/HQCwOtQXQRjhoqIHv90nf107cX6U801TGx7G8z4Wo0Fk+lsto0TJOmSpOT8BucOj1VRX615Z8HSTLg3L3ib/F0aI+iugxvx0zSP3fuoyP803n+dvq8DWQw3IsBgx9cgeCbioOOBzAd/dSILwQS/QfyJw/V9Al5HSMWNvIay8socUi+pd2s8p03spGg4C+5aQbUcHYICGaITKXK+G/r7NMHLxjcUEKQ20ImR9fOQfXjkxVjq9KMq24ft1h1B4wYMAgKkzVoEzGOGwGNE934HifAd65DvQvUDa7ppnT6xH3m00cOKDwJz7gV/vBoqPBIoGJe78OloMVKbZalbcHyXLREMFgGyB4dK85od1fsKYH8WYq3PLFzXqLFpMBtiF70zJ/FitVvz000/idrtGzR5pe+3nxIDvOBhY+QGO9ZL7x2PMhN+Sq/pyg2Bw22lfBCFlzBcMIRTitfPLw5wfwais3AHkdJMYCS3E4izRlLeszoyqj2Cg8bwK8yMcYwl39GqQhZsL3sErZxcD2UK/CINieWs4qK7Q5oteOwVLVvRj1MAyP+5a8rk4TnpP5WdR9qUzK5wfAStCAwAAjUGNJt4a0fy2NrZaivnxMfOa2ciJrETrMT+KcavG/PBBufEZCK/BBKDt/Pz9KqlV3v0XEUehgiOxgo7DGKBUDQWAoiwrdlc2pofzQ8d1BKiNvbcXEMfh4iO6I8euMZaTgcodwJeXA+Ubyec44X5g3L8lKVqKjALgyBtImpsS3Y4A9i8DKrcDnQ5Tfx+tgNNewfHpdBhwwyL1Y4CYnZ+bjd/GdByL9Hd+2AVOWV+gMMRKa90oyrahrMEPR58x6JhthclgwIE6N1y+ILYcbMCWg+ELIccBnbNt6F7gQPd84a8gQ9zOc5hFgzZmHH0TyRvfMReYdSVw7Z8k71tHWsEjGP/UkEcwAPxyO6GSWTDGCLU307Xmh81zD6/5kT9WFiH7guR5i5FhfhQLn8lkiip/3y7hrQPWfwkIQbhcYbfPmAGjiVk4x98HzH8CAGAIEYPHJqi9ccxi4g2EYLdoBHXCnJ8gsGsB8OHZpJH0ZVEWm2AMEfj6/eR/dlcprYxGp9Wi1DQ1QsX5cfFW7DN0BXowEt5K52flB6TustNQ+X61fkJKRGu4qgWDQaqfKt8IzL4HmHAfsPlHsk/h1MCg4fwonMnlPHV+jOr5GxoGbVsbW2HMT5JED/xMrSLHcWLaW6C12lYo7Q0lMwmEp73NvpuM3UJFnbWW8+N3AV8LPQrL1gAXzAhniJVgC9zVhFM00CiIGlx2VA/kOcwY0T0XH/1N6mTTIu0tFASMJjR6A2IRvhLKsbdufy3+3lUFk4HDVcf0SvbVStj4HfD9TSQAk1EIXPA+0Os47eOPnk7YPLbm9KLPyBy2fxkRddKCW0PwgEpcFw2OfK0K5+cS33341PJE2GFjjZsin0cF6e/8KCNlDJSG2IFaD0Z2lyQxrxjbEzeO7wtvIIjSGjf2VbvIX5VL2q52weUL4kCdBwfqPFi6K/zHzLKaUCw4Qj0Exohud8m1w6xWDG8wAOe8Cbw5DqjYDPx2L3CWLoGdbqBRKZtZ+I3XfRHu+AAyYy7d1d7YVLcwtTd/5DQUf0BKe7ObhZqfVFXzaW1snR39GBDnpzDARHiPv4vUu3xzDQxBH/py+zGpgtSVGBxSbYzHH9R2fkwqaW9rPyfbO/8Elr8HjLmaRJO/uJQU6o+7VTpeTUQgFCSpvrk9gG6HSwtgdpewRp5wVYW/nqY4q+SHe2ANrxtQslP/vEn+HlKkYlCGyVkO7FsKDDidpAKy4GMwwIZdSMa/8nXsGvXPmySSTqEUkrDlKD6DghETsCZE1JECvEbQzd/+BA8AoN6dXObHIqQ30zXdF2itOVzp/HQKPyQUDE87eu9kYNRlQJ8TgT4TyL5YZNHL1hLxnntKAFuEPotsqrfSkY8AmvbWOdeGG8eTe/vL5SQ44k1V5odNq131Ab4yTMQds9bi+cnDcf5ojSbSDN4San3OGt4FXXJjYziahaAfmPMgsPQ18rj7WOL4RGPoHPmktp6qW974D1A0ENi7mDyOxJxr1ZnRTAJlkE2JermU+wG+ALf7bsDzljcjvy4GpL/zE2GAeRSGGNWSr25ww7l+LtaaN8M/7lZYzWb0LsxE78LwiCLP86hq9GFvlQslgjPEbh+s96DBG8CmsnpsKgsv7jJwQJdcO3oIrBFJpaOsUS5yzn0L+OhcYjD3Hi+pXOhIC0jOjzARVmyRH1A4kOxjFhgatEtXwQOW+VGyq+GRWLkx4mWkwbWYH7/fj08++QQAMHXqVJjNLZgOkEi4a4kx62sk9H9ucXyv/+xCafuY2zSVc3ymDFjAzD0cR1LjABhDPvxquRdmIbWQG3AqzJs5+IM8PJGUsdRqfjoOkR7/fBtJf2usALb/Tv5Y54dlKujt8sWlRE0osyNw+1apILrTYVI9E41Cb/k5/Jo69CP/VZyfAAzhzk9GjP0y6Hu+cyJQtw845XHSTJUFdVKGnk96X6jh+Lsl58dgArofTX63xkr5ceVMlFKZ657XAzjjeWDlTJKDT52fMVcDv9wBAFhSdBFc+4hjF9CSd9UoQm4zY0uA0jBONvNDWxpQgZtWY36UUGV+AuFBCE8tKTRf8ooUBIinPqxsLdDrWO3n2TTdaM2HGdCxm8mwJjSgqLTjUgYs8/Pz7XjFywHohNtnrVV1ftixd+zEc/HremLYX3tsCzQ1rT8AzJom9SQaewspvVAGebRw1L+AFe+T2qAc4bPRoM6Wn6XUOSXqSkhanPMQ6Yt00kNk/qbzaQTyAgBQvlncrCg8CntKOmM/Xwi734txRxyBw7a+gm6u+FkfoC04P0YzMHoasPoT4HR5XqIyV5QaZg0uN6p+eRFv/wK8cM+/Ii4AHMehQ6YVHTKtGN0jPF/c4w9if43kFCmZI28ghP01buyvcWMxwqOZOXYz/s8+GVPcX8LzzU34vaIjCrr1R/d8Bzrn2NQllHWkDOg9Jqa9yWj/bqRjccUW1ZqfNPV9ZHnugRCPQDAk3qdKtrVa0b/BL0ZQjZLam4L58fl8uPLKKwEAkydPTj8DzVlOjNd5jwOnPAb8/RqR9Lx5VfS0ETX0nwhM+D/iQK2cEfa035SJ6qMfgvn7S/CyYSruBMQ0MmPIBzPHfL+DJsH20yr4g4HIRoWa86NMI/vuxvC+NBSs0bXzT9J3beef5LHzEGF29pFmneh+tNQwlI4TZf8fAOggpOuo5IHnoDG8aFqZUkahNPbo4zqBidr0fbjzQ9PeDpus7fyYrEQedtuvwLG3S9eZ1RkoPgooWSo//rDJ4ap6ADDmGvLH4ohrieNlz8PP320A9pFr1extoVFonPZjS4GWEjzwic4PmecoA9RqNT9haW8aNT+xSNQrx8OUD4GN35I/JQ6ui+z8VLMiP7GzcHTsZlhY54fc28mSL080enNl2Mt3kmwBBdixd8/ngxHigeP6F2JwlwhMWiKwcx7w9TWAq5JI5p/zhqTsGSvsuaQ2J+QHrAJJQNeIqh2kMWpBP8LO+13ARZ8Cn19Cnt/9FwmWAeT9T7xfSouOxg6OuAT4i/TH3Dz2ReCLXQjAhI+DJ2NY12H43DYad/wt9fNEfl8Aq2P6SOnv/BhMwBn/I16sYiFRdp+nKTnKaHVzYDMb0bcoC32LwhfaUIhHhdMrOkR7q+XsUaXTizq3H/e5z0Qfy2qMxnYU/3kzJvseQAAmmAwcuubZpTojRVpdli25C9eCbRXYUlaPa1uz8VaKgxqQIvPD5libbUzairTApHvNj1LhyCdzfsj30aPAgb1VLqzYWx12LCDv86NW7JrWeP9USQHn9/+T9m+fE5/zY7QQJ2LiUyRCd9aLZN+yt2SH+U2ZsPc7HkO97yHAmXBbiIdRWJiMIUXkN7MQVrMRDd5A5EJiZUQuGAiXhHZVakd32Zqfpa8R54YtuN7+O3m90Qp0GSFFJGleOTuOlNekUBeq5x2YFxqBRm8APM9L9ZcqtUEAwlMxlMafasqesGZkFJGmo+Ubw48xWoiYTTdF7wuLA7j6N1LkO4NherJUUpUiQVjfWJnygJZgazvpIafsEZYs5oey3dT5kZqctsIk7nUCS1+X72Odn97jiTRwKBCb8Igy7c2arW2Ulq2LfC427a0JzA9bL0MVVFOW+VE4loVcLQCgY3Z0IZGvV5UCnAXXH5dE1icUAhY+T4Jw4IGOhwEXfihvARAPlIqCyjXi4Dpp3u88AnAUkCAXuxZUbhOujaa9RbFhj7uDqM/1OhamEi8Aae7PtpmQYTWhlC9AV04gFs5+GbgrgnPOIP2dH6OZ1M+oRNCURhWNILRUtMZg4NAx24aO2TaM6al+fSXVbuytasT20hcx+J+LMBI78Ej293iocTJ8wRD2VhFHSQ35GRbRERrUOQvXHNNbjEglAle8T/rU5DksmDImzpSddgJJ7U343tnFhjNKdQoy5ye9a36U48cXCMEhBIFogOG4foX4qGov1pTUygxSKXeeg8PaRvv8aEl/xlM0H/RLRjhbB9I1vKlcwJyJPIcZfpgAHqhx+dBBYH5MvA+NvBUZnJdE48Cmk0RyfhQL+NdXyVNaxOvUMK6UggeVW+WPV5P0D3Q7nDAm9DN66onhrjTeh18ibWfIG5oe4X0NHlgBnhhKYh1Tr+MIW+SuBRrLpRcoHStlfZGawUh/O4OBpOmpOT9KZkwJJRPl6BD5eA2wBrc281MbkwJVusMprPHZNhPqPYGk1fzQ9Daj4PSYW1Ptbe6D4ftYw5Teh6FQZOfH7ybBOaXzb8vRrsUoj5BixPPyerZYRE8EUPZfnvaW4syP4rst5kjqblF2FCVMkHnqsJ7ZGNunIOqxTYKrGvjmOmDHHPJ45GXA6c/GrJ4WE5T3iLtG+k4MJqDfqcDaTxXiNcLcRdcNg8b8RWGyAgNPBwDYLPLvO9tmRqbViGm+u3GH6Utwx9+DozoPUzuL+qljPjJVEbHmRz3tLVXUQxwWEwZ0ysKATlnAkE5At9eALy/HJb6vcdG0qThYOFZThKG60Sf+rS2pxY9rSTTquuOakFajApYdW7SjUnd+NBCW9qZMM4jA/KRtzY8iz52NzNGFamjXbJgMHBo8Afy8vgxnDiPKP34V5sfdlpgfLTlZIL5eOSzLwjIYw6YQQ5zp/8MZTDAZDeiUbcPBeg92VTSiQ2dpYTJB+H0KBwKQjIrIaW+KeVXN8QHkjgRrbNNeH1rYK8ibdj+K/KdF1Nt+BZ5m+l2c9gxgywWGnCPtO+G/RGlI+I48kBw1pzcgOT9mGzB9GVGqenu89HqXnI3EyhnArnnSYzWjjY5rzqgdrYxWvKtkotRS3mJAkGmsrMn8hAKk7seqwX61EdAeYZ1z7Kj3NKAhycwPVXmjzk+gNZif3QvD99lypW261oQCkdPe1n4GHH5VOPNjy9G+xxsOap+vsVISMQHicn7EtDerZAxbY5mnWhOKYFYhagHIHbhIuO643vGrBMeC/SuBWVeQehuTjdQQjrw08e+jnO8aKyA6N0az2FZBtiZSmycUY9obA2U6YZbNjA6ZVmznu+F6/234oHh4HBffFpyfCAVbyrS3LQfrsaakFoFU6cqsxOBJZDJa8T4M392ALv9ajC69i3BU7/DoQIPHj5JqN/ZVN2LRjkp8vHQf3v5rNy47qqe2glMcOFQveet0wtcRjrC0N6VEL21SKBM8oMxP0i8vKVAqHLGRORpYyLKZkWM3o6rRh183HBSdH1Y1SWR+2pLaW6SGmfE4P/Q8RotceY3jSB50dlciOw0g209YjWHdcnBwkwdrSmpwRLeu4kusgsw1rQMSmZ94BA+0wDI0oYBkNClS8zTRXZCmtmrkvef1BPqfKt+X0w24dz+w5hM8upxjMyHQ6A2gMIthrTgunMVSS6ljnTu1tDeq9mYwan83UZkfxWd0NC3q6xcmjg6ZVgRdirl++CXA+lnEuPDUtnnnh84dnXJs2HqoIUxgJVEICN+52UDV3mjaWyvYEmoCBWwEnWYbREt7++k/RCVOuWbZcrWdn8YKErVXs7vCGNQ4mB9fuOCBlPaWouuDwrF0cMTIj6WsokuuDWccFnsfpJjA88Dyd4HZ95LvPr83qd/S6sHTXCjvkaod0rbBJAV+2fuLOj/BGNPeGGQr+iBl2UzoUSCJ33SMgXFjkf7V9BE8R6Xzs3hHFc55bTF2VcYg7dhaOPUJon3eWA58e72Ua65Als2MwV2yMXFoZzx41hB0zbWj0unFZ8v2qR4fLw7UShNsyk4+KQC2hgXrvwL2KKJyKhMAJ9b8pKf3o1zw3f5w58dqMuCRSaSfylamdxZbONwma34iyX7GUnwsnkdQ69KqW+l9PPZbiSTsvo4nAQBGdieCLGtKaqWoGwvhXrQJDZsjSsjG6vywDFUk1ksVHFAsFKuykWsWWk4RxwEjL8UWg5zpVusUH/ZdfH5J+DEs6vYrHpdKaXOcQf27KT5S/TtnoXREtH7bKAgKbEOWzYQgu4SPuQY49w2pGWXldu0mg20E1GguyCS/SbLWKjrn0UCgSUx7a+E5fPdCSZiDBWckrTIOmwwMPY/si0Xw4POLibPMwpYdfo93plF1ntTqqUHp/MSV9hZe8yOlvaVosFrhWNpB5j+te5Ct1Zs2tmdixay8TuCba4kiZMgPDDwTuG5+8hwfNbCsnxbzQ5khNj0uRiibwGbZTOjZQeqN2f6cnwieY1oa7WY7aSZmshN1pCUvR3+J0YDpE4gh9OaCnQn53AcZ5kfpROqQIKagGDmpIZwIXkrnYSQbac1Pero+JO2tD1eK58xvohOqZEXHNOplNhowonsuAGBPZSNCwsQvY36o2ltbur/Y6JcScRgDolMRwUB+oev/cIb3cVR1IA7EiOJcAMAv6w+K7IAMQkSY1gVGNCqUfX40r5ORVFZjTCKhaLBU66PVO0RF1pqFsuA9TO4aiCu6CIAYD+znWv6OtK1Me8vpThTerpwdvb7GZAWOmk62bTlNNkxo2mmm0vmh9WDUkfzoHODpnk16j3QBXZvyhaLDZBnKUtqbnPlpcanrTyar7+cMRPX2/HdFo9Pn92Px9vA0tf0ZQ8L2yWA0hxulF38h9RLSSn1TNrSMkfnxBoKiE6kueJCi64Po/JB7wSE4P26N6/1j0yFx+7xR0fsAxYyKrcA7JxAnljMShdELPw7vGZZouJjAirJ+0WCWGlezATKeJ/fPQUE4I465OcMSnvbmsJjw6iUj8dzk4cjPiHHNEpD+aW8xMD/5GRZUN0oLM2cyo8Oke/DfMwbBao2uzNHiKBoInP4M8MPNwJ+PkgaC3Q6P+JLzR3fFq39ux4E6D2atKMFlR/ds1iWw6QO686MNOmmbDCpxBEsm0JdE5XFwHTGoLBmM2lt6uj/+AI9fLPfCygWQjUa4/aeLz7HOYAchGhsI8aj3+JHrOwTOS5gRs9Eg9flRGKxWqxVffvmluJ1W2KAiD0ux5lPghP/Tfp4FZR8yCzUPqecd2Mj3gklgcoZ1y4GBI+mUM5fsASuW7DHnwiY0/aRF28FIeZexMj9ehumizk+kuoC8nlKKWW53ab8WwxPF+VHOTapzlTLtLRY4y4F8oev6nkXSfoNRzvBc/Vtcnewx8QngxAdIGp3FEf14FdAUrCybWd7nhxqslPmhYGqx0npsqYAyfflJZn4CTJ0VwDY5bWHnRyvAYAi/D6oaXNhTWY9xCiuvlOuMbv+dDzymmFs6jwCOng6e51Hh5iHrHGQwkl5CzoNkbFDwPPDTv4G8XuH3XYxS12zaM2vgpj7zI1y3LRvw1IlpbzWN4b8Rz/OY8c9+dJh0DyYO6YT87MjzWsxY/xXwwy2kqXFmJ2DyB0CPoxNz7migvdkA0p+MZQTZeZJ1irf9Cjz/K3Nc7C6Isj6KBvFoSn28aAPMT/San7OHd8HMq47AEYLiGmcwImPgMTj73PNhMqWo/zfyMmDIeSS68NWVUaVLrSYj/jWepIDMWLKn2W/PRlBbPC3p4Abg++lyoyNFQQ1Ik1IK3JoDnPywXJlKiPwb0rzPDxd0wcqRe2Igt08WfaeGmZHjYDUZkW0j46vm4B7gxaF4YOskACSqR5mfA3UeHPP0n/hxLentYjKZMHnyZEyePDl1x6caAl5SiK8FujgEA4CzQvs4gETzAFGkQA1+Re+RDKsJQ7uSaN+y3fIobKNNklWOqVg75pofJvpH0xtoPx81FPSTtjOYaKFWlDJKahg1dun4U097iy8iCECq8fE6gdJV0n7OIF+wm+JYmW1NdnwAac7Jsprkam/0upQphAzjmLZjSwM0cFKQkVzmRwpy0Sanwhhq6cJNLWORM4ZtBwMBGBHuDJb5HWRMDDlP/sQJ/wWGTcHXq0rx4T+KPlsGkyTN7mSCG6WrSIP2uQ+GN9aNkQmmtobNbJClgsWkStmaoMyPMHc5QLJlKp2+MDGj5XtqsO6AE3lDj8ML99zQ/LEX8AI/30GyTfyNQM9jgRsWtpzjA0hiNQYzYFf0wOQ4qd450poYh+BBopH+zk8Mam+ZVhOO71+IS4/uIXvemkBZ6ISD40hfj9weJJfyx1ujWsvjB5BYTVmtJ+JxscDlbUXm56f/AKs/Br5SppGlHmS54EWDyc7hlwD37iNSu+yiJESKRMGDdFQ8cFXjsvr3ZLtYml90BoW0kA6ZxDj07yV9XCw8WRAtJoNM2Wd/jRt3zFqLTQfqk3ftycaOPwCvenNJAKTuK+gHPj4PeK6vLBUyDHUl5H9eL+3TheRd5wHg/04fBADYeKBe5ji47FJxrVHsTh/h/tNiYpRgJaypsXNIRQaaIkcSYpAFBsw2dYcrCvNDnR0qcqCe9tYEB4VGdUuWylWdDEY526WVrpdE0Dkny2aSq71pMT/xpiOmETyCs5NjTy7zQ+c1qcmpIHjQ0qyEpvPDhR0TCgZg4uTX18hb8Zb7RJTVucFPepWwPRRCTeCLc7fJGUVAYn4A0qSYIsCILyhV42JMe6NjWKmSZhUYbU+qMz9W6vwIggfBUJjk+tt/7QQAnD+qm1yQpSmoLSH9wmg67rG3A5d/L/0+LYXB5wAXfgLcuhao2Bb+fLQaSCAieZFspLD1HyMi0GaUsaDqZzQKzYeCCO5cgoW//YhAIIWLrW05pP7HYAI2fQesmhnxcJov6/YHI6e0xAAnQ0Ur8+qTilAI2L9MuIiDjDpIQJv9+udt4I9HyHb5ZuDg+qRfJgX9no0GTjIyWFlJgwE0J5gaUZLgQQtdZCLx5eU40/uz+LAbVwmvW4r4Sd8HmVoKM8jYq/NJ45RDCGajxPxQeAMh3PjJSlQ73Zg1axZmzZqV2uNTiQ1fk/9HTQfOfoWMXSW8DcDuBWT75zu0AxpU0SmC8U97KpmZaGmvQnJ8WZ0b/it/F/e7HVJqQEz1CmxKWqygzE+kXiDZGs4PoO5wmbUZEp7nUecmBlanHJLSp5pvH8sirASN6iplhTmDfB6Kt54oAaBjLFPJ/NBrUUZhGecnEAik59hSQSAYEr+LbDuZS5LH/CgED4T5TbW2TsDr83fgqg+WJ9Yh0+qLInN+yDF8UM78zM+ZhHG+V7DZV4ijn/wTs9ZWA2e+IL2uQ38AJIDgV1ZEcEam5ueQfD+FRwj80CBGzGlv4WIHgCRtnLKtEETmh8xbdk4q7K9wStvbDzVg7uZygA+ia82a5o297XOBt44FSlcShveSL0kabbR+OcmAwQAMOpMEtPpMkPZbhH5mJg0BArY+KCM+h61TnKIGkZD+vHcEz7HSSSZ9Soln2cjiwAf82P/VE7joK8DpdKY2/d9tNLm55zwA/Ho3URUqGqR6KBtJd3oDRB3D6yTd03sdF9dCzaa6tSjzQyPeFM5ywnptE/JEb9ssz7EP+oFf7yTbvY4DPiRpVfi/g4lt6KUBWedvv8C4mRUD1GAiUTBhskzrmh+Fmp2B42Gt3QmApDMFmbQ3bPsNHx+ainuNV6ExNEZ8TQY8sBgNcCgKGG1mA/ZUuXDn5yvx/rVTAKTB+KTwNQJbfyHbQ88n41bZTwaQF3/uXUQcod7jw4+jUVTlvcRALWJamGmFzWyAxx9CWTAH1IXx2iRHQzTcIqW95fXQfk4LQWHBp01ex99LOsLbckizO0A+dvN6yl+vdHTG3iwED9Th9kuF0pRhVE3li2QY3LOPFAr/fLt8PzVslKm3nLHVFdToZ84MY36E+V2ZQsikvXm9XkyZkmZjSwOso5MtrO3Jq/mR13bG0uT0mdmEFf12dSkuPqIJwQQ1xGLkCseEQkGYBOfnIf/lsA+aDoenFLV1ZJ266+t1mPLk6cCZ/wM6DgUyi1Dr8qHG5YffqGR+TECm0EiVZX7Y66FBAUsG4PbFzfxkKIJhmbYUb4VA5wiheTFlfgCgosGLvkWEeX9nIZkPJ/TNw83XEPsk7rEXCgILngYWPAOAJ4zdlA+bNk8nAyc9RK6l2xgpVVtr7ep7ErDuc7KttvZFwINnDcZzv2/F9QnoZ9kGmB9tg75MGOQ0Kji0azaO6p2PbvmJ8x5bBEffDPQ5kaTNzLpSXecfhCa2CJOymP7x3Q0kzeav5+J6S2dr1fx4FGlDz/eXHB8gPKWmoUzapo4PQDrFtwC6e7fiKuOvsPlrpBQApRFHFwjR+UnTvkkaTIG9bqe4HWCZsE+nwAw/njO/BRdzC2XAA7ORg9lokMlXvnTRSJiNHOYwqjhpg22zicOS1xPoOorsU4t8KfsAfTgJWKeQmnXXSI6USduBbxBESbJsDKvGcSjOI/ffHqe0P0SjcZDqFoKRmJ/OI4COcaqRBXyk0SEVNBh5KXDxp4xMLoAsprdFgWIBYx2da/4ATn404ttR1sdo4JAr3Ee+ePuu2HKAgWeF7w8FCEt3YLXiGo1Nbk6aKAQZwYMgz9b80Oauivknjn4r6QTW+aHzSPLU3pSCB5xsvxL1TLPVneURen/Fg/VfxeZ402yYUAAGocFxAEYUZVkxsofECtrNRsIYHX6VKDm/Q7jWMObHYASyBOenamd4vxZAujY618SobkmdG2XaG53X6pPUuLbZoOmwtOaH84ITvm/abLe83oPvVpP6qauP6dm092msBD4+nzg/4MnvddVvqeP4AGROPPZ2EoCm6Xcsy8/i1MeBsbcA570Tdx+y0w7rjD9uH48pY4qbecFtwfmJwGYcrCPGKHV+rCYjPr/uaMz5z/gWuLAEwmAAzn2LRF4qNpMmVhqg0RLReaHFZotfjOstWbbHH+QT28yN50l0WM34UhZNKtGoKBSvK1U/LqDuICYUDQfxXM2teMD8EU744Wipz4HS6BUXI0XNT7oxP/X7VXdnNkhdJkOKmh8AcPMWeL1SVOxZ81s4/cfRwK4FsmyNkwd1xP1nDk7wRbcQNnxD/g89X0pBUXN+fCqG0DfXyB+v+UzajsD80AWWMtoU3fOJ8bu3VvrO/RmS4IFJbNAY4f6zOIB/LSILmhKZnYDz3wvfH/QC85+SHlNHhy3uz+sJdBpG/gr6yl/PMctRt8OjSkdT5yfHbhYLpSOKOCgxXUivVVtDQkFg3z9hXdzBGYET7id9NC79Ovb3SiDYmh+Z1DX9HMrMgDZa80ObK5uNnJja7guEklJLKQoeGOVqb1pjqLRGWn9URTiagrBWChrgpGCbSTDG+3fKwaQRXfH85OF45vxhAFREegBUCUpl6mlvgvNTvlGyJ4LSHCNjfoA4nB+a9qaQMrZKtoxSQCAlINb8SOm6dpDvjwZhZizZA18whMN75GFk9yYETUqWAW8eC+yaR4Ia575NmLoI60LKgK1XtTOfPaMDcMqjwLApLX9NDNLf+dFgfjz+IGpcZPB1zk5++lPSkVlIHCBwwMoZwEZ1SV06gTQoO10HPPJC3ShQTthhqW9VO6U0r3ix6kPg5ZHAHw/L99fskfoYCPnHYVA6P8rHFBrsWEKx/Xf1/cp0O5H5Id9h2qS97V8BfHAm8OUVJIXrRXUmoE/FXOCl4cCqD+XMj4BqZMHnkwyw44zrYQq6gYXPY2AnIWXAYoTBwOGyo3rgdKbzdSWTO52y8NRJ98LQ86X9BgMRLGFBWZFIYCP1GswPz/PiGGWZHwAoFpyf+7/bgHcyb8CswHGo6XqC+Dytx4rJUThMZYE68QF1eefq3fKeOPS+7zKKiA7Y88jrrpsPXLcgPIWHi285okXF2TYTLKJDpxGkmfi0/HGPcUDhALKtJrQQ8gN7/iLbrEKdwUAi4Bd9IsnYtzAo81OQYVFXe+s/kTho4gtSNHLeTNCaN6vJKMoiA01g/2KAJC5C7lFTlPttP+P8NCTK+YkVwn3A8SH04khmxOXj+iI/wwKb2YgJA0lk3ukLhDmKtCWIn2UUwZH7nh0Hcx8i/9l7y1NL/tNofrxpb2HMj1CmwKdouw0x7U1iL2jqm9cfgtMbwMdL9wIArjuud3zn5nlg6RtE2KDhAPnur/kDGH5hQi69RcCqef5rCekVdU0EJdAWRto7P9d/+A+enr0lbH95PbkJrSaDWAyZ9ugzATjmP2T7h1uBmr3hh5hqkAMn8pc+BWz6Qf7k7r9ifitlqptM9GDPYuCVUcDjHZvmZPwuLMwsG7X5R2JA+wQHLaOQGFlKNCq6S9PO60oolWeSgZ/+o75fGfFnInGAlPaWUoIHfg+wdbY8LeuPR0iNz6bviJQpg08DE/BdPmEsOnj2EKP+h5vlNT8MfD4VJ8Zkxf1nDsakEV3w+lSSKsZxHB6eJDXhu/urdc0W70g6tvxMouuFAyXFP4rr5pMJvxtJK8E312qfJxQCZt9H+gFRaBTru3xB8f5ROj8jheayBg74znIm7gzcAJNZOoam7ERMe6MoGkiaJ7JiBEazuhDBP29J2+MZdrrTUOD2LcBNK0lgwGDUqOWJLx2U1nfYLSaR+fFrfaajbgCy2caCzHupfcehgFTvw+alc8bwY1sYbJ8fXtbfRQgEchxw3B1SMXFbdX4C1PkxyJRbk1H3E1C0NIgmF7+/Rlp/nMpAZFOhVUCuhHBPdEQ1+huEzIgeY8Wn6XzB80CjYp2vVmN+qFOdUUBqjinWfi6JnADNZn6UaW82s0EMooUFc1MB1PkxmOHmyG9j50hA2BcM4fNl+9DgCaB3YQZOGtQx9vN66oFZ04DZ95D3GHIucN08oGOaZUVwHHDTCuK0ZXcGBkwktbApgrR3fn4rz8Eb83eG0aLVLjKIO2Raw5ojpTUm3EcMKW8docHZCebQRrzTcAPW2q5Dr81vAl9eBtkiT1PEXNXAnAeBSu1u9MoiQ9kkufpjaXvlB/F/BmWuP0DEHFhYMkhe6AUzgAFnAAOERpphzo/iMUUymJ9gAIt/+xKzV24ljRxDGhNyWM2PlIONhkPiL5JSVP6c+4HPLgS+uY48bjgoqZIBhK1jcF/gWmwrmAAlRoSI0hfL/HDg4ferpN4EPBjSJQcvXTRSlGkH5Ivgkp1VeOmP7U35RC0HqvLGprxROPLJhB9LmsLOP4ClrwEVTDBHw+ChxoDRwImqSBSnDCYpbiFeypc3M84G/W0iKVXJcNZLZAGjyOyorkLHpogpr9uRT4ynSIhznvYxxm9MvYvAPHfKI9K2mmKotwE4sIZsy5yf1l8yA0wjYYuZYa2U4j+i6lZ6p72FQoTlPFjnwY7yBqzeV4M1JbVigI7+/rQvTDIM5YCY9kYFD+JgfhJVsxKl55UIwfmxc+R357M6y9Zcm1mqDVZ+V+rODzO/jGFSdL+9Xn5vUeaHXqfW+qiA06fO/HAcJzpqTm8KOvA07c1gghdkvss3k8/S6A3g/UW7AQDXHtsbBpUUQ1Uc2gi8M4EEHA1m4LRniA1kzYr60pREh34khTkFkdaUyG7bEMBNbqqKBi+KBBm8/TUunPPaYgBAXkbrNVFKCoxm4Px3SR7o/uXAvMeJ0gYA/PkYzLxyoWMW/BoyGPHFpcDexcDeJcA1c1TfRtkvw8U6QwUMhassCI4FucXAAaFxYChEosAd+gH1TP2OJYN81qHnkb9VH5EicNYgB+TdplloOT9l68j/zsPivuy6xe9i3N93Y3moPzzTP4eqWdpxaHhTRWpc/fMGsPpjjC2+As/j1KY1OeV5IvKQ1Tk2Y7F6F2mYuXcxcWCuWyB1rmexTEhX2irIWK/9XPOU34eOAQCEMsNTnz4wPIK++BjKFlp+NeYnxrTJV/7cjlHdc2UOUkrAWU7G4M555LGyaSCLWKK2dSo1VRrqTtSgyrSawoI7NGIaDPGobSTHsTVY1FGIi1FjDevOw9Vr8yqZXg+xRqlliM/5oZF/i8kQ1RgFIJcV78pEINXG0YHVxJnL7CRXpWsNSVkFAkzDTYvFDNBhpHTiaA1QKzM//mAIWw82wOMPosEbgNMTgFP4Lz32w+kNoIF5TvzvC6jOlWcMI+mxVjNtZWGGx+9NSoG8UvAgmtQ1dSKABNb8xCrZrmAnOdqclEGmzYTqRl8E50clnVLtGljnh9YzUucn7pqfcHM002pCrcuf4syPEW7OilweKDAHAB/w1cr9OFDnQYdMK84dqVH4r8Taz4Ef/03qlbO7ApNnAsVjor5MR9OQ1s5PY0i6/P21btH5+XyZJJeslitqsVgwY8YMcTvtkNcDOPtlYNYVwKIXicKGJVNSiNICdS72EsdQ7KfD4JnZW7C7slGcbCxGA3zBEBrYyAs7qeXEqLrhbSDG9+Bz5FKsnloSFVYu3MooF80frS8lDbUKhZogrZqfH24h0a7z35NUaoJ+opEPAMffQyK6cXREDq4jEf4xhm3YV+8UZYRFmDNIszElqMG0gdRpjS6ZCeDUptX8LPofqZU6+RHivFbvAi76lDiPSvA8qa1i8fII4IZFQCdF/Y7RIhWv/vMWYSEAUph+UHAYC/qCv/Qb3PnMGgCAIzMLVXwWCjiplow21TMy+d5duGpcX/F4+PXtX0aiZwqDkh2fWzJ64fOVZfjPF2vw0y3HomtuK9XvuaqBsjWko/mB1eSPddY7Dwc69NV8uWpdiRJzVNI8NdCgUe8DkIhpptWEOrdfPI5thEoNuLhETPJ6kbGb3VVoohnl3m1Kb504WRVa8M4yPxFFHOLB/hXkf5cR8rkphdLeTAYDWb9E50cR6KP3HDMWW2Ptm/7JKvyeAAVHo4EwAcEgjwZvAOv3E2VQmvKWbTejvMEb1mAyEfArhFzMwntqNTll08QTlvYWa6sK5VrKKizSXYLzs+VgPWatKMFJgzviqN4F6oIH7D2vDGrUKlpTAEzamw/eAOk5qOzpxkJSewsfW6Tux52izo/E/LiFUGiBxQc0AlsOkjXxynE9xXo0zbHn95AUt5VCX7g+JwDnvRudKdfRLKS18+PhpRvoQK0bo7oTGce/tksGMSulS2E2mzFt2rSkX19SMeQcYPdVwIr3gW+uj60pYX2Z/LGiyaDTG8Dr83fK9nXKsWFftUs++bB1IcEYC9K/vQHY8hNhXlhmZN9SIpGpTF9TOj+sWkjJUuL8bPwW2Kyoa6JoOED+tv5MpCEBueDDgqfI3xHXEeYsSid5ACgzd0M+iMNYWV0d7vxc+JG8yI+CGvd+ebS8SaUsVCSCNZR/vx+4RIWpqdJIa/zpP8A1c+X7WOfn17uk/QPPJE6j2QZM/RpBWx58/AYAZAGt4rNlzg8AmBGAKRTjfbFrXljhODs+Pf4gNh50YX1pHaZ/sgpfXn80LEpaKdHwNgBla+WODmVNZeBI0XyXkcBRN0Y+ZzRnoGQ54FWRZ9dwmiSZa3WDKMtmEtXQAHkjVOr8xKWMxnHAFKbJsjnKeGmK82PPjetwqebDGLUAHQBwwfvAJxcApzwW/eSlAjPdebhc2joFmJ8gY4ibTMzvr7w2kfmRovPJXPtCIR4H6twyEU8ePJbsJCqYBg4Y3CUbmVYTMq1mZNlMZFv4Lz4W9mVZzbLnrCYDOI7DzCV78OAPG3Gonnh9ovOTRGlkyvzQcWSmY0ijxswTkJyfY91/Ai/fQYJUGj36YoJWAKXHOPljpfOj7PsEKbX4v99uQIM3gC+Wl2D9w6eiupHM2wFeI+1NOa7XfBJ+PYIqHO+qwmn/+wvuQAgL7pygOW9T5kfNQWIV31IODPPj4sn3kmeWrtNhMeLSIyXBG9WxV7MH+PJyst6AA46/Gzj+rpSYZ9o60tr58TKXz0pLsvm2T5wbZ6+KdMKpTxDnoXwTKfw3WgBw2g5Jg8L5UURaN5QqeuyAdNQNc358jLEbiNHI3fIT+b/uc3l60OcXqx+vdEYcTBQk4AXeO4U0b40GHyN8EFBJs1r2NlHqmvQ60HNc+PMM6gPShDTq13MAADXIQh6E70NNxhhQrylAE9XesrvKGQcAcCkcx10LiMGm1euobC1R5rLlSIadVlQxuwtw499ialCAKSbOtpnhRDgTM896G8zOGGWAD26IqJplMxvx+tRROOPlhVhTUosnftmMh84eonl83PC7gYPriYNDnZ3KbVBlNvJ7E0eny0iiYNZ5WOy52NHSwJTNfSnYHjkMRJlrlVQRILx42MTU/Iiy0M0RklCmdirRlNqYs14GvpgKHHtHTIeLNT9mg1jDoNV3BQBhee/ZF5th4RXmws4jSN+K894lAYAUMEr8TAqWgU1HVI7hFkx743ket325Bt+tOaD6vNnIYdMjE2VOeFOR65D39LGahLQ3IdBZ70785/UzqYaA5AT5NAIIrOjC04ZXgWoA399EVAINZnlUn+eB2n0kgBkplVmNdbz2T6Czgt0Pc4LDxypljCkzTP9XC43hzVbGyWHXL6PC+akNF12iWQictx41dQdRg2wcqHWjZwf1gAmtJ1bOWbLrTMVeP6LzY4IL5HvpYJHspAvHFCPHEYGt2/orqZvy1JHg7vnvtJqCZHtEWjs/Hl66sWhDU18gJOatrrr/ZORnhA/8QCCA3377DQBw6qmnpm+Xa7OdFMO9PZ7kiR5+NWE6avfJjzvqRmDp6+HsisJAqXJKEcJjDevQCDs6ZB2LItSgeNsHwJBbiArJTqb4mTo/2+cQdaQT7g8vvAWICABVYNv4TfTPpmx+xaYUrZhBeg3EArbfj7IOqPtY8l3V7AE+OAM48gaiMMf2JaEIhXB0xayw3T6YsCHUE0NMpeB6Hqt+DSqLFodQ02p+Og4Jd37Y85euBD48m2wPOVf9HEEfSX/LKAJuXSPUV2kYsxkdZAsyKyObZTOhgQ//rrpxlfCveD2GDwOiInf0TbJ7Rjk+i/MdeGHKCFzz4Qp8sGQPRvfIw1nDVaSWoyHgI4GCA4KTU7qaPFb2cgGIMliXEaRhaZdRZNueF35crIiW9hZirmH4xaTO5IjrNI0hp0qDUxbZCkaI9kEBJMGDiI5Cc9GUm7uwP3DT8pgPZ9PeTLGKOMTrvFDnc9jk+F6XRASZtDevJVd6IqzmJ1zwIFlr36yV+0XHx2EJ/46nHF6cEMcHCM/moE4PZUHrk5AiJbFtcqlrrTHk9qvsdx4CXjuSjPWbV5J07ICXKEBu+h4443m5oEDYRagIV1izw5UTlfe4CgubaQ03yr2BoCgUlZ+VCRrTi8j8qKHbGCCrC9BwAN25ctTw2aiN4JBShlptLssUnZ8UZH54Ke2tUWB+Cm3SPH71MfLaWnHsBYM41boCpr9fIk90PZyw6jndoKPlkKZWP4GbSXujCyHtC2I2csjT8Lq9Xi/OPPNMAIDT6Uxf5wcgUrRTPiTpX+PvEep5FM4PpdoDbmIAUiiMcl+QfIeFqMFHFtKs8F7rAiyzTQe2AnhlZri0dMBLlME+uYA87nQYcNgF8mOCgdgZIgo1ZZuRlwGrP4ro+KxHP/QeNBIZm78kO1iHR8n89DsJGHMt8Pv/kXqkf94gLNCUD4k8LwuqZKNAkDfiHN8j+POGMeiu1fldhfmxwt805kdNQadkKfDFZcTY2bNQ2q/sBWXNIawg/R4ay0lqXOfh2sa5QrqZTZXKtptRqcL8AIB5wxdRP4qIlTOAIyQJaLXxedLgjvjX+D54Y/5O3PP1OgzqnI2+RRHUj0JBIvRwYLXk7BzcoM6KZhQKDs5IwdkZKXWpThSUzM/Ur4FPmJ5A7O/aezww/KKIp/tmNXGAtZyfbnl2LNsjPWaPE7vTJ1VCPPlKhlKfF0PUGowmIaNQvZ9RK4OOQaORw57sMUAp4DM6YFE656LzIxmeyVj7dlU48dAPZE6+a+IA3Dg+Qu1bApDrkM9V+YKokUOorUiO1LVc8MAi1pip329etWtg2d1N3wMjLgY+nyqJ+Kz/OrLzo7aGqmUVKINtKnN7tsq8caDWA48wpjrkOBjnhxU80GCwB50FXPgxsS9MFhK8bCDrHAAxnU4Jnuext4oERWl/MhaZKZ32Rp0fI3F+OGB0ZyuKq+04e3gXdMuTfx7Z2Ls3CyYLRwKuJz8anUnXkXCksdUPuEOSc+MLkAWhvIEMssK2JnEdCf1PIX8Aoc5pgTpFv1OlbTZFSsH8+IXvsIiT0t96gmEZ1HrqrPtcbnBv/TXc+WkoU4+uR4Ka8xNDTYA3xOGPgQ/j7PwupI8QqygWpi7GAbZs4OxXgMGTiEhC9U4iKnCBvIN90OuEWsw4AAMCMMHoiMAKqESb7fA2jfkJqET/AO3aJ9mb5hCVLtYJpKlxamlv/U4l4hoM6GJvNHDItplxAAlQU/zlDnKPqPV1YnD7yf2xel8Nlu6qxo2frMR308eRPPFQiNTkiDU6q0hqn1qvJ1suk7omODvZXeOWWY4bysVNmdbJMpQaaZIUwRCPNSW1AICCTPVIbO9C+flZ50dscppM56cFZNwpC2k1GUUp74R+ps7Dk39fNAFiw00DB4PFgSM9r+K6Y3rgamVzZTpfViZPKt4XCOHWz9fA5Qvi6N4FuP44lTYGCUaHTPlYyhOcISp1nQznR0x7EwIHpigCG2IPKrMG07hjDrD2UzJf0ayIkn9IrxytdY4GbroeDpQKghxqATfl/KHC1qgFTXaUk7Rti8mA7Exm/mDtBC3m54z/Cc9bZK8xcDzAA7sqGnHCwPCXTf90FRo8AXAc0F3F+aEsX60rBdLeGg6SbAnKtNGAFWeEM2QFjECe2YeFd52g/vp9S6VtSwZwwavyptg6WhRp7fw4Q+FdncuFIsjCrCYU3LYFMDLGC0xjcfwNLxN63ZxBCu7ZInjFwh7wNeJR0/uogeR4DHH+Hf092TSsLT+RSCNrTGsV3keCmgAB22hRA3v5IgR8AanXzo45wOd7gWEXhi8ULKvR9yTSQ+n76aqF53V1tVDjdQJCJ2xTJB1/pVECwA5f05gfugAeNgUYOZWkMn59dWyvteUS1TIW+5cRZyinK3H8AOD2rYCKPCogOT9mI4dsuwl+PvIUEup6OC7YdSa+sT4U+doWPh/V+TEZDXj5ohG4+uVv0bViGf5+63OckF0K7sAaqUaDhTmDpKuxjk5er9QwaM02YNDZktPK1mfZciO+dHNZvVjvcsuJKip/gCzqaDEZxLoIgGF+kpn21gJgm1zGJHgQLzqPSNy5EoRQiBeFUowGDlaTEYeQj0qTClPZ9yTSPHrPQgB3hz+fADw/ZyvWl9Yh12HGCxcOl/X3ShY6Zttg4CTBmLwM6vwkkfmh855BkfamJXggMCg9O2QANSoHbP+d/LfnA5d+RQSBKrcBu+YTMSPVixACX+e9DbiqiPGtImYQS81P17zwNYk6P/kOC6xWZm3Skro+/Tlg7sPA6c8AmXLxJOr8cAIDvF6lnviL5fvwy/qDAIAxPfPF349FpxzCNJXVJaFvH4tQkKyDWsJHO+cBH50DdDwMOPdNEszdNpu8lEl7MwVUrpPngSWvAL8wjcKn/Qr0HJHYz6AjLqS189MQMImfgKY7UHo0W0XlrV0gV4rU38vfhCVUAjm3O1CxGVj/lXQsz5OUNIMR4DgM2DkTo01yFbC+tYvie/+AB6jZK6/RYZuixgq1SUiLcu88gsgQA7jDfwMe8AUlh6NyG/krXQmc/SrZZ7QCZ74A9D9Vfh7qMKn0CGrQcn6EPsERF/1uY8LEGexcU5kfwfkZdqHUfLHkHyLcEA2O/HBW8I9H5I8nf6Dp+ABSpNNsMCDbbkYDk/bGm2zgAh5c7rsbH/77XGDf3+D6T8S6p9ZEvzYAcFaEL6INh4D9W0VBgqIDq/FjoBKwAKgS/gDym3Y6TEpb6zKKFN6mQIE6gHCn05xBGEfR+WGMgz4akUMBmw4QR2lsnwJVNUtAKgoHwlNcTC3B/AyelLxzC6CpRXKp6yY6P8feThxwFhpiE60J9jczGQ2wCmyHV63GhK4FWo2gm4lF2yvx1oJdAICnzhuGzjktI0NvNhrQMdsm1vnS9Har6Pwk3qlXSl2LaW8B9THkFu7NXh0c6s4PQIIcV/1Gat36nkzWqR1zIjg/AmNvtADFR2hfrFbtF4PeHcIzK7aXkzy3/AwLWL0D2RzKskBDziN1xsqaI+Y4A8hvsX5/HdaW1IoBP28ghLu/Xg+ABKq/uO4o1Y9C76mDdbH1hIsZwYC8NnnOA6TFwxHXEobnrJdIVghA7KSPziHbh9YDb8qFkQJGO+qF2ldTg6LkwF1LAqpbfpKz4YXqQSsdLYe0dn68TMoNZX7c0ejmto7+ExGc/ww+rB+J6iAzKfU/lTg/bPf4un3Ac31Jvu7ZryCrMVzOt1NtE5qYfn0VcPUc0rQxuwuw4avor1FCLe1NyaDctoWIE8y+DyhbgyDPgYeB9HYaeiow/0kp9amhTEot6jICGHmpyvmp86NIl5r/FIr/ek71MoNCMpw1kvxy11Fhu2xNrfmh+ftsGtWA04jkuSWDFMvbcgjD8d0N8tcOPodEFiMhiiqZGAE1GZBpMeG94Ok417gI2V36ofriX3HkE38QFqxoEFA0CByADOuG2EpA9i4i7N5OJj3g5RGAReFYGkyocPTFnNou2IQ+uOKCc9HvsCNi74PRGnArLKC8HvIoKm0WfNgUdWOCwbZDxEgZ0ElbaS6PqYsIU35LBkvCotOwcMGSJECtyWlc8t0sxt8HFB8JLH8P2E4EAVLT+ZF+M5OBE+cdb0CF7aCtDJRqkAlAldOL275cAwC45MjumDhUO2CSDLDOT24LpL2JTU6p4IEosKHF/JBrGNw5G9DKOizoI/Wr63cSsPQ1YMcfxEhWstNep8T6R0v/jkHwoFdheHBxq9CbpijbCis757I1RA6mlYM9V3uuEq7fIEz8uyobMUloPK/Ex1cfqVmi0Flgfg4k0vmZ+xBxdC77lsxVaz4B/hYCo0sFoZ6N3wBXzyXBuPdO1TwVAPgNNswPDcd/8DXMm78Dfr4DOOM50tbjy8tJSrbRAkx8GHhyeuI+h45modWcn9LSUtx999349ddf4XK50LdvX8yYMQOHH354zOdgnR+6kNPmYmqKM+0CucWou3EDHn5sLoAQAsEQmbALhFxsZRd5dw0p9t/6K/prNQyNFZwB4EOk3uLLK4Btv8o6qS8ODsE4Y4wqbWr9cljDnDMQhoLjgBPvx4aqEG7ZQZwMty9I+q/cvAqoPwC8ewKJhn0hODxaecvUuWLlsX0uYP6ToFP82lBvDDfsEp+mzA+bVhSGgvAojx2e5qW9sdG8PieQVDXOIE/tq91HfoOxt5DP1n8icYy+ulL7/FFUyXyszK6BQ6O1I473/A/fnX0S7EJ0VMmCZVpNUiPGSJg1TXgT9nvhgMJBcjGCjkNRYLTiz49WYu7mQ1jwuxc/9QdyVET6UgauKvlj5T24ax75r5IiqUSNkP/eMVvbUWWdH2UvINFgbm6EvNfxUrE2i1DijU81NIpzvYmRHm7iZzKaSIBogyDRbs+LrXdaC0PO/HDivONVE3oQnZ8q1WbCTQXP87j763Uob/Cib1Em7j9jcPQXJRgdmFo3quhqE74LTyJFLwRICnuKJqcq91sgGBJ/jykjOwF/MU8OnkTEDgAp2AaQXj1mBwnSHdoQ3oTaKTSJtWRGl9ePQfBArb6GBlUKM60wOpjn2f50Jgtw9x7yHpHuJ4H5MUL+/XTJscEgfIcmA4dbTuwXMYhDnZ9Kpxe+QKj5Pd4aDpGaXoCo05auBH67T/3Y92KTnfYb7FjLM7Vuy98hbRB+voOs1zndiZpb7gAAuvOTKkhyt0B11NTUYNy4cTCbzfj111+xadMmPP/888jLi09K1sVLiz+dbFzCgmhvr84PgAwmzYUaCGLERimTLB7YTMcHADoyCmnbfiX/S1eS/0POw1a+OPZzqXSlljk/5gwpOpbVCQv73IFdPFFmovcAsjuLPQdkalqNCkNUPKcK86MQeXDydqwJSRNdEEZwnFRHoYqCPmG7LFwg/ianwQBQJ/x+iga1yOgQXtM0/m7guvnA0PMIO8RxQK/jIr9HFClTGlmnxma23QwnHKj3A8GguvOTYTViQ6gnAODv4GA8jStJTxc15PcmDBXFHduA6UuBc98gKQndDgfMZAF9fvJwFOfbUVLtxu2z1iCUVPWyZmLC/0nbavc2hTm6B0cbKNoiGAK5GZLDo7w3xdoINbYgHkz+QNq+YIa0raZImAQ4aa8jm0lk+mnwq8kwCN9bioodBBlmy2QwMMyPisHvKCBGKh+KTRAlRny8dC/mbi6HxWjAyxeNbJW1tjBLMuhp2lsya37C+vzQ1FEVppGVdS6oWiF/UmgASk7CBDpMVmluFuqBVu+rwber95P6Phq0ZF+vhRgED1jZceo80s9YlG2FnXV+2JRcgAQGaEqYFhQ1PxSL7j5B/Jt/5wScNyqyvHN+hgUWkwE8D7GpbbPA1vMaLaTVAYuBZ4Y3jY0Cv8EKgMNDwauknT/cTByffqcC1y9Qzf7Q0bpoFebn6aefRnFxMWbMkBbMXr16RXiFOrby0sDxh6W9aX80i8WCV199Vdxua7CajLCYDPAFQnB6A6QugG0SmgwMOpsoiWlh8CT41ob3yVGFJUu9146ZcX4Uz/uYxd/tZ4wvSyYADrK8Kw3ZavGcbM2PIl/eBRvMkM4fgFHsPK4JlfolK/zx1/xU7yQTqiWTpLUxmLe1HI/8uAk3HN8bF46JELG255N6mAOr1J9XNrFTIKBgdzKErtwubxABe0j2HEWm1YQrfXfi5f7rccu2wwBbJ9zdQfH79jwWuPAjwJ4Hi9+PV+uOBABYsjTkwwHkOMx4Y+ponPfGEszdXI63F+7CDccnX22qSeh1LKnxWf4uaZiphRhS90SJ5wipvWzzU6V9ljDmh72v2TqxFnJ+GpheR9QAdzXX+aFzTJeRkY9rJdA0K44TBA/Emh+Vz200kV5R/7wBfHM9kFEES9cjmrX2bT3YgMd+3gwAuOe0gRjcJboITTLAMpstkvZGFfYEp8Fs0k4dpcpk2TYTjBVy4zpkz5cizkqWt+9JpIh++1y4j/w3LnjzbwRDPPxBHlPKhLYFuTEEEGMQPACAWTccjdX7auAP8nj2t63i/qIsG1HRpNBqlh0BIRhggFTzA5AgjCFOQQyO49A5x4a9VS6U1XlU5bDjuzBmbuKD8nX03lKSrrvha6FliICpX5P0xN0Lge5HAf+8Kaux9YfIZ/rKcCoewvvS6064HzjmNjE1sK3bnemGVmF+fvjhBxx++OGYPHkyioqKMHLkSLzzzjuax3u9XtTX18v+AGAH4/xQ49clCB5ESnszm82YPn06pk+fDrM5hesEmgGa599I9fGVheRNxcVM/5a7dgMPVAPTfiYKKBEkevlYOhdndgLu3AXcsVX9eROzWCgi5LRHEaAwgAyGcJU4ZfG5eE7h/Czz41TIe1syZApnhxu2RU5504AFfvDxej8NZeR/TnFYrvXzv2/F7spGsYhUEwYDcM0fwJkvqj+vph7EQMp9JxO+ZHQGxDQ+pfJdhtWECuThtw6XowJ5pFi4iyISxjQRjWd8Du2ag4fOGgIAePa3rVi6S4PVSwWMuhy4/i8pzx8Ajr1Dfkz9gainofUd1NhTA+uMK3tsJIz5YY0qNtUt1DKytFTcJtNqFo21Zhu+Y64FDr+KOA0pCGX6lTVaqtepj5NodtALfHYxzNXbmrz2efxB3PLZangDIYwfUIgrx/Vs8udoLvoUkpoyu9mIXLuc+Wm2U6+CMKlrg7bUdZ2bqLLlOixhjsOL85mCeCXL2+9k8r/kH+ws2S/+1psO1EvS1lqNq1nEkPYGEIW1647rEyYOVZRlRYbMfoqfUQ9Bqvn54MoxKMqy4u3LYy9pYEFTHGnz+mZBNk8FCSsKAKOnSXWK3ccSWyS3O3D7NlKPldudqKsW9CEsfqYU7HHbybbFZJRSZY+aDhx3h2ydbg92ZzqhVZyfXbt24Y033kC/fv3w22+/4V//+hduueUWzJw5U/X4J598Ejk5OeJfcTGJfgRhRBchJ5SmO1QJA4RSue0V1PkROyNnd5Uf0PPY2CZSAM/6p+DlwDkITvsVGDARmL4MuHUdSbMyGIGex5AosFI9jYHPaIcFESLCwy4Cpn4JZBRoy03KmB95QTW7CIVFf5UUvZocJSBPe6OOiaJGymjLhF9BmEYyQkVM+4UotAny2lYE4qv54Xmihgaofj+lNdJnUi1+ZmEwhDUvFaHVqFUAZX5o2gcNMrj9wTBWiILei3TxspgM5Lccz+RamzV+8xhw8RHFOG9kVwRDPG7+bDXKGxKsDJRMTFDkm6v10lKAGvi2KE53rw7kOz26t5z1TZiRyLKdbES1hWp+6NyWaTOJ92GzmZ+igcCZ/0vJ5qaAlGZFjW+q5Ffn1nA4DUbg/HeB4qOIHPzHFwC1JerHRsFTv27B1kMN6JBpwbMXDG/VPnqTRnTB25eNxvc3jRNFCOg87E6m4AGN4kdQF6TMT67DHJYydijAzHNK5ievJ9ChP8AHUb9RUl3dVeEEqveQB92Pjn6xBoPofJCLjszmK9UgC7OscFiblxRERfCsRmD8gCIs+7+TMGFA0xpHJ7TRqYz5CUlzFeswZncGbt8C/Hs9aROihD0X+M9G4N8bgH8tgdtC1kyL0UDW+alfAxOfaP616kgqWsX5CYVCGDVqFJ544gmMHDkS1113Ha699lq8+eabqsffe++9qKurE/9KSqTJ+7BuJFJd6STRTbHJaYQ+P8FgEPPnz8f8+fMRDLbMQt3SoJ+/tFYwipUTYL9TSM7+hP+Sgvmrfse3nW6VH9PrePBGC74OHosXAlPgLBojnHxAWPNLACR6cp4Kg5fVmRQrQrFAn/USiUr+62/gvLeiqyuxzE+XEbKnZGlvSgOoTrHYa6W00MWIDwGLXwJ2LQhLDzPbs+DgJOM6xHOxMT89x5H+DIJRZeH8sdf8+N3AZxcB3wjdvxUpfzzPyz5/TLKgXUYQh7igLzCCUb6L0mNG6eDQiLvLFxSvwWKUTysZwuJV4/LJn2fvScYQiHd8chyHx84div4dM1HR4MUtn61Onx42yhSV8fepH8dA7G8Txen+7sZxuPPUAbjj1AGy/dRIjOokx4IuowizykrvdggX+EgGGoSan0yrSXTo3P5gatd+NRMBBfNDg3y1rghRcbMduPgzoHAggnWlmP/gyZg/+4e41r4/txzCB0v2AACemzy81fvomYwGnDKkE/p3lIrlRcGDJNb8mMUmp9rqgtT5ybGbxfqdvXxHvB04A0tDg6QD1er7+hL2x7HvT3GXq7YS8BExAraVRSQEeWZuiJLKnG1TMj82BfMTP+gSXJDRfIYjU3DOaI1fs8ArmR/hsXIejubYG00kBbHjEJnqJHKLCVOkgvZgd6YTWsX56dy5MwYPlkeeBw0ahH379qkeb7VakZ2dLfujGNWdpMrUewLw+IOojMH58Xg8mDBhAiZMmACPJ42ixHGALgpbD2rk6x55Pfl//J1E8rH7kZifq2CCps4Cd9tm1JhIylx9tMnHYASGTSESkQNOB25aAZz4IDDtZ3gDIZghDXjeYCLFgBd9AnSMUS2IZX6Uzg9j7Db6IkSIuo4GpnyocX5mMZr7IPDh2cB+ecGqxZ6FHtwh8fFpvicjy1wrISxElmjMj98D1JcBhzYCn04RG6qR65SzJFWNPknYAlIgICJMVuDmlcANi+SOrDFyxC/ANDkFIIu4+9hFgIGS+aH58mJTVUBmPDdlfDosJrxx6WhkWIxYuqsaL8zZFtPrUgrj7wV6RI/sxsr85DjMmD6hL4qy5KpwYqpUItKDrvkDuHMHYSOvnUcY3EmvN/+8UcDzvHjPZ1pNsjTnZqfzpTDo+DMK44/Wu0RNCXLkA5d+DY+tMya8vBUTTpsET4NWAxo5yus9uGMW6Q921bheGN/ECH6yYU1UOqcKxFpi4T5j1QWV6ctU8KCPqUqc437LOg9PBKbCxzPOgJrzIxjO3Wv+Bk0387qFNdxola+BERAAMzeYImfBZNvVmZ/n/ReQHUdcH9N7svAGyf1Z4Gi+80OZKTGLpTlgWWkt5idOaK17SrQHuzOd0CrOz7hx47B1q7yuY9u2bejRI7aoBouBnbPFm66iwYuKGJyf9oA+go7/3iqmfuVwQY1k4JmqVLgvEEINL6STdRpGjsnoIErlxjz5FI8hkcYO/YBjbwMK+hDnh5NeX3HFYkIvxwNW7c0uT8+KyPxcKDRZtWSS+iQtCVujWVJ7oqiSN2mwZ2SjAJJDuZXvHjUCL4OJOj+C4EHdfnkPmP0rgP8dBjzeEXhhIPDGWGD3X/JzKJifvVVyoYmKhhhzo8128pcZuzEj5b4r0t58AXkEjAF1fmhEVGR+OlI5Vw7oMTbma9BCn8JMPHX+MADA6/N34o/Nh6K8IkVw2XdkbI69OabDPTEIHkRCQgvDDQZpLuk6ijC4OV0jvyYB8Ad5sSbCbjHK+ro1O/UthSExP+Q3pMxPgycQvW9TTjfg4k+lx9/eSBQkIyAU4nH7rLWobvRhUOds3H3agIjHtyak+zrxrC9dU+h9xiooBhVMY53Awh3v+l3cN6YDmftkKdNqjowgeZ0frMIgjgSDAx4neS5KDzb2eoJoGvOTZSXiIQ6zEW8Hz8T53gcROOXJmN6XhUfIeyvIaL4SYGLT3ljnJwLzEwdo4FWZ8aAjtdEqam//+c9/MHbsWDzxxBOYMmUKli1bhrfffhtvvx1Dl3oFuubaUJhpRWmtGyU1LjQIA4TtA9AeQZ0/GQsw8WlS59N5hOprvIEQLvL9F2/1Xoye5z8i7s+2mVDp9DZr8lGmvdXauiLu+KHM+ZHLorMLf5jxM+gs4L8VgkRS5EgUb7aD82ozXFmZDpg4+eIal+AB4/xkBOuA/51CIoD/V0YMkS+vAOqFOiPOIPQb6UHqlmiDUkXEcE+lvClrVWMMzA+L4ZcAe5eQ9McoUBZc00hoI8P8KL+PDCXzQxeJUZcTpimG940VZw3vgpV7a/DBkj34zxdr8PMtxzZfISjZ6DOB/MUI6rTExTgyoIxRIMRLfcDSDGxdh81sgMHAwWY2wOMPNV/uOoURUEgu5zDF6nVuf/R1r2igtL19NvDL7UT8RCPN5/3Fu7FweyVsZgNevmhEk8RdWgr2JEpd03M6LCZg9cewV5cAIIGWQIgH+7VQ5mfCIUnNdsTEaZh7ei/s3FcK/CTsVAbaAEnyettsnGhYhZeMr6K/QWhvECPr4wuEFM5P5DWPrY/OEZgau8UILyxYyQ+AJ8gjM05L0Svcp/kJYH4yreQc9QlhfhS1iSLz0/Q5kK575ub2INLRomiVX2vMmDH49ttv8dlnn2Ho0KF49NFH8eKLL2Lq1Klxnef/zhiIvkVZ6CAY+rsrSQSc48KL+Nob6CJY5WRYAJOFTKwaGv1ObwBb+e7YcOQzpN+KgEyRdm56zq03EJQJHjSJwmYLRBUKbizzoxr5NVmiLgJ/76xChSd8ceeZyFkW7wx7Pr60N7LQWBBAJ59Qi+R3EVW5hjLi+BhMwB3bgfurgLt2AdfNk/fnUYg9HKB1XQIqY2V+KEwWUo80/KKoh1LJV5rzTqWu3b5gBOZHqseQPW+2EcYjr2d81xsF950+CCOKc1HvCeDGT1YlprYlhUC/Z1uTmR/pdar9YdIAVNrZwEkR12Qav6kC5fgzGjixPqMx7uAUB6z8AFjwjOqzG0rr8PTsLQCA+88cjH5MfU0qIplqb2L/QJMB+H46rAufQn+OzN8+rxtY8xnQcJA8rq+ATCHtuDvBdToMfYsyUVzEqGlqsA28UPdzh3mW5PgAMTM/3kBQkfYW2SFmnR+6lrFrWlOCCW6B+cmzN98Oy7IlkPnhlcyPcK80h/mhQb80DCK1Z7Tar3XmmWdi/fr18Hg82Lx5M6699tq4z3HxESRNzi7Q3TVCZNlhNraqEk0qgDo/e6tcuOy9f/DzurKor3EJtTIZCqWXrATk3Hr9IcwPjQAA1PIZTXOkZE1O5QuBPO2tadf5+vwdKOLC8+C5oMSkWLggrvf9GxV8DuYdSTT94zJCKfPD+RFgh9+hjZJEsMlGUtFYOWtWnU2R9lbjkn+XcTM/ccCvUJuijnG9xy86GVqCBxRNZSxihcVkwGtTRyHPYcb60jo8+tOm6C9KIzSX+WFfl67OD3Wkbcxcz9ZhtFUomVdAGl9xG4dUkWr+E8QJYuDyBXDL56vhD/I4ZXBHXHJEhN5hKQI6D/uCobBUtOaA53mp5scgza02EHvDtOg54LsbgHdPAtbNwlM7z8EeGxPIHSPZNpl2pl5TjfkB0NhNo8mmUh1OA75ACLt4JqU8SuNkjuNw5bieyLAYceW4XuK+5gQTGn2U+Wm+85NQwQMZ85Ogmp+gIqinIy3QJn4tuujRmoLmyjS2BXTJtcFuNsIXDGHh9ko88cvmqK9p9JJBnGGRf380J1hTTjUG+IIhfB6cgOt9/8HJ3meaFsVhnR+F6g1r8Lj8wbh76OypbMTC7ZXw8ur3zjP+KThg6ILgmOvwW+gIjPG+gb3ZpFdNU5kfE88wND4nEBS+X7V+ScVHStsKGV6q9FQkMKC1rgQsEhpQCh7QtJt6t1+KgJkjOz/mFoiQdc21438XjgDHAR8v3YfvVpdGf1GKocrpxY5yOdMYDPGiw6L8XmOFwcCB2s5po4qnAK3rYGt9zKL8cNtVe1PW3AFsT7c4jdTR04Dj7iTbP/0H2PKL+NSjP23CropGdMq24enzh6VFMJFtOZBI9o8NEDiCDeI2J4jDmLf9THbUlQC/KPp2AYBVYswyHRILE+iu7uTUGDUSwmNmfkKYHRSUWc0ZMSnEPXjWEGx8ZCIuPUo61m6RM/ax4sW52+AWxme33NiuORKylG07moMQM98lquYnRsEDHamFNvFrUeOT5to2V6axLSDLZsZ308fh2QtIXnJprRubyyJ3aqZpExlW+ffXSeilpEyvigdefwghGPBbaAwqkNe0icxgAG7bQvT1rfLUL5b54fn4I9qfLSfFpfcHrsRa2xjZQrOn82l4PXgOHujxEez5UjE3ZVzicn4E5qcTVw1TiHF+gn7J+VFrSufIJ8psk14HRsjTQ+l937MgQ/Y4GVBKXbOOsVbhp1JKNdnMD8X4AUW4+QQiu3zvN+ux7VBDlFekFq76YDlOemEBNpRKvUJcDKsZqZFzNFDj2Z+mstAs80NB76uohf9pDDXmx2FtatobSMPGkZeS9J+vrgT2/YNf15fhs2Ul4DjghQuHIy9Neuax6oeJFL1gz2XzS2Mx10J+i4iqnZxRxthkWk2Y7H0AV/juRmNOf9WXVPmMCPIqzqY/tvXXGwhiRvA0PMtNAy78MKwhdqyggYV4097mba1ASDAtHebmO81UcCnhfX5kNT8JcH70tLe0QpugSJTMj90S+WOZzWY888wz4nZbxYBOWRjQKQsP/rARLl8QH/69B0+eN0zzeNH5UXx/3YWC8X3VrrDXxApl3UWT64c0FOKUBo/HH4w5Hc0XCOGrFURk4MvgBBzoMBkfd/gQWENU4n7seR+wuwSFWVZYTQYYDRyCIV7sWxNXEbBQP3SOcQnyPEwudtAPBAVnSKMjNzodRv4UoNfRo8CBZXuqm8XQRYPY7E8Yc5T5qXP7xVx7ZQQsV1H0mhmlHi+R4/PWE/th1d4aLNpRiRs+XokfbjpGjJSnMoIhHmv3E0Prs2X78Pi55HenhpjRwDXLibQYDfAFQvCnYdobq+ppt4QzP740/Eyxwq+o+QGk+ToW4zBsbHEccOZLQGMlsG02Qp9eiLc8DwDoiH8d3wdj+3RI/IdIEgxC/VOjL4hGbyBhiq9sraKRCVjlWkKAi/QtpOAByMx9a6ZMTMJiMmCdcTC8gRAavH5RYIBFTaMPRk7FoaqMTb7fGyCBxlmms3BnX/WeM7GAMmkuXxDTP1kFpzeA96eNCWtirURJtUtqspqAhseZiZS6ltX8hBjmpxmCBwIbG435aS92Z7og9a2AGEBvujo3mZiiMT8WiwV33nln0q8rVXDRmO54f/Fu7K/RjhyFQjxcwiSvTKfplkecn0ivV8LjD8IfDIlRG6VBkuiiVGWefzwG0G8bD6KK6ZPhD4aILKyAgy4ykRdmWcFxHGwmAxp9QdHZjkvqmpl8j/fMk/YHfQzzE/uw5HkeJYJT2q8jYcPqIjU8bCYo82NWqE3JmJ8ozo+SCVIikePTaODw0kUjcMbLi7CrohH3frMeL180IuXTeA7VS30gWKOWBigclubVNYpNGkPp5SgcrPPg2Gf+FNO/shhHmvaPatM1P0HKvKqlvUU3DlXHltEEXDAD/MyzYShdjlf5x3F/5+fxn5PVmYlURobVhEZfsMksQSAYwozFe1DZ6MUpgzthdI88kfmwmQwyYz7HTLbZprohnofM+vDUQYksmwlep0/zGrV7NsXG0sbaBDkaaGDhYL0bP68nNcM7K5yyxrJKBEM8qht94Cnjwzd/LGaKaW8Jrvnhg1IaXAv0+Wlvdmeqo03wdHrNT2ScPLgjAGDh9kpNp8ATCIKy98q0tyI12ewouP6jlRj71J8obyBGnDINLdGF1v6AfGGI5/yf/LMXADCwE5nUAyEeGHEJebL3hLDeUVTSkhobcUXgveFqcQCI8xOKkPamgX3VLlQ6fbCYDGKUNqnMT0hufEk1PwHRoVUyYXkO+efJiuL8JBoFmVa8eslImAwcflx7AB8t3dui798UsCmmrGIjZX6U7Gy8oIIV6VYfM2fTQdk1s/eSWPPThpkfUe0tEYIHLCwOvNf9SewMdUY3rhJvGZ6C2Rc5TToVkRmnMlijN4CSapf499nyEjz+y2a8tWAXbvp0FXieF7MWrGajLHiVbSb3Ic8Y+GG1pt3D+5eJfWs0mIwalw+X+O5DgDNjftfr1FPgIiBRaVg0jXDbIWnNooq6WqAOCk17S4Tzk838pvHW8oaBZaJCes1Pe0ab+LUsipofR5R0p2AwiOXLl2P58uUIBtuuLCoFNeoBYMXeatVjWCZGabwWZBLjtcrpi2nyafD4sWBbBRo8Afy5uZycX5H2lujobBjzE+P5d1Y4sXRXNQwcMFUo9gyEeCCvB3DXbmDqLFQITh91AqnhSHtKxaX25tOoO4kl7U0FB+uIc9k11y5eX53bL4tGJhJKwQObRWgsGAiKqjdKZ9BmNsr2ZUVJe0vG+Dy8Zz7uOY30OHn0p01YU1KbkPMmCw2M8UYDCADD/FibV9dIf79Amjk/lU55VDyLCXS1B8GDgErNDw3KsGyhFrTG1qp9NXhyQQWu8N8Dt7UDLFWbgc+nAv706kQfDwt2qN6DIx6fi2OfmSf+3f/dBvH5sjoPSmvdcmeCMZ6zTJT5kdYa2bTbfSxw7hvh10jTuCIwP0tCQ/Hk8DlY2eMa/Ns/nTwx4b9RPxMApuVA8+YIyvxsZ2ollQIsStAAtMGQOOeHfl8hPgG1XCFF2htlgprB/HgClBnU7c50QttwfoRFr05kfiLfhB6PB0cccQSOOOIIeDzpNbk3BXkZFgwvzgUAbD2obnxTZ8Fo4MJyekm6FzmmIgb2Zz1ToF0tpGApGadE5+Urzxdr0fNn/xChgwkDisTaJlEBy5EPGM0or1cwP4LhmFDmJ+SXuq2rqb1pgOZBZ9tMyBZYmBAPOJso9x0NktqU4PwIjh/PS9eiFgFjmy92zomsAJSs8Xn1Mb0wcUgn+IM8pn+ySpTGT0WwRcblDdKYo4t/c8QOAOn386dZ2ltZnTz1lnWk24PgQUAx/gCgOI8U1K/eV4uVe8Ol+lmoja0Gjx+3fr4awRCPUcOGwzbtW9JHbe8i4NvrElK30VKIp/5p1d4aNPqCMHBkPNG/Ljk2UQ1xe7mTad5skDE/mYLzo8n8nPKoag+zzCjqZTTtLTszE1aTAT+GxuLRgd8Dx6koyamAMkqZzQyQ0LmdZX52RnN+hAC00Si8d1OZGp9LfK3dbBRtkmaLHuxdLG2HgsD6WWQ72PS1gM7VdktkO6C92Z2pjjbh/FBjlBrwzU0JaYs4pm8BAO3Ijdil2BhOsVtNRhQLdT+7KiLT3gBkUXX6fuFpb4ldUJtS8+PxB/HVKiJ0MPWo7mI0lY2G8zwvOnyFmdT5IcPGKTo/cSwyHQer7w/6msT8NHjJYpNlM8NmNopFqnVJkruW1KbI+7DRLrroqt1D/TtK6nxd82LrV5FocByHZyYPQ88CB0pr3fjPl2uSxpA1F40qdT4A4/yYmzfHmQ3pmSKmrIfIVGF+2rLgQUAx/gCgWAjarNhbg/PfWIK/d1bFdc4Hvt+Ikmo3uuXZ8di5Q8F1HgZc9AmZhzZ9D/x6d9ON2BZGRhyy33uFWsmzhnfBpkcmin9L7j0Rx/UvBACU13vktYws82MUnB9mDpFJx2vM46J6mYbzQ9fP3oUZogNSiRyZcEIk0LRnmpLcVFC1NzYFd1eUtDfadsEkOj9NGIulq4CnewB/PAyAzNs02NNs52ftZ9K2p1baLm96Lzgqq25vYtNpHa2DNuH8KNXdmhsVbYvokU9kkEs0RAv8GjLFFH0Kyeu/XF4S9b02l0nsEq1XSHbNT1OYpV83lKHW5UfXXDuO718kOj9sNNwXDInnoso8JiXzE09h6dE3qe8P+pman9gXLRo9pBFwVoAgGfArag7MRqlnDE3jMKko5/QokJr7dc1tHecHIGILr08dDavJgPlbK/D6/B2tdi2RwKZ3+IO86HRK9QfNm7qpoxBIUedPC1VK54cVPFAEwdoigio1P+P6dsCkEVLvr5/WHYj5fN+u3o9vV5fCwAEvXTRCEiPpdRxw7lsAOGD5O8CiFxJy/clGZhyy35T5LcwMV4XrlE3Y6YN1XgXzI91bGYLzw4qGyJqravTlyRJrtMLn6EqnF1uE7IyxfQpInRHi61tUL9TdZCfI+WHniPoo6wpdd0ymZjg/X19NAoGL/ifuShiry/RcwiHG4WkGu+lRkd3XkfpoE85PV0UjrXTpS9CSoNHBfVXqkRstpS6KXh1I5P6b1aVRJ6C9zHvQviTK2oJER2fpNVHmI5bzfyqkvF04phhGAyfKN7MLGOukUZaDOojU8Ygr7c1shztTpVu6TO2t6c6P2JshgU3+WFBhCfpdcRwnTvqRmJ+jeheI2y0teKDE4C7ZePScoQCAF+Zsw+Idla16PWpoVKQtUqdHZog1A2LaW5o5ClXKmh81wYM0+0zxQJl2ChCj66WLRuKVi0cC0E5tVqKkyoX7v9sIALj1xP4Y3SNffsDQ84CJT5HtPx4BVn/SzKtPPuIRf6D1KUo1SgAoEpyfQw0eeUE7YyQ7jOQ9glr3m0ndDokk3UxZu4GdslCQaSUKc5Ca+saChDE/KkFk5byk9d4mqlgar/PD80D1rrDdluayup46YNaVgIthRev2Sdvepot7qPUc05H6aBPODzXsKTqoRHLaO7oJqUYH6jyqogXUqDVrMD/XHddb3H7ut62qx/iDIbwxfyfW7Zdqfmj6AY2ONXsS0wA9X6aVTPjeKAbQtkMNWL6nBkYDhwvHFAOAatobjepwnGTUU8NDlBSNt7BUTVmmiWlvNMpHjUA6AWtJifM8j1s+W43xz87DloPxT/jUmWXzyUXnhzI/KvfQqUM64t7TBuLty0bH/Z7JwJTDizHl8G4I8cCtn68WhSNSBS5F2g79Pb0JUhaiv1G6CR7UurQFDyztoOZHmXbKgjY53lMVWz+2O75aC6c3gDE98zB9Qh/1g466ARh3K9n+4WZg+5z4L7qxCnh7ArD0zfhfGyfoPFgfgywy7Y+W6wifb6nCmMsbkAcGmZofuyGALLjQMXRI/Q20mJ8Izs+SnSQQM64vUe60NYH5SZTzo2bMR0snpA6luSnMT/0BYOFz8n0Bn3C+Zo7tVR8BG7/Rfr7bmKadF4DbTwOvuvOTTmgbzk+e3Pmh6mQ6JNBifV8ghHp3+KQbjfnplGND7w5kcdXK+/12dSmenr1Fto8ayzRiScUoEpn2FgrxIjVPjfJozhVlfU4aVISOQpRPLRpOjU6bSeqrojQ84o3C8waVRSkYkKJSas9r4JBgtNN73ipGCtUXqUqnDz+sPYA9VS7MXBK/5DN1cNheUDQ6KTo/Kk3wOI7D9cf3wSlDOsX9nsnCI5OGYmCnLFQ6fbj5s1UpZTQrI6weBfPTXBlb2qcp3fr8KCPgLMufrMBKKoHeoyYVdpUKtlQ6vTLBDC2s21+HLJsJL140UjVgIeLEh4BhFxHD/8vLgf0r47vo9bOAA6uA2XcDv96j2vsmUeiYTdY5KlITCbQ4X435oayH2x+UAg5GedpboWsH1tuukb0um2McT40gFg3QqbFTiwQW+hiF8xPPeillAyQm7Y1Foy+y3DR1vMymKMxPYyW5l7b9Ju17YRDw52Py41zk+6BjO267Ye8S4J0TgNUfaR/jKADG/Tu+8zLQa37SE23C+VGqR6nl8LZ32MxGMRJ0qCE8yi0JHmjfEnecOgBAePSVQi19qFFYhP0KMYpEGihsjj9NKYhkyLp9QXwtCB1ccmQPcb9FJW1GrWGc0vCMN+LDq8lqBn3AnAfIdvnGmM9F+y5Qx9QaZbHcXyMtzvO3lsf8PhSqzo9gKDSIaW/pMa3YzEa8celoZFlNWL6nBs9qMJqtAWUxNHXCowUpYoVJrI9JH+YnGOLD6nnYQJcoeJBGnyleBMU+W+HOT7bdJAYeat2xqVc9ed5h0WvwDAZg0qtAnxMBvwv4dDJQGUetHMt0//MG8MrhwNrPkyKiQGt1lKqAaqDrmBpDIqUPh+RsK5P21rV0duQ3iMr8yNkp0mvIDZOBwxG9SApitGCWGqQalGb2+VF5Pc9HTqmmzI/JHMX5WfYOEdP4dIp0YjUI6qh2QxCZcMUmY8/zJJhYsRWYcRpQuhKo2KJ9/An3A+bICqSRIDo/UdTedKQW2oQsmsloQKbVJBpm0dLezGYzHnzwQXG7vaAoy4o6tx/l9d6wLs3RBA8AKULGKi49PXsLdlc04rkpw2VKchceXowvVpSIEUiqgkPVmRJZlMyeKxbn6q/tpAdRtzw7jhUibIBkULKvpRMby+4oo65x11+wzI6jA4lurXhP2lezJ+ZTUcWintT5ibJY7mcEL8rqPChv8KAoK/aJnxYSZ8mYH5r2RvO942vKp0RLjs9eHTLw7ORhuOHjVXj7r10Y1T0PE4e2PjullJSnzE+i0t5EwYMUYruiQW1Ms4Eu+p14k1TvlgqgDLdZJe2N4zjk2M2oavShzu1H55xwp8blB7qecBmc3gAmj+mBM4d1CTtGFUYzMOVDYOaZwIHVwMfnAlfPBbI6Rn7djj+AXwSJ5uyugNkOVO0Avr0eWPkBcPqzQKfDYruGGNBJCIQeioH5ocdQ5p8FdX48viBT8yNvchoVJnU7JEujESsNHo4ozhWDS01hfhLFDqvV/AAkyOXQUNStc9M0tThqftw12u0dhL54rzT8Gz1sezHPtRxAofa5eB5472TAUy8XN1AitwdQK2Q+ZEa5h6NAdDajpL+3V7szVdEmnB9ALp0cLe3NYrHgoYceSvIVpR46Ztuwvdwpa5pIQZ0fcwSjKk/IjabRnT2VjXhj/k4AwFlbu2CfkGs+97bjkG0344sVJSJN7g8p094SZ6Cwcr100Yjk/NCmbUf0zIeBiaCKzo8a88NMbMoUkXiVt3g2EtrjaGDzj3G9niIU4sU0g3wh/SfaYrlfofZXUu2Oy/mh7I6M+THLi3Kby/y09PicOLQzrj22F95ZuBt3zlqLQZ2zZOp0rQFl2o7I/DS1zkwBcxrW/LAO/ZuXjkZ1o09W70kj+LHUe1BsPFCHXRWNmDi0U1owlvT3MmoEGHIcxPmpVZG653keD/68BaYxF2Jkhww8ct6I+N7cmglcMosYlzW7gU/OB6b9AtiytV/z693S9pBzgRMfAP5+DfjrWWDf38BbxwFHXAeMvxew58Z3PSqggc8ajewECqc3IM6dan3HbEzam7zJaRzBArXaTmj3+VksiB2MZQJy0twa+3rpS1CARCujodblR0WDF8//vhWXHd0DJwzsKHuOvHeUPj+sY+gsByyZ8ucL+gFV2wEfyWzoESSOSnbZ38CI/toX7TwE7F+u/lxOd2Dg6aT30qGNYircXweNsFmrRbYtXoiCB1FUhtur3ZmqSP3ZPkawdGg6LGKtgSKxE3h4VEya4LWj9qLz4/aD53ks3F4hPrf1UIModdwtzyEyMDxPjOKAIu1NqyC/KaDOitnIicxHJGaJ9irqUySfcKW0N17s/yJKCzMLifI7itcQNYQYw6Tj0PADpnwY03mIY0m2s4Q88ujMj7wYujyGrvDK9wTkEsN5ioJhNbW3VMddEwfi8B55aPAG8K+PV8VlbCQDbGNTQPo9E2XYqMm6pzoo+2UycJg4tBMuOVKumkidHzXDXw3+YAjnvb4EN3+2Gt+uLk3sxSYJARWpaxaRpO6/XFGCX9YfhNnI4eWLRsoCGDEjsxC47BsgoxA4uB744lKxKF3EvqXAwheIape7WtpvyyFG77G3ATctBwZPIszAP28Crx4OrPms2alwVKrb5QtGTH0uE3rXZNtMqrUxlPlx+QLyMRcL83PyI8BtmzWf7iKkGW4uqxcDhqEQjyWKeh+gaYIHdO1rboBE2S+R2g+1Lh9emLMN87ZW4OqZK2TH0PvOIqa9aVy3j6kb/u0+InbAgjrUXqdchpp9nRpqtOpYOeCsF4HTngaO+hfQVRLeuWV2Daa89TcOxbkWUrh9Ul2wjvRBu/QSQqEQNm7ciI0bNyKURot/c1FIi0HVan5iqCWgaW/BEI96TwBbD0mSqpsOkCLWLJsJNrNRVvzX6AuIzik9Ryx9GGIFq1RH6fhIqjRUsIH2LqJgPzv9PiiDwkbBmit4YHYx6kAZSgqfAwaeFdN5aOTQZODECGG8zI/SyI4G+r2yzSWLFGkjakpU8aA1xqfZaMCrl4xCQYYFm8rq8dAPsdddxYLNZfX4eV0ZdlZE7pAOkFS0qkbyu3QQWGz6e/qC5PtvtuBBGjI/3iiqSnRuibXHVZXTJ36vW5jeZKkMtSanLHKp86NwAHdWOPHQD5vA8yFc0o+DoW5/08dWfm9g6iwSrd+9APjuXxIj4neTOo4/HgZeHimXFmaZkJxuJMhz2bckyt9YAXx3A/D+ROJUNRFsUCZSTxqaut0hSz01TUx784fkAbAI/WBCHQaQ+XzU5UC2djrhoM7ZOK5/IfxBXhQI2nqoAVWNPtjNRowozhWPpQZ1PFLXiZLDz8uQnEKOk5y2WrdfbHzK88Rxu+/b9Tj71UUoEwR4LNHS3lgnZsdc4PsbpcdX/iqlrHnryT0loGvJ95Ev2q9QOhx1OXB/FXDXLqDvidL+wZOArC7YnjMOtSDvtZZpzh4PvGLNT2Tnp73anamKNuP8vHP54bAYDXgrBildt9uNoUOHYujQoXC7oxdGthV0FNKb1JRwqHMSiTVjnZpalw+ljCFNG5vS9CuDQerK7PJKUTiallCv0d26KRANQpMB2XaTcH7thY8WmiolTlnnhxpFXpWaH2VqYLwRtoCdcXiUikD2XFJgHAPYHj9UiS5amgR1dnoJNULrS+NTXnKqpL11Ujg/zWV+Wmt8dsqx4eWLR4LjgM+Xl2DWiugNfWNBeb0Hk15djOmfrsKkVxdH7UFS3egDzwMGxuAQnZ8EMT9ifUwC00+TDY8KC8siXuankqmrKqmJTR66tSFKXWulvdHvgBE88AaCuOWz1XD7gziqeyYeufL05o+tLiOJ82IwARu+AubcT/Zv/FZbzU3JEAFAnxOAfy0BTnoIMGcAJUtJKtwvdwHu2rgvy2jgxHrESGtMNEU0Vu2NOtPZdnNE5sdw/V/AresAe17U67zv9IEwcMDP68uwcm+1WO9zRK982dim87k3EIyossYiUXNEPqOkmGU1iY/rXH5ZacEvG8rw6T/7sG5/nTi3WaIJHvgVDE7lNvK/02FAj7GALZc89tTJHJpOlUsjX3RI8ZsPOAMwmgCHIqXNkQ/ctgknH5ou7tp4IP7WDzzPM31+In/f7dXuTFW0Gefn5MEdse3x03BqCknpphqKsmnam7baW7SIcp4QXa10+rApryFLAABdVElEQVSaiZSUCpEgNgWKOj+NvoAYYaYTqNMbSFixNStFStMeIkX9aBRNKU3Jfnb6faipvZkVKSfxqursn/Ai6nkH3jBODW9oSif9GNCg6PEDSI6YFvNDu5oP6kyiXV+t3B/z7+ALhERGjGV+ChXR0+YyP62JcX074LaTSE75f7/bgE1NWBCVWLanWvzenN4Ajnn6z4hpLNRBLci0MsXR5Lf2JiiqS38/papcKsMThfmJlPKlBlZUIhZ1sFSAKHWtkfZGAzrsd/Dcb1ux8UA98hxmPHnesMRdTN8TgUmvk+2/XwWWvAKsmBHhBVr1HxbgmP+QVLgh5xKDedlbQircp/HV2UBwUhB5DXCqCLewENXefEHRmc53mOXMT+Eg+YvMNsAib7uhhYGdsjF5NOkv99jPm0XnZ1zfAtlxVL0zxCM2pTMkThEyn1nLs2xmkVWsdftkTNS9X4czddZozo9W+lqmYL/Zcsh/d204mxMJQcVvboyQ2slxsnm0Kc6Pxx8S2djWbt6tIz6kr5WiI25QVRu1VCcaAY42YdLFdcHWctUIKxstoiloLl9QzFVnn1dr8tYUsKxVLAaQW4Om5jguTPRAUntjBQ+aV/PjzR+IYd538YHxvHDnJ46iX5b5oYjE/PA8j2qhEPjSoySJ7z1VUfKoBbCpihnMd8emmgDNV3trbUyf0BfjBxTCGwjhxk9WxlVAr4atB+UpVbUuP9ZESLGgaalFWVbk2qVoK5C4qC69ZxLJwCYb4ljUCDZQ40MpIayFKqfERKSLEyg1OY3C/Aj3y1/bKvDOwt0AgGcuGK6qbNYsDL8QOPlRsv37f4H9ywgbZGci7QX9gIwi4PCrIp8rpysw+QPgsu+ADv2FVLh/ATMmAmXrYr4kem+zqqRK0PrUTC3nh2F+aApqXoZFYn76nAhcvyDma1LD7af0h91sxOp9tZi3ldTPjmPqfQB5kMMTI0ubKLU3NjOC53nkiGqvftl4aVBhsqOqvWk5P52Hk/90HfTUAj7J+Qlxxsh1YSHF2FdrKyEgGOJlQcKmNP2ma4PRwMnWRB2pD935aUeg6UkH6z1hFDptfBotekHzgF/+k/R5yFYYvmrMj8sXEHtv2M1GcX9zjUoKNsdZjPpFMGYiNSWzKholOlVqXJSGZ7xqbwYhRY3nEd7QNA7mhy7u6g5n+OevcHrhC4Rg4IBR3fPE3PLNMdY70Gip3WyUKd45FN9juguOGAwc/jdlBLrk2LCnyoW7v1oXc8qJGqgjfvMJfdFPENl4+MdNqsfuKHfiqg9IEXFRllU0OGhDxkQZNnScJCoA0RIQ6+80gg10jDb6YksRYtPenFE616cKaKBHqykpG/zheR73fkOi8pcd1QMnD26epK8mxt4MHCWlD2HA6US9DSANJG9eAdyxDciKMSujzwTghsXASQ8LqXD/AG8fD/xyZ0ypcIM6k2L5f32yEkt2hveeAyQHWRm4AQDsW4rsXT+LD2mdZJ7DIrFQ1ixNKetYUZRtw/XH9xYf52dYMKiTXDnPajJAWC5iFj0Qa5Sa2eeHXecCIV5UBS2v90RM3R3WLQfghNdqOT8eDUej+1HkP10H3bWymh8DHyQ98bSgZH60JLQR/n2W1XnizkYRUyKZ1HMd6YH0tlJ0xAWanuQLhMKYEeqIqDV8Y6Gsk5nKMAiAlBYHSHUhjd6gOKmYjByTmpYYw4tlragzppXyIM/RDTeilL1+1GpcshUOYryGKM0KC/EIl4mNg/mhxhvb14pGn9QEHygD0bMgAzazUewIf7AuNpUbtQangOTkUqS78wOQKO9rU0fBbOTw64aDeH/xniafq15cIM04b1Q3AMCO8ga889cuvLtQ/vfwj5LQQo3LL6WaCJF8l9A3y9EUpS4GEvOTmABES4Ayj8r7jSJDkNFXRnS1UMkw4IkUYEkmgoLxrdbkFJCLPpQ3eFFa64bRwOHe0wcm76I4DjjlMWDEpYDRCoy7FRhzNXD2q8SJocfEA5MFOObfilS4t4FXRgOrP4mYCjd+AKmp9PhDuHLGcvG3bfQGcOYrC3HcM/PEnnSqzM/7p8LyzZXoZygDIKV05zqYmh8NGet4cd1xvUUVtaN7F8haLwAkG4GyP7EqpHoTFCBh4fQG0CWXOD+ltW7VeWPtA6fg/04fhNcuGSX93mrOz/6VwL4l6m/U81jyX2R+6sLT3iIpvilrfiL8TnQuBUidajDEi4INsYLaUdHsJh2ph/S3UnTEDJvZKDonSrnrWAcx69zk2M04e7hc1SabeT3L/ASY1DQHk1KQCLC1AJT50IqSeQMhkTVXU2dROj+itLNVOjaX+Q4sRkPYghUNEvPDk8k+X4r+Yci5MZ9Hcn4kh5Q6JmqRuT2CrGrvQsI+UGdY2VBTCzQCyn4XQLghnu5pbxQju+fhv2cMBgA8+ctmrNxbHeUV6qDsSrbdhBuO7w2TgYM/yOPxXzbjsZ/lfwu3S5HqgZ2ywhTMnN7w+7EpiDdFLBlYubcGRzw+F9+viU1mukqF6WTBSvNWN/oi9vpizweQuYimlKUypHk0svNT6/KLkv7FeXbNppQJg8EAnPMacF8p0O1wYnSOugzI7ty889JUuMu/BzoMIA2hv7+R9BjSUF47/bDO+PdJ/QCQ+X7VvhoAwNzNh7ChtB77ql34ZhW555SZCyz6Wsh4p+tFhtUkvWeEdKp44LCY8OR5h6FXhwxcfnQPzWMAubEeCYlKjWURCPLoKoiv7KxoDGOMCzIsyHGYce1xvUnvLZH5URlTP94Svu+sl0i6o1lIy6TMz9afSWNdFr4IiplK5ifC78RmgBTnkUBgvMInFQ3hAUgd6QHd+WlnoDnf368pxS5GdldStIm8SLJpbQM7ZYVFztiorCR4EBT7iRBZ5sQ6P6wUqVVUx1E3fFin6P/bO/M4p8rr/39u9kwymX1lNoZ9XxQQBFFEERFRWxe+qFi31tpvtT+3+rNWsT9FW1tr1drWjbbWYl1rRUGUiruigCKyM+wMw8wwWzKT9fn9cfPc3GRu1kkmuZPzfr3mRSa5ufOQJ+fe5zznnM8xKdwcQlWw+EXeagw4PLwOA4gub6kE95V8jImLhBs+EdNGLvunKMEZI83+mgX5hZfPh1LaG9/p5sIX3PmJNfLz9Id7AfR2kHtFflQseBDKldNrcd74Cnh8DDf+YxNaYnQU5XTIhCkEQcBfr56KiyYPwoWTlH8umFiJa2YOxm3zRvQS8LA7e38fE4FHftKZ9vb+jiY0dTrxznfHoh8MoNX/fQ/XxFquMDnjwXU4Zfl70uJEieaQuVSymUyDF1drw9hYnpn3YnPhYKu4kKvpz4a9oTWMyaL+dOBHH4k9dLRGYM86YMMzQGdj4Bh3N/Dq9dBvew03zx2OiyYNAgB8vld0YtbvON7rtBX+Bb0SOfpgB9Os1yY98gMAZ44qw39vPR3T6osUX+cRzWgqkYC4oZYswQMAeOG6aSiyGPDbSyZIypOhdgMoLP4jpb3ZZamIExYDi1cCJ10lpjtyImVARIz8xJ72JkXRDVrUFonOz86Q+sxo8OtLqOgPkfmkeDsoM9Hr9bj11lulx9lERZ4J2xs78cf392DlhoN4+OLx+Ok/N0sX1miRnxpZR/WR5bkKKVCB3/lOrMPpkVSK9DpNoJg0xp2saMgjP4EUAeVzc4dLrxUU8+aNoZEfKdVLOfITLgUnMuJNVdpo1puBcx6I+yxKF94cKfLT+/8fmibH5a5j6T3j8zHs8qeKzBsbnLsfWjvV18hPJtmnIAh48Hvj8d3RDuw9bsfNL27Gih9MDZt2pARP7+SOzKlDi3sVNofDLEVP/c64wvcxEbhtJssGE4F/H09EKEyX0+ovPA8X+QHE3Xn+WbXaXXhl4yH8aPaQMH8/+O/and6MV2ziwjGxRH64cEaZ7PqQSbYVNzqDmFK38x1g/0fA27cBHz4M/PgzUR1s/a+Bb14Uf8Z+D6MrbXh102FJ0IVfv+TI72eh5ITUzJj1Wlnkp/82eCwR6jhDcXuZFGwxavvuoM0YUoyv7j4LgNh/TKsRpAip1agLRKJDI2iRnJ/8GqDL77Re8KRySmReTe/nOJGcH29o2lv4eeKfp0mvxeSaAvx3x3Fs2H8CV506OPz5Q+D34NIYnB9V294AJCudH4PBgN/85jfpHkZa+PEZQyEIAj7e3YxWuwu3v/xN0I5SaD1LKFMHB1R8xg7KC1IaA0IiP8ZA5EdK19BognoXJAN55Cdak0++2Asnl8vrVZwyaWIgWFFNXvfU58hPH+CS5bwQFQikQynVMHB1qxL/zvnwMlHuendTF1weX8Sdwu2NnWi1u5Bj0OLamfVBr4U6wOEUlGIl0+zTatThT5efhEWPf4wPdzXjD+/tws/OGh7z+2ONqiohpbz4nXa7JNHbt5tnTohTlQ6Od4rfx0iqXHJa/XVPBTnhnR+rURcU7Xnmo4YIzk/wDnYsO+vphl9Hwznf/LPp7PHgiD+iK1d4yzTbSoiCWtH5AYCuY8CvBwNl43rVhnAnuc0hij80NPdeNPdyfmS1RDmGkMiPQRtYzPen8yPVzkb/frb51Tw1Anrdm/uKTqtBuc0k1UBNqM7Dx7vFJra9UkwjOT9csGDRE+FrwfIjOD/7PxZTK5WII/LDN0JzDFqcXCeuazYfaAv/dxXgjd5jifwMCNsbQAyc/BQiJqbUFeLZq6ZgxhAxxB66+xkt8lNbZMH9F47Fj08fgoUTKqHXaoJqTuTOQGB3ORD50WmFoB4KyUAx8hM27U25xw+HR4N8/t2tQJG13PmRiTokkEuvkYpB435rEE0haWxA5BslX+wV+SM/tYU5KLIY4PT48PWhtoh/a9NBMW/+pNqCXk5SaPRLPp6BwvCyXNx/4VgAwB/W7cL6nb1TaJRgjElSuUUJ5IVLneZdYk0Kd1b6Gvkxy+rx0gX/XGJ1fnh9ki3CNWpSTX7Q7+0Ot2ItT4/bK/1d7kioQfTAE0XqWl7DsvuYGOkYcPY4ZE7v545tAVr3BH5/+iyMaFoNADjhcOF4lxNdTg80AqQUJ0DMhAhC1sTUrNPAgm78Tb8cP9CthlEriPLbQFLT3qIhFw6KBq/fLLQY465FjYX6kkAKZX6OQapTumxqdfCBkZyfbn/tZPGI8H9IZwAqJgY99bnPL9rR2LuvkEQcNT/dsrS3keXiRuDhtu64rgNr/Sm7BRGi0URmkpWRH5/PhwMHDgAAampqoBlANQqx8v8uHIe3vjkKj4/hkbU7pTzhSAsLzpJpwYWZpbkmyYmS7/pzh8Hu8ko3bb02xTU/fhnccIIH4Xr8cHg2CR8v/1zk/RbyZZ9ROCcqEtz56Uvkp0fWeVwecjeH+Wy7nB40+iNFRf4LtUYjYMbQYvzn6yP4cFczptSFdMGWcbRNfG+dQv1AaBQt3r5HoWSqfV40uQpf7j+BFz4/gJtXbsKqn86S8uDD0en0SPLERQncICUnxe2RxDeAMBK98ZyXO1UxKkilAintzeECYyyqVKw9Sm8WAPjtxRPws7nDYTZoMX35e3B5fbjgiY97RUp6/AIHFXkmWIw67G7qUpnzo2wTOq2oeNnR48Fef6RDniaYqbYVF+O+D1RPAzb/A3h/ufIxh77A8ObdAB4PFn8ozMGgfDP2+8VfeqU+y0QUcvQCztRsxGnaLTgNW4BVWuArfxPXJAkexIKk4BnDRkWLVAeamsX49CFFkihLQY4ey84fg5+eOSz2mp+2g4Gan1Cl01AufwXoagL0ZjRs/Ryvrv4S0zTbAWeENO0EIj8mvRYFFgOKrQY0d7mw53gXxlflRx4bELSpMjXCvVMa2kCwvQFEVn763d3dGDx4MAYPHozubnV09k42g/LNuO60etxw+hBcOyuQ45qIZKN8ZzFIdtm/O+1weuD28Fz1QGpashZeSpEfj48pavZH6vEDBBYV/MImr1XiyB3ERBwYQUp7i/utEjy1x6DTBM0Zj8q4Zf/3bw+3Y+w9ayS1tlqZAzPT31H8xQ0Hwsoedzk9+GyvmN5QHrpTmgIy2T5/ed5ojBuUhxMON258YWN0RTHZpkC4VMtI5Mjq47jsul4r9NnB5Od1eX1x97aIl+OdTsXPqdmf9ub2MsVGiXL++P5ubNgnRh9D0yzlCIKA6sIcFFuNGDtI7BK/5XA7Nh9sC/rZ7i9svmDSIMmZUkPaG5e6jlRXx9NyuXMpr2PKZNuKi/xqYNIVEQ/R94gRhhMOl5TyNrjYgjvnj4JWI+CyKdW93ySTSjbrBNghu95xxwdIS+Qnlu9nIMqcGudneGmu9DjfbIAgCMpKZ9z52fu+GI35+0XAPy4Gfj82kJ5ozO39PjmWYqBsNFA4GO7hC2Bn/rlwRhAl6FXzE13qml8Lh/p7sO06Fr0GFgjeYKwqCF87Jh0/UGxvgJCVkR8iGHk6TiJ5wvIc/DKZI2QOUnsL7FiGi04kipLaGyAu7EJ39nio2xhmIcp3iPkOq9sj/ivvmSBfxCaSWsDf05fIT5Os0FK+Y85rlsTCV3E3/eF3dkivF1oMQXPEC++PdTgx7f738N9bTw9ycBrbezD/0Q9wwl9vkfQO8SrDpNfij0smY8EfPsSmA21Y/vY23LNwTNjjW7qiF+lHQp4i2hVD5CPm88oinw63F7YU9WZ6b9sxXPPXLzGqwoa3fjpT+q46XJ4g+z9hd4WtN9zd1Ilfrw58h2OV+X526RRsPHAibEN4o16DqYMLseVQO4DYdtbTjdTkNMKucUGOHgdkquzJ+L5kJLbK6MdAXOTyHmeDiy0YV5WHL/7vmcriFjLnx6QXoAmXm9yPkR9JwTOGtDfeDyy0H1+yqJGlDMrTv3thEjce0LoX2LUW2PNe72OiOT8yzHotuuCPsrsiOD+hkR9Bg3e/O4Z73tiKhy+egOlDAop6fC3Ar4XDSnPx2d5WbG8M04A1BJ4yLAiQ6pgJ9TBAr4pEPMjznhNpUClf/sujEHKVGr67rNcK0sUmnCJbvDiDIj/aoOdD7wFS2luYixXfUfWFpL2FEwPQJtDVmb+jL3oHxzu52EHwrpt8/txeBoNOCJIznlCVF+QsVRXk4IKJlXh98xF0u7248tnPg5zZxo4enHC4YdBqUFVoxqxhsamUDWSqC3Pwu0sm4tq/fYnnPt6Hk2sLsWC8cj+TvjoskjCB2yvNY6TIR6wYtBpJuanb5Y0qdJIoPEVm29EOtHe7A1GJzuA6nxa7KygiKWfP8eBC9Vij0wUWA84cVRb1uICUcPrEH2LF64sseAAAeSEXvWQXvmcMggD8bCvwj0uApq2Kh2gEMcLOe/3U+xUuw9bfydK0zDoBOoT5TvRj5IdfA2KJ/Eg9xVI057VFOSi0GNBqd2FURYS0tYlLgLX3AJ5uMT1RCYM15r9r1GvQ5Y/8MGcnwn77Gz4I/l2jw7V/+xIAsPTZL7Dz/vnSS7yhKY9cnVxXgL9/th9PfdiAm+cOj3qdlZwnvTZqyi6ReZC7SmDuqDLMHFqMH55WH/1gJWR2L78ISH1+nAG1N502EPmJdjGPtemgPPKj1QiSDKyS6EF3lLS30MiPS5auF+n4eJCanPZB8YCnsIVGYuS1SW6vD14fw7ajgZ2sHyooX/3+skm469xRAICdx7rweUOr9LO/xQGdRsC/f3Iq1t1yetjIz1+vnoqSXCOevjKMCs8AY+7oMtxwuvhZ3v7y12HlwrtDUivihW8UMBYQBkjGTr4gBIRHUqn4dsIRcHL4dxbo3Vg3ktz1AX99hsWgxS/PG42hpbHvGMdCPGpa6Ua+iRSO/BDncMBGfgAgrwqoOinsy9zZ/sYf3RtcHGXBLYv85OgY9OGcn44j8Y2zD8Tz/UxmdFgJo06L9/7PbKy7ZXZkuX6jFTjzbvHx9jeVj4nDYRAjP/6oU7ian11rgUMbgp+TOamukPTeff5USF7HOle2URKLoE0gbW4A29cAJi2zdu+992LZsmVBz40YMQLbt29Px3CyHoNOg+evnZbw+2cPL8GrGw8HpYYBgYt2t8srXXj0WiGoF0U4/vH5fix74zssnFCJhy8eH3FnRV7zA4gXaLfXoyil7YwieMBVlHhuPa+dCf2/cXiecDxoklDzs+WweDMfHbL7JnfSXB4fWrpccLi8MOg02HbfOWGdtatOrcPQMqtiakV9iSXyLh/E78CGu+bG+99QNbecNRwb95/A5w2teGDVNjxz1ZRexzhckb9v0ZA76bzOK1kLm1yT2KeDC2ekAnkD3YOtDqkOJ7RZbCTFNy7pvuSUWlw9M/YeHLFiVZPzE0PkpyAkHWnARn44hvDOcLHVEPTdkquVKSKv+dEy6BDmO3F0czwj7BM8Eh+LKmKnrKFyysZjMcSmblYSQc0tTkx6Lbp4/ZWzQ9wNkq8JfF7gH9/v/UaNDgadRtrE3N3UKW2e8P5PvN+dxajDiLJc7DjWGVMza6UegIR6SNtVccyYMXj33XcDA9EN8Av0AOb8CWLu9aTqgqDnc2QqNQG1N410MZfvCoeyZusxuLw+vLLxEK4/rR4jysPf4KTIjz+VzaTXosvpUZQGlSu8KNEr8iOlvQUvNl64bhpe33QY/+fs2Pu9cIQkqL19fbANADC+Oj/oea1GkFI93F6f1JNhUL454oJJr9XgjBGlCY8nG9FpNbj7vNE477GP8NneFngUaswc7r5FfnRaDQxaDVxeX8D5SdJitqrAjKPtPTjY6sDEkO9RsmixK0d+QiX25Qu7li4nthxux4whxTDoNGjr5nUMqVnQJbvpciqR+qVFSE8OTXtLRI5fVWjD//+GleZip7+A/ZT6wt7S1qHI1N6sOh90QpjvhLb/5MN5jWZTZ/QFeUdP7750acNaHv61y16I61R6rQYnhAI4mR5GTw9wfLvYC6inA7BVAA3rld8oaFFiNUr3wX3NDsn5OeJ/rqogoNg5ubYAO451otUefUOIX7Mi9R0jMpe0pb3pdDqUl5dLP8XFVEugVgRBwKKJg4KKIQGZ1LXTI6Ww6TSxRX6aOgI7xnyHJhxS5Mdf71NoEc+v5Fx1uyL3+dFKkR8ueKCc9jZjSDF+/f0JCdVKcB+EMbEPTLy0O9zY508FGu/fSZfD65NcXp90ga/Mz26hglQxqsIGm0kHu8uLrUd6F8p2u3r3iYoXvjg/5q/zSkbNDyDWLgHAwROOKEcmjlzlTe4IhTYYbZXZ6k9e2ISrntuAFZ80AAhcJ1K1yJDk8ZPUdDmVePwR6VgjP4UWQ0r6vagCQYPxVXkowQkI8OH+C8dFr82QRX7yjAif9rbo8SQONDK8ifUx2T0xHLzmJyNSHXPDOD/1ZwAjF8R9OkFvxie+0eIvW18DHp8KPDpBlMP2hVGsNOQECavwjRTGAj3T5JtJvIZ2Z1MEUQU/fH2RqJgNkV7SZiG7du1CZWUlTCYTpk+fjuXLl6OmRrmrr9PphNMZuFl2dMSmxhEOnU6HH//4x9JjIjXw3W55Wo1OFvlpixD5kS+ODrZGXpyFRn4ipQlEj/z4pbK9XOrar/YWRvAgETSyG3Bo9D4WvjncBkDsTq6UfqDXatDj9sHtZQHnJy9yP5pMQk32qdUImDq4EO9ua8LnDS2YEBJB6WvaGyA66u3dbuz3bwKEilwkCu9uH82++oJccr29u7fzo9cKcHsZWv2RIJ+P4VO/rPqLGw7iuln1aGgWd+5TtcjgSk3OOKT3120/hm1HO7F0Rl2/LjTl/dLCIY+QlYQU9qvJtmImXBSGMSzN/xo/NN2IfSf/X9SVLIx+Llnkp8AIZcGDK14Hqvy1jSWjgOPbAEvqouY88tPc5YTXxyI6vnzTMCMW5OZC8ae7Nfj5ulMTOp1Jr8H73RNxhvZrYP2vIXUJb9oGeBXWEvWnA3pzUCNnvuZweX2SLck3ps4cVYpH39uF97Ydg8vji3jf59GhWDdlBqTtqZi0zMC0adOwYsUKjBgxAkePHsWyZcswa9YsfPvtt8jN7Z3etHz58l41Qn3BaDTiiSeeSNr5CGX4DrW8tsUQlPYWPvIjT1k72h55x4tHfvgOLu9xoOT8RO/zE4j8MMZktUrJc36CUpUZgya8do0ivHg3dKHN4fVJLo8PR/yfXUWUZpyZhNrsc9rgIry7rQlfNLTi+tOCBSUkwYMEevxw+CbCnibR+RmUpLnkzs+BfnJ+5JFe3v+ovtiKHcc6pV1Unp4CiCk8u5u6sOe4HQadJkimNpmYpMhPbM6P0+PF1StEBSmrUYelM+pSMi4l+KaMNoLUtVzmWN6DDVCfbcVEtaxedcp1wIan/L8wmF77AQCg7ssHgPPuiH4uFrjv5OoZrpxaCWySvX7lG0D97MDv/7MS+OgRYPr/Jj7+KBRZjVIq89Yj7Rg3KE8xguX0eLG7SdwoGBmlRrNf0GiAwacB370u/v6D1aIq38QlCZ3OpNei0cGbicoWFX87H6idGXywrQpY8gp8PhbUT5BvxMpTXOUpyeMG5cHg3zxs7nJGbGIdiPzElv0xIG1PxaQl7W3+/Pm4+OKLMX78eMybNw9vvfUW2tra8K9//Uvx+DvvvBPt7e3Sz8GDB/t5xEQiKBUC6rQC8v0Xi263V3JG5Ph8rFcPkEiEi/y0KEV+ouzES2lvjElRHyDZzo8s8pPA+3m9z4Sq3ilvgLzXTyDtbRClvaWMqYPFG/IXDa29FApDG+klAv+uNvp3dSPdkOOBOz+8230qkKe98YUZEFB7G1YmCoZwW5Wr5h3vdOLL/aJE8YSqvJTJcfPrhtK1SInjstqLxhhSkWLB4fJIvWgiIU8fDoc82lOeDX25hp4JXPQUcMMnwOTIjU+jIkt7g9eDIUUhUSW54wMABXXAwkeB4qF9+7sR0GoESZr7/Mc/xg3Pb1Q8buuRDnh8DHlmPSr7oRl1TJhkTljNKcCUawF9YtevHIM2uOmsnP0fBf9eOx3Q6qTrB4dvwPDrsl4rBN3bBUGQNk9buiKvO6San0yIshFxkxGxt/z8fAwfPhy7d+9WfN1oNMJoTF6BIWMMzc1i/4ni4mLSaE8RRp0WFoMWdv+FRhDEm3auUQedRoDHx9DmcKM8L3hhGJp73xohPQ7oXfPD+4Bw5Rulc4dLe5NHfuTSmMakpr0FHiciesAjP+Or8hVfV675UU/kR232OabSBotBi44ecQE7ujJww+/wfwf7IlIQGqUsStLNlnclb2zviZpOkyjyDYRdTV04YXehwGKQ0t6Gl+UCOCptcIQKIXzuT4GrKYyi0tUH+HVDSRpfiWMdAeenNcoCKRb+8/UR3PPGVrTaXXj+mmmYGaGXFq/50UVIextTacPP5g7HkbZuXD87uH2B2mwrJgQBGH9J4Per1wCdR4F//29wQ0yfN3p/Hrnz4+kB5IttXfquoXLHfPXWRoz55epe9zC+YThrWAbNa8mowOM+jqnYaoSjKcZ1oD998eWvgjfKV29txK8uGBtIR1ZYBxRZDTja3oNme2SBCamBdYxpbwPS9lRMRvT56erqwp49e1BRodwoMNk4HA6UlpaitLQUDkfqdj2J4F0R3gxMEAKiB0qiBKF9R+KN/ETqi9Ad4aIHyNTevEwSOwCSG/kJrfmJhw93HUdjRw80AjB2kHJqA68HcHkCzk+Fimp+1GafOq0GJ9WJ0Z/PG1qCXuOL/JI+1OmERimTJWNbkmuUNiGaOpMTwQjFHdJbg4sr8F3V4f7ID99FDa0D/Gi3uFioLkzd95cvImON/MjFWJSiy/HyyNqd0v//8mc+D4qWheKJIfIjCAJumjsMD31/PIaUBEvxq822EqLmFGDMhcCdB4FfyPq19LRHf6+s5gfdrYBPtoF29erkjTFOzhod3KzX7vKixe4K+nG4vDDpNbh57rA0jVKBKdcAEy8HLl7R51OV20xwhIv8hOJPXzzSJtrqSL9a7PFOJ/Ye75LqHJX61hVaxGt1tMjP0ThTyrPC9lREWiI/t956KxYuXIja2locOXIE99xzD7RaLRYvXpyO4RAppNBikCRu5TtVeWY9mrtcYRTZ+hb5CfTtiCR1rezMyPv88IWbRkismWk45M5PvJGfVzceBiAugMMpiHFHraXLJUXdSO0ttUwbXIgPdh7H53tb8YNTA71oeIpUiTXxzz80ZS5ZMrZajYDyPBMOnejG4RPdSXeQfT4mLdbrinKwr8WBLYfbMbLcJuXei5Efsb7H7fX16jnEI0GTaoJl9JMJj+rGGvmRSw6HNmtNhND/8+ubDuOSKdWKx0rNoiPU/BB+BAHQGcQ+QK5OwNEC5BRGfo/c+bE3A6Z88fG0G4DKiakaaVSWnT8G546twKSafLTaXWHTpYssBilFLiPQGYELklPnUmoz4Vt5feytu4D/3g9MXirO68ENwKvXiq/555Fvttx+zgipTu9wWze2+1NMlVpoFFt42lt422aMSeuajEkxJOIiLc7PoUOHsHjxYrS0tKCkpAQzZ87EZ599hpKSknQMh0gh8uJbebRFrMuxK8pd9478RNbc541LQyM/XQqRn2iCBxpZnx++GEqm0hsQKngQ33v5Yvq6WeGbPfLx8vqJ/JzwjhKRHE6p99f97GsFY0xKaZCcnz5EfkL7tNjMyat9Kc014tCJ7l7pZsnALZOfrSu2YF+LA4+s3Yk5I0VlLJ1GQE1hjlTMfcKhvBli0GowpS51zg/flHHGGPmRSw7vaOyIqgoVDX6dGlxsQUOzHX/+YE945ycGqWsihJxCv/PTGv1YmeABHC1AQa34OEIvof4g16THXH/0J6Ocm36k2GrALjYI31hnYvyYsYC1VKy34hTUAdvfBL57HWz6T3DdXzdI9Ywjy204qbYAX+0/AbvTg2/9TcJHKjg/Us1PhKjuoRPd6HJ6oNcKqC1KXUoukTrSsn20cuVKHDlyBE6nE4cOHcLKlSsxZMiQ6G8kVEehTHbVKIu25Cs0OnW4xIsSTwHhtTtdTg/awyjDMRZQc+GLGKtfaEEx7Y1HfsIUoMtrfqI5SokSqvYWDzyNKly9DxDYyf5ol5gyNE6hFxCRXMYNyodJr0Gr3SUV9rs8PknRsC/OT2ikJ5nSyrHIzieKvN7ngomD/H/HLaViFloM0Gk10rWg1e6SPq86Wc+wqYMLU+q8m+IUPJDX/PS4fdjb3BXh6Mi4vT5pk+WnZ4pF84fbuuELsysSS5NTIgQe7QmVXP5qBfDUHODX9cDnfxafk9f87P8E+OQx8bEmNWIbROxYjDowaPCHknuB+Q8pH/T954Db9uJ44SS8u60JAFBfYkGZzSRtih7vcmHddvG1U4f2rq/jzmVoLzI53HkaXpab9M1Ron+gWSNSSmjNj/R8SKNTxhjO+8NHOO+xj7D4qc8AiAtGvgjafKhN8fydTo8kTMALDyNFfqLX/Igm4fX1dqqSRV9qfvgOPd+dUoKP99sj4gV6UhhJbCJ5GHQaTPanZn3eIC6yWvwFszqNgPw+RGvkNT5Woy6pu/553A67I0dXE0FeM7dwQiWKrUZ4fAz/+PwAALGAGQhcC1rtLskx+umZw3DfojG445yRWH7RuKSPTY4xTsGD0PqovogeyDdo5o+tgE4joMftkxraymEskEZIkZ84MPudH3nkp+Mo8J+bgMNfiRGet28Xn5c7P/LkMi05P+km0n1dQqMBLEVSrQ8ArL7pNGg1grQp+vneFnS7vSizGTFR4d5YZImu9sYbWo+tpI1FtUK5MERKKQiX9ua/wHAxgyPtPdjbbA96r8WgRX1JHva1OHD7y18rNhPjjk+uUScVhkuCBy6ltDdfr7HI0cnS3rpTFPkJdn5i9368PoZWO68hCR9J4M4PTx/M1jSJ/mbq4EJ8sqcFnze04vJTaoNS3jR9WKzazIHLtLyBZTLIN/PIT/KcH8YYfCwgdqDVCNBqBFxxSi0eeXenVLfG69CKLEbsOW5Hq90lFSIPL8vF2H6KWMYb+enoCb6u8GjVjsZOfLqnGYsmDopZ/rbTfy6jTgOTXovqwhw0NNvRcNzeqwZLLqMeqckpEYJS5OeIslx0UM2PHGfi0T0iOQQyOqLbKd9EOam2QIrMcKn8L/ybU6MqbIqKa1wEYXdTV1DfMTlc2Cac6BCR+ZDzQ6QU+SJAHkHhi7inP2rAyXUF+KLhRK/35pr0mD28BK9tOoxjHc6gdJNQ5PLCNn+akFKqnJTKFq3Pj8z5SX7kJ/A4npqfNodLOj7S4ip0vMleMBPKTBtcBGAXvmhoAWMsKfU+QHDkJ9mS5fy70d6dnLS3LqcHc3+7HsPKrFLEhi/Ur501GE9/tFda8Ff7+wwV+Pt+HZbVHvHX+gOp5ifGyI/Dv/Oca9Khs8cjCbJc/sznON7pxL4WB+49f0xM5+IbNDy1sa7I7/y02DEjJCXHI7tYUOQnDnL8zXEdMiXG5l3Kx377ivLzHYeSOyYibnjto1I6eyhKLR54fQ8XLCkOsyk4pa4QZr0Wh9u6ceqD6yL+nTmjyiK+TmQuWen86HQ6LF26VHpMpA65Br58UT5UJsH6h/d2K0rZWo06LJpYifoSi7RgUkIAMF4WvuYRoo4eDzxeH3Sy/HjJodFFj/z0RFGGSxQhQbU3vjAsyNFHzPk3h4xXKWKWyajVPifV5MOg1eBYhxP7Wxw44I9iVPRRDUhe8zMoyc4Pd6KTJXjwzcE2NHb0oLGjB/uaxf8//65ajDpcfFI1nv24AQBQ5y8U5tKyvH+VzaST6v36A14j1+P2BolVhINHVAflm7G9sRNPfbAXL391SHJ2Y2lWyunoFq9rvI6rrtgC7DiOAwqNZ4MjP4ldk9RqW31CnvbWdhBo3AI07+x93Jq7gM3/6P28rQqYcVNqx0hEJaa0Nz9clKTcFnBwQhUjw11jzAatuFHzYUPE+/OFkwbFdT3OStvLYLJyBoxGI1asWJHuYWQFBbKogzzaMndUGe5dOBr3/ue7sD1GrCYdBEGIWNyvRJ5ZD0EQ62naut3SDg9jsmiOQXnxoNUGpK6jRYn6Ah9fPM4P381S6k0gJzTyozbnR632adJrMaE6Dxv2ncDnDS3Y5Rc+GFpqjfLOyNTJ1IRGVfRWJ+oLZf6olLx3TV+QSz9/7a/TM8gW6j+ZMxRdTje0Gg0WTawEABT6Iz+bD4rH1xT1X9QHAIx+exFT9RgMusjOD4/WjK/Kw/bGThxoDTi6gCjcEis8jbXQ74TyegOlNESPt++RH7XaVp+Qp729fDVw6Avl4z59vPdzg08Dlv4ndWMjYsYaoX9fKNx+5BkSoypsMOg0Uh8tW4R+abecPQK3nD2iL8PtRVbaXgaTlc4P0X8Epb3JVFE0GgELxlfi3v98JzVoA8Qc2m8Pi8WEiapa6bQa5Jn1aHO4ccLukpwfp8cnCQyES2XTCrKanyjiCH1BIwjwMhaX4AHvTTCsLPICOHS8lPbWf0wbXOR3flrR5E/TrC/um/MzdlAeXrlhOtq73Zg5NLntAMr9USnesK+vyAuNeT2fPEpRaDHg19+fEPQe7pzz/Prawv6VjpVHdp0eb1T1Joe/5uDHpw/FOWPLsW57E57/7ID0+vHO2Hv/cDldHv3iKY6dTgXnRyYdHqnJKRGC2b/j37wLOL49vvcakrvZQCROoJbXC5+PRayj5HV4vKYREEVpxlbasPFAG4DIokHEwCcr1d4YY7Db7bDb7XEVnBPxUyhzfowh6ViFFgM0/ggId35Org00oetLM8dCmXwuR54zbwiTNsJ3VD3eQNqbMSXOj/hvPF8/LqE8PEokIXS8sRZfZwpqts9p/n4/X+47IX33knGTPam2EHNGliVdVrXcH0Vs7nIGpVUlirwxIF/Yh9p9KKGfz/iq/lVQMmg1kvw8F0QJh9vrk0RW8nP0mDOyLKipLSBGv2L93nKlOB7x4dc8pTRfudJbtNS8cKjZthKGR37idXwAwNi3jQsiecg3Qx1RxEl4DWPoxp+87cPUwVEa3iaZrLS9DCYrnR+HwwGr1Qqr1QqHo3duNZE85BcftyfY4LUaIajo0GLQYnBxYNe3L86PpCYn61/ijSFthC8uPT4fuqMow/UFvnhJJO0tWjG4fLx6rQBLCtL2Uoma7ZOnqDV19kjfvUxOO+RS1z4GdEWoq4sVucIiT2cNbdIaSujnIxcv6Q8EQZDqfpyeyIsqeQNm3nuovtiCKXUFKPWnELq9TNp5jgYXSyiQnB9xPkIV5QAkReZazbaVMFzwQIk5v4j8XgM1sMwUTHqNtGkYLfWtTYr8BDs/vFHs0FIrhvUxHTlestL2MpisdH6I/sMoExbwKOwsl8oKEm1mPeaNKccp9YWYWleIc8ZUJPx3C6TIT2ARIk8b0YbZOeURIZfHJy2EUtHEjF/E43J+2nsr2ChhCmkmm+guMRE/3NnvcfvQ6K+jKczgyJtRp5W+30qpVvEij1jwtD+LMbLzHfp97qtARCLw61S0yA+v59FpBOlzEwQBK6+fjk/vPFOqcYw19Y07nHyjJxD5Uar5Ecemp5S3+DDLdvg1emDho+LjwacBw+ZFfq+BIj+ZgiAIUvQnmugB71uWFxL5mTWsBP+99XS8fuOpdF/Mcqjmh+g3chQiEKW5JgBijY/NpEd5ngkrr5/e57/Fi6iDIj9+50sjIGy+sEHaAfZJBcbhUuT6Au/1E6vvs/rbRuz3K0Dx/ijhUGomS/QPVqMOOo0Ajy9Qz5XpNVc2kw7NXa6gBcVzHzdg65EOLL9onFSz85cP9uBIWw/uOGekJAKy6cAJfLq3BWeMKMWoClvQjixXXLJEqd2rLgiOZJZGEfRIBSa9Bu3d0Xv9cHW20Kg0j8aU5ppwwuFGU2cPRpRHrxfh6Tv82sjPy/+OHGpwmiA5MudnyrXASVcBVVOBglpR/S0SNX2/FxHJw2rUoaPHEzHywxiT2lzkK0Td5dklRPZCzg+RcibV5GPTgTZccnJ1r9fkzTrlzRz7Ck8jUar50WnCOzNy54c3aUxFcTE/Y6yRnx89/5X0uDwOtTeliz+ROgRBQKHFIPWSMOo0CQt39BdWo9/58UchvD6GZf/5DgAwc2gxLpg0CGu2NuKBt8SaiZJcI84ZWw7GGK545gt0OT34+6f78cnP5wQ1IOSpW9HS3swGLWwmcVGjEcSGxf1NrL1+2vmOchiZ3CKrATgWfN2JBBdV4c4Pvx622p1we31BYhF8wRfNmSRC0OcAYy4Euo4DZ94tPlc2WvxXG2Zj4oZPREnsEfP7Z4xETEhy1wppoZ09bhh0Gnh9LFCX14+S+YS6oKsokXL+ed0pONbRg9qi3jsuM4cV48Uvxd23ZO5o8gLiJln6iTeGnVN52pvbH/nRpyTtLb7IjxxdlEiUiSI/aaW6MEf63tUW5WR8eoU1pMheLtu845ioMPjQ24Fi8d+s2YHfrNkRdI6j7T3YeawLnQo7skoR31Ae/5/JeGvLUcwdVZaWz0uq+YlaSB3Z+YkkWKAET6Mz+x3EYqsRBq0GLq8Pxzp6UCWLirVF2M0mIiAIwMUrlF8L5/yUjRF/iIwiXK+fO1/dgn9+cQA5Bi2e+J/JAMR611iuPUR2QjU/RMox6bWKjg8ALJxQKT22GpO3UB/ul4P+9nC79Fwg8hPB+dEFnB9eI5SKHHshjpofnusPABNkzVzDIb/gZ3Kx/UClRiZIUdPPss2JkGvk8srigmJHY4f02pG2bnh9DIdOdEvP5Zn10o+8nmnL4XbFdJRYIhWnDS/Bg98bLxUk9zdcvMDuis35sYVxfvg1LJZGjIAs8uPfsNBoBFT401oPyz5zIFDHQLvZSURL10c1IfX6kQmrMMbw5jdHAIiCJP/5WnycZ6Z6VyI8FPkh0s4fl0zG65sO46dnDkvaOcf6JS0bmu1weXww6DSSE8EbmSohOT/eQOQnWqQlEXjNUSzqwvLo1d+vmRr1ePmCtCTXGOFIIhXIC/aj1WdlAjzdtM1fH8f7SQFAY3sPjrZ3w+X1Qa8VsP1X83tFTm/8x0as2nIUXT1uRedHDbuvPGLTFUX0IfbIT2ziEd0hNT8AUJZrwv4WB5q7glPn2h3K8r1EH9CEfJbjLwNm3pyWoRDR4eIpXf702m8Pt2Ph4x8FZVB8deAEALITIjJZ6fxotVp8//vflx4T6eXccRU4d1ziym5KyCMe7d1ulOQapV3dSDUIRp087c0f+Ump4EF07+ewJHFtjtiVmiPv6zOhKj+xAaYRtdtnkayOrciS+c5nRZ6otsYblO6QOz8dPZLQRnVhjmLKKF+Q2F1exbS3cA2FMwlrhFoCOdypCR/5ie08HC6dbTbI6/R6i7WIv7uDXk8EtdtW0glNe1vwW+rtk8FIjU7915l125t6pY7z61WmRUjJ9jKLrHR+TCYTXnrppXQPg0ghWo2AXJMOnT0eyfkJlZVVgkveujy+gLRshEhRogSkrqMfy9NfBkWRuOYUyZyfSTX58Q4t7ajdPotlTTvV0EWcf694Hym589Pc6cS+FjuAQA+jUPiCpM3hgktBMCAVUvHJhjstSs6bnNA0tVCkyE+8aW+yDRm+cdMW4vzwmp88c+LfKbXbVtIJTXujvj4ZjTXE+eH3xiXTavC/c4bhlOXvScdmWm0c2V5mkZXOD5Ed5Jn16OzxoMO/W8t3bSOpbwWlvcVQI5Q4sTc55ZGfQfmRm5tyTHotVvxgCgRBCIpCEP1DSVDkJ7NuwEqU+9P0Gtt74PH6JGcHEKM5e4+Lv9cWKX//uD01heltkwqp+GTDRR+iRWwcrt5pakrn6eiOLe2N1y7Iz5cvyfQHn6MtTNd6og+ERn6oRiSjCRU84I2Uxw3Kk65jHLITIhKZf1ciiAThefk8T5/vxlojRH6C1N78u9ipUXsT/41F7S3g/MReP3L6iFLMHl6SyNCIPjK0zCpFC0dW2NI8mujwFK5OpwetDlevaOTupi4AQGWecuSRp2KGFuhz1BD54fLa0VTaeI2OOUzqLI+iNTTbFV+X43B5pKaq8lTVfH9kJzTtrT1M13qiD2go/UhNhEZ++AYBr3P90ewh0rGlVO9KRCDz70opwG63QxAECIIAuz36TYpQJ5Lz479A8l3dmCI/Hp+kDqeP0BcoUXjNT0yRH572VhBb2pvaUbt9luaa8MHtZ+DD289QRUM9K6/ZcXqk/jSFFoPULHdvs+j8FOcqR7H4wkMukS1HVZGfGNPezHrl/9PIctHZbWi2R22Yyj9rg04Diyzyw0Uy9oU4UJLaWx92tNVuWymhYoL4rz62yDqRPrid8H5ifIOAX4OqCwP3yHF+0aNMgWwvs8j8uxJBJAjvHL/T36uEL2wi1fwEq735m5ymsOYnvsgP3ZzVQkWeGdWF6pgveRFxa1dgMcFV4A62it+/4jAplLyuiae9ldmCj1ND5EeK+HojNzkNqLMpX0PKbEYYdRr4GHA8TBoghzs/RZZgSd4xlaIDtb2xU6qh+vpgG77aL6pY9aXmh1Bg7jJg8GnA1avTPRIiClZTsJQ8tyFe3zNYVpc4riqznB8is6CaH2LAMr46Dy9+eRBb/L1+pA7pEdTe5As1nt+fCqlrvtjxRvF+GGNZF/kh+heL1OPGgyfX7wEAFOYYIAA41hFYwIdTrgt1igotRjR3uaSmwmpwfnhqq1tBsEFOoCmpcrqUIAgothpxuK0bzV3OiA5wi3/hFtqLa3CxFaW5RjR1OvG7tTsxqiIXz368T3q9JkztFZEgQ84Qf4iMRx6ldnt9Upoqj/xMqy/CT84YipJcY1CDYIIIhZwfYsBS628weaxDLIoM5OuHz/OWp+hwZ8mQisiP/89ES3trc7ilcVfkZX7PGEJ98MhPj9snRSsKLQaYDFrs8tf7AEB9iXIKX2GIqEOuUYccg1ZamKgh7Y3L2bujRX6ktLfw15Biq8Hv/LjCHgNAirKFKgJqNQIuP6UWv1u7E3/yO6Oc5ReNi1n1kSAGGnLBA65+KAiBFHetRsCt80akbXyEeiDnhxiw8AaffEHHc/Aj9R2RL9SkyE8Kan60Mfb54SlvxVajKvqlEOqD9+kBAoX6P5kzFO9sbcQHO48DAL43uSrs9y/U+bEYtbAadZLzkwrBkGRjkJyfyPao1JQ0FK6w2NwVW9pb6OcHAFedWoc9x7vQInOgJlbn47Ip1RHPSRADGSlF1+WR6n3yzHrF/mMEEQlyfogBC3d+TjjccHl86PYrK0XatdVoBOi1AtxeJkV+UlPzwwUPIh93iFLeiBRj1Gml77zTn/ZVnmfChOp86ZhISoMmvRa5Rp1MTVEvLVIAdUV+otX8cNEUSwTRFC4J/vXBNiyeWhP2uJYIzo/NpMejl02KPGiCyDLkTYRPcPvJsH4+hDrI/LsSQSRIvlkv9ehpsTsDKSsRdm2BwGKN9+BIxeKN1zd7o3g/vPFkFaW6EClEXs9j0GpQmGMIcn6iiTcUylK3rEZtkHqZKmp+/BscngjOD2MMzREcFs6ckaUAgHe3NcEXwb5b7WJkSA29oAgiE7DK0t545If6+RCJkJWRH61Wi3PPPVd6TAxMNBqx+LixowervjkqS3uLvBgz6DSwu7xSD45UCB7wMH20mh+e9lYZR48ftUP22f+U55nQ6K+NqynKkWznySWT0dBix8IJlRHfX2QxYH+LKHVtMeiCIiNGNTg/uuhpb3aXV1JfC63TkTNtcBGsRh2au5zY1tiBqvwcvPHNEXi9Pmg0AkaW2zB1cKGU0lYYRkgiFZBtEWqGOzpuL5OyIiJtRGQSZHuZRVY6PyaTCatWrUr3MIh+gBcwt9hdkvMTKe0N6L1THc1ZSgQp7S1ylg2OtnPnJ3siP2Sf/U9FngmbD4qP62W9ieaPq4jp/TWFOdh4oA2A2DNH3ktLr4K0N0MMggct/hqeHIM2rNQ1IF4/JlTn4ePdLfj6YDte23gYT3/UEHTMxrvPwpF20dms6MeNDbItQs2Y9VoYdRo4PT7sOS7WJ+arJO2NbC+zyPy7EkH0gctPqQUAtHcHVNOiCQeEOj+RipsTJdYmp+3dwR2sCSIVlMuUBMdUxt8fY6ysoWCeWY9SWa8fVUR+Yqj5CSdNrcRY/2e481inJLUvZ/PBE1JKK6m3EURsCIIg2d/e46ISJd0biUTI/LsSQfQBHiaXOz9RIz8hO9XmCLu8icIF5KL1+enoFuuObCbKayZSx8jyXOnxmaNK437/aH9jTgCoK7ZIzj2gjqglFzWJFPnpcUVXeuNwZ7Kpswe7ZXLhnM/3tkobGyRhTxCxw+/pe5vtQb8TRDxkpfNjt9thsVhgsVhgt9vTPRwihXD9/45ut7R4iSp4oAt+3ZKCyE+sUtcdPeICyWbOngxVss/+56LJVXj6ypPx4vWnBEVxYmVMReA9g4ssKJE1PlWD4IGU9uYJb49Ov2NkjCENtjRXdGi2N3ZKEaNvl83D/84ZCgB4ZeNhAGLvpNx+3Ngg2yLUDo/0SD3JVJL2RraXWWTPiioEh8OR7iEQ/QB3fvqS9hbNWUoEIcaanw7/7nC2RX7IPvsXvVaDuaPLEn5/Xo4ev1gwCp09HtQVW3DVqXXY3tiJ88bHVjOUbmJpcur0C6DEov7IZfb3+usSqgrMsBp1Uoob7wE0c2hx4oNOELItQs2Epp0WqCjtjWwvc8ha54fIDrjz0+ZwS+pt0dLejLLFjVYjpETqmvdki5T2xhhDh7+viM2cXc4PoT6unVUvPc416fHEkslpHE18cKnrSDU//DWjLvpmSF1RsDT4OH80raog+PkZQ/rf+SEINVNgCb4XxlKDRxChpD0f4cEHH4QgCLj55pvTPRRiABJwflwJRX5yDFopSpNMuNR1pLQ3h8sr9QHKtsgPQfQnsUV+xOtHLGl8pTYThpZapd/PGCHWUU2oDk4pnF5fFPdYCSKbCXV2eJSVIOIhrc7Phg0b8Oc//xnjx49P5zCIAYxU8+OPoADR09iMIc5PKuAOVaSG8rzeR6cRUiK3TRCECHdoPBH6/AQiP7HZ4qlDAo5NrT8SlGvS44en1aMk14irTx2MPCrWJoi4kDs/Wo2AqoLMF1QhMo+0rai6urqwZMkSPPXUUygoKEjXMIgBjlK6WE6UyI+8QWOkfh59QRuD1LWk9GbWpyT6RBCECI/8eHxMiraGItX8xOj8TJeltMkV7+48dxQ23DUXv1w4OtHhEkTWIm/4PbTEqoo+YkTmkbZvzY033ogFCxZg7ty56RoCkQWY/E3ROBaDFhpNZEci2PlJTeSHS11Hcn46udKbiUrzCCKVyO3c7vIoHhNPzQ8QSGkz6TVBfZQIgkicaYMDEdUxg2wRjiSI8KRlVbVy5Ups3LgRGzZsiOl4p9MJp9Mp/d7R0dGnv6/RaDB79mzpMTGwyc/R41iH+P2ROzbhsBoDi5uUOT+xRH4kmevsSo0h+yT6G6NOA71WgNvLYHd6FGvseOQnFqlrQFTA+/D2M6DRCBmzO022RaidAosB50+oxDvfNeLSk6vTPZyYIdvLLPrd+Tl48CBuuukmrF27FiZTbLthy5cvx7Jly5I2BrPZjPfffz9p5yMymzxzwPmxxuT8BBY+qWhwCsicn0g1P1na4JTsk+hvBEGAxahDm8ONrh4PoNDqyOX1Cx7E4chUF+ZEP6gfIdsiBgJ/WDwJbq8vYzYVYoFsL7Po92/OV199haamJkyePBk6nQ46nQ7r16/HH/7wB+h0Onj9Nxg5d955J9rb26WfgwcP9vewCRWTbw4USMYS+bHIIj+paHAKxCZ1nY0NTgkiXfCNkU6nctpbvJEfgiBSh5ocHyLz6PdV1ZlnnoktW7YEPfeDH/wAI0eOxB133AGttvdi02g0wmgkOUMiMaoLc/DFvlYAwY5NOOTRoVQ0OAVik7rO1ganBJEOuN3b/c6Pw+WBjwWel2p+aNFFEAShavrd+cnNzcXYsWODnrNYLCgqKur1fKqw2+2oq6sDAOzbtw8Wi6Vf/i6RHkaW50qP5Slt4bDKBAbkUaNkEpvUtbgIy80ywQOyTyIdcCenq8cDr49h3u8/gMvjw4e3z4FBp4HD5e8TlqINkf6AbIsg0gPZXmaRXasqGc3NzekeAtFPjKwIOD+xNESTp8YV56bG+YlN6jp7Iz9kn0R/w+2+y+lBQ7MdB1u7AQBH2rpRV2wZMPZItkUQ6YFsL3PICOeHisCIVDJCFvkpsUZ3ZnLlzo8lNemWsUhdZ6vaG0GkA7O//1eP24vtjQFF0SPtfueH7JEgCGJAQMnLxICnxGrEOWPKUZprxFmjy6MeX1ccCEfH2tAwXgRJ7S1Snx/e5DQj9igIYkBj8gsZ9Lh92HY04Pw0tvcAkKsvkj0SBEGoGbqKEwMeQRDwpytOivn4YqsRl5xchXXbj2PWsOLob0iAQNpb+GMGSpoNQagBkzzyc7RTev6o3/npdFLkhyAIYiBAzg9BKPDQ98YDCERokg2Xuo6c9sYjP7TYIohUIzk/Hi+2NwacnyNtYu1PtvbdIgiCGGiQ80MQCqTK6eFo/N6PJ0LohyI/BNF/8P49TR1OHPY7PEAg7Y1LYMfSKJkgCILIXLLyKq7RaHDyySdLjwmiv+Fd4j1htK4ZY1KBdbZJXZN9EunApBMjP5sPtgU9f6S9B26vT9qo4MIIaoRsiyDSA9leZpFdqyo/ZrMZGzZsSPcwiCyGd6d2e5UjPz1un/RatqW9kX0S6YCnve1q6gIADMo343BbNxrbu9Hj9krH8QiRGiHbIoj0QLaXWaj3Kk4QKibg/ChHfnjURyMAFhU3VSQItWAKcWrmjCwFAJxwuNHmEO1REABjihQgCYIgiP6BruIEkQb0WrHmJ5zz0ynrKZLq+iOCIAKRH860+kLk+DceGprt4jE6LdkjQRCEyslK58fhcKCurg51dXVwOBzpHg6RhURLe2vPYmUpsk8iHYRGfkZV2FCeZwIgc35UnPIGkG0RRLog28sssrLmhzGG/fv3S48Jor+JNe0tGxuckn0S6SDfbJAeG3Ua1BVZUJlnxt7jdpnzo+4UVLItgkgPZHuZhbq3sQhCpeiipL2RzDVB9C+DCszS4xHludBqBFT4Iz97/c6PmpXeCIIgCBFyfggiDRiipL1JDU7J+SGIfqEyP+D81BTmAIDk/DQ0iwpwRnJ+CIIgVA85PwSRBqIJHvDIT7b1+CGIdGE16jC+Kg8AsGBcBQCgwu8QHWwVm56qveaHIAiCyNKaH4JIN3pdrDU/FPkhiP7ilRtm4ITDhdJcMeLDBQ84ViPdMgmCINQObWMRRBrQa6KkvWWx2htBpAu9ViM5PgBQmWcOej30d4IgCEJ9ZOU2liAIGD16tPSYIPobvS7WPj/ZZ6Jkn0SmEBr5Cf1dbZBtEUR6INvLLLJvZQUgJycHW7duTfcwiCwmutR19kZ+yD6JTMFm0sFi0MLu8gIAKvPV7fyQbRFEeiDbyywo7Y0g0oAuatob1fwQRLoRBEESPQCACkp7IwiCUD3k/BBEGjBESXuTBA9I7Y0g0kp9sUV6XKHytDeCIAgiS50fh8OBMWPGYMyYMXA4HOkeDpGF6KP1+fELHuRmYdob2SeRSQwttUqP5VEgNUK2RRDpgWwvs8jKbWXGGL777jvpMUH0N4G0t2hS19lnomSfRCZx2ZQabDxwApNqClQvdU22RRDpgWwvs1D3lZwgVEqktLcetxcuj/g81fwQRHqpKcrByuunp3sYBEEQRJLIyrQ3gkg3Utqbp7fzw6M+ggBYDbQ/QRAEQRAEkSzI+SGINCA5P77e4e9Ov8x1rlEHjYb6ARAEQRAEQSQLcn4IIg3oteHT3kjmmiAIgiAIIjWQ80MQacCo0wIAHE5vr+LHbG5wShAEQRAEkUqysqBAEATU1tZKjwmivym1GSEIgMvrQ4vdhWKrUXqNR35ys7THD9knQaQGsi2CSA9ke5lFVq6ucnJysG/fvnQPg8hijDotSqxGNHU68f/e/A6/vWQitP76noDMdXZGfsg+CSI1kG0RRHog28ssKO2NINLEYH/n+Nc3H8GarY3S87zBKaW9EQRBEARBJBdyfggiTSxbNEZ6/PNXvpFqf7K5wSlBEARBEEQqyUrnp7u7G1OmTMGUKVPQ3d2d7uEQWcrIchte/fEMAKLIwTeH2sXHXO0tSyM/ZJ8EkRrItggiPZDtZRZZubXs8/nw5ZdfSo8JIl1MrinAiLJc7DjWifve/A6v3DBD6vOTrTU/ZJ8EkRrItggiPZDtZRZZGfkhiEziiumiAsz+FjsAWdpblqq9EQRBEARBpIq0OD9PPvkkxo8fD5vNBpvNhunTp+Ptt99Ox1AIIu1cOGkQAKC5y4VWu0smdZ2dkR+CIAiCIIhUkRbnp6qqCg8++CC++uorfPnll5gzZw4WLVqErVu3pmM4BJFWLEYdqgrMAICdxzoDTU5J8IAgCIIgCCKppMX5WbhwIc4991wMGzYMw4cPx/333w+r1YrPPvssHcMhiLQzoiwXgN/5yXLBA4IgCIIgiFSR9pofr9eLlStXwm63Y/r06YrHOJ1OdHR0BP0QxEBimNz58df85GWp4AFBEARBEESqSFtezZYtWzB9+nT09PTAarXitddew+jRoxWPXb58OZYtW5bUv19cXJzU8xFEX6guFNPeDrR2o8ctKsFkc+SH7JMgUgPZFkGkB7K9zEFgvLNiP+NyuXDgwAG0t7fj5ZdfxtNPP43169crOkBOpxNOp1P6vaOjA9XV1Whvb4fNZuvPYRNESlj9bSN+9PxXqCnMwYFWBwBgzwPnQqsR0jwygiAIgiCIzKajowN5eXkx+QZpi/wYDAYMHToUAHDSSSdhw4YNePTRR/HnP/+517FGoxFGo7G/h0gQ/UZJrgEAJMcn16gjx4cgCIIgCCLJpL3mh+Pz+YKiOwSRTRRbg537XOrxQxAEQRAEkXTSssK68847MX/+fNTU1KCzsxMvvPAC3n//faxZs6Zf/n53dzfmz58PAHj77bdhNpv75e8SRDhCnR9bFosdkH0SRGog2yKI9EC2l1mkxflpamrClVdeiaNHjyIvLw/jx4/HmjVrcNZZZ/XL3/f5fFi/fr30mCDSTY5BC5NeQ2IHIPskiFRBtkUQ6YFsL7NIi/PzzDPPpOPPEkTGIggCiq1GHDrRDQCozDeleUQEQRAEQRADj4yp+SGIbKe2KEd6PH1IURpHQhAEQRAEMTAh54cgMoRhpbnS4xlDqB8AQRAEQRBEsiHnhyAyhEUTK1FuM2HhhEpUF+ZEfwNBEARBEAQRF6SnSxAZwqSaAnz2f89M9zAIgiAIgiAGLFnr/OTk0M46QWQqZJ8EkRrItggiPZDtZQ5Z6fxYLBbY7fZ0D4MgCAXIPgkiNZBtEUR6INvLLKjmhyAIgiAIgiCIrICcH4IgCIIgCIIgsoKsdH56enqwYMECLFiwAD09PekeDkEQMsg+CSI1kG0RRHog28ssBMYYS/cg4qWjowN5eXlob2+HzWaL+/12ux1WqxUA0NXVBYvFkuwhEgSRIGSfBJEayLYIIj2Q7aWeeHyDrIz8EARBEARBEASRfZDzQxAEQRAEQRBEVkDOD0EQBEEQBEEQWQE5PwRBEARBEARBZAXk/BAEQRAEQRAEkRWQ80MQBEEQBEEQRFagS/cA0oHFYoEKFb4JIisg+ySI1EC2RRDpgWwvs6DID0EQBEEQBEEQWQE5PwRBEARBEARBZAXk/BAEQRAEQRAEkRWQ80MQBEEQBEEQRFZAzg9BEARBEARBEFkBOT8EQRAEQRAEQWQF5PwQBEEQBEEQBJEVkPNDEARBEARBEERWQM4PQRAEQRAEQRBZATk/BEEQBEEQBEFkBeT8EARBEARBEASRFZDzQxAEQRAEQRBEVkDOD0EQBEEQBEEQWQE5PwRBEARBEARBZAW6dA8gERhjAICOjo40j4QgCIIgCIIgiHTCfQLuI0RClc5PZ2cnAKC6ujrNIyEIgiAIgiAIIhPo7OxEXl5exGMEFouLlGH4fD4cOXIEubm5EAQhoXN0dHSguroaBw8ehM1mS/IIiVRCc6dOaN7UC82deqG5Uyc0b+qF5i49MMbQ2dmJyspKaDSRq3pUGfnRaDSoqqpKyrlsNht9OVUKzZ06oXlTLzR36oXmTp3QvKkXmrv+J1rEh0OCBwRBEARBEARBZAXk/BAEQRAEQRAEkRVkrfNjNBpxzz33wGg0pnsoRJzQ3KkTmjf1QnOnXmju1AnNm3qhuct8VCl4QBAEQRAEQRAEES9ZG/khCIIgCIIgCCK7IOeHIAiCIAiCIIisgJwfgiAIgiAIgiCyAnJ+CIIgCIIgCILICjLC+fnggw+wcOFCVFZWQhAEvP7664rHbdu2Deeffz7y8vJgsVgwZcoUHDhwIOx5t27diu9973uoq6uDIAj4/e9/3+sY/lroz4033hj2vDt27MAZZ5yBsrIymEwm1NfX4xe/+AXcbnfQcS+99BJGjhwJk8mEcePG4a233orp81ATaps7Obt370Zubi7y8/ODnl+xYkWvc5pMppjOqRbSOW9erxd33303Bg8eDLPZjCFDhuBXv/oVommvHDhwAAsWLEBOTg5KS0tx2223wePxBB3z/vvvY/LkyTAajRg6dChWrFgR7aNQHWqcu5/+9Kc46aSTYDQaMXHixF6v79u3T9GWP/vss4jnVRtqm7uWlhacc845qKyshNFoRHV1NX7yk5+go6Mj6LiBbndqmzc5LS0tqKqqgiAIaGtrk55///33FW2usbExpvOqhXTOXWdnJ26++WbU1tbCbDZjxowZ2LBhQ9Qx070u9WSE82O32zFhwgQ88cQTYY/Zs2cPZs6ciZEjR+L999/HN998g7vvvjviotThcKC+vh4PPvggysvLFY/ZsGEDjh49Kv2sXbsWAHDxxReHPa9er8eVV16Jd955Bzt27MDvf/97PPXUU7jnnnukYz755BMsXrwY11xzDTZt2oQLLrgAF1xwAb799ttoH4eqUNvccdxuNxYvXoxZs2Ypvm6z2YLOvX///qjnVBPpnLeHHnoITz75JB5//HFs27YNDz30EH7961/jscceC3ter9eLBQsWwOVy4ZNPPsFf//pXrFixAr/85S+lYxoaGrBgwQKcccYZ2Lx5M26++WZce+21WLNmTQyfiHpQ29xxrr76alx66aURj3n33XeD7O6kk06Kel41oba502g0WLRoEd544w3s3LkTK1aswLvvvosf/ehH0jHZYHdqmzc511xzDcaPHx/29R07dgTZXGlpaUznVQvpnLtrr70Wa9euxd///nds2bIFZ599NubOnYvDhw+HPS/d6/oJlmEAYK+99lqv5y+99FJ2+eWXJ3ze2tpa9sgjj0Q97qabbmJDhgxhPp8vrvP/7Gc/YzNnzpR+v+SSS9iCBQuCjpk2bRr74Q9/GNd51YSa5u72229nl19+OXvuuedYXl5e0GtKzw1k+nveFixYwK6++uqg5y666CK2ZMmSsOd66623mEajYY2NjdJzTz75JLPZbMzpdDLGxDkdM2ZMr//DvHnzEv4/ZDpqmDs599xzD5swYUKv5xsaGhgAtmnTpgRGq07UNnecRx99lFVVVUm/Z5vdqWne/vjHP7LZs2ez9957jwFgJ06ckF7773//2+u5gU5/zp3D4WBarZa9+eabQc9PnjyZ3XXXXWHPRfe6/iEjIj/R8Pl8WLVqFYYPH4558+ahtLQU06ZNCxu+TBSXy4Xnn38eV199NQRBkJ6/6qqrcPrpp4d93+7du7F69WrMnj1beu7TTz/F3Llzg46bN28ePv3006SOOdPJxLlbt24dXnrppYg7QV1dXaitrUV1dTUWLVqErVu3JnW8mU4q523GjBl47733sHPnTgDA119/jY8++gjz58+Xjrn33ntRV1cn/f7pp59i3LhxKCsrk56bN28eOjo6pLkhmxPJtLmLh/PPPx+lpaWYOXMm3njjjT6PV21k+twdOXIEr776Kt3rQsjEefvuu+9w33334W9/+xs0mvBLvYkTJ6KiogJnnXUWPv744z6PV22kau48Hg+8Xm+v6JHZbMZHH30k/U73uvSgCuenqakJXV1dePDBB3HOOefgnXfewYUXXoiLLroI69evT9rfef3119HW1oarrroq6PmKigrU1NT0On7GjBkwmUwYNmwYZs2ahfvuu096rbGxMejLCwBlZWUDLp82Gpk2dy0tLbjqqquwYsUK2Gw2xXONGDECzz77LP7973/j+eefh8/nw4wZM3Do0KGkjTfTSeW8/fznP8dll12GkSNHQq/XY9KkSbj55puxZMkS6Zji4mIMGTJE+j2cPfHXIh3T0dGB7u7uPo1ZTWTa3MWC1WrFb3/7W7z00ktYtWoVZs6ciQsuuCDrHKBMnbvFixcjJycHgwYNgs1mw9NPPy29RnaXefPmdDqxePFi/OY3v1FcuwDivfFPf/oTXnnlFbzyyiuorq7G6aefjo0bN/ZpvGojVXOXm5uL6dOn41e/+hWOHDkCr9eL559/Hp9++imOHj0qHUf3ujSR7tBTKFAISx4+fJgBYIsXLw56fuHCheyyyy6L6byxpE6dffbZ7Lzzzot5rAcOHGBbt25lL7zwAhs0aBB76KGHpNf0ej174YUXgo5/4oknWGlpacznVxtqmLsLL7yQ3XHHHdLvsaS4uVwuNmTIEPaLX/wiluGqjv6et3/+85+sqqqK/fOf/2TffPMN+9vf/sYKCwvZihUrwp7ruuuuY2effXbQc3a7nQFgb731FmOMsWHDhrEHHngg6JhVq1YxAMzhcMQ0ZrWhhrmTEy7tTYkrrrgiKJV4oKGmuTt69Cjbtm0b+/e//81Gjx7NbrjhBum1bLM7Nczbz372M3bppZdKv8ea4nbaaaf1Kf0r0+nvudu9ezc77bTTGACm1WrZlClT2JIlS9jIkSPDnovudf2Drl89rQQpLi6GTqfD6NGjg54fNWpUUPiwL+zfvx/vvvsuXn311ZjfU11dDQAYPXo0vF4vrr/+etxyyy3QarUoLy/HsWPHgo4/duxY2MK4gUqmzd26devwxhtv4OGHHwYAMMbg8/mg0+nwl7/8BVdffXWv9/Ddtt27dydlvGoglfN22223SbuZADBu3Djs378fy5cvx9KlSxXfU15eji+++CLoOW5f3KbC2ZzNZoPZbO7TmNVEps1dokybNk0SMckWMnXuysvLUV5ejpEjR6KwsBCzZs3C3XffjYqKCrI7ZN68rVu3Dlu2bMHLL78MAJIyXHFxMe666y4sW7ZM8X1Tp05N2n1ZLaRy7oYMGYL169fDbrejo6MDFRUVuPTSS1FfXx/2PXSv6x9UkfZmMBgwZcoU7NixI+j5nTt3ora2Nil/47nnnkNpaSkWLFiQ0Pt9Ph/cbjd8Ph8AYPr06XjvvfeCjlm7di2mT5/e57GqiUybu08//RSbN2+Wfu677z7k5uZi8+bNuPDCCxXf4/V6sWXLFlRUVCRlvGoglfPmcDh65aBrtVrJdpSYPn06tmzZgqamJum5tWvXwmazSTctsjmRTJu7RNm8eXNW2RygjrnjxzudTgBkd0Dmzdsrr7yCr7/+WrrP8TTFDz/8MGIrCLK5AMlco1gsFlRUVODEiRNYs2YNFi1aFPZYutf1E+kOPTHGWGdnJ9u0aRPbtGkTA8B+97vfsU2bNrH9+/dLx7z66qtMr9ezv/zlL2zXrl3sscceY1qtln344Ydhz+t0OqXzVlRUsFtvvZVt2rSJ7dq1K+g4r9fLampqgtKh5Pz85z9nV1xxhfT7888/z1588UX23XffsT179rAXX3yRVVZWBqmvfPzxx0yn07GHH36Ybdu2jd1zzz1Mr9ezLVu2JPoxZSRqm7tQlNLeli1bxtasWcP27NnDvvrqK3bZZZcxk8nEtm7dGsMnog7SOW9Lly5lgwYNYm+++SZraGhgr776KisuLma33367dMxjjz3G5syZI/3u8XjY2LFj2dlnn802b97MVq9ezUpKStidd94pHbN3716Wk5PDbrvtNrZt2zb2xBNPMK1Wy1avXp2sjy0jUNvcMcbYrl272KZNm9gPf/hDNnz4cOnvcPWiFStWsBdeeIFt27aNbdu2jd1///1Mo9GwZ599NlkfW0agtrlbtWoVe/bZZ9mWLVtYQ0MDe/PNN9moUaPYqaeeKh2TDXantnkLRSnt7ZFHHmGvv/4627VrF9uyZQu76aabmEajYe+++26Cn1Jmks65W716NXv77bfZ3r172TvvvMMmTJjApk2bxlwul3QM3evSQ0Y4P9wwQ3+WLl0adNwzzzzDhg4dykwmE5swYQJ7/fXXI56Xy6eG/syePTvouDVr1jAAbMeOHYrnWbp0adB7Vq5cySZPnsysViuzWCxs9OjR7IEHHmDd3d1B7/vXv/7Fhg8fzgwGAxszZgxbtWpVzJ+JWlDb3IWi5PzcfPPNrKamhhkMBlZWVsbOPfdctnHjxojjVRvpnLeOjg520003sZqaGmYymVh9fT276667pIUwY2JtSG1tbdC59+3bx+bPn8/MZjMrLi5mt9xyC3O73b3+XxMnTmQGg4HV19ez5557LpGPJ6NR49zNnj1b8dwNDQ2MMdH5GTVqFMvJyWE2m41NnTqVvfTSS335mDIStc3dunXr2PTp01leXh4zmUxs2LBh7I477uhVOzLQ7U5t8xZu/PJ5e+ihh9iQIUOYyWRihYWF7PTTT2fr1q2L52NRBemcuxdffJHV19czg8HAysvL2Y033sja2tqCzkP3uvQgMBZjm2CCIAiCIAiCIAgVo4qaH4IgCIIgCIIgiL5Czg9BEARBEARBEFkBOT8EQRAEQRAEQWQF5PwQBEEQBEEQBJEVkPNDEARBEARBEERWQM4PQRAEQRAEQRBZATk/BEEQBEEQBEFkBeT8EARBEARBEASRFZDzQxAEQRAEQRBEVkDOD0EQBEEQBEEQWQE5PwRBEARBEARBZAXk/BAEQRAEQRAEkRX8fzrS1wnTSSb7AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(10, 10))\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(data_nox['timestamp'], data_nox['value'])\n", + "plt.plot(data_nox['timestamp'], data_nox['prediction'])\n", + "plt.vlines(\n", + " x=retrain_data_nox['timestamp'],\n", + " ymin=plt.ylim()[0],\n", + " ymax=plt.ylim()[1],\n", + " colors='k',\n", + " linestyles='--'\n", + ")\n", + "\n", + "\n", + "plt.legend(['real', 'prediction', 'retrain'])\n", + "plt.title('NOx')\n", + "plt.xlim(\n", + " data_nox['timestamp'].min(),\n", + " data_nox['timestamp'].max()\n", + ")\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(data_o2['timestamp'], data_o2['value'])\n", + "plt.plot(data_o2['timestamp'], data_o2['prediction'])\n", + "plt.vlines(\n", + " x=retrain_data_o2['timestamp'],\n", + " ymin=plt.ylim()[0],\n", + " ymax=plt.ylim()[1],\n", + " colors='k',\n", + " linestyles='--'\n", + ")\n", + "\n", + "plt.xlim(\n", + " data_o2['timestamp'].min(),\n", + " data_o2['timestamp'].max()\n", + ")\n", + "\n", + "plt.legend(['real', 'prediction', 'retrain'])\n", + "plt.title('O2')\n", + "plt.show()\n", + "\n", + "\n" + ] } ], "metadata": { diff --git a/tests/laborious/activities/test_api.py b/tests/laborious/activities/test_api.py index a1ff3bb..ad9866f 100644 --- a/tests/laborious/activities/test_api.py +++ b/tests/laborious/activities/test_api.py @@ -127,8 +127,6 @@ async def test_write_pi_web_api_data_success(mock_dataframe, api, base_input_dat result = await api.write_pi_web_api_data(input_data) - api.info.assert_called_once_with('Writing data to PI Web API...', metadata['metadata']) - api.pi_web_api_client.write_value.assert_has_calls( [ call( @@ -292,7 +290,7 @@ async def test_process_pi_web_api_response_success(api): 'workflow_name': 'test_workflow', } - confidence = await api.process_pi_web_api_response( + confidence, message = await api.process_pi_web_api_response( response_data=response_data, tags=tags, core_labels=core_labels, @@ -300,6 +298,7 @@ async def test_process_pi_web_api_response_success(api): ) assert confidence == 0 + assert message == '' assert api.emit_metric.call_count == 2 # Verify that emit_metric was called with correct tags structure call_args_list = api.emit_metric.call_args_list @@ -326,7 +325,7 @@ async def test_process_pi_web_api_response_with_errors(api): 'workflow_name': 'test_workflow', } - confidence = await api.process_pi_web_api_response( + confidence, message = await api.process_pi_web_api_response( response_data=response_data, tags=tags, core_labels=core_labels, @@ -334,10 +333,9 @@ async def test_process_pi_web_api_response_with_errors(api): ) assert confidence == PI_WEB_API_PREDICTION_ERROR_CONFIDENCE + assert message == "The number of written tags does not match the number of tag names: Expected ['tag1', 'tag2'] tags, but ['tag2'] tags were written." assert api.emit_metric.call_count == 2 - api.error.assert_any_call( - "Error writing tag tag1:web_id_1 to PI Web API: ['Error writing tag']", metadata['metadata'] - ) + @mark.asyncio @@ -355,7 +353,7 @@ async def test_process_pi_web_api_response_missing_tags(api): 'workflow_name': 'test_workflow', } - confidence = await api.process_pi_web_api_response( + confidence, message = await api.process_pi_web_api_response( response_data=response_data, tags=tags, core_labels=core_labels, @@ -363,6 +361,7 @@ async def test_process_pi_web_api_response_missing_tags(api): ) assert confidence == PI_WEB_API_PREDICTION_ERROR_CONFIDENCE + assert message == "The number of written tags does not match the number of tag names: Expected ['tag1', 'tag2'] tags, but ['tag1'] tags were written." api.send_notification_async.assert_called_once() call_args = api.send_notification_async.call_args assert call_args.kwargs['notification_id'] == 'WRITE_PI_WEB_API_PREDICTION_ERROR' @@ -385,7 +384,7 @@ async def test_process_pi_web_api_response_missing_webid(api): 'workflow_name': 'test_workflow', } - confidence = await api.process_pi_web_api_response( + confidence, message = await api.process_pi_web_api_response( response_data=response_data, tags=tags, core_labels=core_labels, @@ -393,6 +392,7 @@ async def test_process_pi_web_api_response_missing_webid(api): ) assert confidence == PI_WEB_API_PREDICTION_ERROR_CONFIDENCE + assert message == "The number of written tags does not match the number of tag names: Expected ['tag1', 'tag2'] tags, but ['tag2'] tags were written." api.error.assert_any_call('The response did not contain some WebIds', metadata['metadata']) @@ -411,7 +411,7 @@ async def test_process_pi_web_api_response_missing_tag_name(api): 'workflow_name': 'test_workflow', } - confidence = await api.process_pi_web_api_response( + confidence, message = await api.process_pi_web_api_response( response_data=response_data, tags=tags, core_labels=core_labels, @@ -419,6 +419,7 @@ async def test_process_pi_web_api_response_missing_tag_name(api): ) assert confidence == PI_WEB_API_PREDICTION_ERROR_CONFIDENCE + assert message == "The number of written tags does not match the number of tag names: Expected ['tag1'] tags, but [] tags were written." api.error.assert_any_call( 'The response did not contain the tag name for WebId unknown_web_id', metadata['metadata'] ) diff --git a/tests/laborious/utils/repository/test_model_repository.py b/tests/laborious/utils/repository/test_model_repository.py index 466fae5..d3f98b6 100644 --- a/tests/laborious/utils/repository/test_model_repository.py +++ b/tests/laborious/utils/repository/test_model_repository.py @@ -812,7 +812,7 @@ async def test_fit_models_not_df_target_name_none_and_not_in_model( data = MagicMock() output = await mlflow_repository.fit_models( - 'model_name', data, 'latest_production_id', metadata['metadata'], 'sklearn', 'pyfunc', None + 'model_name', data, 'latest_production_id', metadata['metadata'], 'sklearn', False, 'pyfunc', None ) mlflow_repository.download_model.assert_has_calls( @@ -908,6 +908,7 @@ async def test_fit_models_df_target_name_not_none_and_in_model( 'latest_production_id', metadata['metadata'], 'sklearn', + False, 'pyfunc', 'feat_1', ) @@ -1425,6 +1426,7 @@ async def test_retrain_model(mlflow_repository): model_name=model_name, data=data, transform_flavor='sklearn', + skip_transform=False, predict_flavor='pyfunc', target_name='target', metadata=metadata['metadata'],